ClipperLib::ClipperOffset Class Reference

#include <src/clipper/clipper.hpp>

Collaboration diagram for ClipperLib::ClipperOffset:

Public Member Functions
	ClipperOffset (double miterLimit=2.0, double roundPrecision=0.25, double shortestEdgeLength=0.)
	~ClipperOffset ()
void	AddPath (const Path &path, JoinType joinType, EndType endType)
template<typename PathsProvider >
void	AddPaths (PathsProvider &&paths, JoinType joinType, EndType endType)
void	Execute (Paths &solution, double delta)
void	Execute (PolyTree &solution, double delta)
void	Clear ()

Public Attributes
double	MiterLimit
double	ArcTolerance
double	ShortestEdgeLength

Private Member Functions
void	FixOrientations ()
void	DoOffset (double delta)
void	OffsetPoint (int j, int &k, JoinType jointype)
void	DoSquare (int j, int k)
void	DoMiter (int j, int k, double r)
void	DoRound (int j, int k)

Private Attributes
Paths	m_destPolys
Path	m_srcPoly
Path	m_destPoly
std::vector< DoublePoint, Allocator< DoublePoint > >	m_normals
double	m_delta
double	m_sinA
double	m_sin
double	m_cos
double	m_miterLim
double	m_StepsPerRad
IntPoint	m_lowest
PolyNode	m_polyNodes

Detailed Description

Constructor & Destructor Documentation

ClipperOffset()

ClipperLib::ClipperOffset::ClipperOffset ( double  miterLimit = 2.0, double  roundPrecision = 0.25, double  shortestEdgeLength = 0.  )

inline

                                                                                                       :
    MiterLimit(miterLimit), ArcTolerance(roundPrecision), ShortestEdgeLength(shortestEdgeLength), m_lowest(-1, 0) {}

~ClipperOffset()

ClipperLib::ClipperOffset::~ClipperOffset ( )

inline

{ Clear(); }

Member Function Documentation

AddPath()

void ClipperLib::ClipperOffset::AddPath	(	const Path &	path,
		JoinType	joinType,
		EndType	endType
	)

{
  int highI = (int)path.size() - 1;
  if (highI < 0) return;
  PolyNode* newNode = new PolyNode();
  newNode->m_jointype = joinType;
  newNode->m_endtype = endType;
 
  //strip duplicate points from path and also get index to the lowest point ...
  bool   has_shortest_edge_length = ShortestEdgeLength > 0.;
  double shortest_edge_length2 = has_shortest_edge_length ? ShortestEdgeLength * ShortestEdgeLength : 0.;
  if (endType == etClosedLine || endType == etClosedPolygon)
    for (; highI > 0; -- highI) {
      bool same = false;
      if (has_shortest_edge_length) {
        double dx = double(path[highI].x() - path[0].x());
        double dy = double(path[highI].y() - path[0].y());
        same = dx*dx + dy*dy < shortest_edge_length2;
      } else
        same = path[0] == path[highI];
      if (! same)
        break;
    }
  newNode->Contour.reserve(highI + 1);
  newNode->Contour.emplace_back(path[0]);
  int j = 0, k = 0;
  for (int i = 1; i <= highI; i++) {
    bool same = false;
    if (has_shortest_edge_length) {
      double dx = double(path[i].x() - newNode->Contour[j].x());
      double dy = double(path[i].y() - newNode->Contour[j].y());
      same = dx*dx + dy*dy < shortest_edge_length2;
    } else
      same = newNode->Contour[j] == path[i];
    if (same)
      continue;
    j++;
    newNode->Contour.emplace_back(path[i]);
    if (path[i].y() > newNode->Contour[k].y() ||
      (path[i].y() == newNode->Contour[k].y() &&
      path[i].x() < newNode->Contour[k].x())) k = j;
  }
  if (endType == etClosedPolygon && j < 2)
  {
    delete newNode;
    return;
  }
  m_polyNodes.AddChild(*newNode);
 
  //if this path's lowest pt is lower than all the others then update m_lowest
  if (endType != etClosedPolygon) return;
  if (m_lowest.x() < 0)
    m_lowest = IntPoint2d(m_polyNodes.ChildCount() - 1, k);
  else
  {
    IntPoint ip = m_polyNodes.Childs[(int)m_lowest.x()]->Contour[(int)m_lowest.y()];
    if (newNode->Contour[k].y() > ip.y() ||
      (newNode->Contour[k].y() == ip.y() &&
      newNode->Contour[k].x() < ip.x()))
      m_lowest = IntPoint2d(m_polyNodes.ChildCount() - 1, k);
  }
}

