Index: src/Common/NetTopologySuite/Noding/IntersectionAdder.cs
===================================================================
diff -u -r8f6ae890fed8e8eae3a32f9c0498a10f82e0ddf9 -r5fc71a385897af92ccb092f2f969b5709afab85a
--- src/Common/NetTopologySuite/Noding/IntersectionAdder.cs	(.../IntersectionAdder.cs)	(revision 8f6ae890fed8e8eae3a32f9c0498a10f82e0ddf9)
+++ src/Common/NetTopologySuite/Noding/IntersectionAdder.cs	(.../IntersectionAdder.cs)	(revision 5fc71a385897af92ccb092f2f969b5709afab85a)
@@ -19,38 +19,13 @@
         /// <summary>
         /// 
         /// </summary>
-        /// <param name="i1"></param>
-        /// <param name="i2"></param>
-        /// <returns></returns>
-        public static bool IsAdjacentSegments(int i1, int i2)
-        {
-            return Math.Abs(i1 - i2) == 1;
-        }
+        public int NumIntersections = 0;
 
-        /**
-         * These variables keep track of what types of intersections were
-         * found during ALL edges that have been intersected.
-         */
-        private bool hasIntersection = false;
-        private bool hasProper = false;
-        private bool hasProperInterior = false;
-        private bool hasInterior = false;
-
-        // the proper intersection point found
-        private ICoordinate properIntersectionPoint = null;
-
-        private LineIntersector li = null;        
-        
         /// <summary>
         /// 
         /// </summary>
-        public int NumIntersections = 0;
-        
-        /// <summary>
-        /// 
-        /// </summary>
         public int NumInteriorIntersections = 0;
-        
+
         /// <summary>
         /// 
         /// </summary>
@@ -61,12 +36,26 @@
         /// </summary>
         public int NumTests = 0;
 
+        /**
+         * These variables keep track of what types of intersections were
+         * found during ALL edges that have been intersected.
+         */
+
+        // the proper intersection point found
+
+        private readonly LineIntersector li = null;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="IntersectionAdder"/> class.
         /// </summary>
         /// <param name="li"></param>
         public IntersectionAdder(LineIntersector li)
         {
+            HasInteriorIntersection = false;
+            HasProperInteriorIntersection = false;
+            HasProperIntersection = false;
+            HasIntersection = false;
+            ProperIntersectionPoint = null;
             this.li = li;
         }
 
@@ -84,24 +73,12 @@
         /// <summary>
         /// Returns the proper intersection point, or <c>null</c> if none was found.
         /// </summary>
-        public ICoordinate ProperIntersectionPoint
-        {
-            get
-            {
-                return properIntersectionPoint;
-            }
-        }
+        public ICoordinate ProperIntersectionPoint { get; private set; }
 
         /// <summary>
         /// 
         /// </summary>
-        public bool HasIntersection
-        {
-            get
-            {
-                return hasIntersection;
-            }
-        }
+        public bool HasIntersection { get; private set; }
 
         /// <summary>
         /// A proper intersection is an intersection which is interior to at least two
@@ -110,66 +87,29 @@
         /// an endpoint equal to the intersection, which according to SFS semantics
         /// can result in the point being on the Boundary of the <see cref="Geometry" />.
         /// </summary>
-        public bool HasProperIntersection
-        {
-            get
-            {
-                return hasProper;
-            }
-        }
+        public bool HasProperIntersection { get; private set; }
 
         /// <summary>
         /// A proper interior intersection is a proper intersection which is not
         /// contained in the set of boundary nodes set for this <see cref="ISegmentIntersector" />.
         /// </summary>
-        public bool HasProperInteriorIntersection
-        {
-            get
-            {
-                return hasProperInterior;
-            }
-        }
-        
+        public bool HasProperInteriorIntersection { get; private set; }
+
         /// <summary>
         /// An interior intersection is an intersection which is
         /// in the interior of some segment.
         /// </summary>
-        public bool HasInteriorIntersection
-        {
-            get
-            {
-                return hasInterior;
-            }
-        }
+        public bool HasInteriorIntersection { get; private set; }
 
         /// <summary>
