public MinkowskiDifference(IShape2D shapeA, Transform2D transformA, IShape2D shapeB, Transform2D transformB) { ShapeA = shapeA; TransformA = transformA; ShapeB = shapeB; TransformB = transformB; }
public static Bounds2D GetBounds(IShape2D shape, Matrix4D transformation) { Bounds2D bounds = new Bounds2D(); ShapeTool.AddToBounds(bounds, shape.CreateIterator(), transformation); return(bounds); }
public static Bounds2D GetBounds(IShape2D shape) { Bounds2D bounds = new Bounds2D(); shape.AddToBounds(bounds); return(bounds); }
public Vector3[] GetVectors(IShape2D shape) { RectangleF r = shape.Bounds; float x0 = -0.5f * dxy; float y0 = x0 * (n - 0x01); x0 *= (m - 0x01); double dxyinv = 1.0d / this.dxy; int xi1 = Math.Max(0x00, Math.Min(n - 0x01, (int)Math.Floor((r.X - x0) * dxyinv))); int xi2 = Math.Max(0x00, Math.Min(n - 0x01, (int)Math.Ceiling((r.Right - x0) * dxyinv))); int yi1 = Math.Max(0x00, Math.Min(m - 0x01, (int)Math.Floor((r.Y - y0) * dxyinv))); int yi2 = Math.Max(0x00, Math.Min(m - 0x01, (int)Math.Ceiling((r.Bottom - y0) * dxyinv))); int dx = xi2 - xi1; int dxa = n - dx - 0x01; int k = yi1 * n + xi1, K; Vector3 v; Stack <Vector3> vs = new Stack <Vector3>(); for (int y = yi1; y <= yi2; y++) { for (K = k + dx; k <= K; k++) { v = PosNor[k]; if (shape.Contains(v.X, v.Z)) { vs.Push(v); } } k += dxa; } return(vs.ToArray()); }
public BoundingBox2D(IShape2D obj, Point2D topLeft) { shape = obj; TopLeft = topLeft; Width = obj.GetWidth(); Height = obj.GetHeight(); }
public Collider(IShape2D colliderShape) { shape = colliderShape; OnCollisionEnter += AddNewIntersectingCollider; OnCollisionExit += RemoveIntersectingCollider; IntersectingColliders = new List <Collider>(); }
public Class866(char letter, IShape2D path, Vector2D advance, bool filled) { this.vector2D_0 = advance; this.char_0 = letter; this.ishape2D_0 = path ?? ShapeTool.NullShape; this.bool_0 = filled; }
public Vector3[] GetVectors(IShape2D shape) { RectangleF r = shape.Bounds; float x0 = -0.5f*dxy; float y0 = x0*(n-0x01); x0 *= (m-0x01); double dxyinv = 1.0d/this.dxy; int xi1 = Math.Max(0x00,Math.Min(n-0x01,(int) Math.Floor((r.X-x0)*dxyinv))); int xi2 = Math.Max(0x00,Math.Min(n-0x01,(int) Math.Ceiling((r.Right-x0)*dxyinv))); int yi1 = Math.Max(0x00,Math.Min(m-0x01,(int) Math.Floor((r.Y-y0)*dxyinv))); int yi2 = Math.Max(0x00,Math.Min(m-0x01,(int) Math.Ceiling((r.Bottom-y0)*dxyinv))); int dx = xi2-xi1; int dxa = n-dx-0x01; int k = yi1*n+xi1, K; Vector3 v; Stack<Vector3> vs = new Stack<Vector3>(); for(int y = yi1; y <= yi2; y++) { for(K = k+dx; k <= K; k++) { v = PosNor[k]; if(shape.Contains(v.X,v.Z)) { vs.Push(v); } } k += dxa; } return vs.ToArray(); }
private static Vector2 GenerateDartInShapeBounds(IShape2D shape) { double randW = ThreadSafeRandom.Next() * (shape.MaxX - shape.MinX) + shape.MinX; double randH = ThreadSafeRandom.Next() * (shape.MaxY - shape.MinY) + shape.MinY; var dart = new Vector2(randW, randH); return(dart); }
public static bool AreEqual(IShape2D shape1, IShape2D shape2) { if (shape1 == shape2) { return(true); } return(ShapeTool.smethod_1(shape1.CreateIterator(), shape2.CreateIterator())); }
public void DrawCharPath( IShape2D path, Matrix4D transform, Color color, short lineWeight, bool filled, double extrusion) { this.method_0(path, color, transform, filled, extrusion, true); }
public CachedBoundsShape2D(IShape2D wrappedShape) { this.ishape2D_0 = wrappedShape; this.bounds2D_0 = new Bounds2D(); wrappedShape.AddToBounds(this.bounds2D_0); if (this.bounds2D_0.Initialized) { return; } this.bounds2D_0 = (Bounds2D)null; }
public void DrawCharPath( IShape2D path, Matrix4D transform, Color color, short lineWeight, bool filled, double extrusion) { IShape4D shape = (IShape4D) new FlatShape4D(path, filled); shape.Transform(transform); this.ipathDrawer_0.DrawCharPath(this.iclippingTransformer_0.Transform(shape).ToShape2D(Matrix4D.Identity), Matrix4D.Identity, color, lineWeight, filled, extrusion); }
public static FillableShape2D ToFillableShape(IShape2D shape, bool filled) { FillableShape2D fillableShape2D = shape as FillableShape2D; if (fillableShape2D == null) { return(new FillableShape2D(shape, filled)); } if (fillableShape2D.Filled != filled) { return(new FillableShape2D(fillableShape2D.ishape2D_0, filled)); } return(fillableShape2D); }
internal Class454 method_0(IShape2D shape, GraphicsConfig config) { Struct13 key = new Struct13(shape, config.ShapeFlattenEpsilon); Class454 class454_1; if (this.dictionary_0.TryGetValue(key, out class454_1)) { return(class454_1); } Class454 class454_2 = new Class454(shape, config); this.dictionary_0.Add(key, class454_2); return(class454_2); }
public bool Intersects(IShape2D other, bool doubledsided = true) { if (other is Rect rectangle) { return(this.Intersects(rectangle)); } else if (doubledsided) { return(other.Intersects(this, false)); } else { throw new ArgumentException(); } }
public Interface34 GetText( string text, WW.Cad.Model.Color color, short lineWeight, bool vertical) { GeneralShape2D generalShape2D; using (GraphicsPath graphicsPath = this.class26_0.method_1(text)) generalShape2D = (GeneralShape2D)graphicsPath; generalShape2D.FillMode = WW.Math.Geometry.FillMode.Winding; IShape2D path = generalShape2D.HasSegments ? (IShape2D) new CachedBoundsShape2D((IShape2D)generalShape2D) : (IShape2D)NullShape2D.Instance; return((Interface34) new Class865(text, (Interface14)this, color, lineWeight, path, this.class26_0.CharTransformation, Transformation2D.Scaling(this.class26_0.CanonicalScaling), this.class26_0.imethod_0(text, (IList <Vector2D>)null))); }
public void DrawPath( IShape2D path, Matrix4D transform, Color color, short lineWeight, bool filled, bool forText, double extrusion) { if (!path.HasSegments) { return; } IClippingTransformer transformer = (IClippingTransformer)this.wireframe_0.GetTransformer().Clone(); transformer.SetPreTransform(transform); IWireframeGraphicsFactory graphicsFactory0 = this.iwireframeGraphicsFactory_0; if (extrusion == 0.0) { IShape4D shape1 = (IShape4D) new FlatShape4D((IShape2D)(path as GeneralShape2D ?? new GeneralShape2D(path, true)), filled); IShape4D shape2 = transformer.Transform(shape1); if (shape2.IsEmpty) { return; } graphicsFactory0.CreateShape(this.dxfEntity_0, this.wireframe_0, this.wireframe_0.GetPlotColor(this.dxfEntity_0, color), forText, shape2); } else { IList <Polyline2D> flattened = (IList <Polyline2D>)ShapeTool.GetFlattened(path, this.wireframe_0.Config.ShapeFlattenEpsilon); IList <Polyline4D> polylines1 = DxfUtil.smethod_39(flattened, filled, transformer); ArgbColor plotColor = this.wireframe_0.GetPlotColor(this.dxfEntity_0, color); graphicsFactory0.CreatePathAsOne(this.dxfEntity_0, this.wireframe_0, plotColor, forText, polylines1, false, true); transformer.SetPreTransform(Transformation4D.Translation(0.0, 0.0, extrusion)); IList <Polyline4D> polylines2 = DxfUtil.smethod_39(flattened, filled, transformer); graphicsFactory0.CreatePathAsOne(this.dxfEntity_0, this.wireframe_0, plotColor, forText, polylines2, false, true); for (int index1 = polylines1.Count - 1; index1 >= 0; --index1) { Polyline4D polyline4D1 = polylines1[index1]; Polyline4D polyline4D2 = polylines2[index1]; for (int index2 = polyline4D1.Count - 1; index2 >= 0; --index2) { graphicsFactory0.CreateLine(this.dxfEntity_0, this.wireframe_0, plotColor, forText, polyline4D1[index2], polyline4D2[index2]); } } } }
private static OverlapInformation CalculateOverlap(IShape2D a, IShape2D b) { LineSegment edge = new LineSegment(0, 0, 0, 0); float minOverlap = float.MaxValue; for (int i = 0; i < a.Edges.Length; i++) { Vector2 normal = new Vector2( -(a.Edges[i].Y2 - a.Edges[i].Y1), a.Edges[i].X2 - a.Edges[i].X1 ); float minProjectionA = Vector2.Dot(a.Vertices[0], normal); float maxProjectionA = minProjectionA; for (int j = 1; j < a.Vertices.Length; j++) { float projection = Vector2.Dot(a.Vertices[j], normal); minProjectionA = Math.Min(minProjectionA, projection); maxProjectionA = Math.Max(maxProjectionA, projection); } float minProjectionB = Vector2.Dot(b.Vertices[0], normal); float maxProjectionB = minProjectionB; for (int j = 1; j < b.Vertices.Length; j++) { float projection = Vector2.Dot(b.Vertices[j], normal); minProjectionB = Math.Min(minProjectionB, projection); maxProjectionB = Math.Max(maxProjectionB, projection); } float overlap = Math.Min(maxProjectionA, maxProjectionB) - Math.Max(minProjectionA, minProjectionB); if (overlap < minOverlap) { minOverlap = overlap; edge = a.Edges[i]; } if (maxProjectionB < minProjectionA || maxProjectionA < minProjectionB) { return(new OverlapInformation(new LineSegment(), -1, false)); } } return(new OverlapInformation(edge, minOverlap, true)); }
public Class521(ShxFile font, ShxShape shape, GraphicsConfig graphicsConfig) { this.int_0 = font.Above; Point2D endPoint; IShape2D glyphShape = shape.GetGlyphShape(false, out endPoint); this.vector2D_0 = (Vector2D)endPoint; this.ilist_0 = (IList <Polyline2D>)ShapeTool.GetFlattened(glyphShape, graphicsConfig.ShapeFlattenEpsilon); foreach (List <Point2D> point2DList in (IEnumerable <Polyline2D>) this.ilist_0) { foreach (Point2D p in point2DList) { this.bounds2D_0.Update(p); } } }
public void method_4(IShape2D lining) { if (this.ishape2D_1 == null) { this.ishape2D_1 = new IShape2D[1] { lining }; } else { IShape2D[] shape2DArray = new IShape2D[this.ishape2D_1.Length + 1]; Array.Copy((Array)this.ishape2D_1, (Array)shape2DArray, this.ishape2D_1.Length); shape2DArray[this.ishape2D_1.Length] = lining; this.ishape2D_1 = shape2DArray; } }
/// <summary> /// Calculates the area overlap between two shapes by throwing random darts within the bounds of the /// first shape and counting the darts that lie within both shapes vs total darts thrown. /// </summary> /// <param name="shape1">the first shape</param> /// <param name="shape2">the second shape</param> /// <param name="numOfSamples">the number of darts to throw. The more darts the more accurate the simulation.</param> /// <returns></returns> public static double FindOverlappingArea(IShape2D shape1, IShape2D shape2, long numOfSamples) { long overlap = 0; Parallel.For(0, numOfSamples, i => { Vector2 dart = GenerateDartInShapeBounds(shape1); if (shape1.ContainsPoint(dart) && shape2.ContainsPoint(dart)) { Interlocked.Increment(ref overlap); } }); double boundedArea = (shape1.MaxX - shape1.MinX) * (shape1.MaxY - shape1.MinY); return((double)overlap / numOfSamples * boundedArea); }
public void DrawPath( IShape2D shape, Matrix4D transform, WW.Cad.Model.Color color, short lineWeight, bool filled, bool forText, double extrusion) { Matrix transform1 = this.graphics_0.Transform; using (Matrix matrix = new Matrix((float)transform.M00, (float)transform.M10, (float)transform.M01, (float)transform.M11, (float)transform.M03, (float)transform.M13)) { this.graphics_0.Transform = matrix; using (GraphicsPath graphicsPath = ShapeTool.ToGraphicsPath(shape)) this.graphics_0.DrawPath(this.pen_0, graphicsPath); } this.graphics_0.Transform = transform1; }
public Class865( string text, Interface14 font, Color color, short lineWeight, IShape2D path, Matrix2D charTransform, Matrix2D canonicalizeTransform, Vector2D advance) { this.string_0 = text; this.interface14_0 = font; this.color_0 = color; this.short_0 = lineWeight; this.ishape2D_0 = path; this.matrix2D_0 = charTransform; this.matrix2D_1 = canonicalizeTransform; this.vector2D_0 = advance; this.matrix2D_2 = charTransform * canonicalizeTransform; }
public override bool IsContained(IShape2D shape) { return shape.Contains(WorldDisk); }
public abstract bool Contains(IShape2D shape);
public abstract bool IsContained(IShape2D shape);
public abstract bool Overlaps(IShape2D shape);
public override bool Overlaps(IShape2D shape) { return shape.Overlaps(WorldRect); }
public override bool Contains(IShape2D shape) { return shape.IsContained(WorldRect); }
public override bool Overlaps(IShape2D shape) { return shape.Overlaps(WorldCircle); }