From 0a6da8d0eedeaf84dda73d18038ecd844155f687 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Mon, 15 Jul 2013 12:51:58 +0100
Subject: [PATCH 01/20] Rename projects (and namespaces)

* HalfEdgeMeshLibrary -> Plankton
* PlanktonComponents -> PlanktonGh
---
 Plankton.sln                                        |   4 ++--
 {HalfEdgeMeshLibrary => Plankton}/Plankton.cs       |   0
 {HalfEdgeMeshLibrary => Plankton}/Plankton.csproj   |   0
 .../Properties/AssemblyInfo.cs                      |   6 +++---
 .../DecomposePlankton.cs                            |   4 ++--
 {PlanktonComponents => PlanktonGh}/GHMeshToPMesh.cs |   4 ++--
 .../PlanktonGh.csproj                               |  11 ++++++++---
 .../Properties/AssemblyInfo.cs                      |   8 ++++----
 .../Properties/Resources.Designer.cs                |   4 ++--
 .../Properties/Resources.resx                       |   0
 .../Resources/plankton.png                          | Bin
 .../Resources/plankton_decon.png                    | Bin
 12 files changed, 23 insertions(+), 18 deletions(-)
 rename {HalfEdgeMeshLibrary => Plankton}/Plankton.cs (100%)
 rename {HalfEdgeMeshLibrary => Plankton}/Plankton.csproj (100%)
 rename {HalfEdgeMeshLibrary => Plankton}/Properties/AssemblyInfo.cs (89%)
 rename {PlanktonComponents => PlanktonGh}/DecomposePlankton.cs (97%)
 rename {PlanktonComponents => PlanktonGh}/GHMeshToPMesh.cs (96%)
 rename PlanktonComponents/Plankton_GH_Components.csproj => PlanktonGh/PlanktonGh.csproj (89%)
 rename {PlanktonComponents => PlanktonGh}/Properties/AssemblyInfo.cs (81%)
 rename {PlanktonComponents => PlanktonGh}/Properties/Resources.Designer.cs (95%)
 rename {PlanktonComponents => PlanktonGh}/Properties/Resources.resx (100%)
 rename {PlanktonComponents => PlanktonGh}/Resources/plankton.png (100%)
 rename {PlanktonComponents => PlanktonGh}/Resources/plankton_decon.png (100%)

diff --git a/Plankton.sln b/Plankton.sln
index a38aadb..9c0c6be 100644
--- a/Plankton.sln
+++ b/Plankton.sln
@@ -1,9 +1,9 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual C# Express 2010
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Plankton", "HalfEdgeMeshLibrary\Plankton.csproj", "{BDD288F7-C2E2-4C2A-B083-E4D4D21F528F}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Plankton", "Plankton\Plankton.csproj", "{BDD288F7-C2E2-4C2A-B083-E4D4D21F528F}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Plankton_GH_Components", "PlanktonComponents\Plankton_GH_Components.csproj", "{9C7EA9A3-331B-4574-BF22-B9D609DE2F1E}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PlanktonGh", "PlanktonGh\PlanktonGh.csproj", "{9C7EA9A3-331B-4574-BF22-B9D609DE2F1E}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/HalfEdgeMeshLibrary/Plankton.cs b/Plankton/Plankton.cs
similarity index 100%
rename from HalfEdgeMeshLibrary/Plankton.cs
rename to Plankton/Plankton.cs
diff --git a/HalfEdgeMeshLibrary/Plankton.csproj b/Plankton/Plankton.csproj
similarity index 100%
rename from HalfEdgeMeshLibrary/Plankton.csproj
rename to Plankton/Plankton.csproj
diff --git a/HalfEdgeMeshLibrary/Properties/AssemblyInfo.cs b/Plankton/Properties/AssemblyInfo.cs
similarity index 89%
rename from HalfEdgeMeshLibrary/Properties/AssemblyInfo.cs
rename to Plankton/Properties/AssemblyInfo.cs
index 764aebb..227ae07 100644
--- a/HalfEdgeMeshLibrary/Properties/AssemblyInfo.cs
+++ b/Plankton/Properties/AssemblyInfo.cs
@@ -5,12 +5,12 @@
 // 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("HalfEdgeMeshLibrary")]
