private static void GetClosePart([NotNull] SegmentProxy neighbor,
[NotNull] IPnt near,
double searchDistanceSquared, bool is3D,
out double min, out double max)
{
IList <double[]> limits;
Pnt p = Pnt.Create(near);
bool cut = SegmentUtils.CutCurveCircle(neighbor, p, searchDistanceSquared, is3D,
out limits);
if (cut == false || limits.Count == 0)
{
min = SegmentUtils.GetClosestPointFraction(neighbor, p, is3D);
max = min;
}
else
{
min = double.MaxValue;
max = double.MinValue;
foreach (double[] limit in limits)
{
foreach (double d in limit)
{
min = Math.Min(d, min);
max = Math.Max(d, max);
}
}
}
min = Math.Max(min, 0);
max = Math.Max(max, 0);
min = Math.Min(min, 1);
max = Math.Min(max, 1);
}
protected override bool GetNextSegment(out double length, out double dz,
out int partIndex, out int segmentIndex)
{
if (!_enumSegments.MoveNext())
{
length = double.NaN;
dz = double.NaN;
partIndex = -1;
segmentIndex = -1;
return(false);
}
SegmentProxy segment = Assert.NotNull(_enumSegments.Current);
partIndex = segment.PartIndex;
segmentIndex = segment.SegmentIndex;
length = segment.Length;
double z0 = segment.GetStart(true)[2];
double z1 = segment.GetEnd(true)[2];
dz = z1 - z0;
return(true);
}
protected override bool GetNextSliverArea(out double area, out double perimeter)
{
_latestPartSegments = null;
if (!_enumValid)
{
area = double.NaN;
perimeter = double.NaN;
return(false);
}
SegmentProxy segment = Assert.NotNull(_segmentsEnum.Current);
int currentPart = segment.PartIndex;
int segmentCount = _indexedMultiPatch.GetPartSegmentCount(currentPart);
var partSegments = new List <SegmentProxy>(segmentCount)
{
segment
};
while ((_enumValid = _segmentsEnum.MoveNext()) &&
Assert.NotNull(_segmentsEnum.Current).PartIndex == currentPart)
{
partSegments.Add(_segmentsEnum.Current);
}
List <Pnt> planePoints = QaGeometryUtils.GetPoints(partSegments);
Plane plane = QaGeometryUtils.CreatePlane((IEnumerable <SegmentProxy>)partSegments);
QaGeometryUtils.CalculateProjectedArea(plane, planePoints, out area, out perimeter);
_latestPartSegments = partSegments;
return(true);
}
public SegmentProximity([NotNull] Pnt point,
bool as3D,
[NotNull] SegmentProxy segmentProxy)
: base(point, as3D)
{
_segmentProxy = segmentProxy;
}
public static WKSEnvelope GetEnvelope([NotNull] IIndexedSegments baseGeometry,
int part, int startSegmentIndex,
double startFraction,
int endSegmentIndex, double endFraction)
{
SegmentProxy segment = baseGeometry.GetSegment(part, startSegmentIndex);
double startEnd = 1;
if (startSegmentIndex == endSegmentIndex)
{
startEnd = endFraction;
}
WKSEnvelope box = segment.GetSubCurveBox(startFraction, startEnd);
for (int i = startSegmentIndex + 1; i < endSegmentIndex - 1; i++)
{
segment = baseGeometry.GetSegment(part, i);
box = GetUnion(box, segment.GetSubCurveBox(0, 1));
}
if (endSegmentIndex > startSegmentIndex && endFraction > 0)
{
segment = baseGeometry.GetSegment(part, endSegmentIndex);
box = GetUnion(box, segment.GetSubCurveBox(0, endFraction));
}
return(box);
}
internal static double GetLength([NotNull] IIndexedSegments baseGeometry,
int partIndex,
int startSegmentIndex, double startFraction,
int endSegmentIndex, double endFraction)
{
double length = 0;
for (int i = startSegmentIndex; i <= endSegmentIndex; i++)
{
SegmentProxy seg = baseGeometry.GetSegment(partIndex, i);
double segLength = seg.Length;
double addLength = segLength;
if (i == startSegmentIndex)
{
addLength -= segLength * startFraction;
}
if (i == endSegmentIndex)
{
addLength -= segLength * (1 - endFraction);
}
length += addLength;
}
return(length);
}
public Selection(EditorState state, int segmentNum, int sideNum, int pointNum)
{
_state = state;
_segment = _state.Level.Segments[segmentNum];
_side = _segment.Sides[_sideNum = sideNum];
_point = _side.Points[_pointNum = pointNum];
}
protected override bool VerifyContinue(SegmentProxy seg0, SegmentProxy seg1,
SegmentNeighbors processed1,
SegmentParts partsOfSeg0, bool coincident)
{
TryAssignComplete(seg1, processed1, partsOfSeg0);
SegmentParts coincidentPartsOfSeg0;
var key = new SegmentPart(seg0, 0, 1, true);
if (!_coincidentParts.TryGetValue(key, out coincidentPartsOfSeg0))
{
coincidentPartsOfSeg0 = new SegmentParts();
_coincidentParts.Add(key, coincidentPartsOfSeg0);
}
if (coincident)
{
partsOfSeg0.IsComplete = true;
coincidentPartsOfSeg0.Add(key);
return(false);
}
//return true;
IBox seg0Box = seg0.Extent;
seg0Box = new Box(Pnt.Create(seg0Box.Min), Pnt.Create(seg0Box.Max));
if (_coincidenceTolerance > 0)
{
seg0Box.Min.X -= _coincidenceTolerance;
seg0Box.Min.Y -= _coincidenceTolerance;
seg0Box.Max.X += _coincidenceTolerance;
seg0Box.Max.Y += _coincidenceTolerance;
}
if (!seg0Box.Intersects(seg1.Extent))
{
return(true);
}
var cap = new RoundCap();
NearSegment hullStart;
NearSegment hullEnd;
bool isCoincident;
IList <double[]> limits =
FindNeighborhood(
new SegmentHull(seg0, 0, cap, cap),
new SegmentHull(seg1, _coincidenceTolerance, cap, cap),
_is3D, 0,
out hullStart, out hullEnd, out isCoincident);
IList <SegmentPart> addParts = GetSegmentParts(seg0, seg1, limits, isCoincident);
coincidentPartsOfSeg0.AddRange(addParts);
bool isComplete = SegmentPart.VerifyComplete(coincidentPartsOfSeg0);
partsOfSeg0.IsComplete = isComplete;
return(!isComplete);
}
public HeightSegment(SegmentProxy segment)
{
_segment = segment;
double z0 = segment.GetStart(true)[2];
double z1 = segment.GetStart(true)[2];
_height = (z0 + z1) / 2.0;
}
protected override bool VerifyContinue(SegmentProxy seg0, SegmentProxy seg1,
SegmentNeighbors processed1,
SegmentParts partsOfSeg0, bool coincident)
{
bool isComplete = SegmentPart.VerifyComplete(partsOfSeg0);
TryAssignComplete(seg1, processed1, partsOfSeg0);
return(!isComplete);
}
private static double GetDistanceToVertices([NotNull] IPoint point,
[NotNull] IFeature neighbourFeature,
[NotNull] IPoint nearestPoint,
double maxNeededDistance)
{
double minDistance2 = double.MaxValue;
SegmentProxy nearestSegment = null;
var isEndNearest = false;
Pnt qaPoint = QaGeometryUtils.CreatePoint3D(point);
IEnumerable <SegmentProxy> segments = EnumSegments(qaPoint, neighbourFeature,
maxNeededDistance);
foreach (SegmentProxy segment in segments)
{
if (GetNearest(qaPoint, segment.GetStart(false), ref minDistance2))
{
nearestSegment = segment;
isEndNearest = false;
}
if (GetNearest(qaPoint, segment.GetEnd(false), ref minDistance2))
{
nearestSegment = segment;
isEndNearest = true;
}
}
double minDistance;
if (nearestSegment != null)
{
minDistance = Math.Sqrt(minDistance2);
if (minDistance <= maxNeededDistance)
{
Pnt nearest = !isEndNearest
? nearestSegment.GetStart(true)
: nearestSegment.GetEnd(true);
nearestPoint.PutCoords(nearest.X, nearest.Y);
nearestPoint.Z = nearest[2];
}
}
else
{
minDistance = double.MaxValue;
}
return(minDistance);
}
private IEnumerable <bool> GetConnectedCandidateAtStarts(IIndexedSegments geometry,
SegmentProxy segment)
{
if (segment.SegmentIndex == 0 ||
ConnectionMode != ConnectionMode.EndpointOnEndpoint)
{
yield return(true);
}
if (segment.SegmentIndex + 1 == geometry.GetPartSegmentCount(segment.PartIndex) ||
ConnectionMode != ConnectionMode.EndpointOnEndpoint)
{
yield return(false);
}
}
private static void AddSegment([NotNull] IFeature feature,
[NotNull] IIndexedSegments geom,
[NotNull] IList <Subcurve> connectedList,
[NotNull] SegmentProxy segProxy, double min,
double max)
{
if (min >= max)
{
return;
}
Subcurve current = null;
if (connectedList.Count > 0)
{
current = connectedList[connectedList.Count - 1];
}
if (current != null)
{
if (current.PartIndex != segProxy.PartIndex)
{
current = null;
}
else if (current.EndSegmentIndex + current.EndFraction <
segProxy.SegmentIndex + min)
{
current = null;
}
}
if (current == null)
{
current = new Subcurve(geom, segProxy.PartIndex, segProxy.SegmentIndex,
min, segProxy.SegmentIndex, max);
connectedList.Add(current);
}
else
{
if (current.EndSegmentIndex + current.EndFraction < segProxy.SegmentIndex + max)
{
current.EndSegmentIndex = segProxy.SegmentIndex;
current.EndFraction = max;
}
}
}
private bool IsHorizontal([NotNull] SegmentProxy segment)
{
double length = segment.Length;
if (Math.Abs(length) < double.Epsilon)
{
return(false);
}
double z0 = segment.GetStart(true)[2];
double z1 = segment.GetEnd(true)[2];
double slopeAngle = Math.Atan2(Math.Abs(z1 - z0), length);
bool isHorizontal = slopeAngle <= _horizontalToleranceRad;
return(isHorizontal);
}
public AzimuthSegment([NotNull] SegmentProxy segment, double xyResolution)
{
Segment = segment;
_xyResolution = xyResolution;
Pnt start = Segment.GetStart(false);
Pnt end = Segment.GetEnd(false);
double dx = end.X - start.X;
double dy = end.Y - start.Y;
Azimuth = Math.Atan2(dx, dy); // Azimuth is the angle to north
if (Azimuth < 0) // the orientation must be ignored
{
Azimuth += Math.PI;
}
}
private static SegmentProxyInfo GetSegmentproxyInfo(
[NotNull] NeighboredSegmentsSubpart segmentsSubpart, int baseSegmentIndex)
{
int subpartIndex =
segmentsSubpart.FullStartFraction < segmentsSubpart.FullEndFraction
? baseSegmentIndex - segmentsSubpart.FullStartFraction
: segmentsSubpart.FullStartFraction - baseSegmentIndex - 1;
SegmentProxy segmentProxy = segmentsSubpart.GetSegment(subpartIndex);
var key = new SegmentPart(segmentProxy, 0, 1, true);
// SegmentPart key = new SegmentPart(segmentsSubpart.PartIndex, iSegment, 0, 1, true);
SegmentParts segmentParts;
segmentsSubpart.SegmentNeighbors.TryGetValue(key, out segmentParts);
return(new SegmentProxyInfo(segmentProxy, segmentsSubpart));
}
private static double GetOffset([NotNull] Pnt pnt,
[NotNull] SegmentProxy segmentProxy,
out double fraction,
out bool?onRightSide)
{
double?offset;
fraction = SegmentUtils.GetClosestPointFraction(
segmentProxy, pnt, out offset, out onRightSide, as3D: false);
double distance2;
if (fraction < 0)
{
distance2 = pnt.Dist2(segmentProxy.GetStart(as3D: false));
onRightSide = null;
}
else if (fraction > 1)
{
distance2 = pnt.Dist2(segmentProxy.GetEnd(as3D: false));
onRightSide = null;
}
else
{
if (!offset.HasValue)
{
Pnt s = segmentProxy.GetStart(as3D: false);
Pnt e = segmentProxy.GetEnd(as3D: false);
double vectorProd = (pnt - s).VectorProduct(s - e);
onRightSide = vectorProd < 0;
distance2 = pnt.Dist2(segmentProxy.GetPointAt(fraction, as3D: false));
}
else
{
distance2 = 0; // offset has value and will be used as distance
}
}
double distance = offset ?? Math.Sqrt(distance2);
return(distance);
}
private static void GetClosePart([NotNull] SegmentProxy neighbor,
[NotNull] IIndexedSegments geom,
[NotNull] SegmentPart segPart,
double searchDistanceSquared, bool is3D,
out double min, out double max)
{
SegmentProxy part = geom.GetSegment(segPart.PartIndex, segPart.SegmentIndex);
IPnt start = part.GetPointAt(segPart.MinFraction);
double minStart, maxStart;
GetClosePart(neighbor, start, searchDistanceSquared, is3D, out minStart,
out maxStart);
IPnt end = part.GetPointAt(segPart.MaxFraction);
double minEnd, maxEnd;
GetClosePart(neighbor, end, searchDistanceSquared, is3D, out minEnd, out maxEnd);
min = Math.Min(minStart, minEnd);
max = Math.Max(maxStart, maxEnd);
}
public void CanCutRoundRound()
{
var cap = new RoundCap();
SegmentProxy segment0 = CreateSegment(0, 0, 0, 10);
var hull = new SegmentHull(segment0, 1, cap, cap);
SegmentProxy segment1 = CreateSegment(-5, 5, 5, 5);
var neighbor = new SegmentHull(segment1, 1, cap, cap);
var pair = new SegmentPair2D(hull, neighbor);
IList <double[]> limits;
NearSegment startNear;
NearSegment endNear;
bool coincident;
bool intersects = pair.CutCurveHull(0, out limits, out startNear, out endNear,
out coincident);
Assert.IsTrue(intersects);
}
public void CutCurveHullTest()
{
//seg0 = CreateSegment(GeometryFactory.CreatePoint(0, 0, 0), GeometryFactory.CreatePoint(100, 200, 10));
//seg1 = CreateSegment(GeometryFactory.CreatePoint(0, 0, 0), GeometryFactory.CreatePoint(100, 200, 10));
//SegmentUtils.CutCurveHull(seg0, seg1, 0, 0, true,
// out limits, out hullStartNear, out hullEndNear, out coincident);
const double r = 0.0001;
const double x0 = 600000;
const double y0 = 200000;
SegmentProxy seg0 = CreateSegment(
GeometryFactory.CreatePoint(x0 + 100, y0 + 200, 10),
GeometryFactory.CreatePoint(x0, y0, 500));
SegmentProxy seg1 = CreateSegment(
GeometryFactory.CreatePoint(x0, y0, 500 + 2 * r),
GeometryFactory.CreatePoint(x0 - 200 - r, y0, 20));
IList <double[]> limits;
NearSegment hullStartNear;
NearSegment hullEndNear;
bool coincident;
SegmentHull hull0 = seg0.CreateHull(0);
SegmentHull hull1 = seg1.CreateHull(0);
var pair2D = new SegmentPair2D(hull0, hull1);
pair2D.CutCurveHull(0,
out limits, out hullStartNear, out hullEndNear, out coincident);
Assert.AreEqual(1, limits.Count);
var pair3D = new SegmentPair3D(hull0, hull1);
pair3D.CutCurveHull(0,
out limits, out hullStartNear, out hullEndNear, out coincident);
Assert.AreEqual(0, limits.Count);
}
private static bool AreEqualSegments(SegmentProxy x, SegmentProxy y)
{
return(x.PartIndex == y.PartIndex &&
x.SegmentIndex == y.SegmentIndex);
}
private void AddSegment([NotNull] IFeature feature,
[NotNull] IIndexedSegments geom,
[NotNull] IList <Subcurve> standardConnectedList,
[NotNull] IList <Subcurve> nearSelfConnectedList,
[NotNull] SegmentPart segPart,
double connectedMinLength,
double nearSquared)
{
Subcurve current = null;
IList <Subcurve> connectedList = standardConnectedList;
SegmentProxy neighbor = segPart.NearSelf;
if (neighbor != null)
{
// Get the distance between the parts that are near
double d0 = double.MaxValue;
int partIndex = segPart.PartIndex;
if (geom.IsPartClosed(partIndex) || segPart.SegmentIndex > neighbor.SegmentIndex)
{
if (segPart.PartIndex == neighbor.PartIndex)
// TODO revise; workaround to avoid exception (invalid index)
{
// raw estimate for distance betwenn segPart and neighborPart
// this estimate is too small, because not the entire part of neighbor is near segPart
var curve = new SubClosedCurve(geom, partIndex,
neighbor.SegmentIndex + 1,
segPart.FullMin);
d0 = curve.GetLength();
if (d0 < connectedMinLength)
{
double d0Max = d0 + neighbor.Length;
if (d0Max > connectedMinLength)
{
// closer investigation necessary
double min;
double max;
GetClosePart(neighbor, geom, segPart, nearSquared, Is3D,
out min, out max);
d0 = d0 + (1 - max) * neighbor.Length;
} // else segPart is definitly near neighbor
} //else segPart is definitly not near neighbor
}
}
if (geom.IsPartClosed(partIndex) || segPart.SegmentIndex < neighbor.SegmentIndex)
{
if (segPart.PartIndex == neighbor.PartIndex)
// TODO revise; workaround to avoid exception (invalid index)
{
var curve = new SubClosedCurve(geom, partIndex,
segPart.FullMax,
neighbor.SegmentIndex);
double d0Min = curve.GetLength();
if (d0Min < connectedMinLength)
{
double d0Max = d0Min + neighbor.Length;
if (d0Max > connectedMinLength)
{
// closer investigation necessary
double min;
double max;
GetClosePart(neighbor, geom, segPart, nearSquared, Is3D,
out min, out max);
d0Min = d0Min + min * neighbor.Length;
} //else segPart is definitly near neighbor
} // else segPart is definitly not near neighbor
d0 = Math.Min(d0, d0Min);
}
}
if (d0 < connectedMinLength)
{
connectedList = nearSelfConnectedList;
}
}
if (connectedList.Count > 0)
{
current = connectedList[connectedList.Count - 1];
}
if (current != null)
{
if (current.PartIndex != segPart.PartIndex)
{
current = null;
}
else if (current.EndFullIndex < segPart.FullMin)
{
current = null;
}
}
if (current == null)
{
current = new Subcurve(geom, segPart.PartIndex, segPart.SegmentIndex,
segPart.MinFraction, segPart.SegmentIndex,
segPart.MaxFraction);
connectedList.Add(current);
}
else
{
if (current.EndFullIndex < segPart.FullMax)
{
current.EndSegmentIndex = segPart.SegmentIndex;
current.EndFraction = segPart.MaxFraction;
}
}
}
public SegmentProxyInfo([NotNull] SegmentProxy segmentProxy,
[NotNull] NeighboredSegmentsSubpart subpart)
{
SegmentProxy = segmentProxy;
Subpart = subpart;
}
private static bool?GetOnRightSide(
[NotNull] SegmentProxy nearestSegment, double nearestFraction,
[NotNull] SegmentProxy segmentProxy, double alongFraction,
[NotNull] IGeometry baseGeometry)
{
if (nearestSegment.PartIndex != segmentProxy.PartIndex)
{
return(null);
}
SegmentProxy from;
SegmentProxy to;
if (nearestFraction >= 1)
{
if (alongFraction > 0)
{
return(null);
}
ISegmentProxy next = nearestSegment.GetNextSegment(baseGeometry);
if (next == null)
{
return(null);
}
if (next.SegmentIndex != segmentProxy.SegmentIndex)
{
return(null);
}
from = nearestSegment;
to = segmentProxy;
}
else if (nearestFraction <= 0)
{
if (alongFraction < 1)
{
return(null);
}
ISegmentProxy next = segmentProxy.GetNextSegment(baseGeometry);
if (next == null)
{
return(null);
}
if (next.SegmentIndex != nearestSegment.SegmentIndex)
{
return(null);
}
from = segmentProxy;
to = nearestSegment;
}
else
{
// unexpected
return(null);
}
Pnt vectorFrom = from.GetEnd(as3D: false) - from.GetStart(as3D: false);
Pnt vectorTo = to.GetEnd(as3D: false) - to.GetStart(as3D: false);
bool onRightSide = vectorFrom.VectorProduct(vectorTo) > 0;
return(onRightSide);
}
private static double GetDistanceToCurve(
[NotNull] IPoint point,
[NotNull] IFeature neighbourFeature,
[NotNull] IPoint nearestPoint,
double maxNeededDistance,
out bool onRightSide)
{
var neighborCurve = (ICurve)neighbourFeature.Shape;
if (UseQueryPointAndDistance)
{
const bool asRatio = false;
double along = 0;
double distance = 0;
var rightSide = false;
// TLMQA-292 (EBG - BB): most time spent here (> 90%)
neighborCurve.QueryPointAndDistance(esriSegmentExtension.esriNoExtension,
point, asRatio, nearestPoint,
ref along, ref distance, ref rightSide);
onRightSide = rightSide;
return(distance);
}
{
double nearestDistance = maxNeededDistance * 1.01;
bool? nearestOnRightSide = null;
SegmentProxy nearestSegment = null;
double nearestFraction = 0;
double x;
double y;
point.QueryCoords(out x, out y);
Pnt qaPoint = new Pnt2D(x, y);
foreach (SegmentProxy segmentProxy in
EnumSegments(qaPoint, neighbourFeature, maxNeededDistance))
{
bool? onSegmentRightSide;
double alongFraction;
double offset = GetOffset(qaPoint, segmentProxy,
out alongFraction, out onSegmentRightSide);
if (offset <= nearestDistance)
{
if (!onSegmentRightSide.HasValue && !nearestOnRightSide.HasValue &&
nearestSegment != null)
{
nearestOnRightSide = GetOnRightSide(
nearestSegment, nearestFraction, segmentProxy, alongFraction,
neighborCurve);
}
else if (offset < nearestDistance)
{
nearestOnRightSide = onSegmentRightSide;
}
nearestDistance = offset;
nearestSegment = segmentProxy;
nearestFraction = alongFraction;
}
}
if (nearestSegment != null)
{
double f = Math.Min(1, Math.Max(0, nearestFraction));
IPnt p = nearestSegment.GetPointAt(f, as3D: true);
nearestPoint.PutCoords(p.X, p.Y);
nearestPoint.Z = p[2];
if (!nearestOnRightSide.HasValue)
{
// Extend segment lineary to determine right side
Pnt s = nearestSegment.GetStart(as3D: false);
Pnt e = nearestSegment.GetEnd(as3D: false);
if (nearestFraction >= 1)
{
nearestOnRightSide = (e - s).VectorProduct(e - qaPoint) > 0;
}
else if (nearestFraction <= 0)
{
nearestOnRightSide = (e - s).VectorProduct(s - qaPoint) > 0;
}
}
}
onRightSide = nearestOnRightSide ?? false;
return(nearestDistance);
}
}
private void Initialize()
{
_indexedMultipatch = GetAdaptedMultiPatch();
IMultiPatch multiPatch = _indexedMultipatch.BaseGeometry;
_verticalFaceSegments = new List <SegmentProxy>();
var patches = (IGeometryCollection)multiPatch;
var verticalPatchParts = new Dictionary <int, List <int> >();
int patchCount = patches.GeometryCount;
for (int patchIndex = 0; patchIndex < patchCount; patchIndex++)
{
List <int> partIndexes = _indexedMultipatch.GetPartIndexes(patchIndex);
foreach (int partIndex in partIndexes)
{
int partSegmentCount =
_indexedMultipatch.GetPartSegmentCount(partIndex);
var segments = new List <SegmentProxy>(partSegmentCount);
for (int segmentIndex = 0;
segmentIndex < partSegmentCount;
segmentIndex++)
{
segments.Add(
_indexedMultipatch.GetSegment(partIndex, segmentIndex));
}
Plane plane =
QaGeometryUtils.CreatePlane(
(IEnumerable <SegmentProxy>)segments);
if (Math.Abs(plane.GetNormalVector().Z) < double.Epsilon)
{
List <int> verticalParts;
if (!verticalPatchParts.TryGetValue(
patchIndex, out verticalParts))
{
verticalParts = new List <int>();
verticalPatchParts.Add(patchIndex, verticalParts);
}
verticalParts.Add(partIndex);
_verticalFaceSegments.AddRange(segments);
}
}
}
if (verticalPatchParts.Count > 0)
{
object missing = Type.Missing;
IMultiPatch nonVerticalMultiPatch =
new MultiPatchClass
{
SpatialReference = multiPatch.SpatialReference
};
for (int patchIndex = 0; patchIndex < patchCount; patchIndex++)
{
List <int> verticalParts;
IGeometry patch =
((IGeometryCollection)multiPatch).Geometry[patchIndex];
if (!verticalPatchParts.TryGetValue(
patchIndex, out verticalParts))
{
IGeometry clone = GeometryFactory.Clone(patch);
((IGeometryCollection)nonVerticalMultiPatch).AddGeometry(
clone,
ref missing,
ref missing);
var ring = patch as IRing;
if (ring != null)
{
bool isBeginning = false;
esriMultiPatchRingType ringType =
multiPatch.GetRingType(ring, ref isBeginning);
nonVerticalMultiPatch.PutRingType(
(IRing)clone, ringType);
}
}
else
{
if (patch is IRing)
{
continue;
}
List <int> partIndexes =
_indexedMultipatch.GetPartIndexes(patchIndex);
foreach (int partIndex in partIndexes)
{
if (verticalParts.Contains(partIndex))
{
continue;
}
int partSegmentCount =
_indexedMultipatch.GetPartSegmentCount(partIndex);
var points = new List <WKSPointZ>(3);
for (int segmentIndex = 0;
segmentIndex < partSegmentCount;
segmentIndex++)
{
SegmentProxy segment =
_indexedMultipatch.GetSegment(
partIndex, segmentIndex);
const bool as3D = true;
Pnt p = segment.GetStart(as3D);
points.Add(
WKSPointZUtils.CreatePoint(p.X, p.Y, p[2]));
}
IRing ring = CreateRing(points);
((IGeometryCollection)nonVerticalMultiPatch).AddGeometry(
ring,
ref missing,
ref missing);
}
}
}
_nonVerticalMultipatch = nonVerticalMultiPatch;
}
else
{
_nonVerticalMultipatch = multiPatch;
}
}
protected override bool VerifyContinue(SegmentProxy seg0, SegmentProxy seg1,
SegmentNeighbors processed1,
SegmentParts partsOfSeg0, bool coincident)
{
return(true);
}
