mlSubImage.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_SUB_IMAGE_H
#define ML_SUB_IMAGE_H
 
 
#include "mlInitSystemML.h"
#include "mlImageProperties.h"
 
#include "mlMemoryBlockHandle.h"
#include "mlScaleShiftData.h"
 
 
ML_START_NAMESPACE
 
 
//-------------------------------------------------------------------------
 
//-------------------------------------------------------------------------
class ML_UNIX_ONLY_EXPORT(MLEXPORT) SubImage
{
 
public:
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  inline SubImage() :
  //_box         (),
  _sourceImageExtent(0),
  _data          (nullptr),
  _stride        (0),
  _dataType      (MLuint8Type),
  _dataTypeSize  (1)
  {
  }
 
 
  inline SubImage(const SubImage &si) :
  _box           (si._box),
  _sourceImageExtent(si._sourceImageExtent),
  _data          (si._data),
  _memoryBlock   (si._memoryBlock),
  _stride        (si._stride),
  _dataType      (si._dataType),
  _dataTypeSize  (si._dataTypeSize)
  {
  }
 
  inline SubImage(const SubImageBox& box, MLDataType datatype, void* data = nullptr) :
  _box         (box),
  _sourceImageExtent(0),
  _data        (data),
  _stride      (box.getExtent().getStrides()),
  _dataType    (datatype),
  _dataTypeSize(MLSizeOf(datatype))
  {
  }
 
  inline SubImage(const SubImage &si, const ImageVector& offset) :
    _box           (si._box),
    _sourceImageExtent(si._sourceImageExtent),
    _data          (si._data),
    _memoryBlock   (si._memoryBlock),
    _stride        (si._stride),
    _dataType      (si._dataType),
    _dataTypeSize  (si._dataTypeSize)
  {
    _box.translate(offset);
  }
 
  inline virtual ~SubImage() = default;
 
  inline SubImage &operator=(const SubImage &si)
  {
    if (this != &si)
    {
      _box           = si._box;
      _sourceImageExtent = si._sourceImageExtent;
      _data          = si._data;
      _memoryBlock   = si._memoryBlock;
      _stride        = si._stride;
      _dataType      = si._dataType;
      _dataTypeSize  = si._dataTypeSize;
    }
    return *this;
  }
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  inline void setBox(const SubImageBox &subImageBox)
  {
    _box = subImageBox;
    _stride.set(subImageBox.getExtent().getStrides());
  }
 
 
  inline void setBox(const ImageVector &imageExtent)
  {
    _box = SubImageBox(imageExtent);
    _stride.set(imageExtent.getStrides());
  }
 
  inline void translate(const ImageVector &offset)
  {
    _box.translate(offset);
  }
 
  inline const ImageVector& getOrigin() const { return _box.v1; }
 
  inline void setOrigin(const ImageVector& newOrigin) {
    ImageVector offset = _box.v2 - _box.v1;
    _box.v1 = newOrigin;
    _box.v2 = newOrigin + offset;
  }
 
  inline ImageVector getExtent() const { return _box.getExtent(); }
 
  inline void setExtent(MLint x, MLint y, MLint z = 1, MLint c = 1, MLint t = 1, MLint u = 1) {
    setExtent(ImageVector(x,y,z,c,t,u));
  }
 
  inline void setExtent(const ImageVector& newExtent) {
    _box.v2 = _box.v1 + newExtent -1;
    _stride.set(newExtent.getStrides());
  }
 
  inline SubImageBox getBoxFromExtent() const  { return SubImageBox(getExtent()); }
 
  inline SubImageBox getBoxFromImageExtent() const { return getBoxFromExtent(); }
 
  inline ImageVector getImageExtent() const { return getExtent(); }
 
  inline void setImageExtent(const ImageVector& newExtent) { setExtent(newExtent);}
 
  inline const SubImageBox& getBox() const
  {
    return _box;
  }
 
  inline void setSourceImageExtent(const ImageVector& extent) { _sourceImageExtent = extent; }
 
  inline ImageVector getSourceImageExtent() const { return _sourceImageExtent; }
 
