ClipperLib::ClipperBase Class Reference

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

Inheritance diagram for ClipperLib::ClipperBase:

Collaboration diagram for ClipperLib::ClipperBase:

Public Member Functions
	ClipperBase ()
virtual	~ClipperBase ()
virtual bool	AddPath (const Path &pg, PolyType PolyTyp, bool Closed)
bool	AddPaths (const Paths &ppg, PolyType PolyTyp, bool Closed)
virtual void	Clear ()
IntRect	GetBounds ()
bool	PreserveCollinear ()
void	PreserveCollinear (bool value)

Protected Types
typedef std::vector< LocalMinimum >	MinimaList
typedef std::priority_queue< cInt >	ScanbeamList

Protected Member Functions
void	DisposeLocalMinimaList ()
TEdge *	AddBoundsToLML (TEdge *e, bool IsClosed)
virtual void	Reset ()
TEdge *	ProcessBound (TEdge *E, bool IsClockwise)
void	InsertScanbeam (const cInt Y)
bool	PopScanbeam (cInt &Y)
bool	LocalMinimaPending ()
bool	PopLocalMinima (cInt Y, const LocalMinimum *&locMin)
OutRec *	CreateOutRec ()
void	DisposeAllOutRecs ()
void	DisposeOutRec (PolyOutList::size_type index)
void	SwapPositionsInAEL (TEdge *edge1, TEdge *edge2)
void	DeleteFromAEL (TEdge *e)
void	UpdateEdgeIntoAEL (TEdge *&e)

Protected Attributes
MinimaList::iterator	m_CurrentLM
MinimaList	m_MinimaList
bool	m_UseFullRange
EdgeList	m_edges
bool	m_PreserveCollinear
bool	m_HasOpenPaths
PolyOutList	m_PolyOuts
TEdge *	m_ActiveEdges
ScanbeamList	m_Scanbeam

Detailed Description

Definition at line 218 of file clipper.hpp.

Member Typedef Documentation

MinimaList

typedef std::vector<LocalMinimum> ClipperLib::ClipperBase::MinimaList

protected

Definition at line 245 of file clipper.hpp.

ScanbeamList

typedef std::priority_queue<cInt> ClipperLib::ClipperBase::ScanbeamList

protected

Definition at line 256 of file clipper.hpp.

Constructor & Destructor Documentation

ClipperBase()

ClipperLib::ClipperBase::ClipperBase

(

)

Definition at line 919 of file clipper.cpp.

~ClipperBase()

ClipperLib::ClipperBase::~ClipperBase ( )

virtual

Definition at line 926 of file clipper.cpp.

