/// <summary> /// Marks an edge which forms part of the boundary of the result area. /// This is determined by the overlay operation being executed, /// and the location of the edge. /// The relevant location is either the right side of a boundary edge, /// or the line location of a non-boundary edge. /// </summary> /// <param name="e">The edge to mark</param> /// <param name="overlayOpCode">The overlay operation</param> public void MarkInResultArea(OverlayEdge e, SpatialFunction overlayOpCode) { var label = e.Label; if (label.IsBoundaryEither && OverlayNG.IsResultOfOp( overlayOpCode, label.GetLocationBoundaryOrLine(0, Position.Right, e.IsForward), label.GetLocationBoundaryOrLine(1, Position.Right, e.IsForward))) { e.MarkInResultArea(); } //Debug.println("markInResultArea: " + e); }
/// <summary> /// Checks if the topology indicated by an edge label /// determines that this edge should be part of a result line. /// <para/> /// Note that the logic here relies on the semantic /// that for intersection lines are only returned if /// there is no result area components. /// </summary> /// <param name="lbl">The label for an edge</param> /// <returns><c>true</c> if the edge should be included in the result</returns> private bool IsResultLine(OverlayLabel lbl) { /* * Omit edge which is a boundary of a single geometry * (i.e. not a collapse or line edge as well). * These are only included if part of a result area. * This is a short-circuit for the most common area edge case */ if (lbl.IsBoundarySingleton) { return(false); } /* * Omit edge which is a collapse along a boundary. * I.e a result line edge must be from a input line * OR two coincident area boundaries. * * This logic is only used if not including collapse lines in result. */ if (!_isAllowCollapseLines && lbl.IsBoundaryCollapse) { return(false); } /* * Omit edge which is a collapse interior to its parent area. * (E.g. a narrow gore, or spike off a hole) */ if (lbl.IsInteriorCollapse) { return(false); } /* * For ops other than Intersection, omit a line edge * if it is interior to the other area. * * For Intersection, a line edge interior to an area is included. */ if (_opCode != OverlayNG.INTERSECTION) { /* * Omit collapsed edge in other area interior. */ if (lbl.IsCollapseAndNotPartInterior) { return(false); } /* * If there is a result area, omit line edge inside it. * It is sufficient to check against the input area rather * than the result area, * because if line edges are present then there is only one input area, * and the result area must be the same as the input area. */ if (_hasResultArea && lbl.IsLineInArea(_inputAreaIndex)) { return(false); } } /* * Include line edge formed by touching area boundaries, * if enabled. */ if (_isAllowMixedResult && _opCode == OverlayNG.INTERSECTION && lbl.IsBoundaryTouch) { return(true); } /* * Finally, determine included line edge * according to overlay op boolean logic. */ var aLoc = EffectiveLocation(lbl, 0); var bLoc = EffectiveLocation(lbl, 1); bool isInResult = OverlayNG.IsResultOfOp(_opCode, aLoc, bLoc); return(isInResult); }