-        /// A trivial intersection is an apparent self-intersection which in fact
-        /// is simply the point shared by adjacent line segments.
-        /// Note that closed edges require a special check for the point shared by the beginning and end segments.
+        /// 
         /// </summary>
-        /// <param name="e0"></param>
-        /// <param name="segIndex0"></param>
-        /// <param name="e1"></param>
-        /// <param name="segIndex1"></param>
+        /// <param name="i1"></param>
+        /// <param name="i2"></param>
         /// <returns></returns>
-        private bool IsTrivialIntersection(SegmentString e0, int segIndex0, SegmentString e1, int segIndex1)
+        public static bool IsAdjacentSegments(int i1, int i2)
         {
-            if(e0 == e1)
-            {
-                if(li.IntersectionNum == 1)
-                {
-                    if(IsAdjacentSegments(segIndex0, segIndex1))
-                        return true;
-                    if (e0.IsClosed)
-                    {
-                        int maxSegIndex = e0.Count - 1;
-                        if ( (segIndex0 == 0 && segIndex1 == maxSegIndex) || 
-                             (segIndex1 == 0 && segIndex0 == maxSegIndex) )                        
-                                return true;                        
-                    }
-                }
-            }
-            return false;
+            return Math.Abs(i1 - i2) == 1;
         }
 
         /// <summary>
@@ -187,39 +127,75 @@
         public void ProcessIntersections(SegmentString e0, int segIndex0, SegmentString e1, int segIndex1)
         {
             if (e0 == e1 && segIndex0 == segIndex1)
+            {
                 return;
+            }
 
             NumTests++;
             ICoordinate p00 = e0.Coordinates[segIndex0];
             ICoordinate p01 = e0.Coordinates[segIndex0 + 1];
             ICoordinate p10 = e1.Coordinates[segIndex1];
             ICoordinate p11 = e1.Coordinates[segIndex1 + 1];
 
-            li.ComputeIntersection(p00, p01, p10, p11);            
-            if(li.HasIntersection)
-            {                
+            li.ComputeIntersection(p00, p01, p10, p11);
+            if (li.HasIntersection)
+            {
                 NumIntersections++;
                 if (li.IsInteriorIntersection())
                 {
                     NumInteriorIntersections++;
-                    hasInterior = true;                    
+                    HasInteriorIntersection = true;
                 }
                 // if the segments are adjacent they have at least one trivial intersection,
                 // the shared endpoint.  Don't bother adding it if it is the
                 // only intersection.
                 if (!IsTrivialIntersection(e0, segIndex0, e1, segIndex1))
                 {
-                    hasIntersection = true;
+                    HasIntersection = true;
                     e0.AddIntersections(li, segIndex0, 0);
                     e1.AddIntersections(li, segIndex1, 1);
                     if (li.IsProper)
                     {
                         NumProperIntersections++;
-                        hasProper = true;
-                        hasProperInterior = true;
+                        HasProperIntersection = true;
+                        HasProperInteriorIntersection = true;
                     }
                 }
             }
         }
+
+        /// <summary>
+        /// A trivial intersection is an apparent self-intersection which in fact
+        /// is simply the point shared by adjacent line segments.
+        /// Note that closed edges require a special check for the point shared by the beginning and end segments.
+        /// </summary>
+        /// <param name="e0"></param>
+        /// <param name="segIndex0"></param>
+        /// <param name="e1"></param>
+        /// <param name="segIndex1"></param>
+        /// <returns></returns>
+        private bool IsTrivialIntersection(SegmentString e0, int segIndex0, SegmentString e1, int segIndex1)
+        {
+            if (e0 == e1)
+            {
+                if (li.IntersectionNum == 1)
+                {
+                    if (IsAdjacentSegments(segIndex0, segIndex1))
+                    {
+                        return true;
+                    }
+                    if (e0.IsClosed)
+                    {
+                        int maxSegIndex = e0.Count - 1;
+                        if ((segIndex0 == 0 && segIndex1 == maxSegIndex) ||
+                            (segIndex1 == 0 && segIndex0 == maxSegIndex))
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
     }
-}
+}
\ No newline at end of file