Generic Image Library: ColorBaseConcept< ColorBase > Struct Template Reference

###  | #  |

Public Member Functions | Public Attributes | List of all members
ColorBaseConcept< ColorBase > Struct Template Reference
ColorBase » Concepts

A color base is a container of color elements (such as channels, channel references or channel pointers). More...

`#include <color_base.hpp>`

## Public Member Functions
void | constraints ()

## Public Attributes
ColorBase | cb

## Detailed Description

template<typename ColorBase>
struct boost::gil::ColorBaseConcept< ColorBase >

A color base is a container of color elements (such as channels, channel references or channel pointers).

The most common use of color base is in the implementation of a pixel, in which case the color elements are channel values. The color base concept, however, can be used in other scenarios. For example, a planar pixel has channels that are not contiguous in memory. Its reference is a proxy class that uses a color base whose elements are channel references. Its iterator uses a color base whose elements are channel iterators.

A color base must have an associated layout (which consists of a color space, as well as an ordering of the channels). There are two ways to index the elements of a color base: A physical index corresponds to the way they are ordered in memory, and a semantic index corresponds to the way the elements are ordered in their color space. For example, in the RGB color space the elements are ordered as {red_t, green_t, blue_t}. For a color base with a BGR layout, the first element in physical ordering is the blue element, whereas the first semantic element is the red one. Models of `ColorBaseConcept` are required to provide the `at_c<K>(ColorBase)` function, which allows for accessing the elements based on their physical order. GIL provides a `semantic_at_c<K>(ColorBase)` function (described later) which can operate on any model of ColorBaseConcept and returns the corresponding semantic element.

concept ColorBaseConcept<typename T> : CopyConstructible<T>, EqualityComparable<T>
{
// a GIL layout (the color space and element permutation)
typename layout_t;
// The type of K-th element
template <int K>
struct kth_element_type;
where Metafunction<kth_element_type>;
// The result of at_c
template <int K>
struct kth_element_const_reference_type;
where Metafunction<kth_element_const_reference_type>;
template <int K>
kth_element_const_reference_type<T,K>::type at_c(T);
// Copy-constructible and equality comparable with other compatible color bases
template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
T::T(T2);
template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
bool operator==(const T&, const T2&);
template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
bool operator!=(const T&, const T2&);
};
boost::gil::ColorBaseConcept
A color base is a container of color elements (such as channels, channel references or channel pointe...
Definition concepts/color_base.hpp:138
boost::gil::ColorBasesCompatibleConcept
Two color bases are compatible if they have the same color space and their elements are compatible,...
Definition concepts/color_base.hpp:304
boost::gil::CopyConstructible
Concept of copy construction requirement.
Definition basic.hpp:63
boost::gil::EqualityComparable
Concept of == and != comparability requirement.
Definition basic.hpp:101
boost::gil::Metafunction
Concept for type as metafunction requirement.
Definition basic.hpp:164

The documentation for this struct was generated from the following file:

- concepts/color_base.hpp