Textile3DWeave.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 "Textile.h"
#include "DomainPlanes.h"
#include "SectionPowerEllipse.h"
#include "PatternDraft.h"
 
 
namespace TexGen
{ 
    using namespace std;
 
    class CPatternDraft;
 
    enum
    {
        PATTERN3D_YYARN,
        PATTERN3D_XYARN,
        PATTERN3D_NOYARN
    };
 
    enum
    {
        WARP,
        BINDER,
        WEFT
    };
 
    enum
    {
        BOTTOM_TO_TOP,
        TOP_TO_BOTTOM,
        ALTERNATE_WEFT_STACK
    };
 
    typedef int PATTERN3D;
 
    struct YARNDATA
    {
        double dWidth;
        double dHeight;
        double dSpacing;
        //int iFibresPerYarn;
        //double dFibreDiameter;
    };
 
    class CLASS_DECLSPEC CTextile3DWeave : public CTextile
    {
    public:
 
 
        CTextile3DWeave(int iNumXYarns, int iNumYYarns, double dXSpacing, double dYSpacing,
                            double dXHeight, double dYHeight, bool bRefine = false);
        CTextile3DWeave(TiXmlElement &Element);
        virtual ~CTextile3DWeave(void);
 
        virtual CTextile* Copy() const { return new CTextile3DWeave(*this); }
        virtual string GetType() const { return "CTextile3DWeave"; }
        virtual void PopulateTiXmlElement(TiXmlElement &Element, OUTPUT_TYPE OutputType);
 
 
        void SetThickness(double dThickness);
        void SetMaxVolFraction( double dVolFraction );
        void SetXYarnWidths(int iIndex, double dWidth);
        void SetYYarnWidths(int iIndex, double dWidth);
        void SetXYarnHeights(int iIndex, double dHeight);
        void SetYYarnHeights(int iIndex, double dHeight);
        void SetXYarnSpacings(int iIndex, double dSpacing);
        void SetYYarnSpacings(int iIndex, double dSpacing);
 
 
        double GetXYarnWidths(int iIndex) const;
        double GetYYarnWidths(int iIndex) const;
        double GetXYarnHeights(int iIndex) const;
        double GetYYarnHeights(int iIndex) const;
        double GetXYarnSpacings(int iIndex) const;
        double GetYYarnSpacings(int iIndex) const;
        double GetXYarnGapSize(int iIndex) const;
        double GetYYarnGapSize(int iIndex) const;
 
        void SetXYarnWidths(double dWidth);
        void SetYYarnWidths(double dWidth);
        void SetWarpYarnWidths( double dWidth );
        void SetBinderYarnWidths( double dWidth );
        void SetXYarnHeights(double dHeight);
        void SetYYarnHeights(double dHeight);
        void SetWarpYarnHeights( double dHeight );
        void SetBinderYarnHeights( double dHeight );
        void SetXYarnSpacings(double dSpacing);
        void SetYYarnSpacings(double dSpacing);
        void SetWarpYarnSpacings( double dWidth );
        void SetBinderYarnSpacings( double dWidth );
        void SetWeftYarnPower( double dPower ){ m_dWeftPower = dPower;}
        void SetWarpYarnPower( double dPower ){ m_dWarpPower = dPower;}
        void SetBinderYarnPower( double dPower ){ m_dBinderPower = dPower;}
 
 
        void SetYarnLinearDensity( int iYarnType, double dValue, string Units = "kg/m" );
 
 
        void SetFibreDensity(int iYarnType, double dValue, string Units = "kg/m^3" );
 
        void SetFibreArea(int iYarnType, double dValue, string Units = "m^2" );
 
        void SetFibresPerYarn( int iYarnType, int iNumFibres );
 
        void SetFibreDiameter( int iYarnType, double dValue, string Units = "m" );
 
        double GetFibreArea( int iYarnType, string Units );
 
