boost::polygon::voronoi_visual_utils< CT > Class Template Reference

#include <src/libslic3r/Geometry/VoronoiVisualUtils.hpp>

Static Public Member Functions
template<class InCT1 , class InCT2 , template< class > class Point, template< class > class Segment>
static enable_if< typenamegtl_and< typenamegtl_if< typenameis_point_concept< typenamegeometry_concept< Point< InCT1 > >::type >::type >::type, typenamegtl_if< typenameis_segment_concept< typenamegeometry_concept< Segment< InCT2 > >::type >::type >::type >::type, void >::type	discretize (const Point< InCT1 > &point, const Segment< InCT2 > &segment, const CT max_dist, std::vector< Point< CT > > *discretization)

Static Private Member Functions
static CT	parabola_y (CT x, CT a, CT b)
template<class InCT , template< class > class Point, template< class > class Segment>
static enable_if< typenamegtl_and< typenamegtl_if< typenameis_point_concept< typenamegeometry_concept< Point< int > >::type >::type >::type, typenamegtl_if< typenameis_segment_concept< typenamegeometry_concept< Segment< long > >::type >::type >::type >::type, CT >::type	get_point_projection (const Point< CT > &point, const Segment< InCT > &segment)
template<typename InCT >
static CT	cast (const InCT &value)

Detailed Description

template<typename CT>
class boost::polygon::voronoi_visual_utils< CT >

Member Function Documentation

cast()

template<typename CT >

template<typename InCT >

static CT boost::polygon::voronoi_visual_utils< CT >::cast ( const InCT &  value )

inlinestaticprivate

                                    {
    return static_cast<CT>(value);
  }

discretize()

template<typename CT >

template<class InCT1 , class InCT2 , template< class > class Point, template< class > class Segment>

static enable_if< typenamegtl_and< typenamegtl_if< typenameis_point_concept< typenamegeometry_concept< Point< InCT1 > >::type >::type >::type, typenamegtl_if< typenameis_segment_concept< typenamegeometry_concept< Segment< InCT2 > >::type >::type >::type >::type, void >::type boost::polygon::voronoi_visual_utils< CT >::discretize ( const Point< InCT1 > &  point, const Segment< InCT2 > &  segment, const CT  max_dist, std::vector< Point< CT > > *  discretization  )

