stl.h File Reference

#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <vector>
#include <Eigen/Geometry>

Include dependency graph for stl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	stl_facet
struct	stl_neighbors
struct	stl_stats
struct	stl_file
struct	indexed_triangle_set

Macros
#define	LABEL_SIZE   80
#define	NUM_FACET_SIZE   4
#define	HEADER_SIZE   84
#define	STL_MIN_FILE_SIZE   284
#define	ASCII_LINES_PER_FACET   7
#define	SIZEOF_STL_FACET   50

Typedefs
typedef Eigen::Matrix< float, 3, 1, Eigen::DontAlign >	stl_vertex
typedef Eigen::Matrix< float, 3, 1, Eigen::DontAlign >	stl_normal
typedef Eigen::Matrix< int, 3, 1, Eigen::DontAlign >	stl_triangle_vertex_indices
typedef Eigen::Matrix< float, 3, 1, Eigen::DontAlign >	obj_color

Enumerations
enum	stl_type { binary , ascii , inmemory }

Functions
bool	stl_open (stl_file *stl, const char *file)
void	stl_stats_out (stl_file *stl, FILE *file, char *input_file)
bool	stl_print_neighbors (stl_file *stl, char *file)
bool	stl_write_ascii (stl_file *stl, const char *file, const char *label)
bool	stl_write_binary (stl_file *stl, const char *file, const char *label)
void	stl_check_facets_exact (stl_file *stl)
void	stl_check_facets_nearby (stl_file *stl, float tolerance)
void	stl_remove_unconnected_facets (stl_file *stl)
void	stl_write_vertex (stl_file *stl, int facet, int vertex)
void	stl_write_facet (stl_file *stl, char *label, int facet)
void	stl_write_neighbor (stl_file *stl, int facet)
bool	stl_write_quad_object (stl_file *stl, char *file)
void	stl_verify_neighbors (stl_file *stl)
void	stl_fill_holes (stl_file *stl)
void	stl_fix_normal_directions (stl_file *stl)
void	stl_fix_normal_values (stl_file *stl)
void	stl_reverse_all_facets (stl_file *stl)
void	stl_translate (stl_file *stl, float x, float y, float z)
void	stl_translate_relative (stl_file *stl, float x, float y, float z)
void	stl_scale_versor (stl_file *stl, const stl_vertex &versor)
void	stl_scale (stl_file *stl, float factor)
void	stl_rotate_x (stl_file *stl, float angle)
void	stl_rotate_y (stl_file *stl, float angle)
void	stl_rotate_z (stl_file *stl, float angle)
void	stl_mirror_xy (stl_file *stl)
void	stl_mirror_yz (stl_file *stl)
void	stl_mirror_xz (stl_file *stl)
void	stl_get_size (stl_file *stl)
template<typename T >
void	stl_transform (stl_file *stl, const Eigen::Transform< T, 3, Eigen::Affine, Eigen::DontAlign > &t)
template<typename T >
void	stl_transform (stl_file *stl, const Eigen::Matrix< T, 3, 3, Eigen::DontAlign > &m)
template<typename V >
void	its_translate (indexed_triangle_set &its, const V v)
template<typename T >
void	its_transform (indexed_triangle_set &its, T *trafo3x4)
template<typename T >
void	its_transform (indexed_triangle_set &its, const Eigen::Transform< T, 3, Eigen::Affine, Eigen::DontAlign > &t, bool fix_left_handed=false)
template<typename T >
void	its_transform (indexed_triangle_set &its, const Eigen::Matrix< T, 3, 3, Eigen::DontAlign > &m, bool fix_left_handed=false)
void	its_rotate_x (indexed_triangle_set &its, float angle)
void	its_rotate_y (indexed_triangle_set &its, float angle)
void	its_rotate_z (indexed_triangle_set &its, float angle)
void	stl_generate_shared_vertices (stl_file *stl, indexed_triangle_set &its)
bool	its_write_obj (const indexed_triangle_set &its, const char *file)
bool	its_write_off (const indexed_triangle_set &its, const char *file)
bool	its_write_vrml (const indexed_triangle_set &its, const char *file)
bool	its_write_obj (const indexed_triangle_set &its, const std::vector< obj_color > &color, const char *file)
	write idexed triangle set into obj file with color
bool	stl_write_dxf (stl_file *stl, const char *file, char *label)
void	stl_calculate_normal (stl_normal &normal, stl_facet *facet)
void	stl_normalize_vector (stl_normal &normal)
void	stl_calculate_volume (stl_file *stl)
void	stl_repair (stl_file *stl, bool fixall_flag, bool exact_flag, bool tolerance_flag, float tolerance, bool increment_flag, float increment, bool nearby_flag, int iterations, bool remove_unconnected_flag, bool fill_holes_flag, bool normal_directions_flag, bool normal_values_flag, bool reverse_all_flag, bool verbose_flag)
void	stl_allocate (stl_file *stl)
void	stl_read (stl_file *stl, int first_facet, bool first)
void	stl_facet_stats (stl_file *stl, stl_facet facet, bool &first)
void	stl_reallocate (stl_file *stl)
void	stl_add_facet (stl_file *stl, const stl_facet *new_facet)
bool	stl_validate (const stl_file *stl)
bool	stl_validate (const stl_file *stl, const indexed_triangle_set &its)

Macro Definition Documentation

ASCII_LINES_PER_FACET

#define ASCII_LINES_PER_FACET   7

HEADER_SIZE

#define HEADER_SIZE   84

LABEL_SIZE

#define LABEL_SIZE   80

NUM_FACET_SIZE

#define NUM_FACET_SIZE   4

SIZEOF_STL_FACET

#define SIZEOF_STL_FACET   50

STL_MIN_FILE_SIZE

#define STL_MIN_FILE_SIZE   284

Typedef Documentation

obj_color

typedef Eigen::Matrix<float, 3, 1, Eigen::DontAlign> obj_color

stl_normal

typedef Eigen::Matrix<float, 3, 1, Eigen::DontAlign> stl_normal

stl_triangle_vertex_indices

typedef Eigen::Matrix<int, 3, 1, Eigen::DontAlign> stl_triangle_vertex_indices

stl_vertex

typedef Eigen::Matrix<float, 3, 1, Eigen::DontAlign> stl_vertex

Enumeration Type Documentation

stl_type

enum stl_type

Enumerator
binary
ascii
inmemory

{binary, ascii, inmemory} stl_type;

Function Documentation

its_rotate_x()

void its_rotate_x	(	indexed_triangle_set &	its,
		float	angle
	)

{
  double radian_angle = (angle / 180.0) * M_PI;
  double c = cos(radian_angle);
  double s = sin(radian_angle);
  for (stl_vertex &v : its.vertices)
    rotate_point_2d(v(1), v(2), c, s);
}

References cos(), M_PI, rotate_point_2d(), sin(), and indexed_triangle_set::vertices.

Referenced by Slic3r::TriangleMesh::rotate().

Here is the call graph for this function:

Here is the caller graph for this function:

its_rotate_y()

void its_rotate_y	(	indexed_triangle_set &	its,
		float	angle
	)

{
  double radian_angle = (angle / 180.0) * M_PI;
  double c = cos(radian_angle);
  double s = sin(radian_angle);
  for (stl_vertex& v : its.vertices)
    rotate_point_2d(v(2), v(0), c, s);
}

References cos(), M_PI, rotate_point_2d(), sin(), and indexed_triangle_set::vertices.

Referenced by Slic3r::TriangleMesh::rotate().

Here is the call graph for this function:

Here is the caller graph for this function:

its_rotate_z()

void its_rotate_z	(	indexed_triangle_set &	its,
		float	angle
	)

{
  double radian_angle = (angle / 180.0) * M_PI;
  double c = cos(radian_angle);
  double s = sin(radian_angle);
  for (stl_vertex& v : its.vertices)
    rotate_point_2d(v(0), v(1), c, s);
}

References cos(), M_PI, rotate_point_2d(), sin(), and indexed_triangle_set::vertices.

Referenced by Slic3r::TriangleMesh::rotate(), and Slic3r::TriangleMesh::rotate().

Here is the call graph for this function:

Here is the caller graph for this function:

its_transform() [1/3]

template<typename T >

void its_transform ( indexed_triangle_set &  its, const Eigen::Matrix< T, 3, 3, Eigen::DontAlign > &  m, bool  fix_left_handed = false  )

inline

{
  for (stl_vertex &v : its.vertices)
    v = (m * v.template cast<T>()).template cast<float>().eval();
  if (fix_left_handed && m.determinant() < 0.)
    for (stl_triangle_vertex_indices &i : its.indices)
      std::swap(i[0], i[1]);
}

References indexed_triangle_set::indices, and indexed_triangle_set::vertices.

its_transform() [2/3]

template<typename T >

void its_transform ( indexed_triangle_set &  its, const Eigen::Transform< T, 3, Eigen::Affine, Eigen::DontAlign > &  t, bool  fix_left_handed = false  )

inline

{
  //const Eigen::Matrix<double, 3, 3, Eigen::DontAlign> r = t.matrix().template block<3, 3>(0, 0);
  for (stl_vertex &v : its.vertices)
    v = (t * v.template cast<T>()).template cast<float>().eval();
  if (fix_left_handed && t.matrix().block(0, 0, 3, 3).determinant() < 0.)
    for (stl_triangle_vertex_indices &i : its.indices)
      std::swap(i[0], i[1]);
}

References indexed_triangle_set::indices, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::matrix(), and indexed_triangle_set::vertices.

Here is the call graph for this function:

its_transform() [3/3]

template<typename T >

void its_transform ( indexed_triangle_set &  its, T *  trafo3x4  )

inline

