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 QString getModality() const;
        virtual void setModality(const QString& val);
        virtual QString getImageType() const;
        virtual void setImageType(const QString& 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);
        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);

        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; 

        QString mModality; 
        QString 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_*/