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

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

 

原理

先找到一个白点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:

 

目录
相关文章
|
5月前
|
算法
【MATLAB】语音信号识别与处理:滑动平均滤波算法去噪及谱相减算法呈现频谱
【MATLAB】语音信号识别与处理:滑动平均滤波算法去噪及谱相减算法呈现频谱
171 0
|
5月前
|
算法
【MATLAB】语音信号识别与处理:SG滤波算法去噪及谱相减算法呈现频谱
【MATLAB】语音信号识别与处理:SG滤波算法去噪及谱相减算法呈现频谱
225 1
|
5月前
|
算法
【MATLAB】语音信号识别与处理:T1小波滤波算法去噪及谱相减算法呈现频谱
【MATLAB】语音信号识别与处理:T1小波滤波算法去噪及谱相减算法呈现频谱
143 0
|
5月前
|
机器学习/深度学习 算法 TensorFlow
文本分类识别Python+卷积神经网络算法+TensorFlow模型训练+Django可视化界面
文本分类识别Python+卷积神经网络算法+TensorFlow模型训练+Django可视化界面
116 0
文本分类识别Python+卷积神经网络算法+TensorFlow模型训练+Django可视化界面
|
5月前
|
算法
【MATLAB】语音信号识别与处理:移动中位数滤波算法去噪及谱相减算法呈现频谱
【MATLAB】语音信号识别与处理:移动中位数滤波算法去噪及谱相减算法呈现频谱
82 2
|
5月前
|
算法
【MATLAB】语音信号识别与处理:卷积滑动平均滤波算法去噪及谱相减算法呈现频谱
【MATLAB】语音信号识别与处理:卷积滑动平均滤波算法去噪及谱相减算法呈现频谱
105 0
|
5月前
|
算法
【MATLAB】语音信号识别与处理:一维信号NLM非局部均值滤波算法去噪及谱相减算法呈现频谱
【MATLAB】语音信号识别与处理:一维信号NLM非局部均值滤波算法去噪及谱相减算法呈现频谱
124 1
|
5月前
|
算法
【MATLAB】语音信号识别与处理:高斯加权移动平均滤波算法去噪及谱相减算法呈现频谱
【MATLAB】语音信号识别与处理:高斯加权移动平均滤波算法去噪及谱相减算法呈现频谱
237 0
|
3月前
|
机器学习/深度学习 算法 数据挖掘
算法金 | 欧氏距离算法、余弦相似度、汉明、曼哈顿、切比雪夫、闵可夫斯基、雅卡尔指数、半正矢、Sørensen-Dice
**摘要:** 了解9种距离和相似度算法:欧氏距离、余弦相似度、汉明距离、曼哈顿距离、切比雪夫距离、闵可夫斯基距离、雅卡尔指数、半正矢距离和Sørensen-Dice系数。这些算法在机器学习、文本分析、图像处理和生物学等领域各有应用。例如,欧氏距离用于KNN和K-Means,余弦相似度用于文本相似性,汉明距离在错误检测中,曼哈顿距离在数据挖掘,切比雪夫距离在棋盘游戏,闵可夫斯基距离通过调整参数适应不同场景,雅卡尔指数和Sørensen-Dice系数用于集合相似度。每种算法有其优缺点,如欧氏距离对异常值敏感,余弦相似度忽略数值大小,汉明距离仅适用于等长数据。
102 2
算法金 | 欧氏距离算法、余弦相似度、汉明、曼哈顿、切比雪夫、闵可夫斯基、雅卡尔指数、半正矢、Sørensen-Dice
|
4月前
|
机器学习/深度学习 存储 算法
使用支持向量机算法解决手写体识别问题
使用支持向量机算法解决手写体识别问题
32 2

热门文章

最新文章