{
  for (stl_vertex &v_dst : its.vertices) {
    stl_vertex  v_src = v_dst;
    v_dst(0) = T(trafo3x4[0] * v_src(0) + trafo3x4[1] * v_src(1) + trafo3x4[2]  * v_src(2) + trafo3x4[3]);
    v_dst(1) = T(trafo3x4[4] * v_src(0) + trafo3x4[5] * v_src(1) + trafo3x4[6]  * v_src(2) + trafo3x4[7]);
    v_dst(2) = T(trafo3x4[8] * v_src(0) + trafo3x4[9] * v_src(1) + trafo3x4[10] * v_src(2) + trafo3x4[11]);
  }
}

References indexed_triangle_set::vertices.

Referenced by Slic3r::SeamPlacerImpl::compute_global_occlusion(), priv::create_emboss_projection(), Slic3r::csgmesh_merge_positive_parts(), priv::cut_surface(), Slic3r::SeamPlacerImpl::gather_enforcers_blockers(), Slic3r::csg::get_cgalmesh(), Slic3r::GUI::GLGizmoCut3D::is_outside_of_cut_contour(), Slic3r::PrintObject::prepare_adaptive_infill_data(), Slic3r::TriangleMesh::rotate(), Slic3r::slice_volumes(), Slic3r::TriangleMesh::transform(), and Slic3r::TriangleMesh::transform().

Here is the caller graph for this function:

its_translate()

template<typename V >

void its_translate ( indexed_triangle_set &  its, const V  v  )

inline

{
  for (stl_vertex &v_dst : its.vertices)
    v_dst += v;
}

References indexed_triangle_set::vertices.

Referenced by Slic3r::GUI::GLGizmoBase::Grabber::render().

Here is the caller graph for this function:

its_write_obj() [1/2]

bool its_write_obj	(	const indexed_triangle_set &	its,
		const char *	file
	)

{
    Slic3r::CNumericLocalesSetter locales_setter;
    FILE *fp = boost::nowide::fopen(file, "w");
    if (fp == nullptr) {
    BOOST_LOG_TRIVIAL(error) << "stl_write_obj: Couldn't open " << file << " for writing";
      return false;
    }
 
  for (size_t i = 0; i < its.vertices.size(); ++ i)
      fprintf(fp, "v %f %f %f\n", its.vertices[i](0), its.vertices[i](1), its.vertices[i](2));
    for (size_t i = 0; i < its.indices.size(); ++ i)
      fprintf(fp, "f %d %d %d\n", its.indices[i][0]+1, its.indices[i][1]+1, its.indices[i][2]+1);
    fclose(fp);
    return true;
}

References error, indexed_triangle_set::indices, and indexed_triangle_set::vertices.

Referenced by Slic3r::its_store_triangle_to_obj(), Slic3r::its_store_triangles_to_obj(), Slic3r::mmu_segmentation_top_and_bottom_layers(), and Slic3r::TriangleMesh::WriteOBJFile().

Here is the caller graph for this function:

its_write_obj() [2/2]

bool its_write_obj	(	const indexed_triangle_set &	its,
		const std::vector< obj_color > &	color,
		const char *	file
	)

write idexed triangle set into obj file with color

Parameters

its	input model
color	color of stored model
file	define place to store

Returns

True on success otherwise FALSE

{
    Slic3r::CNumericLocalesSetter locales_setter;
    FILE* fp = boost::nowide::fopen(file, "w");
    if (fp == nullptr) {
        BOOST_LOG_TRIVIAL(error) << "stl_write_obj: Couldn't open " << file << " for writing";
        return false;
    }
 
    for (size_t i = 0; i < its.vertices.size(); ++i)
        fprintf(fp, "v %f %f %f %f %f %f\n", 
            its.vertices[i](0), 
      its.vertices[i](1), 
      its.vertices[i](2),
            color[i](0), 
      color[i](1), 
      color[i](2));
    for (size_t i = 0; i < its.indices.size(); ++i)
        fprintf(fp, "f %d %d %d\n", 
      its.indices[i][0] + 1, 
      its.indices[i][1] + 1, 
      its.indices[i][2] + 1);
    fclose(fp);
    return true;
}

References error, indexed_triangle_set::indices, and indexed_triangle_set::vertices.

its_write_off()

bool its_write_off	(	const indexed_triangle_set &	its,
		const char *	file
	)

{
    Slic3r::CNumericLocalesSetter locales_setter;
  /* Open the file */
  FILE *fp = boost::nowide::fopen(file, "w");
  if (fp == nullptr) {
    BOOST_LOG_TRIVIAL(error) << "stl_write_ascii: Couldn't open " << file << " for writing";
    return false;
  }
 
  fprintf(fp, "OFF\n");
  fprintf(fp, "%d %d 0\n", (int)its.vertices.size(), (int)its.indices.size());
  for (int i = 0; i < its.vertices.size(); ++ i)
    fprintf(fp, "\t%f %f %f\n", its.vertices[i](0), its.vertices[i](1), its.vertices[i](2));
  for (uint32_t i = 0; i < its.indices.size(); ++ i)
    fprintf(fp, "\t3 %d %d %d\n", its.indices[i][0], its.indices[i][1], its.indices[i][2]);
  fclose(fp);
  return true;
}

References error, indexed_triangle_set::indices, and indexed_triangle_set::vertices.

its_write_vrml()

bool its_write_vrml	(	const indexed_triangle_set &	its,
		const char *	file
	)

{
    Slic3r::CNumericLocalesSetter locales_setter;
  /* Open the file */
    FILE *fp = boost::nowide::fopen(file, "w");
  if (fp == nullptr) {
    BOOST_LOG_TRIVIAL(error) << "stl_write_vrml: Couldn't open " << file << " for writing";
    return false;
  }
 
  fprintf(fp, "#VRML V1.0 ascii\n\n");
  fprintf(fp, "Separator {\n");
  fprintf(fp, "\tDEF STLShape ShapeHints {\n");
  fprintf(fp, "\t\tvertexOrdering COUNTERCLOCKWISE\n");
  fprintf(fp, "\t\tfaceType CONVEX\n");
  fprintf(fp, "\t\tshapeType SOLID\n");
  fprintf(fp, "\t\tcreaseAngle 0.0\n");
  fprintf(fp, "\t}\n");
  fprintf(fp, "\tDEF STLModel Separator {\n");
  fprintf(fp, "\t\tDEF STLColor Material {\n");
  fprintf(fp, "\t\t\temissiveColor 0.700000 0.700000 0.000000\n");
  fprintf(fp, "\t\t}\n");
  fprintf(fp, "\t\tDEF STLVertices Coordinate3 {\n");
  fprintf(fp, "\t\t\tpoint [\n");
 
  int i = 0;
  for (; i + 1 < its.vertices.size(); ++ i)
    fprintf(fp, "\t\t\t\t%f %f %f,\n", its.vertices[i](0), its.vertices[i](1), its.vertices[i](2));
  fprintf(fp, "\t\t\t\t%f %f %f]\n", its.vertices[i](0), its.vertices[i](1), its.vertices[i](2));
  fprintf(fp, "\t\t}\n");
  fprintf(fp, "\t\tDEF STLTriangles IndexedFaceSet {\n");
  fprintf(fp, "\t\t\tcoordIndex [\n");
 
  for (size_t i = 0; i + 1 < its.indices.size(); ++ i)
    fprintf(fp, "\t\t\t\t%d, %d, %d, -1,\n", its.indices[i][0], its.indices[i][1], its.indices[i][2]);
  fprintf(fp, "\t\t\t\t%d, %d, %d, -1]\n", its.indices[i][0], its.indices[i][1], its.indices[i][2]);
  fprintf(fp, "\t\t}\n");
  fprintf(fp, "\t}\n");
  fprintf(fp, "}\n");
  fclose(fp);
  return true;
}

References error, indexed_triangle_set::indices, and indexed_triangle_set::vertices.

stl_add_facet()

void stl_add_facet	(	stl_file *	stl,
		const stl_facet *	new_facet
	)

{
  assert(stl->facet_start.size() == stl->stats.number_of_facets);
  assert(stl->neighbors_start.size() == stl->stats.number_of_facets);
  stl->facet_start.emplace_back(*new_facet);
    // note that the normal vector is not set here, just initialized to 0.
    stl->facet_start[stl->stats.number_of_facets].normal = stl_normal::Zero();
    stl->neighbors_start.emplace_back();
  ++ stl->stats.facets_added;
  ++ stl->stats.number_of_facets;
}

References stl_file::facet_start, stl_stats::facets_added, stl_file::neighbors_start, stl_stats::number_of_facets, and stl_file::stats.

Referenced by stl_fill_holes().

Here is the caller graph for this function:

stl_allocate()

void stl_allocate

(

stl_file *

stl

)

{
    //  Allocate memory for the entire .STL file.
    stl->facet_start.assign(stl->stats.number_of_facets, stl_facet());
    // Allocate memory for the neighbors list.
    stl->neighbors_start.assign(stl->stats.number_of_facets, stl_neighbors());
}

References stl_file::facet_start, stl_file::neighbors_start, stl_stats::number_of_facets, and stl_file::stats.

Referenced by stl_open().

Here is the caller graph for this function:

stl_calculate_normal()

void stl_calculate_normal ( stl_normal &  normal, stl_facet *  facet  )

inline

                                                                       {
  normal = (facet->vertex[1] - facet->vertex[0]).cross(facet->vertex[2] - facet->vertex[0]);
}

References stl_facet::vertex.

Referenced by calculate_normals(), check_normal_vector(), get_area(), and stl_reverse_all_facets().

Here is the caller graph for this function:

stl_calculate_volume()

void stl_calculate_volume

(

stl_file *

stl

)

{
    stl->stats.volume = get_volume(stl);
    if (stl->stats.volume < 0.0) {
      stl_reverse_all_facets(stl);
      stl->stats.volume = -stl->stats.volume;
    }
}

References get_volume(), stl_file::stats, stl_reverse_all_facets(), and stl_stats::volume.

Referenced by stl_repair(), and Slic3r::trianglemesh_repair_on_import().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_check_facets_exact()

