CImgList< T > Struct Template Reference

Class representing list of images CImg<T>. More...

#include <CImg.h>

Inheritance diagram for CImgList< T >:

Public Types
typedef CImg< T > *	iterator
	Define a CImgList<T>::iterator. More...
typedef const CImg< T > *	const_iterator
	Define a CImgList<T>::const_iterator. More...
typedef T	value_type
	Value type. More...
typedef cimg::superset< T, bool >::type	Tbool
typedef cimg::superset< T, unsigned char >::type	Tuchar
typedef cimg::superset< T, char >::type	Tchar
typedef cimg::superset< T, unsigned short >::type	Tushort
typedef cimg::superset< T, short >::type	Tshort
typedef cimg::superset< T, unsigned int >::type	Tuint
typedef cimg::superset< T, int > ::type	Tint
typedef cimg::superset< T, unsigned long >::type	Tulong
typedef cimg::superset< T, long >::type	Tlong
typedef cimg::superset< T, float >::type	Tfloat
typedef cimg::superset< T, double >::type	Tdouble
typedef cimg::last< T, bool >::type	boolT
typedef cimg::last< T, unsigned char >::type	ucharT
typedef cimg::last< T, char >::type	charT
typedef cimg::last< T, unsigned short >::type	ushortT
typedef cimg::last< T, short > ::type	shortT
typedef cimg::last< T, unsigned int >::type	uintT
typedef cimg::last< T, int >::type	intT
typedef cimg::last< T, unsigned long >::type	ulongT
typedef cimg::last< T, long >::type	longT
typedef cimg::last< T, float > ::type	floatT
typedef cimg::last< T, double > ::type	doubleT

Public Member Functions
Overloaded Operators
CImg< T > &	operator[] (const unsigned int pos)
	Return a reference to the i-th element of the image list. More...
const CImg< T > &	operator[] (const unsigned int pos) const
CImg< T > &	operator() (const unsigned int pos)
	Equivalent to CImgList<T>::operator[]. More...
const CImg< T > &	operator() (const unsigned int pos) const
T &	operator() (const unsigned int pos, const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0)
	Return a reference to (x,y,z,v) pixel of the pos-th image of the list. More...
const T &	operator() (const unsigned int pos, const unsigned int x, const unsigned int y=0, const unsigned int z=0, const unsigned int v=0) const
	operator bool () const
	Return true if list is not empty. More...
template<typename t >
CImgList< T > &	operator= (const CImg< t > &img)
	Operator=(). More...
CImgList< T > &	operator= (const CImgDisplay &disp)
	Operator=(). More...
template<typename t >
CImgList< T > &	operator= (const CImgList< t > &list)
	Operator=(). More...
CImgList< T > &	operator= (const CImgList< T > &list)
CImgList< T > &	operator= (const char *const filename)
	Operator=(). More...
CImgList< T >	operator+ () const
	Operator+() (unary). More...
template<typename t >
CImgList< T > &	operator, (const CImg< t > &img)
	Operator,(). More...
template<typename t >
CImgList< T > &	operator, (const CImgList< t > &list)
	Operator,(). More...
CImg< T >	operator> (const char axis) const
	Operator>(). More...
CImgList< T >	operator< (const char axis) const
	Operator<(). More...
Instance Checking
bool	is_empty () const
	Return true if list is empty. More...
bool	is_sameN (const unsigned int n) const
	Return true if list if of specified size. More...
template<typename t >
bool	is_sameN (const CImgList< t > &list) const
	Return true if list if of specified size. More...
bool	is_sameXYZV (const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv) const
bool	is_sameNXYZV (const unsigned int n, const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv) const
bool	containsNXYZV (const int n, const int x=0, const int y=0, const int z=0, const int v=0) const
	Return true if the list contains the pixel (n,x,y,z,v). More...
bool	containsN (const int n) const
	Return true if the list contains the image (n). More...
template<typename t >
bool	contains (const T &pixel, t &n, t &x, t &y, t &z, t &v) const
	Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y,z,v). More...
template<typename t >
bool	contains (const T &pixel, t &n, t &x, t &y, t &z) const
	Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y,z). More...
template<typename t >
bool	contains (const T &pixel, t &n, t &x, t &y) const
	Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y). More...
template<typename t >
bool	contains (const T &pixel, t &n, t &x) const
	Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x). More...
template<typename t >
bool	contains (const T &pixel, t &n) const
	Return true if one of the image list contains the specified referenced value. If true, set coordinates (n). More...
bool	contains (const T &pixel) const
	Return true if one of the image list contains the specified referenced value. More...
template<typename t >
bool	contains (const CImg< T > &img, t &n) const
	Return true if the list contains the image 'img'. If true, returns the position (n) of the image in the list. More...
bool	contains (const CImg< T > &img) const
	Return true if the list contains the image img. More...
Mathematical Functions
T &	min ()
	Return a reference to the minimum pixel value of the instance list. More...
const T &	min () const
T &	max ()
	Return a reference to the maximum pixel value of the instance list. More...
const T &	max () const
template<typename t >
T &	minmax (t &max_val)
	Return a reference to the minimum pixel value of the instance list. More...
template<typename t >
const T &	minmax (t &max_val) const
template<typename t >
T &	maxmin (t &min_val)
	Return a reference to the minimum pixel value of the instance list. More...
template<typename t >
const T &	maxmin (t &min_val) const
List Manipulation
template<typename t >
CImgList< T > &	insert (const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false)
	Insert a copy of the image img into the current image list, at position pos. More...
CImgList< T > &	insert (const CImg< T > &img, const unsigned int pos=~0U, const bool shared=false)
template<typename t >
CImgList< T >	get_insert (const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false) const
CImgList< T > &	insert (const unsigned int n, const unsigned int pos=~0U)
	Insert n empty images img into the current image list, at position pos. More...
CImgList< T >	get_insert (const unsigned int n, const unsigned int pos=~0U) const
template<typename t >
CImgList< T > &	insert (const unsigned int n, const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false)
	Insert n copies of the image img into the current image list, at position pos. More...
template<typename t >
CImgList< T >	get_insert (const unsigned int n, const CImg< t > &img, const unsigned int pos=~0U, const bool shared=false) const
template<typename t >
CImgList< T > &	insert (const CImgList< t > &list, const unsigned int pos=~0U, const bool shared=false)
	Insert a copy of the image list list into the current image list, starting from position pos. More...
template<typename t >
CImgList< T >	get_insert (const CImgList< t > &list, const unsigned int pos=~0U, const bool shared=false) const
template<typename t >
CImgList< T > &	insert (const unsigned int n, const CImgList< t > &list, const unsigned int pos=~0U, const bool shared=false)
	Insert n copies of the list list at position pos of the current list. More...
template<typename t >
CImgList< T >	get_insert (const unsigned int n, const CImgList< t > &list, const unsigned int pos=~0U, const bool shared=false) const
CImgList< T > &	remove (const unsigned int pos1, const unsigned int pos2)
	Remove the images from positions pos1 to pos2. More...
CImgList< T >	get_remove (const unsigned int pos1, const unsigned int pos2) const
CImgList< T > &	remove (const unsigned int pos)
	Remove the image at position pos from the image list. More...
CImgList< T >	get_remove (const unsigned int pos) const
CImgList< T > &	remove ()
	Remove the last image from the image list. More...
CImgList< T >	get_remove () const
CImgList< T > &	reverse ()
	Reverse list order. More...
CImgList< T >	get_reverse () const
CImgList< T > &	images (const unsigned int i0, const unsigned int i1)
	Get a sub-list. More...
CImgList< T >	get_images (const unsigned int i0, const unsigned int i1) const
CImgList< T >	get_shared_images (const unsigned int i0, const unsigned int i1)
	Get a shared sub-list. More...
const CImgList< T >	get_shared_images (const unsigned int i0, const unsigned int i1) const
CImg< T >	get_append (const char axis, const char align='p') const
	Return a single image which is the concatenation of all images of the current CImgList instance. More...
CImgList< T > &	split (const char axis, const int nb=0)
	Return a list where each image has been split along the specified axis. More...
CImgList< T >	get_split (const char axis, const int nb=0) const
template<typename t >
CImgList< T > &	push_back (const CImg< t > &img)
	Insert image img at the end of the list (STL-compliant name). More...
template<typename t >
CImgList< T > &	push_front (const CImg< t > &img)
	Insert image img at the front of the list (STL-compliant name). More...
template<typename t >
CImgList< T > &	push_back (const CImgList< t > &list)
	Insert list list at the end of the current list (STL-compliant name). More...
template<typename t >
CImgList< T > &	push_front (const CImgList< t > &list)
	Insert list list at the front of the current list (STL-compliant name). More...
CImgList< T > &	pop_back ()
	Remove last element of the list (STL-compliant name). More...
CImgList< T > &	pop_front ()
	Remove first element of the list (STL-compliant name). More...
CImgList< T > &	erase (const iterator iter)
	Remove the element pointed by iterator iter (STL-compliant name). More...

Public Attributes
unsigned int	width
	Size of the list (number of images). More...
unsigned int	allocated_width
	Allocation size of the list. More...
CImg< T > *	data
	Pointer to the first list element. More...

Constructors / Destructor / Instance Management
	~CImgList ()
	Destructor. More...
	CImgList ()
	Default constructor. More...
	CImgList (const unsigned int n)
	Construct an image list containing n empty images. More...
	CImgList (const unsigned int n, const unsigned int width, const unsigned int height=1, const unsigned int depth=1, const unsigned int dim=1)
	Construct an image list containing n images with specified size. More...
	CImgList (const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const T val)
	Construct an image list containing n images with specified size, filled with specified value. More...
	CImgList (const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const int val0, const int val1,...)
	Construct an image list containing n images with specified size and specified pixel values (int version). More...
	CImgList (const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const double val0, const double val1,...)
	Construct an image list containing n images with specified size and specified pixel values (double version). More...
template<typename t >
	CImgList (const unsigned int n, const CImg< t > &img, const bool shared=false)
	Construct a list containing n copies of the image img. More...
template<typename t >
	CImgList (const CImg< t > &img, const bool shared=false)
	Construct an image list from one image. More...
template<typename t1 , typename t2 >
	CImgList (const CImg< t1 > &img1, const CImg< t2 > &img2, const bool shared=false)
	Construct an image list from two images. More...
template<typename t1 , typename t2 , typename t3 >
	CImgList (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const bool shared=false)
	Construct an image list from three images. More...
template<typename t1 , typename t2 , typename t3 , typename t4 >
	CImgList (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const bool shared=false)
	Construct an image list from four images. More...
template<typename t1 , typename t2 , typename t3 , typename t4 , typename t5 >
	CImgList (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const bool shared=false)
	Construct an image list from five images. More...
template<typename t1 , typename t2 , typename t3 , typename t4 , typename t5 , typename t6 >
	CImgList (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const bool shared=false)
	Construct an image list from six images. More...
template<typename t1 , typename t2 , typename t3 , typename t4 , typename t5 , typename t6 , typename t7 >
	CImgList (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const CImg< t7 > &img7, const bool shared=false)
	Construct an image list from seven images. More...
template<typename t1 , typename t2 , typename t3 , typename t4 , typename t5 , typename t6 , typename t7 , typename t8 >
	CImgList (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const CImg< t7 > &img7, const CImg< t8 > &img8, const bool shared=false)
	Construct an image list from eight images. More...
template<typename t >
	CImgList (const CImgList< t > &list)
	Default copy constructor. More...
	CImgList (const CImgList< T > &list)
template<typename t >
	CImgList (const CImgList< t > &list, const bool shared)
	Advanced copy constructor. More...
	CImgList (const char *const filename)
	Construct an image list from a filename. More...
	CImgList (const CImgDisplay &disp)
	Construct an image list from a display. More...
CImgList< T >	get_shared ()
	Return a shared instance of the list. More...
const CImgList< T >	get_shared () const
	Return a shared instance of the list. More...
CImgList< T > &	clear ()
	In-place version of the default constructor. More...
CImgList< T > &	assign ()
	In-place version of the default constructor and default destructor. More...
CImgList< T > &	assign (const unsigned int n)
	In-place version of the corresponding constructor. More...
CImgList< T > &	assign (const unsigned int n, const unsigned int width, const unsigned int height=1, const unsigned int depth=1, const unsigned int dim=1)
	In-place version of the corresponding constructor. More...
CImgList< T > &	assign (const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const T val)
	In-place version of the corresponding constructor. More...
CImgList< T > &	assign (const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const int val0, const int val1,...)
	In-place version of the corresponding constructor. More...
CImgList< T > &	assign (const unsigned int n, const unsigned int width, const unsigned int height, const unsigned int depth, const unsigned int dim, const double val0, const double val1,...)
	In-place version of the corresponding constructor. More...
template<typename t >
CImgList< T > &	assign (const CImgList< t > &list, const bool shared=false)
	In-place version of the copy constructor. More...
template<typename t >
CImgList< T > &	assign (const unsigned int n, const CImg< t > &img, const bool shared=false)
	In-place version of the corresponding constructor. More...
template<typename t >
CImgList< T > &	assign (const CImg< t > &img, const bool shared=false)
	In-place version of the corresponding constructor. More...
template<typename t1 , typename t2 >
CImgList< T > &	assign (const CImg< t1 > &img1, const CImg< t2 > &img2, const bool shared=false)
	In-place version of the corresponding constructor. More...
template<typename t1 , typename t2 , typename t3 >
CImgList< T > &	assign (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const bool shared=false)
	In-place version of the corresponding constructor. More...
template<typename t1 , typename t2 , typename t3 , typename t4 >
CImgList< T > &	assign (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const bool shared=false)
	In-place version of the corresponding constructor. More...
template<typename t1 , typename t2 , typename t3 , typename t4 , typename t5 >
CImgList< T > &	assign (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const bool shared=false)
	In-place version of the corresponding constructor. More...
template<typename t1 , typename t2 , typename t3 , typename t4 , typename t5 , typename t6 >
CImgList< T > &	assign (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const bool shared=false)
	In-place version of the corresponding constructor. More...
template<typename t1 , typename t2 , typename t3 , typename t4 , typename t5 , typename t6 , typename t7 >
CImgList< T > &	assign (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const CImg< t7 > &img7, const bool shared=false)
	In-place version of the corresponding constructor. More...
template<typename t1 , typename t2 , typename t3 , typename t4 , typename t5 , typename t6 , typename t7 , typename t8 >
CImgList< T > &	assign (const CImg< t1 > &img1, const CImg< t2 > &img2, const CImg< t3 > &img3, const CImg< t4 > &img4, const CImg< t5 > &img5, const CImg< t6 > &img6, const CImg< t7 > &img7, const CImg< t8 > &img8, const bool shared=false)
	In-place version of the corresponding constructor. More...
CImgList< T > &	assign (const char *const filename)
	In-place version of the corresponding constructor. More...
CImgList< T > &	assign (const CImgDisplay &disp)
	In-place version of the corresponding constructor. More...
template<typename t >
CImgList< T > &	transfer_to (CImgList< t > &list)
	Transfer the content of the instance image list into another one. More...
CImgList< T > &	transfer_to (CImgList< T > &list)
template<typename t >
CImgList< t > &	transfer_to (CImgList< t > &list, const unsigned int pos)
CImgList< T > &	swap (CImgList< T > &list)
	Swap all fields of two CImgList instances (use with care !) More...
static CImgList< T > &	empty ()
	Return a reference to an empty list. More...

Instance Characteristics
int	dimx () const
	Return the size of the list. More...
unsigned int	size () const
	Return the size of the list. More...
CImg< T > *	ptr ()
	Return a pointer to the image buffer. More...
const CImg< T > *	ptr () const
CImg< T > *	ptr (const unsigned int l)
	Return a pointer to the image buffer. More...
const CImg< T > *	ptr (const unsigned int l) const
iterator	begin ()
	Returns an iterator to the beginning of the vector (STL-compliant name). More...
const_iterator	begin () const
iterator	end ()
	Returns an iterator just past the last element (STL-compliant name). More...
const_iterator	end () const
CImg< T > &	front ()
	Returns a reference to the first element (STL-compliant name). More...
const CImg< T > &	front () const
const CImg< T > &	back () const
	Return a reference to the last image (STL-compliant name). More...
CImg< T > &	back ()
CImg< T > &	at (const int pos)
	Read an image in specified position. More...
T &	atNXYZV (const int pos, const int x, const int y, const int z, const int v, const T out_val)
	Read a pixel value with Dirichlet boundary conditions. More...
T	atNXYZV (const int pos, const int x, const int y, const int z, const int v, const T out_val) const
T &	atNXYZV (const int pos, const int x, const int y, const int z, const int v)
	Read a pixel value with Neumann boundary conditions. More...
T	atNXYZV (const int pos, const int x, const int y, const int z, const int v) const
T &	_atNXYZV (const int pos, const int x, const int y, const int z, const int v)
T	_atNXYZV (const int pos, const int x, const int y, const int z, const int v) const
T &	atNXYZ (const int pos, const int x, const int y, const int z, const int v, const T out_val)
	Read a pixel value with Dirichlet boundary conditions for the four first coordinates (pos, x,y,z). More...
T	atNXYZ (const int pos, const int x, const int y, const int z, const int v, const T out_val) const
T &	atNXYZ (const int pos, const int x, const int y, const int z, const int v=0)
	Read a pixel value with Neumann boundary conditions for the four first coordinates (pos, x,y,z). More...
T	atNXYZ (const int pos, const int x, const int y, const int z, const int v=0) const
T &	_atNXYZ (const int pos, const int x, const int y, const int z, const int v=0)
T	_atNXYZ (const int pos, const int x, const int y, const int z, const int v=0) const
T &	atNXY (const int pos, const int x, const int y, const int z, const int v, const T out_val)
	Read a pixel value with Dirichlet boundary conditions for the three first coordinates (pos, x,y). More...
T	atNXY (const int pos, const int x, const int y, const int z, const int v, const T out_val) const
T &	atNXY (const int pos, const int x, const int y, const int z=0, const int v=0)
	Read a pixel value with Neumann boundary conditions for the three first coordinates (pos, x,y). More...
T	atNXY (const int pos, const int x, const int y, const int z=0, const int v=0) const
T &	_atNXY (const int pos, const int x, const int y, const int z=0, const int v=0)
T	_atNXY (const int pos, const int x, const int y, const int z=0, const int v=0) const
T &	atNX (const int pos, const int x, const int y, const int z, const int v, const T out_val)
	Read a pixel value with Dirichlet boundary conditions for the two first coordinates (pos,x). More...
T	atNX (const int pos, const int x, const int y, const int z, const int v, const T out_val) const
T &	atNX (const int pos, const int x, const int y=0, const int z=0, const int v=0)
	Read a pixel value with Neumann boundary conditions for the two first coordinates (pos, x). More...
T	atNX (const int pos, const int x, const int y=0, const int z=0, const int v=0) const
T &	_atNX (const int pos, const int x, const int y=0, const int z=0, const int v=0)
T	_atNX (const int pos, const int x, const int y=0, const int z=0, const int v=0) const
T &	atN (const int pos, const int x, const int y, const int z, const int v, const T out_val)
	Read a pixel value with Dirichlet boundary conditions for the first coordinates (pos). More...
T	atN (const int pos, const int x, const int y, const int z, const int v, const T out_val) const
T &	atN (const int pos, const int x=0, const int y=0, const int z=0, const int v=0)
	Read a pixel value with Neumann boundary conditions for the first coordinates (pos). More...
T	atN (const int pos, const int x=0, const int y=0, const int z=0, const int v=0) const
T &	_atN (const int pos, const int x=0, const int y=0, const int z=0, const int v=0)
T	_atN (const int pos, const int x=0, const int y=0, const int z=0, const int v=0) const
CImg< charT >	value_string (const char separator=',', const unsigned int max_size=0) const
	Return a C-string containing the values of all images in the instance list. More...
static const char *	pixel_type ()
	Return a string describing the type of the image pixels in the list (template parameter T). More...

Data Input
CImgList< T > &	load (const char *const filename)
	Load an image list from a file. More...
CImgList< T > &	load_cimg (const char *const filename)
	Load an image list from a .cimg file. More...
CImgList< T > &	load_cimg (std::FILE *const file)
	Load an image list from a .cimg file. More...
