当年参加飞思卡尔自己写的双线识别算法

原理

先找到一个白点A,然后向右找到黑点,记录黑点的位置,以当前黑点的竖坐标位置向上判断,上面的点是什么点,如果为黑点向左找白点,如果为白点向右找黑点(找到边界点),然后接着以当前竖坐标位置判断上面的点...就这样设计的

总体思想是这样,但是并不是简单如此,有几个特殊的处理

没写完呢

int zhidao_flage=0;
    int goto_cross=0;
    
    int xieshizi_among=0;//斜十字中间
    int xieshizi__cnt=0;//斜十字
    
    int start=0;//从哪里开始求平均
    int stop=0;//
    int avg=0;//黑线中点平均位置
    int flage=0,flag=0;
    int i=0,j=0,copy_j=0,among=0,up=0;
    int right[40]={0,0};//右边界记录数组---行列记录
    /*左边缘*/
    int ii=0,iii=0;
    int left_flage=0,left_flag=0;
    int left_i=0,left_j=0,left_copy_j=0,left_among=0,left_up=0;
    int left[40]={0,0}; //左边界记录数组---行列记录
    return_left_max=0;
    return_left_min=0;
    left_carry = 0;
  /*左边缘*/
  return_right_max = 0;//右边界最高点
    return_right_min = 0;//右边界最低点
    right_carry = 0;         //运行标志位
//     printf("left********");

    //左边界
    /*先找到起始点*/
           //中                   //上                      //左                       右
