CDxf.hpp

Go to the documentation of this file.

#ifndef LIBS_CAD_CDxf_HPP_
#define LIBS_CAD_CDxf_HPP_
 
#include "math/structs.hpp"
#include "streams/IInputStream.hpp"
 
#include <memory>
#include <string>
#include <vector>
 
class CGeoBlock;
class CMesh;
class CStackTransformation;
class IGraphics;
struct SEntity;
 
class IBlockExportDxf
{
public:
    virtual ~IBlockExportDxf() = default;
 
    [[maybe_unused]] virtual void setColorARgb(iv::types::color colorARgb) = 0;
};
 
struct SLayerDxf
{
    SLayerDxf(const std::string &nameLayer, bool isColorRGB, uint64_t colorIndex, bool isVisible, int64_t lineWidth);
    SLayerDxf(const SLayerDxf &other) = default;
    ~SLayerDxf() = default;
 
    std::string m_name;
    uint64_t m_colorIndex;
    bool m_isVisible;
    bool m_isColorRGB;
    int64_t m_lineWidth;
};
 
struct SProcessEntitiesGeoBlocks
{
    SProcessEntitiesGeoBlocks(CStackTransformation **stackTransformation, std::vector<CGeoBlock *> **geoBlocks);
    ~SProcessEntitiesGeoBlocks();
 
    bool exists(const std::string &itemSearch, uint32_t *ind) const;
 
    CStackTransformation *m_stackTransformation;
    std::vector<CGeoBlock *> *m_geoBlocks;
};
 
struct SProcessEntitiesPolylines
{
    SProcessEntitiesPolylines(CStackTransformation **stackTransformation,
                              std::vector<std::vector<iv::math::geometry::Point3d>> **polylines);
    ~SProcessEntitiesPolylines();
 
    std::vector<std::vector<iv::math::geometry::Point3d>> *movePolylines();
 
    CStackTransformation *m_stackTransformation;
    std::vector<std::vector<iv::math::geometry::Point3d>> *m_polylines;
};
 
struct SBlockDxf
{
    SBlockDxf(std::string nameBlock, double xOrg, double yOrg, double zOrg);
    SBlockDxf(const SBlockDxf &other);
    ~SBlockDxf() = default;
 
    std::string m_name;
    double m_xOrg;
    double m_yOrg;
    double m_zOrg;
    uint64_t m_idBlock;
    std::vector<SEntity *> m_entities;
};
 
struct SEntity
{
    SEntity(const std::string &nameLayer, bool isColorRGB, uint64_t colorIndex, int64_t lineWidth, double Nx, double Ny,
            double Nz);
    virtual ~SEntity() = default;
 
    void drawEntity(uint64_t colorBlocRGB, int64_t lineWidthBlock, std::vector<SBlockDxf *> *blocks,
                    const std::vector<SLayerDxf *> *layers, IGraphics *graphics);
    virtual void processEntityGeoBlock(CGeoBlock *currentGeoBlock, std::vector<SBlockDxf *> *blocks,
                                       SProcessEntitiesGeoBlocks *dataProcess) const = 0;
    virtual void processEntityPolyline(const std::vector<SBlockDxf *> *blocks, SProcessEntitiesPolylines *dataProcess,
                                       const std::string &nameLayerOpt) const = 0;
 
    void setColorARGB(iv::types::color colorARGB);
 
    [[nodiscard]] bool isLayer(const std::string &nameLayer) const;
 
private:
    virtual void draw(IGraphics *graphics) const = 0;
 
    uint64_t m_colorIndex;
    std::string m_nameLayer;
    bool m_isAttributedCalculated;
    bool m_isColorRGB;
    iv::types::color m_colorARGBCalculated;
    bool m_isVisibleByLayer;
    double m_Nx;
    double m_Ny;
    double m_Nz;
    int64_t m_lineWidth;
    bool m_hasLineWidthCalculated;
    int64_t m_lineWidthCalculated;
};
 
struct SEntityInsert final : SEntity
{
    SEntityInsert(const std::string &nameLayer, const std::string &nameBlock, double xInsert, double yInsert,
                  double xScale, double yScale, double angle, bool isColorRGB, uint64_t colorIndex, int64_t lineWidth,
                  double Nx, double Ny, double Nz);
    ~SEntityInsert() override = default;
 
    void drawBlock(uint64_t colorBlock, int64_t lineWidth, std::vector<SBlockDxf *> *blocks,
                   const std::vector<SLayerDxf *> *layers, IGraphics *graphics) const;
 
    std::string m_nameBlock;
    uint64_t m_colorIndex;
    double m_xInsert;
    double m_yInsert;
    double m_xScale;
    double m_yScale;
    double m_angle;
 
private:
    void processEntityGeoBlock(CGeoBlock *currentGeoBlock, std::vector<SBlockDxf *> *blocks,
                               SProcessEntitiesGeoBlocks *dataProcess) const override;
    void processEntityPolyline(const std::vector<SBlockDxf *> *blocks, SProcessEntitiesPolylines *dataProcess,
                               const std::string &nameLayerOpt) const override;
    void draw(IGraphics *graphics) const override;
};
 
