OpenCV图像处理实现的虚拟16车摆阵列算法

最新推荐文章于 2022-03-28 21:27:22 发布
置顶 最新推荐文章于 2022-03-28 21:27:22 发布
阅读量489 收藏 2
点赞数 1
分类专栏： opencv 文章标签： 图像处理 opencv 摄像头 算法 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29606255/article/details/77602158
版权

为了模拟小车通过接收指令，自主摆阵列的情形，本算法通过摄像头获取各个小车的位置，通过OpenCV图像处理分析出各个小车的距离，并设置一个安全距离，当小车之间的距离小于安全距离时，小车之间就拉开距离，否则，各个小车仍按照阵列各自的位置目标前进。
下面是算法的具体实现。

#include <iostream>
#include<cstdlib>
#include<ctime>
#include "opencv2/objdetect/objdetect.hpp"
#include<fstream>
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <cv.h>    
#include <highgui.h>    
#include <stdio.h>
using namespace cv;
using namespace std;
const int SafeLong = 40;
const int SafeDistance = 20;
const int GoalDistance = 5;
const int TotalNum = 2;
class point
{
public:
    double x, y;
};
point dstlocation[16];
point dirlong[SafeLong+1];
class Car
{
public:

    point location;
    point dstlocation;
    int num;
    int dir;
    int state;
    //int bumpdir[5];
    Car()
    {
        state = 1;
        dir = 0;
        location.x = 0;
        location.y = 0;
        dstlocation.x = 0;
        dstlocation.y = 0;
    }
    double dist(const point &a)
    {
        return sqrt(pow(location.x - a.x, 2) + pow(location.y - a.y, 2));
    }
    void update()
    {}
    void check()
    {}
    void up()
    {}
    void down()
    {}
    void left()
    {}
    void right()
    {}
};