References ClipperLib::PolyNode::AddChild(), ClipperLib::PolyNode::ChildCount(), ClipperLib::PolyNode::Childs, ClipperLib::PolyNode::Contour, ClipperLib::etClosedLine, ClipperLib::etClosedPolygon, ClipperLib::IntPoint2d(), ClipperLib::PolyNode::m_endtype, ClipperLib::PolyNode::m_jointype, m_lowest, m_polyNodes, and ShortestEdgeLength.

Referenced by Slic3r::Algorithm::expolygons_to_zpaths_expanded_opened(), Slic3r::expolygons_to_zpaths_shrunk(), Slic3r::offset_expolygon_inner(), Slic3r::raw_offset(), Slic3r::FFFSupport::tree_supports_generate_paths(), Slic3r::Algorithm::wavefront_initial(), and Slic3r::Algorithm::wavefront_step().

Here is the call graph for this function:

Here is the caller graph for this function:

AddPaths()

template<typename PathsProvider >

void ClipperLib::ClipperOffset::AddPaths ( PathsProvider &&  paths, JoinType  joinType, EndType  endType  )

inline

                                                                           {
    for (const Path &path : paths)
      AddPath(path, joinType, endType);
  }

Clear()

void ClipperLib::ClipperOffset::Clear

(

)

{
  for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    delete m_polyNodes.Childs[i];
  m_polyNodes.Childs.clear();
  m_lowest.x() = -1;
}

References ClipperLib::PolyNode::ChildCount(), ClipperLib::PolyNode::Childs, m_lowest, and m_polyNodes.

Referenced by Slic3r::Algorithm::expolygons_to_zpaths_expanded_opened(), Slic3r::expolygons_to_zpaths_shrunk(), Slic3r::raw_offset(), Slic3r::Algorithm::wavefront_initial(), and Slic3r::Algorithm::wavefront_step().

Here is the call graph for this function:

Here is the caller graph for this function:

DoMiter()

void ClipperLib::ClipperOffset::DoMiter ( int  j, int  k, double  r  )

private

{
  double q = m_delta / r;
  m_destPoly.emplace_back(IntPoint2d(Round(m_srcPoly[j].x() + (m_normals[k].x() + m_normals[j].x()) * q),
      Round(m_srcPoly[j].y() + (m_normals[k].y() + m_normals[j].y()) * q)));
}

References ClipperLib::IntPoint2d(), m_delta, m_destPoly, m_normals, m_srcPoly, and ClipperLib::Round().

Referenced by OffsetPoint().

Here is the call graph for this function:

Here is the caller graph for this function:

DoOffset()

void ClipperLib::ClipperOffset::DoOffset ( double  delta )

private

