Esempio n. 1
0
 public Polygon ToPolygon(int offset = 0)
 {
     offset += HitBox;
     var result = new Polygon();
     var innerRadius = -0.1562f * Distance + 687.31f;
     var outerRadius = 0.35256f * Distance + 133f;
     outerRadius = outerRadius / (float) Math.Cos(2 * Math.PI / CircleLineSegmentN);
     var innerCenters = LeagueSharp.Common.Geometry.CircleCircleIntersection(
         Start, End, innerRadius, innerRadius);
     var outerCenters = LeagueSharp.Common.Geometry.CircleCircleIntersection(
         Start, End, outerRadius, outerRadius);
     var innerCenter = innerCenters[0];
     var outerCenter = outerCenters[0];
     var direction = (End - outerCenter).Normalized();
     var end = (Start - outerCenter).Normalized();
     var maxAngle = (float) (direction.AngleBetween(end) * Math.PI / 180);
     var step = -maxAngle / CircleLineSegmentN;
     for (var i = 0; i < CircleLineSegmentN; i++)
     {
         var angle = step * i;
         var point = outerCenter + (outerRadius + 15 + offset) * direction.Rotated(angle);
         result.Add(point);
     }
     direction = (Start - innerCenter).Normalized();
     end = (End - innerCenter).Normalized();
     maxAngle = (float) (direction.AngleBetween(end) * Math.PI / 180);
     step = maxAngle / CircleLineSegmentN;
     for (var i = 0; i < CircleLineSegmentN; i++)
     {
         var angle = step * i;
         var point = innerCenter + Math.Max(0, innerRadius - offset - 100) * direction.Rotated(angle);
         result.Add(point);
     }
     return result;
 }
Esempio n. 2
0
		public static Polygons GetCorrectedWinding(this Polygons polygonsToFix)
		{
			polygonsToFix = Clipper.CleanPolygons(polygonsToFix);
			Polygon boundsPolygon = new Polygon();
			IntRect bounds = Clipper.GetBounds(polygonsToFix);
			bounds.left -= 10;
			bounds.bottom += 10;
			bounds.right += 10;
			bounds.top -= 10;

			boundsPolygon.Add(new IntPoint(bounds.left, bounds.top));
			boundsPolygon.Add(new IntPoint(bounds.right, bounds.top));
			boundsPolygon.Add(new IntPoint(bounds.right, bounds.bottom));
			boundsPolygon.Add(new IntPoint(bounds.left, bounds.bottom));

			Clipper clipper = new Clipper();

			clipper.AddPaths(polygonsToFix, PolyType.ptSubject, true);
			clipper.AddPath(boundsPolygon, PolyType.ptClip, true);

			PolyTree intersectionResult = new PolyTree();
			clipper.Execute(ClipType.ctIntersection, intersectionResult);

			Polygons outputPolygons = Clipper.ClosedPathsFromPolyTree(intersectionResult);

			return outputPolygons;
		}
 public PDFReferencePointRenderer()
 {
     // Create the polygon that represents the body
     bodyPlygn = new Polygon();
     bodyPlygn.Add(new Vector2(this.X + .25, this.Y + .25));
     bodyPlygn.Add(new Vector2(this.X + .25, this.Y - .25));
     bodyPlygn.Add(new Vector2(this.X - .25, this.Y + .25));
     bodyPlygn.Add(new Vector2(this.X - .25, this.Y - .25));
 }
Esempio n. 4
0
 public WaypointRenderer()
 {
     // Create the polygon that represents the body
     bodyPlygn = new Polygon();
     bodyPlygn.Add(new Vector2(this.X+.2, this.Y+.2));
     bodyPlygn.Add(new Vector2(this.X+.2, this.Y-.2));
     bodyPlygn.Add(new Vector2(this.X-.2, this.Y+.2));
     bodyPlygn.Add(new Vector2(this.X-.2, this.Y-.2));
 }
Esempio n. 5
0
        public static void TestSquare()
        {
            Polygon poly = new Polygon();
            poly.Add(new Position("36.60987854N,88.30194711W"));
            poly.Add(new Position("36.60989999N,88.30430746W"));
            poly.Add(new Position("36.60797953N,88.30428600W"));
            poly.Add(new Position("36.60796880N,88.30190420W"));

            // Built-in formula
            Console.WriteLine("GeoFrameworks new calc: " + poly.Perimeter.ToString());
            // Custom formula
            Console.WriteLine("GeoFrameworks old calc: " + Perimeter(poly));
        }
 /// <summary>
 /// Create and return octagon model of vehicle from given radius
 /// </summary>
 /// <param name="r"></param>
 /// <returns></returns>
 public static Polygon VehiclePolygonWithRadius(double r)
 {
     Polygon poly = new Polygon();
     poly.Add(new Vector2(r, r));
     poly.Add(new Vector2(-r, r));
     poly.Add(new Vector2(-r, -r));
     poly.Add(new Vector2(r, -r));
     /*
     for (int i = -5; i < 7; i += 2)
     {
         poly.Add(new Vector2(r * Math.Cos(Math.PI * i / 8), r * Math.Sin(Math.PI * i / 8)));
     }
      * */
     return poly;
 }
Esempio n. 7
0
 public static Polygon ToPolygon(this Path v) {
     var polygon = new Polygon();
     foreach (var point in v) {
         polygon.Add(new Vector2(point.X, point.Y));
     }
     return polygon;
 }
Esempio n. 8
0
        public static void Build(RooFile Room)
        {
            if (Room == null)
                return;

            room = Room;

            if (BuildStarted != null)
                BuildStarted(null, new EventArgs());

            ///////////////////////////////////////////////////////////////

            BoundingBox2D box = Room.GetBoundingBox2D(true);
            
            Polygon poly = new Polygon();           
            poly.Add(box.Min);
            poly.Add(box.Min + new V2(box.Max.X - box.Min.X, 0f));
            poly.Add(box.Max);
            poly.Add(box.Max - new V2(box.Max.X - box.Min.X, 0f));
            
            ///////////////////////////////////////////////////////////////

            // clean up old data from room
            Room.Walls.Clear();
            Room.BSPTree.Clear();
            foreach (RooSector sector in Room.Sectors)
            {
                sector.Walls.Clear();
                sector.Sides.Clear();
            }

            // convert roomeditor walls to roowall
            for (int i = 0; i < Room.WallsEditor.Count; i++)
            {
                RooWall wall = Room.WallsEditor[i].ToRooWall(RooFile.VERSIONHIGHRESGRID, Room);
                Room.Walls.Add(wall);
            }

            ///////////////////////////////////////////////////////////////

            RooBSPItem tree = BuildNode(Room.Walls, poly, 0);

            ///////////////////////////////////////////////////////////////

            FillNode(tree, Room.BSPTree);
            SetNums(Room.BSPTree);
        }
Esempio n. 9
0
        PathToRobotRenderer runningPath; // the path that the robot is currently running

        #endregion Fields

        #region Constructors

        public RobotKeypoint(int id)
        {
            color = Color.Black;
            this.id = id;
            name = "Robot " + id;
            runningPath = new PathToRobotRenderer();
            commandedPath = new PathToRobotRenderer();
            pose = new RobotPose();

            origPlygn = new Polygon();
            origPlygn.Add(new Vector2(.25, .36));
            origPlygn.Add(new Vector2(.25, -.36));
            origPlygn.Add(new Vector2(-.25, -.36));
            origPlygn.Add(new Vector2(-.25, .36));

            bodyPlygn = new Polygon(origPlygn.points);
        }
Esempio n. 10
0
        public static void Triangulate(IList <Vector2> vertices, IList <Edge> edges, IList <int> indices)
        {
            indices.Clear();

            if (vertices.Count < 3)
            {
                return;
            }

            var polygon = new Polygon(vertices.Count);

            for (int i = 0; i < vertices.Count; ++i)
            {
                Vector2 position = vertices[i];
                polygon.Add(new Vertex(position.x, position.y, 1));
            }

            for (int i = 0; i < edges.Count; ++i)
            {
                Edge edge = edges[i];
                polygon.Add(new Segment(polygon.Points[edge.index1], polygon.Points[edge.index2]));
            }

            var mesh = polygon.Triangulate();

            foreach (ITriangle triangle in mesh.Triangles)
            {
                int id0 = triangle.GetVertexID(0);
                int id1 = triangle.GetVertexID(1);
                int id2 = triangle.GetVertexID(2);

                if (id0 < 0 || id1 < 0 || id2 < 0 || id0 >= vertices.Count || id1 >= vertices.Count || id2 >= vertices.Count)
                {
                    continue;
                }

                indices.Add(id0);
                indices.Add(id2);
                indices.Add(id1);
            }
        }
