Tutorial Images - Revision history

Peter at 15:15, 29 March 2016

2016-03-29T15:15:46Z

← Older revision		Revision as of 15:15, 29 March 2016
Line 65:		Line 65:
	The easiest way to access a pixel is using the set() and get() functions. However pixels can also be accessed directly.		The easiest way to access a pixel is using the set() and get() functions. However pixels can also be accessed directly.
	<pre>		<pre>
	~~ImageFloat32~~ image = new ~~ImageFloat32~~(60,60);		GrayF32 image = new GrayF32(60,60);

	int x = 10;		int x = 10;

Peter at 15:14, 29 March 2016

2016-03-29T15:14:55Z

← Older revision		Revision as of 15:14, 29 March 2016
Line 31:		Line 31:
	{\|		{\|
	\|-		\|-
	! Class ~~inheritance diagram~~ for ~~high level image types~~		! Class Inheritance Diagram for High Level Image Types
	\|-		\|-
	\| [[File:Image_type_class_diagram.png]]		\| [[File:Image_type_class_diagram.png]]
Line 38:		Line 38:
	All image types extend the abstract ImageBase class. ImageBase proves basic information on the size, shape, and internal structure of the class. Immediate children of ImageBase are ImageGray, Interleaved, and Planar. ImageGray contain only one intensity value per pixel and can also be referred to as a gray scale image. Interleaved stores color information in adjacent elements for the same pixel. Planar contains each color band as its own gray scale image. Once advantage to Planar images is that the individual bands can be treated as ImageGray, which is exactly what they are.		All image types extend the abstract ImageBase class. ImageBase proves basic information on the size, shape, and internal structure of the class. Immediate children of ImageBase are ImageGray, Interleaved, and Planar. ImageGray contain only one intensity value per pixel and can also be referred to as a gray scale image. Interleaved stores color information in adjacent elements for the same pixel. Planar contains each color band as its own gray scale image. Once advantage to Planar images is that the individual bands can be treated as ImageGray, which is exactly what they are.

	= ~~Single Band Images~~ =		= Image Gray =

	{\|		{\|
	\|-		\|-
	! Class ~~inheritance diagram~~ for ~~single band images~~		! Class Inheritance Diagram for ImageGray
	\|-		\|-
	\| [[File:Image_type_single_class_diagram.png]]		\| [[File:Image_type_single_class_diagram.png]]
	\|}		\|}

	~~Single~~ band-images ~~are~~ gray scale images which represent an image using a single color or band. They are easier to work with the multi-band data and more commonly used in computer vision because they are faster to work with. ~~The down side to working with gray scale images is that to create one often requires throwing away valuable color information.~~		Gray images are single-band images (a.k.a. gray scale images) which represent an image using a single color or band. They are easier to work with the multi-band data and more commonly used in computer vision because they are faster to work with and much of the visual information is contained in a single band.

	== Data Structure ==		== Internal Data Structure ==

	All images in BoofCV extend ImageBase and ~~have~~ the following ~~data~~ structure:		All images in BoofCV extend ImageBase and has the following structure:
	<pre>		<pre>
	public int startIndex;		public int startIndex;
Line 89:		Line 89:

	= Interleaved Images =		= Interleaved Images =


			{\|
			\|-
			! Class Inheritance Diagram for Interleaved Images
			\|-
			\| [[File:Image_type_interleaved_diagram.png]]
			\|}



	= Planar Images =		= Planar Images =

Peter at 05:40, 29 March 2016

2016-03-29T05:40:27Z

← Older revision		Revision as of 05:40, 29 March 2016
Line 96:		Line 96:
	Working with Planar images is easy. To access the intensity of a pixel in different colors, simply access the image for that band then use the gray scale accessors functions. Below a code sniplet shows how to create a multi spectral image and set the pixel at (5,5) to have a value of (255,50,50), which would appear to be red in an RGB image.		Working with Planar images is easy. To access the intensity of a pixel in different colors, simply access the image for that band then use the gray scale accessors functions. Below a code sniplet shows how to create a multi spectral image and set the pixel at (5,5) to have a value of (255,50,50), which would appear to be red in an RGB image.
	<pre>		<pre>
	~~MultiSpectral~~<~~ImageUInt8~~> image = new ~~MultiSpectral~~<~~ImageUInt8~~>(~~ImageUInt8~~.class,100,200,3);		Planar<GrayU8> image = new Planar<GrayU8>(GrayU8.class,100,200,3);
	image.getBand(0).set(5,5,255);		image.getBand(0).set(5,5,255);
	image.getBand(1).set(5,5,50);		image.getBand(1).set(5,5,50);

Peter at 05:34, 29 March 2016

2016-03-29T05:34:37Z

← Older revision		Revision as of 05:34, 29 March 2016
Line 1:		Line 1:
	Its not surprising that images play a key role inside of BoofCV, since its a computer vision library. Images are 2D arrays which store pixel intensity values, where a single pixel represents the output of a optical sensor. In BoofCV to help catch more errors at compile time and to ensure more meaningful error messages ~~it provides~~ several different types of images. The more standard approach (such as is done in Java2D or OpenCV) is to provide a single data type which can represent many different image types.		Its not surprising that images play a key role inside of BoofCV, since its a computer vision library. Images are 2D arrays which store pixel intensity values, where a single pixel represents the output of a optical sensor. In BoofCV, to help catch more errors at compile time and to ensure more meaningful error messages, several different types of images are provided. The more standard approach (such as is done in Java2D or OpenCV) is to provide a single data type which can represent many different image types.

	There is one image type for each primitive data ~~structure~~, including signed and unsigned data types. For example, GrayF32 and GrayU8 represent single band images containing 32-bit floats and unsigned 8-bit integer pixels, respectively. ~~At the time of this writing, BoofCV primarily supports only single band or gray scale images with some support for~~ color image ~~processing~~. The ~~reason for this~~ is ~~because most computer vision routines~~ are ~~only designed for gray scale images~~.		There is one image type for each primitive data element, including signed and unsigned data types. For example, GrayF32 and GrayU8 represent single band images containing 32-bit floats and unsigned 8-bit integer pixels, respectively. Two color image formats are supported, Planar and Interleaved in different parts of the code. Which one is supported depends on which one is the most advantageous for the algorithm.

			The type of primitive data structure contained in a class is specified with a suffix. Not all data types are supported due to language limitations found in Java, e.g. no unsigned 64-bit integer.
			; U8
			: Unsigned 8-bit integer
			; S8
			: Signed 8-bit integer
			; U16
			: Unsigned 16-bit integer
			; S16
			: Signed 16-bit integer
			; S32
			: Signed 32-bit integer
			; S64
			: Signed 64-bit integer
			; F32
			: Floating point 32-bit
			; F64
			: Floating point 64-bit

	~~Naming Scheme:~~
	~~; Single Band Floating Point Images~~
	: GrayF*
	~~: * indicates the number of bits. 32 bits and 64 bits are supported.~~
	~~; Single Band Integer Images~~
	: Gray**
	~~: The first * can be S or U for signed or unsigned.~~
	~~: The second * is the number of bits and can be 8,16,32, or 64.~~
	~~; Multi-Band Planar Images~~
	~~: Planar<*>~~
	~~: Where * is the name of a gray scale image~~
	~~; Multi-Band Interleaved Images~~
	: Interleaved*
	~~: where * is a specific type using the same scheme as gray-scale images~~

	= Why not use BufferedImage? =		= Why not use BufferedImage? =
Line 23:		Line 27:
	BoofCV provides several routines for quickly converting BufferedImage into BoofCV images. Using BoofCV routines for converting to/from BufferedImages are very fast because they access low level rasters inside of BufferedImage and gracefully handle situations where access is blocked to the rasters (e.g. Applets).		BoofCV provides several routines for quickly converting BufferedImage into BoofCV images. Using BoofCV routines for converting to/from BufferedImages are very fast because they access low level rasters inside of BufferedImage and gracefully handle situations where access is blocked to the rasters (e.g. Applets).

	= Image ~~Types~~ =		= Image Families =

	{\|		{\|
Line 32:		Line 36:
	\|}		\|}

	~~BoofCV supports both color and single band images.~~ All image types extend the abstract ImageBase class. ImageBase proves basic information on the size, shape, and internal structure of the class. Immediate children of ImageBase are ~~ImageSingleBand and MultiSpectral~~, ~~which provide support for gray scale~~ and ~~color image processing, respectively~~.		All image types extend the abstract ImageBase class. ImageBase proves basic information on the size, shape, and internal structure of the class. Immediate children of ImageBase are ImageGray, Interleaved, and Planar. ImageGray contain only one intensity value per pixel and can also be referred to as a gray scale image. Interleaved stores color information in adjacent elements for the same pixel. Planar contains each color band as its own gray scale image. Once advantage to Planar images is that the individual bands can be treated as ImageGray, which is exactly what they are.

	~~ImageSingleBand~~ contain only one intensity value per pixel and can also be referred to as a gray scale image. ~~MultiSpectral~~ contains each color band as its own gray scale image. ~~Any operation which can process an ImageSingleBand can process one of~~ the bands ~~inside of a MultiSpectral image~~, ~~allowing for fast implementation of some color image processing and computer vision algorithms. In the future interleaved color images will also be supported~~.

	= Single Band Images =		= Single Band Images =
Line 81:		Line 83:

	<pre>		<pre>
	~~ImageUInt8~~ image = new ~~ImageUInt8~~(60,60);		GrayU8 image = new GrayU8(60,60);
	image.set(x,y,45);		image.set(x,y,45);
	int value = image.data[ image.startIndex + y*image.stride + x] & 0xFF;		int value = image.data[ image.startIndex + y*image.stride + x] & 0xFF;
	</pre>		</pre>

	= ~~Multi Spectral~~ Images =		= Interleaved Images =

			= Planar Images =

	~~MultiSpectral~~ images are color images where each color band is stored as a separate gray scale image. Storing color images in this format is less common than the typical interleaved format, but allows color images to be easily processed using highly optimized gray scale code that is common throughout BoofCV~~. The main disadvantage is that for some algorithm types an interleaved image will be faster to process when color information can not be processes in each band independently~~.		Planar images are color images where each color band is stored as a separate gray scale image. Storing color images in this format is less common than the typical interleaved format, but allows color images to be easily processed using highly optimized gray scale code that is common throughout BoofCV.

	Working with ~~MultiSpectral~~ images is easy. To access the intensity of a pixel in different colors, simply access the image for that band then use the gray scale accessors functions. Below a code sniplet shows how to create a multi spectral image and set the pixel at (5,5) to have a value of (255,50,50), which would appear to be red in an RGB image.		Working with Planar images is easy. To access the intensity of a pixel in different colors, simply access the image for that band then use the gray scale accessors functions. Below a code sniplet shows how to create a multi spectral image and set the pixel at (5,5) to have a value of (255,50,50), which would appear to be red in an RGB image.
	<pre>		<pre>
	MultiSpectral<ImageUInt8> image = new MultiSpectral<ImageUInt8>(ImageUInt8.class,100,200,3);		MultiSpectral<ImageUInt8> image = new MultiSpectral<ImageUInt8>(ImageUInt8.class,100,200,3);
Line 104:		Line 108:
	<pre>		<pre>
	public static void main( String args[] ) {		public static void main( String args[] ) {
	~~ImageFloat32~~ image = new ~~ImageFloat32~~(100,100);		GrayF32 image = new GrayF32(100,100);
	~~ImageFloat32~~ sub = image.subimage(10,15,30,30);		GrayF32 sub = image.subimage(10,15,30,30);

	sub.set(0,0,100);		sub.set(0,0,100);
Line 121:		Line 125:
	Type specific code:		Type specific code:
	<pre>		<pre>
	public static ~~ImageUInt8~~ typeSpecific( ~~ImageUInt8~~ image ) {		public static GrayU8 typeSpecific( GrayU8 image ) {
	~~ImageUInt8~~ output = new ~~ImageUInt8~~(image.width,image.height);		GrayU8 output = new GrayU8(image.width,image.height);

	BlurImageOps.gaussian(image,output,-1,2,null);		BlurImageOps.gaussian(image,output,-1,2,null);

Peter at 13:05, 28 March 2016

2016-03-28T13:05:41Z

← Older revision		Revision as of 13:05, 28 March 2016
Line 1:		Line 1:
	Its not surprising that images play a key role inside of BoofCV, since its a computer vision library. Images are 2D arrays which store pixel intensity values, where a single pixel represents the output of a optical sensor. In BoofCV to help catch more errors at compile time and to ensure more meaningful error messages it provides several different types of images. The more standard approach (such as is done in Java2D or OpenCV) is to provide a single data type which can represent many different image types.		Its not surprising that images play a key role inside of BoofCV, since its a computer vision library. Images are 2D arrays which store pixel intensity values, where a single pixel represents the output of a optical sensor. In BoofCV to help catch more errors at compile time and to ensure more meaningful error messages it provides several different types of images. The more standard approach (such as is done in Java2D or OpenCV) is to provide a single data type which can represent many different image types.

	There is one image type for each primitive data structure, including signed and unsigned data types. For example, ~~ImageFloat32~~ and ~~ImageUInt8~~ represent single band images containing 32-bit floats and unsigned 8-bit pixels, respectively. At the time of this writing, BoofCV primarily supports only single band or gray scale images with some support for color image processing. The reason for this is because most computer vision routines are only designed for gray scale images.		There is one image type for each primitive data structure, including signed and unsigned data types. For example, GrayF32 and GrayU8 represent single band images containing 32-bit floats and unsigned 8-bit integer pixels, respectively. At the time of this writing, BoofCV primarily supports only single band or gray scale images with some support for color image processing. The reason for this is because most computer vision routines are only designed for gray scale images.

	Naming Scheme:		Naming Scheme:
	; Single Band Floating Point Images		; Single Band Floating Point Images
	: ~~ImageFloat~~*		: GrayF*
	: * indicates the number of bits. ~~Only~~ 32 bits and 64 bits are supported.		: * indicates the number of bits. 32 bits and 64 bits are supported.
	; Single Band Integer Images		; Single Band Integer Images
	: ~~Image~~~~Int~~		: Gray**
	: The first * can be S or U for signed or unsigned.		: The first * can be S or U for signed or unsigned.
	: The second * is the number of bits and can be 8,16,32, or 64.		: The second * is the number of bits and can be 8,16,32, or 64.
			; Multi-Band Planar Images
	~~A different naming~~ scheme ~~is used for multi~~-~~band~~ images ~~but is not yet discussed here since it has only minimal support in BoofCV and is subject to change.~~		: Planar<*>
			: Where * is the name of a gray scale image
			; Multi-Band Interleaved Images
			: Interleaved*
			: where * is a specific type using the same scheme as gray-scale images

	= Why not use BufferedImage? =		= Why not use BufferedImage? =

Peter: Cleaned up writing a bit

2013-02-22T03:56:01Z

Cleaned up writing a bit

← Older revision		Revision as of 03:56, 22 February 2013
Line 15:		Line 15:

	= Why not use BufferedImage? =		= Why not use BufferedImage? =
	Images in BoofCV are designed for high speed image processing. BufferedImages are highly abstracted designed encapsulate just about any image format. Manipulating images using ~~its higher level~~ functions is painfully slow. ~~Infact~~ the only way to get any speed out of BufferedImages is to use the forbidden low level interfaces! Compared to BoofCV where its images are highly type specific, with absolutely minimal abstraction and strong typing. ~~Raw~~ data can even ~~be accessed~~ without ~~any~~ functions for added speed in ~~situations where the VM isn't smart enough to optimize the code~~.		Images in BoofCV are designed for high speed image processing with simple data structures for easier development. BufferedImages are highly abstracted and designed to encapsulate just about any image format. Manipulating images using BufferedImage's getRGB() and setRGB() functions is painfully slow. In-fact the only way to get any speed out of BufferedImages is to use the forbidden low level interfaces! Compared to BoofCV where its images are highly type specific, with absolutely minimal abstraction and strong typing. In BoofCV, raw pixel data can even manipulated without accessors functions, for added speed in low level functions easily.

	It is much faster and easier to work with images in BoofCV than the Java2D data structure BufferedImage. BufferedImages are complex and accessing pixels through their generalized interfaces is very slow. BoofCV provides several routines for quickly converting BufferedImage into BoofCV images. Using BoofCV routines for converting to/from BufferedImages are very fast because they access low level rasters inside of BufferedImage and gracefully handle situations where access is blocked to the rasters (e.g. Applets).		BoofCV provides several routines for quickly converting BufferedImage into BoofCV images. Using BoofCV routines for converting to/from BufferedImages are very fast because they access low level rasters inside of BufferedImage and gracefully handle situations where access is blocked to the rasters (e.g. Applets).

	= Image Types =		= Image Types =
Line 28:		Line 28:
	\|}		\|}

	BoofCV supports both color and single band images ~~and all~~ image types extend the abstract ImageBase class. ImageBase proves basic information on the size, shape, and internal structure of the class. Immediate children of ImageBase is ImageSingleBand and MultiSpectral, which provide support for gray scale and color image processing, respectively.		BoofCV supports both color and single band images. All image types extend the abstract ImageBase class. ImageBase proves basic information on the size, shape, and internal structure of the class. Immediate children of ImageBase are ImageSingleBand and MultiSpectral, which provide support for gray scale and color image processing, respectively.

	ImageSingleBand contain only one intensity value per pixel and can also be referred to as a gray scale image. MultiSpectral contains each color band as its own gray scale image. Any operation which can process a ImageSingleBand can process one of the bands inside of a MultiSpectral image, allowing for fast implementation of some color image processing and computer vision algorithms. In the future interleaved color images will be supported.		ImageSingleBand contain only one intensity value per pixel and can also be referred to as a gray scale image. MultiSpectral contains each color band as its own gray scale image. Any operation which can process an ImageSingleBand can process one of the bands inside of a MultiSpectral image, allowing for fast implementation of some color image processing and computer vision algorithms. In the future interleaved color images will also be supported.

	= Single Band Images =		= Single Band Images =
Line 84:		Line 84:
	= Multi Spectral Images =		= Multi Spectral Images =

	MultiSpectral images are color images where each color band is stored as a separate gray scale image. Storing color images in this format is less common than the typical interleaved format, but ~~allow~~ color images to be easily processed using highly optimized gray scale code that is common throughout BoofCV. The main disadvantage is that for some algorithm types an interleaved image will be faster to process when color information can not be processes in each band independently.		MultiSpectral images are color images where each color band is stored as a separate gray scale image. Storing color images in this format is less common than the typical interleaved format, but allows color images to be easily processed using highly optimized gray scale code that is common throughout BoofCV. The main disadvantage is that for some algorithm types an interleaved image will be faster to process when color information can not be processes in each band independently.

	Working with MultiSpectral images is easy. To access the intensity of a pixel in different colors, simply access the image for that band then use the gray scale accessors functions. Below a code sniplet shows how to create a multi spectral image and set the pixel at (5,5) to have a value of (255,50,50), which would appear to be red in an RGB image.		Working with MultiSpectral images is easy. To access the intensity of a pixel in different colors, simply access the image for that band then use the gray scale accessors functions. Below a code sniplet shows how to create a multi spectral image and set the pixel at (5,5) to have a value of (255,50,50), which would appear to be red in an RGB image.

Peter at 02:09, 6 December 2012

2012-12-06T02:09:26Z

← Older revision		Revision as of 02:09, 6 December 2012
Line 1:		Line 1:
	~~= Images in BoofCV =~~

	Its not surprising that images play a key role inside of BoofCV, since its a computer vision library. Images are 2D arrays which store pixel intensity values, where a single pixel represents the output of a optical sensor. In BoofCV to help catch more errors at compile time and to ensure more meaningful error messages it provides several different types of images. The more standard approach (such as is done in Java2D or OpenCV) is to provide a single data type which can represent many different image types.		Its not surprising that images play a key role inside of BoofCV, since its a computer vision library. Images are 2D arrays which store pixel intensity values, where a single pixel represents the output of a optical sensor. In BoofCV to help catch more errors at compile time and to ensure more meaningful error messages it provides several different types of images. The more standard approach (such as is done in Java2D or OpenCV) is to provide a single data type which can represent many different image types.

Peter: Reworked one paragraph about BufferedImages

2012-02-08T10:23:41Z

Reworked one paragraph about BufferedImages

← Older revision		Revision as of 10:23, 8 February 2012
Line 17:		Line 17:

	= Why not use BufferedImage? =		= Why not use BufferedImage? =
	Images in BoofCV are designed for high speed image processing. ~~Extensive benchmarking has shown that in Java (counter to what many people believe)~~ using ~~accessors (e.g~~. get~~() or set()) will slow down your~~ low level ~~image processing code.~~ ~~It is still true that in high level applications accessors make no performance difference~~. ~~For this reason,~~ data ~~structures~~ in ~~images are publicly accessible~~.		Images in BoofCV are designed for high speed image processing. BufferedImages are highly abstracted designed encapsulate just about any image format. Manipulating images using its higher level functions is painfully slow. Infact the only way to get any speed out of BufferedImages is to use the forbidden low level interfaces! Compared to BoofCV where its images are highly type specific, with absolutely minimal abstraction and strong typing. Raw data can even be accessed without any functions for added speed in situations where the VM isn't smart enough to optimize the code.

	It is much faster and easier to work with images in BoofCV than the Java2D data structure BufferedImage. BufferedImages are complex and accessing pixels through their generalized interfaces is very slow. BoofCV provides several routines for quickly converting BufferedImage into BoofCV images. Using BoofCV routines for ~~conversion is~~ very fast because they access low level rasters inside of BufferedImage and gracefully handle situations where access is blocked to the rasters (e.g. Applets).		It is much faster and easier to work with images in BoofCV than the Java2D data structure BufferedImage. BufferedImages are complex and accessing pixels through their generalized interfaces is very slow. BoofCV provides several routines for quickly converting BufferedImage into BoofCV images. Using BoofCV routines for converting to/from BufferedImages are very fast because they access low level rasters inside of BufferedImage and gracefully handle situations where access is blocked to the rasters (e.g. Applets).

	= Image Types =		= Image Types =

Peter: Added description of MultiSpectral images and updated diagrams

2012-01-02T16:11:55Z

Added description of MultiSpectral images and updated diagrams

← Older revision		Revision as of 16:11, 2 January 2012
Line 1:		Line 1:
	= Images in BoofCV =		= Images in BoofCV =

	Its not surprising that images play a key role inside of BoofCV since its a computer vision library. Images are 2D arrays which store pixel intensity values, where a single pixel represents the output of a optical sensor. In BoofCV to help catch more errors at compile time and to ensure more meaningful error messages it provides several different types of images. The more standard approach (such as is done in Java2D or OpenCV) is to provide a single data type which can represent many different image types.		Its not surprising that images play a key role inside of BoofCV, since its a computer vision library. Images are 2D arrays which store pixel intensity values, where a single pixel represents the output of a optical sensor. In BoofCV to help catch more errors at compile time and to ensure more meaningful error messages it provides several different types of images. The more standard approach (such as is done in Java2D or OpenCV) is to provide a single data type which can represent many different image types.

	There is one image type for each primitive data structure, including signed and unsigned data types. For example, ImageFloat32 and ImageUInt8 represent single band images containing 32-bit floats and unsigned 8-bit pixels, respectively. At the time of this writing, BoofCV primarily supports only single band or gray scale images. The reason for this is because most computer vision routines are only designed for gray scale images~~, mostly for speed reasons~~.		There is one image type for each primitive data structure, including signed and unsigned data types. For example, ImageFloat32 and ImageUInt8 represent single band images containing 32-bit floats and unsigned 8-bit pixels, respectively. At the time of this writing, BoofCV primarily supports only single band or gray scale images with some support for color image processing. The reason for this is because most computer vision routines are only designed for gray scale images.

	Naming Scheme:		Naming Scheme:
Line 20:		Line 20:

	It is much faster and easier to work with images in BoofCV than the Java2D data structure BufferedImage. BufferedImages are complex and accessing pixels through their generalized interfaces is very slow. BoofCV provides several routines for quickly converting BufferedImage into BoofCV images. Using BoofCV routines for conversion is very fast because they access low level rasters inside of BufferedImage and gracefully handle situations where access is blocked to the rasters (e.g. Applets).		It is much faster and easier to work with images in BoofCV than the Java2D data structure BufferedImage. BufferedImages are complex and accessing pixels through their generalized interfaces is very slow. BoofCV provides several routines for quickly converting BufferedImage into BoofCV images. Using BoofCV routines for conversion is very fast because they access low level rasters inside of BufferedImage and gracefully handle situations where access is blocked to the rasters (e.g. Applets).

			= Image Types =

			{\|
			\|-
			! Class inheritance diagram for high level image types
			\|-
			\| [[File:Image_type_class_diagram.png]]
			\|}

			BoofCV supports both color and single band images and all image types extend the abstract ImageBase class. ImageBase proves basic information on the size, shape, and internal structure of the class. Immediate children of ImageBase is ImageSingleBand and MultiSpectral, which provide support for gray scale and color image processing, respectively.

			ImageSingleBand contain only one intensity value per pixel and can also be referred to as a gray scale image. MultiSpectral contains each color band as its own gray scale image. Any operation which can process a ImageSingleBand can process one of the bands inside of a MultiSpectral image, allowing for fast implementation of some color image processing and computer vision algorithms. In the future interleaved color images will be supported.

	= Single Band Images =		= Single Band Images =
Line 27:		Line 40:
	! Class inheritance diagram for single band images		! Class inheritance diagram for single band images
	\|-		\|-
	\| [[File:~~Image class diagram~~.png]]		\| [[File:Image_type_single_class_diagram.png]]
	\|}		\|}

Line 69:		Line 82:
	image.set(x,y,45);		image.set(x,y,45);
	int value = image.data[ image.startIndex + y*image.stride + x] & 0xFF;		int value = image.data[ image.startIndex + y*image.stride + x] & 0xFF;
			</pre>

			= Multi Spectral Images =

			MultiSpectral images are color images where each color band is stored as a separate gray scale image. Storing color images in this format is less common than the typical interleaved format, but allow color images to be easily processed using highly optimized gray scale code that is common throughout BoofCV. The main disadvantage is that for some algorithm types an interleaved image will be faster to process when color information can not be processes in each band independently.

			Working with MultiSpectral images is easy. To access the intensity of a pixel in different colors, simply access the image for that band then use the gray scale accessors functions. Below a code sniplet shows how to create a multi spectral image and set the pixel at (5,5) to have a value of (255,50,50), which would appear to be red in an RGB image.
			<pre>
			MultiSpectral<ImageUInt8> image = new MultiSpectral<ImageUInt8>(ImageUInt8.class,100,200,3);
			image.getBand(0).set(5,5,255);
			image.getBand(1).set(5,5,50);
			image.getBand(2).set(5,5,50);
	</pre>		</pre>

Peter: Added diagram for single band images

2011-12-09T00:00:28Z

Added diagram for single band images

← Older revision		Revision as of 00:00, 9 December 2011
Line 22:		Line 22:

	= Single Band Images =		= Single Band Images =

			{\|
			\|-
			! Class inheritance diagram for single band images
			\|-
			\| [[File:Image class diagram.png]]
			\|}

	Single band-images are gray scale images which represent an image using a single color or band. They are easier to work with the multi-band data and more commonly used in computer vision because they are faster to work with. The down side to working with gray scale images is that to create one often requires throwing away valuable color information.		Single band-images are gray scale images which represent an image using a single color or band. They are easier to work with the multi-band data and more commonly used in computer vision because they are faster to work with. The down side to working with gray scale images is that to create one often requires throwing away valuable color information.