From 815d0a8639acad6134c5847b71371cca03134511 Mon Sep 17 00:00:00 2001
From: Scott Giese <scttgs0@gmail.com>
Date: Mon, 16 Jul 2018 12:18:40 -0500
Subject: [PATCH] Modernize: Convert enums to scoped enums

---
 src/BuildTiles/Main/cliptst.cxx        |  18 +-
 src/Lib/terragear/clipper.cpp          | 272 ++++++++++++-------------
 src/Lib/terragear/clipper.hpp          |  26 +--
 src/Lib/terragear/tg_accumulator.cxx   |  20 +-
 src/Lib/terragear/tg_contour.cxx       |  20 +-
 src/Lib/terragear/tg_polygon.cxx       |   2 +-
 src/Lib/terragear/tg_polygon_clean.cxx |   4 +-
 src/Lib/terragear/tg_polygon_clip.cxx  |  28 +--
 src/Prep/DemChop/srtmchop.cxx          |  26 +--
 9 files changed, 208 insertions(+), 208 deletions(-)

diff --git a/src/BuildTiles/Main/cliptst.cxx b/src/BuildTiles/Main/cliptst.cxx
index 1e31f0c1..6cbaf32f 100644
--- a/src/BuildTiles/Main/cliptst.cxx
+++ b/src/BuildTiles/Main/cliptst.cxx
@@ -266,23 +266,23 @@ int main(int argc, char* argv[])
   
   ClipType clipType;
   switch (toupper(argv[3][0])) {
-    case 'X': clipType = ctXor; break;
-    case 'U': clipType = ctUnion; break;
-    case 'D': clipType = ctDifference; break;
-    default: clipType = ctIntersection;
+    case 'X': clipType = ClipType::Xor; break;
+    case 'U': clipType = ClipType::Union; break;
+    case 'D': clipType = ClipType::Difference; break;
+    default: clipType = ClipType::Intersection;
   }
 
-  PolyFillType subj_pft = pftNonZero, clip_pft = pftNonZero;
+  PolyFillType subj_pft = PolyFillType::NonZero, clip_pft = PolyFillType::NonZero;
   if (argc > 4&& strcasecmp(argv[4], "EVENODD") == 0)
-      subj_pft = pftEvenOdd;
+      subj_pft = PolyFillType::EvenOdd;
   if (argc > 5 && strcasecmp(argv[5], "EVENODD") == 0)
-      clip_pft = pftEvenOdd;
+      clip_pft = PolyFillType::EvenOdd;
 
   cout << "\nclipping ... \n";
 
   Clipper c;
-  c.AddPolygons(subject, ptSubject);
-  c.AddPolygons(clip, ptClip);
+  c.AddPolygons(subject, PolyType::Subject);
+  c.AddPolygons(clip, PolyType::Clip);
   Polygons solution;
 
 //  double elapsed = 0;
diff --git a/src/Lib/terragear/clipper.cpp b/src/Lib/terragear/clipper.cpp
index d3143fe5..ab91cc67 100644
--- a/src/Lib/terragear/clipper.cpp
+++ b/src/Lib/terragear/clipper.cpp
@@ -54,7 +54,7 @@ static double const pi = 3.141592653589793238;
 static double const two_pi = pi *2;
 static double const def_arc_tolerance = 0.25;
 
-enum Direction { dRightToLeft, dLeftToRight };
+enum class Direction { RightToLeft, LeftToRight };
 
 static int const Unassigned = -1;  //edge not currently 'owning' a solution
 static int const Skip = -2;        //edge that would otherwise close a path