Esempio n. 11
0
        void lazyFill(Polygons polysToWriteTo, IntPoint startPoint, int z, CheckForSupport checkIfSupportNeeded)
        {
            Polygon poly = new Polygon();

            polysToWriteTo.Add(poly);

            Polygon tmpPoly = new Polygon();

            while (true)
            {
                IntPoint endPoint = startPoint;
                done[endPoint.X + endPoint.Y * supportStorage.gridWidth] = true;
                while (checkIfSupportNeeded(endPoint + new IntPoint(1, 0), z))
                {
                    endPoint.X++;
                    done[endPoint.X + endPoint.Y * supportStorage.gridWidth] = true;
                }
                tmpPoly.Add(startPoint * supportStorage.gridScale + supportStorage.gridOffset - new IntPoint(supportStorage.gridScale / 2, 0));
                poly.Add(endPoint * supportStorage.gridScale + supportStorage.gridOffset);
                startPoint.Y++;
                while (!checkIfSupportNeeded(startPoint, z) && startPoint.X <= endPoint.X)
                {
                    startPoint.X++;
                }

                if (startPoint.X > endPoint.X)
                {
                    for (int n = 0; n < tmpPoly.Count; n++)
                    {
                        poly.Add(tmpPoly[tmpPoly.Count - n - 1]);
                    }
                    polysToWriteTo.Add(poly);
                    return;
                }

                while (checkIfSupportNeeded(startPoint - new IntPoint(1, 0), z) && startPoint.X > 1)
                {
                    startPoint.X--;
                }
            }
        }
Esempio n. 12
0
        public Shape(GeoPoint center, double radius, int polygons = 60)
        {
            var angle = (360.0 / polygons) * (Math.PI / 180.0);

            Center = center;

            for (int i = 0; i < polygons; i++)
            {
                var point = new GeoPoint(center.Latitude + radius * Math.Cos(angle * i), center.Longitude + (radius / 1.5) * Math.Sin(angle * i));
                Polygon.Add(point);
            }
        }
Esempio n. 13
0
    void Start()
    {
        Triangulator tri = new Triangulator();

        // Vector2 p0 = new Vector2( 0.0f, 0.0f);
        // Vector2 p1 = new Vector2( 0.0f, 1.0f);
        // Vector2 p2 = new Vector2(-0.5f, 0.0f);

        // Debug.Log("Orientation of [" + p0 + p1 + "] [" + p2 + "] : " + Orientation(p0, p1, p2));

        // p0 = new Vector2( 0.0f,  0.0f);
        // p1 = new Vector2( 0.0f,  1.0f);
        // p2 = new Vector2(+4.5f, -1.0f);

        // Debug.Log("Orientation of [" + p0 + p1 + "] [" + p2 + "] : " + Orientation(p0, p1, p2));

        MartinezClipping clippingAlgo = new MartinezClipping();

        Polygon subject = new Polygon();
        Polygon clipper = new Polygon();

        SimpleClosedPath subjectContour = new SimpleClosedPath(subject);
        SimpleClosedPath clipperContour = new SimpleClosedPath(clipper);

        foreach (Vector2 vertex in subjectVerts)
        {
            subjectContour.Add(vertex);
        }
        foreach (Vector2 vertex in clipperVerts)
        {
            clipperContour.Add(vertex);
        }

        subject.Add(subjectContour);
        clipper.Add(clipperContour);

        subject.ComputeHoles();
        clipper.ComputeHoles();

        clippingAlgo.subject = subject;
        clippingAlgo.clipper = clipper;

        Polygon result = clippingAlgo.Compute(operationType);

        result.ComputeHoles();

        //result = tri.Simplify(result);

        polyRenderer.AddPolygon(subject, Color.red);
        polyRenderer.AddPolygon(clipper, Color.blue);
        polyRenderer.AddPolygon(result, Color.green);
        polyRenderer.AddEdges(clippingAlgo.DebugLines);
    }
    private static Polygon CreateRandom()
    {
        Polygon polygon = new Polygon();

        Random.InitState(seed);
        for (int i = 0; i < territoryCount; i++)
        {
            polygon.Add(new Vertex(Random.Range(0, values.x), Random.Range(0, values.y)));
        }

        return(polygon);
    }
Esempio n. 15
0
    public PolygonSurface Triangulate(ModularMesh mesh, Material material)
    {
        Polygon polygon = new Polygon();

        if (Type == StreetPolygonType.LeftHand)
        {
            for (int i = 0; i < streetmember.Count; i++)
            {
                polygon.Add(streetmember[i].LeftOutline);
            }
        }
        else
        {
            for (int i = 0; i < streetmember.Count; i++)
            {
                polygon.Add(streetmember[i].RightOutline);
            }
        }
        polygon.MakeClockwise();
        return(polygon.Triangulate(mesh, material));
    }
Esempio n. 16
0
        //---------------------------------------------------------------------

        private void GenerateTestPolygon(int count)
        {
            subjects.Clear();
            clips.Clear();
            int     SCALE = 1000;
            Polygon subj  = new Polygon(5);

            subj.Add(new IntPoint(SCALE * 05, SCALE * 25));
            subj.Add(new IntPoint(SCALE * 25, SCALE * 70));
            subj.Add(new IntPoint(SCALE * 40, SCALE * 70));
            subj.Add(new IntPoint(SCALE * 40, SCALE * 25));
            subj.Add(new IntPoint(SCALE * 60, SCALE * 10));
            subjects.Add(subj);
            Polygon clip = new Polygon(4);

            clip.Add(new IntPoint(SCALE * 90, SCALE * 90));
            clip.Add(new IntPoint(SCALE * 130, SCALE * 90));
            clip.Add(new IntPoint(SCALE * 130, SCALE * 130));
            clip.Add(new IntPoint(SCALE * 90, SCALE * 130));
            clips.Add(clip);
        }
Esempio n. 17
0
            public Polygon ToPolygon(int offset = 0)
            {
                var result      = new Polygon();
                var outRadius   = (offset + Radius + RingRadius) / (float)Math.Cos(2 * Math.PI / CircleLineSegmentN);
                var innerRadius = Radius - RingRadius - offset;

                for (var i = 0; i <= CircleLineSegmentN; i++)
                {
                    var angle = i * 2 * Math.PI / CircleLineSegmentN;
                    var point = new Vector2(Center.X - outRadius * (float)Math.Cos(angle), Center.Y - outRadius * (float)Math.Sin(angle));
                    result.Add(point);
                }
                for (var i = 0; i <= CircleLineSegmentN; i++)
                {
                    var angle = i * 2 * Math.PI / CircleLineSegmentN;
                    var point = new Vector2(Center.X + innerRadius * (float)Math.Cos(angle), Center.Y - innerRadius * (float)Math.Sin(angle));
                    result.Add(point);
                }

                return(result);
            }
Esempio n. 18
0
        /// <summary>
        /// Creates a collider from the StarMapColliderInfo
        /// </summary>
        /// <param name="starMapColliderInfo"></param>
        public void CreateFromCollider(StarMapColliderInfo starMapColliderInfo)
        {
            polygon = starMapColliderInfo.Polygon;
            Origin  = -(starMapColliderInfo.Size.ToFloat() / 2);

            var first = polygon.FirstOrDefault();

            if (first != null)
            {
                polygon.Add(first);
            }
        }