{
  m_destPolys.clear();
  m_delta = delta;
 
  //if Zero offset, just copy any CLOSED polygons to m_p and return ...
  if (NEAR_ZERO(delta)) 
  {
    m_destPolys.reserve(m_polyNodes.ChildCount());
    for (int i = 0; i < m_polyNodes.ChildCount(); i++)
    {
      PolyNode& node = *m_polyNodes.Childs[i];
      if (node.m_endtype == etClosedPolygon)
        m_destPolys.emplace_back(node.Contour);
    }
    return;
  }
 
  //see offset_triginometry3.svg in the documentation folder ...
  m_miterLim = (MiterLimit > 2) ? 
    2. / (MiterLimit * MiterLimit) :
    0.5;
 
  double y;
  if (ArcTolerance <= 0.0) y = def_arc_tolerance;
  else if (ArcTolerance > std::fabs(delta) * def_arc_tolerance) 
    y = std::fabs(delta) * def_arc_tolerance;
  else y = ArcTolerance;
  //see offset_triginometry2.svg in the documentation folder ...
  double steps = pi / std::acos(1 - y / std::fabs(delta));
  if (steps > std::fabs(delta) * pi) 
    steps = std::fabs(delta) * pi;  //ie excessive precision check
  m_sin = std::sin(two_pi / steps);
  m_cos = std::cos(two_pi / steps);
  m_StepsPerRad = steps / two_pi;
  if (delta < 0.0) m_sin = -m_sin;
 
  m_destPolys.reserve(m_polyNodes.ChildCount() * 2);
  for (int i = 0; i < m_polyNodes.ChildCount(); i++)
  {
    PolyNode& node = *m_polyNodes.Childs[i];
    m_srcPoly = node.Contour;
 
    int len = (int)m_srcPoly.size();
    if (len == 0 || (delta <= 0 && (len < 3 || node.m_endtype != etClosedPolygon)))
        continue;
 
    m_destPoly.clear();
    if (len == 1)
    {
      if (node.m_jointype == jtRound)
      {
        double X = 1.0, Y = 0.0;
        for (cInt j = 1; j <= steps; j++)
        {
          m_destPoly.emplace_back(IntPoint2d(
            Round(m_srcPoly[0].x() + X * delta),
            Round(m_srcPoly[0].y() + Y * delta)));
          double X2 = X;
          X = X * m_cos - m_sin * Y;
          Y = X2 * m_sin + Y * m_cos;
        }
      }
      else
      {
        double X = -1.0, Y = -1.0;
        for (int j = 0; j < 4; ++j)
        {
          m_destPoly.emplace_back(IntPoint2d(
            Round(m_srcPoly[0].x() + X * delta),
            Round(m_srcPoly[0].y() + Y * delta)));
          if (X < 0) X = 1;
          else if (Y < 0) Y = 1;
          else X = -1;
        }
      }
      m_destPolys.emplace_back(m_destPoly);
      continue;
    }
    //build m_normals ...
    m_normals.clear();
    m_normals.reserve(len);
    for (int j = 0; j < len - 1; ++j)
      m_normals.emplace_back(GetUnitNormal(m_srcPoly[j], m_srcPoly[j + 1]));
    if (node.m_endtype == etClosedLine || node.m_endtype == etClosedPolygon)
      m_normals.emplace_back(GetUnitNormal(m_srcPoly[len - 1], m_srcPoly[0]));
    else
      m_normals.emplace_back(DoublePoint(m_normals[len - 2]));
 
    if (node.m_endtype == etClosedPolygon)
    {
      int k = len - 1;
      for (int j = 0; j < len; ++j)
        OffsetPoint(j, k, node.m_jointype);
      m_destPolys.emplace_back(m_destPoly);
    }
    else if (node.m_endtype == etClosedLine)
    {
      int k = len - 1;
      for (int j = 0; j < len; ++j)
        OffsetPoint(j, k, node.m_jointype);
      m_destPolys.emplace_back(m_destPoly);
      m_destPoly.clear();
      //re-build m_normals ...
      DoublePoint n = m_normals[len -1];
      for (int j = len - 1; j > 0; j--)
        m_normals[j] = DoublePoint(-m_normals[j - 1].x(), -m_normals[j - 1].y());
      m_normals[0] = DoublePoint(-n.x(), -n.y());
      k = 0;
      for (int j = len - 1; j >= 0; j--)
        OffsetPoint(j, k, node.m_jointype);
      m_destPolys.emplace_back(m_destPoly);
    }
    else
    {
      int k = 0;
      for (int j = 1; j < len - 1; ++j)
        OffsetPoint(j, k, node.m_jointype);
 
      IntPoint pt1;
      if (node.m_endtype == etOpenButt)
      {
        int j = len - 1;
        pt1 = IntPoint2d(Round(m_srcPoly[j].x() + m_normals[j].x() * delta), Round(m_srcPoly[j].y() + m_normals[j].y() * delta));
        m_destPoly.emplace_back(pt1);
        pt1 = IntPoint2d(Round(m_srcPoly[j].x() - m_normals[j].x() * delta), Round(m_srcPoly[j].y() - m_normals[j].y() * delta));
        m_destPoly.emplace_back(pt1);
      }
      else
      {
        int j = len - 1;
        k = len - 2;
        m_sinA = 0;
        m_normals[j] = DoublePoint(-m_normals[j].x(), -m_normals[j].y());
        if (node.m_endtype == etOpenSquare)
          DoSquare(j, k);
        else
          DoRound(j, k);
      }
 
      //re-build m_normals ...
      for (int j = len - 1; j > 0; j--)
        m_normals[j] = DoublePoint(-m_normals[j - 1].x(), -m_normals[j - 1].y());
      m_normals[0] = DoublePoint(-m_normals[1].x(), -m_normals[1].y());
 
      k = len - 1;
      for (int j = k - 1; j > 0; --j) OffsetPoint(j, k, node.m_jointype);
 
      if (node.m_endtype == etOpenButt)
      {
        pt1 = IntPoint2d(Round(m_srcPoly[0].x() - m_normals[0].x() * delta), Round(m_srcPoly[0].y() - m_normals[0].y() * delta));
        m_destPoly.emplace_back(pt1);
        pt1 = IntPoint2d(Round(m_srcPoly[0].x() + m_normals[0].x() * delta), Round(m_srcPoly[0].y() + m_normals[0].y() * delta));
        m_destPoly.emplace_back(pt1);
      }
      else
      {
        k = 1;
        m_sinA = 0;
        if (node.m_endtype == etOpenSquare)
          DoSquare(0, 1);
        else
          DoRound(0, 1);
      }
      m_destPolys.emplace_back(m_destPoly);
    }
  }
}