@@ -1045,7 +1045,7 @@ TEdge* ClipperBase::ProcessBound(TEdge* E, bool NextIsForward)
 bool ClipperBase::AddPath(const Path &pg, PolyType PolyTyp, bool Closed)
 {
 #ifdef use_lines
-  if (!Closed && PolyTyp == ptClip)
+  if (!Closed && PolyTyp == PolyType::Clip)
     throw clipperException("AddPath: Open paths must be subject.");
 #else
   if (!Closed)
@@ -1154,7 +1154,7 @@ bool ClipperBase::AddPath(const Path &pg, PolyType PolyTyp, bool Closed)
     locMin.Y = E->Bot.Y;
     locMin.LeftBound = 0;
     locMin.RightBound = E;
-    locMin.RightBound->Side = esRight;
+    locMin.RightBound->Side = EdgeSide::Right;
     locMin.RightBound->WindDelta = 0;
     for (;;)
     {
@@ -1259,7 +1259,7 @@ void ClipperBase::Reset()
     if (e)
     {
       e->Curr = e->Bot;
-      e->Side = esLeft;
+      e->Side = EdgeSide::Left;
       e->OutIdx = Unassigned;
     }
 
@@ -1267,7 +1267,7 @@ void ClipperBase::Reset()
     if (e)
     {
       e->Curr = e->Bot;
-      e->Side = esRight;
+      e->Side = EdgeSide::Right;
       e->OutIdx = Unassigned;
     }
   }
@@ -1475,9 +1475,9 @@ Clipper::Clipper(int initOptions) : ClipperBase() //constructor
 {
   m_ExecuteLocked = false;
   m_UseFullRange = false;
-  m_ReverseOutput = ((initOptions & ioReverseSolution) != 0);
-  m_StrictSimple = ((initOptions & ioStrictlySimple) != 0);
-  m_PreserveCollinear = ((initOptions & ioPreserveCollinear) != 0);
+  m_ReverseOutput = ((initOptions & static_cast<int>(InitOptions::ReverseSolution)) != 0);
+  m_StrictSimple = ((initOptions & static_cast<int>(InitOptions::StrictlySimple)) != 0);
+  m_PreserveCollinear = ((initOptions & static_cast<int>(InitOptions::PreserveCollinear)) != 0);
   m_HasOpenPaths = false;
 #ifdef use_xyz  
   m_ZFill = 0;
@@ -1630,15 +1630,15 @@ void Clipper::SetWindingCount(TEdge &edge)
   {
     if (edge.WindDelta == 0)
     {
-      PolyFillType pft = (edge.PolyTyp == ptSubject ? m_SubjFillType : m_ClipFillType);
-      edge.WindCnt = (pft == pftNegative ? -1 : 1);
+      PolyFillType pft = (edge.PolyTyp == PolyType::Subject ? m_SubjFillType : m_ClipFillType);
+      edge.WindCnt = (pft == PolyFillType::Negative ? -1 : 1);
     }
     else
       edge.WindCnt = edge.WindDelta;
     edge.WindCnt2 = 0;
     e = m_ActiveEdges; //ie get ready to calc WindCnt2
   }   
-  else if (edge.WindDelta == 0 && m_ClipType != ctUnion)
+  else if (edge.WindDelta == 0 && m_ClipType != ClipType::Union)
   {
     edge.WindCnt = 1;
     edge.WindCnt2 = e->WindCnt2;
@@ -1724,24 +1724,24 @@ void Clipper::SetWindingCount(TEdge &edge)
 
 bool Clipper::IsEvenOddFillType(const TEdge& edge) const
 {
-  if (edge.PolyTyp == ptSubject)
-    return m_SubjFillType == pftEvenOdd; else
-    return m_ClipFillType == pftEvenOdd;
+  if (edge.PolyTyp == PolyType::Subject)
+    return m_SubjFillType == PolyFillType::EvenOdd; else
+    return m_ClipFillType == PolyFillType::EvenOdd;
 }
 //------------------------------------------------------------------------------
 
 bool Clipper::IsEvenOddAltFillType(const TEdge& edge) const
 {
-  if (edge.PolyTyp == ptSubject)
-    return m_ClipFillType == pftEvenOdd; else
-    return m_SubjFillType == pftEvenOdd;
+  if (edge.PolyTyp == PolyType::Subject)
+    return m_ClipFillType == PolyFillType::EvenOdd; else
+    return m_SubjFillType == PolyFillType::EvenOdd;
 }
 //------------------------------------------------------------------------------
 
 bool Clipper::IsContributing(const TEdge& edge) const
 {
   PolyFillType pft, pft2;
-  if (edge.PolyTyp == ptSubject)
+  if (edge.PolyTyp == PolyType::Subject)
   {
     pft = m_SubjFillType;
     pft2 = m_ClipFillType;
@@ -1753,80 +1753,80 @@ bool Clipper::IsContributing(const TEdge& edge) const
 
   switch(pft)
   {
-    case pftEvenOdd: 
+    case PolyFillType::EvenOdd:
       //return false if a subj line has been flagged as inside a subj polygon
       if (edge.WindDelta == 0 && edge.WindCnt != 1) return false;
       break;
-    case pftNonZero:
+    case PolyFillType::NonZero:
       if (Abs(edge.WindCnt) != 1) return false;
       break;
-    case pftPositive: 
+    case PolyFillType::Positive:
       if (edge.WindCnt != 1) return false;
       break;
-    default: //pftNegative
+    default: //PolyFillType::Negative
       if (edge.WindCnt != -1) return false;
   }
 
   switch(m_ClipType)
   {
-    case ctIntersection:
+    case ClipType::Intersection:
       switch(pft2)
       {
-        case pftEvenOdd: 
-        case pftNonZero: 
+        case PolyFillType::EvenOdd:
+        case PolyFillType::NonZero:
           return (edge.WindCnt2 != 0);
-        case pftPositive: 
+        case PolyFillType::Positive:
           return (edge.WindCnt2 > 0);
-        default: 
+        default:
           return (edge.WindCnt2 < 0);
       }
       break;
-    case ctUnion:
+    case ClipType::Union:
       switch(pft2)
       {
-        case pftEvenOdd: 
-        case pftNonZero: 
+        case PolyFillType::EvenOdd:
+        case PolyFillType::NonZero:
           return (edge.WindCnt2 == 0);
-        case pftPositive: 
+        case PolyFillType::Positive:
           return (edge.WindCnt2 <= 0);
-        default: 
+        default:
           return (edge.WindCnt2 >= 0);
       }
       break;
-    case ctDifference:
-      if (edge.PolyTyp == ptSubject)
+    case ClipType::Difference:
+      if (edge.PolyTyp == PolyType::Subject)
         switch(pft2)
         {
-          case pftEvenOdd: 
-          case pftNonZero: 
+          case PolyFillType::EvenOdd:
+          case PolyFillType::NonZero:
             return (edge.WindCnt2 == 0);
-          case pftPositive: 
+          case PolyFillType::Positive:
             return (edge.WindCnt2 <= 0);
-          default: 
+          default:
             return (edge.WindCnt2 >= 0);
         }
       else
         switch(pft2)
         {
-          case pftEvenOdd: 
-          case pftNonZero: 
+          case PolyFillType::EvenOdd:
+          case PolyFillType::NonZero:
             return (edge.WindCnt2 != 0);
-          case pftPositive: 
+          case PolyFillType::Positive:
             return (edge.WindCnt2 > 0);
-          default: 
+          default:
             return (edge.WindCnt2 < 0);
         }
       break;
-    case ctXor:
+    case ClipType::Xor:
       if (edge.WindDelta == 0) //XOr always contributing unless open
         switch(pft2)
         {
-          case pftEvenOdd: 
-          case pftNonZero: 
+          case PolyFillType::EvenOdd:
+          case PolyFillType::NonZero:
             return (edge.WindCnt2 == 0);
-          case pftPositive: 
+          case PolyFillType::Positive:
             return (edge.WindCnt2 <= 0);
-          default: 
+          default:
             return (edge.WindCnt2 >= 0);
         }
       else 
@@ -1846,8 +1846,8 @@ OutPt* Clipper::AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &Pt)
   {
     result = AddOutPt(e1, Pt);
     e2->OutIdx = e1->OutIdx;
-    e1->Side = esLeft;
-    e2->Side = esRight;
+    e1->Side = EdgeSide::Left;
+    e2->Side = EdgeSide::Right;
     e = e1;
     if (e->PrevInAEL == e2)
       prevE = e2->PrevInAEL; 
@@ -1857,8 +1857,8 @@ OutPt* Clipper::AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &Pt)
   {
     result = AddOutPt(e2, Pt);
     e1->OutIdx = e2->OutIdx;
-    e1->Side = esRight;
-    e2->Side = esLeft;
+    e1->Side = EdgeSide::Right;
+    e2->Side = EdgeSide::Left;
     e = e2;
     if (e->PrevInAEL == e1)
         prevE = e1->PrevInAEL;
@@ -2122,7 +2122,7 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt)
 
     //if intersecting a subj line with a subj poly ...
     else if (e1->PolyTyp == e2->PolyTyp && 
-      e1->WindDelta != e2->WindDelta && m_ClipType == ctUnion)
+      e1->WindDelta != e2->WindDelta && m_ClipType == ClipType::Union)
     {
       if (e1->WindDelta == 0)
       {
@@ -2145,13 +2145,13 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt)
     {
       //toggle subj open path OutIdx on/off when Abs(clip.WndCnt) == 1 ...
       if ((e1->WindDelta == 0) && abs(e2->WindCnt) == 1 && 
-        (m_ClipType != ctUnion || e2->WindCnt2 == 0))
+        (m_ClipType != ClipType::Union || e2->WindCnt2 == 0))
       {
         AddOutPt(e1, Pt);
         if (e1Contributing) e1->OutIdx = Unassigned;
       }
       else if ((e2->WindDelta == 0) && (abs(e1->WindCnt) == 1) && 
-        (m_ClipType != ctUnion || e1->WindCnt2 == 0))
+        (m_ClipType != ClipType::Union || e1->WindCnt2 == 0))
       {
         AddOutPt(e2, Pt);
         if (e2Contributing) e2->OutIdx = Unassigned;
@@ -2186,7 +2186,7 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt)
   }
 
   PolyFillType e1FillType, e2FillType, e1FillType2, e2FillType2;
-  if (e1->PolyTyp == ptSubject)
+  if (e1->PolyTyp == PolyType::Subject)
   {
     e1FillType = m_SubjFillType;
     e1FillType2 = m_ClipFillType;
@@ -2195,7 +2195,7 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt)
     e1FillType = m_ClipFillType;
     e1FillType2 = m_SubjFillType;
   }
-  if (e2->PolyTyp == ptSubject)
+  if (e2->PolyTyp == PolyType::Subject)
   {
     e2FillType = m_SubjFillType;
     e2FillType2 = m_ClipFillType;
@@ -2208,21 +2208,21 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt)
   cInt e1Wc, e2Wc;
   switch (e1FillType)
   {
-    case pftPositive: e1Wc = e1->WindCnt; break;
-    case pftNegative: e1Wc = -e1->WindCnt; break;
+    case PolyFillType::Positive: e1Wc = e1->WindCnt; break;
+    case PolyFillType::Negative: e1Wc = -e1->WindCnt; break;
     default: e1Wc = Abs(e1->WindCnt);
   }
   switch(e2FillType)
   {
-    case pftPositive: e2Wc = e2->WindCnt; break;
-    case pftNegative: e2Wc = -e2->WindCnt; break;
+    case PolyFillType::Positive: e2Wc = e2->WindCnt; break;
+    case PolyFillType::Negative: e2Wc = -e2->WindCnt; break;
     default: e2Wc = Abs(e2->WindCnt);
   }
 
   if ( e1Contributing && e2Contributing )
   {
     if ((e1Wc != 0 && e1Wc != 1) || (e2Wc != 0 && e2Wc != 1) ||
-      (e1->PolyTyp != e2->PolyTyp && m_ClipType != ctXor) )
+      (e1->PolyTyp != e2->PolyTyp && m_ClipType != ClipType::Xor) )
     {
       AddLocalMaxPoly(e1, e2, Pt); 
     }
@@ -2259,14 +2259,14 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt)
     cInt e1Wc2, e2Wc2;
     switch (e1FillType2)
     {
-      case pftPositive: e1Wc2 = e1->WindCnt2; break;
-      case pftNegative : e1Wc2 = -e1->WindCnt2; break;
+      case PolyFillType::Positive: e1Wc2 = e1->WindCnt2; break;
+      case PolyFillType::Negative : e1Wc2 = -e1->WindCnt2; break;
       default: e1Wc2 = Abs(e1->WindCnt2);
     }
     switch (e2FillType2)
     {
-      case pftPositive: e2Wc2 = e2->WindCnt2; break;
-      case pftNegative: e2Wc2 = -e2->WindCnt2; break;
+      case PolyFillType::Positive: e2Wc2 = e2->WindCnt2; break;
+      case PolyFillType::Negative: e2Wc2 = -e2->WindCnt2; break;
       default: e2Wc2 = Abs(e2->WindCnt2);
     }
 
@@ -2276,20 +2276,20 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt)
     }
     else if (e1Wc == 1 && e2Wc == 1)
       switch( m_ClipType ) {
-        case ctIntersection:
+        case ClipType::Intersection:
           if (e1Wc2 > 0 && e2Wc2 > 0)
             AddLocalMinPoly(e1, e2, Pt);
           break;
-        case ctUnion:
+        case ClipType::Union:
           if ( e1Wc2 <= 0 && e2Wc2 <= 0 )
             AddLocalMinPoly(e1, e2, Pt);
           break;
-        case ctDifference:
-          if (((e1->PolyTyp == ptClip) && (e1Wc2 > 0) && (e2Wc2 > 0)) ||
-              ((e1->PolyTyp == ptSubject) && (e1Wc2 <= 0) && (e2Wc2 <= 0)))
+        case ClipType::Difference:
+          if (((e1->PolyTyp == PolyType::Clip) && (e1Wc2 > 0) && (e2Wc2 > 0)) ||
+              ((e1->PolyTyp == PolyType::Subject) && (e1Wc2 <= 0) && (e2Wc2 <= 0)))
                 AddLocalMinPoly(e1, e2, Pt);
           break;
-        case ctXor:
+        case ClipType::Xor:
           AddLocalMinPoly(e1, e2, Pt);
       }
     else
