GUIView3DWrap.h

#pragma once

 
#include "GUIViewImageBaseWrap.h"
 
#include "GUIView3DLayerWrap.h"
#include "DefinitionsGUI.h"

namespace FLImaging
{
    namespace GUI
    {
        class CGUIView3DObject;
        class CGUIView3DObjectHeightMap;
        class CGUIView3DObjectLine;
        class CGUIView3DCamera;

        class FL_EXPORT CGUIView3DWrap : public CGUIViewImageBaseWrap
        {
        public:
            CGUIView3DWrap();

            virtual ~CGUIView3DWrap();

            const CResult Create(int32_t i32L, int32_t i32T, int32_t i32R, int32_t i32B, size_t stParentWindowHandle = 0);

            const CResult CreateAndFitParent(size_t stParentWindowHandle, bool bAutoFit = true);

            const CResult Destroy();

            size_t GetWindowHandle();

            virtual const CResult Load(const wchar_t* pWcsPath, const wchar_t* pWcsTextureImagePath, EView3DLoadOption eOption = EView3DLoadOption_Load);

            virtual const CResult Load(const wchar_t* pWcsPath = nullptr, EView3DLoadOption eOption = EView3DLoadOption_Load);

            virtual const CResult Load(const Base::CFLArray<Base::CFLString<wchar_t>>& flaFilePathToLoad, EView3DLoadOption eOption = EView3DLoadOption_Load);
            
            virtual const CResult Save(const wchar_t* pWcsPath = nullptr, bool bBinaryFormat = true);

            virtual const CResult Clear();

            virtual const CResult PushObject(const FLImaging::Foundation::CFL3DObject& obj, int32_t* pI32ReturnIndex = nullptr);

            virtual const CResult PushObject(const FLImaging::Foundation::CFL3DObjectHeightMap& obj, int32_t* pI32ReturnIndex = nullptr);

            virtual const CResult PushObject(const FLImaging::GUI::CGUIView3DObject& obj, int32_t* pI32ReturnIndex = nullptr);

            virtual const CResult PushObject(const FLImaging::GUI::CGUIView3DObjectHeightMap& obj, int32_t* pI32ReturnIndex = nullptr);
            
            virtual const CResult PushObject(const FLImaging::GUI::CGUIView3DObjectLine& obj, int32_t* pI32ReturnIndex = nullptr);

            virtual const FLImaging::GUI::CGUIView3DObject* GetView3DObject(int32_t i32ObjectIndex) const;

            virtual int32_t GetObjectIndex(const FLImaging::GUI::CGUIView3DObject* pObject) const;

            virtual const CResult SaveObject(int32_t i32ObjectIndex, const wchar_t* pWcsPath = nullptr);

            virtual const CResult RemoveObject(int32_t i32ObjectIndex);

            virtual const CResult ClearObjects();

            virtual int32_t GetObjectCount() const;

            virtual const CResult UpdateObject(int32_t i32ObjectIndex = -1);

            virtual void SetHeightMapColorMappingMode(Foundation::E3DHeightMapColorMappingMode eMode = Foundation::E3DHeightMapColorMappingMode_ImageRange);

            virtual Foundation::E3DHeightMapColorMappingMode GetHeightMapColorMappingMode() const;

            virtual void SetHeightMapColorMappingDirection(Foundation::E3DHeightMapColorMappingDirection eDirection = Foundation::E3DHeightMapColorMappingDirection_Increasing);

            virtual Foundation::E3DHeightMapColorMappingDirection GetHeightMapColorMappingDirection() const;

            virtual const CResult SetHeightMapColorMappingRange(float f32RangeMin, float f32RangeMax);

            virtual const CResult ClearHeightMapColorMappingRange();

            virtual const CResult GetHeightMapColorMappingRange(float& f32RangeMin, float& f32RangeMax) const;

            virtual const CResult SetMeasurementMode(EGUIView3DMeasurementMode eMeasurementMode);

            virtual EGUIView3DMeasurementMode GetMeasurementMode() const;

            virtual const CResult SetTeachingMode(EGUIView3DTeachingMode eTeachingMode);

            virtual EGUIView3DTeachingMode GetTeachingMode() const;

            virtual const CResult SetRotatePivotType(EGUIView3DRotatePivot eRotatePivotType);

            virtual EGUIView3DRotatePivot GetRotatePivotType() const;

            const CResult ShowStatusBar(bool bShow);

            virtual const CResult ShowToolBar(bool bShow) override;

            virtual void ShowCrosshair(bool bShow);

            virtual bool IsCrosshairVisible();

            virtual void ShowAxis(bool bShow);

            virtual bool IsAxisVisible();

            virtual void ShowGrid(bool bShow);

            virtual bool IsGridVisible();

            virtual void ShowLegend(bool bShow);