References ArcTolerance, ClipperLib::PolyNode::ChildCount(), ClipperLib::PolyNode::Childs, ClipperLib::PolyNode::Contour, ClipperLib::def_arc_tolerance, DoRound(), DoSquare(), ClipperLib::etClosedLine, ClipperLib::etClosedPolygon, ClipperLib::etOpenButt, ClipperLib::etOpenSquare, ClipperLib::GetUnitNormal(), ClipperLib::IntPoint2d(), ClipperLib::jtRound, m_cos, m_delta, m_destPoly, m_destPolys, ClipperLib::PolyNode::m_endtype, ClipperLib::PolyNode::m_jointype, m_miterLim, m_normals, m_polyNodes, m_sin, m_sinA, m_srcPoly, m_StepsPerRad, MiterLimit, NEAR_ZERO, OffsetPoint(), ClipperLib::pi, ClipperLib::Round(), and ClipperLib::two_pi.

Referenced by Execute(), and Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

DoRound()

void ClipperLib::ClipperOffset::DoRound ( int  j, int  k  )

private

{
  double a = std::atan2(m_sinA,
  m_normals[k].x() * m_normals[j].x() + m_normals[k].y() * m_normals[j].y());
  auto steps = std::max<int>(Round(m_StepsPerRad * std::fabs(a)), 1);
 
  double X = m_normals[k].x(), Y = m_normals[k].y(), X2;
  for (int i = 0; i < steps; ++i)
  {
    m_destPoly.emplace_back(IntPoint2d(
        Round(m_srcPoly[j].x() + X * m_delta),
        Round(m_srcPoly[j].y() + Y * m_delta)));
    X2 = X;
    X = X * m_cos - m_sin * Y;
    Y = X2 * m_sin + Y * m_cos;
  }
  m_destPoly.emplace_back(IntPoint2d(
  Round(m_srcPoly[j].x() + m_normals[j].x() * m_delta),
  Round(m_srcPoly[j].y() + m_normals[j].y() * m_delta)));
}

