Yarn.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 "Node.h"
#include "YarnSection.h"
#include "YarnSectionConstant.h"
#include "YarnSectionInterpNode.h"
#include "YarnSectionInterpPosition.h"
#include "YarnSectionAdjusted.h"
#include "Interpolation.h"
#include "InterpolationBezier.h"
#include "InterpolationCubic.h"
#include "InterpolationLinear.h"
#include "InterpolationAdjusted.h"
#include "FibreDistribution.h"
#include "FibreDistributionConst.h"
#include "FibreDistribution1DQuad.h"
#include "Mesh.h"
#include "Domain.h"
#include "PropertiesYarn.h"
 
namespace TexGen
{
    class CDomain;
    class CTextile;
 
    using namespace std;
 
    class CLASS_DECLSPEC CYarn : public CPropertiesYarn
    {
    friend class CTextile;
    public:
        CYarn(void);
        CYarn(TiXmlElement &Element);
        ~CYarn(void);
 
        enum BUILD_TYPE
        {
            NONE = 0,
            LINE = 1<<0,
            SURFACE = 1<<1,
            VOLUME = 1<<2,
            ALL = LINE | SURFACE | VOLUME,
            CENTRE_PLANE = 1<<3,
        };
 
        void PopulateTiXmlElement(TiXmlElement &Element, OUTPUT_TYPE OutputType);
 
 
        void AddNode(const CNode &Node);
 
 
        bool InsertNode(const CNode &Node, const CNode* pBefore);
 
 
        bool InsertNode(const CNode &Node, int iIndex);
 
 
        bool ReplaceNode(int iIndex, CNode NewNode);
 
 
        bool DeleteNode(int iIndex);
 
        const CNode* GetNode(int iIndex) const;
 
        void SetNodes(const vector<CNode> &Nodes);
 
 
        void AssignInterpolation(const CInterpolation &Interpolation);
 
        void AssignFibreDistribution(const CFibreDistribution &Distribution);
 
 
        void SetResolution(int iNumSlaveNodes, int iNumSectionPoints);
 
 
        bool SetResolution(int iNumSectionPoints);
 
 
        void SetEquiSpacedSectionMesh(bool bEquiSpacedSectionMesh);
 
        void AssignSection(const CYarnSection &YarnSection);
 
        void Rotate(WXYZ Rotation, XYZ Origin = XYZ(0,0,0));
 
        void Translate(XYZ Vector);
 
        bool AddAABBToMesh(CMesh &Mesh) const;
        
        bool AddAABBToMesh(CMesh &Mesh, const vector<pair<int, int> > &RepeatLimits) const;
 
        bool AddNodesToMesh(CMesh &Mesh) const;
 
        bool AddPathToMesh(CMesh &Mesh) const;
 
 
        bool AddSurfaceToMesh(CMesh &Mesh, bool bAddEndCaps = true) const;
 
 
        bool AddSurfaceToMesh(CMesh &Mesh, const vector<pair<int, int> > &RepeatLimits) const;
 
 
        bool AddSurfaceToMesh(CMesh &Mesh, const vector<XYZ> &TranslationVectors, bool bAddEndCaps = true) const;
 
 
        bool AddSurfaceToMesh(CMesh &Mesh, const CDomain &Domain, bool bAddEndCaps = true, bool bFillGaps = true) const;
 
 
        bool AddSurfaceToMesh( CMesh &Mesh, const CDomain &Domain, vector<CMesh> &DomainMeshes ) const;
 
 
        bool AddVolumeToMesh(CMesh &Mesh) const;
 
 
        bool AddVolumeToMesh(CMesh &Mesh, const vector<pair<int, int> > &RepeatLimits) const;
 
 
        bool AddVolumeToMesh(CMesh &Mesh, const vector<XYZ> &TranslationVectors) const;
 
 
        bool AddVolumeToMesh(CMesh &Mesh, const CDomain &Domain) const;
 
 
        bool AddCentrePlaneToMesh(CMesh &Mesh) const;
 
 
        bool AddCentrePlaneToMesh(CMesh &Mesh, const vector<XYZ> &TranslationVectors) const;
 
 
        bool AddCentrePlaneToMesh(CMesh &Mesh, const CDomain &Domain) const;
 
        void AddRepeat(XYZ Repeat);
 
        void ClearRepeats();
 
        void SetRepeats(const vector<XYZ> &Repeats);
 
 
        bool RepeatMatchesEnds(XYZ Repeat) const;
 
