dl_entities.h

Go to the documentation of this file.

/****************************************************************************
** Copyright (C) 2001-2013 RibbonSoft, GmbH. All rights reserved.
**
** This file is part of the dxflib project.
**
** This file is free software; you can redistribute it and/or modify
** it 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.
**
** Licensees holding valid dxflib Professional Edition licenses may use
** this file in accordance with the dxflib Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.ribbonsoft.com for further details.
**
** Contact info@ribbonsoft.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
 
#ifndef DL_ENTITIES_H
#define DL_ENTITIES_H
 
#include <string>
#include <vector>
 
#include "dl_global.h"
 
struct DXFLIB_EXPORT DL_LayerData {
    DL_LayerData(const std::string& name, int flags, bool off = false)
        : name(name), flags(flags), off(off) {}
 
    std::string name;
    int flags;
    bool off;
};
 
struct DXFLIB_EXPORT DL_BlockData {
    DL_BlockData(const std::string& bName,
                 int bFlags,
                 double bbpx,
                 double bbpy,
                 double bbpz) {
        name = bName;
        flags = bFlags;
        bpx = bbpx;
        bpy = bbpy;
        bpz = bbpz;
    }
 
    std::string name;
    int flags;
    double bpx;
    double bpy;
    double bpz;
};
 
struct DXFLIB_EXPORT DL_LinetypeData {
    DL_LinetypeData(const std::string& name,
                    const std::string& description,
                    int flags,
                    int numberOfDashes,
                    double patternLength,
                    double* pattern = NULL)
        : name(name),
          description(description),
          flags(flags),
          numberOfDashes(numberOfDashes),
          patternLength(patternLength),
          pattern(pattern) {}
 
    std::string name;
    std::string description;
    int flags;
    int numberOfDashes;
    double patternLength;
    double* pattern;
};
 
struct DXFLIB_EXPORT DL_StyleData {
    DL_StyleData(const std::string& name,
                 int flags,
                 double fixedTextHeight,
                 double widthFactor,
                 double obliqueAngle,
                 int textGenerationFlags,
                 double lastHeightUsed,
                 const std::string& primaryFontFile,
                 const std::string& bigFontFile)
        : name(name),
          flags(flags),
          fixedTextHeight(fixedTextHeight),
          widthFactor(widthFactor),
          obliqueAngle(obliqueAngle),
          textGenerationFlags(textGenerationFlags),
          lastHeightUsed(lastHeightUsed),
          primaryFontFile(primaryFontFile),
          bigFontFile(bigFontFile),
          bold(false),
          italic(false) {}
 
    bool operator==(const DL_StyleData& other) {
        // ignore lastHeightUsed:
        return (name == other.name && flags == other.flags &&
                fixedTextHeight == other.fixedTextHeight &&
                widthFactor == other.widthFactor &&
                obliqueAngle == other.obliqueAngle &&
                textGenerationFlags == other.textGenerationFlags &&
                primaryFontFile == other.primaryFontFile &&
                bigFontFile == other.bigFontFile);
    }
 
    std::string name;
    int flags;
    double fixedTextHeight;
    double widthFactor;
    double obliqueAngle;
    int textGenerationFlags;
    double lastHeightUsed;
    std::string primaryFontFile;
    std::string bigFontFile;
 
    bool bold;
    bool italic;
};
 
struct DXFLIB_EXPORT DL_PointData {
    DL_PointData(double px = 0.0, double py = 0.0, double pz = 0.0) {
        x = px;
        y = py;
        z = pz;
    }
 
    double x;
    double y;
    double z;
};
 
struct DXFLIB_EXPORT DL_LineData {
    DL_LineData(double lx1,
                double ly1,
                double lz1,
                double lx2,
                double ly2,
                double lz2) {
        x1 = lx1;
        y1 = ly1;
        z1 = lz1;
 
        x2 = lx2;
        y2 = ly2;
        z2 = lz2;
    }
 
    double x1;
    double y1;
    double z1;
 
    double x2;
    double y2;
    double z2;
};
 
struct DXFLIB_EXPORT DL_XLineData {
    DL_XLineData(
            double bx, double by, double bz, double dx, double dy, double dz)
        : bx(bx), by(by), bz(bz), dx(dx), dy(dy), dz(dz) {}
 
    double bx;
    double by;
    double bz;
 
    double dx;
    double dy;
    double dz;
};
 
struct DXFLIB_EXPORT DL_RayData {
    DL_RayData(double bx, double by, double bz, double dx, double dy, double dz)
        : bx(bx), by(by), bz(bz), dx(dx), dy(dy), dz(dz) {}
 
    double bx;
    double by;
    double bz;
 
    double dx;
    double dy;
    double dz;
};
 
struct DXFLIB_EXPORT DL_ArcData {
    DL_ArcData(double acx,
               double acy,
               double acz,
               double aRadius,
               double aAngle1,
               double aAngle2) {
        cx = acx;
        cy = acy;
        cz = acz;
        radius = aRadius;
        angle1 = aAngle1;
        angle2 = aAngle2;
    }
 
    double cx;
    double cy;
    double cz;
 
    double radius;
    double angle1;
    double angle2;
};
 
struct DXFLIB_EXPORT DL_CircleData {
    DL_CircleData(double acx, double acy, double acz, double aRadius) {
        cx = acx;
        cy = acy;
        cz = acz;
        radius = aRadius;
    }
 
    double cx;
    double cy;
    double cz;
 
    double radius;
};
 
struct DXFLIB_EXPORT DL_PolylineData {
    DL_PolylineData(int pNumber,
                    int pMVerteces,
                    int pNVerteces,
                    int pFlags,
                    double pElevation = 0.0) {
        number = pNumber;
        m = pMVerteces;
        n = pNVerteces;
        elevation = pElevation;
        flags = pFlags;
    }
 
    unsigned int number;
 
    unsigned int m;
 
    unsigned int n;
 
    double elevation;
 
    int flags;
};
 
struct DXFLIB_EXPORT DL_VertexData {
    DL_VertexData(double px = 0.0,
                  double py = 0.0,
                  double pz = 0.0,
                  double pBulge = 0.0) {
        x = px;
        y = py;
        z = pz;
        bulge = pBulge;
    }
 
    double x;
    double y;
    double z;
    double bulge;
};
 
struct DXFLIB_EXPORT DL_TraceData {
    DL_TraceData() {
        thickness = 0.0;
        for (int i = 0; i < 4; i++) {
            x[i] = 0.0;
            y[i] = 0.0;
            z[i] = 0.0;
        }
    }
 
    DL_TraceData(double sx1,
                 double sy1,
                 double sz1,
                 double sx2,
                 double sy2,
                 double sz2,
                 double sx3,
                 double sy3,
                 double sz3,
                 double sx4,
                 double sy4,
                 double sz4,
                 double sthickness = 0.0) {
        thickness = sthickness;
 
        x[0] = sx1;
        y[0] = sy1;
        z[0] = sz1;
 
        x[1] = sx2;
        y[1] = sy2;
        z[1] = sz2;
 
        x[2] = sx3;
        y[2] = sy3;
        z[2] = sz3;
 
        x[3] = sx4;
        y[3] = sy4;
        z[3] = sz4;
    }
 
    double thickness;
 
    double x[4];
    double y[4];
    double z[4];
};
 
typedef DL_TraceData DL_SolidData;
 
typedef DL_TraceData DL_3dFaceData;
 
struct DXFLIB_EXPORT DL_SplineData {
    DL_SplineData(int degree, int nKnots, int nControl, int nFit, int flags)
        : degree(degree),
          nKnots(nKnots),
          nControl(nControl),
          nFit(nFit),
          flags(flags) {}
 
    unsigned int degree;
 
    unsigned int nKnots;
 
    unsigned int nControl;
 
    unsigned int nFit;
 
    int flags;
 
    double tangentStartX;
    double tangentStartY;
    double tangentStartZ;
    double tangentEndX;
    double tangentEndY;
    double tangentEndZ;
};
 
struct DXFLIB_EXPORT DL_KnotData {
    DL_KnotData() {}
    DL_KnotData(double pk) { k = pk; }
 
    double k;
};
 
struct DXFLIB_EXPORT DL_ControlPointData {
    DL_ControlPointData(double px, double py, double pz, double weight) {
        x = px;
        y = py;
        z = pz;
        w = weight;
    }
 
    double x;
    double y;
    double z;
    double w;
};
 
struct DXFLIB_EXPORT DL_FitPointData {
    DL_FitPointData(double x, double y, double z) : x(x), y(y), z(z) {}
 
    double x;
    double y;
    double z;
};
 
struct DXFLIB_EXPORT DL_EllipseData {
    DL_EllipseData(double cx,
                   double cy,
                   double cz,
                   double mx,
                   double my,
                   double mz,
                   double ratio,
                   double angle1,
                   double angle2)
        : cx(cx),
          cy(cy),
          cz(cz),
          mx(mx),
          my(my),
          mz(mz),
          ratio(ratio),
          angle1(angle1),
          angle2(angle2) {}
 
    double cx;
    double cy;
    double cz;
 
    double mx;
    double my;
    double mz;
 
    double ratio;
    double angle1;
    double angle2;
};
 
struct DXFLIB_EXPORT DL_InsertData {
    DL_InsertData(const std::string& name,
                  double ipx,
                  double ipy,
                  double ipz,
                  double sx,
                  double sy,
                  double sz,
                  double angle,
                  int cols,
                  int rows,
                  double colSp,
                  double rowSp)
        : name(name),
          ipx(ipx),
          ipy(ipy),
          ipz(ipz),
          sx(sx),
          sy(sy),
          sz(sz),
          angle(angle),
          cols(cols),
          rows(rows),
          colSp(colSp),
          rowSp(rowSp) {}
 
    std::string name;
    double ipx;
    double ipy;
    double ipz;
    double sx;
    double sy;
    double sz;
    double angle;
    int cols;
    int rows;
    double colSp;
    double rowSp;
};
 
struct DXFLIB_EXPORT DL_MTextData {
    DL_MTextData(double ipx,
                 double ipy,
                 double ipz,
                 double dirx,
                 double diry,
                 double dirz,
                 double height,
                 double width,
                 int attachmentPoint,
                 int drawingDirection,
                 int lineSpacingStyle,
                 double lineSpacingFactor,
                 const std::string& text,
                 const std::string& style,
                 double angle)
        : ipx(ipx),
          ipy(ipy),
          ipz(ipz),
          dirx(dirx),
          diry(diry),
          dirz(dirz),
          height(height),
          width(width),
          attachmentPoint(attachmentPoint),
          drawingDirection(drawingDirection),
          lineSpacingStyle(lineSpacingStyle),
          lineSpacingFactor(lineSpacingFactor),
          text(text),
          style(style),
          angle(angle) {}
 
    double ipx;
    double ipy;
    double ipz;
    double dirx;
    double diry;
    double dirz;
    double height;
    double width;
    int attachmentPoint;
    int drawingDirection;
    int lineSpacingStyle;
    double lineSpacingFactor;
    std::string text;
    std::string style;
    double angle;
};
 
struct DXFLIB_EXPORT DL_TextData {
    DL_TextData(double ipx,
                double ipy,
                double ipz,
                double apx,
                double apy,
                double apz,
                double height,
                double xScaleFactor,
                int textGenerationFlags,
                int hJustification,
                int vJustification,
                const std::string& text,
                const std::string& style,
                double angle)
        : ipx(ipx),
          ipy(ipy),
          ipz(ipz),
          apx(apx),
          apy(apy),
          apz(apz),
          height(height),
          xScaleFactor(xScaleFactor),
          textGenerationFlags(textGenerationFlags),
          hJustification(hJustification),
          vJustification(vJustification),
          text(text),
          style(style),
          angle(angle) {}
 
    double ipx;
    double ipy;
    double ipz;
 
    double apx;
    double apy;
    double apz;
 
    double height;
    double xScaleFactor;
    int textGenerationFlags;
    int hJustification;
    int vJustification;
    std::string text;
    std::string style;
    double angle;
};
 
struct DXFLIB_EXPORT DL_ArcAlignedTextData {
    std::string text;
    std::string font;
    std::string style;
 
    double cx;
    double cy;
    double cz;
    double radius;
 
    double xScaleFactor;
    double height;
    double spacing;
    double offset;
    double rightOffset;
    double leftOffset;
    double startAngle;
    double endAngle;
    bool reversedCharacterOrder;
    int direction;
    int alignment;
    int side;
    bool bold;
    bool italic;
    bool underline;
    int characerSet;
    int pitch;
    bool shxFont;
    bool wizard;
    int arcHandle;
};
 
struct DXFLIB_EXPORT DL_AttributeData : public DL_TextData {
    DL_AttributeData(const DL_TextData& tData, const std::string& tag)
        : DL_TextData(tData), tag(tag) {}
 
    DL_AttributeData(double ipx,
                     double ipy,
                     double ipz,
                     double apx,
                     double apy,
                     double apz,
                     double height,
                     double xScaleFactor,
                     int textGenerationFlags,
                     int hJustification,
                     int vJustification,
                     const std::string& tag,
                     const std::string& text,
                     const std::string& style,
                     double angle)
        : DL_TextData(ipx,
                      ipy,
                      ipz,
                      apx,
                      apy,
                      apz,
                      height,
                      xScaleFactor,
                      textGenerationFlags,
                      hJustification,
                      vJustification,
                      text,
                      style,
                      angle),
          tag(tag) {}
 
    std::string tag;
};
 
struct DXFLIB_EXPORT DL_DimensionData {
    DL_DimensionData(double dpx,
                     double dpy,
                     double dpz,
                     double mpx,
                     double mpy,
                     double mpz,
                     int type,
                     int attachmentPoint,
                     int lineSpacingStyle,
                     double lineSpacingFactor,
                     const std::string& text,
                     const std::string& style,
                     double angle,
                     double linearFactor = 1.0,
                     double dimScale = 1.0)
        : dpx(dpx),
          dpy(dpy),
          dpz(dpz),
          mpx(mpx),
          mpy(mpy),
          mpz(mpz),
          type(type),
          attachmentPoint(attachmentPoint),
          lineSpacingStyle(lineSpacingStyle),
          lineSpacingFactor(lineSpacingFactor),
          text(text),
          style(style),
          angle(angle),
          linearFactor(linearFactor),
          dimScale(dimScale) {}
 
    double dpx;
    double dpy;
    double dpz;
    double mpx;
    double mpy;
    double mpz;
    int type;
    int attachmentPoint;
    int lineSpacingStyle;
    double lineSpacingFactor;
    std::string text;
    std::string style;
    double angle;
    double linearFactor;
    double dimScale;
};
 
struct DXFLIB_EXPORT DL_DimAlignedData {
    DL_DimAlignedData(double depx1,
                      double depy1,
                      double depz1,
                      double depx2,
                      double depy2,
                      double depz2) {
        epx1 = depx1;
        epy1 = depy1;
        epz1 = depz1;
 
        epx2 = depx2;
        epy2 = depy2;
        epz2 = depz2;
    }
 
    double epx1;
    double epy1;
    double epz1;
 
    double epx2;
    double epy2;
    double epz2;
};
 
struct DXFLIB_EXPORT DL_DimLinearData {
    DL_DimLinearData(double ddpx1,
                     double ddpy1,
                     double ddpz1,
                     double ddpx2,
                     double ddpy2,
                     double ddpz2,
                     double dAngle,
                     double dOblique) {
        dpx1 = ddpx1;
        dpy1 = ddpy1;
        dpz1 = ddpz1;
 
        dpx2 = ddpx2;
        dpy2 = ddpy2;
        dpz2 = ddpz2;
 
        angle = dAngle;
        oblique = dOblique;
    }
 
    double dpx1;
    double dpy1;
    double dpz1;
 
    double dpx2;
    double dpy2;
    double dpz2;
 
    double angle;
    double oblique;
};
 
struct DXFLIB_EXPORT DL_DimRadialData {
    DL_DimRadialData(double ddpx, double ddpy, double ddpz, double dleader) {
        dpx = ddpx;
        dpy = ddpy;
        dpz = ddpz;
 
        leader = dleader;
    }
 
    double dpx;
    double dpy;
    double dpz;
 
    double leader;
};
 
struct DXFLIB_EXPORT DL_DimDiametricData {
    DL_DimDiametricData(double ddpx, double ddpy, double ddpz, double dleader) {
        dpx = ddpx;
        dpy = ddpy;
        dpz = ddpz;
 
        leader = dleader;
    }
 
    double dpx;
    double dpy;
    double dpz;
 
    double leader;
};
 
struct DXFLIB_EXPORT DL_DimAngularData {
    DL_DimAngularData(double ddpx1,
                      double ddpy1,
                      double ddpz1,
                      double ddpx2,
                      double ddpy2,
                      double ddpz2,
                      double ddpx3,
                      double ddpy3,
                      double ddpz3,
                      double ddpx4,
                      double ddpy4,
                      double ddpz4) {
        dpx1 = ddpx1;
        dpy1 = ddpy1;
        dpz1 = ddpz1;
 
        dpx2 = ddpx2;
        dpy2 = ddpy2;
        dpz2 = ddpz2;
 
        dpx3 = ddpx3;
        dpy3 = ddpy3;
        dpz3 = ddpz3;
 
        dpx4 = ddpx4;
        dpy4 = ddpy4;
        dpz4 = ddpz4;
    }
 
    double dpx1;
    double dpy1;
    double dpz1;
 
    double dpx2;
    double dpy2;
    double dpz2;
 
    double dpx3;
    double dpy3;
    double dpz3;
 
    double dpx4;
    double dpy4;
    double dpz4;
};
 
struct DXFLIB_EXPORT DL_DimAngular3PData {
    DL_DimAngular3PData(double ddpx1,
                        double ddpy1,
                        double ddpz1,
                        double ddpx2,
                        double ddpy2,
                        double ddpz2,
                        double ddpx3,
                        double ddpy3,
                        double ddpz3) {
        dpx1 = ddpx1;
        dpy1 = ddpy1;
        dpz1 = ddpz1;
 
        dpx2 = ddpx2;
        dpy2 = ddpy2;
        dpz2 = ddpz2;
 
        dpx3 = ddpx3;
        dpy3 = ddpy3;
        dpz3 = ddpz3;
    }
 
    double dpx1;
    double dpy1;
    double dpz1;
 
    double dpx2;
    double dpy2;
    double dpz2;
 
    double dpx3;
    double dpy3;
    double dpz3;
};
 
struct DXFLIB_EXPORT DL_DimOrdinateData {
    DL_DimOrdinateData(double ddpx1,
                       double ddpy1,
                       double ddpz1,
                       double ddpx2,
                       double ddpy2,
                       double ddpz2,
                       bool dxtype) {
        dpx1 = ddpx1;
        dpy1 = ddpy1;
        dpz1 = ddpz1;
 
        dpx2 = ddpx2;
        dpy2 = ddpy2;
        dpz2 = ddpz2;
 
        xtype = dxtype;
    }
 
    double dpx1;
    double dpy1;
    double dpz1;
 
    double dpx2;
    double dpy2;
    double dpz2;
 
    bool xtype;
};
 
struct DXFLIB_EXPORT DL_LeaderData {
    DL_LeaderData(int lArrowHeadFlag,
                  int lLeaderPathType,
                  int lLeaderCreationFlag,
                  int lHooklineDirectionFlag,
                  int lHooklineFlag,
                  double lTextAnnotationHeight,
                  double lTextAnnotationWidth,
                  int lNumber) {
        arrowHeadFlag = lArrowHeadFlag;
        leaderPathType = lLeaderPathType;
        leaderCreationFlag = lLeaderCreationFlag;
        hooklineDirectionFlag = lHooklineDirectionFlag;
        hooklineFlag = lHooklineFlag;
        textAnnotationHeight = lTextAnnotationHeight;
        textAnnotationWidth = lTextAnnotationWidth;
        number = lNumber;
    }
 
    int arrowHeadFlag;
    int leaderPathType;
    int leaderCreationFlag;
    int hooklineDirectionFlag;
    int hooklineFlag;
    double textAnnotationHeight;
    double textAnnotationWidth;
    int number;
};
 
struct DXFLIB_EXPORT DL_LeaderVertexData {
    DL_LeaderVertexData(double px = 0.0, double py = 0.0, double pz = 0.0) {
        x = px;
        y = py;
        z = pz;
    }
 
    double x;
    double y;
    double z;
};
 
struct DXFLIB_EXPORT DL_HatchData {
    DL_HatchData() {}
 
    DL_HatchData(int numLoops,
                 bool solid,
                 double scale,
                 double angle,
                 const std::string& pattern,
                 double originX = 0.0,
                 double originY = 0.0)
        : numLoops(numLoops),
          solid(solid),
          scale(scale),
          angle(angle),
          pattern(pattern),
          originX(originX),
          originY(originY) {}
 
    int numLoops;
    bool solid;
    double scale;
    double angle;
    std::string pattern;
    double originX;
    double originY;
};
 
struct DXFLIB_EXPORT DL_HatchLoopData {
    DL_HatchLoopData() {}
    DL_HatchLoopData(int hNumEdges) { numEdges = hNumEdges; }
 
    int numEdges;
};
 
struct DXFLIB_EXPORT DL_HatchEdgeData {
    DL_HatchEdgeData() : defined(false), x1(0.0), y1(0.0), x2(0.0), y2(0.0) {}
 
    DL_HatchEdgeData(double x1, double y1, double x2, double y2)
        : defined(true), type(1), x1(x1), y1(y1), x2(x2), y2(y2) {}
 
    DL_HatchEdgeData(double cx,
                     double cy,
                     double radius,
                     double angle1,
                     double angle2,
                     bool ccw)
        : defined(true),
          type(2),
          cx(cx),
          cy(cy),
          radius(radius),
          angle1(angle1),
          angle2(angle2),
          ccw(ccw) {}
 
    DL_HatchEdgeData(double cx,
                     double cy,
                     double mx,
                     double my,
                     double ratio,
                     double angle1,
                     double angle2,
                     bool ccw)
        : defined(true),
          type(3),
          cx(cx),
          cy(cy),
          angle1(angle1),
          angle2(angle2),
          ccw(ccw),
          mx(mx),
          my(my),
          ratio(ratio) {}
 
    DL_HatchEdgeData(unsigned int degree,
                     bool rational,
                     bool periodic,
                     unsigned int nKnots,
                     unsigned int nControl,
                     unsigned int nFit,
                     const std::vector<double>& knots,
                     const std::vector<std::vector<double>>& controlPoints,
                     const std::vector<std::vector<double>>& fitPoints,
                     const std::vector<double>& weights,
                     double startTangentX,
                     double startTangentY,
                     double endTangentX,
                     double endTangentY)
        : defined(true),
          type(4),
          degree(degree),
          rational(rational),
          periodic(periodic),
          nKnots(nKnots),
          nControl(nControl),
          nFit(nFit),
          controlPoints(controlPoints),
          knots(knots),
          weights(weights),
          fitPoints(fitPoints),
          startTangentX(startTangentX),
          startTangentY(startTangentY),
          endTangentX(endTangentX),
          endTangentY(endTangentY) {}
 
    bool defined;
 
    int type;
 
    // line edges:
 
    double x1;
    double y1;
    double x2;
    double y2;
 
    double cx;
    double cy;
    double radius;
    double angle1;
    double angle2;
    bool ccw;
 
    double mx;
    double my;
    double ratio;
 
    unsigned int degree;
    bool rational;
    bool periodic;
    unsigned int nKnots;
    unsigned int nControl;
    unsigned int nFit;
 
    std::vector<std::vector<double>> controlPoints;
    std::vector<double> knots;
    std::vector<double> weights;
    std::vector<std::vector<double>> fitPoints;
 
    double startTangentX;
    double startTangentY;
 
    double endTangentX;
    double endTangentY;
 
    std::vector<std::vector<double>> vertices;
    // bool closed;
};
 
struct DXFLIB_EXPORT DL_ImageData {
    DL_ImageData(const std::string& iref,
                 double iipx,
                 double iipy,
                 double iipz,
                 double iux,
                 double iuy,
                 double iuz,
                 double ivx,
                 double ivy,
                 double ivz,
                 int iwidth,
                 int iheight,
                 int ibrightness,
                 int icontrast,
                 int ifade) {
        ref = iref;
        ipx = iipx;
        ipy = iipy;
        ipz = iipz;
        ux = iux;
        uy = iuy;
        uz = iuz;
        vx = ivx;
        vy = ivy;
        vz = ivz;
        width = iwidth;
        height = iheight;
        brightness = ibrightness;
        contrast = icontrast;
        fade = ifade;
    }
 
    std::string ref;
    double ipx;
    double ipy;
    double ipz;
    double ux;
    double uy;
    double uz;
    double vx;
    double vy;
    double vz;
    int width;
    int height;
    int brightness;
    int contrast;
    int fade;
};
 
struct DXFLIB_EXPORT DL_ImageDefData {
    DL_ImageDefData(const std::string& iref, const std::string& ifile) {
        ref = iref;
        file = ifile;
    }
 
    std::string ref;
 
    std::string file;
};
 
struct DXFLIB_EXPORT DL_DictionaryData {
    DL_DictionaryData(const std::string& handle) : handle(handle) {}
    std::string handle;
};
 
struct DXFLIB_EXPORT DL_DictionaryEntryData {
    DL_DictionaryEntryData(const std::string& name, const std::string& handle)
        : name(name), handle(handle) {}
 
    std::string name;
    std::string handle;
};
 
#endif
 
// EOF