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

reduceh is working!

Browse Source
This commit is contained in:
John Cupitt 2016-01-27 14:34:06 +00:00
parent 8b09c86492
commit 3e78bdb6a9
6 changed files with 164 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libvips/include/vips/resample.h
View File

@ -46,8 +46,8 @@ int vips_shrinkv( VipsImage *in, VipsImage **out, int yshrink, ... );
int vips_reduce( VipsImage *in, VipsImage **out, int vips_reduce( VipsImage *in, VipsImage **out,
double xshrink, double yshrink, ... ); double xshrink, double yshrink, ... );
int vips_reduceh( VipsImage *in, VipsImage **out, int xshrink, ... ); int vips_reduceh( VipsImage *in, VipsImage **out, double xshrink, ... );
int vips_reducev( VipsImage *in, VipsImage **out, int yshrink, ... ); int vips_reducev( VipsImage *in, VipsImage **out, double yshrink, ... );
int vips_similarity( VipsImage *in, VipsImage **out, ... ) int vips_similarity( VipsImage *in, VipsImage **out, ... )
__attribute__((sentinel)); __attribute__((sentinel));

3
libvips/resample/Makefile.am
View File

@ -9,10 +9,11 @@ libresample_la_SOURCES = \
shrink.c \ shrink.c \
shrinkh.c \ shrinkh.c \
shrinkv.c \ shrinkv.c \
reduceh.c \
interpolate.c \ interpolate.c \
transform.c \ transform.c \
bicubic.cpp \ bicubic.cpp \
bicubich.cpp \ cubich.cpp \
lbb.cpp \ lbb.cpp \
nohalo.cpp \ nohalo.cpp \
vsqbs.cpp \ vsqbs.cpp \

120
libvips/resample/bicubich.cpp → libvips/resample/cubich.cpp
View File

