vigra - VIGRA Reference Manual

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

VIGRA Reference Manual |

- Installation
  how to get started
- Tutorial
  first steps with VIGRA
- Data Structures
  multi-dimensional arrays, graphs, numeric types etc.
  - vigra::TinyVector
    fixed-size arrays
  - vigra::MultiArrayView
    multi-dimensional array interface
  - vigra::MultiArray
    multi-dimensional array class that holds the actual memory
  - vigra::NumpyArray and vigra::NumpyAnyArray
    wrappers offering VIGRA's multi-array API for Python arrays
  - vigra::linalg::Matrix
    array specialization for linear algebra
  - Image Containers
    classes to manage multiple images and pyramids
  - vigra::SplineImageView
    on-the-fly interpolation of 2D images and their derivatives
  - Chunked arrays
    big data (potentially larger than RAM) stored as a collection of rectangular blocks
  - vigra::AdjacencyListGraph
    general graph class
  - vigra::GridGraph
    direct and indirect neighbor graphs on arbitrary dimensional grids
  - vigra::BinaryForest
    a collection of binary trees
  - Pixel and Number Types
    rationals, complex numbers, RGB tuples etc.
    - Fixed Size Integer Types
    - vigra::RGBValue
    - Numeric and Promote Traits of RGBValue
    - vigra::TinyVector
    - vigra::TinyVectorView
    - Numeric and Promote Traits of TinyVector
    - vigra::FFTWComplex
    - Numeric and Promote Traits of FFTWComplex
    - vigra::Rational
    - vigra::FixedPoint
    - vigra::FixedPoint16
  - vigra::BucketQueue and vigra::MappedBucketQueue
    efficient priority queues for integer priorities
  - vigra::Any
    typesafe storage of arbitrary values
  - vigra::ArrayVector
    replacement for std::vector with stronger guarantees (deprecated as of C++ 11)
  - vigra::BasicImage
    deprecated type for 2D images
  - vigra::BasicImageView
    deprecated type for 2D images that use external memory
- Image and Array I/O
  read and write data from/to disk
  - Image Import/Export Facilities
    highlevel import/export interface for 2D images
  - Import/export of volume data.
    import/export interface for volume data
  - Import/Export of Images and Arrays in HDF5 Format
    import/export of arbitrary-dimensional arrays in the HDF5 format
  - vigra::ChunkedArrayHDF5
    automated memory management of huge datasets via HDF5
  - Import/export of the TIFF format
    image import/export interface to call libtiff functions directly
- Parallel Processing
  using std::thread
- Image Processing
  array arithmetic, convolution filters, morphology, color conversion, registration etc.
  - vigra::multi_math
    arithmetic and algebraic expressions for multi-dimensional arrays
  - Point operators for multi-dimensional arrays.
    point operators on multi-dimensional arrays
  - Color Space Conversions
    convert between RGB and other color spaces like L*u*v* and Y'PbPr
  - Filters
    Gaussian filters, smoothing and sharpening, gradients etc.
    - Convolution Filters
      arbitrary-dimensional filters in the spatial and Fourier domains
    - Recursive convolution functions
      recursive filters (1st and 2nd order)
    - Resampling Convolution Filters
      filters changing the array size
    - Gabor Filter
      Gabor filter creation and related functionality
    - Tensor Image Processing
      tensor-valued pixel features
    - vigra::Kernel1D and vigra::Kernel2D
      generic discrete convolution kernels
    - One-dimensional and separable convolution functions
      1D convolution and separable filters in 2 dimensions
    - BorderTreatmentMode
  - Geometric Transformations and Resizing
    arbitrary-dimensional resize and interpolation, mirroring, rotation, affine warping
  - vigra::SplineImageView
    on-the-fly interpolation of 2D images and their derivatives
  - Fast Fourier Transform
    fast Fourier transform for arrays of arbitrary dimension
  - Image Correlation
    estimate the correlation between images
  - Image Registration
    transform images into a common coordinate system
  - Non-linear Diffusion and Total Variation
    edge-preserving smoothing and denoising
  - Distance Transform
    distance transforms in arbitrary dimensions
  - Morphological operators for multi-dimensional arrays.
    separable morphology with parabola structuring functions in arbitrary dimensions
  - Basic Morphological Operations
    2D erosion, dilation, and median with disc structuring functions
  - Noise Normalization
    transform intensity-dependent noise into additive Gaussian noise
  - Camera MTF Estimation
    determine the magnitude transfer function (MTF) of a camera using the slanted edge method
