安卓：自适应阈值 [英] Android: Adaptive Thresholding
本文介绍了安卓：自适应阈值的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我想落实的德里克·布拉德利采用Android 的。但它是所有的时间返回黑色像素。这是我的code段。请建议我，我该怎么办。先谢谢了。
公共静态位图GrayscaleToBin（位图BM2）
{
位图BM;
BM = bm2.copy（Config.ARGB_8888，真正的）;
最终诠释宽度= bm.getWidth（）;
最终诠释身高= bm.getHeight（）;
INT []像素;
像素=新INT [宽*高]。
bm.getPixels（像素，0，宽度，0,0，宽度，高度）;
//布拉德利AdaptiveThrsholdging
INT [] intImg =新INT [宽*高]。
INT总和= 0;
的for（int i = 0; I＆LT;宽度; ++ I）{
总和= 0;
对于（INT J = 0; J＆LT;高度; ++ j）条
{
总和=总和+像素[I + J *宽]
如果（我== 0）{intImg [I + J *宽=总和;}
其他
{
intImg [I + J *宽= intImg [I-1 + J *宽] +总和;
}
}
}
INT X1，X2，Y1，Y2 = 0，计数= 0;
INT S =宽度GT;＆GT; 3;
诠释T = 15;
的for（int i = 0; I＆LT;宽度; ++ I）
{
对于（INT J = 0; J＆LT;高度; ++ j）条
{
X1 = I-S / 2;
X2 = I + S / 2;
Y1 = J-S / 2;
Y2 = j的+ S / 2;
如果（X1＆小于0）×1 = 0;
如果（X2＆GT; =宽）×2 =宽度-1;
如果体（y1℃，）Y1 = 0;
如果（Y＆GT; =高）Y2 =身高-1;
数=（X2-X1）*（Y2-Y1）;
总和= intImg [Y2 *宽+ X2] -
intImg [Y1 *宽+ X2] -
intImg [Y2 *宽+ X1] +
intImg [Y1 *宽+ X1]
如果（（像素[I + J *宽*计）LT =（总和*（100-T）/ 100））
{
像素[I + J *宽] = 0;
}
其他
{
像素[I + J *宽] = 255;
}
}
}
/ * ------------------------------------------------ --------------------------- * /
bm.setPixels（像素，0，宽度，0,0，宽度，高度）;
// Log.d（cdsfss，afterloop）;
返回BM;
}
解决方案
一个长期的斗争我已经解决了这个问题，下面code后。
公共静态位图GrayscaleToBin（位图BM2）
{
位图BM;
BM = bm2.copy（Config.RGB_565，真正的）;
最终诠释宽度= bm.getWidth（）;
最终诠释身高= bm.getHeight（）;
INT pixel1，pixel2，pixel3类型，pixel3 pixel4，A，R;
INT []像素;
像素=新INT [宽*高]。
bm.getPixels（像素，0，宽度，0,0，宽度，高度）;
INT尺寸=宽*高;
INT S =宽度/ 8;
INT S2 = S取代;大于1;
双T = 0.15;
加倍= 1.0吨;
INT []积分=新INT [尺寸]
INT []阈值=新INT [尺寸]
INT I，J，差异，X1，Y1，X2，Y2，IND1，IND2，IND3;
INT总和= 0;
INT的ind = 0;
而（IND＆LT;大小）
{
总和+ =像素[IND]放大器; 0xFF的;
积分[IND] =总和;
IND + =宽度;
}
X1 = 0;
对于（i = 1; I＆LT;宽度; ++ I）
{
总和= 0;
IND =我;
IND3 = IND-S2;
如果（ⅰ＆GT氏）
{
X1 = I-S;
}
差异= I-X1;
为（J = 0; J＆LT;高度; ++ j）条
{
总和+ =像素[IND]放大器; 0xFF的;
积分[IND] =积分[（int）的（IND-1）] +和;
IND + =宽度;
如果（I＆LT; S2）继续;
如果（J＆LT; S2）继续;
Y1 =（J＆LT; S 0：J-S）;
IND1 = Y1 *宽;
IND2 = j的*宽;
如果（（（象素[IND3]安培;为0xFF）*（差异*（j - Y1）））≤（（积分[（int）的（IND2 + I）] - 积分[（int）的（IND1 + I）] - 积分[（int）的（IND2 + 1次）] +积分[（int）的（IND1 + 1次）]）*它））{
阈值[IND3] = 0×00;
} 其他 {
阈值[IND3] = 0XFFFFFF;
}
IND3 + =宽度;
}
}
Y1 = 0;
为（J = 0; J＆LT;高度; ++ j）条
{
I = 0;
Y2 =高度 - 1;
如果（J＆LT;高度 - S2）
{
I =宽度 - S2;
Y2 = J + S2;
}
IND = j的*宽+我;
如果（J＆GT; S2）Y1 =的J - S2;
IND1 = Y1 *宽;
IND2 = Y2 *宽;
差异= Y2 - Y1;
对于（; I＆LT;宽度; ++我，++ IND）
{
X1 =（ⅰ＆所述; s2的？0：I - S2）;
X2 = I + S2;
//检查边界
如果（X2＆GT; =宽）×2 =宽度 - 1;
如果（（（象素[IND]安培;为0xFF）*（（2次 - 1次）*差异））≤（（积分[（int）的（IND2 + X2）〕 - 积分[（int）的（IND1 +×2）] - 积分[（int）的（IND2 + 1次）] +积分[（int）的（IND1 + 1次）]）*它））{
阈值[IND] = 0×00;
} 其他 {
阈值[IND] = 0XFFFFFF;
}
}
}
/ * -------------------------------
* -------------------------------------------- * /
bm.setPixels（阈值0，宽度，0,0，宽度，高度）;
返回BM;
}
I'm trying to implement adaptive thresholding algorithm by Derek Bradley using Android. But it is returning black pixels all the time. Here is my code snippet. Please suggest me about what should I do. Thanks in advance.
public static Bitmap GrayscaleToBin(Bitmap bm2)
{
Bitmap bm;
bm=bm2.copy(Config.ARGB_8888, true);
final int width = bm.getWidth();
final int height = bm.getHeight();
int[] pixels;
pixels = new int[width*height];
bm.getPixels(pixels,0,width,0,0,width,height);
//Bradley AdaptiveThrsholdging
int []intImg= new int[width*height];
int sum=0;
for(int i=0;i<width;++i){
sum=0;
for(int j=0;j<height;++j)
{
sum=sum+pixels[i+j*width];
if(i==0){intImg[i+j*width]=sum;}
else
{
intImg[i+j*width]= intImg[i-1+j*width]+sum;
}
}
}
int x1,x2,y1,y2=0,count=0;
int s=width >> 3;
int t=15;
for(int i=0;i<width;++i)
{
for(int j=0;j<height;++j)
{
x1=i-s/2;
x2=i+s/2;
y1=j-s/2;
y2=j+s/2;
if (x1 <0) x1 = 0;
if (x2>= width) x2 = width-1;
if (y1 <0) y1 = 0;
if (y2>= height) y2 = height-1;
count = (x2-x1) * (y2-y1);
sum = intImg [y2 * width + x2] -
intImg [y1 * width + x2] -
intImg [y2 * width + x1] +
intImg [y1 * width + x1];
if((pixels[i+j*width]*count)<=(sum*(100-t)/100))
{
pixels[i+j*width]=0;
}
else
{
pixels[i+j*width]=255;
}
}
}
/*---------------------------------------------------------------------------*/
bm.setPixels(pixels,0,width,0,0,width,height);
// Log.d("cdsfss","afterloop");
return bm;
}
解决方案
After a Long struggle I have solved the issue with the following code.
public static Bitmap GrayscaleToBin(Bitmap bm2)
{
Bitmap bm;
bm=bm2.copy(Config.RGB_565, true);
final int width = bm.getWidth();
final int height = bm.getHeight();
int pixel1,pixel2,pixel3,pixel4,A,R;
int[] pixels;
pixels = new int[width*height];
bm.getPixels(pixels,0,width,0,0,width,height);
int size=width*height;
int s=width/8;
int s2=s>>1;
double t=0.15;
double it=1.0-t;
int []integral= new int[size];
int []threshold=new int[size];
int i,j,diff,x1,y1,x2,y2,ind1,ind2,ind3;
int sum=0;
int ind=0;
while(ind<size)
{
sum+=pixels[ind] & 0xFF;
integral[ind]=sum;
ind+=width;
}
x1=0;
for(i=1;i<width;++i)
{
sum=0;
ind=i;
ind3=ind-s2;
if(i>s)
{
x1=i-s;
}
diff=i-x1;
for(j=0;j<height;++j)
{
sum+=pixels[ind] & 0xFF;
integral[ind]=integral[(int)(ind-1)]+sum;
ind+=width;
if(i<s2)continue;
if(j<s2)continue;
y1=(j<s ? 0 : j-s);
ind1=y1*width;
ind2=j*width;
if (((pixels[ind3]&0xFF)*(diff * (j - y1))) < ((integral[(int)(ind2 + i)] - integral[(int)(ind1 + i)] - integral[(int)(ind2 + x1)] + integral[(int)(ind1 + x1)])*it)) {
threshold[ind3] = 0x00;
} else {
threshold[ind3] = 0xFFFFFF;
}
ind3 += width;
}
}
y1 = 0;
for( j = 0; j < height; ++j )
{
i = 0;
y2 =height- 1;
if( j <height- s2 )
{
i = width - s2;
y2 = j + s2;
}
ind = j * width + i;
if( j > s2 ) y1 = j - s2;
ind1 = y1 * width;
ind2 = y2 * width;
diff = y2 - y1;
for( ; i < width; ++i, ++ind )
{
x1 = ( i < s2 ? 0 : i - s2);
x2 = i + s2;
// check the border
if (x2 >= width) x2 = width - 1;
if (((pixels[ind]&0xFF)*((x2 - x1) * diff)) < ((integral[(int)(ind2 + x2)] - integral[(int)(ind1 + x2)] - integral[(int)(ind2 + x1)] + integral[(int)(ind1 + x1)])*it)) {
threshold[ind] = 0x00;
} else {
threshold[ind] = 0xFFFFFF;
}
}
}
/*-------------------------------
* --------------------------------------------*/
bm.setPixels(threshold,0,width,0,0,width,height);
return bm;
}
这篇关于安卓：自适应阈值的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
