gil/toolbox/test/indexed_image_test.cpp

//
// Copyright 2013 Christian Henning
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
#include <boost/gil.hpp>
#include <boost/gil/extension/toolbox/image_types/indexed_image.hpp>

#include <boost/assert.hpp>
#include <boost/test/unit_test.hpp>

using namespace std;
using namespace boost;
using namespace gil;

BOOST_AUTO_TEST_SUITE( toolbox_tests )

BOOST_AUTO_TEST_CASE( index_image_test )
{
    {
        indexed_image< uint8_t, rgb8_pixel_t > img( 640, 480 );
        fill_pixels( view( img ), rgb8_pixel_t( 255, 0, 0 ));

        rgb8_pixel_t p = *view( img ).xy_at( 10, 10 );
    }

    {
        using image_t = indexed_image<gray8_pixel_t, rgb8_pixel_t>;

        image_t img( 640, 480, 256 );

        generate_pixels(img.get_indices_view(), []() -> uint8_t
        {
            static uint8_t i = 0;
            i = (i == 256) ? 0 : (i + 1);
            return gray8_pixel_t(i);
        });

        generate_pixels(img.get_palette_view(), []() -> rgb8_pixel_t
        {
            static uint8_t i = 0;
            i = (i == 256) ? 0 : (i + 1);
            return rgb8_pixel_t(i, i, i);
        });

        gray8_pixel_t index = *img.get_indices_view().xy_at( 10   , 1 );
        rgb8_pixel_t  color = *img.get_palette_view().xy_at( index, 0 );

        rgb8_pixel_t p = *view( img ).xy_at( 10, 1 );
    }

    {
        using image_t = indexed_image<gray8_pixel_t, rgb8_pixel_t>;
        image_t img( 640, 480, 256 );

        generate_pixels(img.get_indices_view(), []() -> uint8_t
        {
            static uint8_t i = 0;
            i = (i == 256) ? 0 : (i + 1);
            return i;
        });

        generate_pixels(img.get_palette_view(), []() -> rgb8_pixel_t
        {
            static uint8_t i = 0;
            i = (i == 256) ? 0 : (i + 1);
            return rgb8_pixel_t(i, i, i);
        });

        uint8_t      index = *img.get_indices_view().xy_at( 10   , 1 );
        rgb8_pixel_t color = *img.get_palette_view().xy_at( index, 0 );

        rgb8_pixel_t p = *view( img ).xy_at( 10, 1 );
    }

    {
        using image_t = indexed_image<uint8_t, rgb8_pixel_t>;
        image_t img( 640, 480, 256 );

        for( image_t::y_coord_t y = 0; y < view( img ).height(); ++y )
        {
            image_t::view_t::x_iterator it = view( img ).row_begin( y );

            for( image_t::x_coord_t x = 0; x < view( img ).width(); ++x )
            {
                rgb8_pixel_t p = *it;
                it++;
            }
        }
    }
}

BOOST_AUTO_TEST_CASE(index_image_view_test)
{
    // generate some data
    std::size_t const width = 640;
    std::size_t const height = 480;
    std::size_t const num_colors = 3;
    std::uint8_t const index = 2;

    // indices
    vector<uint8_t> indices(width * height, index);

    // colors
    vector<rgb8_pixel_t> palette(num_colors);
    palette[0] = rgb8_pixel_t(10, 20, 30);
    palette[1] = rgb8_pixel_t(40, 50, 60);
    palette[2] = rgb8_pixel_t(70, 80, 90);

    // create image views from raw memory
    using indices_loc_t = gray8_image_t::view_t::locator;
    using palette_loc_t = rgb8_image_t::view_t::locator;


    auto indices_view = interleaved_view(width, height
        , (gray8_image_t::view_t::x_iterator) indices.data()
        , width // row size in bytes
    );

    auto palette_view = interleaved_view(100, 1
        , (rgb8_image_t::view_t::x_iterator) palette.data()
        , num_colors * 3 // row size in bytes
    );

    auto ii_view = view(indices_view, palette_view);

    auto p = ii_view(point_t(0, 0));
    auto q = *ii_view.at(point_t(0, 0));

    BOOST_ASSERT(get_color(p, red_t()) == 70);
    BOOST_ASSERT(get_color(p, green_t()) == 80);
    BOOST_ASSERT(get_color(p, blue_t()) == 90);

    BOOST_ASSERT(get_color(q, red_t()) == 70);
    BOOST_ASSERT(get_color(q, green_t()) == 80);
    BOOST_ASSERT(get_color(q, blue_t()) == 90);
}

BOOST_AUTO_TEST_SUITE_END()