如何从图像中检测机器人方向？
How to detect robot direction from Image?
我正在开发可以 运行 在玉米植物中并由罗盘传感器引导的机器人，但我想将相机用作机器人的眼睛并使用图像处理来检测运动的误差角度.
这是图片示例。
处理后的图像
原始图像
分割图像
我使用以下步骤
第 1 步：我目前使用的技术是将颜色值转换为从 this code
第 2 步：所以它会检测选定的颜色，即棕色或污垢颜色，然后我收集两个数组中每个图像行的最左边和最右边的棕色或选定颜色（一个红点).
- 第 3 步：我将 2 线性回归线绘制为蓝色点，并将交点计算为粉红色点
- 第 4 步：绘制绿线以将粉红色点与其他图像进行比较。我还不确定如何处理这条绿线
- 问题是玉米叶之间也存在污垢或棕色，所以我让我的代码错过了计算
问题是如何过滤掉玉米叶之间或其他不在玉米路径中的区域的棕色像素？我应该研究或应用哪种算法或方法来解决这个问题？
EDIT1：使用 Spektre 的答案，看起来更好
这是我用 JAVA+Boofcv
应用后的结果
步骤 1：阈值化或颜色分割
第 2 步：模糊（使用高斯和中值滤波器）
第 3 步：绘制线性回归
More Information
如果我是对的，你问的是被误认为是棕色的部分还是在背景的其他部分？
你是怎么得到最后一张图片的？我假设您将原始图像乘以蒙版？即使您没有，您也可以通过选择图像存在的位置来简单地从图像中获取蒙版（任何简单的、非常低的阈值都可以）。 （应用自适应阈值，一个更准确的原始版本以获得更好的蒙版）
拿那个面具并使用形态学操作清理它，在你的情况下关闭就足够了。形态学由大量操作组成，可以为您提供极其干净的图像蒙版。仔细阅读它们。
对于您的源图像
我会：
制作棕色面具
只是阈值 H,S 并忽略 V，你已经有了这个。我使用整数 255 而不是颜色 (Blue) 进行后期计算。
模糊蒙版
这将删除一小群错误选择的部分。在此之后你应该再次对蒙版进行阈值处理，因为蒙版值会比 255 小一点，除非你有完全选择的区域。面积越大数值越大（接近255）。我用 >=150
水平扫描蒙版
为每一行找到所有选定像素的重心
再次模糊和阈值处理后，使用的蒙版在 Aqua 中。因此计算每行中所有屏蔽像素的平均点 x 坐标。这个点用White.
通过所有重心的回归线
我用我的 来做这个，但你可以使用任何你想要的回归。回归线标有红色
我使用线方程 x=x0+y*dx 其中 y=<0,pic1.ys>。并按时间间隔搜索解决方案：
x0=<-pic1.xs,+2*pic1.xs>
dx=<-10,+10>
其中 pic1.xs,pic1.ys 是图像分辨率。因此，正如您所看到的，我没有涵盖所有角度范围，但我认为这无论如何都不适用于那些边缘情况（接近水平方向）。对于这种情况，您应该在垂直线上执行此操作，并改用 x=y0+x*dy。
这里是 C++ 来源我用：
picture pic0,pic1;
// pic0 - source img
// pic1 - output img
int x,y,h,s,v,px,pn,*p;
color c;
// copy source image to output
pic1=pic0;
pic1.save("cornbot0.png");
// create brown stuff mask
for (y=0;y<pic1.ys;y++) // scan all H lines
for (x=0;x<pic1.xs;x++) // scan actual H line
{
c=pic1.p[y][x]; // get pixel color
rgb2hsv(c); // in HSV
h=WORD(c.db[picture::_h]);
s=WORD(c.db[picture::_s]);
v=WORD(c.db[picture::_v]);
// Treshold brownish stuff
if ((abs(h- 20)<10)&&(abs(s-200)<50)) c.dd=255; else c.dd=0;
pic1.p[y][x]=c;
}
pic1.save("cornbot1.png");
pic1.smooth(10); // blur a bit to remove small clusters as marked
pic1.save("cornbot2.png");
// compute centers of gravity
p=new int[pic1.ys]; // make space for points
for (y=0;y<pic1.ys;y++) // scan all H lines
{
px=0; pn=0; // init center of gravity (avg point) variables
for (x=0;x<pic1.xs;x++) // scan actual H line
if (pic1.p[y][x].dd>=150) // use marked points only
{
px+=x; pn++; // add it to avg point
pic1.p[y][x].dd=0x00004080; // mark used points (after smooth) with Aqua
}
if (pn) // finish avg point computation
{
px/=pn;
pic1.p[y][px].dd=0x00FFFFFF;// mark it by White
p[y]=px; // store result for line regression
} else p[y]=-1; // uncomputed value
}
// regress line
approx x0,dx;
double ee;
for (x0.init(-pic1.xs,pic1.xs<<1,100,3,&ee); !x0.done; x0.step()) // search x0
for (dx.init(-10.0 ,+10.0 ,1.0,3,&ee); !dx.done; dx.step()) // search dx
for (ee=0.0,y=0;y<pic1.ys;y++) // compute actua solution distance to dataset
if (p[y]!=-1) // ignore uncomputed values (no brown stuff)
ee+=fabs(double(p[y])-x0.a-(double(y)*dx.a));
// render regressed line with Red
for (y=0;y<pic1.ys;y++)
{
x=double(x0.aa+(double(y)*dx.aa));
if ((x>=0)&&(x<pic1.xs))
pic1.p[y][x].dd=0x00FF0000;
}
pic1.save("cornbot2.png");
delete[] p;
我使用自己的 picture class 来制作图片，所以一些成员是：
xs,ys 图像大小（以像素为单位）p[y][x].dd是(x,y)位置的像素，为32位整数类型p[y][x].dw[2] 是 (x,y) 位置的像素，作为 2D 字段 p[y][x].db[4]是(x,y)位置的像素，为4x8位整数类型，便于通道访问clear(color) - 清除整个图像resize(xs,ys) - 将图像调整为新分辨率bmp - VCL 封装 GDI 位图 Canvas 访问 smooth(n) - 快速模糊图像 n 次
您可以通过基于区域和位置的分割（删除小簇）进一步改进这一点。您也可以忽略邻居之间的平均点中太大的峰值。您还可以检测天空并忽略存在天空的整个区域。
[edit1] 平滑
这是我平滑的样子：
void picture::smooth(int n)
{
color *q0,*q1;
int x,y,i,c0[4],c1[4],c2[4];
bool _signed;
if ((xs<2)||(ys<2)) return;
for (;n>0;n--)
{
#define loop_beg for (y=0;y<ys-1;y++){ q0=p[y]; q1=p[y+1]; for (x=0;x<xs-1;x++) { dec_color(c0,q0[x],pf); dec_color(c1,q0[x+1],pf); dec_color(c2,q1[x],pf);
#define loop_end enc_color(c0,q0[x ],pf); }}
if (pf==_pf_rgba) loop_beg for (i=0;i<4;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])>>2; clamp_u8(c0[i]); } loop_end
if (pf==_pf_s ) loop_beg { c0[0]=(c0[0]+c0[0]+c1[0]+c2[0])/ 4; clamp_s32(c0[0]); } loop_end
if (pf==_pf_u ) loop_beg { c0[0]=(c0[0]+c0[0]+c1[0]+c2[0])>>2; clamp_u32(c0[0]); } loop_end
if (pf==_pf_ss ) loop_beg for (i=0;i<2;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])/ 4; clamp_s16(c0[i]); } loop_end
if (pf==_pf_uu ) loop_beg for (i=0;i<2;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])>>2; clamp_u16(c0[i]); } loop_end
#undef loop_beg
#define loop_beg for (y=ys-1;y>0;y--){ q0=p[y]; q1=p[y-1]; for (x=xs-1;x>0;x--) { dec_color(c0,q0[x],pf); dec_color(c1,q0[x-1],pf); dec_color(c2,q1[x],pf);
if (pf==_pf_rgba) loop_beg for (i=0;i<4;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])>>2; clamp_u8(c0[i]); } loop_end
if (pf==_pf_s ) loop_beg { c0[0]=(c0[0]+c0[0]+c1[0]+c2[0])/ 4; clamp_s32(c0[0]); } loop_end
if (pf==_pf_u ) loop_beg { c0[0]=(c0[0]+c0[0]+c1[0]+c2[0])>>2; clamp_u32(c0[0]); } loop_end
if (pf==_pf_ss ) loop_beg for (i=0;i<2;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])/ 4; clamp_s16(c0[i]); } loop_end
if (pf==_pf_uu ) loop_beg for (i=0;i<2;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])>>2; clamp_u16(c0[i]); } loop_end
#undef loop_beg
#undef loop_end
}
}
它只是对3个像素进行加权平均
(x,y)=(2*(x,y)+(x-1,y)+(x,y-1))/4
然后用
做同样的事情
(x,y)=(2*(x,y)+(x+1,y)+(x,y+1))/4
以避免图像偏移。然后整个事情循环 n 次，仅此而已。你可以忽略钳位和像素格式选项，在这种情况下它是 pf==_pf_rgba 但无论如何它只使用单通道...... dec_color,enc_color 只是解压，打包颜色通道 into/from 变量数组到避免 8 位通道上的截断和溢出问题，并且 format/simplify 代码更好一点（对于不同的像素格式支持）
顺便说一句，平滑基础与
的卷积相同
0.00 0.25 0.00
0.25 0.50 0.00
0.00 0.00 0.00
和
0.00 0.00 0.00
0.00 0.50 0.25
0.00 0.25 0.00
我正在开发可以 运行 在玉米植物中并由罗盘传感器引导的机器人，但我想将相机用作机器人的眼睛并使用图像处理来检测运动的误差角度.
这是图片示例。
处理后的图像
我使用以下步骤
第 1 步：我目前使用的技术是将颜色值转换为从 this code
修改而来的 HSV
第 2 步：所以它会检测选定的颜色，即棕色或污垢颜色，然后我收集两个数组中每个图像行的最左边和最右边的棕色或选定颜色（一个红点).
- 第 3 步：我将 2 线性回归线绘制为蓝色点，并将交点计算为粉红色点
- 第 4 步：绘制绿线以将粉红色点与其他图像进行比较。我还不确定如何处理这条绿线
- 问题是玉米叶之间也存在污垢或棕色，所以我让我的代码错过了计算
问题是如何过滤掉玉米叶之间或其他不在玉米路径中的区域的棕色像素？我应该研究或应用哪种算法或方法来解决这个问题？
EDIT1：使用 Spektre 的答案，看起来更好
这是我用 JAVA+Boofcv
应用后的结果步骤 1：阈值化或颜色分割
第 2 步：模糊（使用高斯和中值滤波器）
第 3 步：绘制线性回归
More Information
如果我是对的，你问的是被误认为是棕色的部分还是在背景的其他部分？
你是怎么得到最后一张图片的？我假设您将原始图像乘以蒙版？即使您没有，您也可以通过选择图像存在的位置来简单地从图像中获取蒙版（任何简单的、非常低的阈值都可以）。 （应用自适应阈值，一个更准确的原始版本以获得更好的蒙版）
拿那个面具并使用形态学操作清理它，在你的情况下关闭就足够了。形态学由大量操作组成，可以为您提供极其干净的图像蒙版。仔细阅读它们。
对于您的源图像
我会：
制作棕色面具
只是阈值
H,S并忽略V，你已经有了这个。我使用整数255而不是颜色 (Blue) 进行后期计算。模糊蒙版
这将删除一小群错误选择的部分。在此之后你应该再次对蒙版进行阈值处理，因为蒙版值会比
255小一点，除非你有完全选择的区域。面积越大数值越大（接近255）。我用>=150 作为门槛
水平扫描蒙版
为每一行找到所有选定像素的重心
再次模糊和阈值处理后，使用的蒙版在 Aqua 中。因此计算每行中所有屏蔽像素的平均点
x坐标。这个点用White. 标记
通过所有重心的回归线
我用我的
我使用线方程
x=x0+y*dx其中y=<0,pic1.ys>。并按时间间隔搜索解决方案：x0=<-pic1.xs,+2*pic1.xs> dx=<-10,+10>
其中 pic1.xs,pic1.ys 是图像分辨率。因此，正如您所看到的，我没有涵盖所有角度范围，但我认为这无论如何都不适用于那些边缘情况（接近水平方向）。对于这种情况，您应该在垂直线上执行此操作，并改用 x=y0+x*dy。
这里是 C++ 来源我用：
picture pic0,pic1;
// pic0 - source img
// pic1 - output img
int x,y,h,s,v,px,pn,*p;
color c;
// copy source image to output
pic1=pic0;
pic1.save("cornbot0.png");
// create brown stuff mask
for (y=0;y<pic1.ys;y++) // scan all H lines
for (x=0;x<pic1.xs;x++) // scan actual H line
{
c=pic1.p[y][x]; // get pixel color
rgb2hsv(c); // in HSV
h=WORD(c.db[picture::_h]);
s=WORD(c.db[picture::_s]);
v=WORD(c.db[picture::_v]);
// Treshold brownish stuff
if ((abs(h- 20)<10)&&(abs(s-200)<50)) c.dd=255; else c.dd=0;
pic1.p[y][x]=c;
}
pic1.save("cornbot1.png");
pic1.smooth(10); // blur a bit to remove small clusters as marked
pic1.save("cornbot2.png");
// compute centers of gravity
p=new int[pic1.ys]; // make space for points
for (y=0;y<pic1.ys;y++) // scan all H lines
{
px=0; pn=0; // init center of gravity (avg point) variables
for (x=0;x<pic1.xs;x++) // scan actual H line
if (pic1.p[y][x].dd>=150) // use marked points only
{
px+=x; pn++; // add it to avg point
pic1.p[y][x].dd=0x00004080; // mark used points (after smooth) with Aqua
}
if (pn) // finish avg point computation
{
px/=pn;
pic1.p[y][px].dd=0x00FFFFFF;// mark it by White
p[y]=px; // store result for line regression
} else p[y]=-1; // uncomputed value
}
// regress line
approx x0,dx;
double ee;
for (x0.init(-pic1.xs,pic1.xs<<1,100,3,&ee); !x0.done; x0.step()) // search x0
for (dx.init(-10.0 ,+10.0 ,1.0,3,&ee); !dx.done; dx.step()) // search dx
for (ee=0.0,y=0;y<pic1.ys;y++) // compute actua solution distance to dataset
if (p[y]!=-1) // ignore uncomputed values (no brown stuff)
ee+=fabs(double(p[y])-x0.a-(double(y)*dx.a));
// render regressed line with Red
for (y=0;y<pic1.ys;y++)
{
x=double(x0.aa+(double(y)*dx.aa));
if ((x>=0)&&(x<pic1.xs))
pic1.p[y][x].dd=0x00FF0000;
}
pic1.save("cornbot2.png");
delete[] p;
我使用自己的 picture class 来制作图片，所以一些成员是：
xs,ys图像大小（以像素为单位）p[y][x].dd是(x,y)位置的像素，为32位整数类型p[y][x].dw[2]是(x,y)位置的像素，作为 2D 字段 的 2x16 位整数类型
p[y][x].db[4]是(x,y)位置的像素，为4x8位整数类型，便于通道访问clear(color)- 清除整个图像resize(xs,ys)- 将图像调整为新分辨率bmp- VCL 封装 GDI 位图 Canvas 访问smooth(n)- 快速模糊图像n次
您可以通过基于区域和位置的分割（删除小簇）进一步改进这一点。您也可以忽略邻居之间的平均点中太大的峰值。您还可以检测天空并忽略存在天空的整个区域。
[edit1] 平滑
这是我平滑的样子：
void picture::smooth(int n)
{
color *q0,*q1;
int x,y,i,c0[4],c1[4],c2[4];
bool _signed;
if ((xs<2)||(ys<2)) return;
for (;n>0;n--)
{
#define loop_beg for (y=0;y<ys-1;y++){ q0=p[y]; q1=p[y+1]; for (x=0;x<xs-1;x++) { dec_color(c0,q0[x],pf); dec_color(c1,q0[x+1],pf); dec_color(c2,q1[x],pf);
#define loop_end enc_color(c0,q0[x ],pf); }}
if (pf==_pf_rgba) loop_beg for (i=0;i<4;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])>>2; clamp_u8(c0[i]); } loop_end
if (pf==_pf_s ) loop_beg { c0[0]=(c0[0]+c0[0]+c1[0]+c2[0])/ 4; clamp_s32(c0[0]); } loop_end
if (pf==_pf_u ) loop_beg { c0[0]=(c0[0]+c0[0]+c1[0]+c2[0])>>2; clamp_u32(c0[0]); } loop_end
if (pf==_pf_ss ) loop_beg for (i=0;i<2;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])/ 4; clamp_s16(c0[i]); } loop_end
if (pf==_pf_uu ) loop_beg for (i=0;i<2;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])>>2; clamp_u16(c0[i]); } loop_end
#undef loop_beg
#define loop_beg for (y=ys-1;y>0;y--){ q0=p[y]; q1=p[y-1]; for (x=xs-1;x>0;x--) { dec_color(c0,q0[x],pf); dec_color(c1,q0[x-1],pf); dec_color(c2,q1[x],pf);
if (pf==_pf_rgba) loop_beg for (i=0;i<4;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])>>2; clamp_u8(c0[i]); } loop_end
if (pf==_pf_s ) loop_beg { c0[0]=(c0[0]+c0[0]+c1[0]+c2[0])/ 4; clamp_s32(c0[0]); } loop_end
if (pf==_pf_u ) loop_beg { c0[0]=(c0[0]+c0[0]+c1[0]+c2[0])>>2; clamp_u32(c0[0]); } loop_end
if (pf==_pf_ss ) loop_beg for (i=0;i<2;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])/ 4; clamp_s16(c0[i]); } loop_end
if (pf==_pf_uu ) loop_beg for (i=0;i<2;i++) { c0[i]=(c0[i]+c0[i]+c1[i]+c2[i])>>2; clamp_u16(c0[i]); } loop_end
#undef loop_beg
#undef loop_end
}
}
它只是对3个像素进行加权平均
(x,y)=(2*(x,y)+(x-1,y)+(x,y-1))/4
然后用
做同样的事情(x,y)=(2*(x,y)+(x+1,y)+(x,y+1))/4
以避免图像偏移。然后整个事情循环 n 次，仅此而已。你可以忽略钳位和像素格式选项，在这种情况下它是 pf==_pf_rgba 但无论如何它只使用单通道...... dec_color,enc_color 只是解压，打包颜色通道 into/from 变量数组到避免 8 位通道上的截断和溢出问题，并且 format/simplify 代码更好一点（对于不同的像素格式支持）
顺便说一句，平滑基础与
的卷积相同0.00 0.25 0.00
0.25 0.50 0.00
0.00 0.00 0.00
和
0.00 0.00 0.00
0.00 0.50 0.25
0.00 0.25 0.00