sergiotarxz/libvips
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'origin/7.38'

Browse Source 
Conflicts:
	ChangeLog
	configure.ac
This commit is contained in:
John Cupitt 2014-03-06 16:03:33 +00:00
commit 28b6602683
5 changed files with 362 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ChangeLog
View File

@ -10,6 +10,9 @@
- VipsStatistic operations are sequential - VipsStatistic operations are sequential
- VipsLinear has optional complex constants, added vips_linear_complex() etc. - VipsLinear has optional complex constants, added vips_linear_complex() etc.
6/3/14 started 7.38.6
- grey ramp minimum was wrong
24/2/14 started 7.38.5 24/2/14 started 7.38.5
- jpeg load from buffer could write to input, thanks Lovell - jpeg load from buffer could write to input, thanks Lovell
- fix webpload from buffer, thanks Lovell - fix webpload from buffer, thanks Lovell

2
configure.ac
View File

@ -37,7 +37,7 @@ VIPS_VERSION_STRING=$VIPS_VERSION-`date`
# binary interface changes not backwards compatible?: reset age to 0 # binary interface changes not backwards compatible?: reset age to 0
LIBRARY_CURRENT=37 LIBRARY_CURRENT=37
LIBRARY_REVISION=4 LIBRARY_REVISION=5
LIBRARY_AGE=0 LIBRARY_AGE=0
# patched into include/vips/version.h # patched into include/vips/version.h

437
libvips/arithmetic/linear.c
View File