@@ -2387,9 +2387,9 @@ void Clipper::AppendPolygon(TEdge *e1, TEdge *e2)
   OutPt* p2_rt = p2_lft->Prev;
 
   //join e2 poly onto e1 poly and delete pointers to e2 ...
-  if(  e1->Side == esLeft )
+  if(  e1->Side == EdgeSide::Left )
   {
-    if(  e2->Side == esLeft )
+    if(  e2->Side == EdgeSide::Left )
     {
       //z y x a b c
       ReversePolyPtLinks(p2_lft);
@@ -2409,7 +2409,7 @@ void Clipper::AppendPolygon(TEdge *e1, TEdge *e2)
     }
   } else
   {
-    if(  e2->Side == esRight )
+    if(  e2->Side == EdgeSide::Right )
     {
       //a b c z y x
       ReversePolyPtLinks(p2_lft);
@@ -2482,7 +2482,7 @@ OutPt* Clipper::AddOutPt(TEdge *e, const IntPoint &pt)
     //OutRec.Pts is the 'Left-most' point & OutRec.Pts.Prev is the 'Right-most'
     OutPt* op = outRec->Pts;
 
-	bool ToFront = (e->Side == esLeft);
+	bool ToFront = (e->Side == EdgeSide::Left);
 	if (ToFront && (pt == op->Pt)) return op;
     else if (!ToFront && (pt == op->Prev->Pt)) return op->Prev;
 
@@ -2502,7 +2502,7 @@ OutPt* Clipper::AddOutPt(TEdge *e, const IntPoint &pt)
 OutPt* Clipper::GetLastOutPt(TEdge *e)
 {
 	OutRec *outRec = m_PolyOuts[e->OutIdx];
-	if (e->Side == esLeft)
+	if (e->Side == EdgeSide::Left)
 		return outRec->Pts;
 	else
 		return outRec->Pts->Prev;
@@ -2603,7 +2603,7 @@ void Clipper::SwapPositionsInSEL(TEdge *Edge1, TEdge *Edge2)
 
 TEdge* GetNextInAEL(TEdge *e, Direction dir)
 {
-  return dir == dLeftToRight ? e->NextInAEL : e->PrevInAEL;
+  return dir == Direction::LeftToRight ? e->NextInAEL : e->PrevInAEL;
 }
 //------------------------------------------------------------------------------
 
@@ -2613,12 +2613,12 @@ void GetHorzDirection(TEdge& HorzEdge, Direction& Dir, cInt& Left, cInt& Right)
   {
     Left = HorzEdge.Bot.X;
     Right = HorzEdge.Top.X;
-    Dir = dLeftToRight;
+    Dir = Direction::LeftToRight;
   } else
   {
     Left = HorzEdge.Top.X;
     Right = HorzEdge.Bot.X;
-    Dir = dRightToLeft;
+    Dir = Direction::RightToLeft;
   }
 }
 //------------------------------------------------------------------------
@@ -2652,7 +2652,7 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge)
   if (m_Maxima.size() > 0)
   {
       //get the first maxima in range (X) ...
-      if (dir == dLeftToRight)
+      if (dir == Direction::LeftToRight)
       {
           maxIt = m_Maxima.begin();
           while (maxIt != m_Maxima.end() && *maxIt <= horzEdge->Bot.X) maxIt++;
@@ -2683,7 +2683,7 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge)
         //'simplifying' polygons (ie if the Simplify property is set).
         if (m_Maxima.size() > 0)
         {
-            if (dir == dLeftToRight)
+            if (dir == Direction::LeftToRight)
             {
                 while (maxIt != m_Maxima.end() && *maxIt < e->Curr.X) 
                 {
@@ -2703,8 +2703,8 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge)
             }
         };
 
-        if ((dir == dLeftToRight && e->Curr.X > horzRight) ||
-			(dir == dRightToLeft && e->Curr.X < horzLeft)) break;
+        if ((dir == Direction::LeftToRight && e->Curr.X > horzRight) ||
+			(dir == Direction::RightToLeft && e->Curr.X < horzLeft)) break;
 
 		//Also break if we've got to the end of an intermediate horizontal edge ...
 		//nb: Smaller Dx's are to the right of larger Dx's ABOVE the horizontal.
@@ -2744,7 +2744,7 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge)
           return;
         }
         
