Slic3r::AntPathMatrix Class Reference

Collaboration diagram for Slic3r::AntPathMatrix:

Public Member Functions
	AntPathMatrix (const std::vector< MonotonicRegion > &regions, const ExPolygonWithOffset &poly_with_offset, const std::vector< SegmentedIntersectionLine > &segs, const float initial_pheromone)
void	update_inital_pheromone (float initial_pheromone)
AntPath &	operator() (const MonotonicRegion &region_from, bool flipped_from, const MonotonicRegion &region_to, bool flipped_to)
AntPath &	operator() (const MonotonicRegionLink &region_from, const MonotonicRegion &region_to, bool flipped_to)
AntPath &	operator() (const MonotonicRegion &region_from, bool flipped_from, const MonotonicRegionLink &region_to)
AntPath &	operator() (const MonotonicRegionLink &region_from, const MonotonicRegionLink &region_to)

Private Attributes
const std::vector< MonotonicRegion > &	m_regions
const ExPolygonWithOffset &	m_poly_with_offset
const std::vector< SegmentedIntersectionLine > &	m_segs
std::vector< AntPath >	m_matrix

Detailed Description

Constructor & Destructor Documentation

AntPathMatrix()

Slic3r::AntPathMatrix::AntPathMatrix ( const std::vector< MonotonicRegion > &  regions, const ExPolygonWithOffset &  poly_with_offset, const std::vector< SegmentedIntersectionLine > &  segs, const float  initial_pheromone  )

inline

                                                      : 
    m_regions(regions),
    m_poly_with_offset(poly_with_offset),
    m_segs(segs),
    // From end of one region to the start of another region, both flipped or not flipped.
    m_matrix(regions.size() * regions.size() * 4, AntPath{ -1., -1., initial_pheromone}) {}

Member Function Documentation

operator()() [1/4]

AntPath & Slic3r::AntPathMatrix::operator() ( const MonotonicRegion &  region_from, bool  flipped_from, const MonotonicRegion &  region_to, bool  flipped_to  )

inline

  {
    int row = 2 * int(&region_from - m_regions.data()) + flipped_from;
    int col = 2 * int(&region_to   - m_regions.data()) + flipped_to;
    AntPath &path = m_matrix[row * m_regions.size() * 2 + col];
    if (path.length == -1.) {
      // This path is accessed for the first time. Update the length and cost.
      int i_from = region_from.right_intersection_point(flipped_from);
      int i_to   = region_to.left_intersection_point(flipped_to);
      const SegmentedIntersectionLine &vline_from = m_segs[region_from.right.vline];
      const SegmentedIntersectionLine &vline_to   = m_segs[region_to.left.vline];
      if (region_from.right.vline + 1 == region_from.left.vline) {
        int i_right = vline_from.intersections[i_from].right_horizontal();
        if (i_right == i_to && vline_from.intersections[i_from].next_on_contour_quality == SegmentIntersection::LinkQuality::Valid) {
          // Measure length along the contour.
                  path.length = unscale<float>(measure_perimeter_horizontal_segment_length(m_poly_with_offset, m_segs, region_from.right.vline, i_from, i_to));
        }
      }
      if (path.length == -1.) {
        // Just apply the Eucledian distance of the end points.
          path.length = unscale<float>(Vec2f(vline_to.pos - vline_from.pos, vline_to.intersections[i_to].pos() - vline_from.intersections[i_from].pos()).norm());
      }
      path.visibility = 1.f / (path.length + float(EPSILON));
    }
    return path;
  }

References col(), EPSILON, Slic3r::SegmentedIntersectionLine::intersections, Slic3r::MonotonicRegion::left, Slic3r::MonotonicRegion::left_intersection_point(), Slic3r::AntPath::length, m_matrix, m_poly_with_offset, m_regions, m_segs, Slic3r::measure_perimeter_horizontal_segment_length(), Slic3r::SegmentedIntersectionLine::pos, Slic3r::MonotonicRegion::right, Slic3r::MonotonicRegion::right_intersection_point(), row(), Slic3r::SegmentIntersection::Valid, Slic3r::AntPath::visibility, and Slic3r::MonotonicRegion::Boundary::vline.

Here is the call graph for this function:

operator()() [2/4]

AntPath & Slic3r::AntPathMatrix::operator() ( const MonotonicRegion &  region_from, bool  flipped_from, const MonotonicRegionLink &  region_to  )

inline

    { return (*this)(region_from, flipped_from, *region_to.region, region_to.flipped); }

References Slic3r::MonotonicRegionLink::flipped, and Slic3r::MonotonicRegionLink::region.

operator()() [3/4]

AntPath & Slic3r::AntPathMatrix::operator() ( const MonotonicRegionLink &  region_from, const MonotonicRegion &  region_to, bool  flipped_to  )

inline

    { return (*this)(*region_from.region, region_from.flipped, region_to, flipped_to); }

References Slic3r::MonotonicRegionLink::flipped, and Slic3r::MonotonicRegionLink::region.

operator()() [4/4]

AntPath & Slic3r::AntPathMatrix::operator() ( const MonotonicRegionLink &  region_from, const MonotonicRegionLink &  region_to  )

inline

        { return (*this)(*region_from.region, region_from.flipped, *region_to.region, region_to.flipped); }

References Slic3r::MonotonicRegionLink::flipped, and Slic3r::MonotonicRegionLink::region.

update_inital_pheromone()

void Slic3r::AntPathMatrix::update_inital_pheromone ( float  initial_pheromone )

inline

  {
    for (AntPath &ap : m_matrix)
      ap.pheromone = initial_pheromone;
  }

References m_matrix.

Referenced by Slic3r::chain_monotonic_regions().

Here is the caller graph for this function:

Member Data Documentation

m_matrix

std::vector<AntPath> Slic3r::AntPathMatrix::m_matrix

private

Referenced by operator()(), and update_inital_pheromone().

m_poly_with_offset

const ExPolygonWithOffset& Slic3r::AntPathMatrix::m_poly_with_offset

private

Referenced by operator()().

m_regions

const std::vector<MonotonicRegion>& Slic3r::AntPathMatrix::m_regions

private

Referenced by operator()().

m_segs

const std::vector<SegmentedIntersectionLine>& Slic3r::AntPathMatrix::m_segs

private

Referenced by operator()().

---

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

• src/libslic3r/Fill/FillRectilinear.cpp