Esempio n. 19
0
        public static IPolygon CreatePolygon()
        {
            // Generate three concentric circles.
            var poly = new Polygon();

            // Center point.
            var center = new Point(0, 0);

            // Inner contour (hole).
            poly.Add(Generate.Circle(1.0, center, 0.1, 1), center);

            // Internal contour.
            poly.Add(Generate.Circle(2.0, center, 0.1, 2));

            // Outer contour.
            poly.Add(Generate.Circle(3.0, center, 0.3, 3));

            // Note that the outer contour has a larger segment size!

            return(poly);
        }
        private void ReadPoints(BinaryReader f, ref Polygon Shape, int UpTo)
        {
            Shape.Points.BeginUpdate();
            for (int t = 0; t < UpTo - po; ++t)
            {
                Shape.Add(f.ReadDouble(), f.ReadDouble());
            }

            po = UpTo;

            Shape.Points.EndUpdate();
        }
    public virtual void Generate(int worldSeed)
    {
        int chunkSeed = Generator.GetPerIslandSeed(this);

        creatingChunkStopwatch = System.Diagnostics.Stopwatch.StartNew();

        random       = new Random(chunkSeed);
        elevations   = new List <float>();
        islandColors = new List <Color>();

        CreatingPoolTask = delegate {
            PoissonDiscSampler sampler = new PoissonDiscSampler(Size, Size, minPointRadius);

            Polygon polygon = new Polygon();

            //Add uniformly-spaced points
            foreach (Vector2 sample in sampler.Samples(chunkSeed))
            {
                polygon.Add(new Vertex((double)sample.x, (double)sample.y));
            }

            //add points at corners so chunk will be always square shaped
            polygon.Add(new Vertex(0, 0));
            polygon.Add(new Vertex(0, Size));
            polygon.Add(new Vertex(Size, 0));
            polygon.Add(new Vertex(Size, Size));

            //Add some randomly sampled points
            for (int i = 0; i < randomPoints - 4; i++)
            {
                polygon.Add(new Vertex(random.Range(0.0f, Size), random.Range(0.0f, Size)));
            }

            TriangleNet.Meshing.ConstraintOptions options = new TriangleNet.Meshing.ConstraintOptions()
            {
                ConformingDelaunay = true
            };
            mesh = (TriangleNet.Mesh)polygon.Triangulate(options);

            // Sample perlin noise to get elevations
            foreach (Vertex vert in mesh.Vertices)
            {
                float height = Generator.GetTerrainHeight((float)vert.x, (float)vert.y, this);
                Color color  = Generator.GetTerrainColor((float)vert.x, (float)vert.y, height, this);

                elevations.Add(height);
                islandColors.Add(color);
            }

            CreateMeshRequest = true;

            //let this be always the last piece of code here
            try {
                bin = new TriangleBin(mesh, Size, Size, minPointRadius * 2.0f);
            } catch (Exception e) {
                Debug.Log("triangulation failed!");
            }
        };
        CustomThreadPool.AddTask(CreatingPoolTask);
    }
Esempio n. 22
0
        private Obstacle GetSideObstacle(SideObstacles sideObstacles)
        {
            if (sideObstacles == null)
            {
                return(null);
            }

            double   minDist     = 100;
            Obstacle minObstacle = null;

            foreach (SideObstacle obs in sideObstacles.obstacles)
            {
                if (obs.distance > 0.5 && obs.distance < minDist)
                {
                    minDist = obs.distance;

                    // create a polygon the specified distance away and 1 m in front of the rear axle and 0.5 m behind the front axle
                    Polygon poly = new Polygon();
                    if (sideObstacles.side == SideObstacleSide.Driver)
                    {
                        poly.Add(new Coordinates(1, obs.distance + TahoeParams.T / 2.0));
                        poly.Add(new Coordinates(TahoeParams.FL - 0.5, obs.distance + TahoeParams.T / 2.0));
                        poly.Add(new Coordinates(TahoeParams.FL - 0.5, obs.distance + TahoeParams.T / 2.0 + 1));
                        poly.Add(new Coordinates(1, obs.distance + TahoeParams.T / 2.0 + 1));
                    }
                    else
                    {
                        poly.Add(new Coordinates(1, -(obs.distance + TahoeParams.T / 2.0)));
                        poly.Add(new Coordinates(TahoeParams.FL - 0.5, -(obs.distance + TahoeParams.T / 2.0)));
                        poly.Add(new Coordinates(TahoeParams.FL - 0.5, -(obs.distance + TahoeParams.T / 2.0 + 1)));
                        poly.Add(new Coordinates(1, -(obs.distance + TahoeParams.T / 2.0 + 1)));
                    }

                    Obstacle finalObs = new Obstacle();
                    finalObs.age           = 1;
                    finalObs.obstacleClass = ObstacleClass.StaticLarge;

                    finalObs.obstaclePolygon = poly;

                    finalObs.minSpacing = min_spacing[(int)finalObs.obstacleClass];
                    finalObs.desSpacing = des_spacing[(int)finalObs.obstacleClass];

                    finalObs.cspacePolygon = Polygon.ConvexMinkowskiConvolution(conv_polygon[(int)finalObs.obstacleClass], finalObs.AvoidancePolygon);

                    minObstacle = finalObs;
                }
            }

            return(minObstacle);
        }
Esempio n. 23
0
		public static void GenerateLinePaths(Polygons polygonToInfill, ref Polygons infillLinesToPrint, int lineSpacing, int infillExtendIntoPerimeter_um, double rotation, long rotationOffset = 0)
		{
			if (polygonToInfill.Count > 0)
			{
				Polygons outlines = polygonToInfill.Offset(infillExtendIntoPerimeter_um);
				if (outlines.Count > 0)
				{
					PointMatrix matrix = new PointMatrix(-(rotation + 90)); // we are rotating the part so we rotate by the negative so the lines go the way we expect

					outlines.ApplyMatrix(matrix);

					Aabb boundary = new Aabb(outlines);

					boundary.min.X = ((boundary.min.X / lineSpacing) - 1) * lineSpacing - rotationOffset;
					int xLineCount = (int)((boundary.max.X - boundary.min.X + (lineSpacing - 1)) / lineSpacing);
					Polygons unclipedPatern = new Polygons();

					long firstX = boundary.min.X / lineSpacing * lineSpacing;
					for (int lineIndex = 0; lineIndex < xLineCount; lineIndex++)
					{
						Polygon line = new Polygon();
						line.Add(new IntPoint(firstX + lineIndex * lineSpacing, boundary.min.Y));
						line.Add(new IntPoint(firstX + lineIndex * lineSpacing, boundary.max.Y));
						unclipedPatern.Add(line);
					}

					PolyTree ret = new PolyTree();
					Clipper clipper = new Clipper();
					clipper.AddPaths(unclipedPatern, PolyType.ptSubject, false);
					clipper.AddPaths(outlines, PolyType.ptClip, true);
					clipper.Execute(ClipType.ctIntersection, ret, PolyFillType.pftPositive, PolyFillType.pftEvenOdd);

					Polygons newSegments = Clipper.OpenPathsFromPolyTree(ret);
					PointMatrix inversematrix = new PointMatrix((rotation + 90));
					newSegments.ApplyMatrix(inversematrix);

					infillLinesToPrint.AddRange(newSegments);
				}
			}
		}
Esempio n. 24
0
        private Polygon GetPolygon()
        {
            var poly = new Polygon(7);

            var p = new List <Vertex>()
            {
                new Vertex(0.0, 0.0, 1),
                new Vertex(2.0, 0.0, 1),
                new Vertex(2.0, 1.0, 1),
                new Vertex(2.0, 2.0, 1),
                new Vertex(0.0, 2.0, 1),
                new Vertex(1.5, 1.6, 1),
                new Vertex(2.0, 0.0, 1) // duplicate
            };

            poly.Points.AddRange(p);

            poly.Add(new Segment(p[0], p[1], 1));
            poly.Add(new Segment(p[1], p[2], 1));
            poly.Add(new Segment(p[2], p[3], 1));
            poly.Add(new Segment(p[3], p[4], 1));
            poly.Add(new Segment(p[4], p[0], 1));
            poly.Add(new Segment(p[2], p[5], 2));

            return(poly);
        }
Esempio n. 25
0
        public override IPolygon Generate(double param0, double param1, double param2)
        {
            // Number of points on the outer circle
            int n = GetParamValueInt(0, param0);

            double radius = GetParamValueInt(1, param1);

            // Current radius and step size
            double r, h = radius / n;

            var polygon = new Polygon(n + 1);

            // Inner cirlce (radius = 1) (hole)
            r = 1;
            var innerCircleMarker = 1;

            polygon.Add(CreateCircleContour(r, (int)(r / h), innerCircleMarker), new Point(0, 0));

            // Center cirlce
            r = (radius + 1.0) / 2.0;
            var centerCircleMarker = 2;

            polygon.Add(CreateCircleContour(r, (int)(r / h), centerCircleMarker));

            //count = input.Count;

            // Outer cirlce
            r = radius;
            var outerCircleMarker = 3;

            polygon.Add(CreateCircleContour(r, (int)(r / h), outerCircleMarker));

            // Regions: |++++++|++++++|---|
            //          r             1   0

            polygon.Regions.Add(new RegionPointer((r + 3.0) / 4.0, 0, 1));
            polygon.Regions.Add(new RegionPointer((3 * r + 1.0) / 4.0, 0, 2));

            return(polygon);
        }
