cxImage.h

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
 
#ifndef CXIMAGE_H_
#define CXIMAGE_H_
 
#include "cxResourceExport.h"
#include "cxPrecompiledHeader.h"
 
#include <map>
#include <vector>
#include <boost/shared_ptr.hpp>
#include "cxBoundingBox3D.h"
#include "vtkForwardDeclarations.h"
#include "cxForwardDeclarations.h"
#include "cxData.h"
 
typedef boost::shared_ptr<std::map<int, int> > HistogramMapPtr;
 
class QDomNode;
class QDomDocument;
 
 
namespace cx
{
typedef std::map<int, int> IntIntMap;
typedef std::map<int, QColor> ColorMap;
 
class cxResource_EXPORT Image : public Data
{
Q_OBJECT
 
public:
        struct ShadingStruct
        {
                bool on;
                double ambient;
                double diffuse;
                double specular;
                double specularPower;
 
                ShadingStruct();
                void addXml(QDomNode dataNode);
                void parseXml(QDomNode dataNode);
 
        private:
                double loadAttribute(QDomNode dataNode, QString name, double defVal);
        };
 
        static ImagePtr create(const QString& uid, const QString& name);
        ImagePtr copy();
 
        virtual ~Image();
        Image(const QString& uid, const vtkImageDataPtr& data, const QString& name = "");
 
        virtual void intitializeFromParentImage(ImagePtr parentImage);
        virtual void setVtkImageData(const vtkImageDataPtr& data, bool resetTransferFunctions = true);
 
        virtual vtkImageDataPtr getBaseVtkImageData(); 
        virtual vtkImageDataPtr getGrayScaleVtkImageData(); 
        virtual vtkImageDataPtr get8bitGrayScaleVtkImageData();
 
        virtual ImagePtr getUnsigned(ImagePtr self);
 
        virtual IMAGE_MODALITY getModality() const;
        virtual void setModality(const IMAGE_MODALITY &val);
        virtual IMAGE_SUBTYPE getImageType() const;
        virtual void setImageType(const IMAGE_SUBTYPE &val);
 
        virtual ImageTF3DPtr getTransferFunctions3D();
        virtual void setTransferFunctions3D(ImageTF3DPtr transferFuntion);
        virtual ImageLUT2DPtr getLookupTable2D();
        virtual void setLookupTable2D(ImageLUT2DPtr imageLookupTable2D);
 
        virtual void setInitialWindowLevel(double width, double level);
        double getInitialWindowLevel() const { return mInitialWindowLevel; }
        double getInitialWindowWidth() const { return mInitialWindowWidth; }
 
        virtual DoubleBoundingBox3D boundingBox() const; 
        virtual Eigen::Array3d getSpacing() const;
        virtual vtkImageAccumulatePtr getHistogram();
        virtual int getMax();   
        virtual int getMin();   
        virtual int getRange();
        virtual int getMaxAlphaValue();
        virtual void setShadingOn(bool on);
        virtual bool getShadingOn() const;
        virtual void setShadingAmbient(double ambient); 
        virtual void setShadingDiffuse(double diffuse); 
        virtual void setShadingSpecular(double specular); 
        virtual void setShadingSpecularPower(double specularPower); 
        virtual double getShadingAmbient(); 
        virtual double getShadingDiffuse(); 
        virtual double getShadingSpecular(); 
        virtual double getShadingSpecularPower(); 
        virtual Image::ShadingStruct getShading();
        virtual void setShading(Image::ShadingStruct shading);
 
        void addXml(QDomNode& dataNode); 
        virtual void parseXml(QDomNode& dataNode);
        virtual bool load(QString path, FileManagerServicePtr filemanager);
        virtual QString getType() const
        {
                return getTypeName();
        }
        static QString getTypeName()
        {
                return "image";
        }
        virtual QIcon getIcon() {return QIcon(":/icons/volume.png");}
 
        // methods for defining and storing a cropping box. Image does not use these data, this is up to the mapper
        virtual void setCropping(bool on);
        virtual bool getCropping() const;
        virtual void setCroppingBox(const DoubleBoundingBox3D& bb_d);
        virtual DoubleBoundingBox3D getCroppingBox() const;
 
        void mergevtkSettingsIntosscTransform();
 
        void resetTransferFunctions(bool _2D=true, bool _3D=true); 
 
        void moveThisAndChildrenToThread(QThread* thread); 
 
        static vtkImageDataPtr createDummyImageData(int axisSize, int maxVoxelValue); 
 
//      void setInterpolationTypeToNearest();
//      void setInterpolationTypeToLinear();
        void setInterpolationType(int val);
        int getInterpolationType() const;
 
        vtkImageDataPtr resample(long maxVoxels);
 
        virtual void save(const QString &basePath, FileManagerServicePtr filemanager);
 
        void startThresholdPreview(const Eigen::Vector2d& threshold);
        void stopThresholdPreview();
        double getVTKMinValue();
        double getVTKMaxValue();
        bool is2D();
 
signals:
        void vtkImageDataChanged(QString uid = QString()); 
        void transferFunctionsChanged(); 
        void cropBoxChanged();
 
protected slots:
        virtual void transformChangedSlot();
 
protected:
        vtkImageDataPtr mBaseImageData; 
        vtkImageDataPtr mBaseGrayScaleImageData; 
//      vtkImageReslicePtr mOrientator; ///< converts imagedata to outputimagedata
//      vtkMatrix4x4Ptr mOrientatorMatrix;
//      vtkImageDataPtr mReferenceImageData; ///< imagedata after filtering through the orientatior, given in reference space
        vtkImageAccumulatePtr mHistogramPtr;
        ImagePtr mUnsigned; 
 
//      LandmarksPtr mLandmarks;
 
        ShadingStruct mShading;
 
        bool mUseCropping; 
        DoubleBoundingBox3D mCroppingBox_d; 
 
        IMAGE_MODALITY mModality; 
        IMAGE_SUBTYPE mImageType; 
        double mMaxRGBIntensity;
        int mInterpolationType; 
 
 
private:
        Image(const Image& other);
        Image& operator=(const Image& other);
        void resetTransferFunction(ImageTF3DPtr imageTransferFunctions3D, ImageLUT2DPtr imageLookupTable2D);
        void resetTransferFunction(ImageLUT2DPtr imageLookupTable2D);
        void resetTransferFunction(ImageTF3DPtr imageTransferFunctions3D);
        DoubleBoundingBox3D getInitialBoundingBox() const;
        double loadAttribute(QDomNode dataNode, QString name, double defVal);
 
        double computeResampleFactor(long maxVoxels);
 
        ColorMap createPreviewColorMap(const Eigen::Vector2d &threshold);
        IntIntMap createPreviewOpacityMap(const Eigen::Vector2d &threshold);
        void createThresholdPreviewTransferFunctions3D(const Eigen::Vector2d &threshold);
        void createThresholdPreviewLookupTable2D(const Eigen::Vector2d &threshold);
 
        ImageTF3DPtr getUnmodifiedTransferFunctions3D();
        ImageLUT2DPtr getUnmodifiedLookupTable2D();
 
        ImageTF3DPtr mImageTransferFunctions3D;
        ImageLUT2DPtr mImageLookupTable2D;
 
        double mInitialWindowWidth;
        double mInitialWindowLevel;
 
        bool mThresholdPreview;
        ImageTF3DPtr mTresholdPreviewTransferfunctions3D;
        ImageLUT2DPtr mTresholdPreviewLookupTable2D;
};
 
} // end namespace cx
 
#endif /*CXIMAGE_H_*/