[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]

| BasicImage Class Template Reference |
--- | --- | ---

Fundamental class template for images. More...

`#include "vigra/basicimage.hxx"`

## Public Types
typedef PIXELTYPE | value_type
typedef PIXELTYPE | PixelType
typedef PIXELTYPE & | reference
typedef PIXELTYPE const & | const_reference
typedef PIXELTYPE * | pointer
typedef PIXELTYPE const * | const_pointer
typedef PIXELTYPE * | iterator
typedef PIXELTYPE * | ScanOrderIterator
typedef PIXELTYPE const * | const_iterator
typedef PIXELTYPE const * | ConstScanOrderIterator
typedef BasicImageIterator< PIXELTYPE, PIXELTYPE ** > | traverser
typedef BasicImageIterator< PIXELTYPE, PIXELTYPE ** > | Iterator
typedef ConstBasicImageIterator< PIXELTYPE, PIXELTYPE ** > | const_traverser
typedef ConstBasicImageIterator< PIXELTYPE, PIXELTYPE ** > | ConstIterator
typedef Diff2D | difference_type
typedef Size2D | size_type
typedef IteratorTraits< traverser >::DefaultAccessor | Accessor
typedef IteratorTraits< const_traverser >::DefaultAccessor | ConstAccessor
typedef Alloc | allocator_type
## Public Methods
| BasicImage ()
| BasicImage (Alloc const &alloc)
| BasicImage (int width, int height, Alloc const &alloc=Alloc())
| BasicImage (difference_type const &size, Alloc const &alloc=Alloc())
| BasicImage (int width, int height, value_type const &d, Alloc const &alloc=Alloc())
| BasicImage (difference_type const &size, value_type const &d, Alloc const &alloc=Alloc())
| BasicImage (int width, int height, const_pointer d, Alloc const &alloc=Alloc())
| BasicImage (difference_type const &size, const_pointer d, Alloc const &alloc=Alloc())
| BasicImage (const BasicImage &rhs)
| ~BasicImage ()
BasicImage & | operator= (const BasicImage &rhs)
BasicImage & | operator= (value_type pixel)
BasicImage & | init (value_type const &pixel)
void | resize (int width, int height)
void | resize (difference_type const &size)
void | resize (int width, int height, value_type const &d)
void | resizeCopy (int width, int height, const_pointer data)
void | resizeCopy (const BasicImage &rhs)
void | swap (BasicImage &rhs)
int | width () const
int | height () const
size_type | size () const
bool | isInside (difference_type const &d) const
reference | operator[] (difference_type const &d)
const_reference | operator[] (difference_type const &d) const
reference | operator() (int dx, int dy)
const_reference | operator() (int dx, int dy) const
pointer | operator[] (int dy)
const_pointer | operator[] (int dy) const
traverser | upperLeft ()
traverser | lowerRight ()
const_traverser | upperLeft () const
const_traverser | lowerRight () const
iterator | begin ()
iterator | end ()
const_iterator | begin () const
const_iterator | end () const
Accessor | accessor ()
ConstAccessor | accessor () const

## Detailed Description

### template<class PIXELTYPE, class Alloc = std::allocator<PIXELTYPE>>
class vigra::BasicImage< PIXELTYPE, Alloc >

Fundamental class template for images.

A customized memory allocator can be specified as a templated argument ans passed in the constructor.

#include "vigra/basicimage.hxx"

Namespace: vigra

Examples:

  pyramid.cxx, and watershed.cxx.

## Member Typedef Documentation

typedef IteratorTraits<traverser>::DefaultAccessor Accessor

| the BasicImage's default accessor

typedef Alloc allocator_type

| the BasicImage's allocator (default: std::allocator<value_type>)

typedef PIXELTYPE const* const_iterator

| the BasicImage's 1D random access const iterator (note: lower case 'const_iterator' is a STL compatible 1D random access const iterator)

typedef PIXELTYPE const* const_pointer

| the BasicImage's const pointer type