@ -44,6 +44,8 @@
* - try an ORC path with the band loop unrolled * - try an ORC path with the band loop unrolled
* 14/1/14 * 14/1/14
* - add uchar output option * - add uchar output option
* 21/2/14
* - add imaginary components
*/ */
/* /*
@ -84,6 +86,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <math.h> #include <math.h>
#include <vips/vips.h> #include <vips/vips.h>
@ -98,6 +101,11 @@ typedef struct _VipsLinear {
VipsArea *a; VipsArea *a;
VipsArea *b; VipsArea *b;
/* Optional imaginary part. Zero if not set.
*/
VipsArea *a_imag;
VipsArea *b_imag;
/* uchar output. /* uchar output.
*/ */
gboolean uchar; gboolean uchar;
@ -107,6 +115,8 @@ typedef struct _VipsLinear {
int n; int n;
double *a_ready; double *a_ready;
double *b_ready; double *b_ready;
double *a_imag_ready;
double *b_imag_ready;
} VipsLinear; } VipsLinear;
@ -123,46 +133,81 @@ vips_linear_build( VipsObject *object )
VipsLinear *linear = (VipsLinear *) object; VipsLinear *linear = (VipsLinear *) object;
int bands; int bands;
VipsBandFormat format;
int i; int i;
/* How many bands will our input image have after decoding? /* How many bands will our input image have after decoding? Need
* format too.
*/ */
switch( unary->in->Coding ) { switch( unary->in->Coding ) {
case VIPS_CODING_RAD: case VIPS_CODING_RAD:
bands = 3;
format = VIPS_FORMAT_FLOAT;
break;
case VIPS_CODING_LABQ: case VIPS_CODING_LABQ:
bands = 3; bands = 3;
format = VIPS_FORMAT_SHORT;
break; break;
default: default:
bands = unary->in->Bands; bands = unary->in->Bands;
format = unary->in->BandFmt;
break; break;
} }
/* If we have a three-element vector we need to bandup the image to /* If we have a many-element vector, we need to bandup the image to
* match. * match.
*/ */
linear->n = 1; linear->n = 1;
if( linear->a ) if( linear->a )
linear->n = VIPS_MAX( linear->n, linear->b->n ); linear->n = VIPS_MAX( linear->n, linear->a->n );
if( linear->b ) if( linear->b )
linear->n = VIPS_MAX( linear->n, linear->b->n ); linear->n = VIPS_MAX( linear->n, linear->b->n );
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 );
if( unary->in ) if( unary->in )
linear->n = VIPS_MAX( linear->n, bands ); linear->n = VIPS_MAX( linear->n, bands );
arithmetic->base_bands = linear->n; arithmetic->base_bands = linear->n;
if( unary->in && linear->a && linear->b ) { if( unary->in &&
if( vips_check_vector( class->nickname, linear->a &&
linear->a->n, unary->in ) || vips_check_vector( class->nickname, linear->a->n, unary->in ) )
vips_check_vector( class->nickname, return( -1 );
linear->b->n, unary->in ) ) 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 ) )
return( -1 ); return( -1 );
}
/* Make up-banded versions of our constants. /* Make up-banded versions of our constants.
*/ */
linear->a_ready = VIPS_ARRAY( linear, linear->n, double ); linear->a_ready = VIPS_ARRAY( linear, linear->n, double );
linear->b_ready = VIPS_ARRAY( linear, linear->n, double ); linear->b_ready = VIPS_ARRAY( linear, linear->n, double );
/* 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 ) );
}
for( i = 0; i < linear->n; i++ ) { for( i = 0; i < linear->n; i++ ) {
if( linear->a ) { if( linear->a ) {
double *ary = (double *) linear->a->data; double *ary = (double *) linear->a->data;
@ -177,10 +222,31 @@ vips_linear_build( VipsObject *object )
linear->b_ready[i] = ary[j]; linear->b_ready[i] = ary[j];
} }
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];
}
} }
if( linear->uchar ) if( linear->uchar )
arithmetic->format = VIPS_FORMAT_UCHAR; arithmetic->format = VIPS_FORMAT_UCHAR;
else if( linear->a_imag ||
linear->b_imag ) {
if( format == VIPS_FORMAT_DOUBLE )
arithmetic->format = VIPS_FORMAT_DPCOMPLEX;
else
arithmetic->format = VIPS_FORMAT_COMPLEX;
}
if( VIPS_OBJECT_CLASS( vips_linear_parent_class )->build( object ) ) if( VIPS_OBJECT_CLASS( vips_linear_parent_class )->build( object ) )
return( -1 ); return( -1 );
@ -188,7 +254,7 @@ vips_linear_build( VipsObject *object )
return( 0 ); return( 0 );
} }
/* Non-complex input, any output, all bands of the constant equal. /* Non-complex input, non-complex constant, all bands of the constant equal.
*/ */
#define LOOP1( IN, OUT ) { \ #define LOOP1( IN, OUT ) { \
IN * restrict p = (IN *) in[0]; \ IN * restrict p = (IN *) in[0]; \
@ -201,7 +267,7 @@ vips_linear_build( VipsObject *object )
q[x] = a1 * (OUT) p[x] + b1; \ q[x] = a1 * (OUT) p[x] + b1; \
} }
/* Non-complex input, any output. /* Non-complex input, non-complex constant, many-band constant.
*/ */
#define LOOPN( IN, OUT ) { \ #define LOOPN( IN, OUT ) { \
IN * restrict p = (IN *) in[0]; \ IN * restrict p = (IN *) in[0]; \
@ -212,8 +278,25 @@ vips_linear_build( VipsObject *object )
q[i] = a[k] * (OUT) p[i] + b[k]; \ q[i] = a[k] * (OUT) p[i] + b[k]; \
} }
/* 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; \
} \
}
#define LOOP( IN, OUT ) { \ #define LOOP( IN, OUT ) { \
if( linear->a->n == 1 && linear->b->n == 1 ) { \ if( linear->a_imag_ready ) { \
LOOPNC( IN, OUT ); \
} \
else if( linear->a->n == 1 && linear->b->n == 1 ) { \
LOOP1( IN, OUT ); \ LOOP1( IN, OUT ); \
} \ } \
else { \ else { \
@ -221,7 +304,7 @@ vips_linear_build( VipsObject *object )
} \ } \
} }
/* Complex input, complex output. /* Complex input, non-complex constant.
*/ */
#define LOOPCMPLXN( IN, OUT ) { \ #define LOOPCMPLXN( IN, OUT ) { \
IN * restrict p = (IN *) in[0]; \ IN * restrict p = (IN *) in[0]; \
@ -236,10 +319,42 @@ vips_linear_build( VipsObject *object )
} \ } \
} }
/* Non-complex input, any output, all bands of the constant equal, uchar /* Complex input, complex constant.
* output.
*/ */
#define LOOP1uc( IN ) { \ #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 ) { \
IN * restrict p = (IN *) in[0]; \ IN * restrict p = (IN *) in[0]; \
VipsPel * restrict q = (VipsPel *) out; \ VipsPel * restrict q = (VipsPel *) out; \
float a1 = a[0]; \ float a1 = a[0]; \
@ -253,9 +368,10 @@ vips_linear_build( VipsObject *object )
} \ } \
} }
/* Non-complex input, uchar output. /* Non-complex input, non-complex constant, uchar output. Since we are
* outputting non-complex, we will work for a complex constant too.
*/ */
#define LOOPNuc( IN ) { \ #define LOOPNuc( IN, DUMMY ) { \
IN * restrict p = (IN *) in[0]; \ IN * restrict p = (IN *) in[0]; \
VipsPel * restrict q = (VipsPel *) out; \ VipsPel * restrict q = (VipsPel *) out; \
\ \
@ -267,18 +383,18 @@ vips_linear_build( VipsObject *object )
} \ } \
} }
#define LOOPuc( IN ) { \ #define LOOPuc( IN, DUMMY ) { \
if( linear->a->n == 1 && linear->b->n == 1 ) { \ if( linear->a->n == 1 && linear->b->n == 1 ) { \
LOOP1uc( IN ); \ LOOP1uc( IN, DUMMY ); \
} \ } \
else { \ else { \
LOOPNuc( IN ); \ LOOPNuc( IN, DUMMY ); \
} \ } \
} }
/* Complex input, uchar output. /* Complex input, non-complex constant, uchar output.
*/ */
#define LOOPCMPLXNuc( IN ) { \ #define LOOPCMPLXNuc( IN, DUMMY ) { \
IN * restrict p = (IN *) in[0]; \ IN * restrict p = (IN *) in[0]; \
VipsPel * restrict q = (VipsPel *) out; \ VipsPel * restrict q = (VipsPel *) out; \
\ \
@ -291,8 +407,62 @@ vips_linear_build( VipsObject *object )
} \ } \
} }
/* Lintra a buffer, n set of scale/offset. /* Complex input, complex constant, uchar output.
*/ */
#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 ); \
} \
}
static void static void
vips_linear_buffer( VipsArithmetic *arithmetic, vips_linear_buffer( VipsArithmetic *arithmetic,
VipsPel *out, VipsPel **in, int width ) VipsPel *out, VipsPel **in, int width )
@ -301,67 +471,20 @@ vips_linear_buffer( VipsArithmetic *arithmetic,
VipsLinear *linear = (VipsLinear *) arithmetic; VipsLinear *linear = (VipsLinear *) arithmetic;
double * restrict a = linear->a_ready; double * restrict a = linear->a_ready;
double * restrict b = linear->b_ready; double * restrict b = linear->b_ready;
double * restrict a_imag = linear->a_imag_ready;
double * restrict b_imag = linear->b_imag_ready;
int nb = im->Bands; int nb = im->Bands;
int i, x, k; int i, x, k;
if( linear->uchar ) if( linear->uchar ) {
switch( vips_image_get_format( im ) ) { SWITCH( LOOPuc, LOOPCMPLXuc );
case VIPS_FORMAT_UCHAR:
LOOPuc( unsigned char ); break;
case VIPS_FORMAT_CHAR:
LOOPuc( signed char ); break;
case VIPS_FORMAT_USHORT:
LOOPuc( unsigned short ); break;
case VIPS_FORMAT_SHORT:
LOOPuc( signed short ); break;
case VIPS_FORMAT_UINT:
LOOPuc( unsigned int ); break;
case VIPS_FORMAT_INT:
LOOPuc( signed int ); break;
case VIPS_FORMAT_FLOAT:
LOOPuc( float ); break;
case VIPS_FORMAT_DOUBLE:
LOOPuc( double ); break;
case VIPS_FORMAT_COMPLEX:
LOOPCMPLXNuc( float ); break;
case VIPS_FORMAT_DPCOMPLEX:
LOOPCMPLXNuc( double ); break;
default:
g_assert( 0 );
} }
else else {
switch( vips_image_get_format( im ) ) { SWITCH( LOOP, LOOPCMPLX );
case VIPS_FORMAT_UCHAR:
LOOP( unsigned char, float ); break;
case VIPS_FORMAT_CHAR:
LOOP( signed char, float ); break;
case VIPS_FORMAT_USHORT:
LOOP( unsigned short, float ); break;
case VIPS_FORMAT_SHORT:
LOOP( signed short, float ); break;
case VIPS_FORMAT_UINT:
LOOP( unsigned int, float ); break;
case VIPS_FORMAT_INT:
LOOP( signed int, float ); break;
case VIPS_FORMAT_FLOAT:
LOOP( float, float ); break;
case VIPS_FORMAT_DOUBLE:
LOOP( double, double ); break;
case VIPS_FORMAT_COMPLEX:
LOOPCMPLXN( float, float ); break;
case VIPS_FORMAT_DPCOMPLEX:
LOOPCMPLXN( double, double ); break;
default:
g_assert( 0 );
} }
} }
/* Save a bit of typing.
*/
#define UC VIPS_FORMAT_UCHAR #define UC VIPS_FORMAT_UCHAR
#define C VIPS_FORMAT_CHAR #define C VIPS_FORMAT_CHAR
#define US VIPS_FORMAT_USHORT #define US VIPS_FORMAT_USHORT
@ -373,8 +496,6 @@ vips_linear_buffer( VipsArithmetic *arithmetic,
#define D VIPS_FORMAT_DOUBLE #define D VIPS_FORMAT_DOUBLE
#define DX VIPS_FORMAT_DPCOMPLEX #define DX VIPS_FORMAT_DPCOMPLEX
/* Format doesn't change with linear.
*/
static const VipsBandFormat vips_linear_format_table[10] = { static const VipsBandFormat vips_linear_format_table[10] = {
/* UC C US S UI I F X D DX */ /* UC C US S UI I F X D DX */
F, F, F, F, F, F, F, X, D, DX F, F, F, F, F, F, F, X, D, DX
@ -412,7 +533,21 @@ vips_linear_class_init( VipsLinearClass *class )
G_STRUCT_OFFSET( VipsLinear, b ), G_STRUCT_OFFSET( VipsLinear, b ),
VIPS_TYPE_ARRAY_DOUBLE ); VIPS_TYPE_ARRAY_DOUBLE );
VIPS_ARG_BOOL( class, "uchar", 112, 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,
_( "uchar" ), _( "uchar" ),
_( "Output should be uchar" ), _( "Output should be uchar" ),
VIPS_ARGUMENT_OPTIONAL_INPUT, VIPS_ARGUMENT_OPTIONAL_INPUT,
@ -428,21 +563,64 @@ vips_linear_init( VipsLinear *linear )
static int static int
vips_linearv( VipsImage *in, VipsImage **out, vips_linearv( VipsImage *in, VipsImage **out,
double *a, double *b, int n, va_list ap ) double *a, double *a_imag, double *b, double *b_imag, int n,
va_list ap )
{ {
VipsOperation *operation;
VipsArea *area_a; VipsArea *area_a;
VipsArea *area_b; VipsArea *area_b;
int result;
if( !(operation = vips_operation_new( "linear" )) )
return( -1 );
area_a = (VipsArea *) vips_array_double_new( a, n ); area_a = (VipsArea *) vips_array_double_new( a, n );
area_b = (VipsArea *) vips_array_double_new( b, n ); area_b = (VipsArea *) vips_array_double_new( b, n );
result = vips_call_split( "linear", ap, in, out, area_a, area_b ); g_object_set( operation,
"in", in,
"a", area_a,
"b", area_b,
NULL );
vips_area_unref( area_a ); vips_area_unref( area_a );
vips_area_unref( area_b ); vips_area_unref( area_b );
return( result ); 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 );
} }
/** /**
@ -457,11 +635,16 @@ vips_linearv( VipsImage *in, VipsImage **out,
* Optional arguments: * Optional arguments:
* *
* @uchar: output uchar pixels * @uchar: output uchar pixels
* @a_imag: #VipsArrayDouble of imaginary constants for multiplication
* @b_imag: #VipsArrayDouble of imaginary constants for addition
* *
* Pass an image through a linear transform, ie. (@out = @in * @a + @b). Output * Pass an image through a linear transform, ie. (@out = @in * @a + @b). Output
* is float for integer input, double for double input, complex for * is float for integer input, double for double input, complex for
* complex input and double complex for double complex input. Set @uchar to * complex input and double complex for double complex input. If complex
* output uchar pixels. * 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().
* *
* If the arrays of constants have just one element, that constant is used for * 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 * all image bands. If the arrays have more than one element and they have
@ -470,7 +653,12 @@ vips_linearv( VipsImage *in, VipsImage **out,
* element and the image only has a single band, the result is a many-band * element and the image only has a single band, the result is a many-band
* image where each band corresponds to one array element. * image where each band corresponds to one array element.
* *
* See also: vips_linear1(), vips_add(). * 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().
* *
* Returns: 0 on success, -1 on error * Returns: 0 on success, -1 on error
*/ */
@ -481,7 +669,7 @@ vips_linear( VipsImage *in, VipsImage **out, double *a, double *b, int n, ... )
int result; int result;
va_start( ap, n ); va_start( ap, n );
result = vips_linearv( in, out, a, b, n, ap ); result = vips_linearv( in, out, a, NULL, b, NULL, n, ap );
va_end( ap ); va_end( ap );
return( result ); return( result );
@ -498,6 +686,8 @@ vips_linear( VipsImage *in, VipsImage **out, double *a, double *b, int n, ... )
* Optional arguments: * Optional arguments:
* *
* @uchar: output uchar pixels * @uchar: output uchar pixels
* @a_imag: #VipsArrayDouble of imaginary constants for multiplication
* @b_imag: #VipsArrayDouble of imaginary constants for addition
* *
* Run vips_linear() with a single constant. * Run vips_linear() with a single constant.
* *
@ -512,7 +702,76 @@ vips_linear1( VipsImage *in, VipsImage **out, double a, double b, ... )
int result; int result;
va_start( ap, b ); va_start( ap, b );
result = vips_linearv( in, out, &a, &b, 1, ap ); 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 );
va_end( ap ); va_end( ap );
return( result ); return( result );

