#include <ImageResizer.hh>

Collaboration diagram for ImageResizer:

Public Member Functions
	ImageResizer (const ColorImage &img, FilterSet &flt, int *fill=NULL, coeff threshold=0.001, bool optimizeImage=false, int scalingStrategy=0)
	~ImageResizer (void)
ColorImage *	resize (int rows, int cols, int steps=1)
ColorImage *	redimension (int rows, int cols, int steps=1)
double	getInnerAvgPerSize (void) const
double	getInnerSDeviation (void) const
int	getInnerRegionSize (void) const
double	threshold (void) const
void	threshold (double threshold)
void	optimizeImage (bool optimizeImage)
bool	optimizeImage (void)
Protected Types
enum	{ CROP_COLS, CROP_ROWS, CROP_BOTH_OR_NONE, CROP_AUTOMATICALLY }
Protected Member Functions
void	calcDimensions (int rows, int cols)
int	fixDimensions (int rows, int cols)
void	calcOptimization (void)
void	calcOuterStats (coeff &avg, coeff &variance, int firstTop, int firstLeft, int firstBottom, int firstRight, int secondTop, int secondLeft, int secondBottom, int secondRight)
void	calcInnerStats (coeff &avg, coeff &sDev, int top, int left, int bottom, int right)
void	calcStats (int nRows, int nCols, coeff &outerAvg, coeff &outerSDev, coeff &innerAvg, coeff &innerSDev)
void	genMaxDetail (int steps)
ColorImage *	getUnscaledImage (int rows, int cols, int discardRows, int discardCols)
ColorImage *	getScaledImage (int rows, int cols, int discardRows, int discardCols)
ColorImage *	getCroppedImage (int discardRows, int discardCols)
ColorImage *	doResize (int rows, int cols, int steps, bool redimensionOnly)
Protected Attributes
const ColorImage &	m_image
Image *	m_maxDetail
FilterSet &	m_filter
float	m_qRows
float	m_qCols
int *	m_fill
int	m_scalingStrategy
double	m_innerAvgPerSize
double	m_innerSDeviation
int	m_innerRegionSize
coeff	m_threshold
bool	m_optimizeImage
bool	m_optimizationCalculated
int	m_cropMaxRows
int	m_cropMaxCols
double	m_rowsMapping
double	m_colsMapping
int	m_steps
enum ImageResizer:: { ... }	m_cropWhat

Detailed Description

A class for advanced resizing of images, i.e. wavelet-based techniques can be used to intelligently crop images to fit

This class will only discard background pixels if the image is shrunk.

Definition at line 26 of file ImageResizer.hh.

Member Enumeration Documentation

anonymous enum [protected]

Enumerator:

CROP_COLS
CROP_ROWS
CROP_BOTH_OR_NONE
CROP_AUTOMATICALLY

Definition at line 296 of file ImageResizer.hh.

Constructor & Destructor Documentation

ImageResizer::ImageResizer	(	const ColorImage &	img,
		FilterSet &	flt,
		int *	fill = `NULL`,
		coeff	threshold = `0.001`,
		bool	optimizeImage = `false`,
		int	scalingStrategy = `0`
	)

Constructor, loads an image, sets Wavelet to be used.

Parameters:

img	a reference to the image
flt	a reference to the filterset
fill	if not NULL it must point to an array of as many values as color channels, so that each of the image's channels has its own fill greyscale value for the remaining space (else the a smaller image size will be chosen if the aspect ratio does not match)
optimizeImage	if set to true, we will try to locate the actual contents regardless of whether the target dimensions fit or not
threshold	the threshold for the aggressiveness of the cropping (< 1), the higher the more aggressive, default is 0.001
scalingStrategy	the scaling strategy (0: bilinear interpolation, 1: average, 2: nearest neighbour).

Returns:: a new rescaled image

ImageResizer::~ImageResizer ( void )

Destructor. Cleans up if necessary.

Member Function Documentation

