vil_io_image_view_base.cxx
Go to the documentation of this file.
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 {
17  switch (view_base->pixel_format())
18  {
19 #if VXL_HAS_INT_64
20  case VIL_PIXEL_FORMAT_UINT_64: {
21  vil_image_view<vxl_uint_64> v(view_base);
22  vsl_b_write(os, v);
23  break; }
24  case VIL_PIXEL_FORMAT_INT_64: {
25  vil_image_view<vxl_int_64> v(view_base);
26  vsl_b_write(os, v);
27  break; }
28 #endif
29  case VIL_PIXEL_FORMAT_UINT_32: {
30  vil_image_view<vxl_uint_32> v(view_base);
31  vsl_b_write(os, v);
32  break; }
33  case VIL_PIXEL_FORMAT_INT_32: {
34  vil_image_view<vxl_int_32> v(view_base);
35  vsl_b_write(os, v);
36  break; }
37  case VIL_PIXEL_FORMAT_UINT_16: {
38  vil_image_view<vxl_uint_16> v(view_base);
39  vsl_b_write(os, v);
40  break; }
41  case VIL_PIXEL_FORMAT_INT_16: {
42  vil_image_view<vxl_int_16> v(view_base);
43  vsl_b_write(os, v);
44  break; }
45  case VIL_PIXEL_FORMAT_BYTE: {
46  vil_image_view<vxl_byte> v(view_base);
47  vsl_b_write(os, v);
48  break; }
49  case VIL_PIXEL_FORMAT_SBYTE: {
50  vil_image_view<vxl_sbyte> v(view_base);
51  vsl_b_write(os, v);
52  break; }
53  case VIL_PIXEL_FORMAT_FLOAT: {
54  vil_image_view<float> v(view_base);
55  vsl_b_write(os, v);
56  break; }
57  case VIL_PIXEL_FORMAT_DOUBLE: {
58  vil_image_view<double> v(view_base);
59  vsl_b_write(os, v);
60  break; }
61  case VIL_PIXEL_FORMAT_BOOL: {
62  vil_image_view<bool> v(view_base);
63  vsl_b_write(os, v);
64  break; }
65  // No version 1 complex images were ever written. Now added. It should work. Fix if necessary
66  case VIL_PIXEL_FORMAT_COMPLEX_FLOAT: {
67  vil_image_view<std::complex<float> > v(view_base);
68  vsl_b_write(os, v);
69  break; }
70  case VIL_PIXEL_FORMAT_COMPLEX_DOUBLE: {
71  vil_image_view<std::complex<double> > v(view_base);
72  vsl_b_write(os, v);
73  break; }
74  default: {
75  std::cerr << "I/O ERROR: vsl_b_write(vsl_b_ostream &, vil_image_view_base_sptr const&)\n"
76  << " Unknown pixel format "<< view_base->pixel_format() << '\n';
77  os.os().clear(std::ios::badbit); // Set an unrecoverable IO error on stream
78  return; }
79  }
80  //std::cerr << "warning: vsl_b_write not implemented for vil_image_view_base_sptr\n";
81 }
82 
83 //: Binary load image view base from stream.
84 template <>
85 void vsl_b_read(vsl_b_istream& is, vil_image_view_base_sptr &view_base)
86 {
87  if (!is) return;
88 
89  unsigned ni,nj,np;
90  std::ptrdiff_t istep,jstep,pstep;
91  vil_memory_chunk_sptr chunk;
92  std::ptrdiff_t offset;
93 
94  short w;
95  vsl_b_read(is, w);
96  if (w != 1) {
97  std::cerr << "warning: vsl_b_read not implemented for vil_image_view binary io version: " << w << '\n';
98  return;
99  }
100 
101  vsl_b_read(is, ni);
102  vsl_b_read(is, nj);
103  vsl_b_read(is, np);
104  vsl_b_read(is, istep);
105  vsl_b_read(is, jstep);
106  vsl_b_read(is, pstep);
107  if (ni*nj*np==0) {
108  std::cerr << "warning: vsl_b_read image ni*nj*np = 0\n";
109  //image.set_size(0,0,0);
110  }
111  else {
112  vsl_b_read(is, chunk);
113  vsl_b_read(is, offset);
114 
115  switch (chunk->pixel_format()) {
116 #if VXL_HAS_INT_64
117  case VIL_PIXEL_FORMAT_UINT_64: {
118  const auto* data = reinterpret_cast<const vxl_uint_64*>(chunk->data());
119  view_base = new vil_image_view<vxl_uint_64>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
120  break; }
121  case VIL_PIXEL_FORMAT_INT_64: {
122  const auto* data = reinterpret_cast<const vxl_int_64*>(chunk->data());
123  view_base = new vil_image_view<vxl_int_64>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
124  break; }
125 #endif
126  case VIL_PIXEL_FORMAT_UINT_32: {
127  const auto* data = reinterpret_cast<const vxl_uint_32*>(chunk->data());
128  view_base = new vil_image_view<vxl_uint_32>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
129  break; }
130  case VIL_PIXEL_FORMAT_INT_32: {
131  const auto* data = reinterpret_cast<const vxl_int_32*>(chunk->data());
132  view_base = new vil_image_view<vxl_int_32>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
133  break; }
134  case VIL_PIXEL_FORMAT_UINT_16: {
135  const auto* data = reinterpret_cast<const vxl_uint_16*>(chunk->data());
136  view_base = new vil_image_view<vxl_uint_16>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
137  break; }
138  case VIL_PIXEL_FORMAT_INT_16: {
139  const auto* data = reinterpret_cast<const vxl_int_16*>(chunk->data());
140  view_base = new vil_image_view<vxl_int_16>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
141  break; }
142  case VIL_PIXEL_FORMAT_BYTE: {
143  const auto* data = reinterpret_cast<const vxl_byte*>(chunk->data());
144  view_base = new vil_image_view<vxl_byte>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
145  break; }
146  case VIL_PIXEL_FORMAT_SBYTE: {
147  const auto* data = reinterpret_cast<const vxl_sbyte*>(chunk->data());
148  view_base = new vil_image_view<vxl_sbyte>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
149  break; }
150  case VIL_PIXEL_FORMAT_FLOAT: {
151  const auto* data = reinterpret_cast<const float*>(chunk->data());
152  view_base = new vil_image_view<float>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
153  break; }
154  case VIL_PIXEL_FORMAT_DOUBLE: {
155  const auto* data = reinterpret_cast<const double*>(chunk->data());
156  view_base = new vil_image_view<double>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
157  break; }
158  case VIL_PIXEL_FORMAT_BOOL: {
159  const bool* data = reinterpret_cast<const bool*>(chunk->data());
160  view_base = new vil_image_view<bool>(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
161  break; }
162  // No version 1 complex images were ever written. Now added. It should work. Fix if necessary
163  case VIL_PIXEL_FORMAT_COMPLEX_FLOAT: {
164  const auto* data = reinterpret_cast<const std::complex<float>*>(chunk->data());
165  view_base = new vil_image_view<std::complex<float> >(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
166  break; }
167  case VIL_PIXEL_FORMAT_COMPLEX_DOUBLE: {
168  const auto* data = reinterpret_cast<const std::complex<double>*>(chunk->data());
169  view_base = new vil_image_view<std::complex<double> >(chunk,data+offset,ni,nj,np,istep,jstep,pstep);
170  break; }
171  default: {
172  std::cerr << "I/O ERROR: vsl_b_read(vsl_b_istream&, vil_image_view<T>&)\n"
173  << " Unknown version number "<< w << '\n';
174  is.is().clear(std::ios::badbit); // Set an unrecoverable IO error on stream
175  return; }
176  }
177  }
178 //std::cerr << "warning: vsl_b_read not implemented for vil_image_view_base_sptr\n";
179 }
180 
181 template <>
182 void vsl_b_write(vsl_b_ostream & /*os*/, vil_image_resource_sptr const& /*view*/)
183 {
184  std::cerr << "warning: vsl_b_write not implemented for vil_image_resource_sptr\n";
185 }
186 
187 template <>
188 void vsl_b_read(vsl_b_istream & /*is*/, vil_image_resource_sptr & /*view*/)
189 {
190  std::cerr << "warning: vsl_b_read not implemented for vil_image_resource_sptr\n";
191 }
192 
193 #if 0
194 //: Binary write voxel world to stream
195 void vsl_b_write(vsl_b_ostream & , vil_image_view_base const&)
196 {
197  std::cerr << "warning: vsl_b_write not implemented for vil_image_view_base\n";
198 }
199 
200 //: Binary load voxel world from stream.
201 void vsl_b_read(vsl_b_istream &, vil_image_view_base &)
202 {
203  std::cerr << "warning: vsl_b_read not implemented for vil_image_view_base\n";
204 }
205 #endif // 0
vil_image_view_base
An abstract base class of smart pointers to actual image data in memory.
Definition: vil_image_view_base.h:27
VIL_PIXEL_FORMAT_INT_32
Definition: vil_pixel_format.h:34
VIL_PIXEL_FORMAT_COMPLEX_FLOAT
std::complex<float> is a scalar for vil's purposes.
Definition: vil_pixel_format.h:73
vil_smart_ptr
A templated smart pointer class.
Definition: vil_fwd.h:16
vil_image_view_base.h
A base class reference-counting view of some image data.
vil_image_view
Concrete view of image data of type T held in memory.
Definition: vil_fwd.h:13
VIL_PIXEL_FORMAT_UINT_32
Definition: vil_pixel_format.h:33
VIL_PIXEL_FORMAT_INT_16
Definition: vil_pixel_format.h:36
vil_io_image_view_base.h
vsl binary I/O functions for reading and writing vil_image_view_base_sptr.
v
#define v
VIL_PIXEL_FORMAT_DOUBLE
Definition: vil_pixel_format.h:40
VIL_PIXEL_FORMAT_BOOL
Definition: vil_pixel_format.h:42
vil_image_view::vsl_b_write
void vsl_b_write(vsl_b_ostream &os, const vil_image_view< T > &image)
Binary save vil_image_view<T> to stream.
Definition: vil_io_image_view.h:19
vil_image_view.h
A base class reference-counting view of some image data.
VIL_PIXEL_FORMAT_SBYTE
Definition: vil_pixel_format.h:38
vil_io_image_view.h
vil_image_view::vsl_b_read
void vsl_b_read(vsl_b_istream &is, vil_image_view< T > &image)
Binary load vil_image_view<T> from stream.
Definition: vil_io_image_view.h:43
VIL_PIXEL_FORMAT_COMPLEX_DOUBLE
std::complex<double> is a scalar for vil's purposes.
Definition: vil_pixel_format.h:75
VIL_PIXEL_FORMAT_FLOAT
Definition: vil_pixel_format.h:39
VIL_PIXEL_FORMAT_UINT_16
Definition: vil_pixel_format.h:35
vil_image_view::clear
void clear()
Make empty.
Definition: vil_image_view.h:226
VIL_PIXEL_FORMAT_BYTE
Definition: vil_pixel_format.h:37
Generated by   doxygen 1.8.15