Horizon
dl_dxf.h
1/****************************************************************************
2** Copyright (C) 2001-2013 RibbonSoft, GmbH. All rights reserved.
3**
4** This file is part of the dxflib project.
5**
6** This file is free software; you can redistribute it and/or modify
7** it under the terms of the GNU General Public License as published by
8** the Free Software Foundation; either version 2 of the License, or
9** (at your option) any later version.
10**
11** Licensees holding valid dxflib Professional Edition licenses may use
12** this file in accordance with the dxflib Commercial License
13** Agreement provided with the Software.
14**
15** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
17**
18** See http://www.ribbonsoft.com for further details.
19**
20** Contact info@ribbonsoft.com if any conditions of this licensing are
21** not clear to you.
22**
23**********************************************************************/
24
25#ifndef DL_DXF_H
26#define DL_DXF_H
27
28#include "dl_global.h"
29
30#include <limits>
31#include <stdio.h>
32#include <stdlib.h>
33#include <string>
34#include <sstream>
35#include <map>
36
37#include "dl_attributes.h"
38#include "dl_codes.h"
39#include "dl_entities.h"
40#include "dl_writer_ascii.h"
41
42#ifdef _WIN32
43#undef M_PI
44#define M_PI 3.14159265358979323846
45#pragma warning(disable : 4800)
46#endif
47
48#ifndef M_PI
49#define M_PI 3.1415926535897932384626433832795
50#endif
51
52#ifndef DL_NANDOUBLE
53#define DL_NANDOUBLE std::numeric_limits<double>::quiet_NaN()
54#endif
55
57class DL_WriterA;
58
59
60#define DL_VERSION "3.17.0.0"
61
62#define DL_VERSION_MAJOR 3
63#define DL_VERSION_MINOR 17
64#define DL_VERSION_REV 0
65#define DL_VERSION_BUILD 0
66
67#define DL_UNKNOWN 0
68#define DL_LAYER 10
69#define DL_BLOCK 11
70#define DL_ENDBLK 12
71#define DL_LINETYPE 13
72#define DL_STYLE 20
73#define DL_SETTING 50
74#define DL_ENTITY_POINT 100
75#define DL_ENTITY_LINE 101
76#define DL_ENTITY_POLYLINE 102
77#define DL_ENTITY_LWPOLYLINE 103
78#define DL_ENTITY_VERTEX 104
79#define DL_ENTITY_SPLINE 105
80#define DL_ENTITY_KNOT 106
81#define DL_ENTITY_CONTROLPOINT 107
82#define DL_ENTITY_ARC 108
83#define DL_ENTITY_CIRCLE 109
84#define DL_ENTITY_ELLIPSE 110
85#define DL_ENTITY_INSERT 111
86#define DL_ENTITY_TEXT 112
87#define DL_ENTITY_MTEXT 113
88#define DL_ENTITY_DIMENSION 114
89#define DL_ENTITY_LEADER 115
90#define DL_ENTITY_HATCH 116
91#define DL_ENTITY_ATTRIB 117
92#define DL_ENTITY_IMAGE 118
93#define DL_ENTITY_IMAGEDEF 119
94#define DL_ENTITY_TRACE 120
95#define DL_ENTITY_SOLID 121
96#define DL_ENTITY_3DFACE 122
97#define DL_ENTITY_XLINE 123
98#define DL_ENTITY_RAY 124
99#define DL_ENTITY_ARCALIGNEDTEXT 125
100#define DL_ENTITY_SEQEND 126
101#define DL_XRECORD 200
102#define DL_DICTIONARY 210
103
104
122class DXFLIB_EXPORT DL_Dxf {
123public:
124 DL_Dxf();
125 ~DL_Dxf();
126
127 bool in(const std::string& file,
128 DL_CreationInterface* creationInterface);
129 bool readDxfGroups(FILE* fp,
130 DL_CreationInterface* creationInterface);
131 static bool getStrippedLine(std::string& s, unsigned int size,
132 FILE* stream, bool stripSpace = true);
133
134 bool readDxfGroups(std::stringstream& stream,
135 DL_CreationInterface* creationInterface);
136 bool in(std::stringstream &stream,
137 DL_CreationInterface* creationInterface);
138 static bool getStrippedLine(std::string& s, unsigned int size,
139 std::stringstream& stream, bool stripSpace = true);
140
141 static bool stripWhiteSpace(char** s, bool stripSpaces = true);
142
143 bool processDXFGroup(DL_CreationInterface* creationInterface,
144 int groupCode, const std::string& groupValue);
145 void addSetting(DL_CreationInterface* creationInterface);
146 void addLayer(DL_CreationInterface* creationInterface);
147 void addLinetype(DL_CreationInterface *creationInterface);
148 void addBlock(DL_CreationInterface* creationInterface);
149 void endBlock(DL_CreationInterface* creationInterface);
150 void addTextStyle(DL_CreationInterface* creationInterface);
151
152 void addPoint(DL_CreationInterface* creationInterface);
153 void addLine(DL_CreationInterface* creationInterface);
154 void addXLine(DL_CreationInterface* creationInterface);
155 void addRay(DL_CreationInterface* creationInterface);
156
157 void addPolyline(DL_CreationInterface* creationInterface);
158 void addVertex(DL_CreationInterface* creationInterface);
159
160 void addSpline(DL_CreationInterface* creationInterface);
161
162 void addArc(DL_CreationInterface* creationInterface);
163 void addCircle(DL_CreationInterface* creationInterface);
164 void addEllipse(DL_CreationInterface* creationInterface);
165 void addInsert(DL_CreationInterface* creationInterface);
166
167 void addTrace(DL_CreationInterface* creationInterface);
168 void add3dFace(DL_CreationInterface* creationInterface);
169 void addSolid(DL_CreationInterface* creationInterface);
170
171 void addMText(DL_CreationInterface* creationInterface);
172 void addText(DL_CreationInterface* creationInterface);
173 void addArcAlignedText(DL_CreationInterface* creationInterface);
174
175 void addAttribute(DL_CreationInterface* creationInterface);
176
177 DL_DimensionData getDimData();
178 void addDimLinear(DL_CreationInterface* creationInterface);
179 void addDimAligned(DL_CreationInterface* creationInterface);
180 void addDimRadial(DL_CreationInterface* creationInterface);
181 void addDimDiametric(DL_CreationInterface* creationInterface);
182 void addDimAngular(DL_CreationInterface* creationInterface);
183 void addDimAngular3P(DL_CreationInterface* creationInterface);
184 void addDimOrdinate(DL_CreationInterface* creationInterface);
185
186 void addLeader(DL_CreationInterface* creationInterface);
187
188 void addHatch(DL_CreationInterface* creationInterface);
189 void addHatchLoop();
190 void addHatchEdge();
191 bool handleHatchData(DL_CreationInterface* creationInterface);
192
193 void addImage(DL_CreationInterface* creationInterface);
194 void addImageDef(DL_CreationInterface* creationInterface);
195
196 void addComment(DL_CreationInterface* creationInterface, const std::string& comment);
197
198 void addDictionary(DL_CreationInterface* creationInterface);
199 void addDictionaryEntry(DL_CreationInterface* creationInterface);
200
201 bool handleXRecordData(DL_CreationInterface* creationInterface);
202 bool handleDictionaryData(DL_CreationInterface* creationInterface);
203
204 bool handleXData(DL_CreationInterface *creationInterface);
205 bool handleMTextData(DL_CreationInterface* creationInterface);
206 bool handleLWPolylineData(DL_CreationInterface* creationInterface);
207 bool handleSplineData(DL_CreationInterface* creationInterface);
208 bool handleLeaderData(DL_CreationInterface* creationInterface);
209 bool handleLinetypeData(DL_CreationInterface* creationInterface);
210
211 void endEntity(DL_CreationInterface* creationInterface);
212
213 void endSequence(DL_CreationInterface* creationInterface);
214
215 //int stringToInt(const char* s, bool* ok=NULL);
216
217 DL_WriterA* out(const char* file,
218 DL_Codes::version version=DL_VERSION_2000);
219
220 void writeHeader(DL_WriterA& dw);
221
222 void writePoint(DL_WriterA& dw,
223 const DL_PointData& data,
224 const DL_Attributes& attrib);
225 void writeLine(DL_WriterA& dw,
226 const DL_LineData& data,
227 const DL_Attributes& attrib);
228 void writeXLine(DL_WriterA& dw,
229 const DL_XLineData& data,
230 const DL_Attributes& attrib);
231 void writeRay(DL_WriterA& dw,
232 const DL_RayData& data,
233 const DL_Attributes& attrib);
234 void writePolyline(DL_WriterA& dw,
235 const DL_PolylineData& data,
236 const DL_Attributes& attrib);
237 void writeVertex(DL_WriterA& dw,
238 const DL_VertexData& data);
239 void writePolylineEnd(DL_WriterA& dw);
240 void writeSpline(DL_WriterA& dw,
241 const DL_SplineData& data,
242 const DL_Attributes& attrib);
243 void writeControlPoint(DL_WriterA& dw,
244 const DL_ControlPointData& data);
245 void writeFitPoint(DL_WriterA& dw,
246 const DL_FitPointData& data);
247 void writeKnot(DL_WriterA& dw,
248 const DL_KnotData& data);
249 void writeCircle(DL_WriterA& dw,
250 const DL_CircleData& data,
251 const DL_Attributes& attrib);
252 void writeArc(DL_WriterA& dw,
253 const DL_ArcData& data,
254 const DL_Attributes& attrib);
255 void writeEllipse(DL_WriterA& dw,
256 const DL_EllipseData& data,
257 const DL_Attributes& attrib);
258 void writeSolid(DL_WriterA& dw,
259 const DL_SolidData& data,
260 const DL_Attributes& attrib);
261 void writeTrace(DL_WriterA& dw,
262 const DL_TraceData& data,
263 const DL_Attributes& attrib);
264 void write3dFace(DL_WriterA& dw,
265 const DL_3dFaceData& data,
266 const DL_Attributes& attrib);
267 void writeInsert(DL_WriterA& dw,
268 const DL_InsertData& data,
269 const DL_Attributes& attrib);
270 void writeMText(DL_WriterA& dw,
271 const DL_MTextData& data,
272 const DL_Attributes& attrib);
273 void writeText(DL_WriterA& dw,
274 const DL_TextData& data,
275 const DL_Attributes& attrib);
276 void writeAttribute(DL_WriterA& dw,
277 const DL_AttributeData& data,
278 const DL_Attributes& attrib);
279 void writeDimStyleOverrides(DL_WriterA& dw,
280 const DL_DimensionData& data);
281 void writeDimAligned(DL_WriterA& dw,
282 const DL_DimensionData& data,
283 const DL_DimAlignedData& edata,
284 const DL_Attributes& attrib);
285 void writeDimLinear(DL_WriterA& dw,
286 const DL_DimensionData& data,
287 const DL_DimLinearData& edata,
288 const DL_Attributes& attrib);
289 void writeDimRadial(DL_WriterA& dw,
290 const DL_DimensionData& data,
291 const DL_DimRadialData& edata,
292 const DL_Attributes& attrib);
293 void writeDimDiametric(DL_WriterA& dw,
294 const DL_DimensionData& data,
295 const DL_DimDiametricData& edata,
296 const DL_Attributes& attrib);
297 void writeDimAngular(DL_WriterA& dw,
298 const DL_DimensionData& data,
299 const DL_DimAngularData& edata,
300 const DL_Attributes& attrib);
301 void writeDimAngular3P(DL_WriterA& dw,
302 const DL_DimensionData& data,
303 const DL_DimAngular3PData& edata,
304 const DL_Attributes& attrib);
305 void writeDimOrdinate(DL_WriterA& dw,
306 const DL_DimensionData& data,
307 const DL_DimOrdinateData& edata,
308 const DL_Attributes& attrib);
309 void writeLeader(DL_WriterA& dw,
310 const DL_LeaderData& data,
311 const DL_Attributes& attrib);
312 void writeLeaderVertex(DL_WriterA& dw,
313 const DL_LeaderVertexData& data);
314 void writeHatch1(DL_WriterA& dw,
315 const DL_HatchData& data,
316 const DL_Attributes& attrib);
317 void writeHatch2(DL_WriterA& dw,
318 const DL_HatchData& data,
319 const DL_Attributes& attrib);
320 void writeHatchLoop1(DL_WriterA& dw,
321 const DL_HatchLoopData& data);
322 void writeHatchLoop2(DL_WriterA& dw,
323 const DL_HatchLoopData& data);
324 void writeHatchEdge(DL_WriterA& dw,
325 const DL_HatchEdgeData& data);
326
327 int writeImage(DL_WriterA& dw,
328 const DL_ImageData& data,
329 const DL_Attributes& attrib);
330
331 void writeImageDef(DL_WriterA& dw, int handle,
332 const DL_ImageData& data);
333
334 void writeLayer(DL_WriterA& dw,
335 const DL_LayerData& data,
336 const DL_Attributes& attrib);
337
338 void writeLinetype(DL_WriterA& dw,
339 const DL_LinetypeData& data);
340
341 void writeAppid(DL_WriterA& dw, const std::string& name);
342
343 void writeBlock(DL_WriterA& dw,
344 const DL_BlockData& data);
345 void writeEndBlock(DL_WriterA& dw, const std::string& name);
346
347 void writeVPort(DL_WriterA& dw);
348 void writeStyle(DL_WriterA& dw, const DL_StyleData& style);
349 void writeView(DL_WriterA& dw);
350 void writeUcs(DL_WriterA& dw);
351 void writeDimStyle(DL_WriterA& dw,
352 double dimasz, double dimexe, double dimexo,
353 double dimgap, double dimtxt);
354 void writeBlockRecord(DL_WriterA& dw);
355 void writeBlockRecord(DL_WriterA& dw, const std::string& name);
356 void writeObjects(DL_WriterA& dw, const std::string& appDictionaryName = "");
357 void writeAppDictionary(DL_WriterA& dw);
358 int writeDictionaryEntry(DL_WriterA& dw, const std::string& name);
359 void writeXRecord(DL_WriterA& dw, int handle, int value);
360 void writeXRecord(DL_WriterA& dw, int handle, double value);
361 void writeXRecord(DL_WriterA& dw, int handle, bool value);
362 void writeXRecord(DL_WriterA& dw, int handle, const std::string& value);
363 void writeObjectsEnd(DL_WriterA& dw);
364
365 void writeComment(DL_WriterA& dw, const std::string& comment);
366
371 //static double toReal(const char* value, double def=0.0);
372
377// static int toInt(const char* value, int def=0) {
378// if (value!=NULL && value[0] != '\0') {
379// return atoi(value);
380// }
381
382// return def;
383// }
384
389// static const char* toString(const char* value, const char* def="") {
390// if (value!=NULL && value[0] != '\0') {
391// return value;
392// } else {
393// return def;
394// }
395// }
396
397 static bool checkVariable(const char* var, DL_Codes::version version);
398
399 DL_Codes::version getVersion() {
400 return version;
401 }
402
403 int getLibVersion(const std::string &str);
404
405 static void test();
406
407 bool hasValue(int code) {
408 return values.count(code)==1;
409 }
410
411 int getIntValue(int code, int def) {
412 if (!hasValue(code)) {
413 return def;
414 }
415 return toInt(values[code]);
416 }
417
418 int toInt(const std::string& str) {
419 char* p;
420 return strtol(str.c_str(), &p, 10);
421 }
422
423 int getInt16Value(int code, int def) {
424 if (!hasValue(code)) {
425 return def;
426 }
427 return toInt16(values[code]);
428 }
429
430 int toInt16(const std::string& str) {
431 char* p;
432 return strtol(str.c_str(), &p, 16);
433 }
434
435 bool toBool(const std::string& str) {
436 char* p;
437 return (bool)strtol(str.c_str(), &p, 10);
438 }
439
440 std::string getStringValue(int code, const std::string& def) {
441 if (!hasValue(code)) {
442 return def;
443 }
444 return values[code];
445 }
446
447 double getRealValue(int code, double def) {
448 if (!hasValue(code)) {
449 return def;
450 }
451 return toReal(values[code]);
452 }
453
454 double toReal(const std::string& str) {
455 double ret;
456 // make sure the real value uses '.' not ',':
457 std::string str2 = str;
458 std::replace(str2.begin(), str2.end(), ',', '.');
459 // make sure c++ expects '.' not ',':
460 std::istringstream istr(str2);
461 //istr.imbue(std::locale("C"));
462 istr >> ret;
463 return ret;
464 }
465
466private:
467 DL_Codes::version version;
468
469 std::string polylineLayer;
470 double* vertices;
471 int maxVertices;
472 int vertexIndex;
473
474 double* knots;
475 int maxKnots;
476 int knotIndex;
477
478 double* weights;
479 int weightIndex;
480
481 double* controlPoints;
482 int maxControlPoints;
483 int controlPointIndex;
484
485 double* fitPoints;
486 int maxFitPoints;
487 int fitPointIndex;
488
489 double* leaderVertices;
490 int maxLeaderVertices;
491 int leaderVertexIndex;
492
493 bool firstHatchLoop;
494 DL_HatchEdgeData hatchEdge;
495 std::vector<std::vector<DL_HatchEdgeData> > hatchEdges;
496
497 std::string xRecordHandle;
498 bool xRecordValues;
499
500 // Only the useful part of the group code
501 std::string groupCodeTmp;
502 // ...same as integer
503 unsigned int groupCode;
504 // Only the useful part of the group value
505 std::string groupValue;
506 // Current entity type
507 int currentObjectType;
508 // Value of the current setting
509 char settingValue[DL_DXF_MAXLINE+1];
510 // Key of the current setting (e.g. "$ACADVER")
511 std::string settingKey;
512 // Stores the group codes
513 std::map<int, std::string> values;
514 // First call of this method. We initialize all group values in
515 // the first call.
516 bool firstCall;
517 // Attributes of the current entity (layer, color, width, line type)
518 DL_Attributes attrib;
519 // library version. hex: 0x20003001 = 2.0.3.1
520 int libVersion;
521 // app specific dictionary handle:
522 unsigned long appDictionaryHandle;
523 // handle of standard text style, referenced by dimstyle:
524 unsigned long styleHandleStd;
525};
526
527#endif
528
529// EOF
Storing and passing around attributes.
Definition: dl_attributes.h:41
version
Version numbers for the DXF Format.
Definition: dl_codes.h:96
Abstract class (interface) for the creation of new entities.
Definition: dl_creationinterface.h:47
Reading and writing of DXF files.
Definition: dl_dxf.h:122
Implements functions defined in DL_Writer for writing low level DXF constructs to an ASCII format DXF...
Definition: dl_writer_ascii.h:49
Arc Data.
Definition: dl_entities.h:315
Block attribute data.
Definition: dl_entities.h:950
Block Data.
Definition: dl_entities.h:59
Circle Data.
Definition: dl_entities.h:352
Spline control point data.
Definition: dl_entities.h:575
Aligned Dimension Data.
Definition: dl_entities.h:1100
Angular Dimension Data (3 points version).
Definition: dl_entities.h:1301
Angular Dimension Data.
Definition: dl_entities.h:1241
Diametric Dimension Data.
Definition: dl_entities.h:1212
Linear (rotated) Dimension Data.
Definition: dl_entities.h:1137
Ordinate Dimension Data.
Definition: dl_entities.h:1350
Radial Dimension Data.
Definition: dl_entities.h:1183
Generic Dimension Data.
Definition: dl_entities.h:990
Ellipse Data.
Definition: dl_entities.h:622
Spline fit point data.
Definition: dl_entities.h:602
Hatch data.
Definition: dl_entities.h:1464
Hatch edge data.
Definition: dl_entities.h:1533
Hatch boundary path (loop) data.
Definition: dl_entities.h:1511
Image Data.
Definition: dl_entities.h:1703
Insert Data.
Definition: dl_entities.h:669
Spline knot data.
Definition: dl_entities.h:556
Layer Data.
Definition: dl_entities.h:36
Leader (arrow).
Definition: dl_entities.h:1393
Leader Vertex Data.
Definition: dl_entities.h:1440
Line Data.
Definition: dl_entities.h:221
Line Type Data.
Definition: dl_entities.h:90
MText Data.
Definition: dl_entities.h:719
Point Data.
Definition: dl_entities.h:197
Polyline Data.
Definition: dl_entities.h:382
Ray Data.
Definition: dl_entities.h:284
Spline Data.
Definition: dl_entities.h:511
Text style data.
Definition: dl_entities.h:130
Text Data.
Definition: dl_entities.h:800
Trace Data / solid data / 3d face data.
Definition: dl_entities.h:444
Vertex Data.
Definition: dl_entities.h:416
XLine Data.
Definition: dl_entities.h:255