cxImage.h

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.

Copyright (c) 2008-2014, SINTEF Department of Medical Technology
All rights reserved.

Redistribution and use in source and binary forms, with or without 
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, 
   this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, 
   this list of conditions and the following disclaimer in the documentation 
   and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors 
   may be used to endorse or promote products derived from this software 
   without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
=========================================================================*/


#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";
        }

        // 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;

        // methods for defining and storing clip planes. Image does not use these data, this is up to the mapper
        virtual void addPersistentClipPlane(vtkPlanePtr plane);
        virtual std::vector<vtkPlanePtr> getAllClipPlanes();
        virtual void clearPersistentClipPlanes();
        virtual void setInteractiveClipPlane(vtkPlanePtr plane); 

        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();
        int getVTKMinValue();
        int getVTKMaxValue();
signals:
        void vtkImageDataChanged(); 
        void transferFunctionsChanged(); 
        void clipPlanesChanged();
        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; 
        std::vector<vtkPlanePtr> mPersistentClipPlanes;
        vtkPlanePtr mInteractiveClipPlane;
        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_*/