{

Member Function Documentation

AddBoundsToLML()

TEdge* ClipperLib::ClipperBase::AddBoundsToLML ( TEdge *  e, bool  IsClosed  )

protected

AddPath()

bool ClipperLib::ClipperBase::AddPath ( const Path &  pg, PolyType  PolyTyp, bool  Closed  )

virtual

Definition at line 1081 of file clipper.cpp.

  {
    //nb: allows matching start and end points when not Closed ...
    if (E->Curr == E->Next->Curr && (Closed || E->Next != eStart))
    {
      if (E == E->Next) break;
      if (E == eStart) eStart = E->Next;
      E = RemoveEdge(E);
      eLoopStop = E;
      continue;
    }
    if (E->Prev == E->Next) 
      break; //only two vertices
    else if (Closed &&
      SlopesEqual(E->Prev->Curr, E->Curr, E->Next->Curr, m_UseFullRange) && 
      (!m_PreserveCollinear ||
      !Pt2IsBetweenPt1AndPt3(E->Prev->Curr, E->Curr, E->Next->Curr)))
    {
      //Collinear edges are allowed for open paths but in closed paths
      //the default is to merge adjacent collinear edges into a single edge.
      //However, if the PreserveCollinear property is enabled, only overlapping
      //collinear edges (ie spikes) will be removed from closed paths.
      if (E == eStart) eStart = E->Next;
      E = RemoveEdge(E);
      E = E->Prev;
      eLoopStop = E;
      continue;
    }
    E = E->Next;
    if ((E == eLoopStop) || (!Closed && E->Next == eStart)) break;
  }
 
  if ((!Closed && (E == E->Next)) || (Closed && (E->Prev == E->Next)))
  {
    delete [] edges;
    return false;
  }
 
  if (!Closed)
  { 
    m_HasOpenPaths = true;
    eStart->Prev->OutIdx = Skip;
  }
 
  //3. Do second stage of edge initialization ...
  E = eStart;
  do
  {
    InitEdge2(*E, PolyTyp);
    E = E->Next;
    if (IsFlat && E->Curr.Y != eStart->Curr.Y) IsFlat = false;
  }
  while (E != eStart);
 
  //4. Finally, add edge bounds to LocalMinima list ...
 
  //Totally flat paths must be handled differently when adding them
  //to LocalMinima list to avoid endless loops etc ...
  if (IsFlat) 
  {
    if (Closed) 
    {
      delete [] edges;
      return false;
    }
    E->Prev->OutIdx = Skip;
    MinimaList::value_type locMin;
    locMin.Y = E->Bot.Y;
    locMin.LeftBound = 0;
    locMin.RightBound = E;
    locMin.RightBound->Side = esRight;
    locMin.RightBound->WindDelta = 0;
    for (;;)
    {
      if (E->Bot.X != E->Prev->Top.X) ReverseHorizontal(*E);
      if (E->Next->OutIdx == Skip) break;
      E->NextInLML = E->Next;
      E = E->Next;
    }
    m_MinimaList.push_back(locMin);
    m_edges.push_back(edges);
      return true;
  }
 
  m_edges.push_back(edges);
  bool leftBoundIsForward;
  TEdge* EMin = 0;
 
  //workaround to avoid an endless loop in the while loop below when
  //open paths have matching start and end points ...
  if (E->Prev->Bot == E->Prev->Top) E = E->Next;
 
  for (;;)
  {
    E = FindNextLocMin(E);
    if (E == EMin) break;
    else if (!EMin) EMin = E;
 
    //E and E.Prev now share a local minima (left aligned if horizontal).
    //Compare their slopes to find which starts which bound ...
    MinimaList::value_type locMin;
    locMin.Y = E->Bot.Y;
    if (E->Dx < E->Prev->Dx) 
    {
      locMin.LeftBound = E->Prev;
      locMin.RightBound = E;
      leftBoundIsForward = false; //Q.nextInLML = Q.prev
    } else
    {
      locMin.LeftBound = E;
      locMin.RightBound = E->Prev;
      leftBoundIsForward = true; //Q.nextInLML = Q.next
    }
 
    if (!Closed) locMin.LeftBound->WindDelta = 0;
    else if (locMin.LeftBound->Next == locMin.RightBound)
      locMin.LeftBound->WindDelta = -1;
    else locMin.LeftBound->WindDelta = 1;
    locMin.RightBound->WindDelta = -locMin.LeftBound->WindDelta;
 
    E = ProcessBound(locMin.LeftBound, leftBoundIsForward);
    if (E->OutIdx == Skip) E = ProcessBound(E, leftBoundIsForward);
 
    TEdge* E2 = ProcessBound(locMin.RightBound, !leftBoundIsForward);
    if (E2->OutIdx == Skip) E2 = ProcessBound(E2, !leftBoundIsForward);
 
    if (locMin.LeftBound->OutIdx == Skip)
      locMin.LeftBound = 0;
    else if (locMin.RightBound->OutIdx == Skip)
      locMin.RightBound = 0;
    m_MinimaList.push_back(locMin);
    if (!leftBoundIsForward) E = E2;
  }
  return true;
}
//------------------------------------------------------------------------------
 
bool ClipperBase::AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed)
{
  bool result = false;
  for (Paths::size_type i = 0; i < ppg.size(); ++i)
    if (AddPath(ppg[i], PolyTyp, Closed)) result = true;
  return result;
}
//------------------------------------------------------------------------------
 
void ClipperBase::Clear()
{
  DisposeLocalMinimaList();
  for (EdgeList::size_type i = 0; i < m_edges.size(); ++i)
  {
    TEdge* edges = m_edges[i];
    delete [] edges;
  }
  m_edges.clear();
  m_UseFullRange = false;
  m_HasOpenPaths = false;
}
//------------------------------------------------------------------------------
 
