Does boost::gil support 10 bit images?

Question

I'm trying to read 10 bit images from a buffer and analyze them with boost::gil. I noticed that there exists an rgb8_image_t type, a gray8_image_t type, but can't find a gray10_image_t type (which is what I need). Does this exist in gil? Thanks!

EDIT: When using these typedefs:

// reference type
typedef boost::gil::bit_aligned_pixel_reference<unsigned short, boost::mpl::vector1_c<unsigned, 10>, boost::gil::gray_layout_t, true> gray10_ref_t;

// iterator type
typedef boost::gil::bit_aligned_pixel_iterator<gray10_ref_t> gray10_ptr_t;

// pixel type
typedef std::iterator_traits<gray10_ptr_t>::value_type gray10_pixel_t;

// pixel storage to read, contains 3 10-bit gray pixels, all with value of 1 as per the following layout
// spaces show byte breaks, bars show pixel breaks, lsb first
// 10000000 00|100000 0000|1000 00000000
std::uint8_t data[4] = { 0x01, 0x04, 0x10, 0x00 };

// an iterator to the start of the storage
gray10_ptr_t p(&data[0], 0);

// check the expected pixel values
assert(p[0] == 0x01);
assert(p[1] == 0x01);
assert(p[2] == 0x01);

I get the following errors upon compiling:

untitled.cpp:17:6: error: ‘uint8_t’ in namespace ‘std’ does not name a type 
std::uint8_t data[4] = { 0x01, 0x04, 0x10, 0x00 };
     ^
untitled.cpp:20:17: error: ‘data’ was not declared in this scope
 gray10_ptr_t p(&data[0], 0);
                 ^
In file included from /usr/include/boost/predef/detail/_cassert.h:14:0,
                 from /usr/include/boost/predef/library/c/_prefix.h:11,
                 from /usr/include/boost/predef/library/c.h:11,
                 from /usr/include/boost/predef/library.h:11,
                 from /usr/include/boost/predef.h:14,
                 from /usr/include/boost/smart_ptr/detail/yield_k.hpp:28,
                 from /usr/include/boost/smart_ptr/detail/spinlock_sync.hpp:18,
                 from /usr/include/boost/smart_ptr/detail/spinlock.hpp:50,
                 from /usr/include/boost/smart_ptr/detail/spinlock_pool.hpp:25,
                 from /usr/include/boost/smart_ptr/shared_ptr.hpp:34,
                 from /usr/include/boost/shared_ptr.hpp:17,
                 from /usr/include/boost/gil/extension/io/io_error.hpp:23,
                 from /usr/include/boost/gil/extension/io/tiff_io.hpp:29,
                 from untitled.cpp:1:
untitled.cpp:23:13: error: expected ‘)’ before ‘==’ token
 assert(p[0] == 0x01);
             ^
untitled.cpp:23:13: error: expected ‘)’ before ‘==’ token
untitled.cpp:24:13: error: expected ‘)’ before ‘==’ token
 assert(p[1] == 0x01);
             ^
untitled.cpp:24:13: error: expected ‘)’ before ‘==’ token
untitled.cpp:25:13: error: expected ‘)’ before ‘==’ token
 assert(p[2] == 0x01);
             ^
untitled.cpp:25:13: error: expected ‘)’ before ‘==’ token

Does anyone know how to fix these? Thanks.

Answer 1

There isn't, but you can define one yourself.

As your pixel type isn't byte-aligned, you need to declare a bit-aligned pixel and relevant types:

Bit-aligned pixels (and images) are more complex than packed ones. Since packed pixels are byte-aligned, we can use a C++ reference as the reference type to a packed pixel, and a C pointer as an x_iterator over a row of packed pixels. For bit-aligned constructs we need a special reference proxy class (bit_aligned_pixel_reference) and iterator class (bit_aligned_pixel_iterator). The value type of bit-aligned pixels is a packed_pixel.

A working example:

#include <boost/gil.hpp>
#include <boost/mpl/vector.hpp>
#include <cstdint>

int main()
{
    // reference type
    using gray10_ref_t = boost::gil::bit_aligned_pixel_reference<unsigned short, boost::mpl::vector1_c<unsigned, 10>, boost::gil::gray_layout_t, true>;
    // iterator type
    using gray10_ptr_t = boost::gil::bit_aligned_pixel_iterator<gray10_ref_t>;
    // pixel type
    using gray10_pixel_t = std::iterator_traits<gray10_ptr_t>::value_type;

    // pixel storage to read, contains 3 10-bit gray pixels, all with value of 1 as per the following layout
    // spaces show byte breaks, bars show pixel breaks, lsb first
    // 10000000 00|100000 0000|1000 00000000
    std::uint8_t data[4] = { 0x01, 0x04, 0x10, 0x00 };

    // an iterator to the start of the storage
    gray10_ptr_t p(&data[0], 0);

    // check the expected pixel values
    assert(p[0] == 0x01);
    assert(p[1] == 0x01);
    assert(p[2] == 0x01);
}