+[assembly: AssemblyTitle("Plankton")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("HalfEdgeMeshLibrary")]
-[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyProduct("Plankton")]
+[assembly: AssemblyCopyright("Copyright © 2013 Plankton contributors.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
diff --git a/PlanktonComponents/DecomposePlankton.cs b/PlanktonGh/DecomposePlankton.cs
similarity index 97%
rename from PlanktonComponents/DecomposePlankton.cs
rename to PlanktonGh/DecomposePlankton.cs
index 0696284..e12bbf6 100644
--- a/PlanktonComponents/DecomposePlankton.cs
+++ b/PlanktonGh/DecomposePlankton.cs
@@ -5,7 +5,7 @@
 using Rhino.Geometry;
 using Plankton;
 
-namespace PlanktonComponents
+namespace PlanktonGh
 {
     public class DecomposePlankton : GH_Component
     {
@@ -103,7 +103,7 @@ protected override System.Drawing.Bitmap Icon
             {
                 //You can add image files to your project resources and access them like this:
                 // return Resources.IconForThisComponent;                
-                return PlanktonComponents.Properties.Resources.plankton_decon;
+                return PlanktonGh.Properties.Resources.plankton_decon;
             }
         }
 
diff --git a/PlanktonComponents/GHMeshToPMesh.cs b/PlanktonGh/GHMeshToPMesh.cs
similarity index 96%
rename from PlanktonComponents/GHMeshToPMesh.cs
rename to PlanktonGh/GHMeshToPMesh.cs
index b250228..9aeb235 100644
--- a/PlanktonComponents/GHMeshToPMesh.cs
+++ b/PlanktonGh/GHMeshToPMesh.cs
@@ -6,7 +6,7 @@
 using Grasshopper.Kernel;
 using Plankton;
 
-namespace PlanktonComponents
+namespace PlanktonGh
 {
  
     public class GHMeshToPMesh : GH_Component
@@ -65,7 +65,7 @@ protected override System.Drawing.Bitmap Icon
         {
             get
             {
-                return PlanktonComponents.Properties.Resources.plankton;
+                return PlanktonGh.Properties.Resources.plankton;
             }
         }
 
diff --git a/PlanktonComponents/Plankton_GH_Components.csproj b/PlanktonGh/PlanktonGh.csproj
similarity index 89%
rename from PlanktonComponents/Plankton_GH_Components.csproj
rename to PlanktonGh/PlanktonGh.csproj
index 3d0aa0a..f4bf9a9 100644
--- a/PlanktonComponents/Plankton_GH_Components.csproj
+++ b/PlanktonGh/PlanktonGh.csproj
@@ -8,10 +8,12 @@
     <ProjectGuid>{9C7EA9A3-331B-4574-BF22-B9D609DE2F1E}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>PlanktonComponents</RootNamespace>
-    <AssemblyName>PlanktonComponents</AssemblyName>
+    <RootNamespace>PlanktonGh</RootNamespace>
+    <AssemblyName>PlanktonGh</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <NoWin32Manifest>False</NoWin32Manifest>
+    <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -61,7 +63,7 @@
     </Compile>
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\HalfEdgeMeshLibrary\Plankton.csproj">
+    <ProjectReference Include="..\Plankton\Plankton.csproj">
       <Project>{BDD288F7-C2E2-4C2A-B083-E4D4D21F528F}</Project>
       <Name>Plankton</Name>
       <Private>False</Private>
@@ -80,6 +82,9 @@
     <None Include="Resources\plankton_decon.png" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>Copy "$(TargetPath)" "$(TargetDir)$(SolutionName).gha"</PostBuildEvent>
+  </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/PlanktonComponents/Properties/AssemblyInfo.cs b/PlanktonGh/Properties/AssemblyInfo.cs
similarity index 81%
rename from PlanktonComponents/Properties/AssemblyInfo.cs
rename to PlanktonGh/Properties/AssemblyInfo.cs
index d287cd1..a273a0e 100644
--- a/PlanktonComponents/Properties/AssemblyInfo.cs
+++ b/PlanktonGh/Properties/AssemblyInfo.cs
@@ -5,12 +5,12 @@
 // 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("PlanktonComponents")]
-[assembly: AssemblyDescription("")]
+[assembly: AssemblyTitle("PlanktonGh")]
+[assembly: AssemblyDescription("Provides components for mesh operations using Plankton's half-edge, ngon mesh representation.")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("PlanktonComponents")]
-[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyProduct("PlanktonGh")]
+[assembly: AssemblyCopyright("Copyright © 2013 Plankton contributors.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
diff --git a/PlanktonComponents/Properties/Resources.Designer.cs b/PlanktonGh/Properties/Resources.Designer.cs
similarity index 95%
rename from PlanktonComponents/Properties/Resources.Designer.cs
rename to PlanktonGh/Properties/Resources.Designer.cs
index 3f2dd47..0fc5624 100644
--- a/PlanktonComponents/Properties/Resources.Designer.cs
+++ b/PlanktonGh/Properties/Resources.Designer.cs
@@ -8,7 +8,7 @@
 // </auto-generated>
 //------------------------------------------------------------------------------
 
-namespace PlanktonComponents.Properties {
+namespace PlanktonGh.Properties {
     using System;
     
     
@@ -39,7 +39,7 @@ internal Resources() {
         internal static global::System.Resources.ResourceManager ResourceManager {
             get {
                 if (object.ReferenceEquals(resourceMan, null)) {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PlanktonComponents.Properties.Resources", typeof(Resources).Assembly);
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PlanktonGh.Properties.Resources", typeof(Resources).Assembly);
                     resourceMan = temp;
                 }
                 return resourceMan;
diff --git a/PlanktonComponents/Properties/Resources.resx b/PlanktonGh/Properties/Resources.resx
similarity index 100%
rename from PlanktonComponents/Properties/Resources.resx
rename to PlanktonGh/Properties/Resources.resx
diff --git a/PlanktonComponents/Resources/plankton.png b/PlanktonGh/Resources/plankton.png
similarity index 100%
rename from PlanktonComponents/Resources/plankton.png
rename to PlanktonGh/Resources/plankton.png
diff --git a/PlanktonComponents/Resources/plankton_decon.png b/PlanktonGh/Resources/plankton_decon.png
similarity index 100%
rename from PlanktonComponents/Resources/plankton_decon.png
rename to PlanktonGh/Resources/plankton_decon.png

From 543acf53f78505d142cc7f9be202a565f107cf09 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Tue, 16 Jul 2013 11:17:10 +0100
Subject: [PATCH 02/20] Split classes in Plankton.cs into separate files and
 rename

* one file per mesh element class
* rename (for example) P_mesh -> PlanktonMesh to better follow C# naming
* All instances of `HalfEdge' renamed to `Halfedge' (it was bugging me for some reason)
---
 Plankton/Plankton.csproj                  |   5 +-
 Plankton/PlanktonFace.cs                  |  22 ++
 Plankton/PlanktonHalfedge.cs              |  42 +++
 Plankton/{Plankton.cs => PlanktonMesh.cs} | 308 +++++++++-------------
 Plankton/PlanktonVertex.cs                |  31 +++
 PlanktonGh/DecomposePlankton.cs           |  32 +--
 PlanktonGh/GHMeshToPMesh.cs               |   4 +-
 7 files changed, 237 insertions(+), 207 deletions(-)
 create mode 100644 Plankton/PlanktonFace.cs
 create mode 100644 Plankton/PlanktonHalfedge.cs
 rename Plankton/{Plankton.cs => PlanktonMesh.cs} (61%)
 create mode 100644 Plankton/PlanktonVertex.cs

diff --git a/Plankton/Plankton.csproj b/Plankton/Plankton.csproj
index cd621e1..574333f 100644
--- a/Plankton/Plankton.csproj
+++ b/Plankton/Plankton.csproj
@@ -42,7 +42,10 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Plankton.cs" />
+    <Compile Include="PlanktonFace.cs" />
+    <Compile Include="PlanktonHalfEdge.cs" />
+    <Compile Include="PlanktonMesh.cs" />
+    <Compile Include="PlanktonVertex.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
diff --git a/Plankton/PlanktonFace.cs b/Plankton/PlanktonFace.cs
new file mode 100644
index 0000000..35531cd
--- /dev/null
+++ b/Plankton/PlanktonFace.cs
@@ -0,0 +1,22 @@
+using Rhino.Geometry;
+using System;
+
+namespace Plankton
+{
+    /// <summary>
+    /// Description of PlanktonFace.
+    /// </summary>
+    public class PlanktonFace
+    {
+        public int FirstHalfedge;
+        //
+        public int EdgeCount;
+        public Vector3d Normal;
+        public double Area;
+        
+        public PlanktonFace()
+        {
+            FirstHalfedge = -1;
+        }
+    }
+}
diff --git a/Plankton/PlanktonHalfedge.cs b/Plankton/PlanktonHalfedge.cs
new file mode 100644
index 0000000..2d4d602
--- /dev/null
+++ b/Plankton/PlanktonHalfedge.cs
@@ -0,0 +1,42 @@
+using Rhino.Geometry;
+using System;
+
+namespace Plankton
+{
+    /// <summary>
+    /// Description of PlanktonHalfedge.
+    /// </summary>
+    public class PlanktonHalfedge
+    {
+        //primary properties - the minimum ones needed for the halfedge structure
+        public int StartVertex;
+        public int AdjacentFace;
+        public int NextHalfedge;
+        //secondary properties - these should still be kept updated if you change the topology
+        public int PrevHalfedge;
+        public int Index;
+        //tertiary properties - less vital, calculate or refresh only as needed
+        public Vector3d Normal;
+
+        public PlanktonHalfedge()
+        {
+            StartVertex = -1;
+            AdjacentFace = -1;
+            NextHalfedge = -1;
+            PrevHalfedge = -1;
+        }
+        public PlanktonHalfedge(int Start, int AdjFace, int Next)
+        {
+            StartVertex = Start;
+            AdjacentFace = AdjFace;
+            NextHalfedge = Next;
+        }
+        public int Pair()
+        {
+            if (Index % 2 == 0)
+            { return Index + 1; }
+            else
+            { return Index - 1; }
+        }
+    }
+}
diff --git a/Plankton/Plankton.cs b/Plankton/PlanktonMesh.cs
similarity index 61%
rename from Plankton/Plankton.cs
rename to Plankton/PlanktonMesh.cs
index 9e8735b..471d90a 100644
--- a/Plankton/Plankton.cs
+++ b/Plankton/PlanktonMesh.cs
@@ -1,27 +1,28 @@
-using System;
+using Rhino.Geometry;
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Rhino.Geometry;
 
 namespace Plankton
 {
-    public class P_mesh
+    /// <summary>
+    /// Description of PlanktonMesh.
+    /// </summary>
+    public class PlanktonMesh
     {
         #region "members"
-        public List<P_vertex> Vertices;
-        public List<P_halfedge> HalfEdges;        
-        public List<P_face> Faces;
+        public List<PlanktonVertex> Vertices;
+        public List<PlanktonHalfedge> Halfedges;        
+        public List<PlanktonFace> Faces;
         #endregion
 
         #region "constructors"
-        public P_mesh() //blank constructor
+        public PlanktonMesh() //blank constructor
         {
-            this.Faces = new List<P_face>();
-            this.HalfEdges = new List<P_halfedge>();
-            this.Vertices = new List<P_vertex>();
+            this.Faces = new List<PlanktonFace>();
+            this.Halfedges = new List<PlanktonHalfedge>();
+            this.Vertices = new List<PlanktonVertex>();
         }
-        public P_mesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
+        public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
         {
 
             M.Vertices.CombineIdentical(true, true);
@@ -29,33 +30,33 @@ public P_mesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
             M.UnifyNormals();
             M.Weld(Math.PI);            
 
-            this.Faces = new List<P_face>();
-            this.HalfEdges = new List<P_halfedge>();
-            this.Vertices = new List<P_vertex>();
+            this.Faces = new List<PlanktonFace>();
+            this.Halfedges = new List<PlanktonHalfedge>();
+            this.Vertices = new List<PlanktonVertex>();
 
             for (int i = 0; i < M.Vertices.Count; i++)
             {
-                Vertices.Add(new P_vertex(M.TopologyVertices[i]));
+                Vertices.Add(new PlanktonVertex(M.TopologyVertices[i]));
             }
           
             for (int i = 0; i < M.Faces.Count; i++)
-            {Faces.Add(new P_face()); }
+            {Faces.Add(new PlanktonFace()); }
 
             for (int i = 0; i < M.TopologyEdges.Count; i++)
             {
-                P_halfedge HalfA = new P_halfedge();
+                PlanktonHalfedge HalfA = new PlanktonHalfedge();
 
                 HalfA.StartVertex = M.TopologyEdges.GetTopologyVertices(i).I;
 
-                if (Vertices[HalfA.StartVertex].OutgoingHalfEdge == -1)
-                { Vertices[HalfA.StartVertex].OutgoingHalfEdge = HalfEdges.Count; }
+                if (Vertices[HalfA.StartVertex].OutgoingHalfedge == -1)
+                { Vertices[HalfA.StartVertex].OutgoingHalfedge = Halfedges.Count; }
 
-                P_halfedge HalfB = new P_halfedge();
+                PlanktonHalfedge HalfB = new PlanktonHalfedge();
 
                 HalfB.StartVertex = M.TopologyEdges.GetTopologyVertices(i).J;
 
-                if (Vertices[HalfB.StartVertex].OutgoingHalfEdge == -1)
-                { Vertices[HalfB.StartVertex].OutgoingHalfEdge = HalfEdges.Count + 1; }
+                if (Vertices[HalfB.StartVertex].OutgoingHalfedge == -1)
+                { Vertices[HalfB.StartVertex].OutgoingHalfedge = Halfedges.Count + 1; }
 
                 bool[] Match;
                 int[] ConnectedFaces = M.TopologyEdges.GetConnectedFaces(i, out Match);
@@ -111,13 +112,13 @@ public P_mesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
                 if (Match[0] == true)
                 {
                     HalfA.AdjacentFace = ConnectedFaces[0];
-                    if (Faces[HalfA.AdjacentFace].FirstHalfEdge == -1)
-                    { Faces[HalfA.AdjacentFace].FirstHalfEdge = HalfEdges.Count; }
+                    if (Faces[HalfA.AdjacentFace].FirstHalfedge == -1)
+                    { Faces[HalfA.AdjacentFace].FirstHalfedge = Halfedges.Count; }
                     if (ConnectedFaces.Length > 1)
                     {
                         HalfB.AdjacentFace = ConnectedFaces[1];
-                        if (Faces[HalfB.AdjacentFace].FirstHalfEdge == -1)
-                        { Faces[HalfB.AdjacentFace].FirstHalfEdge = HalfEdges.Count + 1; }
+                        if (Faces[HalfB.AdjacentFace].FirstHalfedge == -1)
+                        { Faces[HalfB.AdjacentFace].FirstHalfedge = Halfedges.Count + 1; }
                     }
                     else
                     {
@@ -128,73 +129,73 @@ public P_mesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
                 {
                     HalfB.AdjacentFace = ConnectedFaces[0];
 
-                    if (Faces[HalfB.AdjacentFace].FirstHalfEdge == -1)
-                    { Faces[HalfB.AdjacentFace].FirstHalfEdge = HalfEdges.Count + 1; }
+                    if (Faces[HalfB.AdjacentFace].FirstHalfedge == -1)
+                    { Faces[HalfB.AdjacentFace].FirstHalfedge = Halfedges.Count + 1; }
 
                     if (ConnectedFaces.Length > 1)
                     {
                         HalfA.AdjacentFace = ConnectedFaces[1];
 
-                        if (Faces[HalfA.AdjacentFace].FirstHalfEdge == -1)
-                        { Faces[HalfA.AdjacentFace].FirstHalfEdge = HalfEdges.Count; }
+                        if (Faces[HalfA.AdjacentFace].FirstHalfedge == -1)
+                        { Faces[HalfA.AdjacentFace].FirstHalfedge = Halfedges.Count; }
                     }
                     else
                     {
                         HalfA.AdjacentFace = -1;
                     }
                 }
-                HalfEdges.Add(HalfA);
-                HalfEdges[2 * i].Index = 2 * i; //
-                HalfEdges.Add(HalfB);
-                HalfEdges[2 * i + 1].Index = 2 * i + 1; //
+                Halfedges.Add(HalfA);
+                Halfedges[2 * i].Index = 2 * i; //
+                Halfedges.Add(HalfB);
+                Halfedges[2 * i + 1].Index = 2 * i + 1; //
             }
 
-            for (int i = 0; i < (HalfEdges.Count); i += 2)
+            for (int i = 0; i < (Halfedges.Count); i += 2)
             {
-                int[] EndNeighbours = M.TopologyVertices.ConnectedTopologyVertices(HalfEdges[i + 1].StartVertex, true);
+                int[] EndNeighbours = M.TopologyVertices.ConnectedTopologyVertices(Halfedges[i + 1].StartVertex, true);
                 for (int j = 0; j < EndNeighbours.Length; j++)
                 {
-                    if(EndNeighbours[j]==HalfEdges[i].StartVertex)
+                    if(EndNeighbours[j]==Halfedges[i].StartVertex)
                     {
-                        int EndOfNextHalfEdge = EndNeighbours[(j - 1 + EndNeighbours.Length) % EndNeighbours.Length];
-                        int StartOfPrevOfPairHalfEdge = EndNeighbours[(j + 1) % EndNeighbours.Length];
+                        int EndOfNextHalfedge = EndNeighbours[(j - 1 + EndNeighbours.Length) % EndNeighbours.Length];
+                        int StartOfPrevOfPairHalfedge = EndNeighbours[(j + 1) % EndNeighbours.Length];
                        
-                        int NextEdge = M.TopologyEdges.GetEdgeIndex(HalfEdges[i + 1].StartVertex,EndOfNextHalfEdge);
-                        int PrevPairEdge = M.TopologyEdges.GetEdgeIndex(HalfEdges[i + 1].StartVertex,StartOfPrevOfPairHalfEdge);
+                        int NextEdge = M.TopologyEdges.GetEdgeIndex(Halfedges[i + 1].StartVertex,EndOfNextHalfedge);
+                        int PrevPairEdge = M.TopologyEdges.GetEdgeIndex(Halfedges[i + 1].StartVertex,StartOfPrevOfPairHalfedge);
 
-                        if (M.TopologyEdges.GetTopologyVertices(NextEdge).I == HalfEdges[i + 1].StartVertex)
-                        { HalfEdges[i].NextHalfEdge = NextEdge * 2; }
+                        if (M.TopologyEdges.GetTopologyVertices(NextEdge).I == Halfedges[i + 1].StartVertex)
+                        { Halfedges[i].NextHalfedge = NextEdge * 2; }
                         else
-                        { HalfEdges[i].NextHalfEdge = NextEdge * 2 + 1; }
+                        { Halfedges[i].NextHalfedge = NextEdge * 2 + 1; }
 
-                        if (M.TopologyEdges.GetTopologyVertices(PrevPairEdge).J == HalfEdges[i + 1].StartVertex)
-                        { HalfEdges[i + 1].PrevHalfEdge = PrevPairEdge * 2; }
+                        if (M.TopologyEdges.GetTopologyVertices(PrevPairEdge).J == Halfedges[i + 1].StartVertex)
+                        { Halfedges[i + 1].PrevHalfedge = PrevPairEdge * 2; }
                         else
-                        { HalfEdges[i + 1].PrevHalfEdge = PrevPairEdge * 2+1; }                     
+                        { Halfedges[i + 1].PrevHalfedge = PrevPairEdge * 2+1; }                     
                         break;
                     }                    
                 }
 
-                int[] StartNeighbours = M.TopologyVertices.ConnectedTopologyVertices(HalfEdges[i].StartVertex, true);
+                int[] StartNeighbours = M.TopologyVertices.ConnectedTopologyVertices(Halfedges[i].StartVertex, true);
                 for (int j = 0; j < StartNeighbours.Length; j++)
                 {
-                    if (StartNeighbours[j] == HalfEdges[i+1].StartVertex)
+                    if (StartNeighbours[j] == Halfedges[i+1].StartVertex)
                     {
-                        int EndOfNextOfPairHalfEdge = StartNeighbours[(j - 1 + StartNeighbours.Length) % StartNeighbours.Length];
-                        int StartOfPrevHalfEdge = StartNeighbours[(j + 1) % StartNeighbours.Length];
+                        int EndOfNextOfPairHalfedge = StartNeighbours[(j - 1 + StartNeighbours.Length) % StartNeighbours.Length];
+                        int StartOfPrevHalfedge = StartNeighbours[(j + 1) % StartNeighbours.Length];
 
-                        int NextPairEdge = M.TopologyEdges.GetEdgeIndex(HalfEdges[i].StartVertex, EndOfNextOfPairHalfEdge);
-                        int PrevEdge = M.TopologyEdges.GetEdgeIndex(HalfEdges[i].StartVertex, StartOfPrevHalfEdge);
+                        int NextPairEdge = M.TopologyEdges.GetEdgeIndex(Halfedges[i].StartVertex, EndOfNextOfPairHalfedge);
+                        int PrevEdge = M.TopologyEdges.GetEdgeIndex(Halfedges[i].StartVertex, StartOfPrevHalfedge);
 
-                        if (M.TopologyEdges.GetTopologyVertices(NextPairEdge).I == HalfEdges[i].StartVertex)
-                        { HalfEdges[i + 1].NextHalfEdge = NextPairEdge * 2; }
+                        if (M.TopologyEdges.GetTopologyVertices(NextPairEdge).I == Halfedges[i].StartVertex)
+                        { Halfedges[i + 1].NextHalfedge = NextPairEdge * 2; }
                         else
-                        { HalfEdges[i + 1].NextHalfEdge = NextPairEdge * 2 + 1; }
+                        { Halfedges[i + 1].NextHalfedge = NextPairEdge * 2 + 1; }
 
-                        if (M.TopologyEdges.GetTopologyVertices(PrevEdge).J == HalfEdges[i].StartVertex)
-                        { HalfEdges[i].PrevHalfEdge = PrevEdge * 2; }
+                        if (M.TopologyEdges.GetTopologyVertices(PrevEdge).J == Halfedges[i].StartVertex)
+                        { Halfedges[i].PrevHalfedge = PrevEdge * 2; }
                         else
-                        { HalfEdges[i].PrevHalfEdge = PrevEdge * 2 + 1; }
+                        { Halfedges[i].PrevHalfedge = PrevEdge * 2 + 1; }
                         break;
                     }
                 } 
@@ -208,7 +209,7 @@ public P_mesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
         public Mesh ToRhinoMesh()
         {
             // could add different options for triangulating ngons later
-            P_mesh P = this;
+            PlanktonMesh P = this;
             Mesh M = new Mesh();
             for (int i = 0; i < P.Vertices.Count; i++)
             {
@@ -258,13 +259,13 @@ public List<Polyline> ToPolylines()
        // {
        // }
 
-        public P_mesh Dual()
+        public PlanktonMesh Dual()
         {
             // can later add options for other ways of defining face centres (barycenter/circumcenter etc)
             // won't work yet with naked boundaries
 
-            P_mesh P = this;
-            P_mesh D = new P_mesh();
+            PlanktonMesh P = this;
+            PlanktonMesh D = new PlanktonMesh();
 
             //for every primal face, add the barycenter to the dual's vertex list
             //dual vertex outgoing HE is primal face's start HE
@@ -273,14 +274,14 @@ public P_mesh Dual()
 
             for (int i = 0; i < P.Faces.Count; i++)
             {                               
-                    D.Vertices.Add(new P_vertex(P.FaceCentroid(i)));                   
+                    D.Vertices.Add(new PlanktonVertex(P.FaceCentroid(i)));                   
                     List<int> FaceHalfedges = P.FaceHEs(i);
                     for (int j = 0; j < FaceHalfedges.Count; j++)
                     {
-                        if (P.HalfEdges[P.PairHalfEdge(FaceHalfedges[j])].AdjacentFace != -1)
+                        if (P.Halfedges[P.PairHalfedge(FaceHalfedges[j])].AdjacentFace != -1)
                         {
-                         // D.Vertices[i].OutgoingHalfEdge = FaceHalfedges[j];
-                            D.Vertices[D.Vertices.Count-1].OutgoingHalfEdge = P.PairHalfEdge(FaceHalfedges[j]);
+                         // D.Vertices[i].OutgoingHalfedge = FaceHalfedges[j];
+                            D.Vertices[D.Vertices.Count-1].OutgoingHalfedge = P.PairHalfedge(FaceHalfedges[j]);
                             break;
                         }
                     }                                   
@@ -290,9 +291,9 @@ public P_mesh Dual()
             {
                 if (P.VertexNakedEdgeCount(i) == 0)
                 {
-                    D.Faces.Add(new P_face());
-                 // D.Faces[i].FirstHalfEdge = P.PairHalfEdge(P.Vertices[i].OutgoingHalfEdge);
-                    D.Faces[D.Faces.Count-1].FirstHalfEdge = P.Vertices[i].OutgoingHalfEdge;
+                    D.Faces.Add(new PlanktonFace());
+                 // D.Faces[i].FirstHalfedge = P.PairHalfedge(P.Vertices[i].OutgoingHalfedge);
+                    D.Faces[D.Faces.Count-1].FirstHalfedge = P.Vertices[i].OutgoingHalfedge;
                 }   
             }
 
@@ -305,18 +306,18 @@ public P_mesh Dual()
 
             int newIndex = 0;
 
-            for (int i = 0; i < P.HalfEdges.Count; i++)
+            for (int i = 0; i < P.Halfedges.Count; i++)
             {
-                if ((P.HalfEdges[i].AdjacentFace != -1) & (P.HalfEdges[P.PairHalfEdge(i)].AdjacentFace != -1))
+                if ((P.Halfedges[i].AdjacentFace != -1) & (P.Halfedges[P.PairHalfedge(i)].AdjacentFace != -1))
                 {
-                    P_halfedge DualHE = new P_halfedge();                    
-                    P_halfedge PrimalHE = P.HalfEdges[i];
+                    PlanktonHalfedge DualHE = new PlanktonHalfedge();                    
+                    PlanktonHalfedge PrimalHE = P.Halfedges[i];
                     //DualHE.StartVertex = PrimalHE.AdjacentFace;
-                    DualHE.StartVertex = P.HalfEdges[P.PairHalfEdge(i)].AdjacentFace;
+                    DualHE.StartVertex = P.Halfedges[P.PairHalfedge(i)].AdjacentFace;
 
                     if (P.VertexNakedEdgeCount(PrimalHE.StartVertex) == 0)
                     {
-                        //DualHE.AdjacentFace = P.HalfEdges[P.PairHalfEdge(i)].StartVertex;
+                        //DualHE.AdjacentFace = P.Halfedges[P.PairHalfedge(i)].StartVertex;
                         DualHE.AdjacentFace = PrimalHE.StartVertex;
                     }
                     else { DualHE.AdjacentFace = -1; }
@@ -328,15 +329,15 @@ public P_mesh Dual()
                     //then go through and if any next or prevs are dead hes then replace them with the next one around
                     //this needs to be done repeatedly until no further change
 
-                    //DualHE.NextHalfEdge = P.HalfEdges[P.PairHalfEdge(i)].PrevHalfEdge;
-                    DualHE.NextHalfEdge = P.PairHalfEdge(PrimalHE.PrevHalfEdge);
+                    //DualHE.NextHalfedge = P.Halfedges[P.PairHalfedge(i)].PrevHalfedge;
+                    DualHE.NextHalfedge = P.PairHalfedge(PrimalHE.PrevHalfedge);
 
-                    //DualHE.PrevHalfEdge = P.PairHalfEdge(PrimalHE.NextHalfEdge);
-                    DualHE.PrevHalfEdge = P.HalfEdges[P.PairHalfEdge(i)].NextHalfEdge;
+                    //DualHE.PrevHalfedge = P.PairHalfedge(PrimalHE.NextHalfedge);
+                    DualHE.PrevHalfedge = P.Halfedges[P.PairHalfedge(i)].NextHalfedge;
 
                     DualHE.Index = newIndex;
 
-                    D.HalfEdges.Add(DualHE);
+                    D.Halfedges.Add(DualHE);
                     newIndex += 1;
                 }               
             }            
@@ -388,12 +389,12 @@ public List<int> VertexNeighbours(int V)
         //get the vertices connected to a given vertex by an edge (aka 1-ring)
         {
             List<int> NeighbourVs = new List<int>();
-            int FirstHalfEdge = PairHalfEdge(Vertices[V].OutgoingHalfEdge);
-            int CurrentHalfEdge = FirstHalfEdge;            
+            int FirstHalfedge = PairHalfedge(Vertices[V].OutgoingHalfedge);
+            int CurrentHalfedge = FirstHalfedge;            
             do{
-                NeighbourVs.Add(HalfEdges[CurrentHalfEdge].StartVertex);
-                CurrentHalfEdge = PairHalfEdge(HalfEdges[CurrentHalfEdge].NextHalfEdge);
-              } while (CurrentHalfEdge != FirstHalfEdge);             
+                NeighbourVs.Add(Halfedges[CurrentHalfedge].StartVertex);
+                CurrentHalfedge = PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
+              } while (CurrentHalfedge != FirstHalfedge);             
             return NeighbourVs;
         }
 
@@ -401,13 +402,13 @@ public List<int> VertexFaces(int V)
         // get the faces which use this vertex
         {
             List<int> NeighbourFs = new List<int>();            
-            int FirstHalfEdge = Vertices[V].OutgoingHalfEdge;
-            int CurrentHalfEdge = FirstHalfEdge;
+            int FirstHalfedge = Vertices[V].OutgoingHalfedge;
+            int CurrentHalfedge = FirstHalfedge;
             do
             {
-                NeighbourFs.Add(HalfEdges[CurrentHalfEdge].AdjacentFace);                
-                CurrentHalfEdge = HalfEdges[PairHalfEdge(CurrentHalfEdge)].NextHalfEdge;
-            } while (CurrentHalfEdge != FirstHalfEdge);            
+                NeighbourFs.Add(Halfedges[CurrentHalfedge].AdjacentFace);                
+                CurrentHalfedge = Halfedges[PairHalfedge(CurrentHalfedge)].NextHalfedge;
+            } while (CurrentHalfedge != FirstHalfedge);            
             return NeighbourFs;
         }
 
@@ -415,40 +416,40 @@ public List<int> VertexFaces(int V)
         public List<int> VertexAllOutHE(int V) // all the outgoing Halfedges from a vertex
         {
             List<int> OutHEs = new List<int>();
-            int FirstHalfEdge = Vertices[V].OutgoingHalfEdge;
-            int CurrentHalfEdge = FirstHalfEdge;
+            int FirstHalfedge = Vertices[V].OutgoingHalfedge;
+            int CurrentHalfedge = FirstHalfedge;
             do
             {
-                OutHEs.Add(CurrentHalfEdge);             
-                CurrentHalfEdge = HalfEdges[PairHalfEdge(CurrentHalfEdge)].NextHalfEdge;
-            } while (CurrentHalfEdge != FirstHalfEdge);
+                OutHEs.Add(CurrentHalfedge);             
+                CurrentHalfedge = Halfedges[PairHalfedge(CurrentHalfedge)].NextHalfedge;
+            } while (CurrentHalfedge != FirstHalfedge);
             return OutHEs;
         }
 
         public List<int> VertexAllInHE(int V) // all the incoming Halfedges to a vertex
         {
             List<int> InHEs = new List<int>();
-            int FirstHalfEdge = PairHalfEdge(Vertices[V].OutgoingHalfEdge);
-            int CurrentHalfEdge = FirstHalfEdge;
+            int FirstHalfedge = PairHalfedge(Vertices[V].OutgoingHalfedge);
+            int CurrentHalfedge = FirstHalfedge;
             do
             {
-                InHEs.Add(CurrentHalfEdge);
-                CurrentHalfEdge = PairHalfEdge(HalfEdges[CurrentHalfEdge].NextHalfEdge);
-            } while (CurrentHalfEdge != FirstHalfEdge);
+                InHEs.Add(CurrentHalfedge);
+                CurrentHalfedge = PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
+            } while (CurrentHalfedge != FirstHalfedge);
             return InHEs;
         }
 
         public List<int> FaceHEs(int F)
         {
             List<int> HEs = new List<int>();
-            int FirstHalfEdge = Faces[F].FirstHalfEdge;
-            int CurrentHalfEdge = FirstHalfEdge;
+            int FirstHalfedge = Faces[F].FirstHalfedge;
+            int CurrentHalfedge = FirstHalfedge;
             do
             {
-                HEs.Add(CurrentHalfEdge);
-                CurrentHalfEdge = HalfEdges[CurrentHalfEdge].NextHalfEdge;
+                HEs.Add(CurrentHalfedge);
+                CurrentHalfedge = Halfedges[CurrentHalfedge].NextHalfedge;
             }
-            while (CurrentHalfEdge != FirstHalfEdge);
+            while (CurrentHalfedge != FirstHalfedge);
             return HEs;
         }
 
@@ -456,14 +457,14 @@ public List<int> FaceVertices(int F)
         //get the vertices making up a face
         {
             List<int> FaceVs = new List<int>();
-            int FirstHalfEdge = Faces[F].FirstHalfEdge;
-            int CurrentHalfEdge = FirstHalfEdge;
+            int FirstHalfedge = Faces[F].FirstHalfedge;
+            int CurrentHalfedge = FirstHalfedge;
             do
             {
-                FaceVs.Add(HalfEdges[CurrentHalfEdge].StartVertex);
-                CurrentHalfEdge = HalfEdges[CurrentHalfEdge].NextHalfEdge;
+                FaceVs.Add(Halfedges[CurrentHalfedge].StartVertex);
+                CurrentHalfedge = Halfedges[CurrentHalfedge].NextHalfedge;
             }
-            while (CurrentHalfEdge != FirstHalfEdge);
+            while (CurrentHalfedge != FirstHalfedge);
             return FaceVs;
         }
 
@@ -480,7 +481,7 @@ public Point3d FaceCentroid(int F)
             return Centroid;
         }
 
-        public int PairHalfEdge(int I)
+        public int PairHalfedge(int I)
         {
             if (I % 2 == 0)
             { return I + 1; }
@@ -488,9 +489,9 @@ public int PairHalfEdge(int I)
             { return I - 1; }
         }
 
-        public int IncomingHalfEdge(int I)
+        public int IncomingHalfedge(int I)
         {
-            return PairHalfEdge(Vertices[I].OutgoingHalfEdge);
+            return PairHalfedge(Vertices[I].OutgoingHalfedge);
         }
 
         public int VertexNakedEdgeCount(int V)
@@ -502,8 +503,8 @@ public int VertexNakedEdgeCount(int V)
             List<int> Outgoing = VertexAllOutHE(V);
             for (int i = 0; i < Outgoing.Count; i++)
             {
-                if (HalfEdges[Outgoing[i]].AdjacentFace == -1) { NakedCount++; }
-                if (HalfEdges[PairHalfEdge(Outgoing[i])].AdjacentFace == -1) { NakedCount++; }
+                if (Halfedges[Outgoing[i]].AdjacentFace == -1) { NakedCount++; }
+                if (Halfedges[PairHalfedge(Outgoing[i])].AdjacentFace == -1) { NakedCount++; }
             }
             return NakedCount;
         }
@@ -514,80 +515,11 @@ public int FaceNakedEdgeCount(int F)
             List<int> FaceHEdges = FaceHEs(F);
             foreach (int i in FaceHEdges)
             {
-                if (HalfEdges[PairHalfEdge(i)].AdjacentFace == -1) { NakedCount++; }
+                if (Halfedges[PairHalfedge(i)].AdjacentFace == -1) { NakedCount++; }
             }
             return NakedCount;
         }
 
         #endregion
-
-    }
-    public class P_vertex
-    {
-        public Point3d Position;
-        public int OutgoingHalfEdge;
-        //       
-        public bool Dead;
-        public Vector3d Normal;
-        public P_vertex()
-        {
-            OutgoingHalfEdge = -1;
-        }
-        public P_vertex(Point3f V)
-        {
-            Position = (Point3d)V;
-            OutgoingHalfEdge = -1;
-        }
-        public P_vertex(Point3d V)
-        {
-            Position = V;
-            OutgoingHalfEdge = -1;
-        }
     }
-    public class P_halfedge
-    {
-        //primary properties - the minimum ones needed for the halfedge structure
-        public int StartVertex;
-        public int AdjacentFace;
-        public int NextHalfEdge;
-        //secondary properties - these should still be kept updated if you change the topology
-        public int PrevHalfEdge;
-        public int Index;
-        //tertiary properties - less vital, calculate or refresh only as needed
-        public Vector3d Normal;
-
-        public P_halfedge()
-        {
-            StartVertex = -1;
-            AdjacentFace = -1;
-            NextHalfEdge = -1;
-            PrevHalfEdge = -1;
-        }
-        public P_halfedge(int Start, int AdjFace, int Next)
-        {
-            StartVertex = Start;
-            AdjacentFace = AdjFace;
-            NextHalfEdge = Next;
-        }
-        public int Pair()
-        {
-            if (Index % 2 == 0)
-            { return Index + 1; }
-            else
-            { return Index - 1; }
-        }
-
-    }
-    public class P_face
-    {
-        public int FirstHalfEdge;
-        //
-        public int EdgeCount;
-        public Vector3d Normal;
-        public double Area;
-        public P_face()
-        {
-            FirstHalfEdge = -1;
-        }
-    }   
 }
diff --git a/Plankton/PlanktonVertex.cs b/Plankton/PlanktonVertex.cs
new file mode 100644
index 0000000..756e2fa
--- /dev/null
+++ b/Plankton/PlanktonVertex.cs
@@ -0,0 +1,31 @@
+using Rhino.Geometry;
+using System;
+
+namespace Plankton
+{
+    /// <summary>
+    /// Description of PlanktonVertex.
+    /// </summary>
+    public class PlanktonVertex
+    {
+        public Point3d Position;
+        public int OutgoingHalfedge;
+        //       
+        public bool Dead;
+        public Vector3d Normal;
+        public PlanktonVertex()
+        {
+            OutgoingHalfedge = -1;
+        }
+        public PlanktonVertex(Point3f V)
+        {
+            Position = (Point3d)V;
+            OutgoingHalfedge = -1;
+        }
+        public PlanktonVertex(Point3d V)
+        {
+            Position = V;
+            OutgoingHalfedge = -1;
+        }
+    }
+}
diff --git a/PlanktonGh/DecomposePlankton.cs b/PlanktonGh/DecomposePlankton.cs
index e12bbf6..3ac2a36 100644
--- a/PlanktonGh/DecomposePlankton.cs
+++ b/PlanktonGh/DecomposePlankton.cs
@@ -34,12 +34,12 @@ protected override void RegisterOutputParams(GH_Component.GH_OutputParamManager
         {
             pManager.Register_PointParam("Vertex_Points", "V", "Vertex point positions", GH_ParamAccess.list);
             pManager.Register_IntegerParam("Vertex_Outgoing_Halfedge", "V_He", "One of the outgoing halfedges for each vertex", GH_ParamAccess.list);
-            pManager.Register_IntegerParam("HalfEdge_StartVertex", "He_V", "The starting vertex of each halfedge", GH_ParamAccess.list);
-            pManager.Register_IntegerParam("HalfEdge_AdjacentFace", "He_F", "The face bordered by each halfedge (or -1 if it is adjacent to a boundary)", GH_ParamAccess.list);
-            pManager.Register_IntegerParam("HalfEdge_NextHalfEdge", "He_Nxt", "The next halfedge around the same face", GH_ParamAccess.list);
-            pManager.Register_IntegerParam("HalfEdge_PrevHalfEdge", "He_Prv", "The previous halfedge around the same face", GH_ParamAccess.list);
-            pManager.Register_IntegerParam("HalfEdge_Pair", "He_P", "The halfedge joining the same 2 vertices in the opposite direction", GH_ParamAccess.list);
-            pManager.Register_IntegerParam("Face_HalfEdge", "F_He", "The first halfedge of each face", GH_ParamAccess.list);              
+            pManager.Register_IntegerParam("Halfedge_StartVertex", "He_V", "The starting vertex of each halfedge", GH_ParamAccess.list);
+            pManager.Register_IntegerParam("Halfedge_AdjacentFace", "He_F", "The face bordered by each halfedge (or -1 if it is adjacent to a boundary)", GH_ParamAccess.list);
+            pManager.Register_IntegerParam("Halfedge_NextHalfedge", "He_Nxt", "The next halfedge around the same face", GH_ParamAccess.list);
+            pManager.Register_IntegerParam("Halfedge_PrevHalfedge", "He_Prv", "The previous halfedge around the same face", GH_ParamAccess.list);
+            pManager.Register_IntegerParam("Halfedge_Pair", "He_P", "The halfedge joining the same 2 vertices in the opposite direction", GH_ParamAccess.list);
+            pManager.Register_IntegerParam("Face_Halfedge", "F_He", "The first halfedge of each face", GH_ParamAccess.list);              
         }
 
         /// <summary>
@@ -48,8 +48,8 @@ protected override void RegisterOutputParams(GH_Component.GH_OutputParamManager
         /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
         protected override void SolveInstance(IGH_DataAccess DA)
         {
-            P_mesh P = new P_mesh();
-            if (!DA.GetData<P_mesh>(0, ref P)) return;
+            PlanktonMesh P = new PlanktonMesh();
+            if (!DA.GetData<PlanktonMesh>(0, ref P)) return;
 
             List<Point3d> Positions = new List<Point3d>();
             List<int> OutHEdge = new List<int>();
@@ -57,7 +57,7 @@ protected override void SolveInstance(IGH_DataAccess DA)
             for (int i = 0; i < P.Vertices.Count; i++)
             {
                 Positions.Add(P.Vertices[i].Position);
-                OutHEdge.Add(P.Vertices[i].OutgoingHalfEdge);
+                OutHEdge.Add(P.Vertices[i].OutgoingHalfedge);
             }
            
             List<int> StartV = new List<int>();
@@ -66,19 +66,19 @@ protected override void SolveInstance(IGH_DataAccess DA)
             List<int> Prev = new List<int>();
             List<int> Pair = new List<int>();
 
-            for (int i = 0; i < P.HalfEdges.Count; i++)
+            for (int i = 0; i < P.Halfedges.Count; i++)
             {
-                StartV.Add(P.HalfEdges[i].StartVertex);
-                AdjF.Add(P.HalfEdges[i].AdjacentFace);
-                Next.Add(P.HalfEdges[i].NextHalfEdge);
-                Prev.Add(P.HalfEdges[i].PrevHalfEdge);
-                Pair.Add(P.PairHalfEdge(i));
+                StartV.Add(P.Halfedges[i].StartVertex);
+                AdjF.Add(P.Halfedges[i].AdjacentFace);
+                Next.Add(P.Halfedges[i].NextHalfedge);
+                Prev.Add(P.Halfedges[i].PrevHalfedge);
+                Pair.Add(P.PairHalfedge(i));
             }
      
             List<int> FaceEdge = new List<int>();
             for (int i = 0; i < P.Faces.Count; i++)
             {
-                FaceEdge.Add(P.Faces[i].FirstHalfEdge);
+                FaceEdge.Add(P.Faces[i].FirstHalfedge);
             }
 
             DA.SetDataList(0, Positions);
diff --git a/PlanktonGh/GHMeshToPMesh.cs b/PlanktonGh/GHMeshToPMesh.cs
index 9aeb235..c57c0b9 100644
--- a/PlanktonGh/GHMeshToPMesh.cs
+++ b/PlanktonGh/GHMeshToPMesh.cs
@@ -52,9 +52,9 @@ protected override void SolveInstance(IGH_DataAccess DA)
             Mesh M = new Mesh();          
             if (!DA.GetData(0, ref M)) return;
 
-            P_mesh PlanktonMesh = new P_mesh(M);
+            PlanktonMesh pMesh = new PlanktonMesh(M);
 
-            DA.SetData(0, PlanktonMesh);
+            DA.SetData(0, pMesh);
         }
 
         /// <summary>

From 6cbe0d6d3f6d8b169c16219e8f850ecfcdcfc20e Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Mon, 22 Jul 2013 10:45:16 +0100
Subject: [PATCH 03/20] Tidy up (whitespace changes only)

Just tidied up PlanktonMesh.cs (well, SharpDevelop did...) while I was working on it. Figured I should commit the whitespace changes first to avoid muddying the waters in the next commit.
---
 Plankton/PlanktonMesh.cs | 108 +++++++++++++++++++--------------------
 1 file changed, 54 insertions(+), 54 deletions(-)

diff --git a/Plankton/PlanktonMesh.cs b/Plankton/PlanktonMesh.cs
index 471d90a..6ac9bdf 100644
--- a/Plankton/PlanktonMesh.cs
+++ b/Plankton/PlanktonMesh.cs
@@ -11,7 +11,7 @@ public class PlanktonMesh
     {
         #region "members"
         public List<PlanktonVertex> Vertices;
-        public List<PlanktonHalfedge> Halfedges;        
+        public List<PlanktonHalfedge> Halfedges;
         public List<PlanktonFace> Faces;
         #endregion
 
@@ -28,8 +28,8 @@ public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
             M.Vertices.CombineIdentical(true, true);
             M.Vertices.CullUnused();
             M.UnifyNormals();
-            M.Weld(Math.PI);            
-
+            M.Weld(Math.PI);
+            
             this.Faces = new List<PlanktonFace>();
             this.Halfedges = new List<PlanktonHalfedge>();
             this.Vertices = new List<PlanktonVertex>();
@@ -38,7 +38,7 @@ public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
             {
                 Vertices.Add(new PlanktonVertex(M.TopologyVertices[i]));
             }
-          
+            
             for (int i = 0; i < M.Faces.Count; i++)
             {Faces.Add(new PlanktonFace()); }
 
@@ -80,33 +80,33 @@ public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
 
                 if ((VertA == M.TopologyEdges.GetTopologyVertices(i).I)
                     && (VertB == M.TopologyEdges.GetTopologyVertices(i).J))
-                { Match[0] = true;                   
+                { Match[0] = true;
                 }
                 if ((VertB == M.TopologyEdges.GetTopologyVertices(i).I)
                     && (VertC == M.TopologyEdges.GetTopologyVertices(i).J))
                 {
-                    Match[0] = true;                    
+                    Match[0] = true;
                 }
                 if ((VertC == M.TopologyEdges.GetTopologyVertices(i).I)
                     && (VertD == M.TopologyEdges.GetTopologyVertices(i).J))
                 {
-                    Match[0] = true;                    
+                    Match[0] = true;
                 }
                 if ((VertD == M.TopologyEdges.GetTopologyVertices(i).I)
-                   && (VertA == M.TopologyEdges.GetTopologyVertices(i).J))
+                    && (VertA == M.TopologyEdges.GetTopologyVertices(i).J))
                 {
-                    Match[0] = true;                    
+                    Match[0] = true;
                 }
                 //I don't think these next 2 should ever be needed, but just in case:
                 if ((VertC == M.TopologyEdges.GetTopologyVertices(i).I)
-                   && (VertA == M.TopologyEdges.GetTopologyVertices(i).J))
+                    && (VertA == M.TopologyEdges.GetTopologyVertices(i).J))
                 {
-                    Match[0] = true;                    
+                    Match[0] = true;
                 }
                 if ((VertB == M.TopologyEdges.GetTopologyVertices(i).I)
                     && (VertD == M.TopologyEdges.GetTopologyVertices(i).J))
                 {
-                    Match[0] = true;                    
+                    Match[0] = true;
                 }
                 
                 if (Match[0] == true)
@@ -159,7 +159,7 @@ public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
                     {
                         int EndOfNextHalfedge = EndNeighbours[(j - 1 + EndNeighbours.Length) % EndNeighbours.Length];
                         int StartOfPrevOfPairHalfedge = EndNeighbours[(j + 1) % EndNeighbours.Length];
-                       
+                        
                         int NextEdge = M.TopologyEdges.GetEdgeIndex(Halfedges[i + 1].StartVertex,EndOfNextHalfedge);
                         int PrevPairEdge = M.TopologyEdges.GetEdgeIndex(Halfedges[i + 1].StartVertex,StartOfPrevOfPairHalfedge);
 
@@ -171,9 +171,9 @@ public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
                         if (M.TopologyEdges.GetTopologyVertices(PrevPairEdge).J == Halfedges[i + 1].StartVertex)
                         { Halfedges[i + 1].PrevHalfedge = PrevPairEdge * 2; }
                         else
-                        { Halfedges[i + 1].PrevHalfedge = PrevPairEdge * 2+1; }                     
+                        { Halfedges[i + 1].PrevHalfedge = PrevPairEdge * 2+1; }
                         break;
-                    }                    
+                    }
                 }
 
                 int[] StartNeighbours = M.TopologyVertices.ConnectedTopologyVertices(Halfedges[i].StartVertex, true);
@@ -198,10 +198,10 @@ public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
                         { Halfedges[i].PrevHalfedge = PrevEdge * 2 + 1; }
                         break;
                     }
-                } 
-            }            
+                }
+            }
         }
-
+        
         #endregion
 
         #region "general methods"
@@ -254,10 +254,10 @@ public List<Polyline> ToPolylines()
             return Polylines;
         }
 
-       // public void ReIndex() //clear away all the dead elements to save space      
-       // //maybe it is better to just create a fresh one rather than trying to shuffle the existing
-       // {
-       // }
+        // public void ReIndex() //clear away all the dead elements to save space
+        // //maybe it is better to just create a fresh one rather than trying to shuffle the existing
+        // {
+        // }
 
         public PlanktonMesh Dual()
         {
@@ -273,18 +273,18 @@ public PlanktonMesh Dual()
             //dual face's startHE is primal vertex's outgoing's pair
 
             for (int i = 0; i < P.Faces.Count; i++)
-            {                               
-                    D.Vertices.Add(new PlanktonVertex(P.FaceCentroid(i)));                   
-                    List<int> FaceHalfedges = P.FaceHEs(i);
-                    for (int j = 0; j < FaceHalfedges.Count; j++)
+            {
+                D.Vertices.Add(new PlanktonVertex(P.FaceCentroid(i)));
+                List<int> FaceHalfedges = P.FaceHEs(i);
+                for (int j = 0; j < FaceHalfedges.Count; j++)
+                {
+                    if (P.Halfedges[P.PairHalfedge(FaceHalfedges[j])].AdjacentFace != -1)
                     {
-                        if (P.Halfedges[P.PairHalfedge(FaceHalfedges[j])].AdjacentFace != -1)
-                        {
-                         // D.Vertices[i].OutgoingHalfedge = FaceHalfedges[j];
-                            D.Vertices[D.Vertices.Count-1].OutgoingHalfedge = P.PairHalfedge(FaceHalfedges[j]);
-                            break;
-                        }
-                    }                                   
+                        // D.Vertices[i].OutgoingHalfedge = FaceHalfedges[j];
+                        D.Vertices[D.Vertices.Count-1].OutgoingHalfedge = P.PairHalfedge(FaceHalfedges[j]);
+                        break;
+                    }
+                }
             }
 
             for (int i = 0; i < P.Vertices.Count; i++)
@@ -292,13 +292,13 @@ public PlanktonMesh Dual()
                 if (P.VertexNakedEdgeCount(i) == 0)
                 {
                     D.Faces.Add(new PlanktonFace());
-                 // D.Faces[i].FirstHalfedge = P.PairHalfedge(P.Vertices[i].OutgoingHalfedge);
+                    // D.Faces[i].FirstHalfedge = P.PairHalfedge(P.Vertices[i].OutgoingHalfedge);
                     D.Faces[D.Faces.Count-1].FirstHalfedge = P.Vertices[i].OutgoingHalfedge;
-                }   
+                }
             }
 
             // dual halfedge start V is primal AdjacentFace
-            // dual halfedge AdjacentFace is primal end V            
+            // dual halfedge AdjacentFace is primal end V
             // dual nextHE is primal's pair's prev
             // dual prevHE is primal's next's pair
 
@@ -310,7 +310,7 @@ public PlanktonMesh Dual()
             {
                 if ((P.Halfedges[i].AdjacentFace != -1) & (P.Halfedges[P.PairHalfedge(i)].AdjacentFace != -1))
                 {
-                    PlanktonHalfedge DualHE = new PlanktonHalfedge();                    
+                    PlanktonHalfedge DualHE = new PlanktonHalfedge();
                     PlanktonHalfedge PrimalHE = P.Halfedges[i];
                     //DualHE.StartVertex = PrimalHE.AdjacentFace;
                     DualHE.StartVertex = P.Halfedges[P.PairHalfedge(i)].AdjacentFace;
@@ -321,7 +321,7 @@ public PlanktonMesh Dual()
                         DualHE.AdjacentFace = PrimalHE.StartVertex;
                     }
                     else { DualHE.AdjacentFace = -1; }
-                                   
+                    
                     //This will currently fail with open meshes...
                     //one option could be to build the dual with all halfedges, but mark some as dead
                     //if they connect to vertex -1
@@ -339,8 +339,8 @@ public PlanktonMesh Dual()
 
                     D.Halfedges.Add(DualHE);
                     newIndex += 1;
-                }               
-            }            
+                }
+            }
             return D;
         }
 