Esempio n. 26
0
        public DTConvexPolygroup PolygonToTriangleList(DTPolygon subject)
        {
            // Mark any unmarked holes in the contour, otherwise Triangle.NET won't handle them properly
            subject = DTUtility.IdentifyHoles(subject);
            if (subject.Contour.Count < 3)
            {
                return(new DTConvexPolygroup());
            }
            // Don't triangulate if this is already a triangle
            else if (subject.Contour.Count == 3 && subject.Holes.Count == 0)
            {
                return(new DTConvexPolygroup(new List <DTPolygon>()
                {
                    subject
                }));
            }

            // Format polygon input and execute
            Polygon polygon = new Polygon();

            polygon.Add(new Contour(subject.Contour.ToVertexList()), false);
            foreach (var hole in subject.Holes)
            {
                if (hole.Count >= 3)
                {
                    try {
                        polygon.Add(new Contour(hole.ToVertexList()), true);
                    }
                    catch (Exception) {}
                }
            }
            DTProfilerMarkers.TriangleNet.Begin();
            IMesh triangleNetOutput = polygon.Triangulate();

            ++callCount;
            DTProfilerMarkers.TriangleNet.End();

            // Convert Triangle.NET output into poly group
            return(new DTConvexPolygroup(triangleNetOutput.Triangles.Select(t => t.ToVertexList()).ToList()));
        }
Esempio n. 27
0
        public override unsafe void ReadFrom(ref byte *Buffer)
        {
            base.ReadFrom(ref Buffer);

            SectorNum = *((ushort *)Buffer);
            Buffer   += TypeSizes.SHORT;

            ushort len = *((ushort *)Buffer);

            Buffer += TypeSizes.SHORT;

            Vertices = new Polygon();

            if (RooVersion < RooFile.VERSIONFLOATCOORDS)
            {
                for (int i = 0; i < len; i++)
                {
                    int x = *((int *)Buffer);
                    Buffer += TypeSizes.INT;

                    int y = *((int *)Buffer);
                    Buffer += TypeSizes.INT;

                    Vertices.Add(new V2(x, y));
                }
            }
            else
            {
                for (int i = 0; i < len; i++)
                {
                    float x = *((float *)Buffer);
                    Buffer += TypeSizes.FLOAT;

                    float y = *((float *)Buffer);
                    Buffer += TypeSizes.FLOAT;

                    Vertices.Add(new V2(x, y));
                }
            }
        }
        public override IPolygon Generate(double param0, double param1, double param2)
        {
            int numPoints = GetParamValueInt(0, param0);

            numPoints = (numPoints / 10) * 10;

            if (numPoints < 5)
            {
                numPoints = 5;
            }

            double exp = (param1 + 10) / 100;

            var input = new Polygon(numPoints);

            int i = 0, cNum = 2 * (int)Math.Floor(Math.Sqrt(numPoints));

            double r, phi, radius = 100, step = 2 * Math.PI / cNum;

            // Distrubute points equally on circle border
            for (; i < cNum; i++)
            {
                // Add a little error
                r = Util.Random.NextDouble();

                input.Add(new Vertex((radius + r) * Math.Cos(i * step),
                                     (radius + r) * Math.Sin(i * step)));
            }

            for (; i < numPoints; i++)
            {
                // Use sqrt(rand) to get normal distribution right.
                r   = Math.Pow(Util.Random.NextDouble(), exp) * radius;
                phi = Util.Random.NextDouble() * Math.PI * 2;

                input.Add(new Vertex(r * Math.Cos(phi), r * Math.Sin(phi)));
            }

            return(input);
        }
Esempio n. 29
0
        public static void GenerateLinePaths(Polygons in_outline, ref Polygons result, int lineSpacing, int infillExtendIntoPerimeter_um, double rotation, long rotationOffset = 0)
        {
            if (in_outline.Count > 0)
            {
                Polygons outlines = in_outline.Offset(infillExtendIntoPerimeter_um);
                if (outlines.Count > 0)
                {
                    PointMatrix matrix = new PointMatrix(-(rotation + 90));                     // we are rotating the part so we rotate by the negative so the lines go the way we expect

                    outlines.ApplyMatrix(matrix);

                    Aabb boundary = new Aabb(outlines);

                    boundary.min.X = ((boundary.min.X / lineSpacing) - 1) * lineSpacing - rotationOffset;
                    int      xLineCount     = (int)((boundary.max.X - boundary.min.X + (lineSpacing - 1)) / lineSpacing);
                    Polygons unclipedPatern = new Polygons();

                    long firstX = boundary.min.X / lineSpacing * lineSpacing;
                    for (int lineIndex = 0; lineIndex < xLineCount; lineIndex++)
                    {
                        Polygon line = new Polygon();
                        line.Add(new IntPoint(firstX + lineIndex * lineSpacing, boundary.min.Y));
                        line.Add(new IntPoint(firstX + lineIndex * lineSpacing, boundary.max.Y));
                        unclipedPatern.Add(line);
                    }

                    PolyTree ret     = new PolyTree();
                    Clipper  clipper = new Clipper();
                    clipper.AddPaths(unclipedPatern, PolyType.ptSubject, false);
                    clipper.AddPaths(outlines, PolyType.ptClip, true);
                    clipper.Execute(ClipType.ctIntersection, ret, PolyFillType.pftPositive, PolyFillType.pftEvenOdd);

                    Polygons    newSegments   = Clipper.OpenPathsFromPolyTree(ret);
                    PointMatrix inversematrix = new PointMatrix((rotation + 90));
                    newSegments.ApplyMatrix(inversematrix);

                    result.AddRange(newSegments);
                }
            }
        }
Esempio n. 30
0
        //---------------------------------------------------------------------

        private void GenerateAustPlusRandomEllipses(int count)
        {
            subjects.Clear();
            //load map of Australia from resource ...
            _assembly  = Assembly.GetExecutingAssembly();
            polyStream = _assembly.GetManifestResourceStream("ClipperCSharpDemo1.australia.bin");
            int len = (int)polyStream.Length;

            byte[] b = new byte[len];
            polyStream.Read(b, 0, len);
            int polyCnt = BitConverter.ToInt32(b, 0);
            int k       = 4;

            for (int i = 0; i < polyCnt; ++i)
            {
                int vertCnt = BitConverter.ToInt32(b, k);
                k += 4;
                Polygon pg = new Polygon(vertCnt);
                for (int j = 0; j < vertCnt; ++j)
                {
                    float x = BitConverter.ToSingle(b, k) * scale;
                    float y = BitConverter.ToSingle(b, k + 4) * scale;
                    k += 8;
                    pg.Add(new IntPoint((int)x, (int)y));
                }
                subjects.Add(pg);
            }

            clips.Clear();
            Random       rand = new Random();
            GraphicsPath path = new GraphicsPath();
            Point        pt   = new Point();

            for (int i = 0; i < count; ++i)
            {
                int w = pictureBox1.ClientRectangle.Width - 220;
                int h = pictureBox1.ClientRectangle.Height - 140 - statusStrip1.Height;

                pt.X = rand.Next(w) + panel1.Width + 10;
                pt.Y = rand.Next(h) + 30;
                int size = rand.Next(90) + 10;
                path.Reset();
                path.AddEllipse(pt.X, pt.Y, size, size);
                path.Flatten();
                Polygon clip = new Polygon(path.PathPoints.Count());
                foreach (PointF p in path.PathPoints)
                {
                    clip.Add(new IntPoint((int)(p.X * scale), (int)(p.Y * scale)));
                }
                clips.Add(clip);
            }
        }
