image.cpp

来自「Boost provides free peer-reviewed portab」· C++ 代码 · 共 591 行 · 第 1/2 页

	typedef bit_aligned_image3_type<1,3,1, bgr_layout_t>::type bgr131_image_t;
	typedef bgr131_image_t::value_type bgr131_pixel_t;
	bgr131_pixel_t fill_val(1,3,1);

	bgr131_image_t bgr131_img(3,10);
	fill_pixels(view(bgr131_img), fill_val);

	bgr131_image_t bgr131a_img(3,10,1);
	copy_pixels(const_view(bgr131_img), view(bgr131a_img));

	bgr131_image_t bgr131b_img(3,10,4);
	copy_pixels(const_view(bgr131_img), view(bgr131b_img));

	error_if(bgr131_img!=bgr131a_img || bgr131a_img!=bgr131b_img);
}

void image_test::dynamic_image_test() {
    typedef any_image<mpl::vector<gray8_image_t, bgr8_image_t, argb8_image_t,
                                  rgb8_image_t, rgb8_planar_image_t> > any_image_t;
    rgb8_planar_image_t img(sample_view.dimensions());
    copy_pixels(sample_view, view(img));
    any_image_t any_img=any_image_t(img);

    check_view(view(any_img), "dynamic_");
    check_view(flipped_left_right_view(view(any_img)), "dynamic_fliplr");
    check_view(flipped_up_down_view(view(any_img)), "dynamic_flipud");
    
    any_image_t::view_t subimageView=subimage_view(view(any_img),0,0,10,15);

    check_view(subimageView, "dynamic_subimage");
    check_view(subsampled_view(rotated180_view(view(any_img)), 2,1), "dynamic_subimage_subsampled180rot");
}

template <typename Img>
void image_test::image_all_test(const string& prefix) {
    basic_test<Img>(prefix+"basic_");

    Img img;
    img.recreate(sample_view.dimensions());
    copy_and_convert_pixels(sample_view,view(img));

    view_transformations_test(view(img), prefix+"views_");

    histogram_test(const_view(img),prefix+"histogram_");
}

void image_test::run() {
    initialize();

    image_all_test<bgr8_image_t>("bgr8_");
    image_all_test<rgb8_image_t>("rgb8_");
    image_all_test<rgb8_planar_image_t>("planarrgb8_");
    image_all_test<gray8_image_t>("gray8_");

	typedef const bit_aligned_pixel_reference<boost::uint8_t, mpl::vector3_c<int,1,2,1>, bgr_layout_t, true>  bgr121_ref_t;
    typedef image<bgr121_ref_t,false> bgr121_image_t;
    image_all_test<bgr121_image_t>("bgr121_");

    // TODO: Remove?
    view_transformations_test(subsampled_view(sample_view,point2<ptrdiff_t>(1,2)),"subsampled_");
    view_transformations_test(color_converted_view<gray8_pixel_t>(sample_view),"color_converted_");

    virtual_view_test();
    packed_image_test();
    dynamic_image_test();

    finalize();
}



////////////////////////////////////////////////////
///
///  Performs or generates image tests using checksums
///
////////////////////////////////////////////////////

class checksum_image_mgr : public image_test {
protected:
    typedef map<string,boost::crc_32_type::value_type> crc_map_t;
    crc_map_t _crc_map;
};

////////////////////////////////////////////////////
///
///  Performs image tests by comparing image pixel checksums against a reference
///
////////////////////////////////////////////////////

class checksum_image_test : public checksum_image_mgr {
public:
    checksum_image_test(const char* filename) : _filename(filename) {}
private:
    const char* _filename;
    virtual void initialize();
    virtual void check_view_impl(const rgb8c_view_t& v, const string& name);
};

// Load the checksums from the reference file and create the start image
void checksum_image_test::initialize() {
    string crc_name; 
    boost::crc_32_type::value_type crc_result;
    fstream checksum_ref(_filename,ios::in);
    while (true) {
        checksum_ref >> crc_name >> std::hex >> crc_result;
        if(checksum_ref.fail()) break;
        _crc_map[crc_name]=crc_result;
    }
    checksum_ref.close();
}

// Create a checksum for the given view and compare it with the reference checksum. Throw exception if different
void checksum_image_test::check_view_impl(const rgb8c_view_t& img_view, const string& name) {
    boost::crc_32_type checksum_acumulator;
    checksum_acumulator.process_bytes(img_view.row_begin(0),img_view.size()*3);

    cerr << "Checking checksum for " << name << endl;
    if (checksum_acumulator.checksum()!=_crc_map[name]) {
        cerr << "Checksum error in "<<name<<"\n";
        error_if(true);
    }
}

////////////////////////////////////////////////////
///
///  Generates a set of reference checksums to compare against
///
////////////////////////////////////////////////////

class checksum_image_generate : public checksum_image_mgr {
public:
    checksum_image_generate(const char* filename) : _filename(filename) {}
private:
    const char* _filename;
    virtual void check_view_impl(const rgb8c_view_t& img_view, const string& name);
    virtual void finalize();
};

// Add the checksum of the given view to the map of checksums
void checksum_image_generate::check_view_impl(const rgb8c_view_t& img_view, const string& name) {
    boost::crc_32_type result;
    result.process_bytes(img_view.row_begin(0),img_view.size()*3);
    cerr << "Generating checksum for " << name << endl;
    _crc_map[name] = result.checksum();
}