void stl_check_facets_exact

(

stl_file *

stl

)

{
  assert(stl->facet_start.size() == stl->neighbors_start.size());
 
    stl->stats.connected_edges         = 0;
    stl->stats.connected_facets_1_edge = 0;
    stl->stats.connected_facets_2_edge = 0;
    stl->stats.connected_facets_3_edge = 0;
 
    // If any two of the three vertices are found to be exactally the same, call them degenerate and remove the facet.
    // Do it before the next step, as the next step stores references to the face indices in the hash tables and removing a facet
    // will break the references.
    for (uint32_t i = 0; i < stl->stats.number_of_facets;) {
    stl_facet &facet = stl->facet_start[i];
      if (facet.vertex[0] == facet.vertex[1] || facet.vertex[1] == facet.vertex[2] || facet.vertex[0] == facet.vertex[2]) {
        // Remove the degenerate facet.
        facet = stl->facet_start[-- stl->stats.number_of_facets];
      stl->facet_start.pop_back();
      stl->neighbors_start.pop_back();
        stl->stats.facets_removed += 1;
        stl->stats.degenerate_facets += 1;
      } else
        ++ i;
    }
 
    // Initialize hash table.
    HashTableEdges hash_table(stl->stats.number_of_facets);
  for (auto &neighbor : stl->neighbors_start)
    neighbor.reset();
 
    // Connect neighbor edges.
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
    const stl_facet &facet = stl->facet_start[i];
    for (int j = 0; j < 3; ++ j) {
      HashEdge edge;
      edge.facet_number = i;
      edge.which_edge = j;
      edge.load_exact(stl, &facet.vertex[j], &facet.vertex[(j + 1) % 3]);
      hash_table.insert_edge_exact(stl, edge);
    }
  }
 
#if 0
  printf("Number of faces: %d, number of manifold edges: %d, number of connected edges: %d, number of unconnected edges: %d\r\n", 
      stl->stats.number_of_facets, stl->stats.number_of_facets * 3, 
      stl->stats.connected_edges, stl->stats.number_of_facets * 3 - stl->stats.connected_edges);
#endif
}

References stl_stats::connected_edges, stl_stats::connected_facets_1_edge, stl_stats::connected_facets_2_edge, stl_stats::connected_facets_3_edge, stl_stats::degenerate_facets, HashEdge::facet_number, stl_file::facet_start, stl_stats::facets_removed, HashTableEdges::insert_edge_exact(), HashEdge::load_exact(), stl_file::neighbors_start, stl_stats::number_of_facets, stl_file::stats, stl_facet::vertex, and HashEdge::which_edge.

Referenced by stl_repair(), and Slic3r::trianglemesh_repair_on_import().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_check_facets_nearby()

void stl_check_facets_nearby	(	stl_file *	stl,
		float	tolerance
	)

{
  assert(stl->stats.connected_facets_3_edge <= stl->stats.connected_facets_2_edge);
  assert(stl->stats.connected_facets_2_edge <= stl->stats.connected_facets_1_edge);
  assert(stl->stats.connected_facets_1_edge <= stl->stats.number_of_facets);
 
    if (stl->stats.connected_facets_3_edge == stl->stats.number_of_facets)
      // No need to check any further.  All facets are connected.
      return;
 
    HashTableEdges hash_table(stl->stats.number_of_facets);
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
      //FIXME is the copy necessary?
      stl_facet facet = stl->facet_start[i];
      for (int j = 0; j < 3; j++) {
          if (stl->neighbors_start[i].neighbor[j] == -1) {
            HashEdge edge;
            edge.facet_number = i;
            edge.which_edge = j;
            if (edge.load_nearby(stl, facet.vertex[j], facet.vertex[(j + 1) % 3], tolerance))
                // Only insert edges that have different keys.
                hash_table.insert_edge_nearby(stl, edge);
          }
      }
    }
}

References stl_stats::connected_facets_1_edge, stl_stats::connected_facets_2_edge, stl_stats::connected_facets_3_edge, HashEdge::facet_number, stl_file::facet_start, HashTableEdges::insert_edge_nearby(), HashEdge::load_nearby(), stl_file::neighbors_start, stl_stats::number_of_facets, stl_file::stats, stl_facet::vertex, and HashEdge::which_edge.

Referenced by stl_repair(), and Slic3r::trianglemesh_repair_on_import().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_facet_stats()

void stl_facet_stats	(	stl_file *	stl,
		stl_facet	facet,
		bool &	first
	)

{
  // While we are going through all of the facets, let's find the
  // maximum and minimum values for x, y, and z
 
  if (first) {
    // Initialize the max and min values the first time through
    stl->stats.min = facet.vertex[0];
    stl->stats.max = facet.vertex[0];
    stl_vertex diff = (facet.vertex[1] - facet.vertex[0]).cwiseAbs();
    stl->stats.shortest_edge = std::max(diff(0), std::max(diff(1), diff(2)));
    first = false;
  }
 
  // Now find the max and min values.
  for (size_t i = 0; i < 3; ++ i) {
    stl->stats.min = stl->stats.min.cwiseMin(facet.vertex[i]);
    stl->stats.max = stl->stats.max.cwiseMax(facet.vertex[i]);
  }
}

References cwiseAbs(), stl_stats::max, stl_stats::min, stl_stats::shortest_edge, stl_file::stats, and stl_facet::vertex.

Referenced by stl_read().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_fill_holes()

void stl_fill_holes

(

stl_file *

stl

)

{
  // Insert all unconnected edges into hash list.
  HashTableEdges hash_table(stl->stats.number_of_facets);
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
      stl_facet facet = stl->facet_start[i];
    for (int j = 0; j < 3; ++ j) {
        if(stl->neighbors_start[i].neighbor[j] != -1)
          continue;
      HashEdge edge;
        edge.facet_number = i;
        edge.which_edge = j;
        edge.load_exact(stl, &facet.vertex[j], &facet.vertex[(j + 1) % 3]);
        hash_table.insert_edge_exact(stl, edge);
    }
  }
 
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
    stl_facet facet = stl->facet_start[i];
    int neighbors_initial[3] = { stl->neighbors_start[i].neighbor[0], stl->neighbors_start[i].neighbor[1], stl->neighbors_start[i].neighbor[2] };
    int first_facet = i;
    for (int j = 0; j < 3; ++ j) {
        if (stl->neighbors_start[i].neighbor[j] != -1)
          continue;
 
        stl_facet new_facet;
        new_facet.vertex[0] = facet.vertex[j];
        new_facet.vertex[1] = facet.vertex[(j + 1) % 3];
        bool direction = neighbors_initial[(j + 2) % 3] == -1;
        int facet_num = i;
        int vnot = (j + 2) % 3;
 
        for (;;) {
        int pivot_vertex = 0;
        int next_edge = 0;
          if (vnot > 2) {
              if (direction) {
                pivot_vertex = (vnot + 1) % 3;
                next_edge = vnot % 3;
              } else {
                pivot_vertex = (vnot + 2) % 3;
                next_edge = pivot_vertex;
              }
              direction = ! direction;
          } else {
              if(direction == 0) {
                pivot_vertex = (vnot + 1) % 3;
                next_edge = vnot;
              } else {
                pivot_vertex = (vnot + 2) % 3;
                next_edge = pivot_vertex;
              }
          }
 
          int next_facet = stl->neighbors_start[facet_num].neighbor[next_edge];
          if (next_facet == -1) {
              new_facet.vertex[2] = stl->facet_start[facet_num].vertex[vnot % 3];
            stl_add_facet(stl, &new_facet);
              for (int k = 0; k < 3; ++ k) {
                HashEdge edge;
                edge.facet_number = stl->stats.number_of_facets - 1;
                edge.which_edge = k;
                edge.load_exact(stl, &new_facet.vertex[k], &new_facet.vertex[(k + 1) % 3]);
                hash_table.insert_edge_exact(stl, edge);
              }
              break;
          }
 
            vnot = stl->neighbors_start[facet_num].which_vertex_not[next_edge];
            facet_num = next_facet;
 
          if (facet_num == first_facet) {
              // back to the beginning
            BOOST_LOG_TRIVIAL(info) << "Back to the first facet filling holes: probably a mobius part. Try using a smaller tolerance or don't do a nearby check.";
              return;
          }
        }
    }
  }
}

References HashEdge::facet_number, stl_file::facet_start, HashTableEdges::insert_edge_exact(), HashEdge::load_exact(), stl_file::neighbors_start, stl_stats::number_of_facets, stl_file::stats, stl_add_facet(), stl_facet::vertex, and HashEdge::which_edge.

Referenced by stl_repair(), and Slic3r::trianglemesh_repair_on_import().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_fix_normal_directions()

void stl_fix_normal_directions

(

stl_file *

stl

)

