DxfEntity.h

浏览该文件的文档.

/************************************************************************
* @file DxfEntity.h
*
* @brief DxfEntity类
*
* @details DxfEntity类
*
* @author zhaojuan
*
* @version 版本号  V0.1
*
* @date 2023-2-9
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef TECHDRAWAPP_DXF_DXFENTITY_H
#define TECHDRAWAPP_DXF_DXFENTITY_H
 
#include <libdrfx/drw_base.h>
 
#include "DxfVector.h"
 
class dxfW;
class DRW_Entity;
 
namespace TechDraw {
enum class CrosshairType;
enum class VAlign;
enum class HAlign;
enum class TextGeneration;
enum class MTextDrawingDirection;
enum class MTextLineSpacingStyle;
enum class LineType;
enum class LeaderCreateType;
enum HatchPat;
enum class TechDrawExport DxfEntityType {
    ARC, 
    BLOCK, 
    CIRCLE, 
    DIMALIGNED, 
    DIMANGULAR, 
    DIMDIAMETRIC, 
    DIMLINEAR, 
    DIMRADIAL, 
    ELLIPSE, 
    HATCH, 
    INSERT, 
    LEADER, 
    LINE, 
    MTEXT, 
    POLYLINE, 
    POINT, 
    SPLINE, 
    SOLID, 
    TEXT, 
    FACE3D, 
    VECTOR3D, 
};
 
class TechDrawExport DxfAttribute {
public:
    DxfAttribute();
    ~DxfAttribute();
public:
    std::string layerName = "0";
    int color = DRW::ColorByLayer;
    int realColor = -1;
    int color24 = -1;
    std::string lineType = "BYLAYER";
    enum DRW_LW_Conv::lineWidth lWeight = DRW_LW_Conv::widthByLayer;
    Qt::PenStyle qtLineType = Qt::SolidLine;
    double qtLineWidth = 1.0;
 
    // 填充比例
    double fileScale = 1.0;
};
 
class TechDrawExport DxfLType {
public:
    DxfLType(const std::string& name,
             const std::string& desc,
             int size,
             double length,
             const std::vector<DRW::LineTypeCombinedCode>& path);
    ~DxfLType();
public:
    const std::string& getName();
    const std::string& getDescription();
    int getSize() const;
    double getLength() const;
    const std::vector<DRW::LineTypeCombinedCode>& getPath();
private:
    std::string m_Name;
    std::string m_Description;
    int m_Size;
    double m_Length;
    std::vector<DRW::LineTypeCombinedCode> m_Path;
};
 
class TechDrawExport DxfLayer {
public:
    DxfLayer(const std::string& name,
          bool frozen,
          bool locked);
    ~DxfLayer();
    DxfLayer* clone();
    const std::string& getName();
    bool isFrozen() const;
    void freeze(bool freeze);
    bool isLocked() const;
    void lock(bool l);
    void setLineType(const std::string& lineType);
    const std::string& getLineType();
    void setColor(int c);
    int getColor() const;
    void setPlotF(bool p);
    bool getPlotF() const;
    void seLWeight(enum DRW_LW_Conv::lineWidth lw);
    DRW_LW_Conv::lineWidth getLWeight() const;
    void setColor24(int c24);
    int getColor24() const;
 
private:
    std::string m_Name;
    bool m_Frozen = false;
    bool m_Locked = false;
    std::string m_LineType = "CONTINUOUS";
    // default BYLAYER (256)
    int m_Color = 7;
    // default TRUE (plot yes)
    bool m_PlotF = true;
    // default BYDEFAULT (dxf -3, dwg 31)
    enum DRW_LW_Conv::lineWidth m_LWeight = DRW_LW_Conv::widthDefault;
    //default -1 not set
    int m_Color24 = -1;
};
 
class TechDrawExport DxfTextStyle {
public:
    DxfTextStyle(std::string name, 
                 double height,
                 double width,
                 double oblique,
                 int genFlag,
                 int flags,
                 double lastHeight,
                 std::string font,
                 std::string bigFont,
                 int fontFamily);
    ~DxfTextStyle();
public:
    std::string getName() const;
    double getHeight() const;
    double getWidthFactor() const;
    double getOblique() const;
    int GetGenFlag() const;
    double getLastHeight() const;
    std::string getFont() const;
    std::string getBigFont() const;
    int getFontFamily() const;
    void setWidthFactor(float factor);
    int getFlags() const;
private:
    std::string m_Name;
    double m_Height;          
    double m_WidthFactor;           
    double m_Oblique;         
    int m_GenFlag;            
    int m_flags;                
    double m_LastHeight;      
    UTF8STRING m_Font;        
    UTF8STRING m_BigFont;     
    int m_FontFamily;         
};
 
class TechDrawExport DxfDimStyle {
public:
    DxfDimStyle(const std::string& name);
    ~DxfDimStyle();
public:
    std::string getName() const;
    void setDimasz(double dimasz);
    double getDimasz() const;
    void setDimexo(double dimexo);
    double getDimexo() const;
    void setDimdli(double dimdli);
    double getDimdli() const;
    void setDimexe(double dimexe);
    double getDimexe() const;
    void setDimdle(double dimdle);
    double getDimdle() const;
    void setDimtih(int dimtih);
    int getDimtih() const;
    void setDimtoh(int dimtoh);
    int getDimtoh() const;
    void setDimtad(int dimtad);
    int getDimtad() const;
    void setDimzin(int dimzin);
    int getDimzin() const;
    void setDimtxt(double dimtxt);
    double getDimtxt() const;
    void setDimcen(double dimcen);
    double getDimcen() const;
    void setDimaltf(double dimaltf);
    double getDimaltf() const;
    void setDimlfac(double dimlfac);
    double getDimlfac() const;
    void setDimgap(double dimgap);
    double getDimgap() const;
    void setDimtofl(int dimtofl);
    int getDimtofl() const;
    void setDimtix(int dimtix);
    int getDimtix() const;
    void setDimclrt(int dimclrt);
    int getDimclrt() const;
    void setDimadec(int dimadec);
    int getDimadec() const;
    void setDimdec(int dimdec);
    int getDimdec() const;
    void setDimtdec(int dimtdec);
    int getDimtdec() const;
    void setDimalttd(int dimalttd);
    int getDimalttd() const;
    void setDimdsep(int dimdsep);
    int getDimdsep() const;
    void setDimtmove(int dimtmove);
    int getDimtmove() const;
    void setDimjust(int dimjust);
    int getDimjust() const;
    void setDimtzin(int dimtzin);
    int getDimtzin() const;
    void setDimtxsty(const std::string& txstyle);
    std::string getDimtxsty() const;
    void setDimblk(const std::string& dimblk);
    std::string getDimblk() const;
private:
    std::string m_Name;
    double m_Dimasz;
    double m_Dimexo;
    double m_Dimdli;
    double m_Dimexe;
    double m_Dimdle;
    int m_Dimtih;
    int m_Dimtoh;
    int m_Dimtad;
    int m_Dimzin;
    double m_Dimtxt;
    double m_Dimcen;
    double m_Dimaltf;
    double m_Dimlfac;
    double m_Dimgap;
    int m_Dimtofl;
    int m_Dimtix;
    int m_Dimclrt;
    int m_Dimadec;
    int m_Dimdec;
    int m_Dimtdec;
    int m_Dimalttd;
    int m_Dimdsep;
    int m_Dimtmove;
    int m_Dimjust;
    int m_Dimtzin;
    UTF8STRING m_Dimtxsty;
    UTF8STRING m_Dimblk;
};
 
class TechDrawExport DxfVPoint {
public:
    DxfVPoint();
    ~DxfVPoint();
public:
    void setGridOn(bool grid);
    bool getGridOn() const;
    void setWidth(double width);
    double getWidth() const;
    void setHeight(double height);
    double getHeight() const;
    void setIsometricGrid(int snapStyle);
    int getIsometricGrid() const;
    void setCrosshairType(CrosshairType type);
    CrosshairType getCrosshairType() const;
    void setCenter(const DxfVector& center);
    const DxfVector& getCenter();
    void setRatio(double factor);
    double getRatio() const;
private:
    bool m_GridOn;
    double m_Width;
    double m_Height;
    int m_SnapStyle;
    CrosshairType m_CrosshairType;
    DxfVector m_Center;
    double m_Ratio;
};
 
enum class DxfHeaderType {
    NONE,
    COOD,
    STRING,
    INT,
    DOUBLE,
};
 
class TechDrawExport DxfHeaderData {
public:
    DxfHeaderData();
    virtual ~DxfHeaderData();
    virtual DxfHeaderType getHeaderType() const;
};
 
template<typename T>
class TechDrawExport DxfHeaderDataImpl : public DxfHeaderData {
public:
    DxfHeaderDataImpl(
        enum class DxfHeaderType type)
        : m_Type(type) {
    }
 
    DxfHeaderDataImpl(const DxfHeaderDataImpl& data) {
        this->m_Type = data.m_Type;
        this->m_Key = data.m_Key;
        this->m_Value = data.m_Value;
        this->m_Code = data.m_Code;
    }
 
    void addVariable(const std::string& key, const T& value, int code) {
        m_Key = key;
        m_Value = value;
        m_Code = code;
    }
 
    ~DxfHeaderDataImpl() {
        //
    }
 
public:
    const std::string& getKey() {
        return m_Key;
    }
 
    const T& getValue() {
        return m_Value;
    }
 
    void setValue(const T& v) {
        m_Value = v;
    }
 
    int getCode() const {
        return m_Code;
    }
 
    DxfHeaderType getHeaderType() const override {
        return m_Type;
    }
 
private:
    std::string m_Key;
    T m_Value;
    int m_Code;
    enum class DxfHeaderType m_Type;
};
 
class TechDrawExport DxfHeader {
public:
    DxfHeader();
    ~DxfHeader();
    void addToHeader(const std::string& key, DxfHeaderData* data);
    bool getVector3d(const std::string& key, DxfVector& vec);
    bool getString(const std::string& key, std::string& var);
    bool getInt(const std::string& key, int& var);
    bool setInt(const std::string& key, int var);
    bool getDouble(const std::string& key, double& var);
    const std::map<std::string, DxfHeaderData*>& getHeaders();
private:
    std::map<std::string, DxfHeaderData* > m_HeaderDict;
};
 
class TechDrawExport DxfLayout {
public:
    DxfLayout(const std::string& name,
        const std::string& id);
    ~DxfLayout();
 
    //
    std::string getLayoutName();
    std::string getLayoutId();
public:
    std::string mLayoutName;
    std::string mId;
};
 
class TechDrawExport DxfEntity {
public:
    DxfEntity();
    virtual ~DxfEntity();
    virtual DxfEntity* clone() = 0;
public:
    virtual void calculateBorders();
    virtual DxfVector getStartPoint() const;
    virtual DxfVector getEndPoint() const;
    virtual DxfVector getMiddlePoint() const;
    virtual void move(const TechDraw::DxfVector& offset);
    virtual void rotate(const DxfVector& center, const double& angle);
    virtual void writeDxf(dxfW* writer);
public:
    void resetBorders();
    void setVersion(int version);
    void setAttribute(DRW_Entity& data);
    void setAttribute(const DxfAttribute& attr);
    DxfAttribute getAttribute() const;
    void setLayer(const std::string& name);
    void setLayer(DxfLayer* l);
    DxfEntityType getType() const;
    void setHeaderInfo(TechDraw::DxfHeader*);
    const TechDraw::DxfVector& getMinVector();
    const TechDraw::DxfVector& getMaxVector();
    const TechDraw::DxfVector& getSize();
    // 默认返回0，表示非圆弧段
    virtual double getBulge() const { return 0.0; } 
public:
    double getGeneralFactor() const;
    double getGeneralScale() const;
    double getExtensionLineExtension() const;
    double getExtensionLineOffset() const;
 
    bool getInsideHorizontalText() const;
 
    double getTextHeight() const;
 
    double getDimensionLineGap() const;
 
    double getArrowSize() const;
 
    double getTickSize() const;
    bool getFixedLengthOn() const;
 
    double getFixedLength() const;
 
    std::string getTextStyle();
 
    int getExtensionLineColor() const;
 
    int getExtensionLineWidth() const;
 
    int getDimensionLineColor() const;
 
    int getDimensionLineWidth() const;
 
    int getTextColor() const;
    long getEntityId() const;
    std::string getEntityUuid() const;
 
    void setEntityLayoutId(const std::string& id);
 
    std::string getEntityLayoutId() const;
 
protected:
    DxfAttribute m_Attribute;
    DxfEntityType m_Type;
    int m_Version;
    TechDraw::DxfVector m_MinV;
    TechDraw::DxfVector m_MaxV;
    TechDraw::DxfHeader* m_Header;
    //
    std::string m_EntityUuid;
    // code 330的值，筛选layout
    std::string m_EntityParentId;
    //
    long m_EntityId;
};
 
class TechDrawExport DxfEntityContainer : public DxfEntity {
public:
    DxfEntityContainer();
    virtual ~DxfEntityContainer();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    void cloneEntities(DxfEntityContainer* oldEntity, DxfEntityContainer* newEntity);
    const std::vector<DxfEntity*>& getEntities();
    void addEntity(DxfEntity* entity);
    void clear();
    std::vector<DxfEntity*>& getContainer();
    void addRectangle(const TechDraw::DxfVector& corner1, const TechDraw::DxfVector& corner2);
    void removeEntity(DxfEntity*);
    void removeAllEntities();
    void sortHatchLoop(std::vector<TechDraw::DxfEntityContainer*>& hatchVec);
    
protected:
    std::vector<DxfEntity*> m_EntityContainer;
};
 
class TechDrawExport DxfBlock : public DxfEntityContainer {
public:
    DxfBlock(const std::string& name,
          const DxfVector& iPt);
    ~DxfBlock();
public:
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
public:
    std::string getBlockName() const;
    void setBlockName(const std::string& blkName);
    void setBlockHandle(int handle);
    int getBlockHandle() const;
    const DxfVector& getInsertPoint();
    const DxfVector& getScale();
    double getAngle();
    bool isEndBock();
    void setIsEndBlock(bool isEndBlock);
    bool getIsInsert() const;
    void setIsInsert(bool isInsert);
private:
    std::string m_BlockName="";
    int m_BlockHandle;
    DxfVector m_InsertPoint;
    DxfVector m_Scale;
    double m_Angle = 0.0;
    bool m_IsEndBlock = false;
    bool m_IsInsert = false;
};
 
class TechDrawExport DxfInsert : public DxfEntityContainer {
public:
    DxfInsert(std::string name,
              const DxfVector& insertPt,
              const DxfVector& scaleF,
              double angle,
              int cols,
              int rows,
              const DxfVector& spacing,
              const std::vector<DxfBlock*>& blocks);
    ~DxfInsert();
public:
    virtual DxfEntity* clone() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void calculateBorders() override;
    virtual void writeDxf(dxfW* writer) override;
public:
    std::string getName() const;
    void setName(const std::string& name);
    const DxfVector& getInsertPoint();
    const DxfVector& getScaleFactor();
    double getAngle() const;
    int getCols() const;
    int getRows() const;
    const DxfVector& getSpacing();
    const std::vector<DxfBlock*>& getBlocks();
private:
    std::string m_Name;
    DxfVector m_InsertionPoint;
    DxfVector m_ScaleFactor;
    double m_Angle;
    int m_Cols, m_Rows;
    DxfVector m_Spacing;
    std::vector<DxfBlock*> m_BlockSource;
};
 
class TechDrawExport DxfPatternLine {
public:
    double angle;
    DxfVector offset;
    DxfVector basePoint;
    QList<double> dashes;
 
    bool hasDots() const;
    double getAngle() const {
        return angle;
    }
    DxfVector getOffset() const {
        return offset;
    }
    DxfVector getBasePoint() const {
        return basePoint;
    }
    QList<double> getDashes() const {
        return dashes;
    }
 
    void scale(double f);
};
 
class TechDrawExport DxfPattern {
public:
    DxfPattern();
    DxfPattern(const QString& name, const QString& description);
    ~DxfPattern();
    DxfPattern* clone();
 
    bool hasDots() const;
 
    void clear();
 
    void setFileName(const QString& fileName);
 
    QString getFileName() const;
 
    const QString getName() const;
 
    const QString getDescription() const;
 
    bool isLoaded() const;
 
    void load() const;
 
    QList<DxfPatternLine> getPatternLines() const;
 
    void addPatternLine(const DxfPatternLine& patternLine);
 
    void scale(double f);
 
private:
    QString m_FileName;
 
    QString m_Name;
 
    QString m_Description;
 
    QList<DxfPatternLine> m_PatternLines;
};
 
 
class TechDrawExport DxfHatch : public DxfEntityContainer {
public:
    DxfHatch(bool solid, double scale, double angle, int filltype, const std::string& pattern);
    ~DxfHatch();
public:
    virtual void calculateBorders() override;
    virtual DxfEntity* clone() override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    bool getSolid() const;
    double getScale() const;
    double getAngle() const;
    std::string getPatternName() const;
    void setPatternName(const std::string&);
    void setPatternPath(DxfPattern* pattern);
    void setHatchPat(HatchPat pat);
    HatchPat getHatchPat() const;
    void setShowEdgeLine(bool show);
    bool getShowEdgeLine();
    QList<DxfPatternLine> getPatternLines() const;
    //重新设置HatchLoop的所有实体
    void resetHatchEntities(
        const std::vector<TechDraw::DxfEntity*>& sectionFaces,
        double xScale = 1.0,
        double yScale = 1.0);
    //重新设置HatchLoop的所有实体
    void resetHatchLoopEntities(
        DxfEntityContainer* hatchLoop,
        const std::vector<TechDraw::DxfEntity*>& sectionFaces,
        double xScale = 1.0,
        double yScale = 1.0);
private:
    bool m_Solid;
    double m_Scale;
    double m_Angle;
    std::string m_PatternName;
    HatchPat m_HatchPat;
    DxfPattern* m_Pattern;
    bool m_ShowEdgeLine;
};
 
class TechDrawExport DxfPoint : public DxfEntity {
public:
    DxfPoint(const DxfVector& pt);
    ~DxfPoint();
    const DxfVector& getVector3d();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
private:
    DxfVector m_Point;
};
 
class TechDrawExport DxfLine : public DxfEntity {
public:
    DxfLine() = default;
    DxfLine(const DxfVector& spt, const DxfVector& ePt);
    virtual ~DxfLine();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual DxfVector getStartPoint() const override;
    virtual DxfVector getEndPoint() const override;
    virtual DxfVector getMiddlePoint() const override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    double getDirection1(void) const;
    double getDirection2(void) const;
    double getAngle1() const;
 
    double getAngle2() const;
    void setStartPoint(const TechDraw::DxfVector&);
    void setEndPoint(const TechDraw::DxfVector&);
 
    LineType getLineType() const;
 
    void setLineType(LineType type);
    //
    void setScale(double scale);
protected:
    DxfVector m_StartPoint;
    DxfVector m_EndPoint;
    LineType m_LineType;
    double m_Scale;
};
 
class TechDrawExport DxfRay : public DxfLine {
public:
    DxfRay() = default;
    DxfRay(const DxfVector& spt, const DxfVector& ePt);
    ~DxfRay();
    virtual DxfEntity* clone() override;
};
 
class TechDrawExport DxfXline : public DxfLine {
public:
    DxfXline() = default;
    DxfXline(const DxfVector& spt, const DxfVector& ePt);
    ~DxfXline();
    virtual DxfEntity* clone() override;
};
 
class TechDrawExport DxfDimension : public DxfEntityContainer {
public:
    DxfDimension();
    DxfDimension(const DxfVector& definitionPoint,
        const DxfVector& middleOfText,
        VAlign valign,
        HAlign halign,
        MTextLineSpacingStyle lineSpacingStyle,
        double lineSpacingFactor,
        const std::string& text,
        const std::string& font,
        const std::string& style,
        double angle,
        int textcolor=0,
        int horizonColor=0,
        int verticalColor=0);
    virtual ~DxfDimension();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    virtual void update(double xScale = 1.0, double yScale = 1.0);
    virtual void updateDimension(double xScale = 1.0, double yScale = 1.0, bool autoText = false);
    virtual std::string getMeasuredLabel() const;
public:
    QString stripZerosLinear(QString linear, int zeros) const;
    QString DxfDimension::stripZerosAngle(QString angle, int zeros) const;
    std::string getMeasuredLabel(double dist) const;
    const DxfVector& getDefinitionPoint();
    const DxfVector& getDefinitionPointComstom();
    DxfVector getMiddleOfText();
    DxfVector getMiddleOfTextIfAuto();
    VAlign getVAlign();
    HAlign getHAlign();
    MTextLineSpacingStyle getLineSpacingStyle();
    double getLineSpacingFactor();
    const std::string& getText();
    const std::string& getRealText();
    const std::string& getFont();
    const std::string& getStyle();
    double getAngle();
 
public:
    void updateCreateHorizontalTextDimensionLine(const TechDraw::DxfVector& p1,
        const TechDraw::DxfVector& p2,
        bool arrow1 = true,
        bool arrow2 = true,
        bool autoText = false);
    void updateCreateAlignedTextDimensionLine(const TechDraw::DxfVector& p1,
        const TechDraw::DxfVector& p2,
        bool arrow1 = true,
        bool arrow2 = true,
        double xScale = 1.0,
        double yScale = 1.0,
        bool autoText = false);
    void updateCreateDimensionLine(const TechDraw::DxfVector& p1,
        const TechDraw::DxfVector& p2,
        bool arrow1 = true,
        bool arrow2 = true,
        double xScale = 1.0,
        double yScale = 1.0,
        bool autoText = false);
public:
    std::vector<TechDraw::DxfVector>
        getIntersectionsLineContainer(const DxfLine* l,
            const DxfEntityContainer& c,
            bool infiniteLine = false);
    std::vector<TechDraw::DxfVector>
        getIntersection(DxfEntity const* e1,
            DxfEntity const* e2,
            bool onEntities = false);
    bool isDimension(TechDraw::DxfEntityType type);
    bool isPointInsideContour(const TechDraw::DxfVector& point,
        DxfEntityContainer* contour,
        bool* onContour = nullptr);
    bool isTangent();
    // 设置箭头样式
    void setDimensionArrowStyle(int arrowStyle);
    // 设置箭头大小
    void setDimensionArrowSize(double d);
    // 设置文字大小
    void setDimensionTextSize(double d);
    //
    void setDimensionHorizonColor(int c);
    //
    void setDimensionVerticalColor(int c);
    //
    void setDimensionTextColor(int c);
    // 设置箭头样式句柄
    void setDimensionArrowBlockHandle(const std::string& handle);
protected:
    DxfVector m_DefinitionPoint;
    DxfVector m_DefinitionPointCostom;
    DxfVector m_MiddleOfText;
    DxfVector m_MiddleOfTextIfAuto;
    VAlign m_Valign;
    HAlign m_Halign;
    MTextLineSpacingStyle m_LineSpacingStyle;
    double m_LineSpacingFactor;
    std::string m_Text;
    std::string m_RealText;
    std::string m_Font;
    std::string m_Style;
    double m_Angle;
    bool m_Tangent;
    int m_userPosition;
    // 箭头样式
    enum DRW_Dimension_Arrow::DimensionArrowType m_DimensionArrowStyle;
    int m_DimensionTextColor;
    int m_DimensionHorizonColor;
    int m_DimensionVerticalColor;
    double m_DimensionArrowSize;
    double m_DimensionTextSize;
    std::string m_DimensionArrowBlockHandle;
};
 
class TechDrawExport DxfDimAligned : public DxfDimension {
public:
    DxfDimAligned();
    DxfDimAligned(
        const DxfVector& definitionPoint,
        const DxfVector& middleOfText,
        VAlign valign,
        HAlign halign,
        MTextLineSpacingStyle lineSpacingStyle,
        double lineSpacingFactor,
        const std::string& text,
        const std::string& font,
        const std::string& style,
        double angleDim,
        const DxfVector& extensionPoint1,
        const DxfVector& extensionPoint2,
        int textcolor = 0,
        int horizonColor = 0,
        int verticalColor = 0);
    ~DxfDimAligned();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    virtual void updateDimension(double xScale = 1.0, double yScale = 1.0, bool autoText = false) override;
    virtual std::string getMeasuredLabel() const override;
public:
    DxfVector const& getExtensionPoint1() const;
 
    DxfVector const& getExtensionPoint2() const;
    void updateDimPoint();
private:
    DxfVector m_ExtensionPoint1;
    DxfVector m_ExtensionPoint2;
};
 
class TechDrawExport DxfDimAngular : public DxfDimension {
public:
    DxfDimAngular();
    DxfDimAngular(const DxfVector& definitionPoint,
                  const DxfVector& middleOfText,
                  VAlign valign,
                  HAlign halign,
                  MTextLineSpacingStyle lineSpacingStyle,
                  double lineSpacingFactor,
                  const std::string& text,
                  const std::string& font,
                  const std::string& style,
                  double angleDim,
                  const DxfVector& definitionPoint1,
                  const DxfVector& definitionPoint2,
                  const DxfVector& definitionPoint3,
                  const DxfVector& definitionPoint4,
                  int textcolor = 0,
                  int horizonColor = 0,
                  int verticalColor = 0);
    ~DxfDimAngular();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    virtual void update(double xScale = 1.0, double yScale = 1.0);
    virtual void updateDimension(double xScale = 1.0, double yScale = 1.0, bool autoText = false) override;
    virtual std::string getMeasuredLabel() const override;
public:
    const DxfVector& getDefinitionPoint1();
    const DxfVector& getDefinitionPoint2();
    const DxfVector& getDefinitionPoint3();
    const DxfVector& getDefinitionPoint4();
private:
    void calcDimension(void);
    void fixDimension(void);
    void extensionLine(const TechDraw::DxfVector& dimLineP1,
        const TechDraw::DxfVector& dimLineP2,
        const TechDraw::DxfVector& dimPoint,
        const TechDraw::DxfVector& dirStart,
        const TechDraw::DxfVector& dirEnd,
        const double _dimscale,
        const double _dimexo,
        const double _dimexe,
        const double _dimtxt,
        const double _dimgap,
        const double _arrowSize);
    void arrow(const TechDraw::DxfVector& point,
        const double angle,
        const double direction,
        const bool outsideArrows,
        const double _dimscale,
        const double _dimexo,
        const double _dimexe,
        const double _dimtxt,
        const double _dimgap,
        const double _arrowSize,
        double xScale = 1.0,
        double yScale = 1.0);
private:
    DxfVector m_DefinitionPoint1; 
    DxfVector m_DefinitionPoint2;
    DxfVector m_DefinitionPoint3;
    DxfVector m_DefinitionPoint4;
    TechDraw::DxfVector m_DimDir1s;
    TechDraw::DxfVector m_DimDir1e;
    TechDraw::DxfVector m_DimDir2s;
    TechDraw::DxfVector m_DimDir2e;
    TechDraw::DxfVector m_DimDirRad;
    DxfLine m_DimLine1;
    DxfLine m_DimLine2;
    double m_DimAngle;
    double m_DimRadius;
    double m_DimAngleL1;
    double m_DimAngleL2;
    TechDraw::DxfVector m_DimCenter;
};
 
class TechDrawExport DxfDimDiametric : public DxfDimension {
public:
    DxfDimDiametric();
    DxfDimDiametric(const DxfVector& definitionPoint,
                    const DxfVector& middleOfText,
                    VAlign valign,
                    HAlign halign,
                    MTextLineSpacingStyle lineSpacingStyle,
                    double lineSpacingFactor,
                    const std::string& text,
                    const std::string& font,
                    const std::string& style,
                    double angleDim,
                    const DxfVector& DiameterPoint,
                    double leader,
                    int textcolor = 0,
                    int horizonColor = 0,
                    int verticalColor = 0);
    ~DxfDimDiametric();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    virtual void updateDimension(double xScale = 1.0, double yScale = 1.0, bool autoText = false) override;
    virtual std::string getMeasuredLabel() const override;
public:
    const DxfVector& getDiameterPoint();
    double getLeader() const;
private:
    DxfVector m_DiameterPoint;
    double m_Leader;
};
 
class TechDrawExport DxfDimLinear : public DxfDimension {
public:
    DxfDimLinear();
    DxfDimLinear(const DxfVector& definitionPoint,
                 const DxfVector& middleOfText,
                 VAlign valign,
                 HAlign halign,
                 MTextLineSpacingStyle lineSpacingStyle,
                 double lineSpacingFactor,
                 const std::string& text,
                 const std::string& font,
                 const std::string& style,
                 double angleDim,
                 const DxfVector& extensionPoint1,
                 const DxfVector& extensionPoint2,
                 double angleDimLinear,
                 double oblique,
                 int textcolor = 0,
                 int horizonColor = 0,
                 int verticalColor = 0);
    ~DxfDimLinear();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    virtual void updateDimension(double xScale = 1.0, double yScale = 1.0, bool autoText = false) override;
    virtual std::string getMeasuredLabel() const override;
public:
    DxfVector getExtensionPoint1() const;
    DxfVector getExtensionPoint2() const;
    double getAngle() const;
    void setAngle(double a);
    double getOblique() const;
    void setOblique(double o);
private:
    DxfVector m_ExtensionPoint1;
    DxfVector m_ExtensionPoint2;
    double m_Angle;
    double m_Oblique;
};
 
class TechDrawExport DxfDimRadial : public DxfDimension {
public:
    DxfDimRadial();
    DxfDimRadial(const DxfVector& definitionPoint,
                 const DxfVector& middleOfText,
                 VAlign valign,
                 HAlign halign,
                 MTextLineSpacingStyle lineSpacingStyle,
                 double lineSpacingFactor,
                 const std::string& text,
                 const std::string& font,
                 const std::string& style,
                 double angleDim,
                 const DxfVector& radialPoint,
                 double leader,
                 int textcolor = 0,
                 int horizonColor = 0,
                 int verticalColor = 0);
    ~DxfDimRadial();
public:
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    virtual void updateDimension(double xScale = 1.0, double yScale = 1.0, bool autoText = false) override;
    virtual std::string getMeasuredLabel() const override;
public:
    const DxfVector& getRadialPoint();
    double getLeader() const;
private:
    DxfVector m_RadialPoint;
    double m_Leader;
};
 
class TechDrawExport DxfLeader : public DxfEntity {
public:
    DxfLeader();
    ~DxfLeader();
public:
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    void setStyle(const std::string& style);
    std::string getStyle() const;
    void setArrowFlag(int flag);
    int getArrowFlag() const;
    void setLeaderPathType(int type);
    int getLeaderPathType() const;
    void setLeaderCreateType(TechDraw::LeaderCreateType type);
    TechDraw::LeaderCreateType getLeaderCreateType() const;
    void setBaseLineDirection(int direction);
    int getBaseLineDirection() const;
    void setBaseLineFlag(int flag);
    int getBaseLineFlag() const;
    void setTextWidth(double width);
    double getTextWidth() const;
    void setTextHeight(double height);
    double getTextHeight() const;
    void setAnnotationId(const std::string& anno);
    std::string getAnnotationId() const;
    void setArrowBlockHandle(int handle);
    int getArrowBlockHandle() const;
    void setVerxs(const std::vector<TechDraw::DxfVector>& verx);
    const std::vector<TechDraw::DxfVector>& getVerxs();
public:
    void setArrowStyle(DRW_Dimension_Arrow::DimensionArrowType style);
    DRW_Dimension_Arrow::DimensionArrowType getArrowStyle();
    void setArrowSize(double size);
    double getArrowSize() const;
    void setLineColor(int color);
    int getLineColor() const;
private:
    std::string m_Style;
    int m_ArrowFlag;
    int m_LeaderPathType;
    TechDraw::LeaderCreateType m_LeaderCreateType;
    int m_BaseLineDirection;
    int m_BaseLineFlag;
    double m_TextWidth;
    double m_TextHeight;
    std::string m_AnnotationId;
    int m_ArrowBlockHandle;
    std::vector<TechDraw::DxfVector> m_Verx;
    // 箭头样式
    enum DRW_Dimension_Arrow::DimensionArrowType m_ArrowStyle;
    double m_ArrowSize;
    int m_LineColor;
};
 
class TechDrawExport DxfCircle : public DxfEntity {
public:
    DxfCircle(const DxfVector& center, double radius);
    ~DxfCircle();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    const DxfVector& getCenterPoint();
    void setCenterPoint(const DxfVector& c);
    double getRadius();
    void setRadius(double r);
private:
    DxfVector m_CenterPoint;
    double m_Radius;
};
 
class TechDrawExport DxfArc : public DxfEntity {
public:
    DxfArc(const DxfVector& center,
           double radius,
           double angle1,
           double angle2,
           bool reversed);
    ~DxfArc();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual DxfVector getStartPoint() const override;
    virtual DxfVector getEndPoint() const override;
    virtual DxfVector getMiddlePoint() const override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
 
 
    double bulge;
public:
    double getRadius() const;
    void setRadius(double r);
    double getAngle1() const;
    void setAngle1(double);
    double getAngle2() const;
    void setAngle2(double a);
    bool isReversed() const;
    double getAngleLength() const;
    double getBulge() const;
    double getDirection1() const;
    double getDirection2() const;
    /*
    * * @return 圆心
    */
    const TechDraw::DxfVector& getCenter();
    /*
    * * @return 弧长
    */
    void setCenter(const TechDraw::DxfVector&);
    /*
    * * @return 弧长
    */
    double getLength() const;
    void reverseAngle1AndAngle2();
    bool getAnticlockwise();
    void setAnticlockwise(bool anticlosewise);
 
