libvips/libsrc/convolution/im_shrink.c

/* @(#) Shrink any non-complex image by some x, y, factor. No interpolation!
 * @(#) Just average an area. Suitable for making quicklooks only!
 * @(#)
 * @(#) int 
 * @(#) im_shrink( in, out, xshrink, yshrink )
 * @(#) IMAGE *in, *out;
 * @(#) double xshrink, yshrink;
 * @(#)
 * @(#) Returns either 0 (success) or -1 (fail)
 * @(#)
 *
 * Copyright: 1990, N. Dessipris.
 *
 * Authors: Nicos Dessipris and Kirk Martinez
 * Written on: 29/04/1991
 * Modified on: 2/11/92, 22/2/93 Kirk Martinez - Xres Yres & cleanup 
 incredibly inefficient for box filters as LUTs are used instead of + 
 Needs converting to a smoother filter: eg Gaussian!  KM
 * 15/7/93 JC
 *	- rewritten for partial v2
 *	- ANSIfied
 *	- now shrinks any non-complex type
 *	- no longer cloned from im_convsub()
 *	- could be much better! see km comments above
 * 3/8/93 JC
 *	- rounding bug fixed
 * 11/1/94 JC
 *	- problems with .000001 and round up/down ignored! Try shrink 3738
 *	  pixel image by 9.345000000001
 * 7/10/94 JC
 *	- IM_NEW and IM_ARRAY added
 *	- more typedef
 * 3/7/95 JC
 *	- IM_CODING_LABQ handling added here
 */

/*

    This file is part of VIPS.
    
    VIPS is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

/*

    These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk

 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif /*HAVE_CONFIG_H*/
#include <vips/intl.h>

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include <vips/vips.h>

#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif /*WITH_DMALLOC*/

/* Our main parameter struct.
 */
typedef struct {
	double xshrink;		/* Shrink factors */
	double yshrink;
	int mw;			/* Size of area we average */
	int mh;
	int np;			/* Number of pels we average */
} ShrinkInfo;

/* Our per-sequence parameter struct. We hold an offset for each pel we
 * average.
 */
typedef struct {
	REGION *ir;
	int *off;
} SeqInfo;

/* Free a sequence value.
 */
static int
shrink_stop( void *vseq, void *a, void *b )
{
	SeqInfo *seq = (SeqInfo *) vseq;

	IM_FREEF( im_region_free, seq->ir );

	return( 0 );
}

/* Make a sequence value.
 */
static void *
shrink_start( IMAGE *out, void *a, void *b )
{
	IMAGE *in = (IMAGE *) a;
	ShrinkInfo *st = (ShrinkInfo *) b;
	SeqInfo *seq;

	if( !(seq = IM_NEW( out, SeqInfo )) )
		return( NULL );

	/* Init!
	 */
	seq->ir = NULL;
	seq->off = NULL;
	seq->ir = im_region_create( in );
	seq->off = IM_ARRAY( out, st->np, int );
	if( !seq->off || !seq->ir ) {
		shrink_stop( seq, in, st );
		return( NULL );
	}

	return( (void *) seq );
}

/* Integer shrink. 
 */
#define ishrink(TYPE) \
	for( y = to; y < bo; y++ ) { \
		TYPE *q = (TYPE *) IM_REGION_ADDR( or, le, y ); \
 		\
		for( x = le; x < ri; x++ ) { \
			int ix = x * st->xshrink; \
			int iy = y * st->yshrink; \
			TYPE *p = (TYPE *) IM_REGION_ADDR( ir, ix, iy ); \
 			\
			for( k = 0; k < ir->im->Bands; k++ ) { \
				int sum = 0; \
				int *t = seq->off; \
 				\
				for( z = 0; z < st->np; z++ ) \
					sum += p[*t++]; \
				 \
				*q++ = sum / st->np; \
				p++; \
			} \
		} \
	}

/* FP shrink.
 */
#define fshrink(TYPE) \
	for( y = to; y < bo; y++ ) { \
		TYPE *q = (TYPE *) IM_REGION_ADDR( or, le, y ); \
 		\
		for( x = le; x < ri; x++ ) { \
			int ix = x * st->xshrink; \
			int iy = y * st->yshrink; \
			TYPE *p = (TYPE *) IM_REGION_ADDR( ir, ix, iy ); \
 			\
			for( k = 0; k < ir->im->Bands; k++ ) { \
				double sum = 0; \
				int *t = seq->off; \
 				\
				for( z = 0; z < st->np; z++ ) \
					sum += p[*t++]; \
				 \
				*q++ = sum / st->np; \
				p++; \
			} \
		} \
	}

/* Shrink a REGION.
 */
static int
shrink_gen( REGION *or, void *vseq, void *a, void *b )
{
	SeqInfo *seq = (SeqInfo *) vseq;
	ShrinkInfo *st = (ShrinkInfo *) b;
	REGION *ir = seq->ir;
	Rect *r = &or->valid;
	Rect s;
	int le = r->left;
	int ri = IM_RECT_RIGHT( r );
	int to = r->top;
	int bo = IM_RECT_BOTTOM(r);

	int x, y, z, k;

	/* What part of the input image do we need? Very careful: round left
	 * down, round right up.
	 */
	s.left = r->left * st->xshrink;
	s.top = r->top * st->yshrink;
	s.width = ceil( IM_RECT_RIGHT( r ) * st->xshrink ) - s.left;
	s.height = ceil( IM_RECT_BOTTOM( r ) * st->yshrink ) - s.top;
	if( im_prepare( ir, &s ) )
		return( -1 );

	/* Init offsets for pel addressing. Note that offsets must be for the
	 * type we will address the memory array with.
	 */
	for( z = 0, y = 0; y < st->mh; y++ )
		for( x = 0; x < st->mw; x++ )
			seq->off[z++] = (IM_REGION_ADDR( ir, x, y ) - 
				IM_REGION_ADDR( ir, 0, 0 )) /
				IM_IMAGE_SIZEOF_ELEMENT( ir->im );

	switch( ir->im->BandFmt ) {
        case IM_BANDFMT_UCHAR: 		ishrink(unsigned char); break;
        case IM_BANDFMT_CHAR: 		ishrink(char); break; 
        case IM_BANDFMT_USHORT: 	ishrink(unsigned short); break;
        case IM_BANDFMT_SHORT: 		ishrink(short); break; 
        case IM_BANDFMT_UINT: 		ishrink(unsigned int); break; 
        case IM_BANDFMT_INT: 		ishrink(int);  break; 
        case IM_BANDFMT_FLOAT: 		fshrink(float); break; 
        case IM_BANDFMT_DOUBLE:		fshrink(double); break;

        default:
		im_error( "im_shrink", _( "unsupported input format" ) );
                return( -1 );
        }
 
	return( 0 );
}

static int 
shrink( IMAGE *in, IMAGE *out, double xshrink, double yshrink )
{
	ShrinkInfo *st;

	/* Check parameters.
	 */
	if( !in || im_iscomplex( in ) ) {
		im_error( "im_shrink", _( "non-complex input only" ) );
		return( -1 );
	}
	if( xshrink < 1.0 || yshrink < 1.0 ) {
		im_error( "im_shrink", 
			_( "shrink factors should both be >1" ) );
		return( -1 );
	}
	if( im_piocheck( in, out ) )
		return( -1 );

	/* Prepare output. Note: we round the output width down!
	 */
	if( im_cp_desc( out, in ) )
		return( -1 );
	out->Xsize = in->Xsize / xshrink;
	out->Ysize = in->Ysize / yshrink;
	out->Xres = in->Xres / xshrink;
	out->Yres = in->Yres / yshrink;
	if( out->Xsize <= 0 || out->Ysize <= 0 ) {
		im_error( "im_shrink", _( "image has shrunk to nothing" ) );
		return( -1 );
	}

	/* Build and attach state struct.
	 */
	if( !(st = IM_NEW( out, ShrinkInfo )) )
		return( -1 );
	st->xshrink = xshrink;
	st->yshrink = yshrink;
	st->mw = ceil( xshrink );
	st->mh = ceil( yshrink );
	st->np = st->mw * st->mh;

	/* Set demand hints. We want THINSTRIP, as we will be demanding a
	 * large area of input for each output line.
	 */
	if( im_demand_hint( out, IM_THINSTRIP, in, NULL ) )
		return( -1 );

	/* Generate!
	 */
	if( im_generate( out, 
		shrink_start, shrink_gen, shrink_stop, in, st ) )
		return( -1 );

	return( 0 );
}

/* Wrap up the above: do IM_CODING_LABQ as well.
 */
int
im_shrink( IMAGE *in, IMAGE *out, double xshrink, double yshrink )
{
	if( in->Coding == IM_CODING_LABQ ) {
		IMAGE *t[2];

		if( im_open_local_array( out, t, 2, "im_shrink:1", "p" ) ||
			im_LabQ2LabS( in, t[0] ) ||
			shrink( t[0], t[1], xshrink, yshrink ) ||
			im_LabS2LabQ( t[1], out ) )
			return( -1 );
	}
	else if( in->Coding == IM_CODING_NONE ) {
		if( shrink( in, out, xshrink, yshrink ) )
			return( -1 );
	}
	else {
		im_error( "im_shrink", _( "unknown coding type" ) );
		return( -1 );
	}

	return( 0 );
}