{{ message }}
1
//-----------------------------------------------------------------------------
2
// The file format-specific stuff for all of the 2d vector output formats.
3
//
4
// Copyright 2008-2013 Jonathan Westhues.
5
//-----------------------------------------------------------------------------
6
#include <libdxfrw.h>
7
#include "solvespace.h"
8
9
namespace SolveSpace {
10
11
//-----------------------------------------------------------------------------
12
// Routines for DXF export
13
//-----------------------------------------------------------------------------
14
class DxfWriteInterface : public DRW_Interface {
16
DxfFileWriter *writer;
17
dxfRW *dxf;
18
19
std::set<std::string> messages;
21
static DRW_Coord toCoord(const Vector &v) {
22
return DRW_Coord(v.x, v.y, v.z);
23
}
24
25
Vector xfrm(Vector v) {
26
return writer->Transform(v);
27
}
28
29
void writeTextstyles() override {
30
DRW_Textstyle ts;
31
ts.name = "unicode";
32
ts.font = "unicode";
33
dxf->writeTextstyle(&ts);
34
}
35
36
void writeLayers() override {
37
DRW_Layer layer;
39
layer.name = "dimensions";
40
dxf->writeLayer(&layer);
41
layer.name = "text";
42
dxf->writeLayer(&layer);
44
std::set<uint32_t> usedStyles;
45
46
for(DxfFileWriter::BezierPath &path : writer->paths) {
47
for(SBezier *sb : path.beziers) {
48
usedStyles.insert((uint32_t)sb->auxA);
52
for(uint32_t v : usedStyles) {
53
Style *s = Style::Get(hStyle{v});
54
layer.name = s->DescriptionString();
55
dxf->writeLayer(&layer);
56
}
59
void writeLTypes() override {
60
for(uint32_t i = 0; i <= (uint32_t)StipplePattern::LAST; i++) {
61
StipplePattern st = (StipplePattern)i;
62
DRW_LType type;
63
// LibreCAD requires the line type to have one of these exact names,
64
// or otherwise it overwrites it with its own (continuous) style.
65
type.name = DxfFileWriter::lineTypeName(st);
66
double sw = 1.0;
67
switch(st) {
68
case StipplePattern::CONTINUOUS:
69
break;
70
71
case StipplePattern::SHORT_DASH:
72
type.path.push_back(sw);
73
type.path.push_back(-sw * 2.0);
74
break;
75
76
case StipplePattern::DASH:
77
type.path.push_back(sw);
78
type.path.push_back(-sw);
79
break;
80
81
case StipplePattern::LONG_DASH:
82
type.path.push_back(sw * 2.0);
83
type.path.push_back(-sw);
84
break;
85
86
case StipplePattern::DASH_DOT:
87
type.path.push_back(sw);
88
type.path.push_back(-sw);
89
type.path.push_back(0.0);
90
type.path.push_back(-sw);
91
break;
92
93
case StipplePattern::DOT:
94
type.path.push_back(sw);
95
type.path.push_back(0.0);
96
break;
97
98
case StipplePattern::DASH_DOT_DOT:
99
type.path.push_back(sw);
100
type.path.push_back(-sw);
101
type.path.push_back(0.0);
102
type.path.push_back(-sw);
103
type.path.push_back(0.0);
104
type.path.push_back(-sw);
105
break;
106
107
case StipplePattern::FREEHAND:
108
case StipplePattern::ZIGZAG:
109
// Not implemented; exported as continuous.
110
break;
111
}
112
dxf->writeLineType(&type);
113
}
114
}
115
116
void writePolylines() {
117
PolylineBuilder builder;
118
119
for(DxfFileWriter::BezierPath &path : writer->paths) {
120
for(SBezier *sb : path.beziers) {
121
if(sb->deg != 1) continue;
122
builder.AddEdge(sb->ctrl[0], sb->ctrl[1], (uint32_t)sb->auxA);
126
DRW_Polyline polyline;
128
auto startFunc = [&](PolylineBuilder::Vertex *start,
129
PolylineBuilder::Vertex *next,
130
PolylineBuilder::Edge *e) {
131
hStyle hs = { e->kind };
132
polyline = {};
133
assignEntityDefaults(&polyline, hs);
134
135
if(!(EXACT(start->pos.z == 0.0) && EXACT(next->pos.z == 0.0))) {
136
polyline.flags |= 8 /* 3d polyline */;
137
}
138
polyline.vertlist.push_back(
139
std::make_shared<DRW_Vertex>(start->pos.x, start->pos.y, start->pos.z, 0.0));
140
polyline.vertlist.push_back(
141
std::make_shared<DRW_Vertex>(next->pos.x, next->pos.y, next->pos.z, 0.0));
144
auto nextFunc = [&](PolylineBuilder::Vertex *next, PolylineBuilder::Edge *e) {
145
if(!EXACT(next->pos.z == 0.0)) {
146
polyline.flags |= 8 /* 3d polyline */;
147
}
148
polyline.vertlist.push_back(
149
std::make_shared<DRW_Vertex>(next->pos.x, next->pos.y, next->pos.z, 0.0));
152
auto endFunc = [&]() {
153
dxf->writePolyline(&polyline);
156
auto aloneFunc = [&](PolylineBuilder::Edge *e) {
157
hStyle hs = { e->kind };
158
writeLine(e->a->pos, e->b->pos, hs);
159
};
160
161
builder.Generate(startFunc, nextFunc, aloneFunc, endFunc);
164
void writeEntities() override {
165
writePolylines();
166
167
for(DxfFileWriter::BezierPath &path : writer->paths) {
168
for(SBezier *sb : path.beziers) {
169
if(sb->deg == 1) continue;
170
writeBezier(sb);
171
}
173
174
if(writer->constraint) {
175
for(Constraint &c : *writer->constraint) {
176
if(!writer->NeedToOutput(&c)) continue;
177
switch(c.type) {
178
case Constraint::Type::PT_PT_DISTANCE: {
179
Vector ap = SK.GetEntity(c.ptA)->PointGetNum();
180
Vector bp = SK.GetEntity(c.ptB)->PointGetNum();
181
Vector ref = ((ap.Plus(bp)).ScaledBy(0.5)).Plus(c.disp.offset);
182
writeAlignedDimension(xfrm(ap), xfrm(bp), xfrm(ref),
183
xfrm(ref), c.Label(), c.GetStyle(), c.valA);
184
break;
185
}
186
187
case Constraint::Type::PT_LINE_DISTANCE: {
188
Vector pt = SK.GetEntity(c.ptA)->PointGetNum();
189
Entity *line = SK.GetEntity(c.entityA);
190
Vector lA = SK.GetEntity(line->point[0])->PointGetNum();
191
Vector lB = SK.GetEntity(line->point[1])->PointGetNum();
192
Vector dl = lB.Minus(lA);
193
194
Vector closest = pt.ClosestPointOnLine(lA, dl);
195
196
if(pt.Equals(closest)) break;
197
198
Vector ref = ((closest.Plus(pt)).ScaledBy(0.5)).Plus(c.disp.offset);
199
Vector refClosest = ref.ClosestPointOnLine(lA, dl);
200
201
double ddl = dl.Dot(dl);
202
if(fabs(ddl) > LENGTH_EPS * LENGTH_EPS) {
203
double t = refClosest.Minus(lA).Dot(dl) / ddl;
204
if(t < 0.0) {
205
refClosest = lA;
206
} else if(t > 1.0) {
207
refClosest = lB;
208
}
209
}
210
211
Vector xdl = xfrm(lB).Minus(xfrm(lA));
212
writeLinearDimension(xfrm(pt), xfrm(refClosest), xfrm(ref),
213
xfrm(ref), c.Label(),
214
atan2(xdl.y, xdl.x) / PI * 180.0 + 90.0, 0.0,
215
c.GetStyle(), c.valA);
216
break;
217
}
218
219
case Constraint::Type::DIAMETER: {
220
Entity *circle = SK.GetEntity(c.entityA);
221
Vector center = SK.GetEntity(circle->point[0])->PointGetNum();
222
Quaternion q = SK.GetEntity(circle->normal)->NormalGetNum();
223
Vector n = q.RotationN().WithMagnitude(1);
224
double r = circle->CircleGetRadiusNum();
225
226
Vector ref = center.Plus(c.disp.offset);
227
// Force the label into the same plane as the circle.
228
ref = ref.Minus(n.ScaledBy(n.Dot(ref) - n.Dot(center)));
229
230
Vector rad = ref.Minus(center).WithMagnitude(r);
231
if(/*isRadius*/c.other) {
232
writeRadialDimension(
233
xfrm(center), xfrm(center.Plus(rad)),
234
xfrm(ref), c.Label(), c.GetStyle(), c.valA);
235
} else {
236
writeDiametricDimension(
237
xfrm(center.Minus(rad)), xfrm(center.Plus(rad)),
238
xfrm(ref), c.Label(), c.GetStyle(), c.valA);
239
}
240
break;
241
}
242
243
case Constraint::Type::ANGLE: {
244
Entity *a = SK.GetEntity(c.entityA);
245
Entity *b = SK.GetEntity(c.entityB);
246
247
Vector a0 = a->VectorGetStartPoint();
248
Vector b0 = b->VectorGetStartPoint();
249
Vector da = a->VectorGetNum();
250
Vector db = b->VectorGetNum();
251
if(/*otherAngle*/c.other) {
252
a0 = a0.Plus(da);
253
da = da.ScaledBy(-1);
254
}
255
256
bool skew = false;
257
Vector ref = c.disp.offset;
258
Vector pi = Vector::AtIntersectionOfLines(a0, a0.Plus(da), b0, b0.Plus(db),
259
&skew);
260
if(!skew) ref = pi.Plus(c.disp.offset);
262
Vector norm = da.Cross(db);
263
Vector dna = norm.Cross(da).WithMagnitude(1.0);
264
265
double thetaf = acos(da.DirectionCosineWith(db));
267
// Calculate median
268
Vector m = da.WithMagnitude(1.0).ScaledBy(cos(thetaf/2)).Plus(
269
dna.ScaledBy(sin(thetaf/2)));
270
Vector rm = ref.Minus(pi);
271
272
// Test which side we have to place an arc
273
if(m.Dot(rm) < 0) {
274
da = da.ScaledBy(-1); dna = dna.ScaledBy(-1);
275
db = db.ScaledBy(-1);
276
}
277
278
Vector bisect = da.WithMagnitude(1.0).ScaledBy(cos(thetaf / 2.0)).Plus(
279
dna.ScaledBy(sin(thetaf / 2.0)));
280
281
ref = pi.Plus(bisect.WithMagnitude(c.disp.offset.Magnitude()));
283
// Get lines again to write exact line.
284
a0 = a->VectorGetStartPoint();
285
b0 = b->VectorGetStartPoint();
286
da = a->VectorGetNum();
287
db = b->VectorGetNum();
288
289
writeAngularDimension(
290
xfrm(a0), xfrm(a0.Plus(da)), xfrm(b0), xfrm(b0.Plus(db)), xfrm(ref),
291
xfrm(ref), c.Label(), c.GetStyle(), c.valA);
292
break;
293
}
294
295
case Constraint::Type::COMMENT: {
296
Style *st = SK.style.FindById(c.GetStyle());
297
writeText(xfrm(c.disp.offset), c.Label(),
298
Style::TextHeight(c.GetStyle()) / SS.GW.scale,
299
st->textAngle, st->textOrigin, c.GetStyle());
302
303
default:
304
// Other types of constraints do not have a DXF dimension equivalent.
305
break;
311
int findDxfColor(const RgbaColor &src) {
312
int best = 0;
313
double minDist = VERY_POSITIVE;
314
Vector srcv = {src.redF(), src.greenF(), src.blueF()};
315
for(int i = 1; i < 256; i++) {
316
RgbaColor dst = RGBi(DRW::dxfColors[i][0], DRW::dxfColors[i][1], DRW::dxfColors[i][2]);
317
Vector dstv = {dst.redF(), dst.greenF(), dst.blueF()};
318
double dist = srcv.Minus(dstv).Magnitude();
319
if(dist < minDist || best == 0) {
320
best = i;
321
minDist = dist;
322
}
323
}
324
return best;
325
}
326
327
void assignEntityDefaults(DRW_Entity *entity, hStyle hs) {
328
Style *s = Style::Get(hs);
329
RgbaColor color = Style::Color(hs, /*forExport=*/true);
330
entity->color24 = color.ToPackedIntBGRA();
331
entity->color = findDxfColor(color);
332
entity->layer = s->DescriptionString();
333
entity->lineType = DxfFileWriter::lineTypeName(s->stippleType);
334
entity->ltypeScale = Style::StippleScaleMm(s->h);
335
entity->setWidthMm(Style::WidthMm(hs.v));
336
337
if(s->stippleType == StipplePattern::FREEHAND) {
338
messages.insert(_("freehand lines were replaced with continuous lines"));
339
} else if(s->stippleType == StipplePattern::ZIGZAG) {
340
messages.insert(_("zigzag lines were replaced with continuous lines"));
344
void assignDimensionDefaults(DRW_Dimension *dimension, hStyle hs) {
345
assignEntityDefaults(dimension, hs);
346
dimension->layer = "dimensions";
347
}
348
349
void writeLine(const Vector &p0, const Vector &p1, hStyle hs) {
350
DRW_Line line;
351
assignEntityDefaults(&line, hs);
352
line.basePoint = toCoord(p0);
353
line.secPoint = toCoord(p1);
354
dxf->writeLine(&line);
355
}
356
357
void writeArc(const Vector &c, double r, double sa, double ea, hStyle hs) {
358
DRW_Arc arc;
359
assignEntityDefaults(&arc, hs);
360
arc.radious = r;
361
arc.basePoint = toCoord(c);
362
arc.staangle = sa;
363
arc.endangle = ea;
364
dxf->writeArc(&arc);
365
}
366
367
void writeBezierAsPwl(SBezier *sb) {
368
List<Vector> lv = {};
369
sb->MakePwlInto(&lv, SS.ExportChordTolMm());
370
hStyle hs = { (uint32_t)sb->auxA };
371
DRW_Polyline polyline;
372
assignEntityDefaults(&polyline, hs);
373
for(int i = 0; i < lv.n; i++) {
374
Vector *v = &lv[i];
375
polyline.vertlist.push_back(std::make_shared<DRW_Vertex>(v->x, v->y, v->z, 0.0));
377
dxf->writePolyline(&polyline);
378
lv.Clear();
379
}
380
381
void makeKnotsFor(DRW_Spline *spline) {
382
// QCad/LibreCAD require this for some reason.
383
if(spline->degree == 3) {
384
spline->nknots = 8;
385
spline->knotslist.push_back(0.0);
386
spline->knotslist.push_back(0.0);
387
spline->knotslist.push_back(0.0);
388
spline->knotslist.push_back(0.0);
389
spline->knotslist.push_back(1.0);
390
spline->knotslist.push_back(1.0);
391
spline->knotslist.push_back(1.0);
392
spline->knotslist.push_back(1.0);
393
} else if(spline->degree == 2) {
394
spline->nknots = 6;
395
spline->knotslist.push_back(0.0);
396
spline->knotslist.push_back(0.0);
397
spline->knotslist.push_back(0.0);
398
spline->knotslist.push_back(1.0);
399
spline->knotslist.push_back(1.0);
400
spline->knotslist.push_back(1.0);
401
} else ssassert(false, "Unexpected degree of spline");
402
}
403
404
void writeSpline(SBezier *sb) {
405
bool isRational = sb->IsRational();
406
hStyle hs = { (uint32_t)sb->auxA };
407
DRW_Spline spline;
408
assignEntityDefaults(&spline, hs);
409
spline.flags = (isRational) ? 0x04 : 0x08;
410
spline.degree = sb->deg;
411
spline.ncontrol = sb->deg + 1;
412
makeKnotsFor(&spline);
413
for(int i = 0; i <= sb->deg; i++) {
414
spline.controllist.push_back(
415
std::make_shared<DRW_Coord>(sb->ctrl[i].x, sb->ctrl[i].y, sb->ctrl[i].z));
416
if(isRational) spline.weightlist.push_back(sb->weight[i]);
417
}
418
dxf->writeSpline(&spline);
419
}
420
421
void writeBezier(SBezier *sb) {
422
hStyle hs = { (uint32_t)sb->auxA };
423
Vector c;
424
Vector n = {0.0, 0.0, 1.0};
425
double r;
426
427
if(sb->deg == 1) {
428
// Line
429
writeLine(sb->ctrl[0], sb->ctrl[1], hs);
430
} else if(sb->IsInPlane(n, 0) && sb->IsCircle(n, &c, &r)) {
431
// Circle perpendicular to camera
432
double theta0 = atan2(sb->ctrl[0].y - c.y, sb->ctrl[0].x - c.x);
433
double theta1 = atan2(sb->ctrl[2].y - c.y, sb->ctrl[2].x - c.x);
434
double dtheta = WRAP_SYMMETRIC(theta1 - theta0, 2.0 * PI);
435
if(dtheta < 0.0) swap(theta0, theta1);
436
437
writeArc(c, r, theta0, theta1, hs);
438
} else if(sb->IsRational()) {
439
// Rational bezier
440
// We'd like to export rational beziers exactly, but the resulting DXF
441
// files can only be read by AutoCAD; LibreCAD/QCad simply do not
442
// implement the feature. So, export as piecewise linear for compatibility.
443
writeBezierAsPwl(sb);
444
} else {
445
// Any other curve
446
writeSpline(sb);
450
void writeAlignedDimension(Vector def1, Vector def2, Vector dimp,
451
Vector textp, const std::string &text, hStyle hs, double actual) {
452
DRW_DimAligned dim;
453
assignDimensionDefaults(&dim, hs);
454
dim.setDef1Point(toCoord(def1));
455
dim.setDef2Point(toCoord(def2));
456
dim.setDimPoint(toCoord(dimp));
457
dim.setTextPoint(toCoord(textp));
458
dim.setText(text);
459
dim.setActualMeasurement(actual);
460
dxf->writeDimension(&dim);
461
}
462
463
void writeLinearDimension(Vector def1, Vector def2, Vector dimp,
464
Vector textp, const std::string &text,
465
double angle, double oblique, hStyle hs, double actual) {
466
DRW_DimLinear dim;
467
assignDimensionDefaults(&dim, hs);
468
dim.setDef1Point(toCoord(def1));
469
dim.setDef2Point(toCoord(def2));
470
dim.setDimPoint(toCoord(dimp));
471
dim.setTextPoint(toCoord(textp));
472
dim.setText(text);
473
dim.setAngle(angle);
474
dim.setOblique(oblique);
475
dim.setActualMeasurement(actual);
476
dxf->writeDimension(&dim);
477
}
478
479
void writeRadialDimension(Vector center, Vector radius,
480
Vector textp, const std::string &text, hStyle hs, double actual) {
481
DRW_DimRadial dim;
482
assignDimensionDefaults(&dim, hs);
483
dim.setCenterPoint(toCoord(center));
484
dim.setDiameterPoint(toCoord(radius));
485
dim.setTextPoint(toCoord(textp));
486
dim.setText(text);
487
dim.setActualMeasurement(actual);
488
dxf->writeDimension(&dim);
489
}
490
491
void writeDiametricDimension(Vector def1, Vector def2,
492
Vector textp, const std::string &text, hStyle hs, double actual) {
493
DRW_DimDiametric dim;
494
assignDimensionDefaults(&dim, hs);
495
dim.setDiameter1Point(toCoord(def1));
496
dim.setDiameter2Point(toCoord(def2));
497
dim.setTextPoint(toCoord(textp));
498
dim.setText(text);
499
dim.setActualMeasurement(actual);
500
dxf->writeDimension(&dim);
501
}
502
503
void writeAngularDimension(Vector fl1, Vector fl2, Vector sl1, Vector sl2, Vector dimp,
504
Vector textp, const std::string &text, hStyle hs, double actual) {
505
DRW_DimAngular dim;
506
assignDimensionDefaults(&dim, hs);
507
dim.setFirstLine1(toCoord(fl1));
508
dim.setFirstLine2(toCoord(fl2));
509
dim.setSecondLine1(toCoord(sl1));
510
dim.setSecondLine2(toCoord(sl2));
511
dim.setDimPoint(toCoord(dimp));
512
dim.setTextPoint(toCoord(textp));
513
dim.setText(text);
514
dim.setActualMeasurement(actual * PI / 180.0);
515
dxf->writeDimension(&dim);
516
}
517
518
void writeText(Vector textp, const std::string &text,
519
double height, double angle, Style::TextOrigin origin, hStyle hs) {
520
DRW_Text txt;
521
assignEntityDefaults(&txt, hs);
522
txt.layer = "text";
523
txt.style = "unicode";
524
txt.basePoint = toCoord(textp);
525
txt.secPoint = txt.basePoint;
526
txt.text = text;
527
txt.height = height;
528
txt.angle = angle;
529
txt.alignH = DRW_Text::HCenter;
530
if((uint32_t)origin & (uint32_t)Style::TextOrigin::LEFT) {
531
txt.alignH = DRW_Text::HLeft;
532
} else if((uint32_t)origin & (uint32_t)Style::TextOrigin::RIGHT) {
533
txt.alignH = DRW_Text::HRight;
534
}
535
txt.alignV = DRW_Text::VMiddle;
536
if((uint32_t)origin & (uint32_t)Style::TextOrigin::TOP) {
537
txt.alignV = DRW_Text::VTop;
538
} else if((uint32_t)origin & (uint32_t)Style::TextOrigin::BOT) {
539
txt.alignV = DRW_Text::VBaseLine;
540
}
541
dxf->writeText(&txt);
542
}
545
bool DxfFileWriter::OutputConstraints(IdList<Constraint,hConstraint> *constraint) {
546
this->constraint = constraint;
547
return true;
548
}
549
550
void DxfFileWriter::StartFile() {
551
paths.clear();
554
void DxfFileWriter::Background(RgbaColor color) {
555
}
556
557
void DxfFileWriter::StartPath(RgbaColor strokeRgb, double lineWidth,
558
bool filled, RgbaColor fillRgb, hStyle hs)
560
BezierPath path = {};
561
paths.push_back(path);
563
void DxfFileWriter::FinishPath(RgbaColor strokeRgb, double lineWidth,
564
bool filled, RgbaColor fillRgb, hStyle hs, bool closed)
565
{
566
}
567
568
void DxfFileWriter::Triangle(STriangle *tr) {
569
}
570
571
void DxfFileWriter::Bezier(SBezier *sb) {
572
paths.back().beziers.push_back(sb);
575
void DxfFileWriter::FinishAndCloseFile() {
576
dxfRW dxf;
577
578
DxfWriteInterface interface = {};
579
interface.writer = this;
580
interface.dxf = &dxf;
582
std::stringstream stream;
583
dxf.write(stream, &interface, DRW::AC1021, /*bin=*/false);
584
paths.clear();
585
constraint = NULL;
587
if(!WriteFile(filename, stream.str())) {
588
Error("Couldn't write to '%s'", filename.raw.c_str());
589
return;
590
}
591
592
if(!interface.messages.empty()) {
593
std::string text = _("Some aspects of the drawing have no DXF equivalent and "
594
"were not exported:\n");
595
for(const std::string &message : interface.messages) {
596
text += " * " + message + "\n";
597
}
598
Message(text.c_str());
599
}
602
bool DxfFileWriter::NeedToOutput(Constraint *c) {
603
switch(c->type) {
604
case Constraint::Type::PT_PT_DISTANCE:
605
case Constraint::Type::PT_LINE_DISTANCE:
606
case Constraint::Type::DIAMETER:
607
case Constraint::Type::ANGLE:
608
case Constraint::Type::COMMENT:
609
return c->IsVisible();
610
611
default: // See writeEntities().
612
break;
613
}
614
return false;
615
}
616
617
const char *DxfFileWriter::lineTypeName(StipplePattern stippleType) {
618
switch(stippleType) {
619
case StipplePattern::CONTINUOUS: return "CONTINUOUS";
620
case StipplePattern::SHORT_DASH: return "DASHED";
621
case StipplePattern::DASH: return "DASHED";
622
case StipplePattern::LONG_DASH: return "DASHEDX2";
623
case StipplePattern::DASH_DOT: return "DASHDOT";
624
case StipplePattern::DASH_DOT_DOT: return "DIVIDE";
625
case StipplePattern::DOT: return "DOT";
627
case StipplePattern::FREEHAND:
628
case StipplePattern::ZIGZAG:
629
/* no corresponding DXF line type */
630
break;
632
633
return "CONTINUOUS";
634
}
635
636
//-----------------------------------------------------------------------------
637
// Routines for EPS output
638
//-----------------------------------------------------------------------------
640
static std::string MakeStipplePattern(StipplePattern pattern, double scale, char delimiter,
641
bool inkscapeWorkaround = false) {
642
scale /= 2.0;
643
644
// Inkscape ignores all elements that are exactly zero instead of drawing
645
// them as dots.
646
double zero = inkscapeWorkaround ? 1e-6 : 0;
647
648
std::string result;
649
switch(pattern) {
650
case StipplePattern::CONTINUOUS:
651
return "";
652
653
case StipplePattern::SHORT_DASH:
654
result = ssprintf("%.3f_%.3f", scale, scale * 2.0);
655
break;
656
case StipplePattern::DASH:
657
result = ssprintf("%.3f_%.3f", scale, scale);
658
break;
659
case StipplePattern::DASH_DOT:
660
result = ssprintf("%.3f_%.3f_%.6f_%.3f",
661
scale, scale * 0.5, zero, scale * 0.5);
662
break;
663
case StipplePattern::DASH_DOT_DOT:
664
result = ssprintf("%.3f_%.3f_%.6f_%.3f_%.6f_%.3f",
665
scale, scale * 0.5, zero,
666
scale * 0.5, scale * 0.5, zero);
667
break;
668
case StipplePattern::DOT:
669
result = ssprintf("%.6f_%.3f", zero, scale * 0.5);
670
break;
671
case StipplePattern::LONG_DASH:
672
result = ssprintf("%.3f_%.3f", scale * 2.0, scale * 0.5);
673
break;
675
case StipplePattern::FREEHAND:
676
case StipplePattern::ZIGZAG:
677
dbp("Freehand and zigzag export not implemented; "
678
"exporting as continuous line");
679
break;
680
}
681
std::replace(result.begin(), result.end(), '_', delimiter);
682
return result;
683
}
684
685
void EpsFileWriter::StartFile() {
686
fprintf(f,
687
"%%!PS-Adobe-2.0\r\n"
688
"%%%%Creator: SolveSpace\r\n"
689
"%%%%Title: title\r\n"
690
"%%%%Pages: 0\r\n"
691
"%%%%PageOrder: Ascend\r\n"
692
"%%%%BoundingBox: 0 0 %d %d\r\n"
693
"%%%%HiResBoundingBox: 0 0 %.3f %.3f\r\n"
694
"%%%%EndComments\r\n"
695
"\r\n"
696
"gsave\r\n"
697
"\r\n",
698
(int)ceil(MmToPts(ptMax.x - ptMin.x)),
699
(int)ceil(MmToPts(ptMax.y - ptMin.y)),
700
MmToPts(ptMax.x - ptMin.x),
701
MmToPts(ptMax.y - ptMin.y));
702
}
703
704
void EpsFileWriter::Background(RgbaColor color) {
705
double width = ptMax.x - ptMin.x;
706
double height = ptMax.y - ptMin.y;
707
708
fprintf(f,
709
"%.3f %.3f %.3f setrgbcolor\r\n"
710
"newpath\r\n"
711
" %.3f %.3f moveto\r\n"
712
" %.3f %.3f lineto\r\n"
713
" %.3f %.3f lineto\r\n"
714
" %.3f %.3f lineto\r\n"
715
" closepath\r\n"
716
"gsave fill grestore\r\n",
717
color.redF(), color.greenF(), color.blueF(),
718
MmToPts(0), MmToPts(0),
719
MmToPts(width), MmToPts(0),
720
MmToPts(width), MmToPts(height),
721
MmToPts(0), MmToPts(height));
722
723
// same issue with cracks, stroke it to avoid them
724
double sw = max(width, height) / 1000;
725
fprintf(f,
726
"1 setlinejoin\r\n"
727
"1 setlinecap\r\n"
728
"%.3f setlinewidth\r\n"
729
"gsave stroke grestore\r\n",
730
MmToPts(sw));
731
}
732
733
void EpsFileWriter::StartPath(RgbaColor strokeRgb, double lineWidth,
734
bool filled, RgbaColor fillRgb, hStyle hs)
735
{
736
fprintf(f, "newpath\r\n");
737
prevPt = {VERY_POSITIVE, VERY_POSITIVE, VERY_POSITIVE};
739
void EpsFileWriter::FinishPath(RgbaColor strokeRgb, double lineWidth,
740
bool filled, RgbaColor fillRgb, hStyle hs, bool closed)
742
StipplePattern pattern = Style::PatternType(hs);
743
double stippleScale = MmToPts(Style::StippleScaleMm(hs));
744
745
fprintf(f, " %.3f setlinewidth\r\n"
746
" %.3f %.3f %.3f setrgbcolor\r\n"
747
" 1 setlinejoin\r\n" // rounded
748
" 1 setlinecap\r\n" // rounded
749
" [%s] 0 setdash\r\n"
750
" gsave stroke grestore\r\n",
751
MmToPts(lineWidth),
752
strokeRgb.redF(), strokeRgb.greenF(), strokeRgb.blueF(),
753
MakeStipplePattern(pattern, stippleScale, ' ').c_str());
754
if(filled) {
755
fprintf(f, " %.3f %.3f %.3f setrgbcolor\r\n"
756
" gsave fill grestore\r\n",
757
fillRgb.redF(), fillRgb.greenF(), fillRgb.blueF());
758
}
759
}
760
761
void EpsFileWriter::MaybeMoveTo(Vector st, Vector fi) {
762
if(!prevPt.Equals(st)) {
763
fprintf(f, " %.3f %.3f moveto\r\n",
764
MmToPts(st.x - ptMin.x), MmToPts(st.y - ptMin.y));
765
}
766
prevPt = fi;
767
}
768
769
void EpsFileWriter::Triangle(STriangle *tr) {
770
fprintf(f,
771
"%.3f %.3f %.3f setrgbcolor\r\n"
772
"newpath\r\n"
773
" %.3f %.3f moveto\r\n"
774
" %.3f %.3f lineto\r\n"
775
" %.3f %.3f lineto\r\n"
776
" closepath\r\n"
777
"gsave fill grestore\r\n",
778
tr->meta.color.redF(), tr->meta.color.greenF(), tr->meta.color.blueF(),
779
MmToPts(tr->a.x - ptMin.x), MmToPts(tr->a.y - ptMin.y),
780
MmToPts(tr->b.x - ptMin.x), MmToPts(tr->b.y - ptMin.y),
781
MmToPts(tr->c.x - ptMin.x), MmToPts(tr->c.y - ptMin.y));
782
783
// same issue with cracks, stroke it to avoid them
784
double sw = max(ptMax.x - ptMin.x, ptMax.y - ptMin.y) / 1000;
785
fprintf(f,
786
"1 setlinejoin\r\n"
787
"1 setlinecap\r\n"
788
"%.3f setlinewidth\r\n"
789
"gsave stroke grestore\r\n",
790
MmToPts(sw));
793
void EpsFileWriter::Bezier(SBezier *sb) {
794
Vector c, n = {0, 0, 1};
796
if(sb->deg == 1) {
797
MaybeMoveTo(sb->ctrl[0], sb->ctrl[1]);
798
fprintf(f, " %.3f %.3f lineto\r\n",
799
MmToPts(sb->ctrl[1].x - ptMin.x),
800
MmToPts(sb->ctrl[1].y - ptMin.y));
801
} else if(sb->IsCircle(n, &c, &r)) {
802
Vector p0 = sb->ctrl[0], p1 = sb->ctrl[2];
803
double theta0 = atan2(p0.y - c.y, p0.x - c.x),
804
theta1 = atan2(p1.y - c.y, p1.x - c.x),
805
dtheta = WRAP_SYMMETRIC(theta1 - theta0, 2*PI);
806
MaybeMoveTo(p0, p1);
808
" %.3f %.3f %.3f %.3f %.3f %s\r\n",
809
MmToPts(c.x - ptMin.x), MmToPts(c.y - ptMin.y),
810
MmToPts(r),
811
theta0*180/PI, theta1*180/PI,
812
dtheta < 0 ? "arcn" : "arc");
813
} else if(sb->deg == 3 && !sb->IsRational()) {
814
MaybeMoveTo(sb->ctrl[0], sb->ctrl[3]);
816
" %.3f %.3f %.3f %.3f %.3f %.3f curveto\r\n",
817
MmToPts(sb->ctrl[1].x - ptMin.x), MmToPts(sb->ctrl[1].y - ptMin.y),
818
MmToPts(sb->ctrl[2].x - ptMin.x), MmToPts(sb->ctrl[2].y - ptMin.y),
819
MmToPts(sb->ctrl[3].x - ptMin.x), MmToPts(sb->ctrl[3].y - ptMin.y));
821
BezierAsNonrationalCubic(sb);
825
void EpsFileWriter::FinishAndCloseFile() {
826
fprintf(f,
827
"\r\n"
828
"grestore\r\n"
829
"\r\n");
830
fclose(f);
831
}
832
833
//-----------------------------------------------------------------------------
834
// Routines for PDF output, some extra complexity because we have to generate
835
// a correct xref table.
836
//-----------------------------------------------------------------------------
837
void PdfFileWriter::StartFile() {
838
if((ptMax.x - ptMin.x) > 200*25.4 ||
839
(ptMax.y - ptMin.y) > 200*25.4)
840
{
841
Message(_("PDF page size exceeds 200 by 200 inches; many viewers may "
842
"reject this file."));
845
fprintf(f,
846
"%%PDF-1.1\r\n"
847
"%%%c%c%c%c\r\n",
848
0xe2, 0xe3, 0xcf, 0xd3);
850
xref[1] = (uint32_t)ftell(f);
851
fprintf(f,
852
"1 0 obj\r\n"
853
" << /Type /Catalog\r\n"
854
" /Outlines 2 0 R\r\n"
855
" /Pages 3 0 R\r\n"
856
" >>\r\n"
857
"endobj\r\n");
858
859
xref[2] = (uint32_t)ftell(f);
860
fprintf(f,
861
"2 0 obj\r\n"
862
" << /Type /Outlines\r\n"
863
" /Count 0\r\n"
864
" >>\r\n"
865
"endobj\r\n");
866
867
xref[3] = (uint32_t)ftell(f);
868
fprintf(f,
869
"3 0 obj\r\n"
870
" << /Type /Pages\r\n"
871
" /Kids [4 0 R]\r\n"
872
" /Count 1\r\n"
873
" >>\r\n"
874
"endobj\r\n");
875
876
xref[4] = (uint32_t)ftell(f);
877
fprintf(f,
878
"4 0 obj\r\n"
879
" << /Type /Page\r\n"
880
" /Parent 3 0 R\r\n"
881
" /MediaBox [0 0 %.3f %.3f]\r\n"
882
" /Contents 5 0 R\r\n"
883
" /Resources << /ProcSet 7 0 R\r\n"
884
" /Font << /F1 8 0 R >>\r\n"
885
" >>\r\n"
886
" >>\r\n"
887
"endobj\r\n",
888
MmToPts(ptMax.x - ptMin.x),
889
MmToPts(ptMax.y - ptMin.y));
890
891
xref[5] = (uint32_t)ftell(f);
892
fprintf(f,
893
"5 0 obj\r\n"
894
" << /Length 6 0 R >>\r\n"
895
"stream\r\n");
896
bodyStart = (uint32_t)ftell(f);
899
void PdfFileWriter::FinishAndCloseFile() {
900
uint32_t bodyEnd = (uint32_t)ftell(f);
901
902
fprintf(f,
903
"endstream\r\n"
904
"endobj\r\n");
905
906
xref[6] = (uint32_t)ftell(f);
907
fprintf(f,
908
"6 0 obj\r\n"
909
" %d\r\n"
910
"endobj\r\n",
911
bodyEnd - bodyStart);
912
913
xref[7] = (uint32_t)ftell(f);
914
fprintf(f,
915
"7 0 obj\r\n"
916
" [/PDF /Text]\r\n"
917
"endobj\r\n");
918
919
xref[8] = (uint32_t)ftell(f);
920
fprintf(f,
921
"8 0 obj\r\n"
922
" << /Type /Font\r\n"
923
" /Subtype /Type1\r\n"
924
" /Name /F1\r\n"
925
" /BaseFont /Helvetica\r\n"
926
" /Encoding /WinAnsiEncoding\r\n"
927
" >>\r\n"
928
"endobj\r\n");
929
930
xref[9] = (uint32_t)ftell(f);
931
fprintf(f,
932
"9 0 obj\r\n"
933
" << /Creator (SolveSpace)\r\n"
934
" >>\r\n");
936
uint32_t xrefStart = (uint32_t)ftell(f);
937
fprintf(f,
938
"xref\r\n"
939
"0 10\r\n"
940
"0000000000 65535 f\r\n");
942
int i;
943
for(i = 1; i <= 9; i++) {
944
fprintf(f, "%010d %05d n\r\n", xref[i], 0);
945
}
946
947
fprintf(f,
948
"\r\n"
949
"trailer\r\n"
950
" << /Size 10\r\n"
951
" /Root 1 0 R\r\n"
952
" /Info 9 0 R\r\n"
953
" >>\r\n"
954
"startxref\r\n"
955
"%d\r\n"
956
"%%%%EOF\r\n",
957
xrefStart);
958
959
fclose(f);
960
961
}
962
963
void PdfFileWriter::Background(RgbaColor color) {
964
double width = ptMax.x - ptMin.x;
965
double height = ptMax.y - ptMin.y;
966
double sw = max(width, height) / 1000;
967
968
fprintf(f,
969
"1 J 1 j\r\n"
970
"%.3f %.3f %.3f RG\r\n"
971
"%.3f %.3f %.3f rg\r\n"
972
"%.3f w\r\n"
973
"%.3f %.3f m\r\n"
974
"%.3f %.3f l\r\n"
975
"%.3f %.3f l\r\n"
976
"%.3f %.3f l\r\n"
977
"b\r\n",
978
color.redF(), color.greenF(), color.blueF(),
979
color.redF(), color.greenF(), color.blueF(),
980
MmToPts(sw),
981
MmToPts(0), MmToPts(0),
982
MmToPts(width), MmToPts(0),
983
MmToPts(width), MmToPts(height),
984
MmToPts(0), MmToPts(height));
985
}
986
987
void PdfFileWriter::StartPath(RgbaColor strokeRgb, double lineWidth,
988
bool filled, RgbaColor fillRgb, hStyle hs)
990
StipplePattern pattern = Style::PatternType(hs);
991
double stippleScale = MmToPts(Style::StippleScaleMm(hs));
992
993
fprintf(f, "1 J 1 j " // round endcaps and joins
994
"%.3f w [%s] 0 d "
995
"%.3f %.3f %.3f RG\r\n",
996
MmToPts(lineWidth),
997
MakeStipplePattern(pattern, stippleScale, ' ').c_str(),
998
strokeRgb.redF(), strokeRgb.greenF(), strokeRgb.blueF());
999
if(filled) {
1000
fprintf(f, "%.3f %.3f %.3f rg\r\n",