Kernels::BoxResampling< in_t, out_t > Class Template Reference

#include <resampling_kernels.h>

Static Public Member Functions
static void	process (AbstractBitmap &input, AbstractBitmap &output, IntRectangle &src, IntRectangle &dst, const TaskThread &tt)
	Resamples a rectangle from an input bitmap to a rectangle in an output bitmap applying a box filter. More...

Detailed Description

template<class in_t, class out_t>
class Kernels::BoxResampling< in_t, out_t >

Definition at line 67 of file resampling_kernels.h.

Member Function Documentation

process()

template<class in_t , class out_t >

static void Kernels::BoxResampling< in_t, out_t >::process ( AbstractBitmap &  input, AbstractBitmap &  output, IntRectangle &  src, IntRectangle &  dst, const TaskThread &  tt  )

inlinestatic

Resamples a rectangle from an input bitmap to a rectangle in an output bitmap applying a box filter.

Definition at line 73 of file resampling_kernels.h.

                                                                                                                                       {
            in_t in(input);
            out_t out(output);
 
            const int
                srcW = src.width(), srcH = src.height(),
                dstW = dst.width(), dstH = dst.height();
 
            // dest image slice to process in the current thread
            const int
              sliceStart = tt.currentThread()       * dstH / tt.numThreads(),
              sliceStop  = (tt.currentThread() + 1) * dstH / tt.numThreads();
 
            int x0, y0, x1, y1 = src.a.y + (sliceStart) * srcH / dstH;    // coordinates of source pixels box mapped to a given dest pixel
 
            typename in_t::pixtype acc;
            for (int y = sliceStart; y < sliceStop; ++y) {
                out.goTo(dst.a.x, dst.a.y + y);
                y0 = y1;
                y1 = src.a.y + (y + 1) * srcH / dstH;
                x1 = src.a.x;
                for (int x = 0; x < dstW; ++x) {
                    x0 = x1;
                    x1 = src.a.x + (x + 1) * srcW / dstW;
 
                    // loop over the source area
                    acc.zero();
                    int y = y0;
                    do {
                        in.goTo(x0, y);
                        int x = x0;
                        do {
                            acc = acc + in();
                            in++;
                        } while (++x < x1);
                    } while (++y < y1);
 
                    // write out
                    out = acc / std::max(1, (x1 - x0)*(y1 - y0));
                    out++;
                }
 
                if (tt.isTaskAborted())
                    return;
            }
        }

---

The documentation for this class was generated from the following file:

• core/bitmap/resampling_kernels.h