References ClipperLib::IntPoint2d(), m_cos, m_delta, m_destPoly, m_normals, m_sin, m_sinA, m_srcPoly, m_StepsPerRad, and ClipperLib::Round().

Referenced by DoOffset(), and OffsetPoint().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSquare()

void ClipperLib::ClipperOffset::DoSquare ( int  j, int  k  )

private

{
  double dx = std::tan(std::atan2(m_sinA,
      m_normals[k].x() * m_normals[j].x() + m_normals[k].y() * m_normals[j].y()) / 4);
  m_destPoly.emplace_back(IntPoint2d(
      Round(m_srcPoly[j].x() + m_delta * (m_normals[k].x() - m_normals[k].y() * dx)),
      Round(m_srcPoly[j].y() + m_delta * (m_normals[k].y() + m_normals[k].x() * dx))));
  m_destPoly.emplace_back(IntPoint2d(
      Round(m_srcPoly[j].x() + m_delta * (m_normals[j].x() + m_normals[j].y() * dx)),
      Round(m_srcPoly[j].y() + m_delta * (m_normals[j].y() - m_normals[j].x() * dx))));
}

References ClipperLib::IntPoint2d(), m_delta, m_destPoly, m_normals, m_sinA, m_srcPoly, and ClipperLib::Round().

Referenced by DoOffset(), and OffsetPoint().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute() [1/2]

void ClipperLib::ClipperOffset::Execute	(	Paths &	solution,
		double	delta
	)

{
  solution.clear();
  FixOrientations();
  DoOffset(delta);
  
  //now clean up 'corners' ...
  Clipper clpr;
  clpr.AddPaths(m_destPolys, ptSubject, true);
  if (delta > 0)
  {
    clpr.Execute(ctUnion, solution, pftPositive, pftPositive);
  }
  else
  {
    IntRect r = clpr.GetBounds();
    Path outer(4);
    outer[0] = IntPoint2d(r.left - 10, r.bottom + 10);
    outer[1] = IntPoint2d(r.right + 10, r.bottom + 10);
    outer[2] = IntPoint2d(r.right + 10, r.top - 10);
    outer[3] = IntPoint2d(r.left - 10, r.top - 10);
 
    clpr.AddPath(outer, ptSubject, true);
    clpr.ReverseSolution(true);
    clpr.Execute(ctUnion, solution, pftNegative, pftNegative);
    if (! solution.empty())
      solution.erase(solution.begin());
  }
}

References ClipperLib::ClipperBase::AddPath(), ClipperLib::ClipperBase::AddPaths(), ClipperLib::IntRect::bottom, ClipperLib::ctUnion, DoOffset(), ClipperLib::Clipper::Execute(), FixOrientations(), ClipperLib::ClipperBase::GetBounds(), ClipperLib::IntPoint2d(), ClipperLib::IntRect::left, m_destPolys, ClipperLib::pftNegative, ClipperLib::pftPositive, ClipperLib::ptSubject, ClipperLib::Clipper::ReverseSolution(), ClipperLib::IntRect::right, and ClipperLib::IntRect::top.

Referenced by Slic3r::Algorithm::expolygons_to_zpaths_expanded_opened(), Slic3r::expolygons_to_zpaths_shrunk(), Slic3r::offset_expolygon_inner(), Slic3r::raw_offset(), Slic3r::FFFSupport::tree_supports_generate_paths(), Slic3r::Algorithm::wavefront_initial(), and Slic3r::Algorithm::wavefront_step().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute() [2/2]

void ClipperLib::ClipperOffset::Execute	(	PolyTree &	solution,
		double	delta
	)