void ImageResizer::calcDimensions	(	int	rows,
		int	cols
	)		`[protected]`

Calculate the image's new dimensions

Parameters:

rows	the number of rows
cols	the number of cols

void ImageResizer::calcInnerStats	(	coeff &	avg,
		coeff &	sDev,
		int	top,
		int	left,
		int	bottom,
		int	right
	)		`[protected]`

Calculate the average and variance for an inner region of the (internal) maxDetail image. This is needed to see whether we can discard the region around it or not.

Parameters:

avg	the calculated average
variance	the calculated variance
top	the top of the inner region
left	the left of the inner region
bottom	the bottom of the inner region
right	the right of the inner region

void ImageResizer::calcOptimization ( void ) [protected]

Determine how many rows and cols can be discarded regardless of the target dimensions. This is calculated once within ::resize(), so that if more than one target size is required by repeated resizing operations little or no further effort is necessary after the first operation.

void ImageResizer::calcOuterStats	(	coeff &	avg,
		coeff &	variance,
		int	firstTop,
		int	firstLeft,
		int	firstBottom,
		int	firstRight,
		int	secondTop,
		int	secondLeft,
		int	secondBottom,
		int	secondRight
	)		`[protected]`

Calculate the average and variance for an outer region of the (internal) maxDetail image. This is needed to see whether we can discard this outer region or not.

Parameters:

avg	the calculated average
variance	the calculated variance
firstTop	the first top of the frame
firstLeft	the first left of the frame
firstBottom	the first bottom of the frame
firstRight	the first right of the frame
secondTop	the second top of the frame
secondLeft	the second left of the frame
secondBottom	the second bottom of the frame
secondRight	the second right of the frame

void ImageResizer::calcStats	(	int	nRows,
		int	nCols,
		coeff &	outerAvg,
		coeff &	outerSDev,
		coeff &	innerAvg,
		coeff &	innerSDev
	)		`[protected]`

Calculate average and standard deviation for the regions either top and bottom or left and right (depending on the value of m_cropWhat) and the region between for a given number of rows/columns symetrically from the boundaries to the center of the image.

Parameters:

nRows	the number of rows over which to calculate
nCols	the number of rows over which to calculate
outerAvg	(out parameter) is where the calculated average for the regions to crop is stored
outerSDev	(out parameter) is where the calculated standard deviation for the regions to crop is stored
innerAvg	(out parameter) is where the calculated average for the region between is stored
innerSDev	(out parameter) is where the calculated standard deviation for the region between is stored

ColorImage* ImageResizer::doResize	(	int	rows,
		int	cols,
		int	steps,
		bool	redimensionOnly
	)		`[protected]`

Create a resized image's of x/y dimensions. The result image will be cropped to optimally fit in the new dimensions. The maximal percentage of cropping as well as the thresholds for guessing insignificant areas can be set. If both dimensions are set to 0 and the optimization feature is set, we get an auto-crop (i.e. the size is chosen from the image's contents) The new dimensions must all be greater than zero.

Exceptions:

invalid_argument one or both dimensions are either negative or zero

Parameters:

rows	the new number of rows
cols	the new number of cols
steps	the number of steps to decompose before checking for features
redimensionOnly	if true, the image will be prepared for scaling, i.e. the dimensions are fixed filling performed etc., so that it can be scaled by some other application later.

Returns:: the new resized or prepared image

int ImageResizer::fixDimensions	(	int	rows,
		int	cols
	)		`[protected]`

If the target dimensions do not match the source dimensions, determine how many rows or cols respectively can be discarded to further optimize the image.

Parameters:

rows	the target rows
cols	the target cols

Returns:: the number of rows / cols which can be discarded in the original image

void ImageResizer::genMaxDetail ( int steps ) [protected]

Calculate the maxDetail image for the statistics

Parameters:

steps the number of decomposition steps

ColorImage* ImageResizer::getCroppedImage	(	int	discardRows,
		int	discardCols
	)		`[protected]`

This operation applies the cropping using the previously calculated numbers of rows or cols which can be safely discarded.

