295 lines
9.7 KiB
C++
295 lines
9.7 KiB
C++
#pragma once
|
|
|
|
#ifndef TCG_IMAGE_OPS_HPP
|
|
#define TCG_IMAGE_OPS_HPP
|
|
|
|
// tcg includes
|
|
#include "../image_ops.h"
|
|
#include "../pixel.h"
|
|
#include "../unique_ptr.h"
|
|
|
|
// STD includes
|
|
#include <assert.h>
|
|
#include <memory>
|
|
|
|
namespace tcg
|
|
{
|
|
namespace image_ops
|
|
{
|
|
|
|
//**************************************************************************
|
|
// Flat Blur implementation
|
|
//**************************************************************************
|
|
|
|
template <typename PtrIn, typename PtrOut, typename PixSum>
|
|
void _flatFilterLine(PtrIn in, PtrOut out, int lx, int addIn, int addOut,
|
|
int radius, PixSum *sums)
|
|
{
|
|
typedef typename std::iterator_traits<PtrIn> trIn;
|
|
typedef typename trIn::value_type pixIn_type;
|
|
|
|
struct locals {
|
|
inline static void fillSums(int lx, int radius, PtrIn lineIn, PixSum *pixsum, int addIn, int addSum)
|
|
{
|
|
using namespace pixel_ops;
|
|
|
|
PtrIn newPixIn = lineIn;
|
|
|
|
PixSum sum;
|
|
|
|
// Build up to radius pixels adding new pixels only
|
|
int x, xNew, xEnd = tmin(radius, lx);
|
|
|
|
for (xNew = 0; xNew != xEnd; ++xNew, newPixIn += addIn)
|
|
sum = sum + *newPixIn;
|
|
|
|
// Store sums AND add new pixels. Observe that the current pixel value is decreased
|
|
// BEFORE storage. This makes this function "strict" in calculating the sums.
|
|
for (x = 0; xNew != lx; ++x, ++xNew, lineIn += addIn, newPixIn += addIn, pixsum += addSum) {
|
|
sum = (sum + *newPixIn) - *lineIn;
|
|
*pixsum = *pixsum + sum;
|
|
}
|
|
|
|
// Finally, without adding new pixels
|
|
for (; x != lx; ++x, lineIn += addIn, pixsum += addSum) {
|
|
sum = sum - *lineIn;
|
|
*pixsum = *pixsum + sum;
|
|
}
|
|
}
|
|
};
|
|
|
|
memset(sums, 0, lx * sizeof(PixSum));
|
|
|
|
// Add *strict* halves of the convolution sums
|
|
locals::fillSums(lx, radius, in, sums, addIn, 1); // Right part of the convolution
|
|
locals::fillSums(lx, radius, in + addIn * (lx - 1), sums + lx - 1, -addIn, -1); // Left ...
|
|
|
|
// Normalize sums
|
|
int diameter = 2 * radius + 1;
|
|
|
|
for (int x = 0; x != lx; ++x, in += addIn, out += addOut, ++sums) {
|
|
using namespace pixel_ops;
|
|
|
|
pixIn_type pix(*in);
|
|
pixel_ops::assign(pix, (*sums + pix) / diameter); // Note that *in is added, due *strict*
|
|
// halving the sums above
|
|
*out = pix;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
template <typename PtrIn, typename PtrOut, typename PixSum, typename SelectorFunc>
|
|
void _flatFilterLine(PtrIn in, PtrOut out, int lx, int addIn, int addOut,
|
|
SelectorFunc selector, int radius, PixSum *sums, int *counts)
|
|
{
|
|
typedef typename std::iterator_traits<PtrIn> trIn;
|
|
typedef typename trIn::value_type pixIn_type;
|
|
|
|
struct locals {
|
|
inline static void fillSums(int lx, int radius, PtrIn lineIn, PixSum *pixsum, int *pixcount,
|
|
int addIn, int addSum, SelectorFunc selector)
|
|
{
|
|
using namespace pixel_ops;
|
|
|
|
PtrIn newPixIn = lineIn;
|
|
|
|
PixSum sum;
|
|
int count = 0;
|
|
|
|
// Build up to radius pixels adding new pixels only
|
|
int x, xNew, xEnd = tmin(radius, lx);
|
|
|
|
for (xNew = 0; xNew != xEnd; ++xNew, newPixIn += addIn) {
|
|
const pixIn_type &npi = *newPixIn;
|
|
|
|
if (selector(npi))
|
|
sum = sum + npi, ++count;
|
|
}
|
|
|
|
// Store sums AND add new pixels. Observe that the current pixel value is decreased
|
|
// BEFORE storage. This makes this function "strict" in calculating the sums.
|
|
for (x = 0; xNew != lx; ++x, ++xNew, lineIn += addIn, newPixIn += addIn,
|
|
pixsum += addSum, pixcount += addSum) {
|
|
const pixIn_type &npi = *newPixIn, &li = *lineIn;
|
|
|
|
if (selector(npi))
|
|
sum = sum + npi, ++count;
|
|
if (selector(li))
|
|
sum = sum - li, --count;
|
|
|
|
*pixsum = *pixsum + sum, *pixcount += count;
|
|
}
|
|
|
|
// Finally, without adding new pixels
|
|
for (; x != lx; ++x, lineIn += addIn, pixsum += addSum, pixcount += addSum) {
|
|
const pixIn_type &li = *lineIn;
|
|
|
|
if (selector(li))
|
|
sum = sum - li, --count;
|
|
|
|
*pixsum = *pixsum + sum, *pixcount += count;
|
|
}
|
|
}
|
|
};
|
|
|
|
memset(sums, 0, lx * sizeof(PixSum));
|
|
memset(counts, 0, lx * sizeof(int));
|
|
|
|
// Add *strict* halves of the convolution sums
|
|
locals::fillSums(lx, radius, in, sums, counts, addIn, 1, selector);
|
|
locals::fillSums(lx, radius, in + addIn * (lx - 1), sums + lx - 1, counts + lx - 1,
|
|
-addIn, -1, selector);
|
|
|
|
// Normalize sums
|
|
for (int x = 0; x != lx; ++x, in += addIn, out += addOut, ++sums, ++counts) {
|
|
using namespace pixel_ops;
|
|
|
|
assert(*counts >= 0);
|
|
|
|
pixIn_type pix(*in);
|
|
pixel_ops::assign(pix, (*sums + pix) / (*counts + 1));
|
|
|
|
*out = pix;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
template <typename ImgIn, typename ImgOut, typename Scalar>
|
|
void blurRows(const ImgIn &imgIn, ImgOut &imgOut, int radius, Scalar)
|
|
{
|
|
typedef typename image_traits<ImgIn>::pixel_ptr_type PtrIn;
|
|
typedef typename image_traits<ImgOut>::pixel_ptr_type PtrOut;
|
|
typedef tcg::Pixel<Scalar, image_traits<ImgIn>::pixel_category> PixSum;
|
|
|
|
// Validate parameters
|
|
int inLx = image_traits<ImgIn>::width(imgIn), inLy = image_traits<ImgIn>::height(imgIn);
|
|
int outLx = image_traits<ImgOut>::width(imgOut), outLy = image_traits<ImgOut>::height(imgOut);
|
|
|
|
assert(inLx == outLx && inLy == outLy);
|
|
|
|
int inWrap = image_traits<ImgIn>::wrap(imgIn), outWrap = image_traits<ImgOut>::wrap(imgOut);
|
|
|
|
// Allocate an intermediate line of pixels to store sum values
|
|
tcg::unique_ptr<PixSum[]> sums(new PixSum[inLx]);
|
|
|
|
// Filter rows
|
|
for (int y = 0; y != inLy; ++y) {
|
|
PtrIn lineIn = image_traits<ImgIn>::pixel(imgIn, 0, y);
|
|
PtrOut lineOut = image_traits<ImgOut>::pixel(imgOut, 0, y);
|
|
|
|
_flatFilterLine(lineIn, lineOut, inLx, 1, 1, radius, sums.get());
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
template <typename ImgIn, typename ImgOut, typename SelectorFunc, typename Scalar>
|
|
void blurRows(const ImgIn &imgIn, ImgOut &imgOut, int radius, SelectorFunc selector, Scalar)
|
|
{
|
|
typedef typename image_traits<ImgIn>::pixel_ptr_type PtrIn;
|
|
typedef typename image_traits<ImgOut>::pixel_ptr_type PtrOut;
|
|
typedef tcg::Pixel<Scalar, image_traits<ImgIn>::pixel_category> PixSum;
|
|
|
|
// Validate parameters
|
|
int inLx = image_traits<ImgIn>::width(imgIn), inLy = image_traits<ImgIn>::height(imgIn);
|
|
int outLx = image_traits<ImgOut>::width(imgOut), outLy = image_traits<ImgOut>::height(imgOut);
|
|
|
|
assert(inLx == outLx && inLy == outLy);
|
|
|
|
int inWrap = image_traits<ImgIn>::wrap(imgIn), outWrap = image_traits<ImgOut>::wrap(imgOut);
|
|
|
|
// Allocate an intermediate line of pixels to store sum values
|
|
tcg::unique_ptr<PixSum[]> sums(new PixSum[inLx]);
|
|
tcg::unique_ptr<int[]> counts(new int[inLx]);
|
|
|
|
// Filter rows
|
|
for (int y = 0; y != inLy; ++y) {
|
|
PtrIn lineIn = image_traits<ImgIn>::pixel(imgIn, 0, y);
|
|
PtrOut lineOut = image_traits<ImgOut>::pixel(imgOut, 0, y);
|
|
|
|
_flatFilterLine(lineIn, lineOut, inLx, 1, 1, selector, radius, sums.get(), counts.get());
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
template <typename ImgIn, typename ImgOut, typename Scalar>
|
|
void blurCols(const ImgIn &imgIn, ImgOut &imgOut, int radius, Scalar)
|
|
{
|
|
typedef typename image_traits<ImgIn>::pixel_ptr_type PtrIn;
|
|
typedef typename image_traits<ImgOut>::pixel_ptr_type PtrOut;
|
|
typedef tcg::Pixel<Scalar, typename image_traits<ImgIn>::pixel_category> PixSum;
|
|
|
|
// Validate parameters
|
|
int inLx = image_traits<ImgIn>::width(imgIn), inLy = image_traits<ImgIn>::height(imgIn);
|
|
int outLx = image_traits<ImgOut>::width(imgOut), outLy = image_traits<ImgOut>::height(imgOut);
|
|
|
|
assert(inLx == outLx && inLy == outLy);
|
|
|
|
int inWrap = image_traits<ImgIn>::wrap(imgIn), outWrap = image_traits<ImgOut>::wrap(imgOut);
|
|
|
|
// Allocate an intermediate line of pixels to store sum values
|
|
tcg::unique_ptr<PixSum[]> sums(new PixSum[inLy]);
|
|
|
|
// Filter columns
|
|
for (int x = 0; x != inLx; ++x) {
|
|
PtrIn lineIn = image_traits<ImgIn>::pixel(imgIn, x, 0);
|
|
PtrOut lineOut = image_traits<ImgOut>::pixel(imgOut, x, 0);
|
|
|
|
_flatFilterLine(lineIn, lineOut, inLy, inWrap, outWrap, radius, sums.get());
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
template <typename ImgIn, typename ImgOut, typename SelectorFunc, typename Scalar>
|
|
void blurCols(const ImgIn &imgIn, ImgOut &imgOut, int radius, SelectorFunc selector, Scalar)
|
|
{
|
|
typedef typename image_traits<ImgIn>::pixel_ptr_type PtrIn;
|
|
typedef typename image_traits<ImgOut>::pixel_ptr_type PtrOut;
|
|
typedef tcg::Pixel<Scalar, typename image_traits<ImgIn>::pixel_category> PixSum;
|
|
|
|
// Validate parameters
|
|
int inLx = image_traits<ImgIn>::width(imgIn), inLy = image_traits<ImgIn>::height(imgIn);
|
|
int outLx = image_traits<ImgOut>::width(imgOut), outLy = image_traits<ImgOut>::height(imgOut);
|
|
|
|
assert(inLx == outLx && inLy == outLy);
|
|
|
|
int inWrap = image_traits<ImgIn>::wrap(imgIn), outWrap = image_traits<ImgOut>::wrap(imgOut);
|
|
|
|
// Allocate an intermediate line of pixels to store sum values
|
|
tcg::unique_ptr<PixSum[]> sums(new PixSum[inLy]);
|
|
tcg::unique_ptr<int[]> counts(new int[inLy]);
|
|
|
|
// Filter columns
|
|
for (int x = 0; x != inLx; ++x) {
|
|
PtrIn lineIn = image_traits<ImgIn>::pixel(imgIn, x, 0);
|
|
PtrOut lineOut = image_traits<ImgOut>::pixel(imgOut, x, 0);
|
|
|
|
_flatFilterLine(lineIn, lineOut, inLy, inWrap, outWrap, selector, radius, sums.get(), counts.get());
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
template <typename ImgIn, typename ImgOut, typename Scalar>
|
|
void blur(const ImgIn &imgIn, ImgOut &imgOut, int radius, Scalar)
|
|
{
|
|
blurRows(imgIn, imgOut, radius, Scalar);
|
|
blurCols(imgOut, imgOut, radius, Scalar);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
template <typename ImgIn, typename ImgOut, typename SelectorFunc, typename Scalar>
|
|
void blur(const ImgIn &imgIn, ImgOut &imgOut, int radius, SelectorFunc selector, Scalar)
|
|
{
|
|
blurRows(imgIn, imgOut, radius, selector, Scalar);
|
|
blurCols(imgOut, imgOut, radius, selector, Scalar);
|
|
}
|
|
}
|
|
} // namespace tcg::image_ops
|
|
|
|
#endif // TCG_IMAGE_OPS_HPP
|