//-----------------------------------------------------------------------------

// Export a STEP file describing our ratpoly shell.

//

// Copyright 2008-2013 Jonathan Westhues.

//-----------------------------------------------------------------------------

#include "solvespace.h"

namespace SolveSpace {

#define FP "%.5f" // Floating Point coordinate precision. Since LENGTH_EPS = 1e-6 output 5 decimal places thus rounding out errors e.g. 0.999999mm

#define CARTESIAN_POINT_FORMAT "#%d=CARTESIAN_POINT('',(" FP "," FP "," FP "));\n"

const double PRECISION = 2*LENGTH_EPS;

//-----------------------------------------------------------------------------

// Functions for STEP export: duplication check.

//-----------------------------------------------------------------------------

// Check if this point was already defined with a different ID number.

// inputs:

// number -> id of the cartesian point

// v -> position of the cartesian point

// vertex -> id of the vertex linked to this point (<1 if none)

// return:

// true, if the cartesian point is already defined

bool StepFileWriter::HasCartesianPointAnAlias(int number, Vector v, int vertex, bool *vertex_has_alias) {

// Look for this point "v" in the alias list.

for(pointAliases_t &p : pointAliases) {

if(p.v.Equals(v, PRECISION)) {

// This point was already defined.

// The new number is just an alias.

p.alias.aliases.push_back(number);

if(vertex > 0) {

p.vertexAlias.reference = (p.vertexAlias.reference <= 0 ?

vertex : p.vertexAlias.reference);

p.vertexAlias.aliases.push_back(vertex);

// If the caller is interested let them know if the vertex is new or has an existing alias.

if(nullptr != vertex_has_alias) {

if(p.vertexAlias.aliases.size() == 1) {

// This is a new vertex.

*vertex_has_alias = false;

} else {

*vertex_has_alias = true;

}

}

}

return true;

}

}

// No point was found, it means this is a new point.

pointAliases_t newPoint;

newPoint.alias.reference = number;

newPoint.alias.aliases.push_back(number);

newPoint.v = v;

newPoint.vertexAlias.reference = vertex;

if(vertex > 0) {

newPoint.vertexAlias.aliases.push_back(vertex);

}

// A new entry in the list.

pointAliases.push_back(newPoint);

return false;

}

// Return a cartesian point index; if the point has aliases return the

// first one.

// input:

// number -> the id of the requested cartesian point

// return:

// number, if the point has no aliases, otherwise its first alias

int StepFileWriter::InsertPoint(int number) {

// Look for a point with index "number" in the list of aliases.

for(pointAliases_t p : pointAliases) {

for(int alias : p.alias.aliases) {

if(alias == number) {

return p.alias.reference;

}

}

}

// ERROR: it should never reach this point...

return -1;

}

// Return a vertex index; if the vertex has aliases return the

// first one.

// input:

// number -> the id of the requested vertex

// return:

// number, if the vertex has no aliases, otherwise its first alias

int StepFileWriter::InsertVertex(int number) {

// Look for a point with index "number" in the list of vertex aliases.

for(pointAliases_t p : pointAliases) {

for(int alias : p.vertexAlias.aliases) {

if(alias == number) {

return p.vertexAlias.reference;

}

}

}

// ERROR: it should never reach this point...

return -1;

}

// Check whether this curve was already defined with a different ID number.

// inputs:

// number -> id of the curve

// points -> list of points that define the curve

// return:

// true, if the curve is already defined

bool StepFileWriter::HasBSplineCurveAnAlias(int number, std::vector<int> points) {

// Look for this curve in the alias list.

for(curveAliases_t &c : curveAliases) {

if(points.size() != c.memberPoints.size()) {

continue;

} if(exportParts && !(c.color.Equals(currentColor))) {

continue;

} else {

size_t matches = 0; // is this the same curve?

// FIXME: this hack should work _most_ of the times

for(size_t i = 0; i < points.size(); i++) {

for(size_t j = 0; j < points.size(); j++) {

if(points[i] == c.memberPoints[j]) {

matches++;

}

}

}

if(matches == points.size()) {

// Add this alias.

c.alias.aliases.push_back(number);

return true;

}

}

}

// No curve was found, it means this is a new curve.

curveAliases_t newCurve;

newCurve.alias.reference = number;

newCurve.alias.aliases.push_back(number);

newCurve.memberPoints = points;

newCurve.color = currentColor;

// A new entry in the list.

curveAliases.push_back(newCurve);

return false;

}

// Return a curve index. As above.

int StepFileWriter::InsertCurve(int number) {

for(curveAliases_t c : curveAliases) {

for(int alias : c.alias.aliases) {

if(alias == number && (!exportParts || c.color.Equals(currentColor))) {

return c.alias.reference;

}

}

}

// ERROR: it should never reach this point...

return -1;

}

// Check whether this edge curve was already defined with a different ID number.

// inputs:

// number -> id of the edge

// prevFinish, thisFinish -> points of the edge

// curveID -> curve of the edge

// flip -> if an edge curve already exists this indicates whether it is in the other direction

// return:

// true, if the edge curve is already defined

bool StepFileWriter::HasEdgeCurveAnAlias(int number, int prevFinish, int thisFinish, int curveId, bool *flip) {

// Look for this edge in the alias list.

for(edgeCurveAliases_t &e : edgeCurveAliases) {

if(exportParts && !(e.color.Equals(currentColor))) {

continue;

}

// Check both directions.

if(((prevFinish == e.prevFinish && thisFinish == e.thisFinish) ||

(prevFinish == e.thisFinish && thisFinish == e.prevFinish)) &&

curveId == e.curveId) {

e.alias.aliases.push_back(number);

if(nullptr != flip) {

if(prevFinish == e.thisFinish && thisFinish == e.prevFinish)

*flip = true;

else

*flip = false;

}

return true;

}

}

// New edge curve.

edgeCurveAliases_t newEdgeCurve;

newEdgeCurve.alias.reference = number;

newEdgeCurve.alias.aliases.push_back(number);

newEdgeCurve.prevFinish = prevFinish;

newEdgeCurve.thisFinish = thisFinish;

newEdgeCurve.curveId = curveId;

newEdgeCurve.color = currentColor;

edgeCurveAliases.push_back(newEdgeCurve);

return false;

}

// Return an edge curve index. As above.

int StepFileWriter::InsertEdgeCurve(int number) {

for(edgeCurveAliases_t e : edgeCurveAliases) {

for(int alias : e.alias.aliases) {

if(alias == number && (!exportParts || e.color.Equals(currentColor))) {

return e.alias.reference;

}

}

}

// ERROR: it should never reach this point...

return -1;

}

// Check whether this oriented edge curve was already defined with a different ID number.

// inputs:

// number -> id of the edge

// edgeCurveId -> curve of the edge

// flip -> the direction of the oriented edge

// return:

// true, if the oriented edge is already defined

bool StepFileWriter::HasOrientedEdgeAnAlias(int number, int edgeCurveId, bool flip) {

// Look for this edge in the alias list.

for(orientedEdgeAliases_t &e : orientedEdgeAliases) {

if((edgeCurveId == e.edgeCurveId) && (flip == e.flip)) {

e.alias.aliases.push_back(number);

return true;

}

}

// New oriented edge.

orientedEdgeAliases_t newOrientedEdge;

newOrientedEdge.alias.reference = number;

newOrientedEdge.alias.aliases.push_back(number);

newOrientedEdge.edgeCurveId = edgeCurveId;

newOrientedEdge.flip = flip;

orientedEdgeAliases.push_back(newOrientedEdge);

return false;

}

// Return an oriented edge index. As above.

int StepFileWriter::InsertOrientedEdge(int number) {

for(orientedEdgeAliases_t e : orientedEdgeAliases) {

for(int alias : e.alias.aliases) {

if(alias == number) {

return e.alias.reference;

}

}

}

// ERROR: it should never reach this point...

return -1;

}

//-----------------------------------------------------------------------------

// Functions for STEP export: print to file.

//-----------------------------------------------------------------------------

void StepFileWriter::WriteHeader() {

fprintf(f,

"ISO-10303-21;\n"

"HEADER;\n"

"\n"

"FILE_DESCRIPTION((''), '2;1');\n"

"\n"

"FILE_NAME(\n"

" 'output_file',\n"

" '2009-06-07T17:44:47-07:00',\n"

" (''),\n"

" (''),\n"

" 'SolveSpace',\n"

" '',\n"

" ''\n"

");\n"

"\n"

"FILE_SCHEMA (('CONFIG_CONTROL_DESIGN'));\n"

"ENDSEC;\n"

"\n"

"DATA;\n"

"\n"

"/**********************************************************\n"

" * This defines the units and tolerances for the file. It\n"

" * is always the same, independent of the actual data.\n"

" **********************************************************/\n"

"#158=(\n"

"LENGTH_UNIT()\n"

"NAMED_UNIT(*)\n"

"SI_UNIT(.MILLI.,.METRE.)\n"

");\n"

"#161=(\n"

"NAMED_UNIT(*)\n"

"PLANE_ANGLE_UNIT()\n"

"SI_UNIT($,.RADIAN.)\n"

");\n"

"#166=(\n"

"NAMED_UNIT(*)\n"

"SI_UNIT($,.STERADIAN.)\n"

"SOLID_ANGLE_UNIT()\n"

");\n"

"#167=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(%f),#158,\n"

"'DISTANCE_ACCURACY_VALUE',\n"

"'string');\n"

"#168=(\n"

"GEOMETRIC_REPRESENTATION_CONTEXT(3)\n"

"GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#167))\n"

"GLOBAL_UNIT_ASSIGNED_CONTEXT((#166,#161,#158))\n"

"REPRESENTATION_CONTEXT('ID1','3D')\n"

");\n"

"#169=SHAPE_REPRESENTATION('',(#170),#168);\n"

"#170=AXIS2_PLACEMENT_3D('',#173,#171,#172);\n"

"#171=DIRECTION('',(0.,0.,1.));\n"

"#172=DIRECTION('',(1.,0.,0.));\n"

"#173=CARTESIAN_POINT('',(0.,0.,0.));\n"

"\n",

PRECISION);

// Start the ID somewhere beyond the header IDs.

id = 200;

}

void StepFileWriter::WriteProductHeader() {

fprintf(f,

"#175 = SHAPE_DEFINITION_REPRESENTATION(#176, #169);\n"

"#176 = PRODUCT_DEFINITION_SHAPE('Version', 'Test Part', #177);\n"

"#177 = PRODUCT_DEFINITION('Version', 'Test Part', #182, #178);\n"

"#178 = DESIGN_CONTEXT('3D Mechanical Parts', #181, 'design');\n"

"#179 = PRODUCT('1', 'Product', 'Test Part', (#180));\n"

"#180 = MECHANICAL_CONTEXT('3D Mechanical Parts', #181, 'mechanical');\n"

"#181 = APPLICATION_CONTEXT(\n"

"'configuration controlled 3d designs of mechanical parts and assemblies');\n"

"#182 = PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE('Version',\n"

"'Test Part', #179, .MADE.);\n"

"\n"

);

}

int StepFileWriter::ExportCurve(SBezier *sb) {

int i, ret = id;

std::vector<int> curvePoints = {};

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

if (!HasCartesianPointAnAlias(id + 1 + i, sb->ctrl[i], -1))

fprintf(f, CARTESIAN_POINT_FORMAT,

id + 1 + i,

CO(sb->ctrl[i]));

}

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

int point = InsertPoint(id + 1 + i);

curvePoints.push_back(point);

}

