public void TestPhysicsCircleColliderCreate() { var geometry = new CircleGeometry { Center = new float2(-10.10f, 10.12f), Radius = 3.0f }; const uint UserData = 0xDEADBEEF; using (var colliderBlob = PhysicsCircleCollider.Create(geometry, CollisionFilter.Default, PhysicsMaterial.Default, UserData)) { ref var collider = ref colliderBlob.GetColliderRef <PhysicsCircleCollider>(); Assert.AreEqual(ColliderType.Circle, collider.ColliderType); Assert.AreEqual(CollisionType.Convex, collider.CollisionType); Assert.AreEqual(UserData, collider.UserData); Assert.AreEqual(CollisionFilter.Default, collider.Filter); Assert.AreEqual(PhysicsMaterial.Default, collider.Material); Assert.AreEqual(geometry.Center, collider.Center); Assert.AreEqual(geometry.Center, collider.Geometry.Center); Assert.AreEqual(geometry.Radius, collider.Radius); Assert.AreEqual(geometry.Radius, collider.Geometry.Radius); }
/// <summary> /// Checks whether the current data is enough to construct a circle. /// If so, draws it (erasing any previously drawn circle). /// </summary> void OnChange() { // Try to construct a circle based on what's been entered Circle c = GetCurrentCircle(); if (c == null) { // If we didn't get anything, but we previously had a circle, ensure // it gets erased. if (m_Circle != null) { m_Circle = null; ErasePainting(); } } else { // Just return if current circle matches what we've already got if (m_Circle != null && CircleGeometry.IsCoincident(m_Circle, c, Constants.XYRES)) { return; } // Draw the new circle m_Circle = c; ErasePainting(); } }
private void A_DrawEraseEvent(ActionEventArgs gs) { CircleGeometry line = this.action.Geometry as CircleGeometry; sublineGeometry.Start = line.Start; sublineGeometry.End = line.End; sublineGeometry.Update(); this.Tip.SetText(sublineGeometry.TextValue, sublineGeometry.TextPosition, sublineGeometry.TextAngle); }
/// <summary> /// Draws a circular arc /// </summary> /// <param name="display">The display to draw to</param> /// <param name="arc">The circular arc</param> public void Render(ISpatialDisplay display, IClockwiseCircularArcGeometry arc) { ICircleGeometry circle = arc.Circle; IWindow extent = CircleGeometry.GetExtent(circle); float topLeftX = display.EastingToDisplay(extent.Min.X); float topLeftY = display.NorthingToDisplay(extent.Max.Y); float size = 2.0f * display.LengthToDisplay(circle.Radius); float startAngle = (float)(arc.StartBearingInRadians * MathConstants.RADTODEG - 90.0); float sweepAngle = (float)(arc.SweepAngleInRadians * MathConstants.RADTODEG); display.Graphics.DrawArc(m_Pen, topLeftX, topLeftY, size, size, startAngle, sweepAngle); }
/// <summary> /// Draws this object on the specified display /// </summary> /// <param name="display">The display to draw to</param> /// <param name="style">The drawing style</param> public override void Render(ISpatialDisplay display, IDrawStyle style) { // If we're dealing with a construction line, it's drawn dotted // regardless of the supplied style. if (Geometry.IsCircle && Creator.EditId == EditingActionId.NewCircle) { CircleGeometry.Render(Geometry.Circle, display, new DottedStyle(style.LineColor)); } else { base.Render(display, style); } }
protected override void Setup() { base.Setup(); m_BoxGeometry = new BoxGeometry { Size = new float2(0.01f, 120.40f), Center = new float2(-10.10f, 10.12f), }; m_CapsuleGeometry = new CapsuleGeometry { Vertex0 = new float2(0f, 3f), Vertex1 = new float2(0f, -2f), Radius = 1.5f }; m_CircleGeometry = new CircleGeometry { Center = new float2(-10.10f, 10.12f), Radius = 3.0f }; m_Vertices = new NativeArray <float2>( new float2[] { new float2(-1f, -2f), new float2(2f, -3f), new float2(4f, 5f), new float2(-6f, 7f) }, Allocator.Persistent ); m_GiftWrappedIndices = new NativeArray <int>( new int[] { 2, 3, 0, 1 }, Allocator.Persistent ); Assert.IsTrue(m_Vertices.Length >= 3, "Test array must contain at least 3 points."); Assert.AreEqual(m_Vertices.Length, m_GiftWrappedIndices.Length, "Test array lengths do not match."); m_PolygonGeometry = new PolygonGeometry { Vertices = m_Vertices, BevelRadius = 0.0f }; }
public unsafe void PhysicsBodyCastColliderTest() { var geometry = new BoxGeometry { Size = new float2(1f), }; using (var collider = PhysicsBoxCollider.Create(geometry)) { var physicsBody = new PhysicsBody(collider); var queryInput = new ColliderCastInput() { Rotation = float2x2.identity }; var closestHit = new ColliderCastHit(); var allHits = new NativeList <ColliderCastHit>(Allocator.Temp); var circleGeometry = new CircleGeometry { Radius = 0.5f }; using (var circleBlob = PhysicsCircleCollider.Create(circleGeometry)) { queryInput.Collider = circleBlob; // OK case. var startOK = new float2(-10f, -10f); var endOK = new float2(10f, 10f); queryInput.Start = startOK; queryInput.End = endOK; Assert.IsTrue(physicsBody.CastCollider(queryInput)); Assert.IsTrue(physicsBody.CastCollider(queryInput, out closestHit)); Assert.IsTrue(physicsBody.CastCollider(queryInput, ref allHits)); // Fail Case. var startFail = new float2(-10f, -10f); var endFail = new float2(10f, -10f); queryInput.Start = startFail; queryInput.End = endFail; Assert.IsFalse(physicsBody.CastCollider(queryInput)); Assert.IsFalse(physicsBody.CastCollider(queryInput, out closestHit)); Assert.IsFalse(physicsBody.CastCollider(queryInput, ref allHits)); } allHits.Dispose(); } }
public void Render(ISpatialDisplay display, IDrawStyle style) { if (this.category == CadastralLineCategory.Radial) { style = new DottedStyle(style.LineColor); } if (m_Center == null) { style.Render(display, this.PositionArray); } else { // radius less than zero may represent a counter-clockwise direction bool isClockwise = (this.radius > 0.0); // Define a circular arc that is assumed to run clockwise. ICircleGeometry circle = new CircleGeometry(m_Center.Geometry, Math.Abs(this.radius)); ICircularArcGeometry arc = new CircularArcGeometry(circle, m_From.Geometry, m_To.Geometry, isClockwise); // Assume clockwise, see what it looks like style.Render(display, arc); } /* * else * { * if (!this.arcLengthSpecified) * throw new ApplicationException("Cannot determine arc direction"); * * // Define a circular arc that is assumed to run clockwise. * CircleGeometry circle = new CircleGeometry(m_Center.Geometry, this.radius); * CircularArcGeometry arc = new CircularArcGeometry(circle, m_From.Geometry, m_To.Geometry, true); * * // Assume clockwise, see what it looks like * new DrawStyle(Color.Red).Render(display, arc); * * //double arcLength = arc.Length.Meters; * //double othLength = circle.Length.Meters; * * //// Get the arc length in meters (TODO: need to access file header to determine how to convert lengths) * //if (Math.Abs(othLength - this.arcLength) < Math.Abs(arcLength - this.arcLength)) * // arc.IsClockwise = false; * } */ }
public unsafe void PhysicsBodyOverlapColliderTest() { var geometry = new BoxGeometry { Size = new float2(2f), }; using (var collider = PhysicsBoxCollider.Create(geometry)) { var physicsBody = new PhysicsBody(collider); var queryInput = new OverlapColliderInput() { Filter = CollisionFilter.Default }; var closestHit = new OverlapColliderHit(); var allHits = new NativeList <OverlapColliderHit>(Allocator.Temp); var circleGeometry = new CircleGeometry { Radius = 0.5f }; using (var circleBlob = PhysicsCircleCollider.Create(circleGeometry)) { queryInput.Collider = circleBlob; // OK case. var transformOK = new PhysicsTransform(new float2(1f)); queryInput.Transform = transformOK; Assert.IsTrue(physicsBody.OverlapCollider(queryInput)); Assert.IsTrue(physicsBody.OverlapCollider(queryInput, out closestHit)); Assert.IsTrue(physicsBody.OverlapCollider(queryInput, ref allHits)); // Fail Case. var transformFail = new PhysicsTransform(new float2(-10f)); queryInput.Transform = transformFail; Assert.IsFalse(physicsBody.OverlapCollider(queryInput)); Assert.IsFalse(physicsBody.OverlapCollider(queryInput, out closestHit)); Assert.IsFalse(physicsBody.OverlapCollider(queryInput, ref allHits)); } allHits.Dispose(); } }
public unsafe void PhysicsBodyCalculateDistanceTest() { var geometry = new BoxGeometry { Size = new float2(1f), }; using (var collider = PhysicsBoxCollider.Create(geometry)) { var physicsBody = new PhysicsBody(collider); var circleGeometry = new CircleGeometry { Radius = 1f }; using (var circleBlob = PhysicsCircleCollider.Create(circleGeometry)) { var queryInput = new ColliderDistanceInput { Collider = circleBlob, Transform = new PhysicsTransform(new float2(-10f)) }; var closestHit = new DistanceHit(); var allHits = new NativeList <DistanceHit>(Allocator.Temp); // OK case : with enough max distance queryInput.MaxDistance = 10000.0f; Assert.IsTrue(physicsBody.CalculateDistance(queryInput)); Assert.IsTrue(physicsBody.CalculateDistance(queryInput, out closestHit)); Assert.IsTrue(physicsBody.CalculateDistance(queryInput, ref allHits)); // Fail case : not enough max distance queryInput.MaxDistance = 1f; Assert.IsFalse(physicsBody.CalculateDistance(queryInput)); Assert.IsFalse(physicsBody.CalculateDistance(queryInput, out closestHit)); Assert.IsFalse(physicsBody.CalculateDistance(queryInput, ref allHits)); allHits.Dispose(); } } }
public void PhysicsBodyCalculateAabb_CircleColliderTest() { var geometry = new CircleGeometry { Center = new float2(-10.10f, 10.12f), Radius = 3.0f }; var collider1 = PhysicsCircleCollider.Create(geometry); var collider2 = PhysicsCircleCollider.Create(geometry); var physicsBody = new PhysicsBody(collider1); var aabb = physicsBody.CalculateAabb(); Assert.IsTrue(aabb.Equals(collider2.Value.CalculateAabb())); collider1.Dispose(); collider2.Dispose(); }
protected override void OnUpdate() { Entities.ForEach((UnityEngine.CircleCollider2D collider) => { // Convert the collider if it's valid. if (ConversionUtilities.CanConvertCollider(collider)) { try { var lossyScale = new float3(collider.transform.lossyScale).xy; if (math.any(!math.isfinite(lossyScale)) || math.any(lossyScale <= 0.0f)) { throw new ArgumentException("Transform XY scale cannot be zero or Infinite/NaN.", "Transform XY scale."); } var localToWorld = ConversionUtilities.GetColliderLocalToWorld(collider); var geometry = new CircleGeometry { Center = new float3(localToWorld.MultiplyPoint(collider.offset)).xy, Radius = math.clamp(collider.radius * math.cmax(lossyScale), ConversionUtilities.MinRangeClamp, ConversionUtilities.MaxRangeClamp), }; var colliderBlob = PhysicsCircleCollider.Create( geometry, ConversionUtilities.GetCollisionFilterFromCollider(collider), ConversionUtilities.GetPhysicsMaterialFromCollider(collider) ); // Submit the collider for conversion. m_ColliderConversionSystem.SubmitCollider(collider, ref colliderBlob); } catch (ArgumentException exception) { UnityEngine.Debug.LogWarning($"{collider.name}: {exception.Message}", collider); } } }); }
public static void Generate(MotionCanvas <SkiaSharpDrawingContext> canvas) { var r = new Random(); var p = new SolidColorPaint(SKColors.Blue, 3) { IsFill = true }; canvas.AddDrawableTask(p); for (var i = 0; i < 1000; i++) { var circle = new CircleGeometry { X = r.Next(15, 285), Y = r.Next(15, 285), Width = 5, Height = 5 }; _ = circle .TransitionateProperties( nameof(circle.X), nameof(circle.Y)) .WithAnimation(animation => animation .WithDuration(TimeSpan.FromSeconds(1)) .WithEasingFunction(EasingFunctions.ElasticOut)) .CompleteCurrentTransitions(); //circle.SetPropertiesTransitions( // new Animation(EasingFunctions.ElasticOut, TimeSpan.FromSeconds(1)), // nameof(circle.X), nameof(circle.Y)); //circle.CompleteAllTransitions(); p.AddGeometryToPaintTask(canvas, circle); circle.X = r.Next(15, 285); circle.Y = r.Next(15, 285); } canvas.Invalidate(); }
public void TestPhysicsColliderBlobOwner() { // Create the collider blob. var geometry = new CircleGeometry { Radius = 1f }; var colliderBlob = PhysicsCircleCollider.Create(geometry); // Create the entity that owns the collider blob. var entity = EntityManager.CreateEntity(); EntityManager.AddComponentData(entity, new PhysicsColliderBlob { Collider = colliderBlob }); EntityManager.AddComponentData(entity, new PhysicsColliderBlobOwner { Collider = colliderBlob }); // The collider blob components should be present. Assert.IsTrue(EntityManager.HasComponent <PhysicsColliderBlob>(entity)); Assert.IsTrue(EntityManager.HasComponent <PhysicsColliderBlobOwner>(entity)); // Destroy the entity. EntityManager.DestroyEntity(entity); // The collider blob component should be removed but the blob owner should be present still. Assert.IsFalse(EntityManager.HasComponent <PhysicsColliderBlob>(entity)); Assert.IsTrue(EntityManager.HasComponent <PhysicsColliderBlobOwner>(entity)); // Run the system. MainLoop(); // The collider blob owner should now be removed indicating that the // disposal system has disposed of the blob. // Unfortunately I don't believe there's a way to detect the actual deallocation // as our instance here still assumes the blob ptr is valid. Assert.IsFalse(EntityManager.HasComponent <PhysicsColliderBlobOwner>(entity)); }
/// <summary> /// 解析指定的XML对象 /// </summary> /// <param name="messageXML"></param> private void ParseXML(XmlReader xmlReader) { Geometry2D shape = null; switch (xmlReader.Name) { case "ArcGeometry": shape = new ArcGeometry(); break; case "BeamGeometry": shape = new BeamGeometry(); break; case "CircleGeometry": shape = new CircleGeometry(); break; case "CSectionGeometry": shape = new CSectionGeometry(); break; case "EllipseGeometry": shape = new EllipseGeometry(); break; case "FloorGeometry": shape = new FloorGeometry(); break; case "LineGeometry": shape = new LineGeometry(); break; case "MeasureGeometry": shape = new MeasureGeometry(); break; case "MemberGeometry": shape = new MemberGeometry(); break; case "OSBGeometry": shape = new OSBGeometry(); break; case "PointGeometry": shape = new PointGeometry(); break; case "PolygonGeometry": shape = new PolygonGeometry(); break; case "PolylineGeometry": shape = new PolylineGeometry(); break; case "RectangleGeometry": shape = new RectangleGeometry(); break; case "SteelBeamGeometry": shape = new SteelBeamGeometry(); break; case "TextGeometry": shape = new TextGeometry(); break; case "WallGeometry": shape = new WallGeometry(); break; } if (shape != null) { //将信息写入数据流中 shape.ReadXML(xmlReader); //将图形添加都界面上 this.drawingKernel.AddShape(shape); } }
private ArcFeature ImportArc(Ntx.Line line, Operation creator, ILength tol) { Debug.Assert(line.IsCurve); IEntity what = GetEntityType(line, SpatialType.Line); // Get positions defining the arc PointGeometry[] pts = GetPositions(line); // Ignore zero-length lines if (HasZeroLength(pts)) { return(null); } // Add a point at the center of the circle Ntx.Position pos = line.Center; PointGeometry pc = new PointGeometry(pos.Easting, pos.Northing); PointFeature center = EnsurePointExists(pc, tol, creator); // Calculate exact positions for the arc endpoints double radius = line.Radius; ICircleGeometry cg = new CircleGeometry(pc, radius); IPosition bc = CircleGeometry.GetClosestPosition(cg, pts[0]); IPosition ec = CircleGeometry.GetClosestPosition(cg, pts[pts.Length - 1]); // Round off to nearest micron PointGeometry bcg = PointGeometry.Create(bc); PointGeometry ecg = PointGeometry.Create(ec); // Ensure point features exist at both ends of the line. PointFeature ps = GetArcEndPoint(bcg, tol, creator); PointFeature pe = GetArcEndPoint(ecg, tol, creator); // Try to find a circle that's already been added by this import. Circle c = EnsureCircleExists(center, radius, tol, creator); // Determine which way the arc is directed bool iscw = LineStringGeometry.IsClockwise(pts, center); InternalIdValue id = CadastralMapModel.Current.WorkingSession.AllocateNextId(); ArcFeature arc = new ArcFeature(creator, id, what, c, ps, pe, iscw); // The toological status of the incoming arc may override the status that the // constructor derived from the entity type arc.SetTopology(line.IsTopologicalArc); #if DEBUG // Confirm the NTX data was valid (ensure it's consistent with what we've imported)... double readRad = c.Radius; double calcRad = BasicGeom.Distance(c.Center, ps); Debug.Assert(Math.Abs(readRad - calcRad) < tol.Meters); foreach (IPointGeometry pg in pts) { ILength check = arc.Geometry.Distance(pg); Debug.Assert(check.Meters < tol.Meters); } #endif return(arc); }
/// <summary> /// Obtains the geometry for spans along this leg. /// </summary> /// <param name="bc">The position for the start of the leg. /// <param name="bcBearing">The bearing on entry into the leg.</param> /// <param name="sfac">Scale factor to apply to distances.</param> /// <param name="spans">Information for the spans coinciding with this leg.</param> /// <returns>The sections along this leg</returns> internal override ILineGeometry[] GetSpanSections(IPosition bc, double bcBearing, double sfac, SpanInfo[] spans) { // Can't do anything if the leg radius isn't defined if (m_Metrics.ObservedRadius == null) { throw new InvalidOperationException("Cannot create sections for circular leg with undefined radius"); } var result = new ILineGeometry[spans.Length]; // Use supplied stuff to derive info on the center and EC. IPosition center; IPosition ec; double bearingToBC; double ecBearing; GetPositions(bc, bcBearing, sfac, out center, out bearingToBC, out ec, out ecBearing); // Define the underlying circle ICircleGeometry circle = new CircleGeometry(PointGeometry.Create(center), BasicGeom.Distance(center, bc)); // Handle case where the leg is a cul-de-sac with no observed spans if (spans.Length == 1 && spans[0].ObservedDistance == null) { result[0] = new CircularArcGeometry(circle, bc, ec, m_Metrics.IsClockwise); return(result); } /// Initialize scaling factor for distances in cul-de-sacs (ratio of the length calculated from /// the CA & Radius, versus the observed distances that were actually specified). For curves that /// are not cul-de-sacs, this will be 1.0 double culFactor = 1.0; if (m_Metrics.IsCulDeSac) { double obsv = PrimaryFace.GetTotal(); if (obsv > MathConstants.TINY) { culFactor = Length.Meters / obsv; } } IPosition sPos = bc; IPosition ePos = null; bool isClockwise = m_Metrics.IsClockwise; double radius = RadiusInMeters; double edist = 0.0; for (int i = 0; i < result.Length; i++, sPos = ePos) { // Add on the unscaled distance edist += spans[i].ObservedDistance.Meters; // Get the angle subtended at the center of the circle. We use // unscaled values here, since the scale factors would cancel out. // However, we DO apply any cul-de-sac scaling factor, to account // for the fact that the distance may be inconsistent with the // curve length derived from the CA and radius. For example, it // is possible that the calculated curve length=200, although the // total of the observed spans is somehow only 100. In that case, // if the supplied distance is 50, we actually want to use a // value of 50 * (200/100) = 100. double angle = (edist * culFactor) / radius; // Get the bearing of the point with respect to the center of the circle. double bearing; if (isClockwise) { bearing = bearingToBC + angle; } else { bearing = bearingToBC - angle; } // Calculate the position using the scaled radius. ePos = Geom.Polar(center, bearing, radius * sfac); result[i] = new CircularArcGeometry(circle, sPos, ePos, isClockwise); } return(result); }
// Circle internal uint Intersect(IPointGeometry center, double radius) { ICircleGeometry circle = new CircleGeometry(center, radius); return(m_IntersectedObject.LineGeometry.IntersectCircle(this, circle)); }
private void listView1_Click(object sender, EventArgs e) { if (listView1.SelectedItems.Count > 0) { string areaName = listView1.SelectedItems[0].Text; SelectedIndex = listView1.SelectedItems[0].Index; SelectedItem = task.Items[SelectedIndex]; //Отрисовка превьюшки детали Document Doc = TFlex.Application.ActiveDocument; SelectedArea = Doc.GetObjectByName(areaName) as Area; TFlex.Drawing.Rectangle bound = SelectedArea.BoundRect; double Scale = 159 / Math.Max(bound.Width, bound.Height); Bitmap img = new Bitmap(160, 160); Graphics graph = Graphics.FromImage(img); Pen pen = new Pen(Brushes.White); graph.DrawRectangle(pen, new Rectangle(0, 0, 159, 159)); pen = new Pen(Brushes.Black); pen.Width = 1; for (int cc = 0; cc < SelectedArea.ContourCount; cc++) { Contour cont = SelectedArea.GetContour(cc); foreach (var segm in cont) { switch (segm.GeometryType) { case ObjectGeometryType.Line: LineGeometry line = segm.Geometry as LineGeometry; if (line != null) { graph.DrawLine(pen, (float)((line.X1 - bound.Left) * Scale), (float)((bound.Top - line.Y1) * Scale), (float)((line.X2 - bound.Left) * Scale), (float)((bound.Top - line.Y2) * Scale)); } break; case ObjectGeometryType.Circle: CircleGeometry circle = segm.Geometry as CircleGeometry; if (circle == null) { break; } double radius = (circle.Radius * Scale); int xc = (int)((circle.CenterX - bound.Left) * Scale); int yc = (int)((bound.Top - circle.CenterY) * Scale); graph.DrawEllipse(pen, new Rectangle((int)(xc - radius), (int)(yc - radius), (int)radius * 2, (int)radius * 2)); break; case ObjectGeometryType.CircleArc: CircleArcGeometry cgeom = segm.Geometry as CircleArcGeometry; if (cgeom == null) { break; } int xc1 = (int)((cgeom.CenterX - bound.Left) * Scale); int yc1 = (int)((bound.Top - cgeom.CenterY) * Scale); radius = (cgeom.Radius * Scale); var angles = NFUtils.GetArcAngle(cgeom); double ang = angles.Item1 * 180 / Math.PI; double ang1 = angles.Item2 * 180 / Math.PI - 90; graph.DrawArc(pen, (float)(xc1 - radius), (float)(yc1 - radius), (float)(radius * 2), (float)(radius * 2), (float)ang1, (float)ang); break; default: PolylineGeometry geom = segm.Geometry as PolylineGeometry; if (geom == null) { break; } for (int i = 1; i < geom.Count; i++) { int x1 = (int)((geom.GetX(i) - bound.Left) * Scale); int y1 = (int)((bound.Top - geom.GetY(i)) * Scale); int x2 = (int)((geom.GetX(i - 1) - bound.Left) * Scale); int y2 = (int)((bound.Top - geom.GetY(i - 1)) * Scale); graph.DrawLine(pen, (float)x1, (float)y1, (float)x2, (float)y2); } break; } } } pictureBox1.Image = img; //Задание параметров форме label10.Text = $"Размеры детали = {(int) bound.Width} x {(int) bound.Height}"; label9.Text = $"Количество контуров: {SelectedArea.ContourCount}"; selectComboNum(ref comboBox2, SelectedItem.Rotation); selectComboNum(ref comboBox1, SelectedItem.Reflection); selectComboNum(ref comboBox1, SelectedItem.Reflection); textBox4.Text = SelectedItem.Count.ToString(); } }
public static NFTask GetGeometry() { Msg("[Nesting Factory] Starting collect geometry..."); ICollection <Area> Areas = Doc.GetAreas(); NFTask task = new NFTask(); foreach (var area in Areas) { Rectangle BoundBox = area.BoundRect; double boundX = BoundBox.Left; double boundY = BoundBox.Top; NFItem item = new NFItem(area.ObjectId.ToString()); for (int num_contour = 0; num_contour < area.ContourCount; num_contour++) { Contour contour = area.GetContour(num_contour); NFContour cont = new NFContour(); foreach (var csegment in contour) { switch (csegment.GeometryType) { case ObjectGeometryType.Line: LineGeometry linegeom = csegment.Geometry as LineGeometry; cont.AddPoint(new NFPoint(linegeom.X1 - boundX, boundY - linegeom.Y1, 0)); cont.AddPoint(new NFPoint(linegeom.X2 - boundX, boundY - linegeom.Y2, 0)); break; case ObjectGeometryType.CircleArc: CircleArcGeometry cgeom = csegment.Geometry as CircleArcGeometry; cArcToDoubles(cgeom, ref cont, BoundBox, csegment.IsCounterclockwise); break; case ObjectGeometryType.Circle: CircleGeometry cirgeom = csegment.Geometry as CircleGeometry; cont.AddPoint(new NFPoint(cirgeom.CenterX + cirgeom.Radius - boundX, boundY - cirgeom.CenterY, 1)); cont.AddPoint(new NFPoint(cirgeom.CenterX - cirgeom.Radius - boundX, boundY - cirgeom.CenterY, 1)); break; default: PolylineGeometry polygeom = csegment.Geometry as PolylineGeometry; int v_count = polygeom.Count; for (int i = 0; i < v_count; i++) { if (v_count < 50 || i % (csegment.GeometryType == ObjectGeometryType.Ellipse ? 5 : 1) == 0 || i == v_count) { cont.AddPoint(new NFPoint(polygeom.GetX(i) - boundX, boundY - polygeom.GetY(i), 0)); } } break; } } item.AddContour(cont); } task.AddItem(item); } Msg("[Nesting Factory] Geometry collected"); return(task); }
/// <summary> /// Creates the geometry that can be used to detect intersections with the map. /// </summary> /// <returns>The geometry for the new line (null if insufficient information has been specified)</returns> ArcGeometry CreateIntersectGeometry() { if (m_Circles == null) { return(null); } PointFeature start = StartPoint; if (start == null) { return(null); } IPointGeometry end = LastMousePosition; if (end == null) { return(null); } ITerminal endTerm = new FloatingTerminal(end); // Find the circle that is closest to the end (only looking at the valid circles // that are within a 1mm tolerance). Return null geometry if none of the circles // are within reach. Circle bestCircle = m_Circles[0]; double bestdist = bestCircle.Distance(end).Meters; if (m_Circles.Count > 1) { // See if there is any better choice for (int i = 1; i < m_Circles.Count; i++) { Circle c = m_Circles[i]; double dist = c.Distance(end).Meters; if (dist < bestdist) { bestCircle = c; bestdist = dist; } } } // Ignore if the best circle is too far away double tol = CircleTolerance.Meters; if (bestdist > tol) { return(null); } // Project the end point ON to the circle. //IPointGeometry center = bestCircle.Center; //Turn eturn = new Turn(center, end); //IAngle bearing = eturn.Bearing; //IPosition cirend = Geom.Polar(center, bearing.Radians, bestCircle.Radius.Meters); IPosition cirend = CircleGeometry.GetClosestPosition(bestCircle, end); // Get the clockwise angle from the start to the current end point. IPointGeometry center = bestCircle.Center; Turn sturn = new Turn(center, start); double angle = sturn.GetAngleInRadians(cirend); // Figure out which direction the curve should go, depending // on whether the user wants the short arc or the long one. bool iscw = (angle < MathConstants.PI ? m_IsShortArc : !m_IsShortArc); // Create the required geometry ITerminal ec = new FloatingTerminal(cirend); return(new ArcGeometry(bestCircle, start, ec, iscw)); }
public static NFTask GetGeometry() { Msg("[Nesting Factory] Starting collect geometry..."); ICollection <Area> EO = Doc.GetAreas(); IEnumerator <Area> GeomEnum = EO.GetEnumerator(); GeomEnum.MoveNext(); NFTask task = new NFTask(); for (int area_num = 0; area_num < EO.Count; area_num++) { Area area = GeomEnum.Current; GeomEnum.MoveNext(); Rectangle BoundBox = area.BoundRect; double bound_x = BoundBox.Left; double bound_y = BoundBox.Top; NFItem item = new NFItem(area.ObjectId.ToString()); for (int num_contour = 0; num_contour < area.ContourCount; num_contour++) { Contour contour = area.GetContour(num_contour); NFContour cont = new NFContour(); for (int num_segment = 0; num_segment < contour.SegmentCount; num_segment++) { ContourSegment csegment = contour.GetSegment(num_segment); switch (csegment.GeometryType) { case ObjectGeometryType.Line: LineGeometry linegeom = csegment.Geometry as LineGeometry; cont.AddPoint(new NFPoint(linegeom.X1 - bound_x, bound_y - linegeom.Y1, 0)); cont.AddPoint(new NFPoint(linegeom.X2 - bound_x, bound_y - linegeom.Y2, 0)); break; /*case ObjectGeometryType.Polyline: * * PolylineGeometry polygeom = csegment.Geometry as PolylineGeometry; * CircleArcGeometry[] cArcs = polygeom.GetCircleArcApproximation(2); * * for (int i = 0; i < cArcs.GetLength(0); i++) * { * cArcToDoubles(cArcs[i], ref cont, BoundBox); * } * break;*/ case ObjectGeometryType.CircleArc: CircleArcGeometry cgeom = csegment.Geometry as CircleArcGeometry; cArcToDoubles(cgeom, ref cont, BoundBox, csegment.IsCounterclockwise); break; case ObjectGeometryType.Circle: CircleGeometry cirgeom = csegment.Geometry as CircleGeometry; cont.AddPoint(new NFPoint(cirgeom.CenterX + cirgeom.Radius - bound_x, bound_y - cirgeom.CenterY, 1)); cont.AddPoint(new NFPoint(cirgeom.CenterX - cirgeom.Radius - bound_x, bound_y - cirgeom.CenterY, 1)); break; default: PolylineGeometry polygeom = csegment.Geometry as PolylineGeometry; int v_count = polygeom.Count; for (int i = 0; i < v_count; i++) { if (v_count < 50 || i % (csegment.GeometryType == ObjectGeometryType.Ellipse ? 5 : 1) == 0 || i == v_count) { cont.AddPoint(new NFPoint(polygeom.GetX(i) - bound_x, bound_y - polygeom.GetY(i), 0)); } } break; } } item.AddContour(cont); } task.AddItem(item); } Msg("[Nesting Factory] Geometry collected"); return(task); }
private void listView1_Click(object sender, EventArgs e) { if (listView1.SelectedItems != null && listView1.SelectedItems.Count > 0) { string areaName = listView1.SelectedItems[0].Text; num = listView1.SelectedItems[0].Index; Item = task.GetItem(num); //Отрисовка превьюшки детали Document Doc = TFlex.Application.ActiveDocument; select = Doc.GetObjectByName(areaName) as Area; TFlex.Drawing.Rectangle bound = select.BoundRect; double Scale = 159 / Math.Max(bound.Width, bound.Height); Bitmap img = new Bitmap(160, 160); Graphics graph = Graphics.FromImage(img); Pen pen = new Pen(Brushes.White); graph.DrawRectangle(pen, new Rectangle(0, 0, 159, 159)); pen = new Pen(Brushes.Black); pen.Width = 1; for (int cc = 0; cc < select.ContourCount; cc++) { Contour cont = select.GetContour(cc); for (int sc = 0; sc < cont.SegmentCount; sc++) { ContourSegment segm = cont.GetSegment(sc); switch (segm.GeometryType) { case ObjectGeometryType.Line: LineGeometry line = segm.Geometry as LineGeometry; graph.DrawLine(pen, (float)((line.X1 - bound.Left) * Scale), (float)((bound.Top - line.Y1) * Scale), (float)((line.X2 - bound.Left) * Scale), (float)((bound.Top - line.Y2) * Scale)); break; case ObjectGeometryType.Circle: CircleGeometry circle = segm.Geometry as CircleGeometry; double radius = (circle.Radius * Scale); int xc = (int)((circle.CenterX - bound.Left) * Scale); int yc = (int)((bound.Top - circle.CenterY) * Scale); graph.DrawEllipse(pen, new Rectangle((int)(xc - radius), (int)(yc - radius), (int)radius * 2, (int)radius * 2)); break; case ObjectGeometryType.CircleArc: CircleArcGeometry cgeom = segm.Geometry as CircleArcGeometry; int xc1 = (int)((cgeom.CenterX - bound.Left) * Scale); int yc1 = (int)((bound.Top - cgeom.CenterY) * Scale); radius = (cgeom.Radius * Scale); double[] angles = NFGetGeom.getArcAngle(cgeom, segm.IsCounterclockwise); double ang = angles[0] * 180 / Math.PI; double ang1 = angles[1] * 180 / Math.PI - 90; graph.DrawArc(pen, (float)(xc1 - radius), (float)(yc1 - radius), (float)(radius * 2), (float)(radius * 2), (float)ang1, (float)ang); break; default: PolylineGeometry geom = segm.Geometry as PolylineGeometry; if (geom != null) { for (int i = 1; i < geom.Count; i++) { int x1 = (int)((geom.GetX(i) - bound.Left) * Scale); int y1 = (int)((bound.Top - geom.GetY(i)) * Scale); int x2 = (int)((geom.GetX(i - 1) - bound.Left) * Scale); int y2 = (int)((bound.Top - geom.GetY(i - 1)) * Scale); graph.DrawLine(pen, (float)x1, (float)y1, (float)x2, (float)y2); } } break; } } } pictureBox1.Image = img; //Задание параметров форме label10.Text = "Размер квадрата детали = " + (int)(159 / Scale); label9.Text = "Количество контуров: " + select.ContourCount; selectComboNum(ref comboBox2, Item.Rotation); selectComboNum(ref comboBox1, Item.Reflection); selectComboNum(ref comboBox1, Item.Reflection); textBox4.Text = Item.Count.ToString(); } }
/// <summary> /// Calculates intersection points. /// </summary> /// <param name="dist1">1st distance observation.</param> /// <param name="from1">The point the 1st distance was observed from.</param> /// <param name="dist2">2nd distance observation.</param> /// <param name="from2">The point the 2nd distance was observed from.</param> /// <param name="usedefault">True if the default intersection is required (the one that has the /// lowest bearing with respect to the 2 from points). False for the other one (if any).</param> /// <param name="xsect">The position of the intersection (if any).</param> /// <param name="xsect1">The 1st choice intersection (if any).</param> /// <param name="xsect2">The 2nd choice intersection (if any).</param> /// <returns>True if intersections were calculated. False if the distance circles /// don't intersect.</returns> internal static bool Calculate(Observation dist1, PointFeature from1, Observation dist2, PointFeature from2, bool usedefault, out IPosition xsect, out IPosition xsect1, out IPosition xsect2) { // Initialize intersection positions. xsect = xsect1 = xsect2 = null; // Get the 2 distances. double d1 = dist1.GetDistance(from1).Meters; double d2 = dist2.GetDistance(from2).Meters; if (d1 < Constants.TINY || d2 < Constants.TINY) { return(false); } // Form circles with radii that match the observed distances. ICircleGeometry circle1 = new CircleGeometry(from1, d1); ICircleGeometry circle2 = new CircleGeometry(from2, d2); // See if there is actually an intersection between the two circles. IPosition x1, x2; uint nx = IntersectionHelper.Intersect(circle1, circle2, out x1, out x2); if (nx == 0) { return(false); } // If we have 2 intersections, and we need the non-default one, pick up the 2nd // intersection. If only 1 intersection, use that, regardless of the setting for // the "use default" flag. if (nx == 2 && !usedefault) { xsect = x2; } else { xsect = x1; } // Return if both distances are offset points. OffsetPoint offset1 = (dist1 as OffsetPoint); OffsetPoint offset2 = (dist2 as OffsetPoint); if (offset1 != null && offset2 != null) { xsect1 = x1; xsect2 = x2; return(true); } // Reduce observed distances to the mapping plane. ISpatialSystem sys = CadastralMapModel.Current.SpatialSystem; if (offset1 == null) { d1 = d1 * sys.GetLineScaleFactor(from1, xsect); } if (offset2 == null) { d2 = d2 * sys.GetLineScaleFactor(from2, xsect); } // And calculate the exact intersection (like above)... // Form circles with radii that match the observed distances. ICircleGeometry circle1p = new CircleGeometry(from1, d1); ICircleGeometry circle2p = new CircleGeometry(from2, d2); // See if there is still an intersection between the two circles. nx = IntersectionHelper.Intersect(circle1p, circle2p, out x1, out x2); if (nx == 0) { return(false); } // If we have 2 intersections, and we need the non-default one, pick up the 2nd // intersection. If only 1 intersection, use that, regardless of the setting for // the "use default" flag. if (nx == 2 && !usedefault) { xsect = x2; } else { xsect = x1; } xsect1 = x1; xsect2 = x2; return(true); }
// Use this for initialization void Start() { geo = new CircleGeometry(5, 32, 0, Mathf.PI * 2); meshFilter.mesh = geo.CreateAndGetMesh(); }
/// <summary> /// Calculates the intersection point. /// </summary> /// <param name="dir">Direction observation.</param> /// <param name="distance">Distance observation.</param> /// <param name="from">The point the distance was observed from.</param> /// <param name="usedefault">True if the default intersection is required (the one /// closer to the origin of the direction line). False for the other one (if any).</param> /// <param name="xsect">The position of the intersection (if any).</param> /// <param name="xsect1">The 1st choice intersection (if any).</param> /// <param name="xsect2">The 2nd choice intersection (if any).</param> /// <returns>True if intersections were calculated. False if the distance circles /// don't intersect.</returns> internal static bool Calculate(Direction dir, Observation distance, PointFeature from, bool usedefault, out IPosition xsect, out IPosition xsect1, out IPosition xsect2) { // Initialize intersection positions. xsect = xsect1 = xsect2 = null; // Get the distance. double dist = distance.GetDistance(from).Meters; if (dist < Constants.TINY) { return(false); } // Form circle with a radius that matches the observed distance. ICircleGeometry circle = new CircleGeometry(from, dist); // See if there is actually an intersection between the direction & the circle. IPosition x1, x2; uint nx = dir.Intersect(circle, out x1, out x2); if (nx == 0) { return(false); } // If we have 2 intersections, and we need the non-default one, pick up the 2nd // intersection. If only 1 intersection, use that, regardless of the setting for // the "use default" flag. if (nx == 2 && !usedefault) { xsect = x2; } else { xsect = x1; } // Return if the distance is an offset point. OffsetPoint offset = (distance as OffsetPoint); if (offset != null) { xsect1 = x1; xsect2 = x2; return(true); } // Reduce observed distance to the mapping plane. ISpatialSystem sys = CadastralMapModel.Current.SpatialSystem; dist = dist * sys.GetLineScaleFactor(from, xsect); // And calculate the exact intersection (like above)... // Form circle with a radius that matches the reduced distance. ICircleGeometry circlep = new CircleGeometry(from, dist); // See if there is actually an intersection between the direction & the circle. nx = dir.Intersect(circlep, out x1, out x2); if (nx == 0) { return(false); } // If we have 2 intersections, and we need the non-default one, pick up the 2nd // intersection. If only 1 intersection, use that, regardless of the setting for // the "use default" flag. if (nx == 2 && !usedefault) { xsect = x2; } else { xsect = x1; } xsect1 = x1; xsect2 = x2; return(true); }
/// <summary> /// Draws this object on the specified display /// </summary> /// <param name="display">The display to draw to</param> /// <param name="style">The drawing style</param> public void Render(ISpatialDisplay display, IDrawStyle style) { CircleGeometry.Render(this, display, style); }
/// <summary> /// Calculates the distance from the perimeter of this circle to the specified position. /// </summary> /// <param name="point"></param> /// <returns></returns> public ILength Distance(IPosition point) { return(CircleGeometry.Distance(this, point)); }