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

---

Array2dTem.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Array2dTem_h
#define Impala_Core_Array_Array2dTem_h

#include <sstream>
#include "Core/Array/Pattern/PtrFunc.h"
#include "Core/Array/Element/VecTem.h"
#include "Core/Array/Element/TypeString.h"
#include "Core/Array/ArraySystem.h"
#include "Basis/Std.h"
#include "Basis/String.h"

#ifdef PX_HORUS_USED
#include "Core/Array/Pattern/PxStateTrans.h"
#else
#define SEQ_CREAT   0
#define SEQ_VALID   0
#endif

namespace Impala
{
namespace Core
{
namespace Array
{


template <class StorT, int elemSize, class ArithT>
class Array2dTem
{
public:

    typedef StorT      StorType;
    static const int   ElemSize() { return elemSize; }
    typedef ArithT     ArithType;

    typedef Element::VecTem<StorT,elemSize> VecType;

    // if data != 0 it should contain w * h * ElemSize elements
    // note that the parameters specify core size, not total array size
    Array2dTem(Int64 cw, Int64 ch, Int64 bw, Int64 bh, StorType* data = 0,
               bool isWrapper = false, bool isPartial = false)
    {
        mCW = cw;
        mCH = ch;
        mBW = bw;
        mBH = bh;
        Int64 w = cw + 2*bw;
        Int64 h = ch + 2*bh;
        mDataSize = w * h * elemSize;
        if (data == 0) 
        {
            mData = ArraySystem::Instance().Allocate(mDataSize, StorType());
//          mState = SEQ_CREAT;                 // PxHorus extension
            mState = SEQ_VALID;                 // PxHorus extension
        }
        else
        {
            mData = data;
            mState = SEQ_VALID;                 // PxHorus extension
            if (! isWrapper)
                ArraySystem::Instance().External(mDataSize, mData);
        }
        mIsWrapper = isWrapper;
        mIsPartial = isPartial;                 // PxHorus extension
        mPartArray = 0;                         // PxHorus extension
    }

    Array2dTem()
    {
        mCW = 0;
        mCH = 0;
        mBW = 0;
        mBH = 0;
        mDataSize = 0;
        mData = 0;
        mIsWrapper = false;
        mState = SEQ_CREAT;                     // PxHorus extension
        mIsPartial = false;                     // PxHorus extension
        mPartArray = 0;                         // PxHorus extension
    }

    ~Array2dTem()
    {
        if (mData && !mIsWrapper) 
        {
            ArraySystem::Instance().Deallocate(mData, mDataSize);
            mData = 0;
        }
        if (mPartArray)                         // PxHorus extension
        {
            delete mPartArray;
            mPartArray = 0;
        }
    }

    virtual String 
    GetTypeName()
    {
        std::ostringstream s;
        s << "Array(" << Element::TypeString<StorT>(0) << "," << elemSize << ")";
        return s.str();
    }

    Int64
    W() const
    {
        return mCW + 2*mBW;
    }

    Int64
    BW() const
    {
        return mBW;
    }

    Int64
    CW() const
    {
        return mCW;
    }

    Int64
    H() const
    {
        return mCH + 2*mBH;
    }

    Int64
    BH() const
    {
        return mBH;
    }

    Int64
    CH() const
    {
        return mCH;
    }

    // const pointer access
    const StorType*
    PB(Int64 x=0, Int64 y=0) const
    {
        return mData + Inc(x, y);
    }

    const StorType*
    CPB(Int64 x=0, Int64 y=0) const
    {
        return mData + Inc(BW() + x, BH() + y);
    }

    const StorType*
    CPE(Int64 x=0, Int64 y=0) const
    {
        return mData + Inc(BW() + CW() - 1 + x, BH() + CH() - 1 + y);
    }

    // non const pointer access
    StorType*
    PB(Int64 x=0, Int64 y=0)
    {
        return mData + Inc(x, y);
    }

    StorType*
    CPB(Int64 x=0, Int64 y=0)
    {
        return mData + Inc(BW() + x, BH() + y);
    }

    StorType*
    CPE(Int64 x=0, Int64 y=0)
    {
        return mData + Inc(BW() + CW() - 1 + x, BH() + CH() - 1 + y);
    }

    // value access, scalar only!
    StorType
    Val(Int64 x, Int64 y) const
    {
        return *CPB(x, y);
    }

    // proper value access
    ArithType
    Value(Int64 x, Int64 y)
    {
        return Pattern::PtrRead(CPB(x, y), ArithType());
    }

    void
    SetValue(ArithType value, Int64 x, Int64 y)
    {
        //Pattern::PtrWrite(static_cast<ArithType*>(CPB(x, y)), value);
        Pattern::PtrWrite(CPB(x, y), value);
    }

