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

---

TestImage.h

Go to the documentation of this file.

#ifndef Impala_Core_Test_TestImage_h
#define Impala_Core_Test_TestImage_h

#include "Core/ImageSet/ImageSet.h"
#include "Core/Test/TestBase.h"
#include "Core/Array/ReadFile.h"
#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/Set.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Array/Pattern/PatBinaryPixOp.h"
#include "Core/Array/Trait/BpoTestEqual.h"
#include "Core/Array/Arrays.h"
#include "Core/Feature/FeatureTable.h"
#include "Core/Vector/Norm1Dist.h"
#include "Basis/FileName.h"

namespace Impala
{
namespace Core
{
namespace Test
{


class TestImage : public TestBase
{
public:
    typedef Feature::FeatureTable FeatureTable;

    static void
    SetImageSet(ImageSet::ImageSet* imSet)
    {
        mImSet = imSet;
    }

protected:

    typedef Array::Array2dVec3UInt8 Array2dVec3UInt8;
    typedef Array::Array2dVec3Real64 Array2dVec3Real64;
    typedef Array::Array2dScalarReal64 Array2dScalarReal64;
    typedef Array::Array2dScalarInt32 Array2dScalarInt32;

    // OpenSrcArray variations

    Array2dVec3UInt8*
    OpenSrcArray(String srcName)
    {
        if (!mImSet)
        {
            ILOG_ERROR("No image set");
            return 0;
        }
        int id = mImSet->GetFileId(srcName);
        if (id == -1)
        {
            ILOG_ERROR("Couldn't find " << srcName);
            return 0;
        }
        return mImSet->GetImage(id);
    }

    Array2dVec3Real64*
    OpenSrcArrayAsVec3Real64(String srcName)
    {
        Array2dVec3UInt8* srcData = OpenSrcArray(srcName);
        Array2dVec3Real64* realData = 0;
        Set(realData, srcData);
        delete srcData;
        return realData;
    }

    Array2dScalarReal64*
    OpenSrcArrayAsReal(String srcName)
    {
        Array2dVec3UInt8* srcData = OpenSrcArray(srcName);
        Array2dScalarReal64* realData = 0;
        Array::RGB2Intensity(realData, srcData);
        delete srcData;
        return realData;
    }

    Array2dScalarInt32*
    OpenSrcArrayAsInt(String srcName)
    {
        Array2dScalarReal64* realData = OpenSrcArrayAsReal(srcName);
        Array2dScalarInt32* intData = 0;
        Array::Set(intData, realData);
        delete realData;
        return intData;
    }

    //

    template<class ArrayT>
    void
    Compare(ArrayT* src, String refName)
    {
        ArrayT* ref = 0;
        Array::ReadRaw(ref, refName, mImSet->GetDatabase());
        if (ref == 0)
        {
            SetFailure("unable to read reference");
            return;
        }
        DoCompare(src, ref);
        delete ref;
    }

    template<class ArrayT>
    void
    CompareList(std::vector<ArrayT*> srcList, String refName)
    {
        std::vector<ArrayT*> refList;
        Array::ReadRawList(refList, refName, mImSet->GetDatabase());
        if (refList.size() == 0)
        {
            SetFailure("unable to read reference");
            return;
        }
        if (srcList.size() != refList.size())
        {
            SetFailure("unequal list size");
            Array::ArrayListDelete(&refList);
            return;
        }
        for (int i=0 ; i<srcList.size() ; i++)
            DoCompare(srcList[i], refList[i]);
        Array::ArrayListDelete(&refList);
    }

    void
    Compare(FeatureTable* src, String refName)
    {
        FeatureTable ref(FileNameTail(refName));
        Table::Read(&ref, refName, mImSet->GetDatabase());
        DoCompare(src, &ref);
    }

    static ImageSet::ImageSet* mImSet;

private:

    template<class ArrayT>
    void
    DoCompare(ArrayT* src, ArrayT* ref)
    {
        std::ostringstream ost;
        if (src->CW() != ref->CW())
            ost << "width differs: " << src->CW() << " vs "
                << ref->CW() << std::ends;
        if (src->CH() != ref->CH())
            ost << "height differs: " << src->CH() << " vs " 
                << ref->CH() << std::ends;
        Array::Trait::BpoTestEqual<Array2dScalarReal64, ArrayT, ArrayT> bpo(mErrorTolerance);
        Array2dScalarReal64* dst = 0;
        Array::Pattern::PatBinaryPixOp(dst, src, ref, bpo);
        if (bpo.mNrDiff > 0)
            ost << "TestEqual found " << bpo.mNrDiff << " differences, in "
                << bpo.mNr << " pixels, sum diffs : " << bpo.mSumDiff 
                << " avg diff : " << bpo.mSumDiff / bpo.mNrDiff 
                << " avg src1 : " << bpo.mSumSrc1 / bpo.mNr
                << " avg src2 : " << bpo.mSumSrc2 / bpo.mNr << std::ends;
        String r = ost.str();
        if (r.size() > 0)
            SetFailure(r);
        delete dst;
    }

    void
    DoCompare(FeatureTable* src, FeatureTable* ref)
    {
        std::ostringstream ost;
        if (src->Size() != ref->Size())
            ost << "Size differs: " << src->Size() << " vs "
                << ref->Size() << std::ends;
        if (src->GetFeatureVectorLength() != ref->GetFeatureVectorLength())
            ost << "Featurevectorlength differs: "
                << src->GetFeatureVectorLength() << " vs "
                << ref->GetFeatureVectorLength() << std::ends;
        int checkSize = Min(src->Size(), ref->Size());
        int nDiff = 0;
        for (int i=0 ; i<checkSize ; i++)
        {
            if (src->Get1(i) != ref->Get1(i))
            {
                nDiff++;
            }
            else
            {
                Real64 d = Vector::Norm1Dist(src->Get2(i), ref->Get2(i));
                if (d > mErrorTolerance)
                    nDiff++;
            }
        }
        if (nDiff > 0)
            ost << "Found " << nDiff << " differences on " << checkSize
                << " rows" << std::ends;
        String r = ost.str();
        if (r.size() > 0)
            SetFailure(r);
    }

    static const double mErrorTolerance;

    ILOG_VAR_DEC;

};

const double TestImage::mErrorTolerance = 0.00001;
ImageSet::ImageSet* TestImage::mImSet = 0;

ILOG_VAR_INIT(TestImage, Core.Test);

} // namespace Test
} // namespace Core
} // namespace Impala

#endif

---