        void SetYarnWidths(double dWidth);
        void SetYarnHeights(double dHeight);
        void SetYarnSpacings(double dSpacing);
 
 
        void AddYLayers(int x, int iNumberLayers);
        void AddXLayers(int y, int iNumberLayers);
        void AddYLayers(int iNumberLayers = 1);
        void AddXLayers(int iNumberLayers = 1);
        void AddXYarn(int y, PATTERN3D Pattern );
        void AddYYarn( int x, PATTERN3D Pattern );
        void AddWarpLayer();
        void AddBinderLayer();
        void AddNoYarnLayer();
        void DeleteYLayers(int x, int iNumberLayers);
        void DeleteXLayers(int y, int iNumberLayers);
        void DeleteYLayers(int iNumberLayers = 1);
        void DeleteXLayers(int iNumberLayers = 1);
        void SwapPosition(int x, int y, int iLevel1, int iLevel2);
 
        int GetNumYLayers(int x) const;
        int GetNumXLayers(int y) const;
        int GetMaxNumLayers() const;
        virtual int GetNumBinderLayers() const;
 
        void GetWarpYarnInfo( int& iNumBinderYarns, int& iNumWarpYarns, int& iBinderRatio, int& iWarpRatio, YARNDATA& AveWarp, YARNDATA& AveBinder ) const;
        
        bool IsBinderYarn( int index ) const;
        int GetXYarnIndex( int YarnInd );
        
        int FindNextCellIndex( int index ) const;
        int FindNextYCellIndex( int Starti, int j, int k ) const;
        int FindPrevYCellIndex( int Starti, int j, int k ) const;
 
        void SetWarpRatio( int iWarpRatio ); 
        void SetBinderRatio( int iBinderRatio ); 
        void SetBinderPattern();
        void SetBinderPattern( vector<bool> &BinderPattern );
 
        virtual void SetupLayers( int iNumWarpLayers, int iNumWeftLayers, int iNumBinderLayers = 1 );
 
        void SetGapSize(double dGapSize);
 
        void SetResolution(int iResolution);
 
        void AssignSectionMesh(const CSectionMesh &SectionMesh);
 
        CDomainPlanes GetDefaultDomain( bool bAddedDomainHeight = true );
 
 
        void AssignDefaultDomain( bool bAddedDomainHeight = true );
 
        void SetDomainZValues();
        virtual void FindMinMaxZ( double& dMinZ, double& dMaxZ );
 
        void CheckUpVectors( int WarpIndex, bool Yarn = PATTERN3D_XYARN, bool bYarnsIndex = false ) const;
 
        virtual string GetDefaultName() const;
 
        virtual void SetupWeftRow( vector<int>& Layers, vector<int>& Row, int NumWarps, int Weft );
 
        void ShapeWeftYarns() const;
 
        virtual void ConvertToPatternDraft( int iWeftOrder = BOTTOM_TO_TOP );
        bool NoYarnCell( vector<PATTERN3D> &Cell );
 
        // Accessor methods
        virtual double GetWidth() const;    
        double GetHeight() const;   
        int GetNumXYarns() const { return m_iNumXYarns; }
        int GetNumYYarns() const { return m_iNumYYarns; }
        double GetFabricThickness() const { return m_dFabricThickness; }
        double GetMaxVolFraction() const { return m_dMaxVolumeFraction; }
        double GetGapSize() const { return m_dGapSize; }
        double GetAverageYarnSpacing() const { return (GetWidth()+GetHeight())/(m_iNumXYarns+m_iNumYYarns); }
        double GetAverageYarnWidth() const;
        const vector<PATTERN3D> &GetCell(int x, int y) const;
        int GetResolution() const { return m_iResolution; }
        vector<CYarn*> GetXYarns(int iIndex);
        vector<CYarn*> GetYYarns(int iIndex);
        int GetYarnIndex(int x, int y, int z) const;
        double GetWarpPower() const { return m_dWarpPower; }
        double GetWeftPower() const { return m_dWeftPower; }
        double GetBinderPower() const { return m_dBinderPower; }
        bool GetRefine() const { return m_bRefine; }
        virtual double GetAverageWeftYarnSpacing() const { return GetWidth()/m_iNumYYarns; }
        double GetAverageWeftYarnWidth() const;
        double GetAverageWeftYarnHeight() const;
        vector<PATTERN3D> &GetCell(int x, int y);
        void SetWeftRepeat( bool WeftRepeat ) { m_bWeftRepeat = WeftRepeat; }
        CPatternDraft &GetPatternDraft() { return m_PatternDraft; }
 
