1 #include <iostream>
2 #include "vil_io_image_view_base.h"
3 //:
4 // \file
5 #ifdef _MSC_VER
6 #  include "vcl_msvc_warnings.h"
7 #endif
8 #include "vsl/vsl_binary_io.h"
9 #include "vil/vil_image_view_base.h"
10 #include "vil/vil_image_view.h"
11 #include <vil/io/vil_io_image_view.h>
12 
13 //: Binary write image view base to stream
14 template <>
15 void
vsl_b_write(vsl_b_ostream & os,vil_image_view_base_sptr const & view_base)16 vsl_b_write(vsl_b_ostream & os, vil_image_view_base_sptr const & view_base)
17 {
18   switch (view_base->pixel_format())
19   {
20 #if VXL_HAS_INT_64
21     case VIL_PIXEL_FORMAT_UINT_64: {
22       vil_image_view<vxl_uint_64> v(view_base);
23       vsl_b_write(os, v);
24       break;
25     }
26     case VIL_PIXEL_FORMAT_INT_64: {
27       vil_image_view<vxl_int_64> v(view_base);
28       vsl_b_write(os, v);
29       break;
30     }
31 #endif
32     case VIL_PIXEL_FORMAT_UINT_32: {
33       vil_image_view<vxl_uint_32> v(view_base);
34       vsl_b_write(os, v);
35       break;
36     }
37     case VIL_PIXEL_FORMAT_INT_32: {
38       vil_image_view<vxl_int_32> v(view_base);
39       vsl_b_write(os, v);
40       break;
41     }
42     case VIL_PIXEL_FORMAT_UINT_16: {
43       vil_image_view<vxl_uint_16> v(view_base);
44       vsl_b_write(os, v);
45       break;
46     }
47     case VIL_PIXEL_FORMAT_INT_16: {
48       vil_image_view<vxl_int_16> v(view_base);
49       vsl_b_write(os, v);
50       break;
51     }
52     case VIL_PIXEL_FORMAT_BYTE: {
53       vil_image_view<vxl_byte> v(view_base);
54       vsl_b_write(os, v);
55       break;
56     }
57     case VIL_PIXEL_FORMAT_SBYTE: {
58       vil_image_view<vxl_sbyte> v(view_base);
59       vsl_b_write(os, v);
60       break;
61     }
62     case VIL_PIXEL_FORMAT_FLOAT: {
63       vil_image_view<float> v(view_base);
64       vsl_b_write(os, v);
65       break;
66     }
67     case VIL_PIXEL_FORMAT_DOUBLE: {
68       vil_image_view<double> v(view_base);
69       vsl_b_write(os, v);
70       break;
71     }
72     case VIL_PIXEL_FORMAT_BOOL: {
73       vil_image_view<bool> v(view_base);
74       vsl_b_write(os, v);
75       break;
76     }
77     // No version 1 complex images were ever written. Now added. It should work. Fix if necessary
78     case VIL_PIXEL_FORMAT_COMPLEX_FLOAT: {
79       vil_image_view<std::complex<float>> v(view_base);
80       vsl_b_write(os, v);
81       break;
82     }
83     case VIL_PIXEL_FORMAT_COMPLEX_DOUBLE: {
84       vil_image_view<std::complex<double>> v(view_base);
85       vsl_b_write(os, v);
86       break;
87     }
88     default: {
89       std::cerr << "I/O ERROR: vsl_b_write(vsl_b_ostream &, vil_image_view_base_sptr const&)\n"
90                 << "           Unknown pixel format " << view_base->pixel_format() << '\n';
91       os.os().clear(std::ios::badbit); // Set an unrecoverable IO error on stream
92       return;
93     }
94   }
95   // std::cerr << "warning: vsl_b_write not implemented for vil_image_view_base_sptr\n";
96 }
97 
98 //: Binary load image view base from stream.
99 template <>
100 void
vsl_b_read(vsl_b_istream & is,vil_image_view_base_sptr & view_base)101 vsl_b_read(vsl_b_istream & is, vil_image_view_base_sptr & view_base)
102 {
103   if (!is)
104     return;
105 
106   unsigned ni, nj, np;
107   std::ptrdiff_t istep, jstep, pstep;
108   vil_memory_chunk_sptr chunk;
109   std::ptrdiff_t offset;
110 
111   short w;
112   vsl_b_read(is, w);
113   if (w != 1)
114   {
115     std::cerr << "warning: vsl_b_read not implemented for vil_image_view binary io version: " << w << '\n';
116     return;
117   }
118 
119   vsl_b_read(is, ni);
120   vsl_b_read(is, nj);
121   vsl_b_read(is, np);
122   vsl_b_read(is, istep);
123   vsl_b_read(is, jstep);
124   vsl_b_read(is, pstep);
125   if (ni * nj * np == 0)
126   {
127     std::cerr << "warning: vsl_b_read image ni*nj*np = 0\n";
128     // image.set_size(0,0,0);
129   }
130   else
131   {
132     vsl_b_read(is, chunk);
133     vsl_b_read(is, offset);
134 
135     switch (chunk->pixel_format())
136     {
137 #if VXL_HAS_INT_64
138       case VIL_PIXEL_FORMAT_UINT_64: {
139         const auto * data = reinterpret_cast<const vxl_uint_64 *>(chunk->data());
140         view_base = new vil_image_view<vxl_uint_64>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
141         break;
142       }
143       case VIL_PIXEL_FORMAT_INT_64: {
144         const auto * data = reinterpret_cast<const vxl_int_64 *>(chunk->data());
145         view_base = new vil_image_view<vxl_int_64>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
146         break;
147       }
148 #endif
149       case VIL_PIXEL_FORMAT_UINT_32: {
150         const auto * data = reinterpret_cast<const vxl_uint_32 *>(chunk->data());
151         view_base = new vil_image_view<vxl_uint_32>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
152         break;
153       }
154       case VIL_PIXEL_FORMAT_INT_32: {
155         const auto * data = reinterpret_cast<const vxl_int_32 *>(chunk->data());
156         view_base = new vil_image_view<vxl_int_32>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
157         break;
158       }
159       case VIL_PIXEL_FORMAT_UINT_16: {
160         const auto * data = reinterpret_cast<const vxl_uint_16 *>(chunk->data());
161         view_base = new vil_image_view<vxl_uint_16>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
162         break;
163       }
164       case VIL_PIXEL_FORMAT_INT_16: {
165         const auto * data = reinterpret_cast<const vxl_int_16 *>(chunk->data());
166         view_base = new vil_image_view<vxl_int_16>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
167         break;
168       }
169       case VIL_PIXEL_FORMAT_BYTE: {
170         const auto * data = reinterpret_cast<const vxl_byte *>(chunk->data());
171         view_base = new vil_image_view<vxl_byte>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
172         break;
173       }
174       case VIL_PIXEL_FORMAT_SBYTE: {
175         const auto * data = reinterpret_cast<const vxl_sbyte *>(chunk->data());
176         view_base = new vil_image_view<vxl_sbyte>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
177         break;
178       }
179       case VIL_PIXEL_FORMAT_FLOAT: {
180         const auto * data = reinterpret_cast<const float *>(chunk->data());
181         view_base = new vil_image_view<float>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
182         break;
183       }
184       case VIL_PIXEL_FORMAT_DOUBLE: {
185         const auto * data = reinterpret_cast<const double *>(chunk->data());
186         view_base = new vil_image_view<double>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
187         break;
188       }
189       case VIL_PIXEL_FORMAT_BOOL: {
190         const bool * data = reinterpret_cast<const bool *>(chunk->data());
191         view_base = new vil_image_view<bool>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
192         break;
193       }
194         // No version 1 complex images were ever written. Now added. It should work. Fix if necessary
195       case VIL_PIXEL_FORMAT_COMPLEX_FLOAT: {
196         const auto * data = reinterpret_cast<const std::complex<float> *>(chunk->data());
197         view_base = new vil_image_view<std::complex<float>>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
198         break;
199       }
200       case VIL_PIXEL_FORMAT_COMPLEX_DOUBLE: {
201         const auto * data = reinterpret_cast<const std::complex<double> *>(chunk->data());
202         view_base = new vil_image_view<std::complex<double>>(chunk, data + offset, ni, nj, np, istep, jstep, pstep);
203         break;
204       }
205       default: {
206         std::cerr << "I/O ERROR: vsl_b_read(vsl_b_istream&, vil_image_view<T>&)\n"
207                   << "           Unknown version number " << w << '\n';
208         is.is().clear(std::ios::badbit); // Set an unrecoverable IO error on stream
209         return;
210       }
211     }
212   }
213   // std::cerr << "warning: vsl_b_read not implemented for vil_image_view_base_sptr\n";
214 }
215 
216 template <>
217 void
vsl_b_write(vsl_b_ostream &,vil_image_resource_sptr const &)218 vsl_b_write(vsl_b_ostream & /*os*/, vil_image_resource_sptr const & /*view*/)
219 {
220   std::cerr << "warning: vsl_b_write not implemented for vil_image_resource_sptr\n";
221 }
222 
223 template <>
224 void
vsl_b_read(vsl_b_istream &,vil_image_resource_sptr &)225 vsl_b_read(vsl_b_istream & /*is*/, vil_image_resource_sptr & /*view*/)
226 {
227   std::cerr << "warning: vsl_b_read not implemented for vil_image_resource_sptr\n";
228 }
229 
230 #if 0
231 //: Binary write voxel world to stream
232 void vsl_b_write(vsl_b_ostream & , vil_image_view_base const&)
233 {
234   std::cerr << "warning: vsl_b_write not implemented for vil_image_view_base\n";
235 }
236 
237 //: Binary load voxel world from stream.
238 void vsl_b_read(vsl_b_istream &, vil_image_view_base &)
239 {
240   std::cerr << "warning: vsl_b_read not implemented for vil_image_view_base\n";
241 }
242 #endif // 0
243