private:
    DxfVector m_CenterPoint;
    double m_Radius;
    double m_MinRadius;
    double m_Angle1;
    double m_Angle2;
    bool m_Reversed;
    bool m_Anticlockwise;
};
 
class TechDrawExport DxfEllipse : public DxfEntity {
public:
    DxfEllipse(const DxfVector& center,
            const DxfVector& major,
            double ratio,
            double angle1,
            double angle2,
            bool reversed);
    ~DxfEllipse();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual DxfVector getStartPoint() const override;
    virtual DxfVector getEndPoint() const override;
    virtual DxfVector getMiddlePoint() const override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    TechDraw::DxfVector getCenter() const;
    void setCenter(const TechDraw::DxfVector&);
    const DxfVector& getMajorPoint();
    void setMajor(const TechDraw::DxfVector&);
    double getMajorRadius() const;
    double getMinorRadius() const;
    double getRatio() const;
    double getAngle1() const;
    double getAngle2() const;
    void setAngle1(double angle1);
    void setAngle2(double angle2);
    bool isReversed() const;
    bool isEllipticArc() const;
    bool isArc() const;
    //direction of tangent at endpoints
    double getDirection1() const;
    double getDirection2() const;
    double getAngle() const;
public:
    TechDraw::DxfVector getEllipsePoint(const double& a) const;
    double getEllipseAngle(const DxfVector& pos) const;
private:
    DxfVector getNearestMiddle(const DxfVector& coord,
                               double* dist = nullptr,
                               int middlePoints = 1) const;
    DxfVector getNearestPointOnEntity(const DxfVector& coord,
                                      bool onEntity = true,
                                      double* dist = nullptr,
                                      DxfEntity** entity = nullptr) const;
    DxfVector getNearestEndpoint(const DxfVector& coord,
                                 double* dist = nullptr) const;
public:
    double m_MajorAngle;
private:
    DxfVector m_CenterPoint;
    DxfVector m_MajorPoint;
    double m_Ratio;
    double m_Angle1;
    double m_Angle2;
    bool m_Reversed;
    double m_MajorRadius;
    double m_MinorRadius;
};
 
