DrawPageParameterDefine.h

浏览该文件的文档.

/************************************************************************
* @file DrawPageParameterDefine.h
*
* @brief 图纸相关参数结构
*
* @details 
*
* @author
*
* @version 1.0
*
* @date 2025-6-23
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef TECHDRAW_APP_DRAWPAGEPARAMETERDEFINE_H
#define TECHDRAW_APP_DRAWPAGEPARAMETERDEFINE_H
 
#include "BHGlobal.h"
#include <vector>
#include <map>
#include "Base/Vector3D.h"
 
namespace TechDraw
{
    // 图纸可设置比例
    const int StandarScale[] = { 1,2,5,10,20,25,50,100,200,500 };
 
    // 对应的比例属性下拉列表
    static const char* ViewScaleTypeEnums[] = { "1", "2", "5","10","20", "25", "50", "100","200","500", nullptr };
 
    // 纸张幅面规格尺寸
    const int DrawingStandar[9][2] = { 841, 1189, 594, 841, 420, 594, 297, 420, 210, 297, 148, 210, 105, 148, 74, 105, 52, 74 };
 
    // 半径/直径标注的圆数据结构
    struct TechDrawExport CircleInfo
    {
        CircleInfo() {
            r = 0.0;
        }
        float r;
        Base::Vector3d centerPt;
 
        bool isEquality(const CircleInfo data) {
            if (abs(r - data.r) < FLT_EPSILON &&
                abs(centerPt.x - data.centerPt.x) < FLT_EPSILON &&
                abs(centerPt.y - data.centerPt.y) < FLT_EPSILON &&
                abs(centerPt.z - data.centerPt.z) < FLT_EPSILON)
                return true;
            return false;
        }
    };
    struct Point {
        float x;
        float y;
 
        Point(float x = 0, float y = 0) : x(x), y(y) {}
 
        Point operator+(const Point& other) const {
            return Point(x + other.x, y + other.y);
        }
        Point operator*(const float& d) const {
            return Point(x * d, y * d);
        }
        Point operator/(const float& d) const {
            return Point(x / d, y / d);
        }
        Point operator-(const Point& pot) const {
            return Point(x - pot.x, y - pot.y);
        }
        void set(float xx, float yy) {
            x = xx;
            y = yy;
        }
 
        bool isEquality(const Point pot) {
            if (abs(pot.x - x) < 1.0e-10 &&
                abs(pot.y - y) < 1.0e-10)
                return true;
            return false;
        }
 
        // 单位化
        Point normalizeVector() {
            double length = std::sqrt(x * x + y * y);
            if (length > 0) {
                return Point(x / length, y / length);
            }
            else {
                return Point(0, 0);
            }
        }
        // 沿着p1到p2点形成的线段，计算线上点（x，y）为d的点坐标
        Point moveAlongLine(Point p1, Point p2, float d) {
            double dx = p2.x - p1.x;
            double dy = p2.y - p1.y;
            double L = std::sqrt(std::pow(p2.x - p1.x, 2) + std::pow(p2.y - p1.y, 2));
            double unit_dx = dx / L;
            double unit_dy = dy / L;
            double xNew = x + unit_dx * d;
            double yNew = y + unit_dy * d;
 
            return Point(xNew, yNew);
        }
 
        // (x, y)沿着法线方向移动距离d后的点  
        TechDraw::Point movePointAlongNormal(const TechDraw::Point& dir, const float d) {
            return TechDraw::Point(x, y) + dir * d;
        }
 
        // 计算pot0, pot1线上一点（x,y）沿着线的法线方向移动距离d的点（d的正负符合右手法则）
        TechDraw::Point alongLineNormalMoveDistance(const TechDraw::Point pot0, const TechDraw::Point pot1, float d) {
            TechDraw::Point dir = pot1 - pot0;
            TechDraw::Point normal = Point(dir.y, -dir.x);
            TechDraw::Point unitNormal = normal.normalizeVector();
            TechDraw::Point P(x, y);
            return P.movePointAlongNormal(unitNormal, d);
        }
 
        // 点P到AB的投影
        void perpendicularPointOnLine(Point& newP, const Point A, const Point B) {
            Point P(x, y);
            Point AB = B - A;
            Point AP = P - A;
 
            // 计算向量AB的单位向量  
            Point AB_unit = AB.normalizeVector();
 
            // 计算点P到线段AB的垂足向量（即投影向量）  
            double dotProduct = AP.x * AB_unit.x + AP.y * AB_unit.y;
            Point projection_vector = Point(dotProduct * AB_unit.x, dotProduct * AB_unit.y);
 
            // 计算投影点P'的坐标  
            newP.set(A.x + projection_vector.x, A.y + projection_vector.y);
        }
    };
 
 
    struct Interval {
        double start;
        double end;
 
        Interval(double p, double s) : start(p), end(s) {}
        void set(double p, double s) {
            start = p;
            end = s;
        }
        void setStart(double p) {
            start = p;
        }
 
        void setEnd(double p) {
            end = p;
        }
    };
    static bool compareSection(const TechDraw::Interval& a, const TechDraw::Interval& b);
    // 计算多个区间的交集  
    bool TechDrawExport findIntervalsIntersection(std::vector<TechDraw::Interval> intervals, TechDraw::Interval& interval);
 
    struct DimensionData
    {
        Base::Vector3d sDimStartPotOffset;
        Base::Vector3d sDimEntityOffset;
        double sD;
        double sDimStartPos;
        DimensionData() {
            sDimStartPotOffset.Set(0, 0, 0);
            sDimEntityOffset.Set(0, 0, 0);
            sD = 0;
            sDimStartPos = 0;
        }
    };
 
    enum PlateIndex
    {
        LeftPlate = 0,
        RightPlate,
        TopPlate,
        BottomPlate,
    };
 
    struct DimensionLevel
    {
        int sWellLevel;
        int sEmbedmentLevel;
        int sPitLevel;
        int sTubeHoleLevel;
        int sCoverLevel;
 
        DimensionLevel() {
            sWellLevel = 1;
            sEmbedmentLevel = -1;
            sPitLevel = -1;
            sTubeHoleLevel = -1;
            sCoverLevel = -1;
        }
        bool isOver() const {
            return (sWellLevel != -1 && sEmbedmentLevel != -1 && sPitLevel != -1 && sTubeHoleLevel != -1) || sCoverLevel != -1;
        }
        bool isOver1() const {
            return sWellLevel != -1 && sEmbedmentLevel != -1 && sPitLevel != -1 && sTubeHoleLevel != -1 && sCoverLevel != -1;
        }
    };
 
    struct Boundary
    {
        double sLeft;
        double sTop;
        double sRight;
        double sBottom;
 
        Boundary() {
            sLeft = 0.0;
            sTop = 0.0;
            sRight = 0.0;
            sBottom = 0.0;
        }
    };
    typedef std::map<PlateIndex, DimensionLevel> DimLevel;
 
    enum TechDrawExport OffsetType
    {
        LEFT_BOTTOM,              // 左下为原点
        LEFT_TOP,                 // 左上
        RIGHT_TOP,                // 右上
        RIGHT_BOTTOM,             // 右下
        CENTERPT,                   // 中心
    };
 
}
 
#endif // TECHDRAW_APP_DRAWPAGEPARAMETERDEFINE_H