精华内容
下载资源
问答
  • 碰撞检测,故名思议,两个元素在运动的过程中是否有接触。接下来,我们从简单到复杂的碰撞一一解析其中的算法。编码使用JavaScript。ps:下列图形均指实心图形点与点的碰撞这个太简单了,不多说,就是当坐标一致的...

    碰撞检测,故名思议,两个元素在运动的过程中是否有接触。

    接下来,我们从简单到复杂的碰撞一一解析其中的算法。编码使用JavaScript。

    ps:下列图形均指实心图形

    点与点的碰撞

    这个太简单了,不多说,就是当坐标一致的时候就是碰撞.

    //A(x1,y1)B(x2,y2)

    if(x1===x2 && y1===y2){

    //碰撞

    }else{

    //无碰撞

    }

    点与圆的碰撞

    点A(x1,y1) 圆心(x2,y2) 半径 r

    bVJI3q?w=297&h=127

    我们可以看出红色的点与圆心的距离若小于半径,那么点与圆便发生碰撞。

    根据勾股定理可以得出距离 d = √((x1-x2)^2 + (y1-y2)^2)

    //点A(x1,y1) 圆心(x2,y2) 半径 r

    if(Math.sqrt(Math.pow(x1 - x2,2) + Math.pow(y1-y2,2)) <= r){

    //碰撞

    }else{

    //无碰撞

    }

    圆与圆的碰撞

    圆A(x1,y1) 半径r1 ; 圆B(x2,y2) 半径 r2

    bVJI6Y?w=332&h=194

    同样根据勾股定理可以得出距离 d = √((x1-x2)^2 + (y1-y2)^2)

    if(Math.sqrt(Math.pow(x1 - x2,2) + Math.pow(y1-y2,2)) <= (r1 + r2)){

    //碰撞

    }else{

    //无碰撞

    }

    点与矩形的碰撞

    首先矩形的表达方式有:

    已知四个角的一个顶点(x2,y2)与宽w高h

    已知几何中心点(x2,y2)与宽w高h

    左上角与右下角两个顶点(x2,y2)、(x3,y3)

    //1. 已知四个角的一个顶点(x2,y2)与宽w高h,以左上角为例

    if(x1>=x2 && x1<=(x2+w) || (y1>=y2 && y1<=(y2+h))){

    //碰撞

    }else{

    //无碰撞

    }

    //2. 已知几何中心点(x2,y2)与宽w高h

    if(x1 >= (x2-w/2) && x1 <= (x2+w/2) || (y1 >= (y2-h/2) && y1 <= (y2 + h/2))){

    //碰撞

    }else{

    //无碰撞

    }

    //3. 左上角与右下角两个顶点(x2,y2)、(x3,y3)

    if(x1 >= x2 && x1 <= x3 || (y1 >= y2 && y1 <= y3)){

    //碰撞

    }else{

    //无碰撞

    }

    矩形与矩形的碰撞

    bVJJae?w=314&h=175

    无论矩形是由什么数据表示。我们都可以求出几何中心A点与B点的坐标,与矩形宽w1 w2;高h1 h2。

    假设求出A(x1,y1) B(x2,y2)

    if(Math.abs(x2-x1) <= (w1+w2)/2 && Math.abs(y2-y1) <= (h1+h2)){

    //碰撞

    }else{

    //无碰撞

    }

    下篇继续讲解当圆与矩形碰撞,等更复杂的碰撞检测

    展开全文
  • 同步和碰撞永远的神确实好麻烦啊, ui写了半小时, 算法验证五分钟... 还好vue出活快... 看来需要快点熟悉cocos了3d2d效果随机生成不同位置和大小的box, 任意拖动一个box, 在拖动的过程中检测是否和其他box相交 主要...

    同步和碰撞永远的神

    确实好麻烦啊, ui写了半小时, 算法验证五分钟... 还好vue出活快... 看来需要快点熟悉cocos了

    3d

    2d

    效果

    随机生成不同位置和大小的box,  任意拖动一个box, 在拖动的过程中检测是否和其他box相交

    654e2f58055d1edeed7c52bc61da6764.gif

    主要思想, 将二维AABB检测转换为两个矩形的各两条边的交叉问题

    46ce30520056d18cd4ad9c62f8167cbe.png

    由于一般情况下, 世界坐标系和元素坐标系都是直接按照像素来的, 所以我们可以通过简单的对比就能得到结果

    网页中一般左上角为原点, x向右, y向下

    核心代码

    // 检查两条线段是否有交点

    // 保证顺序 x1<=y1 x2<=y2

    const checkLine = (aMin, aMax, bMin, bMax) => {

    if (aMax < bMin) return false

    if (aMin > bMax) return false

    return true

    }

    // 检查两个box是否相交

    const checkBox = (box1, box2) => {

    return (

    checkLine(box1.x, box1.x + box1.width, box2.x, box2.x + box2.width) &&

    checkLine(box1.y, box1.y + box1.height, box2.y, box2.y + box2.height)

    )

    }

    /*

    检查是否碰撞, 返回碰撞矩形的id

    list中已经去除了 移动的box

    */

    export const check = (item, list) => {

    const ans = []

    for (const box of list) {

    if (checkBox(item, box)) ans.push(box.id)

    }

    return ans

    }

    展开全文
  • 圆与矩形的碰撞检测通常在svg或者canvas中我们会这样表示一个圆: 圆心(cx,cy),半径r;表示矩形:中心点坐标(0,0) width="250" height="250" x=-width/2 y=-height/2 平移(rectX,rectY)并以几何中心旋转任意角度展示...

    这篇我们将讲解圆与矩形的碰撞;

    圆与矩形的碰撞检测

    通常在svg或者canvas中我们会这样表示一个圆: 圆心(cx,cy),半径r;

    表示矩形:中心点坐标(0,0) width="250" height="250" x=-width/2 y=-height/2 平移(rectX,rectY)并以几何中心旋转任意角度

    展示的矩形即几何中心点(rectX,rectY)width="250" height="250";

    你可能会问,如果矩形被旋转了怎么办?

    我们可以在矩形的中心点建立一个新的坐标系统。以宽平行方向为x轴方向,以高平行方向为Y轴方向

    bVJXNi?w=380&h=250

    得到在新的坐标系统中圆的坐标:(cx-rectX,cy-rectY)

    在新坐标系统中计算圆中心点的投影即圆中心点的坐标。那么我们发现,

    bVJXR3?w=275&h=262

    图中L=r/Math.sqrt(r);

    我们可以看到当两边投影 x 方向 小于等于width+L && y方向小于等于heigth/2 或者 x方向小于等于width/2 && y方向上小于等于 height+L的时候即碰撞

    //(cx,cy) 矩形 width height 中心点(rectX,rectY)

    var L=r/Math.sqrt(r);

    if((Math.abs(cx-rectX)<= width/2+L && Math.abs(cy-rectY)<= height/2)||(Math.abs(cx-rectX)<= width/2 && Math.abs(cy-rectY)<= height/2+L)){

    //碰撞

    }else{

    //无碰撞

    }

    展开全文
  • 该代码用于研究随着机器人数量和尺寸的增加以及每次碰撞产生的延迟时间的变化,机器人碰撞的数量和频率。
  • matlab开发-fast3碰撞检测gjkalgorithm。凸三维物体的碰撞检测算法。
  • T = COLDETECT(TRI1, TRI2, TRANS1, TRANS2) 返回涉及两个对象之间碰撞的第一个转换的索引。 这两个对象由 TRI1 和 TRI2 中指定的三角形定义。 矩阵 TRI1 和 TRI2 有九列,定义了三角形的顶点(x1、y1、z1、x2、y2...
  • GJK (Gilbert-Johnson-Keerthi) 碰撞检测算法在 MATLAB 中的实现。 GJK.m 函数获取形状顶点数据并返回两个形状是否穿透。 仅适用于凸形物体! MAIN_example.m 对两个多面体进行动画处理,并在两者相互碰撞时停止。
  • LUSET控制和碰撞检测ROS C ++ / Gazebo项目 作者:尼古拉斯·帕洛莫(Nicholas Palomo) 电子邮件: 领英 的GitHub: 这是C ++中的ROS实现,带有Gazebo仿真,用于瑞士ETH Zurich的LUSET项目的软件方面。 该项目替代...
  • MatLab编写的基本碰撞检测模拟器。 该程序模拟了N个粒子和矩形边界之间的碰撞。 基本模拟器分为4部分: 通过UNIFORM GRID算法的碰撞检测功能 确定碰撞时间的功能 时间步长和解决冲突的功能 将模拟渲染为电影文件...
  • 在仿真时发现物体运动路径上有其他物体时,会直接穿透,这个环境可以设置碰撞检测的仿真嘛?
  • 这是一个用于 OPCODE 的 Matlab 包装器,它是一个碰撞检测或用于三角形 3D 网格的光线投射库。 OPCODE 使用几个不同的 aabb 树来存储网格,这是其中一棵树的一个非常简单的包装器。 操作码的好处在于它允许变形网格...
  • 将末端姿态代入机械臂逆运动模型中,求出八组逆解角度,将八组逆解角度代入机械臂正运动学方程,判断机械臂与障碍物是否发生碰撞,进行碰撞检测,以实现机械臂避障路径规划。
  • 二维碰撞检测程序,含源代码,里面包含两个可执行exe程序,分别是六边形的碰撞检测,圆的碰撞检测,所有逻辑都模拟现实实现。 算法包含:碰撞检测,法向计算,反射速度计算,运动轨迹计算等。 如不有疑问请联系QQ...
  • 在这个版本中,粒子在方形或圆形边界框中弹跳,并发生完美的弹性碰撞。 粒子有质量和半径。 这是一个非常有教育意义的脚本,可以学习有关粒子物理学的知识。 您可以设置标志并将轨迹保存在文件日志中。
  • ist的matlab代码碰撞检测应用 可以在此处下载CHAI3D库。 如何: 注意:在以下文本对象中,是指向cMesh的指针。 构建IST包括以下头文件: # include < ist/InnerSphereTree.h > # include < collisions/...
  • Baidu Apollo代码解析之碰撞检测

    千次阅读 2019-05-30 10:11:44
    在Lattice Planner中,需要对1D横纵向轨迹结合(combine)后形成的2D轨迹做限制检测(速度、加速度等)和碰撞检测碰撞检测由CollisionChecker类完成,文件路径:apollo\modules\planning\constraint_checker\...

    在Lattice Planner中,需要对1D横纵向轨迹结合(combine)后形成的2D轨迹做限制检测(速度、加速度等)和碰撞检测。碰撞检测由CollisionChecker类完成,文件路径:apollo\modules\planning\constraint_checker\collision_checker.cc。碰撞检测主要是遍历每个障碍物的预测轨迹的每个轨迹点、遍历自车规划轨迹的每个轨迹点,分别构造轮廓box(近似bounding box),查看box是否重叠(overlap)。原理比较简单,粗暴贴代码。

    /**
         * @brief Constructor
         * @param obstacles obstacles information from Prediction module
         * @param ego_vehicle_s s position of ego vehicle in Frenet Coordinate System(s-l, s-d)
         * @param ego_vehicle_d d position of ego vehicle in Frenet
         * @param discretized_reference_line the sampling points on reference line, the reference line in discretized form
         * @param ptr_reference_line_info
         * @param ptr_path_time_graph s-t graph
         */
    CollisionChecker::CollisionChecker(
        const std::vector<const Obstacle*>& obstacles, const double ego_vehicle_s,
        const double ego_vehicle_d,
        const std::vector<PathPoint>& discretized_reference_line,
        const ReferenceLineInfo* ptr_reference_line_info,
        const std::shared_ptr<PathTimeGraph>& ptr_path_time_graph) {
      ptr_reference_line_info_ = ptr_reference_line_info;
      ptr_path_time_graph_ = ptr_path_time_graph;
      BuildPredictedEnvironment(obstacles, ego_vehicle_s, ego_vehicle_d,
                                discretized_reference_line);
    }
    
        /**
         * @brief Check if there are overlaps between obstacles' predicted trajectories and ego vehicle's planning trajectory
         * @param obstacles
         * @param ego_trajectory
         * @param ego_length the length of ego vehicle
         * @param ego_width
         * @param ego_back_edge_to_center not sure. I guess it's the gap between the ego vehicle's back and backshaft's center
         * @return true if collision
         */
    bool CollisionChecker::InCollision(
        const std::vector<const Obstacle*>& obstacles,
        const DiscretizedTrajectory& ego_trajectory, const double ego_length,
        const double ego_width, const double ego_back_edge_to_center) {
      //traverse every point on ego vehicle's trajectory
      for (size_t i = 0; i < ego_trajectory.NumOfPoints(); ++i) {
        const auto& ego_point =
            ego_trajectory.TrajectoryPointAt(static_cast<std::uint32_t>(i));
        const auto relative_time = ego_point.relative_time();
        const auto ego_theta = ego_point.path_point().theta();
        //construct a bounding box whose center is the point on trajectory with theta
        Box2d ego_box({ego_point.path_point().x(), ego_point.path_point().y()},
                      ego_theta, ego_length, ego_width);
    
        // correct the inconsistency of reference point and center point
        // TODO(all): move the logic before constructing the ego_box
        double shift_distance = ego_length / 2.0 - ego_back_edge_to_center;
        Vec2d shift_vec(shift_distance * std::cos(ego_theta),
                        shift_distance * std::sin(ego_theta));
        ego_box.Shift(shift_vec);
    
        std::vector<Box2d> obstacle_boxes;
        //traverse every obstacle
        for (const auto obstacle : obstacles) {
          //get obstacle's trajectory point according to the time
          auto obtacle_point = obstacle->GetPointAtTime(relative_time);
          //construct a bounding box according to obstacle's length and width got from Perception module
          Box2d obstacle_box = obstacle->GetBoundingBox(obtacle_point);
          //if there is overlap between obstacle and ego vehicle, return
          if (ego_box.HasOverlap(obstacle_box)) {
            return true;
          }
        }
      }
      return false;
    }
    
        /**
         * @brief Check if there are overlaps between obstacles and ego vehicle according to the predicted obstacles environment
         * @pre BuildPredictedEnvironment() is called before this, so that predicted_bounding_rectangles_ is ready
         * @param discretized_trajectory ego vehicle's trajectory sampling points
         * @return true if collision
         */
    bool CollisionChecker::InCollision(
        const DiscretizedTrajectory& discretized_trajectory) {
      CHECK_LE(discretized_trajectory.NumOfPoints(),
               predicted_bounding_rectangles_.size());
      const auto& vehicle_config =
          common::VehicleConfigHelper::Instance()->GetConfig();
      double ego_length = vehicle_config.vehicle_param().length();
      double ego_width = vehicle_config.vehicle_param().width();
      //traverse every point on ego vehicle's trajectory
      for (size_t i = 0; i < discretized_trajectory.NumOfPoints(); ++i) {
        const auto& trajectory_point =
            discretized_trajectory.TrajectoryPointAt(static_cast<std::uint32_t>(i));
        double ego_theta = trajectory_point.path_point().theta();
        //construct a bounding box according to ego vehicle's length and width got from config
        Box2d ego_box(
            {trajectory_point.path_point().x(), trajectory_point.path_point().y()},
            ego_theta, ego_length, ego_width);
        double shift_distance =
            ego_length / 2.0 - vehicle_config.vehicle_param().back_edge_to_center();
        Vec2d shift_vec{shift_distance * std::cos(ego_theta),
                        shift_distance * std::sin(ego_theta)};
        ego_box.Shift(shift_vec);
        //traverse every obstacle's bounding box stored in predicted_bounding_rectangles_
        for (const auto& obstacle_box : predicted_bounding_rectangles_[i]) {
          if (ego_box.HasOverlap(obstacle_box)) {
            return true;
          }
        }
      }
      return false;
    }
    
        /**
         * @brief choose obstacles of interest and build bounding boxes for every obstacle's every trajectory point
         * @param obstacles
         * @param ego_vehicle_s
         * @param ego_vehicle_d
         * @param discretized_reference_line
         */
    void CollisionChecker::BuildPredictedEnvironment(
        const std::vector<const Obstacle*>& obstacles, const double ego_vehicle_s,
        const double ego_vehicle_d,
        const std::vector<PathPoint>& discretized_reference_line) {
      CHECK(predicted_bounding_rectangles_.empty());
    
      // If the ego vehicle is in lane,
      // then, ignore all obstacles from the same lane behind of the ego vehicle.
      bool ego_vehicle_in_lane = IsEgoVehicleInLane(ego_vehicle_s, ego_vehicle_d);
      std::vector<const Obstacle*> obstacles_considered;
      for (const Obstacle* obstacle : obstacles) {
        if (obstacle->IsVirtual()) {
          continue;
        }
        if (ego_vehicle_in_lane &&
            (IsObstacleBehindEgoVehicle(obstacle, ego_vehicle_s,
                                        discretized_reference_line) ||
             !ptr_path_time_graph_->IsObstacleInGraph(obstacle->Id()))) {
          continue;
        }
    
        obstacles_considered.push_back(obstacle);
      }
    
      double relative_time = 0.0;
      while (relative_time < FLAGS_trajectory_time_length) {
        std::vector<Box2d> predicted_env;
        for (const Obstacle* obstacle : obstacles_considered) {
          // If an obstacle has no trajectory, it is considered as static.
          // Obstacle::GetPointAtTime has handled this case.
          TrajectoryPoint point = obstacle->GetPointAtTime(relative_time);
          //construct a bounding box according to obstacle's length and width got from Perception module
          Box2d box = obstacle->GetBoundingBox(point);
          //consider the safe distance
          box.LongitudinalExtend(2.0 * FLAGS_lon_collision_buffer);
          box.LateralExtend(2.0 * FLAGS_lat_collision_buffer);
          predicted_env.push_back(std::move(box));
        }
        predicted_bounding_rectangles_.push_back(std::move(predicted_env));
        relative_time += FLAGS_trajectory_time_resolution;
      }
    }
    
    bool CollisionChecker::IsEgoVehicleInLane(const double ego_vehicle_s,
                                              const double ego_vehicle_d) {
      double left_width = FLAGS_default_reference_line_width * 0.5;
      double right_width = FLAGS_default_reference_line_width * 0.5;
      ptr_reference_line_info_->reference_line().GetLaneWidth(
          ego_vehicle_s, &left_width, &right_width);
      return ego_vehicle_d < left_width && ego_vehicle_d > -right_width;
    }
    
    bool CollisionChecker::IsObstacleBehindEgoVehicle(
        const Obstacle* obstacle, const double ego_vehicle_s,
        const std::vector<PathPoint>& discretized_reference_line) {
      double half_lane_width = FLAGS_default_reference_line_width * 0.5;
      TrajectoryPoint point = obstacle->GetPointAtTime(0.0);
      auto obstacle_reference_line_position = PathMatcher::GetPathFrenetCoordinate(
          discretized_reference_line, point.path_point().x(),
          point.path_point().y());
    
      if (obstacle_reference_line_position.first < ego_vehicle_s &&
          std::fabs(obstacle_reference_line_position.second) < half_lane_width) {
        ADEBUG << "Ignore obstacle [" << obstacle->Id() << "]";
        return true;
      }
      return false;
    }

    考虑到感知模块对不同类型障碍物的检测准确度可能不同(检测私家车可能比检测货车、卡车更准),预测模块对于不同时刻轨迹点的预测准确度也不同(越往后越不准),可以设计合理的轮廓尺寸的extend程度,自适应调整。

    应该有一个指标量化碰撞检测的置信度,可以根据此置信度制定对应的行为决策,比如适当减速、提示信息等。但是该置信度会受考察的轨迹时间长度影响较大。

    展开全文
  • OgreOpcode碰撞检测使用概述,里面包含OgreOpcode的使用方法,以及详细解释。个人整理的。
  • matlab开发-碰撞后车辆导线的凹痕检测。此程序将在碰撞发生后找到车辆上的凹痕。
  • 受限空间机械臂碰撞检测算法,王占鹏,宋荆洲,为了解决受限空间机械臂与其所处环境边界发生碰撞问题,并且结合包围盒的碰撞检测,提出了一种考虑边界条件的基于包围盒的碰撞检
  • 详细分析比较了基于包围盒的碰撞检测算法中的轴向包围盒法、方向包围盒法、离散方向多面体法的检测原理和检测效率,并改进了轴向包围盒碰撞检测算法,提出利用简化包围盒边缘节点实现碰撞检测的新设想,其可行性已被...
  • 圆与线段碰撞检测

    千次阅读 2014-05-06 21:39:55
    圆与线段的碰撞检测算法利用了一个向量在另一个向量的投影的原理。 假设向量p1p为v1, 向量p1p2为v2,p0为v1在v2上的投影点,则p1p0为v1在v2上的投影。 两个向量点乘v1.dot(v2) = v1.length() * v2.length() * cos...
  • 碰撞检测是机器人轨迹规划、计算机仿真等领域的重要问题之一 ,本文在前人的基础上提出一种工业机器人关节间碰撞检测算法。
  • 基于混合猴群算法的凸多面体碰撞检测
  • 详细介绍了最新的碰撞检测技术,其中有轴向包围盒,方向包围盒等包围盒技术
  • 从知网上下载的一篇论文,相当有用,主要讲述了碰撞检测中包围盒算法的分析
  • 包围盒----碰撞检测

    千次阅读 2019-10-08 13:36:00
    制造几何仿真中的碰撞检测通常视为针对刚体对象间的碰撞检测,这样的话可以把非刚体即软体的建模和变形算法对碰撞检测的影响减少到最小。常见成熟的基于包围盒的碰撞检测(box intersection test)算法如: 1)沿...
  • openGL做的小球三维碰撞检测程序

    热门讨论 2009-07-12 11:29:32
    如对代码有任何疑问,请联系我qq739198750,我上线看见后会立即回复,谢谢! 正确的三维碰撞检测程序(含源代码),欢迎下载,运行环境vs2005以上,运行前请确保你的openGl相关已配置好
  • 高级碰撞检测技术

    千次阅读 2016-07-06 15:28:32
    高级碰撞检测技术      自从计算机游戏出现以来,程序员就不断地想办法来更精确地模拟现实世界。就拿乒乓游戏为例子(译者:Pong—被誉为电子游戏的祖先,有幸见过一次:),能见到祖先做的游戏感觉真是爽啊...
  • 碰撞检测之分离轴定理算法讲解

    万次阅读 多人点赞 2017-02-05 00:24:20
    在阅读了大量有关碰撞检测的资料,并参看了一些代码示例后,这个方法总算被我领悟了。 为了帮助其他那些不精通数学的开发者,我想我应该写下这一篇能快速阐明这个算法工作原理的简短介绍。我还在下文引入了一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 659
精华内容 263
关键字:

碰撞检测matlab

matlab 订阅