struct Edge;

struct Vertex {

Vector pos;

std::vector<Edge *> edges;

bool getNext(hStyle hs, Vertex **next) {

auto it = std::find_if(edges.begin(), edges.end(), [&](const Edge *e) {

return e->tag == 0 && e->style.v == hs.v;

});

if(it != edges.end()) {

(*it)->tag = 1;

*next = (*it)->getOtherVertex(this);

return true;

} else {

return false;

}

}

size_t countEdgesWithTagAndStyle(int tag, hStyle hs) const {

return std::count_if(edges.begin(), edges.end(), [&](const Edge *e) {

return e->tag == tag && e->style.v == hs.v;

});

}

};

struct Edge {

Vertex *a;

Vertex *b;

hStyle style;

int tag;

Vertex *getOtherVertex(Vertex *v) {

if(a == v) return b;

if(b == v) return a;

return NULL;

}

bool getStartAndNext(Vertex **start, Vertex **next, bool loop) {

size_t numA = a->countEdgesWithTagAndStyle(0, style);

size_t numB = b->countEdgesWithTagAndStyle(0, style);

if((numA == 1 && numB > 1) || (loop && numA > 1 && numB > 1)) {

*start = a;

*next = b;

return true;

}

if(numA > 1 && numB == 1) {

*start = b;

*next = a;

return true;

}

return false;

}

};

struct VectorHash {

size_t operator()(const Vector &v) const {

static const size_t size = std::numeric_limits<size_t>::max() / 2 - 1;

static const double eps = (4.0 * LENGTH_EPS);

double x = fabs(v.x) / eps;

double y = fabs(v.y) / eps;

size_t xs = size_t(fmod(x, double(size)));

size_t ys = size_t(fmod(y, double(size)));

return ys * size + xs;

}

};

struct VectorPred {

bool operator()(Vector a, Vector b) const {

return a.Equals(b, LENGTH_EPS);

}

};

std::unordered_map<Vector, Vertex *, VectorHash, VectorPred> vertices;

std::vector<Edge *> edges;

~PolylineBuilder() {

clear();

}

void clear() {

for(Edge *e : edges) {

delete e;

}

edges.clear();

for(auto &v : vertices) {

delete v.second;

}

vertices.clear();

}

Vertex *addVertex(const Vector &pos) {

auto it = vertices.find(pos);

if(it != vertices.end()) {

return it->second;

}

Vertex *result = new Vertex;

result->pos = pos;

vertices.emplace(pos, result);

return result;

}

Edge *addEdge(const Vector &p0, const Vector &p1, int style) {

Vertex *v0 = addVertex(p0);

Vertex *v1 = addVertex(p1);

if(v0 == v1) return NULL;

Edge *edge = new Edge { v0, v1, hStyle { (uint32_t)style }, 0 };

edges.push_back(edge);

v0->edges.push_back(edge);

v1->edges.push_back(edge);

return edge;

}

DxfFileWriter *writer;

dxfRW *dxf;

static DRW_Coord toCoord(const Vector &v) {

return DRW_Coord(v.x, v.y, v.z);

}

Vector xfrm(Vector v) {

return writer->Transform(v);

}

DxfWriteInterface(DxfFileWriter *w, dxfRW *dxfrw) :

writer(w), dxf(dxfrw) {}

virtual void writeTextstyles() {

DRW_Textstyle ts;

ts.name = "unicode";

ts.font = "unicode";

dxf->writeTextstyle(&ts);

}

virtual void writeLayers() {

DRW_Layer layer;

layer.name = "dimensions";

dxf->writeLayer(&layer);

layer.name = "text";

dxf->writeLayer(&layer);

std::set<uint32_t> usedStyles;

for(DxfFileWriter::BezierPath &path : writer->paths) {

for(SBezier *sb : path.beziers) {

usedStyles.insert((uint32_t)sb->auxA);

}

}

for(uint32_t v : usedStyles) {

Style *s = Style::Get(hStyle{v});

layer.name = s->DescriptionString();

dxf->writeLayer(&layer);

}

}

