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

#include <resampling_kernels.h>

Classes
class	BicubicKernel
	Precomputes kernel coefficients in function of bicubic kernel parameter. More...

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

Detailed Description

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

Definition at line 189 of file resampling_kernels.h.

Member Function Documentation

process()

template<class in_t , class out_t >

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

inlinestatic

Resamples a rectangle from an input bitmap to a rectangle in an output bitmap applying a bicubic kernel.

Definition at line 232 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();
 
            BicubicKernel kx(alpha), ky(alpha);
 
            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;
                const int   sy = src.a.y + isy;
 
                const int lineJump[3] = {
                    sy > 0 ? srcW : 0,
                    sy < srcH - 1 ? srcW : 0,
                    sy < srcH - 2 ? srcW : 0
                };
 
                // preparing kernel
                ky(fy);
 
                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;
 
                    kx(fx);
 
                    const int pixJump[3] = {
                        sx > 0        ? -1 : 0,
                        sx < srcW - 1 ? +1 : 0,
                        sx < srcW - 2 ? +2 : 0
                    };
 
                    in.goTo(sx, sy > 0 ? sy - 1 : 0);
                    acc =       in[pixJump[0]] * kx[0] * ky[0] + in() * kx[1] * ky[0] + in[pixJump[1]] * kx[2] * ky[0] + in[pixJump[2]] * kx[3] * ky[0];
                    in += lineJump[0];
                    acc = acc + in[pixJump[0]] * kx[0] * ky[1] + in() * kx[1] * ky[1] + in[pixJump[1]] * kx[2] * ky[1] + in[pixJump[2]] * kx[3] * ky[1];
                    in += lineJump[1];
                    acc = acc + in[pixJump[0]] * kx[0] * ky[2] + in() * kx[1] * ky[2] + in[pixJump[1]] * kx[2] * ky[2] + in[pixJump[2]] * kx[3] * ky[2];
                    in += lineJump[2];
                    acc = acc + in[pixJump[0]] * kx[0] * ky[3] + in() * kx[1] * ky[3] + in[pixJump[1]] * kx[2] * ky[3] + in[pixJump[2]] * kx[3] * ky[3];
 
                    out = acc;
                    out++;
                }
 
                if (tt.isTaskAborted())
                    return;
            }
        }

---

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

• core/bitmap/resampling_kernels.h