  inline SubImageBox getValidRegion() const {
    SubImageBox sourceBox(_sourceImageExtent);
    return SubImageBox::intersect(_box, sourceBox);
  }
 
  inline MLint getNumVoxels() const { return _box.getNumVoxels(); }
 
  inline MLint getSizeInBytes() const { return getNumVoxels() * static_cast<MLint>(_dataTypeSize); }
 
  inline ImageVector getStride() const
  {
    return _stride;
  }
 
  inline MLint getOffset(const ImageVector& voxelPosition) const
  {
    return ImageVector::dot(voxelPosition,_stride);
  }
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  inline void setDataType(MLDataType dataType)
  {
    _dataType = dataType;
    _dataTypeSize = MLSizeOf(dataType);
  }
 
  inline MLDataType getDataType() const               { return _dataType;        }
 
  inline const MLTypeInfos* getDataTypeInfos() const  { return MLGetTypeInfosForDataType(_dataType); }
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  inline void* getSubImagePointer(const ImageVector &voxelPosition) const
  {
    // Use pointer arithmetics with one-byte sized data type, therefore we use make a char pointer.
    // (casting the offset to an unsigned type is ok - the resulting offset needs to be positive, and because of the wrap-around
    //  this would work for negative values anyway)
    return static_cast<void*>(static_cast<char*>(_data) + static_cast<size_t>(ImageVector::dot(voxelPosition, _stride) * static_cast<MLint>(_dataTypeSize)));
  }
 
  inline void* getSubImagePointer(MLint x, MLint y, MLint z) const
  {
    // Use pointer arithmetics with one-byte sized data type, therefore we use make a char pointer.
    // (casting the offset to an unsigned type is ok - the resulting offset needs to be positive, and because of the wrap-around
    //  this would work for negative values anyway)
    return static_cast<void*>(static_cast<char*>(_data) + static_cast<size_t>((x*_stride.x + y*_stride.y + _stride.z*z) * static_cast<MLint>(_dataTypeSize)));
  }
 
  inline void* getImagePointer(const ImageVector& voxelPosition) const
  {
    return getSubImagePointer(voxelPosition-_box.v1);
  }
 
  inline void* getImagePointer(MLint x, MLint y, MLint z) const
  {
    return getSubImagePointer(x-_box.v1.x, y-_box.v1.y, z-_box.v1.z);
  }
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLEXPORT void copySubImage(const SubImage& fromImage, const ScaleShiftData& scaleShiftData);
 
  MLEXPORT void copySubImage(const SubImage& fromImage);
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLEXPORT bool isValid() const;
 
  inline void* getData() const    { return _data; }
 
  MLEXPORT void setData(void* data) { _memoryBlock.clear(); _data = data; }
 
  MLEXPORT void setDataFromMemoryBlockHandle(const MLMemoryBlockHandle& data) { _memoryBlock = data; _data = _memoryBlock.data(); }
 
  inline const MLMemoryBlockHandle& getMemoryBlockHandle() const { return _memoryBlock; }
 
  //----------------------------------------------------------------------
  //----------------------------------------------------------------------
  MLEXPORT static MLint coordToIndex(MLint x, MLint y, MLint z, MLint c, MLint t, MLint u, const ImageVector& size);
 
  //----------------------------------------------------------------------
  //----------------------------------------------------------------------
  MLEXPORT static MLint coordToIndex(const ImageVector& voxelPosition, const ImageVector& size);
 
  //----------------------------------------------------------------------
  //----------------------------------------------------------------------
  MLEXPORT static ImageVector indexToCoord(MLint index, const ImageVector& extent);
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  inline bool isValidSubImagePosition(const ImageVector& voxelPosition) const
  {
    const ImageVector extent = getExtent();
    return ((voxelPosition.x>=0)               && (voxelPosition.y>=0)               && (voxelPosition.z>=0)               &&
            (voxelPosition.c>=0)               && (voxelPosition.t>=0)               && (voxelPosition.u>=0)               &&
            voxelPosition.x < extent.x && voxelPosition.y < extent.y && voxelPosition.z < extent.z &&
            voxelPosition.c < extent.c && voxelPosition.t < extent.t && voxelPosition.u < extent.u );
  }
 