{
  // This may happen for malformed models, see: https://github.com/prusa3d/PrusaSlicer/issues/2209
    if (stl->stats.number_of_facets == 0)
      return;
 
  struct stl_normal {
      int         facet_num;
      stl_normal *next;
    };
 
    // Initialize linked list.
    boost::object_pool<stl_normal> pool;
    stl_normal *head = pool.construct();
    stl_normal *tail = pool.construct();
  head->next = tail;
  tail->next = tail;
 
  // Initialize list that keeps track of already fixed facets.
  std::vector<char> norm_sw(stl->stats.number_of_facets, 0);
  // Initialize list that keeps track of reversed facets.
    std::vector<int>  reversed_ids;
    reversed_ids.reserve(stl->stats.number_of_facets);
 
    int facet_num = 0;
    // If normal vector is not within tolerance and backwards:
    // Arbitrarily starts at face 0.  If this one is wrong, we're screwed. Thankfully, the chances
    // of it being wrong randomly are low if most of the triangles are right:
    if (check_normal_vector(stl, 0, 0)) {
      reverse_facet(stl, 0);
        reversed_ids.emplace_back(0);
    }
 
    // Say that we've fixed this facet:
    norm_sw[facet_num] = 1;
  int checked = 1;
 
    for (;;) {
      // Add neighbors_to_list. Add unconnected neighbors to the list.
      bool force_exit = false;
      for (int j = 0; j < 3; ++ j) {
          // Reverse the neighboring facets if necessary.
          if (stl->neighbors_start[facet_num].which_vertex_not[j] > 2) {
            // If the facet has a neighbor that is -1, it means that edge isn't shared by another facet
            if (stl->neighbors_start[facet_num].neighbor[j] != -1) {
                if (norm_sw[stl->neighbors_start[facet_num].neighbor[j]] == 1) {
                    // trying to modify a facet already marked as fixed, revert all changes made until now and exit (fixes: #716, #574, #413, #269, #262, #259, #230, #228, #206)
                    for (int id = int(reversed_ids.size()) - 1; id >= 0; -- id)
                        reverse_facet(stl, reversed_ids[id]);
                    force_exit = true;
                    break;
                }
                reverse_facet(stl, stl->neighbors_start[facet_num].neighbor[j]);
                reversed_ids.emplace_back(stl->neighbors_start[facet_num].neighbor[j]);
            }
          }
          // If this edge of the facet is connected:
          if (stl->neighbors_start[facet_num].neighbor[j] != -1) {
            // If we haven't fixed this facet yet, add it to the list:
            if (norm_sw[stl->neighbors_start[facet_num].neighbor[j]] != 1) {
                // Add node to beginning of list.
                stl_normal *newn = pool.construct();
                newn->facet_num = stl->neighbors_start[facet_num].neighbor[j];
                newn->next = head->next;
                head->next = newn;
            }
          }
      }
 
      // an error occourred, quit the for loop and exit
      if (force_exit)
        break;
 
      // Get next facet to fix from top of list.
      if (head->next != tail) {
          facet_num = head->next->facet_num;
            assert(facet_num < stl->stats.number_of_facets);
          if (norm_sw[facet_num] != 1) { // If facet is in list mutiple times
            norm_sw[facet_num] = 1; // Record this one as being fixed.
            ++ checked;
          }
          stl_normal *temp = head->next;  // Delete this facet from the list.
          head->next = head->next->next;
          // pool.destroy(temp);
      } else { // If we ran out of facets to fix: All of the facets in this part have been fixed.
          ++ stl->stats.number_of_parts;
          if (checked >= int(stl->stats.number_of_facets))
            // All of the facets have been checked.  Bail out.
            break;
        // There is another part here.  Find it and continue.
        for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
            if (norm_sw[i] == 0) {
              // This is the first facet of the next part.
              facet_num = i;
              if (check_normal_vector(stl, i, 0)) {
                  reverse_facet(stl, i);
                  reversed_ids.emplace_back(i);
              }
              norm_sw[facet_num] = 1;
              ++ checked;
              break;
            }
      }
    }
 
  // pool.destroy(head);
  // pool.destroy(tail);
}

References check_normal_vector(), head(), stl_file::neighbors_start, stl_stats::number_of_facets, stl_stats::number_of_parts, reverse_facet(), stl_file::stats, and tail().

Referenced by stl_repair(), and Slic3r::trianglemesh_repair_on_import().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_fix_normal_values()

void stl_fix_normal_values

(

stl_file *

stl

)

{
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
      check_normal_vector(stl, i, 1);
}

References check_normal_vector(), stl_stats::number_of_facets, and stl_file::stats.

Referenced by stl_repair(), and Slic3r::trianglemesh_repair_on_import().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_generate_shared_vertices()

void stl_generate_shared_vertices	(	stl_file *	stl,
		indexed_triangle_set &	its
	)

{
  // 3 indices to vertex per face
  its.indices.assign(stl->stats.number_of_facets, stl_triangle_vertex_indices(-1, -1, -1));
  // Shared vertices (3D coordinates)
  its.vertices.clear();
  its.vertices.reserve(stl->stats.number_of_facets / 2);
 
  // A degenerate mesh may contain loops: Traversing a fan will end up in an endless loop
  // while never reaching the starting face. To avoid these endless loops, traversed faces at each fan traversal
  // are marked with a unique fan_traversal_stamp.
  unsigned int        fan_traversal_stamp = 0;
  std::vector<unsigned int> fan_traversal_facet_visited(stl->stats.number_of_facets, 0);
 
  for (uint32_t facet_idx = 0; facet_idx < stl->stats.number_of_facets; ++ facet_idx) {
    for (int j = 0; j < 3; ++ j) {
      if (its.indices[facet_idx][j] != -1)
        // Shared vertex was already assigned.
        continue;
      // Create a new shared vertex.
      its.vertices.emplace_back(stl->facet_start[facet_idx].vertex[j]);
      // Traverse the fan around the j-th vertex of the i-th face, assign the newly created shared vertex index to all the neighboring triangles in the triangle fan.
      int  facet_in_fan_idx   = facet_idx;
      bool edge_direction   = false;
      bool traversal_reversed = false;
      int  vnot           = (j + 2) % 3;
      // Increase the 
      ++ fan_traversal_stamp;
      for (;;) {
        // Next edge on facet_in_fan_idx to be traversed. The edge is indexed by its starting vertex index.
        int next_edge    = 0;
        // Vertex index in facet_in_fan_idx, which is being pivoted around, and which is being assigned a new shared vertex.
        int pivot_vertex = 0;
        if (vnot > 2) {
          // The edge of facet_in_fan_idx opposite to vnot is equally oriented, therefore
          // the neighboring facet is flipped.
            if (! edge_direction) {
              pivot_vertex = (vnot + 2) % 3;
              next_edge    = pivot_vertex;              
            } else {
              pivot_vertex = (vnot + 1) % 3;
              next_edge    = vnot % 3;
            }
            edge_direction = ! edge_direction;
        } else {
          // The neighboring facet is correctly oriented.
            if (! edge_direction) {
              pivot_vertex = (vnot + 1) % 3;
              next_edge    = vnot;
            } else {
              pivot_vertex = (vnot + 2) % 3;
              next_edge    = pivot_vertex;
            }
        }
        its.indices[facet_in_fan_idx][pivot_vertex] = its.vertices.size() - 1;
        fan_traversal_facet_visited[facet_in_fan_idx] = fan_traversal_stamp;
 
        // next_edge is an index of the starting vertex of the edge, not an index of the opposite vertex to the edge!
        int next_facet = stl->neighbors_start[facet_in_fan_idx].neighbor[next_edge];
        if (next_facet == -1) {
          // No neighbor going in the current direction.
          if (traversal_reversed) {
            // Went to one limit, then turned back and reached the other limit. Quit the fan traversal.
              break;
          } else {
            // Reached the first limit. Now try to reverse and traverse up to the other limit.
              edge_direction        = true;
              vnot              = (j + 1) % 3;
              traversal_reversed    = true;
              facet_in_fan_idx      = facet_idx;
          }
        } else if (next_facet == facet_idx) {
          // Traversed a closed fan all around.
//          assert(! traversal_reversed);
          break;
        } else if (next_facet >= (int)stl->stats.number_of_facets) {
          // The mesh is not valid!
          // assert(false);
          break;
        } else if (fan_traversal_facet_visited[next_facet] == fan_traversal_stamp) {
          // Traversed a closed fan all around, but did not reach the starting face.
          // This indicates an invalid geometry (non-manifold).
          //assert(false);
          break;
        } else {
          // Continue traversal.
          // next_edge is an index of the starting vertex of the edge, not an index of the opposite vertex to the edge!
          vnot = stl->neighbors_start[facet_in_fan_idx].which_vertex_not[next_edge];
          facet_in_fan_idx = next_facet;
        }
      }
    }
  }
}

References stl_file::facet_start, indexed_triangle_set::indices, stl_file::neighbors_start, stl_stats::number_of_facets, stl_file::stats, and indexed_triangle_set::vertices.

Referenced by Slic3r::TriangleMesh::ReadSTLFile().

Here is the caller graph for this function:

stl_get_size()

void stl_get_size

(

stl_file *

stl

)

{
    if (stl->stats.number_of_facets == 0)
      return;
    stl->stats.min = stl->facet_start[0].vertex[0];
    stl->stats.max = stl->stats.min;
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
      const stl_facet &face = stl->facet_start[i];
      for (int j = 0; j < 3; ++ j) {
          stl->stats.min = stl->stats.min.cwiseMin(face.vertex[j]);
          stl->stats.max = stl->stats.max.cwiseMax(face.vertex[j]);
      }
    }
    stl->stats.size = stl->stats.max - stl->stats.min;
    stl->stats.bounding_diameter = stl->stats.size.norm();
}

References stl_stats::bounding_diameter, stl_file::facet_start, stl_stats::max, stl_stats::min, stl_stats::number_of_facets, stl_stats::size, stl_file::stats, and stl_facet::vertex.

Referenced by stl_rotate_x(), stl_rotate_y(), stl_rotate_z(), stl_transform(), and stl_transform().

Here is the caller graph for this function:

stl_mirror_xy()

void stl_mirror_xy

(

stl_file *

stl

)

{
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
      for (int j = 0; j < 3; ++ j)
          stl->facet_start[i].vertex[j](2) *= -1.0;
  float temp_size = stl->stats.min(2);
  stl->stats.min(2) = stl->stats.max(2);
  stl->stats.max(2) = temp_size;
  stl->stats.min(2) *= -1.0;
  stl->stats.max(2) *= -1.0;
  stl_reverse_all_facets(stl);
  stl->stats.facets_reversed -= stl->stats.number_of_facets;  /* for not altering stats */
}

References stl_file::facet_start, stl_stats::facets_reversed, stl_stats::max, stl_stats::min, stl_stats::number_of_facets, stl_file::stats, and stl_reverse_all_facets().

Here is the call graph for this function:

stl_mirror_xz()

void stl_mirror_xz

(

stl_file *

stl

)

{
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
    for (int j = 0; j < 3; ++ j)
      stl->facet_start[i].vertex[j](1) *= -1.0;
  float temp_size = stl->stats.min(1);
  stl->stats.min(1) = stl->stats.max(1);
  stl->stats.max(1) = temp_size;
  stl->stats.min(1) *= -1.0;
  stl->stats.max(1) *= -1.0;
  stl_reverse_all_facets(stl);
  stl->stats.facets_reversed -= stl->stats.number_of_facets;  // for not altering stats
}

References stl_file::facet_start, stl_stats::facets_reversed, stl_stats::max, stl_stats::min, stl_stats::number_of_facets, stl_file::stats, and stl_reverse_all_facets().

Here is the call graph for this function:

stl_mirror_yz()

void stl_mirror_yz

(

stl_file *

stl

)

{
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
      for (int j = 0; j < 3; j++)
          stl->facet_start[i].vertex[j](0) *= -1.0;
  float temp_size = stl->stats.min(0);
  stl->stats.min(0) = stl->stats.max(0);
  stl->stats.max(0) = temp_size;
  stl->stats.min(0) *= -1.0;
  stl->stats.max(0) *= -1.0;
  stl_reverse_all_facets(stl);
  stl->stats.facets_reversed -= stl->stats.number_of_facets;  /* for not altering stats */
}

References stl_file::facet_start, stl_stats::facets_reversed, stl_stats::max, stl_stats::min, stl_stats::number_of_facets, stl_file::stats, and stl_reverse_all_facets().

Here is the call graph for this function:

stl_normalize_vector()

void stl_normalize_vector ( stl_normal &  normal )

inline

                                                     {
  double length = normal.cast<double>().norm();
  if (length < 0.000000000001)
    normal = stl_normal::Zero();
  else
    normal *= float(1.0 / length);
}

Referenced by calculate_normals(), check_normal_vector(), get_area(), and stl_reverse_all_facets().

Here is the caller graph for this function:

stl_open()

bool stl_open	(	stl_file *	stl,
		const char *	file
	)

{
    Slic3r::CNumericLocalesSetter locales_setter;
  stl->clear();
  FILE *fp = stl_open_count_facets(stl, file);
  if (fp == nullptr)
    return false;
  stl_allocate(stl);
  bool result = stl_read(stl, fp, 0, true);
    fclose(fp);
    return result;
}

References stl_file::clear(), stl_allocate(), stl_open_count_facets(), and stl_read().

Referenced by Slic3r::TriangleMesh::ReadSTLFile().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_print_neighbors()

bool stl_print_neighbors	(	stl_file *	stl,
		char *	file
	)

{
  FILE *fp = boost::nowide::fopen(file, "w");
  if (fp == nullptr) {
    BOOST_LOG_TRIVIAL(error) << "stl_print_neighbors: Couldn't open " << file << " for writing";
      return false;
    }
 
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
      fprintf(fp, "%d, %d,%d, %d,%d, %d,%d\n",
            i,
            stl->neighbors_start[i].neighbor[0],
            (int)stl->neighbors_start[i].which_vertex_not[0],
            stl->neighbors_start[i].neighbor[1],
            (int)stl->neighbors_start[i].which_vertex_not[1],
            stl->neighbors_start[i].neighbor[2],
            (int)stl->neighbors_start[i].which_vertex_not[2]);
    }
    fclose(fp);
    return true;
}

References error, stl_file::neighbors_start, stl_stats::number_of_facets, and stl_file::stats.

stl_read()

void stl_read	(	stl_file *	stl,
		int	first_facet,
		bool	first
	)

stl_reallocate()

void stl_reallocate

(

stl_file *

stl

)

{
  stl->facet_start.resize(stl->stats.number_of_facets);
  stl->neighbors_start.resize(stl->stats.number_of_facets);
}

References stl_file::facet_start, stl_file::neighbors_start, stl_stats::number_of_facets, and stl_file::stats.

stl_remove_unconnected_facets()

void stl_remove_unconnected_facets

(

stl_file *

stl

)

{
  // A couple of things need to be done here.  One is to remove any completely unconnected facets (0 edges connected) since these are
  // useless and could be completely wrong.   The second thing that needs to be done is to remove any degenerate facets that were created during
  // stl_check_facets_nearby().
  auto remove_facet = [stl](int facet_number)
  {
    ++ stl->stats.facets_removed;
    /* Update list of connected edges */
    stl_neighbors &neighbors = stl->neighbors_start[facet_number];
    // Update statistics on unconnected triangle edges.
    switch (neighbors.num_neighbors()) {
    case 3: -- stl->stats.connected_facets_3_edge; // fall through
    case 2: -- stl->stats.connected_facets_2_edge; // fall through
    case 1: -- stl->stats.connected_facets_1_edge; // fall through
    case 0: break;
    default: assert(false);
    }
 
      if (facet_number < int(-- stl->stats.number_of_facets)) {
        // Removing a face, which was not the last one.
        // Copy the face and neighborship from the last face to facet_number.
        stl->facet_start[facet_number] = stl->facet_start[stl->stats.number_of_facets];
        neighbors = stl->neighbors_start[stl->stats.number_of_facets];
        // Update neighborship of faces, which used to point to the last face, now moved to facet_number.
        for (int i = 0; i < 3; ++ i)
          if (neighbors.neighbor[i] != -1) {
            int &other_face_idx = stl->neighbors_start[neighbors.neighbor[i]].neighbor[(neighbors.which_vertex_not[i] + 1) % 3];
            if (other_face_idx != stl->stats.number_of_facets) {
              BOOST_LOG_TRIVIAL(info) << "in remove_facet: neighbor = " << other_face_idx << " numfacets = " << stl->stats.number_of_facets << " this is wrong";
              return;
            }
            other_face_idx = facet_number;
          }
    }
 
      stl->facet_start.pop_back();
      stl->neighbors_start.pop_back();
  };
 
  auto remove_degenerate = [stl, remove_facet](int facet)
  {
    // Update statistics on face connectivity after one edge was disconnected on the facet "facet_num".
    auto update_connects_remove_1 = [stl](int facet_num) {
      switch (stl->neighbors_start[facet_num].num_neighbors()) {
      case 0: assert(false); break;
      case 1: -- stl->stats.connected_facets_1_edge; break;
      case 2: -- stl->stats.connected_facets_2_edge; break;
      case 3: -- stl->stats.connected_facets_3_edge; break;
      default: assert(false);
        }
    };
 
    int edge_to_collapse = 0;
      if (stl->facet_start[facet].vertex[0] == stl->facet_start[facet].vertex[1]) {
      if (stl->facet_start[facet].vertex[1] == stl->facet_start[facet].vertex[2]) {
        // All 3 vertices are equal. Collapse the edge with no neighbor if it exists.
        const int *nbr = stl->neighbors_start[facet].neighbor;
        edge_to_collapse = (nbr[0] == -1) ? 0 : (nbr[1] == -1) ? 1 : 2;
      } else {
        edge_to_collapse = 0;
      }
      } else if (stl->facet_start[facet].vertex[1] == stl->facet_start[facet].vertex[2]) {
      edge_to_collapse = 1;
      } else if (stl->facet_start[facet].vertex[2] == stl->facet_start[facet].vertex[0]) {
      edge_to_collapse = 2;
      } else {
        // No degenerate. Function shouldn't have been called.
        return;
      }
 
    int edge[3] = { (edge_to_collapse + 1) % 3, (edge_to_collapse + 2) % 3, edge_to_collapse };
    int neighbor[] = {
      stl->neighbors_start[facet].neighbor[edge[0]],
      stl->neighbors_start[facet].neighbor[edge[1]],
      stl->neighbors_start[facet].neighbor[edge[2]]
    };
    int vnot[] = {
      stl->neighbors_start[facet].which_vertex_not[edge[0]],
      stl->neighbors_start[facet].which_vertex_not[edge[1]],
      stl->neighbors_start[facet].which_vertex_not[edge[2]]
    };
 
    // Update statistics on edge connectivity.
    if ((neighbor[0] == -1) && (neighbor[1] != -1))
      update_connects_remove_1(neighbor[1]);
    if ((neighbor[1] == -1) && (neighbor[0] != -1))
      update_connects_remove_1(neighbor[0]);
 
      if (neighbor[0] >= 0) {
      if (neighbor[1] >= 0) {
        // Adjust the "flip" flag for the which_vertex_not values.
        if (vnot[0] > 2) {
          if (vnot[1] > 2) {
            // The face to be removed has its normal flipped compared to the left & right neighbors, therefore after removing this face
            // the two remaining neighbors will be oriented correctly.
            vnot[0] -= 3;
            vnot[1] -= 3;
          } else
            // One neighbor has its normal inverted compared to the face to be removed, the other is oriented equally.
            // After removal, the two neighbors will have their normals flipped.
            vnot[1] += 3;
        } else if (vnot[1] > 2)
          // One neighbor has its normal inverted compared to the face to be removed, the other is oriented equally.
          // After removal, the two neighbors will have their normals flipped.
          vnot[0] += 3;
      }
      stl->neighbors_start[neighbor[0]].neighbor[(vnot[0] + 1) % 3] = (neighbor[0] == neighbor[1]) ? -1 : neighbor[1];
        stl->neighbors_start[neighbor[0]].which_vertex_not[(vnot[0] + 1) % 3] = vnot[1];
      }
      if (neighbor[1] >= 0) {
      stl->neighbors_start[neighbor[1]].neighbor[(vnot[1] + 1) % 3] = (neighbor[0] == neighbor[1]) ? -1 : neighbor[0];
        stl->neighbors_start[neighbor[1]].which_vertex_not[(vnot[1] + 1) % 3] = vnot[0];
      }
    if (neighbor[2] >= 0) {
      update_connects_remove_1(neighbor[2]);
      stl->neighbors_start[neighbor[2]].neighbor[(vnot[2] + 1) % 3] = -1;
    }
 
      remove_facet(facet);
  };
 
  // remove degenerate facets
  for (uint32_t i = 0; i < stl->stats.number_of_facets;)
    if (stl->facet_start[i].vertex[0] == stl->facet_start[i].vertex[1] ||
      stl->facet_start[i].vertex[0] == stl->facet_start[i].vertex[2] ||
      stl->facet_start[i].vertex[1] == stl->facet_start[i].vertex[2]) {
      remove_degenerate(i);
//      assert(stl_validate(stl));
    } else
      ++ i;
 
  if (stl->stats.connected_facets_1_edge < (int)stl->stats.number_of_facets) {
    // There are some faces with no connected edge at all. Remove completely unconnected facets.
    for (uint32_t i = 0; i < stl->stats.number_of_facets;)
      if (stl->neighbors_start[i].num_neighbors() == 0) {
        // This facet is completely unconnected.  Remove it.
        remove_facet(i);
        assert(stl_validate(stl));
      } else
        ++ i;
  }
}

