Boost C++ Libraries: Ticket #2211: Can not create image of Regular type

attachment set

john.femiani@… — Mon, 18 Aug 2008 05:08:23 GMT

attachment → test_gil_image_of_regular_type.cpp

A Boost.Test testcase that fails to compile when it should succed AFIK.

john.femiani@… — Mon, 18 Aug 2008 10:42:34 GMT

The issue is twofold:

A regular type (like a single-chennel pixel) can be considered planer or interleaved. When the image type is planar, GIL tends to use the num_channels metafunction (valid only for PixelBased), so it is easier just to say Regular types are not planar.

The is_planar metafunction had no default value. I think it is safe to say that the is_planar metafunction is short for is_planar_pixel, and so if the type is not a pixel it should return false_. In fact, I think it is reasonable to let it have a default value of false_.

Some of the code first checks if the image is planar and then uses PixelBased operations if it is planar, but the code was laid out so that both branches of the if (!IsPLanar) condition had to compiles. I reorganized that code slightly.

Since I have had bad luck attaching patches on this Trac site (Trac thinks they ar spam!), the patch that made my test compile is attached (no clue if I broke anything else, I just have the headers here).

image.hpp

         if (_memory) _alloc.deallocate(_memory, total_allocated_size_in_bytes(dimensions));
+    }
+    struct _channels_in_image :
+        mpl::eval_if<is_pixel<value_type>,
+            num_channels<view_t>,
+            mpl::int_<1>
+            >::type
+    {};
     std::size_t total_allocated_size_in_bytes(const point_t& dimensions) const {
         std::size_t size_in_units = get_row_size_in_memunits(dimensions.x)*dimensions.y;
-                if (IsPlanar)
-                        size_in_units = size_in_units*num_channels<view_t>::value;
+        typedef typename view_t::x_iterator x_iterator;
+        if (IsPlanar)
+                        size_in_units = size_in_units*_channels_in_image::value;
         // return the size rounded up to the nearest byte
+        return (size_in_units + byte_to_memunit<typename view_t::x_iterator>::value - 1) / byte_to_memunit<typename view_t::x_iterator>::value
+                        + (_align_in_bytes>0 ? _align_in_bytes-1:0);    // add extra padding in case we need to align the first image pixel
+        return (size_in_units + byte_to_memunit<x_iterator>::value - 1) / byte_to_memunit<x_iterator>::value
+                        + (_align_in_bytes>0 ? _align_in_bytes-1:0);
+        // add extra padding in case we need to align the first image pixel
+    }
     std::size_t get_row_size_in_memunits(x_coord_t width) const {   // number of units per row

pixel.hpp

 template <typename PixelBased> struct color_space_type;
 template <typename PixelBased> struct channel_mapping_type;
 template <typename PixelBased> struct channel_type;
 template <typename PixelBased> struct is_planar;
+template <typename PixelBased> struct is_planar : mpl::false_{}; //False by default
 template <typename PixelBased> struct color_space_type<const PixelBased> : public color_space_type<PixelBased> {};
 template <typename PixelBased> struct channel_mapping_type<const PixelBased> : public channel_mapping_type<PixelBased> {};

anonymous — Tue, 19 Aug 2008 09:24:42 GMT

Replying to john.femiani@asu.edu:

A regular type (like a single-chennel pixel) can be considered planer or interleaved. When the image type is planar, GIL tends to use the num_channels metafunction (valid only for PixelBased), so it is easier just to say Regular types are not planar.

In order to make this clear, I suggest the following additional patch, to be applied after the first:

image.hpp

 ////////////////////////////////////////////////////////////////////////////////////////
+template <typename Pixel, bool IsPlanar, typename Alloc=std::allocator<unsigned char> >
+template <typename Pixel,
+          bool IsPlanar=false,
+          typename Alloc=std::allocator<unsigned char> >
 class image {
 public:
     typedef typename Alloc::template rebind<unsigned char>::other allocator_type;

This provides a default value for the IsPlanar template argument, so it can b left out if the image is a single channel pixel, so it does not create semantic 'noise'.

For example:

 gil::image<int> the_img(100,100);
 gil::image<int>::view_t the_view = view(img);
 //NOTE: Why arent views constructible from images?

--John

status changed; resolution set

chhenning — Thu, 05 Aug 2010 18:55:31 GMT

status new → closed
resolution → fixed

Patch has been applied. Closing this ticket.