            virtual bool IsLegendVisible();

            virtual void SetCanvasColor(uint32_t u32Color);

            virtual uint32_t GetCanvasColor() const;

            virtual void SetSelectionMode(FLImaging::GUI::ESelectionMode3D eSelectionMode);

            virtual FLImaging::GUI::ESelectionMode3D GetSelectionMode();

            virtual const CResult SetCamera(const CGUIView3DCamera& camera);

            virtual const CResult SetCamera(const Foundation::CFL3DCamera& camera);

            virtual CGUIView3DCamera* GetCamera()const;

            virtual const CResult LoadCamera(const wchar_t* pWcsFilePath = nullptr);

            virtual const CResult SaveCamera(const wchar_t* pWcsFilePath = nullptr, uint8_t u8DecimalPlaces = 10);
 
            virtual const CResult InternalZoomIn(int32_t i32CanvasX, int32_t i32CanvasY);
 
            virtual const CResult InternalZoomOut(int32_t i32CanvasX, int32_t i32CanvasY);

            virtual const CResult ZoomFit(int32_t i32ObjectIndex = -1);

            Foundation::CFLPoint<int32_t> Convert3DCoordToCanvasCoord(const Base::TPoint3<float>& point) const;

            Foundation::CFLPoint<int32_t> Convert3DCoordToCanvasCoord(const Base::TPoint3<float>* pPoint) const;

            Foundation::CFLPoint<int32_t> Convert3DCoordToCanvasCoord(const Base::TPoint3<double>& point) const;

            Foundation::CFLPoint<int32_t> Convert3DCoordToCanvasCoord(const Base::TPoint3<double>* pPoint) const;

            Foundation::CFLPoint<int32_t> Convert3DCoordToCanvasCoord(double x, double y, double z) const;

            Foundation::CFLPoint<int32_t> Convert3DCoordToCanvasCoord(float x, float y, float z) const;

            const Base::TPoint3<double> ConvertCanvasCoordTo3DCoord(const Foundation::CFLPoint<int32_t>& point) const;

            const Base::TPoint3<double> ConvertCanvasCoordTo3DCoord(int32_t x, int32_t y) const;

            virtual Foundation::CFLPoint<int32_t> ConvertClientCoordToCanvasCoord(const Foundation::CFLPoint<int32_t>& flp) const;

            virtual Foundation::CFLRect<int32_t> ConvertClientCoordToCanvasCoord(const Foundation::CFLRect<int32_t>& flr) const;

            virtual Foundation::CFLPoint<int32_t> ConvertClientCoordToCanvasCoord(int32_t i32X, int32_t i32Y) const;

            virtual Foundation::CFLPoint<int32_t> ConvertCanvasCoordToClientCoord(const Foundation::CFLPoint<int32_t>& flp) const;

            virtual Foundation::CFLRect<int32_t> ConvertCanvasCoordToClientCoord(const Foundation::CFLRect<int32_t>& flr) const;

            virtual Foundation::CFLPoint<int32_t> ConvertCanvasCoordToClientCoord(int32_t i32X, int32_t i32Y) const;
 
 

            CGUIView3DLayerWrap GetLayer(int32_t i32Index);

            virtual void ClearAllLayers();

            virtual void SetAvailableView3DContextMenu(FLImaging::GUI::EAvailableView3DContextMenu eMenu);

            virtual FLImaging::GUI::EAvailableView3DContextMenu GetAvailableView3DContextMenu();

            virtual const FLImaging::CResult SelectMenuItem(FLImaging::GUI::EMenuItemView3D eMenuItem);
 

            virtual const FLImaging::CResult GetHeightProfile(const FLImaging::Foundation::CFLPoint<int64_t>* pFlpStart, const FLImaging::Foundation::CFLPoint<int64_t>* pFlpEnd, Base::CFLArray<double>* pFlaF64HeightProfile);

            virtual void EnableDragAndDrop(bool bEnable);

            virtual bool IsDragAndDropEnabled();

            virtual const CGUIView3DObject* GetHitObject() const;

            EGUIView3DHitArea GetHitArea();

            virtual Base::TPoint3<float> UnprojectPoint(int32_t i32CanvasX, int32_t i32CanvasY, float f32Depth) const;

            virtual bool GetCursorProjectionPoint(const int32_t& i32CanvasX, const int32_t& i32CanvasY, float& f32ProjectionX, float& f32ProjectionY, float& f32ProjectionZ, const float& f32Tolerance = 10.f);

            virtual bool GetCursorProjectionPoint(const int32_t& i32CanvasX, const int32_t& i32CanvasY, Base::TPoint3<float>& tp3fProjection, const float& f32Tolerance = 10.f);

