ClipperLib::ClipperOffset Class Reference

#include <users_modules/mortar_contact/src/clipper.hpp>

Collaboration diagram for ClipperLib::ClipperOffset:

Public Member Functions
	ClipperOffset (double miterLimit=2.0, double roundPrecision=0.25)
	~ClipperOffset ()
void	AddPath (const Path &path, JoinType joinType, EndType endType)
void	AddPaths (const Paths &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

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

Definition at line 358 of file clipper.hpp.

Constructor & Destructor Documentation

ClipperOffset()

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

Definition at line 3815 of file clipper.cpp.

    {
      j++;
      newNode->Contour.push_back(path[i]);

~ClipperOffset()

ClipperLib::ClipperOffset::~ClipperOffset

(

)

Definition at line 3823 of file clipper.cpp.

  {

Member Function Documentation

AddPath()

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

Definition at line 3838 of file clipper.cpp.

{
  for (Paths::size_type i = 0; i < paths.size(); ++i)
    AddPath(paths[i], joinType, endType);
}
//------------------------------------------------------------------------------
 
void ClipperOffset::FixOrientations()
{
  //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);
    }
  }
}
//------------------------------------------------------------------------------
 
void ClipperOffset::Execute(Paths& solution, double delta)

AddPaths()

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

Definition at line 3883 of file clipper.cpp.

  {

Clear()

void ClipperLib::ClipperOffset::Clear

(

)

Definition at line 3829 of file clipper.cpp.

  {

DoMiter()

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

private

Definition at line 4217 of file clipper.cpp.

  {
    OutRec* outrec = m_PolyOuts[i++];
    OutPt* op = outrec->Pts;
    if (!op || outrec->IsOpen) continue;
    do //for each Pt in Polygon until duplicate found do ...

DoOffset()

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

private

Definition at line 3987 of file clipper.cpp.

  {
    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.push_back(IntPoint(
            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.push_back(IntPoint(
            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.push_back(m_destPoly);
      continue;
    }
    //build m_normals ...
    m_normals.clear();
    m_normals.reserve(len);
    for (int j = 0; j < len - 1; ++j)
      m_normals.push_back(GetUnitNormal(m_srcPoly[j], m_srcPoly[j + 1]));
    if (node.m_endtype == etClosedLine || node.m_endtype == etClosedPolygon)
      m_normals.push_back(GetUnitNormal(m_srcPoly[len - 1], m_srcPoly[0]));
    else
      m_normals.push_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.push_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.push_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.push_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 = IntPoint((cInt)Round(m_srcPoly[j].X + m_normals[j].X *
          delta), (cInt)Round(m_srcPoly[j].Y + m_normals[j].Y * delta));
        m_destPoly.push_back(pt1);
        pt1 = IntPoint((cInt)Round(m_srcPoly[j].X - m_normals[j].X *
          delta), (cInt)Round(m_srcPoly[j].Y - m_normals[j].Y * delta));
        m_destPoly.push_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 = IntPoint((cInt)Round(m_srcPoly[0].X - m_normals[0].X * delta),
          (cInt)Round(m_srcPoly[0].Y - m_normals[0].Y * delta));
        m_destPoly.push_back(pt1);
        pt1 = IntPoint((cInt)Round(m_srcPoly[0].X + m_normals[0].X * delta),
          (cInt)Round(m_srcPoly[0].Y + m_normals[0].Y * delta));
        m_destPoly.push_back(pt1);
      }
      else
      {
        k = 1;
        m_sinA = 0;
        if (node.m_endtype == etOpenSquare)
          DoSquare(0, 1);
        else
          DoRound(0, 1);
      }
      m_destPolys.push_back(m_destPoly);
    }
  }
}
//------------------------------------------------------------------------------
 
void ClipperOffset::OffsetPoint(int j, int& k, JoinType jointype)
{
  //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.push_back(IntPoint(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.push_back(IntPoint(Round(m_srcPoly[j].X + m_normals[k].X * m_delta),
      Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta)));
    m_destPoly.push_back(m_srcPoly[j]);
    m_destPoly.push_back(IntPoint(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);

DoRound()

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

private

Definition at line 4225 of file clipper.cpp.

      {
        if ((op->Pt == op2->Pt) && op2->Next != op && op2->Prev != op) 
        {
          //split the polygon into two ...
          OutPt* op3 = op->Prev;
          OutPt* op4 = op2->Prev;
          op->Prev = op4;
          op4->Next = op;
          op2->Prev = op3;
          op3->Next = op2;
 
          outrec->Pts = op;
          OutRec* outrec2 = CreateOutRec();
          outrec2->Pts = op2;
          UpdateOutPtIdxs(*outrec2);
          if (Poly2ContainsPoly1(outrec2->Pts, outrec->Pts))
          {
            //OutRec2 is contained by OutRec1 ...
            outrec2->IsHole = !outrec->IsHole;

DoSquare()

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

private

Definition at line 4204 of file clipper.cpp.

{

Execute() [1/2]

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

Definition at line 3916 of file clipper.cpp.

  {
    clpr.Execute(ctUnion, solution, pftPositive, pftPositive);
  }
  else
  {
    IntRect r = clpr.GetBounds();
    Path outer(4);
    outer[0] = IntPoint(r.left - 10, r.bottom + 10);
    outer[1] = IntPoint(r.right + 10, r.bottom + 10);
    outer[2] = IntPoint(r.right + 10, r.top - 10);
    outer[3] = IntPoint(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 ...
    if (solution.ChildCount() == 1 && solution.Childs[0]->ChildCount() > 0)
    {
      PolyNode* outerNode = solution.Childs[0];
      solution.Childs.reserve(outerNode->ChildCount());
      solution.Childs[0] = outerNode->Childs[0];
      solution.Childs[0]->Parent = outerNode->Parent;
      for (int i = 1; i < outerNode->ChildCount(); ++i)
        solution.AddChild(*outerNode->Childs[i]);

Execute() [2/2]

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

Definition at line 3946 of file clipper.cpp.

{
  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.push_back(node.Contour);
    }
    return;
  }
 
  //see offset_triginometry3.svg in the documentation folder ...
  if (MiterLimit > 2) m_miterLim = 2/(MiterLimit * MiterLimit);
  else m_miterLim = 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;

FixOrientations()

void ClipperLib::ClipperOffset::FixOrientations ( )

private

Definition at line 3890 of file clipper.cpp.

  {
    clpr.Execute(ctUnion, solution, pftPositive, pftPositive);
  }
  else
  {
    IntRect r = clpr.GetBounds();
    Path outer(4);
    outer[0] = IntPoint(r.left - 10, r.bottom + 10);
    outer[1] = IntPoint(r.right + 10, r.bottom + 10);
    outer[2] = IntPoint(r.right + 10, r.top - 10);
    outer[3] = IntPoint(r.left - 10, r.top - 10);
 
    clpr.AddPath(outer, ptSubject, true);
    clpr.ReverseSolution(true);
    clpr.Execute(ctUnion, solution, pftNegative, pftNegative);
    if (solution.size() > 0) solution.erase(solution.begin());
  }
}
//------------------------------------------------------------------------------
 
void ClipperOffset::Execute(PolyTree& solution, double delta)
{
  solution.Clear();
  FixOrientations();

OffsetPoint()

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

private

Definition at line 4160 of file clipper.cpp.

                   : DoSquare(j, k); break;
      case jtRound: DoRound(j, k); break;
    }
  k = j;
}
//------------------------------------------------------------------------------
 
void ClipperOffset::DoSquare(int j, int k)
{
  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.push_back(IntPoint(
      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.push_back(IntPoint(
      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))));
}
//------------------------------------------------------------------------------
 
void ClipperOffset::DoMiter(int j, int k, double r)
{
  double q = m_delta / r;
  m_destPoly.push_back(IntPoint(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)));
}
//------------------------------------------------------------------------------
 
void ClipperOffset::DoRound(int j, int k)
{
  double a = std::atan2(m_sinA,
  m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y);
  int 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.push_back(IntPoint(
        Round(m_srcPoly[j].X + X * m_delta),
        Round(m_srcPoly[j].Y + Y * m_delta)));
    X2 = X;

Member Data Documentation

ArcTolerance

double ClipperLib::ClipperOffset::ArcTolerance

Definition at line 369 of file clipper.hpp.

m_cos

double ClipperLib::ClipperOffset::m_cos

private

Definition at line 375 of file clipper.hpp.

m_delta

double ClipperLib::ClipperOffset::m_delta

private

Definition at line 375 of file clipper.hpp.

m_destPoly

Path ClipperLib::ClipperOffset::m_destPoly

private

Definition at line 373 of file clipper.hpp.

m_destPolys

Paths ClipperLib::ClipperOffset::m_destPolys

private

Definition at line 371 of file clipper.hpp.

m_lowest

IntPoint ClipperLib::ClipperOffset::m_lowest

private

Definition at line 377 of file clipper.hpp.

m_miterLim

double ClipperLib::ClipperOffset::m_miterLim

private

Definition at line 376 of file clipper.hpp.

m_normals

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

private

Definition at line 374 of file clipper.hpp.

m_polyNodes

PolyNode ClipperLib::ClipperOffset::m_polyNodes

private

Definition at line 378 of file clipper.hpp.

m_sin

double ClipperLib::ClipperOffset::m_sin

private

Definition at line 375 of file clipper.hpp.

m_sinA

double ClipperLib::ClipperOffset::m_sinA

private

Definition at line 375 of file clipper.hpp.

m_srcPoly

Path ClipperLib::ClipperOffset::m_srcPoly

private

Definition at line 372 of file clipper.hpp.

m_StepsPerRad

double ClipperLib::ClipperOffset::m_StepsPerRad

private

Definition at line 376 of file clipper.hpp.

MiterLimit

double ClipperLib::ClipperOffset::MiterLimit

Definition at line 368 of file clipper.hpp.

---

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

• users_modules/mortar_contact/src/clipper.hpp
• users_modules/mortar_contact/src/impl/clipper.cpp