Esempio n. 31
0
        public void EnsureWipeTowerIsSolid(int layerIndex, LayerGCodePlanner gcodeLayer, GCodePathConfig fillConfig, ConfigSettings config)
        {
            if (layerIndex >= LastLayerWithChange(config) ||
                extrudersThatHaveBeenPrimed == null)
            {
                return;
            }

            // TODO: if layer index == 0 do all the loops from the outside in in order (no lines should be in the wipe tower)
            if (layerIndex == 0)
            {
                CheckNoExtruderPrimed(config);

                long insetPerLoop  = fillConfig.lineWidth_um;
                int  extruderCount = config.GenerateSupport ? config.ExtruderCount * 2 : config.ExtruderCount;

                Polygons outlineForExtruder = this.wipeTower.Offset(-insetPerLoop);

                Polygons fillPolygons = new Polygons();
                while (outlineForExtruder.Count > 0)
                {
                    for (int polygonIndex = 0; polygonIndex < outlineForExtruder.Count; polygonIndex++)
                    {
                        Polygon newInset = outlineForExtruder[polygonIndex];
                        newInset.Add(newInset[0]);                         // add in the last move so it is a solid polygon
                        fillPolygons.Add(newInset);
                    }
                    outlineForExtruder = outlineForExtruder.Offset(-insetPerLoop);
                }

                var oldPathFinder = gcodeLayer.PathFinder;
                gcodeLayer.PathFinder = null;
                gcodeLayer.QueuePolygons(fillPolygons, fillConfig);
                gcodeLayer.PathFinder = oldPathFinder;
            }
            else
            {
                // print all of the extruder loops that have not already been printed
                int extruderCount = config.GenerateSupport ? config.ExtruderCount * 2 : config.ExtruderCount;
                for (int extruderIndex = 0; extruderIndex < extruderCount; extruderIndex++)
                {
                    if (!extrudersThatHaveBeenPrimed[extruderIndex])
                    {
                        // write the loops for this extruder, but don't change to it. We are just filling the prime tower.
                        PrimeOnWipeTower(extruderIndex, layerIndex, gcodeLayer, fillConfig, config, false);
                    }

                    // clear the history of printer extruders for the next layer
                    extrudersThatHaveBeenPrimed[extruderIndex] = false;
                }
            }
        }
    private static Polygon CreatePoisonDisc()
    {
        Polygon polygon = new Polygon();

        Random.InitState(seed);
        DiscPoisonShape poissonDiscSampler = new DiscPoisonShape(values.x, values.y, orbit);

        foreach (var sample in poissonDiscSampler.Samples())
        {
            polygon.Add(sample.ToVertex());
        }
        return(polygon);
    }
Esempio n. 33
0
        /// <summary>
        /// Creates the collider from a polygon
        /// </summary>
        /// <param name="polygon">The polygon</param>
        public void CreateFromPolygon(Polygon polygon)
        {
            this.polygon = polygon;

            Origin = -(new Vector2f(polygon.Width, polygon.Height) / 2);

            var first = polygon.FirstOrDefault();

            if (first != null)
            {
                polygon.Add(first);
            }
        }
Esempio n. 34
0
        public RobotRenderer(string name, Color color)
        {
            this.name = name;
            this.color = color;

            // Create the polygon that represents the body
            origPlygn = new Polygon();
            origPlygn.Add(new Vector2(.25, .36));
            origPlygn.Add(new Vector2(.25, -.36));
            origPlygn.Add(new Vector2(-.25, -.36));
            origPlygn.Add(new Vector2(-.25, .36));

            bodyPlygn = new Polygon();
            bodyPlygn.Add(new Vector2(.25, .36));
            bodyPlygn.Add(new Vector2(.25, -.36));
            bodyPlygn.Add(new Vector2(-.25, -.36));
            bodyPlygn.Add(new Vector2(-.25, .36));

            robotContextMenu = new ContextMenu();

            this.MythName = establishMythName(name);
        }
Esempio n. 35
0
        public static Polygon PathsToPolygon(this Paths paths)
        {
            var result = new Polygon();

            foreach (var path in paths)
            {
                foreach (var point in path)
                {
                    result.Add(new Vector2(point.X, point.Y));
                }
            }
            return(result);
        }
Esempio n. 36
0
        private Polygon ParsePolygon(string value)
        {
            var pointStrings = value.Split(' ');

            Polygon result = new Polygon();

            foreach (var pt in pointStrings)
            {
                result.Add(Vector2X.Parse(pt));
            }

            return(result);
        }
Esempio n. 37
0
        public RobotRenderer(string name, Color color)
        {
            this.name  = name;
            this.color = color;

            // Create the polygon that represents the body
            origPlygn = new Polygon();
            origPlygn.Add(new Vector2(.25, .36));
            origPlygn.Add(new Vector2(.25, -.36));
            origPlygn.Add(new Vector2(-.25, -.36));
            origPlygn.Add(new Vector2(-.25, .36));

            bodyPlygn = new Polygon();
            bodyPlygn.Add(new Vector2(.25, .36));
            bodyPlygn.Add(new Vector2(.25, -.36));
            bodyPlygn.Add(new Vector2(-.25, -.36));
            bodyPlygn.Add(new Vector2(-.25, .36));

            robotContextMenu = new ContextMenu();

            this.MythName = establishMythName(name);
        }
Esempio n. 38
0
    public static Polygon GenerateRandomDistribution(int size, int density)
    {
        Polygon polygon = new Polygon();

        for (int i = 0; i < density; i++)
        {
            Vector2 p = new Vector2(Random.Range(.0f, size), Random.Range(.0f, size));

            polygon.Add(new Vertex(p.x, p.y));
        }

        return(polygon);
    }
Esempio n. 39
0
    private static Polygon GeneratePoisonDisc()
    {
        Polygon polygon = new Polygon();

        Random.InitState(seed);
        PoissonDiscSampler poissonDiscSampler = new PoissonDiscSampler(dimensions.x, dimensions.y, radius);

        foreach (var sample in poissonDiscSampler.Samples())
        {
            polygon.Add(sample.ToVertex());
        }
        return(polygon);
    }
Esempio n. 40
0
        public void CreateWipeTower(int totalLayers, ConfigSettings config)
        {
            if (config.WipeTowerSize_um < 1 ||
                LastLayerWithChange(config) == -1)
            {
                return;
            }

            Polygon wipeTowerShape = new Polygon();

            wipeTowerShape.Add(new IntPoint(this.modelMin.X - 3000, this.modelMax.Y + 3000));
            wipeTowerShape.Add(new IntPoint(this.modelMin.X - 3000, this.modelMax.Y + 3000 + config.WipeTowerSize_um));
            wipeTowerShape.Add(new IntPoint(this.modelMin.X - 3000 - config.WipeTowerSize_um, this.modelMax.Y + 3000 + config.WipeTowerSize_um));
            wipeTowerShape.Add(new IntPoint(this.modelMin.X - 3000 - config.WipeTowerSize_um, this.modelMax.Y + 3000));

            this.WipeTower.Add(wipeTowerShape);
            var wipeTowerBounds = wipeTowerShape.GetBounds();

            config.WipeCenter_um = new IntPoint(
                wipeTowerBounds.minX + (wipeTowerBounds.maxX - wipeTowerBounds.minX) / 2,
                wipeTowerBounds.minY + (wipeTowerBounds.maxY - wipeTowerBounds.minY) / 2);
        }
Esempio n. 41
0
    private void Triangulate(List <Vector2> points)
    {
        // Vertex is TriangleNet.Geometry.Vertex
        Polygon polygon = new Polygon();

        maxX = -1000;
        maxY = -1000;
        minY = 1000;
        minX = 1000;
        float x, y;

        foreach (Vector2 point in points)
        {
            x = point.x;
            y = point.y;

            polygon.Add(new Vertex(x, y));

            if (x > maxX)
            {
                maxX = x;
            }
            if (y > maxY)
            {
                maxY = y;
            }
            if (x < minX)
            {
                minX = x;
            }
            if (y < minY)
            {
                minY = y;
            }
        }

        if (polygon.Count > 2)
        {
            // ConformingDelaunay is false by default; this leads to ugly long polygons at the edges
            // because the algorithm will try to keep the mesh convex
            //   TriangleNet.Meshing.ConstraintOptions options =
            //    new TriangleNet.Meshing.ConstraintOptions() { ConformingDelaunay = true };
            triangulatorMesh = (TriangleNet.Mesh)polygon.Triangulate();
        }
        else
        {
            Debug.Log(string.Format("Mesh needs minimum 3 points but did only receive: {0} point(s)", polygon.Count));
        }

        Debug.Log(points.Count);
    }
        public Polygon ToPolygon()
        {
            double halfWidth = Width/2;
            double halfLength = Length/2;

            Coordinates heading = Heading.Normalize();
            Coordinates heading90 = heading.Rotate90();

            Coordinates l = heading*halfLength;
            Coordinates w = heading90*halfWidth;

            Coordinates pt1 = Position - l - w;
            Coordinates pt2 = Position + l - w;
            Coordinates pt3 = Position + l + w;
            Coordinates pt4 = Position - l + w;

            Polygon poly = new Polygon(4);
            poly.Add(pt1);
            poly.Add(pt2);
            poly.Add(pt3);
            poly.Add(pt4);

            return poly;
        }
        public Polygon ToPolygon(int offset = 0, float overrideWidth = -1)
        {
            var result = new Polygon();
                var outRadius = (overrideWidth > 0
                    ? overrideWidth
                    : (offset + Radius) / (float)Math.Cos(2 * Math.PI / CircleLineSegmentN));

                for (var i = 1; i <= CircleLineSegmentN; i++)
                {
                    var angle = i * 2 * Math.PI / CircleLineSegmentN;
                    var point = new Vector2(
                        Center.X + outRadius * (float)Math.Cos(angle), Center.Y + outRadius * (float)Math.Sin(angle));
                    result.Add(point);
                }

                return result;
        }