@@ -379,36 +379,36 @@ public void RefreshEdgeNormals()
         //dihedral angle for an edge
         //
 
-        //skeletonize - build a new mesh with 4 faces for each original edge        
+        //skeletonize - build a new mesh with 4 faces for each original edge
 
         #endregion
 
         #region "Adjacencies"
         
         public List<int> VertexNeighbours(int V)
-        //get the vertices connected to a given vertex by an edge (aka 1-ring)
+            //get the vertices connected to a given vertex by an edge (aka 1-ring)
         {
             List<int> NeighbourVs = new List<int>();
             int FirstHalfedge = PairHalfedge(Vertices[V].OutgoingHalfedge);
-            int CurrentHalfedge = FirstHalfedge;            
+            int CurrentHalfedge = FirstHalfedge;
             do{
                 NeighbourVs.Add(Halfedges[CurrentHalfedge].StartVertex);
                 CurrentHalfedge = PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
-              } while (CurrentHalfedge != FirstHalfedge);             
+            } while (CurrentHalfedge != FirstHalfedge);
             return NeighbourVs;
         }
 
         public List<int> VertexFaces(int V)
-        // get the faces which use this vertex
+            // get the faces which use this vertex
         {
-            List<int> NeighbourFs = new List<int>();            
+            List<int> NeighbourFs = new List<int>();
             int FirstHalfedge = Vertices[V].OutgoingHalfedge;
             int CurrentHalfedge = FirstHalfedge;
             do
             {
-                NeighbourFs.Add(Halfedges[CurrentHalfedge].AdjacentFace);                
+                NeighbourFs.Add(Halfedges[CurrentHalfedge].AdjacentFace);
                 CurrentHalfedge = Halfedges[PairHalfedge(CurrentHalfedge)].NextHalfedge;
-            } while (CurrentHalfedge != FirstHalfedge);            
+            } while (CurrentHalfedge != FirstHalfedge);
             return NeighbourFs;
         }
 
@@ -420,7 +420,7 @@ public List<int> VertexAllOutHE(int V) // all the outgoing Halfedges from a vert
             int CurrentHalfedge = FirstHalfedge;
             do
             {
-                OutHEs.Add(CurrentHalfedge);             
+                OutHEs.Add(CurrentHalfedge);
                 CurrentHalfedge = Halfedges[PairHalfedge(CurrentHalfedge)].NextHalfedge;
             } while (CurrentHalfedge != FirstHalfedge);
             return OutHEs;
@@ -454,7 +454,7 @@ public List<int> FaceHEs(int F)
         }
 
         public List<int> FaceVertices(int F)
-        //get the vertices making up a face
+            //get the vertices making up a face
         {
             List<int> FaceVs = new List<int>();
             int FirstHalfedge = Faces[F].FirstHalfedge;
@@ -469,7 +469,7 @@ public List<int> FaceVertices(int F)
         }
 
         public Point3d FaceCentroid(int F)
-        //the barycenter of a face's vertices
+            //the barycenter of a face's vertices
         {
             List<int> FaceVs = FaceVertices(F);
             Point3d Centroid = new Point3d(0, 0, 0);
@@ -495,9 +495,9 @@ public int IncomingHalfedge(int I)
         }
 
         public int VertexNakedEdgeCount(int V)