- Image Analysis
  from pixels to structured data
  - Feature Accumulators
    computate multi-dimensional statistics for regions or hte entire image
  - Algorithms to Inspect Images and Functors To Inspect Images
    outdated statistical analysis functions
  - vigra::Threshold
    good old thresholding
  - Connected Components Labeling
    connected components labeling
  - Local Minima and Maxima
    Including extremal plateaus larger than 1 pixel
  - Distance Transform
    including vector distance, eccentricity transforms, and skeletons
  - Edge Detection
    edge detectors based on first and second derivatives
  - Corner Detection
    measure the 'cornerness' at each pixel
  - Symmetry Detection
    measure the local symmetry at each pixel
  - Superpixel Creation
    watersheds, SLIC superpixels, and seeded region growing
  - Graph Data Structures and Algorithms
    graph-based segmentation algorithms
- Graph Data Structures and Algorithms
  graph classes and graph-based algorithms
- Machine Learning
  classification algorithms
- Mathematical Tools
  number types, special functions, linear algebra and optimization etc.
  - Numeric and Promotion Traits
    meta-information about arithmetic types
  - Mathematical Constants
    M_PI, M_SQRT2
  - Mathematical Functions
    and functors
  - Number Types
    - vigra::Rational
    - vigra::TinyVector
    - vigra::autodiff::DualVector
    - vigra::FFTWComplex
    - vigra::FixedPoint16
    - vigra::Quaternion
  - Random Number Generation
    Mersenne twister class and random number functors
  - Polynomials and root determination
    Polynomials and root determination
  - vigra::linalg::Matrix
    array specialization for linear algebra
  - Linear Algebra
    matrix algebra, solution of linear systems, eigenvalue calculation etc.
  - Unsupervised Decomposition
    Unsupervised matrix decomposition methods (pLSA)
  - Optimization and Regression
    ordinary and non-negative least squares, ridge regression, least angle regression (LARS and LASSO)
  - Algebraic Concepts
    Requirements for types that implement arithmetic operations
- Utilities
  error handling, speed measurement
  - Error Reporting
    exceptions and assertions
  - Timing macros for runtime measurements
    macros for taking execution speed measurements
  - VIGRA_FINALLY
    emulation of the 'finally' keyword from Python
  - vigra::Any
    typesafe storage of arbitrary values
  - vigra::BucketQueue and vigra::MappedBucketQueue
    efficient priority queues for integer priorities
  - Ranges and Points
    2-D and N-D positions, extents, and boxes
  - vigra::FilterIterator
    skip elements in a range that don't fulfill a predicate
  - vigra::IteratorAdaptor
    quickly create STL-compatible 1D iterator adaptors
  - Tuple Types
    pair, triple, tuple4, tuple5
  - Utilities to manage pixel neighborhoods
    2D neighborhood definitions (deprecated, use vigra::GridGraph instead)
  - Utilities to manage voxel neighborhoods
    3D neighborhood definitions (deprecated, use vigra::GridGraph instead)
  - vigra::ArrayVector
    replacement for std::vector with stronger guarantees (deprecated as of C++ 11)
- Concepts
  generic interface definitions
  - Algebraic Concepts
    requirements for types that implement arithmetic operations
  - Image Iterators
    2D iterator API
  - Multi-dimensional Array Iterators
    multi-dimensional iterator API
  - vigra::MultiArrayNavigator
    navigator utility for multi-dimensional arrays
  - vigra::FunctorTraits
    requirements for functor traits
  - Crack Edge Image
    topologically correct treatment of interpixel contours
  - Data Accessors
    requirements for data accessors (deprecated)
- Examples
  demonstration programs for VIGRA's usage
- Vigra Matlab
  VIGRA Matlab bindings (unsupported)
- vigranumpy
  VIGRA Python bindings
- Credits and Changelog
  who contributed what?

# VIGRA - Vision with Generic Algorithms

Version 1.11.1 by Ullrich Köthe

VIGRA is a computer vision library that puts its main emphasis on flexible algorithms, because algorithms represent the principle know-how of this field. The library was consequently built using generic programming as introduced by Stepanov and Musser and exemplified in the C++ Standard Template Library. By writing a few adapters (image iterators and accessors) you can use VIGRA's algorithms on top of your data structures, within your environment. Alternatively, you can also use the data structures provided within VIGRA, which can be easily adapted to a wide range of applications. VIGRA's flexibility comes almost for free: Since the design uses compile-time polymorphism (templates), performance of the compiled program approaches that of a traditional, hand tuned, inflexible, solution.

VIGRA's design is documented in the chapter "Reusable Software in Computer Vision" by Ullrich Köthe, in: B. Jähne, H. Haußecker, P. Geißler: "Handbook on Computer Vision and Applications", volume 3, Academic Press, 1999. If you don't have the book, you may read a draft of this article. A shorter article STL Style Generic Programming with Images describing some of the ideas has appeared in the January 2000 issue of C++ Report Magazine. The most comprehensive source of information is U. Köthe's PhD thesis Generische Programmierung für die Bildverarbeitung, but this is written in German.

VIGRA is subject to this LICENSE.

You can also subscribe to the VIGRA Mailing List to get instant information about new releases, discuss VIGRA's features and development, and ask the experts for help.

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python vigra 1.11.1 (Fri May 19 2017)