  inline bool isValidSubImagePosition(MLint x, MLint y, MLint z) const
  {
    const ImageVector extent = getExtent();
    return ((x>=0)                 && (y>=0)                 && (z>=0)                &&
            (x < extent.x) && (y < extent.y) && (z < extent.z));
  }
 
  inline bool isValidImagePosition(const ImageVector& voxelPosition) const
  {
    return ((voxelPosition.x>=_box.v1.x) && (voxelPosition.y>=_box.v1.y) && (voxelPosition.z>=_box.v1.z) &&
            (voxelPosition.c>=_box.v1.c) && (voxelPosition.t>=_box.v1.t) && (voxelPosition.u>=_box.v1.u) &&
            (voxelPosition.x<=_box.v2.x) && (voxelPosition.y<=_box.v2.y) && (voxelPosition.z<=_box.v2.z) &&
            (voxelPosition.c<=_box.v2.c) && (voxelPosition.t<=_box.v2.t) && (voxelPosition.u<=_box.v2.u)    );
  }
 
  inline bool isValidImagePosition(MLint x, MLint y, MLint z) const
  {
    return ((x>=_box.v1.x) && (y>=_box.v1.y) && (z>=_box.v1.z) &&
            (x<=_box.v2.x) && (y<=_box.v2.y) && (z<=_box.v2.z)   );
  }
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLEXPORT void allocate(MLMemoryErrorHandling handleFailure);
 
  MLEXPORT void allocateAsMemoryBlockHandle(MLMemoryErrorHandling handleFailure = ML_RETURN_NULL);
 
  MLEXPORT void free();
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLEXPORT bool isOneValued() const;
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLEXPORT MLint calculateMinMax(MLdouble& minValue, MLdouble& maxValue,
                                 const SubImageBox* const validBox=nullptr) const;
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLEXPORT void compare(const SubImage& subImage2,
                        bool*         regionsMatch,
                        bool*         dataTypesMatch,
                        bool*         thisBoxIsPartOfRegion2,
                        bool*         region2IsPartOfThisBox,
                        bool*         overlapHasSameValues,
                        ImageVector*  firstMismatchPos) const;
 
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLEXPORT void fill(MLdouble value);
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLEXPORT void fillWithTypeData(const MLTypeData* value);
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  MLEXPORT void fillBordersWithScalarValue(const SubImageBox &box, MLdouble fillValue);
  //-------------------------------------------------------------------------------------------
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  MLEXPORT void fillBordersWithTypeData(const SubImageBox &box, const MLTypeData *fillValue);
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  MLEXPORT void fillBordersWithInputValues(const SubImageBox &box, const SubImage &inputSubImage);
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  MLEXPORT void fillBordersWithBorderValues(const SubImageBox& box);
 
  inline void fillInvalidRegionWithScalarValue(MLdouble value) {
    fillBordersWithScalarValue(getValidRegion(), value);
  }
 
  inline void fillInvalidRegionWithTypeData(const MLTypeData *value) {
    fillBordersWithTypeData(getValidRegion(), value);
  }
 
  inline void fillInvalidRegionWithBorderValues() {
    fillBordersWithBorderValues(getValidRegion());
  }
 
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  MLEXPORT ImageProperties toImageProperties() const;
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  MLEXPORT void setFromImageProperties(const ImageProperties& imageProperties);
 
  // Debug output to std::ostream, unoptimized
  void toStream(std::ostream &ostr) const;
 
protected:
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  void _calcFillAreaParams(const SubImageBox &box,
                           const SubImageBox &maxValidInputRegion,
                           ImageVector &boxV1,        ImageVector &boxV2,
                           ImageVector &outputTSubImageV1, ImageVector &outputTSubImageV2,
                           MLint &fullLineLenX,
                           MLint &fullLineLenXB,
                           MLint &leftLineStartX,
                           MLint &leftLineLenX,
                           MLint &leftLineLenXB,
                           MLint &rightLineStartX,
                           MLint &rightLineLenX,
                           MLint &rightLineLenXB);
 
  void _copySubImageGeneric(const SubImage& fromImage, const ScaleShiftData& scaleShiftData);
 
  const MLTypeInfos* _getDataTypeInfos(MLDataType dt) const;
 