Esempio n. 44
0
        /// <summary>
        /// 保持している全DEMデータ情報をKML形式のテキストデータで返す
        /// <para>ファイルへ保存する際はUTF-8で保存してください。</para>
        /// </summary>
        /// <param name="color">色情報</param>
        /// <returns>テキスト形式のKMLポリゴン情報</returns>
        public string ToStringAsKml(Color color)
        {
            Polygon polygon = new Polygon();
            polygon.name = "dummy";
            polygon.color = color;
            var arr = this.dict.Values.ToArray();

            /*
            if (arr.Length != 0)
            {
                for (int i = 1; i < arr.Length; i++)
                {
                    Polygon poly = new Polygon();
                    poly.name = arr[i].DataInfo.ID.ToString();
                    poly.AddToOuter(arr[i].DataInfo.Field.ToArray());
                    polygon.AddPolygon(poly);
                }
            }
             * */

            foreach (DemSet member in arr)
            {
                Polygon poly = new Polygon();
                poly.name = member.DataInfo.ID.ToString();
                poly.AddToOuter(member.DataInfo.Field.ToArray());
                StringBuilder sb = new StringBuilder(300);                      // 予め大きなメモリ容量を確保しておく
                sb.Append("File name: ").Append(member.FileName).Append(System.Environment.NewLine);
                sb.Append("Map Model: ").Append(member.DataInfo.MapModel.ToString()).Append(System.Environment.NewLine);
                sb.Append("Center position: ").Append(member.DataInfo.Field.Center.ToString());
                poly.description = sb.ToString();
                polygon.Add(poly);
            }
            return polygon.GetKmlCode();
        }
Esempio n. 45
0
 public Polygon GetBoundingPolygon()
 {
     bodyPlygn = new Polygon();
     bodyPlygn.Add(new Vector2(this.X + .25, this.Y + .25));
     bodyPlygn.Add(new Vector2(this.X + .25, this.Y - .25));
     bodyPlygn.Add(new Vector2(this.X - .25, this.Y - .25));
     bodyPlygn.Add(new Vector2(this.X - .25, this.Y + .25));
     return bodyPlygn;
 }
Esempio n. 46
0
        private void RefreshAsset(string name)
        {
            var asset = _data.GetAsset(name);

            _sw.Reset();

            foreach (var poly in asset.Polygons)
            {
                var v = new ContourVertex[poly.Count];
                for (int i = 0; i < poly.Count; i++)
                {
                    v[i].Position = new Vec3 { X = poly[i].X, Y = poly[i].Y };
                    v[i].Data = poly[i].Color;
                }
                _sw.Start();
                _tess.AddContour(v, poly.Orientation);
                _sw.Stop();
            }

            _sw.Start();
            _tess.Tessellate(_windingRule, ElementType.Polygons, _polySize, VertexCombine);
            _sw.Stop();

            var output = new PolygonSet();
            for (int i = 0; i < _tess.ElementCount; i++)
            {
                var poly = new Polygon();
                for (int j = 0; j < _polySize; j++)
                {
                    int index = _tess.Elements[i * _polySize + j];
                    if (index == -1)
                        continue;
                    var v = new PolygonPoint {
                        X = _tess.Vertices[index].Position.X,
                        Y = _tess.Vertices[index].Position.Y,
                        Color = (Color)_tess.Vertices[index].Data
                    };
                    poly.Add(v);
                }
                output.Add(poly);
            }

            statusMain.Text = string.Format("{0:F3} ms - {1} polygons (of {2} vertices) {3}", _sw.Elapsed.TotalMilliseconds, _tess.ElementCount, _polySize, _polySize == 3 ? "... triangles" : "");

            _canvas.Input = asset.Polygons;
            _canvas.Output = output;
            _canvas.Invalidate();
        }
Esempio n. 47
0
            public Polygon ToPolygon(int offset = 0)
            {
                var result = new Polygon();

                var outRadius = (offset + Radius + RingRadius)/(float) Math.Cos(2*Math.PI/CircleLineSegmentN);
                var innerRadius = Radius - RingRadius - offset;

                for (var i = 0; i <= CircleLineSegmentN; i++)
                {
                    var angle = i*2*Math.PI/CircleLineSegmentN;
                    var point = new Vector2(
                        Center.X - outRadius*(float) Math.Cos(angle), Center.Y - outRadius*(float) Math.Sin(angle));
                    result.Add(point);
                }

                for (var i = 0; i <= CircleLineSegmentN; i++)
                {
                    var angle = i*2*Math.PI/CircleLineSegmentN;
                    var point = new Vector2(
                        Center.X + innerRadius*(float) Math.Cos(angle),
                        Center.Y - innerRadius*(float) Math.Sin(angle));
                    result.Add(point);
                }

                return result;
            }
Esempio n. 48
0
        //------------------------------------------------------------------------------

        public bool AddPolygon(Polygon pg, PolyType polyType)
        {
            int len = pg.Count;
            if (len < 3) return false;
            Polygon p = new Polygon(len);
            p.Add(new IntPoint(pg[0].X, pg[0].Y));
            int j = 0;
            for (int i = 1; i < len; ++i)
            {

                Int64 maxVal;
                if (m_UseFullRange) maxVal = hiRange; else maxVal = loRange;
                if (Math.Abs(pg[i].X) > maxVal || Math.Abs(pg[i].Y) > maxVal)
                {
                    if (Math.Abs(pg[i].X) > hiRange || Math.Abs(pg[i].Y) > hiRange)
                    throw new ClipperException("Coordinate exceeds range bounds");
                  maxVal = hiRange;
                  m_UseFullRange = true;
                }

                if (PointsEqual(p[j], pg[i])) continue;
                else if (j > 0 && SlopesEqual(p[j-1], p[j], pg[i], m_UseFullRange))
                {
                    if (PointsEqual(p[j-1], pg[i])) j--;
                } else j++;
                if (j < p.Count)
                    p[j] = pg[i]; else
                    p.Add(new IntPoint(pg[i].X, pg[i].Y));
            }
            if (j < 2) return false;

            len = j+1;
            while (len > 2)
            {
                //nb: test for point equality before testing slopes ...
                if (PointsEqual(p[j], p[0])) j--;
                else if (PointsEqual(p[0], p[1]) || SlopesEqual(p[j], p[0], p[1], m_UseFullRange))
                    p[0] = p[j--];
                else if (SlopesEqual(p[j - 1], p[j], p[0], m_UseFullRange)) j--;
                else if (SlopesEqual(p[0], p[1], p[2], m_UseFullRange))
                {
                    for (int i = 2; i <= j; ++i) p[i - 1] = p[i];
                    j--;
                }
                else break;
                len--;
            }
            if (len < 3) return false;

            //create a new edge array ...
            List<TEdge> edges = new List<TEdge>(len);
            for (int i = 0; i < len; i++) edges.Add(new TEdge());
            m_edges.Add(edges);

            //convert vertices to a double-linked-list of edges and initialize ...
            edges[0].xcurr = p[0].X;
            edges[0].ycurr = p[0].Y;
            InitEdge(edges[len-1], edges[0], edges[len-2], p[len-1], polyType);
            for (int i = len-2; i > 0; --i)
            InitEdge(edges[i], edges[i+1], edges[i-1], p[i], polyType);
            InitEdge(edges[0], edges[1], edges[len-1], p[0], polyType);

            //reset xcurr & ycurr and find 'eHighest' (given the Y axis coordinates
            //increase downward so the 'highest' edge will have the smallest ytop) ...
            TEdge e = edges[0];
            TEdge eHighest = e;
            do
            {
            e.xcurr = e.xbot;
            e.ycurr = e.ybot;
            if (e.ytop < eHighest.ytop) eHighest = e;
            e = e.next;
            }
            while ( e != edges[0]);

            //make sure eHighest is positioned so the following loop works safely ...
            if (eHighest.windDelta > 0) eHighest = eHighest.next;
            if (eHighest.dx == horizontal) eHighest = eHighest.next;

            //finally insert each local minima ...
            e = eHighest;
            do {
            e = AddBoundsToLML(e);
            }
            while( e != eHighest );
            return true;
        }
		static public PolyTree FindDistictObjectBounds(ImageBuffer image)
		{
			MarchingSquaresByte marchingSquaresData = new MarchingSquaresByte(image, 5, 0);
			marchingSquaresData.CreateLineSegments();
			Polygons lineLoops = marchingSquaresData.CreateLineLoops(1);

			if (lineLoops.Count == 1)
			{
				return null;
			}

			// create a bounding polygon to clip against
			IntPoint min = new IntPoint(long.MaxValue, long.MaxValue);
			IntPoint max = new IntPoint(long.MinValue, long.MinValue);
			foreach (Polygon polygon in lineLoops)
			{
				foreach (IntPoint point in polygon)
				{
					min.X = Math.Min(point.X - 10, min.X);
					min.Y = Math.Min(point.Y - 10, min.Y);
					max.X = Math.Max(point.X + 10, max.X);
					max.Y = Math.Max(point.Y + 10, max.Y);
				}
			}

			Polygon boundingPoly = new Polygon();
			boundingPoly.Add(min);
			boundingPoly.Add(new IntPoint(min.X, max.Y));
			boundingPoly.Add(max);
			boundingPoly.Add(new IntPoint(max.X, min.Y));

			// now clip the polygons to get the inside and outside polys
			Clipper clipper = new Clipper();
			clipper.AddPaths(lineLoops, PolyType.ptSubject, true);
			clipper.AddPath(boundingPoly, PolyType.ptClip, true);

			PolyTree polyTreeForPlate = new PolyTree();
			clipper.Execute(ClipType.ctIntersection, polyTreeForPlate);

			return polyTreeForPlate;
		}
