MeVisLab Toolbox Reference
mlTVirtualVolume.h
Go to the documentation of this file.
1 /*************************************************************************************
2 **
3 ** Copyright 2007, MeVis Medical Solutions AG
4 **
5 ** The user may use this file in accordance with the license agreement provided with
6 ** the Software or, alternatively, in accordance with the terms contained in a
7 ** written agreement between the user and MeVis Medical Solutions AG.
8 **
9 ** For further information use the contact form at https://www.mevislab.de/contact
10 **
11 **************************************************************************************/
12 
13 #ifndef ML_TVIRTUAL_VOLUME_H
14 #define ML_TVIRTUAL_VOLUME_H
15 
16 
19 
26 
27 // Include dll-specific settings.
28 #include "MLToolsSystem.h"
29 
30 // Include most ml specific things.
31 #include "mlVirtualVolume.h"
32 
33 // Include BitImage.
34 #include "mlBitImage.h"
35 
36 ML_START_NAMESPACE
37 
38 //---------------------------------------------------------------------------------------------------------
209 //---------------------------------------------------------------------------------------------------------
210 template<typename DATATYPE> class TVirtualVolume {
211 
212 protected:
214  inline TVirtualVolume(){}
215 
218  inline TVirtualVolume &operator=(const TVirtualVolume &){}
219 
220 public:
221 
223  typedef DATATYPE ComponentType;
224 
227  inline TVirtualVolume(VirtualVolume &vVol)
228  {
229  _convenienceInstance = nullptr;
230  _init(vVol);
231  }
232 
240  TVirtualVolume(PagedImage *image, MLint maxNumKB=-1,
241  bool areExceptionsOn=false)
242  {
243  _convenienceInstance = new VirtualVolume(image,
244  MLGetDataTypeFromPtr(static_cast<DATATYPE*>(nullptr)),
245  maxNumKB,
246  areExceptionsOn);
247  _init(*_convenienceInstance);
248  }
249 
257  TVirtualVolume(const ImageVector &ext,
258  MLdouble fillVal = 0,
259  MLint maxNumKB = -1,
260  bool areExceptionsOn = false)
261  {
262  _convenienceInstance = new VirtualVolume(ext,
263  fillVal,
264  MLGetDataTypeFromPtr(static_cast<DATATYPE*>(nullptr)),
265  maxNumKB,
266  areExceptionsOn);
267  _init(*_convenienceInstance);
268  }
269 
273  virtual ~TVirtualVolume()
274  {
275  _cleanUp();
276  delete _convenienceInstance;
277  _convenienceInstance = nullptr;
278  }
279 
281  inline VirtualVolume &getVirtualVolume() { return *_virtVol; }
282 
288  inline void getValues(const ImageVector *pos, DATATYPE *results, MLuint num);
289 
292  inline DATATYPE getValue(const ImageVector &pos) { return _getVoxelFunc(this, pos); }
293 
296  inline void setValue(const ImageVector &pos, DATATYPE data) { _setVoxelFunc(this, pos, data); }
297 
299  inline void setCursorPosition(const ImageVector & pos) { _setCursorPosFunc(this, pos); }
300 
302  inline const ImageVector &getCursorPosition() const { return _cPos; }
303 
305  inline void setCursorValue(DATATYPE val);
306 
308  inline DATATYPE getCursorValue();
309 
311  inline bool isMapped(const ImageVector &pos) const { return _isMappedFunc(this, pos); }
312 
315  inline void moveCursorX() { _moveFXFunc(this); }
316  inline void moveCursorY() { _moveFYFunc(this); }
317  inline void moveCursorZ() { _moveFZFunc(this); }
318  inline void moveCursorC() { _moveFCFunc(this); }
319  inline void moveCursorT() { _moveFTFunc(this); }
320  inline void moveCursorU() { _moveFUFunc(this); }
321 
322  inline void reverseMoveCursorX() { _moveBXFunc(this); }
323  inline void reverseMoveCursorY() { _moveBYFunc(this); }
324  inline void reverseMoveCursorZ() { _moveBZFunc(this); }
325  inline void reverseMoveCursorC() { _moveBCFunc(this); }
326  inline void reverseMoveCursorT() { _moveBTFunc(this); }
327  inline void reverseMoveCursorU() { _moveBUFunc(this); }
329 
331  inline void moveCursorByOffset(const ImageVector &off) { _moveCursorOffsetFunc(this, off);}
332 
336  void resetCursor();
337 
347  bool moveCursorXWrapAround();
349 
353  void fill(const SubImageBox &box, DATATYPE value);
354 
359  void copyToSubImage(TSubImage<DATATYPE> &outSubImg);
360 
365  void copyFromSubImage(const TSubImage<DATATYPE> &inImg, const SubImageBox &box, const ImageVector &pos);
366 
386  //
387  // It would be desirable to have this function in the implementation part, but I
388  // don't know how to do that syntactically with the second template argument.
389  // (Maybe the VC++6 compiler does not support that?)
390  //
391  template <typename OUTDTYPE>
392  void copyMaskToSubImage(TSubImage<OUTDTYPE> &outSubImg,
393  BitImage &maskBits,
394  bool maskValue = true,
395  bool writeBK = false,
396  OUTDTYPE bkVal = ml_cast_from_scalar<OUTDTYPE>(0))
397  {
398  // Save cursor positions of *this, maskBits and outSubImg.
399  const ImageVector vvCursorPos(getCursorPosition());
400  const ImageVector bitImgCursorPos(maskBits.getCursorPosition());
401 
402  // Determine valid overlapping region of virtual volume and output page.
403  SubImageBox box = SubImageBox::intersect(_virtVol->getBox(), outSubImg.getBox());
404 
405  // Clamp box against bitImage box.
406  box = box.intersect(SubImageBox(maskBits.getExtent()));
407 
408  // Scan all voxels in both input subimages which have identical
409  // extents (as specified in calculateInputSubImageBox).
410  ImageVector p = box.v1;
411  for (p.u = box.v1.u; p.u <= box.v2.u; p.u++){
412  for (p.t = box.v1.t; p.t <= box.v2.t; p.t++){
413  for (p.c = box.v1.c; p.c <= box.v2.c; p.c++){
414  for (p.z = box.v1.z; p.z <= box.v2.z; p.z++){
415  for (p.y = box.v1.y; p.y <= box.v2.y; p.y++){
416 
417  // Calculate first voxel position in x row.
418  p.x = box.v1.x;
419 
420  // Get pointer to first voxels in x-rows of output subimage.
421  OUTDTYPE* oP = outSubImg.getImagePointer(p);
422 
423  // Set cursor position in virtual volume.
424  setCursorPosition(p);
425 
426  // Set cursor in bitImage of _drawImage.
427  maskBits.setCursorPosition(p);
428 
429  // Iterate over all voxels in voxel rows.
430  for (; p.x <= box.v2.x; p.x++){
431 
432  // Copy value from virtual volume if corresponding bit
433  // image flag denotes a modified value.
434  if (maskBits.getCursorValue() == maskValue){
435  *oP = static_cast<OUTDTYPE>(getCursorValue());
436  }
437  else{
438  // No copy desired. Set bkVal if writeBK permits it.
439  if (writeBK){ *oP =bkVal; }
440  }
441 
442  // Move all image cursors forward, but do not move them
443  // outside image areas in last column to avoid exceptions.
444  if (p.x < box.v2.x){
445  // Move forward the output data pointer.
446  ++oP;
447 
448  // Move forward the virtual volume cursor.
449  moveCursorX();
450 
451  // Move forward the bit image cursor.
452  maskBits.moveCursorX();
453  }
454  }
455  }
456  }
457  }
458  }
459  }
460 
461  // Restore cursor positions.
462  setCursorPosition(vvCursorPos);
463  maskBits.setCursorPosition(bitImgCursorPos);
464  }
465 
466 
473  inline DATATYPE *getWrittenPageData(MLuint32 wp) const { return static_cast<DATATYPE*>(_virtVol->getWrittenPageData(wp)); }
474 
475 
476 
485  static MLint getIntValueWrapped (void *vv, const ImageVector &pos) { return static_cast<MLint >((static_cast<TVirtualVolume<DATATYPE>*>(vv))->getValue(pos)); }
486  static MLint64 getInt64ValueWrapped (void *vv, const ImageVector &pos) { return static_cast<MLint64 >((static_cast<TVirtualVolume<DATATYPE>*>(vv))->getValue(pos)); }
487  static MLdouble getDoubleValueWrapped (void *vv, const ImageVector &pos) { return static_cast<MLdouble >((static_cast<TVirtualVolume<DATATYPE>*>(vv))->getValue(pos)); }
488  static MLldouble getLDoubleValueWrapped (void *vv, const ImageVector &pos) { return static_cast<MLldouble>((static_cast<TVirtualVolume<DATATYPE>*>(vv))->getValue(pos)); }
489  static MLint getIntCursorValueWrapped (void *vv) { return static_cast<MLint >((static_cast<TVirtualVolume<DATATYPE>*>(vv))->getCursorValue()); }
490  static MLint64 getInt64CursorValueWrapped (void *vv) { return static_cast<MLint64 >((static_cast<TVirtualVolume<DATATYPE>*>(vv))->getCursorValue()); }
491  static MLdouble getDoubleCursorValueWrapped (void *vv) { return static_cast<MLdouble >((static_cast<TVirtualVolume<DATATYPE>*>(vv))->getCursorValue()); }
492  static MLldouble getLDoubleCursorValueWrapped (void *vv) { return static_cast<MLldouble>((static_cast<TVirtualVolume<DATATYPE>*>(vv))->getCursorValue()); }
493  static const ImageVector &getCursorPositionWrapped(void *vv) { return (static_cast<TVirtualVolume<DATATYPE>*>(vv))->getCursorPosition(); }
494  static bool isMappedWrapped (void *vv, const ImageVector &pos) { return (static_cast<TVirtualVolume<DATATYPE>*>(vv))->isMapped(pos); }
495  static void setCursorPositionWrapped (void *vv, const ImageVector &pos) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setCursorPosition(pos); }
496  static void setIntValueWrapped (void *vv, const ImageVector &pos, MLint v) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setValue(pos, static_cast<DATATYPE>(v)); }
497  static void setInt64ValueWrapped (void *vv, const ImageVector &pos, MLint64 v) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setValue(pos, static_cast<DATATYPE>(v)); }
498  static void setDoubleValueWrapped (void *vv, const ImageVector &pos, MLdouble v) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setValue(pos, static_cast<DATATYPE>(v)); }
499  static void setLDoubleValueWrapped (void *vv, const ImageVector &pos, MLldouble v) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setValue(pos, static_cast<DATATYPE>(v)); }
500  static void setIntCursorValueWrapped (void *vv, MLint v) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setCursorValue(static_cast<DATATYPE>(v)); }
501  static void setInt64CursorValueWrapped (void *vv, MLint64 v) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setCursorValue(static_cast<DATATYPE>(v)); }
502  static void setDoubleCursorValueWrapped (void *vv, MLdouble v) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setCursorValue(static_cast<DATATYPE>(v)); }
503  static void setLDoubleCursorValueWrapped (void *vv, MLldouble v) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->setCursorValue(static_cast<DATATYPE>(v)); }
504  static void fillIntWrapped (void *vv, const ImageVector &v1, const ImageVector &v2, MLint v){ (static_cast<TVirtualVolume<DATATYPE>*>(vv))->fill(SubImageBox(v1, v2), static_cast<DATATYPE>(v)); }
505  static void fillInt64Wrapped (void *vv, const ImageVector &v1, const ImageVector &v2, MLint64 v){ (static_cast<TVirtualVolume<DATATYPE>*>(vv))->fill(SubImageBox(v1, v2), static_cast<DATATYPE>(v)); }
506  static void fillDoubleWrapped (void *vv, const ImageVector &v1, const ImageVector &v2, MLdouble v){ (static_cast<TVirtualVolume<DATATYPE>*>(vv))->fill(SubImageBox(v1, v2), static_cast<DATATYPE>(v)); }
507  static void fillLDoubleWrapped (void *vv, const ImageVector &v1, const ImageVector &v2, MLldouble v){ (static_cast<TVirtualVolume<DATATYPE>*>(vv))->fill(SubImageBox(v1, v2), static_cast<DATATYPE>(v)); }
508  static void moveCursorXWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->moveCursorX(); }
509  static void moveCursorYWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->moveCursorY(); }
510  static void moveCursorZWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->moveCursorZ(); }
511  static void moveCursorCWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->moveCursorC(); }
512  static void moveCursorTWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->moveCursorT(); }
513  static void moveCursorUWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->moveCursorU(); }
514  static void reverseMoveCursorXWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->reverseMoveCursorX(); }
515  static void reverseMoveCursorYWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->reverseMoveCursorY(); }
516  static void reverseMoveCursorZWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->reverseMoveCursorZ(); }
517  static void reverseMoveCursorCWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->reverseMoveCursorC(); }
518  static void reverseMoveCursorTWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->reverseMoveCursorT(); }
519  static void reverseMoveCursorUWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->reverseMoveCursorU(); }
520  static void moveCursorByOffsetWrapped (void *vv, const ImageVector &off) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->moveCursorByOffset(off); }
521  static void resetCursorWrapped (void *vv) { (static_cast<TVirtualVolume<DATATYPE>*>(vv))->resetCursor(); }
522  static bool moveCursorXWrapAroundWrapped (void *vv) { return (static_cast<TVirtualVolume<DATATYPE>*>(vv))->moveCursorXWrapAround(); }
524 
525 protected:
526 
527  //------------------------------------------------------------------------------------------------------
528  //------------------------------------------------------------------------------------------------------
529  //------------------------------------------------------------------------------------------------------
530  //
531  //
532  // NOTHING BELOW FOR NORMAL VIRTUAL VOLUME USAGE.
533  //
534  //
535  //------------------------------------------------------------------------------------------------------
536  //------------------------------------------------------------------------------------------------------
537  //------------------------------------------------------------------------------------------------------
538 
539 
540  //------------------------------------------------------------------------------------------------------
542  //------------------------------------------------------------------------------------------------------
543  void _init(VirtualVolume &vVol);
544 
545  //------------------------------------------------------------------------------------------------------
547  //------------------------------------------------------------------------------------------------------
548  void _cleanUp();
549 
550  //------------------------------------------------------------------------------------------------------
551  //------------------------------------------------------------------------------------------------------
552  // GetVoxel, SetVoxel and IsMapped implementations.
553  //------------------------------------------------------------------------------------------------------
554  //------------------------------------------------------------------------------------------------------
555 
556  //------------------------------------------------------------------------------------------------------
563  //------------------------------------------------------------------------------------------------------
565  inline DATATYPE _getVoxel1D (const ImageVector &pos);
566  inline DATATYPE _getVoxel2D (const ImageVector &pos);
567  inline DATATYPE _getVoxel3D (const ImageVector &pos);
568  inline DATATYPE _getVoxel4D (const ImageVector &pos);
569  inline DATATYPE _getVoxel5D (const ImageVector &pos);
570  inline DATATYPE _getVoxel6D (const ImageVector &pos);
571 
572  inline DATATYPE _getVoxel1DE(const ImageVector &pos);
573  inline DATATYPE _getVoxel2DE(const ImageVector &pos);
574  inline DATATYPE _getVoxel3DE(const ImageVector &pos);
575  inline DATATYPE _getVoxel4DE(const ImageVector &pos);
576  inline DATATYPE _getVoxel5DE(const ImageVector &pos);
577  inline DATATYPE _getVoxel6DE(const ImageVector &pos);
579 
580  //----------------------------------------------------------------------------------
587  //----------------------------------------------------------------------------------
589  inline void _setVoxel1D (const ImageVector &pos, DATATYPE voxVal);
590  inline void _setVoxel2D (const ImageVector &pos, DATATYPE voxVal);
591  inline void _setVoxel3D (const ImageVector &pos, DATATYPE voxVal);
592  inline void _setVoxel4D (const ImageVector &pos, DATATYPE voxVal);
593  inline void _setVoxel5D (const ImageVector &pos, DATATYPE voxVal);
594  inline void _setVoxel6D (const ImageVector &pos, DATATYPE voxVal);
595 
596  inline void _setVoxel1DE(const ImageVector &pos, DATATYPE voxVal);
597  inline void _setVoxel2DE(const ImageVector &pos, DATATYPE voxVal);
598  inline void _setVoxel3DE(const ImageVector &pos, DATATYPE voxVal);
599  inline void _setVoxel4DE(const ImageVector &pos, DATATYPE voxVal);
600  inline void _setVoxel5DE(const ImageVector &pos, DATATYPE voxVal);
601  inline void _setVoxel6DE(const ImageVector &pos, DATATYPE voxVal);
603 
604  //----------------------------------------------------------------------------------
610  //----------------------------------------------------------------------------------
612  inline bool _isMapped1D (const ImageVector &pos) const;
613  inline bool _isMapped2D (const ImageVector &pos) const;
614  inline bool _isMapped3D (const ImageVector &pos) const;
615  inline bool _isMapped4D (const ImageVector &pos) const;
616  inline bool _isMapped5D (const ImageVector &pos) const;
617  inline bool _isMapped6D (const ImageVector &pos) const;
618 
619  inline bool _isMapped1DE(const ImageVector &pos) const;
620  inline bool _isMapped2DE(const ImageVector &pos) const;
621  inline bool _isMapped3DE(const ImageVector &pos) const;
622  inline bool _isMapped4DE(const ImageVector &pos) const;
623  inline bool _isMapped5DE(const ImageVector &pos) const;
624  inline bool _isMapped6DE(const ImageVector &pos) const;
626 
627 
628  //--------------------------------------------------------------------------------------------------------------------------
633  //--------------------------------------------------------------------------------------------------------------------------
635  inline static DATATYPE _getVoxel1DCB (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel1D(pos); };
636  inline static DATATYPE _getVoxel2DCB (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel2D(pos); };
637  inline static DATATYPE _getVoxel3DCB (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel3D(pos); };
638  inline static DATATYPE _getVoxel4DCB (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel4D(pos); };
639  inline static DATATYPE _getVoxel5DCB (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel5D(pos); };
640  inline static DATATYPE _getVoxel6DCB (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel6D(pos); };
641 
642  inline static DATATYPE _getVoxel1DCBE (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel1DE(pos); };
643  inline static DATATYPE _getVoxel2DCBE (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel2DE(pos); };
644  inline static DATATYPE _getVoxel3DCBE (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel3DE(pos); };
645  inline static DATATYPE _getVoxel4DCBE (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel4DE(pos); };
646  inline static DATATYPE _getVoxel5DCBE (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel5DE(pos); };
647  inline static DATATYPE _getVoxel6DCBE (TVirtualVolume *obj, const ImageVector &pos) { return obj->_getVoxel6DE(pos); };
648 
649  inline static void _setVoxel1DCB (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel1D(pos, voxVal); };
650  inline static void _setVoxel2DCB (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel2D(pos, voxVal); };
651  inline static void _setVoxel3DCB (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel3D(pos, voxVal); };
652  inline static void _setVoxel4DCB (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel4D(pos, voxVal); };
653  inline static void _setVoxel5DCB (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel5D(pos, voxVal); };
654  inline static void _setVoxel6DCB (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel6D(pos, voxVal); };
655 
656  inline static void _setVoxel1DCBE (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel1DE(pos, voxVal); };
657  inline static void _setVoxel2DCBE (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel2DE(pos, voxVal); };
658  inline static void _setVoxel3DCBE (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel3DE(pos, voxVal); };
659  inline static void _setVoxel4DCBE (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel4DE(pos, voxVal); };
660  inline static void _setVoxel5DCBE (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel5DE(pos, voxVal); };
661  inline static void _setVoxel6DCBE (TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal) { obj->_setVoxel6DE(pos, voxVal); };
662 
663  inline static bool _isMapped1DCB (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped1D (pos); }
664  inline static bool _isMapped2DCB (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped2D (pos); };
665  inline static bool _isMapped3DCB (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped3D (pos); };
666  inline static bool _isMapped4DCB (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped4D (pos); };
667  inline static bool _isMapped5DCB (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped5D (pos); };
668  inline static bool _isMapped6DCB (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped6D (pos); };
669 
670  inline static bool _isMapped1DCBE (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped1DE(pos); };
671  inline static bool _isMapped2DCBE (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped2DE(pos); };
672  inline static bool _isMapped3DCBE (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped3DE(pos); };
673  inline static bool _isMapped4DCBE (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped4DE(pos); };
674  inline static bool _isMapped5DCBE (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped5DE(pos); };
675  inline static bool _isMapped6DCBE (const TVirtualVolume *obj, const ImageVector &pos) { return obj->_isMapped6DE(pos); };
677 
678 
679 
680  //----------------------------------------------------------------------------------
681  //----------------------------------------------------------------------------------
683  //----------------------------------------------------------------------------------
684  //----------------------------------------------------------------------------------
685 
686  //----------------------------------------------------------------------------------
688  //----------------------------------------------------------------------------------
690  inline void _setCursorPos1D (const ImageVector & p);
691  inline void _setCursorPos2D (const ImageVector & p);
692  inline void _setCursorPos3D (const ImageVector & p);
693  inline void _setCursorPos4D (const ImageVector & p);
694  inline void _setCursorPos5D (const ImageVector & p);
695  inline void _setCursorPos6D (const ImageVector & p);
696 
697  inline void _setCursorPos1DE(const ImageVector & p);
698  inline void _setCursorPos2DE(const ImageVector & p);
699  inline void _setCursorPos3DE(const ImageVector & p);
700  inline void _setCursorPos4DE(const ImageVector & p);
701  inline void _setCursorPos5DE(const ImageVector & p);
702  inline void _setCursorPos6DE(const ImageVector & p);
704 
705  //--------------------------------------------------------------------------------------------------------------------------
707  //--------------------------------------------------------------------------------------------------------------------------
709  inline static void _setCursorPos1DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos1D(p); };
710  inline static void _setCursorPos2DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos2D(p); };
711  inline static void _setCursorPos3DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos3D(p); };
712  inline static void _setCursorPos4DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos4D(p); };
713  inline static void _setCursorPos5DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos5D(p); };
714  inline static void _setCursorPos6DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos6D(p); };
715 
716  inline static void _setCursorPos1DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos1DE(p); };
717  inline static void _setCursorPos2DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos2DE(p); };
718  inline static void _setCursorPos3DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos3DE(p); };
719  inline static void _setCursorPos4DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos4DE(p); };
720  inline static void _setCursorPos5DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos5DE(p); };
721  inline static void _setCursorPos6DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_setCursorPos6DE(p); };
723 
724 
725  //----------------------------------------------------------------------------------
726  //----------------------------------------------------------------------------------
728  //----------------------------------------------------------------------------------
729  //----------------------------------------------------------------------------------
730 
731  //----------------------------------------------------------------------------------
733  //----------------------------------------------------------------------------------
735  inline void _moveCursorOffset1D (const ImageVector & p);
736  inline void _moveCursorOffset2D (const ImageVector & p);
737  inline void _moveCursorOffset3D (const ImageVector & p);
738  inline void _moveCursorOffset4D (const ImageVector & p);
739  inline void _moveCursorOffset5D (const ImageVector & p);
740  inline void _moveCursorOffset6D (const ImageVector & p);
741 
742  inline void _moveCursorOffset1DE(const ImageVector & p);
743  inline void _moveCursorOffset2DE(const ImageVector & p);
744  inline void _moveCursorOffset3DE(const ImageVector & p);
745  inline void _moveCursorOffset4DE(const ImageVector & p);
746  inline void _moveCursorOffset5DE(const ImageVector & p);
747  inline void _moveCursorOffset6DE(const ImageVector & p);
749 
750  //--------------------------------------------------------------------------------------------------------------------------
752  //--------------------------------------------------------------------------------------------------------------------------
754  inline static void _moveCursorOffset1DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset1D(p); };
755  inline static void _moveCursorOffset2DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset2D(p); };
756  inline static void _moveCursorOffset3DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset3D(p); };
757  inline static void _moveCursorOffset4DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset4D(p); };
758  inline static void _moveCursorOffset5DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset5D(p); };
759  inline static void _moveCursorOffset6DCB (TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset6D(p); };
760 
761  inline static void _moveCursorOffset1DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset1DE(p); };
762  inline static void _moveCursorOffset2DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset2DE(p); };
763  inline static void _moveCursorOffset3DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset3DE(p); };
764  inline static void _moveCursorOffset4DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset4DE(p); };
765  inline static void _moveCursorOffset5DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset5DE(p); };
766  inline static void _moveCursorOffset6DCBE(TVirtualVolume *obj, const ImageVector &p) { obj->_moveCursorOffset6DE(p); };
768 
769 
770  //----------------------------------------------------------------------------------
771  //----------------------------------------------------------------------------------
773  //----------------------------------------------------------------------------------
774  //----------------------------------------------------------------------------------
775 
776  // In the following sections multiple expressions such as
777  // _cIdx -= static_cast<MLuint>(_pStrides.x);
778  // are performed with casts to unsigned MLuint64 values, because according to C-standard
779  // the signed values are cast to unsigned int 64 before subtracting anyway; and this
780  // which is warned by compilers.
781  // Therefore the cast is done explicitly, which is okay, when considering that negative
782  // signed values are cast, converted to usually large unsigned values which are added
783  // with overflows resulting to the same value.
784 
785 
786  //--------------------------------------------------------------------------------------------------------------------------
788  //--------------------------------------------------------------------------------------------------------------------------
790  // See notes about casts at line 1000.
791  inline void _moveFX() { _cPos.x++; _cIdx += static_cast<MLuint>(_pStrides.x); if ((_cPos.x & _idxMask.x) == 0){ _cPageIdx += static_cast<MLuint>(_strides.x); } }
792  inline void _moveFY() { _cPos.y++; _cIdx += static_cast<MLuint>(_pStrides.y); if ((_cPos.y & _idxMask.y) == 0){ _cPageIdx += static_cast<MLuint>(_strides.y); } }
793  inline void _moveFZ() { _cPos.z++; _cIdx += static_cast<MLuint>(_pStrides.z); if ((_cPos.z & _idxMask.z) == 0){ _cPageIdx += static_cast<MLuint>(_strides.z); } }
794  inline void _moveFC() { _cPos.c++; _cIdx += static_cast<MLuint>(_pStrides.c); if ((_cPos.c & _idxMask.c) == 0){ _cPageIdx += static_cast<MLuint>(_strides.c); } }
795  inline void _moveFT() { _cPos.t++; _cIdx += static_cast<MLuint>(_pStrides.t); if ((_cPos.t & _idxMask.t) == 0){ _cPageIdx += static_cast<MLuint>(_strides.t); } }
796  inline void _moveFU() { _cPos.u++; _cIdx += static_cast<MLuint>(_pStrides.u); if ((_cPos.u & _idxMask.u) == 0){ _cPageIdx += static_cast<MLuint>(_strides.u); } }
797 
798  inline void _moveFXE() { if (_cPos.x < _extD.x){ _moveFX(); } else{ throw(ML_OUT_OF_RANGE); } }
799  inline void _moveFYE() { if (_cPos.y < _extD.y){ _moveFY(); } else{ throw(ML_OUT_OF_RANGE); } }
800  inline void _moveFZE() { if (_cPos.z < _extD.z){ _moveFZ(); } else{ throw(ML_OUT_OF_RANGE); } }
801  inline void _moveFCE() { if (_cPos.c < _extD.c){ _moveFC(); } else{ throw(ML_OUT_OF_RANGE); } }
802  inline void _moveFTE() { if (_cPos.t < _extD.t){ _moveFT(); } else{ throw(ML_OUT_OF_RANGE); } }
803  inline void _moveFUE() { if (_cPos.u < _extD.u){ _moveFU(); } else{ throw(ML_OUT_OF_RANGE); } }
805 
806  //--------------------------------------------------------------------------------------------------------------------------
808  //--------------------------------------------------------------------------------------------------------------------------
810  inline static void _moveFXCB (TVirtualVolume *obj) { obj->_moveFX(); }
811  inline static void _moveFYCB (TVirtualVolume *obj) { obj->_moveFY(); }
812  inline static void _moveFZCB (TVirtualVolume *obj) { obj->_moveFZ(); }
813  inline static void _moveFCCB (TVirtualVolume *obj) { obj->_moveFC(); }
814  inline static void _moveFTCB (TVirtualVolume *obj) { obj->_moveFT(); }
815  inline static void _moveFUCB (TVirtualVolume *obj) { obj->_moveFU(); }
816 
817  inline static void _moveFXCBE(TVirtualVolume *obj) { obj->_moveFXE(); }
818  inline static void _moveFYCBE(TVirtualVolume *obj) { obj->_moveFYE(); }
819  inline static void _moveFZCBE(TVirtualVolume *obj) { obj->_moveFZE(); }
820  inline static void _moveFCCBE(TVirtualVolume *obj) { obj->_moveFCE(); }
821  inline static void _moveFTCBE(TVirtualVolume *obj) { obj->_moveFTE(); }
822  inline static void _moveFUCBE(TVirtualVolume *obj) { obj->_moveFUE(); }
824 
825  //--------------------------------------------------------------------------------------------------------------------------
827  //--------------------------------------------------------------------------------------------------------------------------
829  // See notes about casts at line 1000.
830  inline void _moveBX() { _cPos.x--; _cIdx -= static_cast<MLuint>(_pStrides.x); if ((_cPos.x & _idxMask.x) == _idxMask.x){ _cPageIdx -= static_cast<MLuint>(_strides.x); } }
831  inline void _moveBY() { _cPos.y--; _cIdx -= static_cast<MLuint>(_pStrides.y); if ((_cPos.y & _idxMask.y) == _idxMask.y){ _cPageIdx -= static_cast<MLuint>(_strides.y); } }
832  inline void _moveBZ() { _cPos.z--; _cIdx -= static_cast<MLuint>(_pStrides.z); if ((_cPos.z & _idxMask.z) == _idxMask.z){ _cPageIdx -= static_cast<MLuint>(_strides.z); } }
833  inline void _moveBC() { _cPos.c--; _cIdx -= static_cast<MLuint>(_pStrides.c); if ((_cPos.c & _idxMask.c) == _idxMask.c){ _cPageIdx -= static_cast<MLuint>(_strides.c); } }
834  inline void _moveBT() { _cPos.t--; _cIdx -= static_cast<MLuint>(_pStrides.t); if ((_cPos.t & _idxMask.t) == _idxMask.t){ _cPageIdx -= static_cast<MLuint>(_strides.t); } }
835  inline void _moveBU() { _cPos.u--; _cIdx -= static_cast<MLuint>(_pStrides.u); if ((_cPos.u & _idxMask.u) == _idxMask.u){ _cPageIdx -= static_cast<MLuint>(_strides.u); } }
836 
839 #define _VV_MOVEBE_TEST(Q) if (_cPos.Q >= 0){ _cPageIdx -= static_cast<MLuint>(_strides.Q); } \
840  else{ _cPos.Q++; _cIdx += static_cast<MLuint>(_pStrides.Q); throw(ML_OUT_OF_RANGE); }
841 
842  // See notes about casts at line 1000.
843  inline void _moveBXE() { _cPos.x--; _cIdx -= static_cast<MLuint>(_pStrides.x); if ((_cPos.x & _idxMask.x) == _idxMask.x){ _VV_MOVEBE_TEST(x); } }
844  inline void _moveBYE() { _cPos.y--; _cIdx -= static_cast<MLuint>(_pStrides.y); if ((_cPos.y & _idxMask.y) == _idxMask.y){ _VV_MOVEBE_TEST(y); } }
845  inline void _moveBZE() { _cPos.z--; _cIdx -= static_cast<MLuint>(_pStrides.z); if ((_cPos.z & _idxMask.z) == _idxMask.z){ _VV_MOVEBE_TEST(z); } }
846  inline void _moveBCE() { _cPos.c--; _cIdx -= static_cast<MLuint>(_pStrides.c); if ((_cPos.c & _idxMask.c) == _idxMask.c){ _VV_MOVEBE_TEST(c); } }
847  inline void _moveBTE() { _cPos.t--; _cIdx -= static_cast<MLuint>(_pStrides.t); if ((_cPos.t & _idxMask.t) == _idxMask.t){ _VV_MOVEBE_TEST(t); } }
848  inline void _moveBUE() { _cPos.u--; _cIdx -= static_cast<MLuint>(_pStrides.u); if ((_cPos.u & _idxMask.u) == _idxMask.u){ _VV_MOVEBE_TEST(u); } }
849 #undef _VV_MOVEBE_TEST
851 
852 
853 
854  //--------------------------------------------------------------------------------------------------------------------------
856  //--------------------------------------------------------------------------------------------------------------------------
858  inline static void _moveBXCB (TVirtualVolume *obj) { obj->_moveBX(); }
859  inline static void _moveBYCB (TVirtualVolume *obj) { obj->_moveBY(); }
860  inline static void _moveBZCB (TVirtualVolume *obj) { obj->_moveBZ(); }
861  inline static void _moveBCCB (TVirtualVolume *obj) { obj->_moveBC(); }
862  inline static void _moveBTCB (TVirtualVolume *obj) { obj->_moveBT(); }
863  inline static void _moveBUCB (TVirtualVolume *obj) { obj->_moveBU(); }
864 
865  inline static void _moveBXCBE(TVirtualVolume *obj) { obj->_moveBXE(); }
866  inline static void _moveBYCBE(TVirtualVolume *obj) { obj->_moveBYE(); }
867  inline static void _moveBZCBE(TVirtualVolume *obj) { obj->_moveBZE(); }
868  inline static void _moveBCCBE(TVirtualVolume *obj) { obj->_moveBCE(); }
869  inline static void _moveBTCBE(TVirtualVolume *obj) { obj->_moveBTE(); }
870  inline static void _moveBUCBE(TVirtualVolume *obj) { obj->_moveBUE(); }
872 
873 
874 
875 private:
876 
878  typedef DATATYPE (*GetVoxelFunc) (TVirtualVolume *obj, const ImageVector &p);
879 
881  typedef void (*SetVoxelFunc) (TVirtualVolume *obj, const ImageVector &p, DATATYPE voxVal);
882 
884  typedef bool (*IsMappedFunc) (const TVirtualVolume *obj, const ImageVector &p);
885 
887  typedef void (*SetCursorPosFunc) (TVirtualVolume *obj, const ImageVector &p);
888 
890  typedef void (*MoveCursorOffsetFunc)(TVirtualVolume *obj, const ImageVector &p);
891 
893  typedef void (*MoveCursorPosFunc) (TVirtualVolume *obj);
894 
898  VirtualVolume *_convenienceInstance;
899 
901  VirtualVolume *_virtVol;
902 
904  ImageVector _ext;
905 
907  ImageVector _extD;
908 
910  PageBuffer *_pageArray;
911 
914  ImageVector _rShift;
915 
917  ImageVector _strides;
918 
920  ImageVector _pStrides;
921 
923  ImageVector _idxMask;
924 
926  GetVoxelFunc _getVoxelFunc;
927 
929  SetVoxelFunc _setVoxelFunc;
930 
932  IsMappedFunc _isMappedFunc;
933 
935  SetCursorPosFunc _setCursorPosFunc;
936 
938  MoveCursorOffsetFunc _moveCursorOffsetFunc;
939 
942  MoveCursorPosFunc _moveFXFunc;
943  MoveCursorPosFunc _moveFYFunc;
944  MoveCursorPosFunc _moveFZFunc;
945  MoveCursorPosFunc _moveFCFunc;
946  MoveCursorPosFunc _moveFTFunc;
947  MoveCursorPosFunc _moveFUFunc;
948 
949  MoveCursorPosFunc _moveBXFunc;
950  MoveCursorPosFunc _moveBYFunc;
951  MoveCursorPosFunc _moveBZFunc;
952  MoveCursorPosFunc _moveBCFunc;
953  MoveCursorPosFunc _moveBTFunc;
954  MoveCursorPosFunc _moveBUFunc;
956 
958  ImageVector _cPos;
959 
961  MLuint _cPageIdx;
962 
964  MLuint _cIdx;
965 
967  bool _useExc;
968 };
969 
970 //--------------------------------------------------------------------------------------------------------
971 // END OF USER INTERFACE
972 //--------------------------------------------------------------------------------------------------------
973 
974 
975 
976 
977 
978 //--------------------------------------------------------------------------------------------------------
979 //--------------------------------------------------------------------------------------------------------
980 // Implementation part of Virtual Volume.
981 //--------------------------------------------------------------------------------------------------------
982 //--------------------------------------------------------------------------------------------------------
983 
984 template <typename DATATYPE>
985 inline void TVirtualVolume<DATATYPE>::getValues(const ImageVector *pos, DATATYPE *results, MLuint num)
986 {
987  for (MLuint c=0; c < num; c++){
988  *results = _getVoxelFunc(this, *pos);
989  results++;
990  pos++;
991  }
992 }
993 
994 template <typename DATATYPE>
995 inline void TVirtualVolume<DATATYPE>::setCursorValue(DATATYPE val)
996 {
997  PageBuffer *page = _pageArray + _cPageIdx;
998  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[_cIdx] = val;
999  page->_locked = true;
1000 }
1001 
1003 template <typename DATATYPE>
1004 inline DATATYPE TVirtualVolume<DATATYPE>::getCursorValue()
1005 {
1006  PageBuffer *page = _pageArray + _cPageIdx;
1007  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[_cIdx];
1008 }
1009 
1011 template <typename DATATYPE>
1012 inline void TVirtualVolume<DATATYPE>::resetCursor()
1013 {
1014  static const ImageVector zeroPos(0);
1015  _setCursorPosFunc(this, zeroPos);
1016 }
1017 
1027 template <typename DATATYPE>
1028 inline bool TVirtualVolume<DATATYPE>::moveCursorXWrapAround()
1029 {
1030  if (_cPos.x < _extD.x){ _moveFXFunc(this); return true; }
1031  else{
1032  if (_cPos.y < _extD.y){ _moveFYFunc(this); }
1033  else{
1034  if (_cPos.z < _extD.z){ _moveFZFunc(this); }
1035  else{
1036  if (_cPos.c < _extD.c){ _moveFCFunc(this); }
1037  else{
1038  if (_cPos.t < _extD.t){ _moveFTFunc(this); }
1039  else{
1040  if (_cPos.u < _extD.u){ _moveFUFunc(this); }
1041  else{
1042  // Just return false but do not move cursor any
1043  // further. This makes loops much easier.
1044  return false;
1045  }
1046  _cPos.t = 0;
1047  }
1048  _cPos.c = 0;
1049  }
1050  _cPos.z = 0;
1051  }
1052  _cPos.y = 0;
1053  }
1054  _cPos.x = 0;
1055 
1056  // Cursor position has been reset in any component. Update settings.
1057  _setCursorPosFunc(this, _cPos);
1058  return true;
1059  }
1060 }
1061 
1063 template <typename DATATYPE>
1064 void TVirtualVolume<DATATYPE>::fill(const SubImageBox &box, DATATYPE value)
1065 {
1066  // Restrict size of filled area to valid image regions.
1067  SubImageBox subImgBox = SubImageBox::intersect(box, _virtVol->getBox());
1068 
1069  // Note: Future versions could optimise inner loop significantly
1070  // by filling complete rows in pages with memcpy statements
1071  // from a prefilled row (or even by using subimage copies
1072  // from a prefilled page if many pages are filled).
1073  ImageVector p;
1074  for (p.u=subImgBox.v1.u; p.u<=subImgBox.v2.u; p.u++){
1075  for (p.t=subImgBox.v1.t; p.t<=subImgBox.v2.t; p.t++){
1076  for (p.c=subImgBox.v1.c; p.c<=subImgBox.v2.c; p.c++){
1077  for (p.z=subImgBox.v1.z; p.z<=subImgBox.v2.z; p.z++){
1078  for (p.y=subImgBox.v1.y; p.y<=subImgBox.v2.y; p.y++){
1079  for (p.x=subImgBox.v1.x; p.x<=subImgBox.v2.x; p.x++){
1080  setValue(p, value);
1081  } // x
1082  }
1083  }
1084  }
1085  }
1086  } // u
1087 }
1088 
1089 //-----------------------------------------------------------------------------------------------
1091 //-----------------------------------------------------------------------------------------------
1092 template <typename DATATYPE>
1093 void TVirtualVolume<DATATYPE>::copyToSubImage(TSubImage<DATATYPE> &outSubImg)
1094 {
1095  _virtVol->copyToSubImage(outSubImg);
1096 }
1097 
1098 //-----------------------------------------------------------------------------------------------
1100 //-----------------------------------------------------------------------------------------------
1101 template <typename DATATYPE>
1102 void TVirtualVolume<DATATYPE>::copyFromSubImage(const TSubImage<DATATYPE> &inImg, const SubImageBox &box, const ImageVector &pos)
1103 {
1104  // Get extents of subImg as box.
1105  SubImageBox inBox = inImg.getBoxFromImageExtent();
1106 
1107  // Determine valid area in inImg which can be copied (overlap of inBox and box).
1108  // (Source area)
1109  SubImageBox srcBox = SubImageBox::intersect(inBox, box);
1110 
1111  // Get extents of virtualVolume as box.
1112  SubImageBox vvBox = _virtVol->getBox();
1113 
1114  // Determine the area where srcBox is copied to.
1115  SubImageBox tvvBox;
1116  tvvBox.v1 = srcBox.v1 + pos;
1117  tvvBox.v2 = srcBox.v2 + pos;
1118 
1119  // Restrict tvvBox to valid virtualVolume extents. (Destination area)
1120  SubImageBox dstBox = SubImageBox::intersect(vvBox, tvvBox);
1121 
1122  // Iterate over all voxels of the destination area in the virtual volume.
1123  ImageVector dPos, sPos;
1124  for (dPos.u=dstBox.v1.u, sPos.u = srcBox.v1.u; dPos.u<=dstBox.v2.u; dPos.u++, sPos.u++){
1125  for (dPos.t=dstBox.v1.t, sPos.t = srcBox.v1.t; dPos.t<=dstBox.v2.t; dPos.t++, sPos.t++){
1126  for (dPos.c=dstBox.v1.c, sPos.c = srcBox.v1.c; dPos.c<=dstBox.v2.c; dPos.c++, sPos.c++){
1127  for (dPos.z=dstBox.v1.z, sPos.z = srcBox.v1.z; dPos.z<=dstBox.v2.z; dPos.z++, sPos.z++){
1128  for (dPos.y=dstBox.v1.y, sPos.y = srcBox.v1.y; dPos.y<=dstBox.v2.y; dPos.y++, sPos.y++){
1129  for (dPos.x=dstBox.v1.x, sPos.x = srcBox.v1.x; dPos.x<=dstBox.v2.x; dPos.x++, sPos.x++){
1130  setValue(dPos, inImg.getSubImageValue(sPos));
1131  } // x
1132  }
1133  }
1134  }
1135  }
1136  } // u
1137 }
1138 
1142 template <typename DATATYPE>
1143 void TVirtualVolume<DATATYPE>::_init(VirtualVolume &vVol)
1144 {
1145  // To avoid a typical programming error force a fatal error if the template data type
1146  // does not match the virtual volume data type.
1147  if (vVol.getDataType() != MLGetDataTypeFromPtr(static_cast<DATATYPE*>(nullptr))){
1148  ML_PRINT_FATAL_ERROR("TVirtualVolume<DATATYPE>::_init()", ML_BAD_DATA_TYPE,
1149  "Mismatch of data type of virtual volume and template typename");
1150  }
1151 
1152  // Get some parameters from virtual volume instance.
1153  // _convenienceInstance = ...; // Must be initialized in all constructors before.
1154  _virtVol = &vVol;
1155  _ext = vVol._origVolumeExt;
1156  _extD = vVol._origVolumeExt-ImageVector(1);
1157  _pageArray = vVol._pageArray;
1158  _rShift = vVol._rShift;
1159  _strides = vVol._strides;
1160  _pStrides = vVol._pStrides;
1161  _idxMask = vVol._idxMask;
1162  _useExc = vVol._areExceptionsOn;
1163 
1164  // Set cursor position, cursor index and cursor page.
1165  _cPos = ImageVector(0);
1166  _cIdx = 0;
1167  _cPageIdx = 0;
1168 
1169  // Dependent on the dimension of the image we can select different read/write
1170  // functions. We do this to avoid unnecessary calculations of 6d coordinates
1171  // if the volume has only e.g. 2 dimensions.
1172  if (_useExc){
1173 
1175  _moveFXFunc = _moveFXCBE;
1176  _moveFYFunc = _moveFYCBE;
1177  _moveFZFunc = _moveFZCBE;
1178  _moveFCFunc = _moveFCCBE;
1179  _moveFTFunc = _moveFTCBE;
1180  _moveFUFunc = _moveFUCBE;
1181 
1182  _moveBXFunc = _moveBXCBE;
1183  _moveBYFunc = _moveBYCBE;
1184  _moveBZFunc = _moveBZCBE;
1185  _moveBCFunc = _moveBCCBE;
1186  _moveBTFunc = _moveBTCBE;
1187  _moveBUFunc = _moveBUCBE;
1188 
1189  // Set the correct setValue/getValue and setCursorPosition functions.
1190  switch (vVol.getDim()){
1191  case 1:
1192  _getVoxelFunc = _getVoxel1DCBE;
1193  _setVoxelFunc = _setVoxel1DCBE;
1194  _setCursorPosFunc = _setCursorPos1DCBE;
1195  _moveCursorOffsetFunc = _moveCursorOffset1DCBE;
1196  _isMappedFunc = _isMapped1DCBE;
1197  break;
1198  case 2:
1199  _getVoxelFunc = _getVoxel2DCBE;
1200  _setVoxelFunc = _setVoxel2DCBE;
1201  _setCursorPosFunc = _setCursorPos2DCBE;
1202  _moveCursorOffsetFunc = _moveCursorOffset2DCBE;
1203  _isMappedFunc = _isMapped2DCBE;
1204  break;
1205  case 3:
1206  _getVoxelFunc = _getVoxel3DCBE;
1207  _setVoxelFunc = _setVoxel3DCBE;
1208  _setCursorPosFunc = _setCursorPos3DCBE;
1209  _moveCursorOffsetFunc = _moveCursorOffset3DCBE;
1210  _isMappedFunc = _isMapped3DCBE;
1211  break;
1212  case 4:
1213  _getVoxelFunc = _getVoxel4DCBE;
1214  _setVoxelFunc = _setVoxel4DCBE;
1215  _setCursorPosFunc = _setCursorPos4DCBE;
1216  _moveCursorOffsetFunc = _moveCursorOffset4DCBE;
1217  _isMappedFunc = _isMapped4DCBE;
1218  break;
1219  case 5:
1220  _getVoxelFunc = _getVoxel5DCBE;
1221  _setVoxelFunc = _setVoxel5DCBE;
1222  _setCursorPosFunc = _setCursorPos5DCBE;
1223  _moveCursorOffsetFunc = _moveCursorOffset5DCBE;
1224  _isMappedFunc = _isMapped5DCBE;
1225  break;
1226  case 6:
1227  _getVoxelFunc = _getVoxel6DCBE;
1228  _setVoxelFunc = _setVoxel6DCBE;
1229  _setCursorPosFunc = _setCursorPos6DCBE;
1230  _moveCursorOffsetFunc = _moveCursorOffset6DCBE;
1231  _isMappedFunc = _isMapped6DCBE;
1232  break;
1233  default:
1234  _getVoxelFunc = _getVoxel6DCBE;
1235  _setVoxelFunc = _setVoxel6DCBE;
1236  _moveCursorOffsetFunc = _moveCursorOffset6DCBE;
1237  _setCursorPosFunc = _setCursorPos6DCBE;
1238  _isMappedFunc = _isMapped6DCBE;
1239  _virtVol->invalidate();
1240  throw(ML_BAD_DIMENSION);
1241  break;
1242  }
1243  }
1244  else{
1245 
1247  _moveFXFunc = _moveFXCB;
1248  _moveFYFunc = _moveFYCB;
1249  _moveFZFunc = _moveFZCB;
1250  _moveFCFunc = _moveFCCB;
1251  _moveFTFunc = _moveFTCB;
1252  _moveFUFunc = _moveFUCB;
1253 
1254  _moveBXFunc = _moveBXCB;
1255  _moveBYFunc = _moveBYCB;
1256  _moveBZFunc = _moveBZCB;
1257  _moveBCFunc = _moveBCCB;
1258  _moveBTFunc = _moveBTCB;
1259  _moveBUFunc = _moveBUCB;
1260 
1261  // Set the correct setValue/getValue and setCursorPosition functions.
1262  switch (vVol.getDim()){
1263  case 1:
1264  _getVoxelFunc = _getVoxel1DCB;
1265  _setVoxelFunc = _setVoxel1DCB;
1266  _setCursorPosFunc = _setCursorPos1DCB;
1267  _moveCursorOffsetFunc = _moveCursorOffset1DCB;
1268  _isMappedFunc = _isMapped1DCB;
1269  break;
1270  case 2:
1271  _getVoxelFunc = _getVoxel2DCB;
1272  _setVoxelFunc = _setVoxel2DCB;
1273  _setCursorPosFunc = _setCursorPos2DCB;
1274  _moveCursorOffsetFunc = _moveCursorOffset2DCB;
1275  _isMappedFunc = _isMapped2DCB;
1276  break;
1277  case 3:
1278  _getVoxelFunc = _getVoxel3DCB;
1279  _setVoxelFunc = _setVoxel3DCB;
1280  _setCursorPosFunc = _setCursorPos3DCB;
1281  _moveCursorOffsetFunc = _moveCursorOffset3DCB;
1282  _isMappedFunc = _isMapped3DCB;
1283  break;
1284  case 4:
1285  _getVoxelFunc = _getVoxel4DCB;
1286  _setVoxelFunc = _setVoxel4DCB;
1287  _setCursorPosFunc = _setCursorPos4DCB;
1288  _moveCursorOffsetFunc = _moveCursorOffset4DCB;
1289  _isMappedFunc = _isMapped4DCB;
1290  break;
1291  case 5:
1292  _getVoxelFunc = _getVoxel5DCB;
1293  _setVoxelFunc = _setVoxel5DCB;
1294  _setCursorPosFunc = _setCursorPos5DCB;
1295  _moveCursorOffsetFunc = _moveCursorOffset5DCB;
1296  _isMappedFunc = _isMapped5DCB;
1297  break;
1298  case 6:
1299  _getVoxelFunc = _getVoxel6DCB;
1300  _setVoxelFunc = _setVoxel6DCB;
1301  _setCursorPosFunc = _setCursorPos6DCB;
1302  _moveCursorOffsetFunc = _moveCursorOffset6DCB;
1303  _isMappedFunc = _isMapped6DCB;
1304  break;
1305  default:
1306  _getVoxelFunc = _getVoxel6DCB;
1307  _setVoxelFunc = _setVoxel6DCB;
1308  _setCursorPosFunc = _setCursorPos6DCB;
1309  _moveCursorOffsetFunc = _moveCursorOffset6DCB;
1310  _isMappedFunc = _isMapped6DCBE;
1311  _virtVol->invalidate();
1312  ML_PRINT_ERROR("TVirtualVolume::_init()", ML_BAD_DIMENSION, "Invalid image dimension. Using dimension 6. \n");
1313  break;
1314  }
1315  }
1316 }
1317 
1319 template <typename DATATYPE>
1320 void TVirtualVolume<DATATYPE>::_cleanUp()
1321 {
1322  // _convenienceInstance = ...; // Must be handled in destructor explicitly.
1323  _virtVol = nullptr;
1324  _ext = ImageVector(0);
1325  _extD = ImageVector(0);
1326  _pageArray = nullptr;
1327  _rShift = ImageVector(0);
1328  _strides = ImageVector(0);
1329  _pStrides = ImageVector(0);
1330  _getVoxelFunc = nullptr;
1331  _setVoxelFunc = nullptr;
1332  _setCursorPosFunc = nullptr;
1333  _moveCursorOffsetFunc = nullptr;
1334  _isMappedFunc = nullptr;
1335  _moveFXFunc = nullptr;
1336  _moveFYFunc = nullptr;
1337  _moveFZFunc = nullptr;
1338  _moveFCFunc = nullptr;
1339  _moveFTFunc = nullptr;
1340  _moveFUFunc = nullptr;
1341  _moveBXFunc = nullptr;
1342  _moveBYFunc = nullptr;
1343  _moveBZFunc = nullptr;
1344  _moveBCFunc = nullptr;
1345  _moveBTFunc = nullptr;
1346  _moveBUFunc = nullptr;
1347  _idxMask = ImageVector(0);
1348  _cPos = ImageVector(0);
1349  _cIdx = 0;
1350  _cPageIdx = 0;
1351  _useExc = false;
1352 }
1353 
1354 
1355 
1356 //----------------------------------------------------------------------------------------------------------
1357 // GetVoxel
1358 //----------------------------------------------------------------------------------------------------------
1359 
1361 template <typename DATATYPE>
1362 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel1D(const ImageVector &pos)
1363 {
1364  PageBuffer * const page = _pageArray + (pos.x >> _rShift.x);
1365  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x];
1366 };
1367 
1369 template <typename DATATYPE>
1370 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel1DE(const ImageVector &pos)
1371 {
1372  const MLint px = pos.x;
1373  if ((px < 0) || (px >= _ext.x)){ throw(ML_OUT_OF_RANGE); }
1374  PageBuffer * const page = _pageArray + (px >> _rShift.x);
1375  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px];
1376 };
1377 
1378 
1380 template <typename DATATYPE>
1381 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel2D(const ImageVector &pos)
1382 {
1383  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) + (pos.y >> _rShift.y)*_strides.y);
1384  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x+ pos.y*_pStrides.y];
1385 };
1386 
1388 template <typename DATATYPE>
1389 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel2DE(const ImageVector &pos)
1390 {
1391  const MLint px = pos.x;
1392  const MLint py = pos.y;
1393  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y)){ throw(ML_OUT_OF_RANGE); }
1394  PageBuffer * const page = _pageArray + ((px >> _rShift.x) + (py >> _rShift.y)*_strides.y);
1395  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px+ py*_pStrides.y];
1396 };
1397 
1398 
1399 
1401 template <typename DATATYPE>
1402 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel3D(const ImageVector &pos)
1403 {
1404  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
1405  (pos.y >> _rShift.y)*_strides.y +
1406  (pos.z >> _rShift.z)*_strides.z);
1407  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x + pos.y*_pStrides.y + pos.z*_pStrides.z];
1408 };
1409 
1411 template <typename DATATYPE>
1412 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel3DE(const ImageVector &pos)
1413 {
1414  const MLint px = pos.x;
1415  const MLint py = pos.y;
1416  const MLint pz = pos.z;
1417  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1418  (pz < 0) || (pz >= _ext.z)){ throw(ML_OUT_OF_RANGE); }
1419  PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
1420  (py >> _rShift.y)*_strides.y +
1421  (pz >> _rShift.z)*_strides.z);
1422  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px + py*_pStrides.y + pz*_pStrides.z];
1423 };
1424 
1425 
1426 
1428 template <typename DATATYPE>
1429 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel4D(const ImageVector &pos)
1430 {
1431  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
1432  (pos.y >> _rShift.y)*_strides.y +
1433  (pos.z >> _rShift.z)*_strides.z +
1434  (pos.c >> _rShift.c)*_strides.c);
1435  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x +
1436  pos.y*_pStrides.y +
1437  pos.z*_pStrides.z +
1438  pos.c*_pStrides.c];
1439 };
1440 
1442 template <typename DATATYPE>
1443 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel4DE(const ImageVector &pos)
1444 {
1445  const MLint px = pos.x;
1446  const MLint py = pos.y;
1447  const MLint pz = pos.z;
1448  const MLint pc = pos.c;
1449  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1450  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c)){ throw(ML_OUT_OF_RANGE); }
1451  PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
1452  (py >> _rShift.y)*_strides.y +
1453  (pz >> _rShift.z)*_strides.z +
1454  (pc >> _rShift.c)*_strides.c);
1455  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px +
1456  py*_pStrides.y +
1457  pz*_pStrides.z +
1458  pc*_pStrides.c];
1459 };
1460 
1462 template <typename DATATYPE>
1463 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel5D(const ImageVector &pos)
1464 {
1465  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
1466  (pos.y >> _rShift.y)*_strides.y +
1467  (pos.z >> _rShift.z)*_strides.z +
1468  (pos.c >> _rShift.c)*_strides.c +
1469  (pos.t >> _rShift.t)*_strides.t);
1470  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x +
1471  pos.y*_pStrides.y +
1472  pos.z*_pStrides.z +
1473  pos.c*_pStrides.c +
1474  pos.t*_pStrides.t];
1475 };
1476 
1478 template <typename DATATYPE>
1479 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel5DE(const ImageVector &pos)
1480 {
1481  const MLint px = pos.x;
1482  const MLint py = pos.y;
1483  const MLint pz = pos.z;
1484  const MLint pc = pos.c;
1485  const MLint pt = pos.t;
1486  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1487  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
1488  (pt < 0) || (pt >= _ext.t)){ throw(ML_OUT_OF_RANGE); }
1489  PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
1490  (py >> _rShift.y)*_strides.y +
1491  (pz >> _rShift.z)*_strides.z +
1492  (pc >> _rShift.c)*_strides.c +
1493  (pt >> _rShift.t)*_strides.t);
1494  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px +
1495  py*_pStrides.y +
1496  pz*_pStrides.z +
1497  pc*_pStrides.c +
1498  pt*_pStrides.t];
1499 };
1500 
1502 template <typename DATATYPE>
1503 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel6D(const ImageVector &pos)
1504 {
1505  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
1506  (pos.y >> _rShift.y)*_strides.y +
1507  (pos.z >> _rShift.z)*_strides.z +
1508  (pos.c >> _rShift.c)*_strides.c +
1509  (pos.t >> _rShift.t)*_strides.t +
1510  (pos.u >> _rShift.u)*_strides.u);
1511  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x +
1512  pos.y*_pStrides.y +
1513  pos.z*_pStrides.z +
1514  pos.c*_pStrides.c +
1515  pos.t*_pStrides.t +
1516  pos.u*_pStrides.u];
1517 };
1518 
1520 template <typename DATATYPE>
1521 inline DATATYPE TVirtualVolume<DATATYPE>::_getVoxel6DE(const ImageVector &pos)
1522 {
1523  const MLint px = pos.x;
1524  const MLint py = pos.y;
1525  const MLint pz = pos.z;
1526  const MLint pc = pos.c;
1527  const MLint pt = pos.t;
1528  const MLint pu = pos.u;
1529  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1530  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
1531  (pt < 0) || (pt >= _ext.t) || (pu < 0) || (pu >= _ext.u)){ throw(ML_OUT_OF_RANGE); }
1532  PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
1533  (py >> _rShift.y)*_strides.y +
1534  (pz >> _rShift.z)*_strides.z +
1535  (pc >> _rShift.c)*_strides.c +
1536  (pt >> _rShift.t)*_strides.t +
1537  (pu >> _rShift.u)*_strides.u);
1538  return (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px +
1539  py*_pStrides.y +
1540  pz*_pStrides.z +
1541  pc*_pStrides.c +
1542  pt*_pStrides.t +
1543  pu*_pStrides.u];
1544 };
1545 
1546 
1547 
1548 //----------------------------------------------------------------------------------------------------------
1549 // SetVoxel
1550 //----------------------------------------------------------------------------------------------------------
1551 
1552 
1553 
1555 template <typename DATATYPE>
1556 inline void TVirtualVolume<DATATYPE>::_setVoxel1D(const ImageVector &pos, DATATYPE voxVal)
1557 {
1558  PageBuffer * const page = _pageArray + (pos.x >> _rShift.x);
1559  page->_locked = true;
1560  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x] = voxVal;
1561 };
1562 
1564 template <typename DATATYPE>
1565 inline void TVirtualVolume<DATATYPE>::_setVoxel1DE(const ImageVector &pos, DATATYPE voxVal)
1566 {
1567  const MLint px = pos.x;
1568  if ((px < 0) || (px >= _ext.x)){ throw(ML_OUT_OF_RANGE); }
1569  PageBuffer * const page = _pageArray + (px >> _rShift.x);
1570  page->_locked = true;
1571  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px] = voxVal;
1572 };
1573 
1574 
1575 
1577 template <typename DATATYPE>
1578 inline void TVirtualVolume<DATATYPE>::_setVoxel2D(const ImageVector &pos, DATATYPE voxVal)
1579 {
1580  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) + (pos.y >> _rShift.y)*_strides.y);
1581  page->_locked = true;
1582  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x + pos.y*_pStrides.y] = voxVal;
1583 };
1584 
1586 template <typename DATATYPE>
1587 inline void TVirtualVolume<DATATYPE>::_setVoxel2DE(const ImageVector &pos, DATATYPE voxVal)
1588 {
1589  const MLint px = pos.x;
1590  const MLint py = pos.y;
1591  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y)){ throw(ML_OUT_OF_RANGE); }
1592  PageBuffer * const page = _pageArray + ((px >> _rShift.x) + (py >> _rShift.y)*_strides.y);
1593  page->_locked = true;
1594  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px + py*_pStrides.y] = voxVal;
1595 };
1596 
1597 
1598 
1600 template <typename DATATYPE>
1601 inline void TVirtualVolume<DATATYPE>::_setVoxel3D(const ImageVector &pos, DATATYPE voxVal)
1602 {
1603  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
1604  (pos.y >> _rShift.y)*_strides.y +
1605  (pos.z >> _rShift.z)*_strides.z);
1606  page->_locked = true;
1607  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x + pos.y*_pStrides.y + pos.z*_pStrides.z] = voxVal;
1608 };
1609 
1611 template <typename DATATYPE>
1612 inline void TVirtualVolume<DATATYPE>::_setVoxel3DE(const ImageVector &pos, DATATYPE voxVal)
1613 {
1614  const MLint px = pos.x;
1615  const MLint py = pos.y;
1616  const MLint pz = pos.z;
1617  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1618  (pz < 0) || (pz >= _ext.z)){ throw(ML_OUT_OF_RANGE); }
1619  PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
1620  (py >> _rShift.y)*_strides.y +
1621  (pz >> _rShift.z)*_strides.z);
1622  page->_locked = true;
1623  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px + py*_pStrides.y + pz*_pStrides.z] = voxVal;
1624 };
1625 
1626 
1627 
1629 template <typename DATATYPE>
1630 inline void TVirtualVolume<DATATYPE>::_setVoxel4D(const ImageVector &pos, DATATYPE voxVal)
1631 {
1632  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
1633  (pos.y >> _rShift.y)*_strides.y +
1634  (pos.z >> _rShift.z)*_strides.z +
1635  (pos.c >> _rShift.c)*_strides.c);
1636  page->_locked = true;
1637  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x +
1638  pos.y*_pStrides.y +
1639  pos.z*_pStrides.z +
1640  pos.c*_pStrides.c] = voxVal;
1641 };
1642 
1644 template <typename DATATYPE>
1645 inline void TVirtualVolume<DATATYPE>::_setVoxel4DE(const ImageVector &pos, DATATYPE voxVal)
1646 {
1647  const MLint px = pos.x;
1648  const MLint py = pos.y;
1649  const MLint pz = pos.z;
1650  const MLint pc = pos.c;
1651  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1652  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c)){ throw(ML_OUT_OF_RANGE); }
1653  PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
1654  (py >> _rShift.y)*_strides.y +
1655  (pz >> _rShift.z)*_strides.z +
1656  (pc >> _rShift.c)*_strides.c);
1657  page->_locked = true;
1658  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px +
1659  py*_pStrides.y +
1660  pz*_pStrides.z +
1661  pc*_pStrides.c] = voxVal;
1662 };
1663 
1664 
1665 
1667 template <typename DATATYPE>
1668 inline void TVirtualVolume<DATATYPE>::_setVoxel5D(const ImageVector &pos, DATATYPE voxVal)
1669 {
1670  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
1671  (pos.y >> _rShift.y)*_strides.y +
1672  (pos.z >> _rShift.z)*_strides.z +
1673  (pos.c >> _rShift.c)*_strides.c +
1674  (pos.t >> _rShift.t)*_strides.t);
1675  page->_locked = true;
1676  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x +
1677  pos.y*_pStrides.y +
1678  pos.z*_pStrides.z +
1679  pos.c*_pStrides.c +
1680  pos.t*_pStrides.t] = voxVal;
1681 };
1682 
1684 template <typename DATATYPE>
1685 inline void TVirtualVolume<DATATYPE>::_setVoxel5DE(const ImageVector &pos, DATATYPE voxVal)
1686 {
1687  const MLint px = pos.x;
1688  const MLint py = pos.y;
1689  const MLint pz = pos.z;
1690  const MLint pc = pos.c;
1691  const MLint pt = pos.t;
1692  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1693  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
1694  (pt < 0) || (pt >= _ext.t)){ throw(ML_OUT_OF_RANGE); }
1695  PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
1696  (py >> _rShift.y)*_strides.y +
1697  (pz >> _rShift.z)*_strides.z +
1698  (pc >> _rShift.c)*_strides.c +
1699  (pt >> _rShift.t)*_strides.t);
1700  page->_locked = true;
1701  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px +
1702  py*_pStrides.y +
1703  pz*_pStrides.z +
1704  pc*_pStrides.c +
1705  pt*_pStrides.t] = voxVal;
1706 };
1707 
1708 
1709 
1711 template <typename DATATYPE>
1712 inline void TVirtualVolume<DATATYPE>::_setVoxel6D(const ImageVector &pos, DATATYPE voxVal)
1713 {
1714  PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
1715  (pos.y >> _rShift.y)*_strides.y +
1716  (pos.z >> _rShift.z)*_strides.z +
1717  (pos.c >> _rShift.c)*_strides.c +
1718  (pos.t >> _rShift.t)*_strides.t +
1719  (pos.u >> _rShift.u)*_strides.u);
1720  page->_locked = true;
1721  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[pos.x +
1722  pos.y*_pStrides.y +
1723  pos.z*_pStrides.z +
1724  pos.c*_pStrides.c +
1725  pos.t*_pStrides.t +
1726  pos.u*_pStrides.u] = voxVal;
1727 };
1728 
1730 template <typename DATATYPE>
1731 inline void TVirtualVolume<DATATYPE>::_setVoxel6DE(const ImageVector &pos, DATATYPE voxVal)
1732 {
1733  const MLint px = pos.x;
1734  const MLint py = pos.y;
1735  const MLint pz = pos.z;
1736  const MLint pc = pos.c;
1737  const MLint pt = pos.t;
1738  const MLint pu = pos.u;
1739  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1740  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
1741  (pt < 0) || (pt >= _ext.t) || (pu < 0) || (pu >= _ext.u)){ throw(ML_OUT_OF_RANGE); }
1742  PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
1743  (py >> _rShift.y)*_strides.y +
1744  (pz >> _rShift.z)*_strides.z +
1745  (pc >> _rShift.c)*_strides.c +
1746  (pt >> _rShift.t)*_strides.t +
1747  (pu >> _rShift.u)*_strides.u);
1748  page->_locked = true;
1749  (static_cast<DATATYPE*>(page->_getPageFkt(page)))[px +
1750  py*_pStrides.y +
1751  pz*_pStrides.z +
1752  pc*_pStrides.c +
1753  pt*_pStrides.t +
1754  pu*_pStrides.u] = voxVal;
1755 };
1756 
1757 
1758 
1759 
1760 //----------------------------------------------------------------------------------------------------------
1761 // SetCursorPos.
1762 //----------------------------------------------------------------------------------------------------------
1763 
1764 
1765 
1767 template <typename DATATYPE>
1768 inline void TVirtualVolume<DATATYPE>::_setCursorPos1D(const ImageVector & p)
1769 {
1770  _cPos.x = p.x;
1771  _cIdx = static_cast<MLuint>(p.x);
1772  _cPageIdx = static_cast<MLuint>(p.x >> _rShift.x);
1773 }
1774 
1776 template <typename DATATYPE>
1777 inline void TVirtualVolume<DATATYPE>::_setCursorPos1DE(const ImageVector & pos)
1778 {
1779  const MLint px = pos.x;
1780  if ((px < 0) || (px >= _ext.x)){ throw(ML_OUT_OF_RANGE); }
1781  _cPos.x = px;
1782  _cIdx = static_cast<MLuint>(px);
1783  _cPageIdx = static_cast<MLuint>(px >> _rShift.x);
1784 }
1785 
1786 
1787 
1789 template <typename DATATYPE>
1790 inline void TVirtualVolume<DATATYPE>::_setCursorPos2D(const ImageVector & p)
1791 {
1792  _cPos.x = p.x;
1793  _cPos.y = p.y;
1794  _cIdx = static_cast<MLuint>(p.x + p.y*_pStrides.y);
1795  _cPageIdx = static_cast<MLuint>((p.x >> _rShift.x) +
1796  (p.y >> _rShift.y)*_strides.y);
1797 }
1798 
1800 template <typename DATATYPE>
1801 inline void TVirtualVolume<DATATYPE>::_setCursorPos2DE(const ImageVector & pos)
1802 {
1803  const MLint px = pos.x;
1804  const MLint py = pos.y;
1805  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y)){ throw(ML_OUT_OF_RANGE); }
1806  _cPos.x = px;
1807  _cPos.y = py;
1808  _cIdx = static_cast<MLuint>(px + py*_pStrides.y);
1809  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) +
1810  (py >> _rShift.y)*_strides.y);
1811 }
1812 
1813 
1814 
1816 template <typename DATATYPE>
1817 inline void TVirtualVolume<DATATYPE>::_setCursorPos3D(const ImageVector & p)
1818 {
1819  _cPos.x = p.x;
1820  _cPos.y = p.y;
1821  _cPos.z = p.z;
1822  _cIdx = static_cast<MLuint>(p.x + p.y*_pStrides.y + p.z*_pStrides.z);
1823  _cPageIdx = static_cast<MLuint>((p.x >> _rShift.x) +
1824  (p.y >> _rShift.y)*_strides.y +
1825  (p.z >> _rShift.z)*_strides.z);
1826 }
1827 
1829 template <typename DATATYPE>
1830 inline void TVirtualVolume<DATATYPE>::_setCursorPos3DE(const ImageVector & pos)
1831 {
1832  const MLint px = pos.x;
1833  const MLint py = pos.y;
1834  const MLint pz = pos.z;
1835  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1836  (pz < 0) || (pz >= _ext.z)){ throw(ML_OUT_OF_RANGE); }
1837  _cPos.x = px;
1838  _cPos.y = py;
1839  _cPos.z = pz;
1840  _cIdx = static_cast<MLuint>(px + py*_pStrides.y + pz*_pStrides.z);
1841  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) +
1842  (py >> _rShift.y)*_strides.y +
1843  (pz >> _rShift.z)*_strides.z);
1844 }
1845 
1846 
1847 
1849 template <typename DATATYPE>
1850 inline void TVirtualVolume<DATATYPE>::_setCursorPos4D(const ImageVector &p)
1851 {
1852  _cPos.x = p.x;
1853  _cPos.y = p.y;
1854  _cPos.z = p.z;
1855  _cPos.c = p.c;
1856  _cIdx = static_cast<MLuint>(p.x + p.y*_pStrides.y + p.z*_pStrides.z + p.c*_pStrides.c);
1857  _cPageIdx = static_cast<MLuint>((p.x >> _rShift.x) +
1858  (p.y >> _rShift.y)*_strides.y +
1859  (p.z >> _rShift.z)*_strides.z +
1860  (p.c >> _rShift.c)*_strides.c);
1861 }
1862 
1864 template <typename DATATYPE>
1865 inline void TVirtualVolume<DATATYPE>::_setCursorPos4DE(const ImageVector &pos)
1866 {
1867  const MLint px = pos.x;
1868  const MLint py = pos.y;
1869  const MLint pz = pos.z;
1870  const MLint pc = pos.c;
1871  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1872  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c)){ throw(ML_OUT_OF_RANGE); }
1873  _cPos.x = px;
1874  _cPos.y = py;
1875  _cPos.z = pz;
1876  _cPos.c = pc;
1877  _cIdx = static_cast<MLuint>(px + py*_pStrides.y + pz*_pStrides.z + pc*_pStrides.c);
1878  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) +
1879  (py >> _rShift.y)*_strides.y +
1880  (pz >> _rShift.z)*_strides.z +
1881  (pc >> _rShift.c)*_strides.c);
1882 }
1883 
1884 
1885 
1887 template <typename DATATYPE>
1888 inline void TVirtualVolume<DATATYPE>::_setCursorPos5D(const ImageVector & p)
1889 {
1890  // Save cursor position.
1891  _cPos = p;
1892 
1893  // Determine the index to the voxel within the page.
1894  _cIdx = static_cast<MLuint>(p.x + p.y*_pStrides.y + p.z*_pStrides.z + p.c*_pStrides.c + p.t*_pStrides.t);
1895 
1896  // Determine index of the page under the cursor position.
1897  _cPageIdx = static_cast<MLuint>((p.x >> _rShift.x) +
1898  (p.y >> _rShift.y)*_strides.y +
1899  (p.z >> _rShift.z)*_strides.z +
1900  (p.c >> _rShift.c)*_strides.c +
1901  (p.t >> _rShift.t)*_strides.t);
1902 }
1903 
1905 template <typename DATATYPE>
1906 inline void TVirtualVolume<DATATYPE>::_setCursorPos5DE(const ImageVector & pos)
1907 {
1908  const MLint px = pos.x;
1909  const MLint py = pos.y;
1910  const MLint pz = pos.z;
1911  const MLint pc = pos.c;
1912  const MLint pt = pos.t;
1913  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1914  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
1915  (pt < 0) || (pt >= _ext.t)){ throw(ML_OUT_OF_RANGE); }
1916 
1917  // Save cursor position.
1918  _cPos = pos;
1919 
1920  // Determine the index to the voxel within the page.
1921  _cIdx = static_cast<MLuint>(px + py*_pStrides.y + pz*_pStrides.z + pc*_pStrides.c + pt*_pStrides.t);
1922 
1923  // Determine index of the page under the cursor position.
1924  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) +
1925  (py >> _rShift.y)*_strides.y +
1926  (pz >> _rShift.z)*_strides.z +
1927  (pc >> _rShift.c)*_strides.c +
1928  (pt >> _rShift.t)*_strides.t);
1929 }
1930 
1931 
1932 
1934 template <typename DATATYPE>
1935 inline void TVirtualVolume<DATATYPE>::_setCursorPos6D(const ImageVector & p)
1936 {
1937  // Save cursor position.
1938  _cPos = p;
1939 
1940  // Determine the index to the voxel within the page.
1941  _cIdx = static_cast<MLuint>(p.x + p.y*_pStrides.y + p.z*_pStrides.z +
1942  p.c*_pStrides.c + p.t*_pStrides.t + p.u*_pStrides.u);
1943 
1944  // Determine index of the page under the cursor position.
1945  _cPageIdx = static_cast<MLuint>((p.x >> _rShift.x) +
1946  (p.y >> _rShift.y)*_strides.y +
1947  (p.z >> _rShift.z)*_strides.z +
1948  (p.c >> _rShift.c)*_strides.c +
1949  (p.t >> _rShift.t)*_strides.t +
1950  (p.u >> _rShift.u)*_strides.u);
1951 }
1952 
1954 template <typename DATATYPE>
1955 inline void TVirtualVolume<DATATYPE>::_setCursorPos6DE(const ImageVector & pos)
1956 {
1957  const MLint px = pos.x;
1958  const MLint py = pos.y;
1959  const MLint pz = pos.z;
1960  const MLint pc = pos.c;
1961  const MLint pt = pos.t;
1962  const MLint pu = pos.u;
1963  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
1964  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
1965  (pt < 0) || (pt >= _ext.t) || (pu < 0) || (pu >= _ext.u)){ throw(ML_OUT_OF_RANGE); }
1966 
1967  // Save cursor position.
1968  _cPos = pos;
1969 
1970  // Determine the index to the voxel within the page.
1971  _cIdx = static_cast<MLuint>(px + py*_pStrides.y + pz*_pStrides.z +
1972  pc*_pStrides.c + pt*_pStrides.t + pu*_pStrides.u);
1973 
1974  // Determine index of the page under the cursor position.
1975  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) +
1976  (py >> _rShift.y)*_strides.y +
1977  (pz >> _rShift.z)*_strides.z +
1978  (pc >> _rShift.c)*_strides.c +
1979  (pt >> _rShift.t)*_strides.t +
1980  (pu >> _rShift.u)*_strides.u);
1981 }
1982 
1983 
1984 
1985 
1986 //----------------------------------------------------------------------------------------------------------
1987 // MoveCursorOffset
1988 //----------------------------------------------------------------------------------------------------------
1989 
1990 
1991 
1993 template <typename DATATYPE>
1994 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset1D(const ImageVector & off)
1995 {
1996  _cPos.x += off.x;
1997  _cIdx = static_cast<MLuint>(_cPos.x);
1998  _cPageIdx = static_cast<MLuint>(_cPos.x >> _rShift.x);
1999 }
2000 
2002 template <typename DATATYPE>
2003 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset1DE(const ImageVector & off)
2004 {
2005  const MLint px = _cPos.x + off.x;
2006  if ((px < 0) || (px >= _ext.x)){ throw(ML_OUT_OF_RANGE); }
2007  _cPos.x = px;
2008  _cIdx = static_cast<MLuint>(px);
2009  _cPageIdx = static_cast<MLuint>(px >> _rShift.x);
2010 }
2011 
2012 
2013 
2015 template <typename DATATYPE>
2016 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset2D(const ImageVector & off)
2017 {
2018  _cPos.x += off.x;
2019  _cPos.y += off.y;
2020  _cIdx = static_cast<MLuint>(_cPos.x + _cPos.y*_pStrides.y);
2021  _cPageIdx = static_cast<MLuint>((_cPos.x >> _rShift.x) + (_cPos.y >> _rShift.y)*_strides.y);
2022 }
2023 
2025 template <typename DATATYPE>
2026 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset2DE(const ImageVector & off)
2027 {
2028  const MLint px = _cPos.x + off.x;
2029  const MLint py = _cPos.y + off.y;
2030  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y)){ throw(ML_OUT_OF_RANGE); }
2031  _cPos.x = px;
2032  _cPos.y = py;
2033  _cIdx = static_cast<MLuint>(px + py*_pStrides.y);
2034  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) + (py >> _rShift.y)*_strides.y);
2035 }
2036 
2037 
2038 
2040 template <typename DATATYPE>
2041 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset3D(const ImageVector & off)
2042 {
2043  _cPos.x += off.x;
2044  _cPos.y += off.y;
2045  _cPos.z += off.z;
2046  _cIdx = static_cast<MLuint>(_cPos.x + _cPos.y*_pStrides.y + _cPos.z*_pStrides.z);
2047  _cPageIdx = static_cast<MLuint>((_cPos.x >> _rShift.x) +
2048  (_cPos.y >> _rShift.y)*_strides.y +
2049  (_cPos.z >> _rShift.z)*_strides.z);
2050 }
2051 
2053 template <typename DATATYPE>
2054 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset3DE(const ImageVector & off)
2055 {
2056  const MLint px = _cPos.x+off.x;
2057  const MLint py = _cPos.y+off.y;
2058  const MLint pz = _cPos.z+off.z;
2059  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
2060  (pz < 0) || (pz >= _ext.z)){ throw(ML_OUT_OF_RANGE); }
2061  _cPos.x = px;
2062  _cPos.y = py;
2063  _cPos.z = pz;
2064  _cIdx = static_cast<MLuint>(px + py*_pStrides.y + pz*_pStrides.z);
2065  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) +
2066  (py >> _rShift.y)*_strides.y +
2067  (pz >> _rShift.z)*_strides.z);
2068 }
2069 
2070 
2071 
2073 template <typename DATATYPE>
2074 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset4D(const ImageVector &off)
2075 {
2076  _cPos.x += off.x;
2077  _cPos.y += off.y;
2078  _cPos.z += off.z;
2079  _cPos.c += off.c;
2080  _cIdx = static_cast<MLuint>(_cPos.x + _cPos.y*_pStrides.y + _cPos.z*_pStrides.z + _cPos.c*_pStrides.c);
2081  _cPageIdx = static_cast<MLuint>((_cPos.x >> _rShift.x) +
2082  (_cPos.y >> _rShift.y)*_strides.y +
2083  (_cPos.z >> _rShift.z)*_strides.z +
2084  (_cPos.c >> _rShift.c)*_strides.c);
2085 }
2086 
2088 template <typename DATATYPE>
2089 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset4DE(const ImageVector &off)
2090 {
2091  const MLint px = _cPos.x + off.x;
2092  const MLint py = _cPos.y + off.y;
2093  const MLint pz = _cPos.z + off.z;
2094  const MLint pc = _cPos.c + off.c;
2095  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
2096  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c)){ throw(ML_OUT_OF_RANGE); }
2097  _cPos.x = px;
2098  _cPos.y = py;
2099  _cPos.z = pz;
2100  _cPos.c = pc;
2101  _cIdx = static_cast<MLuint>(px + py*_pStrides.y + pz*_pStrides.z + pc*_pStrides.c);
2102  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) +
2103  (py >> _rShift.y)*_strides.y +
2104  (pz >> _rShift.z)*_strides.z +
2105  (pc >> _rShift.c)*_strides.c);
2106 }
2107 
2108 
2109 
2111 template <typename DATATYPE>
2112 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset5D(const ImageVector & off)
2113 {
2114  // Calculate new cursor position.
2115  _cPos += off;
2116 
2117  // Determine the index to the voxel within the page.
2118  _cIdx = static_cast<MLuint>(_cPos.x +
2119  _cPos.y*_pStrides.y + _cPos.z*_pStrides.z +
2120  _cPos.c*_pStrides.c + _cPos.t*_pStrides.t);
2121 
2122  // Determine index of the page under the cursor position.
2123  _cPageIdx = static_cast<MLuint>((_cPos.x >> _rShift.x) +
2124  (_cPos.y >> _rShift.y)*_strides.y +
2125  (_cPos.z >> _rShift.z)*_strides.z +
2126  (_cPos.c >> _rShift.c)*_strides.c +
2127  (_cPos.t >> _rShift.t)*_strides.t);
2128 }
2129 
2131 template <typename DATATYPE>
2132 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset5DE(const ImageVector & off)
2133 {
2134  const MLint px = _cPos.x + off.x;
2135  const MLint py = _cPos.y + off.y;
2136  const MLint pz = _cPos.z + off.z;
2137  const MLint pc = _cPos.c + off.c;
2138  const MLint pt = _cPos.t + off.t;
2139  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
2140  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
2141  (pt < 0) || (pt >= _ext.t)){ throw(ML_OUT_OF_RANGE); }
2142 
2143  // Save cursor position.
2144  _cPos.set(px,py,pz,pc,pt,0);
2145 
2146  // Determine the index to the voxel within the page.
2147  _cIdx = static_cast<MLuint>(px + py*_pStrides.y + pz*_pStrides.z + pc*_pStrides.c + pt*_pStrides.t);
2148 
2149  // Determine index of the page under the cursor position.
2150  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) +
2151  (py >> _rShift.y)*_strides.y +
2152  (pz >> _rShift.z)*_strides.z +
2153  (pc >> _rShift.c)*_strides.c +
2154  (pt >> _rShift.t)*_strides.t);
2155 }
2156 
2157 
2158 
2160 template <typename DATATYPE>
2161 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset6D(const ImageVector & off)
2162 {
2163  // Save cursor position.
2164  _cPos += off;
2165 
2166  // Determine the index to the voxel within the page.
2167  _cIdx = static_cast<MLuint>(_cPos.x + _cPos.y*_pStrides.y + _cPos.z*_pStrides.z +
2168  _cPos.c*_pStrides.c + _cPos.t*_pStrides.t + _cPos.u*_pStrides.u);
2169 
2170  // Determine index of the page under the cursor position.
2171  _cPageIdx = static_cast<MLuint>((_cPos.x >> _rShift.x) +
2172  (_cPos.y >> _rShift.y)*_strides.y +
2173  (_cPos.z >> _rShift.z)*_strides.z +
2174  (_cPos.c >> _rShift.c)*_strides.c +
2175  (_cPos.t >> _rShift.t)*_strides.t +
2176  (_cPos.u >> _rShift.u)*_strides.u);
2177 }
2178 
2180 template <typename DATATYPE>
2181 inline void TVirtualVolume<DATATYPE>::_moveCursorOffset6DE(const ImageVector & off)
2182 {
2183  const MLint px = _cPos.x + off.x;
2184  const MLint py = _cPos.y + off.y;
2185  const MLint pz = _cPos.z + off.z;
2186  const MLint pc = _cPos.c + off.c;
2187  const MLint pt = _cPos.t + off.t;
2188  const MLint pu = _cPos.u + off.u;
2189  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
2190  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
2191  (pt < 0) || (pt >= _ext.t) || (pu < 0) || (pu >= _ext.u)){ throw(ML_OUT_OF_RANGE); }
2192 
2193  // Save cursor position.
2194  _cPos.set(px,py,pz,pc,pt,pu);
2195 
2196  // Determine the index to the voxel within the page.
2197  _cIdx = static_cast<MLuint>(px + py*_pStrides.y + pz*_pStrides.z +
2198  pc*_pStrides.c + pt*_pStrides.t + pu*_pStrides.u);
2199 
2200  // Determine index of the page under the cursor position.
2201  _cPageIdx = static_cast<MLuint>((px >> _rShift.x) + (py >> _rShift.y)*_strides.y +
2202  (pz >> _rShift.z)*_strides.z + (pc >> _rShift.c)*_strides.c +
2203  (pt >> _rShift.t)*_strides.t + (pu >> _rShift.u)*_strides.u);
2204 }
2205 
2206 
2207 
2208 //----------------------------------------------------------------------------------------------------------
2209 // IsMapped.
2210 //----------------------------------------------------------------------------------------------------------
2211 
2212 
2213 
2215 template <typename DATATYPE>
2216 inline bool TVirtualVolume<DATATYPE>::_isMapped1D(const ImageVector &pos) const
2217 {
2218  const PageBuffer * const page = _pageArray + (pos.x >> _rShift.x);
2219  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2220 };
2221 
2223 template <typename DATATYPE>
2224 inline bool TVirtualVolume<DATATYPE>::_isMapped1DE(const ImageVector &pos) const
2225 {
2226  const MLint px = pos.x;
2227  if ((px < 0) || (px >= _ext.x)){ throw(ML_OUT_OF_RANGE); }
2228  const PageBuffer * const page = _pageArray + (px >> _rShift.x);
2229  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2230 };
2231 
2232 
2233 
2235 template <typename DATATYPE>
2236 inline bool TVirtualVolume<DATATYPE>::_isMapped2D(const ImageVector &pos) const
2237 {
2238  const PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) + (pos.y >> _rShift.y)*_strides.y);
2239  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2240 };
2241 
2243 template <typename DATATYPE>
2244 inline bool TVirtualVolume<DATATYPE>::_isMapped2DE(const ImageVector &pos) const
2245 {
2246  const MLint px = pos.x;
2247  const MLint py = pos.y;
2248  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y)){ throw(ML_OUT_OF_RANGE); }
2249  const PageBuffer * const page = _pageArray + ((px >> _rShift.x) + (py >> _rShift.y)*_strides.y);
2250  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2251 };
2252 
2253 
2254 
2256 template <typename DATATYPE>
2257 inline bool TVirtualVolume<DATATYPE>::_isMapped3D(const ImageVector &pos) const
2258 {
2259  const PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
2260  (pos.y >> _rShift.y)*_strides.y +
2261  (pos.z >> _rShift.z)*_strides.z);
2262  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2263 };
2264 
2266 template <typename DATATYPE>
2267 inline bool TVirtualVolume<DATATYPE>::_isMapped3DE(const ImageVector &pos) const
2268 {
2269  const MLint px = pos.x;
2270  const MLint py = pos.y;
2271  const MLint pz = pos.z;
2272  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
2273  (pz < 0) || (pz >= _ext.z)){ throw(ML_OUT_OF_RANGE); }
2274  const PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
2275  (py >> _rShift.y)*_strides.y +
2276  (pz >> _rShift.z)*_strides.z);
2277  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2278 };
2279 
2280 
2281 
2283 template <typename DATATYPE>
2284 inline bool TVirtualVolume<DATATYPE>::_isMapped4D(const ImageVector &pos) const
2285 {
2286  const PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
2287  (pos.y >> _rShift.y)*_strides.y +
2288  (pos.z >> _rShift.z)*_strides.z +
2289  (pos.c >> _rShift.c)*_strides.c);
2290  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2291 };
2292 
2294 template <typename DATATYPE>
2295 inline bool TVirtualVolume<DATATYPE>::_isMapped4DE(const ImageVector &pos) const
2296 {
2297  const MLint px = pos.x;
2298  const MLint py = pos.y;
2299  const MLint pz = pos.z;
2300  const MLint pc = pos.c;
2301  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
2302  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c)){ throw(ML_OUT_OF_RANGE); }
2303  const PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
2304  (py >> _rShift.y)*_strides.y +
2305  (pz >> _rShift.z)*_strides.z +
2306  (pc >> _rShift.c)*_strides.c);
2307  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2308 };
2309 
2310 
2311 
2313 template <typename DATATYPE>
2314 inline bool TVirtualVolume<DATATYPE>::_isMapped5D(const ImageVector &pos) const
2315 {
2316  const PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
2317  (pos.y >> _rShift.y)*_strides.y +
2318  (pos.z >> _rShift.z)*_strides.z +
2319  (pos.c >> _rShift.c)*_strides.c +
2320  (pos.t >> _rShift.t)*_strides.t);
2321  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2322 };
2323 
2325 template <typename DATATYPE>
2326 inline bool TVirtualVolume<DATATYPE>::_isMapped5DE(const ImageVector &pos) const
2327 {
2328  const MLint px = pos.x;
2329  const MLint py = pos.y;
2330  const MLint pz = pos.z;
2331  const MLint pc = pos.c;
2332  const MLint pt = pos.t;
2333  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
2334  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
2335  (pt < 0) || (pt >= _ext.t)){ throw(ML_OUT_OF_RANGE); }
2336  const PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
2337  (py >> _rShift.y)*_strides.y +
2338  (pz >> _rShift.z)*_strides.z +
2339  (pc >> _rShift.c)*_strides.c +
2340  (pt >> _rShift.t)*_strides.t);
2341  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2342 };
2343 
2344 
2345 
2347 template <typename DATATYPE>
2348 inline bool TVirtualVolume<DATATYPE>::_isMapped6D(const ImageVector &pos) const
2349 {
2350  const PageBuffer * const page = _pageArray + ((pos.x >> _rShift.x) +
2351  (pos.y >> _rShift.y)*_strides.y +
2352  (pos.z >> _rShift.z)*_strides.z +
2353  (pos.c >> _rShift.c)*_strides.c +
2354  (pos.t >> _rShift.t)*_strides.t +
2355  (pos.u >> _rShift.u)*_strides.u);
2356  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2357 };
2358 
2360 template <typename DATATYPE>
2361 inline bool TVirtualVolume<DATATYPE>::_isMapped6DE(const ImageVector &pos) const
2362 {
2363  const MLint px = pos.x;
2364  const MLint py = pos.y;
2365  const MLint pz = pos.z;
2366  const MLint pc = pos.c;
2367  const MLint pt = pos.t;
2368  const MLint pu = pos.u;
2369  if ((px < 0) || (px >= _ext.x) || (py < 0) || (py >= _ext.y) ||
2370  (pz < 0) || (pz >= _ext.z) || (pc < 0) || (pc >= _ext.c) ||
2371  (pt < 0) || (pt >= _ext.t) || (pu < 0) || (pu >= _ext.u)){ throw(ML_OUT_OF_RANGE); }
2372  const PageBuffer * const page = _pageArray + ((px >> _rShift.x) +
2373  (py >> _rShift.y)*_strides.y +
2374  (pz >> _rShift.z)*_strides.z +
2375  (pc >> _rShift.c)*_strides.c +
2376  (pt >> _rShift.t)*_strides.t +
2377  (pu >> _rShift.u)*_strides.u);
2378  return page->_getPageFkt != VirtualVolume::_loadPageCB;
2379 };
2380 
2381 
2382 
2383 ML_END_NAMESPACE
2384 
2385 #endif // __mlTVirtualVolume_H
ml::BitImage
Class to manage a binary image.
Definition: mlBitImage.h:67
ml::BitImage::getCursorValue
bool getCursorValue() const
Return true if bit under cursor is true; otherwise, it returns false. Never throws controlled diagnos...
Definition: mlBitImage.h:247
ml::BitImage::getCursorPosition
const ImageVector & getCursorPosition() const
Return current cursor position. Never throws controlled diagnostic exceptions.
Definition: mlBitImage.h:244
ml::BitImage::moveCursorX
void moveCursorX()
Definition: mlBitImage.h:274
ml::BitImage::setCursorPosition
void setCursorPosition(const ImageVector &pos)
Definition: mlBitImage.h:241
ml::BitImage::getExtent
const ImageVector & getExtent() const
Return image size. Never throws controlled diagnostic exceptions.
Definition: mlBitImage.h:150
ml::PagedImage
The class PagedImage, representing a fragmented image that manages properties and data of an image lo...
Definition: mlPagedImage.h:66
ml::SubImage::getBoxFromImageExtent
SubImageBox getBoxFromImageExtent() const
Definition: mlSubImage.h:218
ml::SubImage::getBox
const SubImageBox & getBox() const
Returns the box describing the origin/extent of the subimage.
Definition: mlSubImage.h:230
ml::TSubImageBox::v1
VectorType v1
Corner v1 of the subimage region (included in region).
Definition: mlSubImageBox.h:63
ml::TSubImageBox::intersect
static TSubImageBox< intT > intersect(const TSubImageBox< intT > &box1, const TSubImageBox< intT > &box2)
Returns the overlapping region of subimage regions box1 and box2.
Definition: mlSubImageBox.h:282
ml::TSubImageBox::v2
VectorType v2
Corner v2 of the subimage region (also included in region!).
Definition: mlSubImageBox.h:69
ml::TSubImage
This template class manages/represents a rectangular 6D image region in memory that is organized line...
Definition: mlTSubImage.h:110
ml::TSubImage::getImagePointer
const DATATYPE * getImagePointer(const ImageVector &position) const
Returns a pointer to voxel data of image voxel at 6D position position relative to the origin of the ...
Definition: mlTSubImage.h:253
ml::TSubImage::getSubImageValue
DATATYPE getSubImageValue(const ImageVector &position) const
Returns voxel value at the given position where position is relative to the origin of the subimage re...
Definition: mlTSubImage.h:356
ml::TVector6DBase::c
ComponentType c
Color component of the vector.
Definition: mlImageVector.h:65
ml::TVector6DBase::t
ComponentType t
Time component of the vector.
Definition: mlImageVector.h:67
ml::TVector6DBase::u
ComponentType u
Unit/Modality/User component of the vector.
Definition: mlImageVector.h:69
ml::TVector6DBase::z
ComponentType z
Z component of the vector.
Definition: mlImageVector.h:63
ml::TVector6DBase::x
ComponentType x
X component of the vector.
Definition: mlImageVector.h:59
ml::TVector6DBase::y
ComponentType y
Y component of the vector.
Definition: mlImageVector.h:61
ml::TVirtualVolume
The TVirtualVolume class implements random access to a paged input image or a pure virtual image with...
Definition: mlTVirtualVolume.h:210
ml::TVirtualVolume::_moveFZCB
static void _moveFZCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:812
ml::TVirtualVolume::_setVoxel4DCBE
static void _setVoxel4DCBE(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:659
ml::TVirtualVolume::setInt64ValueWrapped
static void setInt64ValueWrapped(void *vv, const ImageVector &pos, MLint64 v)
Definition: mlTVirtualVolume.h:497
ml::TVirtualVolume::_moveBUCBE
static void _moveBUCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:870
ml::TVirtualVolume::getDoubleCursorValueWrapped
static MLdouble getDoubleCursorValueWrapped(void *vv)
Definition: mlTVirtualVolume.h:491
ml::TVirtualVolume::_moveCursorOffset3DCB
static void _moveCursorOffset3DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:756
ml::TVirtualVolume::_moveFYCBE
static void _moveFYCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:818
ml::TVirtualVolume::_isMapped5DCB
static bool _isMapped5DCB(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:667
ml::TVirtualVolume::~TVirtualVolume
virtual ~TVirtualVolume()
Destructor.
Definition: mlTVirtualVolume.h:273
ml::TVirtualVolume::_setVoxel6DCB
static void _setVoxel6DCB(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:654
ml::TVirtualVolume::_isMapped4DCBE
static bool _isMapped4DCBE(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:673
ml::TVirtualVolume::setCursorPosition
void setCursorPosition(const ImageVector &pos)
Set the cursor to a certain position.
Definition: mlTVirtualVolume.h:299
ml::TVirtualVolume::_moveCursorOffset2DCBE
static void _moveCursorOffset2DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:762
ml::TVirtualVolume::getInt64ValueWrapped
static MLint64 getInt64ValueWrapped(void *vv, const ImageVector &pos)
Definition: mlTVirtualVolume.h:486
ml::TVirtualVolume::_setVoxel6DE
void _setVoxel6DE(const ImageVector &pos, DATATYPE voxVal)
Set voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1731
ml::TVirtualVolume::reverseMoveCursorUWrapped
static void reverseMoveCursorUWrapped(void *vv)
Definition: mlTVirtualVolume.h:519
ml::TVirtualVolume::_setCursorPos4DCB
static void _setCursorPos4DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:712
ml::TVirtualVolume::setIntValueWrapped
static void setIntValueWrapped(void *vv, const ImageVector &pos, MLint v)
Definition: mlTVirtualVolume.h:496
ml::TVirtualVolume::setDoubleValueWrapped
static void setDoubleValueWrapped(void *vv, const ImageVector &pos, MLdouble v)
Definition: mlTVirtualVolume.h:498
ml::TVirtualVolume::_moveBXCB
static void _moveBXCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:858
ml::TVirtualVolume::_moveCursorOffset2DE
void _moveCursorOffset2DE(const ImageVector &p)
Move cursor by an offset to a new position with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:2026
ml::TVirtualVolume::_getVoxel2D
DATATYPE _getVoxel2D(const ImageVector &pos)
Get voxel method for a certain dimension. (2d)
Definition: mlTVirtualVolume.h:1381
ml::TVirtualVolume::_setCursorPos3DCB
static void _setCursorPos3DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:711
ml::TVirtualVolume::fillDoubleWrapped
static void fillDoubleWrapped(void *vv, const ImageVector &v1, const ImageVector &v2, MLdouble v)
Definition: mlTVirtualVolume.h:506
ml::TVirtualVolume::_setCursorPos6DCB
static void _setCursorPos6DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:714
ml::TVirtualVolume::getDoubleValueWrapped
static MLdouble getDoubleValueWrapped(void *vv, const ImageVector &pos)
Definition: mlTVirtualVolume.h:487
ml::TVirtualVolume::setDoubleCursorValueWrapped
static void setDoubleCursorValueWrapped(void *vv, MLdouble v)
Definition: mlTVirtualVolume.h:502
ml::TVirtualVolume::_getVoxel4DE
DATATYPE _getVoxel4DE(const ImageVector &pos)
Get voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1443
ml::TVirtualVolume::reverseMoveCursorCWrapped
static void reverseMoveCursorCWrapped(void *vv)
Definition: mlTVirtualVolume.h:517
ml::TVirtualVolume::_getVoxel6D
DATATYPE _getVoxel6D(const ImageVector &pos)
Get voxel method for a certain dimension. (6d)
Definition: mlTVirtualVolume.h:1503
ml::TVirtualVolume::_isMapped2DCBE
static bool _isMapped2DCBE(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:671
ml::TVirtualVolume::getInt64CursorValueWrapped
static MLint64 getInt64CursorValueWrapped(void *vv)
Definition: mlTVirtualVolume.h:490
ml::TVirtualVolume::setLDoubleCursorValueWrapped
static void setLDoubleCursorValueWrapped(void *vv, MLldouble v)
Definition: mlTVirtualVolume.h:503
ml::TVirtualVolume::fillLDoubleWrapped
static void fillLDoubleWrapped(void *vv, const ImageVector &v1, const ImageVector &v2, MLldouble v)
Definition: mlTVirtualVolume.h:507
ml::TVirtualVolume::_getVoxel1DE
DATATYPE _getVoxel1DE(const ImageVector &pos)
Get voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1370
ml::TVirtualVolume::_getVoxel3DCBE
static DATATYPE _getVoxel3DCBE(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:644
ml::TVirtualVolume::_setCursorPos2D
void _setCursorPos2D(const ImageVector &p)
Set cursor position for a certain dimension. (2d)
Definition: mlTVirtualVolume.h:1790
ml::TVirtualVolume::_isMapped3D
bool _isMapped3D(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2257
ml::TVirtualVolume::_moveBTCB
static void _moveBTCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:862
ml::TVirtualVolume::_setVoxel3DCBE
static void _setVoxel3DCBE(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:658
ml::TVirtualVolume::_setCursorPos3D
void _setCursorPos3D(const ImageVector &p)
Set cursor position for a certain dimension. (3d)
Definition: mlTVirtualVolume.h:1817
ml::TVirtualVolume::_isMapped1DCB
static bool _isMapped1DCB(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:663
ml::TVirtualVolume::ComponentType
DATATYPE ComponentType
A typedef to "export" the type of voxels components.
Definition: mlTVirtualVolume.h:223
ml::TVirtualVolume::_setCursorPos6D
void _setCursorPos6D(const ImageVector &p)
Set cursor position for a certain dimension. (6d)
Definition: mlTVirtualVolume.h:1935
ml::TVirtualVolume::reverseMoveCursorZWrapped
static void reverseMoveCursorZWrapped(void *vv)
Definition: mlTVirtualVolume.h:516
ml::TVirtualVolume::TVirtualVolume
TVirtualVolume()
Hide the default constructor to avoid incorrect usage due to missing initializations.
Definition: mlTVirtualVolume.h:214
ml::TVirtualVolume::_getVoxel1DCBE
static DATATYPE _getVoxel1DCBE(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:642
ml::TVirtualVolume::setIntCursorValueWrapped
static void setIntCursorValueWrapped(void *vv, MLint v)
Definition: mlTVirtualVolume.h:500
ml::TVirtualVolume::_isMapped4D
bool _isMapped4D(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2284
ml::TVirtualVolume::_setVoxel2DE
void _setVoxel2DE(const ImageVector &pos, DATATYPE voxVal)
Set voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1587
ml::TVirtualVolume::setCursorPositionWrapped
static void setCursorPositionWrapped(void *vv, const ImageVector &pos)
Definition: mlTVirtualVolume.h:495
ml::TVirtualVolume::_moveCursorOffset3DCBE
static void _moveCursorOffset3DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:763
ml::TVirtualVolume::getIntCursorValueWrapped
static MLint getIntCursorValueWrapped(void *vv)
Definition: mlTVirtualVolume.h:489
ml::TVirtualVolume::_moveFTCB
static void _moveFTCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:814
ml::TVirtualVolume::_setCursorPos5DCBE
static void _setCursorPos5DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:720
ml::TVirtualVolume::getIntValueWrapped
static MLint getIntValueWrapped(void *vv, const ImageVector &pos)
Wrapper functions for non template application interfaces.
Definition: mlTVirtualVolume.h:485
ml::TVirtualVolume::getCursorPositionWrapped
static const ImageVector & getCursorPositionWrapped(void *vv)
Definition: mlTVirtualVolume.h:493
ml::TVirtualVolume::_setVoxel3DE
void _setVoxel3DE(const ImageVector &pos, DATATYPE voxVal)
Set voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1612
ml::TVirtualVolume::_setVoxel4DE
void _setVoxel4DE(const ImageVector &pos, DATATYPE voxVal)
Set voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1645
ml::TVirtualVolume::moveCursorByOffsetWrapped
static void moveCursorByOffsetWrapped(void *vv, const ImageVector &off)
Definition: mlTVirtualVolume.h:520
ml::TVirtualVolume::_moveCursorOffset1DCB
static void _moveCursorOffset1DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:754
ml::TVirtualVolume::_setCursorPos4DE
void _setCursorPos4DE(const ImageVector &p)
Set cursor position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1865
ml::TVirtualVolume::_getVoxel4DCBE
static DATATYPE _getVoxel4DCBE(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:645
ml::TVirtualVolume::_moveFYCB
static void _moveFYCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:811
ml::TVirtualVolume::moveCursorUWrapped
static void moveCursorUWrapped(void *vv)
Definition: mlTVirtualVolume.h:513
ml::TVirtualVolume::moveCursorYWrapped
static void moveCursorYWrapped(void *vv)
Definition: mlTVirtualVolume.h:509
ml::TVirtualVolume::_setVoxel4D
void _setVoxel4D(const ImageVector &pos, DATATYPE voxVal)
Set voxel method for a certain dimension. (4d)
Definition: mlTVirtualVolume.h:1630
ml::TVirtualVolume::isMappedWrapped
static bool isMappedWrapped(void *vv, const ImageVector &pos)
Definition: mlTVirtualVolume.h:494
ml::TVirtualVolume::moveCursorTWrapped
static void moveCursorTWrapped(void *vv)
Definition: mlTVirtualVolume.h:512
ml::TVirtualVolume::_isMapped6DCB
static bool _isMapped6DCB(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:668
ml::TVirtualVolume::_setVoxel5DCBE
static void _setVoxel5DCBE(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:660
ml::TVirtualVolume::_setCursorPos3DCBE
static void _setCursorPos3DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:718
ml::TVirtualVolume::_setCursorPos2DCBE
static void _setCursorPos2DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:717
ml::TVirtualVolume::_isMapped1DE
bool _isMapped1DE(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2224
ml::TVirtualVolume::_setCursorPos5DE
void _setCursorPos5DE(const ImageVector &p)
Set cursor position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1906
ml::TVirtualVolume::_isMapped3DE
bool _isMapped3DE(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2267
ml::TVirtualVolume::_setVoxel6DCBE
static void _setVoxel6DCBE(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:661
ml::TVirtualVolume::_setVoxel6D
void _setVoxel6D(const ImageVector &pos, DATATYPE voxVal)
Set voxel method for a certain dimension. (6d)
Definition: mlTVirtualVolume.h:1712
ml::TVirtualVolume::_moveCursorOffset5DCBE
static void _moveCursorOffset5DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:765
ml::TVirtualVolume::_setVoxel3D
void _setVoxel3D(const ImageVector &pos, DATATYPE voxVal)
Set voxel method for a certain dimension. (3d)
Definition: mlTVirtualVolume.h:1601
ml::TVirtualVolume::_moveBXCBE
static void _moveBXCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:865
ml::TVirtualVolume::_moveBCCBE
static void _moveBCCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:868
ml::TVirtualVolume::_moveFXCBE
static void _moveFXCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:817
ml::TVirtualVolume::_isMapped2DE
bool _isMapped2DE(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2244
ml::TVirtualVolume::_getVoxel2DE
DATATYPE _getVoxel2DE(const ImageVector &pos)
Get voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1389
ml::TVirtualVolume::_moveFUCBE
static void _moveFUCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:822
ml::TVirtualVolume::copyMaskToSubImage
void copyMaskToSubImage(TSubImage< OUTDTYPE > &outSubImg, BitImage &maskBits, bool maskValue=true, bool writeBK=false, OUTDTYPE bkVal=ml_cast_from_scalar< OUTDTYPE >(0))
Takes overlapping region from *this, outSubImg and maskBits and copies all voxels from *this to outSu...
Definition: mlTVirtualVolume.h:392
ml::TVirtualVolume::_getVoxel4DCB
static DATATYPE _getVoxel4DCB(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:638
ml::TVirtualVolume::_isMapped3DCBE
static bool _isMapped3DCBE(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:672
ml::TVirtualVolume::moveCursorXWrapped
static void moveCursorXWrapped(void *vv)
Definition: mlTVirtualVolume.h:508
ml::TVirtualVolume::_moveCursorOffset5DCB
static void _moveCursorOffset5DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:758
ml::TVirtualVolume::_setVoxel1DE
void _setVoxel1DE(const ImageVector &pos, DATATYPE voxVal)
Set voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1565
ml::TVirtualVolume::TVirtualVolume
TVirtualVolume(const ImageVector &ext, MLdouble fillVal=0, MLint maxNumKB=-1, bool areExceptionsOn=false)
Convenience constructor (3) creating an untyped virtual volume inside the typed one to avoid addition...
Definition: mlTVirtualVolume.h:257
ml::TVirtualVolume::_isMapped1DCBE
static bool _isMapped1DCBE(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:670
ml::TVirtualVolume::_setVoxel1DCBE
static void _setVoxel1DCBE(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:656
ml::TVirtualVolume::_moveCursorOffset6D
void _moveCursorOffset6D(const ImageVector &p)
Move cursor by an offset to a new position. (6d)
Definition: mlTVirtualVolume.h:2161
ml::TVirtualVolume::_moveCursorOffset5DE
void _moveCursorOffset5DE(const ImageVector &p)
Move cursor by an offset to a new position with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:2132
ml::TVirtualVolume::_moveBTCBE
static void _moveBTCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:869
ml::TVirtualVolume::_isMapped6DCBE
static bool _isMapped6DCBE(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:675
ml::TVirtualVolume::getVirtualVolume
VirtualVolume & getVirtualVolume()
Returns the pointer to the wrapped untyped virtual volume.
Definition: mlTVirtualVolume.h:281
ml::TVirtualVolume::_setVoxel2DCB
static void _setVoxel2DCB(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:650
ml::TVirtualVolume::reverseMoveCursorTWrapped
static void reverseMoveCursorTWrapped(void *vv)
Definition: mlTVirtualVolume.h:518
ml::TVirtualVolume::_isMapped2DCB
static bool _isMapped2DCB(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:664
ml::TVirtualVolume::_moveCursorOffset4DE
void _moveCursorOffset4DE(const ImageVector &p)
Move cursor by an offset to a new position with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:2089
ml::TVirtualVolume::resetCursorWrapped
static void resetCursorWrapped(void *vv)
Definition: mlTVirtualVolume.h:521
ml::TVirtualVolume::_setVoxel1D
void _setVoxel1D(const ImageVector &pos, DATATYPE voxVal)
Set voxel method for a certain dimension. (1d)
Definition: mlTVirtualVolume.h:1556
ml::TVirtualVolume::_moveFZCBE
static void _moveFZCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:819
ml::TVirtualVolume::getValue
DATATYPE getValue(const ImageVector &pos)
Get a voxel value from the virtual volume.
Definition: mlTVirtualVolume.h:292
ml::TVirtualVolume::fillIntWrapped
static void fillIntWrapped(void *vv, const ImageVector &v1, const ImageVector &v2, MLint v)
Definition: mlTVirtualVolume.h:504
ml::TVirtualVolume::_setCursorPos6DCBE
static void _setCursorPos6DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:721
ml::TVirtualVolume::_moveFCCB
static void _moveFCCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:813
ml::TVirtualVolume::_getVoxel5D
DATATYPE _getVoxel5D(const ImageVector &pos)
Get voxel method for a certain dimension. (5d)
Definition: mlTVirtualVolume.h:1463
ml::TVirtualVolume::_setVoxel2D
void _setVoxel2D(const ImageVector &pos, DATATYPE voxVal)
Set voxel method for a certain dimension. (2d)
Definition: mlTVirtualVolume.h:1578
ml::TVirtualVolume::operator=
TVirtualVolume & operator=(const TVirtualVolume &)
Hide the default assignment operator to avoid incorrect usage due to missing initializations.
Definition: mlTVirtualVolume.h:218
ml::TVirtualVolume::_setCursorPos2DCB
static void _setCursorPos2DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:710
ml::TVirtualVolume::_setCursorPos1DCB
static void _setCursorPos1DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:709
ml::TVirtualVolume::_setVoxel4DCB
static void _setVoxel4DCB(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:652
ml::TVirtualVolume::moveCursorCWrapped
static void moveCursorCWrapped(void *vv)
Definition: mlTVirtualVolume.h:511
ml::TVirtualVolume::_isMapped5D
bool _isMapped5D(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2314
ml::TVirtualVolume::_moveCursorOffset1DE
void _moveCursorOffset1DE(const ImageVector &p)
Move cursor by an offset to a new position with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:2003
ml::TVirtualVolume::_isMapped5DCBE
static bool _isMapped5DCBE(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:674
ml::TVirtualVolume::_getVoxel1DCB
static DATATYPE _getVoxel1DCB(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:635
ml::TVirtualVolume::_setCursorPos4DCBE
static void _setCursorPos4DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:719
ml::TVirtualVolume::getWrittenPageData
DATATYPE * getWrittenPageData(MLuint32 wp) const
Returns typed pointer to data of written page with page id wp.
Definition: mlTVirtualVolume.h:473
ml::TVirtualVolume::_moveBYCB
static void _moveBYCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:859
ml::TVirtualVolume::_getVoxel6DCBE
static DATATYPE _getVoxel6DCBE(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:647
ml::TVirtualVolume::_getVoxel2DCB
static DATATYPE _getVoxel2DCB(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:636
ml::TVirtualVolume::moveCursorXWrapAroundWrapped
static bool moveCursorXWrapAroundWrapped(void *vv)
Definition: mlTVirtualVolume.h:522
ml::TVirtualVolume::moveCursorZWrapped
static void moveCursorZWrapped(void *vv)
Definition: mlTVirtualVolume.h:510
ml::TVirtualVolume::setInt64CursorValueWrapped
static void setInt64CursorValueWrapped(void *vv, MLint64 v)
Definition: mlTVirtualVolume.h:501
ml::TVirtualVolume::_setCursorPos1DE
void _setCursorPos1DE(const ImageVector &p)
Set cursor position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1777
ml::TVirtualVolume::_moveBUCB
static void _moveBUCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:863
ml::TVirtualVolume::_isMapped4DCB
static bool _isMapped4DCB(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:666
ml::TVirtualVolume::_isMapped5DE
bool _isMapped5DE(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2326
ml::TVirtualVolume::TVirtualVolume
TVirtualVolume(PagedImage *image, MLint maxNumKB=-1, bool areExceptionsOn=false)
Convenience constructor (2) creating an untyped virtual volume inside the typed one to avoid addition...
Definition: mlTVirtualVolume.h:240
ml::TVirtualVolume::_setCursorPos1DCBE
static void _setCursorPos1DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:716
ml::TVirtualVolume::_getVoxel2DCBE
static DATATYPE _getVoxel2DCBE(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:643
ml::TVirtualVolume::_getVoxel5DCBE
static DATATYPE _getVoxel5DCBE(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:646
ml::TVirtualVolume::_moveFXCB
static void _moveFXCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:810
ml::TVirtualVolume::_moveBZCBE
static void _moveBZCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:867
ml::TVirtualVolume::TVirtualVolume
TVirtualVolume(VirtualVolume &vVol)
Constructor 1.
Definition: mlTVirtualVolume.h:227
ml::TVirtualVolume::fillInt64Wrapped
static void fillInt64Wrapped(void *vv, const ImageVector &v1, const ImageVector &v2, MLint64 v)
Definition: mlTVirtualVolume.h:505
ml::TVirtualVolume::_getVoxel6DCB
static DATATYPE _getVoxel6DCB(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:640
ml::TVirtualVolume::_isMapped6D
bool _isMapped6D(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2348
ml::TVirtualVolume::_getVoxel4D
DATATYPE _getVoxel4D(const ImageVector &pos)
Get voxel method for a certain dimension. (4d)
Definition: mlTVirtualVolume.h:1429
ml::TVirtualVolume::_moveCursorOffset1DCBE
static void _moveCursorOffset1DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:761
ml::TVirtualVolume::_moveCursorOffset5D
void _moveCursorOffset5D(const ImageVector &p)
Move cursor by an offset to a new position. (5d)
Definition: mlTVirtualVolume.h:2112
ml::TVirtualVolume::_setVoxel5DE
void _setVoxel5DE(const ImageVector &pos, DATATYPE voxVal)
Set voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1685
ml::TVirtualVolume::_isMapped1D
bool _isMapped1D(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2216
ml::TVirtualVolume::_isMapped4DE
bool _isMapped4DE(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2295
ml::TVirtualVolume::_setVoxel5D
void _setVoxel5D(const ImageVector &pos, DATATYPE voxVal)
Set voxel method for a certain dimension. (5d)
Definition: mlTVirtualVolume.h:1668
ml::TVirtualVolume::_moveBCCB
static void _moveBCCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:861
ml::TVirtualVolume::_moveCursorOffset4D
void _moveCursorOffset4D(const ImageVector &p)
Move cursor by an offset to a new position. (4d)
Definition: mlTVirtualVolume.h:2074
ml::TVirtualVolume::_moveCursorOffset3D
void _moveCursorOffset3D(const ImageVector &p)
Move cursor by an offset to a new position. (3d)
Definition: mlTVirtualVolume.h:2041
ml::TVirtualVolume::_setVoxel5DCB
static void _setVoxel5DCB(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:653
ml::TVirtualVolume::_getVoxel1D
DATATYPE _getVoxel1D(const ImageVector &pos)
Get voxel method for a certain dimension. (1d)
Definition: mlTVirtualVolume.h:1362
ml::TVirtualVolume::_moveCursorOffset2DCB
static void _moveCursorOffset2DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:755
ml::TVirtualVolume::getLDoubleValueWrapped
static MLldouble getLDoubleValueWrapped(void *vv, const ImageVector &pos)
Definition: mlTVirtualVolume.h:488
ml::TVirtualVolume::_getVoxel6DE
DATATYPE _getVoxel6DE(const ImageVector &pos)
Get voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1521
ml::TVirtualVolume::_moveCursorOffset6DCB
static void _moveCursorOffset6DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:759
ml::TVirtualVolume::_moveFCCBE
static void _moveFCCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:820
ml::TVirtualVolume::_getVoxel3D
DATATYPE _getVoxel3D(const ImageVector &pos)
Get voxel method for a certain dimension. (3d)
Definition: mlTVirtualVolume.h:1402
ml::TVirtualVolume::_setCursorPos1D
void _setCursorPos1D(const ImageVector &p)
Set cursor position for a certain dimension. (1d)
Definition: mlTVirtualVolume.h:1768
ml::TVirtualVolume::_moveFTCBE
static void _moveFTCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:821
ml::TVirtualVolume::_moveBZCB
static void _moveBZCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:860
ml::TVirtualVolume::_isMapped3DCB
static bool _isMapped3DCB(const TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:665
ml::TVirtualVolume::_isMapped6DE
bool _isMapped6DE(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2361
ml::TVirtualVolume::reverseMoveCursorXWrapped
static void reverseMoveCursorXWrapped(void *vv)
Definition: mlTVirtualVolume.h:514
ml::TVirtualVolume::setValue
void setValue(const ImageVector &pos, DATATYPE data)
Write a voxel into the virtual volume.
Definition: mlTVirtualVolume.h:296
ml::TVirtualVolume::_moveCursorOffset6DCBE
static void _moveCursorOffset6DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:766
ml::TVirtualVolume::_moveFUCB
static void _moveFUCB(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:815
ml::TVirtualVolume::_moveCursorOffset4DCB
static void _moveCursorOffset4DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:757
ml::TVirtualVolume::_moveCursorOffset2D
void _moveCursorOffset2D(const ImageVector &p)
Move cursor by an offset to a new position. (2d)
Definition: mlTVirtualVolume.h:2016
ml::TVirtualVolume::_setCursorPos5D
void _setCursorPos5D(const ImageVector &p)
Set cursor position for a certain dimension. (5d)
Definition: mlTVirtualVolume.h:1888
ml::TVirtualVolume::_moveCursorOffset6DE
void _moveCursorOffset6DE(const ImageVector &p)
Move cursor by an offset to a new position with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:2181
ml::TVirtualVolume::isMapped
bool isMapped(const ImageVector &pos) const
Returns true if voxel is mapped into memory, otherwise it returns false.
Definition: mlTVirtualVolume.h:311
ml::TVirtualVolume::_setVoxel1DCB
static void _setVoxel1DCB(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:649
ml::TVirtualVolume::moveCursorByOffset
void moveCursorByOffset(const ImageVector &off)
Shift cursor to current position + offset.
Definition: mlTVirtualVolume.h:331
ml::TVirtualVolume::_moveBYCBE
static void _moveBYCBE(TVirtualVolume *obj)
Definition: mlTVirtualVolume.h:866
ml::TVirtualVolume::copyToSubImage
void copyToSubImage(TSubImage< DATATYPE > &outSubImg)
Copy area from the virtual volume into the subimage given by outSubImg.
Definition: mlTVirtualVolume.h:1093
ml::TVirtualVolume::_getVoxel3DCB
static DATATYPE _getVoxel3DCB(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:637
ml::TVirtualVolume::_setCursorPos2DE
void _setCursorPos2DE(const ImageVector &p)
Set cursor position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1801
ml::TVirtualVolume::reverseMoveCursorYWrapped
static void reverseMoveCursorYWrapped(void *vv)
Definition: mlTVirtualVolume.h:515
ml::TVirtualVolume::_moveCursorOffset4DCBE
static void _moveCursorOffset4DCBE(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:764
ml::TVirtualVolume::_setVoxel3DCB
static void _setVoxel3DCB(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:651
ml::TVirtualVolume::_setVoxel2DCBE
static void _setVoxel2DCBE(TVirtualVolume *obj, const ImageVector &pos, DATATYPE voxVal)
Definition: mlTVirtualVolume.h:657
ml::TVirtualVolume::getLDoubleCursorValueWrapped
static MLldouble getLDoubleCursorValueWrapped(void *vv)
Definition: mlTVirtualVolume.h:492
ml::TVirtualVolume::_setCursorPos3DE
void _setCursorPos3DE(const ImageVector &p)
Set cursor position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1830
ml::TVirtualVolume::_setCursorPos4D
void _setCursorPos4D(const ImageVector &p)
Set cursor position for a certain dimension. (4d)
Definition: mlTVirtualVolume.h:1850
ml::TVirtualVolume::_getVoxel5DCB
static DATATYPE _getVoxel5DCB(TVirtualVolume *obj, const ImageVector &pos)
Definition: mlTVirtualVolume.h:639
ml::TVirtualVolume::getCursorPosition
const ImageVector & getCursorPosition() const
Return the current cursor coordinates.
Definition: mlTVirtualVolume.h:302
ml::TVirtualVolume::_isMapped2D
bool _isMapped2D(const ImageVector &pos) const
Returns true if voxel is mapped in memory for a certain dimension; otherwise, it returns false....
Definition: mlTVirtualVolume.h:2236
ml::TVirtualVolume::_getVoxel5DE
DATATYPE _getVoxel5DE(const ImageVector &pos)
Get voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1479
ml::TVirtualVolume::_setCursorPos5DCB
static void _setCursorPos5DCB(TVirtualVolume *obj, const ImageVector &p)
Definition: mlTVirtualVolume.h:713
ml::TVirtualVolume::_setCursorPos6DE
void _setCursorPos6DE(const ImageVector &p)
Set cursor position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1955
ml::TVirtualVolume::_moveCursorOffset3DE
void _moveCursorOffset3DE(const ImageVector &p)
Move cursor by an offset to a new position with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:2054
ml::TVirtualVolume::setLDoubleValueWrapped
static void setLDoubleValueWrapped(void *vv, const ImageVector &pos, MLldouble v)
Definition: mlTVirtualVolume.h:499
ml::TVirtualVolume::_getVoxel3DE
DATATYPE _getVoxel3DE(const ImageVector &pos)
Get voxel at a position for a certain dimension with testing and exception throw if necessary....
Definition: mlTVirtualVolume.h:1412
ml::TVirtualVolume::_moveCursorOffset1D
void _moveCursorOffset1D(const ImageVector &p)
Move cursor by an offset to a new position. (1d)
Definition: mlTVirtualVolume.h:1994
ml::VirtualVolume
This class manages a virtual volume organizing efficient voxel access to the output image of an input...
Definition: mlVirtualVolume.h:74
ml::VirtualVolume::getDim
MLint getDim() const
Return dimension of specified volume.
Definition: mlVirtualVolume.h:112
ml::VirtualVolume::getDataType
MLDataType getDataType() const
Return data type enum.
Definition: mlVirtualVolume.h:121
ML_BAD_DATA_TYPE
#define ML_BAD_DATA_TYPE
A wrong or unexpected data type has been passed to an algorithm, which often is a programming error.
Definition: mlTypeDefs.h:782
ML_BAD_DIMENSION
#define ML_BAD_DIMENSION
The image or data structure has wrong extent or dimensions.
Definition: mlTypeDefs.h:835
ML_OUT_OF_RANGE
#define ML_OUT_OF_RANGE
Any coordinate or value is out of range, often a voxel address that is outside of an image or it is e...
Definition: mlTypeDefs.h:872
ML_PRINT_FATAL_ERROR
#define ML_PRINT_FATAL_ERROR(FUNC_NAME, REASON, HANDLING)
Like ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) without a runtime object to be du...
Definition: mlErrorMacros.h:337
ML_PRINT_ERROR
#define ML_PRINT_ERROR(FUNC_NAME, REASON, HANDLING)
Like ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) without a runtime object to be dumped.
Definition: mlErrorMacros.h:346
_VV_MOVEBE_TEST
#define _VV_MOVEBE_TEST(Q)
Macro to save cursor movement with exception handling if outside image.
Definition: mlTVirtualVolume.h:839
MLGetDataTypeFromPtr
MLDataType MLGetDataTypeFromPtr(const T *)
Definition: mlTemplateSupport.h:54
MLldouble
long double MLldouble
Definition: mlTypeDefs.h:232
MLuint32
unsigned int MLuint32
Definition: mlTypeDefs.h:185
MLuint
MLuint64 MLuint
An unsigned ML integer type with at least 64 bits used for index calculations on very large images ev...
Definition: mlTypeDefs.h:506
MLdouble
double MLdouble
Definition: mlTypeDefs.h:217
MLint64
INT64 MLint64
Include 64-bit integer support for Windows or Unix.
Definition: mlTypeDefs.h:412
MLint
MLint64 MLint
A signed ML integer type with at least 64 bits used for index calculations on very large images even ...
Definition: mlTypeDefs.h:490
ml::WEMSetOp::intersect
MLWEM_EXPORT void intersect(WEMTrianglePatch *inPatch1, WEMTrianglePatch *inPatch2, WEMTrianglePatch *outPatch, unsigned int outputMode, TriangulationModes triangulationMode, WEMVector< WEMCut > *cuts=nullptr)
Returns the intersection of the given patches.
ml::SubImageBox
TSubImageBox< MLint > SubImageBox
Defines the standard SubImageBox type used in the ML. Its size varies with the size of the MLint type...
Definition: mlSubImageBox.h:255
ml::ImageVector
TImageVector< MLint > ImageVector
Defines the standard ImageVector type that is used by the ML for indexing and coordinates.
Definition: mlImageVector.h:285
ml::PageBuffer
PageBuffer is a helper structure to manage one page of input data of the VirtualVolume class and it a...
Definition: mlVirtualVolume.h:463
ml::PageBuffer::_getPageFkt
ReturnPageFunc _getPageFkt
Pointer to function to return the page managed by the PageBuffer.
Definition: mlVirtualVolume.h:489
ml::PageBuffer::_locked
bool _locked
If true this page contains written data and must not be removed.
Definition: mlVirtualVolume.h:486