Esempio n. 1
0
        protected bool is_on_edge(int eid, Vector3d v)
        {
            Index2i   ev  = Target.GetEdgeV(eid);
            Segment3d seg = new Segment3d(Target.GetVertex(ev.a), Target.GetVertex(ev.b));

            return(seg.DistanceSquared(v) < VertexSnapTol * VertexSnapTol);
        }
Esempio n. 2
0
        protected int on_edge(ref Triangle3d tri, ref Vector3d v)
        {
            var s01 = new Segment3d(tri.V0, tri.V1);

            if (s01.DistanceSquared(v) < VertexSnapTol * VertexSnapTol)
            {
                return(0);
            }

            var s12 = new Segment3d(tri.V1, tri.V2);

            if (s12.DistanceSquared(v) < VertexSnapTol * VertexSnapTol)
            {
                return(1);
            }

            var s20 = new Segment3d(tri.V2, tri.V0);

            if (s20.DistanceSquared(v) < VertexSnapTol * VertexSnapTol)
            {
                return(2);
            }

            return(-1);
        }
Esempio n. 3
0
        void find_min_distance(ref Vector3d pt, ref double min_dist, ref int min_dist_seg, ref double min_dist_segt, int bi, int iLayerStart, int iLayer)
        {
            // hit polygon layer, check segments
            if (iLayer == 0)
            {
                int       seg_i = 2 * bi;
                Segment3d seg_a = Curve.GetSegment(seg_i);
                double    segt;
                double    segdist = seg_a.DistanceSquared(pt, out segt);
                if (segdist <= min_dist)
                {
                    min_dist      = segdist;
                    min_dist_seg  = seg_i;
                    min_dist_segt = segt;
                }
                if ((seg_i + 1) < Curve.SegmentCount)
                {
                    Segment3d seg_b = Curve.GetSegment(seg_i + 1);
                    segdist = seg_b.DistanceSquared(pt, out segt);
                    if (segdist <= min_dist)
                    {
                        min_dist      = segdist;
                        min_dist_seg  = seg_i + 1;
                        min_dist_segt = segt;
                    }
                }

                return;
            }

            // test both boxes and recurse
            int    prev_layer = iLayer - 1;
            int    prev_count = layer_counts[prev_layer];
            int    prev_start = iLayerStart - prev_count;
            int    prev_a     = prev_start + 2 * bi;
            double dist       = boxes[prev_a].DistanceSquared(pt);

            if (dist <= min_dist)
            {
                find_min_distance(ref pt, ref min_dist, ref min_dist_seg, ref min_dist_segt, 2 * bi, prev_start, prev_layer);
            }
            if ((2 * bi + 1) >= prev_count)
            {
                return;
            }

            int    prev_b = prev_a + 1;
            double dist2  = boxes[prev_b].DistanceSquared(pt);

            if (dist2 <= min_dist)
            {
                find_min_distance(ref pt, ref min_dist, ref min_dist_seg, ref min_dist_segt, 2 * bi + 1, prev_start, prev_layer);
            }
        }
Esempio n. 4
0
        int find_nearest_edge(DMesh3 mesh, Vector3d v, HashSet <int> vertices)
        {
            int    near_eid = DMesh3.InvalidID;
            double nearSqr  = VertexSnapTol * VertexSnapTol;

            foreach (int eid in mesh.BoundaryEdgeIndices())
            {
                Index2i ev = mesh.GetEdgeV(eid);
                if (vertices.Contains(ev.a) == false || vertices.Contains(ev.b) == false)
                {
                    continue;
                }
                Segment3d seg  = new Segment3d(mesh.GetVertex(ev.a), mesh.GetVertex(ev.b));
                double    dSqr = seg.DistanceSquared(v);
                if (dSqr < nearSqr)
                {
                    near_eid = eid;
                    nearSqr  = dSqr;
                }
            }
            return(near_eid);
        }
Esempio n. 5
0
        public double Value(ref Vector3d pt)
        {
            double d = Math.Sqrt(Segment.DistanceSquared(pt));

            return(d - Radius);
        }