-        //the number of connected halfedges which are naked
-        //(this should also be the number of naked connected actual *edges*
-        // - because if the hemesh is good then there should never be a pair of 2 boundary halfedges)
+            //the number of connected halfedges which are naked
+            //(this should also be the number of naked connected actual *edges*
+            // - because if the hemesh is good then there should never be a pair of 2 boundary halfedges)
         {
             int NakedCount = 0;
             List<int> Outgoing = VertexAllOutHE(V);

From 4450d32996a830f05c36c96188cf1c0c780fbf65 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Mon, 22 Jul 2013 11:24:34 +0100
Subject: [PATCH 04/20] Create PlanktonMesh from face-vertex representation

* new AddFace method follows the process described in OpenMesh's PolyConnectivity class
* Handles creation of any missing halfedge pairs and ensures halfedge data structure (HDS) is always correctly linked (next/prev/etc.)
---
 Plankton/PlanktonMesh.cs | 156 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 152 insertions(+), 4 deletions(-)

diff --git a/Plankton/PlanktonMesh.cs b/Plankton/PlanktonMesh.cs
index 6ac9bdf..12e8a14 100644
--- a/Plankton/PlanktonMesh.cs
+++ b/Plankton/PlanktonMesh.cs
@@ -1,6 +1,7 @@
 using Rhino.Geometry;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Plankton
 {
@@ -23,16 +24,13 @@ public PlanktonMesh() //blank constructor
             this.Vertices = new List<PlanktonVertex>();
         }
         public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
+            : this()
         {
 
             M.Vertices.CombineIdentical(true, true);
             M.Vertices.CullUnused();
             M.UnifyNormals();
             M.Weld(Math.PI);
-            
-            this.Faces = new List<PlanktonFace>();
-            this.Halfedges = new List<PlanktonHalfedge>();
-            this.Vertices = new List<PlanktonVertex>();
 
             for (int i = 0; i < M.Vertices.Count; i++)
             {
@@ -202,9 +200,159 @@ public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
             }
         }
         
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PlanktonMesh"/> class.
+        /// Constructs a new halfedge mesh using the face-vertex representation of another mesh.
+        /// </summary>
+        /// <param name="pts">A list of cartesian coordinates.</param>
+        /// <param name="faces">A list faces, described by the indices of their vertices
+        /// (ordered anticlockwise around the face).</param>
+        public PlanktonMesh(IEnumerable<Point3d> pts, IEnumerable<IEnumerable<int>> faces)
+            : this()
+        {
+            // Add vertices
+            foreach (Point3d pt in pts)
+            {
+                this.Vertices.Add(new PlanktonVertex(pt));
+            }
+            
+            // Add faces (and half-edges)
+            foreach (IEnumerable<int> face in faces)
+            {
+                this.AddFace(face);
+            }
+        }
         #endregion
 
         #region "general methods"
+        /// <summary>
+        /// Adds a new face to the mesh. Creates any halfedge pairs that are required.
+        /// </summary>
+        /// <param name="indices">The indices of the vertices which define this face, ordered anticlockwise.</param>
+        /// <returns>The index of the newly added face.</returns>
+        public int AddFace(IEnumerable<int> indices)
+        {
+            // This method always ensures that if a vertex lies on a boundary,
+            // vertex -> outgoingHalfedge -> adjacentFace == -1
+            
+            int[] array = indices.ToArray(); // using Linq for convenience
+            
+            int n = array.Length;
+            
+            // Don't allow degenerate faces
+            if (n < 3) return -1;
+            
+            // Check vertices
+            foreach (int i in array)
+            {
+                // Check that all vertex indices exist in this mesh
+                if (i < 0 || i >= this.Vertices.Count)
+                    throw new IndexOutOfRangeException("No vertex exists at this index.");
+                // Check that all vertices are on a boundary
+                int outgoing = this.Vertices[i].OutgoingHalfedge;
+                if (outgoing != -1 && this.Halfedges[outgoing].AdjacentFace != -1)
+                    return -1;
+            }
+            
+            // For each pair of vertices, check for an existing halfedge
+            // If it exists, check that it doesn't already have a face
+            // If it doesn't exist, mark for creation of a new halfedge pair
+            int[] loop = new int[n];
+            bool[] is_new = new bool[n];
+            List<int> newHalfedges = new List<int>();
+            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
+            {
+                int v1 = array[i], v2 = array[ii];
+                is_new[i] = true;
+                // Find existing edge, if it exists, by searching 'i'th vertex's neighbourhood
+                if (this.Vertices[v2].OutgoingHalfedge > -1)
+                {
+                    List<int> hs = this.VertexAllOutHE(v2);
+                    foreach (int h in hs)
+                    {
+                        if (v1 == this.Halfedges[this.PairHalfedge(h)].StartVertex)
+                        {
+                            // Don't allow non-manifold edges
+                            if (this.Halfedges[this.PairHalfedge(h)].AdjacentFace > -1) return -1;
+                            loop[i] = this.PairHalfedge(h);
+                            is_new[i] = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            // Now create any missing halfedge pairs...
+            // (This could be done in the loop above but it avoids having to tidy up
+            // any recently added halfedges should a non-manifold condition be found.)
+            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
+            {
+                if (is_new[i]) // new halfedge pair requireds
+                {
+                    int v1 = array[i], v2 = array[ii];
+                    loop[i] = this.Halfedges.Count;
+                    is_new[i] = true;
+                    // he->next = he->pair
+                    this.Halfedges.Add(new PlanktonHalfedge(v1, this.Faces.Count, loop[i] + 1));
+                    this.Halfedges.Add(new PlanktonHalfedge(v2, -1, loop[i]));
+                    this.Vertices[v2].OutgoingHalfedge = loop[i] + 1;
+                }
+                else
+                {
+                    // Link existing halfedge to new face
+                    this.Halfedges[loop[i]].AdjacentFace = this.Faces.Count;
+                }
+            }
+            
+            // Link halfedges
+            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
+            {
+                int v1 = array[i], v2 = array[ii];
+                int id = 0;
+                if (is_new[i])  id += 1;
+                if (is_new[ii]) id += 2;
+                
+                if (id > 0) // At least one of the halfedge pairs is new...
+                {
+                    // Link inner halfedges
+                    this.Halfedges[loop[i]].NextHalfedge = loop[ii];
+                    this.Halfedges[loop[ii]].PrevHalfedge = loop[i];
+                    
+                    // Link outer halfedges
+                    int firstHalfedge, currentHalfedge;
+                    switch (id)
+                    {
+                        case 1: // first is new, second is old
+                            
+                            firstHalfedge = loop[ii];
+                            currentHalfedge = firstHalfedge;
+                            do
+                            {
+                                int pair = PairHalfedge(currentHalfedge);
+                                currentHalfedge = this.Halfedges[pair].NextHalfedge;
+                            } while (this.Halfedges[PairHalfedge(currentHalfedge)].AdjacentFace > -1);
+                            this.Halfedges[PairHalfedge(currentHalfedge)].NextHalfedge = PairHalfedge(loop[i]);
+                            this.Halfedges[PairHalfedge(loop[i])].PrevHalfedge = PairHalfedge(currentHalfedge);
+                            break;
+                        case 2: // second is new, first is old
+                            int outer_next = this.Vertices[v2].OutgoingHalfedge;
+                            this.Halfedges[PairHalfedge(loop[ii])].NextHalfedge = outer_next;
+                            this.Halfedges[outer_next].PrevHalfedge = PairHalfedge(loop[ii]);
+                            break;
+                        case 3: // both are new
+                            this.Halfedges[PairHalfedge(loop[ii])].NextHalfedge = PairHalfedge(loop[i]);
+                            this.Halfedges[PairHalfedge(loop[i])].PrevHalfedge = PairHalfedge(loop[ii]);
+                            break;
+                    }
+                }
+            }
+            
+            int f = this.Faces.Count;
+            this.Faces.Add(new PlanktonFace());
+            this.Faces[f].FirstHalfedge = loop[n - 1];
+            
+            return f;
+        }
 
         public Mesh ToRhinoMesh()
         {

From 92ca33477e2e0521655602032877a4ceca4a68e8 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Mon, 22 Jul 2013 11:33:18 +0100
Subject: [PATCH 05/20] Add test project

---
 Plankton.Test/MeshTest.cs                | 75 ++++++++++++++++++++++++
 Plankton.Test/Plankton.Test.csproj       | 60 +++++++++++++++++++
 Plankton.Test/Properties/AssemblyInfo.cs | 31 ++++++++++
 3 files changed, 166 insertions(+)
 create mode 100644 Plankton.Test/MeshTest.cs
 create mode 100644 Plankton.Test/Plankton.Test.csproj
 create mode 100644 Plankton.Test/Properties/AssemblyInfo.cs

diff --git a/Plankton.Test/MeshTest.cs b/Plankton.Test/MeshTest.cs
new file mode 100644
index 0000000..a9b5511
--- /dev/null
+++ b/Plankton.Test/MeshTest.cs
@@ -0,0 +1,75 @@
+using Plankton;
+using NUnit.Framework;
+using Rhino.Geometry;
+using System;
+using System.Collections.Generic;
+
+namespace Plankton.Test
+{
+    [TestFixture]
+    public class MeshTest
+    {
+        [Test]
+        public void CanCreateFromFaceVertex()
+        {
+            // Create a simple cube
+            
+            var pts = new Point3d[]
+            {
+                new Point3d(-0.5, -0.5, 0.5),
+                new Point3d(-0.5, -0.5, -0.5),
+                new Point3d(-0.5, 0.5, -0.5),
+                new Point3d(-0.5, 0.5, 0.5),
+                new Point3d(0.5, -0.5, 0.5),
+                new Point3d(0.5, -0.5, -0.5),
+                new Point3d(0.5, 0.5, -0.5),
+                new Point3d(0.5, 0.5, 0.5)
+            };
+            
+            var fs = new int[][]
+            {
+                new int[]{ 3, 2, 1, 0 },
+                new int[]{ 1, 5, 4, 0 },
+                new int[]{ 2, 6, 5, 1 },
+                new int[]{ 7, 6, 2, 3 },
+                new int[]{ 4, 7, 3, 0 },
+                new int[]{ 5, 6, 7, 4 }
+            };
+            
+            // Create a PlanktonMesh from the points and face-vertex indices
+            
+            PlanktonMesh pMesh = new PlanktonMesh(pts, fs);
+            
+            Assert.AreEqual(24, pMesh.Halfedges.Count);
+            
+            // Check that half-edges have been linked up correctly
+            
+            // Get all outgoing halfedges from vertex #0 and compare against expected
+            List<int> vertexZeroHalfedges = pMesh.VertexAllOutHE(0);
+            int[] vertexZeroHalfedgesExpected = new int[]{ 13, 5, 6 };
+            Assert.AreEqual(3, vertexZeroHalfedges.Count);
+            foreach (int halfedge in vertexZeroHalfedgesExpected)
+            {
+                Assert.Contains(halfedge, vertexZeroHalfedges);
+            }
+            
+            // Get all halfedges from face #2 and compare against expected
+            List<int> faceTwoHalfedges = pMesh.FaceHEs(2);
+            int[] faceTwoHalfedgesExpected = new int[]{ 14, 16, 9, 3 };
+            Assert.AreEqual(4, faceTwoHalfedges.Count);
+            foreach (int halfedge in faceTwoHalfedgesExpected)
+            {
+                Assert.Contains(halfedge, faceTwoHalfedges);
+            }
+            
+            // Get all faces from vertex #1 and compare against expected
+            List<int> vertexOneFaces = pMesh.VertexFaces(1);
+            int[] vertexOneFacesExpected = new int[]{ 0, 1, 2 };
+            Assert.AreEqual(3, vertexOneFaces.Count);
+            foreach (int face in vertexOneFacesExpected)
+            {
+                Assert.Contains(face, vertexOneFaces);
+            }
+        }
+    }
+}
diff --git a/Plankton.Test/Plankton.Test.csproj b/Plankton.Test/Plankton.Test.csproj
new file mode 100644
index 0000000..e840cf5
--- /dev/null
+++ b/Plankton.Test/Plankton.Test.csproj
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
+  <PropertyGroup>
+    <ProjectGuid>{8FC24017-EDF3-4747-B966-C29DBD18103F}</ProjectGuid>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <OutputType>Library</OutputType>
+    <RootNamespace>Plankton.Test</RootNamespace>
+    <AssemblyName>Plankton.Test</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Platform)' == 'AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <OutputPath>bin\Debug\</OutputPath>
+    <DebugSymbols>True</DebugSymbols>
+    <DebugType>Full</DebugType>
+    <Optimize>False</Optimize>
+    <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <OutputPath>bin\Release\</OutputPath>
+    <DebugSymbols>False</DebugSymbols>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
+    <DefineConstants>TRACE</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="NUnit.Framework">
+      <HintPath>$(SharpDevelopBinPath)\Tools\NUnit\NUnit.Framework.dll</HintPath>
+    </Reference>
+    <Reference Include="RhinoCommon">
+      <HintPath>..\..\..\..\..\..\Program Files\Rhinoceros 5.0 (64-bit)\System\RhinoCommon.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="MeshTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Plankton\Plankton.csproj">
+      <Project>{BDD288F7-C2E2-4C2A-B083-E4D4D21F528F}</Project>
+      <Name>Plankton</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/Plankton.Test/Properties/AssemblyInfo.cs b/Plankton.Test/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..048f039
--- /dev/null
+++ b/Plankton.Test/Properties/AssemblyInfo.cs
@@ -0,0 +1,31 @@
+#region Using directives
+
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+#endregion
+
+// 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("Plankton.Test")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Plankton.Test")]
+[assembly: AssemblyCopyright("Copyright 2013")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+[assembly: ComVisible(false)]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all the values or you can use the default the Revision and 
+// Build Numbers by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.*")]

From f0670b64beb593e12c51342202c8c8497e99d8cb Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Mon, 22 Jul 2013 16:47:15 +0100
Subject: [PATCH 06/20] Update solution to include test project

---
 Plankton.sln | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Plankton.sln b/Plankton.sln
index 9c0c6be..380efcb 100644
--- a/Plankton.sln
+++ b/Plankton.sln
@@ -5,6 +5,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Plankton", "Plankton\Plankt
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PlanktonGh", "PlanktonGh\PlanktonGh.csproj", "{9C7EA9A3-331B-4574-BF22-B9D609DE2F1E}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Plankton.Test", "Plankton.Test\Plankton.Test.csproj", "{8FC24017-EDF3-4747-B966-C29DBD18103F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -19,6 +21,10 @@ Global
 		{9C7EA9A3-331B-4574-BF22-B9D609DE2F1E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9C7EA9A3-331B-4574-BF22-B9D609DE2F1E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9C7EA9A3-331B-4574-BF22-B9D609DE2F1E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8FC24017-EDF3-4747-B966-C29DBD18103F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8FC24017-EDF3-4747-B966-C29DBD18103F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8FC24017-EDF3-4747-B966-C29DBD18103F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8FC24017-EDF3-4747-B966-C29DBD18103F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From 30c9f081289b642b3959c30a5bcd7b14aee9f03f Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Tue, 23 Jul 2013 23:36:48 +0100
Subject: [PATCH 07/20] Add custom collection for faces (WIP)

* List wrapper tailer made for faces
* stores faces and encapsulates all face related functionality
* halfedge traversal using enumerator pattern
---
 Plankton.Test/MeshTest.cs    |  11 +-
 Plankton/Plankton.csproj     |   1 +
 Plankton/PlanktonFaceList.cs | 269 +++++++++++++++++++++++++++++++++++
 Plankton/PlanktonMesh.cs     | 214 +++-------------------------
 4 files changed, 295 insertions(+), 200 deletions(-)
 create mode 100644 Plankton/PlanktonFaceList.cs

diff --git a/Plankton.Test/MeshTest.cs b/Plankton.Test/MeshTest.cs
index a9b5511..587383c 100644
--- a/Plankton.Test/MeshTest.cs
+++ b/Plankton.Test/MeshTest.cs
@@ -54,13 +54,20 @@ public void CanCreateFromFaceVertex()
             }
             
             // Get all halfedges from face #2 and compare against expected
-            List<int> faceTwoHalfedges = pMesh.FaceHEs(2);
+            int[] faceTwoHalfedges = pMesh.Faces.GetHalfedges(2);
             int[] faceTwoHalfedgesExpected = new int[]{ 14, 16, 9, 3 };
-            Assert.AreEqual(4, faceTwoHalfedges.Count);
+            Assert.AreEqual(4, faceTwoHalfedges.Length);
             foreach (int halfedge in faceTwoHalfedgesExpected)
             {
                 Assert.Contains(halfedge, faceTwoHalfedges);
             }
+            // Check that none of these edges are on a boundary (closed mesh)
+            Assert.AreEqual(0, pMesh.Faces.NakedEdgeCount(2));
+            
+            // Get all vertices from face #4 and compare against expected
+            int[] faceFourVertices = pMesh.Faces.GetVertices(4);
+            int[] faceFourVerticesExpected = new int[]{ 4, 7, 3, 0 };
+            Assert.AreEqual(faceFourVerticesExpected, faceFourVertices);
             
             // Get all faces from vertex #1 and compare against expected
             List<int> vertexOneFaces = pMesh.VertexFaces(1);
diff --git a/Plankton/Plankton.csproj b/Plankton/Plankton.csproj
index 574333f..cbe59be 100644
--- a/Plankton/Plankton.csproj
+++ b/Plankton/Plankton.csproj
@@ -43,6 +43,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="PlanktonFace.cs" />
+    <Compile Include="PlanktonFaceList.cs" />
     <Compile Include="PlanktonHalfEdge.cs" />
     <Compile Include="PlanktonMesh.cs" />
     <Compile Include="PlanktonVertex.cs" />
diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
new file mode 100644
index 0000000..99256cc
--- /dev/null
+++ b/Plankton/PlanktonFaceList.cs
@@ -0,0 +1,269 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+using Rhino.Geometry;
+
+namespace Plankton
+{
+    /// <summary>
+    /// Provides access to the faces and Face related functionality of a Mesh.
+    /// </summary>
+    public class PlanktonFaceList : IEnumerable<PlanktonFace>
+    {
+        private readonly PlanktonMesh _mesh;
+        private List<PlanktonFace> _list;
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PlanktonHalfEdgeList"/> class.
+        /// Should be called from the mesh constructor.
+        /// </summary>
+        /// <param name="ownerMesh">The mesh to which this list of half-edges belongs.</param>
+        internal PlanktonFaceList(PlanktonMesh owner)
+        {
+            this._list = new List<PlanktonFace>();
+            this._mesh = owner;
+        }
+        
+        /// <summary>
+        /// Gets the number of half-edges.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this._list.Count;
+            }
+        }
+        
+        #region methods
+        #region face access
+        /// <summary>
+        /// Adds a new face to the end of the Face list.
+        /// </summary>
+        /// <param name="halfEdge">Face to add.</param>
+        /// <returns>The index of the newly added face.</returns>
+        internal int Add(PlanktonFace face)
+        {
+            if (face == null) return -1;
+            this._list.Add(face);
+            return this.Count - 1;
+        }
+        
+        /// <summary>
+        /// Adds a new face to the end of the Face list. Creates any halfedge pairs that are required.
+        /// </summary>
+        /// <param name="indices">The indices of the vertices which define this face, ordered anticlockwise.</param>
+        /// <returns>The index of the newly added face.</returns>
+        public int AddFace(IEnumerable<int> indices)
+        {
+            // This method always ensures that if a vertex lies on a boundary,
+            // vertex -> outgoingHalfedge -> adjacentFace == -1
+            
+            int[] array = indices.ToArray(); // using Linq for convenience
+            
+            int n = array.Length;
+            
+            // Don't allow degenerate faces
+            if (n < 3) return -1;
+            
+            // Check vertices
+            foreach (int i in array)
+            {
+                // Check that all vertex indices exist in this mesh
+                if (i < 0 || i >= _mesh.Vertices.Count)
+                    throw new IndexOutOfRangeException("No vertex exists at this index.");
+                // Check that all vertices are on a boundary
+                int outgoing = _mesh.Vertices[i].OutgoingHalfedge;
+                if (outgoing != -1 && _mesh.Halfedges[outgoing].AdjacentFace != -1)
+                    return -1;
+            }
+            
+            // For each pair of vertices, check for an existing halfedge
+            // If it exists, check that it doesn't already have a face
+            // If it doesn't exist, mark for creation of a new halfedge pair
+            int[] loop = new int[n];
+            bool[] is_new = new bool[n];
+            List<int> newHalfedges = new List<int>();
+            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
+            {
+                int v1 = array[i], v2 = array[ii];
+                is_new[i] = true;
+                // Find existing edge, if it exists, by searching 'i'th vertex's neighbourhood
+                if (_mesh.Vertices[v2].OutgoingHalfedge > -1)
+                {
+                    List<int> hs = _mesh.VertexAllOutHE(v2);
+                    foreach (int h in hs)
+                    {
+                        if (v1 == _mesh.Halfedges[_mesh.PairHalfedge(h)].StartVertex)
+                        {
+                            // Don't allow non-manifold edges
+                            if (_mesh.Halfedges[_mesh.PairHalfedge(h)].AdjacentFace > -1) return -1;
+                            loop[i] = _mesh.PairHalfedge(h);
+                            is_new[i] = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            // Now create any missing halfedge pairs...
+            // (This could be done in the loop above but it avoids having to tidy up
+            // any recently added halfedges should a non-manifold condition be found.)
+            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
+            {
+                if (is_new[i]) // new halfedge pair requireds
+                {
+                    int v1 = array[i], v2 = array[ii];
+                    loop[i] = _mesh.Halfedges.Count;
+                    is_new[i] = true;
+                    // he->next = he->pair
+                    _mesh.Halfedges.Add(new PlanktonHalfedge(v1, this.Count, loop[i] + 1));
+                    _mesh.Halfedges.Add(new PlanktonHalfedge(v2, -1, loop[i]));
+                    _mesh.Vertices[v2].OutgoingHalfedge = loop[i] + 1;
+                }
+                else
+                {
+                    // Link existing halfedge to new face
+                    _mesh.Halfedges[loop[i]].AdjacentFace = this.Count;
+                }
+            }
+            
+            // Link halfedges
+            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
+            {
+                int v1 = array[i], v2 = array[ii];
+                int id = 0;
+                if (is_new[i])  id += 1;
+                if (is_new[ii]) id += 2;
+                
+                if (id > 0) // At least one of the halfedge pairs is new...
+                {
+                    // Link inner halfedges
+                    _mesh.Halfedges[loop[i]].NextHalfedge = loop[ii];
+                    _mesh.Halfedges[loop[ii]].PrevHalfedge = loop[i];
+                    
+                    // Link outer halfedges
+                    int firstHalfedge, currentHalfedge;
+                    switch (id)
+                    {
+                        case 1: // first is new, second is old
+                            // iterate through halfedges around vertex #v2
+                            firstHalfedge = loop[ii];
+                            currentHalfedge = firstHalfedge;
+                            do
+                            {
+                                int pair = _mesh.PairHalfedge(currentHalfedge);
+                                currentHalfedge = _mesh.Halfedges[pair].NextHalfedge;
+                            } while (_mesh.Halfedges[_mesh.PairHalfedge(currentHalfedge)].AdjacentFace > -1);
+                            _mesh.Halfedges[_mesh.PairHalfedge(currentHalfedge)].NextHalfedge = _mesh.PairHalfedge(loop[i]);
+                            _mesh.Halfedges[_mesh.PairHalfedge(loop[i])].PrevHalfedge = _mesh.PairHalfedge(currentHalfedge);
+                            break;
+                        case 2: // second is new, first is old
+                            int outer_next = _mesh.Vertices[v2].OutgoingHalfedge;
+                            _mesh.Halfedges[_mesh.PairHalfedge(loop[ii])].NextHalfedge = outer_next;
+                            _mesh.Halfedges[outer_next].PrevHalfedge = _mesh.PairHalfedge(loop[ii]);
+                            break;
+                        case 3: // both are new
+                            _mesh.Halfedges[_mesh.PairHalfedge(loop[ii])].NextHalfedge = _mesh.PairHalfedge(loop[i]);
+                            _mesh.Halfedges[_mesh.PairHalfedge(loop[i])].PrevHalfedge = _mesh.PairHalfedge(loop[ii]);
+                            break;
+                    }
+                }
+            }
+            
+            int f = this.Count;
+            this.Add(new PlanktonFace());
+            this[f].FirstHalfedge = loop[0];
+            
+            return f;
+        }
+        
+        /// <summary>
+        /// Returns the face at the given index.
+        /// </summary>
+        /// <param name="index">
+        /// Index of face to get.
+        /// Must be larger than or equal to zero and smaller than the Face Count of the mesh.
+        /// </param>
+        /// <returns>The face at the given index.</returns>
+        public PlanktonFace this[int index]
+        {
+            get
+            {
+                return this._list[index];
+            }
+            private set
+            {
+                this._list[index] = value;
+            }
+        }
+        #endregion
+        
+        #region traversals
+        public int[] GetHalfedges(int f)
+        {
+            return this.GetHalfedgesEnumerator(f).ToArray();
+        }
+        
+        public IEnumerable<int> GetHalfedgesEnumerator(int f)
+        {
+            int he_first = this[f].FirstHalfedge;
+            int he_current = he_first;
+            do
+            {
+                yield return he_current;
+                he_current = _mesh.Halfedges[he_current].NextHalfedge;
+            }
+            while (he_current != he_first);
+        }
+        #endregion
+        
+        public int[] GetVertices(int f)
+            //get the vertices making up a face
+        {
+            return this.GetHalfedgesEnumerator(f)
+                .Select(h => _mesh.Halfedges[h].StartVertex).ToArray();
+        }
+
+        public Point3d FaceCentroid(int f)
+            //the barycenter of a face's vertices
+        {
+            int[] fvs = this.GetVertices(f);
+            Point3d Centroid = new Point3d(0, 0, 0);
+            foreach (int i in fvs)
+            {
+                Centroid += _mesh.Vertices[i].Position;
+            }
+            Centroid *= 1.0 / fvs.Length;
+            return Centroid;
+        }
+        
+        public int NakedEdgeCount(int f)
+        {
+            int nakedCount = 0;
+            foreach (int i in this.GetHalfedgesEnumerator(f))
+            {
+                if (_mesh.Halfedges[_mesh.PairHalfedge(i)].AdjacentFace == -1) nakedCount++;
+            }
+            return nakedCount;
+        }
+        #endregion
+        
+        #region IEnumerable implementation
+        /// <summary>
+        /// Gets an enumerator that yields all half-edges in this collection.
+        /// </summary>
+        /// <returns>An enumerator.</returns>
+        public IEnumerator<PlanktonFace> GetEnumerator()
+        {
+            return this._list.GetEnumerator();
+        }
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+        #endregion
+    }
+}
diff --git a/Plankton/PlanktonMesh.cs b/Plankton/PlanktonMesh.cs
index 12e8a14..d0306a0 100644
--- a/Plankton/PlanktonMesh.cs
+++ b/Plankton/PlanktonMesh.cs
@@ -13,13 +13,13 @@ public class PlanktonMesh
         #region "members"
         public List<PlanktonVertex> Vertices;
         public List<PlanktonHalfedge> Halfedges;
-        public List<PlanktonFace> Faces;
+        public PlanktonFaceList Faces;
         #endregion
 
         #region "constructors"
         public PlanktonMesh() //blank constructor
         {
-            this.Faces = new List<PlanktonFace>();
+            this.Faces = new PlanktonFaceList(this);
             this.Halfedges = new List<PlanktonHalfedge>();
             this.Vertices = new List<PlanktonVertex>();
         }
@@ -219,141 +219,12 @@ public PlanktonMesh(IEnumerable<Point3d> pts, IEnumerable<IEnumerable<int>> face
             // Add faces (and half-edges)
             foreach (IEnumerable<int> face in faces)
             {
-                this.AddFace(face);
+                this.Faces.AddFace(face);
             }
         }
         #endregion
 
         #region "general methods"
-        /// <summary>
-        /// Adds a new face to the mesh. Creates any halfedge pairs that are required.
-        /// </summary>
-        /// <param name="indices">The indices of the vertices which define this face, ordered anticlockwise.</param>
-        /// <returns>The index of the newly added face.</returns>
-        public int AddFace(IEnumerable<int> indices)
-        {
-            // This method always ensures that if a vertex lies on a boundary,
-            // vertex -> outgoingHalfedge -> adjacentFace == -1
-            
-            int[] array = indices.ToArray(); // using Linq for convenience
-            
-            int n = array.Length;
-            
-            // Don't allow degenerate faces
-            if (n < 3) return -1;
-            
-            // Check vertices
-            foreach (int i in array)
-            {
-                // Check that all vertex indices exist in this mesh
-                if (i < 0 || i >= this.Vertices.Count)
-                    throw new IndexOutOfRangeException("No vertex exists at this index.");
-                // Check that all vertices are on a boundary
-                int outgoing = this.Vertices[i].OutgoingHalfedge;
-                if (outgoing != -1 && this.Halfedges[outgoing].AdjacentFace != -1)
-                    return -1;
-            }
-            
-            // For each pair of vertices, check for an existing halfedge
-            // If it exists, check that it doesn't already have a face
-            // If it doesn't exist, mark for creation of a new halfedge pair
-            int[] loop = new int[n];
-            bool[] is_new = new bool[n];
-            List<int> newHalfedges = new List<int>();
-            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
-            {
-                int v1 = array[i], v2 = array[ii];
-                is_new[i] = true;
-                // Find existing edge, if it exists, by searching 'i'th vertex's neighbourhood
-                if (this.Vertices[v2].OutgoingHalfedge > -1)
-                {
-                    List<int> hs = this.VertexAllOutHE(v2);
-                    foreach (int h in hs)
-                    {
-                        if (v1 == this.Halfedges[this.PairHalfedge(h)].StartVertex)
-                        {
-                            // Don't allow non-manifold edges
-                            if (this.Halfedges[this.PairHalfedge(h)].AdjacentFace > -1) return -1;
-                            loop[i] = this.PairHalfedge(h);
-                            is_new[i] = false;
-                            break;
-                        }
-                    }
-                }
-            }
-            
-            // Now create any missing halfedge pairs...
-            // (This could be done in the loop above but it avoids having to tidy up
-            // any recently added halfedges should a non-manifold condition be found.)
-            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
-            {
-                if (is_new[i]) // new halfedge pair requireds
-                {
-                    int v1 = array[i], v2 = array[ii];
-                    loop[i] = this.Halfedges.Count;
-                    is_new[i] = true;
-                    // he->next = he->pair
-                    this.Halfedges.Add(new PlanktonHalfedge(v1, this.Faces.Count, loop[i] + 1));
-                    this.Halfedges.Add(new PlanktonHalfedge(v2, -1, loop[i]));
-                    this.Vertices[v2].OutgoingHalfedge = loop[i] + 1;
-                }
-                else
-                {
-                    // Link existing halfedge to new face
-                    this.Halfedges[loop[i]].AdjacentFace = this.Faces.Count;
-                }
-            }
-            
-            // Link halfedges
-            for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
-            {
-                int v1 = array[i], v2 = array[ii];
-                int id = 0;
-                if (is_new[i])  id += 1;
-                if (is_new[ii]) id += 2;
-                
-                if (id > 0) // At least one of the halfedge pairs is new...
-                {
-                    // Link inner halfedges
-                    this.Halfedges[loop[i]].NextHalfedge = loop[ii];
-                    this.Halfedges[loop[ii]].PrevHalfedge = loop[i];
-                    
-                    // Link outer halfedges
-                    int firstHalfedge, currentHalfedge;
-                    switch (id)
-                    {
-                        case 1: // first is new, second is old
-                            
-                            firstHalfedge = loop[ii];
-                            currentHalfedge = firstHalfedge;
-                            do
-                            {
-                                int pair = PairHalfedge(currentHalfedge);
-                                currentHalfedge = this.Halfedges[pair].NextHalfedge;
-                            } while (this.Halfedges[PairHalfedge(currentHalfedge)].AdjacentFace > -1);
-                            this.Halfedges[PairHalfedge(currentHalfedge)].NextHalfedge = PairHalfedge(loop[i]);
-                            this.Halfedges[PairHalfedge(loop[i])].PrevHalfedge = PairHalfedge(currentHalfedge);
-                            break;
-                        case 2: // second is new, first is old
-                            int outer_next = this.Vertices[v2].OutgoingHalfedge;
-                            this.Halfedges[PairHalfedge(loop[ii])].NextHalfedge = outer_next;
-                            this.Halfedges[outer_next].PrevHalfedge = PairHalfedge(loop[ii]);
-                            break;
-                        case 3: // both are new
-                            this.Halfedges[PairHalfedge(loop[ii])].NextHalfedge = PairHalfedge(loop[i]);
-                            this.Halfedges[PairHalfedge(loop[i])].PrevHalfedge = PairHalfedge(loop[ii]);
-                            break;
-                    }
-                }
-            }
-            
-            int f = this.Faces.Count;
-            this.Faces.Add(new PlanktonFace());
-            this.Faces[f].FirstHalfedge = loop[n - 1];
-            
-            return f;
-        }
-
         public Mesh ToRhinoMesh()
         {
             // could add different options for triangulating ngons later
@@ -365,21 +236,21 @@ public Mesh ToRhinoMesh()
             }
             for (int i = 0; i < P.Faces.Count; i++)
             {
-                List<int> FaceVs = P.FaceVertices(i);
-                if (FaceVs.Count == 3)
+                int[] FaceVs = P.Faces.GetVertices(i);
+                if (FaceVs.Length == 3)
                 {
                     M.Faces.AddFace(FaceVs[0], FaceVs[1], FaceVs[2]);
                 }
-                if (FaceVs.Count == 4)
+                if (FaceVs.Length == 4)
                 {
                     M.Faces.AddFace(FaceVs[0], FaceVs[1], FaceVs[2], FaceVs[3]);
                 }
-                if (FaceVs.Count > 4)
+                if (FaceVs.Length > 4)
                 {
-                    M.Vertices.Add(P.FaceCentroid(i));
-                    for (int j = 0; j < FaceVs.Count; j++)
+                    M.Vertices.Add(P.Faces.FaceCentroid(i));
+                    for (int j = 0; j < FaceVs.Length; j++)
                     {
-                        M.Faces.AddFace(FaceVs[j], FaceVs[(j + 1) % FaceVs.Count], M.Vertices.Count - 1);
+                        M.Faces.AddFace(FaceVs[j], FaceVs[(j + 1) % FaceVs.Length], M.Vertices.Count - 1);
                     }
                 }
             }
@@ -392,10 +263,10 @@ public List<Polyline> ToPolylines()
             for (int i = 0; i < Faces.Count; i++)
             {
                 Polyline FacePoly = new Polyline();
-                List<int> VertIndexes = FaceVertices(i);
-                for (int j = 0; j <= VertIndexes.Count; j++)
+                int[] VertIndexes = this.Faces.GetVertices(i);
+                for (int j = 0; j <= VertIndexes.Length; j++)
                 {
-                    FacePoly.Add(Vertices[VertIndexes[j % VertIndexes.Count]].Position);
+                    FacePoly.Add(Vertices[VertIndexes[j % VertIndexes.Length]].Position);
                 }
                 Polylines.Add(FacePoly);
             }
@@ -422,9 +293,9 @@ public PlanktonMesh Dual()
 
             for (int i = 0; i < P.Faces.Count; i++)
             {
-                D.Vertices.Add(new PlanktonVertex(P.FaceCentroid(i)));
-                List<int> FaceHalfedges = P.FaceHEs(i);
-                for (int j = 0; j < FaceHalfedges.Count; j++)
+                D.Vertices.Add(new PlanktonVertex(P.Faces.FaceCentroid(i)));
+                int[] FaceHalfedges = P.Faces.GetHalfedges(i);
+                for (int j = 0; j < FaceHalfedges.Length; j++)
                 {
                     if (P.Halfedges[P.PairHalfedge(FaceHalfedges[j])].AdjacentFace != -1)
                     {
@@ -587,48 +458,6 @@ public List<int> VertexAllInHE(int V) // all the incoming Halfedges to a vertex
             return InHEs;
         }
 
-        public List<int> FaceHEs(int F)
-        {
-            List<int> HEs = new List<int>();
-            int FirstHalfedge = Faces[F].FirstHalfedge;
-            int CurrentHalfedge = FirstHalfedge;
-            do
-            {
-                HEs.Add(CurrentHalfedge);
-                CurrentHalfedge = Halfedges[CurrentHalfedge].NextHalfedge;
-            }
-            while (CurrentHalfedge != FirstHalfedge);
-            return HEs;
-        }
-
-        public List<int> FaceVertices(int F)
-            //get the vertices making up a face
-        {
-            List<int> FaceVs = new List<int>();
-            int FirstHalfedge = Faces[F].FirstHalfedge;
-            int CurrentHalfedge = FirstHalfedge;
-            do
-            {
-                FaceVs.Add(Halfedges[CurrentHalfedge].StartVertex);
-                CurrentHalfedge = Halfedges[CurrentHalfedge].NextHalfedge;
-            }
-            while (CurrentHalfedge != FirstHalfedge);
-            return FaceVs;
-        }
-
-        public Point3d FaceCentroid(int F)
-            //the barycenter of a face's vertices
-        {
-            List<int> FaceVs = FaceVertices(F);
-            Point3d Centroid = new Point3d(0, 0, 0);
-            foreach (int i in FaceVs)
-            {
-                Centroid = Centroid + Vertices[i].Position;
-            }
-            Centroid *= 1.0 / FaceVs.Count;
-            return Centroid;
-        }
-
         public int PairHalfedge(int I)
         {
             if (I % 2 == 0)
@@ -657,17 +486,6 @@ public int VertexNakedEdgeCount(int V)
             return NakedCount;
         }
 
-        public int FaceNakedEdgeCount(int F)
-        {
-            int NakedCount = 0;
-            List<int> FaceHEdges = FaceHEs(F);
-            foreach (int i in FaceHEdges)
-            {
-                if (Halfedges[PairHalfedge(i)].AdjacentFace == -1) { NakedCount++; }
-            }
-            return NakedCount;
-        }
-
         #endregion
     }
 }

From 16f12564438978289f9808cc4666602147c8e803 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Wed, 24 Jul 2013 09:53:35 +0100
Subject: [PATCH 08/20] Tidy up face list

---
 Plankton/PlanktonFaceList.cs | 53 ++++++++++++++++++++++++++----------
 1 file changed, 39 insertions(+), 14 deletions(-)

diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index 99256cc..e3d3ca8 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -54,7 +54,7 @@ internal int Add(PlanktonFace face)
         /// <summary>
         /// Adds a new face to the end of the Face list. Creates any halfedge pairs that are required.
         /// </summary>
-        /// <param name="indices">The indices of the vertices which define this face, ordered anticlockwise.</param>
+        /// <param name="indices">The vertex indices which define this face, ordered anticlockwise.</param>
         /// <returns>The index of the newly added face.</returns>
         public int AddFace(IEnumerable<int> indices)
         {
@@ -149,7 +149,7 @@ public int AddFace(IEnumerable<int> indices)
                     switch (id)
                     {
                         case 1: // first is new, second is old
-                            // iterate through halfedges around vertex #v2
+                            // iterate through halfedges clockwise around vertex #v2 until boundary
                             firstHalfedge = loop[ii];
                             currentHalfedge = firstHalfedge;
                             do
@@ -173,11 +173,10 @@ public int AddFace(IEnumerable<int> indices)
                 }
             }
             
-            int f = this.Count;
-            this.Add(new PlanktonFace());
-            this[f].FirstHalfedge = loop[0];
+            PlanktonFace f = new PlanktonFace();
+            f.FirstHalfedge = loop[0];
             
-            return f;
+            return this.Add(f);
         }
         
         /// <summary>
@@ -202,12 +201,24 @@ private set
         #endregion
         
         #region traversals
+        /// <summary>
+        /// Gets the halfedges which bound a face.
+        /// </summary>
+        /// <param name="f">A face index.</param>
+        /// <returns>The indices of halfedges incident to a particular face.
+        /// Ordered anticlockwise around the face.</returns>
         public int[] GetHalfedges(int f)
         {
-            return this.GetHalfedgesEnumerator(f).ToArray();
+            return this.GetHalfedgesCirculator(f).ToArray();
         }
         
-        public IEnumerable<int> GetHalfedgesEnumerator(int f)
+        /// <summary>
+        /// Traverses the halfedge indices which bound a face.
+        /// </summary>
+        /// <param name="f">A face index.</param>
+        /// <returns>An enumerable of halfedge indices incident to the specified face.
+        /// Ordered anticlockwise around the face.</returns>
+        public IEnumerable<int> GetHalfedgesCirculator(int f)
         {
             int he_first = this[f].FirstHalfedge;
             int he_current = he_first;
@@ -220,15 +231,24 @@ public IEnumerable<int> GetHalfedgesEnumerator(int f)
         }
         #endregion
         
+        /// <summary>
+        /// Gets vertex indices of a face.
+        /// </summary>
+        /// <param name="f">A face index.</param>
+        /// <returns>An array of vertex indices incident to the specified face.
+        /// Ordered anticlockwise around the face.</returns>
         public int[] GetVertices(int f)
-            //get the vertices making up a face
         {
-            return this.GetHalfedgesEnumerator(f)
+            return this.GetHalfedgesCirculator(f)
                 .Select(h => _mesh.Halfedges[h].StartVertex).ToArray();
         }
-
+        
+        /// <summary>
+        /// Gets the barycenter of a face's vertices.
+        /// </summary>
+        /// <param name="f">A face index.</param>
+        /// <returns>The location of the specified face's barycenter.</returns>
         public Point3d FaceCentroid(int f)
-            //the barycenter of a face's vertices
         {
             int[] fvs = this.GetVertices(f);
             Point3d Centroid = new Point3d(0, 0, 0);
@@ -240,10 +260,15 @@ public Point3d FaceCentroid(int f)
             return Centroid;
         }
         
+        /// <summary>
+        /// Gets the number of naked edges which bound this face.
+        /// </summary>
+        /// <param name="f">A face index.</param>
+        /// <returns>The number of halfedges for which the opposite halfedge has no face (i.e. adjacent face index is -1).</returns>
         public int NakedEdgeCount(int f)
         {
             int nakedCount = 0;
-            foreach (int i in this.GetHalfedgesEnumerator(f))
+            foreach (int i in this.GetHalfedgesCirculator(f))
             {
                 if (_mesh.Halfedges[_mesh.PairHalfedge(i)].AdjacentFace == -1) nakedCount++;
             }
@@ -253,7 +278,7 @@ public int NakedEdgeCount(int f)
         
         #region IEnumerable implementation
         /// <summary>
-        /// Gets an enumerator that yields all half-edges in this collection.
+        /// Gets an enumerator that yields all faces in this collection.
         /// </summary>
         /// <returns>An enumerator.</returns>
         public IEnumerator<PlanktonFace> GetEnumerator()

From 3441cde3a51e172c8320ea68b5adc80a4ea9024c Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Wed, 24 Jul 2013 11:08:26 +0100
Subject: [PATCH 09/20] Add custom collection for halfedges

* same idea as face list
* refactor PairHalfedge method (used extensively so many changes necessary)
---
 Plankton/Plankton.csproj         |   1 +
 Plankton/PlanktonFaceList.cs     |  24 +++---
 Plankton/PlanktonHalfedgeList.cs | 142 +++++++++++++++++++++++++++++++
 Plankton/PlanktonMesh.cs         |  62 ++++----------
 PlanktonGh/DecomposePlankton.cs  |   2 +-
 5 files changed, 172 insertions(+), 59 deletions(-)
 create mode 100644 Plankton/PlanktonHalfedgeList.cs

diff --git a/Plankton/Plankton.csproj b/Plankton/Plankton.csproj
index cbe59be..b36aed5 100644
--- a/Plankton/Plankton.csproj
+++ b/Plankton/Plankton.csproj
@@ -45,6 +45,7 @@
     <Compile Include="PlanktonFace.cs" />
     <Compile Include="PlanktonFaceList.cs" />
     <Compile Include="PlanktonHalfEdge.cs" />
+    <Compile Include="PlanktonHalfedgeList.cs" />
     <Compile Include="PlanktonMesh.cs" />
     <Compile Include="PlanktonVertex.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index e3d3ca8..0decf6d 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -96,11 +96,11 @@ public int AddFace(IEnumerable<int> indices)
                     List<int> hs = _mesh.VertexAllOutHE(v2);
                     foreach (int h in hs)
                     {
-                        if (v1 == _mesh.Halfedges[_mesh.PairHalfedge(h)].StartVertex)
+                        if (v1 == _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(h)].StartVertex)
                         {
                             // Don't allow non-manifold edges
-                            if (_mesh.Halfedges[_mesh.PairHalfedge(h)].AdjacentFace > -1) return -1;
-                            loop[i] = _mesh.PairHalfedge(h);
+                            if (_mesh.Halfedges[_mesh.Halfedges.PairHalfedge(h)].AdjacentFace > -1) return -1;
+                            loop[i] = _mesh.Halfedges.PairHalfedge(h);
                             is_new[i] = false;
                             break;
                         }
@@ -154,20 +154,20 @@ public int AddFace(IEnumerable<int> indices)
                             currentHalfedge = firstHalfedge;
                             do
                             {
-                                int pair = _mesh.PairHalfedge(currentHalfedge);
+                                int pair = _mesh.Halfedges.PairHalfedge(currentHalfedge);
                                 currentHalfedge = _mesh.Halfedges[pair].NextHalfedge;
-                            } while (_mesh.Halfedges[_mesh.PairHalfedge(currentHalfedge)].AdjacentFace > -1);
-                            _mesh.Halfedges[_mesh.PairHalfedge(currentHalfedge)].NextHalfedge = _mesh.PairHalfedge(loop[i]);
-                            _mesh.Halfedges[_mesh.PairHalfedge(loop[i])].PrevHalfedge = _mesh.PairHalfedge(currentHalfedge);
+                            } while (_mesh.Halfedges[_mesh.Halfedges.PairHalfedge(currentHalfedge)].AdjacentFace > -1);
+                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(currentHalfedge)].NextHalfedge = _mesh.Halfedges.PairHalfedge(loop[i]);
+                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(loop[i])].PrevHalfedge = _mesh.Halfedges.PairHalfedge(currentHalfedge);
                             break;
                         case 2: // second is new, first is old
                             int outer_next = _mesh.Vertices[v2].OutgoingHalfedge;
-                            _mesh.Halfedges[_mesh.PairHalfedge(loop[ii])].NextHalfedge = outer_next;
-                            _mesh.Halfedges[outer_next].PrevHalfedge = _mesh.PairHalfedge(loop[ii]);
+                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(loop[ii])].NextHalfedge = outer_next;
+                            _mesh.Halfedges[outer_next].PrevHalfedge = _mesh.Halfedges.PairHalfedge(loop[ii]);
                             break;
                         case 3: // both are new
-                            _mesh.Halfedges[_mesh.PairHalfedge(loop[ii])].NextHalfedge = _mesh.PairHalfedge(loop[i]);
-                            _mesh.Halfedges[_mesh.PairHalfedge(loop[i])].PrevHalfedge = _mesh.PairHalfedge(loop[ii]);
+                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(loop[ii])].NextHalfedge = _mesh.Halfedges.PairHalfedge(loop[i]);
+                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(loop[i])].PrevHalfedge = _mesh.Halfedges.PairHalfedge(loop[ii]);
                             break;
                     }
                 }
@@ -270,7 +270,7 @@ public int NakedEdgeCount(int f)
             int nakedCount = 0;
             foreach (int i in this.GetHalfedgesCirculator(f))
             {
-                if (_mesh.Halfedges[_mesh.PairHalfedge(i)].AdjacentFace == -1) nakedCount++;
+                if (_mesh.Halfedges[_mesh.Halfedges.PairHalfedge(i)].AdjacentFace == -1) nakedCount++;
             }
             return nakedCount;
         }