//const int CarWidth = 10;
//const int CarHeight = 10;
//int CarBumpNum = 0;
//int CarBump[16];
Car car[TotalNum];
void start()
{
    for (int i = 0; i < TotalNum; i++)
    {
        if (abs(car[i].location.x-car[i].dstlocation.x)<abs(car[i].location.y-car[i].dstlocation.y)
            && abs(car[i].location.x - car[i].dstlocation.x)>GoalDistance
            )
        {
            if (car[i].location.x < car[i].dstlocation.x)
            {
                car[i].dir = 1;
            }
            else
            {
                car[i].dir = 2;
            }
        }
        else
        {
            if (car[i].location.y < car[i].dstlocation.y)
            {
                car[i].dir = 3;
            }
            else
            {
                car[i].dir = 4;
            }
        }
    }
}
void CheckX(Car&a)
{

    if (a.location.x < a.dstlocation.x)
    {
        a.dir = 1;
    }
    else
    {
        a.dir = 2;
    }
}
void CheckY(Car&a)
{

    if (a.location.y < a.dstlocation.y)
    {
        a.dir = 3;
    }
    else
    {
        a.dir = 4;
    }

}
void move()
{
    for (int i = 0; i < TotalNum; i++)
    {
        cout << car[1].dir << endl;
        if (car[i].dist(car[i].dstlocation) <= sqrt(pow(GoalDistance,2)+pow(GoalDistance,2)))
        {
            car[i].dir = 5;
            car[i].state = 2;
            continue;
        }
        if (car[i].state!=0)
        {
            if (abs(car[i].location.x-car[i].dstlocation.x)<GoalDistance&&car[i].dir==0)
            {
                CheckY(car[i]);
            }
            if (abs(car[i].location.y - car[i].dstlocation.y)<GoalDistance)
            {
                CheckX(car[i]);
            }
            switch (car[i].dir)
            {
            case 1:car[i].location.x++; break;
            case 2:car[i].location.x--; break;
            case 3:car[i].location.y++; break;
            case 4:car[i].location.y--; break;
            default:
                break;
            }
        }
        car[i].state = 1;
        for (int j = 0; j < i; j++)
        {
            if (car[i].dist(car[j].location) < SafeDistance)
            {

                if (car[i].dir==car[j].dir)
                {
                    continue;
                }
                switch (car[i].dir)
                {
                case 1:
                    switch (car[j].dir)
                    {
                    case 2:car[i].state = 0;
                        CheckY(car[i]); break;
                    case 3:
                        if (car[i].location.x<car[j].location.x&&car[i].location.y>car[j].location.y)
                        {
                            car[i].dir = 2;
                            car[i].state = 0;
                        }break;
                    case 4:
                        if (car[i].location.x < car[j].location.x&&car[i].location.y < car[j].location.y)
                        {
                            car[i].dir = 2;
                            car[i].state = 0;
                        }break;
                    case 5:
                        if (car[i].location.x < car[j].location.x)
                        {
                            CheckY(car[i]);
                            car[i].state = 0;
                        }
                        break;
                    }break;
                case 2:
                    switch (car[j].dir)
                    {
                    case 1:car[i].state = 0;
                        CheckY(car[i]); break;
                    case 3:
                        if (car[i].location.x > car[j].location.x&&car[i].location.y > car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 1;
                        }break;
                    case 4:
                        if (car[i].location.x > car[j].location.x&&car[i].location.y < car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 1;
                        }break;
                    case 5:
                        if (car[i].location.x > car[j].location.x)
                        {
                            CheckY(car[i]);
                            cout << car[i].dir << endl;
                            cout << car[j].dir << endl;
                            car[i].state = 0;
                        }
                        break;
                    }break;
                case 3:
                    switch (car[j].dir)
                    {
                    case 1:
                        if (car[i].location.x > car[j].location.x&&car[i].location.y<car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 4;
                        }
                        break;
                    case 2:
                        if (car[i].location.x < car[j].location.x&&car[i].location.y<car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 4;
                        }
                        break;
                    case 4:
                        car[i].state = 0;
                        CheckX(car[i]);
                        break;
                    case 5:
                        if (car[i].location.y < car[j].location.y)
                        {
                            CheckX(car[i]);
                            car[i].state = 0;
                        }
                        break;
                    }break;
                case 4:
                    switch (car[j].dir)
                    {
                    case 1:
                        if (car[i].location.x > car[j].location.x&&car[i].location.y>car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 3;
                        }
                        break;
                    case 2:
                        if (car[i].location.x < car[j].location.x&&car[i].location.y>car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 3;
                        }
                        break;
                    case 3:
                        car[i].state = 0;
                        CheckX(car[i]);
                        break;
                    case 5:
                        if (car[i].location.y > car[j].location.y)
                        {
                            CheckX(car[i]);
                            car[i].state = 0;
                        }
                        break;
                    }break;
                }
            }

            if (car[i].state==0)
            {
                break;
            }
        }
        if (car[i].state==0)
        {
            continue;
        }
        for (int j = i+1; j < TotalNum; j++)
        {

            if (car[i].dist(car[j].location) < SafeDistance)
            {
                if (car[i].dir == car[j].dir)
                {
                    continue;
                }
                switch (car[i].dir)
                {
                case 1:
                    switch (car[j].dir)
                    {
                    case 2:car[i].state = 0;
                        CheckY(car[i]); break;
                    case 3:
                        if (car[i].location.x<car[j].location.x&&car[i].location.y>car[j].location.y)
                        {
                            car[i].dir = 2;
                            car[i].state = 0;
                        }break;
                    case 4:
                        if (car[i].location.x < car[j].location.x&&car[i].location.y < car[j].location.y)
                        {
                            car[i].dir = 2;
                            car[i].state = 0;
                        }break;
                    case 5:
                        if (car[i].location.x < car[j].location.x)
                        {
                            CheckY(car[i]);
                        }
                        break;
                    }break;
                case 2:
                    switch (car[j].dir)
                    {
                    case 1:car[i].state = 0;
                        CheckY(car[i]); break;
                    case 3:
                        if (car[i].location.x > car[j].location.x&&car[i].location.y > car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 1;
                        }break;
                    case 4:
                        if (car[i].location.x > car[j].location.x&&car[i].location.y < car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 1;
                        }break;
                    case 5:
                        if (car[i].location.x > car[j].location.x)
                        {
                            CheckY(car[i]);
                        }
                        break;
                    }break;
                case 3:
                    switch (car[j].dir)
                    {
                    case 1:
                        if (car[i].location.x > car[j].location.x&&car[i].location.y<car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 4;
                        }
                        break;
                    case 2:
                        if (car[i].location.x < car[j].location.x&&car[i].location.y<car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 4;
                        }
                        break;
                    case 4:
                        car[i].state = 0;
                        CheckX(car[i]);
                        break;
                    case 5:
                        if (car[i].location.y < car[j].location.y)
                        {
                            CheckX(car[i]);
                        }
                        break;
                    }break;
                case 4:
                    switch (car[j].dir)
                    {
                    case 1:
                        if (car[i].location.x > car[j].location.x&&car[i].location.y>car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 3;
                        }
                        break;
                    case 2:
                        if (car[i].location.x < car[j].location.x&&car[i].location.y>car[j].location.y)
                        {
                            car[i].state = 0;
                            car[i].dir = 3;
                        }
                        break;
                    case 3:
                        car[i].state = 0;
                        CheckX(car[i]);
                        break;
                    case 5:
                        if (car[i].location.y > car[j].location.y)
                        {
                            CheckX(car[i]);
                        }
                        break;
                    }break;
                }
            }
            if (car[i].state == 0)
            {
                break;
            }
        }
        if (car[i].state == 0)
        {
            continue;
        }
        if (car[i].location.x>car[i].dstlocation.x+20&&car[i].dir==1)
        {
            if (abs(car[i].location.y-car[i].dstlocation.y)<GoalDistance)
            {
                car[i].dir = 2;
            }
            else
            {
                CheckY(car[i]);
            }
        }
        if (car[i].location.x<car[i].dstlocation.x-20&&car[i].dir == 2)
        {
            if (abs(car[i].location.y - car[i].dstlocation.y)<GoalDistance)
            {
                car[i].dir = 2;
            }
            else
            {
                CheckY(car[i]);
            }
        }
        if (car[i].location.y>car[i].dstlocation.y + 20 && car[i].dir == 3)
        {
            if (abs(car[i].location.x - car[i].dstlocation.x)<GoalDistance)
            {
                car[i].dir = 4;
            }
            else
            {
                CheckX(car[i]);
            }
        }
        if (car[i].location.y<car[i].dstlocation.y - 20 && car[i].dir == 4)
        {
            if (abs(car[i].location.x - car[i].dstlocation.x)<GoalDistance)
            {
                car[i].dir = 3;
            }
            else
            {
                CheckX(car[i]);
            }
        }
    }
}
int main()
{
    Mat a = imread("C:\\Users\\ASUS\\Desktop\\box.jpg");
    srand((unsigned)time(0));
    for (int i = 0; i < TotalNum; i++)
    {
        car[i].location.x =50+50*i;
        car[i].location.y = 50;
        car[i].dstlocation.x = 50-25*i;
        car[i].dstlocation.y = 50;
    }
    start();
    while (true)
    {
        a = imread("C:\\Users\\ASUS\\Desktop\\box.jpg");
        move();
        for (int i = 0; i < TotalNum; i++)
        {
            CvPoint firstpoint;
            CvPoint secondpoint;
            firstpoint.x = car[i].location.x-5;
            firstpoint.y = car[i].location.y-5;
            secondpoint.x = car[i].location.x + 5;
            secondpoint.y = car[i].location.y + 5;
            rectangle(a, firstpoint, secondpoint, Scalar(166, 155, 155));
        }
        for (int i = 0; i < TotalNum; i++)
        {
            for (int j = 0; j < i; j++)
            {
                if (car[i].dist(car[j].location) < SafeDistance - 10)
                {
                    cout << "错误" << endl;
                }
            }
            for (int j = i+1; j < TotalNum; j++)
            {
                if (car[i].dist(car[j].location) < SafeDistance - 10)
                {
                    cout << "错误" << endl;
                }
            }
        }
        imshow("youxi", a);
        waitKey(10);
    }

}