CImgList< T > &	_load_cimg (std::FILE *const file, const char *const filename)
CImgList< T > &	load_cimg (const char *const filename, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
	Load a sub-image list from a non compressed .cimg file. More...
CImgList< T > &	load_cimg (std::FILE *const file, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
	Load a sub-image list from a non compressed .cimg file. More...
CImgList< T > &	_load_cimg (std::FILE *const file, const char *const filename, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
CImgList< T > &	load_parrec (const char *const filename)
	Load an image list from a PAR/REC (Philips) file. More...
CImgList< T > &	load_yuv (const char *const filename, const unsigned int sizex, const unsigned int sizey, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true)
	Load an image sequence from a YUV file. More...
CImgList< T > &	load_yuv (std::FILE *const file, const unsigned int sizex, const unsigned int sizey, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true)
	Load an image sequence from a YUV file. More...
CImgList< T > &	_load_yuv (std::FILE *const file, const char *const filename, const unsigned int sizex, const unsigned int sizey, const unsigned int first_frame, const unsigned int last_frame, const unsigned int step_frame, const bool yuv2rgb)
CImgList< T > &	load_ffmpeg (const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool pixel_format=true, const bool resume=false)
	Load an image from a video file, using ffmpeg libraries. More...
CImgList< T > &	load_ffmpeg_external (const char *const filename)
	Load an image from a video file (MPEG,AVI) using the external tool 'ffmpeg'. More...
CImgList< T > &	load_gzip_external (const char *const filename)
	Load a gzipped list, using external tool 'gunzip'. More...
template<typename tf , typename tc >
CImgList< T > &	load_off (const char *const filename, CImgList< tf > &primitives, CImgList< tc > &colors)
	Load a 3D object from a .OFF file. More...
CImgList< T > &	load_tiff (const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1)
	Load a TIFF file. More...
static CImgList< T >	get_load (const char *const filename)
static CImgList< T >	get_load_cimg (const char *const filename)
static CImgList< T >	get_load_cimg (std::FILE *const file)
static CImgList< T >	get_load_cimg (const char *const filename, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
static CImgList< T >	get_load_cimg (std::FILE *const file, const unsigned int n0, const unsigned int n1, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0, const unsigned int x1, const unsigned int y1, const unsigned int z1, const unsigned int v1)
static CImgList< T >	get_load_parrec (const char *const filename)
static CImgList< T >	get_load_yuv (const char *const filename, const unsigned int sizex, const unsigned int sizey=1, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true)
static CImgList< T >	get_load_yuv (std::FILE *const file, const unsigned int sizex, const unsigned int sizey=1, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool yuv2rgb=true)
static CImgList< T >	get_load_ffmpeg (const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1, const bool pixel_format=true)
static CImgList< T >	get_load_ffmpeg_external (const char *const filename)
static CImgList< T >	get_load_gzip_external (const char *const filename)
template<typename tf , typename tc >
static CImgList< T >	get_load_off (const char *const filename, CImgList< tf > &primitives, CImgList< tc > &colors)
static CImgList< T >	get_load_tiff (const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int step_frame=1)

Data Output
const CImgList< T > &	print (const char *title=0, const bool display_stats=true) const
	Print informations about the list on the standard output. More...
const CImgList< T > &	display (CImgDisplay &disp, const char axis='x', const char align='p') const
	Display the current CImgList instance in an existing CImgDisplay window (by reference). More...
const CImgList< T > &	display (CImgDisplay &disp, const bool display_info, const char axis='x', const char align='p') const
	Display the current CImgList instance in a new display window. More...
const CImgList< T > &	display (const char *const title=0, const bool display_info=true, const char axis='x', const char align='p') const
	Display the current CImgList instance in a new display window. More...
const CImgList< T > &	save (const char *const filename, const int number=-1) const
	Save an image list into a file. More...
const CImgList< T > &	save_ffmpeg (const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const unsigned int fps=25) const
	Save an image sequence, using FFMPEG library. More...
const CImgList< T > &	_save_yuv (std::FILE *const file, const char *const filename, const bool rgb2yuv) const
const CImgList< T > &	save_yuv (const char *const filename=0, const bool rgb2yuv=true) const
	Save an image sequence into a YUV file. More...
const CImgList< T > &	save_yuv (std::FILE *const file, const bool rgb2yuv=true) const
	Save an image sequence into a YUV file. More...
const CImgList< T > &	_save_cimg (std::FILE *const file, const char *const filename, const bool compression) const
	Save an image list into a .cimg file. More...
const CImgList< T > &	save_cimg (std::FILE *file, const bool compress=false) const
	Save an image list into a CImg file (RAW binary file + simple header) More...
const CImgList< T > &	save_cimg (const char *const filename, const bool compress=false) const
	Save an image list into a CImg file (RAW binary file + simple header) More...
const CImgList< T > &	_save_cimg (std::FILE *const file, const char *const filename, const unsigned int n0, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0) const
const CImgList< T > &	save_cimg (const char *const filename, const unsigned int n0, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0) const
	Insert the instance image into into an existing .cimg file, at specified coordinates. More...
const CImgList< T > &	save_cimg (std::FILE *const file, const unsigned int n0, const unsigned int x0, const unsigned int y0, const unsigned int z0, const unsigned int v0) const
	Insert the instance image into into an existing .cimg file, at specified coordinates. More...
const CImgList< T > &	save_gzip_external (const char *const filename) const
	Save a file in TIFF format. More...
const CImgList< T > &	save_ffmpeg_external (const char *const filename, const unsigned int first_frame=0, const unsigned int last_frame=~0U, const char *const codec="mpeg2video") const
	Save an image sequence using the external tool 'ffmpeg'. More...
static void	_save_empty_cimg (std::FILE *const file, const char *const filename, const unsigned int nb, const unsigned int dx, const unsigned int dy, const unsigned int dz, const unsigned int dv)
static void	save_empty_cimg (const char *const filename, const unsigned int nb, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
	Create an empty .cimg file with specified dimensions. More...
static void	save_empty_cimg (std::FILE *const file, const unsigned int nb, const unsigned int dx, const unsigned int dy=1, const unsigned int dz=1, const unsigned int dv=1)
	Create an empty .cimg file with specified dimensions. More...

Others
CImgList< T > &	crop_font ()
	Create an auto-cropped font (along the X axis) from a input font font. More...
CImgList< T >	get_crop_font () const
CImgList< T > &	FFT (const char axis, const bool invert=false)
	Compute a 1-D Fast Fourier Transform, along specified axis. More...
CImgList< Tfloat >	get_FFT (const char axis, const bool invert=false) const
CImgList< T > &	FFT (const bool invert=false)
	Compute a N-D Fast Fourier Transform. More...
CImgList< Tfloat >	get_FFT (const bool invert=false) const
CImgList< T > &	reverse_object3d ()
	Invert primitives orientation of a 3D object. More...
CImgList< T >	get_reverse_object3d () const
static CImgList< T >	font (const unsigned int font_width, const bool variable_size=true)
	Return a CImg pre-defined font with desired size. More...
static CImgList< T >	_font (const unsigned int *const font, const unsigned int w, const unsigned int h, const unsigned int paddingx, const unsigned int paddingy, const bool variable_size=true)

Detailed Description

template<typename T = float>
struct cimg_library::CImgList< T >

Class representing list of images CImg<T>.

Definition at line 1906 of file CImg.h.

Member Typedef Documentation

typedef cimg::last<T,bool>::type boolT

Definition at line 33912 of file CImg.h.

typedef cimg::last<T,char>::type charT

Definition at line 33914 of file CImg.h.

typedef const CImg<T>* const_iterator

Define a CImgList<T>::const_iterator.

Definition at line 33895 of file CImg.h.

typedef cimg::last<T,double>::type doubleT

Definition at line 33922 of file CImg.h.

typedef cimg::last<T,float>::type floatT

Definition at line 33921 of file CImg.h.

typedef cimg::last<T,int>::type intT

Definition at line 33918 of file CImg.h.

typedef CImg<T>* iterator

Define a CImgList<T>::iterator.

Definition at line 33892 of file CImg.h.

typedef cimg::last<T,long>::type longT

Definition at line 33920 of file CImg.h.

typedef cimg::last<T,short>::type shortT

Definition at line 33916 of file CImg.h.

typedef cimg::superset<T,bool>::type Tbool

Definition at line 33901 of file CImg.h.

typedef cimg::superset<T,char>::type Tchar

Definition at line 33903 of file CImg.h.

typedef cimg::superset<T,double>::type Tdouble

Definition at line 33911 of file CImg.h.

typedef cimg::superset<T,float>::type Tfloat

Definition at line 33910 of file CImg.h.

typedef cimg::superset<T,int>::type Tint

Definition at line 33907 of file CImg.h.

typedef cimg::superset<T,long>::type Tlong

Definition at line 33909 of file CImg.h.

typedef cimg::superset<T,short>::type Tshort

Definition at line 33905 of file CImg.h.

typedef cimg::superset<T,unsigned char>::type Tuchar

Definition at line 33902 of file CImg.h.

typedef cimg::superset<T,unsigned int>::type Tuint

Definition at line 33906 of file CImg.h.

typedef cimg::superset<T,unsigned long>::type Tulong

Definition at line 33908 of file CImg.h.

typedef cimg::superset<T,unsigned short>::type Tushort

Definition at line 33904 of file CImg.h.

typedef cimg::last<T,unsigned char>::type ucharT

Definition at line 33913 of file CImg.h.

typedef cimg::last<T,unsigned int>::type uintT

Definition at line 33917 of file CImg.h.

typedef cimg::last<T,unsigned long>::type ulongT

Definition at line 33919 of file CImg.h.

typedef cimg::last<T,unsigned short>::type ushortT

Definition at line 33915 of file CImg.h.

typedef T value_type

Value type.

Definition at line 33898 of file CImg.h.

Constructor & Destructor Documentation

~CImgList ( )

inline

Destructor.

Definition at line 33966 of file CImg.h.

                {
      if (data) delete[] data;
    }

CImgList ( )

inline

Default constructor.

Definition at line 33971 of file CImg.h.

              :
      width(0),allocated_width(0),data(0) {}

CImgList ( const unsigned int  n )

inlineexplicit

Construct an image list containing n empty images.

Definition at line 33975 of file CImg.h.

                                           :width(n) {
      data = new CImg<T>[allocated_width = cimg::max(16UL,cimg::nearest_pow2(n))];
    }

CImgList ( const unsigned int  n, const unsigned int  width, const unsigned int  height = 1, const unsigned int  depth = 1, const unsigned int  dim = 1  )

inline

Construct an image list containing n images with specified size.

Definition at line 33980 of file CImg.h.

                                                                  :
      width(0),allocated_width(0),data(0) {
      assign(n);
      cimglist_apply(*this,assign)(width,height,depth,dim);
    }

CImgList ( const unsigned int  n, const unsigned int  width, const unsigned int  height, const unsigned int  depth, const unsigned int  dim, const T  val  )

inline

Construct an image list containing n images with specified size, filled with specified value.

Definition at line 33988 of file CImg.h.

                                                                           :
      width(0),allocated_width(0),data(0) {
      assign(n);
      cimglist_apply(*this,assign)(width,height,depth,dim,val);
    }

CImgList ( const unsigned int  n, const unsigned int  width, const unsigned int  height, const unsigned int  depth, const unsigned int  dim, const int  val0, const int  val1,   ...  )

inline

Construct an image list containing n images with specified size and specified pixel values (int version).

Definition at line 33996 of file CImg.h.

                                                                                                   :
      width(0),allocated_width(0),data(0) {
#define _CImgList_stdarg(t) { \
        assign(n,width,height,depth,dim); \
        const unsigned int siz = width*height*depth*dim, nsiz = siz*n; \
        T *ptrd = data->data; \
        va_list ap; \
        va_start(ap,val1); \
        for (unsigned int l = 0, s = 0, i = 0; i<nsiz; ++i) { \
          *(ptrd++) = (T)(i==0?val0:(i==1?val1:va_arg(ap,t))); \
          if ((++s)==siz) { ptrd = data[++l].data; s = 0; } \
        } \
        va_end(ap); \
      }
      _CImgList_stdarg(int);
    }

CImgList ( const unsigned int  n, const unsigned int  width, const unsigned int  height, const unsigned int  depth, const unsigned int  dim, const double  val0, const double  val1,   ...  )

inline

Construct an image list containing n images with specified size and specified pixel values (double version).

Definition at line 34015 of file CImg.h.

                                                                                                         :
      width(0),allocated_width(0),data(0) {
      _CImgList_stdarg(double);
    }

CImgList ( const unsigned int  n, const CImg< t > &  img, const bool  shared = false  )

inline

Construct a list containing n copies of the image img.

Definition at line 34023 of file CImg.h.

                                                                               :width(0),allocated_width(0),data(0) {
      assign(n);
      cimglist_apply(*this,assign)(img,shared);
    }

CImgList ( const CImg< t > &  img, const bool  shared = false  )

inlineexplicit

Construct an image list from one image.

Definition at line 34030 of file CImg.h.

                                                                  :width(0),allocated_width(0),data(0) {
      assign(1);
      data[0].assign(img,shared);
    }

CImgList ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const bool  shared = false  )

inline

Construct an image list from two images.

Definition at line 34037 of file CImg.h.

                                                                                 :width(0),allocated_width(0),data(0) {
      assign(2);
      data[0].assign(img1,shared); data[1].assign(img2,shared);
    }

CImgList ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const bool  shared = false  )

inline

Construct an image list from three images.

Definition at line 34044 of file CImg.h.

                                                                                                       :
      width(0),allocated_width(0),data(0) {
      assign(3);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared);
    }

CImgList ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const bool  shared = false  )

inline

Construct an image list from four images.

Definition at line 34052 of file CImg.h.

                                                                                                                             :
      width(0),allocated_width(0),data(0) {
      assign(4);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
    }

CImgList ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const CImg< t5 > &  img5, const bool  shared = false  )

inline

Construct an image list from five images.

Definition at line 34060 of file CImg.h.

                                                           :
      width(0),allocated_width(0),data(0) {
      assign(5);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      data[4].assign(img5,shared);
    }

CImgList ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const CImg< t5 > &  img5, const CImg< t6 > &  img6, const bool  shared = false  )

inline

Construct an image list from six images.

Definition at line 34070 of file CImg.h.

                                                                                 :
      width(0),allocated_width(0),data(0) {
      assign(6);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      data[4].assign(img5,shared); data[5].assign(img6,shared);
    }

CImgList ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const CImg< t5 > &  img5, const CImg< t6 > &  img6, const CImg< t7 > &  img7, const bool  shared = false  )

inline

Construct an image list from seven images.

Definition at line 34080 of file CImg.h.

                                                                                                       :
      width(0),allocated_width(0),data(0) {
      assign(7);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      data[4].assign(img5,shared); data[5].assign(img6,shared); data[6].assign(img7,shared);
    }

CImgList ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const CImg< t5 > &  img5, const CImg< t6 > &  img6, const CImg< t7 > &  img7, const CImg< t8 > &  img8, const bool  shared = false  )

inline

Construct an image list from eight images.

Definition at line 34090 of file CImg.h.

                                                                                                                             :
      width(0),allocated_width(0),data(0) {
      assign(8);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      data[4].assign(img5,shared); data[5].assign(img6,shared); data[6].assign(img7,shared); data[7].assign(img8,shared);
    }

CImgList ( const CImgList< t > &  list )

inline

Default copy constructor.

Definition at line 34100 of file CImg.h.

                                     :width(0),allocated_width(0),data(0) {
      assign(list.width);
      cimglist_for(*this,l) data[l].assign(list[l],false);
    }

CImgList ( const CImgList< T > &  list )

inline

Definition at line 34105 of file CImg.h.

                                     :width(0),allocated_width(0),data(0) {
      assign(list.width);
      cimglist_for(*this,l) data[l].assign(list[l],list[l].is_shared);
    }

CImgList ( const CImgList< t > &  list, const bool  shared  )

inline

Advanced copy constructor.

Definition at line 34112 of file CImg.h.

                                                        :width(0),allocated_width(0),data(0) {
      assign(list.width);
      cimglist_for(*this,l) data[l].assign(list[l],shared);
    }

CImgList ( const char *const  filename )

inlineexplicit

Construct an image list from a filename.

Definition at line 34118 of file CImg.h.

                                                 :width(0),allocated_width(0),data(0) {
      assign(filename);
    }

CImgList ( const CImgDisplay &  disp )

inlineexplicit

Construct an image list from a display.

Definition at line 34123 of file CImg.h.

                                              :width(0),allocated_width(0),data(0) {
      assign(disp);
    }

Member Function Documentation

T& _atN ( const int  pos, const int  x = 0, const int  y = 0, const int  z = 0, const int  v = 0  )

inline

Definition at line 34703 of file CImg.h.

Referenced by CImgList< uintT >::atN().

                                                                                       {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)](x,y,z,v);
    }

Here is the caller graph for this function:

T _atN ( const int  pos, const int  x = 0, const int  y = 0, const int  z = 0, const int  v = 0  ) const

inline

Definition at line 34707 of file CImg.h.

                                                                                            {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)](x,y,z,v);
    }

T& _atNX ( const int  pos, const int  x, const int  y = 0, const int  z = 0, const int  v = 0  )

inline

Definition at line 34671 of file CImg.h.

Referenced by CImgList< uintT >::atNX().

                                                                                      {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atX(x,y,z,v);
    }

Here is the caller graph for this function:

T _atNX ( const int  pos, const int  x, const int  y = 0, const int  z = 0, const int  v = 0  ) const

inline

Definition at line 34675 of file CImg.h.

                                                                                           {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atX(x,y,z,v);
    }

T& _atNXY ( const int  pos, const int  x, const int  y, const int  z = 0, const int  v = 0  )

inline

Definition at line 34639 of file CImg.h.

Referenced by CImgList< uintT >::atNXY().

                                                                                     {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXY(x,y,z,v);
    }

Here is the caller graph for this function:

T _atNXY ( const int  pos, const int  x, const int  y, const int  z = 0, const int  v = 0  ) const

inline

Definition at line 34643 of file CImg.h.

                                                                                          {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXY(x,y,z,v);
    }

T& _atNXYZ ( const int  pos, const int  x, const int  y, const int  z, const int  v = 0  )

inline

Definition at line 34607 of file CImg.h.

Referenced by CImgList< uintT >::atNXYZ().

                                                                                    {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXYZ(x,y,z,v);
    }

Here is the caller graph for this function:

T _atNXYZ ( const int  pos, const int  x, const int  y, const int  z, const int  v = 0  ) const

inline

Definition at line 34611 of file CImg.h.

                                                                                         {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXYZ(x,y,z,v);
    }

T& _atNXYZV ( const int  pos, const int  x, const int  y, const int  z, const int  v  )

inline

Definition at line 34575 of file CImg.h.

Referenced by CImgList< uintT >::atNXYZV().

                                                                                   {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXYZV(x,y,z,v);
    }

Here is the caller graph for this function:

T _atNXYZV ( const int  pos, const int  x, const int  y, const int  z, const int  v  ) const

inline

Definition at line 34579 of file CImg.h.

                                                                                        {
      return data[pos<0?0:(pos>=(int)width?(int)width-1:pos)].atXYZV(x,y,z,v);
    }

static CImgList<T> _font ( const unsigned int *const  font, const unsigned int  w, const unsigned int  h, const unsigned int  paddingx, const unsigned int  paddingy, const bool  variable_size = true  )

inlinestatic

Definition at line 37097 of file CImg.h.

Referenced by CImgList< uintT >::font().

                                                                                                                      {
      CImgList<T> res = CImgList<T>(256,w,h,1,3);
      res.insert(256); cimglist_for_in(res,256,511,l) res[l].assign(w,h,1,1);
      const unsigned int *ptr = font;
      unsigned int m = 0, val = 0;
      for (unsigned int y = 0; y<h; ++y)
        for (unsigned int x = 0; x<256*w; ++x) {
          m>>=1; if (!m) { m = 0x80000000; val = *(ptr++); }
          CImg<T>& img = res[x/w], &mask = res[x/w+256];
          unsigned int xm = x%w;
          img(xm,y,0) = img(xm,y,1) = img(xm,y,2) = mask(xm,y,0) = (T)((val&m)?1:0);
        }
      if (variable_size) res.crop_font();
      if (paddingx || paddingy) cimglist_for(res,l) res[l].resize(res[l].dimx() + paddingx,res[l].dimy() + paddingy,1,-100,0);
      return res;
    }

Here is the caller graph for this function:

CImgList<T>& _load_cimg ( std::FILE *const  file, const char *const  filename  )

inline

Definition at line 35550 of file CImg.h.

Referenced by CImgList< uintT >::load_cimg().

                                                                             {
#ifdef cimg_use_zlib
#define _cimgz_load_cimg_case(Tss) { \
   Bytef *const cbuf = new Bytef[csiz]; \
   cimg::fread(cbuf,csiz,nfile); \
   raw.assign(W,H,D,V); \
   unsigned long destlen = (unsigned long)raw.size()*sizeof(T); \
   uncompress((Bytef*)raw.data,&destlen,cbuf,csiz); \
   delete[] cbuf; \
   const Tss *ptrs = raw.data; \
   for (unsigned int off = raw.size(); off; --off) *(ptrd++) = (T)*(ptrs++); \
}
#else
#define _cimgz_load_cimg_case(Tss) \
   throw CImgIOException("CImgList<%s>::load_cimg() : File '%s' contains compressed data, zlib must be used",\
                         pixel_type(),filename?filename:"(FILE*)");
#endif

#define _cimg_load_cimg_case(Ts,Tss) \
      if (!loaded && !cimg::strcasecmp(Ts,str_pixeltype)) { \
        for (unsigned int l = 0; l<N; ++l) { \
          j = 0; while ((i=std::fgetc(nfile))!='\n' && i>=0) tmp[j++] = (char)i; tmp[j] = 0; \
          W = H = D = V = 0; csiz = 0; \
          if ((err = std::sscanf(tmp,"%u %u %u %u #%u",&W,&H,&D,&V,&csiz))<4) \
            throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', Image %u has an invalid size (%u,%u,%u,%u)\n", \
                                  pixel_type(),filename?filename:("(FILE*)"),W,H,D,V); \
          if (W*H*D*V>0) { \
            CImg<Tss> raw; \
            CImg<T> &img = data[l]; \
            img.assign(W,H,D,V); \
            T *ptrd = img.data; \
            if (err==5) _cimgz_load_cimg_case(Tss) \
            else for (int toread = (int)img.size(); toread>0; ) { \
              raw.assign(cimg::min(toread,cimg_iobuffer)); \
              cimg::fread(raw.data,raw.width,nfile); \
              if (endian!=cimg::endianness()) cimg::invert_endianness(raw.data,raw.width); \
              toread-=raw.width; \
              const Tss *ptrs = raw.data; \
              for (unsigned int off = raw.width; off; --off) *(ptrd++) = (T)*(ptrs++); \
            } \
          } \
        } \
        loaded = true; \
      }

      if (!filename && !file)
        throw CImgArgumentException("CImgList<%s>::load_cimg() : Cannot load (null) filename.",
                                    pixel_type());
      typedef unsigned char uchar;
      typedef unsigned short ushort;
      typedef unsigned int uint;
      typedef unsigned long ulong;
      const int cimg_iobuffer = 12*1024*1024;
      std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");
      bool loaded = false, endian = cimg::endianness();
      char tmp[256] = { 0 }, str_pixeltype[256] = { 0 }, str_endian[256] = { 0 };
      unsigned int j, err, N = 0, W, H, D, V, csiz;
      int i;
      j = 0; while((i=std::fgetc(nfile))!='\n' && i!=EOF && j<256) tmp[j++] = (char)i; tmp[j] = 0;
      err = std::sscanf(tmp,"%u%*c%255[A-Za-z_]%*c%255[sA-Za-z_ ]",&N,str_pixeltype,str_endian);
      if (err<2) {
        if (!file) cimg::fclose(nfile);
        throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', Unknow CImg RAW header.",
                              pixel_type(),filename?filename:"(FILE*)");
      }
      if (!cimg::strncasecmp("little",str_endian,6)) endian = false;
      else if (!cimg::strncasecmp("big",str_endian,3)) endian = true;
      assign(N);
      _cimg_load_cimg_case("bool",bool);
      _cimg_load_cimg_case("unsigned_char",uchar);
      _cimg_load_cimg_case("uchar",uchar);
      _cimg_load_cimg_case("char",char);
      _cimg_load_cimg_case("unsigned_short",ushort);
      _cimg_load_cimg_case("ushort",ushort);
      _cimg_load_cimg_case("short",short);
      _cimg_load_cimg_case("unsigned_int",uint);
      _cimg_load_cimg_case("uint",uint);
      _cimg_load_cimg_case("int",int);
      _cimg_load_cimg_case("unsigned_long",ulong);
      _cimg_load_cimg_case("ulong",ulong);
      _cimg_load_cimg_case("long",long);
      _cimg_load_cimg_case("float",float);
      _cimg_load_cimg_case("double",double);
      if (!loaded) {
        if (!file) cimg::fclose(nfile);
        throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', cannot read images of pixels coded as '%s'.",
                              pixel_type(),filename?filename:"(FILE*)",str_pixeltype);
      }
      if (!file) cimg::fclose(nfile);
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& _load_cimg ( std::FILE *const  file, const char *const  filename, const unsigned int  n0, const unsigned int  n1, const unsigned int  x0, const unsigned int  y0, const unsigned int  z0, const unsigned int  v0, const unsigned int  x1, const unsigned int  y1, const unsigned int  z1, const unsigned int  v1  )

inline

