boost::gil
Types
Name |
Description |
Concept of copy assignment requirement. |
|
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. |
|
A channel is convertible to another one if the |
|
Channel mapping concept |
|
A channel that supports default construction. |
|
Channels are compatible if their associated value types (ignoring constness and references) are the same |
|
GIL view as Collection. |
|
A color base is a container of color elements (such as channels, channel references or channel pointers). |
|
Color base that also has a default‐constructor. Refines Regular |
|
Two color bases are compatible if they have the same color space and their elements are compatible, semantic‐pairwise. |
|
Color space type concept |
|
Two color spaces are compatible if they are the same |
|
Concept of copy construction requirement. |
|
Concept of default construction requirement. |
|
Concept of == and != comparability requirement. |
|
GIL view as ForwardCollection. |
|
Concept for iterators, locators and views that can define a type just like the given iterator, locator or view, except it supports runtime specified step along the X navigation. |
|
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 |
|
Concept for locators and views that can define a type just like the given locator or view, except X and Y is swapped |
|
Color base whose elements all have the same type |
|
Homogeneous color base that also has a default constructor. Refines Regular. |
|
Concept for homogeneous pixel‐based GIL constructs |
|
Homogeneous pixel concept |
|
Homogeneous pixel concept that is a Regular type |
|
2‐dimensional image whose value type models PixelValueConcept |
|
GIL's 2‐dimensional view over immutable GIL pixels |
|
Iterator adaptor is a forward iterator adapting another forward iterator. |
|
Concept of a random‐access iterator that can be advanced in memory units (bytes or bits) |
|
Concept for type as metafunction requirement. |
|
A channel that allows for modifying its value |
|
Color base which allows for modifying its elements |
|
Homogeneous color base that allows for modifying its elements |
|
Homogeneous pixel concept that allows for changing its channels |
|
GIL's 2‐dimensional view over mutable GIL pixels |
|
Iterator adaptor that is mutable |
|
Pixel concept that allows for changing its channels |
|
Pixel iterator that allows for changing its pixel |
|
GIL's 2‐dimensional locator over mutable GIL pixels |
|
2‐dimensional view over mutable values |
|
2‐dimensional locator over mutable pixels |
|
N‐dimensional view over mutable values |
|
N‐dimensional locator over mutable pixels |
|
Step iterator that allows for modifying its current value |
|
Concept for all pixel‐based GIL constructs. |
|
Pixel concept ‐ A color base whose elements are channels |
|
Pixel convertible concept Convertibility is non‐symmetric and implies that one pixel can be converted to another, approximating the color. Conversion is explicit and sometimes lossy. |
|
Represents a unary function object that can be invoked upon dereferencing a pixel iterator. |
|
An STL random access traversal iterator over a model of PixelConcept. |
|
GIL's 2‐dimensional locator over immutable GIL pixels |
|
Pixel concept that is a Regular type |
|
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. |
|
2‐dimensional point concept |
|
N‐dimensional point concept |
|
2‐dimensional container of values |
|
2‐dimensional view over immutable values |
|
2‐dimensional locator over immutable values |
|
N‐dimensional container of values |
|
N‐dimensional view over immutable values |
|
N‐dimensional locator over immutable values |
|
Concept for type regularity requirement. |
|
GIL view as ReversibleCollection. |
|
Concept of types equivalence requirement. |
|
Step iterator concept |
|
Concept of swap operation requirement. |
|
Views are compatible if they have the same color spaces and compatible channel values. |
|
Alpha |
|
Represents a run‐time specified image. Note it does NOT model ImageConcept |
|
Represents a run‐time specified image view. Models HasDynamicXStepTypeConcept, HasDynamicYStepTypeConcept, Note that this class does NOT model ImageViewConcept |
|
A generic binary operation on views |
|
Returns the type of a single‐channel bit‐aligned image given the bit size of its channel and its layout |
|
Returns the type of a two channel bit‐aligned image given the bit size of its channels and its layout |
|
Returns the type of a three channel bit‐aligned image given the bit size of its channels and its layout |
|
Returns the type of a four channel bit‐aligned image given the bit size of its channels and its layout |
|
Returns the type of a five channel bit‐aligned image given the bit size of its channels and its layout |
|
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. |
|
An iterator over non‐byte‐aligned pixels. Models PixelIteratorConcept, PixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept |
|
Heterogeneous pixel reference corresponding to non‐byte‐aligned bit range. Models ColorBaseConcept, PixelConcept, PixelBasedConcept |
|
////////////////////////// |
|
Black |
|
Blue |
|
Rasterize a line according to Bresenham algorithm |
|
////////////////////////// |
|
structure for assigning one channel to another |
|
A unary function object converting between channel types |
|
//////////////////////////////////// channel_converter_unsigned/////////////////////////////////// |
|
Arithmetic operation of dividing channel value by scalar. |
|
Arithmetic operation of division of two channel values. |
|
Arithmetic operation of dividing channel value by 2 |
|
Arithmetic operation of subtracting scalar from channel value. |
|
Arithmetic operation of subtraction of two channel values. |
|
A function object to multiply two channels. result = a * b / max_value |
|
This is the default implementation. Performance specializatons are provided |
|
Arithmetic operation of channel value by a scalar. |
|
Arithmetic operation of multiplication of two channel values. |
|
Arithmetic operation of adding scalar to channel value. |
|
Arithmetic operation of addition of two channel values. |
|
Traits for channels. Contains the following members: |
|
Support for fast and simple color conversion. Accurate color conversion using color profiles can be supplied separately in a dedicated module. |
|
Operation of setting channel value to zero |
|
Predicate metafunction returning whether two channels are compatible |
|
Function object that given a source pixel, returns it converted to a given color space and channel depth. Models: PixelDereferenceAdaptorConcept |
|
Returns the type of a view that does color conversion upon dereferencing its pixels |
|
Specifies the return type of the constant element accessor by color name, get_color(color_base, Color()); |
|
Specifies the return type of the mutable element accessor by color name, get_color(color_base, Color()); |
|
Specifies the type of the element associated with a given color tag |
|
Returns the type of an iterator just like the input iterator, except operating over immutable values |
|
A predicate metafunction determining whether a given color base contains a given color |
|
Cyan |
|
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. |
|
class for color‐converting one pixel to another |
|
Color Conversion function object. To be specialized for every src/dst color space |
|
Helper base class for pixel dereference adaptors. |
|
Composes two dereference function objects. Similar to std::unary_compose but needs to pull some aliases from the component types. Models: PixelDereferenceAdaptorConcept |
|
An adaptor over an existing iterator that provides for custom filter on dereferencing the object. Models: IteratorAdaptorConcept, PixelIteratorConcept |
|
Constructs a homogeneous image type from a source image type by changing some of the properties. |
|
Constructs a pixel iterator type from a source pixel iterator type by changing some of the properties. |
|
Constructs a pixel reference type from a source pixel reference type by changing some of the properties. |
|
Constructs an image view type from a source view type by changing some of the properties. |
|
unnamed color |
|
unnamed color layout of up to five channels |
|
Unnamed color space of 1, 2, 3, 4, or 5 channels |
|
Base template for types that model HasDynamicXStepTypeConcept. |
|
Returns the type of a transposed view that has a dynamic step along both X and Y |
|
Returns the type of a view that has a dynamic step along both X and Y |
|
Base template for types that model HasDynamicYStepTypeConcept. |
|
Specifies the return type of the constant element accessor at_c of a homogeneous color base |
|
Specifies the return type of the mutable element accessor at_c of a homogeneous color base |
|
Specifies the element type of a homogeneous color base |
|
Generates the channel type for |
|
Helper metafunction to generate dynamic image reader type. |
|
Helper metafunction to generate dynamic image writer type. |
|
Determines the numbers of bits for the given channel type. |
|
Depending on Image this function generates either the pixel type or the reference type in case the image is bit_aligned. |
|
Helper metafunction to generate image reader type. |
|
Helper metafunction to generate image backend type. |
|
Helper metafunction to generate image scanline_reader type. |
|
Helper metafunction to generate writer type. |
|
Gray |
|
Green |
|
Default histogram class provided by boost::gil. |
|
A type to encapsulate Hough transform parameter range |
|
container interface over image view. Models ImageConcept, PixelBasedConcept |
|
Basic images must use basic views and std::allocator |
|
Returns the type of a homogeneous image given the channel type, layout, and whether it operates on planar data |
|
A lightweight object that interprets memory as a 2D array of pixels. Models ImageViewConcept,PixelBasedConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConcept |
|
Determines whether the given type is bit_aligned. |
|
Determines if a pixel types are homogeneous. |
|
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. |
|
Boolean meta function, std::true_type if the pixel type PixelType is supported by the image format identified with FormatTag. |
|
Determines if two pixel types are similar. |
|
returns the base iterator for a given iterator adaptor. Provide an specialization when introducing new iterator adaptors |
|
Changes the base iterator of an iterator adaptor. Provide an specialization when introducing new iterator adaptors |
|
Returns the type (and creates an instance) of an iterator that invokes the given dereference adaptor upon dereferencing |
|
Provides 1D random‐access navigation to the pixels of the image. Models: PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept |
|
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. |
|
Metafunction predicate returning whether the given iterator allows for changing its values |
|
Determines if the given iterator/locator/view has a step that could be set dynamically |
|
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 |
|
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 |
|
variable‐size kernel |
|
static‐size kernel |
|
Given a source image view type View, returns the type of an image view over a given channel of View. |
|
Specifies the return type of the constant semantic_at_c<K>(color_base); |
|
Specifies the return type of the mutable semantic_at_c<K>(color_base); |
|
Specifies the type of the K‐th semantic element of a color base |
|
Represents a color space and ordering of channels in memory |
|
Determines if a given locator is basic. A basic locator is memory‐based and has basic x_iterator and y_iterator |
|
Determines if the given locator is mutable (i.e. its pixels can be changed) |
|
Determines if the given locator has a horizontal step that could be set dynamically |
|
Determines if the given locator has a vertical step that could be set dynamically |
|
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 |
|
///////////////////////////////////////////////////////////////////////////////////// |
|
Memory‐based pixel locator. Models: PixelLocatorConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConcept |
|
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) |
|
Perform circle rasterization according to Midpoint algorithm |
|
Performs ellipse rasterization using midpoint algorithm. Initially, program considers origin as center of ellipse and obtains first quadrant trajectory points. After that, it shifts origin to provided co‐ordinates of center and then draws the curve. |
|
Given a source image view type View, returns the type of an image view over a single channel of View |
|
Returns the number of channels of a pixel‐based GIL construct |
|
The value of a subbyte channel. Models: ChannelValueConcept |
|
Returns the type of a single‐channel image given its bitfield type, the bit size of its channel and its layout |
|
Returns the type of a two channel image given its bitfield type, the bit size of its channels and its layout |
|
Returns the type of a three channel image given its bitfield type, the bit size of its channels and its layout |
|
Returns the type of a four channel image given its bitfield type, the bit size of its channels and its layout |
|
Returns the type of a five channel image given its bitfield type, the bit size of its channels and its layout |
|
Returns the type of an interleaved packed image: an image whose channels may not be byte‐aligned, but whose pixels are byte aligned. |
|
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) |
|
Returns the type of a packed pixel given its bitfield type, the bit size of its channels and its layout. |
|
Represents a pixel value (a container of channels). Models: HomogeneousColorBaseValueConcept, PixelValueConcept, HomogeneousPixelBasedConcept |
|
base class for models of PixelLocatorConcept |
|
Casts and assigns a pixel to another |
|
Accumulates the all channel size. |
|
Performs channel‐wise division of pixel elements by scalar. |
|
Performs channel‐wise division of two pixels. |
|
Performs channel‐wise division by 2 |
|
Given a model of a pixel, determines whether the model represents a pixel reference (as opposed to pixel value) |
|
Performs channel‐wise subtraction of two pixels. |
|
Performs channel‐wise multiplication of pixel elements by scalar. |
|
Performs channel‐wise multiplication of two pixels. |
|
Performs channel‐wise addition of two pixels. |
|
Reference proxy associated with a type that has a |
|
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. |
|
Determines if the given pixel reference is mutable (i.e. its channels can be changed) |
|
Determines whether the given pixel reference is a proxy class or a native C++ reference |
|
Returns the type of a homogeneous pixel reference given the channel type, layout, whether it operates on planar data and whether it is mutable |
|
Returns the type of a homogeneous pixel given the channel type and layout |
|
Sets pixel elements to zero (for whatever zero means) |
|
Returns whether two pixels are compatible Pixels are compatible if their channels and color space types are compatible. Compatible pixels can be assigned and copy constructed from one another. |
|
An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept |
|
A reference proxy to a planar pixel. |
|
2D point both axes of which have the same dimension type |
|
An iterator that remembers its current X,Y position and invokes a function object with it upon dereferencing. Used to create virtual image views. Models: StepIteratorConcept, PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept |
|
Meta‐function to define an integral type with size than is (roughly) twice the bit size of T |
|
Reader Base Class |
|
Red |
|
Input iterator to read images. |
|
A channel adaptor that modifies the range of the source channel. Models: ChannelValueConcept |
|
Returns an integral constant type specifying the number of elements in a color base |
|
Base template for types that model HasTransposedTypeConcept. The type of a locator or a view that has X and Y swapped. By default it is the same. |
|
Rasterize trigonometric circle according to radius by sine and radius by cosine |
|
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 |
|
Basic views must be over basic locators |
|
Determines if the given view is mutable (i.e. its pixels can be changed) |
|
Determines if the given view has a horizontal step that could be set dynamically |
|
Determines if the given view has a vertical step that could be set dynamically |
|
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 |
|
Returns the type of a view the pixel type, whether it operates on planar data and whether it has a step horizontally |
|
Returns whether two views are compatible |
|
A 2D locator over a virtual image Upon dereferencing, invokes a given function object passing it its coordinates. Models: PixelLocatorConcept, HasDynamicXStepTypeConcept, HasDynamicYStepTypeConcept, HasTransposedTypeConcept |
|
Yellow |
Type Aliases
Name |
Description |
32‐bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept |
|
64‐bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept |
|
|
|
|
|
Alias template for backward compatibility with Boost <=1.68. |
|
Common type to represent 2D dimensions or in‐memory size of image or view. |
|
Enums
Name |
Description |
Boundary options for image boundary extension |
|
Direction of image segmentation. The direction specifies which pixels are considered as corresponding to object and which pixels correspond to background. |
|
Method of optimal threshold value calculation. |
|
TODO |
Functions
Name |
Description |
///////////////////////////////////////////////////////////////////////////// computing size with alignment///////////////////////////////////////////////////////////////////////////// |
|
Performs diffusion according to Perona‐Malik equation |
|
|
|
|
Applies the visitor op to the variants |
|
|
Run‐time detection of whether the underlying architecture is big endian |
|
Calculates the difference between closing of the input image and input image. |
|
rotates an image from its center point using consecutive affine transformations. |
|
Converting from one channel type to another. |
|
Default implementation. Provide overloads for performance |
|
A function multiplying two channels. result = a * b / max_value |
|
Performs dilation and then erosion on the input image view which is exactly opposite to the opening operation . Closing operation can be utilized for closing small holes inside foreground objects. |
|
helper function for converting one pixel to another using GIL default color‐converters where ScrP models HomogeneousPixelConcept DstP models HomogeneousPixelValueConcept |
|
|
|
function to record Harris responses |
|
Compute xy gradient, and second order x and y gradients |
|
Computes Hessian response |
|
|
|
Convolves 1D variable‐size kernel along the columns of image. |
|
Convolve 1D fixed‐size kernel along the columns of image |
|
Convolves 1D variable‐size kernel along the rows of image. |
|
Convolve 1D fixed‐size kernel along the rows of image |
|
std::copy for image views |
|
Correlates 1D variable‐size kernel along the columns of image. |
|
Correlate 1D fixed‐size kernel along the columns of image |
|
1D un‐guarded cross‐correlation with a fixed‐size kernel |
|
1D un‐guarded cross‐correlation with a variable‐size kernel |
|
Correlate 1D variable‐size kernel along the rows of image. |
|
Correlate 1D fixed‐size kernel along the rows of image. |
|
|
|
Invokes the in‐place default constructor on every pixel of the (uninitialized) view. Does not support planar heterogeneous views. If an exception is thrown destructs any in‐place default‐constructed pixels |
|
Invokes the in‐place destructor on every pixel of the view |
|
Applies morphological dilation on the input image view using given structuring element. It gives the maximum overlapped value to the pixel overlapping with the center element of structuring element. |
|
std::equal for image views |
|
std::equal for image views |
|
Applies morphological erosion on the input image view using given structuring element. It gives the minimum overlapped value to the pixel overlapping with the center element of structuring element. |
|
adds new row and column at all sides. Image padding introduces new pixels around the edges of an image. The border provides space for annotations or acts as a boundary when using advanced filtering techniques. |
|
adds new column at left and right. Image padding introduces new pixels around the edges of an image. The border provides space for annotations or acts as a boundary when using advanced filtering techniques. |
|
adds new row at top and bottom. Image padding introduces new pixels around the edges of an image. The border provides space for annotations or acts as a boundary when using advanced filtering techniques. |
|
|
|
|
|
std::for_each for a pair of iterators |
|
std::for_each for any image views |
|
Generate Scharr operator in horizontal direction |
|
Generates Sobel operator in horizontal direction |
|
Generate Scharr operator in vertical direction |
|
Generates Sobel operator in vertical direction |
|
Generate Gaussian kernel |
|
Generate mean kernel |
|
std::generate for image views |
|
Generate kernel with all 1s |
|
|
|
|
|
|
|
Vote for best fit of a circle in parameter space according to rasterizer |
|
Vote for best fit of a line in parameter space |
|
static version of std::inner_product |
|
Constructing image views from raw interleaved pixel data |
|
Returns C pointer to the the channels of an interleaved homogeneous view. |
|
Returns the inverse of the given affine transformation matrix |
|
///////////////////////////////////////////////////////////////////////////// Rounding of real numbers / points to integers / integer points///////////////////////////////////////////////////////////////////////////// |
|
Lanczos response at point x |
|
a single step of lanczos downscaling |
|
Run‐time detection of whether the underlying architecture is little endian |
|
Constructs a step iterator from a base iterator and a step. |
|
Create a Hough transform parameter with optimal angle step |
|
|
|
Calculate minimum angle which would be observable if walked on a circle |
|
Calculates the difference between image views generated after applying dilation dilation and erosion on an image . The resultant image will look like the outline of the object(s) present in the image. |
|
Performs local histogram equalization on tiles of size (tile_width_x, tile_width_y) Then uses the clip limit to redistribute excess pixels above the limit uniformly to other bins. The clip limit is specified as a fraction i.e. a bin's value is clipped if bin_value >= clip_limit * (Total number of pixels in the tile) |
|
Normalized cardinal sine |
|
Performs erosion and then dilation on the input image view . This operation is utilized for removing noise from images. |
|
Multiplication operators |
|
Addition operator |
|
Unary minus operators |
|
Division operator |
|
from raw CMYK planar data |
|
|
|
from raw RGB planar data |
|
from raw RGBA planar data |
|
Returns C pointer to the the channels of a given color plane of a planar homogeneous view. |
|
|
|
Reads and color‐converts an image view. No memory is allocated. |
|
Reads an image without conversion. Image memory is allocated. |
|
Returns the image format backend. Backend is format specific. |
|
Reads an image view without conversion. No memory is allocated. |
|
reverse a kernel |
|
Complete Lanczos algorithm |
|
|
|
Equivalent to std::copy. Pairs the elements semantically |
|
Equivalent to std::equal. Pairs the elements semantically |
|
Equivalent to std::fill. |
|
Equivalent to std::for_each. Pairs the elements semantically |
|
Equivalent to std::generate. |
|
Equivalents to std::min_element and std::max_element for homogeneous color bases |
|
Equivalent to std::transform. Pairs the elements semantically |
|
A version of swap that also works with reference proxy objects Where value_type<T1> == value_type<T2> == Value |
|
|
|
Applies truncating threshold to each pixel of image view. Takes an image view and performs truncating threshold operation on each channel. If mode is threshold and direction is regular: values greater than threshold_value will be set to threshold_value else no change If mode is threshold and direction is inverse: values less than or equal to threshold_value will be set to threshold_value else no change If mode is zero and direction is regular: values less than or equal to threshold_value will be set to 0 else no change If mode is zero and direction is inverse: values more than threshold_value will be set to 0 else no change |
|
Calculates the difference between input image view and the view generated by opening operation on the input image view. |
|
|
|
|
|
std::uninitialized_copy for image views. Does not support planar heterogeneous views. If an exception is thrown destructs any in‐place copy‐constructed objects |
|
std::uninitialized_fill for image views. Does not support planar heterogeneous views. If an exception is thrown destructs any in‐place copy‐constructed pixels |
|
|
|
destination is set to be product of the source and a scalar |
|
/////////////////////////////////// dynamic_image |
|
Sets pixel elements to zero (for whatever zero means) |
|
Equality operators |
|
Inequality operators |
Using Declarations
Name |
Description |
16‐bit signed integral channel type (alias from int16_t). Models ChannelValueConcept |
|
32‐bit signed integral channel type (alias from int32_t). Models ChannelValueConcept |
|
8‐bit signed integral channel type (alias from int8_t). Models ChannelValueConcept |
|
16‐bit unsigned integral channel type (alias from uint16_t). Models ChannelValueConcept |
|
32‐bit unsigned integral channel type (alias from uint32_t). Models ChannelValueConcept |
|
8‐bit unsigned integral channel type (alias from uint8_t). Models ChannelValueConcept |
Created with MrDocs