virtual void writeLTypes() {

for(int i = 0; i <= Style::LAST_STIPPLE; i++) {

DRW_LType type;

// LibreCAD requires the line type to have one of these exact names,

// or otherwise it overwrites it with its own (continuous) style.

type.name = DxfFileWriter::lineTypeName(i);

double sw = 1.0;

switch(i) {

case Style::STIPPLE_CONTINUOUS:

break;

case Style::STIPPLE_DASH:

type.path.push_back(sw);

type.path.push_back(-sw);

break;

case Style::STIPPLE_LONG_DASH:

type.path.push_back(sw * 2.0);

type.path.push_back(-sw);

break;

case Style::STIPPLE_DASH_DOT:

type.path.push_back(sw);

type.path.push_back(-sw);

type.path.push_back(0.0);

type.path.push_back(-sw);

break;

case Style::STIPPLE_DOT:

type.path.push_back(sw);

type.path.push_back(0.0);

break;

case Style::STIPPLE_DASH_DOT_DOT:

type.path.push_back(sw);

type.path.push_back(-sw);

type.path.push_back(0.0);

type.path.push_back(-sw);

type.path.push_back(0.0);

type.path.push_back(-sw);

break;

}

dxf->writeLineType(&type);

}

}

void writePolylines() {

PolylineBuilder builder;

for(DxfFileWriter::BezierPath &path : writer->paths) {

for(SBezier *sb : path.beziers) {

if(sb->deg != 1) continue;

builder.addEdge(sb->ctrl[0], sb->ctrl[1], sb->auxA);

}

}

bool found;

bool loop = false;

do {

found = false;

for(PolylineBuilder::Edge *e : builder.edges) {

if(e->tag != 0) continue;

PolylineBuilder::Vertex *start;

PolylineBuilder::Vertex *next;

if(!e->getStartAndNext(&start, &next, loop)) continue;

found = true;

e->tag = 1;

DRW_Polyline polyline;

assignEntityDefaults(&polyline, e->style);

if(!(EXACT(start->pos.z == 0.0) && EXACT(next->pos.z == 0.0))) {

polyline.flags |= 8 /* 3d polyline */;

}

polyline.vertlist.push_back(

new DRW_Vertex(start->pos.x, start->pos.y, start->pos.z, 0.0));

polyline.vertlist.push_back(

new DRW_Vertex(next->pos.x, next->pos.y, next->pos.z, 0.0));

while(next->getNext(e->style, &next)) {

if(!EXACT(next->pos.z == 0.0)) {

polyline.flags |= 8 /* 3d polyline */;

}

polyline.vertlist.push_back(

new DRW_Vertex(next->pos.x, next->pos.y, next->pos.z, 0.0));

}

dxf->writePolyline(&polyline);

}

if(!found && !loop) {

loop = true;

found = true;

}

} while(found);

for(PolylineBuilder::Edge *e : builder.edges) {

if(e->tag != 0) continue;

writeLine(e->a->pos, e->b->pos, e->style);

}

}