Definition at line 35672 of file CImg.h.

                                                                                                                        {
#define _cimg_load_cimg_case2(Ts,Tss) \
      if (!loaded && !cimg::strcasecmp(Ts,str_pixeltype)) { \
        for (unsigned int l = 0; l<=nn1; ++l) { \
          j = 0; while ((i=std::fgetc(nfile))!='\n' && i>=0) tmp[j++] = (char)i; tmp[j] = 0; \
          W = H = D = V = 0; \
          if (std::sscanf(tmp,"%u %u %u %u",&W,&H,&D,&V)!=4) \
            throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', Image %u has an invalid size (%u,%u,%u,%u)\n", \
                                  pixel_type(), filename?filename:("(FILE*)"), W, H, D, V); \
          if (W*H*D*V>0) { \
            if (l<n0 || x0>=W || y0>=H || z0>=D || v0>=D) std::fseek(nfile,W*H*D*V*sizeof(Tss),SEEK_CUR); \
            else { \
              const unsigned int \
                nx1 = x1>=W?W-1:x1, \
                ny1 = y1>=H?H-1:y1, \
                nz1 = z1>=D?D-1:z1, \
                nv1 = v1>=V?V-1:v1; \
              CImg<Tss> raw(1 + nx1 - x0); \
              CImg<T> &img = data[l - n0]; \
              img.assign(1 + nx1 - x0,1 + ny1 - y0,1 + nz1 - z0,1 + nv1 - v0); \
              T *ptrd = img.data; \
              const unsigned int skipvb = v0*W*H*D*sizeof(Tss); \
              if (skipvb) std::fseek(nfile,skipvb,SEEK_CUR); \
              for (unsigned int v = 1 + nv1 - v0; v; --v) { \
                const unsigned int skipzb = z0*W*H*sizeof(Tss); \
                if (skipzb) std::fseek(nfile,skipzb,SEEK_CUR); \
                for (unsigned int z = 1 + nz1 - z0; z; --z) { \
                  const unsigned int skipyb = y0*W*sizeof(Tss); \
                  if (skipyb) std::fseek(nfile,skipyb,SEEK_CUR); \
                  for (unsigned int y = 1 + ny1 - y0; y; --y) { \
                    const unsigned int skipxb = x0*sizeof(Tss); \
                    if (skipxb) std::fseek(nfile,skipxb,SEEK_CUR); \
                    cimg::fread(raw.data,raw.width,nfile); \
                    if (endian!=cimg::endianness()) cimg::invert_endianness(raw.data,raw.width); \
                    const Tss *ptrs = raw.data; \
                    for (unsigned int off = raw.width; off; --off) *(ptrd++) = (T)*(ptrs++); \
                    const unsigned int skipxe = (W-1-nx1)*sizeof(Tss); \
                    if (skipxe) std::fseek(nfile,skipxe,SEEK_CUR); \
                  } \
                  const unsigned int skipye = (H-1-ny1)*W*sizeof(Tss); \
                  if (skipye) std::fseek(nfile,skipye,SEEK_CUR); \
                } \
                const unsigned int skipze = (D-1-nz1)*W*H*sizeof(Tss); \
                if (skipze) std::fseek(nfile,skipze,SEEK_CUR); \
              } \
              const unsigned int skipve = (V-1-nv1)*W*H*D*sizeof(Tss); \
              if (skipve) std::fseek(nfile,skipve,SEEK_CUR); \
            } \
          } \
        } \
        loaded = true; \
      }

      if (!filename && !file)
        throw CImgArgumentException("CImgList<%s>::load_cimg() : Cannot load (null) filename.",
                                    pixel_type());
      typedef unsigned char uchar;
      typedef unsigned short ushort;
      typedef unsigned int uint;
      typedef unsigned long ulong;
      if (n1<n0 || x1<x0 || y1<y0 || z1<z0 || v1<v0)
        throw CImgArgumentException("CImgList<%s>::load_cimg() : File '%s', Bad sub-region coordinates [%u->%u] "
                                    "(%u,%u,%u,%u)->(%u,%u,%u,%u).",
                                    pixel_type(),filename?filename:"(FILE*)",
                                    n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);
      std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");
      bool loaded = false, endian = cimg::endianness();
      char tmp[256] = { 0 }, str_pixeltype[256] = { 0 }, str_endian[256] = { 0 };
      unsigned int j, err, N, W, H, D, V;
      int i;
      j = 0; while((i=std::fgetc(nfile))!='\n' && i!=EOF && j<256) tmp[j++] = (char)i; tmp[j] = 0;
      err = std::sscanf(tmp,"%u%*c%255[A-Za-z_]%*c%255[sA-Za-z_ ]",&N,str_pixeltype,str_endian);
      if (err<2) {
        if (!file) cimg::fclose(nfile);
        throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', Unknow CImg RAW header.",
                              pixel_type(),filename?filename:"(FILE*)");
      }
      if (!cimg::strncasecmp("little",str_endian,6)) endian = false;
      else if (!cimg::strncasecmp("big",str_endian,3)) endian = true;
      const unsigned int nn1 = n1>=N?N-1:n1;
      assign(1+nn1-n0);
      _cimg_load_cimg_case2("bool",bool);
      _cimg_load_cimg_case2("unsigned_char",uchar);
      _cimg_load_cimg_case2("uchar",uchar);
      _cimg_load_cimg_case2("char",char);
      _cimg_load_cimg_case2("unsigned_short",ushort);
      _cimg_load_cimg_case2("ushort",ushort);
      _cimg_load_cimg_case2("short",short);
      _cimg_load_cimg_case2("unsigned_int",uint);
      _cimg_load_cimg_case2("uint",uint);
      _cimg_load_cimg_case2("int",int);
      _cimg_load_cimg_case2("unsigned_long",ulong);
      _cimg_load_cimg_case2("ulong",ulong);
      _cimg_load_cimg_case2("long",long);
      _cimg_load_cimg_case2("float",float);
      _cimg_load_cimg_case2("double",double);
      if (!loaded) {
        if (!file) cimg::fclose(nfile);
        throw CImgIOException("CImgList<%s>::load_cimg() : File '%s', cannot read images of pixels coded as '%s'.",
                              pixel_type(),filename?filename:"(FILE*)",str_pixeltype);
      }
      if (!file) cimg::fclose(nfile);
      return *this;
    }

CImgList<T>& _load_yuv ( std::FILE *const  file, const char *const  filename, const unsigned int  sizex, const unsigned int  sizey, const unsigned int  first_frame, const unsigned int  last_frame, const unsigned int  step_frame, const bool  yuv2rgb  )

inline

Definition at line 35904 of file CImg.h.

Referenced by CImgList< uintT >::load_yuv().

                                                                              {
      if (!filename && !file)
        throw CImgArgumentException("CImgList<%s>::load_yuv() : Cannot load (null) filename.",
                                    pixel_type());
      if (sizex%2 || sizey%2)
        throw CImgArgumentException("CImgList<%s>::load_yuv() : File '%s', image dimensions along X and Y must be "
                                    "even numbers (given are %ux%u)\n",
                                    pixel_type(),filename?filename:"(FILE*)",sizex,sizey);
      if (!sizex || !sizey)
        throw CImgArgumentException("CImgList<%s>::load_yuv() : File '%s', given image sequence size (%u,%u) is invalid",
                                    pixel_type(),filename?filename:"(FILE*)",sizex,sizey);

      const unsigned int
        nfirst_frame = first_frame<last_frame?first_frame:last_frame,
        nlast_frame = first_frame<last_frame?last_frame:first_frame,
        nstep_frame = step_frame?step_frame:1;

      CImg<ucharT> tmp(sizex,sizey,1,3), UV(sizex/2,sizey/2,1,2);
      std::FILE *const nfile = file?file:cimg::fopen(filename,"rb");
      bool stopflag = false;
      int err;
      if (nfirst_frame) {
        err = std::fseek(nfile,nfirst_frame*(sizex*sizey + sizex*sizey/2),SEEK_CUR);
        if (err) {
          if (!file) cimg::fclose(nfile);
          throw CImgIOException("CImgList<%s>::load_yuv() : File '%s' doesn't contain frame number %u "
                                "(out of range error).",
                                pixel_type(),filename?filename:"(FILE*)",nfirst_frame);
        }
      }
      unsigned int frame;
      for (frame = nfirst_frame; !stopflag && frame<=nlast_frame; frame+=nstep_frame) {
        tmp.fill(0);
        // *TRY* to read the luminance part, do not replace by cimg::fread !
        err = (int)std::fread((void*)(tmp.data),1,(size_t)(tmp.width*tmp.height),nfile);
        if (err!=(int)(tmp.width*tmp.height)) {
          stopflag = true;
          if (err>0)
            cimg::warn("CImgList<%s>::load_yuv() : File '%s' contains incomplete data,"
                       " or given image dimensions (%u,%u) are incorrect.",
                       pixel_type(),filename?filename:"(FILE*)",sizex,sizey);
        } else {
          UV.fill(0);
          // *TRY* to read the luminance part, do not replace by cimg::fread !
          err = (int)std::fread((void*)(UV.data),1,(size_t)(UV.size()),nfile);
          if (err!=(int)(UV.size())) {
            stopflag = true;
            if (err>0)
              cimg::warn("CImgList<%s>::load_yuv() : File '%s' contains incomplete data,"
                         " or given image dimensions (%u,%u) are incorrect.",
                         pixel_type(),filename?filename:"(FILE*)",sizex,sizey);
          } else {
            cimg_forXY(UV,x,y) {
              const int x2 = x*2, y2 = y*2;
              tmp(x2,y2,1) = tmp(x2+1,y2,1) = tmp(x2,y2+1,1) = tmp(x2+1,y2+1,1) = UV(x,y,0);
              tmp(x2,y2,2) = tmp(x2+1,y2,2) = tmp(x2,y2+1,2) = tmp(x2+1,y2+1,2) = UV(x,y,1);
            }
            if (yuv2rgb) tmp.YCbCrtoRGB();
            insert(tmp);
            if (nstep_frame>1) std::fseek(nfile,(nstep_frame-1)*(sizex*sizey + sizex*sizey/2),SEEK_CUR);
          }
        }
      }
      if (stopflag && nlast_frame!=~0U && frame!=nlast_frame)
        cimg::warn("CImgList<%s>::load_yuv() : File '%s', frame %d not reached since only %u frames were found in the file.",
                   pixel_type(),filename?filename:"(FILE*)",nlast_frame,frame-1,filename);
      if (!file) cimg::fclose(nfile);
      return *this;
    }

Here is the caller graph for this function:

const CImgList<T>& _save_cimg ( std::FILE *const  file, const char *const  filename, const bool  compression  ) const

inline

Save an image list into a .cimg file.

A CImg RAW file is a simple uncompressed binary file that may be used to save list of CImg<T> images.

Parameters

filename

: name of the output file.

Returns

A reference to the current CImgList instance is returned.

Definition at line 36700 of file CImg.h.

Referenced by CImgList< uintT >::save_cimg().

                                                                                                                 {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::save_cimg() : File '%s', instance list (%u,%p) is empty.",
                                    pixel_type(),filename?filename:"(FILE*)",width,data);
      if (!file && !filename)
        throw CImgArgumentException("CImg<%s>::save_cimg() : Instance list (%u,%p), specified file is (null).",
                                    pixel_type(),width,data);
      std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");
      const char *const ptype = pixel_type(), *const etype = cimg::endianness()?"big":"little";
      if (std::strstr(ptype,"unsigned")==ptype) std::fprintf(nfile,"%u unsigned_%s %s_endian\n",width,ptype+9,etype);
      else std::fprintf(nfile,"%u %s %s_endian\n",width,ptype,etype);
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        std::fprintf(nfile,"%u %u %u %u",img.width,img.height,img.depth,img.dim);
        if (img.data) {
          CImg<T> tmp;
          if (cimg::endianness()) { tmp = img; cimg::invert_endianness(tmp.data,tmp.size()); }
          const CImg<T>& ref = cimg::endianness()?tmp:img;
          bool compressed = false;
          if (compression) {
#ifdef cimg_use_zlib
            const unsigned long siz = sizeof(T)*ref.size();
            unsigned long csiz = siz + siz/100 + 16;
            Bytef *const cbuf = new Bytef[csiz];
            if (compress(cbuf,&csiz,(Bytef*)ref.data,siz)) {
              cimg::warn("CImgList<%s>::save_cimg() : File '%s', failed to save compressed data.\n Data will be saved uncompressed.",
                       pixel_type(),filename?filename:"(FILE*)");
              compressed = false;
            } else {
              std::fprintf(nfile," #%lu\n",csiz);
              cimg::fwrite(cbuf,csiz,nfile);
              delete[] cbuf;
              compressed = true;
            }
#else
            cimg::warn("CImgList<%s>::save_cimg() : File '%s', cannot save compressed data unless zlib is used "
                       "('cimg_use_zlib' must be defined).\n Data will be saved uncompressed.",
                       pixel_type(),filename?filename:"(FILE*)");
            compressed = false;
#endif
          }
          if (!compressed) {
            std::fputc('\n',nfile);
            cimg::fwrite(ref.data,ref.size(),nfile);
          }
        } else std::fputc('\n',nfile);
      }
      if (!file) cimg::fclose(nfile);
      return *this;
    }

Here is the caller graph for this function:

const CImgList<T>& _save_cimg ( std::FILE *const  file, const char *const  filename, const unsigned int  n0, const unsigned int  x0, const unsigned int  y0, const unsigned int  z0, const unsigned int  v0  ) const

inline

Definition at line 36762 of file CImg.h.

                                                                                     {
#define _cimg_save_cimg_case(Ts,Tss) \
      if (!saved && !cimg::strcasecmp(Ts,str_pixeltype)) { \
        for (unsigned int l = 0; l<lmax; ++l) { \
          j = 0; while((i=std::fgetc(nfile))!='\n') tmp[j++]=(char)i; tmp[j] = 0; \
          W = H = D = V = 0; \
          if (std::sscanf(tmp,"%u %u %u %u",&W,&H,&D,&V)!=4) \
            throw CImgIOException("CImgList<%s>::save_cimg() : File '%s', Image %u has an invalid size (%u,%u,%u,%u)\n", \
                                  pixel_type(), filename?filename:("(FILE*)"), W, H, D, V); \
          if (W*H*D*V>0) { \
            if (l<n0 || x0>=W || y0>=H || z0>=D || v0>=D) std::fseek(nfile,W*H*D*V*sizeof(Tss),SEEK_CUR); \
            else { \
              const CImg<T>& img = (*this)[l - n0]; \
              const T *ptrs = img.data; \
              const unsigned int \
                x1 = x0 + img.width - 1, \
                y1 = y0 + img.height - 1, \
                z1 = z0 + img.depth - 1, \
                v1 = v0 + img.dim - 1, \
                nx1 = x1>=W?W-1:x1, \
                ny1 = y1>=H?H-1:y1, \
                nz1 = z1>=D?D-1:z1, \
                nv1 = v1>=V?V-1:v1; \
              CImg<Tss> raw(1+nx1-x0); \
              const unsigned int skipvb = v0*W*H*D*sizeof(Tss); \
              if (skipvb) std::fseek(nfile,skipvb,SEEK_CUR); \
              for (unsigned int v = 1 + nv1 - v0; v; --v) { \
                const unsigned int skipzb = z0*W*H*sizeof(Tss); \
                if (skipzb) std::fseek(nfile,skipzb,SEEK_CUR); \
                for (unsigned int z = 1 + nz1 - z0; z; --z) { \
                  const unsigned int skipyb = y0*W*sizeof(Tss); \
                  if (skipyb) std::fseek(nfile,skipyb,SEEK_CUR); \
                  for (unsigned int y = 1 + ny1 - y0; y; --y) { \
                    const unsigned int skipxb = x0*sizeof(Tss); \
                    if (skipxb) std::fseek(nfile,skipxb,SEEK_CUR); \
                    raw.assign(ptrs, raw.width); \
                    ptrs+=img.width; \
                    if (endian) cimg::invert_endianness(raw.data,raw.width); \
                    cimg::fwrite(raw.data,raw.width,nfile); \
                    const unsigned int skipxe = (W - 1 - nx1)*sizeof(Tss); \
                    if (skipxe) std::fseek(nfile,skipxe,SEEK_CUR); \
                  } \
                  const unsigned int skipye = (H - 1 - ny1)*W*sizeof(Tss); \
                  if (skipye) std::fseek(nfile,skipye,SEEK_CUR); \
                } \
                const unsigned int skipze = (D - 1 - nz1)*W*H*sizeof(Tss); \
                if (skipze) std::fseek(nfile,skipze,SEEK_CUR); \
              } \
              const unsigned int skipve = (V - 1 - nv1)*W*H*D*sizeof(Tss); \
              if (skipve) std::fseek(nfile,skipve,SEEK_CUR); \
            } \
          } \
        } \
        saved = true; \
      }
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::save_cimg() : File '%s', instance list (%u,%p) is empty.",
                                    pixel_type(),filename?filename:"(FILE*)",width,data);
      if (!file && !filename)
        throw CImgArgumentException("CImg<%s>::save_cimg() : Instance list (%u,%p), specified file is (null).",
                                    pixel_type(),width,data);
      typedef unsigned char uchar;
      typedef unsigned short ushort;
      typedef unsigned int uint;
      typedef unsigned long ulong;
      std::FILE *const nfile = file?file:cimg::fopen(filename,"rb+");
      bool saved = false, endian = cimg::endianness();
      char tmp[256] = { 0 }, str_pixeltype[256] = { 0 }, str_endian[256] = { 0 };
      unsigned int j, err, N, W, H, D, V;
      int i;
      j = 0; while((i=std::fgetc(nfile))!='\n' && i!=EOF && j<256) tmp[j++] = (char)i; tmp[j] = 0;
      err = std::sscanf(tmp,"%u%*c%255[A-Za-z_]%*c%255[sA-Za-z_ ]",&N,str_pixeltype,str_endian);
      if (err<2) {
        if (!file) cimg::fclose(nfile);
        throw CImgIOException("CImgList<%s>::save_cimg() : File '%s', Unknow CImg RAW header.",
                              pixel_type(),filename?filename:"(FILE*)");
      }
      if (!cimg::strncasecmp("little",str_endian,6)) endian = false;
      else if (!cimg::strncasecmp("big",str_endian,3)) endian = true;
      const unsigned int lmax = cimg::min(N,n0+width);
      _cimg_save_cimg_case("bool",bool);
      _cimg_save_cimg_case("unsigned_char",uchar);
      _cimg_save_cimg_case("uchar",uchar);
      _cimg_save_cimg_case("char",char);
      _cimg_save_cimg_case("unsigned_short",ushort);
      _cimg_save_cimg_case("ushort",ushort);
      _cimg_save_cimg_case("short",short);
      _cimg_save_cimg_case("unsigned_int",uint);
      _cimg_save_cimg_case("uint",uint);
      _cimg_save_cimg_case("int",int);
      _cimg_save_cimg_case("unsigned_long",ulong);
      _cimg_save_cimg_case("ulong",ulong);
      _cimg_save_cimg_case("long",long);
      _cimg_save_cimg_case("float",float);
      _cimg_save_cimg_case("double",double);
      if (!saved) {
        if (!file) cimg::fclose(nfile);
        throw CImgIOException("CImgList<%s>::save_cimg() : File '%s', cannot save images of pixels coded as '%s'.",
                              pixel_type(),filename?filename:"(FILE*)",str_pixeltype);
      }
      if (!file) cimg::fclose(nfile);
      return *this;
    }

static void _save_empty_cimg ( std::FILE *const  file, const char *const  filename, const unsigned int  nb, const unsigned int  dx, const unsigned int  dy, const unsigned int  dz, const unsigned int  dv  )

inlinestatic

Definition at line 36886 of file CImg.h.

Referenced by CImgList< uintT >::save_empty_cimg().

                                                                              {
      std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");
      const unsigned int siz = dx*dy*dz*dv*sizeof(T);
      std::fprintf(nfile,"%u %s\n",nb,pixel_type());
      for (unsigned int i=nb; i; --i) {
        std::fprintf(nfile,"%u %u %u %u\n",dx,dy,dz,dv);
        for (unsigned int off=siz; off; --off) std::fputc(0,nfile);
      }
      if (!file) cimg::fclose(nfile);
    }

Here is the caller graph for this function:

const CImgList<T>& _save_yuv ( std::FILE *const  file, const char *const  filename, const bool  rgb2yuv  ) const

inline

Definition at line 36661 of file CImg.h.

Referenced by CImgList< uintT >::save_yuv().

                                                                                                            {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::save_yuv() : File '%s', instance list (%u,%p) is empty.",
                                    pixel_type(),filename?filename:"(FILE*)",width,data);
      if (!file && !filename)
        throw CImgArgumentException("CImg<%s>::save_yuv() : Instance list (%u,%p), specified file is (null).",
                                    pixel_type(),width,data);
      if ((*this)[0].dimx()%2 || (*this)[0].dimy()%2)
        throw CImgInstanceException("CImgList<%s>::save_yuv() : File '%s', image dimensions must be even numbers (current are %ux%u).",
                                    pixel_type(),filename?filename:"(FILE*)",(*this)[0].dimx(),(*this)[0].dimy());

      std::FILE *const nfile = file?file:cimg::fopen(filename,"wb");
      cimglist_for(*this,l) {
        CImg<ucharT> YCbCr((*this)[l]);
        if (rgb2yuv) YCbCr.RGBtoYCbCr();
        cimg::fwrite(YCbCr.data,YCbCr.width*YCbCr.height,nfile);
        cimg::fwrite(YCbCr.get_resize(YCbCr.width/2, YCbCr.height/2,1,3,3).ptr(0,0,0,1),
                     YCbCr.width*YCbCr.height/2,nfile);
      }
      if (!file) cimg::fclose(nfile);
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& assign ( )

inline

In-place version of the default constructor and default destructor.

Definition at line 34151 of file CImg.h.