  SubImageBox _box;
 
  ImageVector _sourceImageExtent;
 
  void* _data;
 
  MLMemoryBlockHandle _memoryBlock;
 
  ImageVector _stride;
 
  MLDataType _dataType;
 
private:
  size_t _dataTypeSize;
 
#if ML_DEPRECATED_SINCE(3,5,0)
 
 
public:
 
  inline ML_DEPRECATED SubImageBox getBoxFromImgExt() const { return getBoxFromExtent(); }
  inline ML_DEPRECATED ImageVector getImgExt() const {return getImageExtent(); }
  inline ML_DEPRECATED void setImgExt(const ImageVector& newExtent) { setImageExtent(newExtent); }
  inline ML_DEPRECATED MLint getSize() const { return getNumVoxels(); }
  inline ML_DEPRECATED MLint getByteSize() const { return getSizeInBytes(); }
  inline ML_DEPRECATED void* getVoidSubImgPos(const ImageVector &p) const { return getSubImagePointer(p); }
  inline ML_DEPRECATED void* getVoidSubImgPos(MLint x, MLint y, MLint z) const { return getSubImagePointer(x, y, z); }
  inline ML_DEPRECATED void* getVoidImgPos(const ImageVector &p) const { return getImagePointer(p); }
  inline ML_DEPRECATED void* getVoidImgPos(MLint x, MLint y, MLint z) const { return getImagePointer(x, y, z); }
  inline ML_DEPRECATED MLint isValidSubImgPos(const ImageVector& p) const { return isValidSubImagePosition(p); }
  inline ML_DEPRECATED MLint isValidSubImgPos(MLint x, MLint y, MLint z) const { return isValidSubImagePosition(x, y, z); }
  inline ML_DEPRECATED MLint isValidImgPos(const ImageVector& p) const { return isValidImagePosition(p); }
  inline ML_DEPRECATED MLint isValidImgPos(MLint x, MLint y, MLint z) const { return isValidImagePosition(x, y, z); }
  inline ML_DEPRECATED MLint calculateMinMax(MLldouble& minValue, MLldouble& maxValue,
                                             const SubImageBox* const validBox=nullptr) const { MLdouble tmpMin, tmpMax; MLint result = calculateMinMax(tmpMin, tmpMax, validBox); minValue = tmpMin; maxValue = tmpMax; return result; }
  inline ML_DEPRECATED MLint calcMinMax(MLdouble& minVal, MLdouble& maxVal,
    const SubImageBox* const validBox=nullptr) const { return calculateMinMax(minVal, maxVal, validBox); }
  inline ML_DEPRECATED MLint calcMinMax(MLldouble &minValue, MLldouble &maxValue,
                                        const SubImageBox * const validBox=nullptr) const { MLdouble tmpMin, tmpMax; MLint result = calculateMinMax(tmpMin, tmpMax, validBox); minValue = tmpMin; maxValue = tmpMax; return result; }
  inline ML_DEPRECATED void fillSubImg(MLldouble val) { fill(static_cast<MLdouble>(val)); }
  inline ML_DEPRECATED void fillSubImgWithTypeData(const MLTypeData *val) { fillWithTypeData(val); }
  inline ML_DEPRECATED void fillBordersWithClampedInputValues(const SubImageBox& box) { fillBordersWithBorderValues(box); }
  inline ML_DEPRECATED void fillBordersWithLDoubleValue(const SubImageBox &box, MLldouble fillValue) { fillBordersWithScalarValue(box, static_cast<MLdouble>(fillValue)); }
  inline ML_DEPRECATED void fillInvalidRegionWithLDoubleValue(MLldouble value) { fillBordersWithScalarValue(getValidRegion(), static_cast<MLdouble>(value)); }
 
 
 
#endif
 
};
 
#if ML_DEPRECATED_SINCE(3,5,0)
ML_DEPRECATED typedef SubImage SubImg;
#endif
 
 
ML_END_NAMESPACE
 
// Stream output for std::ostream
namespace std {
  MLEXPORT ostream& operator<<(ostream& s, const ML_NAMESPACE::SubImage &fc);
}
 
#endif //of __mlSubImage_H