diff --git a/Plankton/PlanktonHalfedgeList.cs b/Plankton/PlanktonHalfedgeList.cs
new file mode 100644
index 0000000..0d8466f
--- /dev/null
+++ b/Plankton/PlanktonHalfedgeList.cs
@@ -0,0 +1,142 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Plankton
+{
+    /// <summary>
+    /// Provides access to the halfedges and Halfedge related functionality of a Mesh.
+    /// </summary>
+    public class PlanktonHalfEdgeList : IEnumerable<PlanktonHalfedge>
+    {
+        private readonly PlanktonMesh _mesh;
+        private List<PlanktonHalfedge> _list;
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PlanktonHalfEdgeList"/> class.
+        /// Should be called from the mesh constructor.
+        /// </summary>
+        /// <param name="ownerMesh">The mesh to which this list of halfedges belongs.</param>
+        internal PlanktonHalfEdgeList(PlanktonMesh owner)
+        {
+            this._list = new List<PlanktonHalfedge>();
+            this._mesh = owner;
+        }
+        
+        /// <summary>
+        /// Gets the number of halfedges.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this._list.Count;
+            }
+        }
+        
+        #region methods
+        #region halfedge access
+        /// <summary>
+        /// Adds a new halfedge to the end of the Halfedge list.
+        /// </summary>
+        /// <param name="halfEdge">Halfedge to add.</param>
+        /// <returns>The index of the newly added halfedge.</returns>
+        public int Add(PlanktonHalfedge halfedge)
+        {
+            if (halfedge == null) return -1;
+            this._list.Add(halfedge);
+            return this.Count - 1;
+        }
+        
+        /// <summary>
+        /// Returns the halfedge at the given index.
+        /// </summary>
+        /// <param name="index">
+        /// Index of halfedge to get.
+        /// Must be larger than or equal to zero and smaller than the Halfedge Count of the mesh.
+        /// </param>
+        /// <returns>The halfedge at the given index.</returns>
+        public PlanktonHalfedge this[int index]
+        {
+            get
+            {
+                return this._list[index];
+            }
+            private set
+            {
+                this._list[index] = value;
+            }
+        }
+        
+        /// <summary>
+        /// Gets the opposing halfedge in a pair.
+        /// </summary>
+        /// <param name="index">A halfedge index.</param>
+        /// <returns>The halfedge index with which the specified halfedge is paired.</returns>
+        public int PairHalfedge(int index)
+        {
+            if (index < 0 || index >= this.Count)
+            {
+                throw new IndexOutOfRangeException();
+            }
+            
+            return index % 2 == 0 ? index + 1 : index - 1;
+        }
+        
+        /// <summary>
+        /// Gets the two vertices for a halfedge.
+        /// </summary>
+        /// <param name="index">A halfedge index.</param>
+        /// <returns>The pair of vertex indices connected by the specified halfedge.
+        /// The order follows the direction of the halfedge.</returns>
+        public int[] GetVertices(int index)
+        {
+            int I, J;
+            I = this[index].StartVertex;
+            J = this[this.PairHalfedge(index)].StartVertex;
+            
+            return new int[]{ I, J };
+        }
+        #endregion
+        
+        public void FlipEdge(int index)
+        {
+            // to flip an edge
+            // update 2 start verts
+            // 2 adjacentfaces
+            // 6 nexts
+            // 6 prevs
+            // for each vert, check if need to update outgoing
+            // for each face, check if need to update start he
+            throw new NotImplementedException();
+        }
+        
+        public void SplitEdge(int index)
+        {
+            // add a new vertex
+            // add 2 new faces
+            throw new NotImplementedException();
+        }
+        
+        public void CollapseEdge(int index)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+        
+        #region IEnumerable implementation
+        /// <summary>
+        /// Gets an enumerator that yields all halfedges in this collection.
+        /// </summary>
+        /// <returns>An enumerator.</returns>
+        public IEnumerator<PlanktonHalfedge> GetEnumerator()
+        {
+            return this._list.GetEnumerator();
+        }
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/Plankton/PlanktonMesh.cs b/Plankton/PlanktonMesh.cs
index d0306a0..94a6de2 100644
--- a/Plankton/PlanktonMesh.cs
+++ b/Plankton/PlanktonMesh.cs
@@ -12,7 +12,7 @@ public class PlanktonMesh
     {
         #region "members"
         public List<PlanktonVertex> Vertices;
-        public List<PlanktonHalfedge> Halfedges;
+        public PlanktonHalfEdgeList Halfedges;
         public PlanktonFaceList Faces;
         #endregion
 
@@ -20,7 +20,7 @@ public class PlanktonMesh
         public PlanktonMesh() //blank constructor
         {
             this.Faces = new PlanktonFaceList(this);
-            this.Halfedges = new List<PlanktonHalfedge>();
+            this.Halfedges = new PlanktonHalfEdgeList(this);
             this.Vertices = new List<PlanktonVertex>();
         }
         public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
@@ -297,10 +297,10 @@ public PlanktonMesh Dual()
                 int[] FaceHalfedges = P.Faces.GetHalfedges(i);
                 for (int j = 0; j < FaceHalfedges.Length; j++)
                 {
-                    if (P.Halfedges[P.PairHalfedge(FaceHalfedges[j])].AdjacentFace != -1)
+                    if (P.Halfedges[P.Halfedges.PairHalfedge(FaceHalfedges[j])].AdjacentFace != -1)
                     {
                         // D.Vertices[i].OutgoingHalfedge = FaceHalfedges[j];
-                        D.Vertices[D.Vertices.Count-1].OutgoingHalfedge = P.PairHalfedge(FaceHalfedges[j]);
+                        D.Vertices[D.Vertices.Count-1].OutgoingHalfedge = P.Halfedges.PairHalfedge(FaceHalfedges[j]);
                         break;
                     }
                 }
@@ -327,12 +327,12 @@ public PlanktonMesh Dual()
 
             for (int i = 0; i < P.Halfedges.Count; i++)
             {
-                if ((P.Halfedges[i].AdjacentFace != -1) & (P.Halfedges[P.PairHalfedge(i)].AdjacentFace != -1))
+                if ((P.Halfedges[i].AdjacentFace != -1) & (P.Halfedges[P.Halfedges.PairHalfedge(i)].AdjacentFace != -1))
                 {
                     PlanktonHalfedge DualHE = new PlanktonHalfedge();
                     PlanktonHalfedge PrimalHE = P.Halfedges[i];
                     //DualHE.StartVertex = PrimalHE.AdjacentFace;
-                    DualHE.StartVertex = P.Halfedges[P.PairHalfedge(i)].AdjacentFace;
+                    DualHE.StartVertex = P.Halfedges[P.Halfedges.PairHalfedge(i)].AdjacentFace;
 
                     if (P.VertexNakedEdgeCount(PrimalHE.StartVertex) == 0)
                     {
@@ -349,10 +349,10 @@ public PlanktonMesh Dual()
                     //this needs to be done repeatedly until no further change
 
                     //DualHE.NextHalfedge = P.Halfedges[P.PairHalfedge(i)].PrevHalfedge;
-                    DualHE.NextHalfedge = P.PairHalfedge(PrimalHE.PrevHalfedge);
+                    DualHE.NextHalfedge = P.Halfedges.PairHalfedge(PrimalHE.PrevHalfedge);
 
                     //DualHE.PrevHalfedge = P.PairHalfedge(PrimalHE.NextHalfedge);
-                    DualHE.PrevHalfedge = P.Halfedges[P.PairHalfedge(i)].NextHalfedge;
+                    DualHE.PrevHalfedge = P.Halfedges[P.Halfedges.PairHalfedge(i)].NextHalfedge;
 
                     DualHE.Index = newIndex;
 
@@ -363,28 +363,6 @@ public PlanktonMesh Dual()
             return D;
         }
 
-        public void FlipEdge(int E)
-        {
-
-            // to flip an edge
-            // update 2 start verts
-            // 2 adjacentfaces
-            // 6 nexts
-            // 6 prevs
-            // for each vert, check if need to update outgoing
-            // for each face, check if need to update start he
-        }
-
-        public void SplitEdge(int E)
-        {
-            // add a new vertex
-            // add 2 new faces
-        }
-
-        public void CollapseEdge(int E)
-        {
-        }
-
         public void RefreshVertexNormals()
         {
         }
@@ -408,11 +386,11 @@ public List<int> VertexNeighbours(int V)
             //get the vertices connected to a given vertex by an edge (aka 1-ring)
         {
             List<int> NeighbourVs = new List<int>();
-            int FirstHalfedge = PairHalfedge(Vertices[V].OutgoingHalfedge);
+            int FirstHalfedge = Halfedges.PairHalfedge(Vertices[V].OutgoingHalfedge);
             int CurrentHalfedge = FirstHalfedge;
             do{
                 NeighbourVs.Add(Halfedges[CurrentHalfedge].StartVertex);
-                CurrentHalfedge = PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
+                CurrentHalfedge = Halfedges.PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
             } while (CurrentHalfedge != FirstHalfedge);
             return NeighbourVs;
         }
@@ -426,7 +404,7 @@ public List<int> VertexFaces(int V)
             do
             {
                 NeighbourFs.Add(Halfedges[CurrentHalfedge].AdjacentFace);
-                CurrentHalfedge = Halfedges[PairHalfedge(CurrentHalfedge)].NextHalfedge;
+                CurrentHalfedge = Halfedges[Halfedges.PairHalfedge(CurrentHalfedge)].NextHalfedge;
             } while (CurrentHalfedge != FirstHalfedge);
             return NeighbourFs;
         }
@@ -440,7 +418,7 @@ public List<int> VertexAllOutHE(int V) // all the outgoing Halfedges from a vert
             do
             {
                 OutHEs.Add(CurrentHalfedge);
-                CurrentHalfedge = Halfedges[PairHalfedge(CurrentHalfedge)].NextHalfedge;
+                CurrentHalfedge = Halfedges[Halfedges.PairHalfedge(CurrentHalfedge)].NextHalfedge;
             } while (CurrentHalfedge != FirstHalfedge);
             return OutHEs;
         }
@@ -448,27 +426,19 @@ public List<int> VertexAllOutHE(int V) // all the outgoing Halfedges from a vert
         public List<int> VertexAllInHE(int V) // all the incoming Halfedges to a vertex
         {
             List<int> InHEs = new List<int>();
-            int FirstHalfedge = PairHalfedge(Vertices[V].OutgoingHalfedge);
+            int FirstHalfedge = Halfedges.PairHalfedge(Vertices[V].OutgoingHalfedge);
             int CurrentHalfedge = FirstHalfedge;
             do
             {
                 InHEs.Add(CurrentHalfedge);
-                CurrentHalfedge = PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
+                CurrentHalfedge = Halfedges.PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
             } while (CurrentHalfedge != FirstHalfedge);
             return InHEs;
         }
 
-        public int PairHalfedge(int I)
-        {
-            if (I % 2 == 0)
-            { return I + 1; }
-            else
-            { return I - 1; }
-        }
-
         public int IncomingHalfedge(int I)
         {
-            return PairHalfedge(Vertices[I].OutgoingHalfedge);
+            return Halfedges.PairHalfedge(Vertices[I].OutgoingHalfedge);
         }
 
         public int VertexNakedEdgeCount(int V)
@@ -481,7 +451,7 @@ public int VertexNakedEdgeCount(int V)
             for (int i = 0; i < Outgoing.Count; i++)
             {
                 if (Halfedges[Outgoing[i]].AdjacentFace == -1) { NakedCount++; }
-                if (Halfedges[PairHalfedge(Outgoing[i])].AdjacentFace == -1) { NakedCount++; }
+                if (Halfedges[Halfedges.PairHalfedge(Outgoing[i])].AdjacentFace == -1) { NakedCount++; }
             }
             return NakedCount;
         }
diff --git a/PlanktonGh/DecomposePlankton.cs b/PlanktonGh/DecomposePlankton.cs
index 3ac2a36..4ae2954 100644
--- a/PlanktonGh/DecomposePlankton.cs
+++ b/PlanktonGh/DecomposePlankton.cs
@@ -72,7 +72,7 @@ protected override void SolveInstance(IGH_DataAccess DA)
                 AdjF.Add(P.Halfedges[i].AdjacentFace);
                 Next.Add(P.Halfedges[i].NextHalfedge);
                 Prev.Add(P.Halfedges[i].PrevHalfedge);