typedef PIXELTYPE const& const_reference

| the BasicImage's const reference type (i.e. the return type of `image[diff]` and `image(dx,dy)` when `image` is const)

typedef ConstBasicImageIterator<PIXELTYPE, PIXELTYPE **> const_traverser

| the BasicImage's 2D random access const iterator ('const traverser')

typedef IteratorTraits<const_traverser>::DefaultAccessor ConstAccessor

| the BasicImage's default const accessor

typedef ConstBasicImageIterator<PIXELTYPE, PIXELTYPE **> ConstIterator

| deprecated, use `const_traverser` instead

typedef PIXELTYPE const* ConstScanOrderIterator

| deprecated, use `const_iterator` instead

typedef Diff2D difference_type

| the BasicImage's difference type (argument type of image[diff])

typedef BasicImageIterator<PIXELTYPE, PIXELTYPE **> Iterator

| deprecated, use `traverser` instead

typedef PIXELTYPE* iterator

| the BasicImage's 1D random access iterator (note: lower case 'iterator' is a STL compatible 1D random access iterator, don't confuse with capitalized Iterator)

typedef PIXELTYPE PixelType

| the BasicImage's pixel type

typedef PIXELTYPE* pointer

| the BasicImage's pointer type

typedef PIXELTYPE& reference

| the BasicImage's reference type (i.e. the return type of `image[diff]` and `image(dx,dy)`)

typedef PIXELTYPE* ScanOrderIterator

| deprecated, use `iterator` instead

typedef Size2D size_type

| the BasicImage's size type (result type of image.size())

typedef BasicImageIterator<PIXELTYPE, PIXELTYPE **> traverser

| the BasicImage's 2D random access iterator ('traverser')

typedef PIXELTYPE value_type

| the BasicImage's pixel type

## Constructor & Destructor Documentation

BasicImage | ( |  | ) | `[inline]`

| construct image of size 0x0

BasicImage | ( | Alloc const & | alloc | ) | `[inline, explicit]`

| construct image of size 0x0, use the specified allocator.

BasicImage | ( | int | width,
|  | int | height,
|  | Alloc const & | alloc = Alloc()
| ) | `[inline]`

| construct image of size width x height, use the specified allocator.

BasicImage | ( | difference_type const & | size,
|  | Alloc const & | alloc = Alloc()
| ) | `[inline, explicit]`

| construct image of size size.x x size.y, use the specified allocator.

BasicImage | ( | int | width,
|  | int | height,
|  | value_type const & | d,
|  | Alloc const & | alloc = Alloc()
| ) | `[inline]`

