libvips/libsrc/arithmetic/im_litecor.c

322 lines
7.4 KiB
C
Raw Normal View History

2007-08-29 18:23:50 +02:00
/* @(#) 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 );
}
}