-                Pair.Add(P.PairHalfedge(i));
+                Pair.Add(P.Halfedges.PairHalfedge(i));
             }
      
             List<int> FaceEdge = new List<int>();

From f92943d2face9611494ad041402c87389c31deb8 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Wed, 24 Jul 2013 11:13:07 +0100
Subject: [PATCH 10/20] Fix xml comments

---
 Plankton/PlanktonFaceList.cs     | 4 ++--
 Plankton/PlanktonHalfedgeList.cs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index 0decf6d..74eb174 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -16,7 +16,7 @@ public class PlanktonFaceList : IEnumerable<PlanktonFace>
         private List<PlanktonFace> _list;
         
         /// <summary>
-        /// Initializes a new instance of the <see cref="PlanktonHalfEdgeList"/> class.
+        /// Initializes a new instance of the <see cref="PlanktonFaceList"/> class.
         /// Should be called from the mesh constructor.
         /// </summary>
         /// <param name="ownerMesh">The mesh to which this list of half-edges belongs.</param>
@@ -27,7 +27,7 @@ internal PlanktonFaceList(PlanktonMesh owner)
         }
         
         /// <summary>
-        /// Gets the number of half-edges.
+        /// Gets the number of faces.
         /// </summary>
         public int Count
         {
diff --git a/Plankton/PlanktonHalfedgeList.cs b/Plankton/PlanktonHalfedgeList.cs
index 0d8466f..d53cdc5 100644
--- a/Plankton/PlanktonHalfedgeList.cs
+++ b/Plankton/PlanktonHalfedgeList.cs
@@ -13,7 +13,7 @@ public class PlanktonHalfEdgeList : IEnumerable<PlanktonHalfedge>
         private List<PlanktonHalfedge> _list;
         
         /// <summary>
-        /// Initializes a new instance of the <see cref="PlanktonHalfEdgeList"/> class.
+        /// Initializes a new instance of the <see cref="PlanktonHalfedgeList"/> class.
         /// Should be called from the mesh constructor.
         /// </summary>
         /// <param name="ownerMesh">The mesh to which this list of halfedges belongs.</param>

From 000207d28848b6459aadf55b8120edb677521621 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Wed, 24 Jul 2013 13:26:26 +0100
Subject: [PATCH 11/20] Add custom collection for vertices

* same idea as halfedge/face list
* new Add methods and vertex constructors
* halfedge circulator for 1-ring
* updated tests
---
 Plankton.Test/MeshTest.cs      |  19 ++-
 Plankton/Plankton.csproj       |   1 +
 Plankton/PlanktonFaceList.cs   |   2 +-
 Plankton/PlanktonMesh.cs       |  93 +-----------
 Plankton/PlanktonVertex.cs     |  14 +-
 Plankton/PlanktonVertexList.cs | 259 +++++++++++++++++++++++++++++++++
 6 files changed, 295 insertions(+), 93 deletions(-)
 create mode 100644 Plankton/PlanktonVertexList.cs

diff --git a/Plankton.Test/MeshTest.cs b/Plankton.Test/MeshTest.cs
index 587383c..bbc75e8 100644
--- a/Plankton.Test/MeshTest.cs
+++ b/Plankton.Test/MeshTest.cs
@@ -45,13 +45,15 @@ public void CanCreateFromFaceVertex()
             // Check that half-edges have been linked up correctly
             
             // Get all outgoing halfedges from vertex #0 and compare against expected
-            List<int> vertexZeroHalfedges = pMesh.VertexAllOutHE(0);
+            int[] vertexZeroHalfedges = pMesh.Vertices.GetHalfedges(0);
             int[] vertexZeroHalfedgesExpected = new int[]{ 13, 5, 6 };
-            Assert.AreEqual(3, vertexZeroHalfedges.Count);
+            Assert.AreEqual(3, vertexZeroHalfedges.Length);
             foreach (int halfedge in vertexZeroHalfedgesExpected)
             {
                 Assert.Contains(halfedge, vertexZeroHalfedges);
             }
+            // Check that none of these edges are on a boundary (closed mesh)
+            Assert.AreEqual(0, pMesh.Vertices.NakedEdgeCount(0));
             
             // Get all halfedges from face #2 and compare against expected
             int[] faceTwoHalfedges = pMesh.Faces.GetHalfedges(2);
@@ -70,13 +72,22 @@ public void CanCreateFromFaceVertex()
             Assert.AreEqual(faceFourVerticesExpected, faceFourVertices);
             
             // Get all faces from vertex #1 and compare against expected
-            List<int> vertexOneFaces = pMesh.VertexFaces(1);
+            int[] vertexOneFaces = pMesh.Vertices.GetVertexFaces(1);
             int[] vertexOneFacesExpected = new int[]{ 0, 1, 2 };
-            Assert.AreEqual(3, vertexOneFaces.Count);
+            Assert.AreEqual(3, vertexOneFaces.Length);
             foreach (int face in vertexOneFacesExpected)
             {
                 Assert.Contains(face, vertexOneFaces);
             }
+            
+            // Get all vertex neighbours from vertex #0 and compare against expected
+            int[] vertexZeroNeighbours = pMesh.Vertices.GetVertexNeighbours(0);
+            int[] vertexZeroNeighboursExpected = new int[]{ 4, 1, 3 };
+            Assert.AreEqual(3, vertexZeroNeighbours.Length);
+            foreach (int vertex in vertexZeroNeighboursExpected)
+            {
+                Assert.Contains(vertex, vertexZeroNeighbours);
+            }
         }
     }
 }
diff --git a/Plankton/Plankton.csproj b/Plankton/Plankton.csproj
index b36aed5..ff72e93 100644
--- a/Plankton/Plankton.csproj
+++ b/Plankton/Plankton.csproj
@@ -48,6 +48,7 @@
     <Compile Include="PlanktonHalfedgeList.cs" />
     <Compile Include="PlanktonMesh.cs" />
     <Compile Include="PlanktonVertex.cs" />
+    <Compile Include="PlanktonVertexList.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index 74eb174..350929b 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -93,7 +93,7 @@ public int AddFace(IEnumerable<int> indices)
                 // Find existing edge, if it exists, by searching 'i'th vertex's neighbourhood
                 if (_mesh.Vertices[v2].OutgoingHalfedge > -1)
                 {
-                    List<int> hs = _mesh.VertexAllOutHE(v2);
+                    int[] hs = _mesh.Vertices.GetHalfedges(v2);
                     foreach (int h in hs)
                     {
                         if (v1 == _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(h)].StartVertex)
diff --git a/Plankton/PlanktonMesh.cs b/Plankton/PlanktonMesh.cs
index 94a6de2..4f6a619 100644
--- a/Plankton/PlanktonMesh.cs
+++ b/Plankton/PlanktonMesh.cs
@@ -11,7 +11,7 @@ namespace Plankton
     public class PlanktonMesh
     {
         #region "members"
-        public List<PlanktonVertex> Vertices;
+        public PlanktonVertexList Vertices;
         public PlanktonHalfEdgeList Halfedges;
         public PlanktonFaceList Faces;
         #endregion
@@ -21,7 +21,7 @@ public PlanktonMesh() //blank constructor
         {
             this.Faces = new PlanktonFaceList(this);
             this.Halfedges = new PlanktonHalfEdgeList(this);
-            this.Vertices = new List<PlanktonVertex>();
+            this.Vertices = new PlanktonVertexList(this);
         }
         public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
             : this()
@@ -210,11 +210,10 @@ public PlanktonMesh(Mesh M) //Create a Plankton Mesh from a Rhino Mesh
         public PlanktonMesh(IEnumerable<Point3d> pts, IEnumerable<IEnumerable<int>> faces)
             : this()
         {
+            // TODO: Should we remove this constructor? I doesn't exactly do much...
+            
             // Add vertices
-            foreach (Point3d pt in pts)
-            {
-                this.Vertices.Add(new PlanktonVertex(pt));
-            }
+            this.Vertices.AddVertices(pts);
             
             // Add faces (and half-edges)
             foreach (IEnumerable<int> face in faces)
@@ -308,7 +307,7 @@ public PlanktonMesh Dual()
 
             for (int i = 0; i < P.Vertices.Count; i++)
             {
-                if (P.VertexNakedEdgeCount(i) == 0)
+                if (P.Vertices.NakedEdgeCount(i) == 0)
                 {
                     D.Faces.Add(new PlanktonFace());
                     // D.Faces[i].FirstHalfedge = P.PairHalfedge(P.Vertices[i].OutgoingHalfedge);
@@ -334,7 +333,7 @@ public PlanktonMesh Dual()
                     //DualHE.StartVertex = PrimalHE.AdjacentFace;
                     DualHE.StartVertex = P.Halfedges[P.Halfedges.PairHalfedge(i)].AdjacentFace;
 
-                    if (P.VertexNakedEdgeCount(PrimalHE.StartVertex) == 0)
+                    if (P.Vertices.NakedEdgeCount(PrimalHE.StartVertex) == 0)
                     {
                         //DualHE.AdjacentFace = P.Halfedges[P.PairHalfedge(i)].StartVertex;
                         DualHE.AdjacentFace = PrimalHE.StartVertex;
@@ -379,83 +378,5 @@ public void RefreshEdgeNormals()
         //skeletonize - build a new mesh with 4 faces for each original edge
 
         #endregion
-
-        #region "Adjacencies"
-        
-        public List<int> VertexNeighbours(int V)
-            //get the vertices connected to a given vertex by an edge (aka 1-ring)
-        {
-            List<int> NeighbourVs = new List<int>();
-            int FirstHalfedge = Halfedges.PairHalfedge(Vertices[V].OutgoingHalfedge);
-            int CurrentHalfedge = FirstHalfedge;
-            do{
-                NeighbourVs.Add(Halfedges[CurrentHalfedge].StartVertex);
-                CurrentHalfedge = Halfedges.PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
-            } while (CurrentHalfedge != FirstHalfedge);
-            return NeighbourVs;
-        }
-
-        public List<int> VertexFaces(int V)
-            // get the faces which use this vertex
-        {
-            List<int> NeighbourFs = new List<int>();
-            int FirstHalfedge = Vertices[V].OutgoingHalfedge;
-            int CurrentHalfedge = FirstHalfedge;
-            do
-            {
-                NeighbourFs.Add(Halfedges[CurrentHalfedge].AdjacentFace);
-                CurrentHalfedge = Halfedges[Halfedges.PairHalfedge(CurrentHalfedge)].NextHalfedge;
-            } while (CurrentHalfedge != FirstHalfedge);
-            return NeighbourFs;
-        }
-
-
-        public List<int> VertexAllOutHE(int V) // all the outgoing Halfedges from a vertex
-        {
-            List<int> OutHEs = new List<int>();
-            int FirstHalfedge = Vertices[V].OutgoingHalfedge;
-            int CurrentHalfedge = FirstHalfedge;
-            do
-            {
-                OutHEs.Add(CurrentHalfedge);
-                CurrentHalfedge = Halfedges[Halfedges.PairHalfedge(CurrentHalfedge)].NextHalfedge;
-            } while (CurrentHalfedge != FirstHalfedge);
-            return OutHEs;
-        }
-
-        public List<int> VertexAllInHE(int V) // all the incoming Halfedges to a vertex
-        {
-            List<int> InHEs = new List<int>();
-            int FirstHalfedge = Halfedges.PairHalfedge(Vertices[V].OutgoingHalfedge);
-            int CurrentHalfedge = FirstHalfedge;
-            do
-            {
-                InHEs.Add(CurrentHalfedge);
-                CurrentHalfedge = Halfedges.PairHalfedge(Halfedges[CurrentHalfedge].NextHalfedge);
-            } while (CurrentHalfedge != FirstHalfedge);
-            return InHEs;
-        }
-
-        public int IncomingHalfedge(int I)
-        {
-            return Halfedges.PairHalfedge(Vertices[I].OutgoingHalfedge);
-        }
-
-        public int VertexNakedEdgeCount(int V)
-            //the number of connected halfedges which are naked
-            //(this should also be the number of naked connected actual *edges*
-            // - because if the hemesh is good then there should never be a pair of 2 boundary halfedges)
-        {
-            int NakedCount = 0;
-            List<int> Outgoing = VertexAllOutHE(V);
-            for (int i = 0; i < Outgoing.Count; i++)
-            {
-                if (Halfedges[Outgoing[i]].AdjacentFace == -1) { NakedCount++; }
-                if (Halfedges[Halfedges.PairHalfedge(Outgoing[i])].AdjacentFace == -1) { NakedCount++; }
-            }
-            return NakedCount;
-        }
-
-        #endregion
     }
 }
diff --git a/Plankton/PlanktonVertex.cs b/Plankton/PlanktonVertex.cs
index 756e2fa..d46b137 100644
--- a/Plankton/PlanktonVertex.cs
+++ b/Plankton/PlanktonVertex.cs
@@ -18,14 +18,24 @@ public PlanktonVertex()
             OutgoingHalfedge = -1;
         }
         public PlanktonVertex(Point3f V)
+            : this()
         {
             Position = (Point3d)V;
-            OutgoingHalfedge = -1;
         }
         public PlanktonVertex(Point3d V)
+            : this()
         {
             Position = V;
-            OutgoingHalfedge = -1;
+        }
+        public PlanktonVertex(double x, double y, double z)
+            : this()
+        {
+            Position = new Point3d(x, y, z);
+        }
+        public PlanktonVertex(float x, float y, float z)
+            : this()
+        {
+            Position = new Point3d(x, y, z);
         }
     }
 }
diff --git a/Plankton/PlanktonVertexList.cs b/Plankton/PlanktonVertexList.cs
new file mode 100644
index 0000000..35a7e1d
--- /dev/null
+++ b/Plankton/PlanktonVertexList.cs
@@ -0,0 +1,259 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+using Rhino.Geometry;
+
+namespace Plankton
+{
+    /// <summary>
+    /// Provides access to the vertices and Vertex related functionality of a Mesh.
+    /// </summary>
+    public class PlanktonVertexList : IEnumerable<PlanktonVertex>
+    {
+        private readonly PlanktonMesh _mesh;
+        private List<PlanktonVertex> _list;
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PlanktonVertexList"/> class.
+        /// Should be called from the mesh constructor.
+        /// </summary>
+        /// <param name="ownerMesh">The mesh to which this list of vertices belongs.</param>
+        internal PlanktonVertexList(PlanktonMesh owner)
+        {
+            this._list = new List<PlanktonVertex>();
+            this._mesh = owner;
+        }
+        
+        /// <summary>
+        /// Gets the number of vertices.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this._list.Count;
+            }
+        }
+        
+        #region methods
+        #region vertex access
+        #region adding
+        /// <summary>
+        /// Adds a new vertex to the end of the Vertex list.
+        /// </summary>
+        /// <param name="halfEdge">Vertex to add.</param>
+        /// <returns>The index of the newly added vertex.</returns>
+        internal int Add(PlanktonVertex vertex)
+        {
+            if (vertex == null) return -1;
+            this._list.Add(vertex);
+            return this.Count - 1;
+        }
+        
+        /// <summary>
+        /// Adds a new vertex to the end of the Vertex list.
+        /// </summary>
+        /// <param name="vertex">Location of new vertex.</param>
+        /// <returns>The index of the newly added vertex.</returns>
+        public int Add(Point3d vertex)
+        {
+            return this.Add(vertex.X, vertex.Y, vertex.Z);
+        }
+        
+        /// <summary>
+        /// Adds a new vertex to the end of the Vertex list.
+        /// </summary>
+        /// <param name="vertex">Location of new vertex.</param>
+        /// <returns>The index of the newly added vertex.</returns>
+        public int Add(Point3f vertex)
+        {
+            return this.Add(vertex.X, vertex.Y, vertex.Z);
+        }
+        
+        /// <summary>
+        /// Adds a new vertex to the end of the Vertex list.
+        /// </summary>
+        /// <param name="x">X component of new vertex coordinate.</param>
+        /// <param name="y">Y component of new vertex coordinate.</param>
+        /// <param name="z">Z component of new vertex coordinate.</param>
+        /// <returns>The index of the newly added vertex.</returns>
+        public int Add(double x, double y, double z)
+        {
+            return this.Add(new PlanktonVertex(x, y, z));
+        }
+        
+        /// <summary>
+        /// Adds a new vertex to the end of the Vertex list.
+        /// </summary>
+        /// <param name="x">X component of new vertex coordinate.</param>
+        /// <param name="y">Y component of new vertex coordinate.</param>
+        /// <param name="z">Z component of new vertex coordinate.</param>
+        /// <returns>The index of the newly added vertex.</returns>
+        public int Add(float x, float y, float z)
+        {
+            return this.Add(new PlanktonVertex(x, y, z));
+        }
+        
+        /// <summary>
+        /// Adds a series of new vertices to the end of the vertex list.
+        /// This overload accepts double-precision points.
+        /// </summary>
+        /// <param name="vertices">A list, an array or any enumerable set of Point3d.</param>
+        public void AddVertices(IEnumerable<Point3d> vertices)
+        {
+            foreach (Point3d v in vertices)
+            {
+                this.Add(v);
+            }
+        }
+        #endregion
+        
+        /// <summary>
+        /// Adds a series of new vertices to the end of the vertex list.
+        /// This overload accepts single-precision points.
+        /// </summary>
+        /// <param name="vertices">A list, an array or any enumerable set of Point3f.</param>
+        public void AddVertices(IEnumerable<Point3f> vertices)
+        {
+            foreach (Point3f v in vertices)
+            {
+                this.Add(v);
+            }
+        }
+        
+        /// <summary>
+        /// Returns the vertex at the given index.
+        /// </summary>
+        /// <param name="index">
+        /// Index of vertex to get.
+        /// Must be larger than or equal to zero and smaller than the Vertex Count of the mesh.
+        /// </param>
+        /// <returns>The vertex at the given index.</returns>
+        public PlanktonVertex this[int index]
+        {
+            get
+            {
+                return this._list[index];
+            }
+            private set
+            {
+                this._list[index] = value;
+            }
+        }
+        #endregion
+        
+        #region traversals
+        /// <summary>
+        /// Gets the halfedges which originate from a vertex.
+        /// </summary>
+        /// <param name="v">A vertex index.</param>
+        /// <returns>The indices of halfedges incident to a particular vertex.
+        /// Ordered clockwise around the vertex.</returns>
+        public int[] GetHalfedges(int v)
+        {
+            return this.GetHalfedgesCirculator(v).ToArray();
+        }
+        
+        /// <summary>
+        /// Traverses the halfedge indices which originate from a vertex.
+        /// </summary>
+        /// <param name="v">A vertex index.</param>
+        /// <returns>An enumerable of halfedge indices incident to the specified vertex.
+        /// Ordered clockwise around the vertex.</returns>
+        public IEnumerable<int> GetHalfedgesCirculator(int v)
+        {
+            int he_first = this[v].OutgoingHalfedge;
+            int he_current = he_first;
+            var hs = _mesh.Halfedges;
+            do
+            {
+                yield return he_current;
+                he_current = hs[hs.PairHalfedge(he_current)].NextHalfedge;
+            }
+            while (he_current != he_first);
+        }
+        #endregion
+        
+        /// <summary>
+        /// Gets the halfedges which end at a vertex.
+        /// </summary>
+        /// <param name="v">A vertex index.</param>
+        /// <returns>The opposing halfedge for each returned by <see cref="GetHalfedges(int)"/>.
+        /// Ordered clockwise around the vertex.</returns>
+        public int[] GetIncomingHalfedges(int v)
+        {
+            return this.GetHalfedgesCirculator(v)
+                .Select(h => _mesh.Halfedges.PairHalfedge(h)).ToArray();
+        }
+        
+        /// <summary>
+        /// Gets vertex neighbours (a.k.a. 1-ring).
+        /// </summary>
+        /// <param name="f">A vertex index.</param>
+        /// <returns>An array of vertex indices incident to the specified vertex.
+        /// Ordered clockwise around the vertex.</returns>
+        public int[] GetVertexNeighbours(int v)
+        {
+            var hs = _mesh.Halfedges;
+            return this.GetHalfedgesCirculator(v)
+                .Select(h => hs[hs.PairHalfedge(h)].StartVertex).ToArray();
+        }
+        
+        /// <summary>
+        /// Gets faces incident to a vertex.
+        /// </summary>
+        /// <param name="v">A vertex index.</param>
+        /// <returns>An array of face indices incident to the specified vertex.
+        /// Ordered clockwise around the vertex</returns>
+        public int[] GetVertexFaces(int v)
+        {
+            return this.GetHalfedgesCirculator(v)
+                .Select(h => _mesh.Halfedges[h].AdjacentFace).ToArray();
+        }
+        
+        /// <summary>
+        /// Gets the number of naked edges incident to this vertex.
+        /// </summary>
+        /// <param name="v">A vertex index.</param>
+        /// <returns>The number of incident halfedges which lie on a boundary.</returns>
+        public int NakedEdgeCount(int v)
+        {
+            int nakedCount = 0;
+            var hs = _mesh.Halfedges;
+            foreach (int i in this.GetHalfedgesCirculator(v))
+            {
+                if (hs[i].AdjacentFace == -1 || hs[hs.PairHalfedge(i)].AdjacentFace == -1)
+                    nakedCount++;
+            }
+            return nakedCount;
+        }
+        
+        /// <summary>
+        /// Gets the first <b>incoming</b> halfedge for a vertex.
+        /// </summary>
+        /// <param name="v">A vertex index.</param>
+        /// <returns>The index of the halfedge paired with the specified vertex's .</returns>
+        public int GetIncomingHalfedge(int v)
+        {
+            return _mesh.Halfedges.PairHalfedge(this[v].OutgoingHalfedge);
+        }
+        #endregion
+        
+        #region IEnumerable implementation
+        /// <summary>
+        /// Gets an enumerator that yields all faces in this collection.
+        /// </summary>
+        /// <returns>An enumerator.</returns>
+        public IEnumerator<PlanktonVertex> GetEnumerator()
+        {
+            return this._list.GetEnumerator();
+        }
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+        #endregion
+    }
+}
\ No newline at end of file

From fc87599f2613ed4c034d7b2c71e12d83d98f3932 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Wed, 24 Jul 2013 14:04:15 +0100
Subject: [PATCH 12/20] tidy up AddFace

* tidy up code and comments
* make use of circulators
---
 Plankton/PlanktonFaceList.cs | 70 ++++++++++++++++++++----------------
 1 file changed, 39 insertions(+), 31 deletions(-)

diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index 350929b..cfe940a 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -63,6 +63,8 @@ public int AddFace(IEnumerable<int> indices)
             
             int[] array = indices.ToArray(); // using Linq for convenience
             
+            var hs = _mesh.Halfedges;
+            var vs = _mesh.Vertices;
             int n = array.Length;
             
             // Don't allow degenerate faces
@@ -72,11 +74,11 @@ public int AddFace(IEnumerable<int> indices)
             foreach (int i in array)
             {
                 // Check that all vertex indices exist in this mesh
-                if (i < 0 || i >= _mesh.Vertices.Count)
+                if (i < 0 || i >= vs.Count)
                     throw new IndexOutOfRangeException("No vertex exists at this index.");
                 // Check that all vertices are on a boundary
-                int outgoing = _mesh.Vertices[i].OutgoingHalfedge;
-                if (outgoing != -1 && _mesh.Halfedges[outgoing].AdjacentFace != -1)
+                int outgoing = vs[i].OutgoingHalfedge;
+                if (outgoing != -1 && hs[outgoing].AdjacentFace != -1)
                     return -1;
             }
             
@@ -91,16 +93,15 @@ public int AddFace(IEnumerable<int> indices)
                 int v1 = array[i], v2 = array[ii];
                 is_new[i] = true;
                 // Find existing edge, if it exists, by searching 'i'th vertex's neighbourhood
