/usr/include/boost/gil/image_view.hpp is in libboost1.55-dev 1.55.0+dfsg-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 | /*
Copyright 2005-2007 Adobe Systems Incorporated
Use, modification and distribution are subject to the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
See http://opensource.adobe.com/gil for most recent version including documentation.
*/
/*************************************************************************************************/
#ifndef GIL_IMAGE_VIEW_H
#define GIL_IMAGE_VIEW_H
////////////////////////////////////////////////////////////////////////////////////////
/// \file
/// \brief image view class
/// \author Lubomir Bourdev and Hailin Jin \n
/// Adobe Systems Incorporated
/// \date 2005-2007 \n Last updated on February 12, 2007
///
////////////////////////////////////////////////////////////////////////////////////////
#include <cstddef>
#include <iterator>
#include "gil_config.hpp"
#include "iterator_from_2d.hpp"
//#ifdef _MSC_VER
//#pragma warning(push)
//#pragma warning(disable : 4244) // conversion from 'gil::image<V,Alloc>::coord_t' to 'int', possible loss of data (visual studio compiler doesn't realize that the two types are the same)
//#endif
namespace boost { namespace gil {
////////////////////////////////////////////////////////////////////////////////////////
/// \class image_view
/// \ingroup ImageViewModel PixelBasedModel
/// \brief A lightweight object that interprets memory as a 2D array of pixels. Models ImageViewConcept,PixelBasedConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConcept
///
/// Image view consists of a pixel 2D locator (defining the mechanism for navigating in 2D)
/// and the image dimensions.
///
/// Image views to images are what ranges are to STL containers. They are lightweight objects,
/// that don't own the pixels. It is the user's responsibility that the underlying data remains
/// valid for the lifetime of the image view.
///
/// Similar to iterators and ranges, constness of views does not extend to constness of pixels.
/// A const \p image_view does not allow changing its location in memory (resizing, moving) but does
/// not prevent one from changing the pixels. The latter requires an image view whose value_type
/// is const.
///
/// Images have interfaces consistent with STL 1D random access containers, so they can be used
/// directly in STL algorithms like:
/// \code
/// std::fill(img.begin(), img.end(), red_pixel);
/// \endcode
///
/// In addition, horizontal, vertical and 2D random access iterators are provided.
///
/// Note also that \p image_view does not require that its element type be a pixel. It could be
/// instantiated with a locator whose \p value_type models only \p Regular. In this case the image
/// view models the weaker RandomAccess2DImageViewConcept, and does not model PixelBasedConcept.
/// Many generic algorithms don't require the elements to be pixels.
///
////////////////////////////////////////////////////////////////////////////////////////
template <typename Loc> // Models 2D Pixel Locator
class image_view {
public:
// typedefs required by ConstRandomAccessNDImageViewConcept
static const std::size_t num_dimensions=2;
typedef typename Loc::value_type value_type;
typedef typename Loc::reference reference; // result of dereferencing
typedef typename Loc::coord_t coord_t; // 1D difference type (same for all dimensions)
typedef coord_t difference_type; // result of operator-(1d_iterator,1d_iterator)
typedef typename Loc::point_t point_t;
typedef Loc locator;
typedef image_view<typename Loc::const_t> const_t; // same as this type, but over const values
template <std::size_t D> struct axis {
typedef typename Loc::template axis<D>::coord_t coord_t; // difference_type along each dimension
typedef typename Loc::template axis<D>::iterator iterator; // 1D iterator type along each dimension
};
typedef iterator_from_2d<Loc> iterator; // 1D iterator type for each pixel left-to-right inside top-to-bottom
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::size_t size_type;
// typedefs required by ConstRandomAccess2DImageViewConcept
typedef locator xy_locator;
typedef typename xy_locator::x_iterator x_iterator; // pixel iterator along a row
typedef typename xy_locator::y_iterator y_iterator; // pixel iterator along a column
typedef typename xy_locator::x_coord_t x_coord_t;
typedef typename xy_locator::y_coord_t y_coord_t;
template <typename Deref> struct add_deref {
typedef image_view<typename Loc::template add_deref<Deref>::type> type;
static type make(const image_view<Loc>& iv, const Deref& d) { return type(iv.dimensions(), Loc::template add_deref<Deref>::make(iv.pixels(),d)); }
};
image_view() : _dimensions(0,0) {}
template <typename View> image_view(const View& iv) : _dimensions(iv.dimensions()), _pixels(iv.pixels()) {}
template <typename L2> image_view(const point_t& sz , const L2& loc) : _dimensions(sz), _pixels(loc) {}
template <typename L2> image_view(coord_t width, coord_t height, const L2& loc) : _dimensions(x_coord_t(width),y_coord_t(height)), _pixels(loc) {}
template <typename View> image_view& operator=(const View& iv) { _pixels=iv.pixels(); _dimensions=iv.dimensions(); return *this; }
image_view& operator=(const image_view& iv) { _pixels=iv.pixels(); _dimensions=iv.dimensions(); return *this; }
template <typename View> bool operator==(const View& v) const { return pixels()==v.pixels() && dimensions()==v.dimensions(); }
template <typename View> bool operator!=(const View& v) const { return !(*this==v); }
template <typename L2> friend void swap(image_view<L2>& x, image_view<L2>& y);
const point_t& dimensions() const { return _dimensions; }
const locator& pixels() const { return _pixels; }
x_coord_t width() const { return dimensions().x; }
y_coord_t height() const { return dimensions().y; }
std::size_t num_channels() const { return gil::num_channels<value_type>::value; }
bool is_1d_traversable() const { return _pixels.is_1d_traversable(width()); }
//\{@
/// \name 1D navigation
size_type size() const { return width()*height(); }
iterator begin() const { return iterator(_pixels,_dimensions.x); }
iterator end() const { return begin()+(difference_type)size(); } // potential performance problem!
reverse_iterator rbegin() const { return reverse_iterator(end()); }
reverse_iterator rend() const { return reverse_iterator(begin()); }
reference operator[](difference_type i) const { return begin()[i]; } // potential performance problem!
iterator at(difference_type i)const { return begin()+i; }
iterator at(const point_t& p) const { return begin()+p.y*width()+p.x; }
iterator at(x_coord_t x, y_coord_t y)const { return begin()+y*width()+x; }
//\}@
//\{@
/// \name 2-D navigation
reference operator()(const point_t& p) const { return _pixels(p.x,p.y); }
reference operator()(x_coord_t x, y_coord_t y)const { return _pixels(x,y); }
template <std::size_t D> typename axis<D>::iterator axis_iterator(const point_t& p) const { return _pixels.axis_iterator<D>(p); }
xy_locator xy_at(x_coord_t x, y_coord_t y) const { return _pixels+point_t(x_coord_t(x),y_coord_t(y)); }
locator xy_at(const point_t& p) const { return _pixels+p; }
//\}@
//\{@
/// \name X navigation
x_iterator x_at(x_coord_t x, y_coord_t y) const { return _pixels.x_at(x,y); }
x_iterator x_at(const point_t& p) const { return _pixels.x_at(p); }
x_iterator row_begin(y_coord_t y) const { return x_at(0,y); }
x_iterator row_end(y_coord_t y) const { return x_at(width(),y); }
//\}@
//\{@
/// \name Y navigation
y_iterator y_at(x_coord_t x, y_coord_t y) const { return xy_at(x,y).y(); }
y_iterator y_at(const point_t& p) const { return xy_at(p).y(); }
y_iterator col_begin(x_coord_t x) const { return y_at(x,0); }
y_iterator col_end(x_coord_t x) const { return y_at(x,height()); }
//\}@
private:
template <typename L2> friend class image_view;
point_t _dimensions;
xy_locator _pixels;
};
template <typename L2>
inline void swap(image_view<L2>& x, image_view<L2>& y) {
using std::swap;
swap(x._dimensions,y._dimensions);
swap(x._pixels, y._pixels); // TODO: Extend further
}
/////////////////////////////
// PixelBasedConcept
/////////////////////////////
template <typename L>
struct channel_type<image_view<L> > : public channel_type<L> {};
template <typename L>
struct color_space_type<image_view<L> > : public color_space_type<L> {};
template <typename L>
struct channel_mapping_type<image_view<L> > : public channel_mapping_type<L> {};
template <typename L>
struct is_planar<image_view<L> > : public is_planar<L> {};
/////////////////////////////
// HasDynamicXStepTypeConcept
/////////////////////////////
template <typename L>
struct dynamic_x_step_type<image_view<L> > {
typedef image_view<typename dynamic_x_step_type<L>::type> type;
};
/////////////////////////////
// HasDynamicYStepTypeConcept
/////////////////////////////
template <typename L>
struct dynamic_y_step_type<image_view<L> > {
typedef image_view<typename dynamic_y_step_type<L>::type> type;
};
/////////////////////////////
// HasTransposedTypeConcept
/////////////////////////////
template <typename L>
struct transposed_type<image_view<L> > {
typedef image_view<typename transposed_type<L>::type> type;
};
} } // namespace boost::gil
//#ifdef _MSC_VER
//#pragma warning(pop)
//#endif
#endif
|