        void ClearMasterNodeOrientations();
 
 
        bool PointInsideYarn( const XYZ &Point, XYZ *pTangent = NULL, XY *pLoc = NULL, double *pVolumeFraction = NULL, double* pDistanceToSurface = NULL, double dTolerance = 1e-9, XYZ *pOrientation = NULL, XYZ *pUp = NULL, bool bSurface = false ) const;
 
 
        bool PointInsideYarn(const XYZ &Point, const vector<XYZ> &Translations, XYZ *pTangent = NULL, XY* pLoc = NULL, double* pVolumeFraction = NULL, double* pDistanceToSurface = NULL, double dTolerance = 1e-9, XYZ *pOrientation = NULL, XYZ *pUp = NULL, bool bSurface = false) const;
 
 
        bool FindPlaneContainingPoint( const XYZ &Point, double &u, double dTolerance, int iSeg) const;
 
 
        double FindClosestSurfacePoint(const XYZ &Point, XYZ &SurfacePoint, int iNumSectionPoints, double dTolerance = 1e-9);
 
 
        bool FindClosestSurfacePoint(const XYZ &Point, const vector<XYZ> &Translations, XYZ &SurfacePoint, int iNumSectionPoints, double dTolerance = 1e-9);
 
 
        void StraightenYarn(double dStraightness = 1);
 
        pair<XYZ, XYZ> GetAABB() const;
 
        pair<XYZ, XYZ> GetSectionAABB(int iIndex) const;
 
 
        double GetRawYarnLength() const;
 
 
        double GetRawYarnSectionLength(int iIndex) const;
 
 
        double GetRawYarnVolume() const;
 
 
        double GetRawRepeatArea() const;
 
        vector<double> GetYarnSectionLengths() const;
 
 
        const vector<CSlaveNode> &GetSlaveNodes(BUILD_TYPE Usage) const;
 
 
 
        double GetRealYarnLength(string Units = "m") const;
 
 
        double GetYarnLengthPerUnitArea(string Units = "/m") const;
 
 
        double GetRealYarnVolume(string Units = "m^3") const;
 
 
        double GetYarnVolumePerUnitArea(string Units = "m") const;
 
        double GetFibreVolume(string Units = "m^3") const;
 
        double GetFibreVolumePerUnitArea(string Units = "m") const;
 
        double GetFibreYarnVolumeFraction() const;
 
        int GetNumSectionPoints() const { return m_iNumSectionPoints; }
 
        int GetNumSlaveNodes() const { return m_iNumSlaveNodes; }
 
        bool ConvertToInterpNodes();
 
        // Accessor methods
        const vector<CNode> &GetMasterNodes() const { return m_MasterNodes; }
        const vector<XYZ> &GetRepeats() const { return m_Repeats; }
        const CYarnSection* GetYarnSection() const { return m_pYarnSection; }
        const CInterpolation* GetInterpolation() const { return m_pInterpolation; }
        const CFibreDistribution* GetFibreDistribution() const { return m_pFibreDistribution;}
        int GetNumNodes() const { return (int)m_MasterNodes.size(); }
        vector<double> GetSectionLengths() const { return m_SectionLengths; }
 
        CMesh::ELEMENT_TYPE GetMeshPoint( CMesh &Mesh, const XY &Point, int &Index ) const;
 
        //int GetMeshPoint( const XY &Point, int& Index );
 
    protected:
 
        bool BuildYarnIfNeeded(int iBuildType) const;
 
        bool BuildSlaveNodes() const;
        bool BuildSections() const;
        bool BuildSectionMeshes() const;
 
        void AddEndCapsToMesh(CMesh &Mesh) const;
 
        void CreateSectionAABBs() const;
 
        void SetParent(const CTextile *pParent);
 
        vector<CNode> m_MasterNodes;    
        CObjectContainer<CInterpolation> m_pInterpolation;  
        CObjectContainer<CYarnSection> m_pYarnSection;  
        CObjectContainer<CFibreDistribution> m_pFibreDistribution;  
 
        vector<XYZ> m_Repeats;  
        int m_iNumSlaveNodes;   
        int m_iNumSectionPoints;    
        bool m_bEquiSpacedSectionMesh;  
 
        double FindClosestEdgeDistance( XY &Loc, const vector<XY> &SectionPoints, double dTolerance ) const;
 
        mutable int m_iNeedsBuilding;   
        mutable vector<CSlaveNode> m_SlaveNodes;    
 
 
        mutable pair<XYZ, XYZ> m_AABB;
 
 
        mutable vector<pair<XYZ, XYZ> > m_SectionAABBs;
 
 
        mutable vector<double> m_SectionLengths;
 
 
        // Copy constructer for the yarn may be needed which sets this value to
        // NULL on the copied yarn
        CWeakPointer<const CTextile> m_pParent;
//      CTextile* m_pParent;
 
    private:
        void AssignDefaults();
    };
 
 
};  // namespace TexGen