コード例 #1
0
        internal static IEnumerable <Ray> AddingMoreRays(Edge[] edges, double[] dir)
        {
            //For the case that two objects are nonadacently blocking each other but the rays shot from the corner
            //vertices cannot detect them, we will add more vertices here to solve this issue.
            var sections = edges.Select(edge => new[] { new Vertex(edge.From.Position), new Vertex(edge.To.Position) }).ToList();
            var newRays  = new List <Ray>();
            var counter  = 0;

            while (counter < 1)
            {
                counter++;
                var section2 = new List <Vertex[]>();
                foreach (var sec in sections)
                {
                    var aP       = sec[0];
                    var bP       = sec[1];
                    var midPoint =
                        new Vertex(new[]
                    {
                        (aP.Position[0] + bP.Position[0]) / 2.0, (aP.Position[1] + bP.Position[1]) / 2.0,
                        (aP.Position[2] + bP.Position[2]) / 2.0
                    });
                    newRays.Add(new Ray(midPoint, dir));
                    section2.Add(new[] { aP, midPoint });
                    section2.Add(new[] { midPoint, bP });
                }
                sections = new List <Vertex[]>(section2);
            }
            return(newRays);
        }
コード例 #2
0
        internal static Vertex[][] SortedEdgesOfTriangle(PolygonalFace triangle)
        {
            // the first one is the shortest edge, the last one is the longest
            var sorted = new Vertex[3][];
            var dic    = new Dictionary <double, Vertex[]>
            {
                {
                    DistanceBetweenTwoVertices(triangle.Vertices[0].Position, triangle.Vertices[1].Position),
                    new[] { triangle.Vertices[0], triangle.Vertices[1] }
                }
            };
            var dis1 = DistanceBetweenTwoVertices(triangle.Vertices[0].Position, triangle.Vertices[2].Position);
            var dis2 = DistanceBetweenTwoVertices(triangle.Vertices[1].Position, triangle.Vertices[2].Position);

            if (dic.ContainsKey(dis1))
            {
                dis1 += 1e-6;
            }
            dic.Add(dis1, new[] { triangle.Vertices[0], triangle.Vertices[2] });
            if (dic.ContainsKey(dis2))
            {
                dis2 += 1e-6;
            }
            dic.Add(dis2, new[] { triangle.Vertices[1], triangle.Vertices[2] });
            var sortedKey = dic.Keys.ToList();

            sortedKey.Sort();
            sorted[0] = dic[sortedKey[0]];
            sorted[1] = dic[sortedKey[1]];
            sorted[2] = dic[sortedKey[2]];
            return(sorted);
        }
コード例 #3
0
        private static double[] ShortestEdgeMidPointOfTriangle(PolygonalFace triangle)
        {
            var shortestEdge = new Vertex[2];
            var shortestDist = double.PositiveInfinity;

            for (var i = 0; i < triangle.Vertices.Count - 1; i++)
            {
                for (var j = i + 1; j < triangle.Vertices.Count; j++)
                {
                    var dis = GeometryFunctions.DistanceBetweenTwoVertices(triangle.Vertices[i].Position,
                                                                           triangle.Vertices[j].Position);
                    if (dis >= shortestDist)
                    {
                        continue;
                    }
                    shortestDist = dis;
                    shortestEdge = new[] { triangle.Vertices[i], triangle.Vertices[j] };
                }
            }
            return((shortestEdge[0].Position.add(shortestEdge[1].Position)).divide(2.0));
        }
コード例 #4
0
        public static bool RayIntersectsWithFace(Ray ray, PolygonalFace face)
        {
            if (Math.Abs(ray.Direction.dotProduct(face.Normal)) < Assembly_Planner.Constants.NearlyParallelFace)
            {
                return(false);
            }
            var inPlaneVerts       = new Vertex[3];
            var negativeDirCounter = 3;

            for (var i = 0; i < 3; i++)
            {
                var vectFromRayToFacePt = face.Vertices[i].Position.subtract(ray.Position); // Interesting
                var dxtoPlane           = ray.Direction.dotProduct(vectFromRayToFacePt);
                if (dxtoPlane < 0)
                {
                    negativeDirCounter--;
                }
                if (negativeDirCounter == 0)
                {
                    return(false);
                }
                inPlaneVerts[i] = new Vertex(face.Vertices[i].Position.add(StarMath.multiply(-dxtoPlane, ray.Direction)));
            }
            if (inPlaneVerts.Min(v => v.Position[0]) > ray.Position[0])
            {
                return(false);
            }
            if (inPlaneVerts.Max(v => v.Position[0]) < ray.Position[0])
            {
                return(false);
            }
            if (inPlaneVerts.Min(v => v.Position[1]) > ray.Position[1])
            {
                return(false);
            }
            if (inPlaneVerts.Max(v => v.Position[1]) < ray.Position[1])
            {
                return(false);
            }
            if (inPlaneVerts.Min(v => v.Position[2]) > ray.Position[2])
            {
                return(false);
            }
            if (inPlaneVerts.Max(v => v.Position[2]) < ray.Position[2])
            {
                return(false);
            }
            if (inPlaneVerts.GetLength(0) > 3)
            {
                return(true);
            }
            var crossProductsToCorners = new List <double[]>();

            for (int i = 0; i < 3; i++)
            {
                var j = (i == 2) ? 0 : i + 1;
                var crossProductsFrom_i_To_j =
                    inPlaneVerts[i].Position.subtract(ray.Position)
                    .normalizeInPlace(3)
                    .crossProduct(inPlaneVerts[j].Position.subtract(ray.Position).normalizeInPlace(3));
                if (crossProductsFrom_i_To_j.norm2(true) < Assembly_Planner.Constants.NearlyOnLine)
                {
                    return(false);
                }
                crossProductsToCorners.Add(crossProductsFrom_i_To_j);
            }
            for (int i = 0; i < 3; i++)
            {
                var j = (i == 2) ? 0 : i + 1;
                if (crossProductsToCorners[i].dotProduct(crossProductsToCorners[j], 3) <= 0)
                {
                    return(false);                                                                         // 0.15
                }
            }
            return(true);
        }