inlinestatic

                                              {
    // Apply the linear transformation to move start point of the segment to
    // the point with coordinates (0, 0) and the direction of the segment to
    // coincide the positive direction of the x-axis.
    CT segm_vec_x = cast(x(high(segment))) - cast(x(low(segment)));
    CT segm_vec_y = cast(y(high(segment))) - cast(y(low(segment)));
    CT sqr_segment_length = segm_vec_x * segm_vec_x + segm_vec_y * segm_vec_y;
 
    // Compute x-coordinates of the endpoints of the edge
    // in the transformed space.
    CT projection_start = sqr_segment_length *
        get_point_projection((*discretization)[0], segment);
    CT projection_end = sqr_segment_length *
        get_point_projection((*discretization)[1], segment);
    assert(projection_start != projection_end);
 
    // Compute parabola parameters in the transformed space.
    // Parabola has next representation:
    // f(x) = ((x-rot_x)^2 + rot_y^2) / (2.0*rot_y).
    CT point_vec_x = cast(x(point)) - cast(x(low(segment)));
    CT point_vec_y = cast(y(point)) - cast(y(low(segment)));
    CT rot_x = segm_vec_x * point_vec_x + segm_vec_y * point_vec_y;
    CT rot_y = segm_vec_x * point_vec_y - segm_vec_y * point_vec_x;
 
    // Save the last point.
    Point<CT> last_point = (*discretization)[1];
    discretization->pop_back();
 
    // Use stack to avoid recursion.
    std::stack<CT> point_stack;
    point_stack.push(projection_end);
    CT cur_x = projection_start;
    CT cur_y = parabola_y(cur_x, rot_x, rot_y);
 
    // Adjust max_dist parameter in the transformed space.
    const CT max_dist_transformed = max_dist * max_dist * sqr_segment_length;
    while (!point_stack.empty()) {
      CT new_x = point_stack.top();
      CT new_y = parabola_y(new_x, rot_x, rot_y);
 
      // Compute coordinates of the point of the parabola that is
      // furthest from the current line segment.
      CT mid_x = (new_y - cur_y) / (new_x - cur_x) * rot_y + rot_x;
      CT mid_y = parabola_y(mid_x, rot_x, rot_y);
      assert(mid_x != cur_x || mid_y != cur_y);
      assert(mid_x != new_x || mid_y != new_y);
 
      // Compute maximum distance between the given parabolic arc
      // and line segment that discretize it.
      CT dist = (new_y - cur_y) * (mid_x - cur_x) -
          (new_x - cur_x) * (mid_y - cur_y);
      CT div = (new_y - cur_y) * (new_y - cur_y) + (new_x - cur_x) * (new_x - cur_x);
      assert(div != 0);
      dist = dist * dist / div;
      if (dist <= max_dist_transformed) {
        // Distance between parabola and line segment is less than max_dist.
        point_stack.pop();
        CT inter_x = (segm_vec_x * new_x - segm_vec_y * new_y) /
            sqr_segment_length + cast(x(low(segment)));
        CT inter_y = (segm_vec_x * new_y + segm_vec_y * new_x) /
            sqr_segment_length + cast(y(low(segment)));
        discretization->push_back(Point<CT>(inter_x, inter_y));
        cur_x = new_x;
        cur_y = new_y;
      } else {
        point_stack.push(mid_x);
      }
    }
 
    // Update last point.
    discretization->back() = last_point;
  }

References cast(), boost::polygon::voronoi_visual_utils< CT >::get_point_projection(), boost::polygon::voronoi_visual_utils< CT >::parabola_y(), and segment().

Referenced by Slic3r::Voronoi::Internal::sample_curved_edge().

Here is the call graph for this function:

Here is the caller graph for this function:

get_point_projection()

template<typename CT >

template<class InCT , template< class > class Point, template< class > class Segment>

static enable_if< typenamegtl_and< typenamegtl_if< typenameis_point_concept< typenamegeometry_concept< Point< int > >::type >::type >::type, typenamegtl_if< typenameis_segment_concept< typenamegeometry_concept< Segment< long > >::type >::type >::type >::type, CT >::type boost::polygon::voronoi_visual_utils< CT >::get_point_projection ( const Point< CT > &  point, const Segment< InCT > &  segment  )

inlinestaticprivate

                                                            {
    CT segment_vec_x = cast(x(high(segment))) - cast(x(low(segment)));
    CT segment_vec_y = cast(y(high(segment))) - cast(y(low(segment)));
    CT point_vec_x = x(point) - cast(x(low(segment)));
    CT point_vec_y = y(point) - cast(y(low(segment)));
    CT sqr_segment_length =
        segment_vec_x * segment_vec_x + segment_vec_y * segment_vec_y;
    CT vec_dot = segment_vec_x * point_vec_x + segment_vec_y * point_vec_y;
    return vec_dot / sqr_segment_length;
  }

References cast(), and segment().

Referenced by boost::polygon::voronoi_visual_utils< CT >::discretize().

Here is the call graph for this function:

Here is the caller graph for this function:

parabola_y()

template<typename CT >

static CT boost::polygon::voronoi_visual_utils< CT >::parabola_y ( CT  x, CT  a, CT  b  )

inlinestaticprivate

                                         {
    return ((x - a) * (x - a) + b * b) / (b + b);
  }

Referenced by boost::polygon::voronoi_visual_utils< CT >::discretize().

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• src/libslic3r/Geometry/VoronoiVisualUtils.hpp