References stl_stats::connected_facets_1_edge, stl_stats::connected_facets_2_edge, stl_stats::connected_facets_3_edge, stl_file::facet_start, stl_stats::facets_removed, stl_neighbors::neighbor, stl_file::neighbors_start, stl_neighbors::num_neighbors(), stl_stats::number_of_facets, stl_file::stats, stl_validate(), and stl_neighbors::which_vertex_not.

Referenced by stl_repair(), and Slic3r::trianglemesh_repair_on_import().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_repair()

void stl_repair	(	stl_file *	stl,
		bool	fixall_flag,
		bool	exact_flag,
		bool	tolerance_flag,
		float	tolerance,
		bool	increment_flag,
		float	increment,
		bool	nearby_flag,
		int	iterations,
		bool	remove_unconnected_flag,
		bool	fill_holes_flag,
		bool	normal_directions_flag,
		bool	normal_values_flag,
		bool	reverse_all_flag,
		bool	verbose_flag
	)

{
  if (exact_flag || fixall_flag || nearby_flag || remove_unconnected_flag || fill_holes_flag || normal_directions_flag) {
    if (verbose_flag)
        printf("Checking exact...\n");
    exact_flag = true;
    stl_check_facets_exact(stl);
    stl->stats.facets_w_1_bad_edge = (stl->stats.connected_facets_2_edge - stl->stats.connected_facets_3_edge);
    stl->stats.facets_w_2_bad_edge = (stl->stats.connected_facets_1_edge - stl->stats.connected_facets_2_edge);
    stl->stats.facets_w_3_bad_edge = (stl->stats.number_of_facets - stl->stats.connected_facets_1_edge);
  }
 
    if (nearby_flag || fixall_flag) {
      if (! tolerance_flag)
          tolerance = stl->stats.shortest_edge;
      if (! increment_flag)
          increment = stl->stats.bounding_diameter / 10000.0;
    }
 
  if (stl->stats.connected_facets_3_edge < int(stl->stats.number_of_facets)) {
      int last_edges_fixed = 0;
      for (int i = 0; i < iterations; ++ i) {
        if (stl->stats.connected_facets_3_edge < int(stl->stats.number_of_facets)) {
            if (verbose_flag)
              printf("Checking nearby. Tolerance= %f Iteration=%d of %d...", tolerance, i + 1, iterations);
            stl_check_facets_nearby(stl, tolerance);
            if (verbose_flag)
              printf("  Fixed %d edges.\n", stl->stats.edges_fixed - last_edges_fixed);
            last_edges_fixed = stl->stats.edges_fixed;
            tolerance += increment;
        } else {
          if (verbose_flag)
              printf("All facets connected.  No further nearby check necessary.\n");
            break;
        }
      }
  } else if (verbose_flag)
      printf("All facets connected.  No nearby check necessary.\n");
 
  if (remove_unconnected_flag || fixall_flag || fill_holes_flag) {
    if (stl->stats.connected_facets_3_edge < int(stl->stats.number_of_facets)) {
        if (verbose_flag)
          printf("Removing unconnected facets...\n");
        stl_remove_unconnected_facets(stl);
    } else if (verbose_flag)
        printf("No unconnected need to be removed.\n");
  }
 
  if (fill_holes_flag || fixall_flag) {
    if (stl->stats.connected_facets_3_edge < int(stl->stats.number_of_facets)) {
        if (verbose_flag)
          printf("Filling holes...\n");
        stl_fill_holes(stl);
    } else if (verbose_flag)
        printf("No holes need to be filled.\n");
  }
 
  if (reverse_all_flag) {
    if (verbose_flag)
        printf("Reversing all facets...\n");
    stl_reverse_all_facets(stl);
  }
 
  if (normal_directions_flag || fixall_flag) {
    if (verbose_flag)
        printf("Checking normal directions...\n");
    stl_fix_normal_directions(stl);
  }
 
  if (normal_values_flag || fixall_flag) {
    if (verbose_flag)
        printf("Checking normal values...\n");
    stl_fix_normal_values(stl);
  }
 
    // Always calculate the volume.  It shouldn't take too long.
  if (verbose_flag)
    printf("Calculating volume...\n");
  stl_calculate_volume(stl);
 
  if (exact_flag) {
    if (verbose_flag)
        printf("Verifying neighbors...\n");
    stl_verify_neighbors(stl);
  }
}

References stl_stats::bounding_diameter, stl_stats::connected_facets_1_edge, stl_stats::connected_facets_2_edge, stl_stats::connected_facets_3_edge, stl_stats::edges_fixed, stl_stats::facets_w_1_bad_edge, stl_stats::facets_w_2_bad_edge, stl_stats::facets_w_3_bad_edge, stl_stats::number_of_facets, stl_stats::shortest_edge, stl_file::stats, stl_calculate_volume(), stl_check_facets_exact(), stl_check_facets_nearby(), stl_fill_holes(), stl_fix_normal_directions(), stl_fix_normal_values(), stl_remove_unconnected_facets(), stl_reverse_all_facets(), and stl_verify_neighbors().

Here is the call graph for this function:

stl_reverse_all_facets()

void stl_reverse_all_facets

(

stl_file *

stl

)

{
  stl_normal normal;
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
      reverse_facet(stl, i);
      stl_calculate_normal(normal, &stl->facet_start[i]);
      stl_normalize_vector(normal);
      stl->facet_start[i].normal = normal;
    }
}

References stl_file::facet_start, stl_stats::number_of_facets, reverse_facet(), stl_file::stats, stl_calculate_normal(), and stl_normalize_vector().

Referenced by stl_calculate_volume(), stl_mirror_xy(), stl_mirror_xz(), stl_mirror_yz(), and stl_repair().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_rotate_x()

void stl_rotate_x	(	stl_file *	stl,
		float	angle
	)

{
  double radian_angle = (angle / 180.0) * M_PI;
  double c = cos(radian_angle);
  double s = sin(radian_angle);
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
      for (int j = 0; j < 3; ++ j)
          rotate_point_2d(stl->facet_start[i].vertex[j](1), stl->facet_start[i].vertex[j](2), c, s);
    stl_get_size(stl);
    calculate_normals(stl);
}

References calculate_normals(), cos(), stl_file::facet_start, M_PI, stl_stats::number_of_facets, rotate_point_2d(), sin(), stl_file::stats, and stl_get_size().

Here is the call graph for this function:

stl_rotate_y()

void stl_rotate_y	(	stl_file *	stl,
		float	angle
	)

{
  double radian_angle = (angle / 180.0) * M_PI;
  double c = cos(radian_angle);
  double s = sin(radian_angle);
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
      for (int j = 0; j < 3; ++ j)
      rotate_point_2d(stl->facet_start[i].vertex[j](2), stl->facet_start[i].vertex[j](0), c, s);
    stl_get_size(stl);
    calculate_normals(stl);
}

References calculate_normals(), cos(), stl_file::facet_start, M_PI, stl_stats::number_of_facets, rotate_point_2d(), sin(), stl_file::stats, and stl_get_size().

Here is the call graph for this function:

stl_rotate_z()

void stl_rotate_z	(	stl_file *	stl,
		float	angle
	)

{
  double radian_angle = (angle / 180.0) * M_PI;
  double c = cos(radian_angle);
  double s = sin(radian_angle);
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
      for (int j = 0; j < 3; ++ j)
          rotate_point_2d(stl->facet_start[i].vertex[j](0), stl->facet_start[i].vertex[j](1), c, s);
    stl_get_size(stl);
    calculate_normals(stl);
}

References calculate_normals(), cos(), stl_file::facet_start, M_PI, stl_stats::number_of_facets, rotate_point_2d(), sin(), stl_file::stats, and stl_get_size().

Here is the call graph for this function:

stl_scale()

void stl_scale ( stl_file *  stl, float  factor  )

inline

{ stl_scale_versor(stl, stl_vertex(factor, factor, factor)); }

References stl_scale_versor().

Here is the call graph for this function:

stl_scale_versor()

void stl_scale_versor	(	stl_file *	stl,
		const stl_vertex &	versor
	)

{
  // Scale extents.
  auto s = versor.array();
  stl->stats.min.array() *= s;
  stl->stats.max.array() *= s;
  // Scale size.
  stl->stats.size.array() *= s;
  // Scale volume.
  if (stl->stats.volume > 0.0)
    stl->stats.volume *= versor(0) * versor(1) * versor(2);
  // Scale the mesh.
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
    for (int j = 0; j < 3; ++ j)
        stl->facet_start[i].vertex[j].array() *= s;
}

References stl_file::facet_start, stl_stats::max, stl_stats::min, stl_stats::number_of_facets, stl_stats::size, stl_file::stats, and stl_stats::volume.

Referenced by stl_scale().

Here is the caller graph for this function:

stl_stats_out()

void stl_stats_out	(	stl_file *	stl,
		FILE *	file,
		char *	input_file
	)

