lolengine
/
lol
镜像来自 https://github.com/lolengine/lol
1
0
複製 0
程式碼 問題管理 0 版本發佈 0 Wiki Activity
瀏覽代碼

image: improve the convolution code and remove redundancy.

undefined
Sam Hocevar 10 年之前
父節點
2ff9a91085
當前提交
06d4d7a2cb
共有 1 個文件被更改，包括 161 次插入 和 179 次删除
統一視圖
  1. +161
    -179
      src/image/filter/convolution.cpp

+ 161
- 179
src/image/filter/convolution.cpp 查看文件

@@ -29,15 +29,15 @@ Image Image::Convolution(Array2D<float> const &kernel)
{ {
/* Find the cell with the largest value */ /* Find the cell with the largest value */
ivec2 ksize = kernel.GetSize(); ivec2 ksize = kernel.GetSize();
int besti = -1, bestj = -1; int bestx = -1, besty = -1;
float tmp = 0.f; float tmp = 0.f;
for (int j = 0; j < ksize.y; ++j) for (int dy = 0; dy < ksize.y; ++dy)
for (int i = 0; i < ksize.x; ++i) for (int dx = 0; dx < ksize.x; ++dx)
if (lol::sq(kernel[i][j] > tmp)) if (lol::sq(kernel[dx][dy] > tmp))
{ {
tmp = sq(kernel[i][j]); tmp = sq(kernel[dx][dy]);
besti = i; bestx = dx;
bestj = j; besty = dy;
} }


/* If the kernel is empty, return a copy of the picture */ /* If the kernel is empty, return a copy of the picture */
@@ -46,18 +46,18 @@ Image Image::Convolution(Array2D<float> const &kernel)


/* Check whether the matrix rank is 1 */ /* Check whether the matrix rank is 1 */
bool separable = true; bool separable = true;
for (int j = 0; j < ksize.y && separable; ++j) for (int dy = 0; dy < ksize.y && separable; ++dy)
{ {
if (j == bestj) if (dy == besty)
continue; continue;


for (int i = 0; i < ksize.x && separable; ++i) for (int dx = 0; dx < ksize.x && separable; ++dx)
{ {
if (i == besti) if (dx == bestx)
continue; continue;


float p = kernel[i][j] * kernel[besti][bestj]; float p = kernel[dx][dy] * kernel[bestx][besty];
float q = kernel[i][bestj] * kernel[besti][j]; float q = kernel[dx][besty] * kernel[bestx][dy];


if (lol::abs(p - q) > 1.0e-8f) if (lol::abs(p - q) > 1.0e-8f)
separable = false; separable = false;
@@ -69,11 +69,11 @@ Image Image::Convolution(Array2D<float> const &kernel)
/* Matrix rank is 1! Separate the filter. */ /* Matrix rank is 1! Separate the filter. */
Array<float> hvec, vvec; Array<float> hvec, vvec;


float norm = 1.0f / lol::sqrt(lol::abs(kernel[besti][bestj])); float norm = 1.0f / lol::sqrt(lol::abs(kernel[bestx][besty]));
for (int i = 0; i < ksize.x; i++) for (int dx = 0; dx < ksize.x; dx++)
hvec << norm * kernel[i][bestj]; hvec << norm * kernel[dx][besty];
for (int j = 0; j < ksize.y; j++) for (int dy = 0; dy < ksize.y; dy++)
vvec << norm * kernel[besti][j]; vvec << norm * kernel[bestx][dy];


return SepConv(*this, hvec, vvec); return SepConv(*this, hvec, vvec);
} }
@@ -83,220 +83,202 @@ Image Image::Convolution(Array2D<float> const &kernel)
} }
} }


template<PixelFormat FORMAT, int WRAP_X, int WRAP_Y>
static Image NonSepConv(Image &src, Array2D<float> const &kernel) static Image NonSepConv(Image &src, Array2D<float> const &kernel)
{ {
typedef typename PixelType<FORMAT>::type pixel_t;

ivec2 const size = src.GetSize(); ivec2 const size = src.GetSize();
ivec2 const ksize = kernel.GetSize(); ivec2 const ksize = kernel.GetSize();
Image dst(size); Image dst(size);


bool const wrap_x = src.GetWrapX() == WrapMode::Repeat; pixel_t const *srcp = src.Lock<FORMAT>();
bool const wrap_y = src.GetWrapY() == WrapMode::Repeat; pixel_t *dstp = dst.Lock<FORMAT>();


if (src.GetFormat() == PixelFormat::Y_8 for (int y = 0; y < size.y; y++)
|| src.GetFormat() == PixelFormat::Y_F32)
{ {
float const *srcp = src.Lock<PixelFormat::Y_F32>(); for (int x = 0; x < size.x; x++)
float *dstp = dst.Lock<PixelFormat::Y_F32>();

for (int y = 0; y < size.y; y++)
{ {
for (int x = 0; x < size.x; x++) pixel_t pixel(0.f);

for (int dy = 0; dy < ksize.y; dy++)
{ {
float pixel = 0.f; int y2 = y + dy - ksize.y / 2;
if (y2 < 0)
y2 = WRAP_Y ? size.y - 1 - ((-y2 - 1) % size.y) : 0;
else if (y2 >= size.y)
y2 = WRAP_Y ? y2 % size.y : size.y - 1;


for (int j = 0; j < ksize.y; j++) for (int dx = 0; dx < ksize.x; dx++)
{ {
int y2 = y + j - ksize.y / 2; float f = kernel[dx][dy];
if (y2 < 0)
y2 = wrap_y ? size.y - 1 - ((-y2 - 1) % size.y) : 0;
else if (y2 >= size.y)
y2 = wrap_y ? y2 % size.y : size.y - 1;

for (int i = 0; i < ksize.x; i++)
{
float f = kernel[i][j];

int x2 = x + i - ksize.x / 2;
if (x2 < 0)
x2 = wrap_x ? size.x - 1 - ((-x2 - 1) % size.x) : 0;
else if (x2 >= size.x)
x2 = wrap_x ? x2 % size.x : size.x - 1;

pixel += f * srcp[y2 * size.x + x2];
}
}

dstp[y * size.x + x] = lol::clamp(pixel, 0.0f, 1.0f);
}
}

src.Unlock(srcp);
dst.Unlock(dstp);
}
else
{
vec4 const *srcp = src.Lock<PixelFormat::RGBA_F32>();
vec4 *dstp = dst.Lock<PixelFormat::RGBA_F32>();


for (int y = 0; y < size.y; y++) int x2 = x + dx - ksize.x / 2;
{ if (x2 < 0)
for (int x = 0; x < size.x; x++) x2 = WRAP_X ? size.x - 1 - ((-x2 - 1) % size.x) : 0;
{ else if (x2 >= size.x)
vec4 pixel(0.f); x2 = WRAP_X ? x2 % size.x : size.x - 1;


for (int j = 0; j < ksize.y; j++) pixel += f * srcp[y2 * size.x + x2];
{
int y2 = y + j - ksize.y / 2;
if (y2 < 0)
y2 = wrap_y ? size.y - 1 - ((-y2 - 1) % size.y) : 0;
else if (y2 >= size.y)
y2 = wrap_y ? y2 % size.y : size.y - 1;

for (int i = 0; i < ksize.x; i++)
{
float f = kernel[i][j];

int x2 = x + i - ksize.x / 2;
if (x2 < 0)
x2 = wrap_x ? size.x - 1 - ((-x2 - 1) % size.x) : 0;
else if (x2 >= size.x)
x2 = wrap_x ? x2 % size.x : size.x - 1;

pixel += f * srcp[y2 * size.x + x2];
}
} }

dstp[y * size.x + x] = lol::clamp(pixel, 0.0f, 1.0f);
} }
}


src.Unlock(srcp); dstp[y * size.x + x] = lol::clamp(pixel, 0.0f, 1.0f);
dst.Unlock(dstp); }
} }


src.Unlock(srcp);
dst.Unlock(dstp);

return dst; return dst;
} }


