//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Catch special circle events and disallow them. </summary> /// <remarks> /// In the book it says to add a circle event if it isn't already in the queue. That seems a bit /// wasteful to me - search the whole queue every time you add a circle event? There has to be a /// better way. This routine is the alternative. Just a few checks on the circle parameters /// ensures that they'll only enter the queue once. Much better than a searh of the queue. It's essentially /// an extension of the counter clockwise generic routine which deals with collinear points as though /// they were points on an infinitely large circle. /// </remarks> /// <param name="pt1"> First point for proposed circle event. </param> /// <param name="pt2"> Second point for proposed circle event. </param> /// <param name="pt3"> Third point for proposed circle event. </param> /// <returns> Acceptable if less than or equal to zero, else rejected. </returns> //////////////////////////////////////////////////////////////////////////////////////////////////// // ReSharper disable once InconsistentNaming internal static int ICcwVoronoi(Vector pt1, Vector pt2, Vector pt3) { // Do the geometry to see if they're clockwise var iSign = Geometry2D.ICcw(pt1, pt2, pt3); // If they're not collilnear if (iSign != 0) { // Return their orientation return(iSign); } // RQS- Treat the Collinear points as though they are on an infinite circle var dx1 = pt2.X - pt1.X; var dx2 = pt3.X - pt1.X; var dy1 = pt2.Y - pt1.Y; var dy2 = pt3.Y - pt1.Y; if (dx1 * dx2 < 0 || dy1 * dy2 < 0) { return(-1); } if (dx1 * dx1 + dy1 * dy1 < dx2 * dx2 + dy2 * dy2) { return(+1); } // -RQS return(0); }
/// <summary> /// 设置当前起点位置 /// </summary> /// <param name="p"></param> public void SetPoint(Vector2D p) { if (GeometryShape == null) { this.start = p; this.end = p; this.Geometry2ds = new List <Geometry2D>(); for (int i = 0; i < number; i++) { Geometry2D gs = this.tagert.Copy(); this.Geometry2ds.Add(gs); } if (DrawStartEvent != null) { this.Geometry2ds.ForEach(x => { this.GeometryShape = x; this.GeometryShape.IsActioning = true; DrawStartEvent(new ActionEventArgs(x)); }); } } else { this.end = p; //完成当前的移动 this.Complete(); } }
private static bool TestFor_AABB(TrackedObjectData item, Vector2 min, Vector2 max) { var itemMin = item.AABB.Min; var itemMax = item.AABB.Max; return(Geometry2D.IsOverlapping(itemMin, itemMax, min, max)); }
/// <summary> /// <para>Returns a random point that is inside the unit circle.</para> /// <para>Lenght: 0 (inclusive) - 1 (exclusive), Rotation: 0 (inclusive) - 360 (exclusive)</para> /// </summary> /// <remarks> Unit Circle: A circle whose center is on the origin, with a radius of 1. </remarks> public Vector2 InUnitCircle() { var rndLength = Mathf.Sqrt(_parent.Float.Next01()); var rndAngle = _parent.Angle.NextInRadians(); return(Geometry2D.PolarToCartesian(rndLength, rndAngle)); }
/// <summary> /// 在界面上添加一个 /// </summary> /// <param name="v"></param> public void AddDrawingVisual(Geometry2D g) { DrawingVisuals.Add(g); this.AddVisual(g); g.Update(); IsUpdated = true; }
static public double OffsetInSpace(Tiler.Settings settings, double p = 0, double q = 0, double r = 1) { return (p * Geometry2D.GetTrianglePSide(settings.P, settings.Q) + q * Geometry2D.GetTriangleQSide(settings.P, settings.Q) + r * Geometry2D.GetTriangleHypotenuse(settings.P, settings.Q)); }
/// <summary> /// 移除一个临时可见对象 /// </summary> /// <param name="e"></param> public void RemoveTemporaryVisual(Geometry2D g) { TemporaryVisuals.Remove(g); this.RemoveVisual(g); g.Update(); IsUpdated = true; }
/// <summary> /// 添加临时可见对象 /// </summary> /// <param name="e"></param> public void AddTemporaryVisual(Geometry2D g) { TemporaryVisuals.Add(g); this.AddVisual(g); g.Update(); IsUpdated = true; }
/// <summary> /// 移除一个参照对象 /// </summary> /// <param name="e"></param> public void RemoveAuxiliaryVisual(Geometry2D g) { AuxiliaryVisuals.Remove(g); this.RemoveVisual(g); g.Update(); IsUpdated = true; }
/// <summary> /// 删除界面上一个图形元素 /// </summary> /// <param name="gs"></param> public void RemoveGeometryShape(Geometry2D gs) { if (gs != null) { this.DrawingControl.RemoveDrawingVisual(gs); } }
/// <summary> /// 指定当前的目标图形 /// </summary> /// <param name="shape"></param> public void SetIntersectGeometry(IntersectGeometry shape) { if (shape.GeometryShape != null && shape.IntersectPoint.Line != null) { if (this.tagert == null) { if (this.Filter != null) { //判断是不是过滤的对象 if (this.Filter.AllowElement(shape.GeometryShape)) { this.tagert = shape.GeometryShape; this.targetLine = shape.IntersectPoint.Line; TipMessage = "请选择参照边"; } } } else { this.referShape = shape.GeometryShape; this.referLine = shape.IntersectPoint.Line; this.Complete(); } } }
//calculates the normal of the two given points public double Normal(TPoint2D p1, TPoint2D p2, bool leftNormal) { var vec = Vector2d.Subtract(p2.AsVector(), p1.AsVector()); var normal = leftNormal ? vec.PerpendicularLeft : vec.PerpendicularRight; return(ConvertToHullAngle(Geometry2D.Angle(normal))); }
/// <summary> /// 添加一个参照对象 /// </summary> /// <param name="e"></param> public void AddAuxiliaryVisual(Geometry2D g) { AuxiliaryVisuals.Add(g); this.AddVisual(g); g.Update(); IsUpdated = true; }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Order the three edges around this vertex. </summary> /// <remarks> Darrellp, 2/19/2011. </remarks> //////////////////////////////////////////////////////////////////////////////////////////////////// internal void OrderEdges() { // If this vertex has already been ordered or is a vertex at infinity if (_fAlreadyOrdered || FAtInfinity) { return; } // If we have the usual case of 3 edges if (CtEdges == 3) { // Get the points at the other end of each of the 3 edges var pt0 = PtAtOtherEnd(FortuneEdges[0]); var pt1 = PtAtOtherEnd(FortuneEdges[1]); var pt2 = PtAtOtherEnd(FortuneEdges[2]); // If ordered incorrectly if (Geometry2D.ICcw(pt0, pt1, pt2) > 0) { // Swap the first two var edge0 = FortuneEdges[0]; FortuneEdges[0] = FortuneEdges[1]; FortuneEdges[1] = edge0; } // Mark ourselves as ordered _fAlreadyOrdered = true; } else { // Do the more complicated sort FortuneEdges.Sort(CompareEdges); _fAlreadyOrdered = true; } }
private static IEnumerable <HoneycombDef> GetEuclidImageSet() { for (int p = 3; p <= 8; p++) { for (int q = 3; q <= 8; q++) { for (int r = 3; r <= 8; r++) { if (!(Geometry2D.GetGeometry(p, q) == Geometry.Euclidean || Geometry2D.GetGeometry(q, r) == Geometry.Euclidean)) { continue; } // Do the last as infinity System.Func <int, int> iSafe = input => input == 8 ? -1 : input; yield return(new HoneycombDef() { P = iSafe(p), Q = iSafe(q), R = iSafe(r) }); } } } }
public static void DoStuff(Settings settings) { HoneycombDef imageData = new HoneycombDef(settings.P, settings.Q, settings.R); ////////////////////////////////////////////////////////////// Various things we've run over time. //Sandbox.CalcSelfSimilarityScale(); //Sandbox.Check_pq_Distances(); //HyperidealSquares(); //S3.Hypercube(); //R3.Geometry.Euclidean.GenEuclidean(); //HoneycombGen.OneHoneycombOldCode(); //AnimateCell( imageData ); //CreateCellPovRay( imageData, "cell.pov" ); //CreateSimplex( imageData ); //HoneycombGen_old.OneHoneycombNew( new HoneycombDef() { P = imageData.P, Q = imageData.Q, R = imageData.R } ); //SphericalAnimate( imageData ); OneImage(settings); HoneycombDef[] scaleLarger = GetImageSet().Where(h => Geometry2D.GetGeometry(h.P, h.Q) == Geometry.Euclidean || Geometry2D.GetGeometry(h.P, h.Q) == Geometry.Spherical).ToArray(); int count = scaleLarger.Length; //foreach( HoneycombAndView h in scaleLarger ) // Trace.WriteLine( h.FormatFilename() ); //BatchRun( settings ); }
public double GetMinEpsilon(TPoint2D shortcutEnd, bool doExtremePointQueries) { double[] distances; if (doExtremePointQueries) { //O(4log n) distances = new [] { Geometry2D.Distance(shortcutStart, shortcutEnd, upper.ExtremePointFromShortcutLine(shortcutEnd)), Geometry2D.Distance(shortcutStart, shortcutEnd, lower.ExtremePointFromShortcutLine(shortcutEnd)), upper.ExtremeDistanceLeftOfShortcut(shortcutEnd), lower.ExtremeDistanceLeftOfShortcut(shortcutEnd) }; } else { //O(2log n) distances = new [] { upper.ExtremeDistanceLeftOfShortcut(shortcutEnd), lower.ExtremeDistanceLeftOfShortcut(shortcutEnd) }; } return(distances.Max()); }
private static void ConnectTop(List <Vector2> left, List <Vector2> right, Vector2 A, Vector2 B, float width) { Vector2 eAB = (B - A).normalized; Vector2 tAB = Geometry2D.RotateVector(eAB, Mathf.PI / 2); left.Add(A + tAB * width / 2); right.Add(A - tAB * width / 2); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Compare edges clockwise around this vertex. </summary> /// <remarks> Darrellp, 2/19/2011. </remarks> /// <param name="e1"> The first WeEdge. </param> /// <param name="e2"> The second WeEdge. </param> /// <returns> +1 if they are CW around the generator, -1 if they're CCW, 0 if neither. </returns> //////////////////////////////////////////////////////////////////////////////////////////////////// private int CompareEdges(WeEdge e1, WeEdge e2) { // Compare edges for clockwise order var fe1 = (FortuneEdge)e1; var fe2 = (FortuneEdge)e2; return(Geometry2D.ICompareCw(Pt, fe1.PolyOrderingTestPoint, fe2.PolyOrderingTestPoint)); }
public Wedge(TPoint2D origin, double startAngle, double endAngle) { Origin = origin; StartAngle = Geometry2D.SimplifyRadians(startAngle); EndAngle = Geometry2D.SimplifyRadians(endAngle); IsFullPlane = false; }
/// <summary> /// Return the distance we represent for a particular {p,q} tiling. /// </summary> public double Dist(int p, int q) { return (this.P * Geometry2D.GetTrianglePSide(p, q) + this.Q * Geometry2D.GetTriangleQSide(p, q) + this.R * Geometry2D.GetTriangleHypotenuse(p, q) + this.D); }
internal override void Mirror(Geometry2D target, Line2D mirrorLine) { if (target is ColumnGeometry) { ColumnGeometry column = (target as ColumnGeometry); this.start = TransformUtil.Mirror(column.start, mirrorLine); this.end = TransformUtil.Mirror(column.end, mirrorLine); } }
internal override void Mirror(Geometry2D target, Line2D mirrorLine) { if (target is CircleGeometry) { CircleGeometry circle = (target as CircleGeometry); this.start = TransformUtil.Mirror(circle.start, mirrorLine); this.end = TransformUtil.Mirror(circle.end, mirrorLine); } }
/// <summary> /// 对当前图形进行镜像处理 /// </summary> /// <param name="mirrorLine"></param> internal override void Mirror(Geometry2D target, Line2D mirrorLine) { if (target is LineGeometry) { LineGeometry line = (target as LineGeometry); this.start = TransformUtil.Mirror(line.start, mirrorLine); this.end = TransformUtil.Mirror(line.end, mirrorLine); } }
/// <summary> /// 指定当前物品高亮 /// </summary> /// <param name="g"></param> public void SetHightLight(Geometry2D g) { List <Line2D> lines = g.Lines; if (lines != null) { this.SetHightLight(lines); } }
internal override void Mirror(Geometry2D target, Line2D mirrorLine) { if (target is BeamGeometry) { BeamGeometry beam = (target as BeamGeometry); this.start = TransformUtil.Mirror(beam.start, mirrorLine); this.end = TransformUtil.Mirror(beam.end, mirrorLine); } }
internal override void Mirror(Geometry2D target, Line2D mirrorLine) { if (target is EllipseGeometry) { EllipseGeometry ellipse = (target as EllipseGeometry); this.central = TransformUtil.Mirror(ellipse.central, mirrorLine); this.reference = TransformUtil.Mirror(ellipse.reference, mirrorLine); } }
/// <summary> Constructor </summary> public Triangle2D(Vector2 a, Vector2 b, Vector2 c) { _a = a; _b = b; _c = c; _A = Vector2.Distance(b, c); _B = Vector2.Distance(a, c); _C = Vector2.Distance(a, c); _area = Geometry2D.ShoelaceFormula(a, b, c); }
internal override void Mirror(Geometry2D target, Line2D mirrorLine) { if (target is MeasureGeometry) { MeasureGeometry measure = (target as MeasureGeometry); this.start = TransformUtil.Mirror(measure.start, mirrorLine); this.end = TransformUtil.Mirror(measure.end, mirrorLine); } }
/// <summary> /// 图形镜像 /// </summary> /// <param name="target"></param> /// <param name="mirrorLine"></param> internal override void Mirror(Geometry2D target, Line2D mirrorLine) { if (target is BeamGeometry) { ArcGeometry arc = (target as ArcGeometry); this.start = TransformUtil.Mirror(arc.start, mirrorLine); this.end = TransformUtil.Mirror(arc.end, mirrorLine); this.central = TransformUtil.Mirror(arc.central, mirrorLine); } }
/// <summary> /// Compute the distance between the specified points a and b in the Cartesian Plan. /// </summary> /// <param name='a'> /// Point a with x and y /// </param> /// <param name='b'> /// Point b with x and y /// </param> public static double Distance(Geometry2D.Point2D a, Geometry2D.Point2D b) { return Math.Sqrt(Math.Pow (a.X - b.X)+Math.Pow(a.Y - b.Y)); }
///<exclude/> public bool Equals(Geometry2D other) { if (ReferenceEquals(null, other)) return false; if (ReferenceEquals(this, other)) return true; return other._Pose.Equals(_Pose) && other._Size.Equals(_Size); }