|| || || || || || || ||

---

IntegrateReduce.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_IntegrateReduce_h
#define Impala_Core_Array_IntegrateReduce_h

#include "Core/Array/Arrays.h"
#include "Core/Array/SetVal.h"
#include "Core/Array/Pattern/PatSetBorder.h"
#include "Core/Array/CheckBorderSize.h"

namespace Impala
{
namespace Core
{
namespace Array
{

void
IntegrateReduceLine(Array::Array2dScalarReal64*& dst,
                    Array::Array2dScalarReal64* src, int n, int y)
{
    double* srcPtr = src->CPB(0, y);
    double* dstPtr = dst->CPB(0, y/n);
    for(int x=0 ; x<src->CW()/n ; ++x)
    {
        double accu = 0;
        for(int i=0 ; i<n ; ++i)
        {
            accu += *srcPtr;
            ++srcPtr;
        }
        *dstPtr += accu;
        ++dstPtr;
    }
}

void
IntegrateReduce(Array::Array2dScalarReal64*& dst,
                Array::Array2dScalarReal64* src, int n)
{
    // if dst exists it should have the correct size
    if(dst && (dst->CW() != src->CW()/n || dst->CH() != src->CH()/n))
    {
        delete dst;
        dst = 0;
    }
    if(dst == 0)
        dst = new Array::Array2dScalarReal64(src->CW()/n, src->CH()/n, 0, 0);
    SetVal(dst, 0);
    int y=0;
    while(y <= src->CH()-n)
    {
        for(int i=0 ; i<n ; ++i)
        {
            IntegrateReduceLine(dst, src, n, y);
            ++y;
        }
    }
}

void
IntegrateReduceLineWeighted(Array::Array2dScalarReal64*& dst,
                            Array::Array2dScalarReal64* src,
                            int n, int dstY, int srcY, double weight)
{
    double* dstPtr = dst->CPB(0, dstY);
    for(int dstX=0 ; dstX<dst->CW() ; ++dstX)
    {
        double accu = 0;
        int srcX=dstX*n - 1; //note the -1: the iterations overlap
        double* srcPtr = src->CPB(srcX, srcY); 
        accu += 0.33 * *srcPtr++;
        accu += 0.67 * *srcPtr++;
        for(int i=1 ; i<n-1 ; ++i)
        {
            accu += *srcPtr++;
        }
        accu += 0.67 * *srcPtr++;
        accu += 0.33 * *srcPtr++; //this is at srcX + n, so this too overlaps
        *dstPtr += weight * accu;
        ++dstPtr;
    }
}

void
IntegrateReduceWeighted(Array::Array2dScalarReal64*& dst,
                        Array::Array2dScalarReal64* src, int n)
{
    // if dst exists it should have the correct size
    if(dst && (dst->CW() != src->CW()/n || dst->CH() != src->CH()/n))
    {
        delete dst;
        dst = 0;
    }
    if(dst == 0)
        dst = new Array::Array2dScalarReal64(src->CW()/n, src->CH()/n, 0, 0);
    SetVal(dst, 0);
    Array::Array2dScalarReal64* bordered = CheckBorderSize(src, 1, 1);
    Pattern::PatSetBorder(bordered, 1, 1); 
    for(int dstY=0 ; dstY<dst->CH() ; ++dstY)
    {
        int srcY = dstY*n;
        IntegrateReduceLineWeighted(dst, bordered, n, dstY, srcY-1, .33);
        IntegrateReduceLineWeighted(dst, bordered, n, dstY, srcY, .67);
        for(int i=1 ; i<n-1 ; ++i)
            IntegrateReduceLineWeighted(dst, bordered, n, dstY, srcY+i, 1.);
        IntegrateReduceLineWeighted(dst, bordered, n, dstY, srcY+n-1, .67);
        IntegrateReduceLineWeighted(dst, bordered, n, dstY, srcY+n, .33);
    }
    if(bordered != src)
        delete bordered;
}


} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---