{
  solution.Clear();
  FixOrientations();
  DoOffset(delta);
 
  //now clean up 'corners' ...
  Clipper clpr;
  clpr.AddPaths(m_destPolys, ptSubject, true);
  if (delta > 0)
  {
    clpr.Execute(ctUnion, solution, pftPositive, pftPositive);
  }
  else
  {
    IntRect r = clpr.GetBounds();
    Path outer(4);
    outer[0] = IntPoint2d(r.left - 10, r.bottom + 10);
    outer[1] = IntPoint2d(r.right + 10, r.bottom + 10);
    outer[2] = IntPoint2d(r.right + 10, r.top - 10);
    outer[3] = IntPoint2d(r.left - 10, r.top - 10);
 
    clpr.AddPath(outer, ptSubject, true);
    clpr.ReverseSolution(true);
    clpr.Execute(ctUnion, solution, pftNegative, pftNegative);
    //remove the outer PolyNode rectangle ...
    solution.RemoveOutermostPolygon();
  }
}

References ClipperLib::ClipperBase::AddPath(), ClipperLib::ClipperBase::AddPaths(), ClipperLib::IntRect::bottom, ClipperLib::PolyTree::Clear(), ClipperLib::ctUnion, DoOffset(), ClipperLib::Clipper::Execute(), FixOrientations(), ClipperLib::ClipperBase::GetBounds(), ClipperLib::IntPoint2d(), ClipperLib::IntRect::left, m_destPolys, ClipperLib::pftNegative, ClipperLib::pftPositive, ClipperLib::ptSubject, ClipperLib::PolyTree::RemoveOutermostPolygon(), ClipperLib::Clipper::ReverseSolution(), ClipperLib::IntRect::right, and ClipperLib::IntRect::top.

Here is the call graph for this function:

FixOrientations()

void ClipperLib::ClipperOffset::FixOrientations ( )

private

{
  //fixup orientations of all closed paths if the orientation of the
  //closed path with the lowermost vertex is wrong ...
  if (m_lowest.x() >= 0 && 
    !Orientation(m_polyNodes.Childs[(int)m_lowest.x()]->Contour))
  {
    for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    {
      PolyNode& node = *m_polyNodes.Childs[i];
      if (node.m_endtype == etClosedPolygon ||
        (node.m_endtype == etClosedLine && Orientation(node.Contour)))
          ReversePath(node.Contour);
    }
  } else
  {
    for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    {
      PolyNode& node = *m_polyNodes.Childs[i];
      if (node.m_endtype == etClosedLine && !Orientation(node.Contour))
        ReversePath(node.Contour);
    }
  }
}

References ClipperLib::PolyNode::ChildCount(), ClipperLib::PolyNode::Childs, ClipperLib::PolyNode::Contour, ClipperLib::etClosedLine, ClipperLib::etClosedPolygon, ClipperLib::PolyNode::m_endtype, m_lowest, m_polyNodes, and ClipperLib::ReversePath().

Referenced by Execute(), and Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

OffsetPoint()

void ClipperLib::ClipperOffset::OffsetPoint ( int  j, int &  k, JoinType  jointype  )

private

{
  //cross product ...
  m_sinA = (m_normals[k].x() * m_normals[j].y() - m_normals[j].x() * m_normals[k].y());
  if (std::fabs(m_sinA * m_delta) < 1.0) 
  {
    //dot product ...
    double cosA = (m_normals[k].x() * m_normals[j].x() + m_normals[j].y() * m_normals[k].y() ); 
    if (cosA > 0) // angle => 0 degrees
    {
      m_destPoly.emplace_back(IntPoint2d(Round(m_srcPoly[j].x() + m_normals[k].x() * m_delta),
        Round(m_srcPoly[j].y() + m_normals[k].y() * m_delta)));
      return; 
    }
    //else angle => 180 degrees   
  }
  else if (m_sinA > 1.0) m_sinA = 1.0;
  else if (m_sinA < -1.0) m_sinA = -1.0;
 
  if (m_sinA * m_delta < 0)
  {
    m_destPoly.emplace_back(IntPoint2d(Round(m_srcPoly[j].x() + m_normals[k].x() * m_delta),
      Round(m_srcPoly[j].y() + m_normals[k].y() * m_delta)));
    m_destPoly.emplace_back(m_srcPoly[j]);
    m_destPoly.emplace_back(IntPoint2d(Round(m_srcPoly[j].x() + m_normals[j].x() * m_delta),
      Round(m_srcPoly[j].y() + m_normals[j].y() * m_delta)));
  }
  else
    switch (jointype)
    {
      case jtMiter:
        {
          double r = 1 + (m_normals[j].x() * m_normals[k].x() +
            m_normals[j].y() * m_normals[k].y());
          if (r >= m_miterLim) DoMiter(j, k, r); else DoSquare(j, k);
          break;
        }
      case jtSquare: DoSquare(j, k); break;
      case jtRound: DoRound(j, k); break;
    }
  k = j;
}

