Added secondary files

1 files changed, 493 insertions, 0 deletions

diff --git a/lib_dxf/drw_base.h b/lib_dxf/drw_base.h
new file mode 100644
index 0000000..df8f155
--- /dev/null
+++ b/lib_dxf/drw_base.h
@@ -0,0 +1,493 @@
+/******************************************************************************
+**  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 <http://www.gnu.org/licenses/>.    **
+******************************************************************************/
+
+#ifndef DRW_BASE_H
+#define DRW_BASE_H
+
+#define DRW_VERSION "0.5.13"
+
+#include <string>
+#include <cmath>
+
+#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
+
+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. */
+};
+
+enum error
+{
+    BAD_NONE,               /*!< No error. */
+    BAD_UNKNOWN,            /*!< UNKNOWN. */
+    BAD_OPEN,               /*!< error opening file. */
+    BAD_VERSION,            /*!< unsupported version. */
+    BAD_READ_FILE_HEADER,   /*!< error in file header read process. */
+    BAD_READ_HEADER,        /*!< error in header vars read process. */
+    BAD_READ_OFFSETS,       /*!< error in object map read process. */
+    BAD_READ_CLASSES,       /*!< error in classes read process. */
+    BAD_READ_TABLES,        /*!< error in tables read process. */
+    BAD_READ_ENTITIES       /*!< error in entities read process. */
+};
+}
+
+// ! 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()
+    {
+// eType = DRW::LWPOLYLINE;
+        x = y = stawidth = endwidth = bulge = 0.0;
+    }
+
+    DRW_Vertex2D( double sx, double sy, double b )
+    {
+        stawidth = endwidth = 0;
+        x   = sx;
+        y   = sy;
+        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
+    };
+
+    DRW_Variant()
+    {
+        type = INVALID;
+        code = 0;
+    }
+
+    DRW_Variant( const DRW_Variant& d )
+    {
+        code    = d.code;
+        type    = d.type;
+
+        if( d.type == COORD ) vdata = d.vdata;
+
+        if( d.type == STRING ) sdata = d.sdata;
+
+        content = d.content;
+    }
+
+    DRW_Variant( int c, UTF8STRING s ) { addString( s ); code = c; }
+    DRW_Variant( int c, int i ) { addInt( i ); code = c; }
+    DRW_Variant( int c, double d ) { addDouble( d ); code = c; }
+    DRW_Variant( int c, double x, double y, double z )
+    {
+        setType( COORD ); vdata.x = x; vdata.y = y;
+        vdata.z = z; content.v = &vdata; code = c;
+    }
+
+    ~DRW_Variant()
+    {
+    }
+
+    void addString( UTF8STRING s ) { setType( STRING ); sdata = s; content.s = &sdata; }
+    void addInt( int i ) { setType( INTEGER ); content.i = i; }
+    void addDouble( double d ) { setType( DOUBLE ); content.d = d; }
+    void addCoord()
+    {
+        setType( COORD ); vdata.x = 0.0; vdata.y = 0.0; vdata.z = 0.0; content.v =
+            &vdata;
+    }
+
+    void addCoord( DRW_Coord v ) { setType( COORD ); vdata = v; content.v = &vdata; }
+    void setType( enum TYPE t ) { type = t; }
+    void setCoordX( double d ) { if( type == COORD ) vdata.x = d; }
+    void setCoordY( double d ) { if( type == COORD ) vdata.y = d; }
+    void setCoordZ( double d ) { if( type == COORD ) vdata.z = d; }
+
+private:
+    typedef union
+    {
+        UTF8STRING* s;
+        int i;
+        double d;
+        DRW_Coord* v;
+    } DRW_VarContent;
+
+public:
+    DRW_VarContent content;
+    enum TYPE type;
+    int code;            /*!< dxf code of this value*/
+
+private:
+    std::string sdata;
+    DRW_Coord   vdata;
+};
+
+
+// ! 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:
+            return -3;
+        }
+
+        return static_cast<int> (lw);
+    }
+
+    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