コード例 #5
0
        private static bool newApproachBoundingBox(double[] v, double[] bB, double[] mB)
        {
            var mV1       = new Vertex(new[] { mB[0], mB[2], mB[4] });
            var mV2       = new Vertex(new[] { mB[0], mB[3], mB[4] });
            var mV3       = new Vertex(new[] { mB[1], mB[3], mB[4] });
            var mV4       = new Vertex(new[] { mB[1], mB[2], mB[4] });
            var mV5       = new Vertex(new[] { mB[0], mB[2], mB[5] });
            var mV6       = new Vertex(new[] { mB[0], mB[3], mB[5] });
            var mV7       = new Vertex(new[] { mB[1], mB[3], mB[5] });
            var mV8       = new Vertex(new[] { mB[1], mB[2], mB[5] });
            var movingVer = new List <Vertex> {
                mV1, mV2, mV3, mV4, mV5, mV6, mV7, mV8
            };
            var mE1       = new Edge(mV1, mV2, true);
            var mE2       = new Edge(mV1, mV4, true);
            var mE3       = new Edge(mV1, mV5, true);
            var mE4       = new Edge(mV2, mV3, true);
            var mE5       = new Edge(mV2, mV6, true);
            var mE6       = new Edge(mV7, mV6, true);
            var mE7       = new Edge(mV7, mV3, true);
            var mE8       = new Edge(mV7, mV8, true);
            var mE9       = new Edge(mV5, mV6, true);
            var mE10      = new Edge(mV5, mV8, true);
            var mE11      = new Edge(mV4, mV3, true);
            var mE12      = new Edge(mV4, mV8, true);
            var movingEdg = new List <Edge> {
                mE1, mE2, mE3, mE4, mE5, mE6, mE7, mE8, mE9, mE10, mE11, mE12
            };

            var bV1         = new Vertex(new[] { bB[0], bB[2], bB[4] });
            var bV2         = new Vertex(new[] { bB[0], bB[3], bB[4] });
            var bV3         = new Vertex(new[] { bB[1], bB[3], bB[4] });
            var bV4         = new Vertex(new[] { bB[1], bB[2], bB[4] });
            var bV5         = new Vertex(new[] { bB[0], bB[2], bB[5] });
            var bV6         = new Vertex(new[] { bB[0], bB[3], bB[5] });
            var bV7         = new Vertex(new[] { bB[1], bB[3], bB[5] });
            var bV8         = new Vertex(new[] { bB[1], bB[2], bB[5] });
            var blockingVer = new List <Vertex> {
                bV1, bV2, bV3, bV4, bV5, bV6, bV7, bV8
            };
            var bE1         = new Edge(bV1, bV2, true);
            var bE2         = new Edge(bV1, bV4, true);
            var bE3         = new Edge(bV1, bV5, true);
            var bE4         = new Edge(bV2, bV3, true);
            var bE5         = new Edge(bV2, bV6, true);
            var bE6         = new Edge(bV7, bV6, true);
            var bE7         = new Edge(bV7, bV3, true);
            var bE8         = new Edge(bV7, bV8, true);
            var bE9         = new Edge(bV5, bV6, true);
            var bE10        = new Edge(bV5, bV8, true);
            var bE11        = new Edge(bV4, bV3, true);
            var bE12        = new Edge(bV4, bV8, true);
            var blockingEdg = new List <Edge> {
                bE1, bE2, bE3, bE4, bE5, bE6, bE7, bE8, bE9, bE10, bE11, bE12
            };

            var movingProj   = _3Dto2D.Get2DProjectionPoints(movingVer, v);
            var blockingProj = _3Dto2D.Get2DProjectionPoints(blockingVer, v);
            var moving2D     = new _3Dto2D {
                Points = movingProj, Edges = _3Dto2D.Get2DEdges2(movingEdg, movingVer, movingProj)
            };
            var blocking2D = new _3Dto2D {
                Points = blockingProj, Edges = _3Dto2D.Get2DEdges2(blockingEdg, blockingVer, movingProj)
            };

            return(moving2D.Edges.Any(movEdge => blocking2D.Edges.Any(refEdge => NonadjacentBlockingDeterminationPro.DoIntersect(movEdge, refEdge))));
        }
コード例 #6
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="Point" /> class.
 /// </summary>
 /// <param name="vertex">The vertex.</param>
 /// <param name="x">The x.</param>
 /// <param name="y">The y.</param>
 public Point(Vertex vertex, double x, double y)
     : this(vertex, x, y, 0.0)
 {
 }
コード例 #7
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="Point" /> class.
 /// </summary>
 /// <param name="v">The v.</param>
 public Point(Vertex v)
     : this(v, v.Position[0], v.Position[1], 0.0)
 {
 }