@ -1,7 +1,7 @@
/* 1D horizontal bicubich (catmull-rom) interpolator /* horizontal cubic (catmull-rom) interpolator
* *
* 26/1/16 * 26/1/16
* - from bicubich.cpp * - from bicubic.cpp
*/ */
/* /*
@ -31,7 +31,7 @@
*/ */
/* Bicubich (Catmull-Rom) interpolator derived from Nicolas Robidoux's /* Cubic (Catmull-Rom) interpolator derived from Nicolas Robidoux's
* original YAFR resampler with permission and thanks. * original YAFR resampler with permission and thanks.
*/ */
@ -56,38 +56,38 @@
#include <dmalloc.h> #include <dmalloc.h>
#endif /*WITH_DMALLOC*/ #endif /*WITH_DMALLOC*/
#define VIPS_TYPE_INTERPOLATE_BICUBICH \ #define VIPS_TYPE_INTERPOLATE_CUBICH \
(vips_interpolate_bicubich_get_type()) (vips_interpolate_cubich_get_type())
#define VIPS_INTERPOLATE_BICUBICH( obj ) \ #define VIPS_INTERPOLATE_CUBICH( obj ) \
(G_TYPE_CHECK_INSTANCE_CAST( (obj), \ (G_TYPE_CHECK_INSTANCE_CAST( (obj), \
VIPS_TYPE_INTERPOLATE_BICUBICH, VipsInterpolateBicubich )) VIPS_TYPE_INTERPOLATE_CUBICH, VipsInterpolateCubich ))
#define VIPS_INTERPOLATE_BICUBICH_CLASS( klass ) \ #define VIPS_INTERPOLATE_CUBICH_CLASS( klass ) \
(G_TYPE_CHECK_CLASS_CAST( (klass), \ (G_TYPE_CHECK_CLASS_CAST( (klass), \
VIPS_TYPE_INTERPOLATE_BICUBICH, VipsInterpolateBicubichClass)) VIPS_TYPE_INTERPOLATE_CUBICH, VipsInterpolateCubichClass))
#define VIPS_IS_INTERPOLATE_BICUBICH( obj ) \ #define VIPS_IS_INTERPOLATE_CUBICH( obj ) \
(G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_INTERPOLATE_BICUBICH )) (G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_INTERPOLATE_CUBICH ))
#define VIPS_IS_INTERPOLATE_BICUBICH_CLASS( klass ) \ #define VIPS_IS_INTERPOLATE_CUBICH_CLASS( klass ) \
(G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_INTERPOLATE_BICUBICH )) (G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_INTERPOLATE_CUBICH ))
#define VIPS_INTERPOLATE_BICUBICH_GET_CLASS( obj ) \ #define VIPS_INTERPOLATE_CUBICH_GET_CLASS( obj ) \
(G_TYPE_INSTANCE_GET_CLASS( (obj), \ (G_TYPE_INSTANCE_GET_CLASS( (obj), \
VIPS_TYPE_INTERPOLATE_BICUBICH, VipsInterpolateBicubichClass )) VIPS_TYPE_INTERPOLATE_CUBICH, VipsInterpolateCubichClass ))
typedef VipsInterpolate VipsInterpolateBicubich; typedef VipsInterpolate VipsInterpolateCubich;
typedef VipsInterpolateClass VipsInterpolateBicubichClass; typedef VipsInterpolateClass VipsInterpolateCubichClass;
/* Precalculated interpolation matrices. int (used for pel /* Precalculated interpolation matrices. int (used for pel
* sizes up to short), and double (for all others). We go to * sizes up to short), and double (for all others). We go to
* scale + 1 so we can round-to-nearest safely. * scale + 1 so we can round-to-nearest safely.
*/ */
static int vips_bicubich_matrixi[VIPS_TRANSFORM_SCALE + 1][4]; static int vips_cubich_matrixi[VIPS_TRANSFORM_SCALE + 1][4];
static double vips_bicubich_matrixf[VIPS_TRANSFORM_SCALE + 1][4]; static double vips_cubich_matrixf[VIPS_TRANSFORM_SCALE + 1][4];
/* We need C linkage for this. /* We need C linkage for this.
*/ */
extern "C" { extern "C" {
G_DEFINE_TYPE( VipsInterpolateBicubich, vips_interpolate_bicubich, G_DEFINE_TYPE( VipsInterpolateCubich, vips_interpolate_cubich,
VIPS_TYPE_INTERPOLATE ); VIPS_TYPE_INTERPOLATE );
} }
@ -103,7 +103,7 @@ G_DEFINE_TYPE( VipsInterpolateBicubich, vips_interpolate_bicubich,
template <typename T, int max_value> template <typename T, int max_value>
static void inline static void inline
bicubich_unsigned_int_tab( void *pout, const VipsPel *pin, cubich_unsigned_int_tab( void *pout, const VipsPel *pin,
const int bands, const int *cx ) const int bands, const int *cx )
{ {
T* restrict out = (T *) pout; T* restrict out = (T *) pout;
@ -119,12 +119,12 @@ bicubich_unsigned_int_tab( void *pout, const VipsPel *pin,
const T thr = in[b2]; const T thr = in[b2];
const T fou = in[b3]; const T fou = in[b3];
int bicubich = bicubic1d_unsigned_int<T>( int cubich = cubic_unsigned_int<T>(
one, two, thr, fou, cx ); one, two, thr, fou, cx );
bicubich = VIPS_CLIP( 0, bicubich, max_value ); cubich = VIPS_CLIP( 0, cubich, max_value );
out[z] = bicubich; out[z] = cubich;
in += 1; in += 1;
} }
@ -132,7 +132,7 @@ bicubich_unsigned_int_tab( void *pout, const VipsPel *pin,
template <typename T, int min_value, int max_value> template <typename T, int min_value, int max_value>
static void inline static void inline
bicubich_signed_int_tab( void *pout, const VipsPel *pin, cubich_signed_int_tab( void *pout, const VipsPel *pin,
const int bands, const int *cx ) const int bands, const int *cx )
{ {
T* restrict out = (T *) pout; T* restrict out = (T *) pout;
@ -148,12 +148,12 @@ bicubich_signed_int_tab( void *pout, const VipsPel *pin,
const T thr = in[b2]; const T thr = in[b2];
const T fou = in[b3]; const T fou = in[b3];
int bicubich = bicubic1d_signed_int<T>( int cubich = cubic_signed_int<T>(
one, two, thr, fou, cx ); one, two, thr, fou, cx );
bicubich = VIPS_CLIP( min_value, bicubich, max_value ); cubich = VIPS_CLIP( min_value, cubich, max_value );
out[z] = bicubich; out[z] = cubich;
in += 1; in += 1;
} }
@ -163,7 +163,7 @@ bicubich_signed_int_tab( void *pout, const VipsPel *pin,
*/ */
template <typename T> template <typename T>
static void inline static void inline
bicubich_float_tab( void *pout, const VipsPel *pin, cubich_float_tab( void *pout, const VipsPel *pin,
const int bands, const double *cx ) const int bands, const double *cx )
{ {
T* restrict out = (T *) pout; T* restrict out = (T *) pout;
@ -179,10 +179,10 @@ bicubich_float_tab( void *pout, const VipsPel *pin,
const T thr = in[b2]; const T thr = in[b2];
const T fou = in[b3]; const T fou = in[b3];
const T bicubich = bicubic1d_float<T>( const T cubich = cubic_float<T>(
one, two, thr, fou, cx ); one, two, thr, fou, cx );
out[z] = bicubich; out[z] = cubich;
in += 1; in += 1;
} }
@ -192,7 +192,7 @@ bicubich_float_tab( void *pout, const VipsPel *pin,
*/ */
template <typename T> template <typename T>
static void inline static void inline
bicubich_notab( void *pout, const VipsPel *pin, cubich_notab( void *pout, const VipsPel *pin,
const int bands, double x ) const int bands, double x )
{ {
T* restrict out = (T *) pout; T* restrict out = (T *) pout;
@ -212,17 +212,17 @@ bicubich_notab( void *pout, const VipsPel *pin,
const T thr = in[b2]; const T thr = in[b2];
const T fou = in[b3]; const T fou = in[b3];
const T bicubich = bicubic1d_float<T>( const T cubich = cubic_float<T>(
one, two, thr, fou, cx ); one, two, thr, fou, cx );
out[z] = bicubich; out[z] = cubich;
in += 1; in += 1;
} }
} }
static void static void
vips_interpolate_bicubich_interpolate( VipsInterpolate *interpolate, vips_interpolate_cubich_interpolate( VipsInterpolate *interpolate,
void *out, VipsRegion *in, double x, double y ) void *out, VipsRegion *in, double x, double y )
{ {
/* Find the mask index. We round-to-nearest, so we need to generate /* Find the mask index. We round-to-nearest, so we need to generate
@ -247,8 +247,8 @@ vips_interpolate_bicubich_interpolate( VipsInterpolate *interpolate,
/* Look up the tables we need. /* Look up the tables we need.
*/ */
const int *cxi = vips_bicubich_matrixi[tx]; const int *cxi = vips_cubich_matrixi[tx];
const double *cxf = vips_bicubich_matrixf[tx]; const double *cxf = vips_cubich_matrixf[tx];
/* Pel size and line size. /* Pel size and line size.
*/ */
@ -265,7 +265,7 @@ vips_interpolate_bicubich_interpolate( VipsInterpolate *interpolate,
g_assert( x >= 1.0 ); g_assert( x >= 1.0 );
#ifdef DEBUG #ifdef DEBUG
printf( "vips_interpolate_bicubich_interpolate: %g %g\n", x, y ); printf( "vips_interpolate_cubich_interpolate: %g %g\n", x, y );
printf( "\tleft=%d, top=%d, width=%d, height=%d\n", printf( "\tleft=%d, top=%d, width=%d, height=%d\n",
ix - 1, iy, 4, 1 ); ix - 1, iy, 4, 1 );
printf( "\tmaskx=%d\n", tx ); printf( "\tmaskx=%d\n", tx );
@ -273,17 +273,17 @@ vips_interpolate_bicubich_interpolate( VipsInterpolate *interpolate,
switch( in->im->BandFmt ) { switch( in->im->BandFmt ) {
case VIPS_FORMAT_UCHAR: case VIPS_FORMAT_UCHAR:
bicubich_unsigned_int_tab<unsigned char, UCHAR_MAX>( cubich_unsigned_int_tab<unsigned char, UCHAR_MAX>(
out, p, bands, cxi ); out, p, bands, cxi );
/* /*
Handy for benchmarking Handy for benchmarking
bicubich_float_tab<unsigned char>( cubich_float_tab<unsigned char>(
out, p, bands, cxf ); out, p, bands, cxf );
bicubich_notab<unsigned char>( cubich_notab<unsigned char>(
out, p, bands, x - ix ); out, p, bands, x - ix );
*/ */
@ -291,47 +291,47 @@ vips_interpolate_bicubich_interpolate( VipsInterpolate *interpolate,
break; break;
case VIPS_FORMAT_CHAR: case VIPS_FORMAT_CHAR:
bicubich_signed_int_tab<signed char, SCHAR_MIN, SCHAR_MAX>( cubich_signed_int_tab<signed char, SCHAR_MIN, SCHAR_MAX>(
out, p, bands, cxi ); out, p, bands, cxi );
break; break;
case VIPS_FORMAT_USHORT: case VIPS_FORMAT_USHORT:
bicubich_unsigned_int_tab<unsigned short, USHRT_MAX>( cubich_unsigned_int_tab<unsigned short, USHRT_MAX>(
out, p, bands, cxi ); out, p, bands, cxi );
break; break;
case VIPS_FORMAT_SHORT: case VIPS_FORMAT_SHORT:
bicubich_signed_int_tab<signed short, SHRT_MIN, SHRT_MAX>( cubich_signed_int_tab<signed short, SHRT_MIN, SHRT_MAX>(
out, p, bands, cxi ); out, p, bands, cxi );
break; break;
case VIPS_FORMAT_UINT: case VIPS_FORMAT_UINT:
bicubich_float_tab<unsigned int>( cubich_float_tab<unsigned int>(
out, p, bands, cxf ); out, p, bands, cxf );
break; break;
case VIPS_FORMAT_INT: case VIPS_FORMAT_INT:
bicubich_float_tab<signed int>( cubich_float_tab<signed int>(
out, p, bands, cxf ); out, p, bands, cxf );
break; break;
case VIPS_FORMAT_FLOAT: case VIPS_FORMAT_FLOAT:
bicubich_float_tab<float>( cubich_float_tab<float>(
out, p, bands, cxf ); out, p, bands, cxf );
break; break;
case VIPS_FORMAT_DOUBLE: case VIPS_FORMAT_DOUBLE:
bicubich_notab<double>( cubich_notab<double>(
out, p, bands, x - ix ); out, p, bands, x - ix );
break; break;
case VIPS_FORMAT_COMPLEX: case VIPS_FORMAT_COMPLEX:
bicubich_float_tab<float>( cubich_float_tab<float>(
out, p, bands * 2, cxf ); out, p, bands * 2, cxf );
break; break;
case VIPS_FORMAT_DPCOMPLEX: case VIPS_FORMAT_DPCOMPLEX:
bicubich_notab<double>( cubich_notab<double>(
out, p, bands * 2, x - ix ); out, p, bands * 2, x - ix );
break; break;
@ -341,17 +341,17 @@ vips_interpolate_bicubich_interpolate( VipsInterpolate *interpolate,
} }
static void static void
vips_interpolate_bicubich_class_init( VipsInterpolateBicubichClass *iclass ) vips_interpolate_cubich_class_init( VipsInterpolateCubichClass *iclass )
{ {
VipsObjectClass *object_class = VIPS_OBJECT_CLASS( iclass ); VipsObjectClass *object_class = VIPS_OBJECT_CLASS( iclass );
VipsInterpolateClass *interpolate_class = VipsInterpolateClass *interpolate_class =
VIPS_INTERPOLATE_CLASS( iclass ); VIPS_INTERPOLATE_CLASS( iclass );
object_class->nickname = "bicubich"; object_class->nickname = "cubich";
object_class->description = object_class->description =
_( "horizontal bicubic interpolation (Catmull-Rom)" ); _( "horizontal cubic interpolation (Catmull-Rom)" );
interpolate_class->interpolate = vips_interpolate_bicubich_interpolate; interpolate_class->interpolate = vips_interpolate_cubich_interpolate;
interpolate_class->window_size = 4; interpolate_class->window_size = 4;
/* Build the tables of pre-computed coefficients. /* Build the tables of pre-computed coefficients.
@ -359,21 +359,21 @@ vips_interpolate_bicubich_class_init( VipsInterpolateBicubichClass *iclass )
for( int x = 0; x < VIPS_TRANSFORM_SCALE + 1; x++ ) { for( int x = 0; x < VIPS_TRANSFORM_SCALE + 1; x++ ) {
calculate_coefficients_catmull( calculate_coefficients_catmull(
(float) x / VIPS_TRANSFORM_SCALE, (float) x / VIPS_TRANSFORM_SCALE,
vips_bicubich_matrixf[x] ); vips_cubich_matrixf[x] );
for( int i = 0; i < 4; i++ ) for( int i = 0; i < 4; i++ )
vips_bicubich_matrixi[x][i] = vips_cubich_matrixi[x][i] =
vips_bicubich_matrixf[x][i] * vips_cubich_matrixf[x][i] *
VIPS_INTERPOLATE_SCALE; VIPS_INTERPOLATE_SCALE;
} }
} }
static void static void
vips_interpolate_bicubich_init( VipsInterpolateBicubich *bicubich ) vips_interpolate_cubich_init( VipsInterpolateCubich *cubich )
{ {
#ifdef DEBUG #ifdef DEBUG
printf( "vips_interpolate_bicubich_init: " ); printf( "vips_interpolate_cubich_init: " );
vips_object_print( VIPS_OBJECT( bicubich ) ); vips_object_print( VIPS_OBJECT( cubich ) );
#endif /*DEBUG*/ #endif /*DEBUG*/
} }

4
libvips/resample/interpolate.c
View File

@ -600,7 +600,7 @@ void
vips__interpolate_init( void ) vips__interpolate_init( void )
{ {
extern GType vips_interpolate_bicubic_get_type( void ); extern GType vips_interpolate_bicubic_get_type( void );
extern GType vips_interpolate_bicubich_get_type( void ); extern GType vips_interpolate_cubich_get_type( void );
extern GType vips_interpolate_lbb_get_type( void ); extern GType vips_interpolate_lbb_get_type( void );
extern GType vips_interpolate_nohalo_get_type( void ); extern GType vips_interpolate_nohalo_get_type( void );
extern GType vips_interpolate_vsqbs_get_type( void ); extern GType vips_interpolate_vsqbs_get_type( void );
@ -609,7 +609,7 @@ vips__interpolate_init( void )
vips_interpolate_bilinear_get_type(); vips_interpolate_bilinear_get_type();
vips_interpolate_bicubic_get_type(); vips_interpolate_bicubic_get_type();
vips_interpolate_bicubich_get_type(); vips_interpolate_cubich_get_type();
vips_interpolate_lbb_get_type(); vips_interpolate_lbb_get_type();
vips_interpolate_nohalo_get_type(); vips_interpolate_nohalo_get_type();
vips_interpolate_vsqbs_get_type(); vips_interpolate_vsqbs_get_type();

153
libvips/resample/reduceh.c
View File

@ -62,135 +62,56 @@ typedef VipsResampleClass VipsReducehClass;
G_DEFINE_TYPE( VipsReduceh, vips_reduceh, VIPS_TYPE_RESAMPLE ); G_DEFINE_TYPE( VipsReduceh, vips_reduceh, VIPS_TYPE_RESAMPLE );
#define INNER( BANDS ) \
sum += p[x1]; \
x1 += BANDS;
/* Integer reduce.
*/
#define IREDUCE( TYPE, BANDS ) { \
TYPE * restrict p = (TYPE *) in; \
TYPE * restrict q = (TYPE *) out; \
\
for( x = 0; x < width; x++ ) { \
for( b = 0; b < BANDS; b++ ) { \
int sum; \
\
sum = 0; \
x1 = b; \
VIPS_UNROLL( reduce->xreduce, INNER( BANDS ) ); \
q[b] = (sum + reduce->xreduce / 2) / \
reduce->xreduce; \
} \
p += ne; \
q += BANDS; \
} \
}
/* Float reduce.
*/
#define FREDUCE( TYPE ) { \
TYPE * restrict p = (TYPE *) in; \
TYPE * restrict q = (TYPE *) out; \
\
for( x = 0; x < width; x++ ) { \
for( b = 0; b < bands; b++ ) { \
double sum; \
\
sum = 0.0; \
x1 = b; \
VIPS_UNROLL( reduce->xreduce, INNER( bands ) ); \
q[b] = sum / reduce->xreduce; \
} \
p += ne; \
q += bands; \
} \
}
/* Generate an line of @or. @ir is large enough.
*/
static void
vips_reduceh_gen2( VipsReduceh *reduce, VipsRegion *or, VipsRegion *ir,
int left, int top, int width )
{
VipsResample *resample = VIPS_RESAMPLE( reduce );
const int bands = resample->in->Bands *
(vips_band_format_iscomplex( resample->in->BandFmt ) ?
2 : 1);
const int ne = reduce->xreduce * bands;
VipsPel *out = VIPS_REGION_ADDR( or, left, top );
VipsPel *in = VIPS_REGION_ADDR( ir, left * reduce->xreduce, top );
int x;
int x1, b;
switch( resample->in->BandFmt ) {
IREDUCE( unsigned char, bands ); break;
case VIPS_FORMAT_CHAR:
IREDUCE( char, bands ); break;
case VIPS_FORMAT_USHORT:
IREDUCE( unsigned short, bands ); break;
case VIPS_FORMAT_SHORT:
IREDUCE( short, bands ); break;
case VIPS_FORMAT_UINT:
IREDUCE( unsigned int, bands ); break;
case VIPS_FORMAT_INT:
IREDUCE( int, bands ); break;
case VIPS_FORMAT_FLOAT:
FREDUCE( float ); break;
case VIPS_FORMAT_DOUBLE:
FREDUCE( double ); break;
case VIPS_FORMAT_COMPLEX:
FREDUCE( float ); break;
case VIPS_FORMAT_DPCOMPLEX:
FREDUCE( double ); break;
default:
g_assert_not_reached();
}
}
static int static int
vips_reduceh_gen( VipsRegion *or, void *seq, vips_reduceh_gen( VipsRegion *or, void *seq,
void *a, void *b, gboolean *stop ) void *a, void *b, gboolean *stop )
{ {
VipsReduceh *reduce = (VipsReduceh *) b; VipsImage *in = (VipsImage *) a;
VipsReduceh *reduceh = (VipsReduceh *) b;
int window_size =
vips_interpolate_get_window_size( reduceh->interpolate );
int window_offset =
vips_interpolate_get_window_offset( reduceh->interpolate );
const VipsInterpolateMethod interpolate =
vips_interpolate_get_method( reduceh->interpolate );
int ps = VIPS_IMAGE_SIZEOF_PEL( in );
VipsRegion *ir = (VipsRegion *) seq; VipsRegion *ir = (VipsRegion *) seq;
VipsRect *r = &or->valid; VipsRect *r = &or->valid;
VipsRect s;
int y; int y;
/* How do we chunk up the image? We don't want to prepare the whole of
* the input region corresponding to *r since it could be huge.
*
* Request input a line at a time.
*/
#ifdef DEBUG #ifdef DEBUG
printf( "vips_reduceh_gen: generating %d x %d at %d x %d\n", printf( "vips_reduceh_gen: generating %d x %d at %d x %d\n",
r->width, r->height, r->left, r->top ); r->width, r->height, r->left, r->top );
#endif /*DEBUG*/ #endif /*DEBUG*/
for( y = 0; y < r->height; y ++ ) { s.left = r->left * reduceh->xreduce - window_offset;
VipsRect s; s.top = r->top;
s.width = r->width * reduceh->xreduce + window_size - 1;
s.left = r->left * reduce->xreduce; s.height = r->height;
s.top = r->top + y;
s.width = r->width * reduce->xreduce;
s.height = 1;
#ifdef DEBUG
printf( "reduceh_gen: requesting line %d\n", s.top );
#endif /*DEBUG*/
if( vips_region_prepare( ir, &s ) ) if( vips_region_prepare( ir, &s ) )
return( -1 ); return( -1 );
VIPS_GATE_START( "vips_reduceh_gen: work" ); VIPS_GATE_START( "vips_reduceh_gen: work" );
vips_reduceh_gen2( reduce, or, ir, for( y = 0; y < r->height; y ++ ) {
r->left, r->top + y, r->width ); VipsPel *q = VIPS_REGION_ADDR( or, r->left, r->top + y );
double Y = r->top + y;
int x;
for( x = 0; x < r->width; x++ ) {
double X = window_offset +
(r->left + x) * reduceh->xreduce;
interpolate( reduceh->interpolate, q, ir, X, Y );
q += ps;
}
}
VIPS_GATE_STOP( "vips_reduceh_gen: work" ); VIPS_GATE_STOP( "vips_reduceh_gen: work" );
}
return( 0 ); return( 0 );
} }
@ -200,7 +121,7 @@ vips_reduceh_build( VipsObject *object )
{ {
VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( object ); VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( object );
VipsResample *resample = VIPS_RESAMPLE( object ); VipsResample *resample = VIPS_RESAMPLE( object );
VipsReduceh *reduce = (VipsReduceh *) object; VipsReduceh *reduceh = (VipsReduceh *) object;
VipsImage **t = (VipsImage **) VipsImage **t = (VipsImage **)
vips_object_local_array( object, 1 ); vips_object_local_array( object, 1 );
@ -236,16 +157,16 @@ vips_reduceh_build( VipsObject *object )
window_offset = window_offset =
vips_interpolate_get_window_offset( reduceh->interpolate ); vips_interpolate_get_window_offset( reduceh->interpolate );
if( reduce->xreduce < 1 ) { if( reduceh->xreduce < 1 ) {
vips_error( class->nickname, vips_error( class->nickname,
"%s", _( "reduce factors should be >= 1" ) ); "%s", _( "reduce factors should be >= 1" ) );
return( -1 ); return( -1 );
} }
if( reduce->xreduce > 2 ) if( reduceh->xreduce > 2 )
vips_warn( class->nickname, vips_warn( class->nickname,
"%s", _( "reduce factor greater than 2" ) ); "%s", _( "reduce factor greater than 2" ) );
if( reduce->xreduce == 1 ) if( reduceh->xreduce == 1 )
return( vips_image_write( in, resample->out ) ); return( vips_image_write( in, resample->out ) );
/* Unpack for processing. /* Unpack for processing.
@ -278,7 +199,7 @@ vips_reduceh_build( VipsObject *object )
* example, vipsthumbnail knows the true reduce factor (including the * example, vipsthumbnail knows the true reduce factor (including the
* fractional part), we just see the integer part here. * fractional part), we just see the integer part here.
*/ */
resample->out->Xsize = in->Xsize / reduce->xreduce; resample->out->Xsize = (in->Xsize - window_size + 1) / reduceh->xreduce;
if( resample->out->Xsize <= 0 ) { if( resample->out->Xsize <= 0 ) {
vips_error( class->nickname, vips_error( class->nickname,
"%s", _( "image has shrunk to nothing" ) ); "%s", _( "image has shrunk to nothing" ) );
@ -293,7 +214,7 @@ vips_reduceh_build( VipsObject *object )
if( vips_image_generate( resample->out, if( vips_image_generate( resample->out,
vips_start_one, vips_reduceh_gen, vips_stop_one, vips_start_one, vips_reduceh_gen, vips_stop_one,
in, reduce ) ) in, reduceh ) )
return( -1 ); return( -1 );
return( 0 ); return( 0 );
@ -333,7 +254,7 @@ vips_reduceh_class_init( VipsReducehClass *class )
} }
static void static void
vips_reduceh_init( VipsReduceh *reduce ) vips_reduceh_init( VipsReduceh *reduceh )
{ {
} }
@ -345,7 +266,7 @@ vips_reduceh_init( VipsReduceh *reduce )
* @...: %NULL-terminated list of optional named arguments * @...: %NULL-terminated list of optional named arguments
* *
* Reduce @in horizontally by a float factor. The pixels in @out are * Reduce @in horizontally by a float factor. The pixels in @out are
* interpolated with a 1D bicubic mask. This operation will not work well for * interpolated with a 1D cubic mask. This operation will not work well for
* a reduction of more than a factor of two. * a reduction of more than a factor of two.
* *
* This is a very low-level operation: see vips_resize() for a more * This is a very low-level operation: see vips_resize() for a more

164
libvips/resample/templates.h
View File

@ -154,49 +154,8 @@ unsigned_fixed_round( int v )
return( (v + round_by) >> VIPS_INTERPOLATE_SHIFT ); return( (v + round_by) >> VIPS_INTERPOLATE_SHIFT );
} }
/* Fixed-point integer bicubic, used for 8 and 16-bit types.
*/
template <typename T> static int inline template <typename T> static int inline
bicubic_unsigned_int( cubic_unsigned_int(
const T uno_one, const T uno_two, const T uno_thr, const T uno_fou,
const T dos_one, const T dos_two, const T dos_thr, const T dos_fou,
const T tre_one, const T tre_two, const T tre_thr, const T tre_fou,
const T qua_one, const T qua_two, const T qua_thr, const T qua_fou,
const int* restrict cx, const int* restrict cy )
{
const int r0 = unsigned_fixed_round(
cx[0] * uno_one +
cx[1] * uno_two +
cx[2] * uno_thr +
cx[3] * uno_fou );
const int r1 = unsigned_fixed_round(
cx[0] * dos_one +
cx[1] * dos_two +
cx[2] * dos_thr +
cx[3] * dos_fou );
const int r2 = unsigned_fixed_round(
cx[0] * tre_one +
cx[1] * tre_two +
cx[2] * tre_thr +
cx[3] * tre_fou );
const int r3 = unsigned_fixed_round(
cx[0] * qua_one +
cx[1] * qua_two +
cx[2] * qua_thr +
cx[3] * qua_fou );
return( unsigned_fixed_round(
cy[0] * r0 +
cy[1] * r1 +
cy[2] * r2 +
cy[3] * r3 ) );
}
template <typename T> static int inline
bicubic1d_unsigned_int(
const T one, const T two, const T thr, const T fou, const T one, const T two, const T thr, const T fou,
const int* restrict cx ) const int* restrict cx )
{ {
@ -207,6 +166,28 @@ bicubic1d_unsigned_int(
cx[3] * fou ) ); cx[3] * fou ) );
} }
/* Fixed-point integer bicubic, used for 8 and 16-bit types.
*/
template <typename T> static int inline
bicubic_unsigned_int(
const T uno_one, const T uno_two, const T uno_thr, const T uno_fou,
const T dos_one, const T dos_two, const T dos_thr, const T dos_fou,
const T tre_one, const T tre_two, const T tre_thr, const T tre_fou,
const T qua_one, const T qua_two, const T qua_thr, const T qua_fou,
const int* restrict cx, const int* restrict cy )
{
const int r0 = cubic_unsigned_int<T>(
uno_one, uno_two, uno_thr, uno_fou, cx );
const int r1 = cubic_unsigned_int<T>(
dos_one, dos_two, dos_thr, dos_fou, cx );
const int r2 = cubic_unsigned_int<T>(
tre_one, tre_two, tre_thr, tre_fou, cx );
const int r3 = cubic_unsigned_int<T>(
qua_one, qua_two, qua_thr, qua_fou, cx );
return( cubic_unsigned_int<T>( r0, r1, r2, r3, cy ) );
}
static int inline static int inline
signed_fixed_round( int v ) signed_fixed_round( int v )
{ {
@ -216,6 +197,18 @@ signed_fixed_round( int v )
return( (v + round_by) >> VIPS_INTERPOLATE_SHIFT ); return( (v + round_by) >> VIPS_INTERPOLATE_SHIFT );
} }
template <typename T> static int inline
cubic_signed_int(
const T one, const T two, const T thr, const T fou,
const int* restrict cx )
{
return( signed_fixed_round(
cx[0] * one +
cx[1] * two +
cx[2] * thr +
cx[3] * fou ) );
}
/* Fixed-point integer bicubic, used for 8 and 16-bit types. /* Fixed-point integer bicubic, used for 8 and 16-bit types.
*/ */
template <typename T> static int inline template <typename T> static int inline
@ -226,47 +219,27 @@ bicubic_signed_int(
const T qua_one, const T qua_two, const T qua_thr, const T qua_fou, const T qua_one, const T qua_two, const T qua_thr, const T qua_fou,
const int* restrict cx, const int* restrict cy ) const int* restrict cx, const int* restrict cy )
{ {
const int r0 = signed_fixed_round( const int r0 = cubic_signed_int<T>(
cx[0] * uno_one + uno_one, uno_two, uno_thr, uno_fou, cx );
cx[1] * uno_two + const int r1 = cubic_signed_int<T>(
cx[2] * uno_thr + dos_one, dos_two, dos_thr, dos_fou, cx );
cx[3] * uno_fou ); const int r2 = cubic_signed_int<T>(
tre_one, tre_two, tre_thr, tre_fou, cx );
const int r3 = cubic_signed_int<T>(
qua_one, qua_two, qua_thr, qua_fou, cx );
const int r1 = signed_fixed_round( return( cubic_signed_int<T>( r0, r1, r2, r3, cy ) );
cx[0] * dos_one +
cx[1] * dos_two +
cx[2] * dos_thr +
cx[3] * dos_fou );
const int r2 = signed_fixed_round(
cx[0] * tre_one +
cx[1] * tre_two +
cx[2] * tre_thr +
cx[3] * tre_fou );
const int r3 = signed_fixed_round(
cx[0] * qua_one +
cx[1] * qua_two +
cx[2] * qua_thr +
cx[3] * qua_fou );
return( signed_fixed_round(
cy[0] * r0 +
cy[1] * r1 +
cy[2] * r2 +
cy[3] * r3 ) );
} }
template <typename T> static int inline template <typename T> static T inline
bicubic1d_signed_int( cubic_float(
const T one, const T two, const T thr, const T fou, const T one, const T two, const T thr, const T fou,
const int* restrict cx ) const double* restrict cx )
{ {
return( signed_fixed_round( return( cx[0] * one +
cx[0] * one +
cx[1] * two + cx[1] * two +
cx[2] * thr + cx[2] * thr +
cx[3] * fou ) ); cx[3] * fou );
} }
/* Floating-point bicubic, used for int/float/double types. /* Floating-point bicubic, used for int/float/double types.
@ -279,37 +252,16 @@ bicubic_float(
const T qua_one, const T qua_two, const T qua_thr, const T qua_fou, const T qua_one, const T qua_two, const T qua_thr, const T qua_fou,
const double* restrict cx, const double* restrict cy ) const double* restrict cx, const double* restrict cy )
{ {
return( const double r0 = cubic_float<T>(
cy[0] * (cx[0] * uno_one + uno_one, uno_two, uno_thr, uno_fou, cx );
cx[1] * uno_two + const double r1 = cubic_float<T>(
cx[2] * uno_thr + dos_one, dos_two, dos_thr, dos_fou, cx );
cx[3] * uno_fou) const double r2 = cubic_float<T>(
+ tre_one, tre_two, tre_thr, tre_fou, cx );
cy[1] * (cx[0] * dos_one + const double r3 = cubic_float<T>(
cx[1] * dos_two + qua_one, qua_two, qua_thr, qua_fou, cx );
cx[2] * dos_thr +
cx[3] * dos_fou)
+
cy[2] * (cx[0] * tre_one +
cx[1] * tre_two +
cx[2] * tre_thr +
cx[3] * tre_fou)
+
cy[3] * (cx[0] * qua_one +
cx[1] * qua_two +
cx[2] * qua_thr +
cx[3] * qua_fou) );
}
template <typename T> static T inline return( cubic_float<T>( r0, r1, r2, r3, cy ) );
bicubic1d_float(
const T one, const T two, const T thr, const T fou,
const double* restrict cx )
{
return( cx[0] * one +
cx[1] * two +
cx[2] * thr +
cx[3] * fou );
} }
/* Given an offset in [0,1] (we can have x == 1 when building tables), /* Given an offset in [0,1] (we can have x == 1 when building tables),