Esempio n. 50
0
 /// <summary>
 ///     Converts a list of <see cref="IntPoint" /> to a polygon.
 /// </summary>
 /// <param name="v">The int points.</param>
 /// <returns></returns>
 public static Polygon ELToPolygon(this List<IntPoint> v)
 {
     var polygon = new Polygon();
     foreach (var point in v)
     {
         polygon.Add(new Vector2(point.X, point.Y));
     }
     return polygon;
 }
Esempio n. 51
0
        /// <summary>
        ///     Moves the polygone to the set position. It dosent rotate the polygone.
        /// </summary>
        /// <param name="polygon">The polygon.</param>
        /// <param name="moveTo">The move to.</param>
        /// <returns></returns>
        public static Polygon ELMovePolygone(this Polygon polygon, Vector2 moveTo)
        {
            var p = new Polygon();

            p.Add(moveTo);

            var count = polygon.Points.Count;

            var startPoint = polygon.Points[0];

            for (var i = 1; i < count; i++)
            {
                var polygonePoint = polygon.Points[i];

                p.Add(
                    new Vector2(
                        moveTo.X + (polygonePoint.X - startPoint.X), moveTo.Y + (polygonePoint.Y - startPoint.Y)));
            }
            return p;
        }
Esempio n. 52
0
            public Polygon ToPolygon(int offset = 0)
            {
                var result = new Polygon();

                result.Add(RStart + (Width + offset)*Perpendicular - offset*Direction);
                result.Add(RStart - (Width + offset)*Perpendicular - offset*Direction);
                result.Add(REnd - (Width + offset)*Perpendicular + offset*Direction);
                result.Add(REnd + (Width + offset) * Perpendicular + offset* Direction);

                return result;
            }
Esempio n. 53
0
        /// <summary>
        ///     Rotates the polygon around the set position.
        ///     Angle is in radians.
        /// </summary>
        /// <param name="polygon">The polygon.</param>
        /// <param name="around">The around.</param>
        /// <param name="angle">The angle.</param>
        /// <returns></returns>
        public static Polygon ELRotatePolygon(this Polygon polygon, Vector2 around, float angle)
        {
            var p = new Polygon();

            foreach (var polygonePoint in polygon.Points.Select(poinit => poinit.ELRotateAroundPoint(around, angle)))
            {
                p.Add(polygonePoint);
            }
            return p;
        }
Esempio n. 54
0
        //------------------------------------------------------------------------------
        // OffsetPolygon functions ...
        //------------------------------------------------------------------------------

        internal static Polygon BuildArc(IntPoint pt, double a1, double a2, double r)
        {
            Int64 steps = Math.Max(6, (int)(Math.Sqrt(Math.Abs(r)) * Math.Abs(a2 - a1)));
            if (steps > 0x100) steps = 0x100;
            int n = (int)steps;
            Polygon result = new Polygon(n);
            double da = (a2 - a1) / (n - 1);
            double a = a1;
            for (int i = 0; i < n; ++i)
            {
                result.Add(new IntPoint(pt.X + Round(Math.Cos(a) * r), pt.Y + Round(Math.Sin(a) * r)));
                a += da;
            }
            return result;
        }
Esempio n. 55
0
        //------------------------------------------------------------------------------

        private void BuildResult(Polygons polyg)
        {
            polyg.Clear();
            polyg.Capacity = m_PolyOuts.Count;
            for (int i = 0; i < m_PolyOuts.Count; i++)
            {
                OutRec outRec = m_PolyOuts[i];
                if (outRec.pts == null) continue;
                OutPt p = outRec.pts;
                int cnt = PointCount(p);
                if (cnt < 3) continue;
                Polygon pg = new Polygon(cnt);
                for (int j = 0; j < cnt; j++)
                {
                    pg.Add(p.pt);
                    p = p.prev;
                }
                polyg.Add(pg);
            }
        }
Esempio n. 56
0
            public PolyOffsetBuilder(Polygons pts, Polygons solution, double delta, 
                JoinType jointype, double MiterLimit = 2, bool AutoFix = true)
            {
                //precondtion: solution != pts

                if (delta == 0)
                {
                    solution = pts;
                    return;
                }

                this.pts = pts;
                this.delta = delta;

                //AutoFix - fixes polygon orientation if necessary and removes 
                //duplicate vertices. Can be set false when you're sure that polygon
                //orientation is correct and that there are no duplicate vertices.
                if (AutoFix)
                {
                    int Len = pts.Count, botI = 0;
                    while (botI < Len && pts[botI].Count == 0) botI++;
                    if (botI == Len) return;

                    //botPt: used to find the lowermost (in inverted Y-axis) & leftmost point
                    //This point (on pts[botI]) must be on an outer polygon ring and if 
                    //its orientation is false (counterclockwise) then assume all polygons 
                    //need reversing ...
                    IntPoint botPt = pts[botI][0];
                    for (int i = botI; i < Len; ++i)
                    {
                        if (pts[i].Count == 0) continue;
                        if (UpdateBotPt(pts[i][0], ref botPt)) botI = i;
                        for (int j = pts[i].Count -1; j > 0; j--)
                        {
                            if (PointsEqual(pts[i][j], pts[i][j -1]))
                                pts[i].RemoveAt(j);
                            else if (UpdateBotPt(pts[i][j], ref botPt))
                                botI = i;
                        }
                    }
                    if (!Orientation(pts[botI]))
                        ReversePolygons(pts);
                }

                if (MiterLimit <= 1) MiterLimit = 1;
                double RMin = 2.0 / (MiterLimit*MiterLimit);

                normals = new List<DoublePoint>();

                double deltaSq = delta*delta;
                solution.Clear();
                solution.Capacity = pts.Count;
                for (m_i = 0; m_i < pts.Count; m_i++)
                {
                    int len = pts[m_i].Count;
                    if (len > 1 && pts[m_i][0].X == pts[m_i][len - 1].X &&
                        pts[m_i][0].Y == pts[m_i][len - 1].Y) len--;

                    if (len == 0 || (len < 3 && delta <= 0)) 
                        continue;
                    else if (len == 1)
                    {
                        Polygon arc;
                        arc = BuildArc(pts[m_i][len - 1], 0, 2 * Math.PI, delta);
                        solution.Add(arc);
                        continue;
                    }

                    //build normals ...
                    normals.Clear();
                    normals.Capacity = len;
                    for (int j = 0; j < len -1; ++j)
                        normals.Add(GetUnitNormal(pts[m_i][j], pts[m_i][j+1]));
                    normals.Add(GetUnitNormal(pts[m_i][len - 1], pts[m_i][0]));

                    currentPoly = new Polygon();
                    m_k = len - 1;
                    for (m_j = 0; m_j < len; ++m_j)
                    {
                        switch (jointype)
                        {
                            case JoinType.jtMiter:
                            {
                                m_R = 1 + (normals[m_j].X*normals[m_k].X + 
                                    normals[m_j].Y*normals[m_k].Y);
                                if (m_R >= RMin) DoMiter(); else DoSquare(MiterLimit);
                                break;
                            }
                            case JoinType.jtRound: 
                                DoRound();
                                break;
                            case JoinType.jtSquare:
                                DoSquare(1);
                                break;
                        }
                        m_k = m_j;
                    }
                    solution.Add(currentPoly);
                }

                //finally, clean up untidy corners ...
                Clipper clpr = new Clipper();
                clpr.AddPolygons(solution, PolyType.ptSubject);
                if (delta > 0)
                {
                    clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftPositive, PolyFillType.pftPositive);
                }
                else
                {
                    IntRect r = clpr.GetBounds();
                    Polygon outer = new Polygon(4);

                    outer.Add(new IntPoint(r.left - 10, r.bottom + 10));
                    outer.Add(new IntPoint(r.right + 10, r.bottom + 10));
                    outer.Add(new IntPoint(r.right + 10, r.top - 10));
                    outer.Add(new IntPoint(r.left - 10, r.top - 10));

                    clpr.AddPolygon(outer, PolyType.ptSubject);
                    clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftNegative, PolyFillType.pftNegative);
                    if (solution.Count > 0)
                    {
                        solution.RemoveAt(0);
                        for (int i = 0; i < solution.Count; i++)
                            solution[i].Reverse();
                    }
                }
            }
