sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-02-23 00:02:38 -05:00
Code Issues Packages Projects Releases Wiki Activity
QGIS/external/libdxfrw/drw_entities.h
Nyall Dawson bdaf65efa2 Partially resync drw_entities with libdxfrw copy 
Mostly indentation changes, with some added bugfixes from upstream!
2021-08-16 05:30:35 +10:00

1409 lines
49 KiB
C++
Raw Blame History

/******************************************************************************
** libDXFrw - Library to read/write DXF files (ascii & binary) **
** **
** Copyright (C) 2011-2015 José F. Soriano, 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 <http://www.gnu.org/licenses/>. **
******************************************************************************/
#ifndef DRW_ENTITIES_H
#define DRW_ENTITIES_H
#include <string>
#include <vector>
#include <list>
#include <memory>
#include "drw_base.h"
class dxfReader;
class dwgBuffer;
class DRW_Polyline;
namespace DRW {
//! Entity's type.
enum ETYPE {
E3DFACE,
// E3DSOLID, //encrypted proprietary data
// ACAD_PROXY_ENTITY,
ARC,
// ATTDEF,
// ATTRIB,
BLOCK,// and ENDBLK
// BODY, //encrypted proprietary data
CIRCLE,
DIMENSION,
DIMALIGNED,
DIMLINEAR,
DIMRADIAL,
DIMDIAMETRIC,
DIMANGULAR,
DIMANGULAR3P,
DIMORDINATE,
ELLIPSE,
HATCH,
// HELIX,
IMAGE,
INSERT,
LEADER,
// LIGHT,
LINE,
LWPOLYLINE,
// MESH,
// MLINE,
// MLEADERSTYLE,
// MLEADER,
MTEXT,
// OLEFRAME,
// OLE2FRAME,
POINT,
POLYLINE,
RAY,
// REGION, //encrypted proprietary data
// SECTION,
// SEQEND,//not needed?? used in polyline and insert/attrib and dwg
// SHAPE,
SOLID,
SPLINE,
// SUN,
// SURFACE, //encrypted proprietary data can be four types
// TABLE,
TEXT,
// TOLERANCE,
TRACE,
UNDERLAY,
VERTEX,
VIEWPORT,
// WIPEOUT, //WIPEOUTVARIABLE
XLINE,
UNKNOWN
};
}
//only in DWG: MINSERT, 5 types of vertex, 4 types of polylines: 2d, 3d, pface & mesh
//shape, dictionary, MLEADER, MLEADERSTYLE
#define SETENTFRIENDS friend class dxfRW; \
friend class dwgReader;
/**
* Base class for entities
* @author Rallaz
*/
class DRW_Entity
{
SETENTFRIENDS
public:
//initializes default values
//handles: default no handle (0), color: default BYLAYER (256), 24 bits color: default -1 (not set)
//line weight: default BYLAYER (dxf -1, dwg 29), space: default ModelSpace (0)
DRW_Entity( enum DRW::ETYPE aType = DRW::UNKNOWN, const UTF8STRING &aLayer = "0" )
: eType( aType )
, handle( DRW::NoHandle )
, appData( 0 )
, layer( aLayer )
, haveNextLinks( 0 )
, plotFlags( 0 )
, ltFlags( 0 )
, materialFlag( 0 )
, shadowFlag( 0 )
, lTypeH( dwgHandle() )
, layerH( dwgHandle() )
, numReactors( 0 )
, objSize( 0 )
, oType( 0 )
, extAxisX( DRW_Coord() )
, extAxisY( DRW_Coord() )
, curr( nullptr )
{
}
DRW_Entity( const DRW_Entity &e )
: eType( e.eType )
, handle( e.handle )
, parentHandle( e.parentHandle ) //no handle (0)
, space( e.space )
, layer( e.layer )
, lineType( e.lineType )
, material( e.material )
, color( e.color ) // default BYLAYER (256)
, lWeight( e.lWeight )
, ltypeScale( e.ltypeScale )
, visible( e.visible )
, numProxyGraph( e.numProxyGraph )
, color24( e.color24 ) //default -1 not set
, transparency( e.transparency )
, plotStyle( e.plotStyle )
, shadow( e.shadow )
, haveExtrusion( e.haveExtrusion )
, nextEntLink( e.nextEntLink )
, prevEntLink( e.prevEntLink )
, ownerHandle( false )
, xDictFlag( e.xDictFlag )
, numReactors( e.numReactors )
, curr( nullptr )
{
for ( auto it = e.extData.begin(); it != e.extData.end(); ++it )
{
extData.push_back( std::make_shared<DRW_Variant>( *( *it ) ) );
}
}
virtual ~DRW_Entity() = default;
void reset()
{
extData.clear();
curr.reset();
}
virtual void applyExtrusion() = 0;
protected:
//parses dxf pair to read entity
bool parseCode(int code, dxfReader *reader);
//calculates extrusion axis (normal vector)
void calculateAxis(const DRW_Coord &extPoint);
//apply extrusion to @extPoint and return data in @point
void extrudePoint(const DRW_Coord &extPoint, DRW_Coord *point);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0)=0;
//parses dwg common start part to read entity
bool parseDwg(DRW::Version version, dwgBuffer *buf, dwgBuffer* strBuf, duint32 bs=0);
//parses dwg common handles part to read entity
bool parseDwgEntHandle(DRW::Version version, dwgBuffer *buf);
//parses dxf 102 groups to read entity
bool parseDxfGroups(int code, dxfReader *reader);
public:
enum DRW::ETYPE eType{DRW::UNKNOWN}; /*!< enum: entity type, code 0 */
duint32 handle{DRW::NoHandle}; /*!< entity identifier, code 5 */
std::list<std::list<DRW_Variant> > appData; /*!< list of application data, code 102 */
duint32 parentHandle{DRW::NoHandle}; /*!< Soft-pointer ID/handle to owner BLOCK_RECORD object, code 330 */
DRW::Space space{DRW::ModelSpace}; /*!< space indicator, code 67*/
UTF8STRING layer{"0"}; /*!< layer name, code 8 */
UTF8STRING lineType{"BYLAYER"}; /*!< line type, code 6 */
duint32 material{DRW::MaterialByLayer}; /*!< hard pointer id to material object, code 347 */
int color{DRW::ColorByLayer}; /*!< entity color, code 62 */
enum DRW_LW_Conv::lineWidth lWeight{DRW_LW_Conv::widthByLayer}; /*!< entity lineweight, code 370 */
double ltypeScale{1.0}; /*!< linetype scale, code 48 */
bool visible{true}; /*!< entity visibility, code 60 */
int numProxyGraph{0}; /*!< Number of bytes in proxy graphics, code 92 */
std::string proxyGraphics; /*!< proxy graphics bytes, code 310 */
int color24{-1}; /*!< 24-bit color, code 420 */
std::string colorName; /*!< color name, code 430 */
int transparency{DRW::Opaque}; /*!< transparency, code 440 */
int plotStyle{DRW::DefaultPlotStyle}; /*!< hard pointer id to plot style object, code 390 */
DRW::ShadowMode shadow{DRW::CastAndReceiveShadows}; /*!< shadow mode, code 284 */
bool haveExtrusion{false}; /*!< set to true if the entity have extrusion*/
std::vector<std::shared_ptr<DRW_Variant>> extData; /*!< FIFO list of extended data, codes 1000 to 1071*/
protected: //only for read dwg
duint8 haveNextLinks; //aka nolinks //B
duint8 plotFlags; //presence of plot style //BB
duint8 ltFlags; //presence of linetype handle //BB
duint8 materialFlag; //presence of material handle //BB
duint8 shadowFlag; //presence of shadow handle ?? (in dwg may be plotflag)//RC
dwgHandle lTypeH;
dwgHandle layerH;
duint32 nextEntLink{0};
duint32 prevEntLink{0};
bool ownerHandle{false};
duint8 xDictFlag{0};
dint32 numReactors{0}; //
duint32 objSize; //RL 32bits object data size in bits
dint16 oType;
private:
DRW_Coord extAxisX;
DRW_Coord extAxisY;
std::shared_ptr<DRW_Variant> curr;
};
/*!
* Class to handle point entity
* @author Rallaz
*/
class DRW_Point : public DRW_Entity {
SETENTFRIENDS
public:
DRW_Point( enum DRW::ETYPE type = DRW::POINT, double sx = 0., double sy = 0., double sz = 0. )
: DRW_Entity( type )
, basePoint( sx, sy, sz )
, extPoint( 0., 0., 1. )
{
}
virtual void applyExtrusion(){}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
DRW_Coord basePoint; /*!< base point, code 10, 20 & 30 */
double thickness{0}; /*!< thickness, code 39 */
DRW_Coord extPoint; /*!< Dir extrusion normal vector, code 210, 220 & 230 */
// TNick: we're not handling code 50 - Angle of the X axis for
// the UCS in effect when the point was drawn
};
/*!
* Class to handle line entity
* @author Rallaz
*/
class DRW_Line : public DRW_Point {
SETENTFRIENDS
public:
DRW_Line( enum DRW::ETYPE type = DRW::LINE )
: DRW_Point( type )
, secPoint( 0., 0., 0. )
{
}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
DRW_Coord secPoint; /*!< second point, code 11, 21 & 31 */
};
/*!
* Class to handle ray entity
* @author Rallaz
*/
class DRW_Ray : public DRW_Line {
SETENTFRIENDS
public:
DRW_Ray( enum DRW::ETYPE type = DRW::RAY )
: DRW_Line( type )
{
}
protected:
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
};
/*!
* Class to handle xline entity
* @author Rallaz
*/
class DRW_Xline : public DRW_Ray
{
public:
DRW_Xline( enum DRW::ETYPE type = DRW::XLINE )
: DRW_Ray( type )
{
}
};
/*!
* Class to handle circle entity
* @author Rallaz
*/
class DRW_Circle : public DRW_Point {
SETENTFRIENDS
public:
DRW_Circle( enum DRW::ETYPE type = DRW::CIRCLE )
: DRW_Point( type )
{
}
virtual void applyExtrusion();
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
double radius{0}; /*!< radius, code 40 */
};
/*!
* Class to handle arc entity
* @author Rallaz
*/
class DRW_Arc : public DRW_Circle {
SETENTFRIENDS
public:
DRW_Arc( enum DRW::ETYPE type = DRW::ARC )
: DRW_Circle( type )
{
}
virtual void applyExtrusion();
//! center point in OCS
const DRW_Coord & center() { return basePoint; }
//! the radius of the circle
double getRadius() { return radius; }
//! start angle in radians
double startAngle() { return staangle; }
//! end angle in radians
double endAngle() { return endangle; }
//! thickness
double thick() { return thickness; }
//! extrusion
const DRW_Coord & extrusion() { return extPoint; }
protected:
//! interpret code in dxf reading process or dispatch to inherited class
void parseCode(int code, dxfReader *reader);
//! interpret dwg data (was already determined to be part of this object)
virtual bool parseDwg(DRW::Version v, dwgBuffer *buf, duint32 bs=0);
public:
double staangle{0}; /*!< start angle, code 50 in radians*/
double endangle{M_PIx2}; /*!< end angle, code 51 in radians */
int isccw{1}; /*!< is counter clockwise arc?, only used in hatch, code 73 */
};
/*!
* 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 {
SETENTFRIENDS
public:
DRW_Ellipse( enum DRW::ETYPE type = DRW::ELLIPSE )
: DRW_Line( type )
{
}
void toPolyline(DRW_Polyline *pol, int parts = 128) const;
virtual void applyExtrusion();
protected:
//! interpret code in dxf reading process or dispatch to inherited class
void parseCode(int code, dxfReader *reader);
//! interpret dwg data (was already determined to be part of this object)
virtual bool parseDwg(DRW::Version v, dwgBuffer *buf, duint32 bs=0);
private:
void correctAxis();
public:
double ratio{1.0}; /*!< ratio, code 40 */
double staparam{0.0}; /*!< start parameter, code 41, 0.0 for full ellipse*/
double endparam{M_PIx2}; /*!< end parameter, code 42, 2*PI for full ellipse */
int isccw{1}; /*!< is counter clockwise arc?, only used in hatch, code 73 */
};
/*!
* Class to handle trace entity
* @author Rallaz
*/
class DRW_Trace : public DRW_Line {
SETENTFRIENDS
public:
DRW_Trace( enum DRW::ETYPE type = DRW::TRACE )
: DRW_Line( type )
, thirdPoint( 0., 0., 0. )
, forthPoint( 0., 0., 0. )
{
}
virtual void applyExtrusion();
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version v, dwgBuffer *buf, duint32 bs=0);
public:
DRW_Coord thirdPoint; /*!< third point, code 12, 22 & 32 */
DRW_Coord forthPoint; /*!< forth point, code 13, 23 & 33 */
};
/*!
* Class to handle solid entity
* @author Rallaz
*/
class DRW_Solid : public DRW_Trace {
SETENTFRIENDS
public:
DRW_Solid( enum DRW::ETYPE type = DRW::SOLID )
: DRW_Trace( type )
{
}
protected:
//! interpret code in dxf reading process or dispatch to inherited class
void parseCode(int code, dxfReader *reader);
//! interpret dwg data (was already determined to be part of this object)
virtual bool parseDwg(DRW::Version v, dwgBuffer *buf, duint32 bs=0);
public:
//! first corner (2D)
const DRW_Coord & firstCorner() { return basePoint; }
//! second corner (2D)
const DRW_Coord & secondCorner() { return secPoint; }
//! third corner (2D)
const DRW_Coord & thirdCorner() { return thirdPoint; }
//! fourth corner (2D)
const DRW_Coord & fourthCorner() { return thirdPoint; }
//! thickness
double thick() { return thickness; }
//! elevation
double elevation() { return basePoint.z; }
//! extrusion
const DRW_Coord & extrusion() { return extPoint; }
};
/*!
* Class to handle 3dface entity
* @author Rallaz
*/
class DRW_3Dface : public DRW_Trace {
SETENTFRIENDS
public:
enum InvisibleEdgeFlags {
NoEdge = 0x00,
FirstEdge = 0x01,
SecodEdge = 0x02,
ThirdEdge = 0x04,
FourthEdge = 0x08,
AllEdges = 0x0F
};
DRW_3Dface( enum DRW::ETYPE type = DRW::E3DFACE )
: DRW_Trace( type )
{
}
virtual void applyExtrusion(){}
//! first corner in WCS
const DRW_Coord & firstCorner() { return basePoint; }
//! second corner in WCS
const DRW_Coord & secondCorner() { return secPoint; }
//! third corner in WCS
const DRW_Coord & thirdCorner() { return thirdPoint; }
//! fourth corner in WCS
const DRW_Coord & fourthCorner() { return forthPoint; }
//! edge visibility flags
InvisibleEdgeFlags edgeFlags() { return static_cast<InvisibleEdgeFlags>(invisibleflag); }
protected:
//! interpret code in dxf reading process or dispatch to inherited class
void parseCode(int code, dxfReader *reader);
//! interpret dwg data (was already determined to be part of this object)
virtual bool parseDwg(DRW::Version v, dwgBuffer *buf, duint32 bs=0);
public:
int invisibleflag{0}; /*!< invisible edge flag, code 70 */
};
/*!
* Class to handle block entries
* @author Rallaz
*/
class DRW_Block : public DRW_Point {
SETENTFRIENDS
public:
DRW_Block( enum DRW::ETYPE type = DRW::BLOCK )
: DRW_Point( type )
{
}
virtual void applyExtrusion(){}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version v, dwgBuffer *buf, duint32 bs=0);
public:
UTF8STRING name{"*U0"}; /*!< block name, code 2 */
int flags{0}; /*!< block type, code 70 */
private:
bool isEnd{false}; //for dwg parsing
};
/*!
* Class to handle insert entries
* @author Rallaz
*/
class DRW_Insert : public DRW_Point {
SETENTFRIENDS
public:
DRW_Insert( enum DRW::ETYPE type = DRW::INSERT )
: DRW_Point( type )
{
}
virtual void applyExtrusion(){DRW_Point::applyExtrusion();}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version v, dwgBuffer *buf, duint32 bs=0);
public:
UTF8STRING name; /*!< block name, code 2 */
double xscale{1}; /*!< x scale factor, code 41 */
double yscale{1}; /*!< y scale factor, code 42 */
double zscale{1}; /*!< z scale factor, code 43 */
double angle{0}; /*!< rotation angle in radians, code 50 */
int colcount{1}; /*!< column count, code 70 */
int rowcount{1}; /*!< row count, code 71 */
double colspace{0}; /*!< column space, code 44 */
double rowspace{0}; /*!< row space, code 45 */
public: //only for read dwg
dwgHandle blockRecH;
dwgHandle seqendH; //RLZ: on implement attrib remove this handle from obj list (see pline/vertex code)
};
/*!
* Class to handle lwpolyline entity
* @author Rallaz
*/
class DRW_LWPolyline : public DRW_Entity {
SETENTFRIENDS
public:
DRW_LWPolyline( enum DRW::ETYPE type = DRW::LWPOLYLINE )
: DRW_Entity( type )
{
}
DRW_LWPolyline( const DRW_LWPolyline &p )
: DRW_Entity( p )
, flags( p.flags )
, width( p.width )
, elevation( p.elevation )
, thickness( p.thickness )
, extPoint( p.extPoint )
{
for (unsigned i=0; i<p.vertlist.size(); i++)// RLZ ok or new
this->vertlist.push_back(
std::make_shared<DRW_Vertex2D>(*p.vertlist.at(i))
);
}
// TODO rule of 5
virtual void applyExtrusion();
void addVertex (DRW_Vertex2D v) {
std::shared_ptr<DRW_Vertex2D> vert = std::make_shared<DRW_Vertex2D>(v);
vertlist.push_back(vert);
}
std::shared_ptr<DRW_Vertex2D> addVertex () {
std::shared_ptr<DRW_Vertex2D> vert = std::make_shared<DRW_Vertex2D>();
vert->stawidth = 0;
vert->endwidth = 0;
vert->bulge = 0;
vertlist.push_back(vert);
return vert;
}
protected:
void parseCode(int code, dxfReader *reader);
bool parseDwg(DRW::Version v, dwgBuffer *buf, duint32 bs=0);
public:
int vertexnum{0}; /*!< number of vertices, code 90 */
int flags{0}; /*!< polyline flag, code 70, default 0 */
double width{0.0}; /*!< constant width, code 43 */
double elevation{0.0}; /*!< elevation, code 38 */
double thickness{0.0}; /*!< thickness, code 39 */
DRW_Coord extPoint{0.0, 0.0, 0.1}; /*!< Dir extrusion normal vector, code 210, 220 & 230 */
std::shared_ptr<DRW_Vertex2D> vertex; /*!< current vertex to add data */
std::vector<std::shared_ptr<DRW_Vertex2D>> vertlist; /*!< vertex list */
};
/*!
* Class to handle insert entries
* @author Rallaz
*/
class DRW_Text : public DRW_Line {
SETENTFRIENDS
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( enum DRW::ETYPE type = DRW::TEXT )
: DRW_Line( type )
{
}
virtual void applyExtrusion(){} //RLZ TODO
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
double height{0}; /*!< height text, code 40 */
UTF8STRING text; /*!< text string, code 1 */
double angle{0}; /*!< rotation angle in degrees (360), code 50 */
double widthscale{1}; /*!< width factor, code 41 */
double oblique{0}; /*!< oblique angle, code 51 */
UTF8STRING style{"STANDARD"}; /*!< style name, code 7 */
int textgen{0}; /*!< text generation, code 71 */
enum HAlign alignH{HLeft}; /*!< horizontal align, code 72 */
enum VAlign alignV{VBaseLine}; /*!< vertical align, code 73 */
dwgHandle styleH; /*!< handle for text style */
};
/*!
* Class to handle insert entries
* @author Rallaz
*/
class DRW_MText : public DRW_Text {
SETENTFRIENDS
public:
//! Attachments.
enum Attach {
TopLeft = 1,
TopCenter,
TopRight,
MiddleLeft,
MiddleCenter,
MiddleRight,
BottomLeft,
BottomCenter,
BottomRight
};
DRW_MText()
{
eType = DRW::MTEXT;
alignV = static_cast< VAlign >(TopLeft );
textgen = 1;
}
protected:
void parseCode(int code, dxfReader *reader);
void updateAngle(); // recalculate angle if 'hasXAxisVec' is true
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
double interlin{1}; /*!< width factor, code 44 */
private:
bool hasXAxisVec{false}; // if true need to calculate angle from secPoint vector
};
/*!
* Class to handle vertex for polyline entity
* @author Rallaz
*/
class DRW_Vertex : public DRW_Point {
SETENTFRIENDS
public:
DRW_Vertex( enum DRW::ETYPE type = DRW::VERTEX )
: DRW_Point( type )
{
}
DRW_Vertex( double sx, double sy, double sz, double b )
: DRW_Point( DRW::VERTEX, sx, sy, sz )
, bulge( b )
{
}
protected:
void parseCode(int code, dxfReader *reader);
bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0, double el=0);
virtual bool parseDwg(DRW::Version version, dwgBuffer* buf, duint32 bs=0){
DRW_UNUSED(version); DRW_UNUSED(buf); DRW_UNUSED(bs); return true;}
public:
double stawidth{0}; /*!< Start width, code 40 */
double endwidth{0}; /*!< End width, code 41 */
double bulge{0}; /*!< bulge, code 42 */
int flags{0}; /*!< vertex flag, code 70, default 0 */
double tgdir{0}; /*!< curve fit tangent direction, code 50 */
int vindex1{0}; /*!< polyface mesh vertex index, code 71, default 0 */
int vindex2{0}; /*!< polyface mesh vertex index, code 72, default 0 */
int vindex3{0}; /*!< polyface mesh vertex index, code 73, default 0 */
int vindex4{0}; /*!< polyface mesh vertex index, code 74, default 0 */
int identifier{0}; /*!< vertex identifier, code 91, default 0 */
};
/*!
* Class to handle polyline entity
* @author Rallaz
*/
class DRW_Polyline : public DRW_Point {
SETENTFRIENDS
public:
DRW_Polyline( enum DRW::ETYPE type = DRW::POLYLINE )
: DRW_Point( type )
{
}
void addVertex (DRW_Vertex v) {
std::shared_ptr<DRW_Vertex> vert = std::make_shared<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 (std::shared_ptr<DRW_Vertex> const& v) {
vertlist.push_back(v);
}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
int flags{0}; /*!< polyline flag, code 70, default 0 */
double defstawidth{0}; /*!< Start width, code 40, default 0 */
double defendwidth{0}; /*!< End width, code 41, default 0 */
int vertexcount{0}; /*!< polygon mesh M vertex or polyface vertex num, code 71, default 0 */
int facecount{0}; /*!< polygon mesh N vertex or polyface face num, code 72, default 0 */
int smoothM{0}; /*!< smooth surface M density, code 73, default 0 */
int smoothN{0}; /*!< smooth surface M density, code 74, default 0 */
int curvetype{0}; /*!< curves & smooth surface type, code 75, default 0 */
std::vector<std::shared_ptr<DRW_Vertex>> vertlist; /*!< vertex list */
private:
std::list<duint32>handlesList; //list of handles, only in 2004+
duint32 firstEH{0}; //handle of first entity, only in pre-2004
duint32 lastEH{0}; //handle of last entity, only in pre-2004
dwgHandle seqEndH; //handle of SEQEND entity
};
/*!
* Class to handle spline entity
* @author Rallaz
*/
class DRW_Spline : public DRW_Entity {
SETENTFRIENDS
public:
DRW_Spline()
: DRW_Entity( DRW::SPLINE )
{
}
virtual void applyExtrusion(){}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
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 */
DRW_Coord normalVec; /*!< normal vector, code 210, 220, 230 */
DRW_Coord tgStart; /*!< start tangent, code 12, 22, 32 */
// double tgsx; /*!< start tangent x coordinate, code 12 */
// double tgsy; /*!< start tangent y coordinate, code 22 */
// double tgsz; /*!< start tangent z coordinate, code 32 */
DRW_Coord tgEnd; /*!< end tangent, code 13, 23, 33 */
// 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{0}; /*!< spline flag, code 70 */
int degree{0}; /*!< degree of the spline, code 71 */
dint32 nknots{0}; /*!< number of knots, code 72, default 0 */
dint32 ncontrol{0}; /*!< number of control points, code 73, default 0 */
dint32 nfit{0}; /*!< number of fit points, code 74, default 0 */
double tolknot{0.0000001}; /*!< knot tolerance, code 42, default 0.0000001 */
double tolcontrol{0.0000001}; /*!< control point tolerance, code 43, default 0.0000001 */
double tolfit{0.0000001}; /*!< fit point tolerance, code 44, default 0.0000001 */
std::vector<double> knotslist; /*!< knots list, code 40 */
std::vector<double> weightlist; /*!< weight list, code 41 */
std::vector<std::shared_ptr<DRW_Coord>> controllist; /*!< control points list, code 10, 20 & 30 */
std::vector<std::shared_ptr<DRW_Coord>> fitlist; /*!< fit points list, code 11, 21 & 31 */
private:
std::shared_ptr<DRW_Coord> controlpoint; /*!< current control point to add data */
std::shared_ptr<DRW_Coord> fitpoint; /*!< current fit point to add data */
};
/*!
* Class to handle hatch loop
* @author Rallaz
*/
class DRW_HatchLoop
{
public:
explicit DRW_HatchLoop( int t )
: type( t )
, numedges( 0 )
{
}
void update() {
numedges = objlist.size();
}
public:
int type; /*!< boundary path type, code 92, polyline=2, default=0 */
int numedges{0}; /*!< number of edges (if not a polyline), code 93 */
//TODO: store lwpolylines as entities
// std::vector<DRW_LWPolyline *> pollist; /*!< polyline list */
std::vector<std::shared_ptr<DRW_Entity>> objlist; /*!< entities list */
};
/*!
* Class to handle hatch entity
* @author Rallaz
*/
//TODO: handle lwpolylines, splines and ellipses
class DRW_Hatch : public DRW_Point {
SETENTFRIENDS
public:
DRW_Hatch( enum DRW::ETYPE type = DRW::HATCH )
: DRW_Point( type )
{
clearEntities();
}
void appendLoop (std::shared_ptr<DRW_HatchLoop> const& v) {
looplist.push_back(v);
}
virtual void applyExtrusion(){}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
UTF8STRING name; /*!< hatch pattern name, code 2 */
int solid{1}; /*!< solid fill flag, code 70, solid=1, pattern=0 */
int associative{0}; /*!< associativity, code 71, associatve=1, non-assoc.=0 */
int hstyle{0}; /*!< hatch style, code 75 */
int hpattern{1}; /*!< hatch pattern type, code 76 */
int doubleflag{0}; /*!< hatch pattern double flag, code 77, double=1, single=0 */
int loopsnum{0}; /*!< namber of boundary paths (loops), code 91 */
double angle{0}; /*!< hatch pattern angle, code 52 */
double scale{0}; /*!< hatch pattern scale, code 41 */
int deflines{0}; /*!< number of pattern definition lines, code 78 */
std::vector<std::shared_ptr<DRW_HatchLoop>> looplist; /*!< polyline list */
private:
void clearEntities(){
pt.reset();
line.reset();
pline.reset();
arc.reset();
ellipse.reset();
spline.reset();
plvert.reset();
}
void addLine() {
clearEntities();
if (loop) {
pt = line = std::make_shared<DRW_Line>();
loop->objlist.push_back(line);
}
}
void addArc() {
clearEntities();
if (loop) {
pt = arc = std::make_shared<DRW_Arc>();
loop->objlist.push_back(arc);
}
}
void addEllipse() {
clearEntities();
if (loop) {
pt = ellipse = std::make_shared<DRW_Ellipse>();
loop->objlist.push_back(ellipse);
}
}
void addSpline() {
clearEntities();
if (loop) {
pt.reset();
spline = std::make_shared<DRW_Spline>();
loop->objlist.push_back(spline);
}
}
std::shared_ptr<DRW_HatchLoop> loop; /*!< current loop to add data */
std::shared_ptr<DRW_Line> line;
std::shared_ptr<DRW_Arc> arc;
std::shared_ptr<DRW_Ellipse> ellipse;
std::shared_ptr<DRW_Spline> spline;
std::shared_ptr<DRW_LWPolyline> pline;
std::shared_ptr<DRW_Point> pt;
std::shared_ptr<DRW_Vertex2D> plvert;
bool ispol;
};
/*!
* Class to handle image entity
* @author Rallaz
*/
class DRW_Image : public DRW_Line {
SETENTFRIENDS
public:
DRW_Image( enum DRW::ETYPE type = DRW::IMAGE )
: DRW_Line( type )
{
}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
duint32 ref{0}; /*!< Hard reference to imagedef object, code 340 */
DRW_Coord vVector; /*!< V-vector of single pixel, x coordinate, code 12, 22 & 32 */
// 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{0}; /*!< image size in pixels, U value, code 13 */
double sizev{0}; /*!< image size in pixels, V value, code 23 */
double dz{0}; /*!< z coordinate, code 33 */
int clip{0}; /*!< Clipping state, code 280, 0=off 1=on */
int brightness{50}; /*!< Brightness value, code 281, (0-100) default 50 */
int contrast{50}; /*!< Brightness value, code 282, (0-100) default 50 */
int fade{0}; /*!< Brightness value, code 283, (0-100) default 0 */
};
/*!
* Base class for dimension entity
* @author Rallaz
*/
class DRW_Dimension : public DRW_Entity {
SETENTFRIENDS
public:
DRW_Dimension( enum DRW::ETYPE type = DRW::DIMENSION )
: DRW_Entity( type )
, extPoint( 0., 0., 1. )
{
}
DRW_Dimension( const DRW_Dimension &d )
: DRW_Entity( d )
, 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 )
, hdir( d.hdir )
, clonePoint( d.clonePoint )
, def1( d.def1 )
, def2( d.def2 )
, angle( d.angle )
, oblique( d.oblique )
, circlePoint( d.circlePoint )
, arcPoint( d.arcPoint )
, length( d.length )
{
}
virtual void applyExtrusion(){}
protected:
void parseCode(int code, dxfReader *reader);
bool parseDwg(DRW::Version version, dwgBuffer *buf, dwgBuffer *sBuf);
virtual bool parseDwg(DRW::Version version, dwgBuffer* buf, duint32 bs=0){
DRW_UNUSED(version); DRW_UNUSED(buf); DRW_UNUSED(bs); return true;}
public:
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() const {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{0}; /*!< 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{"STANDARD"}; /*!< Dimension style, code 3 */
int align{5}; /*!< attachment point, code 71 */
int linesty{1}; /*!< Dimension text line spacing style, code 72, default 1 */
double linefactor{1}; /*!< Dimension text line spacing factor, code 41, default 1? (value range 0.25 to 4.00*/
double rot{0}; /*!< rotation angle of the dimension text, code 53 */
DRW_Coord extPoint; /*!< extrusion normal vector, code 210, 220 & 230 */
double hdir{0}; /*!< 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{0}; /*!< Angle of rotated, horizontal, or vertical dimensions, code 50 */
double oblique{0}; /*!< 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{0}; /*!< Leader length, code 40 */
protected:
dwgHandle dimStyleH;
dwgHandle blockH;
};
/*!
* Class to handle aligned dimension entity
* @author Rallaz
*/
class DRW_DimAligned : public DRW_Dimension {
SETENTFRIENDS
public:
DRW_DimAligned(){
eType = DRW::DIMALIGNED;
}
explicit 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);}
protected:
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
};
/*!
* Class to handle linear or rotated dimension entity
* @author Rallaz
*/
class DRW_DimLinear : public DRW_DimAligned {
public:
DRW_DimLinear() {
eType = DRW::DIMLINEAR;
}
explicit 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 aligned, linear or rotated dimension entity
* @author Rallaz
*/
class DRW_DimRadial : public DRW_Dimension {
SETENTFRIENDS
public:
DRW_DimRadial() {
eType = DRW::DIMRADIAL;
}
explicit 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);}
protected:
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
};
/*!
* Class to handle aligned, linear or rotated dimension entity
* @author Rallaz
*/
class DRW_DimDiametric : public DRW_Dimension {
SETENTFRIENDS
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();} /*!< Opposite 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);}
protected:
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
};
/*!
* Class to handle angular dimension entity
* @author Rallaz
*/
class DRW_DimAngular : public DRW_Dimension {
SETENTFRIENDS
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);}
protected:
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
};
/*!
* Class to handle angular 3p dimension entity
* @author Rallaz
*/
class DRW_DimAngular3p : public DRW_Dimension {
SETENTFRIENDS
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);}
protected:
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
};
/*!
* Class to handle ordinate dimension entity
* @author Rallaz
*/
class DRW_DimOrdinate : public DRW_Dimension {
SETENTFRIENDS
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);}
protected:
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
};
/*!
* Class to handle leader entity
* @author Rallaz
*/
class DRW_Leader : public DRW_Entity {
SETENTFRIENDS
public:
DRW_Leader( enum DRW::ETYPE type = DRW::LEADER )
: DRW_Entity( type )
, extrusionPoint( 0., 0., 1. )
{
}
virtual void applyExtrusion(){}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
UTF8STRING style; /*!< Dimension style name, code 3 */
int arrow{1}; /*!< Arrowhead flag, code 71, 0=Disabled; 1=Enabled */
int leadertype{0}; /*!< Leader path type, code 72, 0=Straight line segments; 1=Spline */
int flag{3}; /*!< Leader creation flag, code 73, default 3 */
int hookline{1}; /*!< Hook line direction flag, code 74, default 1 */
int hookflag{0}; /*!< Hook line flag, code 75 */
double textheight{0}; /*!< Text annotation height, code 40 */
double textwidth{0}; /*!< Text annotation width, code 41 */
int vertnum{0}; /*!< Number of vertices, code 76 */
int coloruse{0}; /*!< Color to use if leader's DIMCLRD = BYBLOCK, code 77 */
duint32 annotHandle{0}; /*!< 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<std::shared_ptr<DRW_Coord>> vertexlist; /*!< vertex points list, code 10, 20 & 30 */
private:
std::shared_ptr<DRW_Coord> vertexpoint; /*!< current control point to add data */
dwgHandle dimStyleH;
dwgHandle AnnotH;
};
/*!
* Class to handle viewport entity
* @author Rallaz
*/
class DRW_Viewport : public DRW_Point {
SETENTFRIENDS
public:
DRW_Viewport( enum DRW::ETYPE type = DRW::VIEWPORT )
: DRW_Point( type )
{
}
virtual void applyExtrusion(){}
protected:
void parseCode(int code, dxfReader *reader);
virtual bool parseDwg(DRW::Version version, dwgBuffer *buf, duint32 bs=0);
public:
double pswidth{205}; /*!< Width in paper space units, code 40 */
double psheight{156}; /*!< Height in paper space units, code 41 */
int vpstatus{0}; /*!< Viewport status, code 68 */
int vpID{0}; /*!< Viewport ID, code 69 */
double centerPX{128.5}; /*!< view center point X, code 12 */
double centerPY{97.5}; /*!< view center point Y, code 22 */
double snapPX{0}; /*!< Snap base point X, code 13 */
double snapPY{0}; /*!< Snap base point Y, code 23 */
double snapSpPX{0}; /*!< Snap spacing X, code 14 */
double snapSpPY{0}; /*!< Snap spacing Y, code 24 */
//TODO: complete in dxf
DRW_Coord viewDir; /*!< View direction vector, code 16, 26 & 36 */
DRW_Coord viewTarget; /*!< View target point, code 17, 27, 37 */
double viewLength{0}; /*!< Perspective lens length, code 42 */
double frontClip{0}; /*!< Front clip plane Z value, code 43 */
double backClip{0}; /*!< Back clip plane Z value, code 44 */
double viewHeight{0}; /*!< View height in model space units, code 45 */
double snapAngle{0}; /*!< Snap angle, code 50 */
double twistAngle{0}; /*!< view twist angle, code 51 */
private:
duint32 frozenLyCount;
};//RLZ: missing 15,25, 72, 331, 90, 340, 1, 281, 71, 74, 110, 120, 130, 111, 121,131, 112,122, 132, 345,346, and more...
//used //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 */
//enum DRW::ETYPE eType; /*!< enum: entity type, code 0 */
//duint32 handle; /*!< entity identifier, code 5 */
//std::list<std::list<DRW_Variant> > appData; /*!< list of application data, code 102 */
//duint32 parentHandle; /*!< Soft-pointer ID/handle to owner BLOCK_RECORD object, code 330 */
//DRW::Space space; /*!< space indicator, code 67*/
//UTF8STRING layer; /*!< layer name, code 8 */
//UTF8STRING lineType; /*!< line type, code 6 */
//duint32 material; /*!< hard pointer id to material object, code 347 */
//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 numProxyGraph; /*!< Number of bytes in proxy graphics, code 92 */
//std::string proxyGraphics; /*!< proxy graphics bytes, code 310 */
//int color24; /*!< 24-bit color, code 420 */
//std::string colorName; /*!< color name, code 430 */
//int transparency; /*!< transparency, code 440 */
//int plotStyle; /*!< hard pointer id to plot style object, code 390 */
//DRW::ShadowMode shadow; /*!< shadow mode, code 284 */
//bool haveExtrusion; /*!< set to true if the entity have extrusion*/
#endif
// EOF
Reference in New Issue View Git Blame Copy Permalink