virtual void writeEntities() {

writePolylines();

for(DxfFileWriter::BezierPath &path : writer->paths) {

for(SBezier *sb : path.beziers) {

if(sb->deg == 1) continue;

writeBezier(sb);

}

}

if(writer->constraint) {

Constraint *c;

for(c = writer->constraint->First(); c; c = writer->constraint->NextAfter(c)) {

if(!writer->NeedToOutput(c)) continue;

switch(c->type) {

case Constraint::PT_PT_DISTANCE: {

Vector ap = SK.GetEntity(c->ptA)->PointGetNum();

Vector bp = SK.GetEntity(c->ptB)->PointGetNum();

Vector ref = ((ap.Plus(bp)).ScaledBy(0.5)).Plus(c->disp.offset);

writeAlignedDimension(xfrm(ap), xfrm(bp), xfrm(ref),

xfrm(ref), c->Label(), c->GetStyle(), c->valA);

break;

}

case Constraint::PT_LINE_DISTANCE: {

Vector pt = SK.GetEntity(c->ptA)->PointGetNum();

Entity *line = SK.GetEntity(c->entityA);

Vector lA = SK.GetEntity(line->point[0])->PointGetNum();

Vector lB = SK.GetEntity(line->point[1])->PointGetNum();

Vector dl = lB.Minus(lA);

Vector closest = pt.ClosestPointOnLine(lA, dl);

if(pt.Equals(closest)) break;

Vector ref = ((closest.Plus(pt)).ScaledBy(0.5)).Plus(c->disp.offset);

Vector refClosest = ref.ClosestPointOnLine(lA, dl);

double ddl = dl.Dot(dl);

if(fabs(ddl) > LENGTH_EPS * LENGTH_EPS) {

double t = refClosest.Minus(lA).Dot(dl) / ddl;

if(t < 0.0) {

refClosest = lA;

} else if(t > 1.0) {

refClosest = lB;

}

}

Vector xdl = xfrm(lB).Minus(xfrm(lA));

writeLinearDimension(xfrm(pt), xfrm(refClosest), xfrm(ref),

xfrm(ref), c->Label(),

atan2(xdl.y, xdl.x) / PI * 180.0 + 90.0, 0.0,

c->GetStyle(), c->valA);

break;

}

case Constraint::DIAMETER: {

Entity *circle = SK.GetEntity(c->entityA);

Vector center = SK.GetEntity(circle->point[0])->PointGetNum();

Quaternion q = SK.GetEntity(circle->normal)->NormalGetNum();

Vector n = q.RotationN().WithMagnitude(1);

double r = circle->CircleGetRadiusNum();

Vector ref = center.Plus(c->disp.offset);

// Force the label into the same plane as the circle.

ref = ref.Minus(n.ScaledBy(n.Dot(ref) - n.Dot(center)));

Vector rad = ref.Minus(center).WithMagnitude(r);

if(/*isRadius*/c->other) {

writeRadialDimension(

xfrm(center), xfrm(center.Plus(rad)),

xfrm(ref), c->Label(), c->GetStyle(), c->valA);

} else {

writeDiametricDimension(

xfrm(center.Minus(rad)), xfrm(center.Plus(rad)),

xfrm(ref), c->Label(), c->GetStyle(), c->valA);

}

break;

}

case Constraint::ANGLE: {

Entity *a = SK.GetEntity(c->entityA);

Entity *b = SK.GetEntity(c->entityB);

Vector a0 = a->VectorGetStartPoint();

Vector b0 = b->VectorGetStartPoint();

Vector da = a->VectorGetNum();

Vector db = b->VectorGetNum();

if(/*otherAngle*/c->other) {

a0 = a0.Plus(da);

da = da.ScaledBy(-1);

}

bool skew = false;

Vector ref = c->disp.offset;

Vector pi = Vector::AtIntersectionOfLines(a0, a0.Plus(da), b0, b0.Plus(db),

&skew);

if(!skew) ref = pi.Plus(c->disp.offset);

Vector norm = da.Cross(db);

Vector dna = norm.Cross(da).WithMagnitude(1.0);

double thetaf = acos(da.DirectionCosineWith(db));

// Calculate median

Vector m = da.WithMagnitude(1.0).ScaledBy(cos(thetaf/2)).Plus(

dna.ScaledBy(sin(thetaf/2)));

Vector rm = ref.Minus(pi);

// Test which side we have to place an arc

if(m.Dot(rm) < 0) {

da = da.ScaledBy(-1); dna = dna.ScaledBy(-1);

db = db.ScaledBy(-1);

}

Vector bisect = da.WithMagnitude(1.0).ScaledBy(cos(thetaf / 2.0)).Plus(

dna.ScaledBy(sin(thetaf / 2.0)));

ref = pi.Plus(bisect.WithMagnitude(c->disp.offset.Magnitude()));

// Get lines agian to write exact line.

a0 = a->VectorGetStartPoint();

b0 = b->VectorGetStartPoint();

da = a->VectorGetNum();

db = b->VectorGetNum();

writeAngularDimension(

xfrm(a0), xfrm(a0.Plus(da)), xfrm(b0), xfrm(b0.Plus(db)), xfrm(ref),

xfrm(ref), c->Label(), c->GetStyle(), c->valA);

break;

}

case Constraint::COMMENT: {

Style *st = SK.style.FindById(c->GetStyle());

writeText(xfrm(c->disp.offset), c->Label(),

Style::TextHeight(c->GetStyle()) / SS.GW.scale,

st->textAngle, st->textOrigin, c->GetStyle());

break;

}

}

}

}

}