class TechDrawExport DxfPolyline : public DxfEntityContainer {
public:
    DxfPolyline(const DxfVector& startPt, const DxfVector& endPt, bool close, int num, double width);
    ~DxfPolyline();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual DxfVector getStartPoint() const override;
    virtual DxfVector getEndPoint() const override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    void appendVertexs(const std::vector<std::pair<DxfVector, double> >& vlist);
    DxfEntity* createVertex(int index);
    bool isClosed();
    int getVertexNum() const;
    double getNextBulge();
    double getLineWidth() const;
    void setLineWidth(double l);
    const std::vector<std::pair<DxfVector, double> >& getVertexList();
    void addToVertexList(const std::pair<DxfVector, double>&);
    void removeAllVertex();
    void setScale(double scale);
private:
    void writePolyline(dxfW* writer);
    void writeLWPolyline(dxfW* writer);
private:
    DxfVector m_StartPoint;
    DxfVector m_EndPoint;
    bool m_Closed;
    double m_NextBulge = 0.0;
    DxfEntity* m_ClosingEntity = nullptr;
    int m_VertexNum = 0;
    double m_LineWidth = 1.0;
    std::vector<std::pair<DxfVector, double> > m_VertexList;
    double m_Scale;
};
 
class TechDrawExport DxfSpline : public DxfEntityContainer {
public:
    DxfSpline() = default;
    DxfSpline(int degree, bool closed);
    ~DxfSpline();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    void addControlPoint(const DxfVector& v);
    void setControlPoints(const std::vector<DxfVector>& controlPt);
    const std::vector<DxfVector>& getControlPoints();
    void addToKnotsLists(double knot);
    void setKnots(const std::vector<double> konts);
    const std::vector<double>& getKnotsLists();
    bool isClosed();
    void setCloseStatus(bool status);
    size_t getDegree();
    void setDegree(size_t degree);
    int getControlPointSize();
    void setControlPointWeight(const std::vector<double>& valueVec);
    std::vector<double> getControlPointWeight();
private:
    size_t m_Degree;
    bool m_Closed;
    std::vector<DxfVector> m_ControlPoints;
    std::vector<double> m_KnotsLists;
    std::vector<double> m_Weights;
};
 
class TechDrawExport DxfText : public DxfEntity {
public:
    DxfText(const DxfVector& insertPt,
            const DxfVector& secondPt,
            double height,
            double widthRel,
            HAlign hAlign,
            VAlign vAlign,
            TextGeneration tg,
            const std::string& text,
            const std::string& font,
            const std::string& style,
            double angle);
    ~DxfText();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    const DxfVector& getInsertPoint();
    void setInsertpoint(const DxfVector&);
    const DxfVector& getSecondPoint();
    void setSectionPoint(const DxfVector&);
    double getHeight();
    void setHeight(double h);
    double getWidthFactor();
    void setWidthFactor(double factor);
    VAlign getVAlign();
    HAlign getHAlign();
    TextGeneration getTextGeneration();
    const std::string& getText();
    void setText(const std::string&);
    void setFont(const std::string&);
    const std::string& getFont();
    void setStyle(const std::string& style);
    const std::string& getStyle();
    double getAngle() const;
    void setAngle(double angle);
    void setScale(double scale);
    void setAmplify(const double times);
    double getAmplify() const;
private:
    DxfVector m_InsertPoint;
    DxfVector m_SecondPoint;
    double m_Height;
    double m_WidthFactor; //宽度因子
    VAlign m_VAlign;
    HAlign m_HAlign;
    TextGeneration m_TextGeneration;
    std::string m_Text;
    std::string m_Font;
    std::string m_Style;
    double m_Angle;
    double m_Scale;
    double m_HeightInDxf;
    double m_Amplify; // 计算BoundingBox使用
};
 
class TechDrawExport DxfMText : public DxfEntity {
public:
    DxfMText(const DxfVector& insertionPoint,
             double height,
             double width,
             VAlign valign,
             HAlign halign,
             MTextDrawingDirection drawingDirection,
             MTextLineSpacingStyle lineSpacingStyle,
             double lineSpacingFactor,
             const std::string& text,
             const std::string& font,
             const std::string& style,
             double angle);
    ~DxfMText();
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    TechDraw::DxfVector getInsertionPoint() const;
    void setInsectionPoint(const TechDraw::DxfVector& point);
    void setAngle(const double& angle);
    double getHeight();
    void setHeight(double h);
    //
    void setFont(const std::string fontFamily);
    double getWidth();
    //
    double getWidthFactor();
    void setWidthFactor(double factor);
 
    VAlign getVAlign();
    HAlign getHAlign();
    MTextDrawingDirection getMTextDrawingDirection();
    MTextLineSpacingStyle getMTextLineSpacingStyle();
    double getLineSpacingFactor();
    const std::string& getText();
    void setText(const std::string&);
    const std::string& getFont();
    //设置样式
    void setStyle(const std::string& style);
    const std::string& getStyle();
    double getAngle() const;
    double getUsedTextWidth() const;
    double getUsedTextHeight() const;
    bool getBold() const;
    bool getItalic() const;
    bool getDimension() const;
    bool getBackward() const;
    bool getUpsideDown() const;
    void setScale(double scale);
    //
    void setAmplify(const double times);
private:
    DxfVector m_InsertionPoint;
    double m_Height;
    double m_Width;
    TechDraw::VAlign m_VAlign;
    TechDraw::HAlign m_HAlign;
    TechDraw::MTextDrawingDirection m_MTextDrawingDirection;
    TechDraw::MTextLineSpacingStyle m_MTextLineSpacingStyle;
    double m_LineSpacingFactor;
    // 宽度因子
    double m_WidthFactor;
    std::string m_Text;
    std::string m_Style;
    std::string m_Font;
    double m_Angle;
    double m_UsedTextWidth;
    double m_UsedTextHeight;
    bool m_Bold;
    bool m_Italic;
    bool m_Dimension;
    bool m_Backward;
    bool m_UpsideDown;
    double m_Scale;
    double m_HeightInDxf;
    double m_Amplify;
};
 