-		if(dir == dLeftToRight)
+		if(dir == Direction::LeftToRight)
         {
           IntPoint Pt = IntPoint(e->Curr.X, horzEdge->Curr.Y);
           IntersectEdges(horzEdge, e, Pt);
@@ -3371,8 +3371,8 @@ OutPt* DupOutPt(OutPt* outPt, bool InsertAfter)
 bool JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b,
   const IntPoint Pt, bool DiscardLeft)
 {
-  Direction Dir1 = (op1->Pt.X > op1b->Pt.X ? dRightToLeft : dLeftToRight);
-  Direction Dir2 = (op2->Pt.X > op2b->Pt.X ? dRightToLeft : dLeftToRight);
+  Direction Dir1 = (op1->Pt.X > op1b->Pt.X ? Direction::RightToLeft : Direction::LeftToRight);
+  Direction Dir2 = (op2->Pt.X > op2b->Pt.X ? Direction::RightToLeft : Direction::LeftToRight);
   if (Dir1 == Dir2) return false;
 
   //When DiscardLeft, we want Op1b to be on the Left of Op1, otherwise we
@@ -3380,7 +3380,7 @@ bool JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b,
   //So, to facilitate this while inserting Op1b and Op2b ...
   //when DiscardLeft, make sure we're AT or RIGHT of Pt before adding Op1b,
   //otherwise make sure we're AT or LEFT of Pt. (Likewise with Op2b.)
-  if (Dir1 == dLeftToRight) 
+  if (Dir1 == Direction::LeftToRight)
   {
     while (op1->Next->Pt.X <= Pt.X && 
       op1->Next->Pt.X >= op1->Pt.X && op1->Next->Pt.Y == Pt.Y)  
@@ -3409,7 +3409,7 @@ bool JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b,
     }
   }
 
-  if (Dir2 == dLeftToRight)
+  if (Dir2 == Direction::LeftToRight)
   {
     while (op2->Next->Pt.X <= Pt.X && 
       op2->Next->Pt.X >= op2->Pt.X && op2->Next->Pt.Y == Pt.Y)
@@ -3437,7 +3437,7 @@ bool JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b,
     };
   };
 
-  if ((Dir1 == dLeftToRight) == DiscardLeft)
+  if ((Dir1 == Direction::LeftToRight) == DiscardLeft)
   {
     op1->Prev = op2;
     op2->Next = op1;
@@ -3815,7 +3815,7 @@ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType
   newNode->m_endtype = endType;
 
   //strip duplicate points from path and also get index to the lowest point ...
-  if (endType == etClosedLine || endType == etClosedPolygon)
+  if (endType == EndType::ClosedLine || endType == EndType::ClosedPolygon)
     while (highI > 0 && path[0] == path[highI]) highI--;
   newNode->Contour.reserve(highI + 1);
   newNode->Contour.push_back(path[0]);
@@ -3829,7 +3829,7 @@ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType
         (path[i].Y == newNode->Contour[k].Y &&
         path[i].X < newNode->Contour[k].X)) k = j;
     }
-  if (endType == etClosedPolygon && j < 2)
+  if (endType == EndType::ClosedPolygon && j < 2)
   {
     delete newNode;
     return;
@@ -3837,7 +3837,7 @@ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType
   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 (endType != EndType::ClosedPolygon) return;
   if (m_lowest.X < 0)
     m_lowest = IntPoint(m_polyNodes.ChildCount() - 1, k);
   else
@@ -3868,8 +3868,8 @@ void ClipperOffset::FixOrientations()
     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)))
+      if (node.m_endtype == EndType::ClosedPolygon ||
+        (node.m_endtype == EndType::ClosedLine && Orientation(node.Contour)))
           ReversePath(node.Contour);
     }
   } else
@@ -3877,7 +3877,7 @@ void ClipperOffset::FixOrientations()
     for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
     {
       PolyNode& node = *m_polyNodes.Childs[i];
-      if (node.m_endtype == etClosedLine && !Orientation(node.Contour))
+      if (node.m_endtype == EndType::ClosedLine && !Orientation(node.Contour))
         ReversePath(node.Contour);
     }
   }
@@ -3892,10 +3892,10 @@ void ClipperOffset::Execute(Paths& solution, double delta)
   
   //now clean up 'corners' ...
   Clipper clpr;
-  clpr.AddPaths(m_destPolys, ptSubject, true);
+  clpr.AddPaths(m_destPolys, PolyType::Subject, true);
   if (delta > 0)
   {
-    clpr.Execute(ctUnion, solution, pftPositive, pftPositive);
+    clpr.Execute(ClipType::Union, solution, PolyFillType::Positive, PolyFillType::Positive);
   }
   else
   {
@@ -3906,9 +3906,9 @@ void ClipperOffset::Execute(Paths& solution, double delta)
     outer[2] = IntPoint(r.right + 10, r.top - 10);
     outer[3] = IntPoint(r.left - 10, r.top - 10);
 
-    clpr.AddPath(outer, ptSubject, true);
+    clpr.AddPath(outer, PolyType::Subject, true);
     clpr.ReverseSolution(true);
-    clpr.Execute(ctUnion, solution, pftNegative, pftNegative);
+    clpr.Execute(ClipType::Union, solution, PolyFillType::Negative, PolyFillType::Negative);
     if (solution.size() > 0) solution.erase(solution.begin());
   }
 }
@@ -3922,10 +3922,10 @@ void ClipperOffset::Execute(PolyTree& solution, double delta)
 
   //now clean up 'corners' ...
   Clipper clpr;