int findDxfColor(const RgbaColor &src) {

int best = 0;

double minDist = VERY_POSITIVE;

Vector srcv = Vector::From(src.redF(), src.greenF(), src.blueF());

for(int i = 1; i < 256; i++) {

RgbaColor dst = RGBi(DRW::dxfColors[i][0], DRW::dxfColors[i][1], DRW::dxfColors[i][2]);

Vector dstv = Vector::From(dst.redF(), dst.greenF(), dst.blueF());

double dist = srcv.Minus(dstv).Magnitude();

if(dist < minDist || best == 0) {

best = i;

minDist = dist;

}

}

return best;

}

void assignEntityDefaults(DRW_Entity *entity, hStyle hs) {

Style *s = Style::Get(hs);

RgbaColor color = s->Color(hs, true);

entity->color24 = color.ToPackedIntBGRA();

entity->color = findDxfColor(color);

entity->layer = s->DescriptionString();

entity->lineType = DxfFileWriter::lineTypeName(s->stippleType);

entity->ltypeScale = Style::StippleScaleMm(s->h);

entity->setWidthMm(Style::WidthMm(hs.v));

}

void assignDimensionDefaults(DRW_Dimension *dimension, hStyle hs) {

assignEntityDefaults(dimension, hs);

dimension->layer = "dimensions";

}

void writeLine(const Vector &p0, const Vector &p1, hStyle hs) {

DRW_Line line;

assignEntityDefaults(&line, hs);

line.basePoint = toCoord(p0);

line.secPoint = toCoord(p1);

dxf->writeLine(&line);

}

void writeArc(const Vector &c, double r, double sa, double ea, hStyle hs) {

DRW_Arc arc;

assignEntityDefaults(&arc, hs);

arc.radious = r;

arc.basePoint = toCoord(c);

arc.staangle = sa;

arc.endangle = ea;

dxf->writeArc(&arc);

}

void writeBezierAsPwl(SBezier *sb) {

List<Vector> lv = {};

sb->MakePwlInto(&lv, SS.ExportChordTolMm());

hStyle hs = { (uint32_t)sb->auxA };

DRW_Polyline polyline;

assignEntityDefaults(&polyline, hs);

for(int i = 0; i < lv.n; i++) {

Vector *v = &lv.elem[i];

DRW_Vertex *vertex = new DRW_Vertex(v->x, v->y, v->z, 0.0);

polyline.vertlist.push_back(vertex);

}

dxf->writePolyline(&polyline);

lv.Clear();

}

void makeKnotsFor(DRW_Spline *spline) {

// QCad/LibreCAD require this for some reason.

if(spline->degree == 3) {

spline->nknots = 8;

spline->knotslist.push_back(0.0);

spline->knotslist.push_back(0.0);

spline->knotslist.push_back(0.0);

spline->knotslist.push_back(0.0);

spline->knotslist.push_back(1.0);

spline->knotslist.push_back(1.0);

spline->knotslist.push_back(1.0);

spline->knotslist.push_back(1.0);

} else if(spline->degree == 2) {

spline->nknots = 6;

spline->knotslist.push_back(0.0);

spline->knotslist.push_back(0.0);

spline->knotslist.push_back(0.0);

spline->knotslist.push_back(1.0);

spline->knotslist.push_back(1.0);

spline->knotslist.push_back(1.0);

} else {

oops();

}

}

void writeSpline(SBezier *sb) {

bool isRational = sb->IsRational();

hStyle hs = { (uint32_t)sb->auxA };

DRW_Spline spline;

assignEntityDefaults(&spline, hs);

spline.flags = (isRational) ? 0x04 : 0x08;

spline.degree = sb->deg;

spline.ncontrol = sb->deg + 1;

makeKnotsFor(&spline);

for(int i = 0; i <= sb->deg; i++) {

spline.controllist.push_back(

new DRW_Coord(sb->ctrl[i].x, sb->ctrl[i].y, sb->ctrl[i].z));

if(isRational) spline.weightlist.push_back(sb->weight[i]);

}

dxf->writeSpline(&spline);

}