struct SEntityPoint final : SEntity
{
    SEntityPoint(const std::string &nameLayer, double x, double y, double z, bool isColorRGB, uint64_t colorIndex,
                 int64_t lineWidth, double Nx, double Ny, double Nz);
 
    double m_x;
    double m_y;
    double m_z;
 
private:
    void draw(IGraphics *graphics) const override;
    void processEntityGeoBlock(CGeoBlock *currentGeoBlock, std::vector<SBlockDxf *> *blocks,
                               SProcessEntitiesGeoBlocks *dataProcess) const override;
    void processEntityPolyline(const std::vector<SBlockDxf *> *blocks, SProcessEntitiesPolylines *dataProcess,
                               const std::string &nameLayerOpt) const override;
};
 
struct SEntityLine final : SEntity
{
    SEntityLine(const std::string &nameLayer, double x1, double y1, double x2, double y2, bool isColorRGB,
                uint64_t colorIndex, int64_t lineWidth, double Nx, double Ny, double Nz);
 
    double m_x1;
    double m_x2;
    double m_y1;
    double m_y2;
 
private:
    void draw(IGraphics *graphics) const override;
    void processEntityGeoBlock(CGeoBlock *currentGeoBlock, std::vector<SBlockDxf *> *blocks,
                               SProcessEntitiesGeoBlocks *dataProcess) const override;
    void processEntityPolyline(const std::vector<SBlockDxf *> *blocks, SProcessEntitiesPolylines *dataProcess,
                               const std::string &nameLayerOpt) const override;
};
 
struct SEntityPolyline : SEntity
{
    SEntityPolyline(const std::string &nameLayer, float **vertex, uint64_t numVertex, bool isColorRGB,
                    uint64_t colorRGB, int64_t lineWidth, double Nx, double Ny, double Nz, double elevation);
    ~SEntityPolyline() override;
 
    uint64_t m_numVertex;
    float *m_vertex;
    double m_elevation;
 
private:
    void draw(IGraphics *graphics) const override;
    void processEntityGeoBlock(CGeoBlock *currentGeoBlock, std::vector<SBlockDxf *> *blocks,
                               SProcessEntitiesGeoBlocks *dataProcess) const override;
    void processEntityPolyline(const std::vector<SBlockDxf *> *blocks, SProcessEntitiesPolylines *dataProcess,
                               const std::string &nameLayerOpt) const override;
};
 
struct SEntityArc final : SEntityPolyline
{
    SEntityArc(const std::string &nameLayer, double xCenter, double yCenter, double radius, double startAngle,
               double endAngle, uint64_t numVertex, float **vertex, bool isColorRGB, uint64_t colorIndex,
               int64_t lineWidth, double Nx, double Ny, double Nz);
 
    double m_xCenter;
    double m_yCenter;
    double m_radius;
    double m_startAngle;
    double m_endAngle;
};
 
struct SEntityCircle final : SEntityPolyline
{
    SEntityCircle(const std::string &nameLayer, double xCenter, double yCenter, double radius, uint64_t numVertex,
                  float **vertex, bool isColorRGB, uint64_t colorIndex, int64_t lineWidth, double Nx, double Ny,
                  double Nz);
 
    double m_xCenter;
    double m_yCenter;
    double m_radius;
};
 
struct SEntityEllipse final : SEntityPolyline
{
    SEntityEllipse(const std::string &nameLayer, double xCenter, double yCenter, double mx, double my, double mz,
                   double ratio, double startAngle, double endAngle, uint64_t numVertex, float **vertex,
                   bool isColorRGB, uint64_t colorIndex, int64_t lineWidth, double Nx, double Ny, double Nz);
 
    double m_xCenter;
    double m_yCenter;
    double m_mx;
    double m_my;
    double m_mz;
    double m_ratio;
    double m_startAngle;
    double m_endAngle;
};
 
struct SEntityLeader final : SEntityPolyline
{
    SEntityLeader(const std::string &nameLayer, float **vertex, uint64_t numVertex, bool isColorRGB, uint64_t colorRGB,
                  int64_t lineWidth, double Nx, double Ny, double Nz);
};
 
struct SEntityHatch final : SEntity
{
    SEntityHatch(const std::string &nameLayer,
                 std::vector<std::shared_ptr<std::vector<iv::math::geometry::Point3d>>> **contoursHatch, CMesh **mesh,
                 bool isColorRGB, uint64_t colorRGB, int64_t lineWidth, double Nx, double Ny, double Nz);
    ~SEntityHatch() override;
 
    CMesh *m_mesh;
    std::vector<std::shared_ptr<std::vector<iv::math::geometry::Point3d>>> *m_contoursHatch;
 
private:
    void draw(IGraphics *graphics) const override;
    void processEntityGeoBlock(CGeoBlock *currentGeoBlock, std::vector<SBlockDxf *> *blocks,
                               SProcessEntitiesGeoBlocks *dataProcess) const override;
    void processEntityPolyline(const std::vector<SBlockDxf *> *blocks, SProcessEntitiesPolylines *dataProcess,
                               const std::string &nameLayerOpt) const override;
};
 
