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

Static Public Member Functions
static void	process (in_t op1, in_t op2, out_t out, BitmapBinaryOperation::Operation operation, int width, int height, const IntPoint &op1Origin, const IntPoint &op2Origin, const IntPoint &outOrigin, const TaskThread &tt)
	Performs a binary operation on two bitmaps. More...
static void	processAlignedBinaryMask (in_t op1, in_t op2, out_t out, BitmapBinaryOperation::Operation operation, int width, int height, const IntPoint &op1Origin, const IntPoint &op2Origin, const IntPoint &outOrigin, const TaskThread &tt)
	Performs a binary operation on two binary masks. More...

Detailed Description

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

Definition at line 29 of file operator.cpp.

Member Function Documentation

process()

template<class in_t , class out_t >

static void Kernels::BinaryOpBody< in_t, out_t >::process ( in_t  op1, in_t  op2, out_t  out, BitmapBinaryOperation::Operation  operation, int  width, int  height, const IntPoint &  op1Origin, const IntPoint &  op2Origin, const IntPoint &  outOrigin, const TaskThread &  tt  )

inlinestatic

Performs a binary operation on two bitmaps.

Definition at line 35 of file operator.cpp.

          {
            if (operation == BitmapBinaryOperation::Operation::NONE)
                return;
 
            for (int y = tt.currentThread(); y < height; y += tt.numThreads()) {
                op1.goTo(op1Origin.x, op1Origin.y + y);
                op2.goTo(op2Origin.x, op2Origin.y + y);
                out.goTo(outOrigin.x, outOrigin.y + y);
 
                switch (operation) {
                    case BitmapBinaryOperation::Operation::ADD:
                        for (int x = 0; x < width; ++x, op1++, op2++, out++) {
                            out = op1() + op2();
                        }
                        break;
 
                    case BitmapBinaryOperation::Operation::MULTIPLY:
                        for (int x = 0; x < width; ++x, op1++, op2++, out++) {
                            out = op1() * op2();
                        }
                        break;
 
                    default: return;
                }
 
                if (tt.isTaskAborted())
                    return;
            }
        }

processAlignedBinaryMask()

template<class in_t , class out_t >

static void Kernels::BinaryOpBody< in_t, out_t >::processAlignedBinaryMask ( in_t  op1, in_t  op2, out_t  out, BitmapBinaryOperation::Operation  operation, int  width, int  height, const IntPoint &  op1Origin, const IntPoint &  op2Origin, const IntPoint &  outOrigin, const TaskThread &  tt  )

inlinestatic

Performs a binary operation on two binary masks.

Definition at line 77 of file operator.cpp.

          {
            if (operation == BitmapBinaryOperation::Operation::NONE)
                return;
 
            BEATMUP_ASSERT_DEBUG(op1Origin.x % 8 == 0);
            BEATMUP_ASSERT_DEBUG(op2Origin.x % 8 == 0);
            BEATMUP_ASSERT_DEBUG(outOrigin.x % 8 == 0);
 
            for (int y = tt.currentThread(); y < height; y += tt.numThreads()) {
                int x = 0;
 
                // running aligned part first
                op1.goTo(op1Origin.x, op1Origin.y + y);
                op2.goTo(op2Origin.x, op2Origin.y + y);
                out.goTo(outOrigin.x, outOrigin.y + y);
 
                pixint_platform
                        *p1 = (pixint_platform*)*op1,
                        *p2 = (pixint_platform*)*op2,
                        *po = (pixint_platform*)*out;
 
                static const int step = 8 * sizeof(pixint_platform);
 
                switch (operation) {
                    case BitmapBinaryOperation::Operation::ADD:
                        for (x = 0; x + step <= width; x += step, p1++, p2++, po++) {
                            *po = *p1 | *p2;
                        }
                        break;
 
                    case BitmapBinaryOperation::Operation::MULTIPLY:
                        for (x = 0; x + step <= width; x += step, p1++, p2++, po++) {
                            *po = *p1 & *p2;
                        }
                        break;
 
                    default: return;
                }
 
                // if unaligned reminder, deal with it
                if (x < width) {
                    op1.goTo(op1Origin.x + x, op1Origin.y + y);
                    op2.goTo(op2Origin.x + x, op2Origin.y + y);
                    out.goTo(outOrigin.x + x, outOrigin.y + y);
 
                    switch (operation) {
                        case BitmapBinaryOperation::Operation::ADD:
                            for (; x < width; ++x, op1++, op2++, out++) {
                                out = op1() + op2();
                            }
                            break;
 
                        case BitmapBinaryOperation::Operation::MULTIPLY:
                            for (; x < width; ++x, op1++, op2++, out++) {
                                out = op1() * op2();
                            }
                            break;
 
                        default: return;
                    }
 
                }
 
                if (tt.isTaskAborted())
                    return;
            }
        }

---

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

• core/bitmap/operator.cpp