  alpha_t | Alpha |
| Assignable< T > | |
| binary_operation_obj< Derived, Result > | A generic binary operation on viewsUse this class as a convenience superclass when defining an operation for any image views. Many operations have different behavior when the two views are compatible. This class checks for compatibility and invokes apply_compatible(V1,V2) or apply_incompatible(V1,V2) of the subclass. You must provide apply_compatible(V1,V2) method in your subclass, but apply_incompatible(V1,V2) is not required and the default throws std::bad_cast |
| binary_operation_obj< copy_and_convert_pixels_fn< CC > > | |
| binary_operation_obj< copy_pixels_fn > | |
| binary_operation_obj< equal_pixels_fn, bool > | |
| bit_aligned_image_type< ChannelBitSizeVector, Layout, Alloc > | Returns the type of a packed image whose pixels may not be byte aligned. For example, an "rgb222" image is bit-aligned because its pixel spans six bits |
 bit_aligned_image_type< mpl::vector1_c< unsigned, Size1 >, Layout, Alloc > | |
  bit_aligned_image1_type< Size1, Layout, Alloc > | Returns the type of a single-channel bit-aligned image given the bit size of its channel and its layout |
| bit_aligned_image_type< mpl::vector2_c< unsigned, Size1, Size2 >, Layout, Alloc > | |
| bit_aligned_image2_type< Size1, Size2, Layout, Alloc > | Returns the type of a two channel bit-aligned image given the bit size of its channels and its layout |
| bit_aligned_image_type< mpl::vector3_c< unsigned, Size1, Size2, Size3 >, Layout, Alloc > | |
| bit_aligned_image3_type< Size1, Size2, Size3, Layout, Alloc > | Returns the type of a three channel bit-aligned image given the bit size of its channels and its layout |
| bit_aligned_image_type< mpl::vector4_c< unsigned, Size1, Size2, Size3, Size4 >, Layout, Alloc > | |
| bit_aligned_image4_type< Size1, Size2, Size3, Size4, Layout, Alloc > | Returns the type of a four channel bit-aligned image given the bit size of its channels and its layout |
| bit_aligned_image_type< mpl::vector5_c< unsigned, Size1, Size2, Size3, Size4, Size5 >, Layout, Alloc > | |
| bit_aligned_image5_type< Size1, Size2, Size3, Size4, Size5, Layout, Alloc > | Returns the type of a five channel bit-aligned image given the bit size of its channels and its layout |
| bit_aligned_pixel_iterator< NonAlignedPixelReference > | An iterator over non-byte-aligned pixels. Models PixelIteratorConcept, PixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept |
| bit_aligned_pixel_reference< BitField, ChannelBitSizes, Layout, IsMutable > | Heterogeneous pixel reference corresponding to non-byte-aligned bit range. Models ColorBaseConcept, PixelConcept, PixelBasedConcept |
| black_t | Black |
| blue_t | Blue |
| bmp_bits_per_pixel | Defines type for bits per pixels property |
| bmp_compression | Defines type for compression property |
| bmp_header_size | Defines type for header sizes |
| bmp_horizontal_resolution | Defines type for horizontal resolution property |
| bmp_image_height | Defines type for image height property |
| bmp_image_size | Defines type for image size property |
| bmp_image_width | Defines type for image width property |
| bmp_num_colors | Defines type for number of colors property |
| bmp_num_important_colors | Defines type for important number of colors property |
| bmp_offset | See http://en.wikipedia.org/wiki/BMP_file_format#BMP_File_Header for reference |
| bmp_tag | Defines bmp tag |
| bmp_top_down | If height is negative then image is stored top-down instead of bottom-up |
| bmp_vertical_resolution | Defines type for vertical resolution property |
| byte_to_memunit< T > | |
| byte_to_memunit< Iterator > | |
| channel_converter< SrcChannelV, DstChannelV > | A unary function object converting between channel types |
| channel_converter_unsigned< bits32, bits32f > | 32 bit <-> float channel conversion |
| channel_converter_unsigned< bits32f, bits32 > | 32 bit <-> float channel conversion |
| channel_converter_unsigned< bits32f, DstChannelV > | Bits32f conversion |
| channel_converter_unsigned_impl< SrcChannelV, DstChannelV, SrcIsIntegral, DstIsIntegral > | This is the default implementation. Performance specializatons are provided |
| channel_converter_unsigned_impl< SrcChannelV, DstChannelV, is_integral< SrcChannelV >::value, is_integral< DstChannelV >::value > | |
| channel_mapping_type< planar_pixel_reference< ChannelReference, ColorSpace > > | Specifies the color space type of a planar pixel reference. Required by PixelBasedConcept |
| channel_multiplier< ChannelValue > | A function object to multiply two channels. result = a * b / max_value |
| channel_multiplier_unsigned< ChannelValue > | This is the default implementation. Performance specializatons are provided |
| channel_multiplier_unsigned< bits16 > | Specialization of channel_multiply for 16-bit unsigned channels |
| channel_multiplier_unsigned< bits32f > | Specialization of channel_multiply for float 0..1 channels |
| channel_multiplier_unsigned< bits8 > | Specialization of channel_multiply for 8-bit unsigned channels |
| channel_traits< T > | Traits for channels. Contains the following members: |
| channel_type< planar_pixel_reference< ChannelReference, ColorSpace > > | Specifies the color space type of a planar pixel reference. Required by HomogeneousPixelBasedConcept |
| ChannelConcept< T > | A channel is the building block of a color. Color is defined as a mixture of primary colors and a channel defines the degree to which each primary color is used in the mixture |
| ChannelConvertibleConcept< SrcChannel, DstChannel > | A channel is convertible to another one if the channel_convert algorithm is defined for the two channels |
| ChannelMappingConcept< CM > | Channel mapping concept |
| channels_are_compatible< T1, T2 > | Predicate metafunction returning whether two channels are compatibleChannels are considered compatible if their value types (ignoring constness and references) are the same |
| ChannelsCompatibleConcept< T1, T2 > | Channels are compatible if their associated value types (ignoring constness and references) are the same |
| ChannelValueConcept< T > | A channel that supports default construction |
| color_converted_view_type< SrcView, DstP, CC > | Returns the type of a view that does color conversion upon dereferencing its pixels |
| color_converted_view_type< any_image_view< ViewTypes >, DstP > | Returns the type of a runtime-specified view, color-converted to a given pixel type with the default coor converter |
| color_converted_view_type< any_image_view< ViewTypes >, DstP, CC > | Returns the type of a runtime-specified view, color-converted to a given pixel type with user specified color converter |
| color_converted_view_type< View, DstP, CC > | |
| color_space_type< planar_pixel_reference< ChannelReference, ColorSpace > > | Specifies the color space type of a planar pixel reference. Required by PixelBasedConcept |
| ColorBaseConcept< ColorBase > | A color base is a container of color elements (such as channels, channel references or channel pointers) |
| ColorBasesCompatibleConcept< ColorBase1, ColorBase2 > | Two color bases are compatible if they have the same color space and their elements are compatible, semantic-pairwise |
| ColorBaseValueConcept< ColorBase > | Color base that also has a default-constructor. Refines Regular |
| ColorSpaceConcept< Cs > | Color space type concept |
| ColorSpacesCompatibleConcept< Cs1, Cs2 > | Two color spaces are compatible if they are the same |
| const_iterator_type< It > | Returns the type of an iterator just like the input iterator, except operating over immutable values |
| contains_color< ColorBase, Color > | A predicate metafunction determining whether a given color base contains a given color |
| copier_n< I, O > | |
| copier_n< I, iterator_from_2d< OL > > | Destination range is delimited by image iterators |
| copier_n< iterator_from_2d< IL >, iterator_from_2d< OL > > | Both source and destination ranges are delimited by image iterators |
| copier_n< iterator_from_2d< IL >, O > | Source range is delimited by image iterators |
| CopyConstructible< T > | |
| cyan_t | Cyan |
| dec< T > | Operator– wrapped in a function object |
| default_channel_converter | Same as channel_converter, except it takes the destination channel by reference, which allows us to move the templates from the class level to the method level. This is important when invoking it on heterogeneous pixels |
| default_color_converter | Class for color-converting one pixel to another |
| default_color_converter_impl< C1, C2 > | Color Convertion function object. To be specialized for every src/dst color space |
| default_color_converter_impl< C, C > | When the color space is the same, color convertion performs channel depth conversion |
| default_color_converter_impl< C1, rgba_t > | Converting any pixel type to RGBA. Note: Supports homogeneous pixels only |
| default_color_converter_impl< cmyk_t, gray_t > | CMYK to Gray |
| default_color_converter_impl< cmyk_t, rgb_t > | CMYK to RGB (not the fastest code in the world) |
| default_color_converter_impl< gray_t, cmyk_t > | Gray to CMYK |
| default_color_converter_impl< gray_t, rgb_t > | Gray to RGB |
| default_color_converter_impl< rgb_t, cmyk_t > | RGB to CMYK (not the fastest code in the world) |
| default_color_converter_impl< rgb_t, gray_t > | RGB to Gray |
| default_color_converter_impl< rgba_t, C2 > | Converting RGBA to any pixel type. Note: Supports homogeneous pixels only |
| default_color_converter_impl< rgba_t, rgba_t > | Unfortunately RGBA to RGBA must be explicitly provided - otherwise we get ambiguous specialization error |
| DefaultConstructible< T > | |
| deref_base< ConstT, Value, Reference, ConstReference, ArgType, ResultType, IsMutable > | Helper base class for pixel dereference adaptors |
| deref_base< color_convert_deref_fn< SrcConstRefP, DstP, CC >, DstP, DstP, const DstP &, SrcConstRefP, DstP, false > | |
| color_convert_deref_fn< SrcConstRefP, DstP, CC > | Function object that given a source pixel, returns it converted to a given color space and channel depth. Models: PixelDereferenceAdaptorConcept |
| deref_base< deref_compose< D1::const_t, D2::const_t >, D1::value_type, D1::reference, D1::const_reference, D2::argument_type, D1::result_type, D1::is_mutable &&D2::is_mutable > | |
| deref_compose< D1, D2 > | Composes two dereference function objects. Similar to std::unary_compose but needs to pull some typedefs from the component types. Models: PixelDereferenceAdaptorConcept |
| dereference_iterator_adaptor< Iterator, DFn > | An adaptor over an existing iterator that provides for custom filter on dereferencing the object. Models: IteratorAdaptorConcept, PixelIteratorConcept |
| derived_image_type< Image, T, L, IsPlanar > | Constructs a homogeneous image type from a source image type by changing some of the properties.Use use_default for the properties of the source image that you want to keep |
| derived_iterator_type< Iterator, T, L, IsPlanar, IsStep, IsMutable > | Constructs a pixel iterator type from a source pixel iterator type by changing some of the properties.Use use_default for the properties of the source view that you want to keep |
| derived_pixel_reference_type< Ref, T, L, IsPlanar, IsMutable > | Constructs a pixel reference type from a source pixel reference type by changing some of the properties.Use use_default for the properties of the source view that you want to keep |
| derived_view_type< View, T, L, IsPlanar, StepX, IsMutable > | Constructs an image view type from a source view type by changing some of the properties.Use use_default for the properties of the source view that you want to keep |
| devicen_color_t< N > | Unnamed color |
| devicen_t< 1 > | Unnamed color space of one channel |
| devicen_t< 2 > | Unnamed color space of two channels |
| devicen_t< 3 > | Unnamed color space of three channels |
| devicen_t< 4 > | Unnamed color space of four channels |
| devicen_t< 5 > | Unnamed color space of five channels |
| dynamic_xy_step_type< View > | Returns the type of a view that has a dynamic step along both X and Y |
| dynamic_xy_step_type< transposed_type< View >::type > | |
| dynamic_xy_step_transposed_type< View > | Returns the type of a transposed view that has a dynamic step along both X and Y |
| element_const_reference_type< ColorBase > | Specifies the return type of the constant element accessor at_c of a homogeneous color base |
| element_reference_type< ColorBase > | Specifies the return type of the mutable element accessor at_c of a homogeneous color base |
| element_type< ColorBase > | Specifies the element type of a homogeneous color base |
| element_type< P > | |
| equal_n_fn< boost::gil::iterator_from_2d< Loc >, I2 > | Source range is delimited by image iterators |
| equal_n_fn< boost::gil::iterator_from_2d< Loc1 >, boost::gil::iterator_from_2d< Loc2 > > | Both source and destination ranges are delimited by image iterators |
| equal_n_fn< const pixel< T, Cs > *, const pixel< T, Cs > * > | |
| equal_n_fn< I1, boost::gil::iterator_from_2d< Loc > > | Destination range is delimited by image iterators |
| equal_n_fn< planar_pixel_iterator< IC, Cs >, planar_pixel_iterator< IC, Cs > > | |
| EqualityComparable< T > | |
| gil_io_png_text | Helper structure for reading text property |
| gray_color_t | Gray |
| green_t | Green |
| HasDynamicXStepTypeConcept< T > | Concept for iterators, locators and views that can define a type just like the given iterator/locator/view, except it supports runtime specified step along the X navigation |
| HasDynamicYStepTypeConcept< T > | Concept for locators and views that can define a type just like the given locator or view, except it supports runtime specified step along the Y navigation |
| HasTransposedTypeConcept< T > | Concept for locators and views that can define a type just like the given locator or view, except X and Y is swapped |
| homogeneous_color_base< Element, Layout, 1 > | A homogeneous color base holding one color element. Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept |
| homogeneous_color_base< Element, Layout, 2 > | A homogeneous color base holding two color elements. Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept |
| homogeneous_color_base< Element, Layout, 3 > | A homogeneous color base holding three color elements. Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept |
| homogeneous_color_base< Element, Layout, 4 > | A homogeneous color base holding four color elements. Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept |
| homogeneous_color_base< Element, Layout, 5 > | A homogeneous color base holding five color elements. Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept |
| HomogeneousColorBaseConcept< ColorBase > | Color base whose elements all have the same type |
| HomogeneousColorBaseValueConcept< ColorBase > | Homogeneous color base that also has a default constructor. Refines Regular |
| HomogeneousPixelBasedConcept< P > | Concept for homogeneous pixel-based GIL constructs |
| HomogeneousPixelConcept< P > | Homogeneous pixel concept |
| HomogeneousPixelValueConcept< P > | Homogeneous pixel concept that is a Regular type |
| identity< T > | Identity taken from SGI STL |
| channel_converter_unsigned< T, T > | Converting a channel to itself - identity operation |
| identity< ChannelValue > | |
| image< Pixel, IsPlanar, Alloc > | Container interface over image view. Models ImageConcept, PixelBasedConcept |
| image_is_basic< Img > | Basic images must use basic views and std::allocator of char |
| image_read_info< bmp_tag > | Constant signature for bmp file format |
| image_read_info< jpeg_tag > | |
| image_read_info< pnm_tag > | |
| image_read_info< raw_tag > | |
| image_read_info< targa_tag > | |
| image_read_info< tiff_tag > | |
| image_read_settings< bmp_tag > | |
| image_read_settings< jpeg_tag > | |
| image_read_settings< pnm_tag > | |
| image_read_settings< raw_tag > | |
| image_read_settings< targa_tag > | |
| image_read_settings< tiff_tag > | |
| image_type< T, L, IsPlanar, Alloc > | Returns the type of a homogeneous image given the channel type, layout, and whether it operates on planar data |
| image_view< Loc > | A lightweight object that interprets memory as a 2D array of pixels. Models ImageViewConcept,PixelBasedConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConcept |
| image_write_info< bmp_tag > | |
| image_write_info< jpeg_tag > | |
| image_write_info< pnm_tag > | |
| image_write_info< raw_tag > | |
| image_write_info< targa_tag > | |
| image_write_info< tiff_tag, Log > | |
| ImageConcept< Img > | 2-dimensional image whose value type models PixelValueConcept |
| ImageViewConcept< View > | GIL's 2-dimensional view over immutable GIL pixels |
| inc< T > | Operator++ wrapped in a function object |
| is_iterator_adaptor< It > | Metafunction predicate determining whether the given iterator is a plain one or an adaptor over another iterator. Examples of adaptors are the step iterator and the dereference iterator adaptor |
| is_pixel< bit_aligned_pixel_reference< B, C, L, M > > | Metafunction predicate that flags bit_aligned_pixel_reference as a model of PixelConcept. Required by PixelConcept |
| is_pixel< planar_pixel_reference< ChannelReference, ColorSpace > > | Metafunction predicate that flags planar_pixel_reference as a model of PixelConcept. Required by PixelConcept |
| is_planar< planar_pixel_reference< ChannelReference, ColorSpace > > | Specifies that planar_pixel_reference represents a planar construct. Required by PixelBasedConcept |
| iterator_adaptor_get_base< It > | Returns the base iterator for a given iterator adaptor. Provide an specialization when introducing new iterator adaptors |
| iterator_adaptor_rebind< It, NewBaseIt > | Changes the base iterator of an iterator adaptor. Provide an specialization when introducing new iterator adaptors |
| iterator_add_deref< Iterator, D > | Returns the type (and creates an instance) of an iterator that invokes the given dereference adaptor upon dereferencing |
| iterator_add_deref< dereference_iterator_adaptor< Iterator, PREV_DEREF >, Deref > | For dereference iterator adaptors, compose the new function object after the old one |
| iterator_from_2d< Loc2 > | Provides 1D random-access navigation to the pixels of the image. Models: PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept |
| iterator_is_basic< Iterator > | Determines if a given pixel iterator is basic Basic iterators must use gil::pixel (if interleaved), gil::planar_pixel_iterator (if planar) and gil::memory_based_step_iterator (if step). They must use the standard constness rules |
| iterator_is_mutable< It > | Metafunction predicate returning whether the given iterator allows for changing its values |
| iterator_is_mutable< Iterator > | |
| iterator_is_mutable< L::x_iterator > | |
| locator_is_mutable< L > | Determines if the given locator is mutable (i.e. its pixels can be changed) |
| iterator_is_mutable< Loc::x_iterator > | |
| iterator_is_mutable< V::x_iterator > | |
| view_is_mutable< V > | Determines if the given view is mutable (i.e. its pixels can be changed) |
| iterator_is_step< I > | Determines if the given iterator has a step that could be set dynamically |
| iterator_is_step< iterator_adaptor_get_base< It >::type > | |
| iterator_is_step< L::x_iterator > | |
| locator_is_step_in_x< L > | Determines if the given locator has a horizontal step that could be set dynamically |
| iterator_is_step< L::y_iterator > | |
| locator_is_step_in_y< L > | Determines if the given locator has a vertical step that could be set dynamically |
| iterator_is_step< V::xy_locator::x_iterator > | |
 locator_is_step_in_x< V::xy_locator > | |
 view_is_step_in_x< V > | Determines if the given view has a horizontal step that could be set dynamically |