2
libvips/create/grey.c
View File

@ -89,6 +89,8 @@ vips_grey_class_init( VipsGreyClass *class )
vobject_class->description = _( "make a grey ramp image" ); vobject_class->description = _( "make a grey ramp image" );
point_class->point = vips_grey_point; point_class->point = vips_grey_point;
point_class->min = 0.0;
point_class->max = 1.0;
} }
static void static void

6
libvips/include/vips/arithmetic.h
View File

@ -185,6 +185,12 @@ int vips_linear( VipsImage *in, VipsImage **out,
__attribute__((sentinel)); __attribute__((sentinel));
int vips_linear1( VipsImage *in, VipsImage **out, double a, double b, ... ) int vips_linear1( VipsImage *in, VipsImage **out, double a, double b, ... )
__attribute__((sentinel)); __attribute__((sentinel));
int vips_linear_complex( VipsImage *in, VipsImage **out,
double *a, double *a_imag, double *b, double *b_imag, int n, ... )
__attribute__((sentinel));
int vips_linear_complex1( VipsImage *in, VipsImage **out,
double a, double a_imag, double b, double b_imag, ... )
__attribute__((sentinel));
int vips_remainder( VipsImage *left, VipsImage *right, VipsImage **out, ... ) int vips_remainder( VipsImage *left, VipsImage *right, VipsImage **out, ... )
__attribute__((sentinel)); __attribute__((sentinel));
int vips_remainder_const( VipsImage *in, VipsImage **out, int vips_remainder_const( VipsImage *in, VipsImage **out,