Referenced by CImg< uintT >::_display_object3d(), CImgList< uintT >::_load_cimg(), CImg< uintT >::_load_off(), CImg< uintT >::append_object3d(), CImgList< uintT >::assign(), CImg< uintT >::box3d(), CImgList< uintT >::CImgList(), CImgList< uintT >::clear(), CImg< uintT >::cone3d(), CImg< uintT >::cylinder3d(), CImg< uintT >::elevation3d(), CImg< uintT >::ellipsoid3d(), CImg< uintT >::get_elevation3d(), CImg< uintT >::get_gradient(), CImg< uintT >::get_hessian(), CImg< uintT >::get_isocurve3d(), CImg< uintT >::get_isosurface3d(), CImg< uintT >::get_split(), CImg< uintT >::isocurve3d(), CImg< uintT >::isosurface3d(), CImgList< uintT >::load(), CImgList< uintT >::load_ffmpeg(), CImgList< uintT >::load_ffmpeg_external(), CImgList< uintT >::load_tiff(), CImgList< uintT >::operator=(), CImg< uintT >::plane3d(), CImgList< uintT >::remove(), CImg< uintT >::sphere3d(), CImg< uintT >::torus3d(), and CImgList< uintT >::transfer_to().

                          {
      if (data) delete[] data;
      width = allocated_width = 0;
      data = 0;
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& assign ( const unsigned int  n )

inline

In-place version of the corresponding constructor.

Definition at line 34159 of file CImg.h.

                                              {
      if (n) {
        if (allocated_width<n || allocated_width>(n<<2)) {
          if (data) delete[] data;
          data = new CImg<T>[allocated_width=cimg::max(16UL,cimg::nearest_pow2(n))];
        }
        width = n;
      } else assign();
      return *this;
    }

CImgList<T>& assign ( const unsigned int  n, const unsigned int  width, const unsigned int  height = 1, const unsigned int  depth = 1, const unsigned int  dim = 1  )

inline

In-place version of the corresponding constructor.

Definition at line 34171 of file CImg.h.

                                                                              {
      assign(n);
      cimglist_apply(*this,assign)(width,height,depth,dim);
      return *this;
    }

CImgList<T>& assign ( const unsigned int  n, const unsigned int  width, const unsigned int  height, const unsigned int  depth, const unsigned int  dim, const T  val  )

inline

In-place version of the corresponding constructor.

Definition at line 34179 of file CImg.h.

                                                                                       {
      assign(n);
      cimglist_apply(*this,assign)(width,height,depth,dim,val);
      return *this;
    }

CImgList<T>& assign ( const unsigned int  n, const unsigned int  width, const unsigned int  height, const unsigned int  depth, const unsigned int  dim, const int  val0, const int  val1,   ...  )

inline

In-place version of the corresponding constructor.

Definition at line 34187 of file CImg.h.

                                                                                                               {
      _CImgList_stdarg(int);
      return *this;
    }

CImgList<T>& assign ( const unsigned int  n, const unsigned int  width, const unsigned int  height, const unsigned int  depth, const unsigned int  dim, const double  val0, const double  val1,   ...  )

inline

In-place version of the corresponding constructor.

Definition at line 34194 of file CImg.h.

                                                                                                                     {
      _CImgList_stdarg(double);
      return *this;
    }

CImgList<T>& assign ( const CImgList< t > &  list, const bool  shared = false  )

inline

In-place version of the copy constructor.

Definition at line 34202 of file CImg.h.

                                                                          {
      assign(list.width);
      cimglist_for(*this,l) data[l].assign(list[l],shared);
      return *this;
    }

CImgList<T>& assign ( const unsigned int  n, const CImg< t > &  img, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34210 of file CImg.h.

                                                                                           {
      assign(n);
      cimglist_apply(*this,assign)(img,shared);
      return *this;
    }

CImgList<T>& assign ( const CImg< t > &  img, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34218 of file CImg.h.

                                                                     {
      assign(1);
      data[0].assign(img,shared);
      return *this;
    }

CImgList<T>& assign ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34226 of file CImg.h.

                                                                                             {
      assign(2);
      data[0].assign(img1,shared); data[1].assign(img2,shared);
      return *this;
    }

CImgList<T>& assign ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34234 of file CImg.h.

                                                                                                                   {
      assign(3);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared);
      return *this;
    }

CImgList<T>& assign ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34242 of file CImg.h.

                                                 {
      assign(4);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      return *this;
    }

CImgList<T>& assign ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const CImg< t5 > &  img5, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34251 of file CImg.h.

                                                                       {
      assign(5);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      data[4].assign(img5,shared);
      return *this;
    }

CImgList<T>& assign ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const CImg< t5 > &  img5, const CImg< t6 > &  img6, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34261 of file CImg.h.

                                                                                             {
      assign(6);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      data[4].assign(img5,shared); data[5].assign(img6,shared);
      return *this;
    }

CImgList<T>& assign ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const CImg< t5 > &  img5, const CImg< t6 > &  img6, const CImg< t7 > &  img7, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34271 of file CImg.h.

                                                                                                                   {
      assign(7);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      data[4].assign(img5,shared); data[5].assign(img6,shared); data[6].assign(img7,shared);
      return *this;
    }

CImgList<T>& assign ( const CImg< t1 > &  img1, const CImg< t2 > &  img2, const CImg< t3 > &  img3, const CImg< t4 > &  img4, const CImg< t5 > &  img5, const CImg< t6 > &  img6, const CImg< t7 > &  img7, const CImg< t8 > &  img8, const bool  shared = false  )

inline

In-place version of the corresponding constructor.

Definition at line 34281 of file CImg.h.

                                                 {
      assign(8);
      data[0].assign(img1,shared); data[1].assign(img2,shared); data[2].assign(img3,shared); data[3].assign(img4,shared);
      data[4].assign(img5,shared); data[5].assign(img6,shared); data[6].assign(img7,shared); data[7].assign(img8,shared);
      return *this;
    }

CImgList<T>& assign ( const char *const  filename )

inline

In-place version of the corresponding constructor.

Definition at line 34291 of file CImg.h.

                                                    {
      return load(filename);
    }

CImgList<T>& assign ( const CImgDisplay &  disp )

inline

In-place version of the corresponding constructor.

Definition at line 34296 of file CImg.h.

                                                 {
      return assign(CImg<T>(disp));
    }

CImg<T>& at ( const int  pos )

inline

Read an image in specified position.

Definition at line 34544 of file CImg.h.

                               {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::at() : Instance list is empty.",
                                    pixel_type());
      return data[pos<0?0:pos>=(int)width?(int)width-1:pos];
    }

T& atN ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  )

inline

Read a pixel value with Dirichlet boundary conditions for the first coordinates (pos).

Definition at line 34680 of file CImg.h.

                                                                                               {
      return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):(*this)(pos,x,y,z,v);
    }

T atN ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  ) const

inline

Definition at line 34684 of file CImg.h.

                                                                                                    {
      return (pos<0 || pos>=(int)width)?out_val:(*this)(pos,x,y,z,v);
    }

T& atN ( const int  pos, const int  x = 0, const int  y = 0, const int  z = 0, const int  v = 0  )

inline

Read a pixel value with Neumann boundary conditions for the first coordinates (pos).

Definition at line 34689 of file CImg.h.

                                                                                      {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atN() : Instance list is empty.",
                                    pixel_type());
      return _atN(pos,x,y,z,v);
    }

T atN ( const int  pos, const int  x = 0, const int  y = 0, const int  z = 0, const int  v = 0  ) const

inline

Definition at line 34696 of file CImg.h.

                                                                                           {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atN() : Instance list is empty.",
                                    pixel_type());
      return _atN(pos,x,y,z,v);
    }

T& atNX ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  )

inline

Read a pixel value with Dirichlet boundary conditions for the two first coordinates (pos,x).

Definition at line 34648 of file CImg.h.

                                                                                                {
      return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):data[pos].atX(x,y,z,v,out_val);
    }

T atNX ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  ) const

inline

Definition at line 34652 of file CImg.h.

                                                                                                     {
      return (pos<0 || pos>=(int)width)?out_val:data[pos].atX(x,y,z,v,out_val);
    }

T& atNX ( const int  pos, const int  x, const int  y = 0, const int  z = 0, const int  v = 0  )

inline

Read a pixel value with Neumann boundary conditions for the two first coordinates (pos, x).

Definition at line 34657 of file CImg.h.

                                                                                     {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atNX() : Instance list is empty.",
                                    pixel_type());
      return _atNX(pos,x,y,z,v);
    }

T atNX ( const int  pos, const int  x, const int  y = 0, const int  z = 0, const int  v = 0  ) const

inline

Definition at line 34664 of file CImg.h.

                                                                                          {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atNX() : Instance list is empty.",
                                    pixel_type());
      return _atNX(pos,x,y,z,v);
    }

T& atNXY ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  )

inline

Read a pixel value with Dirichlet boundary conditions for the three first coordinates (pos, x,y).

Definition at line 34616 of file CImg.h.

                                                                                                 {
      return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):data[pos].atXY(x,y,z,v,out_val);
    }

T atNXY ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  ) const

inline

Definition at line 34620 of file CImg.h.

                                                                                                      {
      return (pos<0 || pos>=(int)width)?out_val:data[pos].atXY(x,y,z,v,out_val);
    }

T& atNXY ( const int  pos, const int  x, const int  y, const int  z = 0, const int  v = 0  )

inline

Read a pixel value with Neumann boundary conditions for the three first coordinates (pos, x,y).

Definition at line 34625 of file CImg.h.

                                                                                    {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atNXY() : Instance list is empty.",
                                    pixel_type());
      return _atNXY(pos,x,y,z,v);
    }

T atNXY ( const int  pos, const int  x, const int  y, const int  z = 0, const int  v = 0  ) const

inline

Definition at line 34632 of file CImg.h.

                                                                                         {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atNXY() : Instance list is empty.",
                                    pixel_type());
      return _atNXY(pos,x,y,z,v);
    }

T& atNXYZ ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  )

inline

Read a pixel value with Dirichlet boundary conditions for the four first coordinates (pos, x,y,z).

Definition at line 34584 of file CImg.h.

                                                                                                  {
      return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):data[pos].atXYZ(x,y,z,v,out_val);
    }

T atNXYZ ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  ) const

inline

Definition at line 34588 of file CImg.h.

                                                                                                       {
      return (pos<0 || pos>=(int)width)?out_val:data[pos].atXYZ(x,y,z,v,out_val);
    }

T& atNXYZ ( const int  pos, const int  x, const int  y, const int  z, const int  v = 0  )

inline

Read a pixel value with Neumann boundary conditions for the four first coordinates (pos, x,y,z).

Definition at line 34593 of file CImg.h.

                                                                                   {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atNXYZ() : Instance list is empty.",
                                    pixel_type());
      return _atNXYZ(pos,x,y,z,v);
    }

T atNXYZ ( const int  pos, const int  x, const int  y, const int  z, const int  v = 0  ) const

inline

Definition at line 34600 of file CImg.h.

                                                                                        {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atNXYZ() : Instance list is empty.",
                                    pixel_type());
      return _atNXYZ(pos,x,y,z,v);
    }

T& atNXYZV ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  )

inline

Read a pixel value with Dirichlet boundary conditions.

Definition at line 34552 of file CImg.h.

                                                                                                   {
      return (pos<0 || pos>=(int)width)?(cimg::temporary(out_val)=out_val):data[pos].atXYZV(x,y,z,v,out_val);
    }

T atNXYZV ( const int  pos, const int  x, const int  y, const int  z, const int  v, const T  out_val  ) const

inline

Definition at line 34556 of file CImg.h.

                                                                                                        {
      return (pos<0 || pos>=(int)width)?out_val:data[pos].atXYZV(x,y,z,v,out_val);
    }

T& atNXYZV ( const int  pos, const int  x, const int  y, const int  z, const int  v  )

inline

Read a pixel value with Neumann boundary conditions.

Definition at line 34561 of file CImg.h.

                                                                                  {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atNXYZV() : Instance list is empty.",
                                    pixel_type());
      return _atNXYZV(pos,x,y,z,v);
    }

T atNXYZV ( const int  pos, const int  x, const int  y, const int  z, const int  v  ) const

inline

Definition at line 34568 of file CImg.h.

                                                                                       {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::atNXYZV() : Instance list is empty.",
                                    pixel_type());
      return _atNXYZV(pos,x,y,z,v);
    }

const CImg<T>& back ( ) const

inline

Return a reference to the last image (STL-compliant name).

Definition at line 34535 of file CImg.h.

                                {
      return *(data + width - 1);
    }

CImg<T>& back ( )

inline

Definition at line 34539 of file CImg.h.

                    {
      return *(data + width - 1);
    }

iterator begin ( )

inline

Returns an iterator to the beginning of the vector (STL-compliant name).

Definition at line 34508 of file CImg.h.

Referenced by CImgList< uintT >::print().

                     {
      return data;
    }

Here is the caller graph for this function:

const_iterator begin ( ) const

inline

Definition at line 34512 of file CImg.h.

                                 {
      return data;
    }

CImgList<T>& clear ( )

inline

In-place version of the default constructor.

This function is strictly equivalent to assign() and has been introduced for having a STL-compliant function name.

Definition at line 34146 of file CImg.h.

                         {
      return assign();
    }

bool contains ( const T &  pixel, t &  n, t &  x, t &  y, t &  z, t &  v  ) const

inline

Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y,z,v).

Definition at line 34838 of file CImg.h.

Referenced by CImgList< uintT >::contains().

                                                                     {
      if (is_empty()) return false;
      cimglist_for(*this,l) if (data[l].contains(pixel,x,y,z,v)) { n = (t)l; return true; }
      return false;
    }

Here is the caller graph for this function:

bool contains ( const T &  pixel, t &  n, t &  x, t &  y, t &  z  ) const

inline

Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y,z).

Definition at line 34846 of file CImg.h.

                                                               {
      t v;
      return contains(pixel,n,x,y,z,v);
    }

bool contains ( const T &  pixel, t &  n, t &  x, t &  y  ) const

inline

Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x,y).

Definition at line 34853 of file CImg.h.

                                                         {
      t z,v;
      return contains(pixel,n,x,y,z,v);
    }

bool contains ( const T &  pixel, t &  n, t &  x  ) const

inline

Return true if one of the image list contains the specified referenced value. If true, set coordinates (n,x).

Definition at line 34860 of file CImg.h.

                                                    {
      t y,z,v;
      return contains(pixel,n,x,y,z,v);
    }

bool contains ( const T &  pixel, t &  n  ) const

inline

Return true if one of the image list contains the specified referenced value. If true, set coordinates (n).

Definition at line 34867 of file CImg.h.

                                              {
      t x,y,z,v;
      return contains(pixel,n,x,y,z,v);
    }

bool contains ( const T &  pixel ) const

inline

Return true if one of the image list contains the specified referenced value.

Definition at line 34873 of file CImg.h.

                                        {
      unsigned int n,x,y,z,v;
      return contains(pixel,n,x,y,z,v);
    }

bool contains ( const CImg< T > &  img, t &  n  ) const

inline

Return true if the list contains the image 'img'. If true, returns the position (n) of the image in the list.

Definition at line 34880 of file CImg.h.

                                                  {
      if (is_empty()) return false;
      const CImg<T> *const ptr = &img;
      cimglist_for(*this,i) if (data+i==ptr) { n = (t)i; return true; }
      return false;
    }

bool contains ( const CImg< T > &  img ) const

inline

Return true if the list contains the image img.

Definition at line 34888 of file CImg.h.

                                            {
      unsigned int n;
      return contains(img,n);
    }

bool containsN ( const int  n ) const

inline

Return true if the list contains the image (n).

Definition at line 34831 of file CImg.h.

                                      {
      if (is_empty()) return false;
      return n>=0 && n<(int)width;
    }

bool containsNXYZV ( const int  n, const int  x = 0, const int  y = 0, const int  z = 0, const int  v = 0  ) const

inline

Return true if the list contains the pixel (n,x,y,z,v).

Definition at line 34825 of file CImg.h.

                                                                                                      {
      if (is_empty()) return false;
      return n>=0 && n<(int)width && x>=0 && x<data[n].dimx() && y>=0 && y<data[n].dimy() && z>=0 && z<data[n].dimz() && v>=0 && v<data[n].dimv();
    }

CImgList<T>& crop_font ( )

inline

Create an auto-cropped font (along the X axis) from a input font font.

Definition at line 37025 of file CImg.h.

                             {
      return get_crop_font().transfer_to(*this);
    }

int dimx ( ) const

inline

Return the size of the list.

Definition at line 34465 of file CImg.h.

Referenced by CImgList< uintT >::_font(), CImgList< uintT >::_save_yuv(), and cimg_library::cimg::dialog().

                     {
      return (int)width;
    }

Here is the caller graph for this function:

const CImgList<T>& display ( CImgDisplay &  disp, const char  axis = 'x', const char  align = 'p'  ) const

inline

Display the current CImgList instance in an existing CImgDisplay window (by reference).

This function displays the list images of the current CImgList instance into an existing CImgDisplay window. Images of the list are concatenated in a single temporarly image for visualization purposes. The function returns immediately.

Parameters

disp	: reference to an existing CImgDisplay instance, where the current image list will be displayed.
axis	: specify the axis for image concatenation. Can be 'x','y','z' or 'v'.
align	: specify the alignment for image concatenation. Can be 'p' (top), 'c' (center) or 'n' (bottom).

Returns

A reference to the current CImgList instance is returned.

Definition at line 36301 of file CImg.h.

                                                                                                   {
      get_append(axis,align).display(disp);
      return *this;
    }

const CImgList<T>& display ( CImgDisplay &  disp, const bool  display_info, const char  axis = 'x', const char  align = 'p'  ) const

inline

Display the current CImgList instance in a new display window.

This function opens a new window with a specific title and displays the list images of the current CImgList instance into it. Images of the list are concatenated in a single temporarly image for visualization purposes. The function returns when a key is pressed or the display window is closed by the user.

Parameters

title	: specify the title of the opening display window.
axis	: specify the axis for image concatenation. Can be 'x','y','z' or 'v'.
align	: specify the alignment for image concatenation. Can be 'p' (top), 'c' (center) or 'n' (bottom).

Returns

A reference to the current CImgList instance is returned.

Definition at line 36316 of file CImg.h.

                                                                                                         {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::display() : Instance list (%u,%u) is empty.",
                                    pixel_type(),width,data);
      const CImg<T> visu = get_append(axis,align);
      if (display_info) print(disp.title);
      visu.display(disp,false);
      return *this;
    }

const CImgList<T>& display ( const char *const  title = 0, const bool  display_info = true, const char  axis = 'x', const char  align = 'p'  ) const

inline

Display the current CImgList instance in a new display window.

Definition at line 36328 of file CImg.h.

                                                                                                              {
      const CImg<T> visu = get_append(axis,align);
      char ntitle[64] = { 0 };
      if (!title) std::sprintf(ntitle,"CImgList<%s>",pixel_type());
      if (display_info) print(title?title:ntitle);
      visu.display(title?title:ntitle,false);
      return *this;
    }

static CImgList<T>& empty ( void  )

inlinestatic

Return a reference to an empty list.

Definition at line 34333 of file CImg.h.

Referenced by cimg_library::cimg::eval().

                                {
      static CImgList<T> _empty;
      return _empty.assign();
    }

Here is the caller graph for this function:

iterator end ( )

inline

Returns an iterator just past the last element (STL-compliant name).

Definition at line 34517 of file CImg.h.

Referenced by CImgList< uintT >::print().

                   {
      return data + width;
    }

Here is the caller graph for this function:

const_iterator end ( ) const

inline

Definition at line 34521 of file CImg.h.

                               {
      return data + width;
    }

CImgList<T>& erase ( const iterator  iter )

inline

Remove the element pointed by iterator iter (STL-compliant name).

Definition at line 35437 of file CImg.h.

                                            {
      return remove(iter-data);
    }

CImgList<T>& FFT ( const char  axis, const bool  invert = false  )

inline

Compute a 1-D Fast Fourier Transform, along specified axis.

Definition at line 37116 of file CImg.h.

