2D射线距离检测——圆与线段

最新推荐文章于 2023-05-10 20:06:19 发布
最新推荐文章于 2023-05-10 20:06:19 发布
阅读量464 收藏 1
点赞数
分类专栏： 几何 2D 射线检测 文章标签： 几何学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35424507/article/details/112334690
版权
几何 同时被 3 个专栏收录
1 篇文章 0 订阅
订阅专栏
2D
1 篇文章 0 订阅
订阅专栏
射线检测
1 篇文章 0 订阅
订阅专栏 
本算法实现2D下的射线检测，可以检测射线段到障碍物的距离。

// An highlighted block
        /// <summary>
        /// 计算线段(M,P)与圆(C,R)的交点距离目标点(M)最近的点的距离
        /// </summary>
        /// <param name="P">线段另一顶点</param>
        /// <param name="C">圆心</param>
        /// <param name="R">圆半径</param>
        /// <param name="M">目标点</param>
        /// <returns></returns>
        private float GetLineTOCirclePoint(Vector M, Vector P, Vector C, float R)
        {
            float _K;             //直线斜率
            float _B;             //直线截距
            float _A = C.X;       //圆心X坐标     (X-_A)^2+(Y-_C)^2=R^2
            float _C = C.Y;       //圆心Y坐标
            float X1 = 0.0f;       //两点坐标
            float X2 = 0.0f;
            float Y1 = 0.0f;
            float Y2 = 0.0f;
            float Dis = Vector.Distance(new Vector(M.X, M.Y), new Vector(P.X, P.Y));       //获取视野距离

            if (P.Y == M.Y)             //情况一   斜率为0时也就是垂直Y轴
            {
                if (P.Y > C.Y + R || P.Y < C.Y - R) //如果没有交点则直接返回
                    return Dis;
                else if (P.Y == C.Y + R || P.Y == C.Y - R)        //如果有一个交点
                {
                    Vector m = new Vector(C.X, P.Y);
                    float d = Vector.Distance(M, m);
                    if (Vector.AngleBetween(new Vector(m.X - M.X, m.Y - M.Y), new Vector(P.X - M.X, P.Y - M.Y)) < Math.PI / 2)
                        return d > Dis ? Dis : d;
                }
                else                            //有两个交点
                {
                    Y1 = M.Y;
                    Y2 = M.Y;
                    X1 = _A + (float)Math.Sqrt(R * R - (M.Y - _C) * (M.Y - _C));
                    X2 = _A - (float)Math.Sqrt(R * R - (M.Y - _C) * (M.Y - _C));
                }
            }
            else if (M.X == P.X)       //情况二   斜率不存在也就是垂直X轴
            {
                if (P.X > C.X + R || P.X < C.X - R) //如果没有交点则直接返回
                    return Dis;
                else if (P.X == C.X + R || P.X == C.X - R)        //如果有一个交点
                {
                    Vector m = new Vector(P.X, C.Y);
                    float d = Vector.Distance(M, m);
                    if (Vector.AngleBetween(new Vector(m.X - M.X, m.Y - M.Y), new Vector(P.X - M.X, P.Y - M.Y)) < Math.PI / 2)
                        return d > Dis ? Dis : d;
                }
                else                            //有两个交点
                {
                    X1 = M.X;
                    X2 = M.X;
                    Y1 = _C + (float)Math.Sqrt(R * R - (M.X - _A) * (M.X - _A));
                    Y2 = _C - (float)Math.Sqrt(R * R - (M.X - _A) * (M.X - _A));
                }
            }
            else
            {
                //情况三   斜率存在不为0
                _K = (P.Y - M.Y) / (P.X - M.X); //计算斜率
                _B = M.Y - (M.X * _K);            //由y=kx-x1k+y1计算得出 b=y1-x1*k

                float B11 = (2 * _K * (_B - _C) - 2 * _A);   //计算一元二次方程的b系数
                float A11 = (_K * _K + 1);                   //计算b
                float C11 = ((_B - _C) * (_B - _C) - R * R + _A * _A); //计算c
                if (B11 * B11 - 4 * A11 * C11 < 0)          //无解表示没有交点，所以距离为0
                    return Dis;
                else if (B11 * B11 - 4 * A11 * C11 == 0)     //只有一个交点
                {
                    float X = -(B11) / (2 * A11);         //韦达定理
                    float Y = _K * X + _B;              //计算Y坐标
                    Vector m = new Vector(X, Y);
                    float d = Vector.Distance(M, m);
                    if (Vector.AngleBetween(new Vector(m.X - M.X, m.Y - M.Y), new Vector(P.X - M.X, P.Y - M.Y)) < Math.PI / 2)
                        return d > Dis ? Dis : d;
                }
                else
                {
                    //求根公式
                    X1 = (-B11 + (float)Math.Sqrt(B11 * B11 - 4 * A11 * C11)) / (2 * A11);
                    X2 = (-B11 - (float)Math.Sqrt(B11 * B11 - 4 * A11 * C11)) / (2 * A11);
                    Y1 = _K * X1 + _B;
                    Y2 = _K * X2 + _B;
                    
                }
            }

            float Dis1 = Vector.Distance(new Vector(M.X, M.Y), new Vector(X1, Y1));
            float Dis2 = Vector.Distance(new Vector(M.X, M.Y), new Vector(X2, Y2));
            //如果两个点都在圆内
            if (Vector.Distance(new Vector(P.X, P.Y), new Vector(C.X, C.Y)) < R &&
                Vector.Distance(new Vector(M.X, M.Y), new Vector(C.X, C.Y)) < R)
            {
                return Dis;
            }
            else if (Vector.Distance(new Vector(P.X, P.Y), new Vector(C.X, C.Y)) < R &&
               Vector.Distance(new Vector(M.X, M.Y), new Vector(C.X, C.Y)) > R)
            {
                //当另一点在圆内，起始点在圆外
                return Dis1 > Dis2 ? Dis2 : Dis1;
            }
            else if (Vector.Distance(new Vector(P.X, P.Y), new Vector(C.X, C.Y)) > R &&
              Vector.Distance(new Vector(M.X, M.Y), new Vector(C.X, C.Y)) < R)
            {
                //当起始点在圆内，另一点在圆外
                Vector r1 = new Vector(X1 - M.X, Y1 - M.Y);
                Vector r2 = new Vector(P.X - M.X, P.Y - M.Y);
                if (Vector.AngleBetween(r1, r2) < Math.PI / 2)
                {
                    //如果起始点到第一个交点的向量与起始点与另一点所构成的角度为锐角，则当前交点为最终交点
                    return Dis1;
                }
                else
                {
                    return Dis2;
                }
                    
            }
            else if (Vector.Distance(new Vector(M.X, M.Y), new Vector(C.X, C.Y)) == R &&
               Vector.Distance(new Vector(P.X, P.Y), new Vector(C.X, C.Y)) != R)
            {
                //如果起始原点在圆上,另一点不再圆上
                Vector m = new Vector(P.X - M.X, P.Y - M.Y);
                float ARC = m.GetAngle_in_RCS();
                if (ARC >= 180 && ARC <= 360)
                {
                    return Dis;
                }
                else
                    return 0.0f;
            }
            else if (Vector.Distance(new Vector(M.X, M.Y), new Vector(C.X, C.Y)) != R &&
               Vector.Distance(new Vector(P.X, P.Y), new Vector(C.X, C.Y)) == R)
            {
                //如果另一原点在圆上,起始点不再圆上
                Vector r1 = new Vector(X1 - M.X, Y1 - M.Y);
                Vector r2 = new Vector(P.X - M.X, P.Y - M.Y);
                if (Vector.AngleBetween(r1, r2) < Math.PI / 2)
                {
                    //如果起始点到第一个交点的向量与起始点与另一点所构成的角度为锐角，则当前交点为最终交点
                    return Dis1;
                }
                else
                {
                    return Dis2;
                }
            }
            else if (Vector.Distance(new Vector(M.X, M.Y), new Vector(C.X, C.Y)) == R &&
              Vector.Distance(new Vector(P.X, P.Y), new Vector(C.X, C.Y)) == R)
            {
                //如果两个点都在圆上,则距离为0
                return 0.0f;
            }
            else
            {
                //如果两点都在圆外
                //如果另一原点在圆上,起始点不再圆上
                Vector r1 = new Vector(X1 - M.X, Y1 - M.Y);
                Vector r2 = new Vector(P.X - M.X, P.Y - M.Y);
                Vector r3 = new Vector(X2 - M.X, Y2 - M.Y);
                float ARC1 = Vector.AngleBetween(r1, r2);
                float ARC2 = Vector.AngleBetween(r3, r2);
                if (ARC1 < Math.PI / 2 && ARC1 > -Math.PI / 2 && ARC2 > -Math.PI / 2 &&
                    ARC2 < Math.PI / 2)
                {
                    //如果起始点到第一个交点的向量与起始点与另一点所构成的角度为锐角，则当前交点为最终交点
                    if (Dis1 > Dis2)
                    {
                        if (Dis2 > Dis)
                        {
                            return Dis;
                        }
                        else
                        {
                            return Dis2;
                        }
                    }
                    else
                    {
                        if (Dis1 > Dis)
                        {
                            return Dis;
                        }
                        else
                        {
                            return Dis1;
                        }
                    }
                }
                else
                {
                    return Dis;
                }
            }
        }
        /// <summary>
        /// 射线对线段检测
        /// </summary>
        /// <param name="M">起点坐标</param>
        /// <param name="P">端点坐标</param>
        /// <param name="V1">线段的一个坐标</param>
        /// <param name="V2">线段另一个坐标</param>
        private float ABenCountCD(Vector M, Vector P, Vector V1, Vector V2)
        {


            float Dis = Vector.Distance(M, P);
            //情况一   斜率为0
            if (P.Y == M.Y)
            {
                //如果另一条直线也是斜率为0，即两者相互平行
                if (V1.Y == V2.Y)
                {
                    return Dis;       //直接返回当前长度
                }
                else if (V1.X == V2.X)
                {
                    float X1 = V1.X;
                    float Y1 = M.Y;
                    float Dis1 = Vector.Distance(M, new Vector(X1, Y1));
                    return Dis1 > Dis ? Dis : Dis1;
                }
                else
                {
                    //计算交点
                    float K = (V1.Y - V2.Y) / (V1.X - V2.X);        //计算V1 V2斜率
                    float X = V1.X + (1 / K) * (M.Y - V1.Y);       //x=x1+(1/k)(y-y1)
                    float Y = M.Y;
                    float d1 = Math.Abs(X - V1.X);
                    float d2 = Math.Abs(X - V2.X);
                    float d3 = Math.Abs(V1.X - V2.X);
                    //if(d1+d2==d3&&)
                    if (!(((X > M.X) && (X > P.X)) || ((X < M.X) && (X < P.X))) &&
                            (X != M.X) || (Y != M.Y))   //如果交点在左边或在右边，则没有交点
                    {
                        return Vector.Distance(M, new Vector(X, Y));
                    }
                    else
                        return Dis;
                }

            }
            //情况二   斜率不存在
            else if (P.X == M.X)
            {
                //如果另一条直线也是斜率不存在，即两者相互平行
                if (V1.X == V2.X)
                {
                    return Dis;       //直接返回当前长度
                }
                else if (V1.Y == V2.Y)
                {
                    float X1 = P.X;
                    float Y1 = V1.Y;
                    float Dis1 = Vector.Distance(M, new Vector(X1, Y1));
                    return Dis1 > Dis ? Dis : Dis1;
                }
                else
                {
                    //计算交点
                    float K = (V1.Y - V2.Y) / (V1.X - V2.X);
                    float B = V1.Y - K * V1.X;       //y=kx-kx1+y1
                    float X = M.X;
                    float Y = M.X * K + B;
                    if (!(((Y > M.Y) && (Y > P.Y)) || ((Y < M.Y) && (Y < P.Y))) &&
                             (X != M.X) || (Y != M.Y))   //如果交点在上边或在下边，则没有交点
                    {
                        return Vector.Distance(M, new Vector(X, Y));
                    }
                    else
                        return Dis;
                }

            }else{
                float X;
                float Y;
                float K1 = (M.Y - P.Y) / (M.X - P.X);
                float B1 = M.Y - K1 * M.X;
                //如果另一条线段斜率不存在
                if (V1.X == V2.X)
                {
                    X = V1.X;
                    Y = K1 * X + B1;
                }else if(V1.Y == V2.Y)
                {
                    X = (1 / K1) * (V1.Y - B1);
                    Y = V1.Y;
                }
                else
                {
                    float K2 = (V1.Y - V2.Y) / (V1.X - V2.X);
                    float B2 = V1.Y - K2 * V1.X;       //y=kx-kx1+y1
                    //如果两个直线斜率相等，说明平行
                    if (K1 == K2)
                        return Dis;
                    X = (B2 - B1) / (K1 - K2);
                    Y = K1 * X + B1;
                }
                Vector G = new Vector(X, Y);
                float Dis1 = Vector.Distance(M, G);
                Vector v1 = new Vector(P.X - M.X, P.Y - M.Y);
                Vector v2 = new Vector(X - M.X, Y - M.Y);
                float arc = Vector.AngleBetween(v1, v2);
                if (arc > Math.PI / 2 && G != M)     //如果交点与与射线方向相反
                {
                    return Dis;
                }
                else if (arc >= 0 && arc < Math.PI / 2 && G != M)     //如果交点与与射线方向相同
                {
                    ///如果交点在四边形内
                    if (!(((X > M.X) && (X > P.X)) || ((X < M.X) && (X < P.X))) &&
                            !(((Y > M.Y) && (Y > P.Y)) || ((Y < M.Y) && (Y < P.Y))) &&
                            !(((X > V1.X) && (X > V2.X)) || ((X < V1.X) && (X < V2.X))) &&
                            !(((Y > V1.Y) && (Y > V2.Y)) || ((Y < V1.Y) && (Y < V2.Y))))
                    {
                        return Dis1;
                    }
                    else
                        return Dis;
                }
                else
                {
                    return Dis;
                }
            }
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WindowsFormsApp3
{
    class Vector
    {
        //向量的X,Y值
        private float _X;
        private float _Y;

        public float X { get => _X; set => _X = value; }
        public float Y { get => _Y; set => _Y = value; }

        /// <summary>
        /// 向量的模
        /// </summary>
        public float Magnitude { get => (float)Math.Sqrt(_X * _X + _Y * _Y); }
        /// <summary>
        /// 单位方向向量
        /// </summary>
        public Vector UnitVector { get => new Vector(_X / (float)Math.Sqrt(_X * _X + _Y * _Y), _Y / (float)Math.Sqrt(_X * _X + _Y * _Y)); }
        /// <summary>
        /// 通过X,Y创建向量
        /// </summary>
        /// <param name="X"></param>
        /// <param name="Y"></param>
        public Vector(float X, float Y)
        {
            _Y = Y;
            _X = X;
        }
        /// <summary>
        /// 创建零向量
        /// </summary>
        public Vector()
        {
            _X = 0f;
            _Y = 0f;
        }
        /// <summary>
        /// 求向量
        /// </summary>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <returns></returns>
        public static Vector operator -(Vector v1, Vector v2)
        {
            Vector d = new Vector(v1.X - v2.X, v1.Y - v2.Y);
            return d;
        }
        /// <summary>
        /// 向量相加
        /// </summary>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <returns></returns>
        public static Vector operator +(Vector v1, Vector v2)
        {
            Vector d = new Vector(v1.X + v2.X, v1.Y + v2.Y);
            return d;
        }
        /// <summary>
        /// 向量乘以一个数
        /// </summary>
        /// <param name="v"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        public static Vector operator *(Vector v, float k)
        {
            Vector d = new Vector(k * v.X, k * v.Y);
            return d;

        }
        /// <summary>
        /// 向量乘以一个数
        /// </summary>
        /// <param name="k"></param>
        /// <param name="v"></param>
        /// <returns></returns>
        public static Vector operator *(float k, Vector v)
        {
            Vector d = new Vector(k * v.X, k * v.Y);
            return d;

        }
        /// <summary>
        /// 向量除以一个数
        /// </summary>
        /// <param name="v"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        public static Vector operator /(Vector v, float k)
        {
            Vector d = new Vector(v.X / k, v.Y / k);
            d.X = v.X / k;
            d.Y = v.Y / k;
            return d;
        }

        /// <summary>
        /// 两向量所在点的距离
        /// </summary>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <returns></returns>
        public static float Distance(Vector v1, Vector v2)
        {
            return (float)Math.Sqrt(Math.Pow((v1.X - v2.X), 2) + Math.Pow((v1.Y - v2.Y), 2));
        }
        /// <summary>
        /// 两点之间的距离
        /// </summary>
        /// <param name="x1"></param>
        /// <param name="y1"></param>
        /// <param name="x2"></param>
        /// <param name="y2"></param>
        /// <returns></returns>
        public static float PDistance(float x1, float y1, float x2, float y2)
        {
            return (float)Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
        }
        public static float Dot(Vector V1, Vector V2)
        {
            return V1.X * V2.X + V1.Y * V2.Y;
        }

        /// <summary>
        /// AngleBetween - the angle between 2 vectors
        /// </summary>
        /// <returns>
        /// Returns the the angle in degrees between vector1 and vector2
        /// </returns>
        /// <param name="vector1"> The first Vector </param>
        /// <param name="vector2"> The second Vector </param>
        public static float AngleBetween(Vector vector1, Vector vector2)
        {
            float sin = vector1.X * vector2.Y - vector2.X * vector1.Y;
            float cos = vector1.X * vector2.X + vector1.Y * vector2.Y;

            return (float)Math.Abs(Math.Atan2(sin, cos));
        }

        /// <summary>
        /// 获得向量在直角坐标系的角度
        /// </summary>
        /// <param name="V1"></param>
        /// <returns></returns>
        public float GetAngle_in_RCS()
        {
            float VP = 0;
            if (X > 0f && Y >= 0f)
            {
                float DA = 1 * X;
                float DL = new Vector(0, 1).Magnitude;
                float GS = Magnitude;
                float An = (float)Math.Acos(DA / (DL * GS));
                VP = An / (float)Math.PI * 180.0f;
            }
            else if (X <= 0f && Y > 0f)
            {
                float DA = 1 * Y;
                float DL = new Vector(0, 1).Magnitude;
                float GS = Magnitude;
                float An = (float)Math.Acos(DA / (DL * GS));
                VP = 90.0f + An / (float)Math.PI * 180.0f;
            }
            else if (X < 0f && Y <= 0f)
            {
                float DA = -1 * X;
                float DL = new Vector(-1, 0).Magnitude;
                float GS = Magnitude;
                float An = (float)Math.Acos(DA / (DL * GS));
                VP = 180.0f + An / (float)Math.PI * 180.0f;
            }
            else if (X >= 0f && Y < 0f)
            {
                float DA = -1 * Y;
                float DL = new Vector(0, -1).Magnitude;
                float GS = Magnitude;
                float An = (float)Math.Acos(DA / (DL * GS));
                VP = 270.0f + An / (float)Math.PI * 180.0f;
            }
            else if (X == 0f && Y == 0f)
            {
                VP = 0.0f;
            }
            return VP;
        }
    }
}

效果图

LikeMoe
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【项目代码】2D图像映射并计算对应的3D的距离.rar
08-30
人们之所以能够看到深度，是因为，来自三维世界的不同视角。本程序尝试从一个2D图像映射并计算对应的3D的距离.rar
14.图像透视——距离的测验，齐次坐标（Homogeneous Coordinate），透视投影（Perspective Projection），投影实战_2
Tom的专栏
03-27 2705
目录 距离的测验 齐次坐标（Homogeneous Coordinate） 透视投影（Perspective Projection） 投影实战 学前概念 透视投影法(perspective projection method)一种投影法。所谓透视，即穿过透明体观察物体。在人与物体之间，设立一个透明的平面，称作画面(即投影面)，人眼的位置称视点(即投影中心COP)，由视点至物体上各个点连...
Box2d源码学习<十一>GJK之距离的实现
cg0206的专栏
12-21 4747
本系列博客是由扭曲45原创，欢迎转载，转载时注明出处，http://blog.csdn.net/cg0206/article/details/8352227 Box2d中距离是指两个形状最近点之间的距离，主要用于形状的碰撞检测，通过GJK算法实现，在GJK中又使用voroni区域算法和重心坐标来完成的。在Box2d最终调用b2Ditance方法来求得距离。使用此方法需要将两个形状转换成一个b2D
几何向量：二维射线与直线相交
羊羊的博客
01-10 1107
      刚好用到二维射线与直线相交，顺便记录一下。       问题如下：       二维平面中存在射线bp和直线ac，计算bp与ac的交点p1，计算原理很简单，通过直线方程组求解即可，如下：       将射线bp和直线ac的方程参数k1、k2、d1、d2计算出
双目相机标定精度测量：匹配点对（2D）的距离（3D）与实际距离的差
TiffanyXYf的博客
04-22 4564
使用边长为25mm的12*9的标准棋盘格标定相机 #include<opencv2/opencv.hpp> #include<iostream> using namespace cv; using namespace std; ///双目相机，y方向存在误差 Mat cameraMatrixL = (Mat_<float>(3, 3) << 23...
Box2D中的距离计算
captsl的博客
10-01 648
GDC 2010 Session：Physics for Programmers，Erin Catto：Computing DistanceErin Catto是二维物理库Box2D的开发者内容：1）点和基本形状的距离计算；2）点和复杂几何体的距离计算（GJK）；3）复杂几何体之间的距离计算2D世界中距离的计算的几个重要的点： 点-线段、点-三角形的距离计算依赖于：barycentric coord
unity2D 射线检测
CrazyApp的博客
11-27 4323
在网上搜了好多关于2D射线检测的，点击屏幕，利用射线检测点击到的物体是否是我想要的物体（物体上添加了2d碰撞器）。 在网上搜到的都是一些这样的答案： RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero); if (hit.collider...
2D项目中射线检测(RaycastHit2D)的使用
hajima_sian的博客
05-10 645
是检测识别触发的layer，需要在最开始用LayerMask 命名一个layer，并且在unity中挂载上已设置的layer,例如图中的"Ground Layer"中选择已设置的layer"Ground"。其中若是在2D项目中则Vector3改为Vector2，RaycastHit 命名 = Raycast(是射线长度，是一个float定义的数。为射线方向，大多可用为。为射线偏移，具体应用为。
unity3d 2d 射线检测
microsoftMSDNNET的博客
09-01 8540
Physics2D.LinecastNonAlloc 直线投射不分配内存 C# ⇒ static int LinecastNonAlloc(Vector2 start, Vector2 end, RaycastHit2D[] results, int layerMask = DefaultRaycastLayers, float minDepth = -Mathf.Infinity, float
Unity 解决子弹穿模问题，2D射线检测
qq_52746379的博客
12-12 833
/子弹一帧走的距离作为射线长度。//从记录的位置向子弹飞行的方向发出射线。//计算当前位置与记录位置的距离。//大于0说明子弹移动了。子弹射速过快导致的穿模问题（2D）1
Cocos2d-x学习笔记——完全掌握JSAPI与游戏项目开发
07-23
资源名称：Cocos2d-x学习笔记——完全掌握JS API与游戏项目开发资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
2D绘图画的带圆形端点的环形进度条——emWin
02-26
这是一个用emWin的2D绘图函数画的一个带圆形端点的环形进度条，压缩包里只有一个.c文件，是在模拟器上跑的。
什么是2D和3D检测？_2D和3D检测_
10-03
介绍了2D与3D检测的原理及应用，对于工业开发及各个行业都能用到！
opengl下2d绘图——线段kock曲线实现
05-11
opengl下2d绘图——线段kock曲线实现 仅有一个cpp文件，编译请配置好opengl环境 程序中按右方向键即可对线段进行kock曲线处理，最多到达6次迭代（屏幕就那么大，再高纯属浪费）
PFC2D PFC5.0版本 巴西试验圆盘 生成试样代码
01-07
PFC2D PFC5.0版本巴西试验圆盘试样生成代码 只是生成圆盘试样的代码 可供初学者参考学习
2D基本图形的Sign Distance Function (SDF)详解（下）
热门推荐
T-Jhon的博客
05-22 1万+
符号距离函数（sign distance function），简称SDF，在光线追踪领域有很重要的应用。本文分析了shadertoy网站上inigo quilez大佬的关于2D基本几何图形的SDF函数，为今后的计算机图形学路程铺垫几何学基础。
从正视图中测量长度和角度
我是100分的博客
06-14 2958
目录 前言 距离公式：已知两点A、B的坐标值： 余弦定理：已知三个边长： 编程语言的选择 具体算法分析 步骤 界面 操作步骤 其他要求 根据上面的步骤开始码代码 HTML框架 CSS样式 JavaScript的编写 定义变量 选择并显示图片 获取坐标和画圆的功能函数 Shift快捷键 鼠标事件 结语 前言 作为一个机械行业的人，总是会充满好奇，总会想知道一个物...
射线到线段的距离
west_gege的博客
12-02 474
/* 射线与线段求交点 射线源点在线段上的情况不考虑*/ #include <iostream> using namespace std; /* ray[0][0]为射线源点 */ double ray[2][2] = { {0,23}, {0,39} }; double edge[2][2] = { {-2,0}, {7,0} }; double x, y;//记录交点 b...
计算二维空间点到线段距离
LaineGates的专栏
05-10 1037
计算二维空间点到线距离，如下图，求p1到线段p2p3的距离 按行列式计算三角形面积可得 Δ=0.5∗∣1x1y11x2y21x3y3∣=0.5∗∣1x1y10x2−x1y2−y10x3−x1y3−y1∣=0.5∗[(x2−x1)∗(y3−y1)−（y2−y1)∗(x3−x1)] \Delta = 0.5*\begin{vmatrix} 1 & x_1 & y_1 \\ 1 & x_2 & y_2 \\ 1 & x_3 & y_3 \\ \end{vmatri
2d射线检测和圆形检测
最新发布
07-28
对于2D射线检测，一种常用的方法是射线与边界框（bounding box）的相交检测。首先，你需要定义射线的起点和方向向量。然后，对于场景中的每个边界框，可以使用边界框的边界线段与射线进行相交测试。如果射线与某个边界框相交，那么你可以进一步检测射线是否与边界框内的物体相交。 圆形检测在2D中可以通过计算射线与圆形的相交点来实现。首先，你需要定义射线的起点和方向向量，以及圆心的位置和半径。然后，可以使用射线方程和圆的方程来求解相交点。如果存在相交点，并且相交点在射线的正方向上（即与射线起点相比更远），那么射线与圆形相交。 这些是基本的方法，实际应用中可能还需要考虑更复杂的情况，如多个物体的相交检测、物体旋转等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值