            virtual bool GetCursorProjectionPoint(const Foundation::CFLPoint<int32_t>& flpCanvas, float& f32ProjectionX, float& f32ProjectionY, float& f32ProjectionZ, const float& f32Tolerance = 10.f);

            virtual bool GetCursorProjectionPoint(const Foundation::CFLPoint<int32_t>& flpCanvas, Base::TPoint3<float>& tp3fProjection, const float& f32Tolerance = 10.f);

            virtual void GetCursorPosOnLButtonDown(Foundation::CFLPoint<int32_t>& flpCanvas, Base::TPoint3<float>* pTp3fProjection = nullptr) const;

            virtual void UpdateScreen();

            virtual const CResult SetTopologyType(Foundation::ETopologyType3D eTopologyType = Foundation::ETopologyType3D_Solid);

            virtual Foundation::ETopologyType3D GetTopologyType() const;

            virtual const CResult SetShadingType(Foundation::EShadingType3D eObjectShadingType = Foundation::EShadingType3D_Phong);

            virtual Foundation::EShadingType3D GetShadingType() const;

            virtual const CResult SetPointSize(float f32PointSize = 1.f);

            virtual float GetPointSize() const;

            virtual const CResult ClearROI();

            virtual const CResult PushBackROI(const Base::TRect<float>* pTr);

            virtual const CResult PushBackROI(const Foundation::CFLFrustum3<float>* pFlfr);

            virtual const CResult PushBackROI(const Foundation::CFLFigure* pFlf);

            virtual const CResult RemoveROI(int32_t i32Index);

            virtual const CResult GetROI(int32_t i32Index, Foundation::CFLFrustum3<float>& frustumResult)  const;

            virtual const CResult GetAllROI(Foundation::CFLFigureArray* pFlfaResult) const;

            virtual int32_t GetROICount() const;

            virtual const CResult ConvertROI2DTo3D(const Base::TRect<int32_t>& tr, Foundation::CFLFrustum3<float>& frustumResult) const;

            virtual const CResult ConvertROI2DTo3D(const Foundation::CFLRect<int32_t>& flr, Foundation::CFLFrustum3<float>& frustumResult) const;

            virtual const CResult ConvertROI2DTo3D(int32_t i32Left, int32_t i32Top, int32_t i32Right, int32_t i32Bottom, Foundation::CFLFrustum3<float>& frustumResult) const;

            virtual const CResult SetPanningMode(bool bSet);

            virtual bool IsPanningMode() const;

            virtual const CResult SetRectangleSelectionMode(bool bSet);

            virtual bool IsRectangleSelectionMode() const;

            virtual const CResult SetZoomMode(EZoomMode eZoomMode);

            virtual EZoomMode GetZoomMode() const;

            const CResult SetRotationAngleLock(EGUIView3DRotationAngle eAngle);

            EGUIView3DRotationAngle GetLockedRotationAngle() const;

            const CResult SetMovementAxisLock(EGUIView3DAxis eAxis);

            EGUIView3DAxis GetLockedMovementAxis() const;

            virtual const CResult SetDecimalPlacesOfCoordinate(uint8_t u8DecimalPlaces = 2);

            virtual uint8_t GetDecimalPlacesOfCoordinate() const;

            virtual const CResult CaptureScreen(Base::CFLImage& fliImage, bool bIncludeFrame = false);

            virtual const CResult CaptureScreen(Base::CFLImage* pFliImage, bool bIncludeFrame = false);

            virtual bool IsSynchronized(EView3DSyncOption eView3DSyncOption) const;

            virtual CGUIView3DWrap* GetRootSyncView(EView3DSyncOption eView3DSyncOption) const;

            virtual const CResult ResignRootSyncView(EView3DSyncOption eView3DSyncOption);

            virtual const CResult SynchronizePointOfView(const CGUIView3DWrap* pTargetView);

            virtual const CResult DesynchronizePointOfView(const CGUIView3DWrap* pTargetView);

            virtual const CResult DesynchronizePointOfViewAll();

            bool DoesHeightMapExist() const;

            bool DoesObjectExist() const;

            bool DoesObjectSTEPExist() const;

            virtual int32_t GetObjectSTEPCount() const;

            virtual const CResult RemoveObjectSTEP(int32_t i32ObjectSTEPIndex);

            virtual const CResult ClearObjectsSTEP();

            virtual const CResult ConvertObjectSTEPToPointCloud(int32_t i32ObjectSTEPIndex, int32_t& i32ResultObjectIndex, bool bEraseObjectSTEP = true);

            virtual CGUIView3DObject* GetPointCloudFromObjectSTEP(int32_t i32ObjectSTEPIndex) const;
 
        private:
            void operator=(const CGUIView3DWrap& rh);
            CGUIView3DWrap(const CGUIView3DWrap& rh);
 
            DeclareGetClassType();
        };
    }
}