Referenced by CImgList< uintT >::get_FFT().

                                                               {
      if (is_empty()) return *this;
      if (width==1) insert(1);
      if (width>2) cimg::warn("CImgList<%s>::FFT() : Instance list (%u,%p) have more than 2 images",
                             pixel_type(),width,data);
      CImg<T>::FFT(data[0],data[1],axis,invert);
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& FFT ( const bool  invert = false )

inline

Compute a N-D Fast Fourier Transform.

Definition at line 37130 of file CImg.h.

                                              {
      if (is_empty()) return *this;
      if (width==1) insert(1);
      if (width>2) cimg::warn("CImgList<%s>::FFT() : Instance list (%u,%p) have more than 2 images",
                             pixel_type(),width,data);
      CImg<T>::FFT(data[0],data[1],invert);
      return *this;
    }

static CImgList<T> font ( const unsigned int  font_width, const bool  variable_size = true  )

inlinestatic

Return a CImg pre-defined font with desired size.

Parameters

font_height	= height of the desired font (can be 11,13,24,38 or 57)
fixed_size	= tell if the font has a fixed or variable width.

Definition at line 37048 of file CImg.h.

Referenced by CImgList< uintT >::_font(), and CImg< uintT >::draw_text().

                                                                                          {
      if (font_width<=11) {
        static CImgList<T> font7x11, nfont7x11;
        if (!variable_size && !font7x11)  font7x11 = _font(cimg::font7x11,7,11,1,0,false);
        if (variable_size  && !nfont7x11) nfont7x11 = _font(cimg::font7x11,7,11,1,0,true);
        return variable_size?nfont7x11:font7x11;
      }
      if (font_width<=13) {
        static CImgList<T> font10x13, nfont10x13;
        if (!variable_size && !font10x13)  font10x13 = _font(cimg::font10x13,10,13,1,0,false);
        if (variable_size  && !nfont10x13) nfont10x13 = _font(cimg::font10x13,10,13,1,0,true);
        return variable_size?nfont10x13:font10x13;
      }
      if (font_width<=17) {
        static CImgList<T> font8x17, nfont8x17;
        if (!variable_size && !font8x17)  font8x17 = _font(cimg::font8x17,8,17,1,0,false);
        if (variable_size  && !nfont8x17) nfont8x17 = _font(cimg::font8x17,8,17,1,0,true);
        return variable_size?nfont8x17:font8x17;
      }
      if (font_width<=19) {
        static CImgList<T> font10x19, nfont10x19;
        if (!variable_size && !font10x19)  font10x19 = _font(cimg::font10x19,10,19,2,0,false);
        if (variable_size  && !nfont10x19) nfont10x19 = _font(cimg::font10x19,10,19,2,0,true);
        return variable_size?nfont10x19:font10x19;
      }
      if (font_width<=24) {
        static CImgList<T> font12x24, nfont12x24;
        if (!variable_size && !font12x24)  font12x24 = _font(cimg::font12x24,12,24,2,0,false);
        if (variable_size  && !nfont12x24) nfont12x24 = _font(cimg::font12x24,12,24,2,0,true);
        return variable_size?nfont12x24:font12x24;
      }
      if (font_width<=32) {
        static CImgList<T> font16x32, nfont16x32;
        if (!variable_size && !font16x32)  font16x32 = _font(cimg::font16x32,16,32,2,0,false);
        if (variable_size  && !nfont16x32) nfont16x32 = _font(cimg::font16x32,16,32,2,0,true);
        return variable_size?nfont16x32:font16x32;
      }
      if (font_width<=38) {
        static CImgList<T> font19x38, nfont19x38;
        if (!variable_size && !font19x38)  font19x38 = _font(cimg::font19x38,19,38,3,0,false);
        if (variable_size  && !nfont19x38) nfont19x38 = _font(cimg::font19x38,19,38,3,0,true);
        return variable_size?nfont19x38:font19x38;
      }
      static CImgList<T> font29x57, nfont29x57;
      if (!variable_size && !font29x57)  font29x57 = _font(cimg::font29x57,29,57,5,0,false);
      if (variable_size  && !nfont29x57) nfont29x57 = _font(cimg::font29x57,29,57,5,0,true);
      return variable_size?nfont29x57:font29x57;
    }

Here is the caller graph for this function:

CImg<T>& front ( )

inline

Returns a reference to the first element (STL-compliant name).

Definition at line 34526 of file CImg.h.

                     {
      return *data;
    }

const CImg<T>& front ( ) const

inline

Definition at line 34530 of file CImg.h.

                                 {
      return *data;
    }

CImg<T> get_append ( const char  axis, const char  align = 'p'  ) const

inline

Return a single image which is the concatenation of all images of the current CImgList instance.

Parameters

axis	: specify the axis for image concatenation. Can be 'x','y','z' or 'v'.
align	: specify the alignment for image concatenation. Can be 'p' (top), 'c' (center) or 'n' (bottom).

Returns

A CImg<T> image corresponding to the concatenation is returned.

Definition at line 35280 of file CImg.h.

Referenced by CImgDisplay::display(), CImgList< uintT >::display(), CImg< uintT >::load_cimg(), CImg< uintT >::load_parrec(), and CImgList< uintT >::operator>().

                                                                    {
      if (align!='p' && align!='c' && align!='n')
        throw CImgArgumentException("CImg<%s>::get_append() : Invalid alignment parameter '%c' (should be 'p','c' or 'n').",
                                    pixel_type(),align);
      if (is_empty()) return CImg<T>();
      if (width==1) return +((*this)[0]);
      unsigned int dx = 0, dy = 0, dz = 0, dv = 0, pos = 0;
      CImg<T> res;
      switch (cimg::uncase(axis)) {
      case 'x' : { // Along the X-axis.
        cimglist_for(*this,l) {
          const CImg<T>& img = (*this)[l];
          dx += img.width; dy = cimg::max(dy,img.height); dz = cimg::max(dz,img.depth); dv = cimg::max(dv,img.dim);
        }
        res.assign(dx,dy,dz,dv,0);
        if (res) switch (cimg::uncase(align)) {
        case 'p' : {
          cimglist_for(*this,l) {
            res.draw_image(pos,(*this)[l]);
            pos+=(*this)[l].width;
          }
        } break;
        case 'c' : {
          cimglist_for(*this,l) {
            res.draw_image(pos,(dy-(*this)[l].height)/2,(dz-(*this)[l].depth)/2,(dv-(*this)[l].dim)/2,(*this)[l]);
            pos+=(*this)[l].width;
          }
        } break;
        default : {
          cimglist_for(*this,l) {
            res.draw_image(pos,dy-(*this)[l].height,dz-(*this)[l].depth,dv-(*this)[l].dim,(*this)[l]);
            pos+=(*this)[l].width;
          }
        }}
      } break;
      case 'y' : { // Along the Y-axis.
        cimglist_for(*this,l) {
          const CImg<T>& img = (*this)[l];
          dx = cimg::max(dx,img.width); dy += img.height; dz = cimg::max(dz,img.depth); dv = cimg::max(dv,img.dim);
        }
        res.assign(dx,dy,dz,dv,0);
        if (res) switch (cimg::uncase(align)) {
        case 'p' : {
          cimglist_for(*this,l) { res.draw_image(0,pos,(*this)[l]); pos+=(*this)[l].height; }
        } break;
        case 'c' : {
          cimglist_for(*this,l) {
            res.draw_image((dx-(*this)[l].width)/2,pos,(dz-(*this)[l].depth)/2,(dv-(*this)[l].dim)/2,(*this)[l]);
            pos+=(*this)[l].height;
          }
        } break;
        default : {
          cimglist_for(*this,l) {
            res.draw_image(dx-(*this)[l].width,pos,dz-(*this)[l].depth,dv-(*this)[l].dim,(*this)[l]);
            pos+=(*this)[l].height;
          }
        }}
      } break;
      case 'z' : { // Along the Z-axis.
        cimglist_for(*this,l) {
          const CImg<T>& img = (*this)[l];
          dx = cimg::max(dx,img.width); dy = cimg::max(dy,img.height); dz += img.depth; dv = cimg::max(dv,img.dim);
        }
        res.assign(dx,dy,dz,dv,0);
        if (res) switch (cimg::uncase(align)) {
        case 'p' : {
          cimglist_for(*this,l) { res.draw_image(0,0,pos,(*this)[l]); pos+=(*this)[l].depth; }
        } break;
        case 'c' : {
          cimglist_for(*this,l) {
            res.draw_image((dx-(*this)[l].width)/2,(dy-(*this)[l].height)/2,pos,(dv-(*this)[l].dim)/2,(*this)[l]);
            pos+=(*this)[l].depth;
          }
        } break;
        default : {
          cimglist_for(*this,l) {
            res.draw_image(dx-(*this)[l].width,dy-(*this)[l].height,pos,dv-(*this)[l].dim,(*this)[l]);
            pos+=(*this)[l].depth;
          }
        }}
      } break;
      case 'v' : { // Along the V-axis.
        cimglist_for(*this,l) {
          const CImg<T>& img = (*this)[l];
          dx = cimg::max(dx,img.width); dy = cimg::max(dy,img.height); dz = cimg::max(dz,img.depth); dv += img.dim;
        }
        res.assign(dx,dy,dz,dv,0);
        if (res) switch (cimg::uncase(align)) {
        case 'p' : {
          cimglist_for(*this,l) { res.draw_image(0,0,0,pos,(*this)[l]); pos+=(*this)[l].dim; }
        } break;
        case 'c' : {
          cimglist_for(*this,l) {
            res.draw_image((dx-(*this)[l].width)/2,(dy-(*this)[l].height)/2,(dz-(*this)[l].depth)/2,pos,(*this)[l]);
            pos+=(*this)[l].dim;
          }
        } break;
        default : {
          cimglist_for(*this,l) {
            res.draw_image(dx-(*this)[l].width,dy-(*this)[l].height,dz-(*this)[l].depth,pos,(*this)[l]);
            pos+=(*this)[l].dim;
          }
        }}
      } break;
      default :
        throw CImgArgumentException("CImgList<%s>::get_append() : Invalid axis parameter '%c' (should be 'x','y','z' or 'v').",
                                    pixel_type(),axis);
      }
      return res;
    }

Here is the caller graph for this function:

CImgList<T> get_crop_font ( ) const

inline

Definition at line 37029 of file CImg.h.

Referenced by CImgList< uintT >::crop_font().

                                      {
      CImgList<T> res;
      cimglist_for(*this,l) {
        const CImg<T>& letter = (*this)[l];
        int xmin = letter.width, xmax = 0;
        cimg_forXY(letter,x,y) if (letter(x,y)) { if (x<xmin) xmin=x; if (x>xmax) xmax=x; }
        if (xmin>xmax) CImg<T>(letter.width,letter.height,1,letter.dim,0).transfer_to(res);
        else letter.get_crop(xmin,0,xmax,letter.height-1).transfer_to(res);
      }
      res[' '].resize(res['f'].width);
      res[' '+256].resize(res['f'].width);
      return res;
    }

Here is the caller graph for this function:

CImgList<Tfloat> get_FFT ( const char  axis, const bool  invert = false  ) const

inline

Definition at line 37125 of file CImg.h.

                                                                             {
      return CImgList<Tfloat>(*this,false).FFT(axis,invert);
    }

CImgList<Tfloat> get_FFT ( const bool  invert = false ) const

inline

Definition at line 37139 of file CImg.h.

                                                            {
      return CImgList<Tfloat>(*this,false).FFT(invert);
    }

CImgList<T> get_images ( const unsigned int  i0, const unsigned int  i1  ) const

inline

Definition at line 35246 of file CImg.h.

Referenced by CImgList< uintT >::images().

                                                                               {
      if (i0>i1 || i1>=width)
        throw CImgArgumentException("CImgList<%s>::images() : Cannot build a sublist (%u->%u) from a list (%u,%p)",
                                    pixel_type(),i0,i1,width,data);
      CImgList<T> res(i1-i0+1);
      cimglist_for(res,l) res[l].assign(data[i0+l]);
      return res;
    }

Here is the caller graph for this function:

CImgList<T> get_insert ( const CImg< t > &  img, const unsigned int  pos = ~0U, const bool  shared = false  ) const

inline

Definition at line 35112 of file CImg.h.

                                                                                                          {
      return (+*this).insert(img,pos,shared);
    }

CImgList<T> get_insert ( const unsigned int  n, const unsigned int  pos = ~0U  ) const

inline

Definition at line 35125 of file CImg.h.

                                                                                   {
      return (+*this).insert(n,pos);
    }

CImgList<T> get_insert ( const unsigned int  n, const CImg< t > &  img, const unsigned int  pos = ~0U, const bool  shared = false  ) const

inline

Definition at line 35140 of file CImg.h.

                                                                                                                                {
      return (+*this).insert(n,img,pos,shared);
    }

CImgList<T> get_insert ( const CImgList< t > &  list, const unsigned int  pos = ~0U, const bool  shared = false  ) const

inline

Definition at line 35154 of file CImg.h.

                                                                                                               {
      return (+*this).insert(list,pos,shared);
    }

CImgList<T> get_insert ( const unsigned int  n, const CImgList< t > &  list, const unsigned int  pos = ~0U, const bool  shared = false  ) const

inline

Definition at line 35168 of file CImg.h.

                                                                                                                                     {
      return (+*this).insert(n,list,pos,shared);
    }

static CImgList<T> get_load ( const char *const  filename )

inlinestatic

Definition at line 35528 of file CImg.h.

                                                            {
      return CImgList<T>().load(filename);
    }

static CImgList<T> get_load_cimg ( const char *const  filename )

inlinestatic

Definition at line 35537 of file CImg.h.

                                                                 {
      return CImgList<T>().load_cimg(filename);
    }

static CImgList<T> get_load_cimg ( std::FILE *const  file )

inlinestatic

Definition at line 35546 of file CImg.h.

                                                          {
      return CImgList<T>().load_cimg(file);
    }

static CImgList<T> get_load_cimg ( const char *const  filename, const unsigned int  n0, const unsigned int  n1, const unsigned int  x0, const unsigned int  y0, const unsigned int  z0, const unsigned int  v0, const unsigned int  x1, const unsigned int  y1, const unsigned int  z1, const unsigned int  v1  )

inlinestatic

Definition at line 35650 of file CImg.h.

                                                                                                                                 {
      return CImgList<T>().load_cimg(filename,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);
    }

static CImgList<T> get_load_cimg ( std::FILE *const  file, const unsigned int  n0, const unsigned int  n1, const unsigned int  x0, const unsigned int  y0, const unsigned int  z0, const unsigned int  v0, const unsigned int  x1, const unsigned int  y1, const unsigned int  z1, const unsigned int  v1  )

inlinestatic

Definition at line 35665 of file CImg.h.

                                                                                                                                 {
      return CImgList<T>().load_cimg(file,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);
    }

static CImgList<T> get_load_ffmpeg ( const char *const  filename, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  step_frame = 1, const bool  pixel_format = true  )

inlinestatic

Definition at line 36121 of file CImg.h.

                                                                                                      {
      return CImgList<T>().load_ffmpeg(filename,first_frame,last_frame,step_frame,pixel_format);
    }

static CImgList<T> get_load_ffmpeg_external ( const char *const  filename )

inlinestatic

Definition at line 36164 of file CImg.h.

                                                                            {
      return CImgList<T>().load_ffmpeg_external(filename);
    }

static CImgList<T> get_load_gzip_external ( const char *const  filename )

inlinestatic

Definition at line 36200 of file CImg.h.

                                                                          {
      return CImgList<T>().load_gzip_external(filename);
    }

static CImgList<T> get_load_off ( const char *const  filename, CImgList< tf > &  primitives, CImgList< tc > &  colors  )

inlinestatic

Definition at line 36212 of file CImg.h.

Referenced by CImgList< uintT >::load_off().

                                                                                      {
      return CImg<T>().load_off(filename,primitives,colors)<'x';
    }

Here is the caller graph for this function:

static CImgList<T> get_load_parrec ( const char *const  filename )

inlinestatic

Definition at line 35870 of file CImg.h.

                                                                   {
      return CImgList<T>().load_parrec(filename);
    }

static CImgList<T> get_load_tiff ( const char *const  filename, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  step_frame = 1  )

inlinestatic

Definition at line 36255 of file CImg.h.

                                                                      {
      return CImgList<T>().load_tiff(filename,first_frame,last_frame,step_frame);
    }

static CImgList<T> get_load_yuv ( const char *const  filename, const unsigned int  sizex, const unsigned int  sizey = 1, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  step_frame = 1, const bool  yuv2rgb = true  )

inlinestatic

Definition at line 35882 of file CImg.h.

                                                                                              {
      return CImgList<T>().load_yuv(filename,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb);
    }

static CImgList<T> get_load_yuv ( std::FILE *const  file, const unsigned int  sizex, const unsigned int  sizey = 1, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  step_frame = 1, const bool  yuv2rgb = true  )

inlinestatic

Definition at line 35897 of file CImg.h.

                                                                                              {
      return CImgList<T>().load_yuv(file,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb);
    }

CImgList<T> get_remove ( const unsigned int  pos1, const unsigned int  pos2  ) const

inline

Definition at line 35206 of file CImg.h.

                                                                                   {
      return (+*this).remove(pos1,pos2);
    }

CImgList<T> get_remove ( const unsigned int  pos ) const

inline

Definition at line 35215 of file CImg.h.

                                                         {
      return (+*this).remove(pos);
    }

CImgList<T> get_remove ( ) const

inline

Definition at line 35227 of file CImg.h.

                                   {
      return (+*this).remove();
    }

CImgList<T> get_reverse ( ) const

inline

Definition at line 35237 of file CImg.h.

                                    {
      return (+*this).reverse();
    }

CImgList<T> get_reverse_object3d ( ) const

inline

Definition at line 37154 of file CImg.h.

                                             {
      return (+*this).reverse_object3d();
    }

CImgList<T> get_shared ( )

inline

Return a shared instance of the list.

Definition at line 34128 of file CImg.h.

                             {
      CImgList<T> res(width);
      cimglist_for(*this,l) res[l].assign(data[l],true);
      return res;
    }

const CImgList<T> get_shared ( ) const

inline

Return a shared instance of the list.

Definition at line 34135 of file CImg.h.

                                         {
      CImgList<T> res(width);
      cimglist_for(*this,l) res[l].assign(data[l],true);
      return res;
    }

CImgList<T> get_shared_images ( const unsigned int  i0, const unsigned int  i1  )

inline

Get a shared sub-list.

Definition at line 35256 of file CImg.h.

                                                                                {
      if (i0>i1 || i1>=width)
        throw CImgArgumentException("CImgList<%s>::get_shared_images() : Cannot build a sublist (%u->%u) from a list (%u,%p)",
                                    pixel_type(),i0,i1,width,data);
      CImgList<T> res(i1-i0+1);
      cimglist_for(res,l) res[l].assign(data[i0+l],true);
      return res;
    }

const CImgList<T> get_shared_images ( const unsigned int  i0, const unsigned int  i1  ) const

inline

Definition at line 35265 of file CImg.h.

                                                                                            {
      if (i0>i1 || i1>=width)
        throw CImgArgumentException("CImgList<%s>::get_shared_images() : Cannot build a sublist (%u->%u) from a list (%u,%p)",
                                    pixel_type(),i0,i1,width,data);
      CImgList<T> res(i1-i0+1);
      cimglist_for(res,l) res[l].assign(data[i0+l],true);
      return res;
    }

CImgList<T> get_split ( const char  axis, const int  nb = 0  ) const

inline

Definition at line 35396 of file CImg.h.

Referenced by CImgList< uintT >::operator<(), and CImgList< uintT >::split().

                                                                 {
      CImgList<T> res;
      cimglist_for(*this,l) data[l].get_split(axis,nb).transfer_to(res,~0U);
      return res;
    }

Here is the caller graph for this function:

CImgList<T>& images ( const unsigned int  i0, const unsigned int  i1  )

inline

Get a sub-list.

Definition at line 35242 of file CImg.h.

                                                                      {
      return get_images(i0,i1).transfer_to(*this);
    }

CImgList<T>& insert ( const CImg< t > &  img, const unsigned int  pos = ~0U, const bool  shared = false  )

inline

Insert a copy of the image img into the current image list, at position pos.

Definition at line 35041 of file CImg.h.

Referenced by CImg< uintT >::_display_object3d(), CImg< uintT >::_load_off(), CImgList< uintT >::_load_yuv(), CImg< uintT >::_save_off(), CImg< uintT >::append_object3d(), CImgList< uintT >::FFT(), CImg< uintT >::get_gradient(), CImgList< uintT >::get_insert(), CImg< uintT >::get_split(), CImgList< uintT >::insert(), CImgList< uintT >::operator,(), CImgList< uintT >::push_back(), CImgList< uintT >::push_front(), and CImg< uintT >::transfer_to().

                                                                                                 {
      const unsigned int npos = pos==~0U?width:pos;
      if (npos>width)
        throw CImgArgumentException("CImgList<%s>::insert() : Cannot insert image (%u,%u,%u,%u,%p) at position %u in a list "
                                    "containing %u elements",
                                    pixel_type(),img.width,img.height,img.depth,img.dim,img.data,npos,width);
      if (shared)
        throw CImgArgumentException("CImgList<%s>::insert() : Cannot insert a shared image CImg<%s> in a CImgList<%s>",
                                    pixel_type(),img.pixel_type(),pixel_type());
      CImg<T> *new_data = (++width>allocated_width)?new CImg<T>[allocated_width?(allocated_width<<=1):(allocated_width=16)]:0;
      if (!width || !data) {
        data = new_data;
        *data = img;
      } else {
        if (new_data) {
          if (npos) std::memcpy(new_data,data,sizeof(CImg<T>)*npos);
          if (npos!=width-1) std::memcpy(new_data+npos+1,data+npos,sizeof(CImg<T>)*(width-1-npos));
          std::memset(data,0,sizeof(CImg<T>)*(width-1));
          delete[] data;
          data = new_data;
        }
        else if (npos!=width-1) std::memmove(data+npos+1,data+npos,sizeof(CImg<T>)*(width-1-npos));
        data[npos].width = data[npos].height = data[npos].depth = data[npos].dim = 0; data[npos].data = 0;
        data[npos] = img;
      }
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& insert ( const CImg< T > &  img, const unsigned int  pos = ~0U, const bool  shared = false  )

inline

Definition at line 35069 of file CImg.h.

                                                                                                 {
      const unsigned int npos = pos==~0U?width:pos;
      if (npos>width)
        throw CImgArgumentException("CImgList<%s>::insert() : Cannot insert at position %u into a list with %u elements",
                                    pixel_type(),npos,width);
      if (&img>=data && &img<data + width) return insert(+img,pos,shared);
      CImg<T> *new_data = (++width>allocated_width)?new CImg<T>[allocated_width?(allocated_width<<=1):(allocated_width=16)]:0;
      if (!width || !data) {
        data = new_data;
        if (shared && img) {
          data->width = img.width; data->height = img.height; data->depth = img.depth; data->dim = img.dim;
          data->is_shared = true; data->data = img.data;
        } else *data = img;
      }
      else {
        if (new_data) {
          if (npos) std::memcpy(new_data,data,sizeof(CImg<T>)*npos);
          if (npos!=width-1) std::memcpy(new_data+npos+1,data+npos,sizeof(CImg<T>)*(width-1-npos));
          if (shared && img) {
            new_data[npos].width = img.width; new_data[npos].height = img.height; new_data[npos].depth = img.depth;
            new_data[npos].dim = img.dim; new_data[npos].is_shared = true; new_data[npos].data = img.data;
          } else {
            new_data[npos].width = new_data[npos].height = new_data[npos].depth = new_data[npos].dim = 0; new_data[npos].data = 0;
            new_data[npos] = img;
          }
          std::memset(data,0,sizeof(CImg<T>)*(width-1));
          delete[] data;
          data = new_data;
        } else {
          if (npos!=width-1) std::memmove(data+npos+1,data+npos,sizeof(CImg<T>)*(width-1-npos));
          if (shared && img) {
            data[npos].width = img.width; data[npos].height = img.height; data[npos].depth = img.depth; data[npos].dim = img.dim;
            data[npos].is_shared = true; data[npos].data = img.data;
          } else {
            data[npos].width = data[npos].height = data[npos].depth = data[npos].dim = 0; data[npos].data = 0;
            data[npos] = img;
          }
        }
      }
      return *this;
    }

CImgList<T>& insert ( const unsigned int  n, const unsigned int  pos = ~0U  )

inline

Insert n empty images img into the current image list, at position pos.

Definition at line 35117 of file CImg.h.

                                                                          {
      CImg<T> foo;
      if (!n) return *this;
      const unsigned int npos = pos==~0U?width:pos;
      for (unsigned int i = 0; i<n; ++i) insert(foo,npos+i);
      return *this;
    }

CImgList<T>& insert ( const unsigned int  n, const CImg< t > &  img, const unsigned int  pos = ~0U, const bool  shared = false  )

inline

Insert n copies of the image img into the current image list, at position pos.

Definition at line 35131 of file CImg.h.

                                                                                                                       {
      if (!n) return *this;
      const unsigned int npos = pos==~0U?width:pos;
      insert(img,npos,shared);
      for (unsigned int i = 1; i<n; ++i) insert(data[npos],npos+i,shared);
      return *this;
    }

CImgList<T>& insert ( const CImgList< t > &  list, const unsigned int  pos = ~0U, const bool  shared = false  )

inline

Insert a copy of the image list list into the current image list, starting from position pos.

Definition at line 35146 of file CImg.h.

                                                                                                      {
      const unsigned int npos = pos==~0U?width:pos;
      if ((void*)this!=(void*)&list) cimglist_for(list,l) insert(list[l],npos+l,shared);
      else insert(CImgList<T>(list),npos,shared);
      return *this;
    }

CImgList<T>& insert ( const unsigned int  n, const CImgList< t > &  list, const unsigned int  pos = ~0U, const bool  shared = false  )

inline

Insert n copies of the list list at position pos of the current list.

Definition at line 35160 of file CImg.h.

                                                                                                                            {
      if (!n) return *this;
      const unsigned int npos = pos==~0U?width:pos;
      for (unsigned int i = 0; i<n; ++i) insert(list,npos,shared);
      return *this;
    }

bool is_empty ( ) const

inline

Return true if list is empty.

Definition at line 34734 of file CImg.h.

Referenced by CImgList< uintT >::_save_cimg(), CImgList< uintT >::_save_yuv(), CImgList< uintT >::at(), CImgList< uintT >::atN(), CImgList< uintT >::atNX(), CImgList< uintT >::atNXY(), CImgList< uintT >::atNXYZ(), CImgList< uintT >::atNXYZV(), CImgList< uintT >::contains(), CImgList< uintT >::containsN(), CImgList< uintT >::containsNXYZV(), CImgList< uintT >::display(), CImgList< uintT >::FFT(), CImgList< uintT >::get_append(), CImgList< uintT >::load(), CImgList< uintT >::load_ffmpeg_external(), CImgList< uintT >::max(), CImgList< uintT >::maxmin(), CImgList< uintT >::min(), CImgList< uintT >::minmax(), CImgList< uintT >::operator bool(), CImgList< uintT >::save(), CImgList< uintT >::save_ffmpeg(), CImgList< uintT >::save_ffmpeg_external(), CImgList< uintT >::transfer_to(), and CImgList< uintT >::value_string().

                          {
      return (!data || !width);
    }

Here is the caller graph for this function:

bool is_sameN ( const unsigned int  n ) const

inline

Return true if list if of specified size.

Definition at line 34739 of file CImg.h.

Referenced by CImgList< uintT >::is_sameNXYZV().

                                              {
      return (width==n);
    }

Here is the caller graph for this function:

bool is_sameN ( const CImgList< t > &  list ) const

inline

Return true if list if of specified size.

Definition at line 34745 of file CImg.h.

                                                 {
      return (width==list.width);
    }

bool is_sameNXYZV ( const unsigned int  n, const unsigned int  dx, const unsigned int  dy, const unsigned int  dz, const unsigned int  dv  ) const

inline

Definition at line 34820 of file CImg.h.

                                                                                                                                              {
      return is_sameN(n) && is_sameXYZV(dx,dy,dz,dv);
    }

bool is_sameXYZV ( const unsigned int  dx, const unsigned int  dy, const unsigned int  dz, const unsigned int  dv  ) const

inline

Definition at line 34814 of file CImg.h.

Referenced by CImgList< uintT >::is_sameNXYZV(), and CImgList< uintT >::is_sameXYZV().

                                                                                                                       {
      bool res = true;
      for (unsigned int l = 0; l<width && res; ++l) res = data[l].is_sameXYZV(dx,dy,dz,dv);
      return res;
    }

Here is the caller graph for this function:

CImgList<T>& load ( const char *const  filename )

inline

Load an image list from a file.

Definition at line 35449 of file CImg.h.

Referenced by CImgList< uintT >::assign(), CImgList< uintT >::get_load(), and CImgList< uintT >::load_gzip_external().

                                                  {
      const char *ext = cimg::split_filename(filename);
      const unsigned int omode = cimg::exception_mode();
      cimg::exception_mode() = 0;
      assign();
      try {
#ifdef cimglist_load_plugin
        cimglist_load_plugin(filename);
#endif
#ifdef cimglist_load_plugin1
        cimglist_load_plugin1(filename);
#endif
#ifdef cimglist_load_plugin2
        cimglist_load_plugin2(filename);
#endif
#ifdef cimglist_load_plugin3
        cimglist_load_plugin3(filename);
#endif
#ifdef cimglist_load_plugin4
        cimglist_load_plugin4(filename);
#endif
#ifdef cimglist_load_plugin5
        cimglist_load_plugin5(filename);
#endif
#ifdef cimglist_load_plugin6
        cimglist_load_plugin6(filename);
#endif
#ifdef cimglist_load_plugin7
        cimglist_load_plugin7(filename);
#endif
#ifdef cimglist_load_plugin8
        cimglist_load_plugin8(filename);
#endif
        if (!cimg::strcasecmp(ext,"tif") ||
            !cimg::strcasecmp(ext,"tiff")) load_tiff(filename);
        if (!cimg::strcasecmp(ext,"cimg") ||
            !cimg::strcasecmp(ext,"cimgz") ||
            !ext[0]) load_cimg(filename);
        if (!cimg::strcasecmp(ext,"rec") ||
            !cimg::strcasecmp(ext,"par")) load_parrec(filename);
        if (!cimg::strcasecmp(ext,"avi") ||
            !cimg::strcasecmp(ext,"mov") ||
            !cimg::strcasecmp(ext,"asf") ||
            !cimg::strcasecmp(ext,"divx") ||
            !cimg::strcasecmp(ext,"flv") ||
            !cimg::strcasecmp(ext,"mpg") ||
            !cimg::strcasecmp(ext,"m1v") ||
            !cimg::strcasecmp(ext,"m2v") ||
            !cimg::strcasecmp(ext,"m4v") ||
            !cimg::strcasecmp(ext,"mjp") ||
            !cimg::strcasecmp(ext,"mkv") ||
            !cimg::strcasecmp(ext,"mpe") ||
            !cimg::strcasecmp(ext,"movie") ||
            !cimg::strcasecmp(ext,"ogm") ||
            !cimg::strcasecmp(ext,"qt") ||
            !cimg::strcasecmp(ext,"rm") ||
            !cimg::strcasecmp(ext,"vob") ||
            !cimg::strcasecmp(ext,"wmv") ||
            !cimg::strcasecmp(ext,"xvid") ||
            !cimg::strcasecmp(ext,"mpeg")) load_ffmpeg(filename);
        if (!cimg::strcasecmp(ext,"gz")) load_gzip_external(filename);
        if (is_empty()) throw CImgIOException("CImgList<%s>::load()",pixel_type());
      } catch (CImgIOException& e) {
        if (!cimg::strncasecmp(e.message,"cimg::fopen()",13)) {
          cimg::exception_mode() = omode;
          throw CImgIOException("CImgList<%s>::load() : File '%s' cannot be opened.",pixel_type(),filename);
        } else try {
          assign(1);
          data->load(filename);
        } catch (CImgException&) {
          assign();
        }
      }
      cimg::exception_mode() = omode;
      if (is_empty())
        throw CImgIOException("CImgList<%s>::load() : File '%s', format not recognized.",pixel_type(),filename);
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& load_cimg ( const char *const  filename )

inline

Load an image list from a .cimg file.

Definition at line 35533 of file CImg.h.

Referenced by CImgList< uintT >::get_load_cimg(), CImgList< uintT >::load(), and CImg< uintT >::load_cimg().

                                                       {
      return _load_cimg(0,filename);
    }

Here is the caller graph for this function:

CImgList<T>& load_cimg ( std::FILE *const  file )

inline

Load an image list from a .cimg file.

Definition at line 35542 of file CImg.h.

                                                {
      return _load_cimg(file,0);
    }

CImgList<T>& load_cimg ( const char *const  filename, const unsigned int  n0, const unsigned int  n1, const unsigned int  x0, const unsigned int  y0, const unsigned int  z0, const unsigned int  v0, const unsigned int  x1, const unsigned int  y1, const unsigned int  z1, const unsigned int  v1  )

inline

Load a sub-image list from a non compressed .cimg file.

Definition at line 35643 of file CImg.h.

                                                                                                                       {
      return _load_cimg(0,filename,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);
    }

CImgList<T>& load_cimg ( std::FILE *const  file, const unsigned int  n0, const unsigned int  n1, const unsigned int  x0, const unsigned int  y0, const unsigned int  z0, const unsigned int  v0, const unsigned int  x1, const unsigned int  y1, const unsigned int  z1, const unsigned int  v1  )

inline

Load a sub-image list from a non compressed .cimg file.

Definition at line 35658 of file CImg.h.

                                                                                                                       {
      return _load_cimg(file,0,n0,n1,x0,y0,z0,v0,x1,y1,z1,v1);
    }

CImgList<T>& load_ffmpeg ( const char *const  filename, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  step_frame = 1, const bool  pixel_format = true, const bool  resume = false  )

inline

Load an image from a video file, using ffmpeg libraries.

Definition at line 35980 of file CImg.h.

Referenced by CImgList< uintT >::get_load_ffmpeg(), and CImgList< uintT >::load().

                                                                                                                     {
      if (!filename)
        throw CImgArgumentException("CImgList<%s>::load_ffmpeg() : Cannot load (null) filename.",
                                    pixel_type());
      const unsigned int
        nfirst_frame = first_frame<last_frame?first_frame:last_frame,
        nlast_frame = first_frame<last_frame?last_frame:first_frame,
        nstep_frame = step_frame?step_frame:1;
      assign();

#ifndef cimg_use_ffmpeg
      if ((nfirst_frame || nlast_frame!=~0U || nstep_frame>1) || (resume && (pixel_format || !pixel_format)))
        throw CImgArgumentException("CImg<%s>::load_ffmpeg() : File '%s', reading sub-frames from a video file requires the use of ffmpeg.\n"
                                    "('cimg_use_ffmpeg' must be defined).",
                                    pixel_type(),filename);
      return load_ffmpeg_external(filename);
#else
      const unsigned int ffmpeg_pixfmt = pixel_format?PIX_FMT_RGB24:PIX_FMT_GRAY8;
      avcodec_register_all();
      av_register_all();
      static AVFormatContext *format_ctx = 0;
      static AVCodecContext *codec_ctx = 0;
      static AVCodec *codec = 0;
      static AVFrame *avframe = avcodec_alloc_frame(), *converted_frame = avcodec_alloc_frame();
      static int vstream = 0;

      if (resume) {
        if (!format_ctx || !codec_ctx || !codec || !avframe || !converted_frame)
          throw CImgArgumentException("CImgList<%s>::load_ffmpeg() : File '%s', cannot resume due to unallocated FFMPEG structures.",
                                      pixel_type(),filename);
      } else {
        // Open video file, find main video stream and codec.
        if (format_ctx) av_close_input_file(format_ctx);
        if (av_open_input_file(&format_ctx,filename,0,0,0)!=0)
          throw CImgIOException("CImgList<%s>::load_ffmpeg() : File '%s' cannot be opened.",
                                pixel_type(),filename);
        if (!avframe || !converted_frame || av_find_stream_info(format_ctx)<0) {
          av_close_input_file(format_ctx); format_ctx = 0;
          cimg::warn("CImgList<%s>::load_ffmpeg() : File '%s', cannot retrieve stream information.\n"
                     "Trying with external ffmpeg executable.",
                     pixel_type(),filename);
          return load_ffmpeg_external(filename);
        }
#if cimg_debug>=3
        dump_format(format_ctx,0,0,0);
#endif

        // Special command : Return informations on main video stream.
        // as a vector 1x4 containing : (nb_frames,width,height,fps).
        if (!first_frame && !last_frame && !step_frame) {
          for (vstream = 0; vstream<(int)(format_ctx->nb_streams); ++vstream)
            if (format_ctx->streams[vstream]->codec->codec_type==CODEC_TYPE_VIDEO) break;
          if (vstream==(int)format_ctx->nb_streams) assign();
          else {
            CImgList<doubleT> timestamps;
            int nb_frames;
            AVPacket packet;
            // Count frames and store timestamps.
            for (nb_frames = 0; av_read_frame(format_ctx,&packet)>=0; av_free_packet(&packet))
              if (packet.stream_index==vstream) {
                CImg<doubleT>::vector((double)packet.pts).transfer_to(timestamps);
                ++nb_frames;
              }
            // Get frame with, height and fps.
            const int
              framew = format_ctx->streams[vstream]->codec->width,
              frameh = format_ctx->streams[vstream]->codec->height;
            const float
              num = (float)(format_ctx->streams[vstream]->r_frame_rate).num,
              den = (float)(format_ctx->streams[vstream]->r_frame_rate).den,
              fps = num/den;
            // Return infos as a list.
            assign(2);
            (*this)[0].assign(1,4).fill((T)nb_frames,(T)framew,(T)frameh,(T)fps);
            (*this)[1] = (timestamps>'y');
          }
          av_close_input_file(format_ctx); format_ctx = 0;
          return *this;
        }

        for (vstream = 0; vstream<(int)(format_ctx->nb_streams) &&
               format_ctx->streams[vstream]->codec->codec_type!=CODEC_TYPE_VIDEO; ) ++vstream;
        if (vstream==(int)format_ctx->nb_streams) {
          cimg::warn("CImgList<%s>::load_ffmpeg() : File '%s', cannot retrieve video stream.\n"
                     "Trying with external ffmpeg executable.",
                     pixel_type(),filename);
          av_close_input_file(format_ctx); format_ctx = 0;
          return load_ffmpeg_external(filename);
        }
        codec_ctx = format_ctx->streams[vstream]->codec;
        codec = avcodec_find_decoder(codec_ctx->codec_id);
        if (!codec) {
          cimg::warn("CImgList<%s>::load_ffmpeg() : File '%s', cannot find video codec.\n"
                     "Trying with external ffmpeg executable.",
                     pixel_type(),filename);
          return load_ffmpeg_external(filename);
        }
        if (avcodec_open(codec_ctx,codec)<0) { // Open codec
          cimg::warn("CImgList<%s>::load_ffmpeg() : File '%s', cannot open video codec.\n"
                     "Trying with external ffmpeg executable.",
                     pixel_type(),filename);
          return load_ffmpeg_external(filename);
        }
      }

      // Read video frames
      const unsigned int numBytes = avpicture_get_size(ffmpeg_pixfmt,codec_ctx->width,codec_ctx->height);
      uint8_t *const buffer = new uint8_t[numBytes];
      avpicture_fill((AVPicture *)converted_frame,buffer,ffmpeg_pixfmt,codec_ctx->width,codec_ctx->height);
      const T foo = (T)0;
      AVPacket packet;
      for (unsigned int frame = 0, next_frame = nfirst_frame; frame<=nlast_frame && av_read_frame(format_ctx,&packet)>=0; ) {
        if (packet.stream_index==(int)vstream) {
          int decoded = 0;
          avcodec_decode_video(codec_ctx,avframe,&decoded,packet.data,packet.size);
          if (decoded) {
            if (frame==next_frame) {
              SwsContext *c = sws_getContext(codec_ctx->width,codec_ctx->height,codec_ctx->pix_fmt,codec_ctx->width,
                                             codec_ctx->height,ffmpeg_pixfmt,1,0,0,0);
              sws_scale(c,avframe->data,avframe->linesize,0,codec_ctx->height,converted_frame->data,converted_frame->linesize);
              if (ffmpeg_pixfmt==PIX_FMT_RGB24) {
                CImg<ucharT> next_image(*converted_frame->data,3,codec_ctx->width,codec_ctx->height,1,true);
                next_image._get_permute_axes("yzvx",foo).transfer_to(*this);
              } else {
                CImg<ucharT> next_image(*converted_frame->data,1,codec_ctx->width,codec_ctx->height,1,true);
                next_image._get_permute_axes("yzvx",foo).transfer_to(*this);
              }
              next_frame+=nstep_frame;
            }
            ++frame;
          }
          av_free_packet(&packet);
          if (next_frame>nlast_frame) break;
        }
      }
      delete[] buffer;
#endif
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& load_ffmpeg_external ( const char *const  filename )

inline

Load an image from a video file (MPEG,AVI) using the external tool 'ffmpeg'.

Definition at line 36127 of file CImg.h.

Referenced by CImgList< uintT >::get_load_ffmpeg_external(), and CImgList< uintT >::load_ffmpeg().

                                                                  {
      if (!filename)
        throw CImgArgumentException("CImgList<%s>::load_ffmpeg_external() : Cannot load (null) filename.",
                                    pixel_type());
      char command[1024] = { 0 }, filetmp[512] = { 0 }, filetmp2[512] = { 0 };
      std::FILE *file = 0;
      do {
        std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());
        std::sprintf(filetmp2,"%s_000001.ppm",filetmp);
        if ((file=std::fopen(filetmp2,"rb"))!=0) std::fclose(file);
      } while (file);
      std::sprintf(filetmp2,"%s_%%6d.ppm",filetmp);
#if cimg_OS!=2
      std::sprintf(command,"%s -i \"%s\" %s >/dev/null 2>&1",cimg::ffmpeg_path(),filename,filetmp2);
#else
      std::sprintf(command,"\"%s -i \"%s\" %s\" >NUL 2>&1",cimg::ffmpeg_path(),filename,filetmp2);
#endif
      cimg::system(command,0);
      const unsigned int omode = cimg::exception_mode();
      cimg::exception_mode() = 0;
      assign();
      unsigned int i = 1;
      for (bool stopflag = false; !stopflag; ++i) {
        std::sprintf(filetmp2,"%s_%.6u.ppm",filetmp,i);
        CImg<T> img;
        try { img.load_pnm(filetmp2); }
        catch (CImgException&) { stopflag = true; }
        if (img) { img.transfer_to(*this); std::remove(filetmp2); }
      }
      cimg::exception_mode() = omode;
      if (is_empty())
        throw CImgIOException("CImgList<%s>::load_ffmpeg_external() : Failed to open image sequence '%s'.\n"
                              "Check the filename and if the 'ffmpeg' tool is installed on your system.",
                              pixel_type(),filename);
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& load_gzip_external ( const char *const  filename )

inline

Load a gzipped list, using external tool 'gunzip'.

Definition at line 36169 of file CImg.h.

Referenced by CImgList< uintT >::get_load_gzip_external(), and CImgList< uintT >::load().

                                                                {
      if (!filename)
        throw CImgIOException("CImg<%s>::load_gzip_external() : Cannot load (null) filename.",
                              pixel_type());
      char command[1024] = { 0 }, filetmp[512] = { 0 }, body[512] = { 0 };
      const char
        *ext = cimg::split_filename(filename,body),
        *ext2 = cimg::split_filename(body,0);
      std::FILE *file = 0;
      do {
        if (!cimg::strcasecmp(ext,"gz")) {
          if (*ext2) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext2);
          else std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());
        } else {
          if (*ext) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext);
          else std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());
        }
        if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);
      } while (file);
      std::sprintf(command,"%s -c \"%s\" > %s",cimg::gunzip_path(),filename,filetmp);
      cimg::system(command);
      if (!(file = std::fopen(filetmp,"rb"))) {
        cimg::fclose(cimg::fopen(filename,"r"));
        throw CImgIOException("CImg<%s>::load_gzip_external() : File '%s' cannot be opened.",
                              pixel_type(),filename);
      } else cimg::fclose(file);
      load(filetmp);
      std::remove(filetmp);
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& load_off ( const char *const  filename, CImgList< tf > &  primitives, CImgList< tc > &  colors  )

