libvips/libsrc/arithmetic/im_litecor.c

/* @(#) Function to perform lighting correction. 
 * @(#) One band IM_BANDFMT_UCHAR images only. Always writes UCHAR.
 * @(#)
 * @(#) Function im_litecor() assumes that imin
 * @(#) is either memory mapped or in a buffer.
 * @(#)
 * @(#) int im_litecor(in, w, out, clip, factor)
 * @(#) IMAGE *in, *w, *out;
 * @(#) int clip;
 * @(#) double factor;
 * @(#)
 * @(#) clip==1	
 * @(#)	   - Compute max(white)*factor*(image/white), Clip to 255.
 * @(#)	clip==0
 * @(#)	   - Compute factor for you.
 * @(#)
 * @(#)
 * @(#)
 * @(#)
 * @(#) Returns 0 on success and -1 on error
 *
 * Copyright: 1990, J. Cupitt, 1991 N. Dessipris
 *
 * Author: J. Cupitt, N. Dessipris
 * Written on: 02/08/1990
 * Modified on : 6/11/1991, by ND to produce a UCHAR output
 * 1/4/93 J.Cupitt
 *	- bugs if white is smaller than image fixed
 *	- im_warning() now called
 *	- clip==0 case not tested or changed! do not use!
 */

/*

    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 <vips/vips.h>

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

/*   If maximum output is > 255 scale output between minout and maxout,
 * by normalising maxout to 255.
 *   If maximum output is < 255 do the light correction without scaling
 */
static int
im_litecor0( in, white, out )
IMAGE *in, *white, *out;
{	PEL *p, *w;
	PEL *q, *bu;
	int c;
	int x, y;
	float xrat = (float) in->Xsize / white->Xsize;
	float yrat = (float) in->Ysize / white->Ysize;
	int xstep = (int) xrat;
	int ystep = (int) yrat;
	double max;
	int wtmp, maxw, maxout, temp;

	/* Check white is some simple multiple of image.  
	 */
	if( xrat < 1.0 || xrat != xstep || yrat < 1.0 || yrat != ystep ) {
		im_error( "im_litecor", "white not simple scale of image" );
		return( -1 );
	}

	/* Find the maximum of the white.  
	 */
	if( im_max( white, &max ) )
		return( -1 );
	maxw = (int)max;

	/* Set up the output header.  
	 */
	if( im_cp_desc( out, in ) ) 
		return( -1 );
	if( im_setupout( out ) )
		return( -1 );

	/* Make buffer for outputting to.  
	 */
	if( !(bu = (PEL *) im_malloc( out, out->Xsize )) )  
		return( -1 ); 

	/* Find largest value we might generate if factor == 1.0
	 */
	maxout = -1;
	p = (PEL *) in->data;
	for( y = 0; y < in->Ysize; y++ ) {
		/* Point w to the start of the line in the white
		 * corresponding to the line we are about to correct. c counts
		 * up to xstep; each time it wraps, we should move w on one.
		 */
		w = (PEL *) (white->data + white->Xsize * (int)(y/ystep));
		c = 0;

		/* Scan along line.  
		 */
		for( x = 0; x < out->Xsize; x++ ) {
			wtmp = (int)*w;
			temp = ( maxw * (int) *p++ + (wtmp>>1) ) / wtmp; 
			if (temp > maxout )
				maxout = temp;

			/* Move white pointer on if necessary.  */
			c++;
			if( c == xstep ) { 
				w++; 
				c = 0; 
			}
		}
	}

	/* Do exactly the same as above by scaling the result with respect to
	 * maxout
	 */
	p = (PEL *) in->data;
	if (maxout <= 255 )	/* no need for rescaling output */
		{
		for( y = 0; y < in->Ysize; y++ ) 
			{
			q = bu;
			w = (PEL *) (white->data + 
				white->Xsize * (int)(y/ystep));
			c = 0;

			/* Scan along line.  */
			for( x = 0; x < in->Xsize; x++ ) 
				{
				wtmp = (int)*w;
				*q++ = (PEL)
				( ( maxw * (int) *p++ + (wtmp>>1) ) / wtmp ); 
				/* Move white pointer on if necessary.
				 */
				c++;
				if( c == xstep ) { w++; c = 0; }
				}
			if( im_writeline( y, out, bu ) ) 
				{
				im_error("im_litecor", "im_writeline failed");
				return( -1 );
				}
			}
		}
	else		/* rescale output wrt maxout */
		{
		for( y = 0; y < in->Ysize; y++ ) 
			{
			q = bu;
			w = (PEL *) (white->data + 
				white->Xsize * (int)(y/ystep));
			c = 0;

			/* Scan along line.  */
			for( x = 0; x < in->Xsize; x++ ) 
				{
				wtmp = maxout * ((int)*w);
				*q++ = (PEL)
				 ( ( maxw * (int) *p++ * 255  + (wtmp>>1)) / wtmp );
				/* Move white pointer on if necessary.
				 */
				c++;
				if( c == xstep ) { w++; c = 0; }
				}
			if( im_writeline( y, out, bu ) ) 
				{
				im_error("im_litecor", "im_writeline failed");
				return( -1 );
				}
			}
		}

	return( 0 );
}

