322 lines
7.4 KiB
C
322 lines
7.4 KiB
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 );
|
|
}
|
|
}
|