        void CalculateReedDesign( string Filename );
 
    protected:
        bool Valid() const;
 
 
        virtual bool BuildTextile() const;
 
        //void CorrectInterference() const;
        //bool NeedsMidSection(int iYarn, int iSection) const;
 
        
 
        CSectionPowerEllipse* GetWeftCrossSection( int WeftYarnIndex ) const;
        CSection* GetCrossSection( int YarnIndex, int Node = -1 ) const;
        
        XYZ GetUpVector( XYZ CheckNodes[], bool bYarn ) const;
 
        void InsertBinderNode( CSectionPowerEllipse* YarnSection, double t, XYZ& WeftNode, int& CurrentNode, int BinderYarnIndex, double Offset, bool bInsert = true ) const;
 
 
        void InsertBinderNode( CSection* YarnSection, double t, XYZ& WeftNode, int& CurrentNode, int BinderYarnIndex, double Offset, bool bInsert = true ) const;
 
        void ReplaceLastNode( int BinderYarnIndex, XYZ& NewNode, XYZ& BinderNode ) const;
 
        bool AdjustPowerEllipseSectionWidth( double &HeightReduction, double &MaxWidth, double TargetArea, CSectionPowerEllipse* YarnSection ) const;
 
        void FindPowerEllipseSectionHeight( double& MaxHeight, double& TargetArea, CSectionPowerEllipse* YarnSection ) const;
 
        bool AdjustPowerEllipsePower( double &HeightReduction, double TargetArea, CSectionPowerEllipse* YarnSection, double MinPower ) const;
 
        void ReducePowerEllipseHeight( double& TargetArea, CSectionPowerEllipse* YarnSection ) const;
 
        void SetYarnProperties( CYarn& Yarn, int iType ) const;
 
        pair<int, int> GetCellCoordinates(int iIndex) const;
 
        int FindWeftHeight( const vector<PATTERN3D>& Cell ) const;
 
        int AddWeftNodes( int CurrentNode, int XNode, int i, int j ) const;
 
        void InsertWeftNode( CSection* YarnSection, double t, XYZ& WarpNode, int& CurrentNode, int WeftYarnIndex, double Offset, bool bInsert = true ) const;
 
        int FindWarpAboveIndex( const vector<PATTERN3D> &Cell, int iIndex ) const;
        int FindWarpBelowIndex( const vector<PATTERN3D> &Cell, int iIndex ) const;
 
        void RemoveCell( int x, int y);
        bool CheckCells() const;
 
        bool BinderYarns() const;
        
        CPatternDraft m_PatternDraft;
 
        int m_iNumXYarns, m_iNumYYarns;
        int m_iWarpRatio, m_iBinderRatio;
        vector<bool> m_BinderPattern;
        int m_iTotalXYarns;
        vector<vector<PATTERN3D> > m_Pattern;
        double m_dGapSize;
        double m_dFabricThickness;
        double m_dMaxVolumeFraction;
        int m_iResolution;
        CObjectContainer<CSectionMesh> m_pSectionMesh;
        mutable double m_dMinZ;
        mutable double m_dMaxZ;
        double m_dWarpPower, m_dWeftPower, m_dBinderPower;
        bool m_bRefine;
        CProperties m_Properties[3];
        bool m_bWeftRepeat;
 
        mutable vector<YARNDATA> m_XYarnData;
        mutable vector<YARNDATA> m_YYarnData;
        mutable vector<vector<int> > m_XYarns;
        mutable vector<vector<int> > m_YYarns;
    };
};  // namespace TexGen