本文项目源代码：
https://github.com/ahongl/ClassicalCode/blob/master/OpenCVDemo.cpp

奕起学习
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于OPenCV实现图像处理各种常用算法
08-05
基于OPenCV实现图像处理各种常用算法 1.Interpolation Algorithm 实现了一些常用插值算法 2.Affine Transformation 实现了仿射变换（旋转、平移、缩放、偏移、组合变换） 3.Grayscale transformation 实现了一些...
基于OPenCV实现图像处理各种常用算法.zip
最新发布
06-04
下面介绍一些基于 OpenCV 实现的常用图像处理算法： 1. 图像滤波：OpenCV 提供了多种图像滤波算法，如均值滤波、中值滤波、高斯滤波等。这些算法可以去除图像中的噪声，平滑图像，提高图像的质量。 2. 边缘检测：...
PCL-渲染小车路径
weixin_45644897的博客
03-27 824
PCL利用线条、圆柱体绘制小车路径
项目实训第一周记录
weixin_45644897的博客
03-06 400
目录前言工作内容2022.2.272022.2.282022.3.12022.3.22022.3.32022.3.42022.3.52022.3.6 前言 项目立项后，我们小组进行了分工，我负责我负责项目的点云图可视化开发部分，最终目标能够实现脱离ROS平台的、高速的可视化渲染，并能够整合到我们团队开发的智能车系统上。（这部分原本是由RVIZ实现的，但由于要脱离ros，只能自己实现一个可视化框架）。 工作内容 2022.2.27 决定将这个项目定为一个C++的工程项目，在Ubuntu上进行开发。于是在git
（十三）Visualization教程一
jiaojialulu的专栏
04-05 5874
CloudViewer如果你只是想简单的显示一幅点云，那么CloudViewer会是一个不错的选择。 注意CloudViewer类不能用在多线程 实例头文件#include <pcl/visualization/cloud_viewer.h>程序pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud; //... populate cloud pcl::visu
PCL-利用相机移动模拟小车移动
weixin_45644897的博客
03-28 997
前言 项目需要视角跟随小车运动，如果只是 小车数据 //点的位置 struct geometry_msgs_Point { double x; double y; double z; }; //四元数 struct geometry_msgs_Quaternion { double x; double y; double z; double w; };
初识 OpenCV 之阵列，线性，图像算术操作的概念以及应用
weixin_38452632的博客
09-29 412
这几天发现越来越不好学妈的，除了工作上突然来一个项目以外，还有的就是发现对一些概念模糊不清，所以先把这些基础的概念先理清。。。。。。。 主要就是讲解阵列与矩阵，线性与非线性，图像的算术操作。。。。。。图文公式文字并茂。。。。。。。 主要是根据数字图像处理（神啊）这本书，还有百度一下概念总结出来的 阵列与矩阵： 同样是2*2的图像操作 图像阵列相乘操作： 矩阵相乘： 线...
opencv图像处理-opencv图像处理算法之图像滤波.zip
03-08
在OpenCV库中，图像处理是一项核心功能，其中包括了丰富的图像滤波算法。图像滤波是一种常见的图像处理技术，主要用于去除噪声、平滑图像或增强图像的某些特征。本资料包"opencv图像处理_opencv图像处理算法之图像...
opencv图像处理-opencv图像处理算法之边缘检测.zip
03-08
在计算机视觉领域，...通过学习和实践这个“opencv图像处理_opencv图像处理算法之边缘检测”的资料包，你可以深入理解各种边缘检测算法的原理和实现，掌握如何在OpenCV中调用这些函数，从而提升你的图像处理技能。
opencv-基于c++实现的opencv图像处理算法之区域生长分割算法.zip
05-15
在计算机视觉领域，OpenCV（开源计算机视觉库）是一个广泛使用的工具，它提供了丰富的API用于图像和视频处理。本篇文章将深入探讨一个...通过实践和调试，开发者可以熟练运用这一技术，提高图像处理的精确性和效率。
[Online zuozuo]阵列算法思考
chizuanduo9634的博客
02-04 346
>通过什么实现 ● Token（理解为某个对象本身的属性，他会根据自身的变化而自动更新自己的Token） ● 编码 ● 集合 >过程 需要实现什么：通过用户的输入获得一个矩形区域，在该矩形局域内以左上角为原点...
opencv生成图图片阵列
TJLCY的博客
11-14 3373
from typing import Tuple import cv2 import numpy as np import argparse import os parser = argparse.ArgumentParser('将目录中的图片生成固定大小的图片阵列') parser.add_argument('inputDir', type=str, help='the directory stores the pictures!') parser.add_arg
Opencv 图像分割： 阈值化分割 区域分割 边缘分割
热门推荐
keen_zuxwang的博客
05-26 1万+
Opencv 图像分割： 阈值化分割 区域分割 边缘分割 卷积 就是两个函数之间的相互关系，然后得出一个新的值，在连续空间做积分计算，然后在离散空间内求和的过程。 在计算机视觉里面，可以把卷积当做一个抽象的过程，就是把小区域内的信息统计抽象出来 图像阈值化分割 按照灰度级，对像素集合进行一个划分，得到的每个子集形成一个与现实景物相对应的区域，
基于OPENCV的动态图片阵列显示程序
s812289480的博客
04-15 801
最近一直在做目标检测的项目，C++写程序真的烦，在面对大量图片显示的时候总觉得只用imshow不太好看，所以就做了这么一个可以动态显示图片阵列的程序，可以选择两种输出方式，一种是固定行列数的，一种是设置最大同时显示数量的自动生成行列数的，原理很简单，在这里就不班门弄斧了。  下面是写好的类，如果有需要就直接复制到自己的项目里吧。class my_show{ public: my_show(...
树莓派小车简单的迷宫算法-基于Python设计
OuMan的博客
11-10 6063
请大家先看看我的法拉利~ 它身上有前中后三个超声波传感器，轻松调用他们就能使小车避障轻松走出迷宫啦。预期小车走的路线是这样子的： 我的核心思路： 初始小车为前进状态，此时使用前、左、右三个传感器检测小车三边与障碍物的距离，当前方距离小于一个界限值时，判断左右传感器与障碍物的距离，如果左大于右，则向左转，否则，向右。当转向完成后小车的转向角度可能会发生偏差，判断左右传感器与障碍物的距离，设置一...
【OpenCV】矩阵和图像的操作总结查询
技术小白
05-03 6111
 矩阵和图像操作 表3-3列出了一些操作矩阵图像的函数，其中的大部分对于图像处理非常有效。它们实现了图像处理中的基本操作，例如对角化、矩阵变换以及一些更复杂的诸如计算图像的统计操作。                                                                                                  【47】 表
虚拟现实
计算机视觉算法、工程、产品
03-28 2728
参考网络资源 虚拟现实技术的应用实际上已极为广泛在 1993 年时对全世界范围内 VR 研究项目统计，就有 800 多个，统计结果表明： 在娱乐、教育及艺术方面的应用占据主流，达 21.4％， 其次是军事与航空达 12.7％，医学方面达 6.13％，机器人方面占 6.21％，商业方面占 4.96％， 另外在可视化计算、制造业等方面也有相当的比重。 目前，国外在虚拟现实系统的硬件构成方面提交
OpenCV+TensorFlow简单的机器小车传统视觉寻迹
qq_42500340的博客
01-12 9295
【小白必看】你还在纠结不知道如何高效进行小车寻迹吗？基于python的传统视觉寻迹方法。加入了算法优化，相比于优化前效率提升70%以上。附带完整代码。
OpenCV图像处理实战：经典算法与应用详解
本文档将介绍如何利用OpenCV（开源计算机视觉库）来实现一系列关键的图像处理任务，包括但不限于： 1. **视频采集与预处理**：通过摄像头采集视频流，并使用`cvcamGetCamerasCount()`获取可用摄像头数量。在Win32...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值