2011-10-31 10:23:43 +01:00
|
|
|
/* im_lintra.c -- linear transform
|
|
|
|
*
|
|
|
|
* Copyright: 1990, N. Dessipris, based on im_powtra()
|
|
|
|
* Author: Nicos Dessipris
|
|
|
|
* Written on: 02/05/1990
|
|
|
|
* Modified on:
|
|
|
|
* 23/4/93 JC
|
|
|
|
* - adapted to work with partial images
|
|
|
|
* 1/7/93 JC
|
|
|
|
* - adapted for partial v2
|
|
|
|
* 7/10/94 JC
|
|
|
|
* - new IM_NEW()
|
|
|
|
* - more typedefs
|
|
|
|
* 9/2/95 JC
|
|
|
|
* - adapted for im_wrap...
|
|
|
|
* - operations on complex images now just transform the real channel
|
|
|
|
* 29/9/95 JC
|
|
|
|
* - complex was broken
|
|
|
|
* 15/4/97 JC
|
|
|
|
* - return(0) missing from generate, arrgh!
|
|
|
|
* 1/7/98 JC
|
|
|
|
* - im_lintra_vec added
|
|
|
|
* 3/8/02 JC
|
|
|
|
* - fall back to im_copy() for a == 1, b == 0
|
|
|
|
* 10/10/02 JC
|
|
|
|
* - auug, failing to multiply imag for complex! (thanks matt)
|
|
|
|
* 10/12/02 JC
|
|
|
|
* - removed im_copy() fallback ... meant that output format could change
|
|
|
|
* with value :-( very confusing
|
|
|
|
* 30/6/04
|
|
|
|
* - added 1 band image * n band vector case
|
|
|
|
* 8/12/06
|
|
|
|
* - add liboil support
|
|
|
|
* 9/9/09
|
|
|
|
* - gtkdoc comment, minor reformat
|
|
|
|
* 31/7/10
|
|
|
|
* - remove liboil
|
|
|
|
* 31/10/11
|
|
|
|
* - rework as a class
|
2011-11-01 13:14:35 +01:00
|
|
|
* - removed the 1-ary constant path, no faster
|
2013-11-30 18:26:13 +01:00
|
|
|
* 30/11/13
|
|
|
|
* - 1ary is back, faster with gcc 4.8
|
2013-12-03 15:25:22 +01:00
|
|
|
* 3/12/13
|
|
|
|
* - try an ORC path with the band loop unrolled
|
2014-01-14 20:31:19 +01:00
|
|
|
* 14/1/14
|
|
|
|
* - add uchar output option
|
2014-03-06 17:03:33 +01:00
|
|
|
* 21/2/14
|
|
|
|
* - add imaginary components
|
2011-10-31 10:23:43 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
Copyright (C) 1991-2005 The National Gallery
|
|
|
|
|
2012-09-17 12:52:32 +02:00
|
|
|
This library 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.1 of the License, or (at your option) any later version.
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2012-09-17 12:52:32 +02:00
|
|
|
This library is distributed in the hope that it will be useful,
|
2011-10-31 10:23:43 +01:00
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2012-09-17 12:52:32 +02:00
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
Lesser General Public License for more details.
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2012-09-17 12:52:32 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
|
|
License along with this library; if not, write to the Free Software
|
2013-03-07 06:40:19 +01:00
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
02110-1301 USA
|
2011-10-31 10:23:43 +01:00
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
#define DEBUG
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include <config.h>
|
|
|
|
#endif /*HAVE_CONFIG_H*/
|
|
|
|
#include <vips/intl.h>
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2014-03-06 17:03:33 +01:00
|
|
|
#include <string.h>
|
2011-10-31 10:23:43 +01:00
|
|
|
#include <math.h>
|
|
|
|
|
|
|
|
#include <vips/vips.h>
|
|
|
|
|
|
|
|
#include "unary.h"
|
|
|
|
|
|
|
|
typedef struct _VipsLinear {
|
|
|
|
VipsUnary parent_instance;
|
|
|
|
|
|
|
|
/* Our constants: multiply by a, add b.
|
|
|
|
*/
|
|
|
|
VipsArea *a;
|
|
|
|
VipsArea *b;
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Optional imaginary part. Zero if not set.
|
|
|
|
*/
|
|
|
|
VipsArea *a_imag;
|
|
|
|
VipsArea *b_imag;
|
|
|
|
|
2014-01-14 20:31:19 +01:00
|
|
|
/* uchar output.
|
|
|
|
*/
|
|
|
|
gboolean uchar;
|
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
/* Our constants expanded to match arith->ready in size.
|
|
|
|
*/
|
|
|
|
int n;
|
|
|
|
double *a_ready;
|
|
|
|
double *b_ready;
|
2014-03-06 17:03:33 +01:00
|
|
|
double *a_imag_ready;
|
|
|
|
double *b_imag_ready;
|
2011-10-31 15:25:27 +01:00
|
|
|
|
2011-10-31 10:23:43 +01:00
|
|
|
} VipsLinear;
|
|
|
|
|
|
|
|
typedef VipsUnaryClass VipsLinearClass;
|
|
|
|
|
|
|
|
G_DEFINE_TYPE( VipsLinear, vips_linear, VIPS_TYPE_UNARY );
|
|
|
|
|
|
|
|
static int
|
|
|
|
vips_linear_build( VipsObject *object )
|
|
|
|
{
|
2012-11-02 15:41:47 +01:00
|
|
|
VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( object );
|
2011-10-31 10:23:43 +01:00
|
|
|
VipsArithmetic *arithmetic = VIPS_ARITHMETIC( object );
|
2011-10-31 15:25:27 +01:00
|
|
|
VipsUnary *unary = (VipsUnary *) object;
|
2011-10-31 10:23:43 +01:00
|
|
|
VipsLinear *linear = (VipsLinear *) object;
|
2013-12-03 15:25:22 +01:00
|
|
|
|
2014-01-22 15:53:48 +01:00
|
|
|
int bands;
|
2014-03-06 17:03:33 +01:00
|
|
|
VipsBandFormat format;
|
2011-10-31 15:25:27 +01:00
|
|
|
int i;
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* How many bands will our input image have after decoding? Need
|
|
|
|
* format too.
|
2014-01-22 15:53:48 +01:00
|
|
|
*/
|
|
|
|
switch( unary->in->Coding ) {
|
|
|
|
case VIPS_CODING_RAD:
|
2014-03-06 17:03:33 +01:00
|
|
|
bands = 3;
|
|
|
|
format = VIPS_FORMAT_FLOAT;
|
|
|
|
break;
|
|
|
|
|
2014-01-22 15:53:48 +01:00
|
|
|
case VIPS_CODING_LABQ:
|
|
|
|
bands = 3;
|
2014-03-06 17:03:33 +01:00
|
|
|
format = VIPS_FORMAT_SHORT;
|
2014-01-22 15:53:48 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
bands = unary->in->Bands;
|
2014-03-06 17:03:33 +01:00
|
|
|
format = unary->in->BandFmt;
|
2014-01-22 15:53:48 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* If we have a many-element vector, we need to bandup the image to
|
2011-10-31 15:25:27 +01:00
|
|
|
* match.
|
|
|
|
*/
|
2014-03-06 17:03:33 +01:00
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
linear->n = 1;
|
|
|
|
if( linear->a )
|
2014-03-06 17:03:33 +01:00
|
|
|
linear->n = VIPS_MAX( linear->n, linear->a->n );
|
2011-10-31 15:25:27 +01:00
|
|
|
if( linear->b )
|
|
|
|
linear->n = VIPS_MAX( linear->n, linear->b->n );
|
2014-03-06 17:03:33 +01:00
|
|
|
if( linear->a_imag )
|
|
|
|
linear->n = VIPS_MAX( linear->n, linear->a_imag->n );
|
|
|
|
if( linear->b_imag )
|
|
|
|
linear->n = VIPS_MAX( linear->n, linear->b_imag->n );
|
2011-10-31 15:25:27 +01:00
|
|
|
if( unary->in )
|
2014-01-22 15:53:48 +01:00
|
|
|
linear->n = VIPS_MAX( linear->n, bands );
|
2011-10-31 15:25:27 +01:00
|
|
|
arithmetic->base_bands = linear->n;
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
if( unary->in &&
|
|
|
|
linear->a &&
|
|
|
|
vips_check_vector( class->nickname, linear->a->n, unary->in ) )
|
|
|
|
return( -1 );
|
|
|
|
if( linear->b &&
|
|
|
|
linear->a &&
|
|
|
|
vips_check_vector_length( class->nickname,
|
|
|
|
linear->b->n, linear->a->n ) )
|
|
|
|
return( -1 );
|
|
|
|
if( linear->a_imag &&
|
|
|
|
linear->a &&
|
|
|
|
vips_check_vector_length( class->nickname,
|
|
|
|
linear->a_imag->n, linear->a->n ) )
|
|
|
|
return( -1 );
|
|
|
|
if( linear->b_imag &&
|
|
|
|
linear->a &&
|
|
|
|
vips_check_vector_length( class->nickname,
|
|
|
|
linear->b_imag->n, linear->a->n ) )
|
2011-10-31 10:23:43 +01:00
|
|
|
return( -1 );
|
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
/* Make up-banded versions of our constants.
|
|
|
|
*/
|
2013-07-15 23:01:00 +02:00
|
|
|
linear->a_ready = VIPS_ARRAY( linear, linear->n, double );
|
|
|
|
linear->b_ready = VIPS_ARRAY( linear, linear->n, double );
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Either complex constant can be missing, we need to default to zero.
|
|
|
|
*/
|
|
|
|
if( linear->a_imag ||
|
|
|
|
linear->b_imag ) {
|
|
|
|
linear->a_imag_ready = VIPS_ARRAY( linear, linear->n, double );
|
|
|
|
linear->b_imag_ready = VIPS_ARRAY( linear, linear->n, double );
|
|
|
|
memset( linear->a_imag_ready, 0, linear->n * sizeof( double ) );
|
|
|
|
memset( linear->b_imag_ready, 0, linear->n * sizeof( double ) );
|
|
|
|
}
|
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
for( i = 0; i < linear->n; i++ ) {
|
|
|
|
if( linear->a ) {
|
|
|
|
double *ary = (double *) linear->a->data;
|
|
|
|
int j = VIPS_MIN( i, linear->a->n - 1 );
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
linear->a_ready[i] = ary[j];
|
|
|
|
}
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
if( linear->b ) {
|
|
|
|
double *ary = (double *) linear->b->data;
|
|
|
|
int j = VIPS_MIN( i, linear->b->n - 1 );
|
|
|
|
|
|
|
|
linear->b_ready[i] = ary[j];
|
|
|
|
}
|
2014-03-06 17:03:33 +01:00
|
|
|
|
|
|
|
if( linear->a_imag ) {
|
|
|
|
double *ary = (double *) linear->a_imag->data;
|
|
|
|
int j = VIPS_MIN( i, linear->a_imag->n - 1 );
|
|
|
|
|
|
|
|
linear->a_imag_ready[i] = ary[j];
|
|
|
|
}
|
|
|
|
|
|
|
|
if( linear->b_imag ) {
|
|
|
|
double *ary = (double *) linear->b_imag->data;
|
|
|
|
int j = VIPS_MIN( i, linear->b_imag->n - 1 );
|
|
|
|
|
|
|
|
linear->b_imag_ready[i] = ary[j];
|
|
|
|
}
|
2011-10-31 15:25:27 +01:00
|
|
|
}
|
|
|
|
|
2014-01-14 20:31:19 +01:00
|
|
|
if( linear->uchar )
|
|
|
|
arithmetic->format = VIPS_FORMAT_UCHAR;
|
2014-03-06 17:03:33 +01:00
|
|
|
else if( linear->a_imag ||
|
|
|
|
linear->b_imag ) {
|
|
|
|
if( format == VIPS_FORMAT_DOUBLE )
|
|
|
|
arithmetic->format = VIPS_FORMAT_DPCOMPLEX;
|
|
|
|
else
|
|
|
|
arithmetic->format = VIPS_FORMAT_COMPLEX;
|
|
|
|
}
|
2014-01-14 20:31:19 +01:00
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
if( VIPS_OBJECT_CLASS( vips_linear_parent_class )->build( object ) )
|
|
|
|
return( -1 );
|
2011-10-31 10:23:43 +01:00
|
|
|
|
|
|
|
return( 0 );
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Non-complex input, non-complex constant, all bands of the constant equal.
|
2013-11-30 18:26:13 +01:00
|
|
|
*/
|
|
|
|
#define LOOP1( IN, OUT ) { \
|
2013-12-03 09:53:36 +01:00
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
OUT * restrict q = (OUT *) out; \
|
2013-11-30 18:26:13 +01:00
|
|
|
OUT a1 = a[0]; \
|
|
|
|
OUT b1 = b[0]; \
|
|
|
|
int sz = width * nb; \
|
|
|
|
\
|
|
|
|
for( x = 0; x < sz; x++ ) \
|
|
|
|
q[x] = a1 * (OUT) p[x] + b1; \
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Non-complex input, non-complex constant, many-band constant.
|
2011-10-31 15:25:27 +01:00
|
|
|
*/
|
|
|
|
#define LOOPN( IN, OUT ) { \
|
2013-12-03 09:53:36 +01:00
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
OUT * restrict q = (OUT *) out; \
|
2011-10-31 15:25:27 +01:00
|
|
|
\
|
|
|
|
for( i = 0, x = 0; x < width; x++ ) \
|
|
|
|
for( k = 0; k < nb; k++, i++ ) \
|
|
|
|
q[i] = a[k] * (OUT) p[i] + b[k]; \
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Non-complex input, complex constant, many-band constant.
|
|
|
|
*/
|
|
|
|
#define LOOPNC( IN, OUT ) { \
|
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
OUT * restrict q = (OUT *) out; \
|
|
|
|
\
|
|
|
|
for( i = 0, x = 0; x < width; x++ ) \
|
|
|
|
for( k = 0; k < nb; k++, i++ ) { \
|
|
|
|
q[0] = p[i] * a[k] + b[k]; \
|
|
|
|
q[1] = p[i] * a_imag[k] + b_imag[k]; \
|
|
|
|
q += 2; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2013-11-30 18:26:13 +01:00
|
|
|
#define LOOP( IN, OUT ) { \
|
2014-03-06 17:03:33 +01:00
|
|
|
if( linear->a_imag_ready ) { \
|
|
|
|
LOOPNC( IN, OUT ); \
|
|
|
|
} \
|
|
|
|
else if( linear->a->n == 1 && linear->b->n == 1 ) { \
|
2013-11-30 18:26:13 +01:00
|
|
|
LOOP1( IN, OUT ); \
|
|
|
|
} \
|
|
|
|
else { \
|
|
|
|
LOOPN( IN, OUT ); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Complex input, non-complex constant.
|
2011-10-31 15:25:27 +01:00
|
|
|
*/
|
|
|
|
#define LOOPCMPLXN( IN, OUT ) { \
|
2013-12-03 09:53:36 +01:00
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
OUT * restrict q = (OUT *) out; \
|
2011-10-31 15:25:27 +01:00
|
|
|
\
|
|
|
|
for( x = 0; x < width; x++ ) \
|
|
|
|
for( k = 0; k < nb; k++ ) { \
|
|
|
|
q[0] = a[k] * p[0] + b[k]; \
|
2013-11-08 15:09:42 +01:00
|
|
|
q[1] = p[1]; \
|
2011-10-31 15:25:27 +01:00
|
|
|
q += 2; \
|
|
|
|
p += 2; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Complex input, complex constant.
|
2014-01-14 20:31:19 +01:00
|
|
|
*/
|
2014-03-06 17:03:33 +01:00
|
|
|
#define LOOPCMPLXNC( IN, OUT ) { \
|
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
OUT * restrict q = (OUT *) out; \
|
|
|
|
\
|
|
|
|
for( x = 0; x < width; x++ ) \
|
|
|
|
for( k = 0; k < nb; k++ ) { \
|
|
|
|
double x1 = p[0]; \
|
|
|
|
double y1 = p[1]; \
|
|
|
|
double x2 = a[k]; \
|
|
|
|
double y2 = a_imag[k]; \
|
|
|
|
\
|
|
|
|
q[0] = x1 * x2 - y1 * y2 + b[k]; \
|
|
|
|
q[1] = x1 * y2 + x2 * y1 + b_imag[k]; \
|
|
|
|
\
|
|
|
|
q += 2; \
|
|
|
|
p += 2; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define LOOPCMPLX( IN, OUT ) { \
|
|
|
|
if( linear->a_imag_ready ) { \
|
|
|
|
LOOPCMPLXNC( IN, OUT ); \
|
|
|
|
} \
|
|
|
|
else { \
|
|
|
|
LOOPCMPLXN( IN, OUT ); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Non-complex input, all bands of the constant equal, uchar output. Since we
|
|
|
|
* don't look at the imaginary component of the constant since we don't
|
|
|
|
* generate the imaginary component of the output, we work for a complex
|
|
|
|
* constant too.
|
|
|
|
*/
|
|
|
|
#define LOOP1uc( IN, DUMMY ) { \
|
2014-01-14 20:31:19 +01:00
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
VipsPel * restrict q = (VipsPel *) out; \
|
|
|
|
float a1 = a[0]; \
|
|
|
|
float b1 = b[0]; \
|
|
|
|
int sz = width * nb; \
|
|
|
|
\
|
|
|
|
for( x = 0; x < sz; x++ ) { \
|
|
|
|
float t = a1 * p[x] + b1; \
|
|
|
|
\
|
|
|
|
q[x] = VIPS_CLIP( 0, t, 255 ); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Non-complex input, non-complex constant, uchar output. Since we are
|
|
|
|
* outputting non-complex, we will work for a complex constant too.
|
2014-01-14 20:31:19 +01:00
|
|
|
*/
|
2014-03-06 17:03:33 +01:00
|
|
|
#define LOOPNuc( IN, DUMMY ) { \
|
2014-01-14 20:31:19 +01:00
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
VipsPel * restrict q = (VipsPel *) out; \
|
|
|
|
\
|
|
|
|
for( i = 0, x = 0; x < width; x++ ) \
|
|
|
|
for( k = 0; k < nb; k++, i++ ) { \
|
|
|
|
double t = a[k] * p[i] + b[k]; \
|
|
|
|
\
|
|
|
|
q[i] = VIPS_CLIP( 0, t, 255 ); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
#define LOOPuc( IN, DUMMY ) { \
|
2014-01-14 20:31:19 +01:00
|
|
|
if( linear->a->n == 1 && linear->b->n == 1 ) { \
|
2014-03-06 17:03:33 +01:00
|
|
|
LOOP1uc( IN, DUMMY ); \
|
2014-01-14 20:31:19 +01:00
|
|
|
} \
|
|
|
|
else { \
|
2014-03-06 17:03:33 +01:00
|
|
|
LOOPNuc( IN, DUMMY ); \
|
2014-01-14 20:31:19 +01:00
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Complex input, non-complex constant, uchar output.
|
2014-01-14 20:31:19 +01:00
|
|
|
*/
|
2014-03-06 17:03:33 +01:00
|
|
|
#define LOOPCMPLXNuc( IN, DUMMY ) { \
|
2014-01-14 20:31:19 +01:00
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
VipsPel * restrict q = (VipsPel *) out; \
|
|
|
|
\
|
|
|
|
for( i = 0, x = 0; x < width; x++ ) \
|
|
|
|
for( k = 0; k < nb; k++, i++ ) { \
|
|
|
|
double t = a[k] * p[0] + b[k]; \
|
|
|
|
\
|
|
|
|
q[i] = VIPS_CLIP( 0, t, 255 ); \
|
|
|
|
p += 2; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
/* Complex input, complex constant, uchar output.
|
2011-10-31 15:25:27 +01:00
|
|
|
*/
|
2014-03-06 17:03:33 +01:00
|
|
|
#define LOOPCMPLXNCuc( IN, DUMMY ) { \
|
|
|
|
IN * restrict p = (IN *) in[0]; \
|
|
|
|
VipsPel * restrict q = (VipsPel *) out; \
|
|
|
|
\
|
|
|
|
for( i = 0, x = 0; x < width; x++ ) \
|
|
|
|
for( k = 0; k < nb; k++, i++ ) { \
|
|
|
|
double x1 = p[0]; \
|
|
|
|
double y1 = p[1]; \
|
|
|
|
double x2 = a[k]; \
|
|
|
|
double y2 = a_imag[k]; \
|
|
|
|
double t = x1 * x2 - y1 * y2 + b[k]; \
|
|
|
|
\
|
|
|
|
q[i] = VIPS_CLIP( 0, t, 255 ); \
|
|
|
|
p += 2; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define LOOPCMPLXuc( IN, OUT ) { \
|
|
|
|
if( linear->a_imag_ready ) { \
|
|
|
|
LOOPCMPLXNCuc( IN, OUT ); \
|
|
|
|
} \
|
|
|
|
else { \
|
|
|
|
LOOPCMPLXNuc( IN, OUT ); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SWITCH( REAL, CMPLX ) { \
|
|
|
|
switch( vips_image_get_format( im ) ) { \
|
|
|
|
case VIPS_FORMAT_UCHAR: \
|
|
|
|
REAL( unsigned char, float ); break; \
|
|
|
|
case VIPS_FORMAT_CHAR: \
|
|
|
|
REAL( signed char, float ); break; \
|
|
|
|
case VIPS_FORMAT_USHORT: \
|
|
|
|
REAL( unsigned short, float ); break; \
|
|
|
|
case VIPS_FORMAT_SHORT: \
|
|
|
|
REAL( signed short, float ); break; \
|
|
|
|
case VIPS_FORMAT_UINT: \
|
|
|
|
REAL( unsigned int, float ); break; \
|
|
|
|
case VIPS_FORMAT_INT: \
|
|
|
|
REAL( signed int, float ); break; \
|
|
|
|
case VIPS_FORMAT_FLOAT: \
|
|
|
|
REAL( float, float ); break; \
|
|
|
|
case VIPS_FORMAT_DOUBLE: \
|
|
|
|
REAL( double, double ); break; \
|
|
|
|
case VIPS_FORMAT_COMPLEX: \
|
|
|
|
CMPLX( float, float ); break; \
|
|
|
|
case VIPS_FORMAT_DPCOMPLEX: \
|
|
|
|
CMPLX( double, double ); break; \
|
|
|
|
\
|
|
|
|
default: \
|
|
|
|
g_assert( 0 ); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2011-10-31 10:23:43 +01:00
|
|
|
static void
|
2011-12-31 19:22:42 +01:00
|
|
|
vips_linear_buffer( VipsArithmetic *arithmetic,
|
|
|
|
VipsPel *out, VipsPel **in, int width )
|
2011-10-31 10:23:43 +01:00
|
|
|
{
|
|
|
|
VipsImage *im = arithmetic->ready[0];
|
2011-10-31 15:25:27 +01:00
|
|
|
VipsLinear *linear = (VipsLinear *) arithmetic;
|
2013-12-03 09:53:36 +01:00
|
|
|
double * restrict a = linear->a_ready;
|
|
|
|
double * restrict b = linear->b_ready;
|
2014-03-06 17:03:33 +01:00
|
|
|
double * restrict a_imag = linear->a_imag_ready;
|
|
|
|
double * restrict b_imag = linear->b_imag_ready;
|
2011-10-31 15:25:27 +01:00
|
|
|
int nb = im->Bands;
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
int i, x, k;
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
if( linear->uchar ) {
|
|
|
|
SWITCH( LOOPuc, LOOPCMPLXuc );
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
SWITCH( LOOP, LOOPCMPLX );
|
|
|
|
}
|
2011-10-31 10:23:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#define UC VIPS_FORMAT_UCHAR
|
|
|
|
#define C VIPS_FORMAT_CHAR
|
|
|
|
#define US VIPS_FORMAT_USHORT
|
|
|
|
#define S VIPS_FORMAT_SHORT
|
|
|
|
#define UI VIPS_FORMAT_UINT
|
|
|
|
#define I VIPS_FORMAT_INT
|
|
|
|
#define F VIPS_FORMAT_FLOAT
|
|
|
|
#define X VIPS_FORMAT_COMPLEX
|
|
|
|
#define D VIPS_FORMAT_DOUBLE
|
|
|
|
#define DX VIPS_FORMAT_DPCOMPLEX
|
|
|
|
|
2013-12-02 12:22:08 +01:00
|
|
|
static const VipsBandFormat vips_linear_format_table[10] = {
|
2011-10-31 10:23:43 +01:00
|
|
|
/* UC C US S UI I F X D DX */
|
2011-10-31 15:25:27 +01:00
|
|
|
F, F, F, F, F, F, F, X, D, DX
|
2011-10-31 10:23:43 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
vips_linear_class_init( VipsLinearClass *class )
|
|
|
|
{
|
2011-10-31 15:25:27 +01:00
|
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS( class );
|
2011-10-31 10:23:43 +01:00
|
|
|
VipsObjectClass *object_class = (VipsObjectClass *) class;
|
|
|
|
VipsArithmeticClass *aclass = VIPS_ARITHMETIC_CLASS( class );
|
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
gobject_class->set_property = vips_object_set_property;
|
|
|
|
gobject_class->get_property = vips_object_get_property;
|
|
|
|
|
2011-10-31 10:23:43 +01:00
|
|
|
object_class->nickname = "linear";
|
|
|
|
object_class->description = _( "calculate (a * in + b)" );
|
|
|
|
object_class->build = vips_linear_build;
|
|
|
|
|
|
|
|
aclass->process_line = vips_linear_buffer;
|
|
|
|
|
2013-12-03 13:39:13 +01:00
|
|
|
vips_arithmetic_set_format_table( aclass, vips_linear_format_table );
|
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
VIPS_ARG_BOXED( class, "a", 110,
|
2011-10-31 10:23:43 +01:00
|
|
|
_( "a" ),
|
|
|
|
_( "Multiply by this" ),
|
2011-10-31 15:25:27 +01:00
|
|
|
VIPS_ARGUMENT_REQUIRED_INPUT,
|
2011-10-31 10:23:43 +01:00
|
|
|
G_STRUCT_OFFSET( VipsLinear, a ),
|
|
|
|
VIPS_TYPE_ARRAY_DOUBLE );
|
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
VIPS_ARG_BOXED( class, "b", 111,
|
2011-10-31 10:23:43 +01:00
|
|
|
_( "b" ),
|
|
|
|
_( "Add this" ),
|
2011-10-31 15:25:27 +01:00
|
|
|
VIPS_ARGUMENT_REQUIRED_INPUT,
|
2011-10-31 10:23:43 +01:00
|
|
|
G_STRUCT_OFFSET( VipsLinear, b ),
|
|
|
|
VIPS_TYPE_ARRAY_DOUBLE );
|
2014-01-14 20:31:19 +01:00
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
VIPS_ARG_BOXED( class, "a_imag", 112,
|
|
|
|
_( "a_imag" ),
|
|
|
|
_( "Multiply by this (imaginary component)" ),
|
|
|
|
VIPS_ARGUMENT_OPTIONAL_INPUT,
|
|
|
|
G_STRUCT_OFFSET( VipsLinear, a_imag ),
|
|
|
|
VIPS_TYPE_ARRAY_DOUBLE );
|
|
|
|
|
|
|
|
VIPS_ARG_BOXED( class, "b_imag", 113,
|
|
|
|
_( "b_imag" ),
|
|
|
|
_( "Add this (imaginary component)" ),
|
|
|
|
VIPS_ARGUMENT_OPTIONAL_INPUT,
|
|
|
|
G_STRUCT_OFFSET( VipsLinear, b_imag ),
|
|
|
|
VIPS_TYPE_ARRAY_DOUBLE );
|
|
|
|
|
|
|
|
VIPS_ARG_BOOL( class, "uchar", 114,
|
2014-01-14 20:31:19 +01:00
|
|
|
_( "uchar" ),
|
|
|
|
_( "Output should be uchar" ),
|
|
|
|
VIPS_ARGUMENT_OPTIONAL_INPUT,
|
|
|
|
G_STRUCT_OFFSET( VipsLinear, uchar ),
|
|
|
|
FALSE );
|
|
|
|
|
2011-10-31 10:23:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
vips_linear_init( VipsLinear *linear )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2011-11-12 14:29:32 +01:00
|
|
|
static int
|
|
|
|
vips_linearv( VipsImage *in, VipsImage **out,
|
2014-03-06 17:03:33 +01:00
|
|
|
double *a, double *a_imag, double *b, double *b_imag, int n,
|
|
|
|
va_list ap )
|
2011-10-31 10:23:43 +01:00
|
|
|
{
|
2014-03-06 17:03:33 +01:00
|
|
|
VipsOperation *operation;
|
2011-10-31 15:25:27 +01:00
|
|
|
VipsArea *area_a;
|
|
|
|
VipsArea *area_b;
|
2014-03-06 17:03:33 +01:00
|
|
|
|
|
|
|
if( !(operation = vips_operation_new( "linear" )) )
|
|
|
|
return( -1 );
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2012-11-02 22:45:13 +01:00
|
|
|
area_a = (VipsArea *) vips_array_double_new( a, n );
|
|
|
|
area_b = (VipsArea *) vips_array_double_new( b, n );
|
2011-10-31 15:25:27 +01:00
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
g_object_set( operation,
|
|
|
|
"in", in,
|
|
|
|
"a", area_a,
|
|
|
|
"b", area_b,
|
|
|
|
NULL );
|
2011-10-31 10:23:43 +01:00
|
|
|
|
2011-10-31 15:25:27 +01:00
|
|
|
vips_area_unref( area_a );
|
|
|
|
vips_area_unref( area_b );
|
|
|
|
|
2014-03-06 17:03:33 +01:00
|
|
|
if( a_imag ) {
|
|
|
|
VipsArea *area_a_imag;
|
|
|
|
|
|
|
|
area_a_imag = (VipsArea *) vips_array_double_new( a_imag, n );
|
|
|
|
g_object_set( operation,
|
|
|
|
"a_imag", area_a_imag,
|
|
|
|
NULL );
|
|
|
|
vips_area_unref( area_a_imag );
|
|
|
|
}
|
|
|
|
|
|
|
|
if( b_imag ) {
|
|
|
|
VipsArea *area_b_imag;
|
|
|
|
|
|
|
|
area_b_imag = (VipsArea *) vips_array_double_new( b_imag, n );
|
|
|
|
g_object_set( operation,
|
|
|
|
"b_imag", area_b_imag,
|
|
|
|
NULL );
|
|
|
|
vips_area_unref( area_b_imag );
|
|
|
|
}
|
|
|
|
|
|
|
|
(void) vips_object_set_valist( VIPS_OBJECT( operation ), ap );
|
|
|
|
|
|
|
|
if( vips_cache_operation_buildp( &operation ) ) {
|
|
|
|
vips_object_unref_outputs( VIPS_OBJECT( operation ) );
|
|
|
|
g_object_unref( operation );
|
|
|
|
|
|
|
|
return( -1 );
|
|
|
|
}
|
|
|
|
|
|
|
|
g_object_get( operation,
|
|
|
|
"out", out,
|
|
|
|
NULL );
|
|
|
|
|
|
|
|
g_object_unref( operation );
|
|
|
|
|
|
|
|
return( 0 );
|
2011-10-31 15:25:27 +01:00
|
|
|
}
|
|
|
|
|
2011-11-18 10:08:45 +01:00
|
|
|
/**
|
|
|
|
* vips_linear:
|
|
|
|
* @in: image to transform
|
|
|
|
* @out: output image
|
2012-11-02 22:45:13 +01:00
|
|
|
* @a: (array length=n): array of constants for multiplication
|
|
|
|
* @b: (array length=n): array of constants for addition
|
2011-11-18 10:08:45 +01:00
|
|
|
* @n: length of constant arrays
|
2011-11-18 10:52:27 +01:00
|
|
|
* @...: %NULL-terminated list of optional named arguments
|
2011-11-18 10:08:45 +01:00
|
|
|
*
|
2014-01-14 20:31:19 +01:00
|
|
|
* Optional arguments:
|
|
|
|
*
|
|
|
|
* @uchar: output uchar pixels
|
2014-03-06 17:03:33 +01:00
|
|
|
* @a_imag: #VipsArrayDouble of imaginary constants for multiplication
|
|
|
|
* @b_imag: #VipsArrayDouble of imaginary constants for addition
|
2014-01-14 20:31:19 +01:00
|
|
|
*
|
2011-11-18 10:08:45 +01:00
|
|
|
* Pass an image through a linear transform, ie. (@out = @in * @a + @b). Output
|
2014-01-14 20:31:19 +01:00
|
|
|
* is float for integer input, double for double input, complex for
|
2014-03-06 17:03:33 +01:00
|
|
|
* complex input and double complex for double complex input. If complex
|
|
|
|
* constants are specified, the output is complex, see below.
|
|
|
|
*
|
|
|
|
* Set @uchar to output uchar pixels. This is much faster than vips_linear()
|
|
|
|
* followed by vips_cast().
|
2011-11-18 10:08:45 +01:00
|
|
|
*
|
|
|
|
* If the arrays of constants have just one element, that constant is used for
|
|
|
|
* all image bands. If the arrays have more than one element and they have
|
|
|
|
* the same number of elements as there are bands in the image, then
|
|
|
|
* one array element is used for each band. If the arrays have more than one
|
|
|
|
* element and the image only has a single band, the result is a many-band
|
|
|
|
* image where each band corresponds to one array element.
|
|
|
|
*
|
2014-03-06 17:03:33 +01:00
|
|
|
* Set @a_imag and @b_imag to set imagiary constants for multiplication and
|
|
|
|
* addition. If imaginary components are specified, the output is complex for
|
|
|
|
* non-double-complex inputs and double-complex for double-complex inputs.
|
|
|
|
*
|
|
|
|
* See also: vips_linear1(), vips_linear_complex(), vips_linear_complex1(),
|
|
|
|
* vips_add().
|
2011-11-18 10:08:45 +01:00
|
|
|
*
|
|
|
|
* Returns: 0 on success, -1 on error
|
|
|
|
*/
|
2011-10-31 15:25:27 +01:00
|
|
|
int
|
2011-11-12 14:29:32 +01:00
|
|
|
vips_linear( VipsImage *in, VipsImage **out, double *a, double *b, int n, ... )
|
2011-10-31 15:25:27 +01:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int result;
|
|
|
|
|
2011-11-12 14:29:32 +01:00
|
|
|
va_start( ap, n );
|
2014-03-06 17:03:33 +01:00
|
|
|
result = vips_linearv( in, out, a, NULL, b, NULL, n, ap );
|
2011-11-12 14:29:32 +01:00
|
|
|
va_end( ap );
|
2011-10-31 15:25:27 +01:00
|
|
|
|
2011-11-12 14:29:32 +01:00
|
|
|
return( result );
|
|
|
|
}
|
|
|
|
|
2011-11-18 10:08:45 +01:00
|
|
|
/**
|
|
|
|
* vips_linear1:
|
|
|
|
* @in: image to transform
|
|
|
|
* @out: output image
|
|
|
|
* @a: constant for multiplication
|
|
|
|
* @b: constant for addition
|
2011-11-18 10:52:27 +01:00
|
|
|
* @...: %NULL-terminated list of optional named arguments
|
2011-11-18 10:08:45 +01:00
|
|
|
*
|
2014-01-14 20:31:19 +01:00
|
|
|
* Optional arguments:
|
|
|
|
*
|
|
|
|
* @uchar: output uchar pixels
|
2014-03-06 17:03:33 +01:00
|
|
|
* @a_imag: #VipsArrayDouble of imaginary constants for multiplication
|
|
|
|
* @b_imag: #VipsArrayDouble of imaginary constants for addition
|
2014-01-14 20:31:19 +01:00
|
|
|
*
|
2011-11-18 10:08:45 +01:00
|
|
|
* Run vips_linear() with a single constant.
|
|
|
|
*
|
|
|
|
* See also: vips_linear().
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, -1 on error
|
|
|
|
*/
|
2011-11-12 14:29:32 +01:00
|
|
|
int
|
|
|
|
vips_linear1( VipsImage *in, VipsImage **out, double a, double b, ... )
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int result;
|
2011-10-31 15:25:27 +01:00
|
|
|
|
|
|
|
va_start( ap, b );
|
2014-03-06 17:03:33 +01:00
|
|
|
result = vips_linearv( in, out, &a, NULL, &b, NULL, 1, ap );
|
|
|
|
va_end( ap );
|
|
|
|
|
|
|
|
return( result );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* vips_linear_complex:
|
|
|
|
* @in: image to transform
|
|
|
|
* @out: output image
|
|
|
|
* @a: (array length=n): array of real constants for multiplication
|
|
|
|
* @a_imag: (array length=n): array of imaginary constants for multiplication
|
|
|
|
* @b: (array length=n): array of real constants for addition
|
|
|
|
* @b_imag: (array length=n): array of imaginary constants for addition
|
|
|
|
* @n: length of constant arrays
|
|
|
|
* @...: %NULL-terminated list of optional named arguments
|
|
|
|
*
|
|
|
|
* Optional arguments:
|
|
|
|
*
|
|
|
|
* @uchar: output uchar pixels
|
|
|
|
*
|
|
|
|
* Run vips_linear() with a set of complex constants.
|
|
|
|
*
|
|
|
|
* See also: vips_linear().
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, -1 on error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vips_linear_complex( VipsImage *in, VipsImage **out,
|
|
|
|
double *a, double *a_imag, double *b, double *b_imag, int n, ... )
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
va_start( ap, n );
|
|
|
|
result = vips_linearv( in, out, a, a_imag, b, b_imag, n, ap );
|
|
|
|
va_end( ap );
|
|
|
|
|
|
|
|
return( result );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* vips_linear_complex1:
|
|
|
|
* @in: image to transform
|
|
|
|
* @out: output image
|
|
|
|
* @a: real constant for multiplication
|
|
|
|
* @a_imag: imaginary constant for multiplication
|
|
|
|
* @b: real constant for addition
|
|
|
|
* @b_imag: imaginary constant for addition
|
|
|
|
* @...: %NULL-terminated list of optional named arguments
|
|
|
|
*
|
|
|
|
* Optional arguments:
|
|
|
|
*
|
|
|
|
* @uchar: output uchar pixels
|
|
|
|
*
|
|
|
|
* Run vips_linear() with a single complex constant.
|
|
|
|
*
|
|
|
|
* See also: vips_linear().
|
|
|
|
*
|
|
|
|
* Returns: 0 on success, -1 on error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vips_linear_complex1( VipsImage *in, VipsImage **out,
|
|
|
|
double a, double a_imag, double b, double b_imag, ... )
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
va_start( ap, b_imag );
|
|
|
|
result = vips_linearv( in, out, &a, &a_imag, &b, &b_imag, 1, ap );
|
2011-10-31 15:25:27 +01:00
|
|
|
va_end( ap );
|
|
|
|
|
2011-10-31 10:23:43 +01:00
|
|
|
return( result );
|
|
|
|
}
|