void writeBezier(SBezier *sb) {

hStyle hs = { (uint32_t)sb->auxA };

Vector c;

Vector n = Vector::From(0.0, 0.0, 1.0);

double r;

if(sb->deg == 1) {

// Line

writeLine(sb->ctrl[0], sb->ctrl[1], hs);

} else if(sb->IsInPlane(n, 0) && sb->IsCircle(n, &c, &r)) {

// Circle perpendicular to camera

double theta0 = atan2(sb->ctrl[0].y - c.y, sb->ctrl[0].x - c.x);

double theta1 = atan2(sb->ctrl[2].y - c.y, sb->ctrl[2].x - c.x);

double dtheta = WRAP_SYMMETRIC(theta1 - theta0, 2.0 * PI);

if(dtheta < 0.0) swap(theta0, theta1);

writeArc(c, r, theta0, theta1, hs);

} else if(sb->IsRational()) {

// Rational bezier

// We'd like to export rational beziers exactly, but the resulting DXF

// files can only be read by AutoCAD; LibreCAD/QCad simply do not

// implement the feature. So, export as piecewise linear for compatiblity.

writeBezierAsPwl(sb);

} else {

// Any other curve

writeSpline(sb);

}

}

void writeAlignedDimension(Vector def1, Vector def2, Vector dimp,

Vector textp, const std::string &text, hStyle hs, double actual) {

DRW_DimAligned dim;

assignDimensionDefaults(&dim, hs);

dim.setDef1Point(toCoord(def1));

dim.setDef2Point(toCoord(def2));

dim.setDimPoint(toCoord(dimp));

dim.setTextPoint(toCoord(textp));

dim.setText(text);

dim.setActualMeasurement(actual);

dxf->writeDimension(&dim);

}

void writeLinearDimension(Vector def1, Vector def2, Vector dimp,

Vector textp, const std::string &text,

double angle, double oblique, hStyle hs, double actual) {

DRW_DimLinear dim;

assignDimensionDefaults(&dim, hs);

dim.setDef1Point(toCoord(def1));

dim.setDef2Point(toCoord(def2));

dim.setDimPoint(toCoord(dimp));

dim.setTextPoint(toCoord(textp));

dim.setText(text);

dim.setAngle(angle);

dim.setOblique(oblique);

dim.setActualMeasurement(actual);

dxf->writeDimension(&dim);

}

void writeRadialDimension(Vector center, Vector radius,

Vector textp, const std::string &text, hStyle hs, double actual) {

DRW_DimRadial dim;

assignDimensionDefaults(&dim, hs);

dim.setCenterPoint(toCoord(center));

dim.setDiameterPoint(toCoord(radius));

dim.setTextPoint(toCoord(textp));

dim.setText(text);

dim.setActualMeasurement(actual);

dxf->writeDimension(&dim);

}

void writeDiametricDimension(Vector def1, Vector def2,

Vector textp, const std::string &text, hStyle hs, double actual) {

DRW_DimDiametric dim;

assignDimensionDefaults(&dim, hs);

dim.setDiameter1Point(toCoord(def1));

dim.setDiameter2Point(toCoord(def2));

dim.setTextPoint(toCoord(textp));

dim.setText(text);

dim.setActualMeasurement(actual);

dxf->writeDimension(&dim);

}

void writeAngularDimension(Vector fl1, Vector fl2, Vector sl1, Vector sl2, Vector dimp,

Vector textp, const std::string &text, hStyle hs, double actual) {

DRW_DimAngular dim;

assignDimensionDefaults(&dim, hs);

dim.setFirstLine1(toCoord(fl1));

dim.setFirstLine2(toCoord(fl2));

dim.setSecondLine1(toCoord(sl1));

dim.setSecondLine2(toCoord(sl2));

dim.setDimPoint(toCoord(dimp));

dim.setTextPoint(toCoord(textp));

dim.setText(text);

dim.setActualMeasurement(actual * PI / 180.0);

dxf->writeDimension(&dim);

}