/* Clip all corrected values above 255, if any.
 */
static int
im_litecor1( in, white, out, factor )
IMAGE *in, *white, *out;
double factor;
{	PEL *p, *w;
	PEL *q, *bu;
	int c;
	int x, y;
	float xrat = (float) in->Xsize / white->Xsize;
	float yrat = (float) in->Ysize / white->Ysize;
	int xstep = (int) xrat;
	int ystep = (int) yrat;
	double max;
	double maxw, temp;
	int nclipped = 0;

	/* Check white is some simple multiple of image.  
	 */
	if( xrat < 1.0 || xrat != xstep || yrat < 1.0 || yrat != ystep ) {
		im_error( "im_litecor", "white not simple scale of image" );
		return( -1 );
	}

	/* Find the maximum of the white.  
	 */
	if( im_max( white, &max ) )
		return( -1 );
	maxw = max;

	/* Set up the output header.  
	 */
	if( im_cp_desc( out, in ) ) 
		return( -1 );
	if( im_setupout( out ) )
		return( -1 );

	/* Make buffer we write to.  
	 */
	if( !(bu = (PEL *) im_malloc( out, out->Xsize )) )  
		return( -1 ); 

	/* Loop through sorting max output  
	 */
	p = (PEL *) in->data;
	for( y = 0; y < in->Ysize; y++ ) {
		q = bu;
		w = (PEL *) (white->data + white->Xsize * (int)(y / ystep));
		c = 0;

		for( x = 0; x < out->Xsize; x++ ) {
			temp = ((factor * maxw * (int) *p++)/((int) *w)) + 0.5;
			if( temp > 255.0 ) { 
				temp = 255; 
				nclipped++; 
			}
			*q++ = temp;

			/* Move white pointer on if necessary.
			 */
			c++;
			if( c == xstep ) { 
				w++; 
				c = 0; 
			}
		}

		if( im_writeline( y, out, bu ) ) 
			return( -1 );
	}

	if( nclipped )
		im_warn( "im_litecor", "%d pels over 255 clipped", nclipped );

	return( 0 );
}

/* Lighting correction. One band uchar images only.
 * Assumes the white is some simple multiple of the image in size; ie. the
 * white has been taken with some smaller or equal set of resolution
 * parameters.
 */
int
im_litecor( in, white, out, clip, factor )
IMAGE *in, *white, *out;
int clip;
double factor;
{	/* Check our args. 
	 */
	if( im_iocheck( in, out ) ) 
		return( -1 );
	if( in->Bands != 1 || in->Bbits != 8 || 
		in->Coding != IM_CODING_NONE || in->BandFmt != IM_BANDFMT_UCHAR ) {
		im_error( "im_litecor", "bad input format" ); 
		return( -1 );
	}
	if( white->Bands != 1 || white->Bbits != 8 || 
		white->Coding != IM_CODING_NONE || white->BandFmt != IM_BANDFMT_UCHAR ) { 
		im_error( "im_litecor", "bad white format" );
		return( -1 );
	}

	switch( clip ) {
	case 1:
		return( im_litecor1( in, white, out, factor ) );
		
	case 0: 
		return( im_litecor0( in, white, out ) );

	default:
		im_error( "im_litecor", "unknown flag %d", clip ); 
		return( -1 );
	}
}