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

finish up

Browse Source
This commit is contained in:
John Cupitt 2016-03-10 17:33:34 +00:00
parent e9bf936377
commit d351e07a6b
10 changed files with 314 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
TODO
View File

@ -1,6 +1,15 @@
- see
- strange
https://en.wikipedia.org/wiki/Lanczos_resampling
john@kiwi:~/pics$ vips gaussblur babe.jpg x.v 0.2
gaussmat: mask too large
- removed the cache from resize since we no longer sharpen, can we get
out-of-order reads?
- vips_resize() needs to take a param for kernel rather than interpolate?
maybe just don't expose this
- what demand hint are we setting for the reduce / shrink funcs?
- try SEQ_UNBUFFERED on jpg source, get out of order error?

12
libvips/create/gaussmat.c
View File

@ -18,6 +18,8 @@
* 16/12/14
* - default to int output to match vips_conv()
* - use @precision, not @integer
* 10/3/16
* - allow 1x1 masks
*/
/*
@ -84,6 +86,10 @@ typedef struct _VipsGaussmatClass {
G_DEFINE_TYPE( VipsGaussmat, vips_gaussmat, VIPS_TYPE_CREATE );
/* Don't allow mask radius to go over this.
*/
#define MASK_SANITY (5000)
static int
vips_gaussmat_build( VipsObject *object )
{
@ -91,7 +97,7 @@ vips_gaussmat_build( VipsObject *object )
VipsCreate *create = VIPS_CREATE( object );
VipsGaussmat *gaussmat = (VipsGaussmat *) object;
double sig2 = 2. * gaussmat->sigma * gaussmat->sigma;
int max_x = 8 * gaussmat->sigma > 5000 ? 5000 : 8 * gaussmat->sigma ;
int max_x = VIPS_CLIP( 0, 8 * gaussmat->sigma, MASK_SANITY );
int x, y;
int width, height;
@ -114,7 +120,7 @@ vips_gaussmat_build( VipsObject *object )
return( -1 );
/* Find the size of the mask. Limit the mask size to 10k x 10k for
* sanity.
* sanity. We allow x == 0, meaning a 1x1 mask.
*/
for( x = 0; x < max_x; x++ ) {
double v = exp( - ((double)(x * x)) / sig2 );
@ -122,7 +128,7 @@ vips_gaussmat_build( VipsObject *object )
if( v < gaussmat->min_ampl )
break;
}
if( x == max_x ) {
if( x >= MASK_SANITY ) {
vips_error( class->nickname, "%s", _( "mask too large" ) );
return( -1 );
}

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

@ -58,6 +58,11 @@ int vips_reduce( VipsImage *in, VipsImage **out,
int vips_reduceh( VipsImage *in, VipsImage **out, double xshrink, ... );
int vips_reducev( VipsImage *in, VipsImage **out, double yshrink, ... );
int vips_reducel3( VipsImage *in, VipsImage **out,
double xshrink, double yshrink, ... );
int vips_reducehl3( VipsImage *in, VipsImage **out, double xshrink, ... );
int vips_reducevl3( VipsImage *in, VipsImage **out, double yshrink, ... );
int vips_similarity( VipsImage *in, VipsImage **out, ... )
__attribute__((sentinel));
int vips_affine( VipsImage *in, VipsImage **out,

1
libvips/resample/Makefile.am
View File

@ -10,6 +10,7 @@ libresample_la_SOURCES = \
shrinkh.c \
shrinkv.c \
reduce.c \
reducel3.c \
reduceh.cpp \
reducehl3.cpp \
reducev.cpp \

20
libvips/resample/reducehl3.cpp
View File

@ -184,24 +184,30 @@ reducehl3_unsigned_int_tab( VipsReducehl3 *reducehl3,
* 11-point kernel for the vector version to be worthwhile.
*/
static void inline
reducehl3_unsigned_uint8_4tab( VipsPel *out, const VipsPel *in,
reducehl3_unsigned_uint8_6tab( VipsPel *out, const VipsPel *in,
const int bands, const int *cx )
{
const int b1 = bands;
const int b2 = b1 + b1;
const int b3 = b1 + b2;
const int b4 = b2 + b2;
const int b5 = b1 + b4;
const int c0 = cx[0];
const int c1 = cx[1];
const int c2 = cx[2];
const int c3 = cx[3];
const int c4 = cx[4];
const int c5 = cx[5];
for( int z = 0; z < bands; z++ ) {
int cubich = unsigned_fixed_round(
c0 * in[0] +
c1 * in[b1] +
c2 * in[b2] +
c3 * in[b3] );
c3 * in[b3] +
c4 * in[b4] +
c5 * in[b5] );
cubich = VIPS_CLIP( 0, cubich, 255 );
@ -368,8 +374,8 @@ vips_reducehl3_gen( VipsRegion *out_region, void *seq,
switch( in->BandFmt ) {
case VIPS_FORMAT_UCHAR:
if( reducehl3->n_points == 4 )
reducehl3_unsigned_uint8_4tab(
if( reducehl3->n_points == 6 )
reducehl3_unsigned_uint8_6tab(
q, p, bands, cxi );
else
reducehl3_unsigned_int_tab
@ -560,14 +566,14 @@ vips_reducehl3_class_init( VipsReducehl3Class *reducehl3_class )
_( "Resampling kernel" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsReducehl3, kernel ),
VIPS_TYPE_KERNEL, VIPS_KERNEL_CUBIC );
VIPS_TYPE_KERNEL, VIPS_KERNEL_LANCZOS3 );
}
static void
vips_reducehl3_init( VipsReducehl3 *reducehl3 )
{
reducehl3->kernel = VIPS_KERNEL_CUBIC;
reducehl3->kernel = VIPS_KERNEL_LANCZOS3;
}
/**
@ -579,7 +585,7 @@ vips_reducehl3_init( VipsReducehl3 *reducehl3 )
*
* Optional arguments:
*
* @kernel: #VipsKernel to use to interpolate (default: cubic)
* @kernel: #VipsKernel to use to interpolate (default: lanczos3)
*
* Reduce @in horizontally by a float factor. The pixels in @out are
* interpolated with a 1D mask. This operation will not work well for

176
libvips/resample/reducel3.c Normal file
View File

@ -0,0 +1,176 @@
/* 2D reducel3 ... call reducel3h and reducel3v
*
* 27/1/16
* - from shrink.c
*/
/*
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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA
*/
/*
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>
#include <math.h>
#include <vips/vips.h>
#include <vips/debug.h>
#include <vips/internal.h>
#include "presample.h"
typedef struct _VipsReducel3 {
VipsResample parent_instance;
double xshrink; /* Shrink factors */
double yshrink;
/* The thing we use to make the kernel.
*/
VipsKernel kernel;
} VipsReducel3;
typedef VipsResampleClass VipsReducel3Class;
G_DEFINE_TYPE( VipsReducel3, vips_reducel3, VIPS_TYPE_RESAMPLE );
static int
vips_reducel3_build( VipsObject *object )
{
VipsResample *resample = VIPS_RESAMPLE( object );
VipsReducel3 *reducel3 = (VipsReducel3 *) object;
VipsImage **t = (VipsImage **)
vips_object_local_array( object, 3 );
if( VIPS_OBJECT_CLASS( vips_reducel3_parent_class )->build( object ) )
return( -1 );
if( vips_reducevl3( resample->in, &t[0], reducel3->yshrink,
"kernel", reducel3->kernel,
NULL ) ||
vips_reducehl3( t[0], &t[1], reducel3->xshrink,
"kernel", reducel3->kernel,
NULL ) ||
vips_image_write( t[1], resample->out ) )
return( -1 );
return( 0 );
}
static void
vips_reducel3_class_init( VipsReducel3Class *class )
{
GObjectClass *gobject_class = G_OBJECT_CLASS( class );
VipsObjectClass *vobject_class = VIPS_OBJECT_CLASS( class );
VipsOperationClass *operation_class = VIPS_OPERATION_CLASS( class );
VIPS_DEBUG_MSG( "vips_reducel3_class_init\n" );
gobject_class->set_property = vips_object_set_property;
gobject_class->get_property = vips_object_get_property;
vobject_class->nickname = "reducel3";
vobject_class->description = _( "reducel3 an image" );
vobject_class->build = vips_reducel3_build;
operation_class->flags = VIPS_OPERATION_SEQUENTIAL;
VIPS_ARG_DOUBLE( class, "xshrink", 8,
_( "Xshrink" ),
_( "Horizontal shrink factor" ),
VIPS_ARGUMENT_REQUIRED_INPUT,
G_STRUCT_OFFSET( VipsReducel3, xshrink ),
1.0, 1000000.0, 1.0 );
VIPS_ARG_DOUBLE( class, "yshrink", 9,
_( "Yshrink" ),
_( "Vertical shrink factor" ),
VIPS_ARGUMENT_REQUIRED_INPUT,
G_STRUCT_OFFSET( VipsReducel3, yshrink ),
1.0, 1000000.0, 1.0 );
VIPS_ARG_ENUM( class, "kernel", 3,
_( "Kernel" ),
_( "Resampling kernel" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsReducel3, kernel ),
VIPS_TYPE_KERNEL, VIPS_KERNEL_LANCZOS3 );
}
static void
vips_reducel3_init( VipsReducel3 *reducel3 )
{
reducel3->kernel = VIPS_KERNEL_LANCZOS3;
}
/**
* vips_reducel3:
* @in: input image
* @out: output image
* @xshrink: horizontal shrink
* @shrinke: vertical shrink
* @...: %NULL-terminated list of optional named arguments
*
* Optional arguments:
*
* @kernel: #VipsKernel to use to interpolate (default: lanczos3)
*
* Reducel3 @in by a pair of factors with a pair of 1D interpolators. This
* will not work well for shrink factors greater than two.
*
* This is a very low-level operation: see vips_resize() for a more
* convenient way to resize images.
*
* This operation does not change xres or yres. The image resolution needs to
* be updated by the application.
*
* See also: vips_resize(), vips_affine().
*
* Returns: 0 on success, -1 on error
*/
int
vips_reducel3( VipsImage *in, VipsImage **out,
double xshrink, double yshrink, ... )
{
va_list ap;
int result;
va_start( ap, yshrink );
result = vips_call_split( "reducel3", ap, in, out, xshrink, yshrink );
va_end( ap );
return( result );
}

20
libvips/resample/reducevl3.cpp
View File

@ -115,24 +115,30 @@ reducevl3_unsigned_int_tab( VipsReducevl3 *reducevl3,
/* An unrolled version of ^^ for the most common case.
*/
static void inline
reducevl3_unsigned_uint8_4tab( VipsPel *out, const VipsPel *in,
reducevl3_unsigned_uint8_6tab( VipsPel *out, const VipsPel *in,
const int ne, const int lskip, const int *cy )
{
const int l1 = lskip;
const int l2 = l1 + l1;
const int l3 = l1 + l2;
const int l4 = l2 + l2;
const int l5 = l4 + l1;
const int c0 = cy[0];
const int c1 = cy[1];
const int c2 = cy[2];
const int c3 = cy[3];
const int c4 = cy[4];
const int c5 = cy[5];
for( int z = 0; z < ne; z++ ) {
int sum = unsigned_fixed_round(
c0 * in[0] +
c1 * in[l1] +
c2 * in[l2] +
c3 * in[l3] );
c3 * in[l3] +
c4 * in[l4] +
c5 * in[l5] );
sum = VIPS_CLIP( 0, sum, 255 );
@ -288,8 +294,8 @@ vips_reducevl3_gen( VipsRegion *out_region, void *seq,
switch( in->BandFmt ) {
case VIPS_FORMAT_UCHAR:
if( reducevl3->n_points == 4 )
reducevl3_unsigned_uint8_4tab(
if( reducevl3->n_points == 6 )
reducevl3_unsigned_uint8_6tab(
q, p, ne, lskip, cyi );
else
reducevl3_unsigned_int_tab
@ -474,14 +480,14 @@ vips_reducevl3_class_init( VipsReducevl3Class *reducevl3_class )
_( "Resampling kernel" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsReducevl3, kernel ),
VIPS_TYPE_KERNEL, VIPS_KERNEL_CUBIC );
VIPS_TYPE_KERNEL, VIPS_KERNEL_LANCZOS3 );
}
static void
vips_reducevl3_init( VipsReducevl3 *reducevl3 )
{
reducevl3->kernel = VIPS_KERNEL_CUBIC;
reducevl3->kernel = VIPS_KERNEL_LANCZOS3;
}
/**
@ -493,7 +499,7 @@ vips_reducevl3_init( VipsReducevl3 *reducevl3 )
*
* Optional arguments:
*
* @kernel: #VipsKernel to use to interpolate (default: cubic)
* @kernel: #VipsKernel to use to interpolate (default: lanczos3)
*
* Reduce @in vertically by a float factor. The pixels in @out are
* interpolated with a 1D mask. This operation will not work well for

2
libvips/resample/resample.c
View File

@ -138,6 +138,7 @@ vips_resample_operation_init( void )
extern GType vips_shrinkh_get_type( void );
extern GType vips_shrinkv_get_type( void );
extern GType vips_reduce_get_type( void );
extern GType vips_reducel3_get_type( void );
extern GType vips_reduceh_get_type( void );
extern GType vips_reducehl3_get_type( void );
extern GType vips_reducev_get_type( void );
@ -156,6 +157,7 @@ vips_resample_operation_init( void )
vips_reducev_get_type();
vips_reducevl3_get_type();
vips_reduce_get_type();
vips_reducel3_get_type();
vips_quadratic_get_type();
vips_affine_get_type();
vips_similarity_get_type();

246
libvips/resample/resize.c
View File

@ -8,6 +8,8 @@
* - smarter cache sizing
* 29/2/16
* - shrink more affine less, now we have better anti-alias settings
* 10/3/16
* - revise again, using new vips_reduce() code
*/
/*
@ -65,6 +67,9 @@ typedef struct _VipsResize {
double scale;
double vscale;
/* Deprecated.
*/
VipsInterpolate *interpolate;
double idx;
double idy;
@ -82,11 +87,11 @@ vips_resize_build( VipsObject *object )
VipsResample *resample = VIPS_RESAMPLE( object );
VipsResize *resize = (VipsResize *) object;
VipsImage **t = (VipsImage **)
vips_object_local_array( object, 7 );
VipsImage **t = (VipsImage **) vips_object_local_array( object, 7 );
VipsImage *in;
int window_size;
int target_width;
int target_height;
int int_hshrink;
int int_vshrink;
double hresidual;
@ -97,115 +102,45 @@ vips_resize_build( VipsObject *object )
if( VIPS_OBJECT_CLASS( vips_resize_parent_class )->build( object ) )
return( -1 );
if( !vips_object_argument_isset( object, "interpolate" ) ) {
VipsInterpolate *interpolate;
char *nick;
if( vips_type_find( "VipsInterpolate", "bicubic" ) )
nick = "bicubic";
else
nick = "bilinear";
interpolate = vips_interpolate_new( nick );
g_object_set( object, "interpolate", interpolate, NULL );
VIPS_UNREF( interpolate );
}
/* Unset vscale means it's equal to hscale.
*/
if( !vips_object_argument_isset( object, "vscale" ) )
resize->vscale = resize->scale;
in = resample->in;
window_size = resize->interpolate ?
vips_interpolate_get_window_size( resize->interpolate ) : 2;
/* The image size we are aiming for.
*/
target_width = in->Xsize * resize->scale;
if( vips_object_argument_isset( object, "vscale" ) )
target_height = in->Ysize * resize->vscale;
else
target_height = in->Ysize * resize->scale;
/* If the factor is > 1.0, we need to zoom rather than shrink.
* Just set the int part to 1 in this case.
*/
int_hshrink = resize->scale > 1.0 ?
1 : VIPS_FLOOR( 1.0 / resize->scale );
int_vshrink = resize->vscale > 1.0 ?
1 : VIPS_FLOOR( 1.0 / resize->vscale );
if( vips_object_argument_isset( object, "vscale" ) )
int_vshrink = resize->vscale > 1.0 ?
1 : VIPS_FLOOR( 1.0 / resize->vscale );
else
int_vshrink = int_hshrink;
/* We want to shrink by less for interpolators with large windows.
*/
int_hshrink = VIPS_MAX( 1,
int_hshrink / VIPS_MAX( 1, window_size / 3 ) );
int_vshrink = VIPS_MAX( 1,
int_vshrink / VIPS_MAX( 1, window_size / 3 ) );
/* Will this produce a residual scale of almost 1? shrink a bit less
* if it will.
*/
if( (in->Xsize * resize->scale) / (in->Xsize / int_hshrink) > 0.9 )
int_hshrink = VIPS_MAX( 1, int_hshrink - 1 );
if( (in->Ysize * resize->vscale) / (in->Ysize / int_vshrink) > 0.9 )
int_vshrink = VIPS_MAX( 1, int_vshrink - 1 );
/* Residual scale factor is.
*/
hresidual = (in->Xsize * resize->scale) / (in->Xsize / int_hshrink);
vresidual = (in->Ysize * resize->vscale) / (in->Ysize / int_vshrink);
/* A copy for enlarge resize.
*/
vips_info( class->nickname, "box shrink by %d x %d",
int_hshrink, int_vshrink );
if( vips_shrink( in, &t[0], int_hshrink, int_vshrink, NULL ) )
return( -1 );
in = t[0];
/* We want to make sure we read the image sequentially.
* However, the convolution we may be doing later will force us
* into SMALLTILE or maybe FATSTRIP mode and that will break
* sequentiality.
*
* So ... read into a cache where tiles are scanlines, and make sure
* we keep enough scanlines.
*
* We use a threaded tilecache to avoid a deadlock: suppose thread1,
* evaluating the top block of the output, is delayed, and thread2,
* evaluating the second block, gets here first (this can happen on
* a heavily-loaded system).
*
* With an unthreaded tilecache, thread2 will get
* the cache lock and start evaling the second block of the shrink.
* When it reaches the png reader it will stall until the first block
* has been used ... but it never will, since thread1 will block on
* this cache lock.
*
* Cache sizing: we double-buffer writes, so threads can be up to one
* line of tiles behind. For example, one thread could be allocated
* tile (0,0) and then stall, the whole write system won't stall until
* it tries to allocate tile (0, 2).
*
* We affine down after this, which can be a scale of up to @residual,
* perhaps 0.5 or down as low as 0.3 depending on the interpolator. So
* the number of scanlines we need to keep for the worst case is
* 2 * @tile_height / @residual, plus a little extra.
*/
if( int_vshrink > 1 ) {
int tile_width;
int tile_height;
int n_lines;
int need_lines;
vips_get_tile_size( in,
&tile_width, &tile_height, &n_lines );
need_lines = 1.2 * n_lines / vresidual;
if( vips_tilecache( in, &t[6],
"tile_width", in->Xsize,
"tile_height", 10,
"max_tiles", 1 + need_lines / 10,
"access", VIPS_ACCESS_SEQUENTIAL,
"threaded", TRUE,
NULL ) )
if( int_hshrink > 1 ||
int_vshrink > 1 ) {
vips_info( class->nickname, "box shrink by %d x %d",
int_hshrink, int_vshrink );
if( vips_shrink( in, &t[0], int_hshrink, int_vshrink, NULL ) )
return( -1 );
in = t[6];
in = t[0];
}
/* Do we need a further size adjustment? It's the difference
* between our target size and the size we have after vips_shrink().
*/
hresidual = (double) target_width / in->Xsize;
if( vips_object_argument_isset( object, "vscale" ) )
vresidual = (double) target_height / in->Ysize;
else
vresidual = hresidual;
/* If the final affine will be doing a large downsample, we can get
* nasty aliasing on hard edges. Blur before affine to smooth this out.
*
@ -215,61 +150,34 @@ vips_resize_build( VipsObject *object )
* Don't try to be clever for non-rectangular shrinks. We just
* consider the horizontal factor.
*/
sigma = ((1.0 / hresidual) - 0.5) / 2.0;
anti_alias = hresidual < 1.0 && sigma > 0.1;
sigma = ((1.0 / hresidual) - 0.5) / 2.5;
anti_alias = hresidual < 0.9 && sigma > 0.1;
if( anti_alias ) {
vips_info( class->nickname, "anti-alias sigma %g", sigma );
if( vips_gaussblur( in, &t[2], sigma, NULL ) )
if( vips_gaussblur( in, &t[1], sigma, NULL ) )
return( -1 );
in = t[1];
}
if( hresidual < 1.0 ||
vresidual < 1.0 ) {
vips_info( class->nickname, "residual reduce by %g x %g",
hresidual, vresidual );
if( vips_reducel3( in, &t[2],
1.0 / hresidual, 1.0 / vresidual, NULL ) )
return( -1 );
in = t[2];
}
vips_info( class->nickname, "residual affine %g x %g",
hresidual, vresidual );
if( resize->interpolate ) {
const char *nickname =
VIPS_OBJECT_GET_CLASS( resize->interpolate )->nickname;
vips_info( class->nickname, "%s interpolation", nickname );
}
/* We have a special path for bicubic, idx/idy == 0.
*/
if( resize->interpolate &&
strcmp( VIPS_OBJECT_GET_CLASS( resize->interpolate )->nickname,
"bicubic" ) == 0 &&
resize->idx == 0.0 &&
resize->idy == 0.0 ) {
vips_info( class->nickname, "using fast path for residual" );
if( vips_reduce( in, &t[3],
1.0 / hresidual, 1.0 / vresidual, NULL ) )
return( -1 );
}
else {
if( hresidual > 1.0 ||
vresidual > 1.0 ) {
vips_info( class->nickname, "residual scale %g x %g",
hresidual, vresidual );
if( vips_affine( in, &t[3], hresidual, 0, 0, vresidual,
"interpolate", resize->interpolate,
"idx", resize->idx,
"idy", resize->idy,
"interpolate", vips_interpolate_nearest_static(),
NULL ) )
return( -1 );
}
in = t[3];
/* If we are upsampling, don't sharpen. Also don't sharpen if we
* skipped the anti-alias filter.
*/
if( int_hshrink >= 1 &&
anti_alias ) {
vips_info( class->nickname, "final sharpen" );
t[5] = vips_image_new_matrixv( 3, 3,
-1.0, -1.0, -1.0,
-1.0, 32.0, -1.0,
-1.0, -1.0, -1.0 );
vips_image_set_double( t[5], "scale", 24 );
if( vips_conv( in, &t[4], t[5], NULL ) )
return( -1 );
in = t[4];
in = t[3];
}
if( vips_image_write( in, resample->out ) )
@ -310,25 +218,33 @@ vips_resize_class_init( VipsResizeClass *class )
G_STRUCT_OFFSET( VipsResize, vscale ),
0, 10000000, 0 );
VIPS_ARG_INTERPOLATE( class, "interpolate", 2,
_( "Interpolate" ),
_( "Interpolate pixels with this" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
G_STRUCT_OFFSET( VipsResize, interpolate ) );
/* We used to let people set the input offset so you could pick centre
* or corner interpolation, but it's not clear this was useful.
*/
VIPS_ARG_DOUBLE( class, "idx", 115,
_( "Input offset" ),
_( "Horizontal input displacement" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
VIPS_ARGUMENT_OPTIONAL_INPUT | VIPS_ARGUMENT_DEPRECATED,
G_STRUCT_OFFSET( VipsResize, idx ),
-10000000, 10000000, 0 );
VIPS_ARG_DOUBLE( class, "idy", 116,
_( "Input offset" ),
_( "Vertical input displacement" ),
VIPS_ARGUMENT_OPTIONAL_INPUT,
VIPS_ARGUMENT_OPTIONAL_INPUT | VIPS_ARGUMENT_DEPRECATED,
G_STRUCT_OFFSET( VipsResize, idy ),
-10000000, 10000000, 0 );
/* We used to let people set the interpolator, but it's not clear this
* was useful. Anyway, vips_reduce() no longer has an interpolator
* param.
*/
VIPS_ARG_INTERPOLATE( class, "interpolate", 2,
_( "Interpolate" ),
_( "Interpolate pixels with this" ),
VIPS_ARGUMENT_OPTIONAL_INPUT | VIPS_ARGUMENT_DEPRECATED,
G_STRUCT_OFFSET( VipsResize, interpolate ) );
}
static void
@ -346,29 +262,21 @@ vips_resize_init( VipsResize *resize )
* Optional arguments:
*
* @vscale: vertical scale factor
* @interpolate: interpolate pixels with this
* @idx: input horizontal offset
* @idy: input vertical offset
*
* Resize an image. When upsizing (@scale > 1), the image is simply resized
* with vips_affine() and the supplied @interpolate. When downsizing, the
* image is block-shrunk with vips_shrink() to roughly half the interpolator
* window size above the target size, then blurred with an anti-alias filter,
* then resampled with vips_affine() and the supplied interpolator, then
* sharpened.
* Resize an image. When upsizing (@scale > 1), the image is simply block
* upsized. When downsizing, the
* image is block-shrunk with vips_shrink(), then an anti-alias blur is
* applied with vips_gaussblur(), then the image is shrunk again to the
* target size with vips_reduce().
*
* vips_resize() normally maintains the image apect ratio. If you set
* @vscale, that factor is used for the vertical scale and @scale for the
* horizontal.
*
* @interpolate defaults to bicubic.
*
* @idx, @idy default to zero. Set them to 0.5 to get pixel-centre sampling.
*
* This operation does not change xres or yres. The image resolution needs to
* be updated by the application.
*
* See also: vips_shrink(), vips_affine(), #VipsInterpolate.
* See also: vips_shrink(), vips_reduce(), vips_gaussblur().
*
* Returns: 0 on success, -1 on error
*/

10
tools/vipsthumbnail.c
View File

@ -189,9 +189,11 @@ calculate_shrink( VipsImage *im )
*
* In crop mode we aim to fill the bounding box, so we must use the
* smaller axis.
*
* Take off a tiny amount to stop us rounding below the target.
*/
double horizontal = (double) width / thumbnail_width;
double vertical = (double) height / thumbnail_height;
double horizontal = (double) width / thumbnail_width - 0.0000001;
double vertical = (double) height / thumbnail_height - 0.0000001;
if( crop_image ) {
if( horizontal < vertical )
@ -518,7 +520,9 @@ thumbnail_shrink( VipsObject *process, VipsImage *in,
shrink = calculate_shrink( in );
if( vips_resize( in, &t[4], 1.0 / shrink,
/* Add a tiny amount to stop rounding below the target.
*/
if( vips_resize( in, &t[4], 1.0 / shrink + 0.0000000001,
"interpolate", interp,
NULL ) )
return( NULL );