-  clpr.AddPaths(m_destPolys, ptSubject, true);
+  clpr.AddPaths(m_destPolys, PolyType::Subject, true);
   if (delta > 0)
   {
-    clpr.Execute(ctUnion, solution, pftPositive, pftPositive);
+    clpr.Execute(ClipType::Union, solution, PolyFillType::Positive, PolyFillType::Positive);
   }
   else
   {
@@ -3936,9 +3936,9 @@ void ClipperOffset::Execute(PolyTree& solution, double delta)
     outer[2] = IntPoint(r.right + 10, r.top - 10);
     outer[3] = IntPoint(r.left - 10, r.top - 10);
 
-    clpr.AddPath(outer, ptSubject, true);
+    clpr.AddPath(outer, PolyType::Subject, true);
     clpr.ReverseSolution(true);
-    clpr.Execute(ctUnion, solution, pftNegative, pftNegative);
+    clpr.Execute(ClipType::Union, solution, PolyFillType::Negative, PolyFillType::Negative);
     //remove the outer PolyNode rectangle ...
     if (solution.ChildCount() == 1 && solution.Childs[0]->ChildCount() > 0)
     {
@@ -3967,7 +3967,7 @@ void ClipperOffset::DoOffset(double delta)
     for (int i = 0; i < m_polyNodes.ChildCount(); i++)
     {
       PolyNode& node = *m_polyNodes.Childs[i];
-      if (node.m_endtype == etClosedPolygon)
+      if (node.m_endtype == EndType::ClosedPolygon)
         m_destPolys.push_back(node.Contour);
     }
     return;
@@ -3998,13 +3998,13 @@ void ClipperOffset::DoOffset(double delta)
     m_srcPoly = node.Contour;
 
     int len = (int)m_srcPoly.size();
-    if (len == 0 || (delta <= 0 && (len < 3 || node.m_endtype != etClosedPolygon)))
+    if (len == 0 || (delta <= 0 && (len < 3 || node.m_endtype != EndType::ClosedPolygon)))
         continue;
 
     m_destPoly.clear();
     if (len == 1)
     {
-      if (node.m_jointype == jtRound)
+      if (node.m_jointype == JoinType::Round)
       {
         double X = 1.0, Y = 0.0;
         for (cInt j = 1; j <= steps; j++)
@@ -4038,19 +4038,19 @@ void ClipperOffset::DoOffset(double delta)
     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)
+    if (node.m_endtype == EndType::ClosedLine || node.m_endtype == EndType::ClosedPolygon)
       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)
+    if (node.m_endtype == EndType::ClosedPolygon)
     {
       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)
+    else if (node.m_endtype == EndType::ClosedLine)
     {
       int k = len - 1;
       for (int j = 0; j < len; ++j)
@@ -4074,7 +4074,7 @@ void ClipperOffset::DoOffset(double delta)
         OffsetPoint(j, k, node.m_jointype);
 
       IntPoint pt1;
-      if (node.m_endtype == etOpenButt)
+      if (node.m_endtype == EndType::OpenButt)
       {
         int j = len - 1;
         pt1 = IntPoint((cInt)Round(m_srcPoly[j].X + m_normals[j].X *
@@ -4090,7 +4090,7 @@ void ClipperOffset::DoOffset(double delta)
         k = len - 2;
         m_sinA = 0;
         m_normals[j] = DoublePoint(-m_normals[j].X, -m_normals[j].Y);
-        if (node.m_endtype == etOpenSquare)
+        if (node.m_endtype == EndType::OpenSquare)
           DoSquare(j, k);
         else
           DoRound(j, k);
@@ -4104,7 +4104,7 @@ void ClipperOffset::DoOffset(double delta)
       k = len - 1;
       for (int j = k - 1; j > 0; --j) OffsetPoint(j, k, node.m_jointype);
 
-      if (node.m_endtype == etOpenButt)
+      if (node.m_endtype == EndType::OpenButt)
       {
         pt1 = IntPoint((cInt)Round(m_srcPoly[0].X - m_normals[0].X * delta),
           (cInt)Round(m_srcPoly[0].Y - m_normals[0].Y * delta));
@@ -4117,7 +4117,7 @@ void ClipperOffset::DoOffset(double delta)
       {
         k = 1;
         m_sinA = 0;
-        if (node.m_endtype == etOpenSquare)
+        if (node.m_endtype == EndType::OpenSquare)
           DoSquare(0, 1);
         else
           DoRound(0, 1);
@@ -4158,15 +4158,15 @@ void ClipperOffset::OffsetPoint(int j, int& k, JoinType jointype)
   else
     switch (jointype)
     {
-      case jtMiter:
+      case JoinType::Miter:
         {
           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;
+      case JoinType::Square: DoSquare(j, k); break;
+      case JoinType::Round: DoRound(j, k); break;
     }
   k = j;
 }
@@ -4297,8 +4297,8 @@ void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillTyp
 {
   Clipper c;
   c.StrictlySimple(true);
-  c.AddPath(in_poly, ptSubject, true);
-  c.Execute(ctUnion, out_polys, fillType, fillType);
+  c.AddPath(in_poly, PolyType::Subject, true);
+  c.Execute(ClipType::Union, out_polys, fillType, fillType);
 }
 //------------------------------------------------------------------------------
 
@@ -4306,8 +4306,8 @@ void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fill
 {
   Clipper c;
   c.StrictlySimple(true);
-  c.AddPaths(in_polys, ptSubject, true);
-  c.Execute(ctUnion, out_polys, fillType, fillType);
+  c.AddPaths(in_polys, PolyType::Subject, true);
+  c.Execute(ClipType::Union, out_polys, fillType, fillType);
 }
 //------------------------------------------------------------------------------
 
@@ -4329,10 +4329,10 @@ double DistanceFromLineSqrd(
   const IntPoint& pt, const IntPoint& ln1, const IntPoint& ln2)
 {
   //The equation of a line in general form (Ax + By + C = 0)
-  //given 2 points (x�,y�) & (x�,y�) is ...
-  //(y� - y�)x + (x� - x�)y + (y� - y�)x� - (x� - x�)y� = 0
-  //A = (y� - y�); B = (x� - x�); C = (y� - y�)x� - (x� - x�)y�
-  //perpendicular distance of point (x�,y�) = (Ax� + By� + C)/Sqrt(A� + B�)
+  //given 2 points (x¹,y¹) & (x²,y²) is ...
+  //(y¹ - y²)x + (x² - x¹)y + (y² - y¹)x¹ - (x² - x¹)y¹ = 0
+  //A = (y¹ - y²); B = (x² - x¹); C = (y² - y¹)x¹ - (x² - x¹)y¹
+  //perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²)
   //see http://en.wikipedia.org/wiki/Perpendicular_distance
   double A = double(ln1.Y - ln2.Y);
   double B = double(ln2.X - ln1.X);
@@ -4515,8 +4515,8 @@ void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool p
 {
   Minkowski(pattern, path, solution, true, pathIsClosed);
   Clipper c;
-  c.AddPaths(solution, ptSubject, true);
-  c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
+  c.AddPaths(solution, PolyType::Subject, true);
+  c.Execute(ClipType::Union, solution, PolyFillType::NonZero, PolyFillType::NonZero);
 }
 //------------------------------------------------------------------------------
 
@@ -4536,15 +4536,15 @@ void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool
   {
     Paths tmp;
     Minkowski(pattern, paths[i], tmp, true, pathIsClosed);
-    c.AddPaths(tmp, ptSubject, true);
+    c.AddPaths(tmp, PolyType::Subject, true);
     if (pathIsClosed)
     {
       Path tmp2;
       TranslatePath(paths[i], tmp2, pattern[0]);
-      c.AddPath(tmp2, ptClip, true);
+      c.AddPath(tmp2, PolyType::Clip, true);
     }
   }
-    c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
+    c.Execute(ClipType::Union, solution, PolyFillType::NonZero, PolyFillType::NonZero);
 }
 //------------------------------------------------------------------------------
 
@@ -4552,18 +4552,18 @@ void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution)
 {
   Minkowski(poly1, poly2, solution, false, true);
   Clipper c;
-  c.AddPaths(solution, ptSubject, true);
-  c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
+  c.AddPaths(solution, PolyType::Subject, true);
+  c.Execute(ClipType::Union, solution, PolyFillType::NonZero, PolyFillType::NonZero);
 }
 //------------------------------------------------------------------------------
 
-enum NodeType {ntAny, ntOpen, ntClosed};
+enum class NodeType {Any, Open, Closed};
 
 void AddPolyNodeToPaths(const PolyNode& polynode, NodeType nodetype, Paths& paths)
 {
   bool match = true;
-  if (nodetype == ntClosed) match = !polynode.IsOpen();
-  else if (nodetype == ntOpen) return;
+  if (nodetype == NodeType::Closed) match = !polynode.IsOpen();
+  else if (nodetype == NodeType::Open) return;
 
   if (!polynode.Contour.empty() && match)
     paths.push_back(polynode.Contour);
@@ -4576,7 +4576,7 @@ void PolyTreeToPaths(const PolyTree& polytree, Paths& paths)
 {
   paths.resize(0); 
   paths.reserve(polytree.Total());
-  AddPolyNodeToPaths(polytree, ntAny, paths);
+  AddPolyNodeToPaths(polytree, NodeType::Any, paths);
 }
 //------------------------------------------------------------------------------
 
@@ -4584,7 +4584,7 @@ void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths)
 {
   paths.resize(0); 
   paths.reserve(polytree.Total());
-  AddPolyNodeToPaths(polytree, ntClosed, paths);
+  AddPolyNodeToPaths(polytree, NodeType::Closed, paths);
 }
 //------------------------------------------------------------------------------
 
diff --git a/src/Lib/terragear/clipper.hpp b/src/Lib/terragear/clipper.hpp
index 5a19617b..e0253e0d 100644
--- a/src/Lib/terragear/clipper.hpp
+++ b/src/Lib/terragear/clipper.hpp
@@ -40,7 +40,7 @@
 //improve performance but coordinate values are limited to the range +/- 46340
 //#define use_int32
 
-//use_xyz: adds a Z member to IntPoint. Adds a minor cost to perfomance.
+//use_xyz: adds a Z member to IntPoint. Adds a minor cost to performance.
 //#define use_xyz
 
 //use_lines: Enables line clipping. Adds a very minor cost to performance.
@@ -61,13 +61,13 @@
 
 namespace ClipperLib {
 
-enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
-enum PolyType { ptSubject, ptClip };
+enum class ClipType { Intersection, Union, Difference, Xor };
+enum class PolyType { Subject, Clip };
 //By far the most widely used winding rules for polygon filling are
 //EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
 //Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
 //see http://glprogramming.com/red/chapter11.html
-enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
+enum class PolyFillType { EvenOdd, NonZero, Positive, Negative };
 
 #ifdef use_int32
   typedef int cInt;
@@ -126,9 +126,9 @@ struct DoublePoint
 typedef void (*ZFillCallback)(IntPoint& e1bot, IntPoint& e1top, IntPoint& e2bot, IntPoint& e2top, IntPoint& pt);
 #endif
 
-enum InitOptions {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4};
-enum JoinType {jtSquare, jtRound, jtMiter};
-enum EndType {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound};
+enum class InitOptions {ReverseSolution = 1, StrictlySimple = 2, PreserveCollinear = 4};
+enum class JoinType {Square, Round, Miter};
+enum class EndType {ClosedPolygon, ClosedLine, OpenButt, OpenSquare, OpenRound};
 
 class PolyNode;
 typedef std::vector< PolyNode* > PolyNodes;
@@ -174,9 +174,9 @@ bool Orientation(const Path &poly);
 double Area(const Path &poly);
 int PointInPolygon(const IntPoint &pt, const Path &path);
 
-void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
-void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
-void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd);
+void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = PolyFillType::EvenOdd);
+void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = PolyFillType::EvenOdd);
+void SimplifyPolygons(Paths &polys, PolyFillType fillType = PolyFillType::EvenOdd);
 
 void CleanPolygon(const Path& in_poly, Path& out_poly, double distance = 1.415);
 void CleanPolygon(Path& poly, double distance = 1.415);
@@ -197,7 +197,7 @@ void ReversePaths(Paths& p);
 struct IntRect { cInt left; cInt top; cInt right; cInt bottom; };
 
 //enums that are used internally ...
-enum EdgeSide { esLeft = 1, esRight = 2};
+enum class EdgeSide { Left = 1, Right = 2};
 
 //forward declarations (for stuff used internally) ...
 struct TEdge;
@@ -266,14 +266,14 @@ public:
   Clipper(int initOptions = 0);
   bool Execute(ClipType clipType,
       Paths &solution,
-      PolyFillType fillType = pftEvenOdd);
+      PolyFillType fillType = PolyFillType::EvenOdd);
   bool Execute(ClipType clipType,
       Paths &solution,
       PolyFillType subjFillType,
       PolyFillType clipFillType);
   bool Execute(ClipType clipType,
       PolyTree &polytree,
-      PolyFillType fillType = pftEvenOdd);
+      PolyFillType fillType = PolyFillType::EvenOdd);
   bool Execute(ClipType clipType,
       PolyTree &polytree,
       PolyFillType subjFillType,
diff --git a/src/Lib/terragear/tg_accumulator.cxx b/src/Lib/terragear/tg_accumulator.cxx
index 39b8996b..85962ba8 100644
--- a/src/Lib/terragear/tg_accumulator.cxx
+++ b/src/Lib/terragear/tg_accumulator.cxx
@@ -35,7 +35,7 @@ tgPolygon tgAccumulator::Diff( const tgContour& subject )
         ClipperLib::Clipper c;
         c.Clear();
 
-        c.AddPath(clipper_subject, ClipperLib::ptSubject, true);
+        c.AddPath(clipper_subject, ClipperLib::PolyType::Subject, true);
 
         // clip result against all polygons in the accum that intersect our bb
         for (unsigned int i=0; i < accum.size(); i++) {
@@ -44,14 +44,14 @@ tgPolygon tgAccumulator::Diff( const tgContour& subject )
             if ( box2.intersects(box1) )
             {
                 if ( num_hits < max_hits ) {
-                    c.AddPaths(accum[i], ClipperLib::ptClip, true);
+                    c.AddPaths(accum[i], ClipperLib::PolyType::Clip, true);
                     num_hits++;
                 }
             }
         }
 
         if (num_hits) {
-            if ( !c.Execute(ClipperLib::ctDifference, clipper_result, ClipperLib::pftNonZero, ClipperLib::pftNonZero) ) {
+            if ( !c.Execute(ClipperLib::ClipType::Difference, clipper_result, ClipperLib::PolyFillType::NonZero, ClipperLib::PolyFillType::NonZero) ) {
                 SG_LOG(SG_GENERAL, SG_ALERT, "Diff With Accumulator returned FALSE - reducing accumulator" );
                 max_hits = num_hits-1;
 
@@ -100,7 +100,7 @@ tgPolygon tgAccumulator::Diff( const tgPolygon& subject )
         ClipperLib::Clipper c;
         c.Clear();
 
-        c.AddPaths(clipper_subject, ClipperLib::ptSubject, true);
+        c.AddPaths(clipper_subject, ClipperLib::PolyType::Subject, true);
 
         // clip result against all polygons in the accum that intersect our bb
         for (unsigned int i=0; i < accum.size(); i++) {
@@ -108,13 +108,13 @@ tgPolygon tgAccumulator::Diff( const tgPolygon& subject )
 
             if ( box2.intersects(box1) )
             {
-                c.AddPaths(accum[i], ClipperLib::ptClip, true);
+                c.AddPaths(accum[i], ClipperLib::PolyType::Clip, true);
                 num_hits++;
             }
         }
 
         if (num_hits) {
-            if ( !c.Execute(ClipperLib::ctDifference, clipper_result, ClipperLib::pftNonZero, ClipperLib::pftNonZero) ) {
+            if ( !c.Execute(ClipperLib::ClipType::Difference, clipper_result, ClipperLib::PolyFillType::NonZero, ClipperLib::PolyFillType::NonZero) ) {
                 SG_LOG(SG_GENERAL, SG_ALERT, "Diff With Accumulator returned FALSE - reducing accumulator" );
                 max_hits = num_hits-1;
 
@@ -189,10 +189,10 @@ void tgAccumulator::ToShapefiles( const std::string& path, const std::string& la
             c.Clear();
 
             for ( unsigned int i=0; i<accum.size(); i++ ) {
-                c.AddPaths(accum[i], ClipperLib::ptSubject, true);
+                c.AddPaths(accum[i], ClipperLib::PolyType::Subject, true);
             }
         
-            if ( c.Execute( ClipperLib::ctUnion, clipper_result, ClipperLib::pftNonZero, ClipperLib::pftNonZero) ) {
+            if ( c.Execute( ClipperLib::ClipType::Union, clipper_result, ClipperLib::PolyFillType::NonZero, ClipperLib::PolyFillType::NonZero) ) {
                 tgShapefile::FromClipper( clipper_result, path, layer_prefix, "accum" );
             } else {
                 SG_LOG(SG_GENERAL, SG_ALERT, "Clipper Failure in tgAccumulator::ToShapefiles()" );
@@ -221,10 +221,10 @@ void tgAccumulator::ToClipperfiles( const std::string& path, const std::string&
             c.Clear();
             
             for ( unsigned int i=0; i<accum.size(); i++ ) {
-                c.AddPaths(accum[i], ClipperLib::ptSubject, true);
+                c.AddPaths(accum[i], ClipperLib::PolyType::Subject, true);
             }
             
-            if ( c.Execute( ClipperLib::ctUnion, clipper_result, ClipperLib::pftNonZero, ClipperLib::pftNonZero) ) {
+            if ( c.Execute( ClipperLib::ClipType::Union, clipper_result, ClipperLib::PolyFillType::NonZero, ClipperLib::PolyFillType::NonZero) ) {
                 sprintf( filename, "%s/%s", path.c_str(), layer_prefix.c_str() );
                 
                 file.open (filename);
diff --git a/src/Lib/terragear/tg_contour.cxx b/src/Lib/terragear/tg_contour.cxx
index f5d22974..7738072a 100644
--- a/src/Lib/terragear/tg_contour.cxx
+++ b/src/Lib/terragear/tg_contour.cxx
@@ -469,9 +469,9 @@ tgPolygon tgContour::Union( const tgContour& subject, tgPolygon& clip )
 
     ClipperLib::Clipper c;
     c.Clear();
-    c.AddPath(clipper_subject, ClipperLib::ptSubject, true);
-    c.AddPaths(clipper_clip, ClipperLib::ptClip, true);
-    c.Execute(ClipperLib::ctUnion, clipper_result, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd);
+    c.AddPath(clipper_subject, ClipperLib::PolyType::Subject, true);
+    c.AddPaths(clipper_clip, ClipperLib::PolyType::Clip, true);
+    c.Execute(ClipperLib::ClipType::Union, clipper_result, ClipperLib::PolyFillType::EvenOdd, ClipperLib::PolyFillType::EvenOdd);
 
     result = tgPolygon::FromClipper( clipper_result );
     result = tgPolygon::AddColinearNodes( result, all_nodes );
@@ -501,9 +501,9 @@ tgPolygon tgContour::Diff( const tgContour& subject, tgPolygon& clip )
 
     ClipperLib::Clipper c;
     c.Clear();
-    c.AddPath(clipper_subject, ClipperLib::ptSubject, true);
-    c.AddPaths(clipper_clip, ClipperLib::ptClip, true);
-    c.Execute(ClipperLib::ctDifference, clipper_result, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd);
+    c.AddPath(clipper_subject, ClipperLib::PolyType::Subject, true);
+    c.AddPaths(clipper_clip, ClipperLib::PolyType::Clip, true);
+    c.Execute(ClipperLib::ClipType::Difference, clipper_result, ClipperLib::PolyFillType::EvenOdd, ClipperLib::PolyFillType::EvenOdd);
 
     result = tgPolygon::FromClipper( clipper_result );
     result = tgPolygon::AddColinearNodes( result, all_nodes );
@@ -531,9 +531,9 @@ tgPolygon tgContour::Intersect( const tgContour& subject, const tgContour& clip
 
     ClipperLib::Clipper c;
     c.Clear();
-    c.AddPath(clipper_subject, ClipperLib::ptSubject, true);
-    c.AddPath(clipper_clip, ClipperLib::ptClip, true);
-    c.Execute(ClipperLib::ctIntersection, clipper_result, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd);
+    c.AddPath(clipper_subject, ClipperLib::PolyType::Subject, true);
+    c.AddPath(clipper_clip, ClipperLib::PolyType::Clip, true);
+    c.Execute(ClipperLib::ClipType::Intersection, clipper_result, ClipperLib::PolyFillType::EvenOdd, ClipperLib::PolyFillType::EvenOdd);
 
     result = tgPolygon::FromClipper( clipper_result );
     result = tgPolygon::AddColinearNodes( result, all_nodes );
@@ -894,7 +894,7 @@ tgContour tgContour::Expand( const tgContour& subject, double offset )
     clipper_src = tgPolygon::ToClipper( poly );
 
     ClipperLib::ClipperOffset co(2.0, 2.0);
-    co.AddPaths(clipper_src, ClipperLib::jtSquare, ClipperLib::etClosedPolygon); 
+    co.AddPaths(clipper_src, ClipperLib::JoinType::Square, ClipperLib::EndType::ClosedPolygon);
     co.Execute(clipper_dst, Dist_ToClipper(offset) );
   
     poly = tgPolygon::FromClipper( clipper_dst );
diff --git a/src/Lib/terragear/tg_polygon.cxx b/src/Lib/terragear/tg_polygon.cxx
index 535f7ef3..555bbaec 100644
--- a/src/Lib/terragear/tg_polygon.cxx
+++ b/src/Lib/terragear/tg_polygon.cxx
@@ -54,7 +54,7 @@ tgPolygon tgPolygon::Expand( const tgPolygon& subject, double offset )
     tgPolygon result;
 
     ClipperLib::ClipperOffset co(2.0, 2.0);
-    co.AddPaths(clipper_src, ClipperLib::jtSquare, ClipperLib::etClosedPolygon); 
+    co.AddPaths(clipper_src, ClipperLib::JoinType::Square, ClipperLib::EndType::ClosedPolygon);
     co.Execute(clipper_dst, Dist_ToClipper(offset) );
 
     result = tgPolygon::FromClipper( clipper_dst );
diff --git a/src/Lib/terragear/tg_polygon_clean.cxx b/src/Lib/terragear/tg_polygon_clean.cxx
index 52fd0e51..68509f74 100644
--- a/src/Lib/terragear/tg_polygon_clean.cxx
+++ b/src/Lib/terragear/tg_polygon_clean.cxx
@@ -117,10 +117,10 @@ tgPolygon tgPolygon::StripHoles( const tgPolygon& subject )
     for ( unsigned int i = 0; i < subject.Contours(); i++ ) {
         tgContour contour = subject.GetContour( i );
         if ( !contour.GetHole() ) {
-            c.AddPath( tgContour::ToClipper( contour ), ClipperLib::ptClip, true );
+            c.AddPath( tgContour::ToClipper( contour ), ClipperLib::PolyType::Clip, true );
         }
     }
-    c.Execute(ClipperLib::ctUnion, clipper_result, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd);
+    c.Execute(ClipperLib::ClipType::Union, clipper_result, ClipperLib::PolyFillType::EvenOdd, ClipperLib::PolyFillType::EvenOdd);
 
     result = tgPolygon::FromClipper( clipper_result );
     result = tgPolygon::AddColinearNodes( result, all_nodes );
diff --git a/src/Lib/terragear/tg_polygon_clip.cxx b/src/Lib/terragear/tg_polygon_clip.cxx
index 359f9ef5..70b93380 100644
--- a/src/Lib/terragear/tg_polygon_clip.cxx
+++ b/src/Lib/terragear/tg_polygon_clip.cxx
@@ -47,9 +47,9 @@ tgPolygon tgPolygon::Union( const tgPolygon& subject, tgPolygon& clip )
 
     ClipperLib::Clipper c;
     c.Clear();
-    c.AddPaths(clipper_subject, ClipperLib::ptSubject, true);
-    c.AddPaths(clipper_clip, ClipperLib::ptClip, true);
-    c.Execute(ClipperLib::ctUnion, clipper_result, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd);
+    c.AddPaths(clipper_subject, ClipperLib::PolyType::Subject, true);
+    c.AddPaths(clipper_clip, ClipperLib::PolyType::Clip, true);
+    c.Execute(ClipperLib::ClipType::Union, clipper_result, ClipperLib::PolyFillType::EvenOdd, ClipperLib::PolyFillType::EvenOdd);
 
     if ( clipper_dump ) {
         dmpfile.open ("result.txt");
@@ -87,9 +87,9 @@ tgPolygon tgPolygon::Union( const tgpolygon_list& polys )
     c.Clear();
     for (unsigned int i=0; i<polys.size(); i++) {
         ClipperLib::Paths clipper_clip = tgPolygon::ToClipper( polys[i] );
-        c.AddPaths(clipper_clip, ClipperLib::ptSubject, true);
+        c.AddPaths(clipper_clip, ClipperLib::PolyType::Subject, true);
     }
-    c.Execute(ClipperLib::ctUnion, clipper_result, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
+    c.Execute(ClipperLib::ClipType::Union, clipper_result, ClipperLib::PolyFillType::NonZero, ClipperLib::PolyFillType::NonZero);
 
     result = tgPolygon::FromClipper( clipper_result );
     result = tgPolygon::AddColinearNodes( result, all_nodes );
@@ -121,9 +121,9 @@ tgPolygon tgPolygon::Diff( const tgPolygon& subject, tgPolygon& clip )
 
     ClipperLib::Clipper c;
     c.Clear();
-    c.AddPaths(clipper_subject, ClipperLib::ptSubject, true);
-    c.AddPaths(clipper_clip, ClipperLib::ptClip, true);
-    c.Execute(ClipperLib::ctDifference, clipper_result, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd);
+    c.AddPaths(clipper_subject, ClipperLib::PolyType::Subject, true);
+    c.AddPaths(clipper_clip, ClipperLib::PolyType::Clip, true);
+    c.Execute(ClipperLib::ClipType::Difference, clipper_result, ClipperLib::PolyFillType::EvenOdd, ClipperLib::PolyFillType::EvenOdd);
 
     result = tgPolygon::FromClipper( clipper_result );
     result = tgPolygon::AddColinearNodes( result, all_nodes );
@@ -160,9 +160,9 @@ tgPolygon tgPolygon::Intersect( const tgPolygon& subject, const tgPolygon& clip
 
     ClipperLib::Clipper c;
     c.Clear();
-    c.AddPaths(clipper_subject, ClipperLib::ptSubject, true);
-    c.AddPaths(clipper_clip, ClipperLib::ptClip, true);
-    c.Execute(ClipperLib::ctIntersection, clipper_result, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd);
+    c.AddPaths(clipper_subject, ClipperLib::PolyType::Subject, true);
+    c.AddPaths(clipper_clip, ClipperLib::PolyType::Clip, true);
+    c.Execute(ClipperLib::ClipType::Intersection, clipper_result, ClipperLib::PolyFillType::EvenOdd, ClipperLib::PolyFillType::EvenOdd);
 
     result = tgPolygon::FromClipper( clipper_result );
     result = tgPolygon::AddColinearNodes( result, all_nodes );
@@ -238,9 +238,9 @@ tgPolygon tgTriangle::Intersect( const tgTriangle& subject, const tgTriangle& cl
 
     ClipperLib::Clipper c;
     c.Clear();
-    c.AddPath(clipper_subject, ClipperLib::ptSubject, true);
-    c.AddPath(clipper_clip, ClipperLib::ptClip, true);
-    c.Execute(ClipperLib::ctIntersection, clipper_result, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd);
+    c.AddPath(clipper_subject, ClipperLib::PolyType::Subject, true);
+    c.AddPath(clipper_clip, ClipperLib::PolyType::Clip, true);
+    c.Execute(ClipperLib::ClipType::Intersection, clipper_result, ClipperLib::PolyFillType::EvenOdd, ClipperLib::PolyFillType::EvenOdd);
 
     result = tgPolygon::FromClipper( clipper_result );
     result = tgPolygon::AddColinearNodes( result, all_nodes );
diff --git a/src/Prep/DemChop/srtmchop.cxx b/src/Prep/DemChop/srtmchop.cxx
index 57f3bad2..b1ea4016 100644
--- a/src/Prep/DemChop/srtmchop.cxx
+++ b/src/Prep/DemChop/srtmchop.cxx
@@ -71,7 +71,7 @@ public:
     virtual short height( int x, int y ) const { return data[x][y]; }
 
 private:
-    enum LoadKind { BottomLeft, BottomRight, TopLeft, TopRight };
+    enum class LoadKind { BottomLeft, BottomRight, TopLeft, TopRight };
     TGSrtmTiff( const SGPath &file, LoadKind lk );
     bool pos_from_name( string name, string &pfx, int &x, int &y );
 
@@ -87,7 +87,7 @@ private:
 };
 
 TGSrtmTiff::TGSrtmTiff( const SGPath &file ) {
-    lkind = BottomLeft;
+    lkind = LoadKind::BottomLeft;
     tif = 0;
     data = new short int[MAX_HGT_SIZE][MAX_HGT_SIZE];
     output_data = new short int[MAX_HGT_SIZE][MAX_HGT_SIZE];
@@ -98,14 +98,14 @@ TGSrtmTiff::TGSrtmTiff( const SGPath &file, LoadKind lk ) {
     lkind = lk;
     tif = 0;
     output_data = 0;
-    if ( lkind == BottomLeft ) {
+    if ( lkind == LoadKind::BottomLeft ) {
         data = new short int[MAX_HGT_SIZE][MAX_HGT_SIZE];
         output_data = new short int[MAX_HGT_SIZE][MAX_HGT_SIZE];
-    } else if ( lkind == TopLeft ) {
+    } else if ( lkind == LoadKind::TopLeft ) {
         data = new short int[MAX_HGT_SIZE][MAX_HGT_SIZE];
-    } else if ( lkind == BottomRight ) {
+    } else if ( lkind == LoadKind::BottomRight ) {
         data = new short int[1][MAX_HGT_SIZE];
-    } else /* if ( lkind == TopRight ) */ {
+    } else /* if ( lkind == LoadKind::TopRight ) */ {
         data = new short int[1][MAX_HGT_SIZE];
     }
     TGSrtmTiff::open( file );
@@ -198,7 +198,7 @@ bool TGSrtmTiff::load() {
     TIFFGetField( tif, TIFFTAG_DATATYPE, &dataType );
 
     tdata_t buf = _TIFFmalloc( TIFFScanlineSize( tif ) );
-    if ( lkind == BottomLeft ) {
+    if ( lkind == LoadKind::BottomLeft ) {
         uint32 row = 0;
         for ( ; row < h; row++ ) {
             TIFFReadScanline( tif, buf, row );
@@ -231,7 +231,7 @@ bool TGSrtmTiff::load() {
             SGPath f = dir;
             f.append( name.str() );
             if ( f.exists() ) {
-                TGSrtmTiff s( f.str(), BottomRight );
+                TGSrtmTiff s( f.str(), LoadKind::BottomRight );
                 s.load();
                 s.close();
                 for ( int i = 0; i < 6000; ++i ) {
@@ -249,7 +249,7 @@ bool TGSrtmTiff::load() {
             SGPath f = dir;
             f.append( name.str() );
             if ( f.exists() ) {
-                TGSrtmTiff s( f.str(), TopLeft );
+                TGSrtmTiff s( f.str(), LoadKind::TopLeft );
                 s.load();
                 s.close();
                 for ( int i = 0; i < 6000; ++i ) {
@@ -271,7 +271,7 @@ bool TGSrtmTiff::load() {
             SGPath f = dir;
             f.append( name.str() );
             if ( f.exists() ) {
-                TGSrtmTiff s( f.str(), TopRight );
+                TGSrtmTiff s( f.str(), LoadKind::TopRight );
                 s.load();
                 s.close();
                 data[6000][6000] = s.data[0][0];
@@ -281,7 +281,7 @@ bool TGSrtmTiff::load() {
         } else {
             data[6000][6000] = data[6000][6000-1];
         }
-    } else if ( lkind == TopLeft ) {
+    } else if ( lkind == LoadKind::TopLeft ) {
         TIFFReadScanline( tif, buf, 0 );
         uint32 col = 0;
         for ( ; col < w; col++ ) {
@@ -293,7 +293,7 @@ bool TGSrtmTiff::load() {
         for ( ; col < 6000; col++ ) {
             data[col][0] = 0;
         }
-    } else if ( lkind == BottomRight ) {
+    } else if ( lkind == LoadKind::BottomRight ) {
         uint32 row = 0;
         for ( ; row < h; row++ ) {
             TIFFReadScanline( tif, buf, row );
@@ -305,7 +305,7 @@ bool TGSrtmTiff::load() {
         for ( ; row < 6000; row++ ) {
             data[0][6000-1-row] = 0;
         }
-    } else /* if ( lkind == TopRight ) */ {
+    } else /* if ( lkind == LoadKind::TopRight ) */ {
         if ( h == 6000 ) {
             TIFFReadScanline( tif, buf, h-1 );
             int16 v = ((int16*)buf)[0];