static Image SepConv(Image &src, Array<float> const &hvec, static Image NonSepConv(Image &src, Array2D<float> const &kernel)
Array<float> const &vvec)
{ {
ivec2 const size = src.GetSize();
ivec2 const ksize = ivec2(hvec.Count(), vvec.Count());
Image dst(size);

bool const wrap_x = src.GetWrapX() == WrapMode::Repeat; bool const wrap_x = src.GetWrapX() == WrapMode::Repeat;
bool const wrap_y = src.GetWrapY() == WrapMode::Repeat; bool const wrap_y = src.GetWrapY() == WrapMode::Repeat;


if (src.GetFormat() == PixelFormat::Y_8 if (src.GetFormat() == PixelFormat::Y_8
|| src.GetFormat() == PixelFormat::Y_F32) || src.GetFormat() == PixelFormat::Y_F32)
{ {
float const *srcp = src.Lock<PixelFormat::Y_F32>(); if (wrap_x)
float *dstp = dst.Lock<PixelFormat::Y_F32>();
/* TODO: compare performances with Array2D here */
float *tmp = new float[size.x * size.y];

for (int y = 0; y < size.y; y++)
{ {
for (int x = 0; x < size.x; x++) if (wrap_y)
{ return NonSepConv<PixelFormat::Y_F32, 1, 1>(src, kernel);
float pixel = 0.f; else
return NonSepConv<PixelFormat::Y_F32, 1, 0>(src, kernel);
}
else
{
if (wrap_y)
return NonSepConv<PixelFormat::Y_F32, 0, 1>(src, kernel);
else
return NonSepConv<PixelFormat::Y_F32, 0, 0>(src, kernel);
}
}
else
{
if (wrap_x)
{
if (wrap_y)
return NonSepConv<PixelFormat::RGBA_F32, 1, 1>(src, kernel);
else
return NonSepConv<PixelFormat::RGBA_F32, 1, 0>(src, kernel);
}
else
{
if (wrap_y)
return NonSepConv<PixelFormat::RGBA_F32, 0, 1>(src, kernel);
else
return NonSepConv<PixelFormat::RGBA_F32, 0, 0>(src, kernel);
}
}
}


for (int i = 0; i < ksize.x; i++) template<PixelFormat FORMAT, int WRAP_X, int WRAP_Y>
{ static Image NonSepConv(Image &src, Array<float> const &hvec,
float f = hvec[i]; Array<float> const &vvec)
{
typedef typename PixelType<FORMAT>::type pixel_t;


int x2 = x + i - ksize.x / 2; ivec2 const size = src.GetSize();
if (x2 < 0) ivec2 const ksize(hvec.Count(), vvec.Count());
x2 = wrap_x ? size.x - 1 - ((-x2 - 1) % size.x) : 0; Image dst(size);
else if (x2 >= size.x)
x2 = wrap_x ? x2 % size.x : size.x - 1;


pixel += f * srcp[y * size.x + x2]; pixel_t const *srcp = src.Lock<FORMAT>();
} pixel_t *dstp = dst.Lock<FORMAT>();


tmp[y * size.x + x] = pixel; Array2D<pixel_t> tmp(size);
}
}


for (int y = 0; y < size.y; y++) for (int y = 0; y < size.y; y++)
{
for (int x = 0; x < size.x; x++)
{ {
for (int x = 0; x < size.x; x++) pixel_t pixel(0.f);
{
float pixel = 0.f;

for (int j = 0; j < ksize.y; j++)
{
double f = vvec[j];

int y2 = y + j - ksize.y / 2;
if (y2 < 0)
y2 = wrap_y ? size.y - 1 - ((-y2 - 1) % size.y) : 0;
else if (y2 >= size.y)
y2 = wrap_y ? y2 % size.y : size.y - 1;


pixel += f * tmp[y2 * size.x + x]; for (int dx = 0; dx < ksize.x; dx++)
} {
int x2 = x + dx - ksize.x / 2;
if (x2 < 0)
x2 = WRAP_X ? size.x - 1 - ((-x2 - 1) % size.x) : 0;
else if (x2 >= size.x)
x2 = WRAP_X ? x2 % size.x : size.x - 1;


dstp[y * size.x + x] = lol::clamp(pixel, 0.0f, 1.0f); pixel += hvec[dx] * srcp[y * size.x + x2];
} }
}


src.Unlock(srcp); tmp[x][y] = pixel;
dst.Unlock(dstp); }
} }
else
{
vec4 const *srcp = src.Lock<PixelFormat::RGBA_F32>();
vec4 *dstp = dst.Lock<PixelFormat::RGBA_F32>();
/* TODO: compare performances with Array2D here */
vec4 *tmp = new vec4[size.x * size.y];


for (int y = 0; y < size.y; y++) for (int y = 0; y < size.y; y++)
{
for (int x = 0; x < size.x; x++)
{ {
for (int x = 0; x < size.x; x++) pixel_t pixel(0.f);
{
vec4 pixel(0.f);

for (int i = 0; i < ksize.x; i++)
{
int x2 = x + i - ksize.x / 2;
if (x2 < 0)
x2 = wrap_x ? size.x - 1 - ((-x2 - 1) % size.x) : 0;
else if (x2 >= size.x)
x2 = wrap_x ? x2 % size.x : size.x - 1;


pixel += hvec[i] * srcp[y * size.x + x2]; for (int j = 0; j < ksize.y; j++)
} {
int y2 = y + j - ksize.y / 2;
if (y2 < 0)
y2 = WRAP_Y ? size.y - 1 - ((-y2 - 1) % size.y) : 0;
else if (y2 >= size.y)
y2 = WRAP_Y ? y2 % size.y : size.y - 1;


tmp[y * size.x + x] = pixel; pixel += vvec[j] * tmp[x][y2];
} }

dstp[y * size.x + x] = lol::clamp(pixel, 0.0f, 1.0f);
} }
}


for (int y = 0; y < size.y; y++) src.Unlock(srcp);
{ dst.Unlock(dstp);
for (int x = 0; x < size.x; x++)
{
vec4 pixel(0.f);


for (int j = 0; j < ksize.y; j++) return dst;
{ }
int y2 = y + j - ksize.y / 2;
if (y2 < 0)
y2 = wrap_y ? size.y - 1 - ((-y2 - 1) % size.y) : 0;
else if (y2 >= size.y)
y2 = wrap_y ? y2 % size.y : size.y - 1;


pixel += vvec[j] * tmp[y2 * size.x + x]; static Image SepConv(Image &src, Array<float> const &hvec,
} Array<float> const &vvec)
{
bool const wrap_x = src.GetWrapX() == WrapMode::Repeat;
bool const wrap_y = src.GetWrapY() == WrapMode::Repeat;


dstp[y * size.x + x] = lol::clamp(pixel, 0.0f, 1.0f); if (src.GetFormat() == PixelFormat::Y_8
} || src.GetFormat() == PixelFormat::Y_F32)
{
if (wrap_x)
{
if (wrap_y)
return NonSepConv<PixelFormat::Y_F32, 1, 1>(src, hvec, vvec);
else
return NonSepConv<PixelFormat::Y_F32, 1, 0>(src, hvec, vvec);
}
else
{
if (wrap_y)
return NonSepConv<PixelFormat::Y_F32, 0, 1>(src, hvec, vvec);
else
return NonSepConv<PixelFormat::Y_F32, 0, 0>(src, hvec, vvec);
}
}
else
{
if (wrap_x)
{
if (wrap_y)
return NonSepConv<PixelFormat::RGBA_F32, 1, 1>(src, hvec, vvec);
else
return NonSepConv<PixelFormat::RGBA_F32, 1, 0>(src, hvec, vvec);
}
else
{
if (wrap_y)
return NonSepConv<PixelFormat::RGBA_F32, 0, 1>(src, hvec, vvec);
else
return NonSepConv<PixelFormat::RGBA_F32, 0, 0>(src, hvec, vvec);
} }

src.Unlock(srcp);
dst.Unlock(dstp);
} }
return dst;
} }


} /* namespace lol */ } /* namespace lol */


Write Preview
||||||
​x
 
​
000:0
Loading…
取消
儲存