From 4d444d38a4a981de2c177ecf975ff1535c4930e9 Mon Sep 17 00:00:00 2001
From: visose <vicente@visose.com>
Date: Mon, 2 Jul 2018 20:41:00 +0100
Subject: [PATCH] Second commit.

---
 Extensions.sln                                |    2 +-
 Extensions/Extensions.csproj                  |  116 +-
 Extensions/Extensions.ruleset                 |   70 +
 Extensions/FodyWeavers.xml                    |    4 +
 Extensions/Libraries/SimplexNoise.cs          |  151 +
 Extensions/Libraries/clipper.cs               | 4913 +++++++++++++++++
 Extensions/Model/Discrete/Assembly.cs         |  209 +
 Extensions/Model/Discrete/CurveSnap.cs        |   81 +
 Extensions/Model/Discrete/VoxelTiles.cs       |  304 +
 Extensions/Model/Document/Cache.cs            |   50 +
 Extensions/Model/Document/Debug.cs            |   56 +
 Extensions/Model/Geometry/BallPivot.cs        |  139 +
 Extensions/Model/Geometry/MeshPipe.cs         |  336 ++
 Extensions/Model/Geometry/PolygonFill.cs      |   64 +
 Extensions/Model/Geometry/Remesher.cs         |  121 +
 Extensions/Model/Geometry/Slicer.cs           |   64 +
 Extensions/Model/Regions/Region.cs            |   71 +
 Extensions/Model/Regions/StraightSkeleton.cs  |  163 +
 .../Model/Rendering/RenderExtensions.cs       |   12 +-
 .../DifferentialGrowth/DifferentialGrowth.cs  |  166 +
 .../Simulations/DifferentialGrowth/Force.cs   |   44 +
 .../DifferentialGrowth/Particle.cs            |  156 +
 .../Simulations/DifferentialGrowth/Spring.cs  |   72 +
 Extensions/Model/Spatial/BucketSearch.cs      |  317 ++
 Extensions/Model/Spatial/Octree.cs            |  123 +
 Extensions/Model/Spatial/Primitives.cs        |   78 +
 Extensions/Model/Toolpaths/CSVConverter.cs    |  140 +
 Extensions/Model/Toolpaths/Column.cs          |  231 +
 .../SpatialExtrusion/SpatialAttributes.cs     |    9 +-
 .../SpatialExtrusion/SpatialExtrusion.cs      |   40 +-
 .../Toolpaths/SpatialExtrusion/Vertex.cs      |   45 +-
 Extensions/Model/Util.cs                      |  153 +
 Extensions/Properties/AssemblyInfo.cs         |   61 +-
 Extensions/Properties/Resources.Designer.cs   |  122 +-
 Extensions/Properties/Resources.resx          |   36 +
 Extensions/Resources/Icons/EyeDropper.png     |  Bin 0 -> 510 bytes
 Extensions/Resources/Icons/Fingerprint.png    |  Bin 0 -> 680 bytes
 Extensions/Resources/Icons/Graph.png          |  Bin 0 -> 439 bytes
 Extensions/Resources/Icons/Grid.png           |  Bin 0 -> 191 bytes
 Extensions/Resources/Icons/Layers.png         |  Bin 0 -> 709 bytes
 Extensions/Resources/Icons/Polyline.png       |  Bin 0 -> 541 bytes
 Extensions/Resources/Icons/Puzzle.png         |  Bin 0 -> 855 bytes
 Extensions/Resources/Icons/Triangle.png       |  Bin 0 -> 377 bytes
 Extensions/Resources/Icons/Virus.png          |  Bin 0 -> 769 bytes
 Extensions/Resources/Icons/Virus2.png         |  Bin 0 -> 547 bytes
 Extensions/Resources/Icons/Wave.png           |  Bin 0 -> 542 bytes
 Extensions/Resources/Robots.gha               |  Bin 0 -> 133632 bytes
 Extensions/Resources/StraightSkeletonNet.dll  |  Bin 0 -> 37888 bytes
 Extensions/View/Discrete/CurveSnap.cs         |   48 +
 Extensions/View/Discrete/UnityExport.cs       |   42 +
 Extensions/View/Discrete/VoxelTiles.cs        |  123 +
 .../View/Geometry/DifferentialGrowth.cs       |   77 +
 Extensions/View/Geometry/Remesher.cs          |   40 +
 Extensions/View/Geometry/StraightSkeleton.cs  |   42 +
 .../Rendering/BitmapFromSolidColoredMeshes.cs |    7 +-
 .../View/Rendering/BitmapFromVertexColors.cs  |    4 +-
 .../View/Rendering/MeshTextureCoords.cs       |    8 +-
 Extensions/View/Toolpaths/CSVConverter.cs     |   58 +
 Extensions/View/Toolpaths/LayeredToolpath.cs  |   54 +
 Extensions/View/Toolpaths/SpatialExtrusion.cs |   23 +-
 Extensions/View/Util.cs                       |   15 +
 Extensions/app.config                         |   11 +
 Extensions/packages.config                    |    8 +
 README.md                                     |   15 +-
 64 files changed, 9219 insertions(+), 75 deletions(-)
 create mode 100644 Extensions/Extensions.ruleset
 create mode 100644 Extensions/FodyWeavers.xml
 create mode 100644 Extensions/Libraries/SimplexNoise.cs
 create mode 100644 Extensions/Libraries/clipper.cs
 create mode 100644 Extensions/Model/Discrete/Assembly.cs
 create mode 100644 Extensions/Model/Discrete/CurveSnap.cs
 create mode 100644 Extensions/Model/Discrete/VoxelTiles.cs
 create mode 100644 Extensions/Model/Document/Cache.cs
 create mode 100644 Extensions/Model/Document/Debug.cs
 create mode 100644 Extensions/Model/Geometry/BallPivot.cs
 create mode 100644 Extensions/Model/Geometry/MeshPipe.cs
 create mode 100644 Extensions/Model/Geometry/PolygonFill.cs
 create mode 100644 Extensions/Model/Geometry/Remesher.cs
 create mode 100644 Extensions/Model/Geometry/Slicer.cs
 create mode 100644 Extensions/Model/Regions/Region.cs
 create mode 100644 Extensions/Model/Regions/StraightSkeleton.cs
 create mode 100644 Extensions/Model/Simulations/DifferentialGrowth/DifferentialGrowth.cs
 create mode 100644 Extensions/Model/Simulations/DifferentialGrowth/Force.cs
 create mode 100644 Extensions/Model/Simulations/DifferentialGrowth/Particle.cs
 create mode 100644 Extensions/Model/Simulations/DifferentialGrowth/Spring.cs
 create mode 100644 Extensions/Model/Spatial/BucketSearch.cs
 create mode 100644 Extensions/Model/Spatial/Octree.cs
 create mode 100644 Extensions/Model/Spatial/Primitives.cs
 create mode 100644 Extensions/Model/Toolpaths/CSVConverter.cs
 create mode 100644 Extensions/Model/Toolpaths/Column.cs
 create mode 100644 Extensions/Model/Util.cs
 create mode 100644 Extensions/Resources/Icons/EyeDropper.png
 create mode 100644 Extensions/Resources/Icons/Fingerprint.png
 create mode 100644 Extensions/Resources/Icons/Graph.png
 create mode 100644 Extensions/Resources/Icons/Grid.png
 create mode 100644 Extensions/Resources/Icons/Layers.png
 create mode 100644 Extensions/Resources/Icons/Polyline.png
 create mode 100644 Extensions/Resources/Icons/Puzzle.png
 create mode 100644 Extensions/Resources/Icons/Triangle.png
 create mode 100644 Extensions/Resources/Icons/Virus.png
 create mode 100644 Extensions/Resources/Icons/Virus2.png
 create mode 100644 Extensions/Resources/Icons/Wave.png
 create mode 100644 Extensions/Resources/Robots.gha
 create mode 100644 Extensions/Resources/StraightSkeletonNet.dll
 create mode 100644 Extensions/View/Discrete/CurveSnap.cs
 create mode 100644 Extensions/View/Discrete/UnityExport.cs
 create mode 100644 Extensions/View/Discrete/VoxelTiles.cs
 create mode 100644 Extensions/View/Geometry/DifferentialGrowth.cs
 create mode 100644 Extensions/View/Geometry/Remesher.cs
 create mode 100644 Extensions/View/Geometry/StraightSkeleton.cs
 create mode 100644 Extensions/View/Toolpaths/CSVConverter.cs
 create mode 100644 Extensions/View/Toolpaths/LayeredToolpath.cs
 create mode 100644 Extensions/View/Util.cs
 create mode 100644 Extensions/app.config
 create mode 100644 Extensions/packages.config

diff --git a/Extensions.sln b/Extensions.sln
index f07277d..f8a81b8 100644
--- a/Extensions.sln
+++ b/Extensions.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26228.9
+VisualStudioVersion = 15.0.26430.14
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Extensions", "Extensions\Extensions.csproj", "{66D4E86F-EC84-40C9-8E32-8CF8875C3FEB}"
 EndProject
diff --git a/Extensions/Extensions.csproj b/Extensions/Extensions.csproj
index a606e9a..c67c8c8 100644
--- a/Extensions/Extensions.csproj
+++ b/Extensions/Extensions.csproj
@@ -10,10 +10,12 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Extensions</RootNamespace>
     <AssemblyName>Extensions</AssemblyName>
-    <TargetFrameworkVersion>v4.7</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <IsWebBootstrapper>false</IsWebBootstrapper>
     <TargetFrameworkProfile />
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
     <DebugSymbols>true</DebugSymbols>
@@ -32,18 +34,32 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisRuleSet>Extensions.ruleset</CodeAnalysisRuleSet>
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject />
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Costura, Version=3.1.0.0, Culture=neutral, PublicKeyToken=9919ef960d84173d, processorArchitecture=MSIL">
+      <HintPath>..\packages\Costura.Fody.3.1.0\lib\net46\Costura.dll</HintPath>
+    </Reference>
+    <Reference Include="geometry3Sharp, Version=1.0.144.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\geometry3Sharp.1.0.144\lib\net45\geometry3Sharp.dll</HintPath>
+    </Reference>
     <Reference Include="GH_IO">
-      <HintPath>..\..\..\..\..\..\Program Files\Common Files\McNeel\Rhinoceros\5.0\Plug-ins\Grasshopper (b45a29b1-4343-4035-989e-044e8580d9cf)\0.9.76.0\GH_IO.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\Program Files\Rhino 6\Plug-ins\Grasshopper\GH_IO.dll</HintPath>
       <Private>False</Private>
     </Reference>
     <Reference Include="Grasshopper">
-      <HintPath>..\..\..\..\..\..\Program Files\Common Files\McNeel\Rhinoceros\5.0\Plug-ins\Grasshopper (b45a29b1-4343-4035-989e-044e8580d9cf)\0.9.76.0\Grasshopper.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\Program Files\Rhino 6\Plug-ins\Grasshopper\Grasshopper.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="MoreLinq, Version=3.0.0.0, Culture=neutral, PublicKeyToken=384d532d7e88985d, processorArchitecture=MSIL">
+      <HintPath>..\packages\morelinq.3.0.0\lib\net451\MoreLinq.dll</HintPath>
+    </Reference>
     <Reference Include="RhinoCommon">
-      <HintPath>..\..\..\..\..\..\Program Files\Rhinoceros 5 (64-bit)\System\RhinoCommon.dll</HintPath>
+      <HintPath>..\..\..\..\..\..\Program Files\Rhino 6\System\RhinoCommon.dll</HintPath>
       <Private>False</Private>
     </Reference>
     <Reference Include="Robots">
@@ -56,36 +72,84 @@
       <SpecificVersion>False</SpecificVersion>
       <Private>False</Private>
     </Reference>
+    <Reference Include="StraightSkeletonNet">
+      <HintPath>Resources\StraightSkeletonNet.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="System.Drawing" />
+    <Reference Include="System.ValueTuple, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.ValueTuple.4.5.0\lib\net47\System.ValueTuple.dll</HintPath>
+    </Reference>
     <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Xml.Serialization" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Libraries\clipper.cs" />
+    <Compile Include="Libraries\SimplexNoise.cs" />
+    <Compile Include="Model\Discrete\Assembly.cs" />
+    <Compile Include="Model\Discrete\CurveSnap.cs" />
+    <Compile Include="Model\Discrete\VoxelTiles.cs" />
+    <Compile Include="Model\Document\Cache.cs" />
+    <Compile Include="Model\Document\Debug.cs" />
+    <Compile Include="Model\Geometry\BallPivot.cs" />
+    <Compile Include="Model\Geometry\PolygonFill.cs" />
+    <Compile Include="Model\Regions\Region.cs" />
+    <Compile Include="Model\Toolpaths\Column.cs" />
+    <Compile Include="Model\Geometry\MeshPipe.cs" />
+    <Compile Include="Model\Geometry\Remesher.cs" />
+    <Compile Include="Model\Geometry\Slicer.cs" />
     <Compile Include="Model\Rendering\RenderExtensions.cs" />
+    <Compile Include="Model\Regions\StraightSkeleton.cs" />
+    <Compile Include="Model\Simulations\DifferentialGrowth\Force.cs" />
+    <Compile Include="Model\Simulations\DifferentialGrowth\Particle.cs" />
+    <Compile Include="Model\Simulations\DifferentialGrowth\DifferentialGrowth.cs" />
+    <Compile Include="Model\Simulations\DifferentialGrowth\Spring.cs" />
+    <Compile Include="Model\Spatial\BucketSearch.cs" />
+    <Compile Include="Model\Spatial\Octree.cs" />
+    <Compile Include="Model\Spatial\Primitives.cs" />
     <Compile Include="Model\Toolpaths\SpatialExtrusion\SpatialAttributes.cs" />
     <Compile Include="Model\Toolpaths\SpatialExtrusion\SpatialExtrusion.cs" />
+    <Compile Include="Model\Toolpaths\CSVConverter.cs" />
     <Compile Include="Model\Toolpaths\SpatialExtrusion\Vertex.cs" />
+    <Compile Include="Model\Util.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="View\Geometry\FlipMesh.cs" />
+    <Compile Include="View\Discrete\VoxelTiles.cs" />
+    <Compile Include="View\Discrete\CurveSnap.cs" />
+    <Compile Include="View\Geometry\DifferentialGrowth.cs" />
+    <Compile Include="View\Discrete\UnityExport.cs" />
+    <Compile Include="View\Toolpaths\LayeredToolpath.cs" />
+    <Compile Include="View\Geometry\Remesher.cs" />
+    <Compile Include="View\Geometry\StraightSkeleton.cs" />
     <Compile Include="View\Rendering\BitmapFromSolidColoredMeshes.cs" />
     <Compile Include="View\Rendering\BitmapFromVertexColors.cs" />
     <Compile Include="View\Rendering\MeshTextureCoords.cs" />
+    <Compile Include="View\Toolpaths\CSVConverter.cs" />
     <Compile Include="View\Toolpaths\SpatialExtrusion.cs" />
+    <Compile Include="View\Util.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Properties\Resources.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <SubType>Designer</SubType>
     </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
+    <None Include="app.config" />
+    <None Include="Extensions.ruleset" />
+    <None Include="packages.config" />
     <None Include="Resources\Icons\PaintBrush01.png" />
+    <None Include="Resources\Robots.gha" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Resources\Icons\PaintBrush02.png" />
@@ -99,10 +163,37 @@
   <ItemGroup>
     <None Include="Resources\Icons\Cube.png" />
   </ItemGroup>
-  <ItemGroup />
   <ItemGroup>
+    <None Include="Resources\Icons\Puzzle.png" />
+    <None Include="Resources\Icons\Wave.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\Icons\Triangle.png" />
     <None Include="Resources\Icons\DCLLogo.png" />
-    <Content Include="Resources\Icons\Spatial.png" />
+    <None Include="FodyWeavers.xml" />
+    <None Include="Resources\Icons\fingerprint.png" />
+    <None Include="Resources\Icons\Spatial.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\Icons\Virus.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\Icons\Graph.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\Icons\Virus2.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\Icons\EyeDropper.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\Icons\Grid.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\Icons\Polyline.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\Icons\Layers.png" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
@@ -125,5 +216,16 @@ Erase "$(TargetPath)"</PostBuildEvent>
     </StartArguments>
     <StartAction>Program</StartAction>
     <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisRuleSet>Extensions.ruleset</CodeAnalysisRuleSet>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
+  <Import Project="..\packages\Fody.3.1.3\build\Fody.targets" Condition="Exists('..\packages\Fody.3.1.3\build\Fody.targets')" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\Fody.3.1.3\build\Fody.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Fody.3.1.3\build\Fody.targets'))" />
+    <Error Condition="!Exists('..\packages\Costura.Fody.3.1.0\build\Costura.Fody.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Costura.Fody.3.1.0\build\Costura.Fody.targets'))" />
+  </Target>
+  <Import Project="..\packages\Costura.Fody.3.1.0\build\Costura.Fody.targets" Condition="Exists('..\packages\Costura.Fody.3.1.0\build\Costura.Fody.targets')" />
 </Project>
\ No newline at end of file
diff --git a/Extensions/Extensions.ruleset b/Extensions/Extensions.ruleset
new file mode 100644
index 0000000..2850b3d
--- /dev/null
+++ b/Extensions/Extensions.ruleset
@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RuleSet Name="Rules for Extensions" Description="Code analysis rules for Extensions.csproj." ToolsVersion="15.0">
+  <Rules AnalyzerId="Microsoft.Analyzers.ManagedCodeAnalysis" RuleNamespace="Microsoft.Rules.Managed">
+    <Rule Id="CA1001" Action="Warning" />
+    <Rule Id="CA1009" Action="Warning" />
+    <Rule Id="CA1016" Action="Warning" />
+    <Rule Id="CA1033" Action="Warning" />
+    <Rule Id="CA1049" Action="Warning" />
+    <Rule Id="CA1060" Action="Warning" />
+    <Rule Id="CA1061" Action="Warning" />
+    <Rule Id="CA1063" Action="Warning" />
+    <Rule Id="CA1065" Action="Warning" />
+    <Rule Id="CA1301" Action="Warning" />
+    <Rule Id="CA1400" Action="Warning" />
+    <Rule Id="CA1401" Action="Warning" />
+    <Rule Id="CA1403" Action="Warning" />
+    <Rule Id="CA1404" Action="Warning" />
+    <Rule Id="CA1405" Action="Warning" />
+    <Rule Id="CA1410" Action="Warning" />
+    <Rule Id="CA1415" Action="Warning" />
+    <Rule Id="CA1821" Action="Warning" />
+    <Rule Id="CA1900" Action="Warning" />
+    <Rule Id="CA1901" Action="Warning" />
+    <Rule Id="CA2002" Action="Warning" />
+    <Rule Id="CA2100" Action="Warning" />
+    <Rule Id="CA2101" Action="Warning" />
+    <Rule Id="CA2108" Action="Warning" />
+    <Rule Id="CA2111" Action="Warning" />
+    <Rule Id="CA2112" Action="Warning" />
+    <Rule Id="CA2114" Action="Warning" />
+    <Rule Id="CA2116" Action="Warning" />
+    <Rule Id="CA2117" Action="Warning" />
+    <Rule Id="CA2122" Action="Warning" />
+    <Rule Id="CA2123" Action="Warning" />
+    <Rule Id="CA2124" Action="Warning" />
+    <Rule Id="CA2126" Action="Warning" />
+    <Rule Id="CA2131" Action="Warning" />
+    <Rule Id="CA2132" Action="Warning" />
+    <Rule Id="CA2133" Action="Warning" />
+    <Rule Id="CA2134" Action="Warning" />
+    <Rule Id="CA2137" Action="Warning" />
+    <Rule Id="CA2138" Action="Warning" />
+    <Rule Id="CA2140" Action="Warning" />
+    <Rule Id="CA2141" Action="Warning" />
+    <Rule Id="CA2146" Action="Warning" />
+    <Rule Id="CA2147" Action="Warning" />
+    <Rule Id="CA2149" Action="Warning" />
+    <Rule Id="CA2200" Action="Warning" />
+    <Rule Id="CA2202" Action="Warning" />
+    <Rule Id="CA2207" Action="Warning" />
+    <Rule Id="CA2212" Action="Warning" />
+    <Rule Id="CA2213" Action="Warning" />
+    <Rule Id="CA2214" Action="Warning" />
+    <Rule Id="CA2216" Action="Warning" />
+    <Rule Id="CA2220" Action="Warning" />
+    <Rule Id="CA2229" Action="Warning" />
+    <Rule Id="CA2231" Action="Warning" />
+    <Rule Id="CA2232" Action="Warning" />
+    <Rule Id="CA2235" Action="Warning" />
+    <Rule Id="CA2236" Action="Warning" />
+    <Rule Id="CA2237" Action="Warning" />
+    <Rule Id="CA2238" Action="Warning" />
+    <Rule Id="CA2240" Action="Warning" />
+    <Rule Id="CA2241" Action="Warning" />
+    <Rule Id="CA2242" Action="Warning" />
+  </Rules>
+  <Rules AnalyzerId="Roslynator.CSharp.Analyzers" RuleNamespace="Roslynator.CSharp.Analyzers">
+    <Rule Id="RCS1018" Action="None" />
+  </Rules>
+</RuleSet>
\ No newline at end of file
diff --git a/Extensions/FodyWeavers.xml b/Extensions/FodyWeavers.xml
new file mode 100644
index 0000000..c6e1b7c
--- /dev/null
+++ b/Extensions/FodyWeavers.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Weavers>
+  <Costura />
+</Weavers>
\ No newline at end of file
diff --git a/Extensions/Libraries/SimplexNoise.cs b/Extensions/Libraries/SimplexNoise.cs
new file mode 100644
index 0000000..d45e4bf
--- /dev/null
+++ b/Extensions/Libraries/SimplexNoise.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+
+namespace Extensions
+{
+    public static class SimplexNoise
+    {
+        static int[][] grad3 = new int[][]{new int[]{1,1,0},new int[]{-1,1,0},new int[]{1,-1,0},new int[]{-1,-1,0},
+      new int[]{1,0,1},new int[]{-1,0,1},new int[]{1,0,-1},new int[]{-1,0,-1},
+      new int[]{0,1,1},new int[]{0,-1,1},new int[]{0,1,-1},new int[]{0,-1,-1}};
+
+        static int[] p = new int[]{151,160,137,91,90,15,
+      131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
+      190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
+      88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
+      77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
+      102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
+      135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
+      5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
+      223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
+      129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
+      251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
+      49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
+      138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180};
+        // To remove the need for index wrapping, double the permutation table length
+        static int[] perm = Perm();
+
+        static int[] Perm()
+        {
+            int[] perm = new int[512];
+            for (int i = 0; i < 512; i++) perm[i] = p[i & 255];
+            return perm;
+        }
+        // This method is a *lot* faster than using (int)Math.floor(x)
+        static int FastFloor(double x)
+        {
+            return x > 0 ? (int)x : (int)x - 1;
+        }
+        static double dot(int[] g, double x, double y)
+        {
+            return g[0] * x + g[1] * y;
+        }
+        static double dot(int[] g, double x, double y, double z)
+        {
+            return g[0] * x + g[1] * y + g[2] * z;
+        }
+        static double dot(int[] g, double x, double y, double z, double w)
+        {
+            return g[0] * x + g[1] * y + g[2] * z + g[3] * w;
+        }
+
+        // 3D simplex noise
+        public static double Noise(Point3d point)
+        {
+            return Noise(point.X, point.Y, point.Z);
+        }
+
+        public static double Noise(double xin, double yin, double zin)
+        {
+            double n0, n1, n2, n3; // Noise contributions from the four corners
+                                   // Skew the input space to determine which simplex cell we're in
+            double F3 = 1.0 / 3.0;
+            double s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
+            int i = FastFloor(xin + s);
+            int j = FastFloor(yin + s);
+            int k = FastFloor(zin + s);
+            double G3 = 1.0 / 6.0; // Very nice and simple unskew factor, too
+            double t = (i + j + k) * G3;
+            double X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+            double Y0 = j - t;
+            double Z0 = k - t;
+            double x0 = xin - X0; // The x,y,z distances from the cell origin
+            double y0 = yin - Y0;
+            double z0 = zin - Z0;
+            // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
+            // Determine which simplex we are in.
+            int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
+            int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
+            if (x0 >= y0)
+            {
+                if (y0 >= z0)
+                { i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; } // X Y Z order
+                else if (x0 >= z0) { i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; } // X Z Y order
+                else { i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; } // Z X Y order
+            }
+            else
+            { // x0<y0
+                if (y0 < z0) { i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1; } // Z Y X order
+                else if (x0 < z0) { i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1; } // Y Z X order
+                else { i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0; } // Y X Z order
+            }
+            // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
+            // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
+            // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
+            // c = 1/6.
+            double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
+            double y1 = y0 - j1 + G3;
+            double z1 = z0 - k1 + G3;
+            double x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
+            double y2 = y0 - j2 + 2.0 * G3;
+            double z2 = z0 - k2 + 2.0 * G3;
+            double x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
+            double y3 = y0 - 1.0 + 3.0 * G3;
+            double z3 = z0 - 1.0 + 3.0 * G3;
+            // Work out the hashed gradient indices of the four simplex corners
+            int ii = i & 255;
+            int jj = j & 255;
+            int kk = k & 255;
+            int gi0 = perm[ii + perm[jj + perm[kk]]] % 12;
+            int gi1 = perm[ii + i1 + perm[jj + j1 + perm[kk + k1]]] % 12;
+            int gi2 = perm[ii + i2 + perm[jj + j2 + perm[kk + k2]]] % 12;
+            int gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] % 12;
+            // Calculate the contribution from the four corners
+            double t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+            if (t0 < 0) n0 = 0.0;
+            else
+            {
+                t0 *= t0;
+                n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
+            }
+            double t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
+            if (t1 < 0) n1 = 0.0;
+            else
+            {
+                t1 *= t1;
+                n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
+            }
+            double t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
+            if (t2 < 0) n2 = 0.0;
+            else
+            {
+                t2 *= t2;
+                n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
+            }
+            double t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
+            if (t3 < 0) n3 = 0.0;
+            else
+            {
+                t3 *= t3;
+                n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
+            }
+            // Add contributions from each corner to get the final noise value.
+            // The result is scaled to stay just inside [-1,1]
+            return 32.0 * (n0 + n1 + n2 + n3);
+        }
+    }
+}
diff --git a/Extensions/Libraries/clipper.cs b/Extensions/Libraries/clipper.cs
new file mode 100644
index 0000000..8c796e2
--- /dev/null
+++ b/Extensions/Libraries/clipper.cs
@@ -0,0 +1,4913 @@
+/*******************************************************************************
+*                                                                              *
+* Author    :  Angus Johnson                                                   *
+* Version   :  6.4.2                                                           *
+* Date      :  27 February 2017                                                *
+* Website   :  http://www.angusj.com                                           *
+* Copyright :  Angus Johnson 2010-2017                                         *
+*                                                                              *
+* License:                                                                     *
+* Use, modification & distribution is subject to Boost Software License Ver 1. *
+* http://www.boost.org/LICENSE_1_0.txt                                         *
+*                                                                              *
+* Attributions:                                                                *
+* The code in this library is an extension of Bala Vatti's clipping algorithm: *
+* "A generic solution to polygon clipping"                                     *
+* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63.             *
+* http://portal.acm.org/citation.cfm?id=129906                                 *
+*                                                                              *
+* Computer graphics and geometric modeling: implementation and algorithms      *
+* By Max K. Agoston                                                            *
+* Springer; 1 edition (January 4, 2005)                                        *
+* http://books.google.com/books?q=vatti+clipping+agoston                       *
+*                                                                              *
+* See also:                                                                    *
+* "Polygon Offsetting by Computing Winding Numbers"                            *
+* Paper no. DETC2005-85513 pp. 565-575                                         *
+* ASME 2005 International Design Engineering Technical Conferences             *
+* and Computers and Information in Engineering Conference (IDETC/CIE2005)      *
+* September 24-28, 2005 , Long Beach, California, USA                          *
+* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf              *
+*                                                                              *
+*******************************************************************************/
+
+/*******************************************************************************
+*                                                                              *
+* This is a translation of the Delphi Clipper library and the naming style     *
+* used has retained a Delphi flavour.                                          *
+*                                                                              *
+*******************************************************************************/
+
+//use_int32: When enabled 32bit ints are used instead of 64bit ints. This
+//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 performance.
+//#define use_xyz
+
+//use_lines: Enables open path clipping. Adds a very minor cost to performance.
+#define use_lines
+
+
+using System;
+using System.Collections.Generic;
+//using System.Text;          //for Int128.AsString() & StringBuilder
+//using System.IO;            //debugging with streamReader & StreamWriter
+//using System.Windows.Forms; //debugging to clipboard
+
+namespace ClipperLib
+{
+
+#if use_int32
+  using cInt = Int32;
+#else
+  using cInt = Int64;
+#endif
+
+  using Path = List<IntPoint>;
+  using Paths = List<List<IntPoint>>;
+
+  public struct DoublePoint
+  {
+    public double X;
+    public double Y;
+
+    public DoublePoint(double x = 0, double y = 0)
+    {
+      this.X = x; this.Y = y;
+    }
+    public DoublePoint(DoublePoint dp)
+    {
+      this.X = dp.X; this.Y = dp.Y;
+    }
+    public DoublePoint(IntPoint ip)
+    {
+      this.X = ip.X; this.Y = ip.Y;
+    }
+  };
+
+
+  //------------------------------------------------------------------------------
+  // PolyTree & PolyNode classes
+  //------------------------------------------------------------------------------
+
+  public class PolyTree : PolyNode
+  {
+      internal List<PolyNode> m_AllPolys = new List<PolyNode>();
+
+      //The GC probably handles this cleanup more efficiently ...
+      //~PolyTree(){Clear();}
+        
+      public void Clear() 
+      {
+          for (int i = 0; i < m_AllPolys.Count; i++)
+              m_AllPolys[i] = null;
+          m_AllPolys.Clear(); 
+          m_Childs.Clear(); 
+      }
+        
+      public PolyNode GetFirst()
+      {
+          if (m_Childs.Count > 0)
+              return m_Childs[0];
+          else
+              return null;
+      }
+
+      public int Total
+      {
+          get 
+          { 
+            int result = m_AllPolys.Count;
+            //with negative offsets, ignore the hidden outer polygon ...
+            if (result > 0 && m_Childs[0] != m_AllPolys[0]) result--;
+            return result;
+          }
+      }
+
+  }
+        
+  public class PolyNode 
+  {
+      internal PolyNode m_Parent;
+      internal Path m_polygon = new Path();
+      internal int m_Index;
+      internal JoinType m_jointype;
+      internal EndType m_endtype;
+      internal List<PolyNode> m_Childs = new List<PolyNode>();
+
+      private bool IsHoleNode()
+      {
+          bool result = true;
+          PolyNode node = m_Parent;
+          while (node != null)
+          {
+              result = !result;
+              node = node.m_Parent;
+          }
+          return result;
+      }
+
+      public int ChildCount
+      {
+          get { return m_Childs.Count; }
+      }
+
+      public Path Contour
+      {
+          get { return m_polygon; }
+      }
+
+      internal void AddChild(PolyNode Child)
+      {
+          int cnt = m_Childs.Count;
+          m_Childs.Add(Child);
+          Child.m_Parent = this;
+          Child.m_Index = cnt;
+      }
+
+      public PolyNode GetNext()
+      {
+          if (m_Childs.Count > 0) 
+              return m_Childs[0]; 
+          else
+              return GetNextSiblingUp();        
+      }
+  
+      internal PolyNode GetNextSiblingUp()
+      {
+          if (m_Parent == null)
+              return null;
+          else if (m_Index == m_Parent.m_Childs.Count - 1)
+              return m_Parent.GetNextSiblingUp();
+          else
+              return m_Parent.m_Childs[m_Index + 1];
+      }
+
+      public List<PolyNode> Childs
+      {
+          get { return m_Childs; }
+      }
+
+      public PolyNode Parent
+      {
+          get { return m_Parent; }
+      }
+
+      public bool IsHole
+      {
+          get { return IsHoleNode(); }
+      }
+
+      public bool IsOpen { get; set; }
+  }
+
+
+  //------------------------------------------------------------------------------
+  // Int128 struct (enables safe math on signed 64bit integers)
+  // eg Int128 val1((Int64)9223372036854775807); //ie 2^63 -1
+  //    Int128 val2((Int64)9223372036854775807);
+  //    Int128 val3 = val1 * val2;
+  //    val3.ToString => "85070591730234615847396907784232501249" (8.5e+37)
+  //------------------------------------------------------------------------------
+
+  internal struct Int128
+  {
+    private Int64 hi;
+    private UInt64 lo;
+
+    public Int128(Int64 _lo)
+    {
+      lo = (UInt64)_lo;
+      if (_lo < 0) hi = -1;
+      else hi = 0;
+    }
+
+    public Int128(Int64 _hi, UInt64 _lo)
+    {
+      lo = _lo;
+      hi = _hi;
+    }
+
+    public Int128(Int128 val)
+    {
+      hi = val.hi;
+      lo = val.lo;
+    }
+
+    public bool IsNegative()
+    {
+      return hi < 0;
+    }
+
+    public static bool operator ==(Int128 val1, Int128 val2)
+    {
+      if ((object)val1 == (object)val2) return true;
+      else if ((object)val1 == null || (object)val2 == null) return false;
+      return (val1.hi == val2.hi && val1.lo == val2.lo);
+    }
+
+    public static bool operator !=(Int128 val1, Int128 val2)
+    {
+      return !(val1 == val2);
+    }
+
+    public override bool Equals(System.Object obj)
+    {
+      if (obj == null || !(obj is Int128))
+        return false;
+      Int128 i128 = (Int128)obj;
+      return (i128.hi == hi && i128.lo == lo);
+    }
+
+    public override int GetHashCode()
+    {
+      return hi.GetHashCode() ^ lo.GetHashCode();
+    }
+
+    public static bool operator >(Int128 val1, Int128 val2)
+    {
+      if (val1.hi != val2.hi)
+        return val1.hi > val2.hi;
+      else
+        return val1.lo > val2.lo;
+    }
+
+    public static bool operator <(Int128 val1, Int128 val2)
+    {
+      if (val1.hi != val2.hi)
+        return val1.hi < val2.hi;
+      else
+        return val1.lo < val2.lo;
+    }
+
+    public static Int128 operator +(Int128 lhs, Int128 rhs)
+    {
+      lhs.hi += rhs.hi;
+      lhs.lo += rhs.lo;
+      if (lhs.lo < rhs.lo) lhs.hi++;
+      return lhs;
+    }
+
+    public static Int128 operator -(Int128 lhs, Int128 rhs)
+    {
+      return lhs + -rhs;
+    }
+
+    public static Int128 operator -(Int128 val)
+    {
+      if (val.lo == 0)
+        return new Int128(-val.hi, 0);
+      else
+        return new Int128(~val.hi, ~val.lo + 1);
+    }
+
+    public static explicit operator double(Int128 val)
+    {
+      const double shift64 = 18446744073709551616.0; //2^64
+      if (val.hi < 0)
+      {
+        if (val.lo == 0)
+          return (double)val.hi * shift64;
+        else
+          return -(double)(~val.lo + ~val.hi * shift64);
+      }
+      else
+        return (double)(val.lo + val.hi * shift64);
+    }
+    
+    //nb: Constructing two new Int128 objects every time we want to multiply longs  
+    //is slow. So, although calling the Int128Mul method doesn't look as clean, the 
+    //code runs significantly faster than if we'd used the * operator.
+
+    public static Int128 Int128Mul(Int64 lhs, Int64 rhs)
+    {
+      bool negate = (lhs < 0) != (rhs < 0);
+      if (lhs < 0) lhs = -lhs;
+      if (rhs < 0) rhs = -rhs;
+      UInt64 int1Hi = (UInt64)lhs >> 32;
+      UInt64 int1Lo = (UInt64)lhs & 0xFFFFFFFF;
+      UInt64 int2Hi = (UInt64)rhs >> 32;
+      UInt64 int2Lo = (UInt64)rhs & 0xFFFFFFFF;
+
+      //nb: see comments in clipper.pas
+      UInt64 a = int1Hi * int2Hi;
+      UInt64 b = int1Lo * int2Lo;
+      UInt64 c = int1Hi * int2Lo + int1Lo * int2Hi;
+
+      UInt64 lo;
+      Int64 hi;
+      hi = (Int64)(a + (c >> 32));
+
+      unchecked { lo = (c << 32) + b; }
+      if (lo < b) hi++;
+      Int128 result = new Int128(hi, lo);
+      return negate ? -result : result;
+    }
+
+  };
+
+  //------------------------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  public struct IntPoint
+  {
+    public cInt X;
+    public cInt Y;
+#if use_xyz
+    public cInt Z;
+    
+    public IntPoint(cInt x, cInt y, cInt z = 0)
+    {
+      this.X = x; this.Y = y; this.Z = z;
+    }
+    
+    public IntPoint(double x, double y, double z = 0)
+    {
+      this.X = (cInt)x; this.Y = (cInt)y; this.Z = (cInt)z;
+    }
+    
+    public IntPoint(DoublePoint dp)
+    {
+      this.X = (cInt)dp.X; this.Y = (cInt)dp.Y; this.Z = 0;
+    }
+
+    public IntPoint(IntPoint pt)
+    {
+      this.X = pt.X; this.Y = pt.Y; this.Z = pt.Z;
+    }
+#else
+    public IntPoint(cInt X, cInt Y)
+    {
+        this.X = X; this.Y = Y;
+    }
+    public IntPoint(double x, double y)
+    {
+      this.X = (cInt)x; this.Y = (cInt)y;
+    }
+
+    public IntPoint(IntPoint pt)
+    {
+        this.X = pt.X; this.Y = pt.Y;
+    }
+#endif
+
+    public static bool operator ==(IntPoint a, IntPoint b)
+    {
+      return a.X == b.X && a.Y == b.Y;
+    }
+
+    public static bool operator !=(IntPoint a, IntPoint b)
+    {
+      return a.X != b.X  || a.Y != b.Y; 
+    }
+
+    public override bool Equals(object obj)
+    {
+      if (obj == null) return false;
+      if (obj is IntPoint)
+      {
+        IntPoint a = (IntPoint)obj;
+        return (X == a.X) && (Y == a.Y);
+      }
+      else return false;
+    }
+
+    public override int GetHashCode()
+    {
+      //simply prevents a compiler warning
+      return base.GetHashCode();
+    }
+
+  }// end struct IntPoint
+
+  public struct IntRect
+  {
+    public cInt left;
+    public cInt top;
+    public cInt right;
+    public cInt bottom;
+
+    public IntRect(cInt l, cInt t, cInt r, cInt b)
+    {
+      this.left = l; this.top = t;
+      this.right = r; this.bottom = b;
+    }
+    public IntRect(IntRect ir)
+    {
+      this.left = ir.left; this.top = ir.top;
+      this.right = ir.right; this.bottom = ir.bottom;
+    }
+  }
+
+  public enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
+  public enum PolyType { ptSubject, ptClip };
+  
+  //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
+  public enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
+  
+  public enum JoinType { jtSquare, jtRound, jtMiter };
+  public enum EndType { etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound };
+
+  internal enum EdgeSide {esLeft, esRight};
+  internal enum Direction {dRightToLeft, dLeftToRight};
+    
+  internal class TEdge {
+    internal IntPoint Bot;
+    internal IntPoint Curr; //current (updated for every new scanbeam)
+    internal IntPoint Top;
+    internal IntPoint Delta;
+    internal double Dx;
+    internal PolyType PolyTyp;
+    internal EdgeSide Side; //side only refers to current side of solution poly
+    internal int WindDelta; //1 or -1 depending on winding direction
+    internal int WindCnt;
+    internal int WindCnt2; //winding count of the opposite polytype
+    internal int OutIdx;
+    internal TEdge Next;
+    internal TEdge Prev;
+    internal TEdge NextInLML;
+    internal TEdge NextInAEL;
+    internal TEdge PrevInAEL;
+    internal TEdge NextInSEL;
+    internal TEdge PrevInSEL;
+  };
+
+  public class IntersectNode
+  {
+      internal TEdge Edge1;
+      internal TEdge Edge2;
+      internal IntPoint Pt;
+  };
+
+  public class MyIntersectNodeSort : IComparer<IntersectNode>
+  {
+    public int Compare(IntersectNode node1, IntersectNode node2)
+    {
+      cInt i = node2.Pt.Y - node1.Pt.Y;
+      if (i > 0) return 1;
+      else if (i < 0) return -1;
+      else return 0;
+    }
+  }
+
+  internal class LocalMinima
+  {
+    internal cInt Y;
+    internal TEdge LeftBound;
+    internal TEdge RightBound;
+    internal LocalMinima Next;
+  };
+
+  internal class Scanbeam
+  {
+      internal cInt Y;
+      internal Scanbeam Next;
+  };
+
+  internal class Maxima
+  {
+      internal cInt X;
+      internal Maxima Next;
+      internal Maxima Prev;
+  };
+
+  //OutRec: contains a path in the clipping solution. Edges in the AEL will
+  //carry a pointer to an OutRec when they are part of the clipping solution.
+  internal class OutRec
+  {
+    internal int Idx;
+    internal bool IsHole;
+    internal bool IsOpen;
+    internal OutRec FirstLeft; //see comments in clipper.pas
+    internal OutPt Pts;
+    internal OutPt BottomPt;
+    internal PolyNode PolyNode;
+  };
+
+  internal class OutPt
+  {
+    internal int Idx;
+    internal IntPoint Pt;
+    internal OutPt Next;
+    internal OutPt Prev;
+  };
+
+  internal class Join
+  {
+    internal OutPt OutPt1;
+    internal OutPt OutPt2;
+    internal IntPoint OffPt;
+  };
+
+  public class ClipperBase
+  {    
+    internal const double horizontal = -3.4E+38;
+    internal const int Skip = -2;
+    internal const int Unassigned = -1;
+    internal const double tolerance = 1.0E-20;
+    internal static bool near_zero(double val){return (val > -tolerance) && (val < tolerance);}
+
+#if use_int32
+    public const cInt loRange = 0x7FFF;
+    public const cInt hiRange = 0x7FFF;
+#else
+    public const cInt loRange = 0x3FFFFFFF;
+    public const cInt hiRange = 0x3FFFFFFFFFFFFFFFL; 
+#endif
+
+    internal LocalMinima m_MinimaList;
+    internal LocalMinima m_CurrentLM;
+    internal List<List<TEdge>> m_edges = new List<List<TEdge>>();
+    internal Scanbeam m_Scanbeam;
+    internal List<OutRec> m_PolyOuts;
+    internal TEdge m_ActiveEdges;
+    internal bool m_UseFullRange;
+    internal bool m_HasOpenPaths;
+
+    //------------------------------------------------------------------------------
+
+    public bool PreserveCollinear
+    {
+      get;
+      set;
+    }
+    //------------------------------------------------------------------------------
+
+    public void Swap(ref cInt val1, ref cInt val2)
+    {
+      cInt tmp = val1;
+      val1 = val2;
+      val2 = tmp;
+    }
+    //------------------------------------------------------------------------------
+
+    internal static bool IsHorizontal(TEdge e)
+    {
+      return e.Delta.Y == 0;
+    }
+    //------------------------------------------------------------------------------
+
+    internal bool PointIsVertex(IntPoint pt, OutPt pp)
+    {
+      OutPt pp2 = pp;
+      do
+      {
+        if (pp2.Pt == pt) return true;
+        pp2 = pp2.Next;
+      }
+      while (pp2 != pp);
+      return false;
+    }
+    //------------------------------------------------------------------------------
+
+    internal bool PointOnLineSegment(IntPoint pt, 
+        IntPoint linePt1, IntPoint linePt2, bool UseFullRange)
+    {
+      if (UseFullRange)
+        return ((pt.X == linePt1.X) && (pt.Y == linePt1.Y)) ||
+          ((pt.X == linePt2.X) && (pt.Y == linePt2.Y)) ||
+          (((pt.X > linePt1.X) == (pt.X < linePt2.X)) &&
+          ((pt.Y > linePt1.Y) == (pt.Y < linePt2.Y)) &&
+          ((Int128.Int128Mul((pt.X - linePt1.X), (linePt2.Y - linePt1.Y)) ==
+          Int128.Int128Mul((linePt2.X - linePt1.X), (pt.Y - linePt1.Y)))));
+      else
+        return ((pt.X == linePt1.X) && (pt.Y == linePt1.Y)) ||
+          ((pt.X == linePt2.X) && (pt.Y == linePt2.Y)) ||
+          (((pt.X > linePt1.X) == (pt.X < linePt2.X)) &&
+          ((pt.Y > linePt1.Y) == (pt.Y < linePt2.Y)) &&
+          ((pt.X - linePt1.X) * (linePt2.Y - linePt1.Y) ==
+            (linePt2.X - linePt1.X) * (pt.Y - linePt1.Y)));
+    }
+    //------------------------------------------------------------------------------
+
+    internal bool PointOnPolygon(IntPoint pt, OutPt pp, bool UseFullRange)
+    {
+      OutPt pp2 = pp;
+      while (true)
+      {
+        if (PointOnLineSegment(pt, pp2.Pt, pp2.Next.Pt, UseFullRange))
+          return true;
+        pp2 = pp2.Next;
+        if (pp2 == pp) break;
+      }
+      return false;
+    }
+    //------------------------------------------------------------------------------
+
+    internal static bool SlopesEqual(TEdge e1, TEdge e2, bool UseFullRange)
+    {
+        if (UseFullRange)
+          return Int128.Int128Mul(e1.Delta.Y, e2.Delta.X) ==
+              Int128.Int128Mul(e1.Delta.X, e2.Delta.Y);
+        else return (cInt)(e1.Delta.Y) * (e2.Delta.X) ==
+          (cInt)(e1.Delta.X) * (e2.Delta.Y);
+    }
+    //------------------------------------------------------------------------------
+
+    internal static bool SlopesEqual(IntPoint pt1, IntPoint pt2,
+        IntPoint pt3, bool UseFullRange)
+    {
+        if (UseFullRange)
+            return Int128.Int128Mul(pt1.Y - pt2.Y, pt2.X - pt3.X) ==
+              Int128.Int128Mul(pt1.X - pt2.X, pt2.Y - pt3.Y);
+        else return
+          (cInt)(pt1.Y - pt2.Y) * (pt2.X - pt3.X) - (cInt)(pt1.X - pt2.X) * (pt2.Y - pt3.Y) == 0;
+    }
+    //------------------------------------------------------------------------------
+
+    internal static bool SlopesEqual(IntPoint pt1, IntPoint pt2,
+        IntPoint pt3, IntPoint pt4, bool UseFullRange)
+    {
+        if (UseFullRange)
+            return Int128.Int128Mul(pt1.Y - pt2.Y, pt3.X - pt4.X) ==
+              Int128.Int128Mul(pt1.X - pt2.X, pt3.Y - pt4.Y);
+        else return
+          (cInt)(pt1.Y - pt2.Y) * (pt3.X - pt4.X) - (cInt)(pt1.X - pt2.X) * (pt3.Y - pt4.Y) == 0;
+    }
+    //------------------------------------------------------------------------------
+
+    internal ClipperBase() //constructor (nb: no external instantiation)
+    {
+        m_MinimaList = null;
+        m_CurrentLM = null;
+        m_UseFullRange = false;
+        m_HasOpenPaths = false;
+    }
+    //------------------------------------------------------------------------------
+
+    public virtual void Clear()
+    {
+        DisposeLocalMinimaList();
+        for (int i = 0; i < m_edges.Count; ++i)
+        {
+            for (int j = 0; j < m_edges[i].Count; ++j) m_edges[i][j] = null;
+            m_edges[i].Clear();
+        }
+        m_edges.Clear();
+        m_UseFullRange = false;
+        m_HasOpenPaths = false;
+    }
+    //------------------------------------------------------------------------------
+
+    private void DisposeLocalMinimaList()
+    {
+        while( m_MinimaList != null )
+        {
+            LocalMinima tmpLm = m_MinimaList.Next;
+            m_MinimaList = null;
+            m_MinimaList = tmpLm;
+        }
+        m_CurrentLM = null;
+    }
+    //------------------------------------------------------------------------------
+
+    void RangeTest(IntPoint Pt, ref bool useFullRange)
+    {
+      if (useFullRange)
+      {
+        if (Pt.X > hiRange || Pt.Y > hiRange || -Pt.X > hiRange || -Pt.Y > hiRange) 
+          throw new ClipperException("Coordinate outside allowed range");
+      }
+      else if (Pt.X > loRange || Pt.Y > loRange || -Pt.X > loRange || -Pt.Y > loRange) 
+      {
+        useFullRange = true;
+        RangeTest(Pt, ref useFullRange);
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    private void InitEdge(TEdge e, TEdge eNext,
+      TEdge ePrev, IntPoint pt)
+    {
+      e.Next = eNext;
+      e.Prev = ePrev;
+      e.Curr = pt;
+      e.OutIdx = Unassigned;
+    }
+    //------------------------------------------------------------------------------
+
+    private void InitEdge2(TEdge e, PolyType polyType)
+    {
+      if (e.Curr.Y >= e.Next.Curr.Y)
+      {
+        e.Bot = e.Curr;
+        e.Top = e.Next.Curr;
+      }
+      else
+      {
+        e.Top = e.Curr;
+        e.Bot = e.Next.Curr;
+      }
+      SetDx(e);
+      e.PolyTyp = polyType;
+    }
+    //------------------------------------------------------------------------------
+
+    private TEdge FindNextLocMin(TEdge E)
+    {
+      TEdge E2;
+      for (;;)
+      {
+        while (E.Bot != E.Prev.Bot || E.Curr == E.Top) E = E.Next;
+        if (E.Dx != horizontal && E.Prev.Dx != horizontal) break;
+        while (E.Prev.Dx == horizontal) E = E.Prev;
+        E2 = E;
+        while (E.Dx == horizontal) E = E.Next;
+        if (E.Top.Y == E.Prev.Bot.Y) continue; //ie just an intermediate horz.
+        if (E2.Prev.Bot.X < E.Bot.X) E = E2;
+        break;
+      }
+      return E;
+    }
+    //------------------------------------------------------------------------------
+
+    private TEdge ProcessBound(TEdge E, bool LeftBoundIsForward)
+    {
+      TEdge EStart, Result = E;
+      TEdge Horz;
+
+      if (Result.OutIdx == Skip)
+      {
+        //check if there are edges beyond the skip edge in the bound and if so
+        //create another LocMin and calling ProcessBound once more ...
+        E = Result;
+        if (LeftBoundIsForward)
+        {
+          while (E.Top.Y == E.Next.Bot.Y) E = E.Next;
+          while (E != Result && E.Dx == horizontal) E = E.Prev;
+        }
+        else
+        {
+          while (E.Top.Y == E.Prev.Bot.Y) E = E.Prev;
+          while (E != Result && E.Dx == horizontal) E = E.Next;
+        }
+        if (E == Result)
+        {
+          if (LeftBoundIsForward) Result = E.Next;
+          else Result = E.Prev;
+        }
+        else
+        {
+          //there are more edges in the bound beyond result starting with E
+          if (LeftBoundIsForward)
+            E = Result.Next;
+          else
+            E = Result.Prev;
+          LocalMinima locMin = new LocalMinima();
+          locMin.Next = null;
+          locMin.Y = E.Bot.Y;
+          locMin.LeftBound = null;
+          locMin.RightBound = E;
+          E.WindDelta = 0;
+          Result = ProcessBound(E, LeftBoundIsForward);
+          InsertLocalMinima(locMin);
+        }
+        return Result;
+      }
+
+      if (E.Dx == horizontal)
+      {
+        //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 (LeftBoundIsForward) EStart = E.Prev;
+        else EStart = E.Next;
+        if (EStart.Dx == horizontal) //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 (LeftBoundIsForward)
+      {
+        while (Result.Top.Y == Result.Next.Bot.Y && Result.Next.OutIdx != Skip)
+          Result = Result.Next;
+        if (Result.Dx == horizontal && 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 (Horz.Prev.Dx == horizontal) Horz = Horz.Prev;
+          if (Horz.Prev.Top.X > Result.Next.Top.X) Result = Horz.Prev;
+        }
+        while (E != Result)
+        {
+          E.NextInLML = E.Next;
+          if (E.Dx == horizontal && E != EStart && E.Bot.X != E.Prev.Top.X) 
+            ReverseHorizontal(E);
+          E = E.Next;
+        }
+        if (E.Dx == horizontal && 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 (Result.Dx == horizontal && Result.Prev.OutIdx != Skip)
+        {
+          Horz = Result;
+          while (Horz.Next.Dx == horizontal) 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 (E.Dx == horizontal && E != EStart && E.Bot.X != E.Next.Top.X) 
+            ReverseHorizontal(E);
+          E = E.Prev;
+        }
+        if (E.Dx == horizontal && E != EStart && E.Bot.X != E.Next.Top.X) 
+          ReverseHorizontal(E);
+        Result = Result.Prev; //move to the edge just beyond current bound
+      }
+      return Result;
+    }
+    //------------------------------------------------------------------------------
+
+
+    public bool AddPath(Path pg, PolyType polyType, bool Closed)
+    {
+#if use_lines
+      if (!Closed && polyType == PolyType.ptClip)
+        throw new ClipperException("AddPath: Open paths must be subject.");
+#else
+      if (!Closed)
+        throw new ClipperException("AddPath: Open paths have been disabled.");
+#endif
+
+      int highI = (int)pg.Count - 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 ...
+      List<TEdge> edges = new List<TEdge>(highI+1);
+      for (int i = 0; i <= highI; i++) edges.Add(new TEdge());
+          
+      bool IsFlat = true;
+
+      //1. Basic (first) edge initialization ...
+      edges[1].Curr = pg[1];
+      RangeTest(pg[0], ref m_UseFullRange);
+      RangeTest(pg[highI], ref 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], ref m_UseFullRange);
+        InitEdge(edges[i], edges[i + 1], edges[i - 1], pg[i]);
+      }
+      TEdge eStart = edges[0];
+
+      //2. Remove duplicate vertices, and (when closed) collinear edges ...
+      TEdge E = eStart, eLoopStop = eStart;
+      for (;;)
+      {
+        //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) && 
+          (!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)))
+        return false;
+
+      if (!Closed)
+      {
+        m_HasOpenPaths = true;
+        eStart.Prev.OutIdx = Skip;
+      }
+
+      //3. Do second stage of edge initialization ...
+      E = eStart;
+      do
+      {
+        InitEdge2(E, polyType);
+        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) return false;
+        E.Prev.OutIdx = Skip;
+        LocalMinima locMin = new LocalMinima();
+        locMin.Next = null;
+        locMin.Y = E.Bot.Y;
+        locMin.LeftBound = null;
+        locMin.RightBound = E;
+        locMin.RightBound.Side = EdgeSide.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;
+        }
+        InsertLocalMinima(locMin);
+        m_edges.Add(edges);
+        return true;
+      }
+
+      m_edges.Add(edges);
+      bool leftBoundIsForward;
+      TEdge EMin = null;
+
+      //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 == null) EMin = E;
+
+        //E and E.Prev now share a local minima (left aligned if horizontal).
+        //Compare their slopes to find which starts which bound ...
+        LocalMinima locMin = new LocalMinima();
+        locMin.Next = null;
+        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
+        }
+        locMin.LeftBound.Side = EdgeSide.esLeft;
+        locMin.RightBound.Side = EdgeSide.esRight;
+
+        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 = null;
+        else if (locMin.RightBound.OutIdx == Skip)
+          locMin.RightBound = null;
+        InsertLocalMinima(locMin);
+        if (!leftBoundIsForward) E = E2;
+      }
+      return true;
+
+    }
+    //------------------------------------------------------------------------------
+
+    public bool AddPaths(Paths ppg, PolyType polyType, bool closed)
+    {
+      bool result = false;
+      for (int i = 0; i < ppg.Count; ++i)
+        if (AddPath(ppg[i], polyType, closed)) result = true;
+      return result;
+    }
+    //------------------------------------------------------------------------------
+
+    internal bool Pt2IsBetweenPt1AndPt3(IntPoint pt1, IntPoint pt2, IntPoint pt3)
+    {
+      if ((pt1 == pt3) || (pt1 == pt2) || (pt3 == pt2)) return false;
+      else if (pt1.X != pt3.X) return (pt2.X > pt1.X) == (pt2.X < pt3.X);
+      else return (pt2.Y > pt1.Y) == (pt2.Y < pt3.Y);
+    }
+    //------------------------------------------------------------------------------
+
+    TEdge RemoveEdge(TEdge e)
+    {
+      //removes e from double_linked_list (but without removing from memory)
+      e.Prev.Next = e.Next;
+      e.Next.Prev = e.Prev;
+      TEdge result = e.Next;
+      e.Prev = null; //flag as removed (see ClipperBase.Clear)
+      return result;
+    }
+    //------------------------------------------------------------------------------
+
+    private void SetDx(TEdge e)
+    {
+      e.Delta.X = (e.Top.X - e.Bot.X);
+      e.Delta.Y = (e.Top.Y - e.Bot.Y);
+      if (e.Delta.Y == 0) e.Dx = horizontal;
+      else e.Dx = (double)(e.Delta.X) / (e.Delta.Y);
+    }
+    //---------------------------------------------------------------------------
+
+    private void InsertLocalMinima(LocalMinima newLm)
+    {
+      if( m_MinimaList == null )
+      {
+        m_MinimaList = newLm;
+      }
+      else if( newLm.Y >= m_MinimaList.Y )
+      {
+        newLm.Next = m_MinimaList;
+        m_MinimaList = newLm;
+      } else
+      {
+        LocalMinima tmpLm = m_MinimaList;
+        while( tmpLm.Next != null  && ( newLm.Y < tmpLm.Next.Y ) )
+          tmpLm = tmpLm.Next;
+        newLm.Next = tmpLm.Next;
+        tmpLm.Next = newLm;
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    internal Boolean PopLocalMinima(cInt Y, out LocalMinima current)
+    {
+        current = m_CurrentLM;
+        if (m_CurrentLM != null && m_CurrentLM.Y == Y)
+        {
+            m_CurrentLM = m_CurrentLM.Next;
+            return true;
+        }
+        return false;
+    }
+    //------------------------------------------------------------------------------
+
+    private void ReverseHorizontal(TEdge e)
+    {
+      //swap horizontal edges' top and bottom x's so they follow the natural
+      //progression of the bounds - ie so their xbots will align with the
+      //adjoining lower edge. [Helpful in the ProcessHorizontal() method.]
+      Swap(ref e.Top.X, ref e.Bot.X);
+#if use_xyz
+      Swap(ref e.Top.Z, ref e.Bot.Z);
+#endif
+    }
+    //------------------------------------------------------------------------------
+
+    internal virtual void Reset()
+    {
+      m_CurrentLM = m_MinimaList;
+      if (m_CurrentLM == null) return; //ie nothing to process
+
+      //reset all edges ...
+      m_Scanbeam = null;
+      LocalMinima lm = m_MinimaList;
+      while (lm != null)
+      {
+        InsertScanbeam(lm.Y);
+        TEdge e = lm.LeftBound;
+        if (e != null)
+        {
+          e.Curr = e.Bot;
+          e.OutIdx = Unassigned;
+        }
+        e = lm.RightBound;
+        if (e != null)
+        {
+          e.Curr = e.Bot;
+          e.OutIdx = Unassigned;
+        }
+        lm = lm.Next;
+      }
+      m_ActiveEdges = null;
+    }
+    //------------------------------------------------------------------------------
+
+    public static IntRect GetBounds(Paths paths)
+    {
+      int i = 0, cnt = paths.Count;
+      while (i < cnt && paths[i].Count == 0) i++;
+      if (i == cnt) return new IntRect(0,0,0,0);
+      IntRect result = new IntRect();
+      result.left = paths[i][0].X;
+      result.right = result.left;
+      result.top = paths[i][0].Y;
+      result.bottom = result.top;
+      for (; i < cnt; i++)
+        for (int j = 0; j < paths[i].Count; j++)
+        {
+          if (paths[i][j].X < result.left) result.left = paths[i][j].X;
+          else if (paths[i][j].X > result.right) result.right = paths[i][j].X;
+          if (paths[i][j].Y < result.top) result.top = paths[i][j].Y;
+          else if (paths[i][j].Y > result.bottom) result.bottom = paths[i][j].Y;
+        }
+      return result;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void InsertScanbeam(cInt Y)
+    {
+        //single-linked list: sorted descending, ignoring dups.
+        if (m_Scanbeam == null)
+        {
+            m_Scanbeam = new Scanbeam();
+            m_Scanbeam.Next = null;
+            m_Scanbeam.Y = Y;
+        }
+        else if (Y > m_Scanbeam.Y)
+        {
+            Scanbeam newSb = new Scanbeam();
+            newSb.Y = Y;
+            newSb.Next = m_Scanbeam;
+            m_Scanbeam = newSb;
+        }
+        else
+        {
+            Scanbeam sb2 = m_Scanbeam;
+            while (sb2.Next != null && (Y <= sb2.Next.Y)) sb2 = sb2.Next;
+            if (Y == sb2.Y) return; //ie ignores duplicates
+            Scanbeam newSb = new Scanbeam();
+            newSb.Y = Y;
+            newSb.Next = sb2.Next;
+            sb2.Next = newSb;
+        }
+    }
+    //------------------------------------------------------------------------------
+
+    internal Boolean PopScanbeam(out cInt Y)
+    {
+        if (m_Scanbeam == null)
+        {
+            Y = 0;
+            return false;
+        }
+        Y = m_Scanbeam.Y;
+        m_Scanbeam = m_Scanbeam.Next;
+        return true;
+    }
+    //------------------------------------------------------------------------------
+
+    internal Boolean LocalMinimaPending()
+    {
+        return (m_CurrentLM != null);
+    }
+    //------------------------------------------------------------------------------
+
+    internal OutRec CreateOutRec()
+    {
+        OutRec result = new OutRec();
+        result.Idx = Unassigned;
+        result.IsHole = false;
+        result.IsOpen = false;
+        result.FirstLeft = null;
+        result.Pts = null;
+        result.BottomPt = null;
+        result.PolyNode = null;
+        m_PolyOuts.Add(result);
+        result.Idx = m_PolyOuts.Count - 1;
+        return result;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DisposeOutRec(int index)
+    {
+        OutRec outRec = m_PolyOuts[index];
+        outRec.Pts = null;
+        outRec = null;
+        m_PolyOuts[index] = null;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void UpdateEdgeIntoAEL(ref TEdge e)
+    {
+        if (e.NextInLML == null)
+            throw new ClipperException("UpdateEdgeIntoAEL: invalid call");
+        TEdge AelPrev = e.PrevInAEL;
+        TEdge AelNext = e.NextInAEL;
+        e.NextInLML.OutIdx = e.OutIdx;
+        if (AelPrev != null)
+            AelPrev.NextInAEL = e.NextInLML;
+        else m_ActiveEdges = e.NextInLML;
+        if (AelNext != null)
+            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);
+    }
+    //------------------------------------------------------------------------------
+
+    internal void SwapPositionsInAEL(TEdge edge1, TEdge edge2)
+    {
+        //check that one or other edge hasn't already been removed from AEL ...
+        if (edge1.NextInAEL == edge1.PrevInAEL ||
+          edge2.NextInAEL == edge2.PrevInAEL) return;
+
+        if (edge1.NextInAEL == edge2)
+        {
+            TEdge next = edge2.NextInAEL;
+            if (next != null)
+                next.PrevInAEL = edge1;
+            TEdge prev = edge1.PrevInAEL;
+            if (prev != null)
+                prev.NextInAEL = edge2;
+            edge2.PrevInAEL = prev;
+            edge2.NextInAEL = edge1;
+            edge1.PrevInAEL = edge2;
+            edge1.NextInAEL = next;
+        }
+        else if (edge2.NextInAEL == edge1)
+        {
+            TEdge next = edge1.NextInAEL;
+            if (next != null)
+                next.PrevInAEL = edge2;
+            TEdge prev = edge2.PrevInAEL;
+            if (prev != null)
+                prev.NextInAEL = edge1;
+            edge1.PrevInAEL = prev;
+            edge1.NextInAEL = edge2;
+            edge2.PrevInAEL = edge1;
+            edge2.NextInAEL = next;
+        }
+        else
+        {
+            TEdge next = edge1.NextInAEL;
+            TEdge prev = edge1.PrevInAEL;
+            edge1.NextInAEL = edge2.NextInAEL;
+            if (edge1.NextInAEL != null)
+                edge1.NextInAEL.PrevInAEL = edge1;
+            edge1.PrevInAEL = edge2.PrevInAEL;
+            if (edge1.PrevInAEL != null)
+                edge1.PrevInAEL.NextInAEL = edge1;
+            edge2.NextInAEL = next;
+            if (edge2.NextInAEL != null)
+                edge2.NextInAEL.PrevInAEL = edge2;
+            edge2.PrevInAEL = prev;
+            if (edge2.PrevInAEL != null)
+                edge2.PrevInAEL.NextInAEL = edge2;
+        }
+
+        if (edge1.PrevInAEL == null)
+            m_ActiveEdges = edge1;
+        else if (edge2.PrevInAEL == null)
+            m_ActiveEdges = edge2;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DeleteFromAEL(TEdge e)
+    {
+        TEdge AelPrev = e.PrevInAEL;
+        TEdge AelNext = e.NextInAEL;
+        if (AelPrev == null && AelNext == null && (e != m_ActiveEdges))
+            return; //already deleted
+        if (AelPrev != null)
+            AelPrev.NextInAEL = AelNext;
+        else m_ActiveEdges = AelNext;
+        if (AelNext != null)
+            AelNext.PrevInAEL = AelPrev;
+        e.NextInAEL = null;
+        e.PrevInAEL = null;
+    }
+    //------------------------------------------------------------------------------
+
+  } //end ClipperBase
+
+  public class Clipper : ClipperBase
+  {
+      //InitOptions that can be passed to the constructor ...
+      public const int ioReverseSolution = 1;
+      public const int ioStrictlySimple = 2;
+      public const int ioPreserveCollinear = 4;
+
+      private ClipType m_ClipType;
+      private Maxima m_Maxima;
+      private TEdge m_SortedEdges;
+      private List<IntersectNode> m_IntersectList;
+      IComparer<IntersectNode> m_IntersectNodeComparer;
+      private bool m_ExecuteLocked;
+      private PolyFillType m_ClipFillType;
+      private PolyFillType m_SubjFillType;
+      private List<Join> m_Joins;
+      private List<Join> m_GhostJoins;
+      private bool m_UsingPolyTree;
+#if use_xyz
+      public delegate void ZFillCallback(IntPoint bot1, IntPoint top1, 
+        IntPoint bot2, IntPoint top2, ref IntPoint pt);
+      public ZFillCallback ZFillFunction { get; set; }
+#endif
+      public Clipper(int InitOptions = 0): base() //constructor
+      {
+          m_Scanbeam = null;
+          m_Maxima = null;
+          m_ActiveEdges = null;
+          m_SortedEdges = null;
+          m_IntersectList = new List<IntersectNode>();
+          m_IntersectNodeComparer = new MyIntersectNodeSort();
+          m_ExecuteLocked = false;
+          m_UsingPolyTree = false;
+          m_PolyOuts = new List<OutRec>();
+          m_Joins = new List<Join>();
+          m_GhostJoins = new List<Join>();
+          ReverseSolution = (ioReverseSolution & InitOptions) != 0;
+          StrictlySimple = (ioStrictlySimple & InitOptions) != 0;
+          PreserveCollinear = (ioPreserveCollinear & InitOptions) != 0;
+#if use_xyz
+          ZFillFunction = null;
+#endif
+      }
+      //------------------------------------------------------------------------------
+
+      private void InsertMaxima(cInt X)
+      {
+          //double-linked list: sorted ascending, ignoring dups.
+          Maxima newMax = new Maxima();
+          newMax.X = X;
+          if (m_Maxima == null)
+          {
+              m_Maxima = newMax;
+              m_Maxima.Next = null;
+              m_Maxima.Prev = null;
+          }
+          else if (X < m_Maxima.X)
+          {
+              newMax.Next = m_Maxima;
+              newMax.Prev = null;
+              m_Maxima = newMax;
+          }
+          else
+          {
+              Maxima m = m_Maxima;
+              while (m.Next != null && (X >= m.Next.X)) m = m.Next;
+              if (X == m.X) return; //ie ignores duplicates (& CG to clean up newMax)
+              //insert newMax between m and m.Next ...
+              newMax.Next = m.Next;
+              newMax.Prev = m;
+              if (m.Next != null) m.Next.Prev = newMax;
+              m.Next = newMax;
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      public bool ReverseSolution
+      {
+        get;
+        set;
+      }
+      //------------------------------------------------------------------------------
+
+      public bool StrictlySimple
+      {
+        get; 
+        set;
+      }
+      //------------------------------------------------------------------------------
+       
+      public bool Execute(ClipType clipType, Paths solution, 
+          PolyFillType FillType = PolyFillType.pftEvenOdd)
+      {
+          return Execute(clipType, solution, FillType, FillType);
+      }
+      //------------------------------------------------------------------------------
+
+      public bool Execute(ClipType clipType, PolyTree polytree,
+          PolyFillType FillType = PolyFillType.pftEvenOdd)
+      {
+          return Execute(clipType, polytree, FillType, FillType);
+      }
+      //------------------------------------------------------------------------------
+
+      public bool Execute(ClipType clipType, Paths solution,
+          PolyFillType subjFillType, PolyFillType clipFillType)
+      {
+          if (m_ExecuteLocked) return false;
+          if (m_HasOpenPaths) throw 
+            new ClipperException("Error: PolyTree struct is needed for open path clipping.");
+
+          m_ExecuteLocked = true;
+          solution.Clear();
+          m_SubjFillType = subjFillType;
+          m_ClipFillType = clipFillType;
+          m_ClipType = clipType;
+          m_UsingPolyTree = false;
+          bool succeeded;
+          try
+          {
+            succeeded = ExecuteInternal();
+            //build the return polygons ...
+            if (succeeded) BuildResult(solution);
+          }
+          finally
+          {
+            DisposeAllPolyPts();
+            m_ExecuteLocked = false;
+          }
+          return succeeded;
+      }
+      //------------------------------------------------------------------------------
+
+      public bool Execute(ClipType clipType, PolyTree polytree,
+          PolyFillType subjFillType, PolyFillType clipFillType)
+      {
+          if (m_ExecuteLocked) return false;
+          m_ExecuteLocked = true;
+          m_SubjFillType = subjFillType;
+          m_ClipFillType = clipFillType;
+          m_ClipType = clipType;
+          m_UsingPolyTree = true;
+          bool succeeded;
+          try
+          {
+            succeeded = ExecuteInternal();
+            //build the return polygons ...
+            if (succeeded) BuildResult2(polytree);
+          }
+          finally
+          {
+            DisposeAllPolyPts();
+            m_ExecuteLocked = false;
+          }
+          return succeeded;
+      }
+      //------------------------------------------------------------------------------
+
+      internal void FixHoleLinkage(OutRec outRec)
+      {
+        //skip if an outermost polygon or
+        //already already points to the correct FirstLeft ...
+        if (outRec.FirstLeft == null ||
+              (outRec.IsHole != outRec.FirstLeft.IsHole &&
+              outRec.FirstLeft.Pts != null)) return;
+
+        OutRec orfl = outRec.FirstLeft;
+        while (orfl != null && ((orfl.IsHole == outRec.IsHole) || orfl.Pts == null))
+          orfl = orfl.FirstLeft;
+        outRec.FirstLeft = orfl;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool ExecuteInternal()
+      {
+        try
+        {
+          Reset();
+          m_SortedEdges = null;
+          m_Maxima = null;
+
+          cInt botY, topY;
+          if (!PopScanbeam(out botY)) return false;
+          InsertLocalMinimaIntoAEL(botY);
+          while (PopScanbeam(out topY) || LocalMinimaPending())
+          {
+            ProcessHorizontals();
+            m_GhostJoins.Clear();
+            if (!ProcessIntersections(topY)) return false;
+            ProcessEdgesAtTopOfScanbeam(topY);
+            botY = topY;
+            InsertLocalMinimaIntoAEL(botY);
+          } 
+
+          //fix orientations ...
+          foreach (OutRec outRec in m_PolyOuts)
+          {
+            if (outRec.Pts == null || outRec.IsOpen) continue;
+            if ((outRec.IsHole ^ ReverseSolution) == (Area(outRec) > 0))
+              ReversePolyPtLinks(outRec.Pts);
+          }
+
+          JoinCommonEdges();
+
+          foreach (OutRec outRec in m_PolyOuts)
+          {
+            if (outRec.Pts == null) 
+                continue;
+            else if (outRec.IsOpen)
+                FixupOutPolyline(outRec);
+            else
+                FixupOutPolygon(outRec);
+          }
+
+          if (StrictlySimple) DoSimplePolygons();
+          return true;
+        }
+        //catch { return false; }
+        finally 
+        {
+          m_Joins.Clear();
+          m_GhostJoins.Clear();          
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void DisposeAllPolyPts(){
+        for (int i = 0; i < m_PolyOuts.Count; ++i) DisposeOutRec(i);
+        m_PolyOuts.Clear();
+      }
+      //------------------------------------------------------------------------------
+
+      private void AddJoin(OutPt Op1, OutPt Op2, IntPoint OffPt)
+      {
+        Join j = new Join();
+        j.OutPt1 = Op1;
+        j.OutPt2 = Op2;
+        j.OffPt = OffPt;
+        m_Joins.Add(j);
+      }
+      //------------------------------------------------------------------------------
+
+      private void AddGhostJoin(OutPt Op, IntPoint OffPt)
+      {
+        Join j = new Join();
+        j.OutPt1 = Op;
+        j.OffPt = OffPt;
+        m_GhostJoins.Add(j);
+      }
+      //------------------------------------------------------------------------------
+
+#if use_xyz
+      internal void SetZ(ref IntPoint pt, TEdge e1, TEdge e2)
+      {
+        if (pt.Z != 0 || ZFillFunction == null) return;
+        else if (pt == e1.Bot) pt.Z = e1.Bot.Z;
+        else if (pt == e1.Top) pt.Z = e1.Top.Z;
+        else if (pt == e2.Bot) pt.Z = e2.Bot.Z;
+        else if (pt == e2.Top) pt.Z = e2.Top.Z;
+        else ZFillFunction(e1.Bot, e1.Top, e2.Bot, e2.Top, ref pt);
+      }
+      //------------------------------------------------------------------------------
+#endif
+
+      private void InsertLocalMinimaIntoAEL(cInt botY)
+      {
+        LocalMinima lm;
+        while (PopLocalMinima(botY, out lm))
+        {
+          TEdge lb = lm.LeftBound;
+          TEdge rb = lm.RightBound;
+
+          OutPt Op1 = null;
+          if (lb == null)
+          {
+            InsertEdgeIntoAEL(rb, null);
+            SetWindingCount(rb);
+            if (IsContributing(rb))
+              Op1 = AddOutPt(rb, rb.Bot);
+          }
+          else if (rb == null)
+          {
+            InsertEdgeIntoAEL(lb, null);
+            SetWindingCount(lb);
+            if (IsContributing(lb))
+              Op1 = AddOutPt(lb, lb.Bot);
+            InsertScanbeam(lb.Top.Y);
+          }
+          else
+          {
+            InsertEdgeIntoAEL(lb, null);
+            InsertEdgeIntoAEL(rb, lb);
+            SetWindingCount(lb);
+            rb.WindCnt = lb.WindCnt;
+            rb.WindCnt2 = lb.WindCnt2;
+            if (IsContributing(lb))
+              Op1 = AddLocalMinPoly(lb, rb, lb.Bot);
+            InsertScanbeam(lb.Top.Y);
+          }
+
+          if (rb != null)
+          {
+            if (IsHorizontal(rb))
+            {
+              if (rb.NextInLML != null)
+                InsertScanbeam(rb.NextInLML.Top.Y);
+              AddEdgeToSEL(rb);
+            }
+            else
+              InsertScanbeam(rb.Top.Y);
+          }
+
+        if (lb == null || rb == null) continue;
+
+          //if output polygons share an Edge with a horizontal rb, they'll need joining later ...
+          if (Op1 != null && IsHorizontal(rb) && 
+            m_GhostJoins.Count > 0 && rb.WindDelta != 0)
+          {
+            for (int i = 0; i < m_GhostJoins.Count; i++)
+            {
+              //if the horizontal Rb and a 'ghost' horizontal overlap, then convert
+              //the 'ghost' join to a real join ready for later ...
+              Join j = m_GhostJoins[i];
+              if (HorzSegmentsOverlap(j.OutPt1.Pt.X, j.OffPt.X, rb.Bot.X, rb.Top.X))
+                AddJoin(j.OutPt1, Op1, j.OffPt);
+            }
+          }
+
+          if (lb.OutIdx >= 0 && lb.PrevInAEL != null &&
+            lb.PrevInAEL.Curr.X == lb.Bot.X &&
+            lb.PrevInAEL.OutIdx >= 0 &&
+            SlopesEqual(lb.PrevInAEL.Curr, lb.PrevInAEL.Top, lb.Curr, lb.Top, m_UseFullRange) &&
+            lb.WindDelta != 0 && lb.PrevInAEL.WindDelta != 0)
+          {
+            OutPt Op2 = AddOutPt(lb.PrevInAEL, lb.Bot);
+            AddJoin(Op1, Op2, lb.Top);
+          }
+
+          if( lb.NextInAEL != rb )
+          {
+
+            if (rb.OutIdx >= 0 && rb.PrevInAEL.OutIdx >= 0 &&
+              SlopesEqual(rb.PrevInAEL.Curr, rb.PrevInAEL.Top, rb.Curr, rb.Top, m_UseFullRange) &&
+              rb.WindDelta != 0 && rb.PrevInAEL.WindDelta != 0)
+            {
+              OutPt Op2 = AddOutPt(rb.PrevInAEL, rb.Bot);
+              AddJoin(Op1, Op2, rb.Top);
+            }
+
+            TEdge e = lb.NextInAEL;
+            if (e != null)
+              while (e != rb)
+              {
+                //nb: For calculating winding counts etc, IntersectEdges() assumes
+                //that param1 will be to the right of param2 ABOVE the intersection ...
+                IntersectEdges(rb, e, lb.Curr); //order important here
+                e = e.NextInAEL;
+              }
+          }
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void InsertEdgeIntoAEL(TEdge edge, TEdge startEdge)
+      {
+        if (m_ActiveEdges == null)
+        {
+          edge.PrevInAEL = null;
+          edge.NextInAEL = null;
+          m_ActiveEdges = edge;
+        }
+        else if (startEdge == null && E2InsertsBeforeE1(m_ActiveEdges, edge))
+        {
+          edge.PrevInAEL = null;
+          edge.NextInAEL = m_ActiveEdges;
+          m_ActiveEdges.PrevInAEL = edge;
+          m_ActiveEdges = edge;
+        }
+        else
+        {
+          if (startEdge == null) startEdge = m_ActiveEdges;
+          while (startEdge.NextInAEL != null &&
+            !E2InsertsBeforeE1(startEdge.NextInAEL, edge))
+            startEdge = startEdge.NextInAEL;
+          edge.NextInAEL = startEdge.NextInAEL;
+          if (startEdge.NextInAEL != null) startEdge.NextInAEL.PrevInAEL = edge;
+          edge.PrevInAEL = startEdge;
+          startEdge.NextInAEL = edge;
+        }
+      }
+      //----------------------------------------------------------------------
+
+      private bool E2InsertsBeforeE1(TEdge e1, TEdge e2)
+      {
+          if (e2.Curr.X == e1.Curr.X)
+          {
+              if (e2.Top.Y > e1.Top.Y)
+                  return e2.Top.X < TopX(e1, e2.Top.Y);
+              else return e1.Top.X > TopX(e2, e1.Top.Y);
+          }
+          else return e2.Curr.X < e1.Curr.X;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsEvenOddFillType(TEdge edge) 
+      {
+        if (edge.PolyTyp == PolyType.ptSubject)
+            return m_SubjFillType == PolyFillType.pftEvenOdd; 
+        else
+            return m_ClipFillType == PolyFillType.pftEvenOdd;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsEvenOddAltFillType(TEdge edge) 
+      {
+        if (edge.PolyTyp == PolyType.ptSubject)
+            return m_ClipFillType == PolyFillType.pftEvenOdd; 
+        else
+            return m_SubjFillType == PolyFillType.pftEvenOdd;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsContributing(TEdge edge)
+      {
+          PolyFillType pft, pft2;
+          if (edge.PolyTyp == PolyType.ptSubject)
+          {
+              pft = m_SubjFillType;
+              pft2 = m_ClipFillType;
+          }
+          else
+          {
+              pft = m_ClipFillType;
+              pft2 = m_SubjFillType;
+          }
+
+          switch (pft)
+          {
+              case PolyFillType.pftEvenOdd:
+                  //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 PolyFillType.pftNonZero:
+                  if (Math.Abs(edge.WindCnt) != 1) return false;
+                  break;
+              case PolyFillType.pftPositive:
+                  if (edge.WindCnt != 1) return false;
+                  break;
+              default: //PolyFillType.pftNegative
+                  if (edge.WindCnt != -1) return false; 
+                  break;
+          }
+
+          switch (m_ClipType)
+          {
+            case ClipType.ctIntersection:
+                switch (pft2)
+                {
+                    case PolyFillType.pftEvenOdd:
+                    case PolyFillType.pftNonZero:
+                        return (edge.WindCnt2 != 0);
+                    case PolyFillType.pftPositive:
+                        return (edge.WindCnt2 > 0);
+                    default:
+                        return (edge.WindCnt2 < 0);
+                }
+            case ClipType.ctUnion:
+                switch (pft2)
+                {
+                    case PolyFillType.pftEvenOdd:
+                    case PolyFillType.pftNonZero:
+                        return (edge.WindCnt2 == 0);
+                    case PolyFillType.pftPositive:
+                        return (edge.WindCnt2 <= 0);
+                    default:
+                        return (edge.WindCnt2 >= 0);
+                }
+            case ClipType.ctDifference:
+                if (edge.PolyTyp == PolyType.ptSubject)
+                    switch (pft2)
+                    {
+                        case PolyFillType.pftEvenOdd:
+                        case PolyFillType.pftNonZero:
+                            return (edge.WindCnt2 == 0);
+                        case PolyFillType.pftPositive:
+                            return (edge.WindCnt2 <= 0);
+                        default:
+                            return (edge.WindCnt2 >= 0);
+                    }
+                else
+                    switch (pft2)
+                    {
+                        case PolyFillType.pftEvenOdd:
+                        case PolyFillType.pftNonZero:
+                            return (edge.WindCnt2 != 0);
+                        case PolyFillType.pftPositive:
+                            return (edge.WindCnt2 > 0);
+                        default:
+                            return (edge.WindCnt2 < 0);
+                    }
+            case ClipType.ctXor:
+                if (edge.WindDelta == 0) //XOr always contributing unless open
+                  switch (pft2)
+                  {
+                    case PolyFillType.pftEvenOdd:
+                    case PolyFillType.pftNonZero:
+                      return (edge.WindCnt2 == 0);
+                    case PolyFillType.pftPositive:
+                      return (edge.WindCnt2 <= 0);
+                    default:
+                      return (edge.WindCnt2 >= 0);
+                  }
+                else
+                  return true;
+          }
+          return true;
+      }
+      //------------------------------------------------------------------------------
+
+      private void SetWindingCount(TEdge edge)
+      {
+        TEdge e = edge.PrevInAEL;
+        //find the edge of the same polytype that immediately preceeds 'edge' in AEL
+        while (e != null && ((e.PolyTyp != edge.PolyTyp) || (e.WindDelta == 0))) e = e.PrevInAEL;
+        if (e == null)
+        {
+          PolyFillType pft;
+          pft = (edge.PolyTyp == PolyType.ptSubject ? m_SubjFillType : m_ClipFillType);
+          if (edge.WindDelta == 0) edge.WindCnt = (pft == PolyFillType.pftNegative ? -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 != ClipType.ctUnion)
+        {
+          edge.WindCnt = 1;
+          edge.WindCnt2 = e.WindCnt2;
+          e = e.NextInAEL; //ie get ready to calc WindCnt2
+        }
+        else if (IsEvenOddFillType(edge))
+        {
+          //EvenOdd filling ...
+          if (edge.WindDelta == 0)
+          {
+            //are we inside a subj polygon ...
+            bool Inside = true;
+            TEdge e2 = e.PrevInAEL;
+            while (e2 != null)
+            {
+              if (e2.PolyTyp == e.PolyTyp && e2.WindDelta != 0)
+                Inside = !Inside;
+              e2 = e2.PrevInAEL;
+            }
+            edge.WindCnt = (Inside ? 0 : 1);
+          }
+          else
+          {
+            edge.WindCnt = edge.WindDelta;
+          }
+          edge.WindCnt2 = e.WindCnt2;
+          e = e.NextInAEL; //ie get ready to calc WindCnt2
+        }
+        else
+        {
+          //nonZero, Positive or Negative filling ...
+          if (e.WindCnt * e.WindDelta < 0)
+          {
+            //prev edge is 'decreasing' WindCount (WC) toward zero
+            //so we're outside the previous polygon ...
+            if (Math.Abs(e.WindCnt) > 1)
+            {
+              //outside prev poly but still inside another.
+              //when reversing direction of prev poly use the same WC 
+              if (e.WindDelta * edge.WindDelta < 0) edge.WindCnt = e.WindCnt;
+              //otherwise continue to 'decrease' WC ...
+              else edge.WindCnt = e.WindCnt + edge.WindDelta;
+            }
+            else
+              //now outside all polys of same polytype so set own WC ...
+              edge.WindCnt = (edge.WindDelta == 0 ? 1 : edge.WindDelta);
+          }
+          else
+          {
+            //prev edge is 'increasing' WindCount (WC) away from zero
+            //so we're inside the previous polygon ...
+            if (edge.WindDelta == 0)
+              edge.WindCnt = (e.WindCnt < 0 ? e.WindCnt - 1 : e.WindCnt + 1);
+            //if wind direction is reversing prev then use same WC
+            else if (e.WindDelta * edge.WindDelta < 0)
+              edge.WindCnt = e.WindCnt;
+            //otherwise add to WC ...
+            else edge.WindCnt = e.WindCnt + edge.WindDelta;
+          }
+          edge.WindCnt2 = e.WindCnt2;
+          e = e.NextInAEL; //ie get ready to calc WindCnt2
+        }
+
+        //update WindCnt2 ...
+        if (IsEvenOddAltFillType(edge))
+        {
+          //EvenOdd filling ...
+          while (e != edge)
+          {
+            if (e.WindDelta != 0)
+              edge.WindCnt2 = (edge.WindCnt2 == 0 ? 1 : 0);
+            e = e.NextInAEL;
+          }
+        }
+        else
+        {
+          //nonZero, Positive or Negative filling ...
+          while (e != edge)
+          {
+            edge.WindCnt2 += e.WindDelta;
+            e = e.NextInAEL;
+          }
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void AddEdgeToSEL(TEdge edge)
+      {
+        //SEL pointers in PEdge are use to build transient lists of horizontal edges.
+        //However, since we don't need to worry about processing order, all additions
+        //are made to the front of the list ...
+        if (m_SortedEdges == null)
+        {
+            m_SortedEdges = edge;
+            edge.PrevInSEL = null;
+            edge.NextInSEL = null;
+        }
+        else
+        {
+            edge.NextInSEL = m_SortedEdges;
+            edge.PrevInSEL = null;
+            m_SortedEdges.PrevInSEL = edge;
+            m_SortedEdges = edge;
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      internal Boolean PopEdgeFromSEL(out TEdge e)
+      {
+        //Pop edge from front of SEL (ie SEL is a FILO list)
+        e = m_SortedEdges;
+        if (e == null) return false;
+        TEdge oldE = e;
+        m_SortedEdges = e.NextInSEL;
+        if (m_SortedEdges != null) m_SortedEdges.PrevInSEL = null;
+        oldE.NextInSEL = null;
+        oldE.PrevInSEL = null;
+        return true;
+      }
+      //------------------------------------------------------------------------------
+     
+      private void CopyAELToSEL()
+      {
+          TEdge e = m_ActiveEdges;
+          m_SortedEdges = e;
+          while (e != null)
+          {
+              e.PrevInSEL = e.PrevInAEL;
+              e.NextInSEL = e.NextInAEL;
+              e = e.NextInAEL;
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private void SwapPositionsInSEL(TEdge edge1, TEdge edge2)
+      {
+          if (edge1.NextInSEL == null && edge1.PrevInSEL == null)
+              return;
+          if (edge2.NextInSEL == null && edge2.PrevInSEL == null)
+              return;
+
+          if (edge1.NextInSEL == edge2)
+          {
+              TEdge next = edge2.NextInSEL;
+              if (next != null)
+                  next.PrevInSEL = edge1;
+              TEdge prev = edge1.PrevInSEL;
+              if (prev != null)
+                  prev.NextInSEL = edge2;
+              edge2.PrevInSEL = prev;
+              edge2.NextInSEL = edge1;
+              edge1.PrevInSEL = edge2;
+              edge1.NextInSEL = next;
+          }
+          else if (edge2.NextInSEL == edge1)
+          {
+              TEdge next = edge1.NextInSEL;
+              if (next != null)
+                  next.PrevInSEL = edge2;
+              TEdge prev = edge2.PrevInSEL;
+              if (prev != null)
+                  prev.NextInSEL = edge1;
+              edge1.PrevInSEL = prev;
+              edge1.NextInSEL = edge2;
+              edge2.PrevInSEL = edge1;
+              edge2.NextInSEL = next;
+          }
+          else
+          {
+              TEdge next = edge1.NextInSEL;
+              TEdge prev = edge1.PrevInSEL;
+              edge1.NextInSEL = edge2.NextInSEL;
+              if (edge1.NextInSEL != null)
+                  edge1.NextInSEL.PrevInSEL = edge1;
+              edge1.PrevInSEL = edge2.PrevInSEL;
+              if (edge1.PrevInSEL != null)
+                  edge1.PrevInSEL.NextInSEL = edge1;
+              edge2.NextInSEL = next;
+              if (edge2.NextInSEL != null)
+                  edge2.NextInSEL.PrevInSEL = edge2;
+              edge2.PrevInSEL = prev;
+              if (edge2.PrevInSEL != null)
+                  edge2.PrevInSEL.NextInSEL = edge2;
+          }
+
+          if (edge1.PrevInSEL == null)
+              m_SortedEdges = edge1;
+          else if (edge2.PrevInSEL == null)
+              m_SortedEdges = edge2;
+      }
+      //------------------------------------------------------------------------------
+
+
+      private void AddLocalMaxPoly(TEdge e1, TEdge e2, IntPoint pt)
+      {
+          AddOutPt(e1, pt);
+          if (e2.WindDelta == 0) AddOutPt(e2, pt);
+          if (e1.OutIdx == e2.OutIdx)
+          {
+              e1.OutIdx = Unassigned;
+              e2.OutIdx = Unassigned;
+          }
+          else if (e1.OutIdx < e2.OutIdx) 
+              AppendPolygon(e1, e2);
+          else 
+              AppendPolygon(e2, e1);
+      }
+      //------------------------------------------------------------------------------
+
+      private OutPt AddLocalMinPoly(TEdge e1, TEdge e2, IntPoint pt)
+      {
+        OutPt result;
+        TEdge e, prevE;
+        if (IsHorizontal(e2) || (e1.Dx > e2.Dx))
+        {
+          result = AddOutPt(e1, pt);
+          e2.OutIdx = e1.OutIdx;
+          e1.Side = EdgeSide.esLeft;
+          e2.Side = EdgeSide.esRight;
+          e = e1;
+          if (e.PrevInAEL == e2)
+            prevE = e2.PrevInAEL; 
+          else
+            prevE = e.PrevInAEL;
+        }
+        else
+        {
+          result = AddOutPt(e2, pt);
+          e1.OutIdx = e2.OutIdx;
+          e1.Side = EdgeSide.esRight;
+          e2.Side = EdgeSide.esLeft;
+          e = e2;
+          if (e.PrevInAEL == e1)
+              prevE = e1.PrevInAEL;
+          else
+              prevE = e.PrevInAEL;
+        }
+
+        if (prevE != null && prevE.OutIdx >= 0 && prevE.Top.Y < pt.Y && e.Top.Y < pt.Y)
+        {
+          cInt xPrev = TopX(prevE, pt.Y);
+          cInt xE = TopX(e, pt.Y);
+          if ((xPrev == xE) && (e.WindDelta != 0) && (prevE.WindDelta != 0) &&
+            SlopesEqual(new IntPoint(xPrev, pt.Y), prevE.Top, new IntPoint(xE, pt.Y), e.Top, m_UseFullRange))
+          {
+            OutPt outPt = AddOutPt(prevE, pt);
+            AddJoin(result, outPt, e.Top);
+          }
+        }
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private OutPt AddOutPt(TEdge e, IntPoint pt)
+      {
+          if (e.OutIdx < 0)
+          {
+              OutRec outRec = CreateOutRec();
+              outRec.IsOpen = (e.WindDelta == 0);
+              OutPt newOp = new OutPt();
+              outRec.Pts = newOp;
+              newOp.Idx = outRec.Idx;
+              newOp.Pt = pt;
+              newOp.Next = newOp;
+              newOp.Prev = newOp;
+              if (!outRec.IsOpen)
+                  SetHoleState(e, outRec);
+              e.OutIdx = outRec.Idx; //nb: do this after SetZ !
+              return newOp;
+          }
+          else
+          {
+              OutRec outRec = m_PolyOuts[e.OutIdx];
+              //OutRec.Pts is the 'Left-most' point & OutRec.Pts.Prev is the 'Right-most'
+              OutPt op = outRec.Pts;
+              bool ToFront = (e.Side == EdgeSide.esLeft);
+              if (ToFront && pt == op.Pt) return op;
+              else if (!ToFront && pt == op.Prev.Pt) return op.Prev;
+
+              OutPt newOp = new OutPt();
+              newOp.Idx = outRec.Idx;
+              newOp.Pt = pt;
+              newOp.Next = op;
+              newOp.Prev = op.Prev;
+              newOp.Prev.Next = newOp;
+              op.Prev = newOp;
+              if (ToFront) outRec.Pts = newOp;
+              return newOp;
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private OutPt GetLastOutPt(TEdge e)
+      {
+        OutRec outRec = m_PolyOuts[e.OutIdx];
+        if (e.Side == EdgeSide.esLeft) 
+            return outRec.Pts;
+        else
+            return outRec.Pts.Prev;
+      }
+      //------------------------------------------------------------------------------
+
+      internal void SwapPoints(ref IntPoint pt1, ref IntPoint pt2)
+      {
+          IntPoint tmp = new IntPoint(pt1);
+          pt1 = pt2;
+          pt2 = tmp;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool HorzSegmentsOverlap(cInt seg1a, cInt seg1b, cInt seg2a, cInt seg2b)
+      {
+        if (seg1a > seg1b) Swap(ref seg1a, ref seg1b);
+        if (seg2a > seg2b) Swap(ref seg2a, ref seg2b);
+        return (seg1a < seg2b) && (seg2a < seg1b);
+      }
+      //------------------------------------------------------------------------------
+  
+      private void SetHoleState(TEdge e, OutRec outRec)
+      {
+        TEdge e2 = e.PrevInAEL;
+        TEdge eTmp = null;  
+        while (e2 != null)
+          {
+            if (e2.OutIdx >= 0 && e2.WindDelta != 0) 
+            {
+              if (eTmp == null)
+                eTmp = e2;
+              else if (eTmp.OutIdx == e2.OutIdx)
+                eTmp = null; //paired               
+            }
+            e2 = e2.PrevInAEL;
+          }
+
+        if (eTmp == null)
+        {
+          outRec.FirstLeft = null;
+          outRec.IsHole = false;
+        }
+        else
+        {
+          outRec.FirstLeft = m_PolyOuts[eTmp.OutIdx];
+          outRec.IsHole = !outRec.FirstLeft.IsHole;
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private double GetDx(IntPoint pt1, IntPoint pt2)
+      {
+          if (pt1.Y == pt2.Y) return horizontal;
+          else return (double)(pt2.X - pt1.X) / (pt2.Y - pt1.Y);
+      }
+      //---------------------------------------------------------------------------
+
+      private bool FirstIsBottomPt(OutPt btmPt1, OutPt btmPt2)
+      {
+        OutPt p = btmPt1.Prev;
+        while ((p.Pt == btmPt1.Pt) && (p != btmPt1)) p = p.Prev;
+        double dx1p = Math.Abs(GetDx(btmPt1.Pt, p.Pt));
+        p = btmPt1.Next;
+        while ((p.Pt == btmPt1.Pt) && (p != btmPt1)) p = p.Next;
+        double dx1n = Math.Abs(GetDx(btmPt1.Pt, p.Pt));
+
+        p = btmPt2.Prev;
+        while ((p.Pt == btmPt2.Pt) && (p != btmPt2)) p = p.Prev;
+        double dx2p = Math.Abs(GetDx(btmPt2.Pt, p.Pt));
+        p = btmPt2.Next;
+        while ((p.Pt == btmPt2.Pt) && (p != btmPt2)) p = p.Next;
+        double dx2n = Math.Abs(GetDx(btmPt2.Pt, p.Pt));
+
+        if (Math.Max(dx1p, dx1n) == Math.Max(dx2p, dx2n) &&
+          Math.Min(dx1p, dx1n) == Math.Min(dx2p, dx2n))
+          return Area(btmPt1) > 0; //if otherwise identical use orientation
+        else
+          return (dx1p >= dx2p && dx1p >= dx2n) || (dx1n >= dx2p && dx1n >= dx2n);
+      }
+      //------------------------------------------------------------------------------
+
+      private OutPt GetBottomPt(OutPt pp)
+      {
+        OutPt dups = null;
+        OutPt p = pp.Next;
+        while (p != pp)
+        {
+          if (p.Pt.Y > pp.Pt.Y)
+          {
+            pp = p;
+            dups = null;
+          }
+          else if (p.Pt.Y == pp.Pt.Y && p.Pt.X <= pp.Pt.X)
+          {
+            if (p.Pt.X < pp.Pt.X)
+            {
+                dups = null;
+                pp = p;
+            } else
+            {
+              if (p.Next != pp && p.Prev != pp) dups = p;
+            }
+          }
+          p = p.Next;
+        }
+        if (dups != null)
+        {
+          //there appears to be at least 2 vertices at bottomPt so ...
+          while (dups != p)
+          {
+            if (!FirstIsBottomPt(p, dups)) pp = dups;
+            dups = dups.Next;
+            while (dups.Pt != pp.Pt) dups = dups.Next;
+          }
+        }
+        return pp;
+      }
+      //------------------------------------------------------------------------------
+
+      private OutRec GetLowermostRec(OutRec outRec1, OutRec outRec2)
+      {
+          //work out which polygon fragment has the correct hole state ...
+          if (outRec1.BottomPt == null) 
+              outRec1.BottomPt = GetBottomPt(outRec1.Pts);
+          if (outRec2.BottomPt == null) 
+              outRec2.BottomPt = GetBottomPt(outRec2.Pts);
+          OutPt bPt1 = outRec1.BottomPt;
+          OutPt bPt2 = outRec2.BottomPt;
+          if (bPt1.Pt.Y > bPt2.Pt.Y) return outRec1;
+          else if (bPt1.Pt.Y < bPt2.Pt.Y) return outRec2;
+          else if (bPt1.Pt.X < bPt2.Pt.X) return outRec1;
+          else if (bPt1.Pt.X > bPt2.Pt.X) return outRec2;
+          else if (bPt1.Next == bPt1) return outRec2;
+          else if (bPt2.Next == bPt2) return outRec1;
+          else if (FirstIsBottomPt(bPt1, bPt2)) return outRec1;
+          else return outRec2;
+      }
+      //------------------------------------------------------------------------------
+
+      bool OutRec1RightOfOutRec2(OutRec outRec1, OutRec outRec2)
+      {
+          do
+          {
+              outRec1 = outRec1.FirstLeft;
+              if (outRec1 == outRec2) return true;
+          } while (outRec1 != null);
+          return false;
+      }
+      //------------------------------------------------------------------------------
+
+      private OutRec GetOutRec(int idx)
+      {
+        OutRec outrec = m_PolyOuts[idx];
+        while (outrec != m_PolyOuts[outrec.Idx])
+          outrec = m_PolyOuts[outrec.Idx];
+        return outrec;
+      }
+      //------------------------------------------------------------------------------
+
+      private void AppendPolygon(TEdge e1, TEdge e2)
+      {
+        OutRec outRec1 = m_PolyOuts[e1.OutIdx];
+        OutRec outRec2 = m_PolyOuts[e2.OutIdx];
+
+        OutRec holeStateRec;
+        if (OutRec1RightOfOutRec2(outRec1, outRec2)) 
+            holeStateRec = outRec2;
+        else if (OutRec1RightOfOutRec2(outRec2, outRec1))
+            holeStateRec = outRec1;
+        else
+            holeStateRec = GetLowermostRec(outRec1, outRec2);
+
+        //get the start and ends of both output polygons and
+        //join E2 poly onto E1 poly and delete pointers to E2 ...
+        OutPt p1_lft = outRec1.Pts;
+        OutPt p1_rt = p1_lft.Prev;
+        OutPt p2_lft = outRec2.Pts;
+        OutPt p2_rt = p2_lft.Prev;
+
+        //join e2 poly onto e1 poly and delete pointers to e2 ...
+        if(  e1.Side == EdgeSide.esLeft )
+        {
+          if (e2.Side == EdgeSide.esLeft)
+          {
+            //z y x a b c
+            ReversePolyPtLinks(p2_lft);
+            p2_lft.Next = p1_lft;
+            p1_lft.Prev = p2_lft;
+            p1_rt.Next = p2_rt;
+            p2_rt.Prev = p1_rt;
+            outRec1.Pts = p2_rt;
+          } else
+          {
+            //x y z a b c
+            p2_rt.Next = p1_lft;
+            p1_lft.Prev = p2_rt;
+            p2_lft.Prev = p1_rt;
+            p1_rt.Next = p2_lft;
+            outRec1.Pts = p2_lft;
+          }
+        } else
+        {
+          if (e2.Side == EdgeSide.esRight)
+          {
+            //a b c z y x
+            ReversePolyPtLinks( p2_lft );
+            p1_rt.Next = p2_rt;
+            p2_rt.Prev = p1_rt;
+            p2_lft.Next = p1_lft;
+            p1_lft.Prev = p2_lft;
+          } else
+          {
+            //a b c x y z
+            p1_rt.Next = p2_lft;
+            p2_lft.Prev = p1_rt;
+            p1_lft.Prev = p2_rt;
+            p2_rt.Next = p1_lft;
+          }
+        }
+
+        outRec1.BottomPt = null; 
+        if (holeStateRec == outRec2)
+        {
+            if (outRec2.FirstLeft != outRec1)
+                outRec1.FirstLeft = outRec2.FirstLeft;
+            outRec1.IsHole = outRec2.IsHole;
+        }
+        outRec2.Pts = null;
+        outRec2.BottomPt = null;
+
+        outRec2.FirstLeft = outRec1;
+
+        int OKIdx = e1.OutIdx;
+        int ObsoleteIdx = e2.OutIdx;
+
+        e1.OutIdx = Unassigned; //nb: safe because we only get here via AddLocalMaxPoly
+        e2.OutIdx = Unassigned;
+
+        TEdge e = m_ActiveEdges;
+        while( e != null )
+        {
+          if( e.OutIdx == ObsoleteIdx )
+          {
+            e.OutIdx = OKIdx;
+            e.Side = e1.Side;
+            break;
+          }
+          e = e.NextInAEL;
+        }
+        outRec2.Idx = outRec1.Idx;
+      }
+      //------------------------------------------------------------------------------
+
+      private void ReversePolyPtLinks(OutPt pp)
+      {
+          if (pp == null) return;
+          OutPt pp1;
+          OutPt pp2;
+          pp1 = pp;
+          do
+          {
+              pp2 = pp1.Next;
+              pp1.Next = pp1.Prev;
+              pp1.Prev = pp2;
+              pp1 = pp2;
+          } while (pp1 != pp);
+      }
+      //------------------------------------------------------------------------------
+
+      private static void SwapSides(TEdge edge1, TEdge edge2)
+      {
+          EdgeSide side = edge1.Side;
+          edge1.Side = edge2.Side;
+          edge2.Side = side;
+      }
+      //------------------------------------------------------------------------------
+
+      private static void SwapPolyIndexes(TEdge edge1, TEdge edge2)
+      {
+          int outIdx = edge1.OutIdx;
+          edge1.OutIdx = edge2.OutIdx;
+          edge2.OutIdx = outIdx;
+      }
+      //------------------------------------------------------------------------------
+
+      private void IntersectEdges(TEdge e1, TEdge e2, IntPoint pt)
+      {
+          //e1 will be to the left of e2 BELOW the intersection. Therefore e1 is before
+          //e2 in AEL except when e1 is being inserted at the intersection point ...
+
+        bool e1Contributing = (e1.OutIdx >= 0);
+        bool e2Contributing = (e2.OutIdx >= 0);
+
+#if use_xyz
+          SetZ(ref pt, e1, e2);
+#endif
+
+#if use_lines
+          //if either edge is on an OPEN path ...
+          if (e1.WindDelta == 0 || e2.WindDelta == 0)
+          {
+            //ignore subject-subject open path intersections UNLESS they
+            //are both open paths, AND they are both 'contributing maximas' ...
+            if (e1.WindDelta == 0 && e2.WindDelta == 0) return;
+            //if intersecting a subj line with a subj poly ...
+            else if (e1.PolyTyp == e2.PolyTyp && 
+              e1.WindDelta != e2.WindDelta && m_ClipType == ClipType.ctUnion)
+            {
+              if (e1.WindDelta == 0)
+              {
+                if (e2Contributing)
+                {
+                  AddOutPt(e1, pt);
+                  if (e1Contributing) e1.OutIdx = Unassigned;
+                }
+              }
+              else
+              {
+                if (e1Contributing)
+                {
+                  AddOutPt(e2, pt);
+                  if (e2Contributing) e2.OutIdx = Unassigned;
+                }
+              }
+            }
+            else if (e1.PolyTyp != e2.PolyTyp)
+            {
+              if ((e1.WindDelta == 0) && Math.Abs(e2.WindCnt) == 1 && 
+                (m_ClipType != ClipType.ctUnion || e2.WindCnt2 == 0))
+              {
+                AddOutPt(e1, pt);
+                if (e1Contributing) e1.OutIdx = Unassigned;
+              }
+              else if ((e2.WindDelta == 0) && (Math.Abs(e1.WindCnt) == 1) && 
+                (m_ClipType != ClipType.ctUnion || e1.WindCnt2 == 0))
+              {
+                AddOutPt(e2, pt);
+                if (e2Contributing) e2.OutIdx = Unassigned;
+              }
+            }
+            return;
+          }
+#endif
+
+          //update winding counts...
+  //assumes that e1 will be to the Right of e2 ABOVE the intersection
+          if (e1.PolyTyp == e2.PolyTyp)
+          {
+              if (IsEvenOddFillType(e1))
+              {
+                  int oldE1WindCnt = e1.WindCnt;
+                  e1.WindCnt = e2.WindCnt;
+                  e2.WindCnt = oldE1WindCnt;
+              }
+              else
+              {
+                  if (e1.WindCnt + e2.WindDelta == 0) e1.WindCnt = -e1.WindCnt;
+                  else e1.WindCnt += e2.WindDelta;
+                  if (e2.WindCnt - e1.WindDelta == 0) e2.WindCnt = -e2.WindCnt;
+                  else e2.WindCnt -= e1.WindDelta;
+              }
+          }
+          else
+          {
+              if (!IsEvenOddFillType(e2)) e1.WindCnt2 += e2.WindDelta;
+              else e1.WindCnt2 = (e1.WindCnt2 == 0) ? 1 : 0;
+              if (!IsEvenOddFillType(e1)) e2.WindCnt2 -= e1.WindDelta;
+              else e2.WindCnt2 = (e2.WindCnt2 == 0) ? 1 : 0;
+          }
+
+          PolyFillType e1FillType, e2FillType, e1FillType2, e2FillType2;
+          if (e1.PolyTyp == PolyType.ptSubject)
+          {
+              e1FillType = m_SubjFillType;
+              e1FillType2 = m_ClipFillType;
+          }
+          else
+          {
+              e1FillType = m_ClipFillType;
+              e1FillType2 = m_SubjFillType;
+          }
+          if (e2.PolyTyp == PolyType.ptSubject)
+          {
+              e2FillType = m_SubjFillType;
+              e2FillType2 = m_ClipFillType;
+          }
+          else
+          {
+              e2FillType = m_ClipFillType;
+              e2FillType2 = m_SubjFillType;
+          }
+
+          int e1Wc, e2Wc;
+          switch (e1FillType)
+          {
+              case PolyFillType.pftPositive: e1Wc = e1.WindCnt; break;
+              case PolyFillType.pftNegative: e1Wc = -e1.WindCnt; break;
+              default: e1Wc = Math.Abs(e1.WindCnt); break;
+          }
+          switch (e2FillType)
+          {
+              case PolyFillType.pftPositive: e2Wc = e2.WindCnt; break;
+              case PolyFillType.pftNegative: e2Wc = -e2.WindCnt; break;
+              default: e2Wc = Math.Abs(e2.WindCnt); break;
+          }
+
+          if (e1Contributing && e2Contributing)
+          {
+            if ((e1Wc != 0 && e1Wc != 1) || (e2Wc != 0 && e2Wc != 1) ||
+              (e1.PolyTyp != e2.PolyTyp && m_ClipType != ClipType.ctXor))
+            {
+              AddLocalMaxPoly(e1, e2, pt);
+            }
+            else
+            {
+              AddOutPt(e1, pt);
+              AddOutPt(e2, pt);
+              SwapSides(e1, e2);
+              SwapPolyIndexes(e1, e2);
+            }
+          }
+          else if (e1Contributing)
+          {
+              if (e2Wc == 0 || e2Wc == 1)
+              {
+                AddOutPt(e1, pt);
+                SwapSides(e1, e2);
+                SwapPolyIndexes(e1, e2);
+              }
+
+          }
+          else if (e2Contributing)
+          {
+              if (e1Wc == 0 || e1Wc == 1)
+              {
+                AddOutPt(e2, pt);
+                SwapSides(e1, e2);
+                SwapPolyIndexes(e1, e2);
+              }
+          }
+          else if ( (e1Wc == 0 || e1Wc == 1) && (e2Wc == 0 || e2Wc == 1))
+          {
+              //neither edge is currently contributing ...
+              cInt e1Wc2, e2Wc2;
+              switch (e1FillType2)
+              {
+                  case PolyFillType.pftPositive: e1Wc2 = e1.WindCnt2; break;
+                  case PolyFillType.pftNegative: e1Wc2 = -e1.WindCnt2; break;
+                  default: e1Wc2 = Math.Abs(e1.WindCnt2); break;
+              }
+              switch (e2FillType2)
+              {
+                  case PolyFillType.pftPositive: e2Wc2 = e2.WindCnt2; break;
+                  case PolyFillType.pftNegative: e2Wc2 = -e2.WindCnt2; break;
+                  default: e2Wc2 = Math.Abs(e2.WindCnt2); break;
+              }
+
+              if (e1.PolyTyp != e2.PolyTyp)
+              {
+                AddLocalMinPoly(e1, e2, pt);
+              }
+              else if (e1Wc == 1 && e2Wc == 1)
+                switch (m_ClipType)
+                {
+                  case ClipType.ctIntersection:
+                    if (e1Wc2 > 0 && e2Wc2 > 0)
+                      AddLocalMinPoly(e1, e2, pt);
+                    break;
+                  case ClipType.ctUnion:
+                    if (e1Wc2 <= 0 && e2Wc2 <= 0)
+                      AddLocalMinPoly(e1, e2, pt);
+                    break;
+                  case ClipType.ctDifference:
+                    if (((e1.PolyTyp == PolyType.ptClip) && (e1Wc2 > 0) && (e2Wc2 > 0)) ||
+                        ((e1.PolyTyp == PolyType.ptSubject) && (e1Wc2 <= 0) && (e2Wc2 <= 0)))
+                          AddLocalMinPoly(e1, e2, pt);
+                    break;
+                  case ClipType.ctXor:
+                    AddLocalMinPoly(e1, e2, pt);
+                    break;
+                }
+              else
+                SwapSides(e1, e2);
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private void DeleteFromSEL(TEdge e)
+      {
+          TEdge SelPrev = e.PrevInSEL;
+          TEdge SelNext = e.NextInSEL;
+          if (SelPrev == null && SelNext == null && (e != m_SortedEdges))
+              return; //already deleted
+          if (SelPrev != null)
+              SelPrev.NextInSEL = SelNext;
+          else m_SortedEdges = SelNext;
+          if (SelNext != null)
+              SelNext.PrevInSEL = SelPrev;
+          e.NextInSEL = null;
+          e.PrevInSEL = null;
+      }
+      //------------------------------------------------------------------------------
+
+      private void ProcessHorizontals()
+      {
+          TEdge horzEdge; //m_SortedEdges;
+          while (PopEdgeFromSEL(out horzEdge))
+            ProcessHorizontal(horzEdge);
+      }
+      //------------------------------------------------------------------------------
+
+      void GetHorzDirection(TEdge HorzEdge, out Direction Dir, out cInt Left, out cInt Right)
+      {
+        if (HorzEdge.Bot.X < HorzEdge.Top.X)
+        {
+          Left = HorzEdge.Bot.X;
+          Right = HorzEdge.Top.X;
+          Dir = Direction.dLeftToRight;
+        } else
+        {
+          Left = HorzEdge.Top.X;
+          Right = HorzEdge.Bot.X;
+          Dir = Direction.dRightToLeft;
+        }
+      }
+      //------------------------------------------------------------------------
+
+      private void ProcessHorizontal(TEdge horzEdge)
+      {
+        Direction dir;
+        cInt horzLeft, horzRight;
+        bool IsOpen = horzEdge.WindDelta == 0;
+
+        GetHorzDirection(horzEdge, out dir, out horzLeft, out horzRight);
+
+        TEdge eLastHorz = horzEdge, eMaxPair = null;
+        while (eLastHorz.NextInLML != null && IsHorizontal(eLastHorz.NextInLML)) 
+          eLastHorz = eLastHorz.NextInLML;
+        if (eLastHorz.NextInLML == null)
+          eMaxPair = GetMaximaPair(eLastHorz);
+
+        Maxima currMax = m_Maxima;
+        if (currMax != null)
+        {
+            //get the first maxima in range (X) ...
+            if (dir == Direction.dLeftToRight)
+            {
+              while (currMax != null && currMax.X <= horzEdge.Bot.X)
+                  currMax = currMax.Next;
+              if (currMax != null && currMax.X >= eLastHorz.Top.X) 
+                  currMax = null;
+            }
+            else
+            {
+              while (currMax.Next != null && currMax.Next.X < horzEdge.Bot.X) 
+                  currMax = currMax.Next;
+              if (currMax.X <= eLastHorz.Top.X) currMax = null;
+            }
+        }
+
+        OutPt op1 = null;
+        for (;;) //loop through consec. horizontal edges
+        {
+          bool IsLastHorz = (horzEdge == eLastHorz);
+          TEdge e = GetNextInAEL(horzEdge, dir);
+          while(e != null)
+          {
+
+              //this code block inserts extra coords into horizontal edges (in output
+              //polygons) whereever maxima touch these horizontal edges. This helps
+              //'simplifying' polygons (ie if the Simplify property is set).
+              if (currMax != null)
+              {
+                  if (dir == Direction.dLeftToRight)
+                  {
+                      while (currMax != null && currMax.X < e.Curr.X) 
+                      {
+                        if (horzEdge.OutIdx >= 0 && !IsOpen) 
+                          AddOutPt(horzEdge, new IntPoint(currMax.X, horzEdge.Bot.Y));
+                        currMax = currMax.Next;                  
+                      }
+                  }
+                  else
+                  {
+                      while (currMax != null && currMax.X > e.Curr.X)
+                      {
+                          if (horzEdge.OutIdx >= 0 && !IsOpen)
+                            AddOutPt(horzEdge, new IntPoint(currMax.X, horzEdge.Bot.Y));
+                        currMax = currMax.Prev;
+                      }
+                  }
+              };
+
+              if ((dir == Direction.dLeftToRight && e.Curr.X > horzRight) ||
+                (dir == Direction.dRightToLeft && 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.
+              if (e.Curr.X == horzEdge.Top.X && horzEdge.NextInLML != null && 
+                e.Dx < horzEdge.NextInLML.Dx) break;
+
+              if (horzEdge.OutIdx >= 0 && !IsOpen)  //note: may be done multiple times
+              {
+#if use_xyz
+                  if (dir == Direction.dLeftToRight) SetZ(ref e.Curr, horzEdge, e);
+                  else SetZ(ref e.Curr, e, horzEdge);
+#endif
+
+                  op1 = AddOutPt(horzEdge, e.Curr);
+                  TEdge eNextHorz = m_SortedEdges;
+                  while (eNextHorz != null)
+                  {
+                      if (eNextHorz.OutIdx >= 0 &&
+                        HorzSegmentsOverlap(horzEdge.Bot.X,
+                        horzEdge.Top.X, eNextHorz.Bot.X, eNextHorz.Top.X))
+                      {
+                          OutPt op2 = GetLastOutPt(eNextHorz);
+                          AddJoin(op2, op1, eNextHorz.Top);
+                      }
+                      eNextHorz = eNextHorz.NextInSEL;
+                  }
+                  AddGhostJoin(op1, horzEdge.Bot);
+              }
+            
+              //OK, so far we're still in range of the horizontal Edge  but make sure
+              //we're at the last of consec. horizontals when matching with eMaxPair
+              if(e == eMaxPair && IsLastHorz)
+              {
+                if (horzEdge.OutIdx >= 0)
+                  AddLocalMaxPoly(horzEdge, eMaxPair, horzEdge.Top);
+                DeleteFromAEL(horzEdge);
+                DeleteFromAEL(eMaxPair);
+                return;
+              }
+              
+              if(dir == Direction.dLeftToRight)
+              {
+                IntPoint Pt = new IntPoint(e.Curr.X, horzEdge.Curr.Y);
+                IntersectEdges(horzEdge, e, Pt);
+              }
+              else
+              {
+                IntPoint Pt = new IntPoint(e.Curr.X, horzEdge.Curr.Y);
+                IntersectEdges(e, horzEdge, Pt);
+              }
+              TEdge eNext = GetNextInAEL(e, dir);
+              SwapPositionsInAEL(horzEdge, e);
+              e = eNext;
+          } //end while(e != null)
+
+          //Break out of loop if HorzEdge.NextInLML is not also horizontal ...
+          if (horzEdge.NextInLML == null || !IsHorizontal(horzEdge.NextInLML)) break;
+
+          UpdateEdgeIntoAEL(ref horzEdge);
+          if (horzEdge.OutIdx >= 0) AddOutPt(horzEdge, horzEdge.Bot);
+          GetHorzDirection(horzEdge, out dir, out horzLeft, out horzRight);
+
+        } //end for (;;)
+
+        if (horzEdge.OutIdx >= 0 && op1 == null)
+        {
+            op1 = GetLastOutPt(horzEdge);
+            TEdge eNextHorz = m_SortedEdges;
+            while (eNextHorz != null)
+            {
+                if (eNextHorz.OutIdx >= 0 &&
+                  HorzSegmentsOverlap(horzEdge.Bot.X,
+                  horzEdge.Top.X, eNextHorz.Bot.X, eNextHorz.Top.X))
+                {
+                    OutPt op2 = GetLastOutPt(eNextHorz);
+                    AddJoin(op2, op1, eNextHorz.Top);
+                }
+                eNextHorz = eNextHorz.NextInSEL;
+            }
+            AddGhostJoin(op1, horzEdge.Top);
+        }
+
+        if (horzEdge.NextInLML != null)
+        {
+          if(horzEdge.OutIdx >= 0)
+          {
+            op1 = AddOutPt( horzEdge, horzEdge.Top);
+
+            UpdateEdgeIntoAEL(ref horzEdge);
+            if (horzEdge.WindDelta == 0) return;
+            //nb: HorzEdge is no longer horizontal here
+            TEdge ePrev = horzEdge.PrevInAEL;
+            TEdge eNext = horzEdge.NextInAEL;
+            if (ePrev != null && ePrev.Curr.X == horzEdge.Bot.X &&
+              ePrev.Curr.Y == horzEdge.Bot.Y && ePrev.WindDelta != 0 &&
+              (ePrev.OutIdx >= 0 && ePrev.Curr.Y > ePrev.Top.Y &&
+              SlopesEqual(horzEdge, ePrev, m_UseFullRange)))
+            {
+              OutPt op2 = AddOutPt(ePrev, horzEdge.Bot);
+              AddJoin(op1, op2, horzEdge.Top);
+            }
+            else if (eNext != null && eNext.Curr.X == horzEdge.Bot.X &&
+              eNext.Curr.Y == horzEdge.Bot.Y && eNext.WindDelta != 0 &&
+              eNext.OutIdx >= 0 && eNext.Curr.Y > eNext.Top.Y &&
+              SlopesEqual(horzEdge, eNext, m_UseFullRange))
+            {
+              OutPt op2 = AddOutPt(eNext, horzEdge.Bot);
+              AddJoin(op1, op2, horzEdge.Top);
+            }
+          }
+          else
+            UpdateEdgeIntoAEL(ref horzEdge); 
+        }
+        else
+        {
+          if (horzEdge.OutIdx >= 0) AddOutPt(horzEdge, horzEdge.Top);
+          DeleteFromAEL(horzEdge);
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private TEdge GetNextInAEL(TEdge e, Direction Direction)
+      {
+          return Direction == Direction.dLeftToRight ? e.NextInAEL: e.PrevInAEL;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsMinima(TEdge e)
+      {
+          return e != null && (e.Prev.NextInLML != e) && (e.Next.NextInLML != e);
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsMaxima(TEdge e, double Y)
+      {
+          return (e != null && e.Top.Y == Y && e.NextInLML == null);
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsIntermediate(TEdge e, double Y)
+      {
+          return (e.Top.Y == Y && e.NextInLML != null);
+      }
+      //------------------------------------------------------------------------------
+
+      internal TEdge GetMaximaPair(TEdge e)
+      {
+        if ((e.Next.Top == e.Top) && e.Next.NextInLML == null)
+          return e.Next;
+        else if ((e.Prev.Top == e.Top) && e.Prev.NextInLML == null)
+          return e.Prev;
+        else 
+					return null;
+      }
+      //------------------------------------------------------------------------------
+
+      internal TEdge GetMaximaPairEx(TEdge e)
+      {
+        //as above but returns null if MaxPair isn't in AEL (unless it's horizontal)
+        TEdge result = GetMaximaPair(e);
+        if (result == null || result.OutIdx == Skip ||
+          ((result.NextInAEL == result.PrevInAEL) && !IsHorizontal(result))) return null;
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool ProcessIntersections(cInt topY)
+      {
+        if( m_ActiveEdges == null ) return true;
+        try {
+          BuildIntersectList(topY);
+          if ( m_IntersectList.Count == 0) return true;
+          if (m_IntersectList.Count == 1 || FixupIntersectionOrder()) 
+              ProcessIntersectList();
+          else 
+              return false;
+        }
+        catch {
+          m_SortedEdges = null;
+          m_IntersectList.Clear();
+          throw new ClipperException("ProcessIntersections error");
+        }
+        m_SortedEdges = null;
+        return true;
+      }
+      //------------------------------------------------------------------------------
+
+      private void BuildIntersectList(cInt topY)
+      {
+        if ( m_ActiveEdges == null ) return;
+
+        //prepare for sorting ...
+        TEdge e = m_ActiveEdges;
+        m_SortedEdges = e;
+        while( e != null )
+        {
+          e.PrevInSEL = e.PrevInAEL;
+          e.NextInSEL = e.NextInAEL;
+          e.Curr.X = TopX( e, topY );
+          e = e.NextInAEL;
+        }
+
+        //bubblesort ...
+        bool isModified = true;
+        while( isModified && m_SortedEdges != null )
+        {
+          isModified = false;
+          e = m_SortedEdges;
+          while( e.NextInSEL != null )
+          {
+            TEdge eNext = e.NextInSEL;
+            IntPoint pt;
+            if (e.Curr.X > eNext.Curr.X)
+            {
+                IntersectPoint(e, eNext, out pt);
+                if (pt.Y < topY)
+                  pt = new IntPoint(TopX(e, topY), topY);
+                IntersectNode newNode = new IntersectNode();
+                newNode.Edge1 = e;
+                newNode.Edge2 = eNext;
+                newNode.Pt = pt;
+                m_IntersectList.Add(newNode);
+
+                SwapPositionsInSEL(e, eNext);
+                isModified = true;
+            }
+            else
+              e = eNext;
+          }
+          if( e.PrevInSEL != null ) e.PrevInSEL.NextInSEL = null;
+          else break;
+        }
+        m_SortedEdges = null;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool EdgesAdjacent(IntersectNode inode)
+      {
+        return (inode.Edge1.NextInSEL == inode.Edge2) ||
+          (inode.Edge1.PrevInSEL == inode.Edge2);
+      }
+      //------------------------------------------------------------------------------
+
+      private static int IntersectNodeSort(IntersectNode node1, IntersectNode node2)
+      {
+        //the following typecast is safe because the differences in Pt.Y will
+        //be limited to the height of the scanbeam.
+        return (int)(node2.Pt.Y - node1.Pt.Y); 
+      }
+      //------------------------------------------------------------------------------
+
+      private bool FixupIntersectionOrder()
+      {
+        //pre-condition: intersections are sorted bottom-most first.
+        //Now it's crucial that intersections are made only between adjacent edges,
+        //so to ensure this the order of intersections may need adjusting ...
+        m_IntersectList.Sort(m_IntersectNodeComparer);
+
+        CopyAELToSEL();
+        int cnt = m_IntersectList.Count;
+        for (int i = 0; i < cnt; i++)
+        {
+          if (!EdgesAdjacent(m_IntersectList[i]))
+          {
+            int j = i + 1;
+            while (j < cnt && !EdgesAdjacent(m_IntersectList[j])) j++;
+            if (j == cnt) return false;
+
+            IntersectNode tmp = m_IntersectList[i];
+            m_IntersectList[i] = m_IntersectList[j];
+            m_IntersectList[j] = tmp;
+
+          }
+          SwapPositionsInSEL(m_IntersectList[i].Edge1, m_IntersectList[i].Edge2);
+        }
+          return true;
+      }
+      //------------------------------------------------------------------------------
+
+      private void ProcessIntersectList()
+      {
+        for (int i = 0; i < m_IntersectList.Count; i++)
+        {
+          IntersectNode iNode = m_IntersectList[i];
+          {
+            IntersectEdges(iNode.Edge1, iNode.Edge2, iNode.Pt);
+            SwapPositionsInAEL(iNode.Edge1, iNode.Edge2);
+          }
+        }
+        m_IntersectList.Clear();
+      }
+      //------------------------------------------------------------------------------
+
+      internal static cInt Round(double value)
+      {
+          return value < 0 ? (cInt)(value - 0.5) : (cInt)(value + 0.5);
+      }
+      //------------------------------------------------------------------------------
+
+      private static cInt TopX(TEdge edge, cInt currentY)
+      {
+          if (currentY == edge.Top.Y)
+              return edge.Top.X;
+          return edge.Bot.X + Round(edge.Dx *(currentY - edge.Bot.Y));
+      }
+      //------------------------------------------------------------------------------
+
+      private void IntersectPoint(TEdge edge1, TEdge edge2, out IntPoint ip)
+      {
+        ip = new IntPoint();
+        double b1, b2;
+        //nb: with very large coordinate values, it's possible for SlopesEqual() to 
+        //return false but for the edge.Dx value be equal due to double precision rounding.
+        if (edge1.Dx == edge2.Dx)
+        {
+          ip.Y = edge1.Curr.Y;
+          ip.X = TopX(edge1, ip.Y);
+          return;
+        }
+
+        if (edge1.Delta.X == 0)
+        {
+            ip.X = edge1.Bot.X;
+            if (IsHorizontal(edge2))
+            {
+                ip.Y = edge2.Bot.Y;
+            }
+            else
+            {
+                b2 = edge2.Bot.Y - (edge2.Bot.X / edge2.Dx);
+                ip.Y = Round(ip.X / edge2.Dx + b2);
+            }
+        }
+        else if (edge2.Delta.X == 0)
+        {
+            ip.X = edge2.Bot.X;
+            if (IsHorizontal(edge1))
+            {
+                ip.Y = edge1.Bot.Y;
+            }
+            else
+            {
+                b1 = edge1.Bot.Y - (edge1.Bot.X / edge1.Dx);
+                ip.Y = Round(ip.X / edge1.Dx + b1);
+            }
+        }
+        else
+        {
+            b1 = edge1.Bot.X - edge1.Bot.Y * edge1.Dx;
+            b2 = edge2.Bot.X - edge2.Bot.Y * edge2.Dx;
+            double q = (b2 - b1) / (edge1.Dx - edge2.Dx);
+            ip.Y = Round(q);
+            if (Math.Abs(edge1.Dx) < Math.Abs(edge2.Dx))
+                ip.X = Round(edge1.Dx * q + b1);
+            else
+                ip.X = Round(edge2.Dx * q + b2);
+        }
+
+        if (ip.Y < edge1.Top.Y || ip.Y < edge2.Top.Y)
+        {
+          if (edge1.Top.Y > edge2.Top.Y)
+            ip.Y = edge1.Top.Y;
+          else
+            ip.Y = edge2.Top.Y;
+          if (Math.Abs(edge1.Dx) < Math.Abs(edge2.Dx))
+            ip.X = TopX(edge1, ip.Y);
+          else
+            ip.X = TopX(edge2, ip.Y);
+        }
+        //finally, don't allow 'ip' to be BELOW curr.Y (ie bottom of scanbeam) ...
+        if (ip.Y > edge1.Curr.Y)
+        {
+          ip.Y = edge1.Curr.Y;
+          //better to use the more vertical edge to derive X ...
+          if (Math.Abs(edge1.Dx) > Math.Abs(edge2.Dx)) 
+            ip.X = TopX(edge2, ip.Y);
+          else 
+            ip.X = TopX(edge1, ip.Y);
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void ProcessEdgesAtTopOfScanbeam(cInt topY)
+      {
+        TEdge e = m_ActiveEdges;
+        while(e != null)
+        {
+          //1. process maxima, treating them as if they're 'bent' horizontal edges,
+          //   but exclude maxima with horizontal edges. nb: e can't be a horizontal.
+          bool IsMaximaEdge = IsMaxima(e, topY);
+
+          if(IsMaximaEdge)
+          {
+            TEdge eMaxPair = GetMaximaPairEx(e);
+            IsMaximaEdge = (eMaxPair == null || !IsHorizontal(eMaxPair));
+          }
+
+          if(IsMaximaEdge)
+          {
+            if (StrictlySimple) InsertMaxima(e.Top.X);
+            TEdge ePrev = e.PrevInAEL;
+            DoMaxima(e);
+            if( ePrev == null) e = m_ActiveEdges;
+            else e = ePrev.NextInAEL;
+          }
+          else
+          {
+            //2. promote horizontal edges, otherwise update Curr.X and Curr.Y ...
+            if (IsIntermediate(e, topY) && IsHorizontal(e.NextInLML))
+            {
+              UpdateEdgeIntoAEL(ref e);
+              if (e.OutIdx >= 0)
+                AddOutPt(e, e.Bot);
+              AddEdgeToSEL(e);
+            } 
+            else
+            {
+              e.Curr.X = TopX( e, topY );
+              e.Curr.Y = topY;
+#if use_xyz
+              if (e.Top.Y == topY) e.Curr.Z = e.Top.Z;
+              else if (e.Bot.Y == topY) e.Curr.Z = e.Bot.Z;
+              else e.Curr.Z = 0;
+#endif
+            }
+            //When StrictlySimple and 'e' is being touched by another edge, then
+            //make sure both edges have a vertex here ...
+            if (StrictlySimple)
+            {
+              TEdge ePrev = e.PrevInAEL;
+              if ((e.OutIdx >= 0) && (e.WindDelta != 0) && ePrev != null &&
+                (ePrev.OutIdx >= 0) && (ePrev.Curr.X == e.Curr.X) &&
+                (ePrev.WindDelta != 0))
+              {
+                IntPoint ip = new IntPoint(e.Curr);
+#if use_xyz
+                SetZ(ref ip, ePrev, e);
+#endif
+                OutPt op = AddOutPt(ePrev, ip);
+                OutPt op2 = AddOutPt(e, ip);
+                AddJoin(op, op2, ip); //StrictlySimple (type-3) join
+              }
+            }
+
+            e = e.NextInAEL;
+          }
+        }
+
+        //3. Process horizontals at the Top of the scanbeam ...
+        ProcessHorizontals();
+        m_Maxima = null;
+
+        //4. Promote intermediate vertices ...
+        e = m_ActiveEdges;
+        while (e != null)
+        {
+          if(IsIntermediate(e, topY))
+          {
+            OutPt op = null;
+            if( e.OutIdx >= 0 ) 
+              op = AddOutPt(e, e.Top);
+            UpdateEdgeIntoAEL(ref e);
+
+            //if output polygons share an edge, they'll need joining later ...
+            TEdge ePrev = e.PrevInAEL;
+            TEdge eNext = e.NextInAEL;
+            if (ePrev != null && ePrev.Curr.X == e.Bot.X &&
+              ePrev.Curr.Y == e.Bot.Y && op != null &&
+              ePrev.OutIdx >= 0 && ePrev.Curr.Y > ePrev.Top.Y &&
+              SlopesEqual(e.Curr, e.Top, ePrev.Curr, ePrev.Top, m_UseFullRange) &&
+              (e.WindDelta != 0) && (ePrev.WindDelta != 0))
+            {
+              OutPt op2 = AddOutPt(ePrev, e.Bot);
+              AddJoin(op, op2, e.Top);
+            }
+            else if (eNext != null && eNext.Curr.X == e.Bot.X &&
+              eNext.Curr.Y == e.Bot.Y && op != null &&
+              eNext.OutIdx >= 0 && eNext.Curr.Y > eNext.Top.Y &&
+              SlopesEqual(e.Curr, e.Top, eNext.Curr, eNext.Top, m_UseFullRange) &&
+              (e.WindDelta != 0) && (eNext.WindDelta != 0))
+            {
+              OutPt op2 = AddOutPt(eNext, e.Bot);
+              AddJoin(op, op2, e.Top);
+            }
+          }
+          e = e.NextInAEL;
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void DoMaxima(TEdge e)
+      {
+        TEdge eMaxPair = GetMaximaPairEx(e);
+        if (eMaxPair == null)
+        {
+          if (e.OutIdx >= 0)
+            AddOutPt(e, e.Top);
+          DeleteFromAEL(e);
+          return;
+        }
+
+        TEdge eNext = e.NextInAEL;
+        while(eNext != null && eNext != eMaxPair)
+        {
+          IntersectEdges(e, eNext, e.Top);
+          SwapPositionsInAEL(e, eNext);
+          eNext = e.NextInAEL;
+        }
+
+        if(e.OutIdx == Unassigned && eMaxPair.OutIdx == Unassigned)
+        {
+          DeleteFromAEL(e);
+          DeleteFromAEL(eMaxPair);
+        }
+        else if( e.OutIdx >= 0 && eMaxPair.OutIdx >= 0 )
+        {
+          if (e.OutIdx >= 0) AddLocalMaxPoly(e, eMaxPair, e.Top);
+          DeleteFromAEL(e);
+          DeleteFromAEL(eMaxPair);
+        }
+#if use_lines
+        else if (e.WindDelta == 0)
+        {
+          if (e.OutIdx >= 0) 
+          {
+            AddOutPt(e, e.Top);
+            e.OutIdx = Unassigned;
+          }
+          DeleteFromAEL(e);
+
+          if (eMaxPair.OutIdx >= 0)
+          {
+            AddOutPt(eMaxPair, e.Top);
+            eMaxPair.OutIdx = Unassigned;
+          }
+          DeleteFromAEL(eMaxPair);
+        } 
+#endif
+        else throw new ClipperException("DoMaxima error");
+      }
+      //------------------------------------------------------------------------------
+
+      public static void ReversePaths(Paths polys)
+      {
+        foreach (var poly in polys) { poly.Reverse(); }
+      }
+      //------------------------------------------------------------------------------
+
+      public static bool Orientation(Path poly)
+      {
+          return Area(poly) >= 0;
+      }
+      //------------------------------------------------------------------------------
+
+      private int PointCount(OutPt pts)
+      {
+          if (pts == null) return 0;
+          int result = 0;
+          OutPt p = pts;
+          do
+          {
+              result++;
+              p = p.Next;
+          }
+          while (p != pts);
+          return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private void BuildResult(Paths polyg)
+      {
+          polyg.Clear();
+          polyg.Capacity = m_PolyOuts.Count;
+          for (int i = 0; i < m_PolyOuts.Count; i++)
+          {
+              OutRec outRec = m_PolyOuts[i];
+              if (outRec.Pts == null) continue;
+              OutPt p = outRec.Pts.Prev;
+              int cnt = PointCount(p);
+              if (cnt < 2) continue;
+              Path pg = new Path(cnt);
+              for (int j = 0; j < cnt; j++)
+              {
+                  pg.Add(p.Pt);
+                  p = p.Prev;
+              }
+              polyg.Add(pg);
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private void BuildResult2(PolyTree polytree)
+      {
+          polytree.Clear();
+
+          //add each output polygon/contour to polytree ...
+          polytree.m_AllPolys.Capacity = m_PolyOuts.Count;
+          for (int i = 0; i < m_PolyOuts.Count; i++)
+          {
+              OutRec outRec = m_PolyOuts[i];
+              int cnt = PointCount(outRec.Pts);
+              if ((outRec.IsOpen && cnt < 2) || 
+                (!outRec.IsOpen && cnt < 3)) continue;
+              FixHoleLinkage(outRec);
+              PolyNode pn = new PolyNode();
+              polytree.m_AllPolys.Add(pn);
+              outRec.PolyNode = pn;
+              pn.m_polygon.Capacity = cnt;
+              OutPt op = outRec.Pts.Prev;
+              for (int j = 0; j < cnt; j++)
+              {
+                  pn.m_polygon.Add(op.Pt);
+                  op = op.Prev;
+              }
+          }
+
+          //fixup PolyNode links etc ...
+          polytree.m_Childs.Capacity = m_PolyOuts.Count;
+          for (int i = 0; i < m_PolyOuts.Count; i++)
+          {
+              OutRec outRec = m_PolyOuts[i];
+              if (outRec.PolyNode == null) continue;
+              else if (outRec.IsOpen)
+              {
+                outRec.PolyNode.IsOpen = true;
+                polytree.AddChild(outRec.PolyNode);
+              }
+              else if (outRec.FirstLeft != null && 
+                outRec.FirstLeft.PolyNode != null)
+                  outRec.FirstLeft.PolyNode.AddChild(outRec.PolyNode);
+              else
+                polytree.AddChild(outRec.PolyNode);
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private void FixupOutPolyline(OutRec outrec)
+      {
+        OutPt pp = outrec.Pts;
+        OutPt lastPP = pp.Prev;
+        while (pp != lastPP)
+        {
+            pp = pp.Next;
+            if (pp.Pt == pp.Prev.Pt)
+            {
+                if (pp == lastPP) lastPP = pp.Prev;
+                OutPt tmpPP = pp.Prev;
+                tmpPP.Next = pp.Next;
+                pp.Next.Prev = tmpPP;
+                pp = tmpPP;
+            }
+        }
+        if (pp == pp.Prev) outrec.Pts = null;
+      }
+      //------------------------------------------------------------------------------
+
+      private void FixupOutPolygon(OutRec outRec)
+      {
+          //FixupOutPolygon() - removes duplicate points and simplifies consecutive
+          //parallel edges by removing the middle vertex.
+          OutPt lastOK = null;
+          outRec.BottomPt = null;
+          OutPt pp = outRec.Pts;
+          bool preserveCol = PreserveCollinear || StrictlySimple;
+          for (;;)
+          {
+              if (pp.Prev == pp || pp.Prev == pp.Next)
+              {
+                  outRec.Pts = null;
+                  return;
+              }
+              //test for duplicate points and collinear edges ...
+              if ((pp.Pt == pp.Next.Pt) || (pp.Pt == pp.Prev.Pt) ||
+                (SlopesEqual(pp.Prev.Pt, pp.Pt, pp.Next.Pt, m_UseFullRange) &&
+                (!preserveCol || !Pt2IsBetweenPt1AndPt3(pp.Prev.Pt, pp.Pt, pp.Next.Pt))))
+              {
+                  lastOK = null;
+                  pp.Prev.Next = pp.Next;
+                  pp.Next.Prev = pp.Prev;
+                  pp = pp.Prev;
+              }
+              else if (pp == lastOK) break;
+              else
+              {
+                  if (lastOK == null) lastOK = pp;
+                  pp = pp.Next;
+              }
+          }
+          outRec.Pts = pp;
+      }
+      //------------------------------------------------------------------------------
+
+      OutPt DupOutPt(OutPt outPt, bool InsertAfter)
+      {
+        OutPt result = new OutPt();
+        result.Pt = outPt.Pt;
+        result.Idx = outPt.Idx;
+        if (InsertAfter)
+        {
+          result.Next = outPt.Next;
+          result.Prev = outPt;
+          outPt.Next.Prev = result;
+          outPt.Next = result;
+        } 
+        else
+        {
+          result.Prev = outPt.Prev;
+          result.Next = outPt;
+          outPt.Prev.Next = result;
+          outPt.Prev = result;
+        }
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      bool GetOverlap(cInt a1, cInt a2, cInt b1, cInt b2, out cInt Left, out cInt Right)
+      {
+        if (a1 < a2)
+        {
+          if (b1 < b2) {Left = Math.Max(a1,b1); Right = Math.Min(a2,b2);}
+          else {Left = Math.Max(a1,b2); Right = Math.Min(a2,b1);}
+        } 
+        else
+        {
+          if (b1 < b2) {Left = Math.Max(a2,b1); Right = Math.Min(a1,b2);}
+          else { Left = Math.Max(a2, b2); Right = Math.Min(a1, b1); }
+        }
+        return Left < Right;
+      }
+      //------------------------------------------------------------------------------
+
+      bool JoinHorz(OutPt op1, OutPt op1b, OutPt op2, OutPt op2b, 
+        IntPoint Pt, bool DiscardLeft)
+      {
+        Direction Dir1 = (op1.Pt.X > op1b.Pt.X ? 
+          Direction.dRightToLeft : Direction.dLeftToRight);
+        Direction Dir2 = (op2.Pt.X > op2b.Pt.X ?
+          Direction.dRightToLeft : Direction.dLeftToRight);
+        if (Dir1 == Dir2) return false;
+
+        //When DiscardLeft, we want Op1b to be on the Left of Op1, otherwise we
+        //want Op1b to be on the Right. (And likewise with Op2 and 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 == Direction.dLeftToRight) 
+        {
+          while (op1.Next.Pt.X <= Pt.X && 
+            op1.Next.Pt.X >= op1.Pt.X && op1.Next.Pt.Y == Pt.Y)  
+              op1 = op1.Next;
+          if (DiscardLeft && (op1.Pt.X != Pt.X)) op1 = op1.Next;
+          op1b = DupOutPt(op1, !DiscardLeft);
+          if (op1b.Pt != Pt) 
+          {
+            op1 = op1b;
+            op1.Pt = Pt;
+            op1b = DupOutPt(op1, !DiscardLeft);
+          }
+        } 
+        else
+        {
+          while (op1.Next.Pt.X >= Pt.X && 
+            op1.Next.Pt.X <= op1.Pt.X && op1.Next.Pt.Y == Pt.Y) 
+              op1 = op1.Next;
+          if (!DiscardLeft && (op1.Pt.X != Pt.X)) op1 = op1.Next;
+          op1b = DupOutPt(op1, DiscardLeft);
+          if (op1b.Pt != Pt)
+          {
+            op1 = op1b;
+            op1.Pt = Pt;
+            op1b = DupOutPt(op1, DiscardLeft);
+          }
+        }
+
+        if (Dir2 == Direction.dLeftToRight)
+        {
+          while (op2.Next.Pt.X <= Pt.X && 
+            op2.Next.Pt.X >= op2.Pt.X && op2.Next.Pt.Y == Pt.Y)
+              op2 = op2.Next;
+          if (DiscardLeft && (op2.Pt.X != Pt.X)) op2 = op2.Next;
+          op2b = DupOutPt(op2, !DiscardLeft);
+          if (op2b.Pt != Pt)
+          {
+            op2 = op2b;
+            op2.Pt = Pt;
+            op2b = DupOutPt(op2, !DiscardLeft);
+          };
+        } else
+        {
+          while (op2.Next.Pt.X >= Pt.X && 
+            op2.Next.Pt.X <= op2.Pt.X && op2.Next.Pt.Y == Pt.Y) 
+              op2 = op2.Next;
+          if (!DiscardLeft && (op2.Pt.X != Pt.X)) op2 = op2.Next;
+          op2b = DupOutPt(op2, DiscardLeft);
+          if (op2b.Pt != Pt)
+          {
+            op2 = op2b;
+            op2.Pt = Pt;
+            op2b = DupOutPt(op2, DiscardLeft);
+          };
+        };
+
+        if ((Dir1 == Direction.dLeftToRight) == DiscardLeft)
+        {
+          op1.Prev = op2;
+          op2.Next = op1;
+          op1b.Next = op2b;
+          op2b.Prev = op1b;
+        }
+        else
+        {
+          op1.Next = op2;
+          op2.Prev = op1;
+          op1b.Prev = op2b;
+          op2b.Next = op1b;
+        }
+        return true;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool JoinPoints(Join j, OutRec outRec1, OutRec outRec2)
+      {
+        OutPt op1 = j.OutPt1, op1b;
+        OutPt op2 = j.OutPt2, op2b;
+
+        //There are 3 kinds of joins for output polygons ...
+        //1. Horizontal joins where Join.OutPt1 & Join.OutPt2 are vertices anywhere
+        //along (horizontal) collinear edges (& Join.OffPt is on the same horizontal).
+        //2. Non-horizontal joins where Join.OutPt1 & Join.OutPt2 are at the same
+        //location at the Bottom of the overlapping segment (& Join.OffPt is above).
+        //3. StrictlySimple joins where edges touch but are not collinear and where
+        //Join.OutPt1, Join.OutPt2 & Join.OffPt all share the same point.
+        bool isHorizontal = (j.OutPt1.Pt.Y == j.OffPt.Y);
+
+        if (isHorizontal && (j.OffPt == j.OutPt1.Pt) && (j.OffPt == j.OutPt2.Pt))
+        {          
+          //Strictly Simple join ...
+          if (outRec1 != outRec2) return false;
+          op1b = j.OutPt1.Next;
+          while (op1b != op1 && (op1b.Pt == j.OffPt)) 
+            op1b = op1b.Next;
+          bool reverse1 = (op1b.Pt.Y > j.OffPt.Y);
+          op2b = j.OutPt2.Next;
+          while (op2b != op2 && (op2b.Pt == j.OffPt)) 
+            op2b = op2b.Next;
+          bool reverse2 = (op2b.Pt.Y > j.OffPt.Y);
+          if (reverse1 == reverse2) return false;
+          if (reverse1)
+          {
+            op1b = DupOutPt(op1, false);
+            op2b = DupOutPt(op2, true);
+            op1.Prev = op2;
+            op2.Next = op1;
+            op1b.Next = op2b;
+            op2b.Prev = op1b;
+            j.OutPt1 = op1;
+            j.OutPt2 = op1b;
+            return true;
+          } else
+          {
+            op1b = DupOutPt(op1, true);
+            op2b = DupOutPt(op2, false);
+            op1.Next = op2;
+            op2.Prev = op1;
+            op1b.Prev = op2b;
+            op2b.Next = op1b;
+            j.OutPt1 = op1;
+            j.OutPt2 = op1b;
+            return true;
+          }
+        } 
+        else if (isHorizontal)
+        {
+          //treat horizontal joins differently to non-horizontal joins since with
+          //them we're not yet sure where the overlapping is. OutPt1.Pt & OutPt2.Pt
+          //may be anywhere along the horizontal edge.
+          op1b = op1;
+          while (op1.Prev.Pt.Y == op1.Pt.Y && op1.Prev != op1b && op1.Prev != op2)
+            op1 = op1.Prev;
+          while (op1b.Next.Pt.Y == op1b.Pt.Y && op1b.Next != op1 && op1b.Next != op2)
+            op1b = op1b.Next;
+          if (op1b.Next == op1 || op1b.Next == op2) return false; //a flat 'polygon'
+
+          op2b = op2;
+          while (op2.Prev.Pt.Y == op2.Pt.Y && op2.Prev != op2b && op2.Prev != op1b)
+            op2 = op2.Prev;
+          while (op2b.Next.Pt.Y == op2b.Pt.Y && op2b.Next != op2 && op2b.Next != op1)
+            op2b = op2b.Next;
+          if (op2b.Next == op2 || op2b.Next == op1) return false; //a flat 'polygon'
+
+          cInt Left, Right;
+          //Op1 -. Op1b & Op2 -. Op2b are the extremites of the horizontal edges
+          if (!GetOverlap(op1.Pt.X, op1b.Pt.X, op2.Pt.X, op2b.Pt.X, out Left, out Right))
+            return false;
+
+          //DiscardLeftSide: when overlapping edges are joined, a spike will created
+          //which needs to be cleaned up. However, we don't want Op1 or Op2 caught up
+          //on the discard Side as either may still be needed for other joins ...
+          IntPoint Pt;
+          bool DiscardLeftSide;
+          if (op1.Pt.X >= Left && op1.Pt.X <= Right) 
+          {
+            Pt = op1.Pt; DiscardLeftSide = (op1.Pt.X > op1b.Pt.X);
+          } 
+          else if (op2.Pt.X >= Left&& op2.Pt.X <= Right) 
+          {
+            Pt = op2.Pt; DiscardLeftSide = (op2.Pt.X > op2b.Pt.X);
+          } 
+          else if (op1b.Pt.X >= Left && op1b.Pt.X <= Right)
+          {
+            Pt = op1b.Pt; DiscardLeftSide = op1b.Pt.X > op1.Pt.X;
+          } 
+          else
+          {
+            Pt = op2b.Pt; DiscardLeftSide = (op2b.Pt.X > op2.Pt.X);
+          }
+          j.OutPt1 = op1;
+          j.OutPt2 = op2;
+          return JoinHorz(op1, op1b, op2, op2b, Pt, DiscardLeftSide);
+        } else
+        {
+          //nb: For non-horizontal joins ...
+          //    1. Jr.OutPt1.Pt.Y == Jr.OutPt2.Pt.Y
+          //    2. Jr.OutPt1.Pt > Jr.OffPt.Y
+
+          //make sure the polygons are correctly oriented ...
+          op1b = op1.Next;
+          while ((op1b.Pt == op1.Pt) && (op1b != op1)) op1b = op1b.Next;
+          bool Reverse1 = ((op1b.Pt.Y > op1.Pt.Y) ||
+            !SlopesEqual(op1.Pt, op1b.Pt, j.OffPt, m_UseFullRange));
+          if (Reverse1)
+          {
+            op1b = op1.Prev;
+            while ((op1b.Pt == op1.Pt) && (op1b != op1)) op1b = op1b.Prev;
+            if ((op1b.Pt.Y > op1.Pt.Y) ||
+              !SlopesEqual(op1.Pt, op1b.Pt, j.OffPt, m_UseFullRange)) return false;
+          };
+          op2b = op2.Next;
+          while ((op2b.Pt == op2.Pt) && (op2b != op2)) op2b = op2b.Next;
+          bool Reverse2 = ((op2b.Pt.Y > op2.Pt.Y) ||
+            !SlopesEqual(op2.Pt, op2b.Pt, j.OffPt, m_UseFullRange));
+          if (Reverse2)
+          {
+            op2b = op2.Prev;
+            while ((op2b.Pt == op2.Pt) && (op2b != op2)) op2b = op2b.Prev;
+            if ((op2b.Pt.Y > op2.Pt.Y) ||
+              !SlopesEqual(op2.Pt, op2b.Pt, j.OffPt, m_UseFullRange)) return false;
+          }
+
+          if ((op1b == op1) || (op2b == op2) || (op1b == op2b) ||
+            ((outRec1 == outRec2) && (Reverse1 == Reverse2))) return false;
+
+          if (Reverse1)
+          {
+            op1b = DupOutPt(op1, false);
+            op2b = DupOutPt(op2, true);
+            op1.Prev = op2;
+            op2.Next = op1;
+            op1b.Next = op2b;
+            op2b.Prev = op1b;
+            j.OutPt1 = op1;
+            j.OutPt2 = op1b;
+            return true;
+          } else
+          {
+            op1b = DupOutPt(op1, true);
+            op2b = DupOutPt(op2, false);
+            op1.Next = op2;
+            op2.Prev = op1;
+            op1b.Prev = op2b;
+            op2b.Next = op1b;
+            j.OutPt1 = op1;
+            j.OutPt2 = op1b;
+            return true;
+          }
+        }
+      }
+      //----------------------------------------------------------------------
+
+      public static int PointInPolygon(IntPoint pt, Path path)
+      {
+        //returns 0 if false, +1 if true, -1 if pt ON polygon boundary
+        //See "The Point in Polygon Problem for Arbitrary Polygons" by Hormann & Agathos
+        //http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf
+        int result = 0, cnt = path.Count;
+        if (cnt < 3) return 0;
+        IntPoint ip = path[0];
+        for (int i = 1; i <= cnt; ++i)
+        {
+          IntPoint ipNext = (i == cnt ? path[0] : path[i]);
+          if (ipNext.Y == pt.Y)
+          {
+            if ((ipNext.X == pt.X) || (ip.Y == pt.Y &&
+              ((ipNext.X > pt.X) == (ip.X < pt.X)))) return -1;
+          }
+          if ((ip.Y < pt.Y) != (ipNext.Y < pt.Y))
+          {
+            if (ip.X >= pt.X)
+            {
+              if (ipNext.X > pt.X) result = 1 - result;
+              else
+              {
+                double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) -
+                  (double)(ipNext.X - pt.X) * (ip.Y - pt.Y);
+                if (d == 0) return -1;
+                else if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result;
+              }
+            }
+            else
+            {
+              if (ipNext.X > pt.X)
+              {
+                double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) -
+                  (double)(ipNext.X - pt.X) * (ip.Y - pt.Y);
+                if (d == 0) return -1;
+                else if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result;
+              }
+            }
+          }
+          ip = ipNext;
+        }
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      //See "The Point in Polygon Problem for Arbitrary Polygons" by Hormann & Agathos
+      //http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf
+      private static int PointInPolygon(IntPoint pt, OutPt op)
+      {
+        //returns 0 if false, +1 if true, -1 if pt ON polygon boundary
+        int result = 0;
+        OutPt startOp = op;
+        cInt ptx = pt.X, pty = pt.Y;
+        cInt poly0x = op.Pt.X, poly0y = op.Pt.Y;
+        do
+        {
+          op = op.Next;
+          cInt poly1x = op.Pt.X, poly1y = op.Pt.Y;
+
+          if (poly1y == pty)
+          {
+            if ((poly1x == ptx) || (poly0y == pty &&
+              ((poly1x > ptx) == (poly0x < ptx)))) return -1;
+          }
+          if ((poly0y < pty) != (poly1y < pty))
+          {
+            if (poly0x >= ptx)
+            {
+              if (poly1x > ptx) result = 1 - result;
+              else
+              {
+                double d = (double)(poly0x - ptx) * (poly1y - pty) -
+                  (double)(poly1x - ptx) * (poly0y - pty);
+                if (d == 0) return -1;
+                if ((d > 0) == (poly1y > poly0y)) result = 1 - result;
+              }
+            }
+            else
+            {
+              if (poly1x > ptx)
+              {
+                double d = (double)(poly0x - ptx) * (poly1y - pty) -
+                  (double)(poly1x - ptx) * (poly0y - pty);
+                if (d == 0) return -1;
+                if ((d > 0) == (poly1y > poly0y)) result = 1 - result;
+              }
+            }
+          }
+          poly0x = poly1x; poly0y = poly1y;
+        } while (startOp != op);
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private static bool Poly2ContainsPoly1(OutPt outPt1, OutPt outPt2)
+      {
+        OutPt op = outPt1;
+        do
+        {
+          //nb: PointInPolygon returns 0 if false, +1 if true, -1 if pt on polygon
+          int res = PointInPolygon(op.Pt, outPt2);
+          if (res >= 0) return res > 0;
+          op = op.Next;
+        }
+        while (op != outPt1);
+        return true;
+      }
+      //----------------------------------------------------------------------
+
+      private void FixupFirstLefts1(OutRec OldOutRec, OutRec NewOutRec)
+      { 
+        foreach (OutRec outRec in m_PolyOuts)
+        {
+          OutRec firstLeft = ParseFirstLeft(outRec.FirstLeft);
+          if (outRec.Pts != null && firstLeft == OldOutRec)
+          {
+            if (Poly2ContainsPoly1(outRec.Pts, NewOutRec.Pts))
+                outRec.FirstLeft = NewOutRec;
+          }
+        }
+      }
+      //----------------------------------------------------------------------
+
+      private void FixupFirstLefts2(OutRec innerOutRec, OutRec outerOutRec)
+      {
+        //A polygon has split into two such that one is now the inner of the other.
+        //It's possible that these polygons now wrap around other polygons, so check
+        //every polygon that's also contained by OuterOutRec's FirstLeft container
+        //(including nil) to see if they've become inner to the new inner polygon ...
+        OutRec orfl = outerOutRec.FirstLeft;
+        foreach (OutRec outRec in m_PolyOuts)
+        {
+          if (outRec.Pts == null || outRec == outerOutRec || outRec == innerOutRec) 
+            continue;
+          OutRec firstLeft = ParseFirstLeft(outRec.FirstLeft);
+          if (firstLeft != orfl && firstLeft != innerOutRec && firstLeft != outerOutRec) 
+            continue;
+          if (Poly2ContainsPoly1(outRec.Pts, innerOutRec.Pts))
+            outRec.FirstLeft = innerOutRec;
+          else if (Poly2ContainsPoly1(outRec.Pts, outerOutRec.Pts))
+            outRec.FirstLeft = outerOutRec;
+          else if (outRec.FirstLeft == innerOutRec || outRec.FirstLeft == outerOutRec) 
+            outRec.FirstLeft = orfl;
+        }
+      }
+      //----------------------------------------------------------------------
+
+      private void FixupFirstLefts3(OutRec OldOutRec, OutRec NewOutRec)
+      {
+        //same as FixupFirstLefts1 but doesn't call Poly2ContainsPoly1()
+        foreach (OutRec outRec in m_PolyOuts)
+        {
+          OutRec firstLeft = ParseFirstLeft(outRec.FirstLeft);
+          if (outRec.Pts != null && firstLeft == OldOutRec) 
+            outRec.FirstLeft = NewOutRec;
+        }
+      }
+      //----------------------------------------------------------------------
+
+      private static OutRec ParseFirstLeft(OutRec FirstLeft)
+      {
+        while (FirstLeft != null && FirstLeft.Pts == null) 
+          FirstLeft = FirstLeft.FirstLeft;
+        return FirstLeft;
+      }
+      //------------------------------------------------------------------------------
+
+    private void JoinCommonEdges()
+      {
+        for (int i = 0; i < m_Joins.Count; i++)
+        {
+          Join join = m_Joins[i];
+
+          OutRec outRec1 = GetOutRec(join.OutPt1.Idx);
+          OutRec outRec2 = GetOutRec(join.OutPt2.Idx);
+
+          if (outRec1.Pts == null || outRec2.Pts == null) continue;
+          if (outRec1.IsOpen || outRec2.IsOpen) continue;
+
+          //get the polygon fragment with the correct hole state (FirstLeft)
+          //before calling JoinPoints() ...
+          OutRec holeStateRec;
+          if (outRec1 == outRec2) holeStateRec = outRec1;
+          else if (OutRec1RightOfOutRec2(outRec1, outRec2)) holeStateRec = outRec2;
+          else if (OutRec1RightOfOutRec2(outRec2, outRec1)) holeStateRec = outRec1;
+          else holeStateRec = GetLowermostRec(outRec1, outRec2);
+
+          if (!JoinPoints(join, outRec1, outRec2)) continue;
+
+          if (outRec1 == outRec2)
+          {
+            //instead of joining two polygons, we've just created a new one by
+            //splitting one polygon into two.
+            outRec1.Pts = join.OutPt1;
+            outRec1.BottomPt = null;
+            outRec2 = CreateOutRec();
+            outRec2.Pts = join.OutPt2;
+
+            //update all OutRec2.Pts Idx's ...
+            UpdateOutPtIdxs(outRec2);
+
+            if (Poly2ContainsPoly1(outRec2.Pts, outRec1.Pts))
+            {
+              //outRec1 contains outRec2 ...
+              outRec2.IsHole = !outRec1.IsHole;
+              outRec2.FirstLeft = outRec1;
+
+              if (m_UsingPolyTree) FixupFirstLefts2(outRec2, outRec1);
+
+              if ((outRec2.IsHole ^ ReverseSolution) == (Area(outRec2) > 0))
+                ReversePolyPtLinks(outRec2.Pts);
+
+            }
+            else if (Poly2ContainsPoly1(outRec1.Pts, outRec2.Pts))
+            {
+              //outRec2 contains outRec1 ...
+              outRec2.IsHole = outRec1.IsHole;
+              outRec1.IsHole = !outRec2.IsHole;
+              outRec2.FirstLeft = outRec1.FirstLeft;
+              outRec1.FirstLeft = outRec2;
+
+              if (m_UsingPolyTree) FixupFirstLefts2(outRec1, outRec2);
+
+              if ((outRec1.IsHole ^ ReverseSolution) == (Area(outRec1) > 0))
+                ReversePolyPtLinks(outRec1.Pts);
+            }
+            else
+            {
+              //the 2 polygons are completely separate ...
+              outRec2.IsHole = outRec1.IsHole;
+              outRec2.FirstLeft = outRec1.FirstLeft;
+
+              //fixup FirstLeft pointers that may need reassigning to OutRec2
+              if (m_UsingPolyTree) FixupFirstLefts1(outRec1, outRec2);
+            }
+     
+          } else
+          {
+            //joined 2 polygons together ...
+
+            outRec2.Pts = null;
+            outRec2.BottomPt = null;
+            outRec2.Idx = outRec1.Idx;
+
+            outRec1.IsHole = holeStateRec.IsHole;
+            if (holeStateRec == outRec2) 
+              outRec1.FirstLeft = outRec2.FirstLeft;
+            outRec2.FirstLeft = outRec1;
+
+            //fixup FirstLeft pointers that may need reassigning to OutRec1
+            if (m_UsingPolyTree) FixupFirstLefts3(outRec2, outRec1);
+          }
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void UpdateOutPtIdxs(OutRec outrec)
+      {  
+        OutPt op = outrec.Pts;
+        do
+        {
+          op.Idx = outrec.Idx;
+          op = op.Prev;
+        }
+        while(op != outrec.Pts);
+      }
+      //------------------------------------------------------------------------------
+
+      private void DoSimplePolygons()
+      {
+        int i = 0;
+        while (i < m_PolyOuts.Count) 
+        {
+          OutRec outrec = m_PolyOuts[i++];
+          OutPt op = outrec.Pts;
+          if (op == null || outrec.IsOpen) continue;
+          do //for each Pt in Polygon until duplicate found do ...
+          {
+            OutPt op2 = op.Next;
+            while (op2 != outrec.Pts) 
+            {
+              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;
+                  outrec2.FirstLeft = outrec;
+                  if (m_UsingPolyTree) FixupFirstLefts2(outrec2, outrec);
+                }
+                else
+                  if (Poly2ContainsPoly1(outrec.Pts, outrec2.Pts))
+                {
+                  //OutRec1 is contained by OutRec2 ...
+                  outrec2.IsHole = outrec.IsHole;
+                  outrec.IsHole = !outrec2.IsHole;
+                  outrec2.FirstLeft = outrec.FirstLeft;
+                  outrec.FirstLeft = outrec2;
+                  if (m_UsingPolyTree) FixupFirstLefts2(outrec, outrec2);
+                }
+                  else
+                {
+                  //the 2 polygons are separate ...
+                  outrec2.IsHole = outrec.IsHole;
+                  outrec2.FirstLeft = outrec.FirstLeft;
+                  if (m_UsingPolyTree) FixupFirstLefts1(outrec, outrec2);
+                }
+                op2 = op; //ie get ready for the next iteration
+              }
+              op2 = op2.Next;
+            }
+            op = op.Next;
+          }
+          while (op != outrec.Pts);
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      public static double Area(Path poly)
+      {
+        int cnt = (int)poly.Count;
+        if (cnt < 3) return 0;
+        double a = 0;
+        for (int i = 0, j = cnt - 1; i < cnt; ++i)
+        {
+          a += ((double)poly[j].X + poly[i].X) * ((double)poly[j].Y - poly[i].Y);
+          j = i;
+        }
+        return -a * 0.5;
+      }
+      //------------------------------------------------------------------------------
+
+      internal double Area(OutRec outRec)
+      {
+        return Area(outRec.Pts);
+      }
+      //------------------------------------------------------------------------------
+
+      internal double Area(OutPt op)
+      {
+        OutPt opFirst = op;
+        if (op == null) return 0;
+        double a = 0;
+        do {
+          a = a + (double)(op.Prev.Pt.X + op.Pt.X) * (double)(op.Prev.Pt.Y - op.Pt.Y);
+          op = op.Next;
+        } while (op != opFirst);
+        return a * 0.5;
+      }
+
+      //------------------------------------------------------------------------------
+      // SimplifyPolygon functions ...
+      // Convert self-intersecting polygons into simple polygons
+      //------------------------------------------------------------------------------
+
+      public static Paths SimplifyPolygon(Path poly, 
+            PolyFillType fillType = PolyFillType.pftEvenOdd)
+      {
+          Paths result = new Paths();
+          Clipper c = new Clipper();
+          c.StrictlySimple = true;
+          c.AddPath(poly, PolyType.ptSubject, true);
+          c.Execute(ClipType.ctUnion, result, fillType, fillType);
+          return result;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths SimplifyPolygons(Paths polys,
+          PolyFillType fillType = PolyFillType.pftEvenOdd)
+      {
+          Paths result = new Paths();
+          Clipper c = new Clipper();
+          c.StrictlySimple = true;
+          c.AddPaths(polys, PolyType.ptSubject, true);
+          c.Execute(ClipType.ctUnion, result, fillType, fillType);
+          return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private static double DistanceSqrd(IntPoint pt1, IntPoint pt2)
+      {
+        double dx = ((double)pt1.X - pt2.X);
+        double dy = ((double)pt1.Y - pt2.Y);
+        return (dx*dx + dy*dy);
+      }
+      //------------------------------------------------------------------------------
+
+      private static double DistanceFromLineSqrd(IntPoint pt, IntPoint ln1, 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²)
+        //see http://en.wikipedia.org/wiki/Perpendicular_distance
+        double A = ln1.Y - ln2.Y;
+        double B = ln2.X - ln1.X;
+        double C = A * ln1.X  + B * ln1.Y;
+        C = A * pt.X + B * pt.Y - C;
+        return (C * C) / (A * A + B * B);
+      }
+      //---------------------------------------------------------------------------
+
+      private static bool SlopesNearCollinear(IntPoint pt1, 
+          IntPoint pt2, IntPoint pt3, double distSqrd)
+      {
+        //this function is more accurate when the point that's GEOMETRICALLY 
+        //between the other 2 points is the one that's tested for distance.  
+        //nb: with 'spikes', either pt1 or pt3 is geometrically between the other pts                    
+        if (Math.Abs(pt1.X - pt2.X) > Math.Abs(pt1.Y - pt2.Y))
+	      {
+          if ((pt1.X > pt2.X) == (pt1.X < pt3.X))
+            return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd;
+          else if ((pt2.X > pt1.X) == (pt2.X < pt3.X))
+            return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd;
+		      else
+	          return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd;
+	      }
+	      else
+	      {
+          if ((pt1.Y > pt2.Y) == (pt1.Y < pt3.Y))
+            return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd;
+          else if ((pt2.Y > pt1.Y) == (pt2.Y < pt3.Y))
+            return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd;
+		      else
+            return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd;
+	      }
+      }
+      //------------------------------------------------------------------------------
+
+      private static bool PointsAreClose(IntPoint pt1, IntPoint pt2, double distSqrd)
+      {
+          double dx = (double)pt1.X - pt2.X;
+          double dy = (double)pt1.Y - pt2.Y;
+          return ((dx * dx) + (dy * dy) <= distSqrd);
+      }
+      //------------------------------------------------------------------------------
+
+      private static OutPt ExcludeOp(OutPt op)
+      {
+        OutPt result = op.Prev;
+        result.Next = op.Next;
+        op.Next.Prev = result;
+        result.Idx = 0;
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Path CleanPolygon(Path path, double distance = 1.415)
+      {
+        //distance = proximity in units/pixels below which vertices will be stripped. 
+        //Default ~= sqrt(2) so when adjacent vertices or semi-adjacent vertices have 
+        //both x & y coords within 1 unit, then the second vertex will be stripped.
+
+        int cnt = path.Count;
+
+        if (cnt == 0) return new Path();
+
+        OutPt [] outPts = new OutPt[cnt];
+        for (int i = 0; i < cnt; ++i) outPts[i] = new OutPt();
+
+        for (int i = 0; i < cnt; ++i)
+        {
+          outPts[i].Pt = path[i];
+          outPts[i].Next = outPts[(i + 1) % cnt];
+          outPts[i].Next.Prev = outPts[i];
+          outPts[i].Idx = 0;
+        }
+
+        double distSqrd = distance * distance;
+        OutPt op = outPts[0];
+        while (op.Idx == 0 && op.Next != op.Prev)
+        {
+          if (PointsAreClose(op.Pt, op.Prev.Pt, distSqrd))
+          {
+            op = ExcludeOp(op);
+            cnt--;
+          }
+          else if (PointsAreClose(op.Prev.Pt, op.Next.Pt, distSqrd))
+          {
+            ExcludeOp(op.Next);
+            op = ExcludeOp(op);
+            cnt -= 2;
+          }
+          else if (SlopesNearCollinear(op.Prev.Pt, op.Pt, op.Next.Pt, distSqrd))
+          {
+            op = ExcludeOp(op);
+            cnt--;
+          }
+          else
+          {
+            op.Idx = 1;
+            op = op.Next;
+          }
+        }
+
+        if (cnt < 3) cnt = 0;
+        Path result = new Path(cnt);
+        for (int i = 0; i < cnt; ++i)
+        {
+          result.Add(op.Pt);
+          op = op.Next;
+        }
+        outPts = null;
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths CleanPolygons(Paths polys,
+          double distance = 1.415)
+      {
+        Paths result = new Paths(polys.Count);
+        for (int i = 0; i < polys.Count; i++)
+          result.Add(CleanPolygon(polys[i], distance));
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      internal static Paths Minkowski(Path pattern, Path path, bool IsSum, bool IsClosed)
+      {
+        int delta = (IsClosed ? 1 : 0);
+        int polyCnt = pattern.Count;
+        int pathCnt = path.Count;
+        Paths result = new Paths(pathCnt);
+        if (IsSum)
+          for (int i = 0; i < pathCnt; i++)
+          {
+            Path p = new Path(polyCnt);
+            foreach (IntPoint ip in pattern)
+              p.Add(new IntPoint(path[i].X + ip.X, path[i].Y + ip.Y));
+            result.Add(p);
+          }
+        else
+          for (int i = 0; i < pathCnt; i++)
+          {
+            Path p = new Path(polyCnt);
+            foreach (IntPoint ip in pattern)
+              p.Add(new IntPoint(path[i].X - ip.X, path[i].Y - ip.Y));
+            result.Add(p);
+          }
+
+        Paths quads = new Paths((pathCnt + delta) * (polyCnt + 1));
+        for (int i = 0; i < pathCnt - 1 + delta; i++)
+          for (int j = 0; j < polyCnt; j++)
+          {
+            Path quad = new Path(4);
+            quad.Add(result[i % pathCnt][j % polyCnt]);
+            quad.Add(result[(i + 1) % pathCnt][j % polyCnt]);
+            quad.Add(result[(i + 1) % pathCnt][(j + 1) % polyCnt]);
+            quad.Add(result[i % pathCnt][(j + 1) % polyCnt]);
+            if (!Orientation(quad)) quad.Reverse();
+            quads.Add(quad);
+          }
+        return quads;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths MinkowskiSum(Path pattern, Path path, bool pathIsClosed)
+      {
+        Paths paths = Minkowski(pattern, path, true, pathIsClosed);
+        Clipper c = new Clipper();
+        c.AddPaths(paths, PolyType.ptSubject, true);
+        c.Execute(ClipType.ctUnion, paths, PolyFillType.pftNonZero, PolyFillType.pftNonZero);
+        return paths;
+      }
+      //------------------------------------------------------------------------------
+
+      private static Path TranslatePath(Path path, IntPoint delta) 
+      {
+        Path outPath = new Path(path.Count);
+        for (int i = 0; i < path.Count; i++)
+          outPath.Add(new IntPoint(path[i].X + delta.X, path[i].Y + delta.Y));
+        return outPath;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths MinkowskiSum(Path pattern, Paths paths, bool pathIsClosed)
+      {
+        Paths solution = new Paths();
+        Clipper c = new Clipper();
+        for (int i = 0; i < paths.Count; ++i)
+        {
+          Paths tmp = Minkowski(pattern, paths[i], true, pathIsClosed);
+          c.AddPaths(tmp, PolyType.ptSubject, true);
+          if (pathIsClosed)
+          {
+            Path path = TranslatePath(paths[i], pattern[0]);
+            c.AddPath(path, PolyType.ptClip, true);
+          }
+        }
+        c.Execute(ClipType.ctUnion, solution, 
+          PolyFillType.pftNonZero, PolyFillType.pftNonZero);
+        return solution;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths MinkowskiDiff(Path poly1, Path poly2)
+      {
+        Paths paths = Minkowski(poly1, poly2, false, true);
+        Clipper c = new Clipper();
+        c.AddPaths(paths, PolyType.ptSubject, true);
+        c.Execute(ClipType.ctUnion, paths, PolyFillType.pftNonZero, PolyFillType.pftNonZero);
+        return paths;
+      }
+      //------------------------------------------------------------------------------
+
+      internal enum NodeType { ntAny, ntOpen, ntClosed };
+
+      public static Paths PolyTreeToPaths(PolyTree polytree)
+      {
+
+        Paths result = new Paths();
+        result.Capacity = polytree.Total;
+        AddPolyNodeToPaths(polytree, NodeType.ntAny, result);
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      internal static void AddPolyNodeToPaths(PolyNode polynode, NodeType nt, Paths paths)
+      {
+        bool match = true;
+        switch (nt)
+        {
+          case NodeType.ntOpen: return;
+          case NodeType.ntClosed: match = !polynode.IsOpen; break;
+          default: break;
+        }
+
+        if (polynode.m_polygon.Count > 0 && match)
+          paths.Add(polynode.m_polygon);
+        foreach (PolyNode pn in polynode.Childs)
+          AddPolyNodeToPaths(pn, nt, paths);
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths OpenPathsFromPolyTree(PolyTree polytree)
+      {
+        Paths result = new Paths();
+        result.Capacity = polytree.ChildCount;
+        for (int i = 0; i < polytree.ChildCount; i++)
+          if (polytree.Childs[i].IsOpen)
+            result.Add(polytree.Childs[i].m_polygon);
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths ClosedPathsFromPolyTree(PolyTree polytree)
+      {
+        Paths result = new Paths();
+        result.Capacity = polytree.Total;
+        AddPolyNodeToPaths(polytree, NodeType.ntClosed, result);
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+  } //end Clipper
+
+  public class ClipperOffset
+  {
+    private Paths m_destPolys;
+    private Path m_srcPoly;
+    private Path m_destPoly;
+    private List<DoublePoint> m_normals = new List<DoublePoint>();
+    private double m_delta, m_sinA, m_sin, m_cos;
+    private double m_miterLim, m_StepsPerRad;
+
+    private IntPoint m_lowest;
+    private PolyNode m_polyNodes = new PolyNode();
+
+    public double ArcTolerance { get; set; }
+    public double MiterLimit { get; set; }
+
+    private const double two_pi = Math.PI * 2;
+    private const double def_arc_tolerance = 0.25;
+
+    public ClipperOffset(
+      double miterLimit = 2.0, double arcTolerance = def_arc_tolerance)
+    {
+      MiterLimit = miterLimit;
+      ArcTolerance = arcTolerance;
+      m_lowest.X = -1;
+    }
+    //------------------------------------------------------------------------------
+
+    public void Clear()
+    {
+      m_polyNodes.Childs.Clear();
+      m_lowest.X = -1;
+    }
+    //------------------------------------------------------------------------------
+
+    internal static cInt Round(double value)
+    {
+      return value < 0 ? (cInt)(value - 0.5) : (cInt)(value + 0.5);
+    }
+    //------------------------------------------------------------------------------
+
+    public void AddPath(Path path, JoinType joinType, EndType endType)
+    {
+      int highI = path.Count - 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 ...
+      if (endType == EndType.etClosedLine || endType == EndType.etClosedPolygon)
+        while (highI > 0 && path[0] == path[highI]) highI--;
+      newNode.m_polygon.Capacity = highI + 1;
+      newNode.m_polygon.Add(path[0]);
+      int j = 0, k = 0;
+      for (int i = 1; i <= highI; i++)
+        if (newNode.m_polygon[j] != path[i])
+        {
+          j++;
+          newNode.m_polygon.Add(path[i]);
+          if (path[i].Y > newNode.m_polygon[k].Y ||
+            (path[i].Y == newNode.m_polygon[k].Y &&
+            path[i].X < newNode.m_polygon[k].X)) k = j;
+        }
+      if (endType == EndType.etClosedPolygon && j < 2) return;
+
+      m_polyNodes.AddChild(newNode);
+
+      //if this path's lowest pt is lower than all the others then update m_lowest
+      if (endType != EndType.etClosedPolygon) return;
+      if (m_lowest.X < 0)
+        m_lowest = new IntPoint(m_polyNodes.ChildCount - 1, k);
+      else
+      {
+        IntPoint ip = m_polyNodes.Childs[(int)m_lowest.X].m_polygon[(int)m_lowest.Y];
+        if (newNode.m_polygon[k].Y > ip.Y ||
+          (newNode.m_polygon[k].Y == ip.Y &&
+          newNode.m_polygon[k].X < ip.X))
+          m_lowest = new IntPoint(m_polyNodes.ChildCount - 1, k);
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    public void AddPaths(Paths paths, JoinType joinType, EndType endType)
+    {
+      foreach (Path p in paths)
+        AddPath(p, joinType, endType);
+    }
+    //------------------------------------------------------------------------------
+
+    private void 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 && 
+        !Clipper.Orientation(m_polyNodes.Childs[(int)m_lowest.X].m_polygon))
+      {
+        for (int i = 0; i < m_polyNodes.ChildCount; i++)
+        {
+          PolyNode node = m_polyNodes.Childs[i];
+          if (node.m_endtype == EndType.etClosedPolygon ||
+            (node.m_endtype == EndType.etClosedLine && 
+            Clipper.Orientation(node.m_polygon)))
+            node.m_polygon.Reverse();
+        }
+      }
+      else
+      {
+        for (int i = 0; i < m_polyNodes.ChildCount; i++)
+        {
+          PolyNode node = m_polyNodes.Childs[i];
+          if (node.m_endtype == EndType.etClosedLine &&
+            !Clipper.Orientation(node.m_polygon))
+          node.m_polygon.Reverse();
+        }
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    internal static DoublePoint GetUnitNormal(IntPoint pt1, IntPoint pt2)
+    {
+      double dx = (pt2.X - pt1.X);
+      double dy = (pt2.Y - pt1.Y);
+      if ((dx == 0) && (dy == 0)) return new DoublePoint();
+
+      double f = 1 * 1.0 / Math.Sqrt(dx * dx + dy * dy);
+      dx *= f;
+      dy *= f;
+
+      return new DoublePoint(dy, -dx);
+    }
+    //------------------------------------------------------------------------------
+
+    private void DoOffset(double delta)
+    {
+      m_destPolys = new Paths();
+      m_delta = delta;
+
+      //if Zero offset, just copy any CLOSED polygons to m_p and return ...
+      if (ClipperBase.near_zero(delta)) 
+      {
+        m_destPolys.Capacity = m_polyNodes.ChildCount;
+        for (int i = 0; i < m_polyNodes.ChildCount; i++)
+        {
+          PolyNode node = m_polyNodes.Childs[i];
+          if (node.m_endtype == EndType.etClosedPolygon)
+            m_destPolys.Add(node.m_polygon);
+        }
+        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 > Math.Abs(delta) * def_arc_tolerance)
+        y = Math.Abs(delta) * def_arc_tolerance;
+      else 
+        y = ArcTolerance;
+      //see offset_triginometry2.svg in the documentation folder ...
+      double steps = Math.PI / Math.Acos(1 - y / Math.Abs(delta));
+      m_sin = Math.Sin(two_pi / steps);
+      m_cos = Math.Cos(two_pi / steps);
+      m_StepsPerRad = steps / two_pi;
+      if (delta < 0.0) m_sin = -m_sin;
+
+      m_destPolys.Capacity = m_polyNodes.ChildCount * 2;
+      for (int i = 0; i < m_polyNodes.ChildCount; i++)
+      {
+        PolyNode node = m_polyNodes.Childs[i];
+        m_srcPoly = node.m_polygon;
+
+        int len = m_srcPoly.Count;
+
+        if (len == 0 || (delta <= 0 && (len < 3 || 
+          node.m_endtype != EndType.etClosedPolygon)))
+            continue;
+
+        m_destPoly = new Path();
+
+        if (len == 1)
+        {
+          if (node.m_jointype == JoinType.jtRound)
+          {
+            double X = 1.0, Y = 0.0;
+            for (int j = 1; j <= steps; j++)
+            {
+              m_destPoly.Add(new 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.Add(new 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.Add(m_destPoly);
+          continue;
+        }
+
+        //build m_normals ...
+        m_normals.Clear();
+        m_normals.Capacity = len;
+        for (int j = 0; j < len - 1; j++)
+          m_normals.Add(GetUnitNormal(m_srcPoly[j], m_srcPoly[j + 1]));
+        if (node.m_endtype == EndType.etClosedLine || 
+          node.m_endtype == EndType.etClosedPolygon)
+          m_normals.Add(GetUnitNormal(m_srcPoly[len - 1], m_srcPoly[0]));
+        else
+          m_normals.Add(new DoublePoint(m_normals[len - 2]));
+
+        if (node.m_endtype == EndType.etClosedPolygon)
+        {
+          int k = len - 1;
+          for (int j = 0; j < len; j++)
+            OffsetPoint(j, ref k, node.m_jointype);
+          m_destPolys.Add(m_destPoly);
+        }
+        else if (node.m_endtype == EndType.etClosedLine)
+        {
+          int k = len - 1;
+          for (int j = 0; j < len; j++)
+            OffsetPoint(j, ref k, node.m_jointype);
+          m_destPolys.Add(m_destPoly);
+          m_destPoly = new Path();
+          //re-build m_normals ...
+          DoublePoint n = m_normals[len - 1];
+          for (int j = len - 1; j > 0; j--)
+            m_normals[j] = new DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y);
+          m_normals[0] = new DoublePoint(-n.X, -n.Y);
+          k = 0;
+          for (int j = len - 1; j >= 0; j--)
+            OffsetPoint(j, ref k, node.m_jointype);
+          m_destPolys.Add(m_destPoly);
+        }
+        else
+        {
+          int k = 0;
+          for (int j = 1; j < len - 1; ++j)
+            OffsetPoint(j, ref k, node.m_jointype);
+
+          IntPoint pt1;
+          if (node.m_endtype == EndType.etOpenButt)
+          {
+            int j = len - 1;
+            pt1 = new 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.Add(pt1);
+            pt1 = new 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.Add(pt1);
+          }
+          else
+          {
+            int j = len - 1;
+            k = len - 2;
+            m_sinA = 0;
+            m_normals[j] = new DoublePoint(-m_normals[j].X, -m_normals[j].Y);
+            if (node.m_endtype == EndType.etOpenSquare)
+              DoSquare(j, k);
+            else
+              DoRound(j, k);
+          }
+
+          //re-build m_normals ...
+          for (int j = len - 1; j > 0; j--)
+            m_normals[j] = new DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y);
+
+          m_normals[0] = new DoublePoint(-m_normals[1].X, -m_normals[1].Y);
+
+          k = len - 1;
+          for (int j = k - 1; j > 0; --j)
+            OffsetPoint(j, ref k, node.m_jointype);
+
+          if (node.m_endtype == EndType.etOpenButt)
+          {
+            pt1 = new 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.Add(pt1);
+            pt1 = new 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.Add(pt1);
+          }
+          else
+          {
+            k = 1;
+            m_sinA = 0;
+            if (node.m_endtype == EndType.etOpenSquare)
+              DoSquare(0, 1);
+            else
+              DoRound(0, 1);
+          }
+          m_destPolys.Add(m_destPoly);
+        }
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    public void Execute(ref Paths solution, double delta)
+    {
+      solution.Clear();
+      FixOrientations();
+      DoOffset(delta);
+      //now clean up 'corners' ...
+      Clipper clpr = new Clipper();
+      clpr.AddPaths(m_destPolys, PolyType.ptSubject, true);
+      if (delta > 0)
+      {
+        clpr.Execute(ClipType.ctUnion, solution,
+          PolyFillType.pftPositive, PolyFillType.pftPositive);
+      }
+      else
+      {
+        IntRect r = Clipper.GetBounds(m_destPolys);
+        Path outer = new Path(4);
+
+        outer.Add(new IntPoint(r.left - 10, r.bottom + 10));
+        outer.Add(new IntPoint(r.right + 10, r.bottom + 10));
+        outer.Add(new IntPoint(r.right + 10, r.top - 10));
+        outer.Add(new IntPoint(r.left - 10, r.top - 10));
+
+        clpr.AddPath(outer, PolyType.ptSubject, true);
+        clpr.ReverseSolution = true;
+        clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftNegative, PolyFillType.pftNegative);
+        if (solution.Count > 0) solution.RemoveAt(0);
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    public void Execute(ref PolyTree solution, double delta)
+    {
+      solution.Clear();
+      FixOrientations();
+      DoOffset(delta);
+
+      //now clean up 'corners' ...
+      Clipper clpr = new Clipper();
+      clpr.AddPaths(m_destPolys, PolyType.ptSubject, true);
+      if (delta > 0)
+      {
+        clpr.Execute(ClipType.ctUnion, solution,
+          PolyFillType.pftPositive, PolyFillType.pftPositive);
+      }
+      else
+      {
+        IntRect r = Clipper.GetBounds(m_destPolys);
+        Path outer = new Path(4);
+
+        outer.Add(new IntPoint(r.left - 10, r.bottom + 10));
+        outer.Add(new IntPoint(r.right + 10, r.bottom + 10));
+        outer.Add(new IntPoint(r.right + 10, r.top - 10));
+        outer.Add(new IntPoint(r.left - 10, r.top - 10));
+
+        clpr.AddPath(outer, PolyType.ptSubject, true);
+        clpr.ReverseSolution = true;
+        clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftNegative, PolyFillType.pftNegative);
+        //remove the outer PolyNode rectangle ...
+        if (solution.ChildCount == 1 && solution.Childs[0].ChildCount > 0)
+        {
+          PolyNode outerNode = solution.Childs[0];
+          solution.Childs.Capacity = outerNode.ChildCount;
+          solution.Childs[0] = outerNode.Childs[0];
+          solution.Childs[0].m_Parent = solution;
+          for (int i = 1; i < outerNode.ChildCount; i++)
+            solution.AddChild(outerNode.Childs[i]);
+        }
+        else
+          solution.Clear();
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    void OffsetPoint(int j, ref 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 (Math.Abs(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.Add(new 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.Add(new 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.Add(m_srcPoly[j]);
+        m_destPoly.Add(new 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 JoinType.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 JoinType.jtSquare: DoSquare(j, k); break;
+          case JoinType.jtRound: DoRound(j, k); break;
+        }
+      k = j;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DoSquare(int j, int k)
+    {
+      double dx = Math.Tan(Math.Atan2(m_sinA,
+          m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y) / 4);
+      m_destPoly.Add(new 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.Add(new 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))));
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DoMiter(int j, int k, double r)
+    {
+      double q = m_delta / r;
+      m_destPoly.Add(new 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)));
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DoRound(int j, int k)
+    {
+      double a = Math.Atan2(m_sinA,
+      m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y);
+      int steps = Math.Max((int)Round(m_StepsPerRad * Math.Abs(a)),1);
+
+      double X = m_normals[k].X, Y = m_normals[k].Y, X2;
+      for (int i = 0; i < steps; ++i)
+      {
+        m_destPoly.Add(new IntPoint(
+            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.Add(new IntPoint(
+      Round(m_srcPoly[j].X + m_normals[j].X * m_delta),
+      Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta)));
+    }
+    //------------------------------------------------------------------------------
+  }
+
+  class ClipperException : Exception
+  {
+      public ClipperException(string description) : base(description){}
+  }
+  //------------------------------------------------------------------------------
+
+} //end ClipperLib namespace
diff --git a/Extensions/Model/Discrete/Assembly.cs b/Extensions/Model/Discrete/Assembly.cs
new file mode 100644
index 0000000..dc68454
--- /dev/null
+++ b/Extensions/Model/Discrete/Assembly.cs
@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Threading.Tasks;
+using Rhino;
+using Rhino.Geometry;
+using Rhino.DocObjects;
+using System.IO;
+
+namespace Extensions.Model.Discrete
+{
+    public class Assembly
+    {
+        public List<Tile> Tiles { get; set; }
+        public List<Instance> Instances { get; set; }
+        public float AngleLimit { get; set; }
+        public float BreakForce { get; set; }
+
+        private Assembly() { }
+
+        public static void Export(List<string> blockNames, string instanceLayerName, double angleLimit, double breakForce, string fileName, RhinoDoc doc)
+        {
+            var definitions = blockNames.Select(n => doc.InstanceDefinitions.First(i => i.Name == n));
+            var instanceLayer = doc.Layers.FindName(instanceLayerName);
+            var assembly = new Assembly()
+            {
+                Tiles = definitions.Select(d => new Tile(d, doc)).ToList(),
+                Instances = definitions
+                         .SelectMany(d => d.GetReferences(1).Where(i => i.Attributes.LayerIndex == instanceLayer.Index))
+                         .Select(d => new Instance(d.InstanceDefinition.Index, d.InstanceXform))
+                         .ToList(),
+                AngleLimit = (float)angleLimit,
+                BreakForce = (float)breakForce
+            };
+
+            var serializer = new XmlSerializer(typeof(Assembly));
+            using (var writer = XmlWriter.Create(fileName))
+            {
+                serializer.Serialize(writer, assembly);
+            }
+        }
+    }
+
+    public class Tile
+    {
+        public int Index { get; set; }
+        public float Mass { get; set; }
+        public Vector3Export Centroid { get; set; }
+        public List<ExportMesh> Renderers { get; set; }
+        public List<ExportMesh> Colliders { get; set; }
+        public List<Orient> Faces { get; set; }
+
+        private Tile() { }
+
+        public Tile(InstanceDefinition definition, RhinoDoc doc)
+        {
+            Index = definition.Index;
+
+              var geometry = definition.GetObjects();
+
+            int renderIndex = doc.Layers.FindName("Renders").Index;
+
+            var renderMeshes = geometry
+                      .Where(g => g.Attributes.LayerIndex == renderIndex)
+                      .Select(g => g.Geometry as Mesh)
+                      .ToList();
+  
+            Renderers = renderMeshes.Select(m => new ExportMesh(m)).ToList();
+
+            int collisionsIndex = doc.Layers.FindName("Collisions").Index;
+
+            var meshColliders = geometry
+                 .Where(g => g.Attributes.LayerIndex == collisionsIndex)
+                 .Select(g => g.Geometry as Mesh)
+                 .ToList();
+
+            Colliders = meshColliders
+                .Select(m => m.Offset(0.001))
+                 .Select(m => new ExportMesh(m))
+                 .ToList();
+
+            Point3d centroid = Point3d.Origin;
+            double mass = 0.0;
+            double density = 2400 * 0.5;
+
+            foreach (var mesh in meshColliders)
+            {
+                var prop = VolumeMassProperties.Compute(mesh);
+                double elementMass = prop.Volume * density;
+                centroid += prop.Centroid * elementMass;
+                mass += elementMass;
+            }
+
+            centroid /= mass;
+            Centroid = new Vector3Export(centroid);
+            Mass = (float)mass;
+
+            int facesIndex = doc.Layers.FindName("Faces").Index;
+
+            Faces = geometry
+                     .Where(g => g.Attributes.LayerIndex == facesIndex)
+                     .Select(g =>
+                      {
+                          Curve curve = g.Geometry as Curve;
+                          curve.TryGetPolyline(out Polyline pl);
+                          var plane = new Plane(pl[1], pl[2], pl[0]);
+                          plane.Origin = (pl[0] * 0.5 + pl[2] * 0.5);
+                          return new Orient(plane);
+                      }).ToList();
+        }
+    }
+
+    public class Instance
+    {
+        public int DefinitionIndex;
+        public Orient Orient;
+
+        private Instance() { }
+
+        public Instance(int definitionIndex, Transform transform)
+        {
+            DefinitionIndex = definitionIndex;
+
+            var plane = Plane.WorldXY;
+            plane.Transform(transform);
+            Orient = new Orient(plane);
+        }
+    }
+
+    public class ExportMesh
+    {
+        public List<Vector3Export> Vertices { get; set; }
+        public List<Vector2Export> TextureCoordinates { get; set; }
+        public List<int> Faces { get; set; }
+
+        private ExportMesh() { }
+
+        public ExportMesh(Mesh mesh)
+        {
+            mesh.Faces.ConvertQuadsToTriangles();
+
+            Vertices = mesh.Vertices.Select(p => new Vector3Export(p)).ToList();
+            TextureCoordinates = mesh.TextureCoordinates.Select(p => new Vector2Export(p)).ToList();
+            Faces = mesh.Faces.SelectMany(f => new int[] { f.C, f.B, f.A }).ToList();
+        }
+    }
+
+    [XmlType(TypeName = "Vector3")]
+    public struct Vector3Export
+    {
+        public float x, y, z;
+
+        public Vector3Export(Point3d point)
+        {
+            x = (float)point.X;
+            y = (float)point.Z;
+            z = (float)point.Y;
+        }
+
+        public Vector3Export(Point3f point)
+        {
+            x = point.X;
+            y = point.Z;
+            z = point.Y;
+        }
+    }
+
+    [XmlType(TypeName = "Vector2")]
+    public struct Vector2Export
+    {
+        public float x, y;
+
+        public Vector2Export(Point2f point)
+        {
+            x = point.X;
+            y = point.Y;
+        }
+    }
+
+    public struct Orient
+    {
+        public Vector3Export Center;
+        public QuaternionExport Rotation;
+
+        public Orient(Plane plane)
+        {
+            Center = new Vector3Export(plane.Origin);
+            Rotation = new QuaternionExport(plane);
+        }
+    }
+
+    [XmlType(TypeName = "Quaternion")]
+    public struct QuaternionExport
+    {
+        public float x, y, z, w;
+
+        public QuaternionExport(Plane plane)
+        {
+            var q = Quaternion.Rotation(Plane.WorldXY, plane);
+            w = (float)-q.A;
+            x = (float)q.B;
+            y = (float)q.D;
+            z = (float)q.C;
+        }
+    }
+}
diff --git a/Extensions/Model/Discrete/CurveSnap.cs b/Extensions/Model/Discrete/CurveSnap.cs
new file mode 100644
index 0000000..bae9128
--- /dev/null
+++ b/Extensions/Model/Discrete/CurveSnap.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using MoreLinq;
+using static System.Math;
+using static Extensions.Model.Util;
+
+namespace Extensions.Model.Discrete
+{
+    public static class CurveSnap
+    {
+        readonly static Sphere _unitSphere;
+
+        static CurveSnap()
+        {
+            _unitSphere = new Sphere(Point3d.Origin, 1);
+        }
+
+        public enum SnapType { Equirectangular, Icosahedral, Quadrangular }
+
+        public static Polyline SnapCurve(Curve curve, double length, SnapType snapType = SnapType.Equirectangular, int divisions = 0)
+        {
+            var snapVectors = SnapVectors();
+
+            var ts = curve.DivideByLength(length, true, out Point3d[] points);
+            Point3d next = points[0];
+            var polyline = new Point3d[ts.Length];
+            polyline[0] = next;
+
+            for (int i = 0; i < ts.Length - 1; i++)
+            {
+                var tangent = points[i + 1] - next;
+                var snappedVector = VectorSnap(tangent);
+                double segmentLength = tangent.Length;
+
+                next += snappedVector * segmentLength;
+                polyline[i + 1] = next;
+            }
+
+            return new Polyline(polyline);
+
+
+            IList<Vector3f> SnapVectors()
+            {
+                switch (snapType)
+                {
+                    case SnapType.Equirectangular:
+                        divisions += 1; divisions *= 2;
+                        return Mesh.CreateFromSphere(_unitSphere, divisions * 2, divisions).Normals;
+                    case SnapType.Icosahedral:
+                        return Mesh.CreateIcoSphere(_unitSphere, divisions).Normals;
+                    case SnapType.Quadrangular:
+                        return Mesh.CreateQuadSphere(_unitSphere, divisions).Normals;
+                    default:
+                        throw new NotSupportedException(" Snap type not supported.");
+                }
+            }
+
+            Vector3d VectorSnap(Vector3d vector)
+            {
+                double minAngle = double.MaxValue;
+                Vector3d minVector = Vector3d.Unset;
+
+                foreach (var v in snapVectors)
+                {
+                    var angle = Vector3d.VectorAngle(vector, v);
+                    if (angle < minAngle)
+                    {
+                        minAngle = angle;
+                        minVector = v;
+                    }
+                }
+
+                return minVector;
+            }
+        }
+    }
+}
diff --git a/Extensions/Model/Discrete/VoxelTiles.cs b/Extensions/Model/Discrete/VoxelTiles.cs
new file mode 100644
index 0000000..e9caf47
--- /dev/null
+++ b/Extensions/Model/Discrete/VoxelTiles.cs
@@ -0,0 +1,304 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using Rhino.Geometry.Intersect;
+using MoreLinq;
+using Extensions.Model.Spatial;
+using static System.Math;
+using static Extensions.Model.Util;
+using System.Collections.Concurrent;
+
+namespace Extensions.Model.Discrete
+{
+    internal class VoxelTiles
+    {
+        static Vector3d[] _faceNormals;
+        static Vector3d[] _edgeNormals;
+        static Vector3d[] _cornerNormals;
+
+        static Mesh UnitBox(double scale = 1.0)
+        {
+            double l = 0.5 * scale;
+            var corner = new Point3d(l, l, l);
+            var bbox = new BoundingBox(-corner, corner);
+            var meshBox = Mesh.CreateFromBox(bbox, 1, 1, 1);
+            meshBox.Weld(PI2);
+            meshBox.Vertices.CombineIdentical(true, true);
+            meshBox.Compact();
+            meshBox.RebuildNormals();
+
+            return meshBox;
+        }
+
+        static VoxelTiles()
+        {
+            var box = UnitBox();
+            _faceNormals = box.FaceNormals.Select(v => new Vector3d(v)).ToArray();
+            _cornerNormals = box.Normals.Select(v => new Vector3d(v)).ToArray();
+            _edgeNormals = Enumerable.Range(0, box.TopologyEdges.Count)
+                            .Select(i =>
+                            {
+                                var v = (Vector3d)box.TopologyEdges.EdgeLine(i).PointAt(0.5);
+                                v.Unitize();
+                                return v;
+                            }).ToArray();
+        }
+
+        public static IList<Voxel> Create(Mesh boundary, double length, List<Curve> alignments, double alignmentDistance, List<GeometryBase> attractors, double attractorDistance, int[] typesCount)
+        {
+            var voxels = new VoxelTiles(boundary, length, alignments, alignmentDistance, attractors, attractorDistance, typesCount);
+            var result = voxels.GetVoxels().Where(v => v.IsActive);
+            return result.ToList();
+        }
+
+        internal Voxel[,,] Voxels;
+        internal Vector3i Size;
+        internal double VoxelSize;
+        internal Point3d Corner;
+
+        int _count;
+        int[] _typesCount;
+
+        internal VoxelTiles(Mesh boundary, double length, List<Curve> alignments, double alignmentDistance, List<GeometryBase> attractors, double attractorDistance, int[] typesCount)
+        {
+            VoxelSize = length;
+            _typesCount = typesCount;
+
+            var bbox = boundary.GetBoundingBox(true);
+
+            var sizef = bbox.Diagonal / length;
+            Size = new Vector3i((int)sizef.X, (int)sizef.Y, (int)sizef.Z);
+            _count = Size.X * Size.Y * Size.Z;
+            sizef = new Vector3d(Size.X, Size.Y, Size.Z);
+            Corner = bbox.Min + (bbox.Diagonal - sizef * length) * 0.5f;
+
+            // make voxels
+            Voxels = new Voxel[Size.X, Size.Y, Size.Z];
+
+            for (int z = 0; z < Size.Z; z++)
+                for (int y = 0; y < Size.Y; y++)
+                    for (int x = 0; x < Size.X; x++)
+                    {
+                        Voxels[x, y, z] = new Voxel(new Vector3i(x, y, z), this);
+                    }
+
+            // voxelize shape
+            SetActiveVoxels(boundary);
+
+            // type
+            SetTypeClosest(attractors, attractorDistance);
+
+            // orientation
+            if (alignmentDistance == 0)
+                SetAlignmentsClosest(alignments);
+            else
+                SetAlignmentsFalloff(alignments, alignmentDistance);
+        }
+
+        void SetActiveVoxels(Mesh boundary)
+        {
+            var unitBox = UnitBox(VoxelSize);
+
+            Parallel.ForEach(GetVoxels(), voxel =>
+            {
+                var p = voxel.Location.Origin;
+                if (boundary.IsPointInside(p, Tol, true))
+                {
+                    voxel.IsActive = true;
+                }
+                else
+                {
+                    var m = unitBox.DuplicateMesh();
+                    m.Translate((Vector3d)p);
+                    var clashes = Intersection.MeshMeshFast(m, boundary);
+                    voxel.IsActive = clashes.Length > 0;
+                }
+            });
+        }
+
+        void SetTypeClosest(IEnumerable<GeometryBase> attractors, double maxDistance)
+        {
+            var points = attractors.Where(a => a is Point).Select(p => (p as Point).Location);
+            var curves = attractors.Where(a => a is Curve).Select(c => (c as Curve));
+            var pointCloud = new PointCloud(points);
+
+            foreach (var voxel in GetVoxels().Where(v => v.IsActive))
+            {
+                Point3d p = voxel.Location.Origin;
+                var closestIndex = pointCloud.ClosestPoint(p);
+                var closestPoint = pointCloud[closestIndex].Location;
+
+                double minDistance = p.DistanceToSquared(closestPoint);
+
+                foreach (var curve in curves)
+                {
+                    if (curve.ClosestPoint(p, out double t, minDistance))
+                    {
+                        minDistance = curve.PointAt(t).DistanceToSquared(p);
+                    }
+                }
+
+                var distance = Sqrt(minDistance);
+
+                var param = distance / maxDistance;
+                param = Rhino.RhinoMath.Clamp(param, 0.0, 1.0);
+                var typeCount = _typesCount.Max();
+                var type = (int)(param * typeCount);
+                if (type == typeCount) type--;
+                voxel.AttractorDistance = param;
+                voxel.Type = type;
+            }
+        }
+
+        void SetAlignmentsClosest(IEnumerable<Curve> curves)
+        {
+            foreach (var voxel in GetVoxels().Where(v => v.IsActive))
+            {
+                Point3d p = voxel.Location.Origin;
+                double minDistance = double.MaxValue;
+                Curve minCurve = null;
+                double minT = 0;
+
+                foreach (var curve in curves)
+                {
+                    if (curve.ClosestPoint(p, out double t, minDistance))
+                    {
+                        minDistance = curve.PointAt(t).DistanceToSquared(p);
+                        minT = t;
+                        minCurve = curve;
+                    }
+                }
+
+                var tangent = minCurve.TangentAt(minT);
+                var curvature = minCurve.CurvatureAt(minT);
+                var normal = Vector3d.CrossProduct(tangent, curvature);
+                var snapPlane = SnapPlane(voxel, normal, tangent);
+                voxel.Location = snapPlane.plane;
+                voxel.SnapType = snapPlane.snapType;
+            }
+        }
+
+        void SetAlignmentsFalloff(IList<Curve> curves, double maxDistance)
+        {
+            foreach (var voxel in GetVoxels().Where(v => v.IsActive))
+            {
+                Point3d p = voxel.Location.Origin;
+
+                double sumWeight = 0;
+                var tangent = Vector3d.Zero;
+                var curvature = Vector3d.Zero;
+
+                double currentMax = double.MaxValue;
+
+                foreach (var curve in curves)
+                {
+                    if (curve.ClosestPoint(p, out double t, currentMax))
+                    {
+                        var weight = maxDistance - curve.PointAt(t).DistanceTo(p);
+                        tangent += curve.TangentAt(t) * weight;
+                        curvature += curve.CurvatureAt(t) * weight;
+                        sumWeight += weight;
+                    }
+
+                    tangent /= sumWeight;
+                    curvature /= sumWeight;
+                }
+
+                if (sumWeight < UnitTol)
+                {
+                    voxel.IsActive = false;
+                }
+                else
+                {
+                    var normal = Vector3d.CrossProduct(tangent, curvature);
+                    var snapPlane = SnapPlane(voxel, normal, tangent);
+                    voxel.Location = snapPlane.plane;
+                    voxel.SnapType = snapPlane.snapType;
+                }
+            }
+        }
+
+        (Plane plane, int snapType) SnapPlane(Voxel voxel, Vector3d normal, Vector3d xAxis)
+        {
+            var snapVectors = new Vector3d[][]
+                {
+                   _faceNormals,
+                   _edgeNormals,
+                   _cornerNormals
+                };
+
+            var snaps = new List<(Vector3d vector, double distance, int snapType)>();
+
+            for (int i = 0; i < 3; i++)
+            {
+                if (_typesCount[i] - 1 >= voxel.Type)
+                {
+                    var (vector, distance) = VectorSnap(xAxis, snapVectors[i]);
+                    snaps.Add((vector, distance, i));
+                }
+            }
+
+            var xSnap = snaps.MinBy(s => s.distance).First();
+
+            var subVectors = snapVectors[xSnap.snapType]
+                                .Where(v => Abs(Vector3d.VectorAngle(xSnap.vector, v) - HalfPI) < HalfPI * 0.25);
+
+            var nSnap = VectorSnap(normal, subVectors);
+            var ySnap = -Vector3d.CrossProduct(nSnap.vector, xSnap.vector);
+
+            return (new Plane(voxel.Location.Origin, xSnap.vector, ySnap), xSnap.snapType);
+        }
+
+        (Vector3d vector, double distance) VectorSnap(Vector3d vector, IEnumerable<Vector3d> snapVectors)
+        {
+            double minAngle = double.MaxValue;
+            Vector3d minVector = Vector3d.Unset;
+
+            foreach (var v in snapVectors)
+            {
+                var angle = Vector3d.VectorAngle(vector, v);
+                if (angle < minAngle)
+                {
+                    minAngle = angle;
+                    minVector = v;
+                }
+            }
+
+            return (minVector, minAngle);
+        }
+
+        IEnumerable<Voxel> GetVoxels()
+        {
+            for (int z = 0; z < Size.Z; z++)
+                for (int y = 0; y < Size.Y; y++)
+                    for (int x = 0; x < Size.X; x++)
+                    {
+                        yield return Voxels[x, y, z];
+                    }
+        }
+    }
+
+    internal class Voxel
+    {
+        public Vector3i Index;
+        public Plane Location;
+        public bool IsActive;
+        public int Type;
+        public double AttractorDistance;
+        public int SnapType;
+        //public GeometryBase Geometry;
+
+        VoxelTiles _grid;
+
+        public Voxel(Vector3i index, VoxelTiles grid)
+        {
+            _grid = grid;
+            Index = index;
+            Location = Plane.WorldXY;
+            Location.Origin = grid.Corner + new Vector3d(index.X + 0.5f, index.Y + 0.5f, index.Z + 0.5f) * grid.VoxelSize;
+        }
+    }
+}
diff --git a/Extensions/Model/Document/Cache.cs b/Extensions/Model/Document/Cache.cs
new file mode 100644
index 0000000..b9a32bb
--- /dev/null
+++ b/Extensions/Model/Document/Cache.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Drawing;
+using Rhino.Geometry;
+using Extensions.Model.Spatial;
+using MoreLinq;
+using static System.Math;
+
+namespace Extensions.Model.Document
+{
+    static class Cache
+    {
+        const string _layerName = "Cache";
+
+        public static T Read<T>(string name) where T : GeometryBase
+        {
+            var doc = Rhino.RhinoDoc.ActiveDoc;
+            var layer = doc.Layers.FindName(_layerName);
+
+            if (layer is null)
+                return null;
+
+            return Array.Find(doc.Objects.FindByLayer(layer), o => o.Name == name && o.Geometry is T)
+                    ?.Geometry as T;
+        }
+
+        public static void Write<T>(string name, T geometry) where T: GeometryBase
+        {
+            var doc = Rhino.RhinoDoc.ActiveDoc;
+            var layer = doc.Layers.FindName(_layerName);
+
+            if (layer is null)
+            {
+                int index = doc.Layers.Add(_layerName, Color.Black);
+                layer = doc.Layers.FindIndex(index);
+            }
+
+            var attributes = new Rhino.DocObjects.ObjectAttributes
+            {
+                LayerIndex = layer.Index,
+                Name = name
+            };
+
+            doc.Objects.Add(geometry, attributes);
+       }
+    }
+}
diff --git a/Extensions/Model/Document/Debug.cs b/Extensions/Model/Document/Debug.cs
new file mode 100644
index 0000000..41fb716
--- /dev/null
+++ b/Extensions/Model/Document/Debug.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Drawing;
+using Rhino.Geometry;
+using Rhino.DocObjects;
+
+namespace Extensions.Model.Document
+{
+    static class Debug
+    {
+        public static void Bake<T>(T geometry, Color? color = null)
+        {
+            const string layerName = "Debug";
+            var doc = Rhino.RhinoDoc.ActiveDoc;
+            var layer = doc.Layers.FindName(layerName);
+
+            if (layer == null)
+            {
+                var layerIndex = doc.Layers.Add(layerName, Color.Red);
+                layer = doc.Layers.FindIndex(layerIndex);
+            }
+
+            var att = new ObjectAttributes
+            {
+                LayerIndex = layer.Index
+            };
+
+            if (color != null)
+            {
+                att.ColorSource = ObjectColorSource.ColorFromObject;
+                att.ObjectColor = (Color)color;
+            }
+
+            switch (geometry)
+            {
+                case GeometryBase geo:
+                    doc.Objects.Add(geo, att);
+                    break;
+                case Polyline pl:
+                    doc.Objects.AddPolyline(pl, att);
+                    break;
+                case IEnumerable<Point3d> pc:
+                    doc.Objects.AddPointCloud(new PointCloud(pc), att);
+                    break;
+                case Line l:
+                    doc.Objects.AddLine(l, att);
+                    break;
+                default:
+                    throw new ArgumentException(" Geometry type not recognized.");
+            }
+        }
+    }
+}
diff --git a/Extensions/Model/Geometry/BallPivot.cs b/Extensions/Model/Geometry/BallPivot.cs
new file mode 100644
index 0000000..8353f43
--- /dev/null
+++ b/Extensions/Model/Geometry/BallPivot.cs
@@ -0,0 +1,139 @@
+using System.Collections.Generic;
+using System.Linq;
+using Rhino.Geometry;
+using Extensions.Model.Spatial;
+using MoreLinq;
+
+namespace Extensions.Model.Geometry
+{
+    internal class BallPivot
+    {
+        public static Polyline Create(IEnumerable<Polyline> contour, double radius)
+        {
+            return new BallPivot(contour, radius).Polyline;
+        }
+
+        public static Polyline Create(Polyline contour, double radius)
+        {
+            return new BallPivot(Enumerable.Repeat(contour, 1), radius).Polyline;
+        }
+
+        readonly BucketSearchSparse2d<Point> _search;
+        readonly List<Point> _points;
+        BoundingBox _box;
+        int _start;
+        Polyline Polyline { get; }
+
+        BallPivot(IEnumerable<Polyline> contour, double radius)
+        {
+            contour = contour
+                .MaxBy(p => p.Length)
+                .Select(FixDirection);
+
+            var polylines = DivideCurves(contour, radius).ToArray();
+            var points = polylines.SelectMany(p => p);
+
+            if (!points.Any())
+            {
+                Polyline = new Polyline();
+                return;
+            }
+
+            var normals = polylines.SelectMany(p => p.GetNormals());
+
+            int i = 0;
+            _points = points.Zip(normals, (p, n) => new Point() { Position = p, Normal = n, Index = i++ }).ToList();
+            _search = new BucketSearchSparse2d<Point>(radius);
+            _search.Populate(_points);
+            _box = new BoundingBox(points);
+
+            Polyline = Pivot();
+        }
+
+        Polyline FixDirection(Polyline polyline)
+        {
+            int count = polyline.Count;
+            var a = polyline[0];
+            var b = polyline[(int)(count * (1 / 3.0))];
+            var c = polyline[(int)(count * (2 / 3.0))];
+            var n = Vector3d.CrossProduct(b - a, c - a);
+            if (n.Z > 0)
+            {
+                var pl = new Polyline(polyline);
+                pl.Reverse();
+                return pl;
+            }
+
+            return polyline;
+            //Document.Debug.Bake(polyline,System.Drawing.Color.Green);
+        }
+
+
+        IEnumerable<Polyline> DivideCurves(IEnumerable<Polyline> contour, double radius)
+        {
+            foreach (var pl in contour)
+            {
+                var curve = new PolylineCurve(pl);
+                curve.DivideByLength(radius * 0.25, true, false, out Point3d[] points);
+
+                if (points == null || points.Length < 3)
+                    yield return new Polyline();
+                else
+                    yield return new Polyline(points);
+            }
+        }
+
+        Polyline Pivot()
+        {
+            Point first = null;
+            Point second = _points.MinBy(p => p.Position.DistanceToSquared(_box.Max)).First();
+            _start = second.Index;
+
+            Polyline pl = new Polyline() { second.Position };
+
+            while (true)
+            {
+                var next = FindNext(first, second);
+                if (next == null)
+                    break;
+                first = second;
+                second = next;
+                pl.Add(next.Position);
+            }
+
+            pl.Add(pl[0]);
+            return pl;
+        }
+
+        Point FindNext(Point a, Point b)
+        {
+            int indexb = Index(b);
+            var closests = _search.GetClosests(b);
+
+            //if (a != null)
+            {
+                closests = closests.Where(p => Index(p) > indexb && ((Index(p) - indexb) < _points.Count / 2));
+            }
+
+            if (!closests.Any())
+                return null;
+
+            Vector3d vector = a == null ? b.Normal : a.Position - b.Position;
+
+            var next = closests
+                .MinBy(p => Vector3d.VectorAngle(vector, p.Position - b.Position, -Vector3d.ZAxis))
+                .First();
+
+            return next;
+
+            int Index(Point p) => p.Index < _start ? _points.Count - 1 + p.Index : p.Index;
+        }
+    }
+
+    class Point : IPositionable
+    {
+        public Point3d Position { get; set; }
+        public Vector3d Normal { get; set; }
+        public int Index { get; set; }
+    }
+}
diff --git a/Extensions/Model/Geometry/MeshPipe.cs b/Extensions/Model/Geometry/MeshPipe.cs
new file mode 100644
index 0000000..e7ecffb
--- /dev/null
+++ b/Extensions/Model/Geometry/MeshPipe.cs
@@ -0,0 +1,336 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Drawing;
+using Rhino.Geometry;
+using Extensions.Model.Spatial;
+using MoreLinq;
+using static System.Math;
+using static Extensions.Model.Util;
+
+namespace Extensions.Model.Geometry
+{
+    static class MeshPipe
+    {
+        public static Mesh MeshFlatPolyline(Polyline polyline, double width, double height, double fillet = 0, int segments = 24)
+        {
+            if (fillet > 0)
+            {
+                polyline = Fillet(polyline, fillet);
+                polyline.ReduceSegments(0.01);
+                //polyline.CollapseShortSegments(0.1);
+                // polyline.MergeColinearSegments(PI * 0.01, true);
+            }
+            //var planes = polyline.Select(p => new Plane(p, Vector3d.ZAxis)).ToList();
+            return MeshExtrusion(polyline, width, height, segments);
+        }
+
+        public static Mesh MeshPlanes(List<Plane> inPlanes, double width, double height, int segments = 24)
+        {
+            inPlanes = inPlanes.ToList();
+            if (inPlanes.Count < 3) return null;
+
+            bool isClosed = Abs(inPlanes[0].Origin.DistanceToSquared(inPlanes[inPlanes.Count - 1].Origin)) < Tol * Tol;
+            if (isClosed) inPlanes.RemoveAt(inPlanes.Count - 1);
+            int last = inPlanes.Count - 1;
+
+            width *= 0.5;
+            height *= 0.5;
+            var profile = new List<Point3d>();
+            double step = PI2 / segments;
+
+            for (int i = 0; i < segments; i++)
+            {
+                double angle = i * step;
+                var vertex = new Point3d(Cos(angle) * width, Sin(angle) * height, 0);
+                profile.Add(vertex);
+            }
+
+            var planes = new List<(Plane, double)>(inPlanes.Count);
+
+            for (int i = 0; i < inPlanes.Count; i++)
+            {
+                Point3d p = inPlanes[i].Origin;
+
+                Vector3d va = p - (i == 0 ? inPlanes[last].Origin : inPlanes[i - 1].Origin);
+                Vector3d vb = (i == last ? inPlanes[0].Origin : inPlanes[i + 1].Origin) - p;
+
+                va.Unitize();
+                vb.Unitize();
+
+                Vector3d vz = va + vb;
+
+                if (!isClosed)
+                {
+                    if (i == 0) vz = vb;
+                    if (i == inPlanes.Count - 1) vz = va;
+                }
+
+                Vector3d vy = inPlanes[i].Normal;
+                Vector3d vx = Vector3d.CrossProduct(-vz, vy);
+                Point3d origin = inPlanes[i].Origin - (inPlanes[i].Normal * height);
+                var plane = new Plane(origin, vx, vy);
+                double scale = 1;
+
+                if (isClosed || (i > 0 && i < last))
+                {
+                    var angle = Vector3d.VectorAngle(-va, vb) * 0.5;
+                    scale = 1 / Sin(angle);
+                }
+
+                planes.Add((plane, scale));
+            }
+
+            int vertexCount = planes.Count * segments;
+
+            var points = new List<Point3d>(vertexCount);
+            var normals = new List<Vector3f>(vertexCount);
+
+            foreach (var (plane, scale) in planes)
+            {
+                var pl = new Polyline(segments + 1);
+                foreach (Point3d point in profile)
+                {
+                    var scaledPoint = point;
+                    scaledPoint.X *= scale;
+                    var vertex = plane.PointAt(scaledPoint.X, scaledPoint.Y);
+                    // var normal = vertex - plane.Origin;
+                    //normal.Unitize();
+                    points.Add(vertex);
+                    pl.Add(vertex);
+                    //normals.Add(new Vector3f((float)normal.X, (float)normal.Y, (float)normal.Z));
+                }
+
+                pl.Add(pl[0]);
+                var normal = pl.GetNormals().Select(n => n.ToVector3f()).ToArray();
+                normals.AddRange(normal);
+            }
+
+            var faces = new List<MeshFace>();
+            int count = isClosed ? vertexCount : vertexCount - segments;
+
+            for (int i = 0; i < count; i++)
+            {
+                int k = i + 1;
+                int j = (k % segments == 0) ? k - segments : k;
+
+                int sj = j + segments;
+                int si = i + segments;
+                if (i >= points.Count - segments)
+                {
+                    sj -= points.Count;
+                    si -= points.Count;
+                }
+
+                faces.Add(new MeshFace(i, j, sj, si));
+            }
+
+            var mesh = new Mesh();
+            mesh.Vertices.AddVertices(points);
+            mesh.Normals.AddRange(normals.ToArray());
+            mesh.Faces.AddFaces(faces);
+
+            return mesh;
+        }
+
+        public static Mesh MeshExtrusion(Polyline polyline, double width, double height, int segments = 12)
+        {
+            if (width < height) throw new ArgumentException(" Width must be larger or equal to height.");
+            if (!polyline.IsValid) return new Mesh(); // throw new ArgumentException(" Invalid polyline.");
+
+            segments *= 2;
+            polyline = new Polyline(polyline);
+            bool isClosed = polyline.IsClosed;
+            if (isClosed) polyline.RemoveAt(polyline.Count - 1);
+            int last = polyline.Count - 1;
+
+            width *= 0.5;
+            height *= 0.5;
+            var profile = new List<Point3d>(segments / 2);
+            double step = PI / ((segments / 2) - 1);
+
+            for (int i = 0; i < segments / 2; i++)
+            {
+                double angle = i * step - HalfPI;
+                var vertex = new Point3d(Cos(angle) * height, Sin(angle) * height, 0);
+                profile.Add(vertex);
+            }
+
+            var planes = new List<(Plane, double)>(polyline.Count);
+
+            for (int i = 0; i < polyline.Count; i++)
+            {
+                Point3d p = polyline[i];
+                Vector3d va = p - (i == 0 ? polyline[last] : polyline[i - 1]);
+                Vector3d vb = (i == last ? polyline[0] : polyline[i + 1]) - p;
+
+                va.Unitize();
+                vb.Unitize();
+
+                Vector3d vz = va + vb;
+
+                if (!isClosed)
+                {
+                    if (i == 0) vz = vb;
+                    if (i == polyline.Count - 1) vz = va;
+                }
+
+                Vector3d vy = Vector3d.ZAxis;
+                Vector3d vx = Vector3d.CrossProduct(-vz, vy);
+                Point3d origin = p - (Vector3d.ZAxis * height);
+                var plane = new Plane(origin, vx, vy);
+                double scale = width;
+
+                if (isClosed || (i > 0 && i < last))
+                {
+                    var angle = Vector3d.VectorAngle(-va, vb) * 0.5;
+                    if (angle < PI * 0.25) angle = PI * 0.25;
+                    scale = width / Sin(angle);
+                }
+
+                planes.Add((plane, scale));
+            }
+
+            int vertexCount = planes.Count * segments;
+
+            var points = new List<Point3d>(vertexCount);
+            var normals = new List<Vector3f>(vertexCount);
+
+            foreach (var (plane, scale) in planes)
+            {
+                var pl = new Polyline(segments);
+
+                foreach (Point3d point in profile)
+                {
+                    var vertex = plane.PointAt(point.X + scale - height, point.Y);
+                    pl.Add(vertex);
+                }
+
+                foreach (Point3d point in profile)
+                {
+                    var vertex = plane.PointAt(-point.X - scale + height, -point.Y);
+                    pl.Add(vertex);
+                }
+
+                points.AddRange(pl);
+                pl.Add(pl[0]);
+                var normal = pl.GetNormals().Select(n => n.ToVector3f()).ToArray();
+
+                normals.AddRange(normal);
+            }
+
+            var faces = new List<MeshFace>();
+            int count = isClosed ? vertexCount : vertexCount - segments;
+
+            for (int i = 0; i < count; i++)
+            {
+                int k = i + 1;
+                int j = (k % segments == 0) ? k - segments : k;
+
+                int sj = j + segments;
+                int si = i + segments;
+                if (i >= points.Count - segments)
+                {
+                    sj -= points.Count;
+                    si -= points.Count;
+                }
+
+                faces.Add(new MeshFace(i, j, sj, si));
+            }
+
+            var mesh = new Mesh();
+            mesh.Vertices.AddVertices(points);
+            mesh.Normals.AddRange(normals.ToArray());
+            mesh.Faces.AddFaces(faces);
+
+            return mesh;
+        }
+
+        public static Polyline Fillet(Polyline polyline, double radius = 2)
+        {
+            polyline = new Polyline(polyline);
+
+            if (polyline.Count < 3)
+                return polyline;
+
+            bool isClosed = polyline.IsClosed;
+
+            if (isClosed)
+            {
+                polyline.RemoveAt(polyline.Count - 1);
+            }
+
+
+            var fillet = new Polyline(isClosed ? polyline.Count * 3 : (polyline.Count - 2) * 3 + 2);
+
+            for (int i = 0; i < polyline.Count; i++)
+            {
+                var p = polyline[i];
+                if ((i == 0 || i == polyline.Count - 1) && !isClosed)
+                {
+                    fillet.Add(p);
+                    continue;
+                }
+
+                var r = radius;
+                var prev = i == 0 ? polyline[polyline.Count - 1] : polyline[i - 1];
+                var next = i == polyline.Count - 1 ? polyline[0] : polyline[i + 1];
+
+                var va = prev - p;
+                var vb = next - p;
+                var aLength = va.Length;
+                var bLength = vb.Length;
+
+                var minLength = Min(aLength, bLength);
+
+                if (minLength < Tol)
+                {
+                    fillet.Add(p);
+                    continue;
+                }
+
+                va.Unitize();
+                vb.Unitize();
+
+                var vmid = va + vb;
+
+                if (vmid.IsTiny(Tol))
+                {
+                    fillet.Add(p);
+                    continue;
+                }
+
+                vmid.Unitize();
+
+                var angle = Vector3d.VectorAngle(va, vb) * 0.5;
+                var tan = Tan(angle);
+                var length = r / tan;
+
+                bool isShort = length > minLength * 0.5;
+                bool aIsShort = length > aLength * 0.5;
+
+                if (isShort)
+                {
+                    length = minLength * 0.5;
+                    r = tan * length;
+                }
+
+                var mid = Sqrt((r * r) + (length * length)) - r;
+
+                if (!aIsShort || (i == 1 && !isClosed))
+                    fillet.Add(p + (va * length));
+                fillet.Add(p + (vmid * mid));
+                fillet.Add(p + (vb * length));
+            }
+
+            if (isClosed)
+            {
+                fillet.Add(fillet[0]);
+            }
+
+            return fillet;
+        }
+    }
+}
diff --git a/Extensions/Model/Geometry/PolygonFill.cs b/Extensions/Model/Geometry/PolygonFill.cs
new file mode 100644
index 0000000..d799eb3
--- /dev/null
+++ b/Extensions/Model/Geometry/PolygonFill.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using MoreLinq;
+using static System.Math;
+
+namespace Extensions.Model.Geometry
+{
+    static class PolygonFill
+    {
+        public static Polyline[][] Square(Polyline[] contours, double size, double offset)
+        {
+            if (contours.Length == 0)
+                return new Polyline[0][];
+
+            var box = new BoundingBox(contours.SelectMany(p => p));
+            box.Inflate(offset);
+
+            int countX = (int)Ceiling(box.Diagonal.X / size);
+            int countY = (int)Ceiling(box.Diagonal.Y / size);
+
+            double stepX = box.Diagonal.X / countX;
+            double stepY = box.Diagonal.Y / countY;
+
+            var rectangles = new List<Polyline>(countX * countY);
+
+            for (double x = box.Min.X; x < box.Max.X; x += stepX)
+            {
+                for (double y = box.Min.Y; y < box.Max.Y; y += stepY)
+                {
+                    var rect = new Rectangle3d(Plane.WorldXY, new Point3d(x + offset, y + offset, 0), new Point3d(x + stepX - offset, y + stepY - offset, 0));
+                    rectangles.Add(rect.ToPolyline());
+                }
+            }
+
+            int layerCount = contours.Length;
+            var layers = new Polyline[layerCount][];
+
+            Parallel.ForEach(Partitioner.Create(0, layerCount), range =>
+            {
+                for (int i = range.Item1; i < range.Item2; i++)
+                {
+                    // var skinOffset = Region.Offset(contours[i], offset);
+                    var skinOffset = contours[i];
+                    if (!skinOffset.IsValid)
+                    {
+                        layers[i] = new Polyline[0];
+                        continue;
+                    }
+
+                    var squares = rectangles.SelectMany(r => Region.Intersection(Enumerable.Repeat(r, 1), Enumerable.Repeat(skinOffset, 1))).ToArray();
+                    //layers[i] = squares.Select(s => Region.Offset(s, offset)).Append(contours[i]).Where(p => p.IsValid).ToArray();
+                    layers[i] = squares;
+                }
+            });
+
+            return layers;
+        }
+    }
+}
diff --git a/Extensions/Model/Geometry/Remesher.cs b/Extensions/Model/Geometry/Remesher.cs
new file mode 100644
index 0000000..52f6a32
--- /dev/null
+++ b/Extensions/Model/Geometry/Remesher.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using g3;
+using Rhino.Geometry;
+
+namespace Extensions.Model.Geometry
+{
+    public static class Remesh
+    {
+        public static DMesh3 ToDMesh3(this Mesh mesh)
+        {
+            var dMesh3 = new DMesh3();
+
+            for (int i = 0; i < mesh.Vertices.Count; i++)
+            {
+                var vertex = mesh.Vertices[i];
+                var normal = mesh.Normals[i];
+
+                NewVertexInfo ni = new NewVertexInfo()
+                {
+                    v = new g3.Vector3d(vertex.X, vertex.Z, vertex.Y),
+                    n = new g3.Vector3f(normal.X, normal.Z, normal.Y)
+                };
+
+                dMesh3.AppendVertex(ni);
+            }
+
+            foreach (var face in mesh.Faces)
+            {
+                dMesh3.AppendTriangle(face.A, face.B, face.C);
+            }
+
+            return dMesh3;
+        }
+
+        public static Mesh ToRhinoMesh(this DMesh3 dMesh3)
+        {
+            dMesh3 = new DMesh3(dMesh3, true, MeshComponents.All);
+            var mesh = new Mesh();
+
+            var vertices = dMesh3.Vertices().Select(v => new Point3d(v.x, v.z, v.y));
+            var faces = dMesh3.Triangles().Select(f => new MeshFace(f.a, f.b, f.c));
+
+            mesh.Vertices.AddVertices(vertices);
+            mesh.Faces.AddFaces(faces);
+            mesh.Normals.ComputeNormals();
+            mesh.Compact();
+
+            return mesh;
+        }
+
+
+        public static Mesh RemeshTest(Mesh inMesh, double fResScale = 1.0, int iterations = 50)
+        {
+            inMesh.Faces.ConvertQuadsToTriangles();
+            DMesh3 mesh = inMesh.ToDMesh3();
+            mesh.CheckValidity();
+            AxisAlignedBox3d bounds = mesh.CachedBounds;
+
+            // construct mesh projection target
+            DMesh3 meshCopy = new DMesh3(mesh);
+            meshCopy.CheckValidity();
+            DMeshAABBTree3 tree = new DMeshAABBTree3(meshCopy);
+            tree.Build();
+            MeshProjectionTarget target = new MeshProjectionTarget()
+            {
+                Mesh = meshCopy,
+                Spatial = tree
+            };
+
+            // construct constraint set
+            MeshConstraints cons = new MeshConstraints();
+
+            //EdgeRefineFlags useFlags = EdgeRefineFlags.NoFlip | EdgeRefineFlags.NoCollapse;
+            EdgeRefineFlags useFlags = EdgeRefineFlags.NoFlip;
+
+            foreach (int eid in mesh.EdgeIndices())
+            {
+                double fAngle = MeshUtil.OpeningAngleD(mesh, eid);
+                if (fAngle > 30.0)
+                {
+                    cons.SetOrUpdateEdgeConstraint(eid, new EdgeConstraint(useFlags));
+                    Index2i ev = mesh.GetEdgeV(eid);
+                    int nSetID0 = (mesh.GetVertex(ev[0]).y > bounds.Center.y) ? 1 : 2;
+                    int nSetID1 = (mesh.GetVertex(ev[1]).y > bounds.Center.y) ? 1 : 2;
+                    cons.SetOrUpdateVertexConstraint(ev[0], new VertexConstraint(true, nSetID0));
+                    cons.SetOrUpdateVertexConstraint(ev[1], new VertexConstraint(true, nSetID1));
+                }
+            }
+
+            Remesher r = new Remesher(mesh);
+            r.Precompute();
+            r.SetExternalConstraints(cons);
+            r.SetProjectionTarget(target);
+
+            r.EnableFlips = r.EnableSplits = r.EnableCollapses = true;
+            r.MinEdgeLength = 0.5 * fResScale;
+            r.MaxEdgeLength = 1.0 * fResScale;
+            r.EnableSmoothing = true;
+            r.SmoothSpeedT = 0.5;
+
+            try
+            {
+                for (int k = 0; k < iterations; ++k)
+                {
+                    r.BasicRemeshPass();
+                    // mesh.CheckValidity();
+                }
+            }
+            catch
+            {
+                // ignore
+            }
+
+            return mesh.ToRhinoMesh();
+        }
+    }
+}
diff --git a/Extensions/Model/Geometry/Slicer.cs b/Extensions/Model/Geometry/Slicer.cs
new file mode 100644
index 0000000..f16fb5d
--- /dev/null
+++ b/Extensions/Model/Geometry/Slicer.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using static System.Math;
+
+namespace Extensions.Model.Geometry
+{
+    class Slicer
+    {
+        public static Polyline[][] Create(Mesh mesh, double height, Interval modelRegion)
+        {
+            var slicer = new Slicer(mesh, height, modelRegion);
+            slicer.Slice();
+            return slicer.Contours;
+        }
+
+        readonly Mesh _mesh;
+        readonly double _height;
+        Interval _modelRegion;
+
+        Polyline[][] Contours { get; set; }
+
+        private Slicer(Mesh mesh, double height, Interval modelRegion)
+        {
+            _mesh = mesh;
+            _height = height;
+            _modelRegion = modelRegion;
+        }
+
+        void Slice()
+        {
+            var box = _mesh.GetBoundingBox(true);
+            var layerCount = (int)Ceiling(box.Diagonal.Z / _height) - 1;
+            var planes = Enumerable.Range(0, layerCount).Select(i => new Plane(new Point3d(0, 0, (i + 1) * _height), Vector3d.ZAxis)).ToList();
+            var subPlanes = planes.GetRange((int)(_modelRegion.T0 * (planes.Count - 1)), (int)Ceiling(_modelRegion.Length * planes.Count));
+
+            var processors = Environment.ProcessorCount;
+            var chunk = (int)Ceiling(subPlanes.Count / (double)processors);
+            if (chunk == 0) chunk = 1;
+            var partitions = Partitioner.Create(0, subPlanes.Count, chunk);
+
+            Contours = new Polyline[subPlanes.Count][];
+
+            Parallel.ForEach(partitions, range =>
+            {
+                var loopPlanes = subPlanes.GetRange(range.Item1, range.Item2 - range.Item1);
+
+                var layers = Rhino.Geometry.Intersect.Intersection.MeshPlane(_mesh, loopPlanes)
+                                   .GroupBy(p => (int)Round(p[0].Z / _height))
+                                   .Select(p => p.ToArray())
+                                   .ToArray();
+
+                for (int i = 0; i < layers.Length; i++)
+                {
+                    Contours[range.Item1 + i] = layers[i];
+                }
+            });
+        }
+    }
+}
diff --git a/Extensions/Model/Regions/Region.cs b/Extensions/Model/Regions/Region.cs
new file mode 100644
index 0000000..a7a7bdc
--- /dev/null
+++ b/Extensions/Model/Regions/Region.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Drawing;
+using Rhino.Geometry;
+using MoreLinq;
+using static System.Math;
+using static Extensions.Model.Util;
+using ClipperLib;
+
+namespace Extensions.Model.Geometry
+{
+    static class Region
+    {
+        public static Polyline Offset(Polyline polyline, double distance)
+        {
+            if (polyline.Count < 2) return new Polyline();
+
+            var region = polyline.ToRegion();
+            var offset = new ClipperOffset();
+            offset.AddPath(region, JoinType.jtRound, EndType.etClosedPolygon);
+            PolyTree tree = new PolyTree();
+           
+            offset.Execute(ref tree, distance / Tol);
+
+            var height = polyline[0].Z;
+            var first = tree.ToPolylines(height).MaxBy(p => p.Length).FirstOrDefault();
+            return first ?? new Polyline(0);
+        }
+
+        public static Polyline[] Intersection(IEnumerable<Polyline> a, IEnumerable<Polyline> b)
+        {
+            Clipper clipper = new Clipper(Clipper.ioStrictlySimple);
+            clipper.AddPaths(a.ToRegions(), PolyType.ptClip, true);
+            clipper.AddPaths(b.ToRegions(), PolyType.ptSubject, true);
+
+            PolyTree tree = new PolyTree();
+            clipper.Execute(ClipType.ctIntersection, tree);
+
+            double height = b.First()[0].Z;
+            return tree.ToPolylines(height);
+        }
+
+        public static List<IntPoint> ToRegion(this Polyline polyline)
+        {
+            return polyline.Select(p => new IntPoint(p.X / Tol, p.Y / Tol)).ToList();
+        }
+
+        public static List<List<IntPoint>> ToRegions(this IEnumerable<Polyline> polylines)
+        {
+            return polylines.Select(ToRegion).ToList();
+        }
+
+        public static Polyline[] ToPolylines(this PolyTree tree, double height)
+        {
+            var polylines = new Polyline[tree.ChildCount];
+
+            for (int i = 0; i < tree.ChildCount; i++)
+            {
+                var node = tree.Childs[i];
+                var pl = new Polyline(node.m_polygon.Select(p => new Point3d(p.X * Tol, p.Y * Tol, height)));
+                pl.Add(pl[0]);
+                polylines[i] = pl;
+            }
+
+            return polylines;
+        }
+    }
+}
diff --git a/Extensions/Model/Regions/StraightSkeleton.cs b/Extensions/Model/Regions/StraightSkeleton.cs
new file mode 100644
index 0000000..220ed04
--- /dev/null
+++ b/Extensions/Model/Regions/StraightSkeleton.cs
@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using StraightSkeletonNet;
+using Rhino.Geometry;
+
+namespace Extensions.Model.StraightSkeleton
+{
+    public static class StraightSkeleton
+    {
+        const double Tol = 0.001;
+
+        public static IEnumerable<Polyline> GetStraightSkeleton(Polyline polyline)
+        {
+            if (!polyline.IsClosed)
+                throw new Exception(" Polyline must be closed.");
+
+            var polygon = polyline.Select(p => p.ToVector2d()).ToList();
+            polygon.RemoveAt(polygon.Count - 1);
+
+            var skeleton = SkeletonBuilder.Build(polygon);
+
+            return skeleton.Edges.Select(e =>
+                {
+                    var region = new Polyline(e.Polygon.Select(v => v.ToPoint3d()));
+                    region.Add(region[0]);
+                    return region;
+                }
+            );
+        }
+
+        static bool Exists(Point3d point, PointCloud pc)
+        {
+            int index = pc.ClosestPoint(point);
+            if (index == -1) return false;
+            Point3d closest = pc[index].Location;
+            return (closest - point).SquareLength < 0.0001;
+        }
+
+        public static Polyline GetAxis(IEnumerable<Polyline> regions, Polyline boundary)
+        {
+            var lines = regions.SelectMany(e => e.GetSegments());
+            var pc = new PointCloud(boundary.GetSegments().Select(l => l.PointAt(0.5)));
+
+            var edges = lines.Select(l => (Line: l, Center: l.PointAt(0.5)));
+            var interiorEdges = edges.Where(e => !Exists(e.Center, pc));
+            var interiorLines = new List<Line>();
+
+            foreach (var edge in interiorEdges)
+            {
+                if (Exists(edge.Center, pc)) continue;
+
+                pc.Add(edge.Center);
+                interiorLines.Add(edge.Line);
+            }
+
+            return GetAxis(interiorLines);
+        }
+
+
+        public static Polyline GetAxis(IEnumerable<Line> lines)
+        {
+            var allPoints = lines.SelectMany(l => new Point3d[] { l.From, l.To });
+            var pc = new PointCloud();
+
+            foreach (var point in allPoints)
+            {
+                if (Exists(point, pc)) continue;
+                pc.Add(point);
+            }
+
+            var nodes = new List<List<Edge>>(Enumerable.Repeat(new List<Edge>(), pc.Count));
+
+            var edges = lines.Select(l =>
+            {
+                var edge = new Edge() { Start = pc.ClosestPoint(l.From), End = pc.ClosestPoint(l.To), Line = l, Enabled = true };
+                nodes[edge.Start].Add(edge);
+                nodes[edge.End].Add(edge);
+                return edge;
+            }).ToList();
+
+            while (true)
+            {
+                var toDisable = new List<Edge>();
+
+                for (int i = 0; i < nodes.Count; i++)
+                {
+                    var node = nodes[i];
+                    int valence = node.Count(e => e.Enabled);
+
+                    if (valence == 1)
+                    {
+                        var edge = node.First(e => e.Enabled);
+                        var j = edge.Start == i ? edge.End : edge.Start;
+
+                        int otherValence = nodes[j].Count(e => e.Enabled);
+                        if (otherValence >= 3) toDisable.Add(edge);
+                    }
+                }
+
+                if (toDisable.Count == 0) break;
+
+                foreach (var edge in toDisable)
+                    edge.Enabled = false;
+            }
+
+            var axes = edges
+                .Where(e => e.Enabled)
+                .Select(e => e.Line.ToNurbsCurve());
+
+            var curve = Curve.JoinCurves(axes);
+            Polyline pl = new Polyline();
+
+            if (curve.Length > 0)
+            {
+                curve[0].TryGetPolyline(out pl);
+            }
+            else
+            {
+                Line maxLine = Line.Unset;
+                double maxLength = 0;
+
+                foreach (var line in lines)
+                {
+                    double length = line.Direction.SquareLength;
+                    if (length > maxLength)
+                    {
+                        maxLength = length;
+                        maxLine = line;
+                    }
+                }
+
+                pl = new Polyline(new Point3d[] { maxLine.From, maxLine.To });
+            }
+
+            return pl;
+        }
+
+        class Edge
+        {
+            public int Start;
+            public int End;
+            public Line Line;
+            public bool Enabled;
+        }
+
+
+        static StraightSkeletonNet.Primitives.Vector2d ToVector2d(this Point3d point)
+        {
+            point /= 0.1;
+            return new StraightSkeletonNet.Primitives.Vector2d(point.X, point.Y);
+        }
+
+        static Point3d ToPoint3d(this StraightSkeletonNet.Primitives.Vector2d vector)
+        {
+            var point = new Point3d(vector.X, vector.Y, 0);
+            point *= 0.1;
+            return point;
+        }
+    }
+}
diff --git a/Extensions/Model/Rendering/RenderExtensions.cs b/Extensions/Model/Rendering/RenderExtensions.cs
index 2d97e27..302286a 100644
--- a/Extensions/Model/Rendering/RenderExtensions.cs
+++ b/Extensions/Model/Rendering/RenderExtensions.cs
@@ -99,10 +99,18 @@ public static IEnumerable<Mesh> BitmapFromSolidColoredMeshes(IEnumerable<Mesh> m
 
         public static Mesh SetTextureCoords(Mesh mesh, IEnumerable<Point3d> coords)
         {
-            var coords2f = coords.Select(p => new Point2f(p.X, p.Y)).ToArray();
+            if (!coords.Any()) throw new Exception(" There should be at least one texture coordinate.");
+
+            var coords2f = coords.Select(p => new Point2f(p.X, p.Y)).ToList();
+            if(coords2f.Count < mesh.Vertices.Count)
+            {
+                var last = coords2f.Last();
+                int difference = mesh.Vertices.Count - coords2f.Count;
+                coords2f.AddRange(Enumerable.Repeat(last, difference));
+            }
 
             mesh.ClearTextureData();
-            mesh.TextureCoordinates.AddRange(coords2f);
+            mesh.TextureCoordinates.AddRange(coords2f.ToArray());
 
             return mesh;
         }
diff --git a/Extensions/Model/Simulations/DifferentialGrowth/DifferentialGrowth.cs b/Extensions/Model/Simulations/DifferentialGrowth/DifferentialGrowth.cs
new file mode 100644
index 0000000..c2be74c
--- /dev/null
+++ b/Extensions/Model/Simulations/DifferentialGrowth/DifferentialGrowth.cs
@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using Extensions.Model.Spatial;
+using ClipperLib;
+using static Extensions.Model.Util;
+
+namespace Extensions.Model.Simulations.DifferentialGrowth
+{
+    public class DifferentialGrowth
+    {
+        internal List<Particle> Particles = new List<Particle>();
+        internal List<Spring> Springs = new List<Spring>();
+        internal BucketSearchDense3d Search;
+        internal double Radius;
+
+        public double Growth;
+        public List<IntPoint> Region;
+        public Mesh Mesh;
+        public Polyline Polyline;
+        public List<List<Polyline>> AllPolylines = new List<List<Polyline>>();
+        public Polyline Boundary;
+        public System.Diagnostics.Stopwatch Watch = new System.Diagnostics.Stopwatch();
+
+        int _convergence;
+
+        public DifferentialGrowth(IEnumerable<Polyline> polylines, double radius, int convergence, int maxIterations, Polyline region = null, Mesh mesh = null)
+        {
+            Region = region?.Select(p => new IntPoint(p.X / Tol, p.Y / Tol)).ToList();
+            Polyline = region;
+            Mesh = mesh;
+            Radius = radius;
+            Growth = radius * 0.5;
+            _convergence = convergence;
+            Boundary = mesh.GetNakedEdges().First();
+
+            var box = Polyline != null ? Polyline.BoundingBox : mesh.GetBoundingBox(true);
+
+            Search = new BucketSearchDense3d(box, Radius * 2);
+
+            foreach (var polyline in polylines)
+            {
+                if (polyline == null) continue;
+                var startPl = new Particle(polyline[0], this);
+
+                int j = polyline.IsClosed ? -1 : 0;
+
+                for (int i = 1; i < polyline.Count + j; i++)
+                {
+                    var start = Particles[Particles.Count - 1];
+                    var end = new Particle(polyline[i], this);
+                    new Spring(start, end, Springs.Count, this);
+                }
+
+                if (polyline.IsClosed)
+                {
+                    new Spring(Particles[Particles.Count - 1], startPl, Springs.Count, this);
+                }
+            }
+
+            AllPolylines.Add(GetPolylines());
+            double lastLength = double.MaxValue;
+            int count = 0;
+
+            for (count = 0; count < maxIterations; ++count)
+            {
+                Update();
+                AllPolylines.Add(GetPolylines());
+                double length = GetLengthSquared();
+                if (Math.Abs(lastLength - length) < 1.0) break;
+                lastLength = length;
+            }
+        }
+
+        void Grow()
+        {
+            Parallel.ForEach(Springs, spring =>
+            {
+                spring.RestLength = spring.Length + Growth;
+            });
+        }
+
+        void Split()
+        {
+            for (int i = Springs.Count - 1; i >= 0; i--)
+            {
+                var spring = Springs[i];
+                if (spring.Length > Radius)
+                    spring.Split(i);
+            }
+        }
+
+        void Update()
+        {
+            Split();
+            Grow();
+
+            int iterations = _convergence;
+            double totVel;
+
+            do
+            {
+                Search.Populate(Particles);
+
+                if (Mesh != null)
+                {
+                    var pullPoints = Mesh.PullPointsToMesh(Particles.Select(p => p.Position));
+                    Parallel.For(0, Particles.Count, i => Particles[i].Forces(pullPoints[i]));
+                }
+                else
+                {
+                    Parallel.ForEach(Particles, p => p.Forces());
+                }
+
+                // Watch.Start();
+
+                //Watch.Stop();
+                Parallel.ForEach(Springs, s => s.Forces(10));
+
+                Parallel.ForEach(Particles, p => p.Move());
+                Parallel.ForEach(Springs, s => s.Update());
+
+                totVel = 0;
+                foreach (var particle in Particles)
+                    totVel += particle.Velocity.SquareLength;
+            } while (totVel > 0.001 && iterations-- >= 0);
+        }
+
+        public List<Polyline> GetPolylines()
+        {
+            var polylines = new List<Polyline>();
+            Polyline pl = new Polyline
+            {
+                Springs[0].Start.Position,
+                Springs[0].End.Position
+            };
+
+            for (int i = 1; i < Springs.Count; i++)
+            {
+                if (Springs[i - 1].End != Springs[i].Start)
+                {
+                    polylines.Add(pl);
+                    pl = new Polyline
+                    {
+                        Springs[i].Start.Position,
+                        Springs[i].End.Position
+                    };
+                }
+                else
+                {
+                    pl.Add(Springs[i].End.Position);
+                }
+            }
+            polylines.Add(pl);
+            return polylines;
+        }
+
+        public double GetLengthSquared()
+        {
+            return Springs.Sum(s => s.Vector.SquareLength);
+        }
+    }
+}
diff --git a/Extensions/Model/Simulations/DifferentialGrowth/Force.cs b/Extensions/Model/Simulations/DifferentialGrowth/Force.cs
new file mode 100644
index 0000000..f101624
--- /dev/null
+++ b/Extensions/Model/Simulations/DifferentialGrowth/Force.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+
+namespace Extensions.Model.Simulations.DifferentialGrowth
+{
+    public struct Force
+    {
+        public Vector3d vector;
+        public double weight;
+        private Object thisLock;
+
+        public Force(Vector3d vector, double weight)
+        {
+            this.thisLock = new Object();
+            this.vector = vector;
+            this.weight = weight;
+        }
+
+        public void Add(Vector3d vector, double weight)
+        {
+            lock (thisLock)
+            {
+                this.vector += vector;
+                this.weight += weight;
+            }
+        }
+
+        public void Add(Force other)
+        {
+            this.vector += other.vector;
+            this.weight += other.weight;
+        }
+
+        public void SetZero()
+        {
+            vector = Vector3d.Zero;
+            weight = 0.0;
+        }
+    }
+}
diff --git a/Extensions/Model/Simulations/DifferentialGrowth/Particle.cs b/Extensions/Model/Simulations/DifferentialGrowth/Particle.cs
new file mode 100644
index 0000000..5d1546a
--- /dev/null
+++ b/Extensions/Model/Simulations/DifferentialGrowth/Particle.cs
@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using Extensions.Model.Spatial;
+using ClipperLib;
+using static Extensions.Model.Util;
+
+namespace Extensions.Model.Simulations.DifferentialGrowth
+{
+    public class Particle : IPositionable
+    {
+        Point3d _p;
+        //Point3d _pPrev;
+        Vector3d _v;
+        //Vector3d _vPrev;
+        public Force delta = new Force(Vector3d.Zero, 0);
+        public List<Force> deltas = new List<Force>();
+        public List<Particle> neighbours = new List<Particle>(2);
+        DifferentialGrowth _simulation;
+
+        public Stopwatch Watch = new Stopwatch();
+
+        public Point3d Position { get { return _p; } }
+        public Vector3d Velocity { get { return _v; } }
+
+        public Particle(Point3d p, DifferentialGrowth simulation, bool insert = true)
+        {
+            _simulation = simulation;
+            _p = p;
+            if (insert) simulation.Particles.Add(this);
+        }
+
+        public void Forces()
+        {
+            Collision(100);
+            Pull(1000);
+        }
+
+        public void Forces(Point3d pullPoint)
+        {
+            Collision(100);
+            PullMesh(1000, pullPoint);
+            KeepAngle(200);
+            //   PushBoundary(100);
+        }
+
+        void Collision(double weight)
+        {
+
+            var collided = _simulation.Search.GetClosests(this)
+              .Where(p => !neighbours.Contains(p));
+
+            foreach (Particle collider in collided)
+            {
+                Vector3d vector = collider.Position - _p;
+                double distance = vector.Length;
+                vector *= ((distance - _simulation.Radius * 2) / distance) * 0.5;
+                this.delta.Add(vector * weight, weight);
+            }
+        }
+
+        void PullMesh(double weight, Point3d pullPoint)
+        {
+            var closest = pullPoint;
+            Vector3d vector = closest - _p;
+            this.delta.Add(vector * weight, weight);
+        }
+
+        void PushBoundary(double weight)
+        {
+            var closest = _simulation.Boundary.ClosestPoint(_p);
+            Vector3d vector = closest - _p;
+            double distance = vector.Length;
+            if (distance < _simulation.Radius * 2)
+            {
+                vector *= ((distance - _simulation.Radius * 2) / distance) * 0.5;
+                this.delta.Add(vector * weight, weight);
+            }
+        }
+
+        void KeepAngle(double weight)
+        {
+            /// <param name="RA">Rest Angle.</param>
+            /// <param name="P0">Start of the first line segment.</param>
+            /// <param name="P1">End of the first line segment. This can be identical to P2 if the line segments are connected.</param>
+            /// <param name="P2">Start of the second line segment. This can be identical to P1 if the line segments are connected.</param>
+            /// <param name="P3">End of the second line segment.</param>
+            /// 
+            if (this.neighbours.Count != 2) return;
+
+            double restAngle = 0;//Math.PI;
+
+            Point3d P0 = this.neighbours[0]._p;
+            Point3d P1 = _p;
+            Point3d P2 = _p;
+            Point3d P3 = this.neighbours[1]._p;
+
+            Vector3d V01 = P1 - P0;
+            Vector3d V23 = P3 - P2;
+            double top = 2 * Math.Sin(Vector3d.VectorAngle(V01, V23) - restAngle);
+            double Lc = (V01 + V23).Length;
+            double Sa = top / (V01.Length * Lc);
+            double Sb = top / (V23.Length * Lc);
+
+            Vector3d Perp = Vector3d.CrossProduct(V01, V23);
+            Vector3d ShearA = Vector3d.CrossProduct(V01, Perp);
+            Vector3d ShearB = Vector3d.CrossProduct(Perp, V23);
+
+            ShearA.Unitize();
+            ShearB.Unitize();
+
+            ShearA *= Sa;
+            ShearB *= Sb;
+
+            this.neighbours[0].delta.Add(ShearA * weight, weight);
+            this.delta.Add(-ShearA * weight, weight);
+            this.delta.Add(ShearB * weight, weight);
+            this.neighbours[1].delta.Add(-ShearB * weight, weight);
+
+           // Move[0] = ShearA;
+           // Move[1] = -ShearA;
+           // Move[2] = ShearB;
+           // Move[3] = -ShearB;
+        }
+
+        void Pull(double weight)
+        {
+            bool isInside = Clipper.PointInPolygon(new IntPoint(_p.X / Tol, _p.Y / Tol), _simulation.Region) != 0;
+
+            if (!isInside)
+            {
+                var closest = _simulation.Polyline.ClosestPoint(_p);
+                Vector3d vector = closest - _p;
+                this.delta.Add(vector * weight, weight);
+            }
+        }
+
+        public void Move()
+        {
+            foreach (var subDelta in deltas)
+                delta.Add(subDelta);
+
+            delta.vector /= delta.weight;
+            _v = delta.vector;
+            _p = _p + 1.0 * _v;
+
+            delta.SetZero();
+            deltas.Clear();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Extensions/Model/Simulations/DifferentialGrowth/Spring.cs b/Extensions/Model/Simulations/DifferentialGrowth/Spring.cs
new file mode 100644
index 0000000..e2e05b8
--- /dev/null
+++ b/Extensions/Model/Simulations/DifferentialGrowth/Spring.cs
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+
+namespace Extensions.Model.Simulations.DifferentialGrowth
+{
+    public class Spring
+    {
+        public Particle Start;
+        public Particle End;
+        double _restLength;
+        public double Length;
+        public Vector3d Vector;
+
+        DifferentialGrowth _simulation;
+
+        public Line Line { get { return new Line(Start.Position, End.Position); } }
+        public Point3d Mid { get { return new Point3d((Start.Position + End.Position) / 2); } }
+
+        public double RestLength
+        {
+            get { return _restLength; }
+            set
+            {
+                _restLength = Math.Max(0, value);
+            }
+        }
+        public void Update()
+        {
+            Vector = new Vector3d(End.Position - Start.Position);
+            Length = Vector.Length;
+        }
+
+        public Spring(Particle start, Particle end, int i, DifferentialGrowth simulation)
+        {
+            Start = start;
+            End = end;
+            _simulation = simulation;
+
+            start.neighbours.Add(end);
+            end.neighbours.Add(start);
+            Update();
+            _restLength = Length;
+            simulation.Springs.Insert(i, this);
+        }
+
+        public void Forces(double weight)
+        {
+            Vector3d vector = this.Vector;
+            vector *= ((Length - _restLength) / Length) * 0.5;
+
+            lock (Start.deltas)
+                Start.deltas.Add(new Force(vector * weight, weight));
+
+            lock (End.deltas)
+                End.deltas.Add(new Force(-vector * weight, weight));
+        }
+
+        public void Split(int i)
+        {
+            Start.neighbours.Remove(End);
+            End.neighbours.Remove(Start);
+            _simulation.Springs.Remove(this);
+            var mid = new Particle((Start.Position + End.Position) / 2, _simulation);
+            new Spring(mid, End, i, _simulation);
+            new Spring(Start, mid, i, _simulation);
+        }
+    }
+}
diff --git a/Extensions/Model/Spatial/BucketSearch.cs b/Extensions/Model/Spatial/BucketSearch.cs
new file mode 100644
index 0000000..e9c037c
--- /dev/null
+++ b/Extensions/Model/Spatial/BucketSearch.cs
@@ -0,0 +1,317 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+
+namespace Extensions.Model.Spatial
+{
+    public class BucketSearchSparse2d<T> where T : IPositionable
+    {
+        Dictionary<Vector2i, List<T>> _table;
+        double _distanceSquared;
+        double _factor;
+
+        public BucketSearchSparse2d(double distance)
+        {
+            _table = new Dictionary<Vector2i, List<T>>();
+            _distanceSquared = distance * distance;
+            _factor = 1.0 / distance;
+        }
+
+        public void Populate(IEnumerable<T> elements)
+        {
+            _table.Clear();
+
+            foreach (var element in elements)
+            {
+                var key = new Vector2i(element.Position, _factor);
+
+                if (!_table.TryGetValue(key, out List<T> bucket))
+                {
+                    bucket = new List<T>();
+                    _table.Add(key, bucket);
+                }
+
+                bucket.Add(element);
+            }
+        }
+
+        public IEnumerable<T> GetClosests(T element)
+        {
+            var center = new Vector2i(element.Position, _factor);
+            var keys = new Vector2i[9];
+
+            int count = 0;
+            for (int i = -1; i < 2; i++)
+                for (int j = -1; j < 2; j++)
+                    keys[count++] = new Vector2i(center.X + i, center.Y + j);
+
+            var elements = new List<T>();
+
+            foreach (var key in keys)
+            {
+                if (!_table.TryGetValue(key, out List<T> value)) continue;
+
+                foreach (var other in value)
+                {
+                    if (element as IPositionable == other as IPositionable) continue;
+
+                    double distance = (element.Position - other.Position).SquareLength;
+                    if (distance <= _distanceSquared)
+                        elements.Add(other);
+                }
+            }
+
+            return elements;
+        }
+    }
+
+    public class BucketSearchSparse3d
+    {
+        Dictionary<Vector3i, List<IPositionable>> _table;
+        double _distanceSquared;
+        double _factor;
+
+        public BucketSearchSparse3d(double distance)
+        {
+            _table = new Dictionary<Vector3i, List<IPositionable>>();
+            _distanceSquared = distance * distance;
+            _factor = 1.0 / distance;
+        }
+
+        public void Populate(IEnumerable<IPositionable> elements)
+        {
+            _table.Clear();
+
+            foreach (var element in elements)
+            {
+                var key = new Vector3i(element.Position, _factor);
+
+                if (!_table.TryGetValue(key, out List<IPositionable> bucket))
+                {
+                    bucket = new List<IPositionable>();
+                    _table.Add(key, bucket);
+                }
+
+                bucket.Add(element);
+            }
+        }
+
+        public IEnumerable<IPositionable> GetClosests(IPositionable element)
+        {
+            var center = new Vector3i(element.Position, _factor);
+            var keys = new Vector3i[27];
+
+            int count = 0;
+            for (int i = -1; i < 2; i++)
+                for (int j = -1; j < 2; j++)
+                    for (int k = -1; k < 2; k++)
+                        keys[count++] = new Vector3i(center.X + i, center.Y + j, center.Z + k);
+
+            var elements = new List<IPositionable>();
+
+            foreach (var key in keys)
+            {
+                if (!_table.TryGetValue(key, out List<IPositionable> value)) continue;
+
+                foreach (var other in value)
+                {
+                    if (element == other) continue;
+
+                    double distance = (element.Position - other.Position).SquareLength;
+                    if (distance <= _distanceSquared)
+                        elements.Add(other);
+                }
+            }
+
+            return elements;
+        }
+    }
+
+
+    public class BucketSearchDense2d
+    {
+        List<IPositionable>[][] _table;
+        double _distanceSquared;
+        double _factor;
+        Vector2i _start;
+        Vector2i _size;
+
+        public BucketSearchDense2d(BoundingBox box, double distance)
+        {
+            _distanceSquared = distance * distance;
+            _factor = 1.0 / distance;
+
+            _start = new Vector2i(box.Corner(true, true, true), _factor);
+            var end = new Vector2i(box.Corner(false, false, false), _factor);
+            _size = new Vector2i(end.X - _start.X + 1, end.Y - _start.Y + 1);
+
+            _table = new List<IPositionable>[_size.X][];
+            for (int i = 0; i < _size.X; i++)
+                _table[i] = new List<IPositionable>[_size.Y];
+        }
+
+        public void Populate(IEnumerable<IPositionable> elements)
+        {
+            for (int i = 0; i < _size.X; i++)
+                for (int j = 0; j < _size.Y; j++)
+                {
+                    var bucket = _table[i][j];
+                    if (bucket != null) bucket.Clear();
+                }
+
+            foreach (var element in elements)
+            {
+                var key = new Vector2i(element.Position, _factor);
+                key.X -= _start.X;
+                key.Y -= _start.Y;
+
+                if (key.X < 0 || key.Y < 0) continue;
+                if (key.X >= _size.X || key.Y >= _size.Y) continue;
+
+                List<IPositionable> bucket = _table[key.X][key.Y];
+
+                if (bucket == null)
+                {
+                    bucket = new List<IPositionable>();
+                    _table[key.X][key.Y] = bucket;
+                }
+
+                bucket.Add(element);
+            }
+        }
+
+        public IEnumerable<IPositionable> GetClosests(IPositionable element)
+        {
+            var center = new Vector2i(element.Position, _factor);
+            center.X -= _start.X;
+            center.Y -= _start.Y;
+            var keys = new Vector2i[9];
+
+            int count = 0;
+            for (int i = -1; i < 2; i++)
+                for (int j = -1; j < 2; j++)
+                    keys[count++] = new Vector2i(center.X + i, center.Y + j);
+
+            var elements = new List<IPositionable>();
+
+            foreach (var key in keys)
+            {
+                if (key.X < 0 || key.Y < 0) continue;
+                if (key.X >= _size.X || key.Y >= _size.Y) continue;
+
+                List<IPositionable> bucket = _table[key.X][key.Y];
+                if (bucket == null) continue;
+
+                foreach (var other in bucket)
+                {
+                    if (element == other) continue;
+
+                    double distance = (element.Position - other.Position).SquareLength;
+                    if (distance <= _distanceSquared)
+                        elements.Add(other);
+                }
+            }
+
+            return elements;
+        }
+    }
+
+    public class BucketSearchDense3d
+    {
+        List<IPositionable>[][][] _table;
+        double _distanceSquared;
+        double _factor;
+        Vector3i _start;
+        Vector3i _size;
+
+        public BucketSearchDense3d(BoundingBox box, double distance)
+        {
+            _distanceSquared = distance * distance;
+            _factor = 1.0 / distance;
+
+            _start = new Vector3i(box.Corner(true, true, true), _factor);
+            var end = new Vector3i(box.Corner(false, false, false), _factor);
+            _size = new Vector3i(end.X - _start.X + 1, end.Y - _start.Y + 1, end.Z - _start.Z + 1);
+
+            _table = new List<IPositionable>[_size.X][][];
+            for (int i = 0; i < _size.X; i++)
+            {
+                _table[i] = new List<IPositionable>[_size.Y][];
+                for (int j = 0; j < _size.Y; j++)
+                    _table[i][j] = new List<IPositionable>[_size.Z];
+            }
+
+            //_table = (List < IPositionable >[][][])Array.CreateInstance(typeof(List<IPositionable>), _size.X, _size.Y, _size.Z);
+        }
+
+        public void Populate(IEnumerable<IPositionable> elements)
+        {
+            for (int i = 0; i < _size.X; i++)
+                for (int j = 0; j < _size.Y; j++)
+                    for (int k = 0; k < _size.Z; k++)
+                    {
+                    var bucket = _table[i][j][k];
+                    if (bucket != null) bucket.Clear();
+                }
+
+            foreach (var element in elements)
+            {
+                var key = new Vector3i(element.Position, _factor);
+                key.X -= _start.X;
+                key.Y -= _start.Y;
+
+                if (key.X < 0 || key.Y < 0) continue;
+                if (key.X >= _size.X || key.Y >= _size.Y) continue;
+
+                List<IPositionable> bucket = _table[key.X][key.Y][key.Z];
+
+                if (bucket == null)
+                {
+                    bucket = new List<IPositionable>();
+                    _table[key.X][key.Y][key.Z] = bucket;
+                }
+
+                bucket.Add(element);
+            }
+        }
+
+        public IEnumerable<IPositionable> GetClosests(IPositionable element)
+        {
+            var center = new Vector3i(element.Position, _factor);
+            center.X -= _start.X;
+            center.Y -= _start.Y;
+            var keys = new Vector3i[9];
+
+            int count = 0;
+            for (int i = -1; i < 2; i++)
+                for (int j = -1; j < 2; j++)
+                    for (int k = -1; k < 2; k++)
+                        keys[count++] = new Vector3i(center.X + i, center.Y + j, center.Z + k);
+
+            var elements = new List<IPositionable>();
+
+            foreach (var key in keys)
+            {
+                if (key.X < 0 || key.Y < 0) continue;
+                if (key.X >= _size.X || key.Y >= _size.Y) continue;
+
+                List<IPositionable> bucket = _table[key.X][key.Y][key.Z];
+                if (bucket == null) continue;
+
+                foreach (var other in bucket)
+                {
+                    if (element == other) continue;
+
+                    double distance = (element.Position - other.Position).SquareLength;
+                    if (distance <= _distanceSquared)
+                        elements.Add(other);
+                }
+            }
+
+            return elements;
+        }
+    }
+}
diff --git a/Extensions/Model/Spatial/Octree.cs b/Extensions/Model/Spatial/Octree.cs
new file mode 100644
index 0000000..ecc2fda
--- /dev/null
+++ b/Extensions/Model/Spatial/Octree.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+
+namespace Extensions.Model.Spatial
+{
+    public class Octree<T> where T : IPositionable
+    {
+        static int capacity = 4;
+        Box _box;
+        List<T> _elements;
+        List<Octree<T>> _children;
+
+        public Octree(Box box)
+        {
+            _elements = new List<T>();
+            _box = box;
+        }
+
+        void Subdivide()
+        {
+            _children = new List<Octree<T>>(8)
+            {
+                new Octree<T>(new Box(_box.Plane, new Interval(_box.X.T0, (_box.X.T0 + _box.X.T1) / 2), new Interval(_box.Y.T0, (_box.Y.T0 + _box.Y.T1) / 2), new Interval(_box.Z.T0, (_box.Z.T0 + _box.Z.T1) / 2))),
+                new Octree<T>(new Box(_box.Plane, new Interval(_box.X.T0, (_box.X.T0 + _box.X.T1) / 2), new Interval(_box.Y.T0, (_box.Y.T0 + _box.Y.T1) / 2), new Interval((_box.Z.T0 + _box.Z.T1) / 2, _box.Z.T1))),
+                new Octree<T>(new Box(_box.Plane, new Interval((_box.X.T0 + _box.X.T1) / 2, _box.X.T1), new Interval(_box.Y.T0, (_box.Y.T0 + _box.Y.T1) / 2), new Interval((_box.Z.T0 + _box.Z.T1) / 2, _box.Z.T1))),
+                new Octree<T>(new Box(_box.Plane, new Interval((_box.X.T0 + _box.X.T1) / 2, _box.X.T1), new Interval(_box.Y.T0, (_box.Y.T0 + _box.Y.T1) / 2), new Interval(_box.Z.T0, (_box.Z.T0 + _box.Z.T1) / 2))),
+                new Octree<T>(new Box(_box.Plane, new Interval(_box.X.T0, (_box.X.T0 + _box.X.T1) / 2), new Interval((_box.Y.T0 + _box.Y.T1) / 2, _box.Y.T1), new Interval(_box.Z.T0, (_box.Z.T0 + _box.Z.T1) / 2))),
+                new Octree<T>(new Box(_box.Plane, new Interval(_box.X.T0, (_box.X.T0 + _box.X.T1) / 2), new Interval((_box.Y.T0 + _box.Y.T1) / 2, _box.Y.T1), new Interval((_box.Z.T0 + _box.Z.T1) / 2, _box.Z.T1))),
+                new Octree<T>(new Box(_box.Plane, new Interval((_box.X.T0 + _box.X.T1) / 2, _box.X.T1), new Interval((_box.Y.T0 + _box.Y.T1) / 2, _box.Y.T1), new Interval((_box.Z.T0 + _box.Z.T1) / 2, _box.Z.T1))),
+                new Octree<T>(new Box(_box.Plane, new Interval((_box.X.T0 + _box.X.T1) / 2, _box.X.T1), new Interval((_box.Y.T0 + _box.Y.T1) / 2, _box.Y.T1), new Interval(_box.Z.T0, (_box.Z.T0 + _box.Z.T1) / 2)))
+            };
+        }
+
+        public bool Insert(T element)
+        {
+            if (!_box.Contains(element.Position))
+                return false;
+
+            if (_elements.Count < capacity)
+            {
+                _elements.Add(element);
+                return true;
+            }
+
+            if (_children == null)
+                Subdivide();
+
+            foreach (var tree in _children)
+                if (tree.Insert(element)) return true;
+
+            return false;
+        }
+
+        public List<T> SquareClosest(Point3d point, double squareRadius)
+        {
+            var elementsInRange = new List<T>();
+
+            if (!BoxSphereIntersection(_box, point, squareRadius))
+                return elementsInRange;
+
+            foreach (var element in _elements)
+            {
+                Vector3d vector = point - element.Position;
+                if (vector.SquareLength <= squareRadius)
+                    elementsInRange.Add(element);
+            }
+
+            if (_children == null)
+                return elementsInRange;
+
+            foreach (var tree in _children)
+                elementsInRange.AddRange(tree.SquareClosest(point, squareRadius));
+
+            return elementsInRange;
+        }
+
+        public List<T> GetAll()
+        {
+            var nodeElements = new List<T>();
+            nodeElements.AddRange(_elements);
+            if (_children != null)
+            {
+                foreach (var tree in _children)
+                    nodeElements.AddRange(tree.GetAll());
+            }
+
+            return nodeElements;
+        }
+
+        bool BoxSphereIntersection(Box box, Point3d center, double squareRadius)
+        {
+            Point3d corner = new Point3d(box.X.T0, box.Y.T0, box.Z.T0);
+            double dmin = 0;
+            double xLength = box.X.Length;
+            double yLength = box.Y.Length;
+            double zLength = box.Z.Length;
+
+            if (center.X < corner.X)
+                dmin += (center.X - corner.X) * (center.X - corner.X);
+            else if (center.X > (corner.X + xLength))
+                dmin += (center.X - (corner.X + xLength)) * (center.X - (corner.X + xLength));
+
+            if (center.Y < corner.Y)
+                dmin += (center.Y - corner.Y) * (center.Y - corner.Y);
+            else if (center.Y > (corner.Y + yLength))
+                dmin += (center.Y - (corner.Y + yLength)) * (center.Y - (corner.Y + yLength));
+
+            if (center.Z < corner.Z)
+                dmin += (center.Z - corner.Z) * (center.Z - corner.Z);
+            else if (center.Z > (corner.Z + zLength))
+                dmin += (center.Z - (corner.Z + zLength)) * (center.Z - (corner.Z + zLength));
+
+            if (dmin <= squareRadius)
+                return true;
+            else
+                return false;
+        }
+    }
+}
diff --git a/Extensions/Model/Spatial/Primitives.cs b/Extensions/Model/Spatial/Primitives.cs
new file mode 100644
index 0000000..7a58c68
--- /dev/null
+++ b/Extensions/Model/Spatial/Primitives.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+
+namespace Extensions.Model.Spatial
+{
+    public interface IPositionable
+    {
+        Point3d Position { get; }
+    }
+
+    public struct Vector3i
+    {
+        public int X;
+        public int Y;
+        public int Z;
+
+        public Vector3i(int x, int y, int z)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+        }
+
+        public Vector3i(Point3d point, double scale)
+        {
+            point *= scale;
+            X = point.X > 0 ? (int)point.X : (int)point.X - 1;
+            Y = point.Y > 0 ? (int)point.Y : (int)point.Y - 1;
+            Z = point.Z > 0 ? (int)point.Z : (int)point.Z - 1;
+        }
+
+        public override bool Equals(object obj)
+        {
+            Vector3i other = (Vector3i)obj;
+
+            return (X == other.X && Y == other.Y && Z == other.Z);
+        }
+
+
+        // Lifted from Geometry3Sharp
+        public override int GetHashCode()
+        {
+            //return 137 * X + 149 * Y + 163 * Z;
+            unchecked // Overflow is fine, just wrap
+            {
+                int hash = (int)2166136261;
+                // Suitable nullity checks etc, of course :)
+                hash = (hash * 16777619) ^ X.GetHashCode();
+                hash = (hash * 16777619) ^ Y.GetHashCode();
+                hash = (hash * 16777619) ^ Z.GetHashCode();
+                return hash;
+            }
+        }
+    }
+
+    public struct Vector2i
+    {
+        public int X;
+        public int Y;
+
+        public Vector2i(int x, int y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        public Vector2i(Point3d point, double scale)
+        {
+            point *= scale;
+            X = point.X > 0 ? (int)point.X : (int)point.X - 1;
+            Y = point.Y > 0 ? (int)point.Y : (int)point.Y - 1;
+        }
+    }
+}
diff --git a/Extensions/Model/Toolpaths/CSVConverter.cs b/Extensions/Model/Toolpaths/CSVConverter.cs
new file mode 100644
index 0000000..1aff007
--- /dev/null
+++ b/Extensions/Model/Toolpaths/CSVConverter.cs
@@ -0,0 +1,140 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Collections.Generic;
+using Rhino.Geometry;
+using Robots;
+using static System.Math;
+
+namespace Extensions.Toolpaths
+{
+    // pX,pY,pZ,nX,nY,nZ,F'
+
+    internal class CSVConverter
+    {
+        public List<Target> Targets { get; } = new List<Target>();
+        public List<Polyline> ToolPath { get; } = new List<Polyline>();
+
+        string[] validParameters = { "type", "position", "normal", "xaxis", "speed", "zone" };
+
+        public CSVConverter(string file, CartesianTarget referenceTarget, string mask, bool reverse, double cutSpeed = 0, Point3d? point = null)
+        {
+            var splitMask = mask.Split(',').Select(p => p.Trim().ToLower());
+            if (!splitMask.All(p => validParameters.Contains(p))) throw new Exception(" Mask not valid.");
+
+            var parameterIndex = splitMask.ToDictionary(p => p, p => -1);
+
+            int count = 0;
+            foreach (var parameter in splitMask)
+            {
+                parameterIndex[parameter] = count;
+                if (parameter == "position" || parameter == "normal" || parameter == "xaxis")
+                    count += 3;
+                else
+                    count += 1;
+            }
+
+            var lines = File.ReadAllLines(file);
+
+            var planes = new List<Plane>(lines.Length);
+            var speedValues = new List<double>(lines.Length);
+            var zoneValues = new List<double>(lines.Length);
+            var types = new List<double>(lines.Length);
+
+
+
+            foreach (var line in lines)
+            {
+                var fields = line.Split(',');
+                if (fields.Length != count) continue;//throw new Exception(" Number of values in a line is not correct.");
+
+                var numbers = fields.Select(s =>
+                {
+                    if (!double.TryParse(s, out double n)) throw new Exception(" Can't convert field to number.");
+                    return n;
+                }).ToArray();
+
+                Vector3d GetVector(int index) => new Vector3d(numbers[index], numbers[index + 1], numbers[index + 2]);
+
+                var position = parameterIndex.TryGetValue("position", out int positionIndex) ? (Point3d)GetVector(positionIndex) : referenceTarget.Plane.Origin;
+                var normal = parameterIndex.TryGetValue("normal", out int normalIndex) ? GetVector(normalIndex) : referenceTarget.Plane.Normal;
+                if (reverse) normal *= -1.0;
+                var xaxis = parameterIndex.TryGetValue("xaxis", out int xaxisIndex) ? GetVector(xaxisIndex) : referenceTarget.Plane.XAxis;
+
+                if (point != null)
+                {
+                    Point3d localPoint = (Point3d)point;
+                    localPoint.Transform(Transform.PlaneToPlane(referenceTarget.Frame.Plane, Plane.WorldXY));
+                    xaxis = localPoint - position;
+                }
+
+                var plane = new Plane(position, normal);
+                double angle = Vector3d.VectorAngle(plane.XAxis, xaxis, plane);
+                plane.Rotate(angle, plane.Normal);
+                planes.Add(plane);
+
+                double speed = 0;
+
+                if (parameterIndex.TryGetValue("speed", out int speedIndex))
+                {
+                    speed = numbers[speedIndex];
+                    speedValues.Add(speed * (1.0 / 60.0));
+                }
+
+                if (parameterIndex.TryGetValue("zone", out int zoneIndex))
+                    zoneValues.Add(numbers[zoneIndex]);
+
+                if (parameterIndex.TryGetValue("type", out int typeIndex))
+                    types.Add(numbers[typeIndex]);
+                else
+                    types.Add(speed <= cutSpeed ? 1 : 0);
+            }
+
+            var distinctSpeeds = speedValues.Distinct().Select(s => new Speed(translation: s, rotationSpeed: referenceTarget.Speed.RotationSpeed));
+            var speeds = speedValues.Select(v => distinctSpeeds.First(s => s.TranslationSpeed == v)).ToList();
+
+            var distinctZones = zoneValues.Distinct().Select(z => new Zone(distance: z));
+            var zones = zoneValues.Select(v => distinctZones.First(z => z.Distance == v)).ToList();
+
+
+            for (int i = 0; i < planes.Count; i++)
+            {
+                var speed = parameterIndex.ContainsKey("speed") ? speeds[i] : referenceTarget.Speed;
+                var zone = parameterIndex.ContainsKey("zone") ? zones[i] : referenceTarget.Zone;
+
+                var target = new CartesianTarget(planes[i], null, Target.Motions.Joint, referenceTarget.Tool, speed, zone, null, referenceTarget.Frame);
+                Targets.Add(target);
+            }
+
+            {
+                Polyline polyline = null;
+
+                for (int i = 0; i < planes.Count; i++)
+                {
+                    bool cutting = types[i] == 1;
+                    Point3d vertex = planes[i].Origin;
+
+                    if (cutting)
+                    {
+                        if (polyline == null)
+                        {
+                            polyline = new Polyline();
+                            ToolPath.Add(polyline);
+                        }
+
+                        polyline.Add(vertex);
+                    }
+                    else
+                    {
+                        polyline = null;
+                    }
+                }
+            }
+
+            foreach (var polyline in ToolPath)
+            {
+                polyline.CollapseShortSegments(0.01);
+            }
+        }
+    }
+}
diff --git a/Extensions/Model/Toolpaths/Column.cs b/Extensions/Model/Toolpaths/Column.cs
new file mode 100644
index 0000000..f13fdd0
--- /dev/null
+++ b/Extensions/Model/Toolpaths/Column.cs
@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Drawing;
+using System.Diagnostics;
+using Rhino.Geometry;
+using Rhino.UI;
+using Extensions.Model.Spatial;
+using Extensions.Model.Geometry;
+using Extensions.Model.Document;
+using MoreLinq;
+using static System.Math;
+
+namespace Extensions.Model.Toolpath
+{
+    class Column
+    {
+        public Polyline[][] Layers { get; }
+        public Mesh[][] Pipes { get; }
+        public Polyline[] Contours { get; }
+        public Mesh Skin { get; }
+
+        public Column(Mesh mesh, double diameter, double height, Interval region)
+        {
+            double width = Util.GetWidth(diameter, height);
+            double offset = width * 0.5;
+            const double fillSize = 400;
+            const double shortenDist = 10;
+
+            var watch = new Stopwatch();
+            string _text = null;
+
+            Progress("Contouring");
+            var contours = Contouring(mesh);
+
+            Progress("Cleaning");
+            var cleanContours = Cleaning(contours);
+
+            Progress("FixCantilevers");
+            cleanContours = FixCantilevers(cleanContours);
+
+            Progress("Toolpathing");
+            var toolpath = Toolpathing(cleanContours);
+
+            Progress("Piping");
+            var pipes = Piping(toolpath);
+
+            Progress("Skin");
+            var skin = new Mesh();
+            for (int i = 0; i < pipes.Length; i++)
+            {
+                var pipe = pipes[i].Last();
+                skin.Append(pipe);
+            }
+
+            Progress("end");
+
+            Contours = contours;
+            Layers = toolpath;//new Polyline[0][];
+            Pipes = pipes; //new Mesh[0][];
+            Skin = skin;
+
+            Polyline[] Contouring(Mesh m)
+            {
+                Polyline[] outPolylines;
+                var contour = Cache.Read<Curve>("contours")?.ToPolyline();
+
+                if (contour is null)
+                {
+                    outPolylines = Slicer.Create(m, height, region)
+                                  .Select(c => c.MaxBy(p => p.Length).First())
+                                  .ToArray();
+
+                    Cache.Write<Curve>("contours", new PolylineCurve(outPolylines[0]));
+                }
+                else
+                {
+                    outPolylines = Enumerable.Repeat(contour, 1).ToArray();
+                }
+
+                return outPolylines;
+            }
+
+            Polyline[] Cleaning(Polyline[] inPolylines)
+            {
+                var outPolylines = new Polyline[inPolylines.Length];
+
+                Parallel.ForEach(Partitioner.Create(0, inPolylines.Length), range =>
+                {
+                    for (int i = range.Item1; i < range.Item2; i++)
+                    {
+                        var polyline = inPolylines[i];
+                        polyline = Shorten(polyline, shortenDist);
+                        //polyline = BallPivot.Create(polyline, width * 0.2); // simplfy
+                        outPolylines[i] = polyline;
+                    }
+                });
+
+                Polyline Shorten(Polyline contour, double resolution)
+                {
+                    var maxDist = resolution * 1;
+                    var maxDistSq = maxDist * maxDist;
+                    var pivot = BallPivot.Create(contour, resolution);
+
+                    var outCurve = new Polyline(contour.Where(p => pivot.ClosestPoint(p).DistanceToSquared(p) < maxDistSq));
+                    if (!outCurve.IsClosed)
+                        outCurve.Add(outCurve[0]);
+
+                    return outCurve;
+                }
+
+                return outPolylines;
+            }
+
+            Mesh[][] Piping(Polyline[][] inPolylines)
+            {
+                var outMeshes = new Mesh[inPolylines.Length][];
+                if (inPolylines.Length == 0) return outMeshes;
+
+                Parallel.ForEach(Partitioner.Create(0, inPolylines.Length), range =>
+                {
+                    for (int i = range.Item1; i < range.Item2; i++)
+                    {
+                        //var pls = inPolylines[i].Select(p => p.ToPolyline(0.01, PI * 0.01, 1, double.MaxValue).ToPolyline());
+                        outMeshes[i] = inPolylines[i].Select(p => MeshPipe.MeshFlatPolyline(p, width, height, width * 0.5, 5)).ToArray();
+                    }
+                });
+
+                return outMeshes;
+            }
+
+            Polyline[][] Toolpathing(Polyline[] inPolylines)
+            {
+                var outPolylines = new Polyline[inPolylines.Length][];
+
+                Parallel.ForEach(Partitioner.Create(0, inPolylines.Length), range =>
+                {
+                    for (int i = range.Item1; i < range.Item2; i++)
+                    {
+                        // var pl = inPolylines[i];
+                        var outerSkin = inPolylines[i];
+                        //var outerSkin = Geometry.Region.Offset(pl, -offset);
+                        var innerSkin = Geometry.Region.Offset(outerSkin, -offset * 2);
+                        var outPolyline = new Polyline[] { outerSkin, innerSkin };
+
+                        outPolylines[i] = outPolyline.Select(p => Clean(p, offset)).ToArray();
+                    }
+                });
+
+                //   Progress("Filling");
+                var layers = PolygonFill.Square(outPolylines.Select(l => l[1]).ToArray(), fillSize, offset);
+
+                for (int i = 0; i < inPolylines.Length; i++)
+                {
+                    outPolylines[i] = MoreEnumerable.Append(layers[i], outPolylines[i][0]).ToArray();
+                }
+
+                return outPolylines;
+
+                Polyline Clean(Polyline contour, double resolution)
+                {
+                    var clean = new Polyline(contour);
+                    var removed = clean.ReduceSegments(resolution * 0.02);
+                    removed = clean.CollapseShortSegments(2);
+                    //var nurbs = Curve.CreateInterpolatedCurve(clean, 3);
+                    //Document.Debug.Bake(nurbs, Color.Red);
+                    //var curve = nurbs.ToArcsAndLines(resolution * 0.1, PI * 0.1, width * 0.5, double.MaxValue);
+                    // Document.Debug.Bake(curve, Color.Blue);
+                    //var pl = curve.ToPolyline(0.01, PI * 0.01, 0.1, double.MaxValue);
+                    //Document.Debug.Bake(pl, Color.Green);
+                    return clean;
+                }
+            }
+
+            Polyline[] FixCantilevers(Polyline[] polylines)
+            {
+                Parallel.ForEach(Partitioner.Create(0, polylines.Length), range =>
+                {
+                    for (int i = range.Item1; i < range.Item2; i++)
+                    {
+                        var contour = Geometry.Region.Offset(polylines[i], -offset);
+                        var removed = contour.ReduceSegments(width * 0.02);
+                        removed = contour.CollapseShortSegments(2);
+                        polylines[i] = contour;
+                    }
+                });
+
+                double maxSeparation = width * 0.75;
+                double maxSeparationSq = maxSeparation * maxSeparation;
+
+                for (int i = 1; i < polylines.Length; i++)
+                {
+                    var contour = polylines[i];
+                    var prev = polylines[i - 1];
+
+                    for (int j = 0; j < contour.Count; j++)
+                    {
+                        var p = contour[j];
+                        var closest = prev.ClosestPointFast(p);
+                        var v = closest - p;
+                        v.Z = 0;
+                        var lengthSq = v.SquareLength;
+                        if (lengthSq > maxSeparationSq)
+                        {
+                            var length = Sqrt(lengthSq);
+                            var move = v * ((length - maxSeparation) / length);
+                            p += move;
+                            contour[j] = p;
+                        }
+                    }
+                }
+
+                return polylines;
+            }
+
+            void Progress(string text)
+            {
+                if (text != "Contouring") Rhino.RhinoApp.WriteLine($"{ _text}: {watch.ElapsedMilliseconds}");
+                StatusBar.HideProgressMeter();
+                if (text == "end") return;
+                _text = text;
+                StatusBar.ShowProgressMeter(0, 4, $"{text}...", true, true);
+                if (text != "Contouring") StatusBar.UpdateProgressMeter(1, true);
+                watch.Restart();
+            }
+        }
+    }
+}
diff --git a/Extensions/Model/Toolpaths/SpatialExtrusion/SpatialAttributes.cs b/Extensions/Model/Toolpaths/SpatialExtrusion/SpatialAttributes.cs
index 74fd5d0..02523fe 100644
--- a/Extensions/Model/Toolpaths/SpatialExtrusion/SpatialAttributes.cs
+++ b/Extensions/Model/Toolpaths/SpatialExtrusion/SpatialAttributes.cs
@@ -15,6 +15,8 @@ internal class SpatialAttributes
         public double DistanceAhead { get; set; }
         public double DistanceHorizontal { get; set; }
 
+        public List<GeometryBase> Environment { get; set; }
+
         public CartesianTarget ReferenceTarget { get; set; }
 
         public Speed Approach { get; set; }
@@ -33,7 +35,7 @@ internal class SpatialAttributes
 
         public Command AheadCommand { get; set; }
 
-        public SpatialAttributes(IList<double> variables, CartesianTarget target, IList<double> speeds, IList<double> waits, IList<int> dos)
+        public SpatialAttributes(IList<double> variables, CartesianTarget target, IList<double> speeds, IList<double> waits, IList<int> dos, IList<GeometryBase> environment)
         {
             if (variables.Count != 6) throw new Exception(" There must be 6 variables.");
             if (speeds.Count != 5) throw new Exception(" There must be 5 speeds.");
@@ -47,6 +49,8 @@ public SpatialAttributes(IList<double> variables, CartesianTarget target, IList<
             DistanceAhead = variables[4];
             DistanceHorizontal = variables[5];
 
+            Environment = new List<GeometryBase>(environment);
+
             ReferenceTarget = target;
 
             Approach = new Speed(name: "Approach", translation: speeds[0]);
@@ -57,7 +61,7 @@ public SpatialAttributes(IList<double> variables, CartesianTarget target, IList<
 
             var waitAfterStart = new Wait(waits[0]);
 
-            StopExtrusion = new Group() { new SetDO(dos[0], false), new SetDO(dos[1], false)};
+            StopExtrusion = new Group() { new SetDO(dos[0], false), new SetDO(dos[1], false) };
             FastExtrusion = new Group() { new SetDO(dos[0], true), new SetDO(dos[1], false), waitAfterStart };
             MediumExtrusion = new Group() { new SetDO(dos[0], false), new SetDO(dos[1], true), waitAfterStart };
             SlowExtrusion = new Group() { new SetDO(dos[0], true), new SetDO(dos[1], true), waitAfterStart };
@@ -67,6 +71,5 @@ public SpatialAttributes(IList<double> variables, CartesianTarget target, IList<
 
             AheadCommand = new Group() { StopExtrusion, new Wait(waits[1]) };
         }
-
     }
 }
\ No newline at end of file
diff --git a/Extensions/Model/Toolpaths/SpatialExtrusion/SpatialExtrusion.cs b/Extensions/Model/Toolpaths/SpatialExtrusion/SpatialExtrusion.cs
index 3bc909d..872d205 100644
--- a/Extensions/Model/Toolpaths/SpatialExtrusion/SpatialExtrusion.cs
+++ b/Extensions/Model/Toolpaths/SpatialExtrusion/SpatialExtrusion.cs
@@ -10,24 +10,44 @@ namespace Extensions.Toolpaths
     internal class SpatialExtrusion
     {
         public List<Target> Targets { get; private set; } = new List<Target>();
-        public IEnumerable<(Line segment, int type)> Display { get; private set; }
+        public List<(Line segment, int type)> Display { get; private set; } = new List<(Line segment, int type)>();
 
-        public SpatialExtrusion(Polyline polyline, SpatialAttributes attributes)
+        public SpatialExtrusion(IEnumerable<Polyline> polylines, SpatialAttributes attributes)
         {
-            CreateTargets(polyline, attributes);
+            CreateTargets(polylines.ToList(), attributes);
         }
 
-        void CreateTargets(Polyline polyline, SpatialAttributes attributes)
+        void CreateTargets(IEnumerable<Polyline> polylines, SpatialAttributes attributes)
         {
-            var vertices = new List<Vertex>(polyline.Count);
+            var meshes = attributes.Environment.OfType<Mesh>()
+                         .Select(m => (mesh: m, height: m.GetBoundingBox(true).Max.Z)).ToList();
 
-            for (int i = 0; i < polyline.Count; i++)
-                new Vertex(i, polyline[i], vertices, attributes);
+            attributes.Environment.RemoveAll(g => g is Mesh);
 
-            foreach (var vertex in vertices) vertex.Initialize();
-            foreach (var vertex in vertices) Targets.AddRange(vertex.GetTargets());
+            foreach (var polyline in polylines)
+            {
+                double height = polyline.BoundingBox.Min.Z;
 
-            Display = vertices.Select(v => v.GetDisplay());
+                var meshesToAdd = meshes.Where(m => m.height < (height + 1.0)).Select(m => m.mesh).ToList();
+                bool hasToWait = meshesToAdd.Count > 0;
+
+                for (int i = meshes.Count - 1; i >= 0; i--)
+                    if (meshesToAdd.Contains(meshes[i].mesh))
+                        meshes.RemoveAt(i);
+
+                attributes.Environment.AddRange(meshesToAdd);
+
+                var vertices = new List<Vertex>(polyline.Count);
+
+                for (int i = 0; i < polyline.Count; i++)
+                    new Vertex(i, polyline[i], vertices, attributes);
+
+                foreach (var vertex in vertices) vertex.Initialize();
+                foreach (var vertex in vertices) Targets.AddRange(vertex.GetTargets(hasToWait));
+                foreach (var vertex in vertices) Display.Add(vertex.GetDisplay());
+
+                attributes.Environment.Add(polyline.ToNurbsCurve());
+            }
         }
     }
 }
diff --git a/Extensions/Model/Toolpaths/SpatialExtrusion/Vertex.cs b/Extensions/Model/Toolpaths/SpatialExtrusion/Vertex.cs
index cc4b3ce..0a42774 100644
--- a/Extensions/Model/Toolpaths/SpatialExtrusion/Vertex.cs
+++ b/Extensions/Model/Toolpaths/SpatialExtrusion/Vertex.cs
@@ -59,6 +59,7 @@ void CalcNeighbours()
                 _prev = _vertices[_index - 1];
                 _prevVector = _prev._point - _point;
             }
+
             if (_index < _vertices.Count - 1)
             {
                 _post = _vertices[_index + 1];
@@ -82,13 +83,41 @@ void CalcSupported()
 
         bool IsSupported(Point3d point)
         {
-            if (point.Z < _tol) return true;
+            {
+                var meshes = _att.Environment.OfType<Mesh>();
+
+                if (meshes.Count() > 0)
+                {
+                    var environmentMesh = new Mesh();
+                    foreach (var mesh in meshes)
+                        environmentMesh.Append(mesh);
+
+                    Point3d closest = environmentMesh.ClosestPoint(point);
+                    if (point.DistanceTo(closest) < 0.1) return true;
+                }
+            }
+
+            var curves = _att.Environment.OfType<Curve>();
+            var polylines = new List<Polyline>();
+
+            foreach (var curve in curves)
+            {
+                if (!curve.TryGetPolyline(out Polyline polyline)) continue;
+                polylines.Add(polyline);
+            }
 
-            Polyline subPolyline = new Polyline(_vertices.Select(v => v._point).Take(_index - 1));
-            Point3d closest = subPolyline.ClosestPoint(point);
-            Vector3d vector = point - closest;
-            Vector3d horizontal = new Vector3d(vector.X, vector.Y, 0);
-            return (horizontal.Length < _att.Diameter * 0.5) && vector.Z > 0 && vector.Z < _att.Diameter * 1.1;
+            polylines.Add(new Polyline(_vertices.Select(v => v._point).Take(_index)));
+
+            foreach (var polyline in polylines)
+            {
+                Point3d closest = polyline.ClosestPoint(point);
+                Vector3d vector = point - closest;
+                Vector3d horizontal = new Vector3d(vector.X, vector.Y, 0);
+                bool isSupported = (horizontal.Length < _att.Diameter * 0.5) && vector.Z >= 0 && vector.Z < _att.Diameter * 1.1;
+                if (isSupported) return true;
+            }
+
+            return false;
         }
 
         void CalcDown()
@@ -149,7 +178,7 @@ Command GetExtrusionSpeed()
             throw new Exception($" ExtrusionSpeed case in node {_index} not considered.");
         }
 
-        public List<Target> GetTargets()
+        public List<Target> GetTargets(bool hasToWait)
         {
             var targets = new List<Target>();
 
@@ -167,7 +196,7 @@ public List<Target> GetTargets()
                 var approachTarget = target.ShallowClone() as CartesianTarget;
                 approachTarget.Plane = new Plane(target.Plane.Origin + Vector3d.ZAxis * _att.DistancePlunge, target.Plane.XAxis, target.Plane.YAxis);
                 approachTarget.Speed = _att.Approach;
-                approachTarget.Command = null;
+                approachTarget.Command = hasToWait ? new Stop() : null;
                 targets.Add(approachTarget);
             }
 
diff --git a/Extensions/Model/Util.cs b/Extensions/Model/Util.cs
new file mode 100644
index 0000000..b227b25
--- /dev/null
+++ b/Extensions/Model/Util.cs
@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using static System.Math;
+
+namespace Extensions.Model
+{
+    static class Util
+    {
+        public const double HalfPI = PI * 0.5;
+        public const double PI2 = PI * 2;
+        public const double Tol = 0.001;
+        public const double UnitTol = 1E-08;
+
+        public static Polyline ToPolyline(this Curve curve)
+        {
+            if (curve == null) return null;
+
+            if (!curve.TryGetPolyline(out Polyline polyline))
+                throw new Exception("Curve is not a polyline.");
+
+            return polyline;
+        }
+
+        public static Vector3f ToVector3f(this Vector3d v)
+        {
+            return new Vector3f((float)v.X, (float)v.Y, (float)v.Z);
+        }
+
+        public static IEnumerable<Vector3d> GetNormals(this Polyline pl)
+        {
+            if (pl.Count < 3)
+                throw new ArgumentException("Polyline must have 3 or more vertices.");
+
+            int last = pl.Count - 1;
+            bool isClosed = pl.IsClosed;
+            if (isClosed)
+                last--;
+
+            Vector3d lastFaceNormal = Vector3d.ZAxis;
+
+            for (int i = 0; i <= last; i++)
+            {
+                Point3d p = pl[i];
+                Point3d prev = i == 0 ? pl[last] : pl[i - 1];
+                Point3d next = i == last ? pl[0] : pl[i + 1];
+                Vector3d va = pl[i] - prev;
+                Vector3d vb = next - pl[i];
+                va.Unitize();
+                vb.Unitize();
+
+                Vector3d tangent = va + vb;
+                tangent.Unitize();
+
+                if (!isClosed)
+                {
+                    if (i == 0)
+                        tangent = vb;
+                    else if (i == last)
+                        tangent = va;
+                }
+
+                Vector3d faceNormal = Vector3d.CrossProduct(-va, vb);
+
+                if (!isClosed)
+                {
+                    if (i == 0)
+                    {
+                        faceNormal = Vector3d.CrossProduct(pl[0] - pl[1], pl[2] - pl[1]);
+                        if (faceNormal.IsTiny()) faceNormal = Vector3d.ZAxis;
+                    }
+                    else if (i == last)
+                    {
+                        faceNormal = Vector3d.CrossProduct(pl[last - 2] - pl[last - 1], pl[last] - pl[last - 1]);
+                    }
+                }
+
+                if (i == 0)
+                    lastFaceNormal = faceNormal;
+
+                if (faceNormal.IsTiny())
+                    faceNormal = lastFaceNormal;
+                else
+                    lastFaceNormal = faceNormal;
+
+                var normal = Vector3d.CrossProduct(tangent, -faceNormal);
+                normal.Unitize();
+
+                if (normal.IsTiny())
+                    throw new ArgumentException(" Normal invalid.");
+
+                yield return normal;
+            }
+        }
+
+        public static double GetWidth(double diameter, double height)
+        {
+            double r = diameter * 0.5;
+            return ((r * r) / (height * 0.5)) * 2;
+        }
+
+        public static double Snap(double number, double interval)
+        {
+            number /= interval;
+            number = Round(number);
+            number *= interval;
+            return number;
+        }
+
+        public static Point3d ClosestPointFast(this Polyline pl, Point3d testPoint)
+        {
+            int count = pl.Count;
+            if (count < 2) return Point3d.Unset;
+
+            int s_min = 0;
+            double t_min = 0.0;
+            double d_min = double.MaxValue;
+
+            for (int i = 0; i < count - 1; i++)
+            {
+                Line seg = new Line(pl[i], pl[i + 1]);
+                double d;
+                double t;
+
+                if (seg.Direction.IsTiny(1e-32))
+                {
+                    t = 0.0;
+                    d = pl[i].DistanceToSquared(testPoint);
+                }
+                else
+                {
+                    t = seg.ClosestParameter(testPoint);
+                    if (t <= 0.0) { t = 0.0; }
+                    else if (t > 1.0) { t = 1.0; }
+                    d = seg.PointAt(t).DistanceToSquared(testPoint);
+                }
+
+                if (d < d_min)
+                {
+                    d_min = d;
+                    t_min = t;
+                    s_min = i;
+                }
+            }
+
+            double pt = s_min + t_min;
+            return pl.PointAt(pt);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Extensions/Properties/AssemblyInfo.cs b/Extensions/Properties/AssemblyInfo.cs
index f92be9b..3e82ef8 100644
--- a/Extensions/Properties/AssemblyInfo.cs
+++ b/Extensions/Properties/AssemblyInfo.cs
@@ -7,12 +7,8 @@
 using Rhino.PlugIns;
 using Grasshopper.Kernel;
 
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
 [assembly: AssemblyTitle("Extensions")]
-[assembly: AssemblyDescription("Extensions for Grasshopper")]
+[assembly: AssemblyDescription("Assorted components for Grasshopper")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Design Computation Lab - UCL")]
 [assembly: AssemblyProduct("Extensions")]
@@ -20,40 +16,59 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
-// COM, set the ComVisible attribute to true on that type.
 [assembly: ComVisible(false)]
+[assembly: Guid("66d4e86f-ec84-40c9-8e32-8cf8875c3feb")]
 
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("66d4e86f-ec84-40c9-8e32-8cf8875c3feb")] // This will also be the Guid of the Rhino plug-in
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("1.0.0.0")]
 [assembly: AssemblyFileVersion("1.0.0.0")]
 
+[assembly: GH_Loading(GH_LoadingDemand.ForceDirect)]
+
 namespace Extensions
 {
     public class ExtensionsInfo : GH_AssemblyInfo
     {
         public ExtensionsInfo()
         {
-            var dllPath = Path.Combine(Directory.GetCurrentDirectory(), "Robots.gha");
+            string codeBase = Assembly.GetExecutingAssembly().CodeBase;
+            UriBuilder uri = new UriBuilder(codeBase);
+            string path = Uri.UnescapeDataString(uri.Path);
+            string folder = Path.GetDirectoryName(path);
+            const string resName = "Robots.gha";
+            var dllPath = Path.Combine(folder, resName);
             Assembly.LoadFile(dllPath);
+
+            var assembly = Assembly.GetExecutingAssembly();
+            using (var input = assembly.GetManifestResourceStream(resName))
+            {
+                if (input == null) return;
+                Assembly.Load(StreamToBytes(input));
+            }
+        }
+
+        static byte[] StreamToBytes(Stream input)
+        {
+            if (input == null) return null;
+
+            var capacity = input.CanSeek ? (int)input.Length : 0;
+            using (var output = new MemoryStream(capacity))
+            {
+                int readLength;
+                var buffer = new byte[4096];
+
+                do
+                {
+                    readLength = input.Read(buffer, 0, buffer.Length);
+                    output.Write(buffer, 0, readLength);
+                }
+                while (readLength != 0);
+                return output.ToArray();
+            }
         }
 
         public override string Name => "Extensions";
         public override Bitmap Icon => Properties.Resources.DCLLogo;
-        public override string Description => "Extensions for Grasshopper";
+        public override string Description => "Assorted components for Grasshopper";
         public override Guid Id => new Guid("29035877-56b2-45cd-b65d-bf19a046d30b");
         public override string AuthorName => "Design Computation Lab - UCL";
         public override string AuthorContact => "v.soler@ucl.ac.uk";
diff --git a/Extensions/Properties/Resources.Designer.cs b/Extensions/Properties/Resources.Designer.cs
index e12becc..f47e0b9 100644
--- a/Extensions/Properties/Resources.Designer.cs
+++ b/Extensions/Properties/Resources.Designer.cs
@@ -19,7 +19,7 @@ namespace Extensions.Properties {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     internal class Resources {
@@ -90,6 +90,56 @@ internal static System.Drawing.Bitmap DCLLogo {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap EyeDropper {
+            get {
+                object obj = ResourceManager.GetObject("EyeDropper", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Fingerprint {
+            get {
+                object obj = ResourceManager.GetObject("Fingerprint", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Graph {
+            get {
+                object obj = ResourceManager.GetObject("Graph", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Grid {
+            get {
+                object obj = ResourceManager.GetObject("Grid", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Layers {
+            get {
+                object obj = ResourceManager.GetObject("Layers", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -110,6 +160,36 @@ internal static System.Drawing.Bitmap PaintBrush02 {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Polyline {
+            get {
+                object obj = ResourceManager.GetObject("Polyline", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Puzzle {
+            get {
+                object obj = ResourceManager.GetObject("Puzzle", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Byte[].
+        /// </summary>
+        internal static byte[] Robots {
+            get {
+                object obj = ResourceManager.GetObject("Robots", resourceCulture);
+                return ((byte[])(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -120,6 +200,16 @@ internal static System.Drawing.Bitmap Spatial {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Triangle {
+            get {
+                object obj = ResourceManager.GetObject("Triangle", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -129,5 +219,35 @@ internal static System.Drawing.Bitmap Undo {
                 return ((System.Drawing.Bitmap)(obj));
             }
         }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Virus {
+            get {
+                object obj = ResourceManager.GetObject("Virus", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Virus2 {
+            get {
+                object obj = ResourceManager.GetObject("Virus2", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap Wave {
+            get {
+                object obj = ResourceManager.GetObject("Wave", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
     }
 }
diff --git a/Extensions/Properties/Resources.resx b/Extensions/Properties/Resources.resx
index 8d9470c..c6e23a0 100644
--- a/Extensions/Properties/Resources.resx
+++ b/Extensions/Properties/Resources.resx
@@ -127,16 +127,52 @@
   <data name="DCLLogo" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\Icons\DCLLogo.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="EyeDropper" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Icons\EyeDropper.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Fingerprint" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Icons\Fingerprint.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Graph" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Icons\Graph.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Grid" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Icons\Grid.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Layers" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Icons\Layers.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="PaintBrush01" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\Icons\PaintBrush01.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="PaintBrush02" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\Icons\PaintBrush02.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="Polyline" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Icons\Polyline.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Puzzle" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\resources\icons\puzzle.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Robots" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Robots.gha;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
   <data name="Spatial" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\Icons\Spatial.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="Triangle" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\resources\icons\triangle.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="Undo" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\Icons\Undo.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="Virus" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Icons\Virus.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Virus2" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\Icons\Virus2.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Wave" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\resources\icons\wave.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/Extensions/Resources/Icons/EyeDropper.png b/Extensions/Resources/Icons/EyeDropper.png
new file mode 100644
index 0000000000000000000000000000000000000000..d58f9450e553cb4df8e3795a2c578c867f2c9cfb
GIT binary patch
literal 510
zcmV<a0RjGrP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<Sut`KgR7l6=m9cBWP!Pt?@`fN11Q#h15IVhpV^Ctiy=z|!U3GGD
zD5XP541$7-QwJ#>9W?y|oRlI`9Hp8?3Ko<sCB%f1A&6ZRqIRi?OZ&ks?~dPh+`GpE
z_}8jbD!0L4@QY>H@nkYN^A#>hk_-T=P2_U9$DiuZZ=jt{C*wE{YPZ|xvMd+exkx1P
z>A7p3=X>t1H<3=KdzNK|JR9h`9_Bc1;D!r=&@)ZbJG@%0-qh>$oM9MrDwXO3z>1<M
z+b|5;GrU|b-ywvYX0v%|+cssIW=If(9zw{`G%e~0UMiLD5kgL@)w<9$Ey}X&Tcgpq
zwk#`DtJMn2<?`fUc(GU%0bs>2%m*PviO1vb9LEiGT@QO6iztd)dkz4rWHR~c%gpEV
z`ROj4=lT9(vG5KD0O)qR8Q5OM7hhI!qkKO95C{a8i9}+U&1Ro`c|>kar&DG)9435)
z9$ll+2*b|BVvNTC0Foq$ySeoltZTM%YZd?i>^%~Uu}TPerfJ&rqwzfhLP%3l6cUTY
zW=Anl6y=H#qReKqm>&jvAC9W3SXEVg2<&g_8&7V>JUI)cdjJ3c07*qoM6N<$f_n$t
AcK`qY

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Fingerprint.png b/Extensions/Resources/Icons/Fingerprint.png
new file mode 100644
index 0000000000000000000000000000000000000000..49c4e31aa9afc2e992d7033f95efda7fa0326b62
GIT binary patch
literal 680
zcmV;Z0$2TsP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv0007SNkl<ZNXOlj
zKWI}?6vkg(l9ymYd3h8GMT$ca5fKp)kqqJ>B2t2ggM&Co2N7{}2nCT24k98&oH{s&
z6e*=RiZ}%6AR-+^I*Eu#5s@I`AkW`Nz6Z9H=B1N(;NzTg?|a|5=g+-C@ZU<kUJna}
z!dc8k@EQCDKfqgXCk(^A+a~AdCh8?vCCD}W15p%>7K_Dk{8Owy0N=sga=9E0MGi@f
zdIugtT8Hoo_Oeee(&wz5Q!wl<SgKa5;V?0#!P8Qy6r12Rgy$jL4JNQJv-SbZar!!X
zg|(~0lxGa05zHqJw9_S71+N?|QI^UMobg_M;ioog4f4djSRinV^$XZv)clN?@~8*D
z_;zd{F&`=Ad#W`Ar&Vk0k7}gIH92ZJYm1diMOmgh5S5I*!+9D!8h8XfE#Guf{9OvF
zX~I7Qrs6o(7~ibbY9(dG-oAkWG!6W8QYBG|uqWLQP0{@=`gW8=22T<n9t-*-I;}?H
z?+^MHYk`rC+@DF*5?GP8pI;h{MyL~E&Ve2ToovprZ>#QVDtK?5dVR3aOwInMp#L<e
z7vtF;BrTJ7$*$?1Np~Hjl`9B8?a@1g*4WJ`18=DZ>BeT-Pq*sPI)U&6>IL`-<~2Fq
zdMu(ON!GnR_EYcY3UCBm(#Yywxbc#XOVQr&ecJ&#xdLQCe4-wB=2EC+dhB#Jrtl9+
z%U1vnl>hnmGjIcv35}~Soz{<|)_md&J?mw^#QB7Y(i89~=#T1rwochb@Gq()()Mo+
z9mMa?b!VY*oB^}Ge4AyhAYBE_oyA}B#yyz@Um<C3_7M+Ybvxw$w)_FN^LvM#4u<al
O0000<MNUMnLSTZ8ls8iV

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Graph.png b/Extensions/Resources/Icons/Graph.png
new file mode 100644
index 0000000000000000000000000000000000000000..2f07998831080728bb39097cce3302e1532ef5bd
GIT binary patch
literal 439
zcmV;o0Z9IdP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<SX-PyuR7l6=R6UD>KolI#C7mD^5mKiJ{s4np1Wj>eiu?_0A;onm
zEK=uJSXl-Pv9Ym_jja$YLP)1<vDbLPI}X=;!f^vzy!U426^|X@-@x;{g`y}YMNv+k
z=Pe#;zS(Tv0r2LldqTW*Atgy-bm`r^z%Y!YOYbf`^#(6P5CpRz2xd=PpzHcx*Y*81
znodW43DPtjsj7NZRrQ#r>FA;6zVFXvSw0g&7$JnovV8V^e}1<yV~n`2y8^&9O*=$U
zG>M{UqG{Rz0C!z?#TX+unHNRTw{3e1fSaZn=XpN(n&o*uFikTCz-`;!7Dds&%Dk$o
zo@H4(0Nin$byZcp-#CurtO0P#vUb05T2Yo|FAT$}h!=+8v@A=pd6s2EN@*-f5~GyH
zS(Xi(^R}oEX#oI~(in|6u4@3|xNg&4AW0HylIj`&uv{)belDncLha=zkH_P0@!PCL
haowhU-3|UMJ^@7!+!Y8_u?GME002ovPDHLkV1j3mxWxbf

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Grid.png b/Extensions/Resources/Icons/Grid.png
new file mode 100644
index 0000000000000000000000000000000000000000..47f530a8ab249cb1d2a0816c1a5a431d5d2a1566
GIT binary patch
literal 191
zcmeAS@N?(olHy`uVBq!ia0vp^5+KaM1|%Pp+x`GjoCO|{#S9F5M?jcysy3fAP_WR`
z#WBR=_}j^jTnz?1Ebbp;C)J%1u)p@`_?HE(QAg&vtdZqt(L2pH%fWYzIBUZyznx`!
zMECx^9K5|j{=!kUXlsTuIcy*9d2=NCm<mSDDPH)*H?#bM-vI&X(5o>f#tHue9xUlT
lA@tQcKX!}hT9XIAb3WDv-te68W*5+M22WQ%mvv4FO#nAqM!5h0

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Layers.png b/Extensions/Resources/Icons/Layers.png
new file mode 100644
index 0000000000000000000000000000000000000000..dbaf2ca8277792ae70a18ce5f824dbf1302f8228
GIT binary patch
literal 709
zcmV;$0y_PPP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<TcS%G+R7l6=mCb76P!z{c#Dp$l=*Ew|O?7XTkOz<&w2z<?`T$y`
z_6Zz<LLNXG=o<*JNcT#p!)#N{Fk7`Ny>wwN^>SyGA>;Vb>2zRV&h{Suobx;Xb1uMt
z6XWstG?&ZW=W@CG@pydtVZsO@p<b`ISeC^M!w>+VEX(40z1~6y3GWsrgai!3C`Y5w
z8352!D)o6d9Lj^iKu)DnUjTqcqtTgR7-d38;J3sr%aYRR^dkV!NF?&y>2xmF>-7(j
z^?DuXbUK&eaQGPjXeN_+v@9!gP<T3>#)`$_9m6n$W!cwiwW==`i{oASi^bx&QmN>{
zVDOb;7*Z;g?xxdeY-_Tv>y=O_gaClbvOKhHJNed*ZQD-DvOEL;8VZGwuIrUwl026H
z0Ofi9rP*xWtX8X|L*lE|>ZsXl-tavC0s!=&%S_W$L{Xdo0FB4vU%TDz#jf0Lw|fzf
z$G-sp6-9B<>-Chq)nJS{LP)@MT~5=qYY$mAn|<&jvu!(>&1N4wB$}pOyROR-LIN0L
zZg1t1Bw3@;=xoc-akX02cMWwk8l6d!WbN$4kA`6wqN?icd_Io={A^p;u;qL{kEp78
z>n))uiWAc`x1-ubBM1U&x7$}9I>Ru^-eO^lxpupKB?toAM0L=1el!3;6N$uAzu!Oi
z-uwOjc_NW`^19vYf4@x?MY-RHrcfxD`F!5ohe}bD?Kbr<+BP)aO#%QKi^XR9P;Fhb
zLui)ErBJKYTK+5gE>yeFIF57Ty*rL`vJ2IlV-pR>ak$ZFd}=fr8pm-M{^VTy10f{T
rYPA;2ve>KmLq43%_-kM0KOf%#Q^3uE)dR5W00000NkvXXu0mjfX82X}

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Polyline.png b/Extensions/Resources/Icons/Polyline.png
new file mode 100644
index 0000000000000000000000000000000000000000..d5e5802954dd970c45ae91933935d890c09527b7
GIT binary patch
literal 541
zcmV+&0^<FNP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<S&q+i<R7l6|mA`8uK@`Wogq;v!!8L?fD7b>fl0wpGd9bCG$7!+E
zVX=ah#^Z?j4`e}Dtgf(#m0O5}6jvU>(nd%jDdgB9#R<!8z;LJ=mbu0ai$BPCBv<7F
zQ@okS`@Z?{-T?3XFHF-Ed%fOA(=^3b4{jKS!g1Ua0LpRPlVKRjs|rLSk$V8t8%z6T
zY}*!8Rc$4c$y-%bTefWroBRTSz#qTB(teq2HhT?#Mx)Vt0CZ`uQ7jf)et}Y{^o>b?
z5VDYE`3C^VvV21bS!_w<3INUJa$Q~5&m70$m;@wAy5o8Nv0AO_JkLK$l61G~)9?2`
z0HFDNzRMKUPrY8h@NYelNQ|e`DetYjuDh2?r3QqM#dthU>=b-9n;pbrF*6hj{T>d7
zr<$gH1wadh!lmca>2wqTv{I=wcg|kZv~vKo(P(_}vdv^N-vQ8eyZw1I8l8xuXbOVx
zU|H7TPQfk9Itm7Z5Ak^X=X^fj_vR;)$#FOw{^dWmTCJw-oPD`mZUUg2Dw5^mH{v)B
zr|bHeq9_I-WRXs%2d?Yxt@^P(-8GiQ@w|2aW%^+)zBO3Oowa?e@y`v5l{as>!1Jf^
f=}kV3cee2tC^+M6I(F{;00000NkvXXu0mjfAjJN~

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Puzzle.png b/Extensions/Resources/Icons/Puzzle.png
new file mode 100644
index 0000000000000000000000000000000000000000..01ed2995c225c5204b2bae6b2b9adb267f1135e0
GIT binary patch
literal 855
zcmV-d1E~CoP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<U2}wjjR7l6=R8L6Ta1{PbB$h;qXfR3wiu5r5P|9ktYAq!f*}M&^
z48|t7g9i&9c4_b8K`6`~Mo%kVRLYK{Fcb*|V=2;MD-J|5h*+_;&|0ZlYIaenf4a`$
zW$eK_{CMB*`|`bC-UI%-@Or(|f*`0QNfs>@OC%f)4?G#U-|v49K;wB{9T^$<s?+HT
zG)<o>iqifh0-`9cG7NK?PNy3IU}<S-6oBUQ`KBt}As!>Zaoka{Sgg%vvkd@{N~Kr;
zXl`ykd=dxi>+4p6AWAlyEv%}lKvC3rM@PqAp-|BMEvNQS8VrWrt*xz|O7*J*0Mu4f
z5CmbrzrTOu`phs)-sN)nj7DQ35D2^rg+ebbFE4L+WLdWE@9ztL?7-=C1|MVj3V-9^
zQIA|H^7%X+jYfNOxm^9-+N~D({r>mM%ge7@TU!rZF4sq^)moKYk|cXuTici8<71X(
z*)+#-M-KwMUhgyjji%{SilWX5f+zvd#>dA$S0cZ-xTxiMUe)XMS-0Cg%P`Cd0Ij>b
zJAMx=2!hJ<yqZp@8~671ItB*^!v=$4cXM;|c_o2ZEM@|rc|4vO07xVfU2}7DAIc~D
zrbWqQvSoO9_#4Zz8337sg9B$an{DXq?EFzlK&R840YD~`X#{|HJZ{|B*yuBvOy2?g
zyal#cED?&L&KDLI-ptR>Pu11c6#!^~K;Z4&w!~sF)6UM$vr?%<n9b%WK@cTT6jy6%
zYBT^E$8pJfUlR_82WXl;McFU`(8k8b7Rw)$=Xv!SV>X+kk|fz24#yfvl101SE)5M0
zNhteGZ-t^L?LMDxDi{pDIy*a~P&Nnoe4cJ<YD($#`mD#}nVFoN{6r8$$>DIUm2=#k
zgKBXj5RFEA0cdWwd-l30isC9slEo(x$mMeNEX$@ChB-+j5?zani=zNEyWKARPN3>8
zl4aTIbUK3*6BFP#?r3{^yDJn5y^KU6eE^_o8p_v+EX&oWv)sYm?CI%=D~i&-va%w!
hw6r8qWt;x{@e68CS;aOTVO#(J002ovPDHLkV1jt3gt-6!

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Triangle.png b/Extensions/Resources/Icons/Triangle.png
new file mode 100644
index 0000000000000000000000000000000000000000..fa12c23ac20ac804978cc84e3049c72615802db9
GIT binary patch
literal 377
zcmV-<0fzpGP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<SD@jB_R7l6|lCf@sFc3hmQic<ff54krz48Iwsk(LXPZV|QLe-50
ziGD;DHk1$G13E@*PMOS}#fiMQ3q&-+RSazHlPsOi=R3>K0ROCs)*7|e=yPV{Q=Dbl
zYahO?etRiph=?adJV`0T)d$3JyaNCW0Je|UqpGS00I))ctq@`h0JhI9M{A9Yu>&FG
zsFb2gDM|=AGR6+R!Y4`7^c?_fp64$^u8(cMH=jW)=X`IBx%@a|%!YHmUo3nOTi5md
z^<JNwFMKT4RWlO)=+*pMtgCLe@F}q_yoI~Oy6_hMn^+e&3%^CI3zzV_A<$YQ=e%j#
zHY|$bnNr&M4CuO!CQ0(a82f6Ph6h1#{!uW9U1N=fUnE9R^jVhWlkd|^fr#hjUH%N;
XFm=lsxOo0>00000NkvXXu0mjfSJtHu

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Virus.png b/Extensions/Resources/Icons/Virus.png
new file mode 100644
index 0000000000000000000000000000000000000000..68b6a1abb37c53ba4ff056c3832ee44370a070fc
GIT binary patch
literal 769
zcmV+c1OEJpP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<Tvq?ljR7l6=RXu3iKotH6mN^WHBM8NUVmfK)U`mh@2$H6*A%jy-
zfmn;=wat`8kg1b1DtHJPx<t;<p=%anI=DszLl!Rq4J9E2i~?#dvf;YuLU8QHffNe;
zCf$ASNAG=)cffyvIF56U<Lrx~7>S}7IgYa*$8qk(5>%_zLjX)w)vl_lT>vb-dp<^^
z(VXkLyM;pGLXxC`Wm$)UAl#Xz+2S^)X|@DGxU($lP?DrUp-{MRU3Ygh8qGbKz;)eS
z08CMozNTp%01N<ITU-0aZPITBfN7f6RTQNUfTg~FhAhiJ6-DV&O0xh^E|-saupkJQ
zf*@Gp=ad7bG^;2|UzX*I@pz9)qLk+H`TPwbBmsa*rE<)<PN%cn>2#L)nRA4YB%jaU
z+}_@jnFTGE%g4U&SBAr3#<uN-uIueE42xkH7Ij^3+qT^p4u=`v_ba^0t*x!;!pCu(
zt5&Orf*{=S764$jZ8rem>gsB-Uax<;yu5tHeNyh;HWmJ0;s`sA(*VFs(`-EyQP=f0
z0PO7Sd<MX_x3}xu$1sf6!y!l~jn!(k{YMEzQH;_V2LJ>?u;h7OEeyjV0Gyqjz1`g0
z{L<_7N>LQe13(ytMbGnUsqg>*RaLv9C`MC7o`#c?llOajdmpc_uNM~<76wO0N0nK9
z0RU-P%rJ~cElQFkv%0$a{q*$o-TC?XoAveeuf1NcWEe(!<`%_qoU<(JV4BF2@GOxz
zW*F1ghGDd9+ioODlJR}Nvazx8^q6u;k~GjX?Otr(_bdDlJ<qFoo>$}Nlmh^0n%0#h
zX)qoyGk!q`p-~jgQ%bXhkfhmce&F27%E}MM*u8DaH7TXpQmHgg2>JD71!K#ui<e$@
zd|k`3JoCDiWqI~>Jqea&z1)K{34i^`{HO67Gc2B;lQoGQ00000NkvXXu0mjf8DDJX

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Virus2.png b/Extensions/Resources/Icons/Virus2.png
new file mode 100644
index 0000000000000000000000000000000000000000..67cca12a611fe2d41be65728427d536adf10f1b8
GIT binary patch
literal 547
zcmV+;0^I$HP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<S)k#D_R7l6&RWWPZKoovNrI;+v5XxCpP~K{;ga3r_=37Fh3|*94
z6a9=^gEDy0qD8}LYw?dLhJ$Vv*d{vJ8r(&~5J9^nMv>*p7+h#Sc-wp5$NS#hdjS76
z@;q;Oo_E6-la^&I48wRf4CC3dtOa9CdY*Ta=XvWWa^Lr_P1Ae=fM0(K(=?xa-@iVX
zxG0J<+qT^%;%eBo?G{CG)+lfcd0C{<mSf3ZW3OF#p0}Djmr@R;l*6W(ln1}{EC_<D
zIF8M#u;VyF2yqVpptUAiYXSfugt&JcM^y9UI5vYIxY`j2!;sZ=MhMZI^G8IClu}eF
zMG-OLoIesmbX`p?mt|RteQhJ+G)>dX(P;E#KA(R~)ASM%r~C3>xBvj)U8yxv6_rvl
ztu;|f(RRE2b37jRyWQ@OUa$AP-|v5;l&VgrlQ70)#U`>N(1h7+_GvH}d=0~pO(v7i
zht?fz(Q>)`uwJh(Hk-}+)oOLHMO(bIxsxn}xXZHa91*9S^9RoP10qhdEISuM+||{T
zE!)1L;czIS21$~1T-Uvgq6jIaic+egC_>kDZ<8eH)Ya5-o$8~#!AV!eD^9xX0RF<d
lF57jIgHs*+$xh}!gWnKhrtoSWsgVEx002ovPDHLkV1l7~{SyEH

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Icons/Wave.png b/Extensions/Resources/Icons/Wave.png
new file mode 100644
index 0000000000000000000000000000000000000000..11084f7f5069cf8890afd1d43fe7b61ccb5e8cac
GIT binary patch
literal 542
zcmV+(0^$9MP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv00009a7bBm000ie
z000ie0hKEb8vp<S&`Cr=R7l6|k};?f0T{>srwwvQG@QpF_u}0%8jcWAh!O*NAchKx
zxE4fjsHmaa1h)oh5aH0_92^{49OAv<S%@^GAVQFGBBCaWXWrRzq1YhVQcV$0;t@Rj
zP2ceG|MBttfgL+89-=5dr6_7X7z_^1MPRqvo7rskQ6iCeah83<HsQLiUpARc-$J3#
zX`|7&`OkvUXmpifn9rF^<_Q1{hr@l2<36!0JDE%-EC8sgN(+LJnog(8)`CKza9<FF
zlq5-y0bn+pF$}|KMx*gNK@eE4*M@XD{k+%fU5m%#FaIj=cs%cUo^Nv;H^}93M*vW-
z*Kdcz;S;mj{8iI5YCfOS6h)~3V6|GOilVTUO64%0&p&Lp+kB~1x+}{v-|zQ-7vR#b
zp<1op0f5C~LAqS756k89mDA}wu-R;Vhr`iowOV#nRcV^0wV%)aSS%J}1VO-Jv3%)t
zI`@*vWPG(+kt9hj06YKy;!kG@f{@y5HU?Ri`Et4Jmn7*(*YzukqU`zo{!$<ic++e)
zZ$zWfV^I{J1%tuUZOQ^gQLK?j<aMo9y9EH<Zuh#^>wV{TyKCd|nB6Muti)omqR;1h
gdoJNScKly{0P}gZ;dNv6KL7v#07*qoM6N<$f}w5vng9R*

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/Robots.gha b/Extensions/Resources/Robots.gha
new file mode 100644
index 0000000000000000000000000000000000000000..905ed6a2c96118d3bab744a76292c0f21a37ea59
GIT binary patch
literal 133632
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

literal 0
HcmV?d00001

diff --git a/Extensions/Resources/StraightSkeletonNet.dll b/Extensions/Resources/StraightSkeletonNet.dll
new file mode 100644
index 0000000000000000000000000000000000000000..bfb0bf1b99ff643a31e5892d6b5bbb1137e064be
GIT binary patch
literal 37888
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
PVg94o|L^mEod*6lFDN$3

literal 0
HcmV?d00001

diff --git a/Extensions/View/Discrete/CurveSnap.cs b/Extensions/View/Discrete/CurveSnap.cs
new file mode 100644
index 0000000..2ccafd4
--- /dev/null
+++ b/Extensions/View/Discrete/CurveSnap.cs
@@ -0,0 +1,48 @@
+using System;
+using Grasshopper.Kernel;
+using Rhino.Geometry;
+using Grasshopper.Kernel.Parameters;
+
+namespace Extensions.View
+{
+    public class CurveSnap : GH_Component
+    {
+        public CurveSnap() : base("Curve snap", "CurveSnap", "Snaps curves to discrete intervals and directions.", "Extensions", "Discrete") { }
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.Polyline;
+        public override Guid ComponentGuid => new Guid("{4F45F86C-6B7E-4327-9475-467CB82DAF13}");
+
+        protected override void RegisterInputParams(GH_InputParamManager pManager)
+        {
+            pManager.AddCurveParameter("Curve", "C", "Curve.", GH_ParamAccess.item);
+            pManager.AddNumberParameter("Segment length", "L", "Length of the segments.", GH_ParamAccess.item);
+            pManager.AddIntegerParameter("Snap type", "S", "Directions based on spherical mapping. Right click for types.", GH_ParamAccess.item, 0);
+            pManager.AddIntegerParameter("Subdivisions", "D", "Number of spherical subdivisions.", GH_ParamAccess.item, 0);
+
+            var param = pManager[2] as Param_Integer;
+            param.AddNamedValue("Equirectangular", 0);
+            param.AddNamedValue("Icosahedral", 1);
+            param.AddNamedValue("Quadrangular", 2);
+        }
+
+        protected override void RegisterOutputParams(GH_OutputParamManager pManager)
+        {
+            pManager.AddCurveParameter("Discretized curve", "C", "Discretized curve.", GH_ParamAccess.item);
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            Curve curve = null;
+            double length = 0;
+            int snapType = 0;
+            int divisions = 0;
+
+            if (!DA.GetData(0, ref curve)) return;
+            if (!DA.GetData(1, ref length)) return;
+            if (!DA.GetData(2, ref snapType)) return;
+            if (!DA.GetData(3, ref divisions)) return;
+
+            var result = Model.Discrete.CurveSnap.SnapCurve(curve, length, (Model.Discrete.CurveSnap.SnapType)snapType, divisions);
+            DA.SetData(0, result);
+        }
+    }
+}
diff --git a/Extensions/View/Discrete/UnityExport.cs b/Extensions/View/Discrete/UnityExport.cs
new file mode 100644
index 0000000..e1d83c1
--- /dev/null
+++ b/Extensions/View/Discrete/UnityExport.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using Grasshopper.Kernel;
+using Extensions.Model.Discrete;
+
+namespace Extensions.View
+{
+    public class UnityExport : GH_Component
+    {
+        public UnityExport() : base("Unity export", "UnityExport", "Exports block instances to Unity 3D.", "Extensions", "Discrete") { }
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.Puzzle;
+        public override Guid ComponentGuid => new Guid("{09694580-A4BB-4CD8-B061-E158BC83478F}");
+
+        protected override void RegisterInputParams(GH_InputParamManager pManager)
+        {
+            pManager.AddTextParameter("Block names", "B", "Block names.", GH_ParamAccess.list);
+            pManager.AddTextParameter("Instances layer", "I", "Layer name where the instances are placed.", GH_ParamAccess.item);
+            pManager.AddNumberParameter("Angle limit", "Ja", "Maximum angle rotation for joints (0 for rigid joints).", GH_ParamAccess.item);
+            pManager.AddNumberParameter("Break force", "Jf", "Break force (in newtons) for joints.", GH_ParamAccess.item);
+            pManager.AddTextParameter("File name", "F", "XML export file name.", GH_ParamAccess.item);
+        }
+
+        protected override void RegisterOutputParams(GH_OutputParamManager pManager)
+        {
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            var blockNames = new List<string>();
+            string instancesLayer = null, fileName = null;
+            double angleLimit = 0, breakForce = 0;
+
+            if(!DA.GetDataList(0, blockNames)) return;
+            if (!DA.GetData(1, ref instancesLayer)) return;
+            if (!DA.GetData(2, ref angleLimit)) return;
+            if (!DA.GetData(3, ref breakForce)) return;
+            if (!DA.GetData(4, ref fileName)) return;
+
+            Assembly.Export(blockNames, instancesLayer, angleLimit, breakForce, fileName, Rhino.RhinoDoc.ActiveDoc);
+        }
+    }
+}
diff --git a/Extensions/View/Discrete/VoxelTiles.cs b/Extensions/View/Discrete/VoxelTiles.cs
new file mode 100644
index 0000000..5627406
--- /dev/null
+++ b/Extensions/View/Discrete/VoxelTiles.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Grasshopper.Kernel;
+using Rhino.Geometry;
+using Grasshopper.Kernel.Types;
+
+namespace Extensions.View
+{
+    public class VoxelTiles : GH_Component
+    {
+        public VoxelTiles() : base("Voxel tiles", "VoxelTiles", "Voxelizes a boundary shape and places discrete elements on each voxel based on guide curves and points.", "Extensions", "Discrete") { }
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.Cube;
+        public override Guid ComponentGuid => new Guid("{769FB3B8-6C88-4130-AA32-FB9D0D1BC6AA}");
+
+        protected override void RegisterInputParams(GH_InputParamManager pManager)
+        {
+            pManager.AddMeshParameter("Boundary mesh", "B", "Boundary mesh.", GH_ParamAccess.item);
+            pManager.AddNumberParameter("Voxel size", "S", "Length of the voxel edges.", GH_ParamAccess.item);
+            pManager.AddCurveParameter("Curves for alignment", "A", "Curves for alignment.", GH_ParamAccess.list);
+            pManager.AddNumberParameter("Alignment max distance", "Ad", "The weighted average direction of curves within this distance will be used. If no curves are within this distance the voxel is removed. Use 0 for closest curve only.", GH_ParamAccess.item);
+            pManager.AddGenericParameter("Attractors for types", "D", "Types are selected based on the distance to this geometry. Only points and curves are supported.", GH_ParamAccess.list);
+            pManager.AddNumberParameter("Attractors max distance", "Dd", "Max distance for the last type.", GH_ParamAccess.item);
+            pManager.AddGeometryParameter("Face types", "Ft", "Face types. Only one geometry object per type. If a type consists on multiple objects, use a group object.", GH_ParamAccess.list);
+            pManager.AddGeometryParameter("Edge types", "Et", "Edge types.", GH_ParamAccess.list);
+            pManager.AddGeometryParameter("Corner types", "Ct", "Corner types.", GH_ParamAccess.list);
+
+            pManager[6].Optional = true;
+            pManager[7].Optional = true;
+            pManager[8].Optional = true;
+        }
+
+        protected override void RegisterOutputParams(GH_OutputParamManager pManager)
+        {
+            pManager.AddGeometryParameter("Voxel geometry", "G", "Oriented tiles.", GH_ParamAccess.list);
+            pManager.AddPlaneParameter("Voxel orientation", "O", "Orientation of each voxel as a plane.", GH_ParamAccess.list);
+            pManager.AddIntegerParameter("Voxel type", "T", "Voxel type as index values.", GH_ParamAccess.list);
+            pManager.AddIntegerParameter("Voxel snap type", "S", "Voxel snap types. 0 = face, 1 = edge, 2 = corner.", GH_ParamAccess.list);
+            pManager.AddNumberParameter("Voxel distance", "D", "Normalized distance to closest attractor.", GH_ParamAccess.list);
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            Mesh boundary = null;
+            double length = 0;
+            var alignments = new List<Curve>();
+            var ghAttractors = new List<IGH_GeometricGoo>();
+            double alignmentDistance = 0, attractorDistance = 0;
+            var faceTypes = new List<IGH_GeometricGoo>();
+            var edgeTypes = new List<IGH_GeometricGoo>();
+            var cornerTypes = new List<IGH_GeometricGoo>();
+
+            if (!DA.GetData(0, ref boundary)) return;
+            if (!DA.GetData(1, ref length)) return;
+            if (!DA.GetDataList(2, alignments)) return;
+            if (!DA.GetData(3, ref alignmentDistance)) return;
+            if (!DA.GetDataList(4, ghAttractors)) return;
+            if (!DA.GetData(5, ref attractorDistance)) return;
+            DA.GetDataList(6, faceTypes);
+            DA.GetDataList(7, edgeTypes);
+            DA.GetDataList(8, cornerTypes);
+
+            var attractors = new List<GeometryBase>();
+
+            foreach (var geo in ghAttractors)
+            {
+                if (geo is GH_Point)
+                {
+                    var point = geo as GH_Point;
+                    attractors.Add(new Point(point.Value));
+                }
+                else if (geo is GH_Curve)
+                {
+                    var curve = geo as GH_Curve;
+                    attractors.Add(curve.Value);
+                }
+                else
+                {
+                    AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Geometry '{geo.TypeDescription}' not supported as attractor.");
+                }
+            }
+
+            var types = new[]
+            {
+                faceTypes,
+                edgeTypes,
+                cornerTypes
+            };
+
+            var typesCount = types.Select(t => t.Count).ToArray();
+
+            if (typesCount.Sum() == 0)
+            {
+                AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "You need to input at least one type.");
+                return;
+            }
+
+            var voxels = Model.Discrete.VoxelTiles.Create(boundary, length, alignments, alignmentDistance, attractors, attractorDistance, typesCount);
+
+            var geometry = new List<IGH_GeometricGoo>();
+
+            foreach (var voxel in voxels)
+            {
+                var type = types[voxel.SnapType][voxel.Type];
+                var xform = Transform.PlaneToPlane(Plane.WorldXY, voxel.Location) * Transform.Scale(Point3d.Origin, length);
+                var placedType = type.DuplicateGeometry();
+                placedType = placedType.Transform(xform);
+                geometry.Add(placedType);
+            }
+
+            var orientations = voxels.Select(v => v.Location);
+            var voxelTypes = voxels.Select(v => v.Type);
+            var snapTypes = voxels.Select(v => v.SnapType);
+            var voxelDistances = voxels.Select(v => v.AttractorDistance);
+
+            DA.SetDataList(0, geometry);
+            DA.SetDataList(1, orientations);
+            DA.SetDataList(2, voxelTypes);
+            DA.SetDataList(3, snapTypes);
+            DA.SetDataList(4, voxelDistances);
+        }
+    }
+}
diff --git a/Extensions/View/Geometry/DifferentialGrowth.cs b/Extensions/View/Geometry/DifferentialGrowth.cs
new file mode 100644
index 0000000..d0e2b15
--- /dev/null
+++ b/Extensions/View/Geometry/DifferentialGrowth.cs
@@ -0,0 +1,77 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Grasshopper.Kernel;
+using Grasshopper.Kernel.Types;
+using Grasshopper.Kernel.Data;
+using Rhino.Geometry;
+using static Extensions.Model.Util;
+
+namespace Extensions.View
+{
+    public class DifferentialGrowth : GH_Component
+    {
+        public DifferentialGrowth() : base("Differential growth", "DifferentialGrowth", "Grows a polyline using a differential growth algorithm.", "Extensions", "Geometry") { }
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.Virus;
+        public override Guid ComponentGuid => new Guid("{64C4B469-E923-4B7E-B746-C2599F7ED0A0}");
+
+        protected override void RegisterInputParams(GH_InputParamManager pManager)
+        {
+            pManager.AddGeometryParameter("Region", "R", "Boundary region as either a planar polyline or a mesh.", GH_ParamAccess.item);
+            pManager.AddCurveParameter("Polylines", "P", "Polylines to grow.", GH_ParamAccess.list);
+            pManager.AddNumberParameter("Radius", "R", "Collision radius.", GH_ParamAccess.item);
+            pManager.AddIntegerParameter("Iterations", "I", "Simulation iterations.", GH_ParamAccess.item);
+            pManager.AddIntegerParameter("Convergence", "C", "Convergence iterations.", GH_ParamAccess.item);
+        }
+
+        protected override void RegisterOutputParams(GH_OutputParamManager pManager)
+        {
+            pManager.AddCurveParameter("Polylines", "P", "Resulting polylines.", GH_ParamAccess.tree);
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            GeometryBase region = null;
+            var curves = new List<Curve>();
+            double radius = 0;
+            int iterations = 0, convergence = 0;
+
+            DA.GetData(0, ref region);
+            DA.GetDataList(1, curves);
+            DA.GetData(2, ref radius);
+            DA.GetData(3, ref iterations);
+            DA.GetData(4, ref convergence);
+
+            Polyline polyline = null;
+            Mesh mesh = null;
+
+            if (region is Curve)
+            {
+                polyline = (region as Curve).ToPolyline();
+            }
+            else if (region is Mesh)
+            {
+                mesh = (region as Mesh);
+            }
+            else
+            {
+                throw new Exception(" Region should be polyline or mesh.");
+            }
+
+            var inPolylines = curves.Select(c => c.ToPolyline()).ToList();
+
+            var simulation = new Model.Simulations.DifferentialGrowth.DifferentialGrowth(inPolylines, radius, convergence, iterations, polyline, mesh);
+            var polylines = simulation.AllPolylines;
+
+            var outCurves = new GH_Structure<GH_Curve>();
+            var path = DA.ParameterTargetPath(0);
+
+            for (int j = 0; j < polylines.Count; j++)
+            {
+                outCurves.AppendRange(polylines[j].Select(p => new GH_Curve(p.ToNurbsCurve())), path.AppendElement(j));
+            }
+
+            DA.SetDataTree(0, outCurves);
+        }
+    }
+}
diff --git a/Extensions/View/Geometry/Remesher.cs b/Extensions/View/Geometry/Remesher.cs
new file mode 100644
index 0000000..cca39fe
--- /dev/null
+++ b/Extensions/View/Geometry/Remesher.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using Grasshopper.Kernel;
+using Rhino.Geometry;
+using Extensions.Model.Geometry;
+
+namespace Extensions.View
+{
+    public class RemesherComponent : GH_Component
+    {
+        public RemesherComponent() : base("Remesher", "Remesher", "Triangular remeshing trying to keep edge lengths as equal as possible.", "Extensions", "Geometry") { }
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.Triangle;
+        public override Guid ComponentGuid => new Guid("{55D4CA7D-D9C7-485A-BC7A-BFDA387D4163}");
+
+        protected override void RegisterInputParams(GH_InputParamManager pManager)
+        {
+            pManager.AddMeshParameter("Mesh", "M", "Input mesh.", GH_ParamAccess.item);
+            pManager.AddNumberParameter("Length", "L", "Target edge length.", GH_ParamAccess.item);
+            pManager.AddIntegerParameter("Iterations", "I", "Number of iterations.", GH_ParamAccess.item,50);
+        }
+
+        protected override void RegisterOutputParams(GH_OutputParamManager pManager)
+        {
+            pManager.AddMeshParameter("Mesh", "M", "Resulting mesh.", GH_ParamAccess.item);
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            Mesh mesh = new Mesh();
+            double length = 0.0;
+            int iterations = 50;
+            DA.GetData(0, ref mesh);
+            DA.GetData(1, ref length);
+            DA.GetData(2, ref iterations);
+
+            Mesh outMesh = Remesh.RemeshTest(mesh, length, iterations);
+            DA.SetData(0, outMesh);
+        }
+    }
+}
diff --git a/Extensions/View/Geometry/StraightSkeleton.cs b/Extensions/View/Geometry/StraightSkeleton.cs
new file mode 100644
index 0000000..c54d6c4
--- /dev/null
+++ b/Extensions/View/Geometry/StraightSkeleton.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Grasshopper.Kernel;
+using Rhino.Geometry;
+using Extensions;
+using static Extensions.Model.Util;
+
+namespace Extensions.View
+{
+    public class StraightSkeleton : GH_Component
+    {
+        public StraightSkeleton() : base("Straight skeleton", "StraightSkeleton", "Returns the straight skeleton of a polygon.", "Extensions", "Geometry") { }
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.Graph;
+        public override Guid ComponentGuid => new Guid("{d529efd9-2fdd-4751-a6b4-307c8f82390b}");
+
+        protected override void RegisterInputParams(GH_InputParamManager pManager)
+        {
+            pManager.AddCurveParameter("Polygon", "P", "Polygon to create the straight skeleton.", GH_ParamAccess.item);
+        }
+
+        protected override void RegisterOutputParams(GH_OutputParamManager pManager)
+        {
+            pManager.AddCurveParameter("Regions", "R", "Closed regions of the straight skeleton.", GH_ParamAccess.list);
+            pManager.AddCurveParameter("Axis", "A", "Attempt to get a medial axis.", GH_ParamAccess.item);
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            Curve curve = null;
+            DA.GetData(0, ref curve);
+            Polyline polyline = curve.ToPolyline();
+
+            var regions = Model.StraightSkeleton.StraightSkeleton.GetStraightSkeleton(polyline);
+            var regionCurves = regions.Select(e => e.ToNurbsCurve());
+            var axis = Model.StraightSkeleton.StraightSkeleton.GetAxis(regions, polyline);
+
+            DA.SetDataList(0, regionCurves);
+            DA.SetData(1, new PolylineCurve(axis));
+        }
+    }
+}
diff --git a/Extensions/View/Rendering/BitmapFromSolidColoredMeshes.cs b/Extensions/View/Rendering/BitmapFromSolidColoredMeshes.cs
index 78895ce..346d211 100644
--- a/Extensions/View/Rendering/BitmapFromSolidColoredMeshes.cs
+++ b/Extensions/View/Rendering/BitmapFromSolidColoredMeshes.cs
@@ -2,22 +2,21 @@
 using System.Collections.Generic;
 using Grasshopper.Kernel;
 using Rhino.Geometry;
-using Extensions;
 
 
 namespace Extensions.View
 {
     public class BitmapFromSolidColoredMeshes : GH_Component
     {
-        public BitmapFromSolidColoredMeshes() : base("Bitmap from meshes", "BitmapMeshes", "Bitmap from solid colored meshes", "Extensions", "Rendering") { }
+        public BitmapFromSolidColoredMeshes() : base("Bitmap from meshes", "BitmapMeshes", "Creates a bitmap from solid colored meshes and assigns the corresponding uv coordinates to the meshes.", "Extensions", "Rendering") { }
         protected override System.Drawing.Bitmap Icon => Properties.Resources.PaintBrush02;
         public override Guid ComponentGuid => new Guid("{db4d6bc7-9e3c-459b-8494-6fd92dc526ca}");
 
 
         protected override void RegisterInputParams(GH_InputParamManager pManager)
         {
-            pManager.AddMeshParameter("Meshes", "M", "One or more meshes, each with a single vertex color.", GH_ParamAccess.list);
-            pManager.AddTextParameter("File path", "F", "File path to a png image.", GH_ParamAccess.item);
+            pManager.AddMeshParameter("Meshes", "M", "One or more meshes, each with a unique vertex color.", GH_ParamAccess.list);
+            pManager.AddTextParameter("File path", "F", "File path to a PNG image.", GH_ParamAccess.item);
         }
 
         protected override void RegisterOutputParams(GH_OutputParamManager pManager)
diff --git a/Extensions/View/Rendering/BitmapFromVertexColors.cs b/Extensions/View/Rendering/BitmapFromVertexColors.cs
index 4c4241e..3e252f5 100644
--- a/Extensions/View/Rendering/BitmapFromVertexColors.cs
+++ b/Extensions/View/Rendering/BitmapFromVertexColors.cs
@@ -9,7 +9,7 @@ namespace Extensions.View
 {
     public class BitMapFromVertexColors : GH_Component
     {
-        public BitMapFromVertexColors() : base("Bitmap from mesh", "BitmapMesh", "Bitmap from vertex colors.", "Extensions", "Rendering") { }
+        public BitMapFromVertexColors() : base("Bitmap from mesh", "BitmapMesh", "Creates a bitmap from a mesh with multiple vertex colors and assigns the corresponding uv coordinates to the mesh.", "Extensions", "Rendering") { }
         protected override System.Drawing.Bitmap Icon => Properties.Resources.PaintBrush01;
         public override Guid ComponentGuid => new Guid("{7aedf2f4-75e2-48be-94c5-fe116caf8b26}");
 
@@ -17,7 +17,7 @@ public BitMapFromVertexColors() : base("Bitmap from mesh", "BitmapMesh", "Bitmap
         protected override void RegisterInputParams(GH_InputParamManager pManager)
         {
             pManager.AddMeshParameter("Mesh", "M", "Single mesh with render colors.", GH_ParamAccess.item);
-            pManager.AddTextParameter("File path", "F", "File path to a png image.", GH_ParamAccess.item);
+            pManager.AddTextParameter("File path", "F", "File path to a PNG image.", GH_ParamAccess.item);
         }
 
         protected override void RegisterOutputParams(GH_OutputParamManager pManager)
diff --git a/Extensions/View/Rendering/MeshTextureCoords.cs b/Extensions/View/Rendering/MeshTextureCoords.cs
index 1d7eaca..b6db2cb 100644
--- a/Extensions/View/Rendering/MeshTextureCoords.cs
+++ b/Extensions/View/Rendering/MeshTextureCoords.cs
@@ -10,18 +10,18 @@ namespace Extensions.View
     public class MeshTextureCoords : GH_Component
     {
         public MeshTextureCoords() : base("Mesh texture coordinates", "MeshTexCoords", "Sets mesh texture coordinates.", "Extensions", "Rendering") { }
-        protected override System.Drawing.Bitmap Icon => Properties.Resources.Cube;
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.EyeDropper;
         public override Guid ComponentGuid => new Guid("{297d173d-4eac-4a93-947c-fa8216e73cfa}");
 
         protected override void RegisterInputParams(GH_InputParamManager pManager)
         {
-            pManager.AddMeshParameter("Mesh", "M", "Single mesh with render colors.", GH_ParamAccess.item);
-            pManager.AddPointParameter("Texture coords", "T", "Texture coordinates. Must equal the number of mesh vertices. The Z components will be ignored.", GH_ParamAccess.list);
+            pManager.AddMeshParameter("Mesh", "M", "Mesh object.", GH_ParamAccess.item);
+            pManager.AddPointParameter("Texture coords", "T", "Texture coordinates as a list of 3D points. The Z component will be ignored.", GH_ParamAccess.list);
         }
 
         protected override void RegisterOutputParams(GH_OutputParamManager pManager)
         {
-            pManager.AddMeshParameter("Mesh", "M", "Mesh with texture coordinates set.", GH_ParamAccess.item);
+            pManager.AddMeshParameter("Mesh", "M", "Resulting mesh with texture coordinates.", GH_ParamAccess.item);
         }
 
         protected override void SolveInstance(IGH_DataAccess DA)
diff --git a/Extensions/View/Toolpaths/CSVConverter.cs b/Extensions/View/Toolpaths/CSVConverter.cs
new file mode 100644
index 0000000..8e0f9c6
--- /dev/null
+++ b/Extensions/View/Toolpaths/CSVConverter.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Grasshopper.Kernel;
+using Rhino.Geometry;
+using Robots;
+using Robots.Grasshopper;
+using static Extensions.Model.Util;
+
+namespace Extensions.View
+{
+    public class CSVConverter : GH_Component
+    {
+        public CSVConverter() : base("CSV to robot targets", "CSVRobot", "Converts a CSV file to robot targets.", "Extensions", "Toolpaths") { }
+        public override GH_Exposure Exposure => GH_Exposure.primary;
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.Fingerprint;
+        public override Guid ComponentGuid => new Guid("{0C7F5A9E-40CC-4A87-AB23-6333D274FF14}");
+        protected override void RegisterInputParams(GH_InputParamManager pManager)
+        {
+            pManager.AddTextParameter("File", "F", "Text file. Each target should be one line, values should be separated by commas.", GH_ParamAccess.item);
+            pManager.AddParameter(new TargetParameter(), "Target", "T", "Created targets will use the parameters of this reference target if they're not supplied in the CSV file.", GH_ParamAccess.item);
+            pManager.AddTextParameter("Mask", "M", "Mask representing CSV format. Parameters allowed: 'position, normal, xaxis, speed, zone, type'. The first three should be 3 values (x,y,z). Distance values should be defined in mm. Speed is defined in mm/minute. Type should be an integer (0,1) where 0 is a rapid move and 1 is a cutting move.", GH_ParamAccess.item, "position, normal, speed");
+            pManager.AddBooleanParameter("Reverse normal", "R", "Reverses the tool normal.", GH_ParamAccess.item, false);
+            pManager.AddNumberParameter("Cutting speed", "C", "Maximum speed in mm/min that will be considered a cutting move.", GH_ParamAccess.item, 2750);
+            pManager.AddPointParameter("Point alignment", "P", "Aligns the X axis of the tagets to look towards this point (in world coordinate system). If not supplied it will use the X axis of the reference target.", GH_ParamAccess.item);
+            pManager[4].Optional = true;
+            pManager[5].Optional = true;
+        }
+
+        protected override void RegisterOutputParams(GH_OutputParamManager pManager)
+        {
+            pManager.AddParameter(new TargetParameter(), "Targets", "T", "List of targets.", GH_ParamAccess.list);
+            pManager.AddCurveParameter("ToolPath", "C", "Only the cutting paths.", GH_ParamAccess.list);
+        }
+
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            string file = null, mask = null;
+            GH_Target target = null;
+            bool reverse = false;
+            double cuttingSpeed = 0;
+            Point3d? point = null;
+
+            if (!DA.GetData(0, ref file)) return;
+            if (!DA.GetData(1, ref target)) return;
+            if (!DA.GetData(2, ref mask)) return;
+            if (!DA.GetData(3, ref reverse)) return;
+            DA.GetData(4, ref cuttingSpeed);
+            DA.GetData(5, ref point);
+
+            var converter = new Extensions.Toolpaths.CSVConverter(file, target.Value as CartesianTarget, mask, reverse, cuttingSpeed, point);
+
+            DA.SetDataList(0, converter.Targets);
+            DA.SetDataList(1, converter.ToolPath);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Extensions/View/Toolpaths/LayeredToolpath.cs b/Extensions/View/Toolpaths/LayeredToolpath.cs
new file mode 100644
index 0000000..bbbb323
--- /dev/null
+++ b/Extensions/View/Toolpaths/LayeredToolpath.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Linq;
+using Grasshopper.Kernel;
+using Rhino.Geometry;
+
+namespace Extensions.View
+{
+    public class LayeredToolpath : GH_Component
+    {
+        public LayeredToolpath() : base("Layered toolpath", "LayeredToolpath", "Creates a layered extrusion toolpath.", "Extensions", "Toolpaths") { }
+        protected override System.Drawing.Bitmap Icon => Properties.Resources.Layers;
+        public override Guid ComponentGuid => new Guid("{82C1EFE1-97C3-438C-84F4-C23F92574373}");
+
+        protected override void RegisterInputParams(GH_InputParamManager pManager)
+        {
+            pManager.AddMeshParameter("Mesh", "M", "Mesh.", GH_ParamAccess.item);
+            pManager.AddNumberParameter("Nozzle diameter", "D", "Nozzle diameter", GH_ParamAccess.item);
+            pManager.AddNumberParameter("Layer height", "H", "Layer height", GH_ParamAccess.item);
+            pManager.AddIntervalParameter("Region", "R", "Region", GH_ParamAccess.item);
+        }
+
+        protected override void RegisterOutputParams(GH_OutputParamManager pManager)
+        {
+            pManager.AddCurveParameter("Original", "O", "Original contours.", GH_ParamAccess.list);
+            pManager.AddCurveParameter("Clean", "C", "Cleaned contours.", GH_ParamAccess.list);
+            pManager.AddMeshParameter("Pipe", "P", "3D beads.", GH_ParamAccess.list);
+            pManager.AddMeshParameter("Skin", "S", "3D skin for visualization.", GH_ParamAccess.item);
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            Mesh mesh = new Mesh();
+            double diameter = 0, height = 0;
+            Interval region = Interval.Unset;
+
+            DA.GetData(0, ref mesh);
+            DA.GetData(1, ref diameter);
+            DA.GetData(2, ref height);
+            DA.GetData(3, ref region);
+
+            var column = new Model.Toolpath.Column(mesh, diameter, height, region);
+
+            var original = column.Contours.Select(p => new PolylineCurve(p));
+            var contours = column.Layers.SelectMany(p => p.Select(c => new PolylineCurve(c)));
+            var pipes = column.Pipes.SelectMany(p => p);
+            var skin = column.Skin;
+
+            DA.SetDataList(0, original);
+            DA.SetDataList(1, contours);
+            DA.SetDataList(2, pipes);
+            DA.SetData(3, skin);
+        }
+    }
+}
diff --git a/Extensions/View/Toolpaths/SpatialExtrusion.cs b/Extensions/View/Toolpaths/SpatialExtrusion.cs
index 8ba055e..77757f8 100644
--- a/Extensions/View/Toolpaths/SpatialExtrusion.cs
+++ b/Extensions/View/Toolpaths/SpatialExtrusion.cs
@@ -5,25 +5,27 @@
 using Rhino.Geometry;
 using Robots;
 using Robots.Grasshopper;
+using static Extensions.Model.Util;
 
 namespace Extensions.View
 {
     public class SpatialExtrusion : GH_Component
     {
-        public SpatialExtrusion() : base("Spatial extrusion", "Spatial", "Create a toolpath spatial extrusion given a polyline. Requires the Robots plugin.", "Extensions", "Toolpaths")
-        { }
-
+        public SpatialExtrusion() : base("Spatial extrusion", "Spatial", "Create a spatial extrusion toolpath given a polyline. Requires the Robots plugin.", "Extensions", "Toolpaths") { }
+        public override GH_Exposure Exposure => GH_Exposure.primary;
         protected override System.Drawing.Bitmap Icon => Properties.Resources.Spatial;
         public override Guid ComponentGuid => new Guid("{79EE65B3-CB2F-4704-8B01-C7C9F379B7C4}");
 
         protected override void RegisterInputParams(GH_InputParamManager pManager)
         {
-            pManager.AddCurveParameter("Polyline", "P", "Polyline", GH_ParamAccess.item);
+            pManager.AddCurveParameter("Polylines", "P", "Polylines", GH_ParamAccess.list);
             pManager.AddNumberParameter("Variables", "V", "0. Extrusion diameter (mm).\r\n1. Plunge distance (mm).\r\n2. Unsupported nodes vertical offset (mm).\r\n3. Unsupported segments rotation compensation (rad). \r\n4. Distance ahead to stop in upwards segments as a factor of length (0..1).\r\n5. Horizontal displacement before downward segment (mm).", GH_ParamAccess.list);
             pManager.AddParameter(new TargetParameter(), "Target", "T", "Target reference. Will use tool, frame and orientation of this target.", GH_ParamAccess.item);
             pManager.AddNumberParameter("Speeds", "S", "0. Approach speed.\r\n1. Plunge speed.\r\n2. Supported segments\r\n3. Downward segments\r\n4. Unsupported nodes", GH_ParamAccess.list);
             pManager.AddNumberParameter("Wait times", "W", "0. Wait time after extrusion.\r\n1. Wait time ahead stop.\r\n2. Wait on supported node before unsupported segment.\r\n3. Wait on unsupported node.", GH_ParamAccess.list);
             pManager.AddIntegerParameter("Digital outputs", "D", "The indices of the two digital outputs connected to the extruder.", GH_ParamAccess.list);
+            pManager.AddGeometryParameter("Environment", "E", "Environment to detect supported nodes and segments. Should be only meshes or polylines.", GH_ParamAccess.list);
+            pManager[6].Optional = true;
         }
 
         protected override void RegisterOutputParams(GH_OutputParamManager pManager)
@@ -36,9 +38,9 @@ protected override void RegisterOutputParams(GH_OutputParamManager pManager)
 
         protected override void SolveInstance(IGH_DataAccess DA)
         {
-            Curve curve = null;
-            if (!DA.GetData(0, ref curve)) return;
-            if (!curve.TryGetPolyline(out var pl)) throw new Exception(" Curve must be a polyline.");
+            var curves = new List<Curve>();
+            if (!DA.GetDataList(0, curves)) return;
+            var polylines = curves.Select(c => c.ToPolyline());
 
             var variables = new List<double>();
             if (!DA.GetDataList(1, variables)) return;
@@ -56,8 +58,11 @@ protected override void SolveInstance(IGH_DataAccess DA)
             var dos = new List<int>();
             if (!DA.GetDataList(5, dos)) return;
 
-            var attributes = new Toolpaths.SpatialAttributes(variables, (target.Value) as CartesianTarget, speeds, waits, dos);
-            var spatial = new Toolpaths.SpatialExtrusion(pl, attributes);
+            var environment = new List<GeometryBase>();
+            DA.GetDataList(6, environment);
+
+            var attributes = new Toolpaths.SpatialAttributes(variables, (target.Value) as CartesianTarget, speeds, waits, dos, environment);
+            var spatial = new Toolpaths.SpatialExtrusion(polylines, attributes);
 
             DA.SetDataList(0, spatial.Targets);
             DA.SetDataList(1, spatial.Display.Select(d => d.segment));
diff --git a/Extensions/View/Util.cs b/Extensions/View/Util.cs
new file mode 100644
index 0000000..63fd087
--- /dev/null
+++ b/Extensions/View/Util.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Grasshopper.Kernel;
+using Grasshopper.Kernel.Data;
+using Rhino.Geometry;
+
+namespace Extensions.View
+{
+    static class Util
+    {
+    }
+}
diff --git a/Extensions/app.config b/Extensions/app.config
new file mode 100644
index 0000000..557095a
--- /dev/null
+++ b/Extensions/app.config
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.ValueTuple" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.3.0" newVersion="4.0.3.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>
\ No newline at end of file
diff --git a/Extensions/packages.config b/Extensions/packages.config
new file mode 100644
index 0000000..4e421c8
--- /dev/null
+++ b/Extensions/packages.config
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Costura.Fody" version="3.1.0" targetFramework="net471" developmentDependency="true" />
+  <package id="Fody" version="3.1.3" targetFramework="net471" developmentDependency="true" />
+  <package id="geometry3Sharp" version="1.0.144" targetFramework="net471" />
+  <package id="morelinq" version="3.0.0" targetFramework="net471" />
+  <package id="System.ValueTuple" version="4.5.0" targetFramework="net471" />
+</packages>
\ No newline at end of file
diff --git a/README.md b/README.md
index c574937..4dac007 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,15 @@
 # Extensions
-Plugin for Rhino and Grasshopper with miscelaneous features developed in Design Computation lab.
+Plugin for Rhino and Grasshopper with miscelaneous features developed in Design Computation lab (UCL).
+
+### Installation
+1. Download the latest release.
+2. Right click on the file, select properties and make sure it's unblocked.
+3. Drag the Extensions.gha file to the Grasshopper canvas.
+
+### Dependencies
+This application makes use of the following libraries:
+* Robots (https://github.com/visose/Robots)
+* Clipper (http://www.angusj.com/delphi/clipper.php)
+* Kendzi straight skeleton (https://github.com/kendzi/kendzi-math)
+* Geometry3Sharp (https://github.com/gradientspace/geometry3Sharp)
+* Stefan Gustavson's simplex noise (http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf)