479 lines
13 KiB
C++
479 lines
13 KiB
C++
/******************************************************************************
|
|
** 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_BASE_H
|
|
#define DRW_BASE_H
|
|
|
|
#define DRW_VERSION "0.6.3"
|
|
|
|
#include <string>
|
|
#include <list>
|
|
#include <cmath>
|
|
|
|
#ifdef DRW_ASSERTS
|
|
# define drw_assert(a) assert(a)
|
|
#else
|
|
# define drw_assert(a)
|
|
#endif
|
|
|
|
#define UTF8STRING std::string
|
|
#define DRW_UNUSED(x) (void)x
|
|
|
|
#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
|
|
# define DRW_WIN
|
|
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
|
|
# define DRW_WIN
|
|
#elif defined(__MWERKS__) && defined(__INTEL__)
|
|
# define DRW_WIN
|
|
#else
|
|
# define DRW_POSIX
|
|
#endif
|
|
|
|
#ifndef M_PI
|
|
#define M_PI 3.141592653589793238462643
|
|
#endif
|
|
#ifndef M_PI_2
|
|
#define M_PI_2 1.57079632679489661923
|
|
#endif
|
|
#define M_PIx2 6.283185307179586 // 2*PI
|
|
#define ARAD 57.29577951308232
|
|
|
|
typedef signed char dint8; /* 8 bit signed */
|
|
typedef signed short dint16; /* 16 bit signed */
|
|
typedef signed int dint32; /* 32 bit signed */
|
|
typedef long long int dint64; /* 64 bit signed */
|
|
|
|
typedef unsigned char duint8; /* 8 bit unsigned */
|
|
typedef unsigned short duint16; /* 16 bit unsigned */
|
|
typedef unsigned int duint32; /* 32 bit unsigned */
|
|
typedef unsigned long long int duint64; /* 64 bit unsigned */
|
|
|
|
typedef float dfloat32; /* 32 bit floating point */
|
|
typedef double ddouble64; /* 64 bit floating point */
|
|
typedef long double ddouble80; /* 80 bit floating point */
|
|
|
|
|
|
namespace DRW {
|
|
|
|
//! Version numbers for the DXF Format.
|
|
enum Version {
|
|
UNKNOWNV, /*!< UNKNOWN VERSION. */
|
|
AC1006, /*!< R10. */
|
|
AC1009, /*!< R11 & R12. */
|
|
AC1012, /*!< R13. */
|
|
AC1014, /*!< R14. */
|
|
AC1015, /*!< ACAD 2000. */
|
|
AC1018, /*!< ACAD 2004. */
|
|
AC1021, /*!< ACAD 2007. */
|
|
AC1024, /*!< ACAD 2010. */
|
|
AC1027 /*!< ACAD 2013. */
|
|
};
|
|
|
|
enum error {
|
|
BAD_NONE, /*!< No error. */
|
|
BAD_UNKNOWN, /*!< UNKNOWN. */
|
|
BAD_OPEN, /*!< error opening file. */
|
|
BAD_VERSION, /*!< unsupported version. */
|
|
BAD_READ_METADATA, /*!< error reading matadata. */
|
|
BAD_READ_FILE_HEADER, /*!< error in file header read process. */
|
|
BAD_READ_HEADER, /*!< error in header vars read process. */
|
|
BAD_READ_HANDLES, /*!< error in object map read process. */
|
|
BAD_READ_CLASSES, /*!< error in classes read process. */
|
|
BAD_READ_TABLES, /*!< error in tables read process. */
|
|
BAD_READ_BLOCKS, /*!< error in block read process. */
|
|
BAD_READ_ENTITIES, /*!< error in entities read process. */
|
|
BAD_READ_OBJECTS /*!< error in objects read process. */
|
|
};
|
|
|
|
enum DBG_LEVEL {
|
|
NONE,
|
|
DEBUG
|
|
};
|
|
|
|
//! Special codes for colors
|
|
enum ColorCodes {
|
|
black = 250,
|
|
green = 3,
|
|
red = 1,
|
|
brown = 15,
|
|
yellow = 2,
|
|
cyan = 4,
|
|
magenta = 6,
|
|
gray = 8,
|
|
blue = 5,
|
|
l_blue = 163,
|
|
l_green = 121,
|
|
l_cyan = 131,
|
|
l_red = 23,
|
|
l_magenta = 221,
|
|
l_gray = 252,
|
|
white = 7,
|
|
ColorByLayer = 256,
|
|
ColorByBlock = 0
|
|
};
|
|
|
|
//! Spaces
|
|
enum Space {
|
|
ModelSpace = 0,
|
|
PaperSpace = 1
|
|
};
|
|
|
|
//! Special kinds of handles
|
|
enum HandleCodes {
|
|
NoHandle = 0
|
|
};
|
|
|
|
//! Shadow mode
|
|
enum ShadowMode {
|
|
CastAndReceieveShadows = 0,
|
|
CastShadows = 1,
|
|
ReceiveShadows = 2,
|
|
IgnoreShadows = 3
|
|
};
|
|
|
|
//! Special kinds of materials
|
|
enum MaterialCodes {
|
|
MaterialByLayer = 0
|
|
};
|
|
|
|
//! Special kinds of plot styles
|
|
enum PlotStyleCodes {
|
|
DefaultPlotStyle = 0
|
|
};
|
|
|
|
//! Special kinds of transparencies
|
|
enum TransparencyCodes {
|
|
Opaque = 0,
|
|
Transparent = -1
|
|
};
|
|
|
|
} // namespace DRW
|
|
|
|
//! Class to handle 3D coordinate point
|
|
/*!
|
|
* Class to handle 3D coordinate point
|
|
* @author Rallaz
|
|
*/
|
|
class DRW_Coord {
|
|
public:
|
|
DRW_Coord():x(0), y(0),z(0) {}
|
|
DRW_Coord(double ix, double iy, double iz): x(ix), y(iy),z(iz){}
|
|
|
|
DRW_Coord& operator = (const DRW_Coord& data) {
|
|
x = data.x; y = data.y; z = data.z;
|
|
return *this;
|
|
}
|
|
/*!< convert to unitary vector */
|
|
void unitize(){
|
|
double dist;
|
|
dist = sqrt(x*x + y*y + z*z);
|
|
if (dist > 0.0) {
|
|
x= x/dist;
|
|
y= y/dist;
|
|
z= z/dist;
|
|
}
|
|
}
|
|
|
|
public:
|
|
double x;
|
|
double y;
|
|
double z;
|
|
};
|
|
|
|
|
|
//! Class to handle vertex
|
|
/*!
|
|
* Class to handle vertex for lwpolyline entity
|
|
* @author Rallaz
|
|
*/
|
|
class DRW_Vertex2D {
|
|
public:
|
|
DRW_Vertex2D(): x(0), y(0), stawidth(0), endwidth(0), bulge(0){}
|
|
|
|
DRW_Vertex2D(double sx, double sy, double b): x(sx), y(sy), stawidth(0), endwidth(0), bulge(b) {}
|
|
|
|
public:
|
|
double x; /*!< x coordinate, code 10 */
|
|
double y; /*!< y coordinate, code 20 */
|
|
double stawidth; /*!< Start width, code 40 */
|
|
double endwidth; /*!< End width, code 41 */
|
|
double bulge; /*!< bulge, code 42 */
|
|
};
|
|
|
|
|
|
//! Class to handle header vars
|
|
/*!
|
|
* Class to handle header vars
|
|
* @author Rallaz
|
|
*/
|
|
class DRW_Variant {
|
|
public:
|
|
enum TYPE {
|
|
STRING,
|
|
INTEGER,
|
|
DOUBLE,
|
|
COORD,
|
|
INVALID
|
|
};
|
|
//TODO: add INT64 support
|
|
DRW_Variant(): sdata(std::string()), vdata(), content(0), vType(INVALID), vCode(0) {}
|
|
|
|
DRW_Variant(int c, dint32 i): sdata(std::string()), vdata(), content(i), vType(INTEGER), vCode(c){}
|
|
|
|
DRW_Variant(int c, duint32 i): sdata(std::string()), vdata(), content(static_cast<dint32>(i)), vType(INTEGER), vCode(c) {}
|
|
|
|
DRW_Variant(int c, double d): sdata(std::string()), vdata(), content(d), vType(DOUBLE), vCode(c) {}
|
|
|
|
DRW_Variant(int c, UTF8STRING s): sdata(s), vdata(), content(&sdata), vType(STRING), vCode(c) {}
|
|
|
|
DRW_Variant(int c, DRW_Coord crd): sdata(std::string()), vdata(crd), content(&vdata), vType(COORD), vCode(c) {}
|
|
|
|
DRW_Variant(const DRW_Variant& d): sdata(d.sdata), vdata(d.vdata), content(d.content), vType(d.vType), vCode(d.vCode) {
|
|
if (d.vType == COORD)
|
|
content.v = &vdata;
|
|
if (d.vType == STRING)
|
|
content.s = &sdata;
|
|
}
|
|
|
|
~DRW_Variant() {
|
|
}
|
|
|
|
void addString(int c, UTF8STRING s) {vType = STRING; sdata = s; content.s = &sdata; vCode=c;}
|
|
void addInt(int c, int i) {vType = INTEGER; content.i = i; vCode=c;}
|
|
void addDouble(int c, double d) {vType = DOUBLE; content.d = d; vCode=c;}
|
|
void addCoord(int c, DRW_Coord v) {vType = COORD; vdata = v; content.v = &vdata; vCode=c;}
|
|
void setCoordX(double d) { if (vType == COORD) vdata.x = d;}
|
|
void setCoordY(double d) { if (vType == COORD) vdata.y = d;}
|
|
void setCoordZ(double d) { if (vType == COORD) vdata.z = d;}
|
|
enum TYPE type() { return vType;}
|
|
int code() { return vCode;} /*!< returns dxf code of this value*/
|
|
|
|
private:
|
|
std::string sdata;
|
|
DRW_Coord vdata;
|
|
|
|
private:
|
|
union DRW_VarContent{
|
|
UTF8STRING *s;
|
|
dint32 i;
|
|
double d;
|
|
DRW_Coord *v;
|
|
|
|
DRW_VarContent(UTF8STRING *sd):s(sd){}
|
|
DRW_VarContent(dint32 id):i(id){}
|
|
DRW_VarContent(double dd):d(dd){}
|
|
DRW_VarContent(DRW_Coord *vd):v(vd){}
|
|
};
|
|
|
|
public:
|
|
DRW_VarContent content;
|
|
private:
|
|
enum TYPE vType;
|
|
int vCode; /*!< dxf code of this value*/
|
|
|
|
};
|
|
|
|
//! Class to handle dwg handles
|
|
/*!
|
|
* Class to handle dwg handles
|
|
* @author Rallaz
|
|
*/
|
|
class dwgHandle{
|
|
public:
|
|
dwgHandle(): code(0), size(0), ref(0){}
|
|
|
|
~dwgHandle(){}
|
|
duint8 code;
|
|
duint8 size;
|
|
duint32 ref;
|
|
};
|
|
|
|
//! Class to convert between line width and integer
|
|
/*!
|
|
* Class to convert between line width and integer
|
|
* verifing valid values, if value is not valid
|
|
* returns widthDefault.
|
|
* @author Rallaz
|
|
*/
|
|
class DRW_LW_Conv{
|
|
public:
|
|
enum lineWidth {
|
|
width00 = 0, /*!< 0.00mm (dxf 0)*/
|
|
width01 = 1, /*!< 0.05mm (dxf 5)*/
|
|
width02 = 2, /*!< 0.09mm (dxf 9)*/
|
|
width03 = 3, /*!< 0.13mm (dxf 13)*/
|
|
width04 = 4, /*!< 0.15mm (dxf 15)*/
|
|
width05 = 5, /*!< 0.18mm (dxf 18)*/
|
|
width06 = 6, /*!< 0.20mm (dxf 20)*/
|
|
width07 = 7, /*!< 0.25mm (dxf 25)*/
|
|
width08 = 8, /*!< 0.30mm (dxf 30)*/
|
|
width09 = 9, /*!< 0.35mm (dxf 35)*/
|
|
width10 = 10, /*!< 0.40mm (dxf 40)*/
|
|
width11 = 11, /*!< 0.50mm (dxf 50)*/
|
|
width12 = 12, /*!< 0.53mm (dxf 53)*/
|
|
width13 = 13, /*!< 0.60mm (dxf 60)*/
|
|
width14 = 14, /*!< 0.70mm (dxf 70)*/
|
|
width15 = 15, /*!< 0.80mm (dxf 80)*/
|
|
width16 = 16, /*!< 0.90mm (dxf 90)*/
|
|
width17 = 17, /*!< 1.00mm (dxf 100)*/
|
|
width18 = 18, /*!< 1.06mm (dxf 106)*/
|
|
width19 = 19, /*!< 1.20mm (dxf 120)*/
|
|
width20 = 20, /*!< 1.40mm (dxf 140)*/
|
|
width21 = 21, /*!< 1.58mm (dxf 158)*/
|
|
width22 = 22, /*!< 2.00mm (dxf 200)*/
|
|
width23 = 23, /*!< 2.11mm (dxf 211)*/
|
|
widthByLayer = 29, /*!< by layer (dxf -1) */
|
|
widthByBlock = 30, /*!< by block (dxf -2) */
|
|
widthDefault = 31 /*!< by default (dxf -3) */
|
|
};
|
|
|
|
static int lineWidth2dxfInt(enum lineWidth lw){
|
|
switch (lw){
|
|
case widthByLayer:
|
|
return -1;
|
|
case widthByBlock:
|
|
return -2;
|
|
case widthDefault:
|
|
return -3;
|
|
case width00:
|
|
return 0;
|
|
case width01:
|
|
return 5;
|
|
case width02:
|
|
return 9;
|
|
case width03:
|
|
return 13;
|
|
case width04:
|
|
return 15;
|
|
case width05:
|
|
return 18;
|
|
case width06:
|
|
return 20;
|
|
case width07:
|
|
return 25;
|
|
case width08:
|
|
return 30;
|
|
case width09:
|
|
return 35;
|
|
case width10:
|
|
return 40;
|
|
case width11:
|
|
return 50;
|
|
case width12:
|
|
return 53;
|
|
case width13:
|
|
return 60;
|
|
case width14:
|
|
return 70;
|
|
case width15:
|
|
return 80;
|
|
case width16:
|
|
return 90;
|
|
case width17:
|
|
return 100;
|
|
case width18:
|
|
return 106;
|
|
case width19:
|
|
return 120;
|
|
case width20:
|
|
return 140;
|
|
case width21:
|
|
return 158;
|
|
case width22:
|
|
return 200;
|
|
case width23:
|
|
return 211;
|
|
default:
|
|
break;
|
|
}
|
|
return -3;
|
|
}
|
|
|
|
static int lineWidth2dwgInt(enum lineWidth lw){
|
|
return static_cast<int> (lw);
|
|
}
|
|
|
|
static enum lineWidth dxfInt2lineWidth(int i){
|
|
if (i<0) {
|
|
if (i==-1)
|
|
return widthByLayer;
|
|
else if (i==-2)
|
|
return widthByBlock;
|
|
else if (i==-3)
|
|
return widthDefault;
|
|
} else if (i<3) {
|
|
return width00;
|
|
} else if (i<7) {
|
|
return width01;
|
|
} else if (i<11) {
|
|
return width02;
|
|
} else if (i<14) {
|
|
return width03;
|
|
} else if (i<16) {
|
|
return width04;
|
|
} else if (i<19) {
|
|
return width05;
|
|
} else if (i<22) {
|
|
return width06;
|
|
} else if (i<27) {
|
|
return width07;
|
|
} else if (i<32) {
|
|
return width08;
|
|
} else if (i<37) {
|
|
return width09;
|
|
} else if (i<45) {
|
|
return width10;
|
|
} else if (i<52) {
|
|
return width11;
|
|
} else if (i<57) {
|
|
return width12;
|
|
} else if (i<65) {
|
|
return width13;
|
|
} else if (i<75) {
|
|
return width14;
|
|
} else if (i<85) {
|
|
return width15;
|
|
} else if (i<95) {
|
|
return width16;
|
|
} else if (i<103) {
|
|
return width17;
|
|
} else if (i<112) {
|
|
return width18;
|
|
} else if (i<130) {
|
|
return width19;
|
|
} else if (i<149) {
|
|
return width20;
|
|
} else if (i<180) {
|
|
return width21;
|
|
} else if (i<205) {
|
|
return width22;
|
|
} else {
|
|
return width23;
|
|
}
|
|
//default by default
|
|
return widthDefault;
|
|
}
|
|
|
|
static enum lineWidth dwgInt2lineWidth(int i){
|
|
if ( (i>-1 && i<24) || (i>28 && i<32) ) {
|
|
return static_cast<lineWidth> (i);
|
|
}
|
|
//default by default
|
|
return widthDefault;
|
|
}
|
|
};
|
|
|
|
#endif
|
|
|
|
// EOF
|
|
|