inline

Load a 3D object from a .OFF file.

Definition at line 36206 of file CImg.h.

Referenced by CImgList< uintT >::get_load_off().

                                                                          {
      return get_load_off(filename,primitives,colors).transfer_to(*this);
    }

Here is the caller graph for this function:

CImgList<T>& load_parrec ( const char *const  filename )

inline

Load an image list from a PAR/REC (Philips) file.

Definition at line 35781 of file CImg.h.

Referenced by CImgList< uintT >::get_load_parrec(), CImgList< uintT >::load(), and CImg< uintT >::load_parrec().

                                                         {
      if (!filename)
        throw CImgArgumentException("CImgList<%s>::load_parrec() : Cannot load (null) filename.",
                                    pixel_type());
      char body[1024] = { 0 }, filenamepar[1024] = { 0 }, filenamerec[1024] = { 0 };
      const char *ext = cimg::split_filename(filename,body);
      if (!std::strcmp(ext,"par")) { std::strcpy(filenamepar,filename); std::sprintf(filenamerec,"%s.rec",body); }
      if (!std::strcmp(ext,"PAR")) { std::strcpy(filenamepar,filename); std::sprintf(filenamerec,"%s.REC",body); }
      if (!std::strcmp(ext,"rec")) { std::strcpy(filenamerec,filename); std::sprintf(filenamepar,"%s.par",body); }
      if (!std::strcmp(ext,"REC")) { std::strcpy(filenamerec,filename); std::sprintf(filenamepar,"%s.PAR",body); }
      std::FILE *file = cimg::fopen(filenamepar,"r");

      // Parse header file
      CImgList<floatT> st_slices;
      CImgList<uintT> st_global;
      int err;
      char line[256] = { 0 };
      do { err=std::fscanf(file,"%255[^\n]%*c",line); } while (err!=EOF && (line[0]=='#' || line[0]=='.'));
      do {
        unsigned int sn,sizex,sizey,pixsize;
        float rs,ri,ss;
        err = std::fscanf(file,"%u%*u%*u%*u%*u%*u%*u%u%*u%u%u%g%g%g%*[^\n]",&sn,&pixsize,&sizex,&sizey,&ri,&rs,&ss);
        if (err==7) {
          CImg<floatT>::vector((float)sn,(float)pixsize,(float)sizex,(float)sizey,ri,rs,ss,0).transfer_to(st_slices);
          unsigned int i; for (i = 0; i<st_global.width && sn<=st_global[i][2]; ++i) {}
          if (i==st_global.width) CImg<uintT>::vector(sizex,sizey,sn).transfer_to(st_global);
          else {
            CImg<uintT> &vec = st_global[i];
            if (sizex>vec[0]) vec[0] = sizex;
            if (sizey>vec[1]) vec[1] = sizey;
            vec[2] = sn;
          }
          st_slices[st_slices.width-1][7] = (float)i;
        }
      } while (err==7);

      // Read data
      std::FILE *file2 = cimg::fopen(filenamerec,"rb");
      cimglist_for(st_global,l) {
        const CImg<uintT>& vec = st_global[l];
        CImg<T>(vec[0],vec[1],vec[2]).transfer_to(*this);
      }

      cimglist_for(st_slices,l) {
        const CImg<floatT>& vec = st_slices[l];
        const unsigned int
          sn = (unsigned int)vec[0]-1,
          pixsize = (unsigned int)vec[1],
          sizex = (unsigned int)vec[2],
          sizey = (unsigned int)vec[3],
          imn = (unsigned int)vec[7];
        const float ri = vec[4], rs = vec[5], ss = vec[6];
        switch (pixsize) {
        case 8 : {
          CImg<ucharT> buf(sizex,sizey);
          cimg::fread(buf.data,sizex*sizey,file2);
          if (cimg::endianness()) cimg::invert_endianness(buf.data,sizex*sizey);
          CImg<T>& img = (*this)[imn];
          cimg_forXY(img,x,y) img(x,y,sn) = (T)(( buf(x,y)*rs + ri )/(rs*ss));
        } break;
        case 16 : {
          CImg<ushortT> buf(sizex,sizey);
          cimg::fread(buf.data,sizex*sizey,file2);
          if (cimg::endianness()) cimg::invert_endianness(buf.data,sizex*sizey);
          CImg<T>& img = (*this)[imn];
          cimg_forXY(img,x,y) img(x,y,sn) = (T)(( buf(x,y)*rs + ri )/(rs*ss));
        } break;
        case 32 : {
          CImg<uintT> buf(sizex,sizey);
          cimg::fread(buf.data,sizex*sizey,file2);
          if (cimg::endianness()) cimg::invert_endianness(buf.data,sizex*sizey);
          CImg<T>& img = (*this)[imn];
          cimg_forXY(img,x,y) img(x,y,sn) = (T)(( buf(x,y)*rs + ri )/(rs*ss));
        } break;
        default :
          cimg::fclose(file);
          cimg::fclose(file2);
          throw CImgIOException("CImg<%s>::load_parrec() : File '%s', cannot handle image with pixsize = %d bits.",
                                pixel_type(),filename,pixsize);
        }
      }
      cimg::fclose(file);
      cimg::fclose(file2);
      if (!width)
        throw CImgIOException("CImg<%s>::load_parrec() : File '%s' does not appear to be a valid PAR-REC file.",
                              pixel_type(),filename);
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& load_tiff ( const char *const  filename, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  step_frame = 1  )

inline

Load a TIFF file.

Definition at line 36218 of file CImg.h.

Referenced by CImgList< uintT >::get_load_tiff(), and CImgList< uintT >::load().

                                                            {
      const unsigned int
        nfirst_frame = first_frame<last_frame?first_frame:last_frame,
        nstep_frame = step_frame?step_frame:1;
      unsigned int nlast_frame = first_frame<last_frame?last_frame:first_frame;
#ifndef cimg_use_tiff
      if (nfirst_frame || nlast_frame!=~0U || nstep_frame!=1)
        throw CImgArgumentException("CImgList<%s>::load_tiff() : File '%s', reading sub-images from a tiff file requires the use of libtiff.\n"
                                    "('cimg_use_tiff' must be defined).",
                                    pixel_type(),filename);
      return assign(CImg<T>::get_load_tiff(filename));
#else
      TIFF *tif = TIFFOpen(filename,"r");
      if (tif) {
        unsigned int nb_images = 0;
        do ++nb_images; while (TIFFReadDirectory(tif));
        if (nfirst_frame>=nb_images || (nlast_frame!=~0U && nlast_frame>=nb_images))
          cimg::warn("CImgList<%s>::load_tiff() : File '%s' contains %u image(s), specified frame range is [%u,%u] (step %u).",
                     pixel_type(),filename,nb_images,nfirst_frame,nlast_frame,nstep_frame);
        if (nfirst_frame>=nb_images) return assign();
        if (nlast_frame>=nb_images) nlast_frame = nb_images-1;
        assign(1+(nlast_frame-nfirst_frame)/nstep_frame);
        TIFFSetDirectory(tif,0);
#if cimg_debug>=3
        TIFFSetWarningHandler(0);
        TIFFSetErrorHandler(0);
#endif
        cimglist_for(*this,l) data[l]._load_tiff(tif,nfirst_frame + l*nstep_frame);
        TIFFClose(tif);
      } else throw CImgException("CImgList<%s>::load_tiff() : File '%s' cannot be opened.",
                                 pixel_type(),filename);
      return *this;
#endif
    }

Here is the caller graph for this function:

CImgList<T>& load_yuv ( const char *const  filename, const unsigned int  sizex, const unsigned int  sizey, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  step_frame = 1, const bool  yuv2rgb = true  )

inline

Load an image sequence from a YUV file.

Definition at line 35875 of file CImg.h.

Referenced by CImgList< uintT >::get_load_yuv().

                                                                                    {
      return _load_yuv(0,filename,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb);
    }

Here is the caller graph for this function:

CImgList<T>& load_yuv ( std::FILE *const  file, const unsigned int  sizex, const unsigned int  sizey, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  step_frame = 1, const bool  yuv2rgb = true  )

inline

Load an image sequence from a YUV file.

Definition at line 35890 of file CImg.h.

                                                                                    {
      return _load_yuv(file,0,sizex,sizey,first_frame,last_frame,step_frame,yuv2rgb);
    }

T& max ( void  )

inline

Return a reference to the maximum pixel value of the instance list.

Definition at line 34928 of file CImg.h.

             {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::max() : Instance image list is empty.",
                                    pixel_type());
      T *ptrmax = data->data;
      T max_value = *ptrmax;
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        cimg_for(img,ptr,T) if ((*ptr)>max_value) max_value = *(ptrmax=ptr);
      }
      return *ptrmax;
    }

const T& max ( void  ) const

inline

Definition at line 34941 of file CImg.h.

                         {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::max() : Instance image list is empty.",
                                    pixel_type());
      const T *ptrmax = data->data;
      T max_value = *ptrmax;
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        cimg_for(img,ptr,T) if ((*ptr)>max_value) max_value = *(ptrmax=ptr);
      }
      return *ptrmax;
    }

T& maxmin ( t &  min_val )

inline

Return a reference to the minimum pixel value of the instance list.

Definition at line 34995 of file CImg.h.

                          {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::maxmin() : Instance image list is empty.",
                                    pixel_type());
      T *ptrmax = data->data;
      T min_value = *ptrmax, max_value = min_value;
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        cimg_for(img,ptr,T) {
          const T val = *ptr;
          if (val>max_value) { max_value = val; ptrmax = ptr; }
          if (val<min_value) min_value = val;
        }
      }
      min_val = (t)min_value;
      return *ptrmax;
    }

const T& maxmin ( t &  min_val ) const

inline

Definition at line 35014 of file CImg.h.

                                      {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::maxmin() : Instance image list is empty.",
                                    pixel_type());
      const T *ptrmax = data->data;
      T min_value = *ptrmax, max_value = min_value;
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        cimg_for(img,ptr,T) {
          const T val = *ptr;
          if (val>max_value) { max_value = val; ptrmax = ptr; }
          if (val<min_value) min_value = val;
        }
      }
      min_val = (t)min_value;
      return *ptrmax;
    }

T& min ( )

inline

Return a reference to the minimum pixel value of the instance list.

Definition at line 34901 of file CImg.h.

             {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::min() : Instance image list is empty.",
                                    pixel_type());
      T *ptrmin = data->data;
      T min_value = *ptrmin;
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        cimg_for(img,ptr,T) if ((*ptr)<min_value) min_value = *(ptrmin=ptr);
      }
      return *ptrmin;
    }

const T& min ( ) const

inline

Definition at line 34914 of file CImg.h.

                         {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::min() : Instance image list is empty.",
                                    pixel_type());
      const T *ptrmin = data->data;
      T min_value = *ptrmin;
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        cimg_for(img,ptr,T) if ((*ptr)<min_value) min_value = *(ptrmin=ptr);
      }
      return *ptrmin;
    }

T& minmax ( t &  max_val )

inline

Return a reference to the minimum pixel value of the instance list.

Definition at line 34956 of file CImg.h.

Referenced by CImg< uintT >::_display_object3d().

                          {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::minmax() : Instance image list is empty.",
                                    pixel_type());
      T *ptrmin = data->data;
      T min_value = *ptrmin, max_value = min_value;
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        cimg_for(img,ptr,T) {
          const T val = *ptr;
          if (val<min_value) { min_value = val; ptrmin = ptr; }
          if (val>max_value) max_value = val;
        }
      }
      max_val = (t)max_value;
      return *ptrmin;
    }

Here is the caller graph for this function:

const T& minmax ( t &  max_val ) const

inline

Definition at line 34975 of file CImg.h.

                                      {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::minmax() : Instance image list is empty.",
                                    pixel_type());
      const T *ptrmin = data->data;
      T min_value = *ptrmin, max_value = min_value;
      cimglist_for(*this,l) {
        const CImg<T>& img = data[l];
        cimg_for(img,ptr,T) {
          const T val = *ptr;
          if (val<min_value) { min_value = val; ptrmin = ptr; }
          if (val>max_value) max_value = val;
        }
      }
      max_val = (t)max_value;
      return *ptrmin;
    }

operator bool ( ) const

inline

Return true if list is not empty.

Definition at line 34388 of file CImg.h.

                          {
      return !is_empty();
    }

CImg<T>& operator() ( const unsigned int  pos )

inline

Equivalent to CImgList<T>::operator[].

Definition at line 34369 of file CImg.h.

                                                {
      return (*this)[pos];
    }

const CImg<T>& operator() ( const unsigned int  pos ) const

inline

Definition at line 34373 of file CImg.h.

                                                            {
      return (*this)[pos];
    }

T& operator() ( const unsigned int  pos, const unsigned int  x, const unsigned int  y = 0, const unsigned int  z = 0, const unsigned int  v = 0  )

inline

Return a reference to (x,y,z,v) pixel of the pos-th image of the list.

Definition at line 34378 of file CImg.h.

                                                                  {
      return (*this)[pos](x,y,z,v);
    }

const T& operator() ( const unsigned int  pos, const unsigned int  x, const unsigned int  y = 0, const unsigned int  z = 0, const unsigned int  v = 0  ) const

inline

Definition at line 34382 of file CImg.h.

                                                                              {
      return (*this)[pos](x,y,z,v);
    }

CImgList<T> operator+ ( ) const

inline

Operator+() (unary).

Writting '+list' is a convenient shortcut to 'CImgList<T>(list,false)' (forces a copy with non-shared elements).

Definition at line 34423 of file CImg.h.

                                  {
      return CImgList<T>(*this,false);
    }

CImgList<T>& operator, ( const CImg< t > &  img )

inline

Operator,().

Definition at line 34429 of file CImg.h.

                                               {
      return insert(img);
    }

CImgList<T>& operator, ( const CImgList< t > &  list )

inline

Operator,().

Definition at line 34435 of file CImg.h.

                                                    {
      return insert(list);
    }

CImgList<T> operator< ( const char  axis ) const

inline

Operator<().

Definition at line 34445 of file CImg.h.

                                                 {
      return get_split(axis);
    }

CImgList<T>& operator= ( const CImg< t > &  img )

inline

Operator=().

Definition at line 34394 of file CImg.h.

                                               {
      return assign(img);
    }

CImgList<T>& operator= ( const CImgDisplay &  disp )

inline

Operator=().

Definition at line 34399 of file CImg.h.

                                                    {
      return assign(disp);
    }

CImgList<T>& operator= ( const CImgList< t > &  list )

inline

Operator=().

Definition at line 34405 of file CImg.h.

                                                    {
      return assign(list);
    }

CImgList<T>& operator= ( const CImgList< T > &  list )

inline

Definition at line 34409 of file CImg.h.

                                                    {
      return assign(list);
    }

CImgList<T>& operator= ( const char *const  filename )

inline

Operator=().

Definition at line 34414 of file CImg.h.

                                                       {
      return assign(filename);
    }

CImg<T> operator> ( const char  axis ) const

inline

Operator>().

Definition at line 34440 of file CImg.h.

                                             {
      return get_append(axis,'p');
    }

CImg<T>& operator[] ( const unsigned int  pos )

inline

Return a reference to the i-th element of the image list.

Definition at line 34346 of file CImg.h.

                                                {
#if cimg_debug>=3
      if (pos>=width) {
        cimg::warn("CImgList<%s>::operator[] : bad list position %u, in a list of %u images",
                   pixel_type(),pos,width);
        return *data;
      }
#endif
      return data[pos];
    }

const CImg<T>& operator[] ( const unsigned int  pos ) const

inline

Definition at line 34357 of file CImg.h.

                                                            {
#if cimg_debug>=3
      if (pos>=width) {
        cimg::warn("CImgList<%s>::operator[] : bad list position %u, in a list of %u images",
                   pixel_type(),pos,width);
        return *data;
      }
#endif
      return data[pos];
    }

static const char* pixel_type ( )

inlinestatic

Return a string describing the type of the image pixels in the list (template parameter T).

Definition at line 34460 of file CImg.h.

Referenced by CImgList< uintT >::_load_cimg(), CImgList< uintT >::_load_yuv(), CImgList< uintT >::_save_cimg(), CImgList< uintT >::_save_empty_cimg(), CImgList< uintT >::_save_yuv(), CImgList< uintT >::at(), CImgList< uintT >::atN(), CImgList< uintT >::atNX(), CImgList< uintT >::atNXY(), CImgList< uintT >::atNXYZ(), CImgList< uintT >::atNXYZV(), CImgList< uintT >::display(), CImgList< uintT >::FFT(), CImgList< uintT >::get_append(), CImgList< uintT >::get_images(), CImgList< uintT >::get_shared_images(), CImgList< uintT >::insert(), CImgList< uintT >::load(), CImgList< uintT >::load_ffmpeg(), CImgList< uintT >::load_ffmpeg_external(), CImgList< uintT >::load_gzip_external(), CImgList< uintT >::load_parrec(), CImgList< uintT >::load_tiff(), CImgList< uintT >::max(), CImgList< uintT >::maxmin(), CImgList< uintT >::min(), CImgList< uintT >::minmax(), CImgList< uintT >::operator[](), CImgList< uintT >::print(), CImgList< uintT >::remove(), CImgList< uintT >::save(), CImgList< uintT >::save_ffmpeg(), CImgList< uintT >::save_ffmpeg_external(), and CImgList< uintT >::save_gzip_external().

                                    {
      return cimg::type<T>::string();
    }

Here is the caller graph for this function:

CImgList<T>& pop_back ( )

inline

Remove last element of the list (STL-compliant name).

Definition at line 35427 of file CImg.h.

                            {
      return remove(width-1);
    }

CImgList<T>& pop_front ( )

inline

Remove first element of the list (STL-compliant name).

Definition at line 35432 of file CImg.h.

                             {
      return remove(0);
    }

const CImgList<T>& print ( const char *  title = 0, const bool  display_stats = true  ) const

inline

Print informations about the list on the standard output.

Definition at line 36269 of file CImg.h.

Referenced by CImgList< uintT >::display().

                                                                                       {
      unsigned int msiz = 0;
      cimglist_for(*this,l) msiz += data[l].size();
      msiz*=sizeof(T);
      const unsigned int mdisp = msiz<8*1024?0:(msiz<8*1024*1024?1:2);
      char ntitle[64] = { 0 };
      if (!title) std::sprintf(ntitle,"CImgList<%s>",pixel_type());
      std::fprintf(cimg_stdout,"%s: this = %p, size = %u [%u %s], data = (CImg<%s>*)%p..%p.\n",
                   title?title:ntitle,(void*)this,width,
                   mdisp==0?msiz:(mdisp==1?(msiz>>10):(msiz>>20)),
                   mdisp==0?"b":(mdisp==1?"Kb":"Mb"),
                   pixel_type(),(void*)begin(),(void*)((char*)end()-1));
      char tmp[16] = { 0 };
      cimglist_for(*this,ll) {
        std::sprintf(tmp,"[%d]",ll);
        std::fprintf(cimg_stdout,"  ");
        data[ll].print(tmp,display_stats);
        if (ll==3 && width>8) { ll = width-5; std::fprintf(cimg_stdout,"  ...\n"); }
      }
      return *this;
    }

Here is the caller graph for this function:

CImg<T>* ptr ( )

inline

Return a pointer to the image buffer.

Definition at line 34475 of file CImg.h.

Referenced by CImgList< uintT >::max(), CImgList< uintT >::maxmin(), CImgList< uintT >::min(), and CImgList< uintT >::minmax().

                   {
      return data;
    }

Here is the caller graph for this function:

const CImg<T>* ptr ( ) const

inline

Definition at line 34479 of file CImg.h.

                               {
      return data;
    }

CImg<T>* ptr ( const unsigned int  l )

inline

Return a pointer to the image buffer.

Definition at line 34498 of file CImg.h.

                                       {
      return data + l;
    }

const CImg<T>* ptr ( const unsigned int  l ) const

inline

Definition at line 34502 of file CImg.h.

                                                   {
      return data + l;
    }

CImgList<T>& push_back ( const CImg< t > &  img )

inline

Insert image img at the end of the list (STL-compliant name).

Definition at line 35404 of file CImg.h.

                                               {
      return insert(img);
    }

CImgList<T>& push_back ( const CImgList< t > &  list )

inline

Insert list list at the end of the current list (STL-compliant name).

Definition at line 35416 of file CImg.h.

                                                    {
      return insert(list);
    }

CImgList<T>& push_front ( const CImg< t > &  img )

inline

Insert image img at the front of the list (STL-compliant name).

Definition at line 35410 of file CImg.h.

                                                {
      return insert(img,0);
    }

CImgList<T>& push_front ( const CImgList< t > &  list )

inline

Insert list list at the front of the current list (STL-compliant name).

Definition at line 35422 of file CImg.h.

                                                     {
      return insert(list,0);
    }

CImgList<T>& remove ( const unsigned int  pos1, const unsigned int  pos2  )

inline

Remove the images from positions pos1 to pos2.

Definition at line 35173 of file CImg.h.

Referenced by CImgList< uintT >::get_remove(), and CImg< uintT >::sphere3d().

                                                                          {
      const unsigned int
        npos1 = pos1<pos2?pos1:pos2,
        tpos2 = pos1<pos2?pos2:pos1,
        npos2 = tpos2<width?tpos2:width-1;
      if (npos1>=width)
        cimg::warn("CImgList<%s>::remove() : Cannot remove images from a list (%p,%u), at positions %u->%u.",
                   pixel_type(),data,width,npos1,tpos2);
      else {
        if (tpos2>=width)
          cimg::warn("CImgList<%s>::remove() : Cannot remove all images from a list (%p,%u), at positions %u->%u.",
                     pixel_type(),data,width,npos1,tpos2);
        for (unsigned int k = npos1; k<=npos2; ++k) data[k].assign();
        const unsigned int nb = 1 + npos2 - npos1;
        if (!(width-=nb)) return assign();
        if (width>(allocated_width>>2) || allocated_width<=8) { // Removing items without reallocation.
          if (npos1!=width) std::memmove(data+npos1,data+npos2+1,sizeof(CImg<T>)*(width - npos1));
          std::memset(data + width,0,sizeof(CImg<T>)*nb);
        } else { // Removing items with reallocation.
          allocated_width>>=2;
          while (allocated_width>8 && width<(allocated_width>>1)) allocated_width>>=1;
          CImg<T> *new_data = new CImg<T>[allocated_width];
          if (npos1) std::memcpy(new_data,data,sizeof(CImg<T>)*npos1);
          if (npos1!=width) std::memcpy(new_data+npos1,data+npos2+1,sizeof(CImg<T>)*(width-npos1));
          if (width!=allocated_width) std::memset(new_data+width,0,sizeof(allocated_width - width));
          std::memset(data,0,sizeof(CImg<T>)*(width+nb));
          delete[] data;
          data = new_data;
        }
      }
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& remove ( const unsigned int  pos )

inline

Remove the image at position pos from the image list.

Definition at line 35211 of file CImg.h.

                                                {
      return remove(pos,pos);
    }

CImgList<T>& remove ( )

inline

Remove the last image from the image list.

Definition at line 35220 of file CImg.h.

                          {
      if (width) return remove(width-1);
      else cimg::warn("CImgList<%s>::remove() : List is empty",
                      pixel_type());
      return *this;
    }

CImgList<T>& reverse ( )

inline

Reverse list order.

Definition at line 35232 of file CImg.h.

Referenced by CImgList< uintT >::get_reverse().

                           {
      for (unsigned int l = 0; l<width/2; ++l) (*this)[l].swap((*this)[width-1-l]);
      return *this;
    }

Here is the caller graph for this function:

CImgList<T>& reverse_object3d ( )

inline

Invert primitives orientation of a 3D object.

Definition at line 37144 of file CImg.h.

Referenced by CImgList< uintT >::get_reverse_object3d().

                                    {
      cimglist_for(*this,l) {
        CImg<T>& p = data[l];
        const unsigned int siz = p.size();
        if (siz==2 || siz==3 || siz==6 || siz==9) cimg::swap(p[0],p[1]);
        else if (siz==4 || siz==12) cimg::swap(p[0],p[3],p[1],p[2]);
      }
      return *this;
    }

Here is the caller graph for this function:

const CImgList<T>& save ( const char *const  filename, const int  number = -1  ) const

inline

Save an image list into a file.

Depending on the extension of the given filename, a file format is chosen for the output file.

Definition at line 36342 of file CImg.h.

Referenced by CImgList< uintT >::save_gzip_external().

                                                                                   {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::save() : File '%s, instance list (%u,%p) is empty.",
                                    pixel_type(),filename?filename:"(null)",width,data);
      if (!filename)
        throw CImgArgumentException("CImg<%s>::save() : Instance list (%u,%p), specified filename is (null).",
                                    pixel_type(),width,data);
      const char *ext = cimg::split_filename(filename);
      char nfilename[1024] = { 0 };
      const char *const fn = (number>=0)?cimg::number_filename(filename,number,6,nfilename):filename;
#ifdef cimglist_save_plugin
      cimglist_save_plugin(fn);
#endif
#ifdef cimglist_save_plugin1
      cimglist_save_plugin1(fn);
#endif
#ifdef cimglist_save_plugin2
      cimglist_save_plugin2(fn);
#endif
#ifdef cimglist_save_plugin3
      cimglist_save_plugin3(fn);
#endif
#ifdef cimglist_save_plugin4
      cimglist_save_plugin4(fn);
#endif
#ifdef cimglist_save_plugin5
      cimglist_save_plugin5(fn);
#endif
#ifdef cimglist_save_plugin6
      cimglist_save_plugin6(fn);
#endif
#ifdef cimglist_save_plugin7
      cimglist_save_plugin7(fn);
#endif
#ifdef cimglist_save_plugin8
      cimglist_save_plugin8(fn);
#endif
#ifdef cimg_use_tiff
      if (!cimg::strcasecmp(ext,"tif") ||
          !cimg::strcasecmp(ext,"tiff")) return save_tiff(fn);
#endif
      if (!cimg::strcasecmp(ext,"cimgz")) return save_cimg(fn,true);
      if (!cimg::strcasecmp(ext,"cimg") || !ext[0]) return save_cimg(fn,false);
      if (!cimg::strcasecmp(ext,"yuv")) return save_yuv(fn,true);
      if (!cimg::strcasecmp(ext,"avi") ||
          !cimg::strcasecmp(ext,"mov") ||
          !cimg::strcasecmp(ext,"asf") ||
          !cimg::strcasecmp(ext,"divx") ||
          !cimg::strcasecmp(ext,"flv") ||
          !cimg::strcasecmp(ext,"mpg") ||
          !cimg::strcasecmp(ext,"m1v") ||
          !cimg::strcasecmp(ext,"m2v") ||
          !cimg::strcasecmp(ext,"m4v") ||
          !cimg::strcasecmp(ext,"mjp") ||
          !cimg::strcasecmp(ext,"mkv") ||
          !cimg::strcasecmp(ext,"mpe") ||
          !cimg::strcasecmp(ext,"movie") ||
          !cimg::strcasecmp(ext,"ogm") ||
          !cimg::strcasecmp(ext,"qt") ||
          !cimg::strcasecmp(ext,"rm") ||
          !cimg::strcasecmp(ext,"vob") ||
          !cimg::strcasecmp(ext,"wmv") ||
          !cimg::strcasecmp(ext,"xvid") ||
          !cimg::strcasecmp(ext,"mpeg")) return save_ffmpeg(fn);
      if (!cimg::strcasecmp(ext,"gz")) return save_gzip_external(fn);
      if (width==1) data[0].save(fn,-1); else cimglist_for(*this,l) data[l].save(fn,l);
      return *this;
    }

Here is the caller graph for this function:

const CImgList<T>& save_cimg ( std::FILE *  file, const bool  compress = false  ) const

inline

Save an image list into a CImg file (RAW binary file + simple header)

Definition at line 36752 of file CImg.h.

Referenced by CImgList< uintT >::save().

                                                                                 {
      return _save_cimg(file,0,compress);
    }

Here is the caller graph for this function:

const CImgList<T>& save_cimg ( const char *const  filename, const bool  compress = false  ) const

inline

Save an image list into a CImg file (RAW binary file + simple header)

Definition at line 36757 of file CImg.h.

                                                                                              {
      return _save_cimg(0,filename,compress);
    }

const CImgList<T>& save_cimg ( const char *const  filename, const unsigned int  n0, const unsigned int  x0, const unsigned int  y0, const unsigned int  z0, const unsigned int  v0  ) const

inline

Insert the instance image into into an existing .cimg file, at specified coordinates.

Definition at line 36870 of file CImg.h.

                                                                                     {
      return _save_cimg(0,filename,n0,x0,y0,z0,v0);
    }

const CImgList<T>& save_cimg ( std::FILE *const  file, const unsigned int  n0, const unsigned int  x0, const unsigned int  y0, const unsigned int  z0, const unsigned int  v0  ) const

inline

Insert the instance image into into an existing .cimg file, at specified coordinates.

Definition at line 36878 of file CImg.h.

                                                                                     {
      return _save_cimg(file,0,n0,x0,y0,z0,v0);
    }

static void save_empty_cimg ( const char *const  filename, const unsigned int  nb, const unsigned int  dx, const unsigned int  dy = 1, const unsigned int  dz = 1, const unsigned int  dv = 1  )

inlinestatic

Create an empty .cimg file with specified dimensions.

Definition at line 36901 of file CImg.h.

