Esempio n. 1
0
        public static bool PointIsInside(BoxPosition bPos, Vector3D dim, Vector2D pt)
        {
            var bbox = bPos.BBox(dim);

            return(pt.X >= bbox.PtMin.X && pt.X <= bbox.PtMax.X &&
                   pt.Y >= bbox.PtMin.Y && pt.Y <= bbox.PtMax.Y);
        }
Esempio n. 2
0
        public static bool BoxIsInside(BoxPosition bPos, Vector3D dim, Vector2D ptMin, Vector2D ptMax)
        {
            var bbox = bPos.BBox(dim);

            return(ptMin.X <= bbox.PtMin.X && ptMin.Y <= bbox.PtMin.Y &&
                   bbox.PtMax.X <= ptMax.X && bbox.PtMax.Y <= ptMax.Y);
        }
Esempio n. 3
0
        public static bool BoxCanMoveInside(BoxPosition bPos, Vector3D dim, Vector2D ptMin, Vector2D ptMax, HalfAxis.HAxis axis)
        {
            var bbox = bPos.BBox(dim);

            switch (axis)
            {
            case HalfAxis.HAxis.AXIS_X_N: return(bbox.PtMin.X > ptMin.X);

            case HalfAxis.HAxis.AXIS_X_P: return(bbox.PtMax.X < ptMax.X);

            case HalfAxis.HAxis.AXIS_Y_N: return(bbox.PtMin.Y > ptMin.Y);

            case HalfAxis.HAxis.AXIS_Y_P: return(bbox.PtMax.Y < ptMax.Y);

            default: return(false);
            }
        }
Esempio n. 4
0
        public static bool HaveIntersection(BoxPosition bPos1, Vector3D dim1, BoxPosition bPos2, Vector3D dim2)
        {
            var      bbox1 = bPos1.BBox(dim1);
            var      bbox2 = bPos2.BBox(dim2);
            Vector3D pt1 = bbox1.PtMin, pt2 = bbox1.PtMax;
            Vector3D pt3 = bbox2.PtMin, pt4 = bbox2.PtMax;

            Vector3D pt5 = new Vector3D(Math.Max(pt1.X, pt3.X), Math.Max(pt1.Y, pt3.Y), Math.Max(pt1.Z, pt3.Z));
            Vector3D pt6 = new Vector3D(Math.Min(pt2.X, pt4.X), Math.Min(pt2.Y, pt4.Y), Math.Min(pt2.Z, pt4.Z));

            // no intersections ?
            if ((pt5.X - pt6.X > -EPSILON) ||
                (pt5.Y - pt6.Y > -EPSILON) ||
                (pt5.Z - pt6.Z > -EPSILON))
            {
                return(false);
            }
            else
            {
                return(true);
            }
        }
Esempio n. 5
0
        public static bool MinDistance(
            BoxPosition bPos1, Vector3D dim1
            , BoxPosition bPos2, Vector3D dim2
            , HalfAxis.HAxis axis
            , ref double distance)
        {
            var      bbox1 = bPos1.BBox(dim1);
            var      bbox2 = bPos2.BBox(dim2);
            Vector3D pt1 = bbox1.PtMin, pt2 = bbox1.PtMax;
            Vector3D pt3 = bbox2.PtMin, pt4 = bbox2.PtMax;

            Vector3D pt5 = new Vector3D(Math.Max(pt1.X, pt3.X), Math.Max(pt1.Y, pt3.Y), Math.Max(pt1.Z, pt3.Z));
            Vector3D pt6 = new Vector3D(Math.Min(pt2.X, pt4.X), Math.Min(pt2.Y, pt4.Y), Math.Min(pt2.Z, pt4.Z));

            if (axis == HalfAxis.HAxis.AXIS_X_N || axis == HalfAxis.HAxis.AXIS_X_P)
            {
                if ((pt5.Y - pt6.Y > -EPSILON) || (pt5.Z - pt6.Z > -EPSILON))
                {
                    return(false);
                }
                if (axis == HalfAxis.HAxis.AXIS_X_N)
                {
                    distance = pt1.X - pt4.X;
                    return(distance >= -EPSILON);
                }
                else if (axis == HalfAxis.HAxis.AXIS_X_P)
                {
                    distance = pt3.X - pt2.X;
                    return(distance >= -EPSILON);
                }
            }
            else if (axis == HalfAxis.HAxis.AXIS_Y_N || axis == HalfAxis.HAxis.AXIS_Y_P)
            {
                if ((pt5.X - pt6.X > -EPSILON) || (pt5.Z - pt6.Z > -EPSILON))
                {
                    return(false);
                }
                if (axis == HalfAxis.HAxis.AXIS_Y_N)
                {
                    distance = pt1.Y - pt4.Y;
                    return(distance >= -EPSILON);
                }
                else if (axis == HalfAxis.HAxis.AXIS_Y_P)
                {
                    distance = pt3.Y - pt2.Y;
                    return(distance >= -EPSILON);
                }
            }
            else if (axis == HalfAxis.HAxis.AXIS_Z_N || axis == HalfAxis.HAxis.AXIS_Z_P)
            {
                if ((pt5.X - pt6.X > -EPSILON) || (pt5.Y - pt6.Z > -EPSILON))
                {
                    return(false);
                }
                if (axis == HalfAxis.HAxis.AXIS_Z_N)
                {
                    distance = pt1.Z - pt4.Z;
                    return(distance >= -EPSILON);
                }
                else if (axis == HalfAxis.HAxis.AXIS_Z_P)
                {
                    distance = pt3.Z - pt2.Z;
                    return(distance >= -EPSILON);
                }
            }
            distance = 0.0;
            return(false);
        }