/Src/Dependencies/Boost/libs/gil/doc/doxygen/gil_standalone/main.dox

http://hadesmem.googlecode.com/ · text · 278 lines · 218 code · 60 blank · 0 comment · 0 complexity · 93d21dc1c10f7f9f94f8f4a4467b6073 MD5 · raw file

  1. /// \defgroup BasicConcepts Basic Concepts
  2. /// \brief Various basic concepts
  3. /// \defgroup Point Point
  4. /// \brief N-dimensional point
  5. /// \defgroup PointConcept Concepts
  6. /// \ingroup Point
  7. /// \brief Concepts for points
  8. /// \defgroup PointModel Models
  9. /// \ingroup Point
  10. /// \brief Models for points
  11. /// \defgroup PointAlgorithm Algorithms and Utility Functions
  12. /// \ingroup Point
  13. /// \brief Algorithms and Utility Functions for points
  14. /// \defgroup ColorSpaceAndLayout Color, Color Space, and Layout
  15. /// \brief The color space and the layout define the set, ordering and interpretation of channels in a pixel
  16. /// \defgroup ColorSpaceAndLayoutConcept Concepts
  17. /// \ingroup ColorSpaceAndLayout
  18. /// \defgroup ColorSpaceAndLayoutModel Models
  19. /// \ingroup ColorSpaceAndLayout
  20. /// \defgroup ColorNameModel Color Names
  21. /// \ingroup ColorSpaceAndLayoutModel
  22. /// \defgroup ColorSpaceModel Color Spaces
  23. /// \ingroup ColorSpaceAndLayoutModel
  24. /// \defgroup LayoutModel Layouts
  25. /// \ingroup ColorSpaceAndLayoutModel
  26. /// \defgroup Channel Channel
  27. /// \brief Channel is the building block of pixel
  28. /// \defgroup ChannelConcept Concepts
  29. /// \ingroup Channel
  30. /// \brief Concepts for channels
  31. /// \defgroup ChannelModel Models
  32. /// \ingroup Channel
  33. /// \brief Channel models. Although not required by the ChannelConcept, all GIL-provided channels support arithmetic operations
  34. /// \defgroup ChannelAlgorithm Algorithms and Utility Functions
  35. /// \ingroup Channel
  36. /// \brief Channel algorithms, metafunctions and utility functions
  37. /**
  38. \defgroup ColorBase ColorBase
  39. \brief A color base is a container of color elements.
  40. The most common use of color base is in the implementation of a pixel, in which case the color
  41. 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
  42. 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
  43. whose elements are channel iterators.
  44. */
  45. /// \defgroup ColorBaseConcept Concepts
  46. /// \ingroup ColorBase
  47. /// \brief ColorBase concepts
  48. /// \defgroup ColorBaseModel Models
  49. /// \ingroup ColorBase
  50. /// \brief ColorBase models
  51. /// \defgroup ColorBaseAlgorithm Algorithms and Utility Functions
  52. /// \ingroup ColorBase
  53. /// \brief ColorBase algorithms, metafunctions and utility functions
  54. /**
  55. \defgroup PixelBased PixelBased
  56. \brief Concepts for all GIL constructs that are pixel-based (pixels, pixel iterators, locators, views, images).
  57. PixelBasedConcept provides a uniform interface for getting some common properties of pixel-based constructs, such as the number of channels,
  58. the color space, the layout, etc.
  59. */
  60. /// \defgroup PixelBasedConcept Concepts
  61. /// \ingroup PixelBased
  62. /// \brief PixelBased concepts
  63. /// \defgroup PixelBasedModel Models
  64. /// \ingroup PixelBased
  65. /// \brief PixelBased models
  66. /// \defgroup PixelBasedAlgorithm Algorithms and Utility Functions
  67. /// \ingroup PixelBased
  68. /// \brief PixelBased algorithms, metafunctions and utility functions.
  69. /**
  70. \defgroup Pixel Pixel
  71. \brief A pixel is a set of channels defining the color at a given point in an image.
  72. Conceptually, a pixel is little more than a color base whose elements model \p ChannelConcept.
  73. Many properties of pixels inherit from color bases: pixels may be <i>homogeneous</i> if all of their channels have the same type; otherwise they are
  74. called <i>heterogeneous</i>. The channels of a pixel may be addressed using semantic or physical indexing, or by color; all color base algorithms
  75. work on pixels as well. Two pixels are <i>compatible</i> if their color spaces are the same and their channels, paired semantically, are compatible.
  76. Note that constness, memory organization and reference/value are ignored. For example, an 8-bit RGB planar reference is compatible to a constant 8-bit
  77. BGR interleaved pixel value. Most pairwise pixel operations (copy construction, assignment, equality, etc.) are only defined for compatible pixels.
  78. */
  79. /// \defgroup PixelConcept Concepts
  80. /// \ingroup Pixel
  81. /// \brief Pixel concepts
  82. /// \defgroup PixelModel Models
  83. /// \ingroup Pixel
  84. /// \brief Pixel models
  85. /**
  86. \defgroup PixelAlgorithm Algorithms and Utility Functions
  87. \ingroup Pixel
  88. \brief Pixel algorithms, metafunctions and utility functions.
  89. Since pixels model the ColorBaseConcept, all color-base related algorithms also apply to pixels. See \ref ColorBaseAlgorithm for more.
  90. */
  91. /// \defgroup PixelDereferenceAdaptor Pixel Dereference Adaptor
  92. /// \brief A function object invoked upon accessing of the pixel of a pixel iterator/locator/view
  93. /// \defgroup PixelDereferenceAdaptorConcept Concepts
  94. /// \ingroup PixelDereferenceAdaptor
  95. /// \defgroup PixelDereferenceAdaptorModel Models
  96. /// \ingroup PixelDereferenceAdaptor
  97. /// \defgroup PixelIterator Pixel Iterator
  98. /// \brief STL Iterators over models of PixelConcept
  99. /// \defgroup PixelIteratorConcept Concepts
  100. /// \ingroup PixelIterator
  101. /// \brief Pixel iterator concepts
  102. /// \defgroup PixelIteratorModel Models
  103. /// \ingroup PixelIterator
  104. /// \brief Pixel iterator models
  105. /// \defgroup PixelLocator Pixel Locator
  106. /// \brief Generalization of an iterator to multiple dimensions
  107. /// \defgroup PixelLocatorConcept Concepts
  108. /// \ingroup PixelLocator
  109. /// \brief Pixel locator concepts
  110. /// \defgroup PixelLocatorModel Models
  111. /// \ingroup PixelLocator
  112. /// \brief Pixel locator models
  113. /// \defgroup ImageView Image View
  114. /// \brief N-dimensional range
  115. /// \defgroup ImageViewConcept Concepts
  116. /// \ingroup ImageView
  117. /// \brief Image view concepts
  118. /// \defgroup ImageViewModel Models
  119. /// \ingroup ImageView
  120. /// \brief Image view models
  121. /// \defgroup ImageViewAlgorithm Algorithms and Utility Functions
  122. /// \ingroup ImageView
  123. /// \brief Image view algorithms, metafunctions and utility functions
  124. /**
  125. \defgroup Image Image
  126. \brief N-dimensional container
  127. An image is a container of N-dimensional data. GIL provides only one model, a two dimensional image whose \p value_type is a pixel.
  128. Images are regular types (which means they have a default constructor, a copy constructor, \p operator=, \p operator==, \p operator!=, and \p swap)
  129. As containers, images own the data, which means they allocate the data in their constructors and deallocate in the destructors. Their copy construction,
  130. assignment and equality comparison is deep (i.e. propagates the operation to the values). That makes images expensive to pass by value, unlike views.
  131. Also, unlike views, images propagate their constness to the data. An const-qualified image does not allow for modifying its pixels and does not provide
  132. a mutable view over its pixels.
  133. Images provide two services: they manage ownership of their data (the pixels) and they can return a view over their pixels.
  134. Algorithms predominantly operate on views. This is analogous to the STL: In the STL containers (like \p std::vector) provide ranges (\p vec.begin()
  135. and \p vec.end() ) and algorithms typically operate on ranges. The GIL equivalent of a range is an image view.
  136. */
  137. /// \defgroup ImageConcept Concepts
  138. /// \ingroup Image
  139. /// \brief Image concepts
  140. /// \defgroup ImageModel Models
  141. /// \ingroup Image
  142. /// \brief Image models
  143. /// \defgroup Variant Variant
  144. /// \brief A holder of a runtime instantiated type. Used to provide runtime-specified images and views
  145. /// \defgroup Metafunctions Metafunctions
  146. /// \brief Metafunctions to construct or query GIL types
  147. /// \defgroup TypeFactory Type Factory Metafunctions
  148. /// \ingroup Metafunctions
  149. /// \brief Metafunctions that construct GIL types from related types or from components
  150. /// \defgroup TypeAnalysis Type Analysis Metafunctions
  151. /// \ingroup Metafunctions
  152. /// \brief Metafunctions that determine properties of GIL types
  153. /// \defgroup IO I/O
  154. /// \brief Support for reading and writing images to file
  155. /// \defgroup JPEG_IO JPEG I/O
  156. /// \ingroup IO
  157. /// \brief Support for reading and writing JPEG image files
  158. /// \defgroup TIFF_IO TIFF I/O
  159. /// \ingroup IO
  160. /// \brief Support for reading and writing TIFF image files
  161. /// \defgroup PNG_IO PNG I/O
  162. /// \ingroup IO
  163. /// \brief Support for reading and writing PNG image files
  164. /*!
  165. \mainpage Generic Image Library
  166. \section Documentation
  167. - A Quick, Hands-on \ref GILTutorial "Tutorial".
  168. - A Detailed \ref GILDesignGuide "Design Guide".
  169. \section Modules
  170. - \ref BasicConcepts
  171. - \ref Point
  172. - \ref PointConcept
  173. - \ref PointModel
  174. - \ref PointAlgorithm
  175. - \ref ColorSpaceAndLayout
  176. - \ref ColorSpaceAndLayoutConcept
  177. - \ref ColorSpaceAndLayoutModel
  178. - \ref Channel
  179. - \ref ChannelConcept
  180. - \ref ChannelModel
  181. - \ref ChannelAlgorithm
  182. - \ref ColorBase
  183. - \ref ColorBaseConcept
  184. - \ref ColorBaseModel
  185. - \ref ColorBaseAlgorithm
  186. - \ref PixelBased
  187. - \ref PixelBasedConcept
  188. - \ref PixelBasedModel
  189. - \ref PixelBasedAlgorithm
  190. - \ref Pixel
  191. - \ref PixelConcept
  192. - \ref PixelModel
  193. - \ref PixelAlgorithm
  194. - \ref PixelDereferenceAdaptor
  195. - \ref PixelDereferenceAdaptorConcept
  196. - \ref PixelDereferenceAdaptorModel
  197. - \ref PixelIterator
  198. - \ref PixelIteratorConcept
  199. - \ref PixelIteratorModel
  200. - \ref PixelLocator
  201. - \ref PixelLocatorConcept
  202. - \ref PixelLocatorModel
  203. - \ref ImageView
  204. - \ref ImageViewConcept
  205. - \ref ImageViewModel
  206. - \ref ImageViewAlgorithm
  207. - \ref Image
  208. - \ref ImageConcept
  209. - \ref ImageModel
  210. - \ref Metafunctions
  211. - \ref TypeFactory
  212. - \ref TypeAnalysis
  213. - \ref Variant
  214. - \ref IO
  215. - \ref JPEG_IO
  216. - \ref TIFF_IO
  217. - \ref PNG_IO
  218. */