TexGenRenderer.h

Go to the documentation of this file.

/*=============================================================================
TexGen: Geometric textile modeller.
Copyright (C) 2006 Martin Sherburn
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program 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 General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
=============================================================================*/
 
#pragma once
 
#include "../Core/TexGen.h"
namespace TexGen
{
    struct PROP_INFO { virtual ~PROP_INFO() {} };
 
    struct PROP_YARN_INFO : public PROP_INFO
    {
        string TextileName;
        int iYarn;
    };
 
    struct PROP_NODE_INFO : public PROP_INFO
    {
        string TextileName;
        int iYarn;
        int iNode;
    };
 
    struct PROP_IMAGE_INFO : public PROP_INFO
    {
        int iImageID;
    };
 
    inline bool operator < (const PROP_YARN_INFO &left, const PROP_YARN_INFO &right)
    {
        if (left.TextileName != right.TextileName)
            return left.TextileName < right.TextileName;
        else if (left.iYarn != right.iYarn)
            return left.iYarn < right.iYarn;
        else
            return false;
    }
 
    inline bool operator < (const PROP_NODE_INFO &left, const PROP_NODE_INFO &right)
    {
        if (left.TextileName != right.TextileName)
            return left.TextileName < right.TextileName;
        else if (left.iYarn != right.iYarn)
            return left.iYarn < right.iYarn;
        else if (left.iNode != right.iNode)
            return left.iNode < right.iNode;
        else
            return false;
    }
 
    class CTextile; // This makes sure that swig knows CTextile is part of the TexGen namespace...
 
    class CTexGenRenderer
    {
    public:
        CTexGenRenderer(vtkRenderWindowInteractor *pRenderWindowInteractor = NULL);
        ~CTexGenRenderer(void);
 
        enum PROP_TYPE
        {
            PROP_NODE,
            PROP_PATH,
            PROP_SURFACE,
            PROP_VOLUME,
            PROP_AXES,
            PROP_INTERFERENCE,
            PROP_ORIENTATION,
            PROP_DOMAIN,
            PROP_DOMAINAXES,
            PROP_IMAGE,
            PROP_INTERFERENCE_DEPTH,
        };
 
        enum EXPORT_FLAG
        {
            EXPORT_NODES = 1<<0,
            EXPORT_PATH = 1<<1,
            EXPORT_SURFACE = 1<<2,
            EXPORT_DOMAIN = 1<<3,
        };
 
 
        void RenderTextile(string TextileName = "", double dOpacity = 1);
 
 
        void RenderTextile(CTextile &Textile, double dOpacity = 1);
 
        vtkProp* RenderYarn(CYarn &Yarn, const CDomain *pDomain = NULL, COLOR Color = COLOR(1, 1, 1), double dOpacity = 1);
 
 
        void RenderMesh(string TextileName = "");
 
 
        void RenderMesh(CTextile &Textile);
 
        vtkProp* RenderYarnMesh(CYarn &Yarn, const CDomain *pDomain = NULL, COLOR Color = COLOR(1, 1, 1));
 
        void RenderDomain(string TextileName = "", COLOR Color = COLOR(1, 1, 1), double dOpacity = 0.5);
 
        void RenderDomain(const CDomain &Domain, COLOR Color = COLOR(1, 1, 1), double dOpacity = 0.5);
 
        void RenderDomainAxes(string TextileName = "");
 
        void RenderDomainAxes(const CDomain &Domain);
 
        void RenderNodes(string TextileName = "");
 
        void RenderNodes(CTextile &Textile);
 
        void RenderNodes(CTextile &Textile, int iYarn);
 
        void RenderPaths(string TextileName = "");
 
        void RenderPaths(CTextile &Textile);
 
        void RenderPath(CTextile &Textile, int iYarn);
 
        void RenderInterference(string TextileName = "", bool bDepth = false );
 
        void RenderInterference(CTextile &Textile, bool bDepth = false);
 
        void RenderGrid(string TextileName = "", int iResX = 20, int iResY = 20, int iResZ = 20, double dLengthModifier = 1);
 
        void RenderGrid(CTextile &Textile, int iResX = 20, int iResY = 20, int iResZ = 20, double dLengthModifier = 1);
 
        //bool RenderImage(string FileName, double dMaxDim = 1, XYZ Orientation = XYZ());
 
        void SetBackgroundColor(COLOR Color);
 
        void RenderAxes();
 
        void ClearScene();
 
        void RemoveProps(PROP_TYPE Type);
 
        void SetPropsColor(PROP_TYPE Type, COLOR Color);
 
        int GetNumProps(PROP_TYPE Type) const;
 
        vector<vtkProp*> GetProps(PROP_TYPE Type);
 