| iterator_is_step< V::xy_locator::y_iterator > | |
| locator_is_step_in_y< V::xy_locator > | |
| view_is_step_in_y< V > | Determines if the given view has a vertical step that could be set dynamically |
| iterator_type< T, L, IsPlanar, IsStep, IsMutable > | Returns the type of a homogeneous iterator given the channel type, layout, whether it operates on planar data, whether it is a step iterator, and whether it is mutable |
| iterator_type_from_pixel< Pixel, IsPlanar, IsStep, IsMutable > | Returns the type of a pixel iterator given the pixel type, whether it operates on planar data, whether it is a step iterator, and whether it is mutable |
| iterator_type_from_pixel< const bit_aligned_pixel_reference< B, C, L, M >, IsPlanar, IsStep, IsMutable > | |
| IteratorAdaptorConcept< Iterator > | Iterator adaptor is a forward iterator adapting another forward iterator |
| jpeg_color_space | Defines type for color space property |
| jpeg_data_precision | Defines type for data precision property |
| jpeg_dct_method | Defines type for dct ( discrete cosine transformation ) method property |
| jpeg_density_unit | JFIF code for pixel size units |
| jpeg_image_height | Defines type for image height property |
| jpeg_image_width | See http://en.wikipedia.org/wiki/JPEG for reference |
| jpeg_num_components | Defines type for number of components property |
| jpeg_pixel_density | Pixel density |
| jpeg_quality | Defines type for jpeg quality property |
| jpeg_tag | Defines jpeg tag |
| kth_channel_deref_fn< K, SrcP > | Function object that returns a grayscale reference of the K-th channel (specified as a template parameter) of a given reference. Models: PixelDereferenceAdaptorConcept.If the input is a pixel value or constant reference, the function object is immutable. Otherwise it is mutable (and returns non-const reference to the k-th channel) |
| kth_channel_view_type< K, View > | Given a source image view type View, returns the type of an image view over a given channel of View.If the channels in the source view are adjacent in memory (such as planar non-step view or single-channel view) then the return view is a single-channel non-step view. If the channels are non-adjacent (interleaved and/or step view) then the return view is a single-channel step view |
| kth_semantic_element_const_reference_type< ColorBase, K > | Specifies the return type of the constant semantic_at_c<K>(color_base); |
| kth_semantic_element_const_reference_type< ColorBase, color_index_type< ColorBase, Color >::value > | |
| color_element_const_reference_type< ColorBase, Color > | Specifies the return type of the constant element accessor by color name, get_color(color_base, Color()); |
| kth_semantic_element_reference_type< ColorBase, K > | Specifies the return type of the mutable semantic_at_c<K>(color_base); |
| kth_semantic_element_reference_type< ColorBase, color_index_type< ColorBase, Color >::value > | |
| color_element_reference_type< ColorBase, Color > | Specifies the return type of the mutable element accessor by color name, get_color(color_base, Color()); |
| kth_semantic_element_type< ColorBase, K > | Specifies the type of the K-th semantic element of a color base |
| kth_semantic_element_type< ColorBase, color_index_type< ColorBase, Color >::value > | |
| color_element_type< ColorBase, Color > | Specifies the type of the element associated with a given color tag |
| layout< ColorSpace, ChannelMapping > | Represents a color space and ordering of channels in memory |
| layout< devicen_t< N > > | |
| devicen_layout_t< N > | Unnamed color layout of up to five channels |
| locator_is_basic< Loc > | Determines if a given locator is basic. A basic locator is memory-based and has basic x_iterator and y_iterator |
| locator_type< T, L, IsPlanar, IsStepX, IsMutable > | Returns the type of a homogeneous locator given the channel type, layout, whether it operates on planar data and whether it has a step horizontally |
| magenta_t | Magenta |
| MemoryBasedIteratorConcept< Iterator > | Concept of a random-access iterator that can be advanced in memory units (bytes or bits) |
| memunit_step_fn< Iterator > | Function object that returns the memory unit distance between two iterators and advances a given iterator a given number of mem units (bytes or bits) |
| Metafunction< T > | |
| MutableChannelConcept< T > | A channel that allows for modifying its value |
| MutableColorBaseConcept< ColorBase > | Color base which allows for modifying its elements |
| MutableHomogeneousColorBaseConcept< ColorBase > | Homogeneous color base that allows for modifying its elements |
| MutableHomogeneousPixelConcept< P > | Homogeneous pixel concept that allows for changing its channels |
| MutableImageViewConcept< View > | GIL's 2-dimensional view over mutable GIL pixels |
| MutableIteratorAdaptorConcept< Iterator > | Iterator adaptor that is mutable |
| MutablePixelConcept< P > | Pixel concept that allows for changing its channels |
| MutablePixelIteratorConcept< Iterator > | Pixel iterator that allows for changing its pixel |
| MutablePixelLocatorConcept< Loc > | GIL's 2-dimensional locator over mutable GIL pixels |
| MutableRandomAccess2DImageViewConcept< View > | 2-dimensional view over mutable values |
| MutableRandomAccess2DLocatorConcept< Loc > | 2-dimensional locator over mutable pixels |
| MutableRandomAccessNDImageViewConcept< View > | N-dimensional view over mutable values |
| MutableRandomAccessNDLocatorConcept< Loc > | N-dimensional locator over mutable pixels |
| MutableStepIteratorConcept< Iterator > | Step iterator that allows for modifying its current value |
| nth_channel_deref_fn< SrcP > | Function object that returns a grayscale reference of the N-th channel of a given reference. Models: PixelDereferenceAdaptorConcept.If the input is a pixel value or constant reference, the function object is immutable. Otherwise it is mutable (and returns non-const reference to the n-th channel) |
| nth_channel_view_type< View > | Given a source image view type View, returns the type of an image view over a single channel of ViewIf the channels in the source view are adjacent in memory (such as planar non-step view or single-channel view) then the return view is a single-channel non-step view. If the channels are non-adjacent (interleaved and/or step view) then the return view is a single-channel step view |
| nth_channel_view_type< any_image_view< ViewTypes > > | Given a runtime source image view, returns the type of a runtime image view over a single channel of the source view |
| num_channels< T > | Returns the number of channels of a pixel-based GIL construct |
| packed_channel_reference< BitField, FirstBit, NumBits, false > | A constant subbyte channel reference whose bit offset is fixed at compile time. Models ChannelConcept |
| packed_channel_reference< BitField, FirstBit, NumBits, true > | A mutable subbyte channel reference whose bit offset is fixed at compile time. Models ChannelConcept |
| packed_channel_value< NumBits > | The value of a subbyte channel. Models: ChannelValueConcept |
| packed_dynamic_channel_reference< BitField, NumBits, false > | Models a constant subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept Same as packed_channel_reference, except that the offset is a runtime parameter |
| packed_dynamic_channel_reference< BitField, NumBits, true > | Models a mutable subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept Same as packed_channel_reference, except that the offset is a runtime parameter |
| packed_image_type< BitField, ChannelBitSizeVector, Layout, Alloc > | Returns the type of an interleaved packed image: an image whose channels may not be byte-aligned, but whose pixels are byte aligned |
| packed_image_type< BitField, mpl::vector1_c< unsigned, Size1 >, Layout, Alloc > | |
| packed_image1_type< BitField, Size1, Layout, Alloc > | Returns the type of a single-channel image given its bitfield type, the bit size of its channel and its layout |
| packed_image_type< BitField, mpl::vector2_c< unsigned, Size1, Size2 >, Layout, Alloc > | |
| packed_image2_type< BitField, Size1, Size2, Layout, Alloc > | Returns the type of a two channel image given its bitfield type, the bit size of its channels and its layout |
| packed_image_type< BitField, mpl::vector3_c< unsigned, Size1, Size2, Size3 >, Layout, Alloc > | |
| packed_image3_type< BitField, Size1, Size2, Size3, Layout, Alloc > | Returns the type of a three channel image given its bitfield type, the bit size of its channels and its layout |
| packed_image_type< BitField, mpl::vector4_c< unsigned, Size1, Size2, Size3, Size4 >, Layout, Alloc > | |
| packed_image4_type< BitField, Size1, Size2, Size3, Size4, Layout, Alloc > | Returns the type of a four channel image given its bitfield type, the bit size of its channels and its layout |
| packed_image_type< BitField, mpl::vector5_c< unsigned, Size1, Size2, Size3, Size4, Size5 >, Layout, Alloc > | |
| packed_image5_type< BitField, Size1, Size2, Size3, Size4, Size5, Layout, Alloc > | Returns the type of a five channel image given its bitfield type, the bit size of its channels and its layout |
| packed_pixel< P, C, L > | Heterogeneous pixel value whose channel references can be constructed from the pixel bitfield and their index. Models ColorBaseValueConcept, PixelValueConcept, PixelBasedConcept Typical use for this is a model of a packed pixel (like 565 RGB) |
| packed_pixel_type< BitField, ChannelBitSizeVector, Layout > | Returns the type of a packed pixel given its bitfield type, the bit size of its channels and its layout |
| packed_pixel_type< BitField, mpl::vector1_c< unsigned, NumBits >, Layout > | |
| packed_pixel_type< detail::min_fast_uint< NumBits >::type, mpl::vector1_c< unsigned, NumBits >, Layout > | |
| pixel< T, L > | Represents a pixel value (a container of channels). Models: HomogeneousColorBaseValueConcept, PixelValueConcept, HomogeneousPixelBasedConcept |
| pixel_2d_locator_base< Loc, XIterator, YIterator > | Base class for models of PixelLocatorConceptPixel locator is similar to a pixel iterator, but allows for 2D navigation of pixels within an image view. It has a 2D difference_type and supports random access operations like: |
| pixel_2d_locator_base< memory_based_2d_locator< StepIterator >, iterator_adaptor_get_base< StepIterator >::type, StepIterator > | |
| memory_based_2d_locator< StepIterator > | Memory-based pixel locator. Models: PixelLocatorConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConceptThe class takes a step iterator as a parameter. The step iterator provides navigation along the vertical axis while its base iterator provides horizontal navigation |
| pixel_2d_locator_base< virtual_2d_locator< Deref, IsTransposed >, position_iterator< Deref, IsTransposed >, position_iterator< Deref, 1-IsTransposed > > | |
| virtual_2d_locator< Deref, IsTransposed > | A 2D locator over a virtual image. Upon dereferencing, invokes a given function object passing it its coordinates. Models: PixelLocatorConcept, HasDynamicXStepTypeConcept, HasDynamicYStepTypeConcept, HasTransposedTypeConcept |
| pixel_is_reference< Pixel > | Given a model of a pixel, determines whether the model represents a pixel reference (as opposed to pixel value) |
| pixel_reference_is_basic< PixelRef > | Determines if a given pixel reference is basic Basic references must use gil::pixel& (if interleaved), gil::planar_pixel_reference (if planar). They must use the standard constness rules |
| pixel_reference_is_mutable< R > | Determines if the given pixel reference is mutable (i.e. its channels can be changed) |
| pixel_reference_is_proxy< PixelReference > | Determines whether the given pixel reference is a proxy class or a native C++ reference |
| pixel_reference_type< T, L, IsPlanar, IsMutable > | Returns the type of a homogeneous pixel reference given the channel type, layout, whether it operates on planar data and whether it is mutable |
| pixel_value_type< Channel, Layout > | Returns the type of a homogeneous pixel given the channel type and layout |
| PixelBasedConcept< P > | Concept for all pixel-based GIL constructs, such as pixels, iterators, locators, views and images whose value type is a pixel |
| PixelConcept< P > | Pixel concept - A color base whose elements are channels |
| PixelConvertibleConcept< SrcP, DstP > | Pixel convertible concept |
| PixelDereferenceAdaptorConcept< D > | Represents a unary function object that can be invoked upon dereferencing a pixel iterator |
| PixelIteratorConcept< Iterator > | An STL random access traversal iterator over a model of PixelConcept |
| PixelLocatorConcept< Loc > | GIL's 2-dimensional locator over immutable GIL pixels |
| pixels_are_compatible< P1, P2 > | Returns whether two pixels are compatible |
| pixels_are_compatible< V1::value_type, V2::value_type > | |
| views_are_compatible< V1, V2 > | Returns whether two views are compatible |
| PixelsCompatibleConcept< P1, P2 > | Concept for pixel compatibility Pixels are compatible if their channels and color space types are compatible. Compatible pixels can be assigned and copy constructed from one another |
| PixelValueConcept< P > | Pixel concept that is a Regular type |
| planar_pixel_iterator< ChannelPtr, ColorSpace > | An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept |
| planar_pixel_reference< T, C > | A reference proxy to a planar pixel. Models: HomogeneousColorBaseConcept, HomogeneousPixelConcept |
| plus_asymmetric< T1, T2 > | Plus function object whose arguments may be of different type |
| png_background | Defines type for background property |
| png_bitdepth | Defines type for bit depth method property |
| png_CAL | Defines type pixel calibration for property |
| png_CAL_nparam | Defines type for number of pixel calibration properties |
| png_CAL_params | Defines type for pixel calibration parameters property |
| png_CAL_type | Defines type for pixel calibration type property |
| png_CAL_X | Defines type for pixel calibration x property |
| png_chromacities_type | Defines type for CIE chromacities property |
| png_color_palette | Defines type for color palette property |
| png_color_type | Defines type for bit depth method property |
| png_filter_method | Defines type for filter method property |
| png_gamma | Defines type for gamma correction property |
| png_histrogram | Defines type for histogram property |
| png_ICC_compression_type | Defines type for ICC compression property |
| png_ICC_name | Defines type for ICC profile name property |
| png_ICC_profile | Defines type for ICC profile property |
| png_ICC_profile_length | Defines type for ICC profile length property |
| png_image_height | Defines type for image height property |
| png_image_width | See http://en.wikipedia.org/wiki/Portable_Network_Graphics for reference |
| png_info_base | |
| image_read_info< png_tag > | |
| image_write_info< png_tag > | |
| png_intent | Defines type for rendering intent property |
| png_interlace_method | Defines type for interlace method property |
| png_mod_time | Defines type for modification time property |
| png_num_channels | Defines type for number of channels property |
| png_num_palette | Defines type for number of colors property |
| png_num_text | Defines type for number of text property |
| png_num_trans | Defines type for number of transparency data property |
| png_offset | Defines type for screen offset property |
| png_offset_type | Defines type for screen offset type property |
| png_pixels_per_meter | Returns image resolution in pixels per meter, from pHYs chunk data |
| png_read_settings_base | |
| image_read_settings< png_tag > | |
| png_resolution | Defines type for physical resolution property |
| png_return_value | Defines type for png function return type |
| png_scale | Defines type for physical scale property |
| png_significant_bits | Defines type for significant bits property |
| png_tag | Defines png tag |
| png_text_ | Defines type for text property |
| png_trans | Defines type for transparency data property |
| png_trans_values | Defines type for transparency data values property |
| png_unit | Defines type for physical scale unit property |
| png_unit_type | Defines type for physical resolution unit property |
| pnm_image_height | Defines type for image height property |
| pnm_image_max_value | Defines type for image max value property |
| pnm_image_type | See http://en.wikipedia.org/wiki/Portable_Bitmap_File_Format for reference |
| pnm_image_width | Defines type for image width property |
| pnm_tag | Defines pnm tag |
| point2< T > | 2D point both axes of which have the same dimension typeModels: Point2DConcept |
| point2< std::ptrdiff_t > | |
| Point2DConcept< P > | 2-dimensional point concept |
| PointNDConcept< P > | N-dimensional point concept |
| position_iterator< Deref, Dim > | An iterator that remembers its current X,Y position and invokes a function object with it upon dereferencing. Models PixelIteratorConcept. Used to create virtual image views. Models: StepIteratorConcept, PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept |
| RandomAccess2DImageConcept< Img > | 2-dimensional container of values |
| RandomAccess2DImageViewConcept< View > | 2-dimensional view over immutable values |
| RandomAccess2DLocatorConcept< Loc > | 2-dimensional locator over immutable values |
| RandomAccessNDImageConcept< Img > | N-dimensional container of values |
| RandomAccessNDImageViewConcept< View > | N-dimensional view over immutable values |
| RandomAccessNDLocatorConcept< Loc > | N-dimensional locator over immutable values |
| raw_aperture | Defines type for aperture |
| raw_artist | Defines type for artist |
| raw_bits_per_pixel | Defines type for bits per pixel property |
| raw_camera_manufacturer | Defines type for camera manufacturer |
| raw_camera_model | Defines type for camera model |
| raw_colors_description | Defines type for colors description |
| raw_dng_version | Defines type for dng version |
| raw_flip | Defines type for image orientation |
| raw_focal_length | Defines type for focal length |
| raw_image_description | Defines type for image description |
| raw_image_height | Defines type for image height property |
| raw_image_width | Defines type for image width property |
| raw_iso_speed | Defines type for iso speed |
| raw_left_margin | Defines type for left margin |
| raw_libraw_version | Defines type for libraw version |
| raw_number_colors | Defines type for number of colors |
| raw_output_height | Defines type for output height |
| raw_output_width | Defines type for output width |
| raw_pixel_aspect | Defines type for pixel aspect |
| raw_raw_height | Defines type for raw height |
| raw_raw_images_count | Defines type for raw images count |
| raw_raw_width | Defines type for raw width |
| raw_samples_per_pixel | Defines type for samples per pixel property |
| raw_shot_order | Defines type for shot order |
| raw_shutter | Defines type for shutter |
| raw_tag | Defines tiff tag |
| raw_timestamp | Defines type for timestamp |
| raw_top_margin | Defines type for top margin |
| raw_unpack_function_name | Defines type for unpack function name |
| raw_visible_height | Defines type for visible height |
| raw_visible_width | Defines type for visible width |
| red_t | Red |
| Regular< T > | |
| rgb_to_luminance_fn< RedChannel, GreenChannel, BlueChannel, GrayChannelValue > | Red * .3 + green * .59 + blue * .11 + .5 |
| SameType< T, U > | |
| scoped_channel_value< BaseChannelValue, MinVal, MaxVal > | A channel adaptor that modifies the range of the source channel. Models: ChannelValueConcept |
| size< ColorBase > | Returns an MPL integral type specifying the number of elements in a color base |
| std_fill_t | Struct to do std::fill |
| step_iterator_adaptor< Derived, Iterator, SFn > | An adaptor over an existing iterator that changes the step unit |
| step_iterator_adaptor< memory_based_step_iterator< Iterator >, Iterator, memunit_step_fn< Iterator > > | |
| memory_based_step_iterator< Iterator > | MEMORY-BASED STEP ITERATOR |
| StepIteratorConcept< Iterator > | Step iterator concept |
| Swappable< T > | |
| targa_color_map_depth | Defines type for color map bit depth property |
| targa_color_map_length | Defines type for color map length property |
| targa_color_map_start | Defines type for color map start property |
| targa_color_map_type | Defines type for color map type property |
| targa_depth | Defines type for image bit depth property |
| targa_descriptor | Defines type for image descriptor property |
| targa_dimension | Defines type for image dimension properties |
| targa_header_size | Defines type for header sizes |
| targa_image_type | Defines type for image type property |
| targa_offset | Defines type for offset value |
| targa_origin_element | Defines type for origin x and y value properties |
| targa_tag | Defines targa tag |
| tiff_color_map | Helper structure for reading a color mapper |
| tiff_directory | Defines the page to read in a multipage tiff file |
| tiff_property_base< T, Value > | TIFF property base class |
| tiff_property_base< bool, false > | |
| tiff_is_tiled | Tile related tags |
| tiff_property_base< float, TIFFTAG_XRESOLUTION > | |
| tiff_x_resolution | Defines type for x resolution property |
| tiff_property_base< float, TIFFTAG_YRESOLUTION > | |
| tiff_y_resolution | Defines type for y resolution property |
| tiff_property_base< long, TIFFTAG_TILELENGTH > | |
| tiff_tile_length | Defines type for tile length |
| tiff_property_base< long, TIFFTAG_TILEWIDTH > | |
| tiff_tile_width | Defines type for tile width |
| tiff_property_base< std::string, TIFFTAG_ARTIST > | |
| tiff_artist | Defines type for artist information property |
| tiff_property_base< std::string, TIFFTAG_COPYRIGHT > | |
| tiff_copyright | Defines type for copyright property |
| tiff_property_base< std::string, TIFFTAG_DATETIME > | |
| tiff_date_time | Defines type for date time property |
| tiff_property_base< std::string, TIFFTAG_FILLORDER > | |
| tiff_fill_order | Defines type for fill order property |
| tiff_property_base< std::string, TIFFTAG_HOSTCOMPUTER > | |
| tiff_host_computer | Defines type for host computer property |
| tiff_property_base< std::string, TIFFTAG_IMAGEDESCRIPTION > | |
| tiff_image_description | Defines type for image description |
| tiff_property_base< std::string, TIFFTAG_MAKE > | |
| tiff_make | Defines type for make property |
| tiff_property_base< std::string, TIFFTAG_MODEL > | |
| tiff_model | Defines type for model property |
| tiff_property_base< std::string, TIFFTAG_SOFTWARE > | |
| tiff_software | Defines type for software vendor property |
| tiff_property_base< std::vector< uint16_t >, TIFFTAG_EXTRASAMPLES > | |
| tiff_extra_samples | Defines type for extra samples property |
| tiff_property_base< std::vector< uint8_t >, TIFFTAG_ICCPROFILE > | |
| tiff_icc_profile | Non-baseline tags |
| tiff_property_base< tiff_resolution_unit_value, TIFFTAG_RESOLUTIONUNIT > | |
| tiff_property_base< uint16_t *, TIFFTAG_GRAYRESPONSECURVE > | |
| tiff_gray_response_curve | Defines type for gray response curve property |
| tiff_property_base< uint16_t, TIFFTAG_BITSPERSAMPLE > | |
| tiff_bits_per_sample | Defines type for bits per sample property |
| tiff_property_base< uint16_t, TIFFTAG_CELLLENGTH > | |
| tiff_cell_length | Defines type for cell length property |
| tiff_property_base< uint16_t, TIFFTAG_CELLWIDTH > | |
| tiff_cell_width | Defines type for cell width property |
| tiff_property_base< uint16_t, TIFFTAG_COMPRESSION > | |
| tiff_compression | Defines type for compression property |
| tiff_property_base< uint16_t, TIFFTAG_GRAYRESPONSEUNIT > | |
| tiff_gray_response_unit | Defines type for gray response unit property |
| tiff_property_base< uint16_t, TIFFTAG_MAXSAMPLEVALUE > | |
| tiff_max_sample_value | Defines type for max sample property |
| tiff_property_base< uint16_t, TIFFTAG_MINSAMPLEVALUE > | |
| tiff_min_sample_value | Defines type for min sample property |
| tiff_property_base< uint16_t, TIFFTAG_ORIENTATION > | |
| tiff_orientation | Defines type for image orientation |
| tiff_property_base< uint16_t, TIFFTAG_OSUBFILETYPE > | |
| tiff_subfile_type | Defines type for subfile property |
| tiff_property_base< uint16_t, TIFFTAG_PHOTOMETRIC > | |
| tiff_photometric_interpretation | Defines type for photometric interpretation property |
| tiff_property_base< uint16_t, TIFFTAG_PLANARCONFIG > | |
| tiff_planar_configuration | Defines type for planar configuration property |
| tiff_property_base< uint16_t, TIFFTAG_SAMPLEFORMAT > | |
| tiff_sample_format | Non-baseline tags |
| tiff_property_base< uint16_t, TIFFTAG_SAMPLESPERPIXEL > | |
| tiff_samples_per_pixel | Defines type for samples per pixel property |
| tiff_property_base< uint16_t, TIFFTAG_THRESHHOLDING > | |
| tiff_thresholding | Defines type for threshold property |
| tiff_property_base< uint32_t, TIFFTAG_IMAGELENGTH > | |
| tiff_image_height | Defines type for image height property |
| tiff_property_base< uint32_t, TIFFTAG_IMAGEWIDTH > | |
| tiff_image_width | Defines type for image width property |
| tiff_property_base< uint32_t, TIFFTAG_ROWSPERSTRIP > | |
| tiff_rows_per_strip | Defines type for rows per strip property |
| tiff_property_base< uint32_t, TIFFTAG_SUBFILETYPE > | |
| tiff_new_subfile_type | Baseline tags |
| tiff_tag | Defines tiff tag |
| type_from_x_iterator< XIterator > | Given a pixel iterator defining access to pixels along a row, returns the types of the corresponding built-in step_iterator, xy_locator, image_view |
| type_to_index< Types, T > | Returns the index corresponding to the first occurrance of a given given type in |
| type_to_index< ColorBase::layout_t::color_space_t, Color > | |
| variant< Types > | Represents a concrete instance of a run-time specified type from a set of typesA concept is typically modeled by a collection of different types. They may be instantiations of a templated type with different template parameters or even completely unrelated types |
| variant< ImageTypes > | |
| any_image< ImageTypes > | Represents a run-time specified image. Note it does NOT model ImageConcept |
| variant< ImageViewTypes > | |
| any_image_view< ImageViewTypes > | Represents a run-time specified image view. Models HasDynamicXStepTypeConcept, HasDynamicYStepTypeConcept, Note that this class does NOT model ImageViewConcept |
| view_is_basic< View > | Basic views must be over basic locators |
| view_type< T, L, IsPlanar, IsStepX, IsMutable > | Returns the type of a homogeneous view given the channel type, layout, whether it operates on planar data and whether it has a step horizontally |
| view_type_from_pixel< Pixel, IsPlanar, IsStepX, IsMutable > | Returns the type of a view the pixel type, whether it operates on planar data and whether it has a step horizontally |
| view_type_from_pixel< Pixel, IsPlanar > | |
| ViewsCompatibleConcept< V1, V2 > | Views are compatible if they have the same color spaces and compatible channel values. Constness and layout are not important for compatibility |
| yellow_t | Yellow |
1.8.6