// Save the checksums into the reference file
void checksum_image_generate::finalize() {
    fstream checksum_ref(_filename,ios::out);
    for (crc_map_t::const_iterator it=_crc_map.begin(); it!=_crc_map.end(); ++it) {
        checksum_ref << it->first << " " << std::hex << it->second << "\r\n";
    }
    checksum_ref.close();
}


////////////////////////////////////////////////////
///
///  Performs or generates image tests using image I/O
///
////////////////////////////////////////////////////

extern const string in_dir;
extern const string out_dir;
extern const string ref_dir;

const string in_dir="";  // directory of source images
const string out_dir=in_dir+"image-out/";    // directory where to write output
const string ref_dir=in_dir+"image-ref/";  // reference directory to compare written with actual output

#ifndef BOOST_GIL_NO_IO

#include <boost/gil/extension/io/jpeg_io.hpp>

class file_image_mgr : public image_test {};

class file_image_test : public file_image_mgr {
public:
    file_image_test(const char*) {}
protected:
    void check_view_impl(const boost::gil::rgb8c_view_t& img_view,const string& name) {
        jpeg_write_view(out_dir+name+".jpg",img_view);
        rgb8_image_t img1, img2;
        jpeg_read_and_convert_image(out_dir+name+".jpg",img1);
        cerr << "Testing "<<name<<"\n";

        jpeg_read_and_convert_image(ref_dir+name+".jpg",img2);
        if (img1!=img2) {
            cerr << "Error with "<<name<<"\n";
            error_if(true);
        }
    }
};

class file_image_generate : public file_image_mgr {
public:
    file_image_generate(const char*) {}
protected:
    void check_view_impl(const boost::gil::rgb8c_view_t& img_view,const string& name) {
        jpeg_write_view(ref_dir+name+".jpg",img_view);
        cerr << "Writing "<<name<<"\n";
    }
};
#endif








void static_checks() {
    gil_function_requires<ImageConcept<rgb8_image_t> >();

    BOOST_STATIC_ASSERT(view_is_basic<rgb8_step_view_t>::value);
    BOOST_STATIC_ASSERT(view_is_basic<cmyk8c_planar_step_view_t>::value);
    BOOST_STATIC_ASSERT(view_is_basic<rgb8_planar_view_t>::value);

    BOOST_STATIC_ASSERT(view_is_step_in_x<rgb8_step_view_t>::value);
    BOOST_STATIC_ASSERT(view_is_step_in_x<cmyk8c_planar_step_view_t>::value);
    BOOST_STATIC_ASSERT(!view_is_step_in_x<rgb8_planar_view_t>::value);

    BOOST_STATIC_ASSERT(!is_planar<rgb8_step_view_t>::value);
    BOOST_STATIC_ASSERT(is_planar<cmyk8c_planar_step_view_t>::value);
    BOOST_STATIC_ASSERT(is_planar<rgb8_planar_view_t>::value);

    BOOST_STATIC_ASSERT(view_is_mutable<rgb8_step_view_t>::value);
    BOOST_STATIC_ASSERT(!view_is_mutable<cmyk8c_planar_step_view_t>::value);
    BOOST_STATIC_ASSERT(view_is_mutable<rgb8_planar_view_t>::value);

    BOOST_STATIC_ASSERT((boost::is_same<derived_view_type<cmyk8c_planar_step_view_t>::type, cmyk8c_planar_step_view_t>::value));
    BOOST_STATIC_ASSERT((boost::is_same<derived_view_type<cmyk8c_planar_step_view_t, bits16, rgb_layout_t>::type,  rgb16c_planar_step_view_t>::value));
    BOOST_STATIC_ASSERT((boost::is_same<derived_view_type<cmyk8c_planar_step_view_t, use_default, rgb_layout_t, mpl::false_, use_default, mpl::false_>::type,  rgb8c_step_view_t>::value));

    // test view get raw data (mostly compile-time test)
    {
    rgb8_image_t rgb8(100,100);
    unsigned char* data=interleaved_view_get_raw_data(view(rgb8));
    const unsigned char* cdata=interleaved_view_get_raw_data(const_view(rgb8));
    error_if(data!=cdata);
    }

    {
    rgb16s_planar_image_t rgb8(100,100);
    short* data=planar_view_get_raw_data(view(rgb8),1);
    const short* cdata=planar_view_get_raw_data(const_view(rgb8),1);
    error_if(data!=cdata);
    }
}

#ifdef BOOST_GIL_NO_IO
typedef checksum_image_test     image_test_t;
typedef checksum_image_generate image_generate_t;
#else
typedef file_image_test         image_test_t;
typedef file_image_generate     image_generate_t;
#endif

#ifdef BOOST_GIL_GENERATE_REFERENCE_DATA
typedef image_generate_t        image_mgr_t;
#else
typedef image_test_t            image_mgr_t;
#endif


void test_image(const char* ref_checksum) {
    image_mgr_t mgr(ref_checksum);

    mgr.run();
    static_checks();
}

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

    const char* local_name = "gil_reference_checksums.txt";
    const char* name_from_status = "../libs/gil/test/gil_reference_checksums.txt";

    std::ifstream file_is_there(local_name);
    if (file_is_there) {
        test_image(local_name);
    } else {
        std::ifstream file_is_there(name_from_status);
        if (file_is_there)
            test_image(name_from_status);
        else {
            std::cerr << "Unable to open gil_reference_checksums.txt"<<std::endl;
            return 1;
        }
    }

    return 0;
}