131 lines
3.6 KiB
C++
131 lines
3.6 KiB
C++
#pragma once
|
|
|
|
#include <cmath>
|
|
#include <vector>
|
|
|
|
#include "Image2D.h"
|
|
#include "BoxSizes.h"
|
|
|
|
template <class T>
|
|
struct BoxGaus
|
|
{
|
|
void boxfilter(std::vector<T>& input, size_t w, size_t h, unsigned filterSize)
|
|
{
|
|
assertMsg((filterSize % 2) == 1, "filterSize must be odd");
|
|
|
|
unsigned radius = filterSize / 2;
|
|
|
|
std::vector<T> buffer(input.size());
|
|
boxBlur(input, buffer, w, h, radius);
|
|
boxBlur(buffer, input, w, h, radius);
|
|
}
|
|
|
|
void approxGaus(Image2D<T>& input, T sigmaX, T sigmaY, unsigned nFilt)
|
|
{
|
|
approxGaus(input.data(), input.width, input.height, sigmaX, sigmaY, nFilt);
|
|
}
|
|
|
|
void approxGaus(std::vector<T>& input, size_t w, size_t h, T sigmaX, T sigmaY, unsigned nFilt)
|
|
{
|
|
BoxSizes<T> bsX(sigmaX, nFilt);
|
|
BoxSizes<T> bsY(sigmaY, nFilt);
|
|
std::vector<T> buffer(input.size());
|
|
|
|
assertMsg((2 * bsX.wl + 1 < w) && (2 * bsX.wl + 1 < h), "Box-Filter size in X direction is too big");
|
|
assertMsg((2 * bsX.wu + 1 < w) && (2 * bsX.wu + 1 < h), "Box-Filter size in X direction is too big");
|
|
assertMsg((2 * bsY.wl + 1 < w) && (2 * bsY.wl + 1 < h), "Box-Filter size in Y direction is too big");
|
|
assertMsg((2 * bsY.wu + 1 < w) && (2 * bsY.wu + 1 < h), "Box-Filter size in Y direction is too big");
|
|
|
|
// if equal, we can save some cond's inside the loop
|
|
if (bsX.m == bsY.m)
|
|
{
|
|
const size_t m = bsX.m;
|
|
|
|
for (size_t i = 0; i < m; i++)
|
|
{
|
|
boxBlur(input, buffer, w, h, bsY.wl);
|
|
boxBlur(buffer, input, w, h, bsX.wl);
|
|
}
|
|
|
|
for (size_t i = 0; i < nFilt - m; i++)
|
|
{
|
|
boxBlur(input, buffer, w, h, bsY.wu);
|
|
boxBlur(buffer, input, w, h, bsX.wu);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < nFilt; i++)
|
|
{
|
|
boxBlur(input, buffer, w, h, (i < bsY.m ? bsY.wl : bsY.wu) );
|
|
boxBlur(buffer, input, w, h, (i < bsX.m ? bsX.wl : bsX.wu));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private:
|
|
void boxBlur(const std::vector<T> &src, std::vector<T> &dst, size_t w, size_t h, size_t r)
|
|
{
|
|
T iarr = (T)1.0 / (r + r + 1);
|
|
|
|
for (size_t i = 0; i < w; i++)
|
|
{
|
|
// Init indexes
|
|
size_t ti = i;
|
|
size_t li = ti;
|
|
size_t ri = ti + r*w;
|
|
|
|
// Init values
|
|
T fv = src[ti]; // first values
|
|
T lv = src[ti + w*(h - 1)]; // last values
|
|
T val = fv * (r + 1); // overhang over image border
|
|
|
|
for (size_t j = 0; j < r; j++)
|
|
{
|
|
val += src[ti + j*w]; // col sum
|
|
}
|
|
|
|
// Überhangbereich links vom Bild
|
|
for (size_t j = 0; j <= r; j++)
|
|
{
|
|
val += src[ri] - fv;
|
|
dst[i + j*w] = val * iarr;
|
|
|
|
ri += w;
|
|
ti += w;
|
|
}
|
|
|
|
// Bildbereich
|
|
for (size_t j = r + 1; j < h - r; j++)
|
|
{
|
|
val += src[ri] - src[li];
|
|
dst[i + j*w] = val * iarr;
|
|
|
|
li += w;
|
|
ri += w;
|
|
ti += w;
|
|
}
|
|
|
|
// Überhangbereich rechts vom Bild
|
|
for (size_t j = h - r; j < h; j++)
|
|
{
|
|
val += lv - src[li];
|
|
dst[i + j*w] = val * iarr;
|
|
|
|
li += w;
|
|
ti += w;
|
|
}
|
|
}
|
|
|
|
int test = 0;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|