{
    // This is here for Slic3r, without our config.h it won't use this part of the code anyway.
#ifndef VERSION
#define VERSION "unknown"
#endif
    fprintf(file, "\n================= Results produced by ADMesh version " VERSION " ================\n");
    fprintf(file, "Input file         : %s\n", input_file);
    if (stl->stats.type == binary)
      fprintf(file, "File type          : Binary STL file\n");
    else
      fprintf(file, "File type          : ASCII STL file\n");
    fprintf(file, "Header             : %s\n", stl->stats.header);
    fprintf(file, "============== Size ==============\n");
    fprintf(file, "Min X = % f, Max X = % f\n", stl->stats.min(0), stl->stats.max(0));
    fprintf(file, "Min Y = % f, Max Y = % f\n", stl->stats.min(1), stl->stats.max(1));
    fprintf(file, "Min Z = % f, Max Z = % f\n", stl->stats.min(2), stl->stats.max(2));
    fprintf(file, "========= Facet Status ========== Original ============ Final ====\n");
    fprintf(file, "Number of facets                 : %5d               %5d\n", stl->stats.original_num_facets, stl->stats.number_of_facets);
    fprintf(file, "Facets with 1 disconnected edge  : %5d               %5d\n", 
      stl->stats.facets_w_1_bad_edge, stl->stats.connected_facets_2_edge - stl->stats.connected_facets_3_edge);
    fprintf(file, "Facets with 2 disconnected edges : %5d               %5d\n",
      stl->stats.facets_w_2_bad_edge, stl->stats.connected_facets_1_edge - stl->stats.connected_facets_2_edge);
    fprintf(file, "Facets with 3 disconnected edges : %5d               %5d\n",
        stl->stats.facets_w_3_bad_edge, stl->stats.number_of_facets - stl->stats.connected_facets_1_edge);
    fprintf(file, "Total disconnected facets        : %5d               %5d\n",
    stl->stats.facets_w_1_bad_edge + stl->stats.facets_w_2_bad_edge + stl->stats.facets_w_3_bad_edge, stl->stats.number_of_facets - stl->stats.connected_facets_3_edge);
    fprintf(file, "=== Processing Statistics ===     ===== Other Statistics =====\n");
    fprintf(file, "Number of parts       : %5d        Volume   : %f\n", stl->stats.number_of_parts, stl->stats.volume);
    fprintf(file, "Degenerate facets     : %5d\n", stl->stats.degenerate_facets);
    fprintf(file, "Edges fixed           : %5d\n", stl->stats.edges_fixed);
    fprintf(file, "Facets removed        : %5d\n", stl->stats.facets_removed);
    fprintf(file, "Facets added          : %5d\n", stl->stats.facets_added);
    fprintf(file, "Facets reversed       : %5d\n", stl->stats.facets_reversed);
    fprintf(file, "Backwards edges       : %5d\n", stl->stats.backwards_edges);
    fprintf(file, "Normals fixed         : %5d\n", stl->stats.normals_fixed);
}

References stl_stats::backwards_edges, binary, stl_stats::connected_facets_1_edge, stl_stats::connected_facets_2_edge, stl_stats::connected_facets_3_edge, stl_stats::degenerate_facets, stl_stats::edges_fixed, stl_stats::facets_added, stl_stats::facets_removed, stl_stats::facets_reversed, stl_stats::facets_w_1_bad_edge, stl_stats::facets_w_2_bad_edge, stl_stats::facets_w_3_bad_edge, stl_stats::header, stl_stats::max, stl_stats::min, stl_stats::normals_fixed, stl_stats::number_of_facets, stl_stats::number_of_parts, stl_stats::original_num_facets, stl_file::stats, stl_stats::type, VERSION, and stl_stats::volume.

stl_transform() [1/2]

template<typename T >

void stl_transform ( stl_file *  stl, const Eigen::Matrix< T, 3, 3, Eigen::DontAlign > &  m  )

inline

{
    const Eigen::Matrix<T, 3, 3, Eigen::DontAlign> r = m.inverse().transpose();
    for (size_t i = 0; i < stl->stats.number_of_facets; ++ i) {
    stl_facet &f = stl->facet_start[i];
    for (size_t j = 0; j < 3; ++j)
      f.vertex[j] = (m * f.vertex[j].template cast<T>()).template cast<float>().eval();
        f.normal = (r * f.normal.template cast<T>()).template cast<float>().eval();
    }
 
  stl_get_size(stl);
}

References stl_file::facet_start, stl_facet::normal, stl_stats::number_of_facets, stl_file::stats, stl_get_size(), and stl_facet::vertex.

Here is the call graph for this function:

stl_transform() [2/2]

template<typename T >

void stl_transform ( stl_file *  stl, const Eigen::Transform< T, 3, Eigen::Affine, Eigen::DontAlign > &  t  )

inline

{
    const Eigen::Matrix<T, 3, 3, Eigen::DontAlign> r = t.matrix().template block<3, 3>(0, 0).inverse().transpose();
    for (size_t i = 0; i < stl->stats.number_of_facets; ++ i) {
    stl_facet &f = stl->facet_start[i];
    for (size_t j = 0; j < 3; ++j)
      f.vertex[j] = (t * f.vertex[j].template cast<T>()).template cast<float>().eval();
    f.normal = (r * f.normal.template cast<T>()).template cast<float>().eval();
  }
 
  stl_get_size(stl);
}

References stl_file::facet_start, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::matrix(), stl_facet::normal, stl_stats::number_of_facets, stl_file::stats, stl_get_size(), and stl_facet::vertex.

Here is the call graph for this function:

stl_translate()

void stl_translate	(	stl_file *	stl,
		float	x,
		float	y,
		float	z
	)

{
  stl_vertex new_min(x, y, z);
  stl_vertex shift = new_min - stl->stats.min;
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
    for (int j = 0; j < 3; ++ j)
        stl->facet_start[i].vertex[j] += shift;
  stl->stats.min = new_min;
  stl->stats.max += shift;
}

References stl_file::facet_start, stl_stats::max, stl_stats::min, stl_stats::number_of_facets, and stl_file::stats.

stl_translate_relative()

void stl_translate_relative	(	stl_file *	stl,
		float	x,
		float	y,
		float	z
	)

{
  stl_vertex shift(x, y, z);
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
    for (int j = 0; j < 3; ++ j)
        stl->facet_start[i].vertex[j] += shift;
  stl->stats.min += shift;
  stl->stats.max += shift;
}

References stl_file::facet_start, stl_stats::max, stl_stats::min, stl_stats::number_of_facets, and stl_file::stats.

stl_validate() [1/2]

bool stl_validate

(

const stl_file *

stl

)

{
  indexed_triangle_set its;
  return stl_validate(stl, its);
}

References stl_validate().

Here is the call graph for this function:

stl_validate() [2/2]

bool stl_validate	(	const stl_file *	stl,
		const indexed_triangle_set &	its
	)

{
  assert(! stl->facet_start.empty());
  assert(stl->facet_start.size() == stl->stats.number_of_facets);
  assert(stl->neighbors_start.size() == stl->stats.number_of_facets);
  assert(stl->facet_start.size() == stl->neighbors_start.size());
  assert(! stl->neighbors_start.empty());
  assert((its.indices.empty()) == (its.vertices.empty()));
  assert(stl->stats.number_of_facets > 0);
  assert(its.vertices.empty() || its.indices.size() == stl->stats.number_of_facets);
 
#ifdef _DEBUG
    // Verify validity of neighborship data.
    for (int facet_idx = 0; facet_idx < (int)stl->stats.number_of_facets; ++ facet_idx) {
        const stl_neighbors &nbr    = stl->neighbors_start[facet_idx];
        const int       *vertices   = its.indices.empty() ? nullptr : its.indices[facet_idx].data();
        for (int nbr_idx = 0; nbr_idx < 3; ++ nbr_idx) {
            int nbr_face = stl->neighbors_start[facet_idx].neighbor[nbr_idx];
            assert(nbr_face < (int)stl->stats.number_of_facets);
            if (nbr_face != -1) {
              int nbr_vnot = nbr.which_vertex_not[nbr_idx];
        assert(nbr_vnot >= 0 && nbr_vnot < 6);
        // Neighbor of the neighbor is the original face.
        assert(stl->neighbors_start[nbr_face].neighbor[(nbr_vnot + 1) % 3] == facet_idx);
        int vnot_back = stl->neighbors_start[nbr_face].which_vertex_not[(nbr_vnot + 1) % 3];
        assert(vnot_back >= 0 && vnot_back < 6);
        assert((nbr_vnot < 3) == (vnot_back < 3));
        assert(vnot_back % 3 == (nbr_idx + 2) % 3);
        if (vertices != nullptr) {
          // Has shared vertices.
                if (nbr_vnot < 3) {
                  // Faces facet_idx and nbr_face share two vertices accross the common edge. Faces are correctly oriented.
            assert((its.indices[nbr_face][(nbr_vnot + 1) % 3] == vertices[(nbr_idx + 1) % 3] && its.indices[nbr_face][(nbr_vnot + 2) % 3] == vertices[nbr_idx]));
          } else {
                  // Faces facet_idx and nbr_face share two vertices accross the common edge. Faces are incorrectly oriented, one of them is flipped.
            assert((its.indices[nbr_face][(nbr_vnot + 2) % 3] == vertices[(nbr_idx + 1) % 3] && its.indices[nbr_face][(nbr_vnot + 1) % 3] == vertices[nbr_idx]));
          }
        }
            }
        }
    }
#endif /* _DEBUG */
 
  return true;
}

References stl_file::facet_start, indexed_triangle_set::indices, stl_file::neighbors_start, stl_stats::number_of_facets, stl_file::stats, indexed_triangle_set::vertices, and stl_neighbors::which_vertex_not.

Referenced by stl_remove_unconnected_facets(), stl_validate(), and Slic3r::trianglemesh_repair_on_import().

Here is the caller graph for this function:

