ImageComponent.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2018 Univ. Grenoble Alpes, CNRS, TIMC-IMAG UMR 5525 (GMCAO)
 *
 * Visit http://camitk.imag.fr for more information
 *
 * This file is part of CamiTK.
 *
 * CamiTK is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * CamiTK is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with CamiTK.  If not, see <http://www.gnu.org/licenses/>.
 *
 * $CAMITK_LICENCE_END$
 ****************************************************************************/

#ifndef IMAGE_COMPONENT_H
#define IMAGE_COMPONENT_H

// -- Core image component stuff
#include "SingleImageComponent.h"
#include "CamiTKAPI.h"
#include "ImageOrientationHelper.h"

// -- vtk stuff
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>
#include <vtkImageData.h>
#include <vtkTransform.h>
#include <vtkImageFlip.h>
#include <vtkWindowLevelLookupTable.h>
#include <vtkMatrix4x4.h>

// -- QT stuff classes
class QMenu;
class QTableView;
class QVector3D;
class QVariant;
class QTableView;
class QStandardItemModel;

namespace camitk {

class MeshComponent;

class CAMITK_API ImageComponent : public camitk::Component {
    Q_OBJECT

public:
    ImageComponent(const QString& file);

    ImageComponent(vtkSmartPointer<vtkImageData> anImageData, const QString& name, bool copy = false, ImageOrientationHelper::PossibleImageOrientations initialOrientation = ImageOrientationHelper::RAI);

    ~ImageComponent() override;

    void setSelected(const bool b, const bool recursive = false) override;

    QString getImageName() const;
    void setImageName(const QString&);

    vtkSmartPointer<vtkImageData> getImageData() const {
        return originalImageData;
    }

    vtkSmartPointer<vtkImageData> getImageDataWithFrameTransform();

    ImageOrientationHelper::PossibleImageOrientations getInitialOrientation() const {
        return initialOrientation;
    }

    void pixelPicked(double x, double y, double z, SingleImageComponent* whoIsAsking);

    void getLastPixelPicked(int* x, int* y, int* z);

    void getLastPointPickedImageCoords(double* x, double* y, double* z);

    void getLastPointPickedWorldCoords(double* x, double* y, double* z);


    int getNumberOfColors() const override;

    double getMinColor() const;

    double getMaxColor() const;

    int getActualNumberOfColors() const;

    double getActualMinColor() const;

    double getActualMaxColor() const;

    int getNumberOfSlices() const override;

    virtual void setLut(vtkSmartPointer<vtkWindowLevelLookupTable> lookupTable);

    virtual vtkSmartPointer<vtkWindowLevelLookupTable>  getLut();

    void refresh() const override;

    SingleImageComponent* getAxialSlices();
    SingleImageComponent* getCoronalSlices();
    SingleImageComponent* getSagittalSlices();
    SingleImageComponent* getArbitrarySlices();
    MeshComponent* getVolumeRenderingChild();

    virtual void replaceImageData(vtkSmartPointer<vtkImageData> anImageData, bool copy = false, ImageOrientationHelper::PossibleImageOrientations initialOrientation = ImageOrientationHelper::RAI);

    void updateProperty(QString, QVariant) override;

    unsigned int getNumberOfPropertyWidget() override;

    QWidget* getPropertyWidgetAt(unsigned int i) override;

    const vtkSmartPointer<vtkMatrix4x4> getRotationMatrix() {
        return rotationMatrix;
    }


protected:

    virtual void setImageData(vtkSmartPointer<vtkImageData> anImageData,
                              bool copy,
                              ImageOrientationHelper::PossibleImageOrientations initialOrientation = ImageOrientationHelper::RAI,
                              vtkSmartPointer<vtkMatrix4x4> initialTransformMatrix = nullptr);

    virtual void setSingleImageComponents(SingleImageComponent* axialSlices, SingleImageComponent* sagittalSlices, SingleImageComponent* coronalSlices, SingleImageComponent* arbitrarySlices);

private:
    virtual void initImageProperties();

    void initRepresentation() {}

    // builds default lookup table
    void initLookupTable();

    void buildImageComponents();

    void updateImageComponents();

    void update3DViewer();

    vtkSmartPointer<vtkPolyData> getBoundingBox();

    vtkSmartPointer<vtkImageData> originalImageData;

    SingleImageComponent* axialSlices;

    SingleImageComponent* sagittalSlices;

    SingleImageComponent* coronalSlices;

    SingleImageComponent* arbitrarySlices;

    MeshComponent* volumeRenderingChild;

    vtkSmartPointer<vtkWindowLevelLookupTable> lut;

    double currentPixelPicked[3];

    virtual void init();

    QTableView* selectionView;

    QStandardItemModel* model;

    ImageOrientationHelper::PossibleImageOrientations initialOrientation;

    vtkSmartPointer<vtkTransform> initialImageDataTransform;

    vtkSmartPointer<vtkTransform> initialFrameTransform;

    vtkSmartPointer<vtkMatrix4x4> rotationMatrix;
};

}

#endif //IMAGE_COMPONENT_H