Kernels::BilinearResampling< 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 by bilinear interpolation. More...

Detailed Description

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

Definition at line 122 of file resampling_kernels.h.

Member Function Documentation

process()

template<class in_t , class out_t >

static void Kernels::BilinearResampling< 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 by bilinear interpolation.

Definition at line 128 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(),
                shiftX = (srcW - dstW) / 2,
                shiftY = (srcH - dstH) / 2;
 
            // dest image slice to process in the current thread
            const int
              sliceStart = tt.currentThread()       * dstH / tt.numThreads(),
              sliceStop  = (tt.currentThread() + 1) * dstH / tt.numThreads();
 
            for (int y = sliceStart; y < sliceStop; ++y) {
                out.goTo(dst.a.x, dst.a.y + y);
                const float fsy = (float)(y * srcH + shiftY) / dstH;
                const int   isy = (int)fsy;
                const float fy = fsy - (float)isy, _fy = 1 - fy;
                const int   sy = src.a.y + isy;
 
                const int
                    lineJump = sy < srcH - 1 ? srcW - 1 : -1,
                    xBound = srcW - 1;
 
                typename out_t::pixtype acc;
                for (int x = 0; x < dstW; ++x) {
 
                    const float fsx = (float)(x * srcW + shiftX) / dstW;
                    const int   isx = (int)fsx;
                    const float fx = fsx - (float)isx;
                    const int   sx = src.a.x + isx;
 
                    in.goTo(sx, sy);
                    if (sx < xBound) {
                        acc = in() * (1 - fx) * _fy;
                        in++;
                        acc = acc + in() * fx * _fy;
                        in += lineJump;
                        acc = acc + in() * (1 - fx) * fy;
                        in++;
                        acc = acc + in() * fx * fy;
                    }
                    else {
                        acc = in() * _fy;
                        in += lineJump + 1;
                        acc = acc + in() * fy;
                    }
 
                    out = acc;
                    out++;
                }
 
                if (tt.isTaskAborted())
                    return;
            }
        }

---

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

• core/bitmap/resampling_kernels.h