stl_verify_neighbors()

void stl_verify_neighbors

(

stl_file *

stl

)

{
  stl->stats.backwards_edges = 0;
 
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
    for (int j = 0; j < 3; ++ j) {
      struct stl_edge {
        stl_vertex p1;
        stl_vertex p2;
        int        facet_number;
      };
      stl_edge edge_a;
      edge_a.p1 = stl->facet_start[i].vertex[j];
      edge_a.p2 = stl->facet_start[i].vertex[(j + 1) % 3];
      int neighbor = stl->neighbors_start[i].neighbor[j];
      if (neighbor == -1)
        continue; // this edge has no neighbor... Continue.
      int vnot = stl->neighbors_start[i].which_vertex_not[j];
      stl_edge edge_b;
      if (vnot < 3) {
        edge_b.p1 = stl->facet_start[neighbor].vertex[(vnot + 2) % 3];
        edge_b.p2 = stl->facet_start[neighbor].vertex[(vnot + 1) % 3];
      } else {
        stl->stats.backwards_edges += 1;
        edge_b.p1 = stl->facet_start[neighbor].vertex[(vnot + 1) % 3];
        edge_b.p2 = stl->facet_start[neighbor].vertex[(vnot + 2) % 3];
      }
      if (edge_a.p1 != edge_b.p1 || edge_a.p2 != edge_b.p2) {
        // These edges should match but they don't.  Print results.
        BOOST_LOG_TRIVIAL(info) << "edge " << j << " of facet " << i << " doesn't match edge " << (vnot + 1) << " of facet " << neighbor;
        stl_write_facet(stl, (char*)"first facet", i);
        stl_write_facet(stl, (char*)"second facet", neighbor);
      }
    }
  }
}

References stl_stats::backwards_edges, stl_file::facet_start, stl_file::neighbors_start, stl_stats::number_of_facets, stl_file::stats, and stl_write_facet().

Referenced by stl_repair(), and Slic3r::trianglemesh_repair_on_import().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_write_ascii()

bool stl_write_ascii	(	stl_file *	stl,
		const char *	file,
		const char *	label
	)

{
  FILE *fp = boost::nowide::fopen(file, "w");
    if (fp == nullptr) {
    BOOST_LOG_TRIVIAL(error) << "stl_write_ascii: Couldn't open " << file << " for writing";
      return false;
    }
 
  fprintf(fp, "solid  %s\n", label);
 
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
    fprintf(fp, "  facet normal % .8E % .8E % .8E\n", stl->facet_start[i].normal(0), stl->facet_start[i].normal(1), stl->facet_start[i].normal(2));
    fprintf(fp, "    outer loop\n");
    fprintf(fp, "      vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[0](0), stl->facet_start[i].vertex[0](1), stl->facet_start[i].vertex[0](2));
    fprintf(fp, "      vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[1](0), stl->facet_start[i].vertex[1](1), stl->facet_start[i].vertex[1](2));
    fprintf(fp, "      vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2));
    fprintf(fp, "    endloop\n");
    fprintf(fp, "  endfacet\n");
  }
 
    fprintf(fp, "endsolid  %s\n", label);
    fclose(fp);
    return true;
}

References error, stl_file::facet_start, stl_stats::number_of_facets, and stl_file::stats.

stl_write_binary()

bool stl_write_binary	(	stl_file *	stl,
		const char *	file,
		const char *	label
	)

{
  FILE *fp = boost::nowide::fopen(file, "wb");
  if (fp == nullptr) {
    BOOST_LOG_TRIVIAL(error) << "stl_write_binary: Couldn't open " << file << " for writing";
      return false;
    }
 
  fprintf(fp, "%s", label);
  for (size_t i = strlen(label); i < LABEL_SIZE; ++ i)
    putc(0, fp);
 
#if !defined(SEEK_SET)
  #define SEEK_SET 0
#endif
  fseek(fp, LABEL_SIZE, SEEK_SET);
#if BOOST_ENDIAN_LITTLE_BYTE
  fwrite(&stl->stats.number_of_facets, 4, 1, fp);
  for (const stl_facet &facet : stl->facet_start)
      fwrite(&facet, SIZEOF_STL_FACET, 1, fp);
#else /* BOOST_ENDIAN_LITTLE_BYTE */
  char buffer[50];
  // Convert the number of facets to little endian.
  memcpy(buffer, &stl->stats.number_of_facets, 4);
  stl_internal_reverse_quads(buffer, 4);
  fwrite(buffer, 4, 1, fp);
  for (const stl_facet &facet : stl->facet_start) {
    memcpy(buffer, &facet, 50);
    // Convert to little endian.
    stl_internal_reverse_quads(buffer, 48);
    fwrite(buffer, SIZEOF_STL_FACET, 1, fp);
  }
#endif /* BOOST_ENDIAN_LITTLE_BYTE */
  fclose(fp);
  return true;
}

References error, stl_file::facet_start, LABEL_SIZE, stl_stats::number_of_facets, SEEK_SET, SIZEOF_STL_FACET, and stl_file::stats.

stl_write_dxf()

bool stl_write_dxf	(	stl_file *	stl,
		const char *	file,
		char *	label
	)

{
  FILE *fp = boost::nowide::fopen(file, "w");
  if (fp == nullptr) {
    BOOST_LOG_TRIVIAL(error) << "stl_write_quad_object: Couldn't open " << file << " for writing";
      return false;
    }
 
  fprintf(fp, "999\n%s\n", label);
  fprintf(fp, "0\nSECTION\n2\nHEADER\n0\nENDSEC\n");
  fprintf(fp, "0\nSECTION\n2\nTABLES\n0\nTABLE\n2\nLAYER\n70\n1\n\
  0\nLAYER\n2\n0\n70\n0\n62\n7\n6\nCONTINUOUS\n0\nENDTAB\n0\nENDSEC\n");
  fprintf(fp, "0\nSECTION\n2\nBLOCKS\n0\nENDSEC\n");
 
  fprintf(fp, "0\nSECTION\n2\nENTITIES\n");
 
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
    fprintf(fp, "0\n3DFACE\n8\n0\n");
    fprintf(fp, "10\n%f\n20\n%f\n30\n%f\n", stl->facet_start[i].vertex[0](0), stl->facet_start[i].vertex[0](1), stl->facet_start[i].vertex[0](2));
    fprintf(fp, "11\n%f\n21\n%f\n31\n%f\n", stl->facet_start[i].vertex[1](0), stl->facet_start[i].vertex[1](1), stl->facet_start[i].vertex[1](2));
    fprintf(fp, "12\n%f\n22\n%f\n32\n%f\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2));
    fprintf(fp, "13\n%f\n23\n%f\n33\n%f\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2));
  }
 
    fprintf(fp, "0\nENDSEC\n0\nEOF\n");
    fclose(fp);
    return true;
}

References error, stl_file::facet_start, stl_stats::number_of_facets, and stl_file::stats.

stl_write_facet()

void stl_write_facet	(	stl_file *	stl,
		char *	label,
		int	facet
	)

{
  printf("facet (%d)/ %s\n", facet, label);
  stl_write_vertex(stl, facet, 0);
  stl_write_vertex(stl, facet, 1);
  stl_write_vertex(stl, facet, 2);
}

References stl_write_vertex().

Referenced by stl_verify_neighbors().

Here is the call graph for this function:

Here is the caller graph for this function:

stl_write_neighbor()

void stl_write_neighbor	(	stl_file *	stl,
		int	facet
	)

{
  printf("Neighbors %d: %d, %d, %d ;  %d, %d, %d\n", facet,
    stl->neighbors_start[facet].neighbor[0],
    stl->neighbors_start[facet].neighbor[1],
    stl->neighbors_start[facet].neighbor[2],
    stl->neighbors_start[facet].which_vertex_not[0],
    stl->neighbors_start[facet].which_vertex_not[1],
    stl->neighbors_start[facet].which_vertex_not[2]);
}

References stl_file::neighbors_start.

stl_write_quad_object()

bool stl_write_quad_object	(	stl_file *	stl,
		char *	file
	)

{
  stl_vertex connect_color = stl_vertex::Zero();
  stl_vertex uncon_1_color = stl_vertex::Zero();
  stl_vertex uncon_2_color = stl_vertex::Zero();
  stl_vertex uncon_3_color = stl_vertex::Zero();
  stl_vertex color;
 
  FILE *fp = boost::nowide::fopen(file, "w");
  if (fp == nullptr) {
    BOOST_LOG_TRIVIAL(error) << "stl_write_quad_object: Couldn't open " << file << " for writing";
    return false;
  }
 
    fprintf(fp, "CQUAD\n");
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
      switch (stl->neighbors_start[i].num_neighbors()) {
        case 0:
        default: color = uncon_3_color; break;
        case 1:  color = uncon_2_color; break;
        case 2:  color = uncon_1_color; break;
      case 3:  color = connect_color; break;
      }
      fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[0](0), stl->facet_start[i].vertex[0](1), stl->facet_start[i].vertex[0](2), color(0), color(1), color(2));
      fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[1](0), stl->facet_start[i].vertex[1](1), stl->facet_start[i].vertex[1](2), color(0), color(1), color(2));
      fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2), color(0), color(1), color(2));
      fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2), color(0), color(1), color(2));
  }
  fclose(fp);
  return true;
}

References error, stl_file::facet_start, stl_file::neighbors_start, stl_stats::number_of_facets, and stl_file::stats.

stl_write_vertex()

void stl_write_vertex	(	stl_file *	stl,
		int	facet,
		int	vertex
	)

{
    printf("  vertex %d/%d % .8E % .8E % .8E\n", vertex, facet,
         stl->facet_start[facet].vertex[vertex](0),
         stl->facet_start[facet].vertex[vertex](1),
         stl->facet_start[facet].vertex[vertex](2));
}

References stl_file::facet_start.

Referenced by stl_write_facet().

Here is the caller graph for this function: