#include <Map2D.h>

Public Types
typedef Storage	StorageType

typedef Compute	ComputeType

typedef Map2D< Storage, Compute >	Type

typedef shared_ptr< Map2D >	Ref

Public Member Functions
const Storage &	fastGet (int x, int y) const

void	fastSet (int x, int y, const Storage &v)

void	resize (uint32 newW, uint32 newH)

bool	changed ()

void	setChanged (bool c)

Storage *	getCArray ()

const Storage *	getCArray () const

Array< Storage > &	getArray ()

const Array< Storage > &	getArray () const

bool	inBounds (int x, int y) const

bool	inBounds (const Vector2int16 &v) const

const Storage &	get (int x, int y, WrapMode wrap) const

const Storage &	get (int x, int y) const

const Storage &	get (const Vector2int16 &p) const

const Storage &	get (const Vector2int16 &p, WrapMode wrap) const

Storage &	get (int x, int y, WrapMode wrap)

Storage &	get (int x, int y)

Storage &	get (const Vector2int16 &p)

void	set (const Vector2int16 &p, const Storage &v)

void	set (int x, int y, const Storage &v, WrapMode wrap)

void	set (int x, int y, const Storage &v)

void	setAll (const Storage &v)

template<class T >
void	set (const shared_ptr< Map2D< Storage, T > > &src)

void	maybeFlipVertical (bool flip)

virtual void	flipVertical ()

virtual void	flipHorizontal ()

virtual void	crop (int newX, int newY, int newW, int newH)

virtual void	crop (const Rect2D &rect)

Compute	nearest (float x, float y, WrapMode wrap) const

Compute	nearest (float x, float y) const

Compute	nearest (const Vector2 &p) const

Compute	average () const

Compute	bilinear (float x, float y, WrapMode wrap) const

Compute	bilinear (float x, float y) const

Compute	bilinear (const Vector2 &p) const

Compute	bilinear (const Vector2 &p, WrapMode wrap) const

Compute	bicubic (float x, float y, WrapMode wrap) const

Compute	bicubic (float x, float y) const

Compute	bicubic (const Vector2 &p, WrapMode wrap) const

Compute	bicubic (const Vector2 &p) const

int32	width () const

int32	height () const

Vector2int16	size () const

Rect2D	rect2DBounds () const

size_t	sizeInMemory () const

WrapMode	wrapMode () const

void	setWrapMode (WrapMode m)

Public Member Functions inherited from G3D::ReferenceCountedObject
virtual	~ReferenceCountedObject ()

Static Public Member Functions
static Ref	create (int w=0, int h=0, WrapMode wrap=WrapMode::ERROR)

Public Attributes
GMutex	mutex

Protected Member Functions
const Storage &	slowGet (int x, int y, WrapMode wrap)

Compute	bicubic (const Compute *ctrl, double s) const

	Map2D (int w, int h, WrapMode wrap)

Protected Attributes
Storage	ZERO

uint32	w

uint32	h

WrapMode	_wrapMode

AtomicInt32	m_changed

Array< Storage >	data

Detailed Description

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
class G3D::Map2D< Storage, Compute >

Map of values across a discrete 2D plane. Can be thought of as a generic class for 2D images, allowing flexibility as to pixel format and convenient methods. In fact, the "pixels" can be any values on a grid that can be sensibly interpolated–RGB colors, scalars, 4D vectors, and so on.

Other "image" classes in G3D:

G3D::GImage - Supports file formats, fast, Color3uint8 and Color4uint8 formats. No interpolation.

G3D::shared_ptr<Texture> - Represents image on the graphics card (not directly readable on the CPU). Supports 2D, 3D, and a variety of interpolation methods, loads file formats.

G3D::Image3 - A subclass of Map2D<Color3> that supports image loading and saving and conversion to Texture.

G3D::Image4 - A subclass of Map2D<Color4> that supports image loading and saving and conversion to Texture.

G3D::Image3uint8 - A subclass of Map2D<Color3uint8> that supports image loading and saving and conversion to Texture.

G3D::Image4uint8 - A subclass of Map2D<Color4uint8> that supports image loading and saving and conversion to Texture.

There are two type parameters– the first (@ Storage) is the type used to store the "pixel" values efficiently and the second (Compute) is the type operated on by computation. The Compute::Compute(Storage&) constructor is used to convert between storage and computation types. Storage is often an integer version of Compute, for example Map2D<double, uint8>. By default, the computation type is:

   Storage       Computation

   uint8          float32
   uint16         float32
   uint32         float64
   uint64         float64

   int8           float32
   int16          float32
   int32          float64
   int64          float64

   float32        float64
   float64        float64

   Vector2        Vector2
   Vector2int16   Vector2

   Vector3        Vector3
   Vector3int16   Vector3

   Vector4        Vector4

   Color3         Color3
   Color3uint8    Color3

   Color4         Color4
   Color4uint8    Color4

Any other storage type defaults to itself as the computation type.

The computation type can be any that supports lerp, +, -, *, /, and an empty constructor.

Assign value:

im->set(x, y, 7); or im->get(x, y) = 7;

Read value:

int c = im(x, y);

Can also sample with nearest neighbor, bilinear, and bicubic interpolation.

Sampling follows OpenGL conventions, where pixel values represent grid points and (0.5, 0.5) is half-way between two vertical and two horizontal grid points. To draw an image of dimensions w x h with nearest neighbor sampling, render pixels from [0, 0] to [w - 1, h - 1].

Under the WrapMode::CLAMP wrap mode, the value of bilinear interpolation becomes constant outside [1, w - 2] horizontally. Nearest neighbor interpolation is constant outside [0, w - 1] and bicubic outside [3, w - 4]. The class does not offer quadratic interpolation because the interpolation filter could not center over a pixel.

Author: Morgan McGuire, http://graphics.cs.williams.edu

Member Typedef Documentation

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

typedef Compute G3D::Map2D< Storage, Compute >::ComputeType

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

typedef shared_ptr<Map2D> G3D::Map2D< Storage, Compute >::Ref

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

typedef Storage G3D::Map2D< Storage, Compute >::StorageType

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

typedef Map2D<Storage, Compute> G3D::Map2D< Storage, Compute >::Type

Constructor & Destructor Documentation

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

G3D::Map2D< Storage, Compute >::Map2D	(	int	w,
		int	h,
		WrapMode	wrap
	)

inlineprotected

  : w(0), h(0), _wrapMode(wrap), m_changed(1) {
  ZERO = Storage(Compute(Storage()) * 0);
  resize(w, h);
  }

Here is the caller graph for this function:

Member Function Documentation

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::average ( ) const

inline

Returns the average value of all elements of the map

  {
  if ((w == 0) || (h == 0)) {
  return ZERO;
  }
 
  // To avoid overflows, compute the average of row averages
 
  Compute rowSum = ZERO;
  for (unsigned int y = 0; y < h; ++y) {
  Compute sum = ZERO;
  int offset = y * w;
  for (unsigned int x = 0; x < w; ++x) {
  sum += Compute(data[offset + x]);
  }
  rowSum += sum * (1.0f / w);
  }
 
  return rowSum * (1.0f / h);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bicubic	(	const Compute *	ctrl,
		double	s
	)		const

inlineprotected

Given four control points and a value on the range [0, 1) evaluates the Catmull-rom spline between the times of the middle two control points

  {
 
  // f = B * S * ctrl'
 
  // B matrix: Catmull-Rom spline basis
  static const double B[4][4] = {
  { 0.0, -0.5, 1.0, -0.5},
  { 1.0, 0.0, -2.5, 1.5},
  { 0.0, 0.5, 2.0, -1.5},
  { 0.0, 0.0, -0.5, 0.5}}; 
 
  // S: Powers of the fraction
  double S[4];
  double s2 = s * s;
  S[0] = 1.0;
  S[1] = s;
  S[2] = s2;
  S[3] = s2 * s;
 
  Compute sum(ZERO);
 
  for (int c = 0; c < 4; ++c) {
  double coeff = 0.0;
  for (int power = 0; power < 4; ++power) {
  coeff += B[c][power] * S[power];
  }
  sum += ctrl[c] * coeff;
  }
 
  return sum;
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bicubic	(	float	x,
		float	y,
		WrapMode	wrap
	)		const

inline

Uses Catmull-Rom splines to interpolate between grid values. Guaranteed to match nearest(x, y) at integers.

  {
  int i = iFloor(x);
  int j = iFloor(y);
  float fX = x - i;
  float fY = y - j;
 
  Compute vsample[4];
  for (int v = 0; v < 4; ++v) {
 
  // Horizontal interpolation
  Compute hsample[4];
  for (int u = 0; u < 4; ++u) {
  hsample[u] = Compute(get(i + u - 1, j + v - 1, wrap));
  }
  
  vsample[v] = bicubic(hsample, fX);
  }
 
  // Vertical interpolation
  return bicubic(vsample, fY);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bicubic	(	float	x,
		float	y
	)		const

inline

  {
  return bicubic(x, y, _wrapMode);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bicubic	(	const Vector2 &	p,
		WrapMode	wrap
	)		const

inline

  {
  return bicubic(p.x, p.y, wrap);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bicubic ( const Vector2 & p ) const

inline

  {
  return bicubic(p.x, p.y, _wrapMode);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bilinear	(	float	x,
		float	y,
		WrapMode	wrap
	)		const

inline

Needs to access elements from (floor(x), floor(y)) to (floor(x) + 1, floor(y) + 1) and will use the wrap mode appropriately (possibly generating out of bounds errors).

Guaranteed to match nearest(x, y) at integers.

  {
  const int i = iFloor(x);
  const int j = iFloor(y);
  
  const float fX = x - i;
  const float fY = y - j;
 
  // Horizontal interpolation, first row
  const Compute& t0 = get(i, j, wrap);
  const Compute& t1 = get(i + 1, j, wrap);
 
  // Horizontal interpolation, second row
  const Compute& t2 = get(i, j + 1, wrap);
  const Compute& t3 = get(i + 1, j + 1, wrap);
 
  const Compute& A = lerp(t0, t1, fX);
  const Compute& B = lerp(t2, t3, fX);
 
  // Vertical interpolation
  return lerp(A, B, fY);
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bilinear	(	float	x,
		float	y
	)		const

inline

  {
  return bilinear(x, y, _wrapMode);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bilinear ( const Vector2 & p ) const

inline

  {
  return bilinear(p.x, p.y, _wrapMode);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::bilinear	(	const Vector2 &	p,
		WrapMode	wrap
	)		const

inline

  {
  return bilinear(p.x, p.y, wrap);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

bool G3D::Map2D< Storage, Compute >::changed ( )

inline

Returns true if this map has been written to since the last call to setChanged(false). This is useful if you are caching a texture map other value that must be recomputed whenever this changes.

  {
  return m_changed.value() != 0;
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

static Ref G3D::Map2D< Storage, Compute >::create	(	int	w = `0`,
		int	h = `0`,
		WrapMode	wrap = `WrapMode::ERROR`
	)

inlinestatic

  {
  return Ref(new Map2D(w, h, wrap));
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

virtual void G3D::Map2D< Storage, Compute >::crop	(	int	newX,
		int	newY,
		int	newW,
		int	newH
	)

inlinevirtual

Crops this map so that it only contains pixels between (x, y) and (x + w - 1, y + h - 1) inclusive.

  {
  alwaysAssertM(newX + newW <= (int)w, "Cannot grow when cropping");
  alwaysAssertM(newY + newH <= (int)h, "Cannot grow when cropping");
  alwaysAssertM(newX >= 0 && newY >= 0, "Origin out of bounds.");
 
  // Always safe to copy towards the upper left, provided 
  // that we're iterating towards the lower right. This lets us avoid
  // reallocating the underlying array.
  for (int y = 0; y < newH; ++y) {
  for (int x = 0; x < newW; ++x) {
  data[x + y * newW] = data[(x + newX) + (y + newY) * w];
  }
  }
 
  resize(newW, newH);
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

virtual void G3D::Map2D< Storage, Compute >::crop ( const Rect2D & rect )

inlinevirtual

iRounds to the nearest x0 and y0.

  {
  crop(iRound(rect.x0()), iRound(rect.y0()), iRound(rect.x1()) - iRound(rect.x0()), iRound(rect.y1()) - iRound(rect.y0()));
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

const Storage& G3D::Map2D< Storage, Compute >::fastGet	(	int	x,
		int	y
	)		const

inline

Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds.

  {
  debugAssert(((uint32)x < w) && ((uint32)y < h));
  return data[x + y * w];
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::fastSet	(	int	x,
		int	y,
		const Storage &	v
	)

inline

Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds.

  {
  debugAssert(((uint32)x < w) && ((uint32)y < h));
  data[x + y * w] = v;
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

virtual void G3D::Map2D< Storage, Compute >::flipHorizontal ( )

inlinevirtual

  {
  int halfWidth = w / 2;
  Storage* d = data.getCArray();
  for (int x = 0; x < halfWidth; ++x) {
  for (int y = 0; y < (int)h; ++y) {
  int i1 = y * w + x;
  int i2 = y * w + (w - x - 1);
  Storage temp = d[i1];
  d[i1] = d[i2];
  d[i2] = temp;
  }
  }
  setChanged(true);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

virtual void G3D::Map2D< Storage, Compute >::flipVertical ( )

inlinevirtual

  {
  int halfHeight = h/2;
  Storage* d = data.getCArray();
  for (int y = 0; y < halfHeight; ++y) {
  int o1 = y * w;
  int o2 = (h - y - 1) * w;
  for (int x = 0; x < (int)w; ++x) {
  int i1 = o1 + x;
  int i2 = o2 + x;
  Storage temp = d[i1];
  d[i1] = d[i2];
  d[i2] = temp;
  }
  }
  setChanged(true);
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

const Storage& G3D::Map2D< Storage, Compute >::get	(	int	x,
		int	y,
		WrapMode	wrap
	)		const

inline

Get the value at (x, y).

Note that the type of image->get(x, y) is the storage type, not the computation type. If the constructor promoting Storage to Compute rescales values (as, for example Color3(Color3uint8&) does), this will not match the value returned by Map2D::nearest.

  {
  if (((uint32)x < w) && ((uint32)y < h)) {
  return data[x + y * w];
  } else {
  // Remove the const to allow a slowGet on this object
  // (we're returning a const reference so this is ok)
  return const_cast<Type*>(this)->slowGet(x, y, wrap);
  }
 # ifndef G3D_WINDOWS
  // gcc gives a useless warning that the above code might reach the end of the function;
  // we use this line to supress the warning.
  return ZERO;
 # endif
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

const Storage& G3D::Map2D< Storage, Compute >::get	(	int	x,
		int	y
	)		const

inline

  {
  return get(x, y, _wrapMode);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

const Storage& G3D::Map2D< Storage, Compute >::get ( const Vector2int16 & p ) const

inline

  {
  return get(p.x, p.y, _wrapMode);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

const Storage& G3D::Map2D< Storage, Compute >::get	(	const Vector2int16 &	p,
		WrapMode	wrap
	)		const

inline

  {
  return get(p.x, p.y, wrap);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Storage& G3D::Map2D< Storage, Compute >::get	(	int	x,
		int	y,
		WrapMode	wrap
	)

inline

  {
  return const_cast<Storage&>(const_cast<const Type*>(this)->get(x, y, wrap));
 # ifndef G3D_WINDOWS
  // gcc gives a useless warning that the above code might reach the end of the function;
  // we use this line to supress the warning.
  return ZERO;
 # endif
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Storage& G3D::Map2D< Storage, Compute >::get	(	int	x,
		int	y
	)

inline

  {
  return const_cast<Storage&>(const_cast<const Type*>(this)->get(x, y));
 # ifndef G3D_WINDOWS
  // gcc gives a useless warning that the above code might reach the end of the function;
  // we use this line to supress the warning.
  return ZERO;
 # endif
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Storage& G3D::Map2D< Storage, Compute >::get ( const Vector2int16 & p )

inline

  {
  return get(p.x, p.y);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Array<Storage>& G3D::Map2D< Storage, Compute >::getArray ( )

inline

Row-major array. You should call setChanged(true) if you mutate the array.

  {
  return data;
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

const Array<Storage>& G3D::Map2D< Storage, Compute >::getArray ( ) const

inline

  {
  return data;
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Storage* G3D::Map2D< Storage, Compute >::getCArray ( )

inline

Returns a pointer to the underlying row-major data. There is no padding at the end of the row. Be careful–this will be reallocated during a resize. You should call setChanged(true) if you mutate the array.

  {
  return data.getCArray();
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

const Storage* G3D::Map2D< Storage, Compute >::getCArray ( ) const

inline

  {
  return data.getCArray();
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

int32 G3D::Map2D< Storage, Compute >::height ( ) const

inline

Pixel height

  {
  return (int32)h;
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

bool G3D::Map2D< Storage, Compute >::inBounds	(	int	x,
		int	y
	)		const

inline

is (x, y) strictly within the image bounds, or will it trigger some kind of wrap mode

  {
  return (((uint32)x < w) && ((uint32)y < h));
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

bool G3D::Map2D< Storage, Compute >::inBounds ( const Vector2int16 & v ) const

inline

is (x, y) strictly within the image bounds, or will it trigger some kind of wrap mode

  {
  return inBounds(v.x, v.y);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::maybeFlipVertical ( bool flip )

inline

flips if flip is true

  {
  if (flip) {
  flipVertical();
  }
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::nearest	(	float	x,
		float	y,
		WrapMode	wrap
	)		const

inline

Returns the nearest neighbor. Pixel values are considered to be at the upper left corner, so image->nearest(x, y) == image(x, y)

  {
  int ix = iRound(x);
  int iy = iRound(y);
  return Compute(get(ix, iy, wrap));
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::nearest	(	float	x,
		float	y
	)		const

inline

  {
  return nearest(x, y, _wrapMode);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Compute G3D::Map2D< Storage, Compute >::nearest ( const Vector2 & p ) const

inline

  {
  return nearest(p.x, p.y);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Rect2D G3D::Map2D< Storage, Compute >::rect2DBounds ( ) const

inline

Rectangle from (0, 0) to (w, h)

  {
  return Rect2D::xywh(0, 0, w, h);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::resize	(	uint32	newW,
		uint32	newH
	)

inline

Resizes without clearing, leaving garbage.

  {
  if ((newW != w) || (newH != h)) {
  w = newW;
  h = newH;
  data.resize(w * h);
  setChanged(true);
  }
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::set	(	const Vector2int16 &	p,
		const Storage &	v
	)

inline

Sets the changed flag to true

  {
  set(p.x, p.y, v);
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::set	(	int	x,
		int	y,
		const Storage &	v,
		WrapMode	wrap
	)

inline

Sets the changed flag to true

  {
  setChanged(true);
  if (((uint32)x < w) && ((uint32)y < h)) {
  // In bounds, wrapping isn't an issue.
  data[x + y * w] = v;
  } else {
  const_cast<Storage&>(slowGet(x, y, wrap)) = v;
  }
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::set	(	int	x,
		int	y,
		const Storage &	v
	)

inline

  {
  set(x, y, v, _wrapMode);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

template<class T >

void G3D::Map2D< Storage, Compute >::set ( const shared_ptr< Map2D< Storage, T > > & src )

inline

Copy values from src, which must have the same size

  {
  debugAssert(src->width() == width());
  debugAssert(src->height() == height());
  const Array<Storage>& s = src->data;
  int N = w * h;
  for (int i = 0; i < N; ++i) {
  data[i] = s[i];
  }
  setChanged(true);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::setAll ( const Storage & v )

inline

  {
  for(int i = 0; i < data.size(); ++i) {
  data[i] = v;
  }
  setChanged(true);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::setChanged ( bool c )

inline

Set/unset the changed flag.

  {
  m_changed = c ? 1 : 0;
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

void G3D::Map2D< Storage, Compute >::setWrapMode ( WrapMode m )

inline

  {
  _wrapMode = m;
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Vector2int16 G3D::Map2D< Storage, Compute >::size ( ) const

inline

Dimensions in pixels

  {
  return Vector2int16(w, h);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

size_t G3D::Map2D< Storage, Compute >::sizeInMemory ( ) const

inline

Number of bytes occupied by the image data and this structure

  {
  return data.size() * sizeof(Storage) + sizeof(*this);
  }

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

const Storage& G3D::Map2D< Storage, Compute >::slowGet	(	int	x,
		int	y,
		WrapMode	wrap
	)

inlineprotected

Handles the exceptional cases from get

  {
  switch (wrap) {
  case WrapMode::CLAMP:
  return fastGet(iClamp(x, 0, w - 1), iClamp(y, 0, h - 1));
 
  case WrapMode::TILE:
  return fastGet(iWrap(x, w), iWrap(y, h));
 
  case WrapMode::ZERO:
  return ZERO;
 
  case WrapMode::ERROR:
  alwaysAssertM(((uint32)x < w) && ((uint32)y < h), 
  format("Index out of bounds: (%d, %d), w = %d, h = %d",
  x, y, w, h));
 
  // intentionally fall through
  case WrapMode::IGNORE:
  // intentionally fall through
  default:
  {
  static Storage temp;
  return temp;
  }
  }
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

int32 G3D::Map2D< Storage, Compute >::width ( ) const

inline

Pixel width

  {
  return (int32)w;
  }

Here is the caller graph for this function:

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

WrapMode G3D::Map2D< Storage, Compute >::wrapMode ( ) const

inline

  {
  return _wrapMode;
  }

Member Data Documentation

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

WrapMode G3D::Map2D< Storage, Compute >::_wrapMode

protected

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Array<Storage> G3D::Map2D< Storage, Compute >::data

protected

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

uint32 G3D::Map2D< Storage, Compute >::h

protected

Height, in pixels.

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

AtomicInt32 G3D::Map2D< Storage, Compute >::m_changed

protected

0 if no mutating method has been invoked since the last call to setChanged();

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

GMutex G3D::Map2D< Storage, Compute >::mutex

Although Map2D is not threadsafe (except for the setChanged() method), you can use this mutex to create your own threadsafe access to a Map2D. Not used by the default implementation.

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

uint32 G3D::Map2D< Storage, Compute >::w

protected

Width, in pixels.

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>

Storage G3D::Map2D< Storage, Compute >::ZERO

protected

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

dep/g3dlite/include/G3D/Map2D.h

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type> class G3D::Map2D< Storage, Compute >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
class G3D::Map2D< Storage, Compute >