| construct image of size width*height and initialize every pixel with the value d (use this constructor, if value_type doesn't have a default constructor). Use the specified allocator.

BasicImage | ( | difference_type const & | size,
|  | value_type const & | d,
|  | Alloc const & | alloc = Alloc()
| ) | `[inline, explicit]`

| construct image of size size.x x size.y and initialize every pixel with given data (use this constructor, if value_type doesn't have a default constructor). Use the specified allocator.

BasicImage | ( | int | width,
|  | int | height,
|  | const_pointer | d,
|  | Alloc const & | alloc = Alloc()
| ) | `[inline]`

| construct image of size width*height and copy the data from the given C-style array d. Use the specified allocator.

BasicImage | ( | difference_type const & | size,
|  | const_pointer | d,
|  | Alloc const & | alloc = Alloc()
| ) | `[inline, explicit]`

| construct image of size size.x x size.y and copy the data from the given C-style array. Use the specified allocator.

BasicImage | ( | const BasicImage< PIXELTYPE, Alloc > & | rhs | ) | `[inline]`

| copy rhs image

~BasicImage | ( |  | ) | `[inline]`

| destructor

## Member Function Documentation

ConstAccessor accessor | ( |  | ) | const`[inline]`

| return default const accessor

Accessor accessor | ( |  | ) | `[inline]`

| return default accessor

const_iterator begin | ( |  | ) | const`[inline]`

| init 1D random access const iterator pointing to first pixel

iterator begin | ( |  | ) | `[inline]`

| init 1D random access iterator pointing to first pixel

const_iterator end | ( |  | ) | const`[inline]`

| init 1D random access const iterator pointing past the end

iterator end | ( |  | ) | `[inline]`

| init 1D random access iterator pointing past the end

int height | ( |  | ) | const`[inline]`

| height of Image

BasicImage< PIXELTYPE, Alloc > & init | ( | value_type const & | pixel | ) |

| set Image with const value

bool isInside | ( | difference_type const & | d | ) | const`[inline]`

| test whether a given coordinate is inside the image

const_traverser lowerRight | ( |  | ) | const`[inline]`

| init 2D random access const iterator poining to pixel(width, height), i.e. one pixel right and below lower right corner of the image as is common in C/C++.

traverser lowerRight | ( |  | ) | `[inline]`

| init 2D random access iterator poining to pixel(width, height), i.e. one pixel right and below lower right corner of the image as is common in C/C++.

const_reference operator() | ( | int | dx,
|  | int | dy
| ) | const`[inline]`

| read pixel at given location. usage: `value_type value = image(1,2)`

reference operator() | ( | int | dx,
|  | int | dy
| ) | `[inline]`

| access pixel at given location. usage: `value_type value = image(1,2)`

BasicImage< PIXELTYPE, Alloc > & operator= | ( | value_type | pixel | ) |

| Deprecated: set Image with const value

BasicImage< PIXELTYPE, Alloc > & operator= | ( | const BasicImage< PIXELTYPE, Alloc > & | rhs | ) |

| copy rhs image (image is resized if necessary)

const_pointer operator[] | ( | int | dy | ) | const`[inline]`

| read pixel at given location. Note that the 'x' index is the trailing index. usage: `value_type value = image[2][1]`

pointer operator[] | ( | int | dy | ) | `[inline]`

| access pixel at given location. Note that the 'x' index is the trailing index. usage: `value_type value = image[2][1]`

const_reference operator[] | ( | difference_type const & | d | ) | const`[inline]`

| read pixel at given location. usage: `value_type value = image[Diff2D(1,2)]`

reference operator[] | ( | difference_type const & | d | ) | `[inline]`

| access pixel at given location. usage: `value_type value = image[Diff2D(1,2)]`

void resize | ( | int | width,
|  | int | height,
|  | value_type const & | d
| ) |

| reset image to specified size and initialize it with given data (use this if value_type doesn't have a default constructor, dimensions must not be negative, old data are kept if new size matches old size)

void resize | ( | difference_type const & | size | ) | `[inline]`

| reset image to specified size (dimensions must not be negative) (old data are kept if new size matches old size)

void resize | ( | int | width,
|  | int | height
| ) | `[inline]`

| reset image to specified size (dimensions must not be negative) (old data are kept if new size matches old size)

void resizeCopy | ( | const BasicImage< PIXELTYPE, Alloc > & | rhs | ) | `[inline]`

| resize image to size of other image and copy it's data

void resizeCopy | ( | int | width,
|  | int | height,
|  | const_pointer | data
| ) |

| resize image to given size and initialize by copying data from the C-style arra data.

size_type size | ( |  | ) | const`[inline]`

| size of Image

void swap | ( | BasicImage< PIXELTYPE, Alloc > & | rhs | ) |

| swap the internal data with the rhs image in constant time

const_traverser upperLeft | ( |  | ) | const`[inline]`

| init 2D random access const iterator poining to upper left pixel

traverser upperLeft | ( |  | ) | `[inline]`

| init 2D random access iterator poining to upper left pixel

int width | ( |  | ) | const`[inline]`

| width of Image

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

- vigra/basicimage.hxx

© Ullrich Köthe (koethe@informatik.uni-hamburg.de) Cognitive Systems Group, University of Hamburg, Germany | html generated using doxygen and Python VIGRA 1.3.2 (27 Jan 2005)