util.cpp File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <boost/log/trivial.hpp>
#include "stl.h"

Include dependency graph for util.cpp:

Go to the source code of this file.

Functions
void	stl_verify_neighbors (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)
static void	calculate_normals (stl_file *stl)
static void	rotate_point_2d (float &x, float &y, const double c, const double s)
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	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_get_size (stl_file *stl)
void	stl_mirror_xy (stl_file *stl)
void	stl_mirror_yz (stl_file *stl)
void	stl_mirror_xz (stl_file *stl)
static float	get_area (stl_facet *facet)
static float	get_volume (stl_file *stl)
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)

Function Documentation

calculate_normals()

static void calculate_normals ( stl_file *  stl )

static

{
  stl_normal normal;
  for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ 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, stl_file::stats, stl_calculate_normal(), and stl_normalize_vector().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_area()

static float get_area ( stl_facet *  facet )

static

{
  /* cast to double before calculating cross product because large coordinates
   can result in overflowing product
  (bad area is responsible for bad volume and bad facets reversal) */
  double cross[3][3];
  for (int i = 0; i < 3; i++) {
    cross[i][0]=(((double)facet->vertex[i](1) * (double)facet->vertex[(i + 1) % 3](2)) -
                 ((double)facet->vertex[i](2) * (double)facet->vertex[(i + 1) % 3](1)));
    cross[i][1]=(((double)facet->vertex[i](2) * (double)facet->vertex[(i + 1) % 3](0)) -
                 ((double)facet->vertex[i](0) * (double)facet->vertex[(i + 1) % 3](2)));
    cross[i][2]=(((double)facet->vertex[i](0) * (double)facet->vertex[(i + 1) % 3](1)) -
                 ((double)facet->vertex[i](1) * (double)facet->vertex[(i + 1) % 3](0)));
  }
 
  stl_normal sum;
  sum(0) = cross[0][0] + cross[1][0] + cross[2][0];
  sum(1) = cross[0][1] + cross[1][1] + cross[2][1];
  sum(2) = cross[0][2] + cross[1][2] + cross[2][2];
 
  // This should already be done.  But just in case, let's do it again.
  //FIXME this is questionable. the "sum" normal should be accurate, while the normal "n" may be calculated with a low accuracy.
  stl_normal n;
  stl_calculate_normal(n, facet);
  stl_normalize_vector(n);
  return 0.5f * n.dot(sum);
}

References stl_calculate_normal(), stl_normalize_vector(), and stl_facet::vertex.

Referenced by get_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

get_volume()

static float get_volume ( stl_file *  stl )

static

{
    // Choose a point, any point as the reference.
    stl_vertex p0 = stl->facet_start[0].vertex[0];
    float volume = 0.f;
    for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
      // Do dot product to get distance from point to plane.
      float height = stl->facet_start[i].normal.dot(stl->facet_start[i].vertex[0] - p0);
      float area   = get_area(&stl->facet_start[i]);
      volume += (area * height) / 3.0f;
    }
    return volume;
}

References stl_file::facet_start, get_area(), stl_stats::number_of_facets, and stl_file::stats.

Referenced by stl_calculate_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

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:

rotate_point_2d()

static void rotate_point_2d ( float &  x, float &  y, const double  c, const double  s  )

inlinestatic

{
  double xold = x;
  double yold = y;
  x = float(c * xold - s * yold);
  y = float(s * xold + c * yold);
}

Referenced by its_rotate_x(), its_rotate_y(), its_rotate_z(), stl_rotate_x(), stl_rotate_y(), and stl_rotate_z().

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_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_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_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_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_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_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: