Setting.h

浏览该文件的文档.

/************************************************************************
* @file Setting.h
*
* @brief Setting命名空间
*
* @details Setting命名空间
*
* @author zhaojuan
*
* @version 版本号  V0.1
*
* @date 2023-2-9
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef TECHDRAW_SETTING_H
#define TECHDRAW_SETTING_H
 
#include <libdrfx/drw_base.h>
#include <QString>
#include <Base/Tools2D.h>
#include "DxfVector.h"
#include "Base/BallonText.h"
namespace Part {
    class Geometry;
}
namespace TechDraw {
    class DxfAttribute;
    class DxfEntity;
    class DxfBlock;
    class DxfMText;
    class DxfText;
    class DxfLine;
    class DxfPolyline;
    class DxfCircle;
    class DxfArc;
    class DxfDimRadial;
    class DxfDimDiametric;
    class DxfEllipse;
    class DxfLeader;
    class DxfHatch;
    class DxfEntityContainer;
    class DxfInsert;
    class DxfSpline;
    constexpr double m_piX2 = M_PI * 2;
 
    enum class TechDrawExport CrosshairType {
        LeftCrosshair,         
        TopCrosshair,         
        RightCrosshair,         
        OrthogonalCrosshair         
    };
 
    enum class TechDrawExport DxfExportType {
        DXF2004,
        DXF2000
    };
    enum class TechDrawExport DwgExportType {
        DWG2008,
        DWG2004,
        DWG2000
    };
 
    enum class TechDrawExport VAlign {
        VABaseLine = 0,  
        VABottom,        
        VAMiddle,        
        VATop            
    };
 
    enum class TechDrawExport HAlign {
        HALeft,     
        HACenter,   
        HARight,     
        HAAligned,  
        HAMiddle,   
        HAFit       
    };
 
    enum class TechDrawExport TextGeneration {
        None,      
        Backward,  
        UpsideDown 
    };
 
    enum class TechDrawExport MTextDrawingDirection {
        LeftToRight,     
        TopToBottom,     
        ByStyle          
    };
 
    enum  class TechDrawExport MTextLineSpacingStyle {
        AtLeast,        
        Exact           
    };
 
    enum class TechDrawExport LineType {
        LINE,
        DIMENSIONLINE,
        EXTENSIONLINE,
    };
 
 
    enum class TechDrawExport LeaderCreateType {
        TEXT_ANNOTATION,
        TOLERANCE_ANNOTATION,
        BLOCK_ANNOTATION,
        LEADER_NONE,
    };
    enum TechDrawExport Unit {
        None = 0,               
        Inch = 1,               
        Foot = 2,               
        Mile = 3,               
        Millimeter = 4,         
        Centimeter = 5,         
        Meter = 6,              
        Kilometer = 7,          
        Microinch = 8,          
        Mil = 9,                
        Yard = 10,              
        Angstrom = 11,          
        Nanometer = 12,         
        Micron = 13,            
        Decimeter = 14,         
        Decameter = 15,         
        Hectometer = 16,        
        Gigameter = 17,         
        Astro = 18,             
        Lightyear = 19,         
        Parsec = 20,            
        LastUnit = 21           
    };
 
    enum TechDrawExport LinearFormat {
        Scientific,
        Decimal,
        Engineering,
        Architectural,
        Fractional,
        ArchitecturalMetric
    };
 
    enum TechDrawExport AngleUnit {
        Deg,               
        Rad,               
        Gra                
    };
 
    enum TechDrawExport AngleFormat {
        DegreesDecimal,
        DegreesMinutesSeconds,
        Gradians,
        Radians,
        Surveyors
    };
 
    enum TechDrawExport HatchPat {
        NONEPAT = -1,
        SOLID,
        ANGLE,
        ANSI31,
        ANSI37,
        AR_B816,
        AR_B816C,
        AR_B88,
        AR_BRELM,
        AR_BRSTD,
        AR_CONC,
        AR_HBONE,
        AR_PARQ1,
        AR_RROOF,
        ARMORED,
        JIS_WOOD,
        AR_RSHKE,
        AR_SAND,
        BOX,
        BRASS,
        BRICK,
        CLAY,
        CLAY1,
        CORK,
        CROSS,
        DASH,
        DOLMIT,
        DOTS,
        EARTH,
        ESCHER,
        FLEX,
        GOST_GLASS,
        GOST_WOOD,
        GOST_GROUND,
        GRASS,
        GRATE,
        GRAVEL,
        HEX,
        HONEY,
        HOUND,
        INSUL,
        JIS_LC_20,
        JIS_LC_20A,
        JIS_LC_8,
        JIS_LC_8A,
        JIS_RC_10,
        JIS_RC_15,
        JIS_RC_18,
        JIS_RC_30,
        JIS_STN_1E,
        JIS_STN_25,
        LINE,
        MUDST,
        NET,
        NET3,
        PLAST,
        PLASTI,
        SACNCR,
        SQUARE,
        STARS,
        STEEL,
        SWAMP,
        TRANS,
        TRIANG,
        ZIGZAG
    };
 
    enum class Side {
        NoSide = 0,
        LeftHand = 1,
        RightHand = 2,
        BothSides = 3
    };
 
 
    class TechDrawExport Calculator {
    public:
        static std::string replace(std::string str, const std::string& from, const std::string& to);
        static double correctAngle(double a);
        static double correctAngleU(double a);
        static double getAngleDifferenceU(double a1, double a2);
        static double getAngleDifference(double a1, double a2, bool reversed = false);
        static double getAngleDifference180(double a1, double a2);
        static double getAngleLength(double a, double b, double isReversed);
        static bool isAngleBetween(double a, double a1, double a2, bool reversed);
        static double deg2rad(double a);
 
        static double rad2deg(double a);
 
        static double rad2gra(double a);
 
        static double gra2rad(double a);
 
        static std::vector<double> quadraticSolver(const std::vector<double>& ce);
 
        static std::vector<double> cubicSolver(const std::vector<double>& ce);
 
        static std::vector<double> quarticSolver(const std::vector<double>& ce);
 
        static int round(double v);
 
        static unsigned findGCD(unsigned a, unsigned b);
 
        static bool isAngleReadable(double angle);
 
        static double makeAngleReadable(double angle, bool readable = true,
            bool* corrected = nullptr);
 
        static QString decode(const QString& str);
 
        static bool getNearestPointOnEntity(TechDraw::DxfVector& ret,
            const TechDraw::DxfVector& point1,
            const TechDraw::DxfVector& point2,
            const TechDraw::DxfVector& coord,
            bool onEntity = true,
            double* dist = NULL);
 
        static bool isEllipticArc(double angle1, double angle2);
 
        static double getNormalizedAngle(double a);
 
        static bool fuzzyCompare(double v1, double v2, double tolerance = RS_ANGLETOLERANCE);
 
        static bool isNaN(double v);
 
        static bool isInf(double v);
 
        static int absmod(int a, int b);
 
        static double trunc(double v);
 
        static bool isSane(double v);
 
        static double pow(double x, double y);
 
        static bool GetUtf8CharCount(const std::string& str, int& count);
 
        static int GetUtf8CharCount(const std::string& str);
 
        static void getText(const std::string& s, std::string& english, std::string& chinese);
 
        // 根据传入的字体和字体高度，计算真实字体宽度
        static void getFontWidthAndHeight(double heightInDxf,
            const QString& fontFamily,
            const std::string& str,
            double& fontWidth,
            double& fontHeight,
            double coefficient = 1.0);
    };
 
    class TechDrawExport LineRenderer {
    public:
        static LinearFormat getLinearFormat(int f);
        static QString formatLinear(double length,
            Unit unit,
            LinearFormat format,
            int prec,
            bool showUnit = false);
        static QString formatScientific(double length,
            Unit unit,
            int prec,
            bool showUnit = false);
        static QString formatDecimal(double length,
            Unit unit,
            int prec,
            bool showUnit = false);
        static QString formatEngineering(double length, int prec);
        static QString formatArchitectural(double length, int prec, bool showUnit = false);
        static QString formatFractional(double length, int prec);
        static QString formatArchitecturalMetric(double length,
            Unit unit,
            int prec,
            bool showUnit = false);
        static std::string unitToSign(Unit u);
        static AngleFormat numberToAngleFormat(int num);
        static QString formatAngle(double angle,
            AngleFormat format,
            int prec);
 
        static Qt::PenStyle nameToLineType(const std::string& name);
        static int numberToWidth(DRW_LW_Conv::lineWidth lw);
 
    };
 
    class TechDrawExport EntityFactory {
    public:
        static DxfMText* createMText(const std::string& text,
            DxfVector position,
            double height,
            double angle,
            int widthscale = 1.0,
            std::string style = "HKR",
            std::string font = "simsunb",
            double xScale = 1.0,
            double yScale = 1.0);
        static DxfText* createText(const std::string& text,
            DxfVector position1,
            DxfVector position2,
            double height,
            double angle,
            int widthscale = 1.0,
            std::string style = "HKR",
            std::string font = "simsunb",
            double xScale = 1.0,
            double yScale = 1.0,
            bool codeTrans = true
        );
        static DxfLine* createLine(DxfVector position1,
            DxfVector position2,
            double lineWidth = 1.0,
            double xScale = 1.0,
            double yScale = 1.0);
        static DxfPolyline* createPolyline(const std::vector< std::pair<DxfVector, double> >& positionList,
            bool closed,
            double lineWidth = 1.0,
            double xScale = 1.0,
            double yScale = 1.0);
 
        //接口，通过解析std::vector<DxfEntity*>来创建Polyline
        static DxfPolyline* createPolylineforEntity(std::vector<DxfEntity*> entities, bool closed, double lineWidth = 1.0);
 
        static DxfSpline* createSpline(
            const std::vector<DxfVector>& controlPoints,
            const std::vector<double>& knotsLists,
            int degree,
            bool closed);
 
        static DxfBlock* createBlock(const std::string name, 
            const DxfVector& insertPt,
            const std::vector<DxfEntity*>& entities);
 
        static DxfInsert* createInsert(const std::string name,
            const DxfVector& insertPt,
            double angle);
        static DxfCircle* createCircle(DxfVector center,
            double radius,
            double xScale = 1.0,
            double yScale = 1.0);
        static DxfArc* createArc(const DxfVector& center,
            double radius,
            double angle1,
            double angle2,
            bool reversed,
            double xScale = 1.0,
            double yScale = 1.0);
        static DxfDimRadial* createDimRadius(const DxfVector& center,
            const DxfVector& textLoca,
            const DxfVector& radiusLoca,
            const std::string& text,
            std::string style = "HKR",
            std::string font = "simsunb",
            double angleDim = 0.0,
            double leader = 0,
            double xScale = 1.0,
            double yScale = 1.0,
            int textcolor = 0,
            int horizonColor = 0,
            int verticalColor = 0);
        static DxfDimDiametric* createDimDiametric(const DxfVector& defLoca,
            const DxfVector& textLoca,
            const DxfVector& diametricLoca,
            const std::string& text,
            std::string style = "HKR",
            std::string font = "simsunb",
            double angleDim = 0.0,
            double leader = 0,
            double xScale = 1.0,
            double yScale = 1.0,
            int textcolor = 0,
            int horizonColor = 0,
            int verticalColor = 0);
        static DxfEllipse* createEllipse(const DxfVector& center,
            const DxfVector& major,
            double ratio,
            double angle1,
            double angle2,
            bool reversed,
            double xScale = 1.0,
            double yScale = 1.0);
        static DxfLeader* createLeader(double textWidth,
            double textHeight,
            int arrowStyle,
            int lineColor,
            const std::vector<TechDraw::DxfVector>& pointVec);
        static DxfHatch* createHatch(bool bSolid,
            const std::vector < std::vector<TechDraw::DxfEntity*> >& sectionFaces,
            HatchPat patFileInfo = HatchPat::SOLID,
            bool isShowEdgeLine = false,
            DxfVector centerPoint = DxfVector(0, 0, 0),
            double xScale = 1.0,
            double yScale = 1.0);
        static std::vector<std::vector<TechDraw::DxfEntity*> > getHatchChildEntities(DxfHatch* hatch);
        static void setEntityAttribute(DxfEntity* entity, const DxfAttribute& attr);
        static std::string getPatFileNameFromPat(HatchPat patNum);
        static HatchPat getPatFromPatFileName(std::string patFileName);
        static void getPartNames(std::vector<std::string>& patNames);
 
        // 
        static bool isSamePoint(const DxfVector& v1, const DxfVector& v2, double tol = 1e-6);
 
 
        /*****************************************************************
         * @brief       Part::Geometry转换为DxfEntity
         * @details
         * @param[in]   geometry    线对象
         * @return      DxfEntity对象
         ****************************************************************/
        static TechDraw::DxfEntity* convertGeometryToDxfEntity(const Part::Geometry* geometry);
 
    };
 
    class FileOperator {
    public:
        static QStringList getFilesInDir(const QString& dirPath);
    };
 
}
 
#endif // !TECHDRAW_SETTING_H