Parameters:

discardRows	the number of rows to discard on each side (i.e. we actually discard 2 * discardRows overall); if less than or equal to zero, nothing will be discarded
discardCols	the number of rows to discard on each side (i.e. we actually discard 2 * discardCols overall); if less than or equal to zero, nothing will be discarded

Returns:: the cropped image or a copy of the original if nothing was cropped

double ImageResizer::getInnerAvgPerSize ( void ) const [inline]

Return the inner (absolute) average per size (used for quality measurements)

Returns:: the inner average per size

Definition at line 95 of file ImageResizer.hh.

References m_innerAvgPerSize.

int ImageResizer::getInnerRegionSize ( void ) const [inline]

Return the size of the inner region used for the above calculation

Returns:: the size of the inner region used for the above calculation

Definition at line 105 of file ImageResizer.hh.

References m_innerRegionSize.

double ImageResizer::getInnerSDeviation ( void ) const [inline]

Return the inner standard deviation (used for quality measurements)

Returns:: the inner standard deviation

Definition at line 100 of file ImageResizer.hh.

References m_innerSDeviation.

ColorImage* ImageResizer::getScaledImage	(	int	rows,
		int	cols,
		int	discardRows,
		int	discardCols
	)		`[protected]`

Create the final scaled result image using the previously calculated number of vectors to discard.

Parameters:

rows	the number of rows
cols	the number of cols
discardRows	the number of rows to discard on each side (i.e. we actually discard 2 * discardRows overall); if less than or equal to zero, nothing will be discarded
discardCols	the number of rows to discard on each side (i.e. we actually discard 2 * discardCols overall); if less than or equal to zero, nothing will be discarded

Returns:: the result image

ColorImage* ImageResizer::getUnscaledImage	(	int	rows,
		int	cols,
		int	discardRows,
		int	discardCols
	)		`[protected]`

Create the final unscaled result image using the previously calculated number of vectors to discard.

Parameters:

rows	the number of rows
cols	the number of cols
discardRows	the number of rows to discard on each side (i.e. we actually discard 2 * discardRows overall); if less than or equal to zero, nothing will be discarded
discardCols	the number of rows to discard on each side (i.e. we actually discard 2 * discardCols overall); if less than or equal to zero, nothing will be discarded

Returns:: the result image

void ImageResizer::optimizeImage ( bool optimizeImage ) [inline]

Set the optimize-image-setting

Parameters:

optimize true if optimization is active

Definition at line 122 of file ImageResizer.hh.

References m_optimizeImage, and optimizeImage().

Referenced by optimizeImage().

bool ImageResizer::optimizeImage ( void ) [inline]

Return the optimize-image-setting

Returns:: true if optimization is active

Definition at line 127 of file ImageResizer.hh.

References m_optimizeImage.

ColorImage* ImageResizer::redimension	(	int	rows,
		int	cols,
		int	steps = `1`
	)

Prepare an image for resizing to x/y dimensions. The result image will be cropped to optimally fit in the new dimensions. The maximal percentage of cropping as well as the thresholds for guessing insignificant areas can be set. This operation skips the actual scaling, so that it can be performed by someone else. The new dimensions must all be greater than zero.

Exceptions:

invalid_argument one or both dimensions are either negative or zero

Parameters:

rows	the new number of rows
cols	the new number of cols
steps	the number of steps to decompose before checking for features

Returns:: the new redimensioned image

ColorImage* ImageResizer::resize	(	int	rows,
		int	cols,
		int	steps = `1`
	)

Create a resized image's of x/y dimensions. The result image will be cropped to optimally fit in the new dimensions. The maximal percentage of cropping as well as the thresholds for guessing insignificant areas can be set. If both dimensions are set to 0 and the optimization feature is set, we get an auto-crop (i.e. the size is chosen from the image's contents) The new dimensions must all be greater than zero.

Exceptions:

invalid_argument one or both dimensions are either negative or zero

Parameters: