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

---

PatGeometricOp.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_PatGeometricOp_h
#define Impala_Core_Array_Pattern_PatGeometricOp_h

#include "Core/Array/Element/ArithTypes.h"
#include "Core/Matrix/MatCopy.h"
#include "Core/Matrix/MatInverse.h"
#include "Core/Matrix/MatMulVec.h"
#include "Core/Array/Element/E2Inf.h"
#include "Core/Array/Element/E2Sup.h"
#include "Core/Geometry/GeoIntType.h"
#include "Core/Array/Pattern/FuncGeometricOp.h"

#ifdef PX_HORUS_USED
#include "Core/Array/Pattern/PxArrayFunc.h"
#include "Core/Array/Pattern/PxStateTrans.h"
#endif

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Pattern
{


template<class DstArrayT, class SrcArrayT>
inline void
PatGeometricOp(DstArrayT*& dst, SrcArrayT* src, Matrix::Mat* func,
               bool isForward, Geometry::GeoIntType gi, bool adjustSize,
               typename DstArrayT::ArithType background)
{
    if ((Matrix::MatNrRow(func) != 3) || (Matrix::MatNrCol(func) != 3))
    {
        std::cout << "PatGeometricOp: matrix needs to be 3x3" << std::endl;
        return;
    }

    Matrix::Mat* fForw = (isForward) ? Matrix::MatCopy(func) : Matrix::MatInverse(func);
    Matrix::Mat* fBack = (isForward) ? Matrix::MatInverse(func) : Matrix::MatCopy(func);

    int sW = ArrayCW(src);
    int sH = ArrayCH(src);
    int reqW = (dst) ? ArrayCW(dst) : sW;
    int reqH = (dst) ? ArrayCH(dst) : sH;

    Vec3Real64 translate(0, 0, 0);

    if (adjustSize)
    {
        Vec3Real64 ulP = Matrix::MatMulVec(fForw, Vec3Real64(0,  0,  1));
        Vec3Real64 llP = Matrix::MatMulVec(fForw, Vec3Real64(0,  sH, 1));
        Vec3Real64 urP = Matrix::MatMulVec(fForw, Vec3Real64(sW, 0,  1));
        Vec3Real64 lrP = Matrix::MatMulVec(fForw, Vec3Real64(sW, sH, 1));

        //homogeneous coordinates
        ulP /= Vec3Real64(ulP.Z(), ulP.Z(), ulP.Z());
        llP /= Vec3Real64(llP.Z(), ulP.Z(), ulP.Z());
        urP /= Vec3Real64(urP.Z(), ulP.Z(), ulP.Z());
        lrP /= Vec3Real64(lrP.Z(), ulP.Z(), ulP.Z());

        Vec3Real64 maerB = E2Inf(E2Inf(E2Inf(ulP,llP),urP),lrP);
        Vec3Real64 maerE = E2Sup(E2Sup(E2Sup(ulP,llP),urP),lrP);
        reqW = int(maerE.X() - maerB.X() + 0.5);
        reqH = int(maerE.Y() - maerB.Y() + 0.5);
        translate = Vec3Real64(maerB.X(), maerB.Y(), 0);
    }

    if (dst == 0)
    {
        dst = ArrayCreate<DstArrayT>(reqW, reqH,
                                     ArrayBW(src), ArrayBH(src));
    }
    else
        if ((ArrayCW(dst) != reqW) || (ArrayCH(dst) != reqH))
        {
            delete dst;
            dst = ArrayCreate<DstArrayT>(reqW, reqH,
                                         ArrayBW(src), ArrayBH(src));
        }

#ifdef PX_HORUS_USED
    if (!PxRunParallel()) {                         // run sequential
#endif
        FuncGeometricOp(dst, src, fBack, gi, translate, background);

#ifdef PX_HORUS_USED
    } else {                                        // run parallel
        PxArrayPreStateTrans(src, PAR_FULL, STRONG);
        PxArrayPreStateTrans(dst, PAR_PART, WEAK);
        translate += Vec3Real64(PxLclStartX(PxMyCPU()),
                        PxLclStartY(PxMyCPU()), PxLclStartZ(PxMyCPU()));
        FuncGeometricOp(PxArrayPD(dst), PxArrayPD(src),
                          fBack, gi, translate, background);
        PxArrayPostStateTrans(dst);

        if (!PxRunLazyParallel()) {
            PxArrayForceNonDistributed(src);
            PxArrayForceNonDistributed(dst);
        }
    }
#endif

    delete fForw;
    delete fBack;
}

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

#endif

---