Referenced by CImg< uintT >::save_empty_cimg().

                                                                                  {
      return _save_empty_cimg(0,filename,nb,dx,dy,dz,dv);
    }

Here is the caller graph for this function:

static void save_empty_cimg ( std::FILE *const  file, const unsigned int  nb, const unsigned int  dx, const unsigned int  dy = 1, const unsigned int  dz = 1, const unsigned int  dv = 1  )

inlinestatic

Create an empty .cimg file with specified dimensions.

Definition at line 36909 of file CImg.h.

                                                                                  {
      return _save_empty_cimg(file,0,nb,dx,dy,dz,dv);
    }

const CImgList<T>& save_ffmpeg ( const char *const  filename, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const unsigned int  fps = 25  ) const

inline

Save an image sequence, using FFMPEG library.

Definition at line 36413 of file CImg.h.

Referenced by CImgList< uintT >::save().

                                                                    {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::save_ffmpeg() : File '%s', instance list (%u,%p) is empty.",
                                    pixel_type(),filename?filename:"(null)",width,data);
      if (!filename)
        throw CImgArgumentException("CImgList<%s>::save_ffmpeg() : Instance list (%u,%p), specified filename is (null).",
                                    pixel_type(),width,data);
      if (!fps)
        throw CImgArgumentException("CImgList<%s>::save_ffmpeg() : File '%s', specified framerate is 0.",
                                    pixel_type(),filename);
      const unsigned int nlast_frame = last_frame==~0U?width-1:last_frame;
      if (first_frame>=width || nlast_frame>=width)
        throw CImgArgumentException("CImgList<%s>::save_ffmpeg() : File '%s', specified frames [%u,%u] are out of list range (%u elements).",
                                    pixel_type(),filename,first_frame,last_frame,width);
      for (unsigned int ll = first_frame; ll<=nlast_frame; ++ll) if (!data[ll].is_sameXYZ(data[0]))
        throw CImgInstanceException("CImgList<%s>::save_ffmpeg() : File '%s', images of the sequence have different dimensions.",
                                    pixel_type(),filename);

#ifndef cimg_use_ffmpeg
      return save_ffmpeg_external(filename,first_frame,last_frame);
#else
      avcodec_register_all();
      av_register_all();
      const int
        frame_dimx = data[first_frame].dimx(),
        frame_dimy = data[first_frame].dimy(),
        frame_dimv = data[first_frame].dimv();
      if (frame_dimv!=1 && frame_dimv!=3)
        throw CImgInstanceException("CImgList<%s>::save_ffmpeg() : File '%s', image[0] (%u,%u,%u,%u,%p) has not 1 or 3 channels.",
                                    pixel_type(),filename,data[0].width,data[0].height,data[0].depth,data[0].dim,data);

      PixelFormat dest_pxl_fmt = PIX_FMT_YUV420P;
      PixelFormat src_pxl_fmt  = (frame_dimv == 3)?PIX_FMT_RGB24:PIX_FMT_GRAY8;

      int sws_flags = SWS_FAST_BILINEAR; // Interpolation method (keeping same size images for now).
      AVOutputFormat *fmt = 0;
      fmt = guess_format(0,filename,0);
      if (!fmt) fmt = guess_format("mpeg",0,0); // Default format "mpeg".
      if (!fmt)
        throw CImgArgumentException("CImgList<%s>::save_ffmpeg() : File '%s', could not determine file format from filename.",
                                    pixel_type(),filename);

      AVFormatContext *oc = 0;
      oc = av_alloc_format_context();
      if (!oc) // Failed to allocate format context.
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate structure for format context.",
                              pixel_type(),filename);

      AVCodec *codec = 0;
      AVFrame *picture = 0;
      AVFrame *tmp_pict = 0;
      oc->oformat = fmt;
      std::sprintf(oc->filename,"%s",filename);

      // Add video stream.
      int stream_index = 0;
      AVStream *video_str = 0;
      if (fmt->video_codec!=CODEC_ID_NONE) {
        video_str = av_new_stream(oc,stream_index);
        if (!video_str) { // Failed to allocate stream.
          av_free(oc);
          throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate video stream structure.",
                                pixel_type(),filename);
        }
      } else { // No codec identified.
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', no proper codec identified.",
                              pixel_type(),filename);
      }

      AVCodecContext *c = video_str->codec;
      c->codec_id = fmt->video_codec;
      c->codec_type = CODEC_TYPE_VIDEO;
      c->bit_rate = 400000;
      c->width = frame_dimx;
      c->height = frame_dimy;
      c->time_base.num = 1;
      c->time_base.den = fps;
      c->gop_size = 12;
      c->pix_fmt = dest_pxl_fmt;
      if (c->codec_id == CODEC_ID_MPEG2VIDEO) c->max_b_frames = 2;
      if (c->codec_id == CODEC_ID_MPEG1VIDEO) c->mb_decision = 2;

      if (av_set_parameters(oc,0)<0) { // Parameters not properly set.
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', parameters for avcodec not properly set.",
                              pixel_type(),filename);
      }

      // Open codecs and alloc buffers.
      codec = avcodec_find_encoder(c->codec_id);
      if (!codec) { // Failed to find codec.
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', no codec found.",
                              pixel_type(),filename);
      }
      if (avcodec_open(c,codec)<0) // Failed to open codec.
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to open codec.",
                              pixel_type(),filename);
      tmp_pict = avcodec_alloc_frame();
      if (!tmp_pict) { // Failed to allocate memory for tmp_pict frame.
        avcodec_close(video_str->codec);
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate memory for data buffer.",
                              pixel_type(),filename);
      }
      tmp_pict->linesize[0] = (src_pxl_fmt==PIX_FMT_RGB24)?3*frame_dimx:frame_dimx;
      tmp_pict->type = FF_BUFFER_TYPE_USER;
      int tmp_size = avpicture_get_size(src_pxl_fmt,frame_dimx,frame_dimy);
      uint8_t *tmp_buffer = (uint8_t*)av_malloc(tmp_size);
      if (!tmp_buffer) { // Failed to allocate memory for tmp buffer.
        av_free(tmp_pict);
        avcodec_close(video_str->codec);
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate memory for data buffer.",
                              pixel_type(),filename);
      }

      // Associate buffer with tmp_pict.
      avpicture_fill((AVPicture*)tmp_pict,tmp_buffer,src_pxl_fmt,frame_dimx,frame_dimy);
      picture = avcodec_alloc_frame();
      if (!picture) { // Failed to allocate picture frame.
        av_free(tmp_pict->data[0]);
        av_free(tmp_pict);
        avcodec_close(video_str->codec);
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate memory for picture frame.",
                              pixel_type(),filename);
      }

      int size = avpicture_get_size(c->pix_fmt,frame_dimx,frame_dimy);
      uint8_t *buffer = (uint8_t*)av_malloc(size);
      if (!buffer) { // Failed to allocate picture frame buffer.
        av_free(picture);
        av_free(tmp_pict->data[0]);
        av_free(tmp_pict);
        avcodec_close(video_str->codec);
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to allocate memory for picture frame buffer.",
                              pixel_type(),filename);
      }

      // Associate the buffer with picture.
      avpicture_fill((AVPicture*)picture,buffer,c->pix_fmt,frame_dimx,frame_dimy);

      // Open file.
      if (!(fmt->flags&AVFMT_NOFILE)) {
        if (url_fopen(&oc->pb,filename,URL_WRONLY)<0)
          throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s' cannot be opened.",
                                pixel_type(),filename);
      }

      if (av_write_header(oc)<0)
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', could not write header.",
                              pixel_type(),filename);
      double video_pts;
      SwsContext *img_convert_context = 0;
      img_convert_context = sws_getContext(frame_dimx,frame_dimy,src_pxl_fmt,
                                           c->width,c->height,c->pix_fmt,sws_flags,0,0,0);
      if (!img_convert_context) { // Failed to get swscale context.
        // if (!(fmt->flags & AVFMT_NOFILE)) url_fclose(&oc->pb);
        av_free(picture->data);
        av_free(picture);
        av_free(tmp_pict->data[0]);
        av_free(tmp_pict);
        avcodec_close(video_str->codec);
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%', failed to get conversion context.",
                              pixel_type(),filename);
      }
      int ret = 0, out_size;
      uint8_t *video_outbuf = 0;
      int video_outbuf_size = 1000000;
      video_outbuf = (uint8_t*)av_malloc(video_outbuf_size);
      if (!video_outbuf) {
        // if (!(fmt->flags & AVFMT_NOFILE)) url_fclose(&oc->pb);
        av_free(picture->data);
        av_free(picture);
        av_free(tmp_pict->data[0]);
        av_free(tmp_pict);
        avcodec_close(video_str->codec);
        av_free(oc);
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', memory allocation error.",
                              pixel_type(),filename);
      }

      // Loop through each desired image in list.
      for (unsigned int i = first_frame; i<=nlast_frame; ++i) {
        CImg<uint8_t> currentIm = data[i], red, green, blue, gray;
        if (src_pxl_fmt == PIX_FMT_RGB24) {
          red = currentIm.get_shared_channel(0);
          green = currentIm.get_shared_channel(1);
          blue = currentIm.get_shared_channel(2);
          cimg_forXY(currentIm,X,Y) { // Assign pizel values to data buffer in interlaced RGBRGB ... format.
            tmp_pict->data[0][Y*tmp_pict->linesize[0] + 3*X]     = red(X,Y);
            tmp_pict->data[0][Y*tmp_pict->linesize[0] + 3*X + 1] = green(X,Y);
            tmp_pict->data[0][Y*tmp_pict->linesize[0] + 3*X + 2] = blue(X,Y);
          }
        } else {
          gray = currentIm.get_shared_channel(0);
          cimg_forXY(currentIm,X,Y) tmp_pict->data[0][Y*tmp_pict->linesize[0] + X] = gray(X,Y);
        }

        if (video_str) video_pts = (video_str->pts.val * video_str->time_base.num)/(video_str->time_base.den);
        else video_pts = 0.0;
        if (!video_str) break;
        if (sws_scale(img_convert_context,tmp_pict->data,tmp_pict->linesize,0,c->height,picture->data,picture->linesize)<0) break;
        out_size = avcodec_encode_video(c,video_outbuf,video_outbuf_size,picture);
        if (out_size>0) {
          AVPacket pkt;
          av_init_packet(&pkt);
          pkt.pts = av_rescale_q(c->coded_frame->pts,c->time_base,video_str->time_base);
          if (c->coded_frame->key_frame) pkt.flags|=PKT_FLAG_KEY;
          pkt.stream_index = video_str->index;
          pkt.data = video_outbuf;
          pkt.size = out_size;
          ret = av_write_frame(oc,&pkt);
        } else if (out_size<0) break;
        if (ret) break; // Error occured in writing frame.
      }

      // Close codec.
      if (video_str) {
        avcodec_close(video_str->codec);
        av_free(picture->data[0]);
        av_free(picture);
        av_free(tmp_pict->data[0]);
        av_free(tmp_pict);
      }
      if (av_write_trailer(oc)<0)
        throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to write trailer.",
                              pixel_type(),filename);
      av_freep(&oc->streams[stream_index]->codec);
      av_freep(&oc->streams[stream_index]);
      if (!(fmt->flags&AVFMT_NOFILE)) {
        /*if (url_fclose(oc->pb)<0)
          throw CImgIOException("CImgList<%s>::save_ffmpeg() : File '%s', failed to close file.",
          pixel_type(),filename);
        */
      }
      av_free(oc);
      av_free(video_outbuf);
#endif
      return *this;
    }

Here is the caller graph for this function:

const CImgList<T>& save_ffmpeg_external ( const char *const  filename, const unsigned int  first_frame = 0, const unsigned int  last_frame = ~0U, const char *const  codec = "mpeg2video"  ) const

inline

Save an image sequence using the external tool 'ffmpeg'.

Definition at line 36975 of file CImg.h.

Referenced by CImgList< uintT >::save_ffmpeg().

                                                                                        {
      if (is_empty())
        throw CImgInstanceException("CImgList<%s>::save_ffmpeg_external() : File '%s', instance list (%u,%p) is empty.",
                                    pixel_type(),filename?filename:"(null)",width,data);
      if (!filename)
        throw CImgArgumentException("CImgList<%s>::save_ffmpeg_external() : Instance list (%u,%p), specified filename is (null).",
                                    pixel_type(),width,data);
      char command[1024] = { 0 }, filetmp[512] = { 0 }, filetmp2[512] = { 0 };
      std::FILE *file = 0;
      const unsigned int nlast_frame = last_frame==~0U?width-1:last_frame;
      if (first_frame>=width || nlast_frame>=width)
        throw CImgArgumentException("CImgList<%s>::save_ffmpeg_external() : File '%s', specified frames [%u,%u] are out of list range (%u elements).",
                                    pixel_type(),filename,first_frame,last_frame,width);
      for (unsigned int ll = first_frame; ll<=nlast_frame; ++ll) if (!data[ll].is_sameXYZ(data[0]))
        throw CImgInstanceException("CImgList<%s>::save_ffmpeg_external() : File '%s', all images of the sequence must be of the same dimension.",
                                    pixel_type(),filename);
      do {
        std::sprintf(filetmp,"%s%c%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());
        std::sprintf(filetmp2,"%s_000001.ppm",filetmp);
        if ((file=std::fopen(filetmp2,"rb"))!=0) std::fclose(file);
      } while (file);
      for (unsigned int l = first_frame; l<=nlast_frame; ++l) {
        std::sprintf(filetmp2,"%s_%.6u.ppm",filetmp,l+1);
        if (data[l].depth>1 || data[l].dim!=3) data[l].get_resize(-100,-100,1,3).save_pnm(filetmp2);
        else data[l].save_pnm(filetmp2);
      }
#if cimg_OS!=2
      std::sprintf(command,"ffmpeg -i %s_%%6d.ppm -vcodec %s -sameq -y \"%s\" >/dev/null 2>&1",filetmp,codec,filename);
#else
      std::sprintf(command,"\"ffmpeg -i %s_%%6d.ppm -vcodec %s -sameq -y \"%s\"\" >NUL 2>&1",filetmp,codec,filename);
#endif
      cimg::system(command);
      file = std::fopen(filename,"rb");
      if (!file)
        throw CImgIOException("CImg<%s>::save_ffmpeg_external() : Failed to save image sequence '%s'.\n\n",
                              pixel_type(),filename);
      else cimg::fclose(file);
      cimglist_for(*this,lll) { std::sprintf(filetmp2,"%s_%.6u.ppm",filetmp,lll+1); std::remove(filetmp2); }
      return *this;
    }

Here is the caller graph for this function:

const CImgList<T>& save_gzip_external ( const char *const  filename ) const

inline

Save a file in TIFF format.

Save an image list as a gzipped file, using external tool 'gzip'.

Definition at line 36943 of file CImg.h.

Referenced by CImgList< uintT >::save().

                                                                            {
      if (!filename)
        throw CImgIOException("CImg<%s>::save_gzip_external() : Cannot save (null) filename.",
                              pixel_type());
      char command[1024] = { 0 }, filetmp[512] = { 0 }, body[512] = { 0 };
      const char
        *ext = cimg::split_filename(filename,body),
        *ext2 = cimg::split_filename(body,0);
      std::FILE *file;
      do {
        if (!cimg::strcasecmp(ext,"gz")) {
          if (*ext2) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext2);
          else std::sprintf(filetmp,"%s%c%s.cimg",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());
        } else {
          if (*ext) std::sprintf(filetmp,"%s%c%s.%s",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand(),ext);
          else std::sprintf(filetmp,"%s%c%s.cimg",cimg::temporary_path(),cimg_file_separator,cimg::filenamerand());
        }
        if ((file=std::fopen(filetmp,"rb"))!=0) std::fclose(file);
      } while (file);
      save(filetmp);
      std::sprintf(command,"%s -c %s > \"%s\"",cimg::gzip_path(),filetmp,filename);
      cimg::system(command);
      file = std::fopen(filename,"rb");
      if (!file)
        throw CImgIOException("CImgList<%s>::save_gzip_external() : File '%s' cannot be saved.",
                              pixel_type(),filename);
      else cimg::fclose(file);
      std::remove(filetmp);
      return *this;
    }

Here is the caller graph for this function:

const CImgList<T>& save_yuv ( const char *const  filename = 0, const bool  rgb2yuv = true  ) const

inline

Save an image sequence into a YUV file.

Definition at line 36685 of file CImg.h.

Referenced by CImgList< uintT >::save().

                                                                                             {
      return _save_yuv(0,filename,rgb2yuv);
    }

Here is the caller graph for this function:

const CImgList<T>& save_yuv ( std::FILE *const  file, const bool  rgb2yuv = true  ) const

inline

Save an image sequence into a YUV file.

Definition at line 36690 of file CImg.h.

                                                                                    {
      return _save_yuv(file,0,rgb2yuv);
    }

unsigned int size ( ) const

inline

Return the size of the list.

Definition at line 34470 of file CImg.h.

Referenced by CImg< uintT >::_display_object3d(), CImg< uintT >::_save_off(), CImg< uintT >::draw_spline(), CImgList< uintT >::save_ffmpeg(), and CImgList< uintT >::transfer_to().

                              {
      return width;
    }

Here is the caller graph for this function:

CImgList<T>& split ( const char  axis, const int  nb = 0  )

inline

Return a list where each image has been split along the specified axis.

Definition at line 35392 of file CImg.h.

                                                        {
      return get_split(axis,nb).transfer_to(*this);
    }

CImgList<T>& swap ( CImgList< T > &  list )

inline

Swap all fields of two CImgList instances (use with care !)

Definition at line 34325 of file CImg.h.

Referenced by CImgList< uintT >::reverse(), and CImgList< uintT >::transfer_to().

                                         {
      cimg::swap(width,list.width);
      cimg::swap(allocated_width,list.allocated_width);
      cimg::swap(data,list.data);
      return list;
    }

Here is the caller graph for this function:

CImgList<T>& transfer_to ( CImgList< t > &  list )

inline

Transfer the content of the instance image list into another one.

Definition at line 34302 of file CImg.h.

Referenced by cimg_library::cimg::dialog(), CImgList< uintT >::get_crop_font(), CImg< uintT >::load_cimg(), CImg< uintT >::load_parrec(), CImgList< uintT >::load_parrec(), and CImgList< uintT >::value_string().

                                                {
      list.assign(size());
      cimglist_for(*this,l) data[l].transfer_to(list[l]);
      assign();
      return list;
    }

Here is the caller graph for this function:

CImgList<T>& transfer_to ( CImgList< T > &  list )

inline

Definition at line 34309 of file CImg.h.

                                                {
      list.assign();
      return swap(list);
    }

CImgList<t>& transfer_to ( CImgList< t > &  list, const unsigned int  pos  )

inline

Definition at line 34315 of file CImg.h.

                                                                        {
      if (is_empty()) return list;
      const unsigned int npos = pos>list.width?list.width:pos;
      list.insert(width,npos);
      cimglist_for(*this,l) (*this)[l].transfer_to(list.at(npos+l));
      assign();
      return list;
    }

CImg<charT> value_string ( const char  separator = ',', const unsigned int  max_size = 0  ) const

inline

Return a C-string containing the values of all images in the instance list.

Definition at line 34712 of file CImg.h.

                                                                                            {
      if (is_empty()) return CImg<ucharT>(1,1,1,1,0);
      CImgList<charT> items;
      for (unsigned int l = 0; l<width-1; ++l) {
        CImg<charT> item = data[l].value_string(separator,0);
        item.back() = separator;
        item.transfer_to(items);
      }
      data[width-1].value_string(separator,0).transfer_to(items);
      CImg<charT> res; (items>'x').transfer_to(res);
      if (max_size) { res.crop(0,max_size); res(max_size) = 0; }
      return res;
    }

Member Data Documentation

unsigned int allocated_width

Allocation size of the list.

Definition at line 33886 of file CImg.h.

Referenced by CImgList< uintT >::assign(), CImgList< uintT >::CImgList(), CImgList< uintT >::insert(), CImgList< uintT >::remove(), and CImgList< uintT >::swap().

CImg<T>* data

Pointer to the first list element.

Definition at line 33889 of file CImg.h.

Referenced by CImgList< uintT >::_atN(), CImgList< uintT >::_atNX(), CImgList< uintT >::_atNXY(), CImgList< uintT >::_atNXYZ(), CImgList< uintT >::_atNXYZV(), CImg< uintT >::_draw_text(), CImgList< uintT >::_save_cimg(), CImgList< uintT >::_save_yuv(), CImgList< uintT >::assign(), CImgList< uintT >::at(), CImgList< uintT >::atNX(), CImgList< uintT >::atNXY(), CImgList< uintT >::atNXYZ(), CImgList< uintT >::atNXYZV(), CImgList< uintT >::back(), CImgList< uintT >::begin(), CImgList< uintT >::CImgList(), CImgList< uintT >::contains(), CImgList< uintT >::containsNXYZV(), CImgList< uintT >::display(), CImgList< uintT >::end(), CImgList< uintT >::erase(), CImgList< uintT >::FFT(), CImgList< uintT >::front(), CImgList< uintT >::get_images(), CImgList< uintT >::get_shared(), CImgList< uintT >::get_shared_images(), CImgList< uintT >::get_split(), CImgList< uintT >::insert(), CImgList< uintT >::is_empty(), CImgList< uintT >::is_sameXYZV(), CImgList< uintT >::load(), CImgList< uintT >::load_tiff(), CImgList< uintT >::max(), CImgList< uintT >::maxmin(), CImgList< uintT >::min(), CImgList< uintT >::minmax(), CImgList< uintT >::operator[](), CImgList< uintT >::print(), CImgList< uintT >::ptr(), CImgList< uintT >::remove(), CImgList< uintT >::reverse_object3d(), CImgList< uintT >::save(), CImgList< uintT >::save_ffmpeg(), CImgList< uintT >::save_ffmpeg_external(), CImgList< uintT >::swap(), CImgList< uintT >::transfer_to(), CImgList< uintT >::value_string(), and CImgList< uintT >::~CImgList().

unsigned int width

Size of the list (number of images).

Definition at line 33883 of file CImg.h.

Referenced by CImg< uintT >::_display_object3d(), CImg< uintT >::_draw_object3d(), CImg< uintT >::_draw_text(), CImg< uintT >::_load_off(), CImg< uintT >::_save_off(), CImg< uintT >::append_object3d(), CImgDisplay::assign(), CImgList< uintT >::assign(), CImgList< uintT >::CImgList(), CImgList< uintT >::dimx(), CImg< uintT >::draw_line(), CImg< uintT >::draw_object3d(), CImg< uintT >::draw_point(), CImg< uintT >::draw_polygon(), CImg< uintT >::draw_spline(), CImgList< uintT >::end(), CImg< uintT >::is_object3d(), CImg< uintT >::isocurve3d(), CImg< uintT >::isosurface3d(), CImg< uintT >::load_cimg(), CImg< uintT >::load_parrec(), CImgList< uintT >::load_parrec(), CImgList< uintT >::size(), CImg< uintT >::sphere3d(), and CImg< uintT >::transfer_to().

---

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

• CImg.h