struct SEntityText final : SEntity
{
    SEntityText(const std::string &nameLayer, const std::string &text, double x, double y, double z, double height,
                unsigned char justify, double angle, uint64_t colorIndex, bool isColorRGB, int64_t lineWidth, double Nx,
                double Ny, double Nz);
    ~SEntityText() override = default;
 
    std::string m_text;
    double m_x;
    double m_y;
    double m_z;
    double m_height;
    unsigned char m_justify;
    double m_angleGrd;
 
private:
    void draw(IGraphics *graphics) const override;
    void processEntityGeoBlock(CGeoBlock *currentGeoBlock, std::vector<SBlockDxf *> *blocks,
                               SProcessEntitiesGeoBlocks *dataProcess) const override;
    void processEntityPolyline(const std::vector<SBlockDxf *> *blocks, SProcessEntitiesPolylines *dataProcess,
                               const std::string &nameLayerOpt) const override;
};
 
struct SEntitySolid final : SEntity
{
    SEntitySolid(const std::string &nameLayer, double x1, double y1, double x2, double y2, double x3, double y3,
                 double x4, double y4, bool isColorRGB, uint64_t colorRGB, int64_t lineWidth, double Nx, double Ny,
                 double Nz);
 
    double m_x1;
    double m_y1;
    double m_x2;
    double m_y2;
    double m_x3;
    double m_y3;
    double m_x4;
    double m_y4;
 
private:
    void draw(IGraphics *graphics) const override;
    void processEntityGeoBlock(CGeoBlock *currentGeoBlock, std::vector<SBlockDxf *> *blocks,
                               SProcessEntitiesGeoBlocks *dataProcess) const override;
    void processEntityPolyline(const std::vector<SBlockDxf *> *blocks, SProcessEntitiesPolylines *dataProcess,
                               const std::string &nameLayerOpt) const override;
};
 
class CDxf
{
public:
    enum class EPrvUnits
    {
        Inch,
        Millimeter,
        Centimeter,
        Meter
    };
 
    enum class EEndEntityType
    {
        Polyline,
        Hatch,
        Leader
    };
 
    CDxf();
    explicit CDxf(std::string_view nameFileDxf);
    explicit CDxf(const std::shared_ptr<iv::streams::IInputStream> &inputStream);
    explicit CDxf(const CDxf *other);
    ~CDxf();
 
    void addLine(double x1, double y1, double z1, double x2, double y2, double z2) const;
    [[maybe_unused]] void addPoint(double x, double y, double z) const;
    void addPolyLine(float **vertex, uint64_t numVertex) const;
    void addRectangle(double x1, double y1, double x2, double y2) const;
    void addSolid(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3,
                  double x4, double y4, double z4) const;
    void addText(const std::string &text, double x, double y, double z, double height, unsigned char justify) const;
    void addTriangle(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3,
                     double z3) const;
 
    void draw(IGraphics *graphics) const;
 
    [[nodiscard]] std::vector<std::string> getAllBlocksNames() const;
    [[maybe_unused]] [[nodiscard]] std::vector<std::vector<iv::math::geometry::Point3d>> *getAllPolylines() const;
    [[nodiscard]] std::vector<std::vector<iv::math::geometry::Point3d>> *
    getAllPolylinesInLayer(const std::string &nameLayer) const;
    [[maybe_unused]] [[nodiscard]] IBlockExportDxf *getEntityLogicExpression(const std::string &nameBlock) const;
    [[nodiscard]] std::vector<CGeoBlock *> getGeoBlocksByNames(const std::vector<std::string> &nameBlocks) const;
    [[maybe_unused]] [[nodiscard]] std::string getNameDXF() const;
    [[nodiscard]] std::vector<iv::math::geometry::Point2d>
    getPositionsDigitalChannel(const std::string &nameBlock) const;
    [[nodiscard]] CGeoBlock *getOnlyOneGeoBlock(const std::string &nameBlock) const;
 
    void setVisibleLayer(const std::string &nameLayer, bool isVisible);
 
    [[nodiscard]] bool existLayer(const std::string &nameLayer) const;
    [[nodiscard]] bool existOnlyOneGeoBlock(const std::string &nameBlock) const;
    bool hasCapture(double x, double y, double radiusCapture, double *xCaptured, double *yCaptured) const;
    [[nodiscard]] bool hasCaptureInclusive(double xMin, double yMin, double xMax, double yMax,
                                           double radiusCapture) const;
    [[nodiscard]] bool hasCaptureNoInclusive(double xMin, double yMin, double xMax, double yMax,
                                             double radiusCapture) const;
    [[nodiscard]] bool hasCaptureByGraphic(double xMin, double yMin, double xMax, double yMax,
                                           double radiusCapture) const;
 
private:
    std::string m_nameDXF;
    EPrvUnits m_units;
    SBlockDxf *m_modelBlock;
    std::vector<SLayerDxf *> *m_layers;
    std::vector<SBlockDxf *> *m_blocks;
};
 
#endif /* LIBS_CAD_CDxf_HPP_ */