if (!HasBSplineCurveAnAlias(ret, curvePoints)) {

fprintf(f, "#%d=(\n", ret);

fprintf(f, "BOUNDED_CURVE()\n");

fprintf(f, "B_SPLINE_CURVE(%d,(", sb->deg);

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

fprintf(f, "#%d", InsertPoint(ret + i + 1));

if(i != sb->deg) fprintf(f, ",");

}

fprintf(f, "),.UNSPECIFIED.,.F.,.F.)\n");

fprintf(f, "B_SPLINE_CURVE_WITH_KNOTS((%d,%d),",

(sb->deg + 1), (sb-> deg + 1));

fprintf(f, "(0.000,1.000),.UNSPECIFIED.)\n");

fprintf(f, "CURVE()\n");

fprintf(f, "GEOMETRIC_REPRESENTATION_ITEM()\n");

fprintf(f, "RATIONAL_B_SPLINE_CURVE((");

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

fprintf(f, "%.10f", sb->weight[i]);

if(i != sb->deg) fprintf(f, ",");

}

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

fprintf(f, "REPRESENTATION_ITEM('')\n);\n");

fprintf(f, "\n");

}

id = ret + 1 + (sb->deg + 1);

return ret;

}

int StepFileWriter::ExportCurveLoop(SBezierLoop *loop, bool inner) {

ssassert(loop->l.n >= 1, "Expected at least one loop");

List<int> listOfTrims = {};

SBezier *sb = loop->l.Last();

int lastFinish, prevFinish;

// Generate "exactly closed" contours, with the same vertex id for the

// finish of a previous edge and the start of the next one. So we need

// the finish of the last Bezier in the loop before we start our process.

bool vertex_has_alias;

if(!HasCartesianPointAnAlias(id, sb->Finish(), id + 1, &vertex_has_alias)) {

fprintf(f, CARTESIAN_POINT_FORMAT,

id, CO(sb->Finish()));

fprintf(f, "#%d=VERTEX_POINT('',#%d);\n", id + 1, InsertPoint(id));

lastFinish = id + 1;

} else if(!vertex_has_alias) {

fprintf(f, "#%d=VERTEX_POINT('',#%d);\n", id + 1, InsertPoint(id));

lastFinish = id + 1;

}

else {

lastFinish = InsertVertex(id+1);

}

prevFinish = lastFinish;

id += 2;

for(sb = loop->l.First(); sb; sb = loop->l.NextAfter(sb)) {

int curveId = ExportCurve(sb);

int thisFinish;

if(loop->l.NextAfter(sb) != NULL) {

if(!HasCartesianPointAnAlias(id, sb->Finish(), id + 1, &vertex_has_alias)) {

fprintf(f, CARTESIAN_POINT_FORMAT,

id, CO(sb->Finish()));

fprintf(f, "#%d=VERTEX_POINT('',#%d);\n", id + 1, InsertPoint(id));

thisFinish = id + 1;

} else if(!vertex_has_alias) {

fprintf(f, "#%d=VERTEX_POINT('',#%d);\n", id + 1, InsertPoint(id));

thisFinish = id + 1;

} else {

thisFinish = InsertVertex(id+1);

}

id += 2;

} else {

thisFinish = lastFinish;

}

bool flip_edge;

if (!HasEdgeCurveAnAlias(id, prevFinish, thisFinish, InsertCurve(curveId), &flip_edge)) {

fprintf(f, "#%d=EDGE_CURVE('',#%d,#%d,#%d,%s);\n",

id, prevFinish, thisFinish, InsertCurve(curveId), ".T.");

if(!HasOrientedEdgeAnAlias(id + 1, id, flip_edge)) {

fprintf(f, "#%d=ORIENTED_EDGE('',*,*,#%d,.T.);\n", id + 1, id);

} else {

ssassert(false, "Impossible");

}

} else if(!HasOrientedEdgeAnAlias(id + 1, id, flip_edge)) {

fprintf(f, "#%d=ORIENTED_EDGE('',*,*,#%d,.%c.);\n", id + 1, InsertEdgeCurve(id),

flip_edge ? 'F' : 'T');

}

int oe = id+1;

listOfTrims.Add(&oe);

id += 2;

prevFinish = thisFinish;

}

fprintf(f, "#%d=EDGE_LOOP('',(", id);

int *oe;

for(oe = listOfTrims.First(); oe; oe = listOfTrims.NextAfter(oe)) {

fprintf(f, "#%d", InsertOrientedEdge(*oe));

if(listOfTrims.NextAfter(oe) != NULL) fprintf(f, ",");

}

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

int fb = id + 1;

fprintf(f, "#%d=%s('',#%d,.T.);\n",

fb, inner ? "FACE_BOUND" : "FACE_OUTER_BOUND", id);

id += 2;

listOfTrims.Clear();

return fb;

}