if(image[38][40] > thresh && image[37][40] > thresh &&image[38][39] > thresh &&image[38][41] > thresh)//所选点为白点
{
//     peedPid -> SetPoint = 20;//设置起始速度为
    if(image[38][40] > thresh)
    {
        for(left_i=40;left_i>0;left_i--)
        {
            if(image[38][left_i] < thresh)
            {
                
                left_flage = 1;              //标志位置一
                left_carry = 1;          //运行标志位置一
                left[38] = left_i;              //记录当前位置
                left_copy_j = 38;            //把最低位置传递给下面的函数
//                 left_lie[i]=copy_j;   //第i行的边界是copy_j
                return_left_min = 38; //左边界最低点
                break;
      }
        }
  }
    if(left_flage == 0)//左边上上找
    {
        for(left_j=38;left_j>16;left_j--)
        {
            if(image[left_j][1] < thresh)
            {
                if(left_j<30)
                {
                    for(ii=38;ii>20;ii--)
                    {
                        if(image[ii][40]<thresh)
                        {
                            
                            left_carry = 0;
                            return_left_max = 0;
                            return_left_min = 0;
                            goto diuxian1;
                        }
                    }
        }
//                 if(image[left_j][4] >thresh&&image[left_j][6] >thresh&&image[left_j][8] >thresh)
//                 {
//                     if(image[left_j-1][6] >thresh&&image[left_j-1][8] >thresh&&image[left_j-1][10] >thresh)
//                     {
                        left_copy_j = left_j;                    //把最低位置传递给下面的函数
//                     left_lie[i]=copy_j; //第i行的边界是copy_j
                        left_flage = 1;                    //标志位置一
                        left_carry = 1;            //运行标志位置一
                        left[left_j] = left_i;                //记录当前位置
                        return_left_min = left_j;//左边界最低点
                        break;
//           }
//         }
                
            }
        }
    }
    
    if(left_flage==1)
    {
        for(left_j = left_copy_j; left_j>1; left_j --)
        {
            left_among = left[left_j];//记录现在点的x坐标
            left_up    = left_j - 1;       //上
            if(left_up < 0) left_up = 0;
            if(*(*(image+left_up)+left_among)>thresh)//如果上面是白点
            {
                left_flag = 0;
//                 printf("111111111111");
                for(left_i = left_among; left_i >1; left_i --)//向左找黑色边缘
                {
//                     if(left_i <0)
//                     {
//                         left_i=0;
//           }
                    if(image[left_up][left_i] < thresh)//容差大于delta--找到
                    {
                        left_flag = 1;//找到边缘标志
                        left[left_up] = left_i;//记录
//                         left_lie[i]=up; //第i行的边界是up
//                         printf("22222222222");
                        break;
                    }
        }
            }
            else
            {
//                 printf("aaaaaaaaaaaaa");
                left_flag = 0;
                for(left_i = left_among; left_i<78; left_i ++)//向右找白色边缘
                {
//                     if(left_i>79)
//                     {
//                         left_i=79;
//           }
                    if(image[left_up][left_i] > thresh)//容差大于delta--找到
                    {
                        left_flag = 1;//找到边缘标志
                        left[left_up] = left_i;//记录
//                         left_lie[i]=up; //第i行的边界是up
//                         printf("bbbbbbbbbbbbb");
                        break;
                    }
        }
      }
            if(left_flag==0)
            {
//                 printf("jkfhuidasf");
                return_left_max = left_j+1;
                break;
      }
            else
            {
        return_left_max = left_j+1;//返回函数检测的最高点
//                 printf("jkfhuidasf");
      }
    }
//         printf("return_left=%d\r\n",return_left_max);
//         printf("return_left_max==%d\r\n",left[return_left_max]);
//       for(ii = 0;ii<40;ii++)
//         {
//             printf("%d",ii);
//             printf("==%d\r\n",left[ii]);
//     }
  }
diuxian1:
    /*右边界************************************************/
    if(image[38][40] > thresh)//所选点为白点
    {
        for(i=40;i<78;i++)//向右找黑点
        {
            if(image[38][i] < thresh)//找到黑点
            {
                flage = 1;              //标志位置一
                right_carry = 1;        //运行标志位置一
                right[38] = i;          //记录当前位置--第38行的边界是i
                copy_j = 38;            //把最低位置传递给下面的函数
//                 right_lie[i]=copy_j;  //第i列的边界是copy_j
                return_right_min = 38;//右边界最低点
                break;
      }
        }
  }
    if(flage == 0)//上面没找到边界
    {
        return_right_min=0;
        for(j=38;j>16;j--)//向上找10行
        {
            if(image[j][77] < thresh)//如果找到边界
            {
//                 if(image[j][74] >thresh&&image[j][71] >thresh&&image[j][68] >thresh)
//                 {
//                     if(image[j-1][72] >thresh&&image[j-1][70] >thresh&&image[j-1][68] >thresh)
//                     {
                if(j<30)
                {
                    for(ii=38;ii>20;ii--)
                    {
                        if(image[ii][40]<thresh)
                        {
//                             printf("****%d",ii);
                            right_carry = 0;
                            return_right_max = 0;
                            return_right_min = 0;
                            goto diuxian2;
                        }
                    }
        }
                        flage = 1;                        //标志位置一
                        right_carry = 1;            //运行标志位置一
                        right[j] = i;                    //记录当前位置
                        copy_j = j;                    //把最低位置传递给下面的函数
        //                 right_lie[i]=copy_j;  //第i列的边界是copy_j
                        return_right_min = j; //右边界最低点
                        break;
//                     }
//                 }
                
            }
        }
    }
    
    if(flage==1)
    {
        for(j = copy_j; j>1; j --)
        {
            among = right[j];//记录现在点的x坐标
            up    = j - 1;       //上
            if(up < 0) up = 0;
            
            if(*(*(image+up)+among)>thresh)//如果上面是白点
            {
                flag = 0;
                for(i = among; i < 78; i ++)//向右找黑色边缘
                {
//                     if(i>79)
//                     {
//                         i=79;
//           }
                    if(image[up][i] < thresh)//容差大于delta--找到
                    {
                        flag = 1;//找到边缘标志
                        right[up] = i;//记录
//                         right_lie[i]=up;  //第i列的边界是up
                        break;
                    }
        }
            }
            else
            {
                flag = 0;
                for(i = among; i > 1; i --)//向左找白色边缘
                {
//                     if(i<0)
//                     {
//                         i=0;
//           }
                    if(image[up][i] > thresh)//容差大于delta--找到
                    {
                        flag = 1;//找到边缘标志
                        right[up] = i;//记录
//                         right_lie[i]=up;  //第i列的边界是up
                        break;
                    }
        }
      }
            if(flag==0)
            {
                return_right_max = j+1;//返回函数检测的最高点
//                 printf("j==%d\r\n",j);
                break;
      }
            else
            {
        return_right_max = j+1;//返回函数检测的最高点
//                 printf("j==%d\r\n",j);
      }
    }
//         printf("return_right_max==%d\r\n",return_right_max);
//         printf("return_right_max==%d\r\n",right[return_right_max]);
//         for(ii = 0;ii<40;ii++)
//         {
//             printf("%d",ii);
//             printf("==%d\r\n",right[ii]);
//     }
  }
    diuxian2:

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏漫漫深度学习路

pytorch学习笔记(十三):backward过程的底层实现解析

博主水平有限,如有错误,请不吝指出。 pytorch源码注释,欢迎 pr,提 issue 和 star 当我们使用 pytorch 的 python 的接口编写...

59710
来自专栏GIS讲堂

postgis常用函数介绍(一)

在进行地理信息系统开发的过程中,常用的空间数据库有esri的sde,postgres的postgis以及mySQL的mysql gis等等,在本文,给大家介绍的...

3093
来自专栏小狼的世界

使用Numpy验证Google GRE的随机选择算法

最近在读《SRE Google运维解密》第20章提到数据中心内部服务器的负载均衡方法,文章对比了几种负载均衡的算法,其中随机选择算法,非常适合用 Numpy 模...

1252
来自专栏SeanCheney的专栏

《Scikit-Learn与TensorFlow机器学习实用指南》 第09章 启动并运行TensorFlow

TensorFlow 是一款用于数值计算的强大的开源软件库,特别适用于大规模机器学习的微调。 它的基本原理很简单:首先在 Python 中定义要执行的计算图(例...

1423
来自专栏落影的专栏

GPUImage详细解析

从源码的角度分析、学习GPUImage和OpenGL ES,这是第一篇,介绍GPUImageFilter 和 GPUImageFramebuffer。 Open...

3496
来自专栏IT派

PyTorch和Tensorflow版本更新点

导语:今天为大家带来最近更新的Pytorch的更新点介绍,另外,小编Tom邀请你一起搞事情!,源代码可以扫描二维码进群找小编获取哦~ Tensorflow 主...

4885
来自专栏机器学习原理

深度学习(2)——tensorflow可视化TensorFlow变量作用域TensorFlow可视化示例

1645
来自专栏深度学习计算机视觉

pytorch demo 实践

相关环境 python opencv pytorch ubuntu 14.04 pytorch 基本内容 60分钟快速入门,参考:https://blog...

7496
来自专栏深度学习之tensorflow实战篇

Python基础整理操作积累

Python编程积累 列表内容 Python基础 for变化量的灵活应用 for x,y in [[0,1],[0,2],[1,2]]: d...

35110
来自专栏漫漫深度学习路

tensorflow学习笔记(三十四):Saver(保存与加载模型)

Saver tensorflow 中的 Saver 对象是用于 参数保存和恢复的。如何使用呢? 这里介绍了一些基本的用法。 官网中给出了这么一个例子: ...

4048

扫码关注云+社区

领取腾讯云代金券