From 039ac92480a09266146fc5b0c9ec67a32a2565ad Mon Sep 17 00:00:00 2001
From: saurabhb17
Date: Wed, 26 Feb 2020 16:04:40 +0530
Subject: Added secondary files
---
lib_dxf/drw_entities.h | 1342 ++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 1342 insertions(+)
create mode 100644 lib_dxf/drw_entities.h
(limited to 'lib_dxf/drw_entities.h')
diff --git a/lib_dxf/drw_entities.h b/lib_dxf/drw_entities.h
new file mode 100644
index 0000000..7f7b085
--- /dev/null
+++ b/lib_dxf/drw_entities.h
@@ -0,0 +1,1342 @@
+/******************************************************************************
+** libDXFrw - Library to read/write DXF files (ascii & binary) **
+** **
+** Copyright (C) 2011 Rallaz, rallazz@gmail.com **
+** **
+** This library is free software, licensed 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. **
+** You should have received a copy of the GNU General Public License **
+** along with this program. If not, see . **
+******************************************************************************/
+
+#ifndef DRW_ENTITIES_H
+#define DRW_ENTITIES_H
+
+
+#include
+#include
+#include "drw_base.h"
+
+class dxfReader;
+class DRW_Polyline;
+
+namespace DRW {
+// ! Entity's type.
+enum ETYPE
+{
+ POINT,
+ LINE,
+ CIRCLE,
+ ARC,
+ ELLIPSE,
+ TRACE,
+ SOLID,
+ BLOCK,
+ INSERT,
+ LWPOLYLINE,
+ POLYLINE,
+ VERTEX,
+ SPLINE,
+ HATCH,
+ TEXT,
+ MTEXT,
+ E3DFACE,
+ IMAGE,
+ LEADER,
+ DIMENSION,
+ DIMALIGNED,
+ DIMLINEAR,
+ DIMRADIAL,
+ DIMDIAMETRIC,
+ DIMANGULAR,
+ DIMANGULAR3P,
+ DIMORDINATE,
+
+// OVERLAYBOX,
+// CONSTRUCTIONLINE,
+ RAY,
+ XLINE,
+ VIEWPORT,
+ UNKNOWN
+};
+}
+
+// ! Base class for entities
+/*!
+ * Base class for entities
+ * @author Rallaz
+ */
+class DRW_Entity
+{
+public:
+ // initializes default values
+ DRW_Entity()
+ {
+ eType = DRW::UNKNOWN;
+ lineType = "BYLAYER";
+ color = 256; // default BYLAYER (256)
+ ltypeScale = 1.0;
+ visible = true;
+ layer = "0";
+ lWeight = DRW_LW_Conv::widthByLayer; // default BYLAYER (dxf -1, dwg 29)
+ handleBlock = space = 0; // default ModelSpace (0) & handleBlock = no handle (0)
+ haveExtrusion = false;
+ color24 = -1; // default -1 not set
+ handle = 0;
+ curr = NULL;
+ }
+
+ virtual ~DRW_Entity()
+ {
+ for( std::vector::iterator it = extData.begin(); it!=extData.end(); ++it )
+ delete *it;
+
+ extData.clear();
+ }
+
+ DRW_Entity( const DRW_Entity& d )
+ {
+ eType = d.eType;
+ handle = d.handle;
+ handleBlock = d.handleBlock;
+ layer = d.layer;
+ lineType = d.lineType;
+ color = d.color;
+ color24 = d.color24;
+ colorName = d.colorName;
+ ltypeScale = d.ltypeScale;
+ visible = d.visible;
+ lWeight = d.lWeight;
+ space = d.space;
+ haveExtrusion = d.haveExtrusion;
+ curr = NULL;
+ }
+
+ virtual void applyExtrusion() = 0;
+
+protected:
+ void parseCode( int code, dxfReader* reader );
+ void calculateAxis( DRW_Coord extPoint );
+ void extrudePoint( DRW_Coord extPoint, DRW_Coord* point );
+
+public:
+ enum DRW::ETYPE eType; /*!< enum: entity type, code 0 */
+ int handle; /*!< entity identifier, code 5 */
+ int handleBlock; /*!< Soft-pointer ID/handle to owner BLOCK_RECORD object, code 330 */
+ UTF8STRING layer; /*!< layer name, code 8 */
+ UTF8STRING lineType; /*!< line type, code 6 */
+ int color; /*!< entity color, code 62 */
+ enum DRW_LW_Conv::lineWidth lWeight; /*!< entity lineweight, code 370 */
+ double ltypeScale; /*!< linetype scale, code 48 */
+ bool visible; /*!< entity visibility, code 60 */
+ int color24; /*!< 24-bit color, code 420 */
+ std::string colorName; /*!< color name, code 430 */
+ int space; /*!< space indicator 0 = model, 1 paper, code 67*/
+ bool haveExtrusion; /*!< set to true if the entity have extrusion*/
+ std::vector extData; /*!< FIFO list of extended data, codes 1000 to 1071*/
+
+private:
+ DRW_Coord extAxisX;
+ DRW_Coord extAxisY;
+ DRW_Variant* curr;
+};
+
+
+// ! Class to handle point entity
+/*!
+ * Class to handle point entity
+ * @author Rallaz
+ */
+class DRW_Point : public DRW_Entity
+{
+public:
+ DRW_Point()
+ {
+ eType = DRW::POINT;
+ basePoint.z = extPoint.x = extPoint.y = 0;
+ extPoint.z = 1;
+ thickness = 0;
+ }
+
+ virtual void applyExtrusion() {}
+
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ DRW_Coord basePoint; /*!< base point, code 10, 20 & 30 */
+ double thickness; /*!< thickness, code 39 */
+ DRW_Coord extPoint; /*!< Dir extrusion normal vector, code 210, 220 & 230 */
+};
+
+// ! Class to handle line entity
+/*!
+ * Class to handle line entity
+ * @author Rallaz
+ */
+class DRW_Line : public DRW_Point
+{
+public:
+ DRW_Line()
+ {
+ eType = DRW::LINE;
+ secPoint.z = 0;
+ }
+
+ virtual void applyExtrusion() {}
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ DRW_Coord secPoint; /*!< second point, code 11, 21 & 31 */
+};
+
+// ! Class to handle ray entity
+/*!
+ * Class to handle ray entity
+ * @author Rallaz
+ */
+class DRW_Ray : public DRW_Line
+{
+public:
+ DRW_Ray()
+ {
+ eType = DRW::RAY;
+ }
+};
+
+// ! Class to handle xline entity
+/*!
+ * Class to handle xline entity
+ * @author Rallaz
+ */
+class DRW_Xline : public DRW_Line
+{
+public:
+ DRW_Xline()
+ {
+ eType = DRW::XLINE;
+ }
+};
+
+// ! Class to handle circle entity
+/*!
+ * Class to handle circle entity
+ * @author Rallaz
+ */
+class DRW_Circle : public DRW_Point
+{
+public:
+ DRW_Circle()
+ {
+ eType = DRW::CIRCLE;
+ radious = 0.0;
+ }
+
+ virtual void applyExtrusion();
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ double radious; /*!< radius, code 40 */
+};
+
+// ! Class to handle arc entity
+/*!
+ * Class to handle arc entity
+ * @author Rallaz
+ */
+class DRW_Arc : public DRW_Circle
+{
+public:
+ DRW_Arc()
+ {
+ eType = DRW::ARC;
+ isccw = 1;
+ staangle = 0.0;
+ endangle = 0.0;
+ }
+
+ virtual void applyExtrusion();
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ double staangle; /*!< start angle, code 50 in radians*/
+ double endangle; /*!< end angle, code 51 in radians */
+ int isccw; /*!< is counter clockwise arc?, only used in hatch, code 73 */
+};
+
+// ! Class to handle ellipse entity
+/*!
+ * Class to handle ellipse and elliptic arc entity
+ * Note: start/end parameter are in radians for ellipse entity but
+ * for hatch boundary are in degrees
+ * @author Rallaz
+ */
+class DRW_Ellipse : public DRW_Line
+{
+public:
+ DRW_Ellipse()
+ {
+ eType = DRW::ELLIPSE;
+ isccw = 1;
+ ratio = 1.0;
+ staparam = endparam = 0;
+ }
+
+ void parseCode( int code, dxfReader* reader );
+ void toPolyline( DRW_Polyline* pol, int parts = 128 );
+ virtual void applyExtrusion();
+ void correctAxis();
+
+public:
+ double ratio; /*!< ratio, code 40 */
+ double staparam; /*!< start parameter, code 41, 0.0 for full ellipse*/
+ double endparam; /*!< end parameter, code 42, 2*PI for full ellipse */
+ int isccw; /*!< is counter clockwise arc?, only used in hatch, code 73 */
+};
+
+// ! Class to handle trace entity
+/*!
+ * Class to handle trace entity
+ * @author Rallaz
+ */
+class DRW_Trace : public DRW_Line
+{
+public:
+ DRW_Trace()
+ {
+ eType = DRW::TRACE;
+ thirdPoint.z = 0;
+ fourPoint.z = 0;
+ }
+
+ virtual void applyExtrusion();
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ DRW_Coord thirdPoint; /*!< third point, code 12, 22 & 32 */
+ DRW_Coord fourPoint; /*!< four point, code 13, 23 & 33 */
+};
+
+// ! Class to handle solid entity
+/*!
+ * Class to handle solid entity
+ * @author Rallaz
+ */
+class DRW_Solid : public DRW_Trace
+{
+public:
+ DRW_Solid()
+ {
+ eType = DRW::SOLID;
+ }
+
+ void parseCode( int code, dxfReader* reader );
+};
+
+// ! Class to handle 3dface entity
+/*!
+ * Class to handle 3dface entity
+ * @author Rallaz
+ */
+class DRW_3Dface : public DRW_Trace
+{
+public:
+ DRW_3Dface()
+ {
+ eType = DRW::E3DFACE;
+ invisibleflag = 0;
+ }
+
+ virtual void applyExtrusion() {}
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ int invisibleflag; /*!< invisible edge flag, code 70 */
+};
+
+// ! Class to handle block entries
+/*!
+ * Class to handle block entries
+ * @author Rallaz
+ */
+class DRW_Block : public DRW_Point
+{
+public:
+ DRW_Block()
+ {
+ eType = DRW::BLOCK;
+ layer = "0";
+ flags = 0;
+ name = "*U0";
+ }
+
+ virtual void applyExtrusion() {}
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ UTF8STRING name; /*!< block name, code 2 */
+ int flags; /*!< block type, code 70 */
+};
+
+
+// ! Class to handle insert entries
+/*!
+ * Class to handle insert entries
+ * @author Rallaz
+ */
+class DRW_Insert : public DRW_Point
+{
+public:
+ DRW_Insert()
+ {
+ eType = DRW::INSERT;
+ xscale = 1;
+ yscale = 1;
+ zscale = 1;
+ angle = 0;
+ colcount = 1;
+ rowcount = 1;
+ colspace = 0;
+ rowspace = 0;
+ }
+
+ virtual void applyExtrusion() { DRW_Point::applyExtrusion(); }
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ UTF8STRING name; /*!< block name, code 2 */
+ double xscale; /*!< x scale factor, code 41 */
+ double yscale; /*!< y scale factor, code 42 */
+ double zscale; /*!< z scale factor, code 43 */
+ double angle; /*!< rotation angle, code 50 */
+ int colcount; /*!< column count, code 70 */
+ int rowcount; /*!< row count, code 71 */
+ double colspace; /*!< column space, code 44 */
+ double rowspace; /*!< row space, code 45 */
+};
+
+// ! Class to handle lwpolyline entity
+/*!
+ * Class to handle lwpolyline entity
+ * @author Rallaz
+ */
+class DRW_LWPolyline : public DRW_Entity
+{
+public:
+ DRW_LWPolyline()
+ {
+ eType = DRW::LWPOLYLINE;
+ elevation = thickness = width = 0.0;
+ flags = 0;
+ extPoint.x = extPoint.y = 0;
+ extPoint.z = 1;
+ vertex = NULL;
+ vertexnum = 0;
+ }
+
+ ~DRW_LWPolyline()
+ {
+ while( !vertlist.empty() )
+ {
+ vertlist.pop_back();
+ }
+ }
+
+ virtual void applyExtrusion();
+
+ void addVertex( DRW_Vertex2D v )
+ {
+ DRW_Vertex2D* vert = new DRW_Vertex2D();
+
+ vert->x = v.x;
+ vert->y = v.y;
+ vert->stawidth = v.stawidth;
+ vert->endwidth = v.endwidth;
+ vert->bulge = v.bulge;
+ vertlist.push_back( vert );
+ }
+
+ DRW_Vertex2D* addVertex()
+ {
+ DRW_Vertex2D* vert = new DRW_Vertex2D();
+
+ vert->stawidth = 0;
+ vert->endwidth = 0;
+ vert->bulge = 0;
+ vertlist.push_back( vert );
+ return vert;
+ }
+
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ int vertexnum; /*!< number of vertex, code 90 */
+ int flags; /*!< polyline flag, code 70, default 0 */
+ double width; /*!< constant width, code 43 */
+ double elevation; /*!< elevation, code 38 */
+ double thickness; /*!< thickness, code 39 */
+ DRW_Coord extPoint; /*!< Dir extrusion normal vector, code 210, 220 & 230 */
+ DRW_Vertex2D* vertex; /*!< current vertex to add data */
+ std::vector vertlist; /*!< vertex list */
+};
+
+// ! Class to handle insert entries
+/*!
+ * Class to handle insert entries
+ * @author Rallaz
+ */
+class DRW_Text : public DRW_Line
+{
+public:
+ // ! Vertical alignments.
+ enum VAlign
+ {
+ VBaseLine = 0, /*!< Top = 0 */
+ VBottom, /*!< Bottom = 1 */
+ VMiddle, /*!< Middle = 2 */
+ VTop /*!< Top = 3 */
+ };
+
+ // ! Horizontal alignments.
+ enum HAlign
+ {
+ HLeft = 0, /*!< Left = 0 */
+ HCenter, /*!< Centered = 1 */
+ HRight, /*!< Right = 2 */
+ HAligned, /*!< Aligned = 3 (if VAlign==0) */
+ HMiddle, /*!< middle = 4 (if VAlign==0) */
+ HFit /*!< fit into point = 5 (if VAlign==0) */
+ };
+
+ DRW_Text()
+ {
+ eType = DRW::TEXT;
+ angle = 0;
+ widthscale = 1;
+ oblique = 0;
+ style = "STANDARD";
+ textgen = 0;
+ alignH = HLeft;
+ alignV = VBaseLine;
+ height = 0.0;
+ }
+
+ virtual void applyExtrusion() {} // RLZ TODO
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ double height; /*!< height text, code 40 */
+ UTF8STRING text; /*!< text string, code 1 */
+ double angle; /*!< rotation angle in degrees (360), code 50 */
+ double widthscale; /*!< width factor, code 41 */
+ double oblique; /*!< oblique angle, code 51 */
+ UTF8STRING style; /*!< style name, code 7 */
+ int textgen; /*!< text generation, code 71 */
+ enum HAlign alignH; /*!< horizontal align, code 72 */
+ enum VAlign alignV; /*!< vertical align, code 73 */
+};
+
+// ! Class to handle insert entries
+/*!
+ * Class to handle insert entries
+ * @author Rallaz
+ */
+class DRW_MText : public DRW_Text
+{
+public:
+ // ! Attachments.
+ enum Attach
+ {
+ TopLeft = 1,
+ TopCenter,
+ TopRight,
+ MiddleLeft,
+ MiddleCenter,
+ MiddleRight,
+ BottomLeft,
+ BottomCenter,
+ BottomRight
+ };
+
+ DRW_MText()
+ {
+ eType = DRW::MTEXT;
+ interlin = 1;
+ alignV = (VAlign) TopLeft;
+ textgen = 1;
+ haveXAxis = false; // if true needed to recalculate angle
+ }
+
+ void parseCode( int code, dxfReader* reader );
+ void updateAngle(); // recalculate angle if 'haveXAxis' is true
+
+public:
+ double interlin; /*!< width factor, code 44 */
+
+private:
+ bool haveXAxis;
+};
+
+// ! Class to handle vertex
+/*!
+ * Class to handle vertex for polyline entity
+ * @author Rallaz
+ */
+class DRW_Vertex : public DRW_Point
+{
+public:
+ DRW_Vertex()
+ {
+ eType = DRW::VERTEX;
+ stawidth = endwidth = bulge = 0;
+ vindex1 = vindex2 = vindex3 = vindex4 = 0;
+ flags = identifier = 0;
+ tgdir = 0.0;
+ }
+
+ DRW_Vertex( double sx, double sy, double sz, double b )
+ {
+ stawidth = endwidth = 0;
+ vindex1 = vindex2 = vindex3 = vindex4 = 0;
+ flags = identifier = 0;
+ basePoint.x = sx;
+ basePoint.y = sy;
+ basePoint.z = sz;
+ bulge = b;
+ tgdir = 0.0;
+ }
+
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ double stawidth; /*!< Start width, code 40 */
+ double endwidth; /*!< End width, code 41 */
+ double bulge; /*!< bulge, code 42 */
+
+ int flags; /*!< vertex flag, code 70, default 0 */
+ double tgdir; /*!< curve fit tangent direction, code 50 */
+ int vindex1; /*!< polyface mesh vertex index, code 71, default 0 */
+ int vindex2; /*!< polyface mesh vertex index, code 72, default 0 */
+ int vindex3; /*!< polyface mesh vertex index, code 73, default 0 */
+ int vindex4; /*!< polyface mesh vertex index, code 74, default 0 */
+ int identifier; /*!< vertex identifier, code 91, default 0 */
+};
+
+// ! Class to handle polyline entity
+/*!
+ * Class to handle polyline entity
+ * @author Rallaz
+ */
+class DRW_Polyline : public DRW_Point
+{
+public:
+ DRW_Polyline()
+ {
+ eType = DRW::POLYLINE;
+ defstawidth = defendwidth = 0.0;
+ basePoint.x = basePoint.y = 0.0;
+ flags = vertexcount = facecount = 0;
+ smoothM = smoothN = curvetype = 0;
+ }
+
+ ~DRW_Polyline()
+ {
+ while( !vertlist.empty() )
+ {
+ vertlist.pop_back();
+ }
+ }
+
+ void addVertex( DRW_Vertex v )
+ {
+ DRW_Vertex* vert = new DRW_Vertex();
+
+ vert->basePoint.x = v.basePoint.x;
+ vert->basePoint.y = v.basePoint.y;
+ vert->basePoint.z = v.basePoint.z;
+ vert->stawidth = v.stawidth;
+ vert->endwidth = v.endwidth;
+ vert->bulge = v.bulge;
+ vertlist.push_back( vert );
+ }
+
+ void appendVertex( DRW_Vertex* v )
+ {
+ vertlist.push_back( v );
+ }
+
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ int flags; /*!< polyline flag, code 70, default 0 */
+ double defstawidth; /*!< Start width, code 40, default 0 */
+ double defendwidth; /*!< End width, code 41, default 0 */
+ int vertexcount; /*!< polygon mesh M vertex or polyface vertex num, code 71, default 0 */
+ int facecount; /*!< polygon mesh N vertex or polyface face num, code 72, default 0 */
+ int smoothM; /*!< smooth surface M density, code 73, default 0 */
+ int smoothN; /*!< smooth surface M density, code 74, default 0 */
+ int curvetype; /*!< curves & smooth surface type, code 75, default 0 */
+
+ std::vector vertlist; /*!< vertex list */
+};
+
+
+// ! Class to handle spline entity
+/*!
+ * Class to handle spline entity
+ * @author Rallaz
+ */
+class DRW_Spline : public DRW_Entity
+{
+public:
+ DRW_Spline()
+ {
+ eType = DRW::SPLINE;
+ flags = nknots = ncontrol = nfit = 0;
+ ex = ey = 0.0;
+ ez = 1.0;
+ tolknot = tolcontrol = tolfit = 0.0000001;
+ tgsx = tgsy = tgsz = tgex = tgey = tgez = 0.0;
+ degree = 0;
+ controlpoint = 0;
+ fitpoint = 0;
+ }
+
+ ~DRW_Spline()
+ {
+ while( !controllist.empty() )
+ {
+ controllist.pop_back();
+ }
+
+ while( !fitlist.empty() )
+ {
+ fitlist.pop_back();
+ }
+ }
+
+ virtual void applyExtrusion() {}
+
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ double ex; /*!< normal vector x coordinate, code 210 */
+ double ey; /*!< normal vector y coordinate, code 220 */
+ double ez; /*!< normal vector z coordinate, code 230 */
+ double tgsx; /*!< start tangent x coordinate, code 12 */
+ double tgsy; /*!< start tangent y coordinate, code 22 */
+ double tgsz; /*!< start tangent z coordinate, code 32 */
+ double tgex; /*!< end tangent x coordinate, code 13 */
+ double tgey; /*!< end tangent y coordinate, code 23 */
+ double tgez; /*!< end tangent z coordinate, code 33 */
+ int flags; /*!< spline flag, code 70 */
+ int degree; /*!< degree of the spline, code 71 */
+ int nknots; /*!< number of knots, code 72, default 0 */
+ int ncontrol; /*!< number of control points, code 73, default 0 */
+ int nfit; /*!< number of fit points, code 74, default 0 */
+ double tolknot; /*!< knot tolerance, code 42, default 0.0000001 */
+ double tolcontrol; /*!< control point tolerance, code 43, default 0.0000001 */
+ double tolfit; /*!< fit point tolerance, code 44, default 0.0000001 */
+
+ std::vector knotslist; /*!< knots list, code 40 */
+ std::vector controllist; /*!< control points list, code 10, 20 & 30 */
+ std::vector fitlist; /*!< fit points list, code 11, 21 & 31 */
+
+private:
+ DRW_Coord* controlpoint; /*!< current control point to add data */
+ DRW_Coord* fitpoint; /*!< current fit point to add data */
+};
+
+// ! Class to handle hatch loop
+/*!
+ * Class to handle hatch loop
+ * @author Rallaz
+ */
+class DRW_HatchLoop
+{
+public:
+ DRW_HatchLoop( int t )
+ {
+ type = t;
+ numedges = 0;
+ }
+
+ ~DRW_HatchLoop()
+ {
+/* while (!pollist.empty()) {
+ * pollist.pop_back();
+ * }*/
+ while( !objlist.empty() )
+ {
+ objlist.pop_back();
+ }
+ }
+
+ void update()
+ {
+ numedges = objlist.size();
+ }
+
+public:
+ int type; /*!< boundary path type, code 92, polyline=2, default=0 */
+ int numedges; /*!< number of edges (if not a polyline), code 93 */
+// TODO: store lwpolylines as entities
+// std::vector pollist; /*!< polyline list */
+ std::vector objlist; /*!< entities list */
+};
+
+// ! Class to handle hatch entity
+/*!
+ * Class to handle hatch entity
+ * @author Rallaz
+ */
+// TODO: handle lwpolylines, splines and ellipses
+class DRW_Hatch : public DRW_Point
+{
+public:
+ DRW_Hatch()
+ {
+ eType = DRW::HATCH;
+ angle = scale = 0.0;
+ basePoint.x = basePoint.y = basePoint.z = 0.0;
+ loopsnum = hstyle = associative = 0;
+ solid = hpattern = 1;
+ deflines = doubleflag = 0;
+ loop = NULL;
+ clearEntities();
+ ispol = false;
+ }
+
+ ~DRW_Hatch()
+ {
+ while( !looplist.empty() )
+ {
+ looplist.pop_back();
+ }
+ }
+
+ void appendLoop( DRW_HatchLoop* v )
+ {
+ looplist.push_back( v );
+ }
+
+ virtual void applyExtrusion() {}
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ UTF8STRING name; /*!< hatch pattern name, code 2 */
+ int solid; /*!< solid fill flag, code 70, solid=1, pattern=0 */
+ int associative; /*!< associativity, code 71, associatve=1, non-assoc.=0 */
+ int hstyle; /*!< hatch style, code 75 */
+ int hpattern; /*!< hatch pattern type, code 76 */
+ int doubleflag; /*!< hatch pattern double flag, code 77, double=1, single=0 */
+ int loopsnum; /*!< namber of boundary paths (loops), code 91 */
+ double angle; /*!< hatch pattern angle, code 52 */
+ double scale; /*!< hatch pattern scale, code 41 */
+ int deflines; /*!< number of pattern definition lines, code 78 */
+
+ std::vector looplist; /*!< polyline list */
+
+private:
+ void clearEntities()
+ {
+ pt = line = NULL;
+ pline = NULL;
+ arc = NULL;
+ ellipse = NULL;
+ spline = NULL;
+ plvert = NULL;
+ }
+
+ void addLine()
+ {
+ clearEntities();
+
+ if( loop )
+ {
+ pt = line = new DRW_Line;
+ loop->objlist.push_back( line );
+ }
+ }
+
+ void addArc()
+ {
+ clearEntities();
+
+ if( loop )
+ {
+ pt = arc = new DRW_Arc;
+ loop->objlist.push_back( arc );
+ }
+ }
+
+ void addEllipse()
+ {
+ clearEntities();
+
+ if( loop )
+ {
+ pt = ellipse = new DRW_Ellipse;
+ loop->objlist.push_back( ellipse );
+ }
+ }
+
+ void addSpline()
+ {
+ clearEntities();
+
+ if( loop )
+ {
+ pt = NULL;
+ spline = new DRW_Spline;
+ loop->objlist.push_back( spline );
+ }
+ }
+
+ DRW_HatchLoop* loop; /*!< current loop to add data */
+ DRW_Line* line;
+ DRW_Arc* arc;
+ DRW_Ellipse* ellipse;
+ DRW_Spline* spline;
+ DRW_LWPolyline* pline;
+ DRW_Point* pt;
+ DRW_Vertex2D* plvert;
+ bool ispol;
+};
+
+// ! Class to handle image entity
+/*!
+ * Class to handle image entity
+ * @author Rallaz
+ */
+class DRW_Image : public DRW_Line
+{
+public:
+ DRW_Image()
+ {
+ eType = DRW::IMAGE;
+ vz = fade = clip = 0;
+ brightness = contrast = 50;
+ vx = vy = sizeu = sizev = dz = 0.0;
+ }
+
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ std::string ref; /*!< Hard reference to imagedef object, code 340 */
+ double vx; /*!< V-vector of single pixel, x coordinate, code 12 */
+ double vy; /*!< V-vector of single pixel, y coordinate, code 22 */
+ double vz; /*!< V-vector of single pixel, z coordinate, code 32 */
+ double sizeu; /*!< image size in pixels, U value, code 13 */
+ double sizev; /*!< image size in pixels, V value, code 23 */
+ double dz; /*!< z coordinate, code 33 */
+ int clip; /*!< Clipping state, code 280, 0=off 1=on */
+ int brightness; /*!< Brightness value, code 281, (0-100) default 50 */
+ int contrast; /*!< Brightness value, code 282, (0-100) default 50 */
+ int fade; /*!< Brightness value, code 283, (0-100) default 0 */
+};
+
+
+// ! Base class for dimension entity
+/*!
+ * Base class for dimension entity
+ * @author Rallaz
+ */
+class DRW_Dimension : public DRW_Entity
+{
+public:
+ DRW_Dimension()
+ {
+ eType = DRW::DIMENSION;
+ linesty = 1;
+ linefactor = extPoint.z = 1.0;
+ angle = oblique = rot = 0.0;
+ align = 5;
+ style = "STANDARD";
+ defPoint.z = extPoint.x = extPoint.y = 0;
+ textPoint.z = rot = 0;
+ clonePoint.x = clonePoint.y = clonePoint.z = 0;
+ type = 0;
+ length = 0.0;
+ }
+
+ DRW_Dimension( const DRW_Dimension& d ) : DRW_Entity( d )
+ {
+ eType = DRW::DIMENSION;
+ type = d.type;
+ name = d.name;
+ defPoint = d.defPoint;
+ textPoint = d.textPoint;
+ text = d.text;
+ style = d.style;
+ align = d.align;
+ linesty = d.linesty;
+ linefactor = d.linefactor;
+ rot = d.rot;
+ extPoint = d.extPoint;
+ clonePoint = d.clonePoint;
+ def1 = d.def1;
+ def2 = d.def2;
+ angle = d.angle;
+ oblique = d.oblique;
+ arcPoint = d.arcPoint;
+ circlePoint = d.circlePoint;
+ length = d.length;
+ }
+
+ virtual ~DRW_Dimension() {}
+
+ void parseCode( int code, dxfReader* reader );
+
+ virtual void applyExtrusion() {}
+
+ DRW_Coord getDefPoint() const { return defPoint; } /*!< Definition point, code 10, 20 & 30 */
+ void setDefPoint( const DRW_Coord& p ) { defPoint = p; }
+ DRW_Coord getTextPoint() const { return textPoint; } /*!< Middle point of text, code 11, 21 & 31 */
+ void setTextPoint( const DRW_Coord& p ) { textPoint = p; }
+ std::string getStyle() const { return style; } /*!< Dimension style, code 3 */
+ void setStyle( const std::string& s ) { style = s; }
+ int getAlign() const { return align; } /*!< attachment point, code 71 */
+ void setAlign( const int a ) { align = a; }
+ int getTextLineStyle() const { return linesty; } /*!< Dimension text line spacing style, code 72, default 1 */
+ void setTextLineStyle( const int l ) { linesty = l; }
+ std::string getText() const { return text; } /*!< Dimension text explicitly entered by the user, code 1 */
+ void setText( const std::string& t ) { text = t; }
+ double getTextLineFactor() const { return linefactor; } /*!< Dimension text line spacing factor, code 41, default 1? */
+ void setTextLineFactor( const double l ) { linefactor = l; }
+ double getDir() const { return rot; } /*!< rotation angle of the dimension text, code 53 (optional) default 0 */
+ void setDir( const double d ) { rot = d; }
+
+ DRW_Coord getExtrusion() { return extPoint; } /*!< extrusion, code 210, 220 & 230 */
+ void setExtrusion( const DRW_Coord& p ) { extPoint = p; }
+ std::string getName() { return name; } /*!< Name of the block that contains the entities, code 2 */
+ void setName( const std::string& s ) { name = s; }
+// int getType(){ return type;} /*!< Dimension type, code 70 */
+
+protected:
+ DRW_Coord getPt2() const { return clonePoint; }
+ void setPt2( const DRW_Coord& p ) { clonePoint = p; }
+ DRW_Coord getPt3() const { return def1; }
+ void setPt3( const DRW_Coord& p ) { def1 = p; }
+ DRW_Coord getPt4() const { return def2; }
+ void setPt4( const DRW_Coord& p ) { def2 = p; }
+ DRW_Coord getPt5() const { return circlePoint; }
+ void setPt5( const DRW_Coord& p ) { circlePoint = p; }
+ DRW_Coord getPt6() const { return arcPoint; }
+ void setPt6( const DRW_Coord& p ) { arcPoint = p; }
+ double getAn50() const { return angle; } /*!< Angle of rotated, horizontal, or vertical dimensions, code 50 */
+ void setAn50( const double d ) { angle = d; }
+ double getOb52() const { return oblique; } /*!< oblique angle, code 52 */
+ void setOb52( const double d ) { oblique = d; }
+ double getRa40() const { return length; } /*!< Leader length, code 40 */
+ void setRa40( const double d ) { length = d; }
+
+public:
+ int type; /*!< Dimension type, code 70 */
+
+private:
+ std::string name; /*!< Name of the block that contains the entities, code 2 */
+ DRW_Coord defPoint; /*!< definition point, code 10, 20 & 30 (WCS) */
+ DRW_Coord textPoint; /*!< Middle point of text, code 11, 21 & 31 (OCS) */
+ UTF8STRING text; /*!< Dimension text explicitly entered by the user, code 1 */
+ UTF8STRING style; /*!< Dimension style, code 3 */
+ int align; /*!< attachment point, code 71 */
+ int linesty; /*!< Dimension text line spacing style, code 72, default 1 */
+ double linefactor; /*!< Dimension text line spacing factor, code 41, default 1? (value range 0.25 to 4.00*/
+ double rot; /*!< rotation angle of the dimension text, code 53 */
+ DRW_Coord extPoint; /*!< extrusion normal vector, code 210, 220 & 230 */
+
+ // double hdir; /*!< horizontal direction for the dimension, code 51, default ? */
+ DRW_Coord clonePoint; /*!< Insertion point for clones (Baseline & Continue), code 12, 22 & 32 (OCS) */
+ DRW_Coord def1; /*!< Definition point 1for linear & angular, code 13, 23 & 33 (WCS) */
+ DRW_Coord def2; /*!< Definition point 2, code 14, 24 & 34 (WCS) */
+ double angle; /*!< Angle of rotated, horizontal, or vertical dimensions, code 50 */
+ double oblique; /*!< oblique angle, code 52 */
+
+ DRW_Coord circlePoint; /*!< Definition point for diameter, radius & angular dims code 15, 25 & 35 (WCS) */
+ DRW_Coord arcPoint; /*!< Point defining dimension arc, x coordinate, code 16, 26 & 36 (OCS) */
+ double length; /*!< Leader length, code 40 */
+};
+
+
+// ! Class to handle aligned dimension entity
+/*!
+ * Class to handle aligned dimension entity
+ * @author Rallaz
+ */
+class DRW_DimAligned : public DRW_Dimension
+{
+public:
+ DRW_DimAligned()
+ {
+ eType = DRW::DIMALIGNED;
+ }
+
+ DRW_DimAligned( const DRW_Dimension& d ) : DRW_Dimension( d )
+ {
+ eType = DRW::DIMALIGNED;
+ }
+
+ DRW_Coord getClonepoint() const { return getPt2(); } /*!< Insertion for clones (Baseline & Continue), 12, 22 & 32 */
+ void setClonePoint( DRW_Coord& c ) { setPt2( c ); }
+
+ DRW_Coord getDimPoint() const { return getDefPoint(); } /*!< dim line location point, code 10, 20 & 30 */
+ void setDimPoint( const DRW_Coord& p ) { setDefPoint( p ); }
+ DRW_Coord getDef1Point() const { return getPt3(); } /*!< Definition point 1, code 13, 23 & 33 */
+ void setDef1Point( const DRW_Coord& p ) { setPt3( p ); }
+ DRW_Coord getDef2Point() const { return getPt4(); } /*!< Definition point 2, code 14, 24 & 34 */
+ void setDef2Point( const DRW_Coord& p ) { setPt4( p ); }
+};
+
+// ! Class to handle linear or rotated dimension entity
+/*!
+ * Class to handle linear or rotated dimension entity
+ * @author Rallaz
+ */
+class DRW_DimLinear : public DRW_DimAligned
+{
+public:
+ DRW_DimLinear()
+ {
+ eType = DRW::DIMLINEAR;
+ }
+
+ DRW_DimLinear( const DRW_Dimension& d ) : DRW_DimAligned( d )
+ {
+ eType = DRW::DIMLINEAR;
+ }
+
+ double getAngle() const { return getAn50(); } /*!< Angle of rotated, horizontal, or vertical dimensions, code 50 */
+ void setAngle( const double d ) { setAn50( d ); }
+ double getOblique() const { return getOb52(); } /*!< oblique angle, code 52 */
+ void setOblique( const double d ) { setOb52( d ); }
+};
+
+// ! Class to handle radial dimension entity
+/*!
+ * Class to handle aligned, linear or rotated dimension entity
+ * @author Rallaz
+ */
+class DRW_DimRadial : public DRW_Dimension
+{
+public:
+ DRW_DimRadial()
+ {
+ eType = DRW::DIMRADIAL;
+ }
+
+ DRW_DimRadial( const DRW_Dimension& d ) : DRW_Dimension( d )
+ {
+ eType = DRW::DIMRADIAL;
+ }
+
+ DRW_Coord getCenterPoint() const { return getDefPoint(); } /*!< center point, code 10, 20 & 30 */
+ void setCenterPoint( const DRW_Coord& p ) { setDefPoint( p ); }
+ DRW_Coord getDiameterPoint() const { return getPt5(); } /*!< Definition point for radius, code 15, 25 & 35 */
+ void setDiameterPoint( const DRW_Coord& p ) { setPt5( p ); }
+ double getLeaderLength() const { return getRa40(); } /*!< Leader length, code 40 */
+ void setLeaderLength( const double d ) { setRa40( d ); }
+};
+
+// ! Class to handle radial dimension entity
+/*!
+ * Class to handle aligned, linear or rotated dimension entity
+ * @author Rallaz
+ */
+class DRW_DimDiametric : public DRW_Dimension
+{
+public:
+ DRW_DimDiametric()
+ {
+ eType = DRW::DIMDIAMETRIC;
+ }
+
+ DRW_DimDiametric( const DRW_Dimension& d ) : DRW_Dimension( d )
+ {
+ eType = DRW::DIMDIAMETRIC;
+ }
+
+ DRW_Coord getDiameter1Point() const { return getPt5(); } /*!< First definition point for diameter, code 15, 25 & 35 */
+ void setDiameter1Point( const DRW_Coord& p ) { setPt5( p ); }
+ DRW_Coord getDiameter2Point() const { return getDefPoint(); } /*!< Oposite point for diameter, code 10, 20 & 30 */
+ void setDiameter2Point( const DRW_Coord& p ) { setDefPoint( p ); }
+ double getLeaderLength() const { return getRa40(); } /*!< Leader length, code 40 */
+ void setLeaderLength( const double d ) { setRa40( d ); }
+};
+
+// ! Class to handle angular dimension entity
+/*!
+ * Class to handle angular dimension entity
+ * @author Rallaz
+ */
+class DRW_DimAngular : public DRW_Dimension
+{
+public:
+ DRW_DimAngular()
+ {
+ eType = DRW::DIMANGULAR;
+ }
+
+ DRW_DimAngular( const DRW_Dimension& d ) : DRW_Dimension( d )
+ {
+ eType = DRW::DIMANGULAR;
+ }
+
+ DRW_Coord getFirstLine1() const { return getPt3(); } /*!< Definition point line 1-1, code 13, 23 & 33 */
+ void setFirstLine1( const DRW_Coord& p ) { setPt3( p ); }
+ DRW_Coord getFirstLine2() const { return getPt4(); } /*!< Definition point line 1-2, code 14, 24 & 34 */
+ void setFirstLine2( const DRW_Coord& p ) { setPt4( p ); }
+ DRW_Coord getSecondLine1() const { return getPt5(); } /*!< Definition point line 2-1, code 15, 25 & 35 */
+ void setSecondLine1( const DRW_Coord& p ) { setPt5( p ); }
+ DRW_Coord getSecondLine2() const { return getDefPoint(); } /*!< Definition point line 2-2, code 10, 20 & 30 */
+ void setSecondLine2( const DRW_Coord& p ) { setDefPoint( p ); }
+ DRW_Coord getDimPoint() const { return getPt6(); } /*!< Dimension definition point, code 16, 26 & 36 */
+ void setDimPoint( const DRW_Coord& p ) { setPt6( p ); }
+};
+
+
+// ! Class to handle angular 3p dimension entity
+/*!
+ * Class to handle angular 3p dimension entity
+ * @author Rallaz
+ */
+class DRW_DimAngular3p : public DRW_Dimension
+{
+public:
+ DRW_DimAngular3p()
+ {
+ eType = DRW::DIMANGULAR3P;
+ }
+
+ DRW_DimAngular3p( const DRW_Dimension& d ) : DRW_Dimension( d )
+ {
+ eType = DRW::DIMANGULAR3P;
+ }
+
+ DRW_Coord getFirstLine() const { return getPt3(); } /*!< Definition point line 1, code 13, 23 & 33 */
+ void setFirstLine( const DRW_Coord& p ) { setPt3( p ); }
+ DRW_Coord getSecondLine() const { return getPt4(); } /*!< Definition point line 2, code 14, 24 & 34 */
+ void setSecondLine( const DRW_Coord& p ) { setPt4( p ); }
+ DRW_Coord getVertexPoint() const { return getPt5(); } /*!< Vertex point, code 15, 25 & 35 */
+ void SetVertexPoint( const DRW_Coord& p ) { setPt5( p ); }
+ DRW_Coord getDimPoint() const { return getDefPoint(); } /*!< Dimension definition point, code 10, 20 & 30 */
+ void setDimPoint( const DRW_Coord& p ) { setDefPoint( p ); }
+};
+
+// ! Class to handle ordinate dimension entity
+/*!
+ * Class to handle ordinate dimension entity
+ * @author Rallaz
+ */
+class DRW_DimOrdinate : public DRW_Dimension
+{
+public:
+ DRW_DimOrdinate()
+ {
+ eType = DRW::DIMORDINATE;
+ }
+
+ DRW_DimOrdinate( const DRW_Dimension& d ) : DRW_Dimension( d )
+ {
+ eType = DRW::DIMORDINATE;
+ }
+
+ DRW_Coord getOriginPoint() const { return getDefPoint(); } /*!< Origin definition point, code 10, 20 & 30 */
+ void setOriginPoint( const DRW_Coord& p ) { setDefPoint( p ); }
+ DRW_Coord getFirstLine() const { return getPt3(); } /*!< Feature location point, code 13, 23 & 33 */
+ void setFirstLine( const DRW_Coord& p ) { setPt3( p ); }
+ DRW_Coord getSecondLine() const { return getPt4(); } /*!< Leader end point, code 14, 24 & 34 */
+ void setSecondLine( const DRW_Coord& p ) { setPt4( p ); }
+};
+
+
+// ! Class to handle leader entity
+/*!
+ * Class to handle leader entity
+ * @author Rallaz
+ */
+class DRW_Leader : public DRW_Entity
+{
+public:
+ DRW_Leader()
+ {
+ eType = DRW::LEADER;
+ flag = 3;
+ hookflag = vertnum = leadertype = 0;
+ extrusionPoint.x = extrusionPoint.y = 0.0;
+ arrow = 1;
+ extrusionPoint.z = 1.0;
+ hookline = 0;
+ textheight = textwidth = 0.0;
+ coloruse = 0;
+ vertexpoint = NULL;
+ }
+
+ ~DRW_Leader()
+ {
+ while( !vertexlist.empty() )
+ {
+ vertexlist.pop_back();
+ }
+ }
+
+ virtual void applyExtrusion() {}
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ UTF8STRING style; /*!< Dimension style name, code 3 */
+ int arrow; /*!< Arrowhead flag, code 71, 0=Disabled; 1=Enabled */
+ int leadertype; /*!< Leader path type, code 72, 0=Straight line segments; 1=Spline */
+ int flag; /*!< Leader creation flag, code 73, default 3 */
+ int hookline; /*!< Hook line direction flag, code 74, default 1 */
+ int hookflag; /*!< Hook line flag, code 75 */
+ double textheight; /*!< Text annotation height, code 40 */
+ double textwidth; /*!< Text annotation width, code 41 */
+ int vertnum; /*!< Number of vertices, code 76 */
+ int coloruse; /*!< Color to use if leader's DIMCLRD = BYBLOCK, code 77 */
+ std::string handle; /*!< Hard reference to associated annotation, code 340 */
+ DRW_Coord extrusionPoint; /*!< Normal vector, code 210, 220 & 230 */
+ DRW_Coord horizdir; /*!< "Horizontal" direction for leader, code 211, 221 & 231 */
+ DRW_Coord offsetblock; /*!< Offset of last leader vertex from block, code 212, 222 & 232 */
+ DRW_Coord offsettext; /*!< Offset of last leader vertex from annotation, code 213, 223 & 233 */
+
+ std::vector vertexlist; /*!< vertex points list, code 10, 20 & 30 */
+
+private:
+ DRW_Coord* vertexpoint; /*!< current control point to add data */
+};
+
+// ! Class to handle viewport entity
+/*!
+ * Class to handle viewport entity
+ * @author Rallaz
+ */
+class DRW_Viewport : public DRW_Point
+{
+public:
+ DRW_Viewport()
+ {
+ eType = DRW::VIEWPORT;
+ vpID = vpstatus = 0;
+ pswidth = 205;
+ psheight = 156;
+ centerPX = 128.5;
+ centerPY = 97.5;
+ }
+
+ virtual void applyExtrusion() {}
+ void parseCode( int code, dxfReader* reader );
+
+public:
+ double pswidth; /*!< Width in paper space units, code 40 */
+ double psheight; /*!< Height in paper space units, code 41 */
+ int vpstatus; /*!< Viewport status, code 68 */
+ int vpID; /*!< Viewport ID, code 69 */
+ double centerPX; /*!< view center piont X, code 12 */
+ double centerPY; /*!< view center piont Y, code 22 */
+};
+
+
+#endif
+
+// EOF
--
cgit