void StepFileWriter::ExportSurface(SSurface *ss, SBezierList *sbl) {

int i, j, srfid = id;

// Read the colour of the surface: use it to tell apart surfaces

// from different parts.

currentColor = ss->color;

// First, define the control points for the untrimmed surface, if they

// were not already defined.

for(i = 0; i <= ss->degm; i++) {

for(j = 0; j <= ss->degn; j++) {

if (!HasCartesianPointAnAlias(srfid + 1 + j + i*(ss->degn + 1),

ss->ctrl[i][j], -1)) {

fprintf(f, CARTESIAN_POINT_FORMAT,

srfid + 1 + j + i*(ss->degn + 1),

CO(ss->ctrl[i][j]));

}

}

}

// Then, we create the untrimmed surface. We always specify a rational

// B-spline surface (in fact, just a Bezier surface).

fprintf(f, "#%d=(\n", srfid);

fprintf(f, "BOUNDED_SURFACE()\n");

fprintf(f, "B_SPLINE_SURFACE(%d,%d,(", ss->degm, ss->degn);

for(i = 0; i <= ss->degm; i++) {

fprintf(f, "(");

for(j = 0; j <= ss->degn; j++) {

fprintf(f, "#%d", InsertPoint(srfid + 1 + j + i*(ss->degn + 1)));

if(j != ss->degn) fprintf(f, ",");

}

fprintf(f, ")");

if(i != ss->degm) fprintf(f, ",");

}

fprintf(f, "),.UNSPECIFIED.,.F.,.F.,.F.)\n");

fprintf(f, "B_SPLINE_SURFACE_WITH_KNOTS((%d,%d),(%d,%d),",

(ss->degm + 1), (ss->degm + 1),

(ss->degn + 1), (ss->degn + 1));

fprintf(f, "(0.000,1.000),(0.000,1.000),.UNSPECIFIED.)\n");

fprintf(f, "GEOMETRIC_REPRESENTATION_ITEM()\n");

fprintf(f, "RATIONAL_B_SPLINE_SURFACE((");

for(i = 0; i <= ss->degm; i++) {

fprintf(f, "(");

for(j = 0; j <= ss->degn; j++) {

fprintf(f, "%.10f", ss->weight[i][j]);

if(j != ss->degn) fprintf(f, ",");

}

fprintf(f, ")");

if(i != ss->degm) fprintf(f, ",");

}

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

fprintf(f, "REPRESENTATION_ITEM('')\n");

fprintf(f, "SURFACE()\n");

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

fprintf(f, "\n");

id = srfid + 1 + (ss->degm + 1)*(ss->degn + 1);

// Now we do the trim curves. We must group each outer loop separately

// along with its inner faces, so do that now.

SBezierLoopSetSet sblss = {};

SPolygon spxyz = {};

bool allClosed;

SEdge notClosedAt;

// We specify a surface, so it doesn't check for coplanarity; and we

// don't want it to give us any open contours. The polygon and chord

// tolerance are required, because they are used to calculate the

// contour directions and determine inner vs. outer contours.

sblss.FindOuterFacesFrom(sbl, &spxyz, ss,

SS.ExportChordTolMm(),

&allClosed, &notClosedAt,

NULL, NULL,

NULL);

// So in our list of SBezierLoopSet, each set contains at least one loop

// (the outer boundary), plus any inner loops associated with that outer

// loop.

SBezierLoopSet *sbls;

for(sbls = sblss.l.First(); sbls; sbls = sblss.l.NextAfter(sbls)) {

SBezierLoop *loop = sbls->l.First();

List<int> listOfLoops = {};

// Create the face outer boundary from the outer loop.

int fob = ExportCurveLoop(loop, /*inner=*/false);

listOfLoops.Add(&fob);

// And create the face inner boundaries from any inner loops that

// lie within this contour.

loop = sbls->l.NextAfter(loop);

for(; loop; loop = sbls->l.NextAfter(loop)) {

int fib = ExportCurveLoop(loop, /*inner=*/true);

listOfLoops.Add(&fib);

}

// And now create the face that corresponds to this outer loop

// and all of its holes.

int advFaceId = id;

fprintf(f, "#%d=ADVANCED_FACE('',(", advFaceId);

int *fb;

for(fb = listOfLoops.First(); fb; fb = listOfLoops.NextAfter(fb)) {

fprintf(f, "#%d", *fb);

if(listOfLoops.NextAfter(fb) != NULL) fprintf(f, ",");

}

fprintf(f, "),#%d,.T.);\n", srfid);

advancedFaces.Add(&advFaceId);

// Export the surface color and transparency

// https://www.cax-if.org/documents/rec_prac_styling_org_v16.pdf sections 4.4.2 4.2.4 etc.

// https://tracker.dev.opencascade.org/view.php?id=31550

fprintf(f, "#%d=COLOUR_RGB('',%.2f,%.2f,%.2f);\n", ++id, ss->color.redF(),

ss->color.greenF(), ss->color.blueF());

/* // This works in Kisters 3DViewStation but not in KiCAD and Horison EDA,

// it seems they do not support transparency so use the more verbose one below

fprintf(f, "#%d=SURFACE_STYLE_TRANSPARENT(%.2f);\n", ++id, 1.0 - ss->color.alphaF());

++id;

fprintf(f, "#%d=SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#%d,(#%d));\n",

id, id - 2, id - 1);

++id;

fprintf(f, "#%d=SURFACE_SIDE_STYLE('',(#%d));\n", id, id - 1);

*/

// This works in Horison EDA but is more verbose.

++id;

fprintf(f, "#%d=FILL_AREA_STYLE_COLOUR('',#%d);\n", id, id - 1);

++id;

fprintf(f, "#%d=FILL_AREA_STYLE('',(#%d));\n", id, id - 1);

++id;

fprintf(f, "#%d=SURFACE_STYLE_FILL_AREA(#%d);\n", id, id - 1);

fprintf(f, "#%d=SURFACE_STYLE_TRANSPARENT(%.2f);\n", ++id, 1.0 - ss->color.alphaF());

++id;

fprintf(f, "#%d=SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#%d,(#%d));\n", id, id - 5, id - 1);

++id;

fprintf(f, "#%d=SURFACE_SIDE_STYLE('',(#%d, #%d));\n", id, id - 3, id - 1);

++id;

fprintf(f, "#%d=SURFACE_STYLE_USAGE(.BOTH.,#%d);\n", id, id - 1);

++id;

fprintf(f, "#%d=PRESENTATION_STYLE_ASSIGNMENT((#%d));\n", id, id - 1);

++id;

fprintf(f, "#%d=STYLED_ITEM('',(#%d),#%d);\n", id, id - 1, advFaceId);

fprintf(f, "\n");

id++;

listOfLoops.Clear();

}

sblss.Clear();

spxyz.Clear();

}

void StepFileWriter::WriteFooter() {

fprintf(f,

"\n"

"ENDSEC;\n"

"\n"

"END-ISO-10303-21;\n"

);

}

void StepFileWriter::ExportSurfacesTo(const Platform::Path &filename) {

Group *g = SK.GetGroup(SS.GW.activeGroup);

SShell *shell = &(g->runningShell);

if(shell->surface.IsEmpty()) {

Error("The model does not contain any surfaces to export.%s",

!g->runningMesh.l.IsEmpty()

? "\n\nThe model does contain triangles from a mesh, but "

"a triangle mesh cannot be exported as a STEP file. Try "

"File -> Export Mesh... instead."

: "");

return;

}

f = OpenFile(filename, "wb");

if(!f) {

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

return;

}

// Initialization of lists.

pointAliases = {};

curveAliases = {};

edgeCurveAliases = {};

orientedEdgeAliases = {};

WriteHeader();

WriteProductHeader();

advancedFaces = {};

for(SSurface &ss : shell->surface) {

if(ss.trim.IsEmpty())

continue;

// Get all of the loops of Beziers that trim our surface (with each

// Bezier split so that we use the section as t goes from 0 to 1), and

// the piecewise linearization of those loops in xyz space.

SBezierList sbl = {};

ss.MakeSectionEdgesInto(shell, NULL, &sbl);

// Apply the export scale factor.

ss.ScaleSelfBy(1.0/SS.exportScale);

sbl.ScaleSelfBy(1.0/SS.exportScale);

ExportSurface(&ss, &sbl);

sbl.Clear();

}

fprintf(f, "#%d=CLOSED_SHELL('',(", id);

int *af;

for(af = advancedFaces.First(); af; af = advancedFaces.NextAfter(af)) {

fprintf(f, "#%d", *af);

if(advancedFaces.NextAfter(af) != NULL) fprintf(f, ",");

}

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

fprintf(f, "#%d=MANIFOLD_SOLID_BREP('brep',#%d);\n", id+1, id);

fprintf(f, "#%d=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#%d,#170),#168);\n",

id+2, id+1);

fprintf(f, "#%d=SHAPE_REPRESENTATION_RELATIONSHIP($,$,#169,#%d);\n",

id+3, id+2);

WriteFooter();

fclose(f);

advancedFaces.Clear();

pointAliases.clear();

curveAliases.clear();

edgeCurveAliases.clear();

orientedEdgeAliases.clear();

}

void StepFileWriter::WriteWireframe() {

fprintf(f, "#%d=GEOMETRIC_CURVE_SET('curves',(", id);

int *c;

for(c = curves.First(); c; c = curves.NextAfter(c)) {

fprintf(f, "#%d", *c);

if(curves.NextAfter(c) != NULL) fprintf(f, ",");

}

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

fprintf(f, "#%d=GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION"

"('',(#%d,#170),#168);\n", id+1, id);

fprintf(f, "#%d=SHAPE_REPRESENTATION_RELATIONSHIP($,$,#169,#%d);\n",

id+2, id+1);

id += 3;

curves.Clear();

}

} // namespace SolveSpace