cartodata  5.1.2
volumeutilio_d.h
Go to the documentation of this file.
1 /* This software and supporting documentation are distributed by
2 * Institut Federatif de Recherche 49
3 * CEA/NeuroSpin, Batiment 145,
4 * 91191 Gif-sur-Yvette cedex
5 * France
6 *
7 * This software is governed by the CeCILL-B license under
8 * French law and abiding by the rules of distribution of free software.
9 * You can use, modify and/or redistribute the software under the
10 * terms of the CeCILL-B license as circulated by CEA, CNRS
11 * and INRIA at the following URL "http://www.cecill.info".
12 *
13 * As a counterpart to the access to the source code and rights to copy,
14 * modify and redistribute granted by the license, users are provided only
15 * with a limited warranty and the software's author, the holder of the
16 * economic rights, and the successive licensors have only limited
17 * liability.
18 *
19 * In this respect, the user's attention is drawn to the risks associated
20 * with loading, using, modifying and/or developing or reproducing the
21 * software by the user in light of its specific status of free software,
22 * that may mean that it is complicated to manipulate, and that also
23 * therefore means that it is reserved for developers and experienced
24 * professionals having in-depth computer knowledge. Users are therefore
25 * encouraged to load and test the software's suitability as regards their
26 * requirements in conditions enabling the security of their systems and/or
27 * data to be ensured and, more generally, to use and operate it in the
28 * same conditions as regards security.
29 *
30 * The fact that you are presently reading this means that you have had
31 * knowledge of the CeCILL-B license and that you accept its terms.
32 */
33 #ifndef CARTODATA_IO_VOLUMEUTILIO_D_H
34 #define CARTODATA_IO_VOLUMEUTILIO_D_H
35 
36 //--- cartodata --------------------------------------------------------------
37 #include <cartodata/io/volumeutilio.h> // class definition
38 #include <cartodata/volume/volume.h>
39 //--- soma-io ----------------------------------------------------------------
40 #include <soma-io/config/soma_config.h> // (#define soma)
41 #include <soma-io/io/reader.h>
42 #include <soma-io/datasourceinfo/datasourceinfoloader.h>
43 #include <soma-io/datasourceinfo/datasourceinfo.h>
44 //--- cartobase --------------------------------------------------------------
45 #include <cartobase/object/object.h> // header, options
46 #include <cartobase/object/property.h> // header, options
47 //--- system -----------------------------------------------------------------
48 #include <vector> // 4D vectors
49 #include <set> // properties list
50 //--- debug ------------------------------------------------------------------
51 #include <cartobase/config/verbose.h>
52 #define localMsg( message ) cartoCondMsg( 3, message, "VOLUMEUTILIO" )
53 // #undef localMsg
54 // #define localMsg( message ) std::cerr << (message) << std::endl;
55 // localMsg must be undef at end of file
56 //----------------------------------------------------------------------------
57 
58 namespace soma {
59 
60  template <typename T> std::set<std::string>
61  VolumeUtilIO<T>::listReadProperties()
62  {
63  std::set<std::string> properties;
64  properties.insert( "ox" );
65  properties.insert( "oy" );
66  properties.insert( "oz" );
67  properties.insert( "ot" );
68  properties.insert( "sx" );
69  properties.insert( "sy" );
70  properties.insert( "sz" );
71  properties.insert( "st" );
72  properties.insert( "bx" );
73  properties.insert( "by" );
74  properties.insert( "bz" );
75  properties.insert( "border" );
76  properties.insert( "ox1" );
77  properties.insert( "ox2" );
78  properties.insert( "ox3" );
79  properties.insert( "ox4" );
80  properties.insert( "ox5" );
81  properties.insert( "ox6" );
82  properties.insert( "ox7" );
83  properties.insert( "ox8" );
84  properties.insert( "sx1" );
85  properties.insert( "sx2" );
86  properties.insert( "sx3" );
87  properties.insert( "sx4" );
88  properties.insert( "sx5" );
89  properties.insert( "sx6" );
90  properties.insert( "sx7" );
91  properties.insert( "sx8" );
92 
93  return properties;
94  }
95 
96  //==========================================================================
97  // R E A D
98  //==========================================================================
99 
100  template <typename T> carto::Volume<T>*
101  VolumeUtilIO<T>::read( carto::Volume<T> * obj,
102  carto::rc_ptr<DataSourceInfo> dsi,
103  carto::Object options )
104  {
105  localMsg( "VolumeUtilIO<T>::read" );
106  if( obj )
107  localMsg( "with existing object" );
108  std::vector<int> position( 4, 0 );
109  std::vector<int> frame( 4, -1 );
110  std::vector<int> borders( 4, 0 );
111  try {
112  position[0] = (int) rint(options->getProperty( "ox" )->getScalar() );
113  options->removeProperty( "ox" );
114  } catch( ... ) {}
115  try {
116  position[1] = (int) rint( options->getProperty( "oy" )->getScalar() );
117  options->removeProperty( "oy" );
118  } catch( ... ) {}
119  try {
120  position[2] = (int) rint( options->getProperty( "oz" )->getScalar() );
121  options->removeProperty( "oz" );
122  } catch( ... ) {}
123  try {
124  position[3] = (int) rint( options->getProperty( "ot" )->getScalar() );
125  options->removeProperty( "ot" );
126  } catch( ... ) {}
127  try {
128  frame[0] = (int) rint( options->getProperty( "sx" )->getScalar() );
129  options->removeProperty( "sx" );
130  } catch( ... ) {}
131  try {
132  frame[1] = (int) rint( options->getProperty( "sy" )->getScalar() );
133  options->removeProperty( "sy" );
134  } catch( ... ) {}
135  try {
136  frame[2] = (int) rint( options->getProperty( "sz" )->getScalar() );
137  options->removeProperty( "sz" );
138  } catch( ... ) {}
139  try {
140  frame[3] = (int) rint( options->getProperty( "st" )->getScalar() );
141  options->removeProperty( "st" );
142  } catch( ... ) {}
143  try {
144  borders[0] = (int) rint( options->getProperty( "border" )->getScalar() );
145  borders[1] = (int) rint( options->getProperty( "border" )->getScalar() );
146  borders[2] = (int) rint( options->getProperty( "border" )->getScalar() );
147  options->removeProperty( "border" );
148  } catch( ... ) {}
149  try {
150  borders[0] = (int) rint( options->getProperty( "bx" )->getScalar() );
151  options->removeProperty( "bx" );
152  } catch( ... ) {}
153  try {
154  borders[1] = (int) rint( options->getProperty( "by" )->getScalar() );
155  options->removeProperty( "by" );
156  } catch( ... ) {}
157  try {
158  borders[2] = (int) rint( options->getProperty( "bz" )->getScalar() );
159  options->removeProperty( "bz" );
160  } catch( ... ) {}
161 
162  size_t dim, value;
163  for( dim=0; dim<carto::Volume<T>::DIM_MAX; ++dim )
164  {
165  try
166  {
167  std::stringstream skey;
168  skey << "ox" << dim+1;
169  std::string key = skey.str();
170  value = (int) rint( options->getProperty( key )->getScalar() );
171  options->removeProperty( key );
172  if( position.size() <= dim )
173  position.resize( dim + 1, 0 );
174  position[ dim ] = value;
175  }
176  catch( ... ) {}
177  try
178  {
179  std::stringstream skey;
180  skey << "sx" << dim+1;
181  std::string key = skey.str();
182  value = (int) rint( options->getProperty( key )->getScalar() );
183  options->removeProperty( key );
184  if( frame.size() <= dim )
185  frame.resize( dim + 1, -1 );
186  frame[ dim ] = value;
187  }
188  catch( ... ) {}
189  }
190 
191  bool partial = false;
192  for( dim=0; !partial && dim<position.size(); ++dim )
193  if( position[dim] != 0 )
194  partial = true;
195  for( dim=0; !partial && dim<frame.size(); ++dim )
196  if( frame[dim] != -1 )
197  partial = true;
198 
199  if( partial )
200  return readPartial( obj, dsi, position, frame, borders, options );
201  else
202  return readFull( obj, dsi, borders, options );
203  }
204 
205  template <typename T> carto::Volume<T>*
206  VolumeUtilIO<T>::readFull( carto::Volume<T> * obj,
207  carto::rc_ptr<DataSourceInfo> dsi,
208  std::vector<int> borders,
209  carto::Object options )
210  {
211  //=== VARIABLES ==========================================================
212  //int verbose = carto::debugMessageLevel;
213  carto::Object newoptions;
214  soma::Reader<carto::Volume<T> > rVol;
215  soma::DataSourceInfoLoader dsil;
216  carto::VolumeRef<T> bordersVolume;
217  std::vector<int> fullsize;
218  std::vector<int> bordersize;
219  std::vector<int> volumepos;
220 
221  if( borders[0] !=0 || borders[1] !=0 || borders[2] !=0 )
222  {
223  //=== CHECK FULL VOLUME ================================================
224  localMsg( "=== READING FULL VOLUME SIZE" );
225  newoptions = carto::Object::value( carto::PropertySet() );
226  newoptions->copyProperties( options );
227  localMsg( "checking full volume..." );
228  *dsi = dsil.check( *dsi, options );
229  localMsg( "reading size..." );
230  if( !dsi->header()->getProperty( "volume_dimension", fullsize ) )
231  {
232  fullsize[0] = (int) rint(
233  dsi->header()->getProperty( "sizeX" )->getScalar() );
234  fullsize[1] = (int) rint(
235  dsi->header()->getProperty( "sizeY" )->getScalar() );
236  fullsize[2] = (int) rint(
237  dsi->header()->getProperty( "sizeZ" )->getScalar() );
238  fullsize[3] = (int) rint(
239  dsi->header()->getProperty( "sizeT" )->getScalar() );
240  }
241  if( fullsize.size() < 4 )
242  fullsize.resize( 4, 1 );
243  volumepos.resize( fullsize.size(), 0 );
244  volumepos[0] = borders[0];
245  volumepos[1] = borders[1];
246  volumepos[2] = borders[2];
247  localMsg( "-> size = ( "
248  + carto::toString( fullsize[0] ) + ", "
249  + carto::toString( fullsize[1] ) + ", "
250  + carto::toString( fullsize[2] ) + ", "
251  + carto::toString( fullsize[3] ) + " )"
252  );
253 
254  //=== BORDERS VOLUME ===================================================
255  localMsg( "=== ALLOCATED BORDERS VOLUME" );
256  localMsg( "computing sizes..." );
257  bordersize = fullsize;
258  bordersize[0] = fullsize[0] + 2*borders[0];
259  bordersize[1] = fullsize[1] + 2*borders[1];
260  bordersize[2] = fullsize[2] + 2*borders[2];
261  localMsg( "creating allocated volume..." );
262  localMsg( "-> with size ( "
263  + carto::toString( bordersize[0] ) + ", "
264  + carto::toString( bordersize[1] ) + ", "
265  + carto::toString( bordersize[2] ) + ", "
266  + carto::toString( bordersize[3] ) + " )"
267  );
268  bordersVolume = carto::VolumeRef<T>(
269  new carto::Volume<T>( bordersize ) );
270 
271  //=== READ FULL VOLUME =================================================
272  localMsg( "=== UNALLOCATED FULL VIEW" );
273  rVol = soma::Reader< carto::Volume<T> >( dsi );
274  newoptions = carto::Object::value( carto::PropertySet() );
275  newoptions->copyProperties( options );
276  newoptions->setProperty( "keep_allocation", true );
277  rVol.setOptions( newoptions );
278  localMsg( "creating volume view..." );
279  localMsg( "-> with pos ( "
280  + carto::toString( volumepos[0] ) + ", "
281  + carto::toString( volumepos[1] ) + ", "
282  + carto::toString( volumepos[2] ) + ", "
283  + carto::toString( volumepos[3] ) + " )"
284  );
285  localMsg( "-> with size ( "
286  + carto::toString( fullsize[0] ) + ", "
287  + carto::toString( fullsize[1] ) + ", "
288  + carto::toString( fullsize[2] ) + ", "
289  + carto::toString( fullsize[3] ) + " )"
290  );
291  if( obj )
292  *obj = carto::Volume<T>( bordersVolume, volumepos, fullsize );
293  else
294  obj = new carto::Volume<T>( bordersVolume, volumepos, fullsize );
295  localMsg( "reading unallocated volume..." );
296  rVol.setAllocatorContext( obj->allocatorContext() );
297  rVol.read( *obj );
298 
299  /* copy voxel_size to underlying volume, if any.
300  This should probably be more general, but cannot be applied to all
301  header properties (size, transformations...).
302  WARNING: Moreover here we do not guarantee to keep both voxel_size
303  unique: we point to the same vector of values for now, but it can be
304  replaced (thus, duplicated) by a setProperty().
305  We could use a addBuiltinProperty(), but then the voxel size has to be
306  stored in a fixed location somewhere.
307  */
308  try
309  {
310  carto::Object vs = obj->header().getProperty( "voxel_size" );
311  bordersVolume->header().setProperty( "voxel_size", vs );
312  }
313  catch( ... )
314  { // never mind.
315  }
316 
317  }
318  else
319  {
320  //=== FULL VOLUME ======================================================
321  localMsg( "=== ALLOCATED FULL VIEW" );
322  rVol = soma::Reader< carto::Volume<T> >( dsi );
323  newoptions = carto::Object::value( carto::PropertySet() );
324  newoptions->copyProperties( options );
325  rVol.setOptions( newoptions );
326  localMsg( "reading volume..." );
327  obj = rVol.read();
328  }
329 
330  return obj;
331  }
332 
333  template <typename T> carto::Volume<T>*
334  VolumeUtilIO<T>::readPartial( carto::Volume<T> * obj,
335  carto::rc_ptr<DataSourceInfo> dsi,
336  std::vector<int> position,
337  std::vector<int> frame,
338  std::vector<int> borders,
339  carto::Object options )
340  {
341  //=== VARIABLES ==========================================================
342  localMsg( "VolumeUtilIO<T>::readPartial" );
343  std::vector<int> viewframe( frame );
344  size_t dim, ndim = std::max( position.size(), frame.size() );
345  if( viewframe.size() < ndim )
346  viewframe.resize( ndim, -1 );
347  std::vector<int> viewpos( position );
348  if( viewpos.size() < ndim )
349  viewpos.resize( ndim, 0 );
350  std::vector<int> fullsize; // full size
351  std::vector<int> borderframe( ndim, 1 ); // allocated volume size
352  std::vector<int> borderpos; // allocated volume origin
353  std::vector<int> readframe( ndim, 0 ); // read frame size
354  std::vector<int> readpos( ndim, 0 ); // read frame origin
355  carto::Object newoptions;
356  soma::Reader<carto::Volume<T> > rVol;
357  soma::Reader<carto::Volume<T> > rView;
358  carto::VolumeRef<T> fullVolume, bordersVolume, readVolume;
359 // carto::Volume<T>* viewVolume;
360 
361  //=== UNALLOCATED FULL VOLUME ============================================
362  localMsg( "=== UNALLOCATED FULL VOLUME" );
363  rVol = soma::Reader<carto::Volume<T> >( dsi );
364  newoptions = carto::Object::value( carto::PropertySet() );
365  newoptions->setProperty( "unallocated", true );
366  newoptions->copyProperties( options );
367  rVol.setOptions( newoptions );
368  localMsg( "reading unallocated volume..." );
369  fullVolume = carto::VolumeRef<T>( rVol.read() );
370  localMsg( "reading size from volume..." );
371  fullsize = fullVolume->getSize();
372 // localMsg( "-> full size ( "
373 // + carto::toString( fullsize[0] ) + ", "
374 // + carto::toString( fullsize[1] ) + ", "
375 // + carto::toString( fullsize[2] ) + ", "
376 // + carto::toString( fullsize[3] ) + " )" );
377 // localMsg( "-> position ( "
378 // + carto::toString( position[0] ) + ", "
379 // + carto::toString( position[1] ) + ", "
380 // + carto::toString( position[2] ) + ", "
381 // + carto::toString( position[3] ) + " )" );
382 // localMsg( "-> borders ( "
383 // + carto::toString( borders[0] ) + ", "
384 // + carto::toString( borders[1] ) + ", "
385 // + carto::toString( borders[2] ) + ", "
386 // + carto::toString( borders[3] ) + " )" );
387  for( dim=0; dim<ndim; ++dim )
388  if( viewframe[ dim ] == -1 )
389  viewframe[ dim ] = (fullsize[ dim ] - position[ dim ]);
390 
391  localMsg( "===" );
392 
393  // processes full image upper and lower overflows
394  std::vector<int> loverflow(3,0), uoverflow(3, 0);
395  loverflow[0] = (viewpos[0] < 0 ? -viewpos[0] : 0);
396  loverflow[1] = (viewpos[1] < 0 ? -viewpos[1] : 0);
397  loverflow[2] = (viewpos[2] < 0 ? -viewpos[2] : 0);
398 
399  uoverflow[0] = (viewpos[0] + viewframe[0] - fullsize[0] > 0 ?
400  viewpos[0] + viewframe[0] - fullsize[0] : 0);
401  uoverflow[1] = (viewpos[1] + viewframe[1] - fullsize[1] > 0 ?
402  viewpos[1] + viewframe[1] - fullsize[1] : 0);
403  uoverflow[2] = (viewpos[2] + viewframe[2] - fullsize[2] > 0 ?
404  viewpos[2] + viewframe[2] - fullsize[2] : 0);
405 
406  // To deal with negative view positions and view frames that ends over the
407  // full volume size, we use an overflow policy.
408  // Overflow policy : 0 => overflow is managed as unread data in the view
409  // 1 => overflow is managed as border
410  int overflow_policy = 0;
411  try
412  {
413  carto::Object overflow_pol = newoptions->getProperty(
414  "overflow_policy" );
415  overflow_policy = int( overflow_pol->getScalar() );
416  }
417  catch( ... )
418  {
419  }
420 
421  if( borders[0] != 0 || borders[1] != 0 || borders[2] != 0
422  || (overflow_policy == 1 &&
423  (loverflow[0] > 0 || loverflow[1] > 0 || loverflow[2] > 0
424  || uoverflow[0] > 0 || uoverflow[1] > 0 || uoverflow[2] > 0 ) ) )
425  {
426  //=== ALLOCATED BORDERS VOLUME =========================================
427  localMsg( "=== ALLOCATED BORDERS VOLUME" );
428  localMsg( "computing borders..." );
429  // setting "bordersVolume" position / "fullVolume"
430  borderpos = viewpos;
431  borderpos[0] -= borders[0];
432  borderpos[1] -= borders[1];
433  borderpos[2] -= borders[2];
434 
435  borderframe = viewframe;
436  borderframe[0] += 2*borders[0];
437  borderframe[1] += 2*borders[1];
438  borderframe[2] += 2*borders[2];
439 
440  localMsg( "creating volume..." );
441  localMsg( "-> with frame size ( "
442  + carto::toString( borderframe[0] ) + ", "
443  + carto::toString( borderframe[1] ) + ", "
444  + carto::toString( borderframe[2] ) + ", "
445  + carto::toString( borderframe[3] ) + " )"
446  );
447  localMsg( "-> with frame pos ( "
448  + carto::toString( borderpos[0] ) + ", "
449  + carto::toString( borderpos[1] ) + ", "
450  + carto::toString( borderpos[2] ) + ", "
451  + carto::toString( borderpos[3] ) + " )"
452  );
453  bordersVolume = carto::VolumeRef<T>(
454  new carto::Volume<T>( fullVolume, borderpos, borderframe ) );
455 
456 // localMsg( "-> effective frame size ( "
457 // + carto::toString( bordersVolume->getSizeX() ) + ", "
458 // + carto::toString( bordersVolume->getSizeY() ) + ", "
459 // + carto::toString( bordersVolume->getSizeZ() ) + ", "
460 // + carto::toString( bordersVolume->getSizeT() ) + " )"
461 // );
462 
463  //=== UNALLOCATED READ VIEW ============================================
464  localMsg( "=== UNALLOCATED READ VIEW" );
465  localMsg( "computing read frame..." );
466  // setting "readVolume" position / "bordersVolume"
467  readpos[0] = ( borderpos[0] < 0 ? borders[0] + loverflow[0] : 0 );
468  readpos[1] = ( borderpos[1] < 0 ? borders[1] + loverflow[1] : 0 );
469  readpos[2] = ( borderpos[2] < 0 ? borders[2] + loverflow[2] : 0 );
470  readpos[3] = 0;
471  std::vector<int> borderdep( 3, 0 );
472  borderdep[0] = ( borderpos[0] + borderframe[0] - fullsize[0] > 0
473  ? borderpos[0] + borderframe[0] - fullsize[0] : 0 );
474  borderdep[1] = ( borderpos[1] + borderframe[1] - fullsize[1] > 0
475  ? borderpos[1] + borderframe[1] - fullsize[1] : 0 );
476  borderdep[2] = ( borderpos[2] + borderframe[2] - fullsize[2] > 0
477  ? borderpos[2] + borderframe[2] - fullsize[2] : 0 );
478  readframe[0] = borderframe[0] - readpos[0] - borderdep[0];
479  readframe[1] = borderframe[1] - readpos[1] - borderdep[1];
480  readframe[2] = borderframe[2] - readpos[2] - borderdep[2];
481  readframe[3] = borderframe[3];
482  rView = soma::Reader<carto::Volume<T> >( rVol.dataSourceInfo() );
483  newoptions = carto::Object::value( carto::PropertySet() );
484  newoptions->setProperty( "partial_reading", true );
485  newoptions->copyProperties( options );
486  rView.setOptions( newoptions );
487  localMsg( "creating read volume..." );
488  localMsg( "-> with frame size ( "
489  + carto::toString( readframe[0] ) + ", "
490  + carto::toString( readframe[1] ) + ", "
491  + carto::toString( readframe[2] ) + ", "
492  + carto::toString( readframe[3] ) + " )"
493  );
494  localMsg( "-> with frame pos ( "
495  + carto::toString( readpos[0] ) + ", "
496  + carto::toString( readpos[1] ) + ", "
497  + carto::toString( readpos[2] ) + ", "
498  + carto::toString( readpos[3] ) + " )"
499  );
500  readVolume = carto::VolumeRef<T>(
501  new carto::Volume<T>( bordersVolume, readpos, readframe ) );
502 
503 // localMsg( "-> effective read view size ( "
504 // + carto::toString( readVolume->getSizeX() ) + ", "
505 // + carto::toString( readVolume->getSizeY() ) + ", "
506 // + carto::toString( readVolume->getSizeZ() ) + ", "
507 // + carto::toString( readVolume->getSizeT() ) + " )"
508 // );
509 
510  localMsg( "reading frame..." );
511  rView.read( *readVolume );
512 
513 // localMsg( "-> effective read view size after read ( "
514 // + carto::toString( readVolume->getSizeX() ) + ", "
515 // + carto::toString( readVolume->getSizeY() ) + ", "
516 // + carto::toString( readVolume->getSizeZ() ) + ", "
517 // + carto::toString( readVolume->getSizeT() ) + " )"
518 // );
519 
520  //=== UNALLOCATED PROCCESSED VOLUME ====================================
521  localMsg( "=== UNALLOCATED PROCESSED VOLUME" );
522  localMsg( "computing view frame..." );
523  // setting "viewVolume" position / "bordersVolume"
524  if (overflow_policy == 1)
525  {
526  viewframe[0] -= loverflow[0] + uoverflow[0];
527  viewframe[1] -= loverflow[1] + uoverflow[1];
528  viewframe[2] -= loverflow[2] + uoverflow[2];
529 
530  viewpos[0] = borders[0] + loverflow[0];
531  viewpos[1] = borders[1] + loverflow[1];
532  viewpos[2] = borders[2] + loverflow[2];
533  }
534  else
535  {
536  viewpos[0] = borders[0];
537  viewpos[1] = borders[1];
538  viewpos[2] = borders[2];
539  }
540  viewpos[3] = 0;
541 
542  localMsg( "creating volume..." );
543  localMsg( "-> with frame size ( "
544  + carto::toString( viewframe[0] ) + ", "
545  + carto::toString( viewframe[1] ) + ", "
546  + carto::toString( viewframe[2] ) + ", "
547  + carto::toString( viewframe[3] ) + " )"
548  );
549  localMsg( "-> with frame pos ( "
550  + carto::toString( viewpos[0] ) + ", "
551  + carto::toString( viewpos[1] ) + ", "
552  + carto::toString( viewpos[2] ) + ", "
553  + carto::toString( viewpos[3] ) + " )"
554  );
555  if(obj)
556  {
557  bool keep_allocation = false;
558  try
559  {
560  carto::Object keep_alloc = newoptions->getProperty(
561  "keep_allocation" );
562  keep_allocation = bool( keep_alloc->getScalar() );
563  }
564  catch( ... )
565  {
566  }
567  if( !keep_allocation )
568  *obj = carto::Volume<T>( bordersVolume, viewpos, viewframe );
569  }
570  else
571  obj = new carto::Volume<T>( bordersVolume, viewpos, viewframe );
572 
573  localMsg( "copying header..." );
574  obj->blockSignals( true );
575  obj->header().copyProperties( carto::Object::value( readVolume->header() ) );
576  /* copy voxel_size to underlying volume, if any.
577  This should probably be more general, but cannot be applied to all
578  header properties (size, transformations...).
579  WARNING: Moreover here we do not guarantee to keep both voxel_size
580  unique: we point to the same vector of values for now, but it can be
581  replaced (thus, duplicated) by a setProperty().
582  We could use a addBuiltinProperty(), but then the voxel size has to be
583  stored in a fixed location somewhere.
584  */
585  try
586  {
587  carto::Object vs = obj->header().getProperty( "voxel_size" );
588  bordersVolume->header().setProperty( "voxel_size", vs );
589  }
590  catch( ... )
591  { // never mind.
592  }
593  carto::PropertySet & ps = obj->header();
594  ps.setProperty( "sizeX", viewframe[0] );
595  ps.setProperty( "sizeY", viewframe[1] );
596  ps.setProperty( "sizeZ", viewframe[2] );
597  ps.setProperty( "sizeT", viewframe[3] );
598  ps.setProperty( "volume_dimension", viewframe );
599  obj->blockSignals( false );
600  }
601  else
602  {
603  //=== ALLOCATED PROCESSED VOLUME =======================================
604  localMsg( "=== ALLOCATED PROCESSED VOLUME" );
605  rView = soma::Reader<carto::Volume<T> >( rVol.dataSourceInfo() );
606  newoptions = carto::Object::value( carto::PropertySet() );
607  newoptions->setProperty( "partial_reading", true );
608  newoptions->copyProperties( options );
609  rView.setOptions( newoptions );
610  localMsg( "creating volume..." );
611  VolumeRef<T> tmp;
612  if( obj )
613  {
614  localMsg( "existing volume" );
615  bool keep_allocation = false;
616  try
617  {
618  carto::Object keep_alloc = newoptions->getProperty(
619  "keep_allocation" );
620  keep_allocation = bool( keep_alloc->getScalar() );
621  }
622  catch( ... )
623  {
624  }
625  if( keep_allocation )
626  {
627  /* read inside an existing allocated volume.
628 
629  The problem here is that we need a view which is attached both
630  to a file parent (fullVolume) with a certain position, and at
631  the same time to an allocated parent volume, with another
632  position.
633 
634  The trick here is to build a view in the unallocated fullVolume
635  (representing the whole file) with the size/position of the
636  patch to be read from file, and pointing to the memory block of
637  the view (obj) in memory. Then read the "file view" as for the
638  border case.
639  */
640 
641  tmp.reset( new carto::Volume<T>( fullVolume, viewpos, viewframe,
642  &obj->at(0), obj->getStrides() ) );
643 
644  obj = tmp.get(); // read the temp volume
645  }
646  else
647  *obj = carto::Volume<T>( fullVolume, viewpos, viewframe );
648  }
649  else
650  obj = new carto::Volume<T>( fullVolume, viewpos, viewframe );
651 
652  if ( loverflow[0] > 0 || loverflow[1] > 0 || loverflow[2] > 0
653  || uoverflow[0] > 0 || uoverflow[1] > 0 || uoverflow[2] > 0 )
654  {
655  //=== UNALLOCATED READ VIEW ============================================
656  localMsg( "=== UNALLOCATED READ VIEW" );
657  localMsg( "computing read frame for overflows..." );
658  // setting "readVolume" position / "bordersVolume"
659  readpos[0] = loverflow[0];
660  readpos[1] = loverflow[1];
661  readpos[2] = loverflow[2];
662  readpos[3] = 0;
663  readframe[0] = viewframe[0] - loverflow[0] - uoverflow[0];
664  readframe[1] = viewframe[1] - loverflow[1] - uoverflow[1];
665  readframe[2] = viewframe[2] - loverflow[2] - uoverflow[2];
666  readframe[3] = viewframe[3];
667  localMsg( "creating read volume..." );
668  localMsg( "-> with frame size ( "
669  + carto::toString( readframe[0] ) + ", "
670  + carto::toString( readframe[1] ) + ", "
671  + carto::toString( readframe[2] ) + ", "
672  + carto::toString( readframe[3] ) + " )"
673  );
674  localMsg( "-> with frame pos ( "
675  + carto::toString( readpos[0] ) + ", "
676  + carto::toString( readpos[1] ) + ", "
677  + carto::toString( readpos[2] ) + ", "
678  + carto::toString( readpos[3] ) + " )"
679  );
680 
681  // To avoid underlying data deletion when readVolume is deleted
682  // We need to recreate a Volume that is based on the full volume
683  tmp.reset( new carto::Volume<T>( fullVolume, viewpos, viewframe,
684  &obj->at(0), obj->getStrides() ) );
685  readVolume = carto::VolumeRef<T>(
686  new carto::Volume<T>( tmp,
687  readpos, readframe ) );
688 
689  // localMsg( "-> effective read view size ( "
690  // + carto::toString( readVolume->getSizeX() ) + ", "
691  // + carto::toString( readVolume->getSizeY() ) + ", "
692  // + carto::toString( readVolume->getSizeZ() ) + ", "
693  // + carto::toString( readVolume->getSizeT() ) + " )"
694  // );
695 
696  localMsg( "reading partial volume using read view ..." );
697  rView.read( *readVolume );
698  }
699  else {
700  localMsg( "reading partial volume..." );
701  rView.read( *obj );
702  }
703  }
704 
705  return obj;
706  }
707 
708 }
709 
710 #undef localMsg
711 #endif
carto::DictionaryInterface::copyProperties
virtual void copyProperties(Object source)
carto::Headered::blockSignals
void blockSignals(bool)
carto::Headered::header
const PropertySet & header() const
carto::Object::value
static Object value()
carto::PropertySet::setProperty
void setProperty(const std::string &, const T &)
carto::PropertySet::getProperty
bool getProperty(const std::string &, T &) const
carto::VolumeRef
Convenient handle for a Volume - this is normally the entry point for all volumes handling.
Definition: volumeref.h:60
carto::VolumeRef::getSize
std::vector< int > getSize() const
Definition: volumeref_d_inline.h:139
carto::VolumeRef::header
const PropertySet & header() const
Definition: volumeref_d_inline.h:174
carto::Volume
N-D Volume main class.
Definition: volumebase.h:119
carto::Volume::allocatorContext
const AllocatorContext & allocatorContext() const
returns volume's AllocatorContext
Definition: volumebase_d.h:521
carto::Volume::getStrides
std::vector< size_t > getStrides() const
Get strides for the volume.
Definition: volumebase_d.h:726
carto::Volume::at
const T & at(long x, long y=0, long z=0, long t=0) const
Definition: volumebase_d_inline.h:48
carto::rc_ptr
soma::DataSourceInfoLoader::check
DataSourceInfo check(DataSourceInfo dsi, carto::Object options=carto::none(), int passbegin=1, int passend=3)
soma::Reader::setAllocatorContext
void setAllocatorContext(const AllocatorContext &ac)
soma::Reader::dataSourceInfo
const carto::rc_ptr< DataSourceInfo > & dataSourceInfo() const
soma::Reader::read
virtual bool read(T &obj, carto::Object header=carto::none(), int passbegin=1, int passend=4)
soma::Reader::setOptions
void setOptions(carto::Object options)
soma::VolumeUtilIO::listReadProperties
static std::set< std::string > listReadProperties()
list of properties triggering partial reading and/or borders
Definition: volumeutilio_d.h:61
soma::VolumeUtilIO::readFull
static carto::Volume< T > * readFull(carto::Volume< T > *obj, carto::rc_ptr< DataSourceInfo > dsi, std::vector< int > borders, carto::Object options)
Worker for full reading case.
Definition: volumeutilio_d.h:206
soma::VolumeUtilIO::readPartial
static carto::Volume< T > * readPartial(carto::Volume< T > *obj, carto::rc_ptr< DataSourceInfo > dsi, std::vector< int > position, std::vector< int > frame, std::vector< int > borders, carto::Object options)
Worker for partial reading case.
Definition: volumeutilio_d.h:334
soma::VolumeUtilIO::read
static carto::Volume< T > * read(carto::Volume< T > *obj, carto::rc_ptr< DataSourceInfo > dsi, carto::Object options)
Manages all the volumes necessary and returns the final Volume.
Definition: volumeutilio_d.h:101
carto::toString
std::string toString(const T &object)
carto::max
T max(const Volume< T > &vol)
Returns the maximum value of the volume.
Definition: volumeutil.h:1153
soma_config.h
localMsg
#define localMsg(message)
Definition: volumeutilio_d.h:52