Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs =================================================================== diff -u -r5542 -r5561 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs (.../GeometryGenerator.cs) (revision 5542) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs (.../GeometryGenerator.cs) (revision 5561) @@ -40,8 +40,6 @@ private readonly List newlyDetectedSurfaceList = new List(); - private bool isRegenerationOn; - /// /// Regenerates the geometry. /// @@ -60,7 +58,7 @@ SetupCurveSurfaceAssociations(); var firstRegeneration = true; - isRegenerationOn = true; + while (true) { // break up all curves at intersections @@ -99,7 +97,6 @@ firstRegeneration = false; } - isRegenerationOn = false; } /// @@ -135,24 +132,24 @@ /// /// Adds the curve to the list in given direction. /// - /// - /// - /// + /// + /// + /// /// - private bool AddCurve(GeometryCurve aCurve, CurveDirection aDirection, GeometryLoop aEditedLoop) + private bool AddCurve(GeometryCurve curve, CurveDirection direction, GeometryLoop editedLoop) { - if (FindCurveIndex(aEditedLoop, aCurve, aDirection) > -1) + if (FindCurveIndex(editedLoop, curve, direction) > -1) { return false; } - aEditedLoop.CurveList.Add(aCurve); - if (!geometryLoopDirections.ContainsKey(aEditedLoop)) + editedLoop.CurveList.Add(curve); + if (!geometryLoopDirections.ContainsKey(editedLoop)) { - geometryLoopDirections.Add(aEditedLoop, new List()); + geometryLoopDirections.Add(editedLoop, new List()); } - geometryLoopDirections[aEditedLoop].Add(aDirection); + geometryLoopDirections[editedLoop].Add(direction); return true; } @@ -162,14 +159,14 @@ /// /// Creates the surface. /// - /// a loop. + /// a loop. /// - private GeometrySurface CreateSurface(GeometryLoop aLoop) + private GeometrySurface CreateSurface(GeometryLoop loop) { - if (aLoop.IsLoop() && aLoop.HasArea()) + if (loop.IsLoop() && loop.HasArea()) { var newSurface = new GeometrySurface(); - newSurface.SetOuterLoop(aLoop); + newSurface.SetOuterLoop(loop); geometryData.Surfaces.Add(newSurface); return newSurface; } @@ -180,24 +177,24 @@ /// /// Finds the index of the curve. /// - /// a geometry loop. - /// a curve. - /// a direction. + /// a geometry loop. + /// a curve. + /// a direction. /// - private int FindCurveIndex(GeometryLoop aGeometryLoop, GeometryCurve aCurve, CurveDirection aDirection) + private int FindCurveIndex(GeometryLoop geometryLoop, GeometryCurve curve, CurveDirection direction) { - if (!aGeometryLoop.CurveList.Contains(aCurve)) + if (!geometryLoop.CurveList.Contains(curve)) { return -1; } - int curvesCount = aGeometryLoop.CurveList.Count; + int curvesCount = geometryLoop.CurveList.Count; for (var index = 0; index < curvesCount; index++) { // Note Bka: Checking the direction does allow one curve to be added to ONE loop twice! // This produces some strange surfaces (see LoopDetectionCase5) but that seems to be required - if (aGeometryLoop.CurveList[index] == aCurve && geometryLoopDirections[aGeometryLoop][index] == aDirection) + if (geometryLoop.CurveList[index] == curve && geometryLoopDirections[geometryLoop][index] == direction) { return index; } @@ -209,49 +206,49 @@ /// /// /// - /// - /// - /// - public void SetIsUsed(GeometryCurve aCurve, CurveDirection aDirection, bool aValue) + /// + /// + /// + public void SetIsUsed(GeometryCurve curve, CurveDirection direction, bool isUsed) { - if (aDirection == CurveDirection.Forward) + if (direction == CurveDirection.Forward) { - if (!(geometryCurveForwardsIsUsed.ContainsKey(aCurve))) + if (!(geometryCurveForwardsIsUsed.ContainsKey(curve))) { - geometryCurveForwardsIsUsed.Add(aCurve, aValue); + geometryCurveForwardsIsUsed.Add(curve, isUsed); } else { - geometryCurveForwardsIsUsed[aCurve] = aValue; + geometryCurveForwardsIsUsed[curve] = isUsed; } } else { - if (!(geometryCurveReversedIsUsed.ContainsKey(aCurve))) + if (!(geometryCurveReversedIsUsed.ContainsKey(curve))) { - geometryCurveReversedIsUsed.Add(aCurve, aValue); + geometryCurveReversedIsUsed.Add(curve, isUsed); } else { - geometryCurveReversedIsUsed[aCurve] = aValue; + geometryCurveReversedIsUsed[curve] = isUsed; } } } /// /// /// - /// - /// + /// + /// /// - private bool GetIsUsed(GeometryCurve aCurve, CurveDirection aDirection) + private bool GetIsUsed(GeometryCurve curve, CurveDirection direction) { - if (aDirection == CurveDirection.Forward) + if (direction == CurveDirection.Forward) { - return geometryCurveForwardsIsUsed[aCurve]; + return geometryCurveForwardsIsUsed[curve]; } - return geometryCurveReversedIsUsed[aCurve]; + return geometryCurveReversedIsUsed[curve]; } /// @@ -366,7 +363,7 @@ } } - private int DetectSurfaces(bool aFirstRegeneration) + private int DetectSurfaces(bool firstRegeneration) { try { @@ -430,7 +427,7 @@ // the curve wasn't added bcos the curve-direction pair was already present in loop. // problem case - break here, else we'd get aValue1 hang! // Todo: Solve this problem - if (!aFirstRegeneration) + if (!firstRegeneration) { //TODO:Show error message box break; @@ -536,18 +533,18 @@ #endif } - private int CreateSurfaces(List aNewLoopList) + private int CreateSurfaces(List newLoopList) { var newSurfacesGeoDtaObjectList = new List(); - int loopsCount = aNewLoopList.Count; + int loopsCount = newLoopList.Count; int curvesCount; GeometrySurface newSurface; var newSurfaceList = new List(); for (var index = 0; index < loopsCount; index++) { - GeometryLoop loop = aNewLoopList[index]; + GeometryLoop loop = newLoopList[index]; curvesCount = loop.CurveList.Count; if (curvesCount < 2) // dont create aValue1 surface for loops that have less than 2 curves @@ -626,20 +623,20 @@ /// /// Checks if loop encloses open polyline. /// - /// a loop. + /// a loop. /// - private bool CheckIfLoopEnclosesOpenPolyline(GeometryLoop aLoop) + private bool CheckIfLoopEnclosesOpenPolyline(GeometryLoop loop) { - int curvesCount = aLoop.CurveList.Count; + int curvesCount = loop.CurveList.Count; if (curvesCount < 3) { return true; } for (var index = 0; index < curvesCount; index++) { - GeometryCurve curve = aLoop.CurveList[index]; - CurveDirection direction = geometryLoopDirections[aLoop][index]; + GeometryCurve curve = loop.CurveList[index]; + CurveDirection direction = geometryLoopDirections[loop][index]; var foundOppDirection = false; for (var index1 = 0; index1 < curvesCount; index1++) @@ -649,7 +646,7 @@ continue; } - if (aLoop.CurveList[index1] == curve && geometryLoopDirections[aLoop][index] != direction) + if (loop.CurveList[index1] == curve && geometryLoopDirections[loop][index] != direction) { foundOppDirection = true; break; @@ -665,21 +662,21 @@ return true; } - private GeometrySurface GetReassignmentSurfaceFromCurves(GeometryLoop aLoop) + private GeometrySurface GetReassignmentSurfaceFromCurves(GeometryLoop loop) { GeometrySurface surface = null; GeometrySurface reassignmentSurface = null; - int curvesCount = aLoop.CurveList.Count; + int curvesCount = loop.CurveList.Count; - if (!geometryLoopDirections.ContainsKey(aLoop)) + if (!geometryLoopDirections.ContainsKey(loop)) { return null; } for (var index = 0; index < curvesCount; index++) { - GeometryCurve curve = aLoop.CurveList[index]; - if (geometryLoopDirections[aLoop][index] == CurveDirection.Forward) + GeometryCurve curve = loop.CurveList[index]; + if (geometryLoopDirections[loop][index] == CurveDirection.Forward) { if (curve.SurfaceAtRight != null) { @@ -703,7 +700,7 @@ var noTimesSurfaceFound = 0; for (var index1 = 0; index1 < curvesCount; index1++) { - if (geometryLoopDirections[aLoop][index] == CurveDirection.Forward) + if (geometryLoopDirections[loop][index] == CurveDirection.Forward) { if (curve.SurfaceAtRight == surface) { @@ -810,37 +807,37 @@ } } - private void SetUpGeometryLoopDirections(GeometryLoop aLoop) + private void SetUpGeometryLoopDirections(GeometryLoop loop) { - if (aLoop.CurveList.Count > 0) + if (loop.CurveList.Count > 0) { Point2D loopPoint; - geometryLoopDirections.Add(aLoop, new List()); + geometryLoopDirections.Add(loop, new List()); // get the first curve - if (aLoop.CurveList[0].EndPoint == aLoop.CurveList[1].HeadPoint || aLoop.CurveList[0].EndPoint == aLoop.CurveList[1].EndPoint) + if (loop.CurveList[0].EndPoint == loop.CurveList[1].HeadPoint || loop.CurveList[0].EndPoint == loop.CurveList[1].EndPoint) { - geometryLoopDirections[aLoop].Add(CurveDirection.Forward); - loopPoint = aLoop.CurveList[0].EndPoint; + geometryLoopDirections[loop].Add(CurveDirection.Forward); + loopPoint = loop.CurveList[0].EndPoint; } else { - geometryLoopDirections[aLoop].Add(CurveDirection.Reverse); - loopPoint = aLoop.CurveList[0].HeadPoint; + geometryLoopDirections[loop].Add(CurveDirection.Reverse); + loopPoint = loop.CurveList[0].HeadPoint; } // the rest of the curves - for (var index1 = 1; index1 < aLoop.CurveList.Count; index1++) + for (var index1 = 1; index1 < loop.CurveList.Count; index1++) { - if (loopPoint == aLoop.CurveList[index1].HeadPoint) + if (loopPoint == loop.CurveList[index1].HeadPoint) { - geometryLoopDirections[aLoop].Add(CurveDirection.Forward); - loopPoint = aLoop.CurveList[index1].EndPoint; + geometryLoopDirections[loop].Add(CurveDirection.Forward); + loopPoint = loop.CurveList[index1].EndPoint; } else { - geometryLoopDirections[aLoop].Add(CurveDirection.Reverse); - loopPoint = aLoop.CurveList[index1].HeadPoint; + geometryLoopDirections[loop].Add(CurveDirection.Reverse); + loopPoint = loop.CurveList[index1].HeadPoint; } } } @@ -849,10 +846,10 @@ /// /// Checks and adds inner loop to the new surface. /// - /// - private void CheckAndAddInnerLoops(ref object aNewSurface) + /// + private void CheckAndAddInnerLoops(ref object newSurfaceObject) { - var newSurface = (GeometrySurface) aNewSurface; + var newSurface = (GeometrySurface) newSurfaceObject; int surfaceCount = geometryData.Surfaces.Count; GeometryLoop newLoop = newSurface.OuterLoop; int newPointCount = newLoop.CurveList.Count; @@ -921,10 +918,10 @@ /// /// Gets the newly detected surface from the list. /// - /// - private void GetNewlyDetectedSurfaces(ref List aNewSurfaceList) + /// + private void GetNewlyDetectedSurfaces(ref List newSurfaceList) { - aNewSurfaceList.AddRange(newlyDetectedSurfaceList); + newSurfaceList.AddRange(newlyDetectedSurfaceList); } #region Nested type: DirectionCurve @@ -956,63 +953,57 @@ private void RegenerateAllCurvesIntersection() { - //try + intersectedCurveList.Clear(); + MergePoints(); + bool isCurveInserted = false; + bool hasCurveBeenSplit = true; + while (hasCurveBeenSplit) { - intersectedCurveList.Clear(); - MergePoints(); - bool isCurveInserted = false; - bool flag = true; - while (flag) + hasCurveBeenSplit = false; + List geometryCurveList = new List((IEnumerable) geometryData.NewlyEffectedCurves); + geometryData.NewlyEffectedCurves.Clear(); + foreach (GeometryCurve geometryCurve1 in geometryCurveList) { - flag = false; - List geometryCurveList = new List((IEnumerable) geometryData.NewlyEffectedCurves); - geometryData.NewlyEffectedCurves.Clear(); - foreach (GeometryCurve geometryCurve1 in geometryCurveList) + foreach (GeometryCurve geometryCurve2 in geometryData.Curves.ToArray()) { - foreach (GeometryCurve geometryCurve2 in geometryData.Curves.ToArray()) - { - isCurveInserted = FindAndHandleCurveIntersections(geometryCurve1, geometryCurve2, isCurveInserted, ref flag); - } + isCurveInserted = FindAndProcessCurveIntersections(geometryCurve1, geometryCurve2, isCurveInserted, ref hasCurveBeenSplit); } - - FilterOutDoublePoints(); } - geometryData.NewlyEffectedCurves.Clear(); - MergePoints(); - this.DeleteDuplicateCurves(); + FilterOutDoublePoints(); } - // catch (Exception ex) - // { - // LogManager.Add(new LogMessage(LogMessageType.FatalError, (object) this, "RegenerateAllCurvesIntersection: " + ex.Message)); - // } + + geometryData.NewlyEffectedCurves.Clear(); + MergePoints(); + DeleteDuplicateCurves(); } - private bool FindAndHandleCurveIntersections(GeometryCurve geometryCurve1, GeometryCurve geometryCurve2, bool isCurveInserted, ref bool flag) + private bool FindAndProcessCurveIntersections(GeometryCurve geometryCurve1, GeometryCurve geometryCurve2, bool isCurveInserted, + ref bool hasCurveBeenSplit) { - Point2D pointXz1 = geometryCurve1.HeadPoint; - Point2D pointXz2 = geometryCurve1.EndPoint; - Point2D pointXz3 = geometryCurve2.HeadPoint; - Point2D pointXz4 = geometryCurve2.EndPoint; + Point2D geometryCurve1HeadPoint = geometryCurve1.HeadPoint; + Point2D geometryCurve1EndPoint = geometryCurve1.EndPoint; + Point2D geometryCurve2HeadPoint = geometryCurve2.HeadPoint; + Point2D geometryCurve2EndPoint = geometryCurve2.EndPoint; if (!geometryCurve1.LocationEquals(geometryCurve2) && // geometryCurve1 != geometryCurve2 && !RegenerateParallelCurves(geometryCurve2, geometryCurve1, ref isCurveInserted) && - Routines2D.DetermineIf2DLinesIntersectStrickly(pointXz1, pointXz2, pointXz3, pointXz4, out Point2D intersectionPoint) == + Routines2D.DetermineIf2DLinesIntersectStrickly(geometryCurve1HeadPoint, geometryCurve1EndPoint, geometryCurve2HeadPoint, geometryCurve2EndPoint, out Point2D intersectionPoint) == LineIntersection.Intersects) { - if (!Routines2D.DetermineIfPointsCoincide(pointXz1.X, pointXz1.Z, intersectionPoint.X, intersectionPoint.Z, 0.001) - && !Routines2D.DetermineIfPointsCoincide(pointXz2.X, pointXz2.Z, intersectionPoint.X, intersectionPoint.Z, 0.001)) + if (!Routines2D.DetermineIfPointsCoincide(geometryCurve1HeadPoint.X, geometryCurve1HeadPoint.Z, intersectionPoint.X, intersectionPoint.Z, 0.001) + && !Routines2D.DetermineIfPointsCoincide(geometryCurve1EndPoint.X, geometryCurve1EndPoint.Z, intersectionPoint.X, intersectionPoint.Z, 0.001)) { Point2D point = geometryData.CreatePointAndAddItToTheProperListsWhenNeeded(new Point2D(intersectionPoint.X, intersectionPoint.Z)); SplitCurve(geometryCurve1, point); - flag = true; + hasCurveBeenSplit = true; } - if (!Routines2D.DetermineIfPointsCoincide(pointXz3.X, pointXz3.Z, intersectionPoint.X, intersectionPoint.Z, 0.001) && - !Routines2D.DetermineIfPointsCoincide(pointXz4.X, pointXz4.Z, intersectionPoint.X, intersectionPoint.Z, 0.001)) + if (!Routines2D.DetermineIfPointsCoincide(geometryCurve2HeadPoint.X, geometryCurve2HeadPoint.Z, intersectionPoint.X, intersectionPoint.Z, 0.001) && + !Routines2D.DetermineIfPointsCoincide(geometryCurve2EndPoint.X, geometryCurve2EndPoint.Z, intersectionPoint.X, intersectionPoint.Z, 0.001)) { Point2D point = this.geometryData.CreatePointAndAddItToTheProperListsWhenNeeded(new Point2D(intersectionPoint.X, intersectionPoint.Z)); SplitCurve(geometryCurve2, point); - flag = true; + hasCurveBeenSplit = true; } } @@ -1039,9 +1030,9 @@ { aConnectedAtHeadCurveList.Clear(); aConnectedAtEndCurveList.Clear(); - GetConnectedCurves(this.geometryData.Points[index1], ref aConnectedAtHeadCurveList, ref aConnectedAtEndCurveList); - SetPointInCurves(aConnectedAtHeadCurveList, geometryData.Points[index2], true); - SetPointInCurves(aConnectedAtEndCurveList, geometryData.Points[index2], false); + DetermineConnectedCurves(this.geometryData.Points[index1], ref aConnectedAtHeadCurveList, ref aConnectedAtEndCurveList); + AssignPointToCurves(aConnectedAtHeadCurveList, geometryData.Points[index2], true); + AssignPointToCurves(aConnectedAtEndCurveList, geometryData.Points[index2], false); --count; geometryData.DeletePointAndPossibleObsoleteCurveItsPartOf(geometryData.Points[index1]); break; @@ -1154,7 +1145,7 @@ newLine = SplitCurve(line1, line2.HeadPoint); line2.HeadPoint = isPoint2OnLine2 ? newLine.EndPoint : line1.HeadPoint; - CheckAndAddToIntersectedCurveList(line2); + AddToIntersectedCurveList(line2); isCurveInserted = true; return true; @@ -1165,7 +1156,7 @@ { newLine = SplitCurve(line1, line2.EndPoint); line2.EndPoint = isPoint2OnLine2 ? newLine.EndPoint : line1.HeadPoint; - CheckAndAddToIntersectedCurveList(line2); + AddToIntersectedCurveList(line2); isCurveInserted = true; return true; @@ -1188,7 +1179,7 @@ newLine = SplitCurve(line1, line2.EndPoint); newLine.HeadPoint = line2.HeadPoint; } - CheckAndAddToIntersectedCurveList(line2); + AddToIntersectedCurveList(line2); isCurveInserted = true; return true; @@ -1211,7 +1202,7 @@ newLine = SplitCurve(line2, line1.EndPoint); newLine.HeadPoint = line1.HeadPoint; } - CheckAndAddToIntersectedCurveList(line1); + AddToIntersectedCurveList(line1); isCurveInserted = true; return true; @@ -1237,8 +1228,8 @@ { line1.HeadPoint = line2.HeadPoint; } - CheckAndAddToIntersectedCurveList(line1); - CheckAndAddToIntersectedCurveList(line2); + AddToIntersectedCurveList(line1); + AddToIntersectedCurveList(line2); return true; } @@ -1263,122 +1254,95 @@ { line2.HeadPoint = line1.HeadPoint; } - CheckAndAddToIntersectedCurveList(line1); - CheckAndAddToIntersectedCurveList(line2); + AddToIntersectedCurveList(line1); + AddToIntersectedCurveList(line2); return true; } } // Line1 and Line2 are same if ((isPoint1SameAsPoint3 && isPoint2SameAsPoint4) || (isPoint1SameAsPoint4 && isPoint2SameAsPoint3)) { - CheckAndAddToIntersectedCurveList(line1); - CheckAndAddToIntersectedCurveList(line2); + AddToIntersectedCurveList(line1); + AddToIntersectedCurveList(line2); return true; } return false; } - private GeometryCurve SplitCurve(GeometryCurve curve, Point2D aPointOnCurve) + private GeometryCurve SplitCurve(GeometryCurve srcCurve, Point2D pointOnCurve) { - if (aPointOnCurve.LocationEquals(curve.HeadPoint) || aPointOnCurve.LocationEquals(curve.EndPoint)) + if (pointOnCurve.LocationEquals(srcCurve.HeadPoint) || pointOnCurve.LocationEquals(srcCurve.EndPoint)) return null; - GeometryCurve curve1 = geometryData.CreateCurve(aPointOnCurve, curve.EndPoint); - curve.EndPoint = curve1.HeadPoint; - curve1.AssignSurfacesFromCurve(curve); - this.CheckAndAddToIntersectedCurveList(curve); - this.CheckAndAddToIntersectedCurveList(curve1); - if (!geometryData.Curves.Contains(curve1)) - geometryData.Curves.Add(curve1); - return curve1; + GeometryCurve newCurve = geometryData.CreateCurve(pointOnCurve, srcCurve.EndPoint); + srcCurve.EndPoint = newCurve.HeadPoint; + newCurve.AssignSurfacesFromCurve(srcCurve); + this.AddToIntersectedCurveList(srcCurve); + this.AddToIntersectedCurveList(newCurve); + if (!geometryData.Curves.Contains(newCurve)) + geometryData.Curves.Add(newCurve); + return newCurve; } - private void GetConnectedCurves( - Point2D aPoint, - ref List aConnectedAtHeadCurveList, - ref List aConnectedAtEndCurveList) + private void DetermineConnectedCurves( + Point2D point, + ref List connectedAtHeadCurveList, + ref List connectedAtEndCurveList) { - aConnectedAtHeadCurveList.Clear(); - aConnectedAtEndCurveList.Clear(); + connectedAtHeadCurveList.Clear(); + connectedAtEndCurveList.Clear(); int count = this.geometryData.Curves.Count; for (int index = 0; index < count; ++index) { GeometryCurve curve = this.geometryData.Curves[index]; - if (curve.HeadPoint == aPoint) - aConnectedAtHeadCurveList.Add(curve); - if (curve.EndPoint == aPoint) - aConnectedAtEndCurveList.Add(curve); + if (curve.HeadPoint == point) + connectedAtHeadCurveList.Add(curve); + if (curve.EndPoint == point) + connectedAtEndCurveList.Add(curve); } } - private static void SetPointInCurves(List aCurveList, Point2D aPoint, bool aHead) + private static void AssignPointToCurves(List aCurveList, Point2D aPoint, bool aHead) { int count = aCurveList.Count; if (count < 1) return; - for (int index = 0; index < count; ++index) + for (int i = 0; i < count; ++i) { if (aHead) - aCurveList[index].HeadPoint = aPoint; + aCurveList[i].HeadPoint = aPoint; else - aCurveList[index].EndPoint = aPoint; + aCurveList[i].EndPoint = aPoint; } } private void DeleteDuplicateCurves() { - List list = geometryData.Curves.Where((Func) (curve => curve.HeadPoint == curve.EndPoint)).ToList(); - foreach (GeometryCurve aCurve in list) + List curvesToDelete = geometryData.Curves.Where((Func) (curve => curve.HeadPoint == curve.EndPoint)).ToList(); + foreach (GeometryCurve aCurve in curvesToDelete) geometryData.DeleteCurve(aCurve, true); - list.Clear(); - List intList = new List(); - for (int index1 = 0; index1 < geometryData.Curves.Count; ++index1) + curvesToDelete.Clear(); + for (int i = 0; i < geometryData.Curves.Count; ++i) { - GeometryCurve curve1 = geometryData.Curves[index1]; - for (int index2 = index1 + 1; index2 < geometryData.Curves.Count; ++index2) + GeometryCurve curve1 = geometryData.Curves[i]; + for (int j = i + 1; j < geometryData.Curves.Count; ++j) { - GeometryCurve curve2 = geometryData.Curves[index2]; + GeometryCurve curve2 = geometryData.Curves[j]; if ((curve1.HeadPoint == curve2.HeadPoint && curve1.EndPoint == curve2.EndPoint) || (curve1.HeadPoint == curve2.EndPoint && curve1.EndPoint == curve2.HeadPoint)) { - list.Add(curve2); - intList.Add(index2); + curvesToDelete.Add(curve2); } } } - foreach (GeometryCurve aCurve in list) + foreach (GeometryCurve aCurve in curvesToDelete) geometryData.DeleteCurve(aCurve, true); } - private void CheckAndAddToIntersectedCurveList(GeometryCurve aCurve) + private void AddToIntersectedCurveList(GeometryCurve aCurve) { if (!intersectedCurveList.Contains(aCurve)) intersectedCurveList.Add(aCurve); } - /// - /// Split the curve at the coincident point. - /// - /// - /// - public void SplitCurvesAtCoincidentPoint(Point2D aPoint, List aCoincidentCurves) - { - int count = aCoincidentCurves.Count; - for (int index = 0; index < count; ++index) - SplitCurve(aCoincidentCurves[index], aPoint); - } - - /// - /// Gets a value indicating whether this instance is regeneration on. - /// - /// - /// true if this instance is regeneration on; otherwise, false. - /// - public bool IsRegenerationOn - { - get - { - return isRegenerationOn; - } - } } \ No newline at end of file