testImage.cpp

#include <cstdio>
#include <cmath>
#include <iostream>

#include "DGtal/base/Common.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/images/CImage.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/images/ImageContainerBySTLMap.h"
#include "DGtal/images/ImageContainerByHashTree.h"
#include "DGtal/images/Image.h"


using namespace DGtal;
using namespace std;


template<typename Image>
bool testImage(const Image& aImage)
{

    BOOST_CONCEPT_ASSERT(( CImage<Image> ));

    int nb = 0;
    int nbok = 0;

    trace.beginBlock ( "Main services, range" );

    Image img(aImage);
    Image img2 = img; //copy

    //fill
    typename Image::Domain::ConstIterator dit = img.domain().begin();
    typename Image::Domain::ConstIterator ditEnd = img.domain().end();
    for (int i = 0; ( (dit != ditEnd)&&(i < 5) ); ++dit, ++i)
    {
        img.setValue(*dit, i);
    }
    Image img3(img2);
    img3 = img; //assignment

    //ranges comparison
    typename Image::ConstRange rimg = img.constRange();
    typename Image::ConstRange rimg2 = img2.constRange();
    typename Image::ConstRange rimg3 = img3.constRange();

    bool flag2 = std::equal(rimg.begin(), rimg.end(), rimg2.begin());
    bool flag3 = std::equal(rimg.begin(), rimg.end(), rimg3.begin());
    bool flag23 = std::equal(rimg2.begin(), rimg2.end(), rimg3.begin());

    nbok += ( (!flag2) && flag3 && (!flag23) )?1:0;
    nb++;
    trace.info() << "(" <<nbok << "/" << nb << ")" << std::endl;
    trace.endBlock();

    trace.beginBlock ( "Output iterator" );
    std::copy(rimg.begin(), rimg.end(), img2.range().outputIterator());

    //rimg2 is invalid if Image is a proxy image
    //because its iterators point to the data of aImage
    //instead of pointing to the data of img2
    rimg2 = img2.constRange();
    flag2 = std::equal(rimg.begin(), rimg.end(), rimg2.begin());
    nbok += (flag2)?1:0;
    nb++;
    trace.info() << "(" <<nbok << "/" << nb << ")" << std::endl;
    trace.endBlock();

    trace.beginBlock ( " Getters / setters " );
    typename Image::Domain::Point p = img.domain().upperBound();

    //local comparison
    img.setValue( p, 128 );
    bool flag4 = ( img(p) == 128 );

    //range comparison
    rimg = img.constRange();
    rimg2 = img2.constRange();
    rimg3 = img3.constRange();
    std::copy( rimg.begin(), rimg.end(), std::ostream_iterator<int>(cout,", ") );
    cout << endl;
    flag2 = std::equal(rimg.begin(), rimg.end(), rimg2.begin());
    std::copy( rimg2.begin(), rimg2.end(), std::ostream_iterator<int>(cout,", ") );
    cout << endl;
    flag3 = std::equal(rimg.begin(), rimg.end(), rimg3.begin());
    std::copy( rimg3.begin(), rimg3.end(), std::ostream_iterator<int>(cout,", ") );
    cout << endl;

    nbok += ( flag4 && (!flag2) && (!flag3) )?1:0;
    nb++;
    trace.info() << "(" <<nbok << "/" << nb << ")" << std::endl;
    trace.endBlock();

    trace.beginBlock ( " Display " );
    trace.info() << img << std::endl;
    trace.info() << img2 << std::endl;
    trace.info() << img3 << std::endl;
    trace.endBlock();

    return ( img.isValid() && img2.isValid() && img3.isValid() && (nbok == nb) );
}

int main( int argc, char** argv )
{

    trace.beginBlock ( "Testing image classes" );
    trace.info() << "Args:";
    for ( int i = 0; i < argc; ++i )
        trace.info() << " " << argv[ i ];
    trace.info() << endl;

    typedef DGtal::int64_t Integer;
    typedef SpaceND<2,Integer> Space;
    typedef Space::Point Point;
    typedef HyperRectDomain<Space> Domain;

    const Integer size = 5;
    Point p = Point::diagonal(0);
    Point q = Point::diagonal(size-1);
    Domain d(p,q);

    typedef short Value;
    typedef ImageContainerBySTLVector<Domain,Value> VImage;
    typedef ImageContainerBySTLMap<Domain,Value> MImage;
    typedef ImageContainerByHashTree<Domain,Value> HImage;
    typedef Image<VImage > LImage;

    VImage vi(d);
    bool res = testImage(vi);

    MImage mi(d);
    res = res && testImage(mi);

    // TODO
    // HImage hi(3, p, q, 0);
    // res = res && testImage(hi);

    // LImage li( new VImage(d) );
    // res = res && testImage(li);

    trace.emphase() << ( res ? "Passed." : "Error." ) << endl;
    trace.endBlock();
    return res ? 0 : 1;
}