CN106960209A

CN106960209A - 一种图像轮廓有序点集提取方法、计算机视觉系统

Info

Publication number: CN106960209A
Application number: CN201710172510.0A
Authority: CN
Inventors: 刘伟
Original assignee: Individual
Current assignee: Haode Technology Co Ltd
Priority date: 2013-10-30
Filing date: 2013-10-30
Publication date: 2017-07-18
Anticipated expiration: 2033-10-30
Also published as: CN103530639B; CN106960209B; CN103530639A

Abstract

本发明公开了一种图像轮廓有序点集提取方法，其的特征在于：基于一种逻辑拓扑结构，每个点对应八个碎点，一个碎点代表点的一个联通方向；将所有碎点进行连接，其方法是，如果一个碎点对应联通方向达到联通条件，则将碎点指向对应联通方向的碎点的时针方向上的下一个碎点，否则将其指向本点的时针方向上的下一个碎点。所述的时针方向包括顺时针和逆时针。所述的时针方向对所有的点都是统一的。本发明的新颖性在于：本发明相对现有技术可以更加快速便捷的获得图像轮廓有序点集数据。

Description

一种图像轮廓有序点集提取方法、计算机视觉系统

技术领域

本发明属于计算机视觉领域，更具体的涉及一种图像轮廓有序点集提取方法、计算机视觉系统，属于专利分类名称为 “图像特征或特性的抽取”的G06K9/46(2006.01)I号分类。

背景技术

图像轮廓的提取是计算机视觉中一个基础性的核心步骤，在很多场合需要对图像轮廓提取并转换为有序点集。

现有的计算机图像轮廓有序点集提取方法一般使用虫随法、光栅扫描法等，这些方法运行时都难以实现并行运算，图像内部小图像越多，耗时越大，难以预测轮廓抽取的耗时；这些方法难以解析交叉的边界；这些方法收敛特性不够稳定，可能掉入所谓的“陷阱”。

发明内容

本发明的目的在于针对现有技术的不足提出一种图像轮廓有序点集提取方法，解决现有图像轮廓有序点集提取方法运行缓慢、难以解析相交叉的边界、收敛不稳定的问题，有利于计算机视觉开发者开发计算机视觉系统。

一种图像轮廓有序点集提取方法，基于一种逻辑拓扑结构，每个点对应八个碎点，一个碎点代表点的一个联通方向；将所有碎点进行连接，其方法是：如果一个碎点对应联通方向达到联通条件，则将碎点指向对应联通方向的碎点的时针方向上的下一个碎点，否则将其指向本点的时针方向上的下一个碎点。

进一步说明 1：所述的时针方向包括逆时针方向和顺时针方向。

进一步说明2：所述的时针方向对所有的点都是统一的，也就是说在一次图片处理中所有点使用的时针方向必须是一致的，也就是说，不允许任何一个点使用与其他点不同的时针方向；(参见图2)。

进一步说明3：所述的联通条件是可变的，由使用本发明的计算机视觉开发者根据需求而定义。

进一步说明4：所述的统一的时针方向不是对碎点连接形成的边界链的时针方向的限定，也就是说碎点连接完毕后产生的碎点链可以是不同的时针方向，事实上本发明碎点连接形成的碎点链，其方向既有顺时针也有逆时针。

进一步说明5：由于进行过碎点连接运算后，边界碎点链就被勾出，又由于碎点和点是对应的，也就是说边界碎点链的勾出，对于计算机视觉开发者而言，等同于有序点集的勾出；（参见图3、图4、图5）。

进一步说明6：为了方便计算机视觉开发者对本发明的理解和利用，特意做出非本发明必要特征的补充——孤点的判断依据：孤点即对外无连接的点，一个碎点链其包含的所有碎点都对应同一个点，那么这条碎点链也就是一个孤点的碎点链（参见图3，点P8）。

进一步说明7：为了方便计算机视觉开发者对本发明的理解和利用，特意做出非本发明必要特征的补充——非边界碎点链的判断依据1：由于所有连接都成对出现，那么当一个点的两个相邻联通方向都对外先连接时，位于时针方向上排位靠后的碎点所在的碎点链一定是非边界碎点链；参见图3，碎点链P0（S6）、P1（S3,S4）、P4(S1)和碎点链P1（S5,S6）、P2(S3,S4)、P4(S7,S0)、P5(S5,S2)。

进一步说明8：为了方便计算机视觉开发者对本发明的理解和利用，特意做出非本发明必要特征的补充——非边界碎点链的判断依据2：孤点不算作有效图像的情况下，由于一个点对应八个碎点，那么连接后一个有效碎点链碎点数一定大于八,无效碎点链碎点数一定小于等于八；参见图3，碎点链P0（S6）、P1（S3,S4）、P4(S1)和碎点链P1（S5,S6）、P2(S3,S4)、P4(S7,S0)、P5(S5,S2)。

进一步说明9：为了方便计算机视觉开发者对本发明的理解和利用，特意做出非本发明必要特征的补充——碎点链的简化方法，以点为单元顺着时针方向的逆方向依次运算八个碎点，如果某碎点对外不联通，就将其指向更改为时针方向上下一个碎点的指向，并将下一个碎点清除；经过运算后同一点上的碎点出现在同一碎点链中的次数减少了；值得注意的是，由于孤点的所有碎点对外均无连接经过简化后会被消除（参见图5）。

进一步说明10：由于所有碎点的联通条件是一致的，也就是说一个联通方向上的连接是成对出现；由于连接成对出现且所有的点使用的连接方向规则相同（时针方向），所以所有碎点形成的连接一定都是闭合链接，所以不用担心收敛问题。

进一步说明11：由于每个碎点对应一个联通方向，碎点的连接只与这个方向是否达到条件相关，所以当两个边界交叉时，本发明也能分别检测出来，而不会出现判断冲突。

进一步说明12：因为每个联通方向上的碎点连接运算是独立的，和其他联通方向状况无关，且碎点之间的数据相关性比较小，所以本发明很适合并行运算。

进一步说明13：理解了进一步说明1-12后可知，本发明虽为并行化运算而创造，但相对传统方法其运行速度较快、可以检测交叉边界、不必担心收敛问题的优势，在非并行计算中同样存在。

本发明的新颖性在于：本发明是一种新的图像轮廓有序点集提取方法。

本发明的实用性在于：为计算机视觉开发者提供了一种图像轮廓有序点集提取方法，方便计算机视觉开发者开发适应于多处理器并行的计算机视觉系统，相对现有技术可以更加快速便捷的获得图像轮廓有序点集数据。

附图说明

图1是本发明提出的的逻辑拓扑结构一个示例，点P的横坐标为x，纵坐标为y，颜色值为c，点P对应的八个碎点为S0-S7。

图2是本发明的一个实施实例，体现的是一个3*3像素的图像数据被导入后的逻辑拓扑结构。

图3 是图2实施实例的另一个状态，体现了图2经过碎点连接运算后的逻辑拓扑结构。

图4 是图2实施实例的另一个状态，体现了图3清除非边界碎点链后的逻辑拓扑结构。

图5 是图2实施实例的另一个状态，体现了图4简化碎点链并清除孤点后的逻辑拓扑结构。

具体实施方式

下面将结合实施实例对本发明进行说明。

如图2、图3、图4、图5所示，是本发明一种图像轮廓有序点集提取方法的一个实施实例，处理了一个具有3*3像素、具有0，1，3三种颜色值的图像；本实例使用的联通条件是颜色相同。

如图2所示，是本实施实例在图像数据导入后，碎点连接运算之前的逻辑拓扑结构；其中所有点的碎点都构成了一个顺时针的圈状闭合链；其中所有的辅助点P(-1,-1,-1)构成一道防止计算溢出的‘围墙’，因为‘围墙’中的碎点没有参与运算，为了视图的清晰、简洁，图中未将其指向画出。

如图3所示，是图2经过碎点连接运算后的逻辑拓扑结构，P0（S6）、P1（S3,S4）、P4(S1)构成了一条“长条形”的非边界碎点链；P1（S5,S6）、P2(S3,S4)、P4(S7,S0)、P5(S5,S2)构成了一个“十字形”非边界碎点链。

如图3所示，P3、P7构成的图像的边界与P6所在图像的边界虽然是交叉边界，但经过碎点连接运算后他们被分别检出为两条碎点链。

如图3所示，孤点P8对外没有联通。

如图4，是图3剔除非边界碎点链后的逻辑拓扑结构，非边界碎点链被清除（即标记为负，为了视图的清晰没有画出）。

如图5，是图4进行碎点链简化运算后的逻辑拓扑结构，同一点的碎点在同一碎点链上出现的次数减少了，孤点也被消除（即标记为负，为了视图的清晰没有画出）。

如图5所示，本实例得出的边界有序集是：（P3,P7）和（P0,P4,P6,P4,P5,P2,P1），P4在对应的轮廓有序集中出现了两次，符合实际情况。

以下是本实施实例的基于英伟达公司CUDA并行计算技术的部分代码，体现了本发明适合并行运算的特性；提供这些代码的目的是，为计算机视觉开发者理解和使用本发明提供参考。

struct FR_POINT{ //碎点

long next_x; //指向的碎点所在点的x值

long next_y; //指向的碎点所在点的y值

long next_s; //指向的碎点的编号

};

struct POINT{

long X; //点的横坐标

long y; //点的纵坐标

long c; //点的颜色值

long selsete[4]; //用于选择，可以代替if语句根据不同情况结合运

算，产生不同值

FR_POINT S[8]; //碎点集

};

POINT P[5][5]; //构造一个被点结构体组

for(i=0;i<5;i++){

//构造围墙，防止计算溢出，其颜色值-1为无效值，以防被连接

P[0][i].c = -1;

P[4][i].c = -1;

P[i][0].c = -1;

P[i][4].c = -1;

}

idx=threadIdx.x+1; //线程号x，idx的范围1-3

idy=threadIdx.y+1; //线程号y，idy的范围1-3

if（idx<4 && idy<4）{ // idx的范围1-3, idy的范围1-3

for(t=0;t<8;t++){

P[idx][idy].S[t].next_x=idx; //将所有碎点指向本点，

P[idx][idy].S[t].next_y=idy;

P[idx][idy].S[t].next_s=（t+1）%8; //将碎点构成顺时针闭合环状链，

结果见图2；

}

P[idx][idy].c=IMAGE_COLOR[idx][idy]; //导入图像颜色值

//碎点连接，连接运算为并行运算，运算结果见图3

P[idx][idy].selsete[3] = !P[idx][idy].c-P[idx][idy-1].c；

//保存S0对应联通方向的联通状况，颜色相等则连接状态为1，否则为零

P[idx][idy].S[0].next_y -= P[idx][idy].selsete[3];

//如果S0对外联通改变y的值，S0对应联通方向的点横坐标与S0所在点一致；S0对

应的联通方向的点横坐标x值和本点的相同所以无需变化

P[idx][idy].S[0].next_s = 4 * P[idx][idy].selsete[3]+1;

//如果S0对外联通变S的值为5，如果不联通则S值为1

P[idx][idy].selsete[3] = !(P[idx][idy].c-P[idx-1][idy-1].c);

P[idx][idy].S[1].next_x -= P[idx][idy].selsete[3];

P[idx][idy].S[1].next_y -= P[idx][idy].selsete[3];

P[idx][idy].S[1].next_s = 4 * P[idx][idy].selsete[3]+2;

P[idx][idy].selsete[3] = !(P[idx][idy].c-P[idx-1][idy].c);

P[idx][idy].S[2].next_x -= P[idx][idy].selsete[3];

P[idx][idy].S[2].next_s = 4 * P[idx][idy].selsete[3]+3;

P[idx][idy].selsete[3] = !(P[idx][idy].c-P[idx-1][idy+1].c);

P[idx][idy].S[3].next_x -= P[idx][idy].selsete[3];

P[idx][idy].S[3].next_y += P[idx][idy].selsete[3];

P[idx][idy].S[3].next_s = 4 * !P[idx][idy].selsete[3];

P[idx][idy].selsete[3] = !(P[idx][idy].c-P[idx][idy+1].c);

P[idx][idy].S[4].next_y += P[idx][idy].selsete[3];

P[idx][idy].S[4].next_s = 4 * !P[idx][idy].selsete[3]+1;

P[idx][idy].selsete[3] = !(P[idx][idy].c-P[idx+1][idy+1].c)；

P[idx][idy].S[5].next_x += P[idx][idy].selsete[3];

P[idx][idy].S[5].next_y += P[idx][idy].selsete[3];

P[idx][idy].S[5].next_s = 4 * !P[idx][idy].selsete[3]+2;

P[idx][idy].selsete[3] = !(P[idx][idy].c-P[idx+1][idy].c);

P[idx][idy].S[6].next_x += P[idx][idy].selsete[3];

P[idx][idy].S[6].next_s = 4 * !P[idx][idy].selsete[3]+3;

P[idx][idy].selsete[3] = !(P[idx][idy].c-P[idx+1][idy-1].c);

P[idx][idy].S[7].next_x += P[idx][idy].selsete[3];

P[idx][idy].S[7].next_y += P[idx][idy].selsete[3];

P[idx][idy].S[7].next_s = 4 * P[idx][idy].selsete[3];

//以下是将非边界碎点链标记为负数，以清除非边界碎点链，运算结果参图4

P[idx][idy].selsete[0] = -10;

P[idx][idy].selsete[1] = 0;

P[idx][idy].selsete[2] = 0;

P[idx][idy].selsete[3]=!(P[idx][idy].S[0].next_s-1)+ !(P[idx][idy].S[1].

next_s-2);

//判断相邻两碎点S0,S1对外联通状况

P[idx][idy].S[1].next_s += P[idx][idy].selsete[P[idx][idy].selsete[3]];

//如果S0,S1都对外联通，S1.next_s指向被变化为负值，代表被消除

P[idx][idy].selsete[3]=!(P[idx][idy].S[1].next_s-2)+ !(P[idx][idy].S[2].

next_s-3);

P[idx][idy].S[2].next_s += P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3]=!(P[idx][idy].S[2].next_s-3)+ !(P[idx][idy].S[3].

next_s-4);

P[idx][idy].S[3].next_s += P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3]=!(P[idx][idy].S[3].next_s-4)+ !(P[idx][idy].S[4].

next_s-5);

P[idx][idy].S[4].next_s += P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3]=!(P[idx][idy].S[4].next_s-5)+ !(P[idx][idy].S[5].

next_s-6);

P[idx][idy].S[5].next_s += P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3]=!(P[idx][idy].S[5].next_s-6)+ !(P[idx][idy].S[6].

next_s-7);

P[idx][idy].S[6].next_s += P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3]=!(P[idx][idy].S[6].next_s-7)+ !(P[idx][idy].S[7].

next_s-0);

P[idx][idy].S[7].next_s += P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3]=!(P[idx][idy].S[7].next_s-0)+ !(P[idx][idy].S[0].

next_s-1);

P[idx][idy].S[0].next_s += P[idx][idy].selsete[P[idx][idy].selsete[3]];

//以下是对前面的运算可能未完全清除的非边界碎点链(比如P1(S3）)进行清除;

P[idx][idy].selsete[3]=!(P[idx][idy].S[0].next_s-1)+ !(P[idx][idy].S[2].

next_s-3);

//保存S0、S2对外联通情况，如果都对外联通则所得值为零

P[idx][idy].S[1].next_s += P[idx][idy].selsete[ P[idx][idy].selsete[3] ];

//如果S0、S2对外联通，则S1的指向变为负数

P[idx][idy].selsete[3]=!(P[idx][idy].S[2].next_s-3)+ !(P[idx][idy].S[4].

next_s-5);

P[idx][idy].S[3].next_s += P[idx][idy].selsete[ P[idx][idy].selsete[3] ];

P[idx][idy].selsete[3]=!(P[idx][idy].S[4].next_s-5)+ !(P[idx][idy].S[6].

next_s-7);

P[idx][idy].S[5].next_s += P[idx][idy].selsete[ P[idx][idy].selsete[3] ];

P[idx][idy].selsete[3]=!(P[idx][idy].S[6].next_s-0)+ !(P[idx][idy].S[0].

next_s-1);

P[idx][idy].S[7].next_s += P[idx][idy].selsete[ P[idx][idy].selsete[3] ];

//下面是边界碎点链的简化，运算结果参见图5

P[idx][idy].selsete[3] = !（P[idx][idy].S[7].next_s-0）;

//如果指向0，则说明S[7]对外不联通，如果对外不联通就将其指向S[0]的指向，并

清除S[0]

P[idx][idy].selsete[0] = P[idx][idy].S[7].next_x;

//S[7]对外联通则S7指向的横坐标x不变

P[idx][idy].selsete[1] = P[idx][idy].S[0].next_x;

//S[7]对外不联通则S7指向的横坐标 x变为S[0]指向的横坐标

P[idx][idy].S[7].next_x = P[idx][idy].selsete[P[idx][idy].selsete[3]];

//选择运算，如果

P[idx][idy].selsete[0] = P[idx][idy].S[7].next_y;

P[idx][idy].selsete[1] = P[idx][idy].S[0].next_y;

P[idx][idy].S[7].next_y = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[7].next_s;

P[idx][idy].selsete[1] = P[idx][idy].S[0].next_s;

P[idx][idy].S[7].next_s = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = 1;

//如果S[7]对外连通，其指向在前面几行代码中没被改变，需要保留S[0]

P[idx][idy].selsete[1] = -10;

//如果S[7]对外不连通，其指向会在前面几行代码中改变，需要清除S[0] ，负值代

表清除

P[idx][idy].S[0].next_s *=P[idx][idy].selsete[P[idx][idy].selsete[3]];

//做出选择运算，

P[idx][idy].selsete[3] = !（P[idx][idy].S[6].next_s-7）; //如果指向7，则说

明S[6]对外不联通

P[idx][idy].selsete[0] = P[idx][idy].S[6].next_x;

P[idx][idy].selsete[1] = P[idx][idy].S[7].next_x;

P[idx][idy].S[6].next_x = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[6].next_y;

P[idx][idy].selsete[1] = P[idx][idy].S[7].next_y;

P[idx][idy].S[6].next_y = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[6].next_s;

P[idx][idy].selsete[1] = P[idx][idy].S[7].next_s;

P[idx][idy].S[6].next_s = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = 1;

P[idx][idy].selsete[1] = -10;

P[idx][idy].S[7].next_s *=P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3] = !（P[idx][idy].S[5].next_s-6）; //如果指向6，则说

明S[5]对外不联通

P[idx][idy].selsete[0] = P[idx][idy].S[5].next_x;

P[idx][idy].selsete[1] = P[idx][idy].S[6].next_x;

P[idx][idy].S[5].next_x = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[5].next_y;

P[idx][idy].selsete[1] = P[idx][idy].S[6].next_y;

P[idx][idy].S[5].next_y = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[5].next_s;

P[idx][idy].selsete[1] = P[idx][idy].S[6].next_s;

P[idx][idy].S[5].next_s = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = 1;

P[idx][idy].selsete[1] = -10;

P[idx][idy].S[6].next_s *=P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3] = !（P[idx][idy].S[4].next_s-5）; //如果指向5，则说

明S[4]对外不联通

P[idx][idy].selsete[0] = P[idx][idy].S[4].next_x;

P[idx][idy].selsete[1] = P[idx][idy].S[5].next_x;

P[idx][idy].S[4].next_x = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[4].next_y;

P[idx][idy].selsete[1] = P[idx][idy].S[5].next_y;

P[idx][idy].S[4].next_y = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[4].next_s;

P[idx][idy].selsete[1] = P[idx][idy].S[5].next_s;

P[idx][idy].S[4].next_s = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = 1;

P[idx][idy].selsete[1] = -10;

P[idx][idy].S[5].next_s *=P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3] = !（P[idx][idy].S[3].next_s-4）; //如果指向4，则说

明S[3]对外不联通

P[idx][idy].selsete[0] = P[idx][idy].S[3].next_x;

P[idx][idy].selsete[1] = P[idx][idy].S[4].next_x;