class TechDrawExport DxfSolid : public DxfEntity {
public:
    DxfSolid();
    DxfSolid(const DxfVector& corner1,
             const DxfVector& corner2,
             const DxfVector& corner3);
    DxfSolid(const DxfVector& corner1,
             const DxfVector& corner2,
             const DxfVector& corner3,
             const DxfVector& corner4);
    ~DxfSolid();
public:
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
public:
    void setCorner(const std::vector<DxfVector>& corner);
    const std::vector<DxfVector>& getCorner();
public:
    void shapeArrow(const TechDraw::DxfVector& point,
                    double angle,
                    double arrowSize,
                    double xScale = 1.0,
                    double yScale = 1.0);
protected:
    std::vector<DxfVector> m_Corner;
};
 
class TechDrawExport Dxf3DFace : public DxfSolid {
public:
    Dxf3DFace();
    Dxf3DFace(const DxfVector& corner1,
              const DxfVector& corner2,
              const DxfVector& corner3);
    Dxf3DFace(const DxfVector& corner1,
              const DxfVector& corner2,
              const DxfVector& corner3,
              const DxfVector& corner4);
    ~Dxf3DFace();
public:
    virtual DxfEntity* clone() override;
    virtual void calculateBorders() override;
    virtual void move(const TechDraw::DxfVector& offset) override;
    virtual void rotate(const TechDraw::DxfVector& center, const double& angle) override;
    virtual void writeDxf(dxfW* writer) override;
};
 
}
 
#endif // !TECHDRAWAPP_DXF_DXFENTITY_H