void
TriangleMesh::WriteOBJFile(char* output_file) {
stl_generate_shared_vertices(&stl);
stl_write_obj(&stl, output_file);
}
std::vector<Polygons>*
TriangleMesh::slice(const std::vector<double> &z)
{
/*
This method gets called with a list of Z coordinates and outputs
a vector pointer having the same number of items as the original list.
Each item is a vector of polygons created by slicing our mesh at the
given heights.
This method should basically combine the behavior of the existing
Perl methods defined in lib/Slic3r/TriangleMesh.pm:
- analyze(): this creates the 'facets_edges' and the 'edges_facets'
tables (we don't need the 'edges' table)
- slice_facet(): this has to be done for each facet. It generates
intersection lines with each plane identified by the Z list.
The get_layer_range() binary search used to identify the Z range
of the facet is already ported to C++ (see Object.xsp)
- make_loops(): this has to be done for each layer. It creates polygons
from the lines generated by the previous step.
At the end, we free the tables generated by analyze() as we don't
need them anymore.
FUTURE: parallelize slice_facet() and make_loops()
*/
// build a table to map a facet_idx to its three edge indices
if (this->stl.v_shared == NULL) stl_generate_shared_vertices(&(this->stl));
typedef std::pair<int,int> t_edge;
typedef std::vector<t_edge> t_edges; // edge_idx => a_id,b_id
typedef std::map<t_edge,int> t_edges_map; // a_id,b_id => edge_idx
typedef std::vector< std::vector<int> > t_facets_edges;
t_facets_edges facets_edges;
facets_edges.resize(this->stl.stats.number_of_facets);
{
t_edges edges;
// reserve() instad of resize() because otherwise we couldn't read .size() below to assign edge_idx
edges.reserve(this->stl.stats.number_of_facets * 3); // number of edges = number of facets * 3
t_edges_map edges_map;
for (int facet_idx = 0; facet_idx < this->stl.stats.number_of_facets; facet_idx++) {
facets_edges[facet_idx].resize(3);
for (int i = 0; i <= 2; i++) {
int a_id = this->stl.v_indices[facet_idx].vertex[i];
int b_id = this->stl.v_indices[facet_idx].vertex[(i+1) % 3];
int edge_idx;
t_edges_map::const_iterator my_edge = edges_map.find(std::make_pair(b_id,a_id));
if (my_edge != edges_map.end()) {
edge_idx = my_edge->second;
} else {
/* admesh can assign the same edge ID to more than two facets (which is
still topologically correct), so we have to search for a duplicate of
this edge too in case it was already seen in this orientation */
my_edge = edges_map.find(std::make_pair(a_id,b_id));
if (my_edge != edges_map.end()) {
edge_idx = my_edge->second;
} else {
// edge isn't listed in table, so we insert it
edge_idx = edges.size();
edges.push_back(std::make_pair(a_id,b_id));
edges_map[ edges[edge_idx] ] = edge_idx;
}
}
facets_edges[facet_idx][i] = edge_idx;
#ifdef SLIC3R_DEBUG
printf(" [facet %d, edge %d] a_id = %d, b_id = %d --> edge %d\n", facet_idx, i, a_id, b_id, edge_idx);
#endif
}
}
}
std::vector<IntersectionLines> lines(z.size());
for (int facet_idx = 0; facet_idx < this->stl.stats.number_of_facets; facet_idx++) {
stl_facet* facet = &(this->stl.facet_start[facet_idx]);
float min_z = fminf(facet->vertex[0].z, fminf(facet->vertex[1].z, facet->vertex[2].z));
float max_z = fmaxf(facet->vertex[0].z, fmaxf(facet->vertex[1].z, facet->vertex[2].z));
#ifdef SLIC3R_DEBUG
printf("\n==> FACET %d (%f,%f,%f - %f,%f,%f - %f,%f,%f):\n", facet_idx,
facet->vertex[0].x, facet->vertex[0].y, facet->vertex[0].z,
facet->vertex[1].x, facet->vertex[1].y, facet->vertex[1].z,
facet->vertex[2].x, facet->vertex[2].y, facet->vertex[2].z);
printf("z: min = %.2f, max = %.2f\n", min_z, max_z);
#endif
if (min_z == max_z) {
#ifdef SLIC3R_DEBUG
printf("Facet is horizontal; ignoring\n");
#endif
continue;
}
std::vector<double>::const_iterator min_layer, max_layer;
min_layer = std::lower_bound(z.begin(), z.end(), min_z); // first layer whose slice_z is >= min_z
max_layer = std::upper_bound(z.begin() + (min_layer - z.begin()), z.end(), max_z) - 1; // last layer whose slice_z is <= max_z
#ifdef SLIC3R_DEBUG
printf("layers: min = %d, max = %d\n", (int)(min_layer - z.begin()), (int)(max_layer - z.begin()));
#endif
for (std::vector<double>::const_iterator it = min_layer; it != max_layer + 1; ++it) {
std::vector<double>::size_type layer_idx = it - z.begin();
double slice_z = *it;
std::vector<IntersectionPoint> points;
std::vector< std::vector<IntersectionPoint>::size_type > points_on_layer;
bool found_horizontal_edge = false;
/* reorder vertices so that the first one is the one with lowest Z
this is needed to get all intersection lines in a consistent order
(external on the right of the line) */
int i = 0;
if (facet->vertex[1].z == min_z) {
// vertex 1 has lowest Z
i = 1;
} else if (facet->vertex[2].z == min_z) {
// vertex 2 has lowest Z
i = 2;
}
for (int j = i; (j-i) < 3; j++) { // loop through facet edges
int edge_id = facets_edges[facet_idx][j % 3];
int a_id = this->stl.v_indices[facet_idx].vertex[j % 3];
int b_id = this->stl.v_indices[facet_idx].vertex[(j+1) % 3];
stl_vertex* a = &(this->stl.v_shared[a_id]);
stl_vertex* b = &(this->stl.v_shared[b_id]);
if (a->z == b->z && a->z == slice_z) {
// edge is horizontal and belongs to the current layer
/* We assume that this method is never being called for horizontal
facets, so no other edge is going to be on this layer. */
IntersectionLine line;
if (facet->vertex[0].z < slice_z || facet->vertex[1].z < slice_z || facet->vertex[2].z < slice_z) {
line.edge_type = feTop;
std::swap(a, b);
std::swap(a_id, b_id);
} else {
line.edge_type = feBottom;
}
line.a.x = a->x;
line.a.y = a->y;
line.b.x = b->x;
line.b.y = b->y;
line.a_id = a_id;
line.b_id = b_id;
lines[layer_idx].push_back(line);
found_horizontal_edge = true;
break;
} else if (a->z == slice_z) {
IntersectionPoint point;
point.x = a->x;
point.y = a->y;
point.point_id = a_id;
points.push_back(point);
points_on_layer.push_back(points.size()-1);
} else if (b->z == slice_z) {
IntersectionPoint point;
point.x = b->x;
point.y = b->y;
point.point_id = b_id;
points.push_back(point);
points_on_layer.push_back(points.size()-1);
} else if ((a->z < slice_z && b->z > slice_z) || (b->z < slice_z && a->z > slice_z)) {
// edge intersects the current layer; calculate intersection
IntersectionPoint point;
point.x = b->x + (a->x - b->x) * (slice_z - b->z) / (a->z - b->z);
point.y = b->y + (a->y - b->y) * (slice_z - b->z) / (a->z - b->z);
point.edge_id = edge_id;
points.push_back(point);
}
}
if (found_horizontal_edge) continue;
if (!points_on_layer.empty()) {
// we can't have only one point on layer because each vertex gets detected
// twice (once for each edge), and we can't have three points on layer because
// we assume this code is not getting called for horizontal facets
assert(points_on_layer.size() == 2);
assert( points[ points_on_layer[0] ].point_id == points[ points_on_layer[1] ].point_id );
if (points.size() < 3) continue; // no intersection point, this is a V-shaped facet tangent to plane
points.erase( points.begin() + points_on_layer[1] );
}
if (!points.empty()) {
assert(points.size() == 2); // facets must intersect each plane 0 or 2 times
IntersectionLine line;
line.a.x = points[1].x;
line.a.y = points[1].y;
line.b.x = points[0].x;
line.b.y = points[0].y;
line.a_id = points[1].point_id;
line.b_id = points[0].point_id;
line.edge_a_id = points[1].edge_id;
line.edge_b_id = points[0].edge_id;
lines[layer_idx].push_back(line);
}
}
}
// build loops
std::vector<Polygons>* layers = new std::vector<Polygons>(z.size());
for (std::vector<IntersectionLines>::iterator it = lines.begin(); it != lines.end(); ++it) {
int layer_idx = it - lines.begin();
#ifdef SLIC3R_DEBUG
printf("Layer %d:\n", layer_idx);
#endif
// remove tangent edges
for (IntersectionLines::iterator line = it->begin(); line != it->end(); ++line) {
if (line->skip || line->edge_type == feNone) continue;
/* if the line is a facet edge, find another facet edge
having the same endpoints but in reverse order */
for (IntersectionLines::iterator line2 = line + 1; line2 != it->end(); ++line2) {
if (line2->skip || line2->edge_type == feNone) continue;
// are these facets adjacent? (sharing a common edge on this layer)
if (line->a_id == line2->a_id && line->b_id == line2->b_id) {
line2->skip = true;
/* if they are both oriented upwards or downwards (like a 'V')
then we can remove both edges from this layer since it won't
affect the sliced shape */
/* if one of them is oriented upwards and the other is oriented
downwards, let's only keep one of them (it doesn't matter which
one since all 'top' lines were reversed at slicing) */
if (line->edge_type == line2->edge_type) {
line->skip = true;
break;
}
}
}
}
// build a map of lines by edge_a_id and a_id
std::vector<IntersectionLinePtrs> by_edge_a_id, by_a_id;
by_edge_a_id.resize(this->stl.stats.number_of_facets * 3);
by_a_id.resize(this->stl.stats.shared_vertices);
for (IntersectionLines::iterator line = it->begin(); line != it->end(); ++line) {
if (line->skip) continue;
if (line->edge_a_id != -1) by_edge_a_id[line->edge_a_id].push_back(&(*line));
if (line->a_id != -1) by_a_id[line->a_id].push_back(&(*line));
}
CYCLE: while (1) {
// take first spare line and start a new loop
IntersectionLine* first_line = NULL;
for (IntersectionLines::iterator line = it->begin(); line != it->end(); ++line) {
if (line->skip) continue;
first_line = &(*line);
break;
}
if (first_line == NULL) break;
first_line->skip = true;
IntersectionLinePtrs loop;
loop.push_back(first_line);
/*
printf("first_line edge_a_id = %d, edge_b_id = %d, a_id = %d, b_id = %d, a = %d,%d, b = %d,%d\n",
first_line->edge_a_id, first_line->edge_b_id, first_line->a_id, first_line->b_id,
first_line->a.x, first_line->a.y, first_line->b.x, first_line->b.y);
*/
while (1) {
// find a line starting where last one finishes
IntersectionLine* next_line = NULL;
if (loop.back()->edge_b_id != -1) {
IntersectionLinePtrs* candidates = &(by_edge_a_id[loop.back()->edge_b_id]);
for (IntersectionLinePtrs::iterator lineptr = candidates->begin(); lineptr != candidates->end(); ++lineptr) {
if ((*lineptr)->skip) continue;
next_line = *lineptr;
break;
}
}
if (next_line == NULL && loop.back()->b_id != -1) {
IntersectionLinePtrs* candidates = &(by_a_id[loop.back()->b_id]);
for (IntersectionLinePtrs::iterator lineptr = candidates->begin(); lineptr != candidates->end(); ++lineptr) {
if ((*lineptr)->skip) continue;
next_line = *lineptr;
break;
}
}
if (next_line == NULL) {
// check whether we closed this loop
if ((loop.front()->edge_a_id != -1 && loop.front()->edge_a_id == loop.back()->edge_b_id)
|| (loop.front()->a_id != -1 && loop.front()->a_id == loop.back()->b_id)) {
// loop is complete
Polygon p;
p.points.reserve(loop.size());
for (IntersectionLinePtrs::iterator lineptr = loop.begin(); lineptr != loop.end(); ++lineptr) {
p.points.push_back((*lineptr)->a);
}
(*layers)[layer_idx].push_back(p);
#ifdef SLIC3R_DEBUG
printf(" Discovered %s polygon of %d points\n", (p.is_counter_clockwise() ? "ccw" : "cw"), (int)p.points.size());
#endif
goto CYCLE;
}
// we can't close this loop!
//// push @failed_loops, [@loop];
#ifdef SLIC3R_DEBUG
printf(" Unable to close this loop having %d points\n", (int)loop.size());
#endif
goto CYCLE;
}
/*
printf("next_line edge_a_id = %d, edge_b_id = %d, a_id = %d, b_id = %d, a = %d,%d, b = %d,%d\n",
next_line->edge_a_id, next_line->edge_b_id, next_line->a_id, next_line->b_id,
next_line->a.x, next_line->a.y, next_line->b.x, next_line->b.y);
*/
loop.push_back(next_line);
next_line->skip = true;
}
}
}
return layers;
}
int
main(int argc, char **argv) {
stl_file stl_in;
float tolerance = 0;
float increment = 0;
float x_trans;
float y_trans;
float z_trans;
float scale_factor = 0;
float rotate_x_angle = 0;
float rotate_y_angle = 0;
float rotate_z_angle = 0;
int c;
char *program_name;
char *binary_name = NULL;
char *ascii_name = NULL;
char *merge_name = NULL;
char *off_name = NULL;
char *dxf_name = NULL;
char *vrml_name = NULL;
int fixall_flag = 1; /* Default behavior is to fix all. */
int exact_flag = 0; /* All checks turned off by default. */
int tolerance_flag = 0; /* Is tolerance specified on cmdline */
int nearby_flag = 0;
int remove_unconnected_flag = 0;
int fill_holes_flag = 0;
int normal_directions_flag = 0;
int normal_values_flag = 0;
int reverse_all_flag = 0;
int write_binary_stl_flag = 0;
int write_ascii_stl_flag = 0;
int generate_shared_vertices_flag = 0;
int write_off_flag = 0;
int write_dxf_flag = 0;
int write_vrml_flag = 0;
int translate_flag = 0;
int scale_flag = 0;
int rotate_x_flag = 0;
int rotate_y_flag = 0;
int rotate_z_flag = 0;
int mirror_xy_flag = 0;
int mirror_yz_flag = 0;
int mirror_xz_flag = 0;
int merge_flag = 0;
int help_flag = 0;
int version_flag = 0;
int iterations = 2; /* Default number of iterations. */
int increment_flag = 0;
char *input_file = NULL;
int ret = 0;
enum {rotate_x = 1000, rotate_y, rotate_z, merge, help, version,
mirror_xy, mirror_yz, mirror_xz, scale, translate, reverse_all,
off_file, dxf_file, vrml_file
};
struct option long_options[] = {
{"exact", no_argument, NULL, 'e'},
{"nearby", no_argument, NULL, 'n'},
{"tolerance", required_argument, NULL, 't'},
{"iterations", required_argument, NULL, 'i'},
{"increment", required_argument, NULL, 'm'},
{"remove-unconnected", no_argument, NULL, 'u'},
{"fill-holes", no_argument, NULL, 'f'},
{"normal-directions", no_argument, NULL, 'd'},
{"normal-values", no_argument, NULL, 'v'},
{"no-check", no_argument, NULL, 'c'},
{"reverse-all", no_argument, NULL, reverse_all},
{"write-binary-stl", required_argument, NULL, 'b'},
{"write-ascii-stl", required_argument, NULL, 'a'},
{"write-off", required_argument, NULL, off_file},
{"write-dxf", required_argument, NULL, dxf_file},
{"write-vrml", required_argument, NULL, vrml_file},
{"translate", required_argument, NULL, translate},
{"scale", required_argument, NULL, scale},
{"x-rotate", required_argument, NULL, rotate_x},
{"y-rotate", required_argument, NULL, rotate_y},
{"z-rotate", required_argument, NULL, rotate_z},
{"xy-mirror", no_argument, NULL, mirror_xy},
{"yz-mirror", no_argument, NULL, mirror_yz},
{"xz-mirror", no_argument, NULL, mirror_xz},
{"merge", required_argument, NULL, merge},
{"help", no_argument, NULL, help},
{"version", no_argument, NULL, version},
{NULL, 0, NULL, 0}
};
program_name = argv[0];
while((c = getopt_long(argc, argv, "et:i:m:nufdcvb:a:",
long_options, (int *) 0)) != EOF) {
switch(c) {
case 0: /* If *flag is not null */
break;
case 'e':
exact_flag = 1;
fixall_flag = 0;
break;
case 'n':
nearby_flag = 1;
fixall_flag = 0;
break;
case 't':
tolerance_flag = 1;
tolerance = atof(optarg);
break;
case 'i':
iterations = atoi(optarg);
break;
case 'm':
increment_flag = 1;
increment = atof(optarg);
break;
case 'u':
remove_unconnected_flag = 1;
fixall_flag = 0;
break;
case 'f':
fill_holes_flag = 1;
fixall_flag = 0;
break;
case 'd':
normal_directions_flag = 1;
fixall_flag = 0;
break;
case 'v':
normal_values_flag = 1;
fixall_flag = 0;
break;
case 'c':
fixall_flag = 0;
break;
case reverse_all:
reverse_all_flag = 1;
fixall_flag = 0;
break;
case 'b':
write_binary_stl_flag = 1;
binary_name = optarg; /* I'm not sure if this is safe. */
break;
case 'a':
write_ascii_stl_flag = 1;
ascii_name = optarg; /* I'm not sure if this is safe. */
break;
case off_file:
generate_shared_vertices_flag = 1;
write_off_flag = 1;
off_name = optarg;
break;
case vrml_file:
generate_shared_vertices_flag = 1;
write_vrml_flag = 1;
vrml_name = optarg;
break;
case dxf_file:
write_dxf_flag = 1;
dxf_name = optarg;
break;
case translate:
translate_flag = 1;
sscanf(optarg, "%f,%f,%f", &x_trans, &y_trans, &z_trans);
break;
case scale:
scale_flag = 1;
scale_factor = atof(optarg);
break;
case rotate_x:
rotate_x_flag = 1;
rotate_x_angle = atof(optarg);
break;
case rotate_y:
rotate_y_flag = 1;
rotate_y_angle = atof(optarg);
break;
case rotate_z:
rotate_z_flag = 1;
rotate_z_angle = atof(optarg);
break;
case mirror_xy:
mirror_xy_flag = 1;
break;
case mirror_yz:
mirror_yz_flag = 1;
break;
case mirror_xz:
mirror_xz_flag = 1;
break;
case merge:
merge_flag = 1;
merge_name = optarg;
break;
case help:
help_flag = 1;
break;
case version:
version_flag = 1;
break;
default:
usage(1, program_name);
return 1;
}
}
if(help_flag) {
usage(0, program_name);
return 0;
}
if(version_flag) {
printf("ADMesh - version " VERSION "\n");
return 0;
}
if(optind == argc) {
printf("No input file name given.\n");
usage(1, program_name);
return 1;
} else {
input_file = argv[optind];
}
printf("\
ADMesh version " VERSION ", Copyright (C) 1995, 1996 Anthony D. Martin\n\
ADMesh comes with NO WARRANTY. This is free software, and you are welcome to\n\
redistribute it under certain conditions. See the file COPYING for details.\n");
printf("Opening %s\n", input_file);
stl_open(&stl_in, input_file);
stl_exit_on_error(&stl_in);
if(rotate_x_flag) {
printf("Rotating about the x axis by %f degrees...\n", rotate_x_angle);
stl_rotate_x(&stl_in, rotate_x_angle);
}
if(rotate_y_flag) {
printf("Rotating about the y axis by %f degrees...\n", rotate_y_angle);
stl_rotate_y(&stl_in, rotate_y_angle);
}
if(rotate_z_flag) {
printf("Rotating about the z axis by %f degrees...\n", rotate_z_angle);
stl_rotate_z(&stl_in, rotate_z_angle);
}
if(mirror_xy_flag) {
printf("Mirroring about the xy plane...\n");
stl_mirror_xy(&stl_in);
}
if(mirror_yz_flag) {
printf("Mirroring about the yz plane...\n");
stl_mirror_yz(&stl_in);
}
if(mirror_xz_flag) {
printf("Mirroring about the xz plane...\n");
stl_mirror_xz(&stl_in);
}
if(scale_flag) {
printf("Scaling by factor %f...\n", scale_factor);
stl_scale(&stl_in, scale_factor);
}
if(translate_flag) {
printf("Translating to %f, %f, %f ...\n", x_trans, y_trans, z_trans);
stl_translate(&stl_in, x_trans, y_trans, z_trans);
}
if(merge_flag) {
printf("Merging %s with %s\n", input_file, merge_name);
/* Open the file and add the contents to stl_in: */
stl_open_merge(&stl_in, merge_name);
}
stl_repair(&stl_in,
fixall_flag,
exact_flag,
tolerance_flag,
tolerance,
increment_flag,
increment,
nearby_flag,
iterations,
remove_unconnected_flag,
fill_holes_flag,
normal_directions_flag,
normal_values_flag,
reverse_all_flag,
1);
if(generate_shared_vertices_flag) {
printf("Generating shared vertices...\n");
stl_generate_shared_vertices(&stl_in);
}
if(write_off_flag) {
printf("Writing OFF file %s\n", off_name);
stl_write_off(&stl_in, off_name);
if (stl_in.error) {
stl_clear_error(&stl_in);
ret = 1;
}
}
if(write_dxf_flag) {
printf("Writing DXF file %s\n", dxf_name);
stl_write_dxf(&stl_in, dxf_name, "Created by ADMesh version " VERSION);
if (stl_in.error) {
stl_clear_error(&stl_in);
ret = 1;
}
}
if(write_vrml_flag) {
printf("Writing VRML file %s\n", vrml_name);
stl_write_vrml(&stl_in, vrml_name);
if (stl_in.error) {
stl_clear_error(&stl_in);
ret = 1;
}
}
if(write_ascii_stl_flag) {
printf("Writing ascii file %s\n", ascii_name);
stl_write_ascii(&stl_in, ascii_name,
"Processed by ADMesh version " VERSION);
if (stl_in.error) {
stl_clear_error(&stl_in);
ret = 1;
}
}
if(write_binary_stl_flag) {
printf("Writing binary file %s\n", binary_name);
stl_write_binary(&stl_in, binary_name,
"Processed by ADMesh version " VERSION);
if (stl_in.error) {
stl_clear_error(&stl_in);
ret = 1;
}
}
stl_stats_out(&stl_in, stdout, input_file);
stl_close(&stl_in);
if (ret)
fprintf(stderr, "Some part of the procedure failed, see the above log for more information about what happened.\n");
return ret;
}