P[idx][idy].S[3].next_x = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[3].next_y;

P[idx][idy].selsete[1] = P[idx][idy].S[4].next_y;

P[idx][idy].S[3].next_y = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[3].next_s;

P[idx][idy].selsete[1] = P[idx][idy].S[4].next_s;

P[idx][idy].S[3].next_s = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = 1;

P[idx][idy].selsete[1] = -10;

P[idx][idy].S[4].next_s *=P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3] = !（P[idx][idy].S[2].next_s-3）; //如果指向3，则说

明S[2]对外不联通

P[idx][idy].selsete[0] = P[idx][idy].S[2].next_x;

P[idx][idy].selsete[1] = P[idx][idy].S[3].next_x;

P[idx][idy].S[2].next_x = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[2].next_y;

P[idx][idy].selsete[1] = P[idx][idy].S[3].next_y;

P[idx][idy].S[2].next_y = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[2].next_s;

P[idx][idy].selsete[1] = P[idx][idy].S[3].next_s;

P[idx][idy].S[2].next_s = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = 1;

P[idx][idy].selsete[1] = -10;

P[idx][idy].S[3].next_s *=P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3] = !（P[idx][idy].S[1].next_s-2）; //如果指向2，则说

明S[1]对外不联通

P[idx][idy].selsete[0] = P[idx][idy].S[1].next_x;

P[idx][idy].selsete[1] = P[idx][idy].S[2].next_x;

P[idx][idy].S[1].next_x = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[1].next_y;

P[idx][idy].selsete[1] = P[idx][idy].S[2].next_y;

P[idx][idy].S[1].next_y = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[1].next_s;

P[idx][idy].selsete[1] = P[idx][idy].S[2].next_s;

P[idx][idy].S[1].next_s = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = 1;

P[idx][idy].selsete[1] = -10;

P[idx][idy].S[2].next_s *=P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[3] = !（P[idx][idy].S[0].next_s-1）; //如果指向1，则说

明S[0]对外不联通

P[idx][idy].selsete[0] = P[idx][idy].S[0].next_x;

P[idx][idy].selsete[1] = P[idx][idy].S[1].next_x;

P[idx][idy].S[0].next_x = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[0].next_y;

P[idx][idy].selsete[1] = P[idx][idy].S[1].next_y;

P[idx][idy].S[0].next_y = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = P[idx][idy].S[0].next_s;

P[idx][idy].selsete[1] = P[idx][idy].S[1].next_s;

P[idx][idy].S[0].next_s = P[idx][idy].selsete[P[idx][idy].selsete[3]];

P[idx][idy].selsete[0] = 1;

P[idx][idy].selsete[1] = -10;

P[idx][idy].S[1].next_s *=P[idx][idy].selsete[P[idx][idy].selsete[3]];

｝。

本发明提供的一种图像轮廓有序点集提取方法，是一种方法发明，它可以通过CPU、GPU、MCU、DSP、FPGA等计算机硬件来实现。

根据发明内容说明和实施实例可知，本发明的典型实施实例并不是对本发明的限定，任何利用本发明提出的逻辑拓扑结构，并依照本发明提出的碎点连接方法进行碎点连接的图像轮廓有序点集提取方法，都应属于本发明的范畴。

Claims

1.一种图像轮廓有序点集提取方法，其的特征在于：基于一种逻辑拓扑结构，每个点对应八个碎点，一个碎点代表点的一个联通方向；将所有碎点进行连接，其方法是，如果一个碎点对应联通方向达到联通条件，则将碎点指向对应联通方向的碎点的时针方向上的下一个碎点，否则将其指向本点的时针方向上的下一个碎点。

2.如权利要求1所述，一种图像轮廓有序点集提取方法的特征在于：所述的时针方向包括顺时针和逆时针。

3.如权利要求1所述，一种图像轮廓有序点集提取方法的特征在于：所述的时针方向对所有的点都是统一的。

4.计算机视觉系统，其的特征在于：具有权利要求1的技术方案。

5.计算机视觉系统，其的特征在于：具有权利要求2的技术方案。

6.计算机视觉系统，其的特征在于：具有权利要求3的技术方案。