        vector<vtkProp*> GetProps(set<PROP_TYPE> Types);
 
        const PROP_YARN_INFO *GetYarnPropInfo(vtkProp* pProp) const;
 
        const PROP_NODE_INFO *GetNodePropInfo(vtkProp* pProp) const;
 
        const PROP_IMAGE_INFO *GetImagePropInfo(vtkProp* pProp) const;
 
        vector<vtkProp*> GetProps(PROP_INFO* pInfo, bool bIgnoreTextileName = false);
 
        vector<vtkProp*> GetNodeProps(PROP_YARN_INFO Info, bool bIgnoreTextileName = false);
 
        void RefreshYarn(PROP_YARN_INFO YarnInfo);
 
        void RefreshTextile(string TextileName);
 
        void ResetCamera(XYZ LookDirection = XYZ());
 
        void RefreshView();
 
 
        void Start(bool bTakeControl = true, int iWidth = 800, int iHeight = 600, bool bFullScreen = false);
 
 
        void TakeScreenShot(string FileName, int iMagnification = 1);
 
        void SetParallelProjection(bool bParallelProjection);
 
        vtkRenderer * GetRenderer() { return m_pRenderer; }
 
        vtkRenderWindowInteractor * GetInteractor() { return m_pRenderWindowInteractor; }
 
        void SetCallback(void (*pCallback)());
 
        void SetXRay(bool bXRay);
 
        void SetTrimToDomain(bool bTrim);
 
        void SetYarnColor(int iYarn, COLOR Color);
 
        static void ApplyColor(vtkActor *pActor, COLOR Color);
 
        void ApplyDefaultColor(vtkActor *pActor);
 
 
        bool SaveTextileToVTK(string FileName, string TextileName = "", int iExportFlags = EXPORT_NODES | EXPORT_PATH | EXPORT_SURFACE | EXPORT_DOMAIN);
 
        bool SaveMeshToVTK(string FileName, const CMesh &Mesh);
 
 
        void BeginBatch();
        
 
        void EndBatch();
 
        // Convenience functions
        void RemoveNodes() { RemoveProps(PROP_NODE); }
        void RemovePaths() { RemoveProps(PROP_PATH); }
        void RemoveTextiles() { RemoveProps(PROP_SURFACE); }
        void RemoveMeshes() { RemoveProps(PROP_VOLUME); }
        void RemoveAxes() { m_pOrientationMarkerWidget->SetEnabled(0); RefreshView();/*RemoveProps(PROP_AXES);*/ }
        void RemoveInterference() { RemoveProps(PROP_INTERFERENCE); }
        void RemoveInterferenceDepth() { RemoveProps(PROP_INTERFERENCE_DEPTH); }
        void RemoveOrientations() { RemoveProps(PROP_ORIENTATION); }
        void RemoveDomains() { RemoveProps(PROP_DOMAIN); }
        void RemoveDomainAxes() { RemoveProps(PROP_DOMAINAXES); }
        vtkPolyData *GetPolyData(const CMesh &Mesh);
        bool GetXRay() const { return m_bXRay; }
        bool GetTrimToDomain() const { return m_bTrimToDomain; }
        bool GetParallelProjection() const;
 
 
    protected:
 
        void UpdateAxesColor();
 
 
        COLOR GetBestAnnotationColor();
 
        void AddProp(PROP_TYPE Type, vtkProp *pProp);
 
        // Remove an actor from the scene
        void RemoveProp(vtkProp *pProp);
 
        int GetUniqueImageID();
 
        vtkActor *ConvertToActor(vtkAlgorithm *pAlgorithm);
        vtkActor *ConvertToActor(vtkPolyData *pPolyData);
        vtkAlgorithm *CalculateNormals(vtkPolyData *pInput);
 
//      void RenderDirection(XYZ Position, XYZ Direction, PROP_TYPE Type, double dScale = 1, double adColor[3] = COLOR_WHITE, bool bRefresh = true);
 
        multimap<PROP_TYPE, vtkProp*> m_Props;
        map<vtkProp*, PROP_YARN_INFO> m_YarnProps;
        map<vtkProp*, PROP_NODE_INFO> m_NodeProps;
        map<vtkProp*, PROP_IMAGE_INFO> m_ImageProps;
 
        vtkRenderer *m_pRenderer;
        vtkRenderWindow *m_pRenderWindow;
        vtkRenderWindowInteractor *m_pRenderWindowInteractor;
        vtkOrientationMarkerWidget *m_pOrientationMarkerWidget;
 
        void (*m_pCallback)();
 
        bool m_bXRay;
        bool m_bTrimToDomain;
        int m_iBatchCount;
    };
 
};  // namespace TexGen