cxViewGroupData.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 CXVIEWGROUPDATA_H
#define CXVIEWGROUPDATA_H

#include "cxResourceVisualizationExport.h"

#include <vector>
#include <QVariant>
#include <QObject>
#include "cxDefinitions.h"
#include "vtkForwardDeclarations.h"
#include "cxForwardDeclarations.h"
#include "cxForwardDeclarations.h"
#include "cxPlaneTypeCollection.h"
#include "cxViewService.h"
class QDomNode;

namespace cx
{

typedef boost::shared_ptr<class CameraData> CameraDataPtr;
typedef boost::shared_ptr<class CoreServices> CoreServicesPtr;
typedef boost::shared_ptr<class VisServices> VisServicesPtr;
typedef boost::shared_ptr<class StringListProperty> StringListPropertyPtr;


struct cxResourceVisualization_EXPORT CameraStyleData
{
        CameraStyleData();
        explicit CameraStyleData(CAMERA_STYLE_TYPE style);
        void setCameraStyle(CAMERA_STYLE_TYPE style);
        CAMERA_STYLE_TYPE getStyle();
        void clear();
        void addXml(QDomNode& dataNode);
        void parseXml(QDomNode dataNode);

        double mCameraViewAngle;
        bool mCameraFollowTool;
        bool mFocusFollowTool;
        bool mCameraLockToTooltip;
        double mCameraTooltipOffset;
        bool mTableLock;
        double mElevation;
        bool mUniCam;
        QString mCameraNotBehindROI; // never move camera behind this roi
        QString mFocusROI; // name of ROI to set focus in.
        QString mAutoZoomROI; // name of ROI to zoom to.
};
cxResourceVisualization_EXPORT bool operator==(const CameraStyleData& lhs, const CameraStyleData& rhs);

cxResourceVisualization_EXPORT int getPriority(DataPtr data);

cxResourceVisualization_EXPORT bool dataTypeSort(const DataPtr data1, const DataPtr data2);

typedef boost::shared_ptr<class SyncedValue> SyncedValuePtr;
typedef boost::shared_ptr<class ViewGroupData> ViewGroupDataPtr;

class cxResourceVisualization_EXPORT DataViewProperties
{
public:
        DataViewProperties() : mVolume3D(false), mSlice3D(false), mSlice2D(false) {}
        static DataViewProperties createDefault();
        static DataViewProperties createFull();
        static DataViewProperties createVolume3D();
        static DataViewProperties createSlice3D();
        static DataViewProperties createSlice2D();
        static DataViewProperties create3D();
        void addXml(QDomNode& dataNode);
        void parseXml(QDomNode dataNode);
        bool empty() const;
        DataViewProperties addFlagsIn(DataViewProperties rhs) const;
        DataViewProperties removeFlagsIn(DataViewProperties rhs) const;
        bool containsAnyFlagsIn(DataViewProperties required) const;

        bool hasVolume3D() const { return mVolume3D; }
        bool hasSlice3D() const { return mSlice3D; }
        bool hasSlice2D() const { return mSlice2D; }

private:
        bool mVolume3D;
        bool mSlice3D;
        bool mSlice2D;
};

class cxResourceVisualization_EXPORT ViewGroupData: public QObject
{
Q_OBJECT

public:
        explicit ViewGroupData(CoreServicesPtr services, QString uid);
        void requestInitialize();
        QString getUid() const { return mUid; }
        std::vector<DataPtr> getData(DataViewProperties properties=DataViewProperties::createFull()) const;
        QString getVideoSource() const;
        void addData(QString uid);
        void addDataSorted(QString uid); 
        void setVideoSource(QString uid);
        bool removeData(QString uid);
        void clearData();
        std::vector<ImagePtr> getImages(DataViewProperties properties) const;
        std::vector<MeshPtr> getMeshes(DataViewProperties properties) const;
        std::vector<TrackedStreamPtr> getTrackedStreams(DataViewProperties properties) const;
        std::vector<ImagePtr> getImagesAndChangingImagesFromTrackedStreams(DataViewProperties properties, bool include2D = false) const;
        DataViewProperties getProperties(QString uid);
        void setProperties(QString uid, DataViewProperties properties);

        void initializeGlobal2DZoom(SyncedValuePtr val);
        SyncedValuePtr getGroup2DZoom();
        SyncedValuePtr getGlobal2DZoom();

        CameraDataPtr getCamera3D() { return mCamera3D; }
        void zoomCamera3D(int zoomFactor);

        PlaneTypeCollection getSliceDefinitions();
        void setSliceDefinitions(PlaneTypeCollection val);
        StringListPropertyPtr getSliceDefinitionProperty();
        
        ToolPtr getControllingTool();
        void setControllingTool(ToolPtr tool);

        // view options for this group.
        struct Options
        {
                Options();
                bool mShowLandmarks;
                bool mShowPointPickerProbe;
                MeshPtr mPickerGlyph;
                CameraStyleData mCameraStyle;
        };

        Options getOptions() const;
        void setOptions(Options options);
        void setRegistrationMode(REGISTRATION_STATUS mode);

        void addXml(QDomNode& dataNode);
        void parseXml(QDomNode dataNode);

private slots:
        void purgeDataNotExistingInPatientModelService();

signals:
        void dataViewPropertiesChanged(QString uid);
        void videoSourceChanged(QString uid);
        void initialized();
        void optionsChanged();
        void controllingToolChanged();

private:
        typedef std::pair<QString, DataViewProperties> DataAndViewPropertiesPair;

        struct data_equals
        {
                data_equals(QString uid) : mData(uid) {}
                bool operator()(const DataAndViewPropertiesPair& right)
                {
                        return mData == right.first;
                }
                QString mData;
        };

        template<class DATA_TYPE>
        std::vector<boost::shared_ptr<DATA_TYPE> > getDataOfType(DataViewProperties requiredProperties) const;
        bool contains(QString uid) const;
        void createSliceDefinitionProperty();
        void insertData(std::vector<DataAndViewPropertiesPair>::iterator iter, DataAndViewPropertiesPair &item);

        QString mUid;
        CoreServicesPtr mServices;
        QString mVideoSource;
        std::vector<DataAndViewPropertiesPair> mData;
        CameraDataPtr mCamera3D;
        Options mOptions;
        SyncedValuePtr mGroup2DZoom;
        SyncedValuePtr mGlobal2DZoom;
        StringListPropertyPtr mSliceDefinitionProperty;
        DataPtr getData(QString uid) const;
        //SharedOpenGLContextPtr mSharedOpenGLContext;
        ToolPtr mControllingTool; 

};


} //namespace cx

#endif // CXVIEWGROUPDATA_H