-                if (_mesh.Vertices[v2].OutgoingHalfedge > -1)
+                if (vs[v2].OutgoingHalfedge > -1)
                 {
-                    int[] hs = _mesh.Vertices.GetHalfedges(v2);
-                    foreach (int h in hs)
+                    foreach (int h in vs.GetHalfedgesCirculator(v2))
                     {
-                        if (v1 == _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(h)].StartVertex)
+                        if (v1 == hs[hs.PairHalfedge(h)].StartVertex)
                         {
                             // Don't allow non-manifold edges
-                            if (_mesh.Halfedges[_mesh.Halfedges.PairHalfedge(h)].AdjacentFace > -1) return -1;
-                            loop[i] = _mesh.Halfedges.PairHalfedge(h);
+                            if (hs[hs.PairHalfedge(h)].AdjacentFace > -1) return -1;
+                            loop[i] = hs.PairHalfedge(h);
                             is_new[i] = false;
                             break;
                         }
@@ -119,14 +120,15 @@ public int AddFace(IEnumerable<int> indices)
                     loop[i] = _mesh.Halfedges.Count;
                     is_new[i] = true;
                     // he->next = he->pair
-                    _mesh.Halfedges.Add(new PlanktonHalfedge(v1, this.Count, loop[i] + 1));
-                    _mesh.Halfedges.Add(new PlanktonHalfedge(v2, -1, loop[i]));
-                    _mesh.Vertices[v2].OutgoingHalfedge = loop[i] + 1;
+                    hs.Add(new PlanktonHalfedge(v1, this.Count, loop[i] + 1));
+                    hs.Add(new PlanktonHalfedge(v2, -1, loop[i]));
+                    // ensure vertex->outgoing is boundary if vertex is boundary
+                    vs[v2].OutgoingHalfedge = loop[i] + 1;
                 }
                 else
                 {
                     // Link existing halfedge to new face
-                    _mesh.Halfedges[loop[i]].AdjacentFace = this.Count;
+                    hs[loop[i]].AdjacentFace = this.Count;
                 }
             }
             
@@ -135,44 +137,50 @@ public int AddFace(IEnumerable<int> indices)
             {
                 int v1 = array[i], v2 = array[ii];
                 int id = 0;
-                if (is_new[i])  id += 1;
-                if (is_new[ii]) id += 2;
+                if (is_new[i])  id += 1; // first is new
+                if (is_new[ii]) id += 2; // second is new
                 
                 if (id > 0) // At least one of the halfedge pairs is new...
                 {
                     // Link inner halfedges
-                    _mesh.Halfedges[loop[i]].NextHalfedge = loop[ii];
-                    _mesh.Halfedges[loop[ii]].PrevHalfedge = loop[i];
+                    hs[loop[i]].NextHalfedge = loop[ii];
+                    hs[loop[ii]].PrevHalfedge = loop[i];
                     
                     // Link outer halfedges
-                    int firstHalfedge, currentHalfedge;
+                    int outer_prev = -1, outer_next = -1;
                     switch (id)
                     {
                         case 1: // first is new, second is old
                             // iterate through halfedges clockwise around vertex #v2 until boundary
-                            firstHalfedge = loop[ii];
-                            currentHalfedge = firstHalfedge;
-                            do
+                            foreach (int h in vs.GetHalfedgesCirculator(v2))
                             {
-                                int pair = _mesh.Halfedges.PairHalfedge(currentHalfedge);
-                                currentHalfedge = _mesh.Halfedges[pair].NextHalfedge;
-                            } while (_mesh.Halfedges[_mesh.Halfedges.PairHalfedge(currentHalfedge)].AdjacentFace > -1);
-                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(currentHalfedge)].NextHalfedge = _mesh.Halfedges.PairHalfedge(loop[i]);
-                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(loop[i])].PrevHalfedge = _mesh.Halfedges.PairHalfedge(currentHalfedge);
+                                if (hs[hs.PairHalfedge(h)].AdjacentFace < 0) // boundary
+                                {
+                                    outer_prev = hs.PairHalfedge(h);
+                                    outer_next = hs.PairHalfedge(loop[i]);
+                                    break;
+                                }
+                            }
                             break;
                         case 2: // second is new, first is old
-                            int outer_next = _mesh.Vertices[v2].OutgoingHalfedge;
-                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(loop[ii])].NextHalfedge = outer_next;
-                            _mesh.Halfedges[outer_next].PrevHalfedge = _mesh.Halfedges.PairHalfedge(loop[ii]);
+                            outer_prev = hs.PairHalfedge(loop[ii]);
+                            outer_next = _mesh.Vertices[v2].OutgoingHalfedge;
                             break;
                         case 3: // both are new
-                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(loop[ii])].NextHalfedge = _mesh.Halfedges.PairHalfedge(loop[i]);
-                            _mesh.Halfedges[_mesh.Halfedges.PairHalfedge(loop[i])].PrevHalfedge = _mesh.Halfedges.PairHalfedge(loop[ii]);
+                            outer_prev = hs.PairHalfedge(loop[ii]);
+                            outer_next = hs.PairHalfedge(loop[i]);
                             break;
                     }
+                    // outer_{prev,next} should now be set, so store links in HDS
+                    if (outer_prev > -1 && outer_next > -1)
+                    {
+                        hs[outer_prev].NextHalfedge = outer_next;
+                        hs[outer_next].PrevHalfedge = outer_prev;
+                    }
                 }
             }
             
+            // Finally, add the face and return its index
             PlanktonFace f = new PlanktonFace();
             f.FirstHalfedge = loop[0];
             

From 217f742a4f61e5c2c4fcdde17eb8d017d7a9f0a4 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Wed, 24 Jul 2013 21:27:46 +0100
Subject: [PATCH 13/20] Tidy up collections

* modify circulators to handle naked faces or vertices
* refactor methods to add and find halfedge into halfedge list
* lots of tidying up
* add more tests
---
 Plankton.Test/MeshTest.cs          | 48 ++++++++++++-------------
 Plankton.Test/Plankton.Test.csproj |  1 +
 Plankton.Test/VertexTest.cs        | 28 +++++++++++++++
 Plankton/PlanktonFaceList.cs       | 58 +++++++++++++-----------------
 Plankton/PlanktonHalfedgeList.cs   | 35 ++++++++++++++++++
 Plankton/PlanktonVertexList.cs     |  1 +
 6 files changed, 111 insertions(+), 60 deletions(-)
 create mode 100644 Plankton.Test/VertexTest.cs

diff --git a/Plankton.Test/MeshTest.cs b/Plankton.Test/MeshTest.cs
index bbc75e8..0d5932f 100644
--- a/Plankton.Test/MeshTest.cs
+++ b/Plankton.Test/MeshTest.cs
@@ -1,8 +1,6 @@
-using Plankton;
-using NUnit.Framework;
-using Rhino.Geometry;
-using System;
+using System;
 using System.Collections.Generic;
+using NUnit.Framework;
 
 namespace Plankton.Test
 {
@@ -14,35 +12,29 @@ public void CanCreateFromFaceVertex()
         {
             // Create a simple cube
             
-            var pts = new Point3d[]
-            {
-                new Point3d(-0.5, -0.5, 0.5),
-                new Point3d(-0.5, -0.5, -0.5),
-                new Point3d(-0.5, 0.5, -0.5),
-                new Point3d(-0.5, 0.5, 0.5),
-                new Point3d(0.5, -0.5, 0.5),
-                new Point3d(0.5, -0.5, -0.5),
-                new Point3d(0.5, 0.5, -0.5),
-                new Point3d(0.5, 0.5, 0.5)
-            };
+            PlanktonMesh pMesh = new PlanktonMesh();
             
-            var fs = new int[][]
-            {
-                new int[]{ 3, 2, 1, 0 },
-                new int[]{ 1, 5, 4, 0 },
-                new int[]{ 2, 6, 5, 1 },
-                new int[]{ 7, 6, 2, 3 },
-                new int[]{ 4, 7, 3, 0 },
-                new int[]{ 5, 6, 7, 4 }
-            };
+            pMesh.Vertices.Add(-0.5, -0.5, 0.5);
+            pMesh.Vertices.Add(-0.5, -0.5, -0.5);
+            pMesh.Vertices.Add(-0.5, 0.5, -0.5);
+            pMesh.Vertices.Add(-0.5, 0.5, 0.5);
+            pMesh.Vertices.Add(0.5, -0.5, 0.5);
+            pMesh.Vertices.Add(0.5, -0.5, -0.5);
+            pMesh.Vertices.Add(0.5, 0.5, -0.5);
+            pMesh.Vertices.Add(0.5, 0.5, 0.5);
             
-            // Create a PlanktonMesh from the points and face-vertex indices
+            pMesh.Faces.AddFace(new int[]{ 3, 2, 1, 0 });
+            pMesh.Faces.AddFace(new int[]{ 1, 5, 4, 0 });
+            pMesh.Faces.AddFace(new int[]{ 2, 6, 5, 1 });
+            pMesh.Faces.AddFace(new int[]{ 7, 6, 2, 3 });
+            pMesh.Faces.AddFace(new int[]{ 4, 7, 3, 0 });
+            pMesh.Faces.AddFace(new int[]{ 5, 6, 7, 4 });
             
-            PlanktonMesh pMesh = new PlanktonMesh(pts, fs);
             
             Assert.AreEqual(24, pMesh.Halfedges.Count);
             
             // Check that half-edges have been linked up correctly
+            // TODO: Add individual unit tests to verify the methods used below
             
             // Get all outgoing halfedges from vertex #0 and compare against expected
             int[] vertexZeroHalfedges = pMesh.Vertices.GetHalfedges(0);
@@ -88,6 +80,10 @@ public void CanCreateFromFaceVertex()
             {
                 Assert.Contains(vertex, vertexZeroNeighbours);
             }
+            
+            // Check that halfedges exist where they are expected to
+            Assert.AreEqual(13, pMesh.Halfedges.FindHalfedge(0, 4)); // exists
+            Assert.AreEqual(-1, pMesh.Halfedges.FindHalfedge(1, 3)); // doesn't exist
         }
     }
 }
diff --git a/Plankton.Test/Plankton.Test.csproj b/Plankton.Test/Plankton.Test.csproj
index e840cf5..562b3ab 100644
--- a/Plankton.Test/Plankton.Test.csproj
+++ b/Plankton.Test/Plankton.Test.csproj
@@ -49,6 +49,7 @@
   <ItemGroup>
     <Compile Include="MeshTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="VertexTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Plankton\Plankton.csproj">
diff --git a/Plankton.Test/VertexTest.cs b/Plankton.Test/VertexTest.cs
new file mode 100644
index 0000000..951c25a
--- /dev/null
+++ b/Plankton.Test/VertexTest.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace Plankton.Test
+{
+    [TestFixture]
+    public class VertexTest
+    {
+        [Test]
+        public void CanTraverseNakedVertex()
+        {
+            PlanktonMesh pMesh = new PlanktonMesh();
+            pMesh.Vertices.Add(0, 0, 0);
+            pMesh.Vertices.Add(1, 1, 1);
+            Assert.AreEqual(0, pMesh.Vertices.GetHalfedgesCirculator(0).Count());
+        }
+        
+        [Test]
+        public void CanFindHalfedgeNakedVertex()
+        {
+            PlanktonMesh pMesh = new PlanktonMesh();
+            pMesh.Vertices.Add(0, 0, 0);
+            pMesh.Vertices.Add(1, 1, 1);
+            Assert.AreEqual(-1, pMesh.Halfedges.FindHalfedge(0, 1));
+        }
+    }
+}
diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index cfe940a..f298abe 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -54,8 +54,9 @@ internal int Add(PlanktonFace face)
         /// <summary>
         /// Adds a new face to the end of the Face list. Creates any halfedge pairs that are required.
         /// </summary>