void writeText(Vector textp, const std::string &text,

double height, double angle, int origin, hStyle hs) {

DRW_Text txt;

assignEntityDefaults(&txt, hs);

txt.layer = "text";

txt.style = "unicode";

txt.basePoint = toCoord(textp);

txt.secPoint = txt.basePoint;

txt.text = text;

txt.height = height;

txt.angle = angle;

txt.alignH = DRW_Text::HCenter;

if(origin & Style::ORIGIN_LEFT) {

txt.alignH = DRW_Text::HLeft;

} else if(origin & Style::ORIGIN_RIGHT) {

txt.alignH = DRW_Text::HRight;

}

txt.alignV = DRW_Text::VMiddle;

if(origin & Style::ORIGIN_TOP) {

txt.alignV = DRW_Text::VTop;

} else if(origin & Style::ORIGIN_BOT) {

txt.alignV = DRW_Text::VBaseLine;

}

dxf->writeText(&txt);

}

bool filled, RgbaColor fillRgb, hStyle hs)

{

BezierPath path = {};

paths.push_back(path);

dxfRW dxf;

DxfWriteInterface interface(this, &dxf);

std::stringstream stream;

dxf.write(stream, &interface, DRW::AC1021, /*bin=*/false);

paths.clear();

constraint = NULL;

if(!WriteFile(filename, stream.str())) {

Error("Couldn't write to '%s'", filename.c_str());

return;

}

switch(c->type) {

case Constraint::PT_PT_DISTANCE:

case Constraint::PT_LINE_DISTANCE:

case Constraint::DIAMETER:

case Constraint::ANGLE:

case Constraint::COMMENT:

return c->IsVisible();

}

return false;

bool inkscapeWorkaround = false) {

scale /= 2.0;

// Inkscape ignores all elements that are exactly zero instead of drawing

// them as dots.

double zero = inkscapeWorkaround ? 1e-6 : 0;

std::string result;

switch(pattern) {

case Style::STIPPLE_CONTINUOUS:

case Style::STIPPLE_FREEHAND:

case Style::STIPPLE_ZIGZAG:

return "";

case Style::STIPPLE_DASH:

result = ssprintf("%.3f_%.3f", scale, scale);

break;

case Style::STIPPLE_DASH_DOT:

result = ssprintf("%.3f_%.3f_%.6f_%.3f",

scale, scale * 0.5, zero, scale * 0.5);

break;

case Style::STIPPLE_DASH_DOT_DOT:

result = ssprintf("%.3f_%.3f_%.6f_%.3f_%.6f_%.3f",

scale, scale * 0.5, zero,

scale * 0.5, scale * 0.5, zero);

break;

case Style::STIPPLE_DOT:

result = ssprintf("%.6f_%.3f", zero, scale * 0.5);

break;

case Style::STIPPLE_LONG_DASH:

result = ssprintf("%.3f_%.3f", scale * 2.0, scale * 0.5);

break;

default:

oops();

}

std::replace(result.begin(), result.end(), '_', delimiter);

return result;

fprintf(f,

"\r\n",

(int)ceil(MmToPts(ptMax.x - ptMin.x)),

(int)ceil(MmToPts(ptMax.y - ptMin.y)),

MmToPts(ptMax.x - ptMin.x),

MmToPts(ptMax.y - ptMin.y));

bool filled, RgbaColor fillRgb, hStyle hs)

{

fprintf(f, "newpath\r\n");

prevPt = Vector::From(VERY_POSITIVE, VERY_POSITIVE, VERY_POSITIVE);

bool filled, RgbaColor fillRgb, hStyle hs)