References DoMiter(), DoRound(), DoSquare(), ClipperLib::IntPoint2d(), ClipperLib::jtMiter, ClipperLib::jtRound, ClipperLib::jtSquare, m_delta, m_destPoly, m_miterLim, m_normals, m_sinA, m_srcPoly, and ClipperLib::Round().

Referenced by DoOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

ArcTolerance

double ClipperLib::ClipperOffset::ArcTolerance

Referenced by DoOffset(), Slic3r::offset_expolygon_inner(), Slic3r::Algorithm::propagate_waves(), Slic3r::raw_offset(), and Slic3r::FFFSupport::tree_supports_generate_paths().

m_cos

double ClipperLib::ClipperOffset::m_cos

private

Referenced by DoOffset(), and DoRound().

m_delta

double ClipperLib::ClipperOffset::m_delta

private

Referenced by DoMiter(), DoOffset(), DoRound(), DoSquare(), and OffsetPoint().

m_destPoly

Path ClipperLib::ClipperOffset::m_destPoly

private

Referenced by DoMiter(), DoOffset(), DoRound(), DoSquare(), and OffsetPoint().

m_destPolys

Paths ClipperLib::ClipperOffset::m_destPolys

private

Referenced by DoOffset(), Execute(), and Execute().

m_lowest

IntPoint ClipperLib::ClipperOffset::m_lowest

private

Referenced by AddPath(), Clear(), and FixOrientations().

m_miterLim

double ClipperLib::ClipperOffset::m_miterLim

private

Referenced by DoOffset(), and OffsetPoint().

m_normals

std::vector<DoublePoint, Allocator<DoublePoint> > ClipperLib::ClipperOffset::m_normals

private

Referenced by DoMiter(), DoOffset(), DoRound(), DoSquare(), and OffsetPoint().

m_polyNodes

PolyNode ClipperLib::ClipperOffset::m_polyNodes

private

Referenced by AddPath(), Clear(), DoOffset(), and FixOrientations().

m_sin

double ClipperLib::ClipperOffset::m_sin

private

Referenced by DoOffset(), and DoRound().

m_sinA

double ClipperLib::ClipperOffset::m_sinA

private

Referenced by DoOffset(), DoRound(), DoSquare(), and OffsetPoint().

m_srcPoly

Path ClipperLib::ClipperOffset::m_srcPoly

private

Referenced by DoMiter(), DoOffset(), DoRound(), DoSquare(), and OffsetPoint().

m_StepsPerRad

double ClipperLib::ClipperOffset::m_StepsPerRad

private

Referenced by DoOffset(), and DoRound().

MiterLimit

double ClipperLib::ClipperOffset::MiterLimit

Referenced by DoOffset(), Slic3r::expolygons_to_zpaths_shrunk(), Slic3r::offset_expolygon_inner(), Slic3r::raw_offset(), and Slic3r::FFFSupport::tree_supports_generate_paths().

ShortestEdgeLength

double ClipperLib::ClipperOffset::ShortestEdgeLength

Referenced by AddPath(), Slic3r::Algorithm::expolygons_to_zpaths_expanded_opened(), Slic3r::offset_expolygon_inner(), Slic3r::Algorithm::propagate_waves(), Slic3r::raw_offset(), and Slic3r::FFFSupport::tree_supports_generate_paths().

---

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

• src/clipper/clipper.hpp
• src/clipper/clipper.cpp