    // Returns a vector "around" the element at (x,y).
    // The vector is a wrapper so it behaves as a reference to the element!
    VecType
    Elem(Int64 x, Int64 y)
    {
        return VecType(CPB(x, y), true);
    }

    void
    WriteTo(std::ostream& os)
    {
        os << Element::TypeString<StorT>(0) << " " << mDataSize << "\n"
           << mCW << " " << mCH << " "
           << mBW << " " << mBH << "\n";
        for(Int64 i=0 ; i<mDataSize ; i++)
            os << mData[i] << " ";
        os << "\n";
    }

    void
    WriteTo(std::ostream& os, Int64 w, Int64 h)
    {
        WriteTo(os,0,0,w,h);
    }
    
    void
    WriteTo(std::ostream& os, Int64 startx, Int64 starty, Int64 w, Int64 h)
    {
        if(w == -1 && startx == 0)
            w = CW();
        if(h == -1 && starty == 0)
            h = CH();
        if(startx+w > W()-BW())
            w = W()-startx-BW();
        if(starty+h > H()-BH())
            h = H()-starty-BH();
        os << "partial array dump from ("
           << startx << "," << starty << ") size ("
           << w << "," << h << ")\n";
        Int64 x,y;
        for(y=0 ; y<h ; ++y)
        {
            for(x=0 ; x<w ; ++x)
                os << Pattern::PtrRead(CPB(x+startx, y+starty), ArithType()) << " ";
            os << "\n";
        }
    }

    void FindNaN(CString name)
    {
        Int64 count=0;
        Int64 y;
        for(y=0 ; y<H() ; ++y)
        {
            Int64 x;
            for(x=0 ; x<W() ; ++x)
            {
                Int64 i;
                for(i=0 ; i<ElemSize() ; ++i)
                {
                    StorType e = mData[i + ElemSize()*(x + W()*y)];
                    if(e != e) 
                    {
                        if(count==0)
                            std::cout << name << " contains nan! first @ (" << x << "," << y
                                      << ") elem" << i << "((debug:" << i + ElemSize()*(x + W()*y) << "))";
                        count++;
                    }
                } 
            }
        }
        if(count > 0)
            std::cout << ", " << count << " of " << W()*H()*ElemSize() << " in total" << std::endl;
    }
    void GrowBorder(Int64 amount)
    {
        if(amount < 0)
        {
            if(-amount > mBH || -amount > mBW)
            {
                std::cerr 
                    << "WARNING: [Array2dTem::GrowBorder] negative amount > border" 
                    << std::endl;
                return;
            }
            if(2*amount > mCH || 2*amount > mCW)
            {
                std::cerr 
                    << "WARNING: [Array2dTem::GrowBorder] amount > half of image " 
                    << std::endl;
                return;
            }
        }

        mBW += amount;
        mBH += amount;
        mCW -= 2*amount;
        mCH -= 2*amount;
    }
    

    Int64         mCW;
    Int64         mCH;
    Int64         mBW;
    Int64         mBH;
    StorType*   mData;
    size_t      mDataSize;
    bool        mIsWrapper;
    int         mState;                     // PxHorus extension
    bool        mIsPartial;                 // PxHorus extension
    Array2dTem* mPartArray;                 // PxHorus extension

private:

    Int64
    Inc(Int64 x, Int64 y) const
    {
        return y * W() * ElemSize() + x * ElemSize();
    }

};

// we want bytes to be printed as numbers, not chars
inline std::ostream&
operator<< (std::ostream& os, UInt8 v)
{
    return os << int(v);
}

template<class ArrayT>
inline std::ostream&
ArrayPrintElem(std::ostream& os, ArrayT* array, typename ArrayT::StorType* ptr)
{
    for (int i=0 ; i<array->ElemSize() ; i++)
    {
        if ((i == 0) && (array->ElemSize() > 1))
            os << "(";
        os << *ptr++;
        if (i+1 < array->ElemSize())
            os << ",";
        if ((i+1 == array->ElemSize()) && (array->ElemSize() > 1))
            os << ")";
    }
    return os;
}

template<class ArrayT>
ArrayT*
ArrayCreate(Int64 cw, Int64 ch, Int64 bw = 0, Int64 bh = 0,
            typename ArrayT::StorType* data = 0, bool isWrapper = false)
{
    return new ArrayT(cw, ch, bw, bh, data, isWrapper);
}

template<class DstArrayT, class SrcArrayT>
DstArrayT*
ArrayClone(SrcArrayT* src, Int64 minimalBW = 0, Int64 minimalBH = 0)
{
    Int64 bw = Impala::Max(src->BW(), minimalBW);
    Int64 bh = Impala::Max(src->BH(), minimalBH);
    return new DstArrayT(src->CW(), src->CH(), bw, bh);
}

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


#endif

---