Esempio n. 57
0
            public Polygon ToPolygon(int offset = 0, float overrideWidth = -1)
            {
                var result = new Polygon();

                result.Add(
                    RStart + (overrideWidth > 0 ? overrideWidth : Width + offset)*Perpendicular - offset*Direction);
                result.Add(
                    RStart - (overrideWidth > 0 ? overrideWidth : Width + offset)*Perpendicular - offset*Direction);
                result.Add(
                    REnd - (overrideWidth > 0 ? overrideWidth : Width + offset)*Perpendicular + offset*Direction);
                result.Add(
                    REnd + (overrideWidth > 0 ? overrideWidth : Width + offset)*Perpendicular + offset*Direction);

                return result;
            }
Esempio n. 58
0
        //---------------------------------------------------------------------

        bool LoadFromFile(string filename, Polygons ppg, double scale = 0,
          int xOffset = 0, int yOffset = 0)
        {
            double scaling = Math.Pow(10, scale);
            ppg.Clear();
            if (!File.Exists(filename)) return false;
            StreamReader sr = new StreamReader(filename);
            if (sr == null) return false;
            string line;
            if ((line = sr.ReadLine()) == null) return false;
            int polyCnt, vertCnt;
            if (!Int32.TryParse(line, out polyCnt) || polyCnt < 0) return false;
            ppg.Capacity = polyCnt;
            for (int i = 0; i < polyCnt; i++)
            {
                if ((line = sr.ReadLine()) == null) return false;
                if (!Int32.TryParse(line, out vertCnt) || vertCnt < 0) return false;
                Polygon pg = new Polygon(vertCnt);
                ppg.Add(pg);
                for (int j = 0; j < vertCnt; j++)
                {
                    double x, y;
                    if ((line = sr.ReadLine()) == null) return false;
                    char[] delimiters = new char[] { ',', ' ' };
                    string [] vals = line.Split(delimiters);
                    if (vals.Length < 2) return false;
                    if (!double.TryParse(vals[0], out x)) return false;
                    if (!double.TryParse(vals[1], out y))
                        if (vals.Length < 2 || !double.TryParse(vals[2], out y)) return false;
                    x = x * scaling + xOffset;
                    y = y * scaling + yOffset;
                    pg.Add(new IntPoint((int)Math.Round(x), (int)Math.Round(y)));
                }
            }
            return true;
        }
Esempio n. 59
0
            public Polygon ToPolygon(int offset = 0)
            {
                var result = new Polygon();
                var outRadius = (Radius + offset)/(float) Math.Cos(2*Math.PI/CircleLineSegmentN);

                result.Add(Center);
                var Side1 = Direction.Rotated(-Angle*0.5f);

                for (var i = 0; i <= CircleLineSegmentN; i++)
                {
                    var cDirection = Side1.Rotated(i*Angle/CircleLineSegmentN).Normalized();
                    result.Add(new Vector2(Center.X + outRadius*cDirection.X, Center.Y + outRadius*cDirection.Y));
                }

                return result;
            }
Esempio n. 60
0
		public static void GenerateHexLinePaths(Polygons in_outline, ref Polygons result, int lineSpacing, int infillExtendIntoPerimeter_um, double rotationDegrees, int layerIndex)
		{
			int extraRotationAngle = 0;
			if (in_outline.Count > 0)
			{
				Polygons outlines = in_outline.Offset(infillExtendIntoPerimeter_um);
				if (outlines.Count > 0)
				{
					int perIncrementOffset = (int)(lineSpacing * Math.Sqrt(3) / 2 + .5);
					PointMatrix matrix = new PointMatrix(-(rotationDegrees + extraRotationAngle)); // we are rotating the part so we rotate by the negative so the lines go the way we expect

					outlines.ApplyMatrix(matrix);

					Aabb boundary = new Aabb(outlines);

					boundary.min.X = ((boundary.min.X / lineSpacing) - 1) * lineSpacing;
					boundary.min.Y = ((boundary.min.Y / perIncrementOffset) - 2) * perIncrementOffset;
					boundary.max.X += lineSpacing;
					boundary.max.Y += perIncrementOffset;
					Polygons unclipedPatern = new Polygons();

					foreach (IntPoint startPoint in StartPositionIterator(boundary, lineSpacing, layerIndex))
					{
						Polygon attachedLine = new Polygon();
						foreach (IntPoint center in IncrementPositionIterator(startPoint, boundary, lineSpacing, layerIndex))
						{
							// what we are adding are the little plusses that define the points
							//        | top
							//        |
							//        /\ center
							//   left/  \ right
							//
							IntPoint left = center + new IntPoint(-lineSpacing / 2, -perIncrementOffset / 3);
							IntPoint right = center + new IntPoint(lineSpacing / 2, -perIncrementOffset / 3);
							IntPoint top = center + new IntPoint(0, perIncrementOffset * 2 / 3);

							switch (layerIndex % 3)
							{
								case 0: // left to right
									attachedLine.Add(left); attachedLine.Add(center);
									attachedLine.Add(center); attachedLine.Add(right);
									unclipedPatern.Add(new Polygon() { top, center });
									break;

								case 1: // left to top
									attachedLine.Add(left); attachedLine.Add(center);
									attachedLine.Add(center); attachedLine.Add(top);
									unclipedPatern.Add(new Polygon() { center, right });
									break;

								case 2: // top to right
									attachedLine.Add(top); attachedLine.Add(center);
									attachedLine.Add(center); attachedLine.Add(right);
									unclipedPatern.Add(new Polygon() { left, center });
									break;
							}
						}
						if (attachedLine.Count > 0)
						{
							unclipedPatern.Add(attachedLine);
						}
					}

					PolyTree ret = new PolyTree();
					Clipper clipper = new Clipper();
					clipper.AddPaths(unclipedPatern, PolyType.ptSubject, false);
					clipper.AddPaths(outlines, PolyType.ptClip, true);
					clipper.Execute(ClipType.ctIntersection, ret, PolyFillType.pftPositive, PolyFillType.pftEvenOdd);

					Polygons newSegments = Clipper.OpenPathsFromPolyTree(ret);
					PointMatrix inversematrix = new PointMatrix((rotationDegrees + extraRotationAngle));
					newSegments.ApplyMatrix(inversematrix);

					result.AddRange(newSegments);
				}
			}
		}