static VipsImage *
thumbnail_shrink( VipsObject *process, VipsImage *in )
{
VipsImage **t = (VipsImage **) vips_object_local_array( process, 10 );
VipsInterpretation interpretation = linear_processing ?
VIPS_INTERPRETATION_XYZ : VIPS_INTERPRETATION_sRGB;
/* TRUE if we've done the import of an ICC transform and still need to
* export.
*/
gboolean have_imported;
/* TRUE if we've premultiplied and need to unpremultiply.
*/
gboolean have_premultiplied;
VipsBandFormat unpremultiplied_format;
/* Sniff the incoming image and try to guess what the alpha max is.
*/
double max_alpha;
double shrink;
/* RAD needs special unpacking.
*/
if( in->Coding == VIPS_CODING_RAD ) {
vips_info( "vipsthumbnail", "unpacking Rad to float" );
/* rad is scrgb.
*/
if( vips_rad2float( in, &t[0], NULL ) )
return( NULL );
in = t[0];
}
/* Try to guess what the maximum alpha might be.
*/
max_alpha = 255;
if( in->BandFmt == VIPS_FORMAT_USHORT )
max_alpha = 65535;
/* In linear mode, we import right at the start.
*
* We also have to import the whole image if it's CMYK, since
* vips_colourspace() (see below) doesn't know about CMYK.
*
* This is only going to work for images in device space. If you have
* an image in PCS which also has an attached profile, strange things
* will happen.
*/
have_imported = FALSE;
if( (linear_processing ||
in->Type == VIPS_INTERPRETATION_CMYK) &&
in->Coding == VIPS_CODING_NONE &&
(in->BandFmt == VIPS_FORMAT_UCHAR ||
in->BandFmt == VIPS_FORMAT_USHORT) &&
(vips_image_get_typeof( in, VIPS_META_ICC_NAME ) ||
import_profile) ) {
if( vips_image_get_typeof( in, VIPS_META_ICC_NAME ) )
vips_info( "vipsthumbnail",
"importing with embedded profile" );
else
vips_info( "vipsthumbnail",
"importing with profile %s", import_profile );
if( vips_icc_import( in, &t[1],
"input_profile", import_profile,
"embedded", TRUE,
"pcs", VIPS_PCS_XYZ,
NULL ) )
return( NULL );
in = t[1];
have_imported = TRUE;
}
/* To the processing colourspace. This will unpack LABQ as well.
*/
vips_info( "vipsthumbnail", "converting to processing space %s",
vips_enum_nick( VIPS_TYPE_INTERPRETATION, interpretation ) );
if( vips_colourspace( in, &t[2], interpretation, NULL ) )
return( NULL );
in = t[2];
/* If there's an alpha, we have to premultiply before shrinking. See
* https://github.com/jcupitt/libvips/issues/291
*/
have_premultiplied = FALSE;
if( in->Bands == 2 ||
(in->Bands == 4 && in->Type != VIPS_INTERPRETATION_CMYK) ||
in->Bands == 5 ) {
vips_info( "vipsthumbnail", "premultiplying alpha" );
if( vips_premultiply( in, &t[3],
"max_alpha", max_alpha,
NULL ) )
return( NULL );
have_premultiplied = TRUE;
/* vips_premultiply() makes a float image. When we
* vips_unpremultiply() below, we need to cast back to the
* pre-premultiply format.
*/
unpremultiplied_format = in->BandFmt;
in = t[3];
}
shrink = calculate_shrink( in );
if( vips_resize( in, &t[4], 1.0 / shrink, NULL ) )
return( NULL );
in = t[4];
if( have_premultiplied ) {
vips_info( "vipsthumbnail", "unpremultiplying alpha" );
if( vips_unpremultiply( in, &t[5],
"max_alpha", max_alpha,
NULL ) ||
vips_cast( t[5], &t[6], unpremultiplied_format, NULL ) )
return( NULL );
in = t[6];
}
/* Colour management.
*
* If we've already imported, just export. Otherwise, we're in
* device space and we need a combined import/export to transform to
* the target space.
*/
if( have_imported ) {
if( export_profile ||
vips_image_get_typeof( in, VIPS_META_ICC_NAME ) ) {
vips_info( "vipsthumbnail",
"exporting to device space with a profile" );
if( vips_icc_export( in, &t[7],
"output_profile", export_profile,
NULL ) )
return( NULL );
in = t[7];
}
else {
vips_info( "vipsthumbnail", "converting to sRGB" );
if( vips_colourspace( in, &t[7],
VIPS_INTERPRETATION_sRGB, NULL ) )
return( NULL );
in = t[7];
}
}
else if( export_profile &&
(vips_image_get_typeof( in, VIPS_META_ICC_NAME ) ||
import_profile) ) {
VipsImage *out;
vips_info( "vipsthumbnail",
"exporting with profile %s", export_profile );
/* We first try with the embedded profile, if any, then if
* that fails try again with the supplied fallback profile.
*/
out = NULL;
if( vips_image_get_typeof( in, VIPS_META_ICC_NAME ) ) {
vips_info( "vipsthumbnail",
"importing with embedded profile" );
if( vips_icc_transform( in, &t[7], export_profile,
"embedded", TRUE,
NULL ) ) {
vips_warn( "vipsthumbnail",
_( "unable to import with "
"embedded profile: %s" ),
vips_error_buffer() );
vips_error_clear();
}
else
out = t[7];
}
if( !out &&
import_profile ) {
vips_info( "vipsthumbnail",
"importing with fallback profile" );
if( vips_icc_transform( in, &t[7], export_profile,
"input_profile", import_profile,
"embedded", FALSE,
NULL ) )
return( NULL );
out = t[7];
}
/* If the embedded profile failed and there's no fallback or
* the fallback failed, out will still be NULL.
*/
if( out )
in = out;
}
if( delete_profile &&
vips_image_get_typeof( in, VIPS_META_ICC_NAME ) ) {
vips_info( "vipsthumbnail",
"deleting profile from output image" );
if( !vips_image_remove( in, VIPS_META_ICC_NAME ) )
return( NULL );
}
return( in );
}
static int
vips_smartcrop_attention( VipsSmartcrop *smartcrop,
VipsImage *in, int *left, int *top )
{
/* From smartcrop.js.
*/
static double skin_vector[] = {-0.78, -0.57, -0.44};
static double ones[] = {1.0, 1.0, 1.0};
VipsImage **t = (VipsImage **)
vips_object_local_array( VIPS_OBJECT( smartcrop ), 24 );
double hscale;
double vscale;
double sigma;
double max;
int x_pos;
int y_pos;
/* The size we shrink to gives the precision with which we can place
* the crop
*/
hscale = 32.0 / in->Xsize;
vscale = 32.0 / in->Ysize;
sigma = VIPS_MAX( sqrt( pow( smartcrop->width * hscale, 2 ) +
pow( smartcrop->height * vscale, 2 ) ) / 10, 1.0 );
if ( vips_resize( in, &t[17], hscale,
"vscale", vscale,
NULL ) )
return( -1 );
/* Simple edge detect.
*/
if( !(t[21] = vips_image_new_matrixv( 3, 3,
0.0, -1.0, 0.0,
-1.0, 4.0, -1.0,
0.0, -1.0, 0.0 )) )
return( -1 );
/* Convert to XYZ and just use the first three bands.
*/
if( vips_colourspace( t[17], &t[0], VIPS_INTERPRETATION_XYZ, NULL ) ||
vips_extract_band( t[0], &t[1], 0, "n", 3, NULL ) )
return( -1 );
/* Edge detect on Y.
*/
if( vips_extract_band( t[1], &t[2], 1, NULL ) ||
vips_conv( t[2], &t[3], t[21],
"precision", VIPS_PRECISION_INTEGER,
NULL ) ||
vips_linear1( t[3], &t[4], 5.0, 0.0, NULL ) ||
vips_abs( t[4], &t[14], NULL ) )
return( -1 );
/* Look for skin colours. Taken from smartcrop.js.
*/
if(
/* Normalise to magnitude of colour in XYZ.
*/
pythagoras( smartcrop, t[1], &t[5] ) ||
vips_divide( t[1], t[5], &t[6], NULL ) ||
/* Distance from skin point.
*/
vips_linear( t[6], &t[7], ones, skin_vector, 3, NULL ) ||
pythagoras( smartcrop, t[7], &t[8] ) ||
/* Rescale to 100 - 0 score.
*/
vips_linear1( t[8], &t[9], -100.0, 100.0, NULL ) ||
/* Ignore dark areas.
*/
vips_more_const1( t[2], &t[10], 5.0, NULL ) ||
!(t[11] = vips_image_new_from_image1( t[10], 0.0 )) ||
vips_ifthenelse( t[10], t[9], t[11], &t[15], NULL ) )
return( -1 );
/* Look for saturated areas.
*/
if( vips_colourspace( t[1], &t[12],
VIPS_INTERPRETATION_LAB, NULL ) ||
vips_extract_band( t[12], &t[13], 1, NULL ) ||
vips_ifthenelse( t[10], t[13], t[11], &t[16], NULL ) )
return( -1 );
/* Sum, blur and find maxpos.
*
* The amount of blur is related to the size of the crop
* area: how large an area we want to consider for the scoring
* function.
*/
if( vips_sum( &t[14], &t[18], 3, NULL ) ||
vips_gaussblur( t[18], &t[19], sigma, NULL ) ||
vips_max( t[19], &max, "x", &x_pos, "y", &y_pos, NULL ) )
return( -1 );
/* Centre the crop over the max.
*/
*left = VIPS_CLIP( 0,
x_pos / hscale - smartcrop->width / 2,
in->Xsize - smartcrop->width );
*top = VIPS_CLIP( 0,
y_pos / vscale - smartcrop->height / 2,
in->Ysize - smartcrop->height );
return( 0 );
}