-        /// <param name="indices">The vertex indices which define this face, ordered anticlockwise.</param>
-        /// <returns>The index of the newly added face.</returns>
+        /// <param name="indices">The vertex indices which define the face, ordered anticlockwise.</param>
+        /// <returns>The index of the newly added face (-1 in the case that the face could not be added).</returns>
+        /// <remarks>The mesh must remain 2-manifold and orientable at all times.</remarks>
         public int AddFace(IEnumerable<int> indices)
         {
             // This method always ensures that if a vertex lies on a boundary,
@@ -91,22 +92,17 @@ public int AddFace(IEnumerable<int> indices)
             for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
             {
                 int v1 = array[i], v2 = array[ii];
-                is_new[i] = true;
-                // Find existing edge, if it exists, by searching 'i'th vertex's neighbourhood
-                if (vs[v2].OutgoingHalfedge > -1)
-                {
-                    foreach (int h in vs.GetHalfedgesCirculator(v2))
-                    {
-                        if (v1 == hs[hs.PairHalfedge(h)].StartVertex)
-                        {
-                            // Don't allow non-manifold edges
-                            if (hs[hs.PairHalfedge(h)].AdjacentFace > -1) return -1;
-                            loop[i] = hs.PairHalfedge(h);
-                            is_new[i] = false;
-                            break;
-                        }
-                    }
-                }
+
+                // Find existing edge, if it exists
+                int h = hs.FindHalfedge(v1, v2);
+                if (h < 0)
+                    // No halfedge found, mark for creation
+                    is_new[i] = true;
+                else if (hs[h].AdjacentFace > -1)
+                    // Existing halfedge already has a face (non-manifold)
+                    return -1;
+                else
+                    loop[i] = h;
             }
             
             // Now create any missing halfedge pairs...
@@ -114,14 +110,10 @@ public int AddFace(IEnumerable<int> indices)
             // any recently added halfedges should a non-manifold condition be found.)
             for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
             {
-                if (is_new[i]) // new halfedge pair requireds
+                if (is_new[i]) // new halfedge pair required
                 {
                     int v1 = array[i], v2 = array[ii];
-                    loop[i] = _mesh.Halfedges.Count;
-                    is_new[i] = true;
-                    // he->next = he->pair
-                    hs.Add(new PlanktonHalfedge(v1, this.Count, loop[i] + 1));
-                    hs.Add(new PlanktonHalfedge(v2, -1, loop[i]));
+                    loop[i] = hs.AddPair(v1, v2, this.Count);
                     // ensure vertex->outgoing is boundary if vertex is boundary
                     vs[v2].OutgoingHalfedge = loop[i] + 1;
                 }
@@ -135,6 +127,9 @@ public int AddFace(IEnumerable<int> indices)
             // Link halfedges
             for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
             {
+                // TODO: consider case of non-manifold vertex
+                // (i.e. vertex with 2+ outgoing boundary halfedges)
+                
                 int v1 = array[i], v2 = array[ii];
                 int id = 0;
                 if (is_new[i])  id += 1; // first is new
@@ -152,19 +147,13 @@ public int AddFace(IEnumerable<int> indices)
                     {
                         case 1: // first is new, second is old
                             // iterate through halfedges clockwise around vertex #v2 until boundary
-                            foreach (int h in vs.GetHalfedgesCirculator(v2))
-                            {
-                                if (hs[hs.PairHalfedge(h)].AdjacentFace < 0) // boundary
-                                {
-                                    outer_prev = hs.PairHalfedge(h);
-                                    outer_next = hs.PairHalfedge(loop[i]);
-                                    break;
-                                }
-                            }
+                            outer_prev = hs.PairHalfedge(vs.GetHalfedgesCirculator(v2)
+                                                         .First(h => hs[hs.PairHalfedge(h)].AdjacentFace < 0));
+                            outer_next = hs.PairHalfedge(loop[i]);
                             break;
                         case 2: // second is new, first is old
                             outer_prev = hs.PairHalfedge(loop[ii]);
-                            outer_next = _mesh.Vertices[v2].OutgoingHalfedge;
+                            outer_next = vs[v2].OutgoingHalfedge;
                             break;
                         case 3: // both are new
                             outer_prev = hs.PairHalfedge(loop[ii]);
@@ -229,6 +218,7 @@ public int[] GetHalfedges(int f)
         public IEnumerable<int> GetHalfedgesCirculator(int f)
         {
             int he_first = this[f].FirstHalfedge;
+            if (he_first < 0) yield break; // face has no connectivity, exit
             int he_current = he_first;
             do
             {
diff --git a/Plankton/PlanktonHalfedgeList.cs b/Plankton/PlanktonHalfedgeList.cs
index d53cdc5..69c850f 100644
--- a/Plankton/PlanktonHalfedgeList.cs
+++ b/Plankton/PlanktonHalfedgeList.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Plankton
 {
@@ -48,6 +49,22 @@ public int Add(PlanktonHalfedge halfedge)
             return this.Count - 1;
         }
         
+        /// <summary>
+        /// Add a pair of halfedges to the mesh.
+        /// </summary>
+        /// <param name="start">A vertex index (from which the first halfedge originates).</param>
+        /// <param name="end">A vertex index (from which the second halfedge originates).</param>
+        /// <param name="face">A face index (adjacent to the first halfedge).</param>
+        /// <returns>The index of the first halfedge in the pair.</returns>
+        public int AddPair(int start, int end, int face)
+        {
+            // he->next = he->pair
+            int i = this.Count;
+            this.Add(new PlanktonHalfedge(start, face, i + 1));
+            this.Add(new PlanktonHalfedge(end, -1, i));
+            return i;
+        }
+        
         /// <summary>
         /// Returns the halfedge at the given index.
         /// </summary>
@@ -99,6 +116,24 @@ public int[] GetVertices(int index)
         }
         #endregion
         
+        /// <summary>
+        /// Gets the halfedge index between two vertices.
+        /// </summary>
+        /// <param name="start">A vertex index.</param>
+        /// <param name="end">A vertex index.</param>
+        /// <returns>If it exists, the index of the halfedge which originates
+        /// from <paramref name="start"/> and terminates at <paramref name="end"/>.
+        /// Otherwise -1 is returned.</returns>
+        public int FindHalfedge(int start, int end)
+        {
+            foreach (int h in _mesh.Vertices.GetHalfedgesCirculator(start))
+            {
+                if (end == this[this.PairHalfedge(h)].StartVertex)
+                    return h;
+            }
+            return -1;
+        }
+        
         public void FlipEdge(int index)
         {
             // to flip an edge
diff --git a/Plankton/PlanktonVertexList.cs b/Plankton/PlanktonVertexList.cs
index 35a7e1d..e586027 100644
--- a/Plankton/PlanktonVertexList.cs
+++ b/Plankton/PlanktonVertexList.cs
@@ -165,6 +165,7 @@ public int[] GetHalfedges(int v)
         public IEnumerable<int> GetHalfedgesCirculator(int v)
         {
             int he_first = this[v].OutgoingHalfedge;
+            if (he_first < 0) yield break; // vertex has no connectivity, exit
             int he_current = he_first;
             var hs = _mesh.Halfedges;
             do

From 037f818975669c907bbba250a5aeed334dc01900 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Sat, 27 Jul 2013 19:49:57 +0100
Subject: [PATCH 14/20] Implement edge flipping

* See xml comment for implementation details
* Could add an overload to specify the direction of the edge 'shift' in quad/n-gon applications?
* A simple test is included
* Rough and ready implementation - needs refactoring
---
 Plankton.Test/HalfedgeTest.cs      | 50 +++++++++++++++++++++++++++
 Plankton.Test/Plankton.Test.csproj |  1 +
 Plankton/PlanktonHalfedgeList.cs   | 54 ++++++++++++++++++++++++++++--
 3 files changed, 103 insertions(+), 2 deletions(-)
 create mode 100644 Plankton.Test/HalfedgeTest.cs

diff --git a/Plankton.Test/HalfedgeTest.cs b/Plankton.Test/HalfedgeTest.cs
new file mode 100644
index 0000000..f3a620e
--- /dev/null
+++ b/Plankton.Test/HalfedgeTest.cs
@@ -0,0 +1,50 @@
+using System;
+using NUnit.Framework;
+
+namespace Plankton.Test
+{
+    [TestFixture]
+    public class HalfedgeTest
+    {
+        [Test]
+        public void CanFlipEdge()
+        {
+            // Create a simple square
+            
+            PlanktonMesh pMesh = new PlanktonMesh();
+            
+            pMesh.Vertices.Add(-0.5, -0.5, 0.0); // bottom-left
+            pMesh.Vertices.Add(-0.5, 0.5, 0.0);  // top-left
+            pMesh.Vertices.Add(0.5, 0.5, 0.0);   // top right
+            pMesh.Vertices.Add(0.5, -0.5, 0.0);  // bottom-right
+            
+            pMesh.Faces.AddFace(new int[]{ 0, 2, 1 });
+            pMesh.Faces.AddFace(new int[]{ 2, 0, 3 });
+            
+            // Flip zero-th halfedge
+            
+            Assert.IsTrue(pMesh.Halfedges.FlipEdge(0));
+            
+            // Check vertices for each face
+            Assert.AreEqual(new int[]{ 3, 1, 0 }, pMesh.Faces.GetVertices(0));
+            Assert.AreEqual(new int[]{ 1, 3, 2 }, pMesh.Faces.GetVertices(1));
+            
+            // Check adjacent face in each interior halfedge is correct
+            foreach (int h in pMesh.Faces.GetHalfedgesCirculator(0))
+            {
+                Assert.AreEqual(0, pMesh.Halfedges[h].AdjacentFace);
+            }
+            foreach (int h in pMesh.Faces.GetHalfedgesCirculator(1))
+            {
+                Assert.AreEqual(1, pMesh.Halfedges[h].AdjacentFace);
+            }
+            
+            // Check halfedges for each vertex
+            Assert.AreEqual(new int[]{ 5, 6 }, pMesh.Vertices.GetHalfedges(0));
+            Assert.AreEqual(new int[]{ 3, 1, 4 }, pMesh.Vertices.GetHalfedges(1));
+            Assert.AreEqual(new int[]{ 9, 2 }, pMesh.Vertices.GetHalfedges(2));
+            Assert.AreEqual(new int[]{ 7, 0, 8 }, pMesh.Vertices.GetHalfedges(3));
+            
+        }
+    }
+}
diff --git a/Plankton.Test/Plankton.Test.csproj b/Plankton.Test/Plankton.Test.csproj
index 562b3ab..98326cf 100644
--- a/Plankton.Test/Plankton.Test.csproj
+++ b/Plankton.Test/Plankton.Test.csproj
@@ -47,6 +47,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="HalfedgeTest.cs" />
     <Compile Include="MeshTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="VertexTest.cs" />
diff --git a/Plankton/PlanktonHalfedgeList.cs b/Plankton/PlanktonHalfedgeList.cs
index 69c850f..5a89e3a 100644
--- a/Plankton/PlanktonHalfedgeList.cs
+++ b/Plankton/PlanktonHalfedgeList.cs
@@ -134,16 +134,66 @@ public int FindHalfedge(int start, int end)
             return -1;
         }
         
-        public void FlipEdge(int index)
+        internal int EndVertex(int index)
         {
+            return this[PairHalfedge(index)].StartVertex;
+        }
+        
+        internal void MakeAdjacent(int prev, int next)
+        {
+            this[prev].NextHalfedge = next;
+            this[next].PrevHalfedge = prev;
+        }
+        
+        /// <summary>
+        /// Performs an edge flip. This works by shifting the start/end vertices of the edge
+        /// anticlockwise around their faces (by one vertex) and as such can be applied to any
+        /// n-gon mesh, not just triangulations.
+        /// </summary>
+        /// <param name="index">The index of a halfedge in the edge to be flipped.</param>
+        /// <returns>True on success, otherwise false.</returns>
+        public bool FlipEdge(int index)
+        {
+            // Don't allow if halfedge is on a boundary
+            if (this[index].AdjacentFace < 0 || this[PairHalfedge(index)].AdjacentFace < 0)
+                return false;
+            
+            // Make a note of some useful halfedges, along with 'index' itself
+            int pair = this.PairHalfedge(index);
+            int next = this[index].NextHalfedge;
+            int pair_next = this[pair].NextHalfedge;
+            
             // to flip an edge
             // update 2 start verts
+            this[index].StartVertex = EndVertex(pair_next);
+            this[pair].StartVertex = EndVertex(next);
             // 2 adjacentfaces
+            this[next].AdjacentFace = this[pair].AdjacentFace;
+            this[pair_next].AdjacentFace = this[index].AdjacentFace;
             // 6 nexts
             // 6 prevs
+            this.MakeAdjacent(this[pair].PrevHalfedge, next);
+            this.MakeAdjacent(index, this[next].NextHalfedge);
+            this.MakeAdjacent(next, pair);
+            this.MakeAdjacent(this[index].PrevHalfedge, pair_next);
+            this.MakeAdjacent(pair, this[pair_next].NextHalfedge);
+            this.MakeAdjacent(pair_next, index);
             // for each vert, check if need to update outgoing
+            int v = this[index].StartVertex;
+            if (_mesh.Vertices[v].OutgoingHalfedge == index)
+                _mesh.Vertices[v].OutgoingHalfedge = pair_next;
+            v = this[pair].StartVertex;
+            if (_mesh.Vertices[v].OutgoingHalfedge == pair)
+                _mesh.Vertices[v].OutgoingHalfedge = next;
             // for each face, check if need to update start he
-            throw new NotImplementedException();
+            int f = this[index].AdjacentFace;
+            if (_mesh.Faces[f].FirstHalfedge == next)
+                _mesh.Faces[f].FirstHalfedge = index;
+            f = this[pair].AdjacentFace;
+            if (_mesh.Faces[f].FirstHalfedge == pair_next)
+                _mesh.Faces[f].FirstHalfedge = pair;
+            
+            return true;
         }
         
         public void SplitEdge(int index)

From 7e2457af0ae3197265a1a49586d247d14f8abc56 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Fri, 26 Jul 2013 18:16:49 +0100
Subject: [PATCH 15/20] Enhanced face creation handles non-manifold vertices

When constructing a halfedge mesh from a face-vertex representation it is highly possible that a non-manifold vertex case might arise. This condition could simply be caught (and the face rejected) but it was more fun to try and allow it...
---
 Plankton.Test/MeshTest.cs    | 55 +++++++++++++++++++++++++++
 Plankton/PlanktonFaceList.cs | 74 ++++++++++++++++++++++++++++++------
 2 files changed, 118 insertions(+), 11 deletions(-)

diff --git a/Plankton.Test/MeshTest.cs b/Plankton.Test/MeshTest.cs
index 0d5932f..016da2d 100644
--- a/Plankton.Test/MeshTest.cs
+++ b/Plankton.Test/MeshTest.cs
@@ -85,5 +85,60 @@ public void CanCreateFromFaceVertex()
             Assert.AreEqual(13, pMesh.Halfedges.FindHalfedge(0, 4)); // exists
             Assert.AreEqual(-1, pMesh.Halfedges.FindHalfedge(1, 3)); // doesn't exist
         }
+        
+        [Test]
+        public void CanAddFacesNonManifoldVertex()
+        {
+            // a.k.a. the pizza slice test...
+            
+            PlanktonMesh pMesh = new PlanktonMesh();
+            
+            pMesh.Vertices.Add(0.0, 0.0, 0.0);   // 0 - center
+            pMesh.Vertices.Add(-0.5, -0.2, 0.0); // 1 - left/bottom
+            pMesh.Vertices.Add(-0.5, 0.2, 0.0);  // 2 - left/top
+            pMesh.Vertices.Add(-0.2, 0.5, 0.0);  // 3 - top/left
+            pMesh.Vertices.Add(0.2, 0.5, 0.0);   // 4 - top/right
+            pMesh.Vertices.Add(0.5, 0.2, 0.0);   // 5 - right/top
+            pMesh.Vertices.Add(0.5, -0.2, 0.0);  // 6 - right/bottom
+            
+            
+            // Add the first face
+            pMesh.Faces.AddFace(new int[]{ 2, 1, 0 });
+            
+            // Check vertex #0 outgoing halfedge index
+            Assert.AreEqual(3, pMesh.Vertices[0].OutgoingHalfedge);
+            
+            // Add a face which would create a non-manifold condition at vertex #1
+            pMesh.Faces.AddFace(new int[]{ 0, 4, 3 });
+            
+            //Assert.AreEqual(12, pMesh.Halfedges.Count);
+            
+            // Check that vertex #0 has the expected number of boundary edges
+            Assert.AreEqual(4, pMesh.Vertices.NakedEdgeCount(0));
+            
+            // Check vertex #0 outgoing halfedge index
+            Assert.AreEqual(11, pMesh.Vertices[0].OutgoingHalfedge);
+            
+            
+            // Add another face and check again
+            pMesh.Faces.AddFace(new int[]{ 6, 5, 0 });
+            Assert.AreEqual(6, pMesh.Vertices.NakedEdgeCount(0));
+            Assert.AreEqual(15, pMesh.Vertices[0].OutgoingHalfedge);
+            
+            
+            // Plug a gap - vertex #0 ->outgoing should move
+            pMesh.Faces.AddFace(new int[]{ 5, 4, 0 });
+            //Assert.AreEqual(4, pMesh.Vertices.NakedEdgeCount(0));
+            Assert.IsTrue(pMesh.Halfedges[pMesh.Vertices[0].OutgoingHalfedge].AdjacentFace < 0);
+            
+            
+            // Plug another gap which should make vertex #0 manifold again
+            int f = pMesh.Faces.AddFace(new int[]{ 0, 3, 2 });
+            Assert.AreEqual(6, pMesh.Vertices.GetHalfedges(0).Length);
+            
+            // Try adding a face which already exits
+            f = pMesh.Faces.AddFace(new int[]{ 0, 5, 4 });
+            Assert.AreEqual(-1, f, "Face not added.");
+        }
     }
 }
diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index f298abe..8d07b1e 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -103,19 +103,19 @@ public int AddFace(IEnumerable<int> indices)
                     return -1;
                 else
                     loop[i] = h;
+                // NOTE: To PREVENT non-manifold vertices, uncomment the line below...
+                //if(is_new[i] && is_new[(i+n-1)%n] && vs[v2].OutgoingHalfedge > -1) return -1;
             }
             
             // Now create any missing halfedge pairs...
             // (This could be done in the loop above but it avoids having to tidy up
-            // any recently added halfedges should a non-manifold condition be found.)
+            // any recently added halfedges should a non-manifold edge be found.)
             for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
             {
                 if (is_new[i]) // new halfedge pair required
                 {
                     int v1 = array[i], v2 = array[ii];
                     loop[i] = hs.AddPair(v1, v2, this.Count);
-                    // ensure vertex->outgoing is boundary if vertex is boundary
-                    vs[v2].OutgoingHalfedge = loop[i] + 1;
                 }
                 else
                 {
@@ -127,20 +127,23 @@ public int AddFace(IEnumerable<int> indices)
             // Link halfedges
             for (int i = 0, ii = 1; i < n; i++, ii++, ii %= n)
             {
-                // TODO: consider case of non-manifold vertex
-                // (i.e. vertex with 2+ outgoing boundary halfedges)
-                
                 int v1 = array[i], v2 = array[ii];
                 int id = 0;
                 if (is_new[i])  id += 1; // first is new
                 if (is_new[ii]) id += 2; // second is new
                 
+                // Check for non-manifold vertex case, i.e. both current halfedges are new
+                // but the vertex between them is already part of another face. This vertex
+                // will have TWO OR MORE outgoing boundary halfedges! (Not strictly allowed,
+                // but it could happen if faces are added in an UGLY order.)
+                // TODO: If a mesh has non-manifold vertices perhaps it should be considered
+                // INVALID. Any operations performed on such a mesh cannot be relied upon to
+                // perform correctly as the adjacency information may not be correct.
+                // (More reading: http://www.pointclouds.org/blog/nvcs/)
+                if (id == 3 && vs[v2].OutgoingHalfedge > -1) id++; // id == 4
+                
                 if (id > 0) // At least one of the halfedge pairs is new...
                 {
-                    // Link inner halfedges
-                    hs[loop[i]].NextHalfedge = loop[ii];
-                    hs[loop[ii]].PrevHalfedge = loop[i];
-                    
                     // Link outer halfedges
                     int outer_prev = -1, outer_next = -1;
                     switch (id)
@@ -153,12 +156,22 @@ public int AddFace(IEnumerable<int> indices)
                             break;
                         case 2: // second is new, first is old
                             outer_prev = hs.PairHalfedge(loop[ii]);
-                            outer_next = vs[v2].OutgoingHalfedge;
+                            outer_next = hs[loop[i]].NextHalfedge;
                             break;
                         case 3: // both are new
                             outer_prev = hs.PairHalfedge(loop[ii]);
                             outer_next = hs.PairHalfedge(loop[i]);
                             break;
+                        case 4: // both are new (non-manifold vertex)
+                            // We have TWO boundaries to take care of here: first...
+                            outer_prev = hs[vs[v2].OutgoingHalfedge].PrevHalfedge;
+                            outer_next = hs.PairHalfedge(loop[i]);
+                            hs[outer_prev].NextHalfedge = outer_next;
+                            hs[outer_next].PrevHalfedge = outer_prev;
+                            // and second...
+                            outer_prev = hs.PairHalfedge(loop[ii]);
+                            outer_next = vs[v2].OutgoingHalfedge;
+                            break;
                     }
                     // outer_{prev,next} should now be set, so store links in HDS
                     if (outer_prev > -1 && outer_next > -1)
@@ -166,6 +179,45 @@ public int AddFace(IEnumerable<int> indices)
                         hs[outer_prev].NextHalfedge = outer_next;
                         hs[outer_next].PrevHalfedge = outer_prev;
                     }
+                    
+                    // Link inner halfedges
+                    hs[loop[i]].NextHalfedge = loop[ii];
+                    hs[loop[ii]].PrevHalfedge = loop[i];
+                    
+                    // ensure vertex->outgoing is boundary if vertex is boundary
+                    if (is_new[i]) // first is new
+                        vs[v2].OutgoingHalfedge = loop[i] + 1;
+                }
+                else // both old (non-manifold vertex trickery below)
+                {
+                    // In the case that v2 links to the current second halfedge, creating a
+                    // face here will redefine v2 as a non-boundary vertex. Do a quick lap of
+                    // v2's other outgoing halfedges in case one of them is still a boundary
+                    // (as will be the case if v2 was non-manifold).
+                    if (vs[v2].OutgoingHalfedge == loop[ii])
+                    {
+                        foreach (int h in vs.GetHalfedgesCirculator(v2).Skip(1))
+                        {
+                            if (hs[h].AdjacentFace < 0)
+                            {
+                                vs[v2].OutgoingHalfedge = h;
+                                break;
+                            }
+                        }
+                    }
+                    // If inner loop exists, but for some reason it's not linked (non-manifold vertex)
+                    // make loop[i] adjacent to loop[ii].
+                    // TODO: In the current implementation (below) by making loop[i]->next and
+                    // loop[ii]->prev adjacent a face will be 'hidden' from vertex v2 until another face
+                    // is added which connects it with another face which is both incident to v2 and
+                    // 'known' to v2. Non-manifold vertices are tricky...
+                    if (hs[loop[i]].NextHalfedge != loop[ii] || hs[loop[ii]].PrevHalfedge != loop[i])
+                    {
+                        hs[hs[loop[i]].NextHalfedge].PrevHalfedge = hs[loop[ii]].PrevHalfedge;
+                        hs[hs[loop[ii]].PrevHalfedge].NextHalfedge = hs[loop[i]].NextHalfedge;
+                        hs[loop[i]].NextHalfedge = loop[ii];
+                        hs[loop[ii]].PrevHalfedge = loop[i];
+                    }
                 }
             }
             

From bbc2d07866ea56df6d04292dd10434537595348e Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Tue, 30 Jul 2013 14:01:26 +0100
Subject: [PATCH 16/20] Fix bug in non-manifold vertex handling

* When re-linking halfedges to accommodate a new face which is incident to a non-manifold vertex, ensure that all existing halfedges remain accessible to the vertex.
* Add new vertex-halfedge circulator which allows user to specify starting point.
---
 Plankton.Test/MeshTest.cs      |  5 ++++-
 Plankton/PlanktonFaceList.cs   | 27 ++++++++++++++++-----------
 Plankton/PlanktonVertexList.cs | 27 +++++++++++++++++++++++++++
 3 files changed, 47 insertions(+), 12 deletions(-)

diff --git a/Plankton.Test/MeshTest.cs b/Plankton.Test/MeshTest.cs
index 016da2d..ba6d878 100644
--- a/Plankton.Test/MeshTest.cs
+++ b/Plankton.Test/MeshTest.cs
@@ -124,17 +124,20 @@ public void CanAddFacesNonManifoldVertex()
             pMesh.Faces.AddFace(new int[]{ 6, 5, 0 });
             Assert.AreEqual(6, pMesh.Vertices.NakedEdgeCount(0));
             Assert.AreEqual(15, pMesh.Vertices[0].OutgoingHalfedge);
+            Assert.AreEqual(6, pMesh.Vertices.GetHalfedges(0).Length);
             
             
             // Plug a gap - vertex #0 ->outgoing should move
             pMesh.Faces.AddFace(new int[]{ 5, 4, 0 });
-            //Assert.AreEqual(4, pMesh.Vertices.NakedEdgeCount(0));
+            Assert.AreEqual(4, pMesh.Vertices.NakedEdgeCount(0));
             Assert.IsTrue(pMesh.Halfedges[pMesh.Vertices[0].OutgoingHalfedge].AdjacentFace < 0);
+            Assert.AreEqual(6, pMesh.Vertices.GetHalfedges(0).Length);
             
             
             // Plug another gap which should make vertex #0 manifold again
             int f = pMesh.Faces.AddFace(new int[]{ 0, 3, 2 });
             Assert.AreEqual(6, pMesh.Vertices.GetHalfedges(0).Length);
+            Assert.AreEqual(2, pMesh.Vertices.NakedEdgeCount(0));
             
             // Try adding a face which already exits
             f = pMesh.Faces.AddFace(new int[]{ 0, 5, 4 });
diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index 8d07b1e..fa1a3ca 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -104,7 +104,7 @@ public int AddFace(IEnumerable<int> indices)
                 else
                     loop[i] = h;
                 // NOTE: To PREVENT non-manifold vertices, uncomment the line below...
-                //if(is_new[i] && is_new[(i+n-1)%n] && vs[v2].OutgoingHalfedge > -1) return -1;
+                //if(is_new[i] && is_new[(i+n-1)%n] && vs[v1].OutgoingHalfedge > -1) return -1;
             }
             
             // Now create any missing halfedge pairs...
@@ -205,18 +205,23 @@ public int AddFace(IEnumerable<int> indices)
                             }
                         }
                     }
-                    // If inner loop exists, but for some reason it's not linked (non-manifold vertex)
-                    // make loop[i] adjacent to loop[ii].
-                    // TODO: In the current implementation (below) by making loop[i]->next and
-                    // loop[ii]->prev adjacent a face will be 'hidden' from vertex v2 until another face
-                    // is added which connects it with another face which is both incident to v2 and
-                    // 'known' to v2. Non-manifold vertices are tricky...
+                    // If inner loop exists, but for some reason it's not already linked
+                    // (non-manifold vertex) make loop[i] adjacent to loop[ii]. Tidy up other
+                    // halfedge links such that all outgoing halfedges remain visible to v2.
                     if (hs[loop[i]].NextHalfedge != loop[ii] || hs[loop[ii]].PrevHalfedge != loop[i])
                     {
-                        hs[hs[loop[i]].NextHalfedge].PrevHalfedge = hs[loop[ii]].PrevHalfedge;
-                        hs[hs[loop[ii]].PrevHalfedge].NextHalfedge = hs[loop[i]].NextHalfedge;
-                        hs[loop[i]].NextHalfedge = loop[ii];
-                        hs[loop[ii]].PrevHalfedge = loop[i];
+                        int next = hs[loop[i]].NextHalfedge;
+                        int prev = hs[loop[ii]].PrevHalfedge;
+                        foreach (int h in vs.GetHalfedgesCirculator(v2, loop[ii]).Skip(1))
+                        {
+                            if (hs[h].AdjacentFace < 0)
+                            {
+                                hs.MakeAdjacent(loop[i], loop[ii]);
+                                hs.MakeAdjacent(hs[h].PrevHalfedge, next);
+                                hs.MakeAdjacent(prev, h);
+                                break;
+                            }
+                        }
                     }
                 }
             }
diff --git a/Plankton/PlanktonVertexList.cs b/Plankton/PlanktonVertexList.cs
index e586027..e18a530 100644
--- a/Plankton/PlanktonVertexList.cs
+++ b/Plankton/PlanktonVertexList.cs
@@ -175,6 +175,33 @@ public IEnumerable<int> GetHalfedgesCirculator(int v)
             }
             while (he_current != he_first);
         }
+        
+        /// <summary>
+        /// Traverses the halfedge indices which originate from a vertex.
+        /// </summary>
+        /// <param name="v">A vertex index.</param>
+        /// <param name="first">A halfedge index. Halfedge must start at the specified vertex.</param>
+        /// <returns>An enumerable of halfedge indices incident to the specified vertex.
+        /// Ordered clockwise around the vertex.
+        /// The returned enumerable will start with the specified halfedge.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// The specified halfedge does not originate from the specified vertex.
+        /// </exception>
+        public IEnumerable<int> GetHalfedgesCirculator(int v, int first)
+        {
+            if (_mesh.Halfedges[first].StartVertex != v)
+                throw new ArgumentOutOfRangeException("Halfedge does not start at vertex.");
+            // TODO: The code below is the same as above.
+            // Can we refactor (without extra, unnecessary iterators)?
+            int h = first;
+            var hs = _mesh.Halfedges;
+            do
+            {
+                yield return h;
+                h = hs[hs.PairHalfedge(h)].NextHalfedge;
+            }
+            while (h != first);
+        }
         #endregion
         
         /// <summary>

From 6348a87079bc23e4ddcba58d89456fe7dbe53e4d Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Tue, 30 Jul 2013 23:25:07 +0100
Subject: [PATCH 17/20] Fix another bug that sometimes caused asymmetric
 linking of the halfedges incident to a non-manifold vertex.

Include error handling in case bug pops up again.
---
 Plankton/PlanktonFaceList.cs | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/Plankton/PlanktonFaceList.cs b/Plankton/PlanktonFaceList.cs
index fa1a3ca..4169272 100644
--- a/Plankton/PlanktonFaceList.cs
+++ b/Plankton/PlanktonFaceList.cs
@@ -150,8 +150,7 @@ public int AddFace(IEnumerable<int> indices)
                     {
                         case 1: // first is new, second is old
                             // iterate through halfedges clockwise around vertex #v2 until boundary
-                            outer_prev = hs.PairHalfedge(vs.GetHalfedgesCirculator(v2)
-                                                         .First(h => hs[hs.PairHalfedge(h)].AdjacentFace < 0));
+                            outer_prev = hs[loop[ii]].PrevHalfedge;
                             outer_next = hs.PairHalfedge(loop[i]);
                             break;
                         case 2: // second is new, first is old
@@ -212,15 +211,20 @@ public int AddFace(IEnumerable<int> indices)
                     {
                         int next = hs[loop[i]].NextHalfedge;
                         int prev = hs[loop[ii]].PrevHalfedge;
-                        foreach (int h in vs.GetHalfedgesCirculator(v2, loop[ii]).Skip(1))
+                        // Find another boundary at this vertex to link 'next' and 'prev' into.
+                        try
                         {
-                            if (hs[h].AdjacentFace < 0)
-                            {
-                                hs.MakeAdjacent(loop[i], loop[ii]);
-                                hs.MakeAdjacent(hs[h].PrevHalfedge, next);
-                                hs.MakeAdjacent(prev, h);
-                                break;
-                            }
+                            int boundary = vs.GetHalfedgesCirculator(v2, loop[ii]).Skip(1)
+                                .First(h => hs[h].AdjacentFace < 0);
+                            hs.MakeAdjacent(loop[i], loop[ii]);
+                            hs.MakeAdjacent(hs[boundary].PrevHalfedge, next);
+                            hs.MakeAdjacent(prev, boundary);
+                        }
+                        // If no other boundary is found, something must be wrong...
+                        catch (InvalidOperationException)
+                        {
+                            throw new InvalidOperationException(string.Format(
+                                "Failed to relink halfedges around vertex #{0} during creation of face #{1}", v2, this.Count));
                         }
                     }
                 }

From 31cbe1e88980f2da89579ffeaf7707153b5d43ed Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Mon, 5 Aug 2013 11:10:33 +0100
Subject: [PATCH 18/20] Update LICENSE.txt

Replaced existing license with LGPL v3 template to remove strange characters.
---
 LICENSE.txt | 218 ++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 159 insertions(+), 59 deletions(-)

diff --git a/LICENSE.txt b/LICENSE.txt
index 7b0b9ef..65c5ca8 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,65 +1,165 @@
-GNU LESSER GENERAL PUBLIC LICENSE
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
 
-Version 3, 29 June 2007
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-Copyright � 2007 Free Software Foundation, Inc. <http://fsf.org/>
 
-Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
 
-This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.
-0. Additional Definitions.
+  0. Additional Definitions.
 
-As used herein, �this License� refers to version 3 of the GNU Lesser General Public License, and the �GNU GPL� refers to version 3 of the GNU General Public License.
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
 
-�The Library� refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.
-
-An �Application� is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.
-
-A �Combined Work� is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the �Linked Version�.
-
-The �Minimal Corresponding Source� for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.
-
-The �Corresponding Application Code� for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.
-1. Exception to Section 3 of the GNU GPL.
-
-You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.
-2. Conveying Modified Versions.
-
-If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:
-
-    a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or
-    b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.
-
-3. Object Code Incorporating Material from Library Header Files.
-
-The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:
-
-    a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.
-    b) Accompany the object code with a copy of the GNU GPL and this license document.
-
-4. Combined Works.
-
-You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:
-
-    a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.
-    b) Accompany the Combined Work with a copy of the GNU GPL and this license document.
-    c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.
-    d) Do one of the following:
-        0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.
-        1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.
-    e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)
-
-5. Combined Libraries.
-
-You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:
-
-    a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.
-    b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.
-
-6. Revised Versions of the GNU Lesser General Public License.
-
-The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License �or any later version� applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.
-
-If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

From 3b868f69473ef06b538e1f5efc97e3ca192d25d8 Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Mon, 5 Aug 2013 11:15:22 +0100
Subject: [PATCH 19/20] Update and rename copyright.txt to COPYRIGHT.txt

Attribute copyright to 'contributors' and include list of current contributors.
---
 COPYRIGHT.txt | 4 ++++
 copyright.txt | 1 -
 2 files changed, 4 insertions(+), 1 deletion(-)
 create mode 100644 COPYRIGHT.txt
 delete mode 100644 copyright.txt

diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt
new file mode 100644
index 0000000..4e424ec
--- /dev/null
+++ b/COPYRIGHT.txt
@@ -0,0 +1,4 @@
+Copyright (C) 2013 Plankton contributors.
+
+Daniel Piker
+Will Pearson
diff --git a/copyright.txt b/copyright.txt
deleted file mode 100644
index 4054acc..0000000
--- a/copyright.txt
+++ /dev/null
@@ -1 +0,0 @@
-copyright 2013 Daniel Piker

From 35ad179ea7a6c5d59ca788ca15f6a2f0f0af9fed Mon Sep 17 00:00:00 2001
From: Will Pearson <pearswj@gmail.com>
Date: Mon, 5 Aug 2013 23:59:33 +0100
Subject: [PATCH 20/20] Update AssemblyVersion to 0.2.0

Attempting to follow http://semver.org
---
 Plankton/Properties/AssemblyInfo.cs   | 3 +--
 PlanktonGh/Properties/AssemblyInfo.cs | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/Plankton/Properties/AssemblyInfo.cs b/Plankton/Properties/AssemblyInfo.cs
index 227ae07..9522c42 100644
--- a/Plankton/Properties/AssemblyInfo.cs
+++ b/Plankton/Properties/AssemblyInfo.cs
@@ -32,5 +32,4 @@
 // 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: AssemblyVersion("0.2.0")]
diff --git a/PlanktonGh/Properties/AssemblyInfo.cs b/PlanktonGh/Properties/AssemblyInfo.cs
index a273a0e..9f2c0be 100644
--- a/PlanktonGh/Properties/AssemblyInfo.cs
+++ b/PlanktonGh/Properties/AssemblyInfo.cs
@@ -32,5 +32,4 @@
 // 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: AssemblyVersion("0.2.0")]