public void Dispose(bool disposing) { if (disposing) { if (this.basePath != null) { this.basePath.Dispose(); this.basePath = null; } if (this.continuation != null) { this.continuation.Dispose(); this.continuation = null; } if (this.cumulativeTransform != null) { this.cumulativeTransform.Dispose(); this.cumulativeTransform = null; } if (this.interimTransform != null) { this.interimTransform.Dispose(); this.interimTransform = null; } } }
// only works if base is empty public void SetContinuation(GeometryGraphicsPath path, CombineMode combineMode, bool takeOwnership) { lock (this.syncRoot) { if (!this.data.basePath.IsEmpty) { throw new InvalidOperationException("base path must be empty to use this overload of SetContinuation"); } OnChanging(); CommitInterimTransform(); ResetCumulativeTransform(); this.data.continuationCombineMode = combineMode; if (takeOwnership) { this.data.continuation.Dispose(); this.data.continuation = path; } else { this.data.continuation.Reset(); this.data.continuation.AddPath(path, false); } OnChanged(); } }
public GeometryRegion CreateRegionRaw() { using (GeometryGraphicsPath path = CreatePath()) { return(new GeometryRegion(path)); } }
public GeometryGraphicsPath Clone() { GeometryGraphicsPath path = new GeometryGraphicsPath((GraphicsPath)gdiPath.Clone()); path.tooComplex = this.tooComplex; return(path); }
public bool IsVisible(Point pt) { using (GeometryGraphicsPath path = CreatePath()) //GeometryGraphicsPath path = GetPathReadOnly(); { return(path.IsVisible(pt)); } }
public RectangleF GetBoundsF(bool applyInterimTransformation) { using (GeometryGraphicsPath path = this.CreatePath(applyInterimTransformation)) //GeometryGraphicsPath path = GetPathReadOnly(applyInterimTransformation); { RectangleF bounds2 = path.GetBounds2(); return(bounds2); } }
public Data() { this.basePath = new GeometryGraphicsPath(); this.continuation = new GeometryGraphicsPath(); this.continuationCombineMode = CombineMode.Xor; this.cumulativeTransform = new Matrix(); this.cumulativeTransform.Reset(); this.interimTransform = new Matrix(); this.interimTransform.Reset(); }
public GeometryGraphicsPath CreatePixelatedPath() { using (GeometryGraphicsPath path = CreatePath()) //GeometryGraphicsPath path = GetPathReadOnly(); { using (GeometryRegion region = new GeometryRegion(path)) { GeometryGraphicsPath pixellatedPath = GeometryGraphicsPath.FromRegion(region); return(pixellatedPath); } } }
public void CommitContinuation() { lock (this.syncRoot) { OnChanging(); this.data.continuation.CloseAllFigures(); GeometryGraphicsPath newBasePath = CreatePath(); this.data.basePath.Dispose(); this.data.basePath = newBasePath; this.data.continuation.Reset(); this.data.continuationCombineMode = CombineMode.Xor; OnChanged(); } }
public GeometryGraphicsPath CreatePath(bool applyInterimTransform) { lock (this.syncRoot) { GeometryGraphicsPath returnPath = GeometryGraphicsPath.Combine(this.data.basePath, this.data.continuationCombineMode, this.data.continuation); if (applyInterimTransform) { returnPath.Transform(this.data.interimTransform); } return(returnPath); } }
public static GeometryGraphicsPath FromRegion(GeometryRegion region) { Rectangle[] scans = region.GetRegionScansReadOnlyInt(); if (scans.Length == 1) { var path = new GeometryGraphicsPath(); path.AddRectangle(scans[0]); path.CloseFigure(); return(path); } else { Rectangle bounds = region.GetBoundsInt(); var stencil = new BitVector2D(bounds.Width, bounds.Height); for (int i = 0; i < scans.Length; ++i) { Rectangle rect = scans[i]; rect.X -= bounds.X; rect.Y -= bounds.Y; stencil.UnsafeSet(rect, true); } GeometryGraphicsPath path = PathFromStencil(stencil, new Rectangle(0, 0, stencil.Width, stencil.Height)); using (Matrix matrix = new Matrix()) { matrix.Reset(); matrix.Translate(bounds.X, bounds.Y); path.Transform(matrix); } return(path); } }
public GeometryRegion(GeometryGraphicsPath pdnPath) : this(pdnPath.GetRegionCache()) { }
public static GeometryGraphicsPath Combine(GeometryGraphicsPath subjectPath, CombineMode combineMode, GeometryGraphicsPath clipPath) { switch (combineMode) { case CombineMode.Complement: return(Combine(clipPath, CombineMode.Exclude, subjectPath)); case CombineMode.Replace: return(clipPath.Clone()); case CombineMode.Xor: case CombineMode.Intersect: case CombineMode.Union: case CombineMode.Exclude: if (subjectPath.IsEmpty && clipPath.IsEmpty) { return(new GeometryGraphicsPath()); // empty path } if (subjectPath.IsEmpty) { switch (combineMode) { case CombineMode.Xor: case CombineMode.Union: return(clipPath.Clone()); case CombineMode.Intersect: case CombineMode.Exclude: return(new GeometryGraphicsPath()); default: throw new InvalidEnumArgumentException(); } } if (clipPath.IsEmpty) { switch (combineMode) { case CombineMode.Exclude: case CombineMode.Xor: case CombineMode.Union: return(subjectPath.Clone()); case CombineMode.Intersect: return(new GeometryGraphicsPath()); default: throw new InvalidEnumArgumentException(); } } else { return(null); // GraphicsPath resultPath = PtnGraphics.ClipPath(subjectPath, combineMode, clipPath); // return new GeometryGraphicsPath(resultPath); } default: throw new InvalidEnumArgumentException(); } }
/// <summary> /// Creates a graphics path from the given stencil buffer. It should be filled with 'true' values /// to indicate the areas that should be outlined. /// </summary> /// <param name="stencil">The stencil buffer to read from. NOTE: The contents of this will be destroyed when this method returns.</param> /// <param name="bounds">The bounding box within the stencil buffer to limit discovery to.</param> /// <returns>A GeometryGraphicsPath with traces that outline the various areas from the given stencil buffer.</returns> public unsafe static GeometryGraphicsPath PathFromStencil(IBitVector2D stencil, Rectangle bounds) { if (stencil.IsEmpty) { return(new GeometryGraphicsPath()); } var ret = new GeometryGraphicsPath(); Point start = bounds.Location; var pts = new Vector <Point>(); int count = 0; // find all islands while (true) { bool startFound = false; while (true) { if (stencil[start]) { startFound = true; break; } ++start.X; if (start.X >= bounds.Right) { ++start.Y; start.X = bounds.Left; if (start.Y >= bounds.Bottom) { break; } } } if (!startFound) { break; } pts.Clear(); Point last = new Point(start.X, start.Y + 1); Point curr = new Point(start.X, start.Y); Point next = curr; Point left = Point.Empty; Point right = Point.Empty; // trace island outline while (true) { left.X = ((curr.X - last.X) + (curr.Y - last.Y) + 2) / 2 + curr.X - 1; left.Y = ((curr.Y - last.Y) - (curr.X - last.X) + 2) / 2 + curr.Y - 1; right.X = ((curr.X - last.X) - (curr.Y - last.Y) + 2) / 2 + curr.X - 1; right.Y = ((curr.Y - last.Y) + (curr.X - last.X) + 2) / 2 + curr.Y - 1; if (bounds.Contains(left) && stencil[left]) { // go left next.X += curr.Y - last.Y; next.Y -= curr.X - last.X; } else if (bounds.Contains(right) && stencil[right]) { // go straight next.X += curr.X - last.X; next.Y += curr.Y - last.Y; } else { // turn right next.X -= curr.Y - last.Y; next.Y += curr.X - last.X; } if (Math.Sign(next.X - curr.X) != Math.Sign(curr.X - last.X) || Math.Sign(next.Y - curr.Y) != Math.Sign(curr.Y - last.Y)) { pts.Add(curr); ++count; } last = curr; curr = next; if (next.X == start.X && next.Y == start.Y) { break; } } Point[] points = pts.ToArray(); Scanline[] scans = Utility.GetScans(points); foreach (Scanline scan in scans) { stencil.Invert(scan); } ret.AddLines(points); ret.CloseFigure(); } return(ret); }
public static GeometryGraphicsPath FromRegions(GeometryRegion lhs, CombineMode combineMode, GeometryRegion rhs) { Rectangle lhsBounds = lhs.GetBoundsInt(); Rectangle rhsBounds = rhs.GetBoundsInt(); int left = Math.Min(lhsBounds.Left, rhsBounds.Left); int top = Math.Min(lhsBounds.Top, rhsBounds.Top); int right = Math.Max(lhsBounds.Right, rhsBounds.Right); int bottom = Math.Max(lhsBounds.Bottom, rhsBounds.Bottom); Rectangle bounds = Rectangle.FromLTRB(left, top, right, bottom); BitVector2D stencil = new BitVector2D(bounds.Width, bounds.Height); Rectangle[] lhsScans = lhs.GetRegionScansReadOnlyInt(); Rectangle[] rhsScans = rhs.GetRegionScansReadOnlyInt(); switch (combineMode) { case CombineMode.Complement: case CombineMode.Intersect: case CombineMode.Replace: throw new ArgumentException("combineMode can't be Complement, Intersect, or Replace"); } for (int i = 0; i < lhsScans.Length; ++i) { Rectangle rect = lhsScans[i]; rect.X -= bounds.X; rect.Y -= bounds.Y; stencil.UnsafeSet(rect, true); } for (int i = 0; i < rhsScans.Length; ++i) { Rectangle rect = rhsScans[i]; rect.X -= bounds.X; rect.Y -= bounds.Y; switch (combineMode) { case CombineMode.Xor: stencil.UnsafeInvert(rect); break; case CombineMode.Union: stencil.UnsafeSet(rect, true); break; case CombineMode.Exclude: stencil.UnsafeSet(rect, false); break; } } GeometryGraphicsPath path = PathFromStencil(stencil, new Rectangle(0, 0, stencil.Width, stencil.Height)); using (var matrix = new Matrix()) { matrix.Reset(); matrix.Translate(bounds.X, bounds.Y); path.Transform(matrix); } return(path); }