{

int pattern = Style::PatternType(hs);

double stippleScale = MmToPts(Style::StippleScaleMm(hs));

fprintf(f, " %.3f setlinewidth\r\n"

" %.3f %.3f %.3f setrgbcolor\r\n"

" 1 setlinejoin\r\n" // rounded

" 1 setlinecap\r\n" // rounded

" [%s] 0 setdash\r\n"

" gsave stroke grestore\r\n",

MmToPts(lineWidth),

strokeRgb.redF(), strokeRgb.greenF(), strokeRgb.blueF(),

MakeStipplePattern(pattern, stippleScale, ' ').c_str()

);

if(filled) {

fprintf(f, " %.3f %.3f %.3f setrgbcolor\r\n"

" gsave fill grestore\r\n",

fillRgb.redF(), fillRgb.greenF(), fillRgb.blueF());

}

if(!prevPt.Equals(st)) {

fprintf(f, " %.3f %.3f moveto\r\n",

MmToPts(st.x - ptMin.x), MmToPts(st.y - ptMin.y));

}

prevPt = fi;

fprintf(f,

"gsave fill grestore\r\n",

tr->meta.color.redF(), tr->meta.color.greenF(), tr->meta.color.blueF(),

MmToPts(tr->a.x - ptMin.x), MmToPts(tr->a.y - ptMin.y),

MmToPts(tr->b.x - ptMin.x), MmToPts(tr->b.y - ptMin.y),

MmToPts(tr->c.x - ptMin.x), MmToPts(tr->c.y - ptMin.y));

// same issue with cracks, stroke it to avoid them

double sw = max(ptMax.x - ptMin.x, ptMax.y - ptMin.y) / 1000;

fprintf(f,

"gsave stroke grestore\r\n",

MmToPts(sw));

Vector c, n = Vector::From(0, 0, 1);

double r;

if(sb->deg == 1) {

MaybeMoveTo(sb->ctrl[0], sb->ctrl[1]);

fprintf(f, " %.3f %.3f lineto\r\n",

MmToPts(sb->ctrl[1].x - ptMin.x),

MmToPts(sb->ctrl[1].y - ptMin.y));

} else if(sb->IsCircle(n, &c, &r)) {

Vector p0 = sb->ctrl[0], p1 = sb->ctrl[2];

double theta0 = atan2(p0.y - c.y, p0.x - c.x),

theta1 = atan2(p1.y - c.y, p1.x - c.x),

dtheta = WRAP_SYMMETRIC(theta1 - theta0, 2*PI);

MaybeMoveTo(p0, p1);

fprintf(f,

" %.3f %.3f %.3f %.3f %.3f %s\r\n",

MmToPts(c.x - ptMin.x), MmToPts(c.y - ptMin.y),

MmToPts(r),

theta0*180/PI, theta1*180/PI,

dtheta < 0 ? "arcn" : "arc");

} else if(sb->deg == 3 && !sb->IsRational()) {

MaybeMoveTo(sb->ctrl[0], sb->ctrl[3]);

fprintf(f,

" %.3f %.3f %.3f %.3f %.3f %.3f curveto\r\n",

MmToPts(sb->ctrl[1].x - ptMin.x), MmToPts(sb->ctrl[1].y - ptMin.y),

MmToPts(sb->ctrl[2].x - ptMin.x), MmToPts(sb->ctrl[2].y - ptMin.y),

MmToPts(sb->ctrl[3].x - ptMin.x), MmToPts(sb->ctrl[3].y - ptMin.y));

} else {

BezierAsNonrationalCubic(sb);

}

fprintf(f,

"\r\n");

fclose(f);

if((ptMax.x - ptMin.x) > 200*25.4 ||

(ptMax.y - ptMin.y) > 200*25.4)

{

Message("PDF page size exceeds 200 by 200 inches; many viewers may "

"reject this file.");

}

fprintf(f,

"%%%c%c%c%c\r\n",

0xe2, 0xe3, 0xcf, 0xd3);

xref[1] = (uint32_t)ftell(f);

fprintf(f,

"endobj\r\n");

xref[2] = (uint32_t)ftell(f);

fprintf(f,

"endobj\r\n");

xref[3] = (uint32_t)ftell(f);

fprintf(f,

"endobj\r\n");

xref[4] = (uint32_t)ftell(f);

fprintf(f,

"endobj\r\n",

MmToPts(ptMax.x - ptMin.x),

MmToPts(ptMax.y - ptMin.y));

xref[5] = (uint32_t)ftell(f);

fprintf(f,

"stream\r\n");

bodyStart = (uint32_t)ftell(f);

uint32_t bodyEnd = (uint32_t)ftell(f);

fprintf(f,

"endobj\r\n");

xref[6] = (uint32_t)ftell(f);

fprintf(f,

"endobj\r\n",

bodyEnd - bodyStart);

xref[7] = (uint32_t)ftell(f);

fprintf(f,

"endobj\r\n");

xref[8] = (uint32_t)ftell(f);

fprintf(f,

"endobj\r\n");

xref[9] = (uint32_t)ftell(f);

fprintf(f,