void ClipperBase::Reset()
{
  m_CurrentLM = m_MinimaList.begin();
  if (m_CurrentLM == m_MinimaList.end()) return; //ie nothing to process
  std::sort(m_MinimaList.begin(), m_MinimaList.end(), LocMinSorter());
 
  m_Scanbeam = ScanbeamList(); //clears/resets priority_queue
  //reset all edges ...
  for (MinimaList::iterator lm = m_MinimaList.begin(); lm != m_MinimaList.end(); ++lm)
  {
    InsertScanbeam(lm->Y);

AddPaths()

bool ClipperLib::ClipperBase::AddPaths	(	const Paths &	ppg,
		PolyType	PolyTyp,
		bool	Closed
	)

Definition at line 1260 of file clipper.cpp.

    {
      e->Curr = e->Bot;
      e->Side = esLeft;
      e->OutIdx = Unassigned;
    }
 
    e = lm->RightBound;

Clear()

void ClipperLib::ClipperBase::Clear ( )

virtual

Definition at line 1269 of file clipper.cpp.

{

CreateOutRec()

OutRec * ClipperLib::ClipperBase::CreateOutRec ( )

protected

Definition at line 1416 of file clipper.cpp.

  {
    TEdge* Next = Edge1->NextInAEL;
    TEdge* Prev = Edge1->PrevInAEL;
    Edge1->NextInAEL = Edge2->NextInAEL;
    if (Edge1->NextInAEL) Edge1->NextInAEL->PrevInAEL = Edge1;

DeleteFromAEL()

void ClipperLib::ClipperBase::DeleteFromAEL ( TEdge *  e )

protected

Definition at line 1403 of file clipper.cpp.

  {

DisposeAllOutRecs()

void ClipperLib::ClipperBase::DisposeAllOutRecs ( )

protected

Definition at line 1387 of file clipper.cpp.

DisposeLocalMinimaList()

void ClipperLib::ClipperBase::DisposeLocalMinimaList ( )

protected

Definition at line 1315 of file clipper.cpp.

      {
        if (e->Bot.X < result.left) result.left = e->Bot.X;
        if (e->Bot.X > result.right) result.right = e->Bot.X;
        e = e->NextInLML;

DisposeOutRec()

void ClipperLib::ClipperBase::DisposeOutRec ( PolyOutList::size_type  index )

protected

Definition at line 1394 of file clipper.cpp.

{
  //check that one or other edge hasn't already been removed from AEL ...
  if (Edge1->NextInAEL == Edge1->PrevInAEL ||
    Edge2->NextInAEL == Edge2->PrevInAEL) return;
 

GetBounds()

IntRect ClipperLib::ClipperBase::GetBounds

(

)

Definition at line 1331 of file clipper.cpp.

{
  m_Scanbeam.push(Y);
}
//------------------------------------------------------------------------------
 
bool ClipperBase::PopScanbeam(cInt &Y)
{
  if (m_Scanbeam.empty()) return false;
  Y = m_Scanbeam.top();
  m_Scanbeam.pop();
  while (!m_Scanbeam.empty() && Y == m_Scanbeam.top()) { m_Scanbeam.pop(); } // Pop duplicates.
  return true;
}
//------------------------------------------------------------------------------
 
void ClipperBase::DisposeAllOutRecs(){
  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i)
    DisposeOutRec(i);
  m_PolyOuts.clear();
}
//------------------------------------------------------------------------------
 
void ClipperBase::DisposeOutRec(PolyOutList::size_type index)
{
  OutRec *outRec = m_PolyOuts[index];
  if (outRec->Pts) DisposeOutPts(outRec->Pts);
  delete outRec;
  m_PolyOuts[index] = 0;
}
//------------------------------------------------------------------------------
 
void ClipperBase::DeleteFromAEL(TEdge *e)
{

InsertScanbeam()

void ClipperLib::ClipperBase::InsertScanbeam ( const cInt  Y )

protected

Definition at line 1371 of file clipper.cpp.

LocalMinimaPending()

bool ClipperLib::ClipperBase::LocalMinimaPending ( )

protected

Definition at line 1501 of file clipper.cpp.

{
    return Execute(clipType, polytree, fillType, fillType);

PopLocalMinima()

bool ClipperLib::ClipperBase::PopLocalMinima ( cInt  Y, const LocalMinimum *&  locMin  )

protected

Definition at line 1322 of file clipper.cpp.

PopScanbeam()

bool ClipperLib::ClipperBase::PopScanbeam ( cInt &  Y )

protected

Definition at line 1377 of file clipper.cpp.

{
  OutRec* result = new OutRec;
  result->IsHole = false;
  result->IsOpen = false;

PreserveCollinear() [1/2]

bool ClipperLib::ClipperBase::PreserveCollinear ( )

inline

Definition at line 227 of file clipper.hpp.

{return m_PreserveCollinear;};

PreserveCollinear() [2/2]

void ClipperLib::ClipperBase::PreserveCollinear ( bool  value )

inline

Definition at line 228 of file clipper.hpp.

{m_PreserveCollinear = value;};

ProcessBound()

TEdge * ClipperLib::ClipperBase::ProcessBound ( TEdge *  E, bool  IsClockwise  )

protected

Definition at line 964 of file clipper.cpp.

  {
    //We need to be careful with open paths because this may not be a
    //true local minima (ie E may be following a skip edge).
    //Also, consecutive horz. edges may start heading left before going right.
    if (NextIsForward) 
      EStart = E->Prev;
    else 
      EStart = E->Next;
    if (IsHorizontal(*EStart)) //ie an adjoining horizontal skip edge
      {
        if (EStart->Bot.X != E->Bot.X && EStart->Top.X != E->Bot.X)
          ReverseHorizontal(*E);
      }
      else if (EStart->Bot.X != E->Bot.X)
        ReverseHorizontal(*E);
  }
  
  EStart = E;
  if (NextIsForward)
  {
    while (Result->Top.Y == Result->Next->Bot.Y && Result->Next->OutIdx != Skip)
      Result = Result->Next;
    if (IsHorizontal(*Result) && Result->Next->OutIdx != Skip)
    {
      //nb: at the top of a bound, horizontals are added to the bound
      //only when the preceding edge attaches to the horizontal's left vertex
      //unless a Skip edge is encountered when that becomes the top divide
      Horz = Result;
      while (IsHorizontal(*Horz->Prev)) Horz = Horz->Prev;
      if (Horz->Prev->Top.X > Result->Next->Top.X) Result = Horz->Prev;
    }
    while (E != Result) 
    {
      E->NextInLML = E->Next;
      if (IsHorizontal(*E) && E != EStart &&
        E->Bot.X != E->Prev->Top.X) ReverseHorizontal(*E);
      E = E->Next;
    }
    if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Prev->Top.X) 
      ReverseHorizontal(*E);
    Result = Result->Next; //move to the edge just beyond current bound
  } else
  {
    while (Result->Top.Y == Result->Prev->Bot.Y && Result->Prev->OutIdx != Skip) 
      Result = Result->Prev;
    if (IsHorizontal(*Result) && Result->Prev->OutIdx != Skip)
    {
      Horz = Result;
      while (IsHorizontal(*Horz->Next)) Horz = Horz->Next;
      if (Horz->Next->Top.X == Result->Prev->Top.X ||
          Horz->Next->Top.X > Result->Prev->Top.X) Result = Horz->Next;
    }
 
    while (E != Result)
    {
      E->NextInLML = E->Prev;
      if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Next->Top.X) 
        ReverseHorizontal(*E);
      E = E->Prev;
    }
    if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Next->Top.X) 
      ReverseHorizontal(*E);
    Result = Result->Prev; //move to the edge just beyond current bound
  }
 
  return Result;
}
//------------------------------------------------------------------------------
 
bool ClipperBase::AddPath(const Path &pg, PolyType PolyTyp, bool Closed)
{
#ifdef use_lines
  if (!Closed && PolyTyp == ptClip)
    throw clipperException("AddPath: Open paths must be subject.");
#else
  if (!Closed)
    throw clipperException("AddPath: Open paths have been disabled.");
#endif
 
  int highI = (int)pg.size() -1;
  if (Closed) while (highI > 0 && (pg[highI] == pg[0])) --highI;
  while (highI > 0 && (pg[highI] == pg[highI -1])) --highI;
  if ((Closed && highI < 2) || (!Closed && highI < 1)) return false;
 
  //create a new edge array ...
  TEdge *edges = new TEdge [highI +1];
 
  bool IsFlat = true;
  //1. Basic (first) edge initialization ...
  try
  {
    edges[1].Curr = pg[1];
    RangeTest(pg[0], m_UseFullRange);
    RangeTest(pg[highI], m_UseFullRange);
    InitEdge(&edges[0], &edges[1], &edges[highI], pg[0]);
    InitEdge(&edges[highI], &edges[0], &edges[highI-1], pg[highI]);
    for (int i = highI - 1; i >= 1; --i)
    {
      RangeTest(pg[i], m_UseFullRange);
      InitEdge(&edges[i], &edges[i+1], &edges[i-1], pg[i]);
    }
  }
  catch(...)

Reset()

void ClipperLib::ClipperBase::Reset ( )

protectedvirtual

Definition at line 1283 of file clipper.cpp.

{
  if (m_CurrentLM == m_MinimaList.end() || (*m_CurrentLM).Y != Y) return false;
  locMin = &(*m_CurrentLM);
  ++m_CurrentLM;
  return true;
}
//------------------------------------------------------------------------------
 
IntRect ClipperBase::GetBounds()
{
  IntRect result;
  MinimaList::iterator lm = m_MinimaList.begin();
  if (lm == m_MinimaList.end())
  {
    result.left = result.top = result.right = result.bottom = 0;
    return result;
  }
  result.left = lm->LeftBound->Bot.X;
  result.top = lm->LeftBound->Bot.Y;
  result.right = lm->LeftBound->Bot.X;
  result.bottom = lm->LeftBound->Bot.Y;
  while (lm != m_MinimaList.end())
  {
    //todo - needs fixing for open paths
    result.bottom = std::max(result.bottom, lm->LeftBound->Bot.Y);
    TEdge* e = lm->LeftBound;

SwapPositionsInAEL()

void ClipperLib::ClipperBase::SwapPositionsInAEL ( TEdge *  edge1, TEdge *  edge2  )

protected

Definition at line 1431 of file clipper.cpp.

{
  if (!e->NextInLML) 
    throw clipperException("UpdateEdgeIntoAEL: invalid call");
 
  e->NextInLML->OutIdx = e->OutIdx;
  TEdge* AelPrev = e->PrevInAEL;
  TEdge* AelNext = e->NextInAEL;
  if (AelPrev) AelPrev->NextInAEL = e->NextInLML;
  else m_ActiveEdges = e->NextInLML;
  if (AelNext) AelNext->PrevInAEL = e->NextInLML;
  e->NextInLML->Side = e->Side;
  e->NextInLML->WindDelta = e->WindDelta;
  e->NextInLML->WindCnt = e->WindCnt;
  e->NextInLML->WindCnt2 = e->WindCnt2;
  e = e->NextInLML;
  e->Curr = e->Bot;
  e->PrevInAEL = AelPrev;
  e->NextInAEL = AelNext;
  if (!IsHorizontal(*e)) InsertScanbeam(e->Top.Y);
}
//------------------------------------------------------------------------------
 
bool ClipperBase::LocalMinimaPending()
{
  return (m_CurrentLM != m_MinimaList.end());
}
 
//------------------------------------------------------------------------------
// TClipper methods ...
//------------------------------------------------------------------------------
 
Clipper::Clipper(int initOptions) : ClipperBase() //constructor
{

UpdateEdgeIntoAEL()

void ClipperLib::ClipperBase::UpdateEdgeIntoAEL ( TEdge *&  e )

protected

Definition at line 1478 of file clipper.cpp.

{  
  m_ZFill = zFillFunc;
}
//------------------------------------------------------------------------------
#endif
 
bool Clipper::Execute(ClipType clipType, Paths &solution, PolyFillType fillType)
{
    return Execute(clipType, solution, fillType, fillType);

Member Data Documentation

m_ActiveEdges

TEdge* ClipperLib::ClipperBase::m_ActiveEdges

protected

Definition at line 254 of file clipper.hpp.

m_CurrentLM

MinimaList::iterator ClipperLib::ClipperBase::m_CurrentLM

protected

Definition at line 246 of file clipper.hpp.

m_edges

EdgeList ClipperLib::ClipperBase::m_edges

protected

Definition at line 250 of file clipper.hpp.

m_HasOpenPaths

bool ClipperLib::ClipperBase::m_HasOpenPaths

protected

Definition at line 252 of file clipper.hpp.

m_MinimaList

MinimaList ClipperLib::ClipperBase::m_MinimaList

protected

Definition at line 247 of file clipper.hpp.

m_PolyOuts

PolyOutList ClipperLib::ClipperBase::m_PolyOuts

protected

Definition at line 253 of file clipper.hpp.

m_PreserveCollinear

bool ClipperLib::ClipperBase::m_PreserveCollinear

protected

Definition at line 251 of file clipper.hpp.

m_Scanbeam

ScanbeamList ClipperLib::ClipperBase::m_Scanbeam

protected

Definition at line 257 of file clipper.hpp.

m_UseFullRange

bool ClipperLib::ClipperBase::m_UseFullRange

protected

Definition at line 249 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