static int
ifthenelse( IMAGE *c, IMAGE *a, IMAGE *b, IMAGE *out )
{
IMAGE **in;
/* Check args.
*/
if( im_check_uncoded( "im_ifthenelse", c ) ||
im_check_coding_known( "im_ifthenelse", a ) ||
im_check_coding_known( "im_ifthenelse", b ) ||
im_check_format( "ifthenelse", c, IM_BANDFMT_UCHAR ) ||
im_check_format_same( "ifthenelse", a, b ) ||
im_check_bands_same( "ifthenelse", a, b ) ||
im_check_bands_1orn( "im_ifthenelse", c, a ) ||
im_piocheck( c, out ) ||
im_pincheck( a ) ||
im_pincheck( b ) )
return( -1 );
/* Make output image.
*/
if( im_demand_hint( out, IM_THINSTRIP, c, a, b, NULL ) ||
im_cp_descv( out, a, b, c, NULL ) ||
!(in = im_allocate_input_array( out, c, a, b, NULL )) ||
im_generate( out,
im_start_many, ifthenelse_gen, im_stop_many,
in, NULL ) )
return( -1 );
return( 0 );
}
int
im_stdif_raw( IMAGE *in, IMAGE *out,
double a, double m0, double b, double s0,
int xwin, int ywin )
{
StdifInfo *inf;
if( xwin > in->Xsize ||
ywin > in->Ysize ) {
im_error( "im_stdif", "%s", _( "window too large" ) );
return( -1 );
}
if( xwin <= 0 ||
ywin <= 0 ) {
im_error( "im_lhisteq", "%s", _( "window too small" ) );
return( -1 );
}
if( m0 < 0 || m0 > 255 || a < 0 || a > 1.0 || b < 0 || b > 2 ||
s0 < 0 || s0 > 255 ) {
im_error( "im_stdif", "%s", _( "parameters out of range" ) );
return( -1 );
}
if( im_check_format( "im_stdif", in, IM_BANDFMT_UCHAR ) ||
im_check_uncoded( "im_stdif", in ) ||
im_check_mono( "im_stdif", in ) ||
im_piocheck( in, out ) )
return( -1 );
if( im_cp_desc( out, in ) )
return( -1 );
out->Xsize -= xwin;
out->Ysize -= ywin;
/* Save parameters.
*/
if( !(inf = IM_NEW( out, StdifInfo )) )
return( -1 );
inf->xwin = xwin;
inf->ywin = ywin;
inf->a = a;
inf->m0 = m0;
inf->b = b;
inf->s0 = s0;
/* Set demand hints. FATSTRIP is good for us, as THINSTRIP will cause
* too many recalculations on overlaps.
*/
if( im_demand_hint( out, IM_FATSTRIP, in, NULL ) )
return( -1 );
/* Write the hist.
*/
if( im_generate( out,
im_start_one, stdif_gen, im_stop_one, in, inf ) )
return( -1 );
return( 0 );
}
int
im_contrast_surface_raw (IMAGE * in, IMAGE * out, int half_win_size,
int spacing)
{
#define FUNCTION_NAME "im_contrast_surface_raw"
cont_surf_params_t *params;
if (im_piocheck (in, out) ||
im_check_uncoded (FUNCTION_NAME, in) ||
im_check_mono (FUNCTION_NAME, in) ||
im_check_format (FUNCTION_NAME, in, IM_BANDFMT_UCHAR))
return -1;
if (half_win_size < 1 || spacing < 1)
{
im_error (FUNCTION_NAME, "%s", _("bad parameters"));
return -1;
}
if (DOUBLE (half_win_size) >= LESSER (in->Xsize, in->Ysize))
{
im_error (FUNCTION_NAME,
"%s", _("parameters would result in zero size output image"));
return -1;
}
params = IM_NEW (out, cont_surf_params_t);
if (!params)
return -1;
params->half_win_size = half_win_size;
params->spacing = spacing;
if (im_cp_desc (out, in))
return -1;
out->BandFmt = IM_BANDFMT_UINT;
out->Xsize = 1 + ((in->Xsize - DOUBLE_ADD_ONE (half_win_size)) / spacing);
out->Ysize = 1 + ((in->Ysize - DOUBLE_ADD_ONE (half_win_size)) / spacing);
out->Xoffset = -half_win_size;
out->Yoffset = -half_win_size;
if (im_demand_hint (out, IM_FATSTRIP, in, NULL))
return -1;
return im_generate (out, im_start_one, cont_surf_gen, im_stop_one, in,
params);
#undef FUNCTION_NAME
}
int
im_lhisteq_raw( IMAGE *in, IMAGE *out, int xwin, int ywin )
{
LhistInfo *inf;
if( im_check_mono( "im_lhisteq", in ) ||
im_check_uncoded( "im_lhisteq", in ) ||
im_check_format( "im_lhisteq", in, IM_BANDFMT_UCHAR ) ||
im_piocheck( in, out ) )
return( -1 );
if( xwin > in->Xsize ||
ywin > in->Ysize ) {
im_error( "im_lhisteq", "%s", _( "window too large" ) );
return( -1 );
}
if( xwin <= 0 ||
ywin <= 0 ) {
im_error( "im_lhisteq", "%s", _( "window too small" ) );
return( -1 );
}
if( im_cp_desc( out, in ) )
return( -1 );
out->Xsize -= xwin - 1;
out->Ysize -= ywin - 1;
/* Save parameters.
*/
if( !(inf = IM_NEW( out, LhistInfo )) )
return( -1 );
inf->xwin = xwin;
inf->ywin = ywin;
inf->npels = xwin * ywin;
/* Set demand hints. FATSTRIP is good for us, as THINSTRIP will cause
* too many recalculations on overlaps.
*/
if( im_demand_hint( out, IM_FATSTRIP, in, NULL ) )
return( -1 );
if( im_generate( out,
im_start_one, lhist_gen, im_stop_one, in, inf ) )
return( -1 );
out->Xoffset = -xwin / 2;
out->Yoffset = -xwin / 2;
return( 0 );
}
/**
* im_circle:
* @im: image to draw on
* @cx: centre of circle
* @cy: centre of circle
* @radius: circle radius
* @intensity: value to draw
*
* Draws a circle on a 1-band 8-bit image.
*
* This an inplace operation, so @im is changed. It does not thread and will
* not work well as part of a pipeline. On 32-bit machines it will be limited
* to 2GB images.
*
* See also: im_fastline().
*
* Returns: 0 on success, or -1 on error.
*/
int
im_circle( IMAGE *im, int cx, int cy, int radius, int intensity )
{
PEL ink[1];
if( im_rwcheck( im ) ||
im_check_uncoded( "im_circle", im ) ||
im_check_mono( "im_circle", im ) ||
im_check_format( "im_circle", im, IM_BANDFMT_UCHAR ) )
return( -1 );
ink[0] = intensity;
return( im_draw_circle( im, cx, cy, radius, FALSE, ink ) );
}
/* Raw fastcor, with no borders.
*/
int
im_fastcor_raw( IMAGE *in, IMAGE *ref, IMAGE *out )
{
/* PIO between in and out; WIO from ref.
*/
if( im_piocheck( in, out ) ||
im_incheck( ref ) )
return( -1 );
/* Check sizes.
*/
if( in->Xsize < ref->Xsize || in->Ysize < ref->Ysize ) {
im_error( "im_fastcor", "%s",
_( "ref not smaller than or equal to in" ) );
return( -1 );
}
/* Check types.
*/
if( im_check_uncoded( "im_fastcor", in ) ||
im_check_mono( "im_fastcor", in ) ||
im_check_format( "im_fastcor", in, IM_BANDFMT_UCHAR ) ||
im_check_coding_same( "im_fastcor", in, ref ) ||
im_check_bands_same( "im_fastcor", in, ref ) ||
im_check_format_same( "im_fastcor", in, ref ) )
return( -1 );
/* Prepare the output image.
*/
if( im_cp_descv( out, in, ref, NULL ) )
return( -1 );
out->BandFmt = IM_BANDFMT_UINT;
out->Xsize = in->Xsize - ref->Xsize + 1;
out->Ysize = in->Ysize - ref->Ysize + 1;
/* FATSTRIP is good for us, as THINSTRIP will cause
* too many recalculations on overlaps.
*/
if( im_demand_hint( out, IM_FATSTRIP, in, NULL ) ||
im_generate( out,
im_start_one, fastcor_gen, im_stop_one, in, ref ) )
return( -1 );
out->Xoffset = -ref->Xsize / 2;
out->Yoffset = -ref->Ysize / 2;
return( 0 );
}
/**
* im_tone_analyse:
* @in: input image
* @out: output image
* @Ps: shadow point (eg. 0.2)
* @Pm: mid-tone point (eg. 0.5)
* @Ph: highlight point (eg. 0.8)
* @S: shadow adjustment (+/- 30)
* @M: mid-tone adjustment (+/- 30)
* @H: highlight adjustment (+/- 30)
*
* As im_tone_build(), but analyse the histogram of @in and use it to
* pick the 0.1% and 99.9% points for @Lb and @Lw.
*
* See also: im_tone_build().
*
* Returns: 0 on success, -1 on error
*/
int
im_tone_analyse(
IMAGE *in,
IMAGE *out,
double Ps, double Pm, double Ph,
double S, double M, double H )
{
IMAGE *t[4];
int low, high;
double Lb, Lw;
if( im_open_local_array( out, t, 4, "im_tone_map", "p" ) )
return( -1 );
/* If in is IM_CODING_LABQ, unpack.
*/
if( in->Coding == IM_CODING_LABQ ) {
if( im_LabQ2LabS( in, t[0] ) )
return( -1 );
}
else
t[0] = in;
/* Should now be 3-band short.
*/
if( im_check_uncoded( "im_tone_analyse", t[0] ) ||
im_check_bands( "im_tone_analyse", t[0], 3 ) ||
im_check_format( "im_tone_analyse", t[0], IM_BANDFMT_SHORT ) )
return( -1 );
if( im_extract_band( t[0], t[1], 0 ) ||
im_clip2fmt( t[1], t[2], IM_BANDFMT_USHORT ) ||
im_histgr( t[2], t[3], -1 ) )
return( -1 );
if( im_mpercent_hist( t[3], 0.1 / 100.0, &high ) ||
im_mpercent_hist( t[3], 99.9 / 100.0, &low ) )
return( -1 );
Lb = 100 * low / 32768;
Lw = 100 * high / 32768;
im_diag( "im_tone_analyse", "set Lb = %g, Lw = %g", Lb, Lw );
return( im_tone_build( out, Lb, Lw, Ps, Pm, Ph, S, M, H ) );
}
static Mask *
mask_new( VipsImage *im, int x, int y, PEL *ink, VipsImage *mask_im )
{
Mask *mask;
Rect area, image;
if( im_check_coding_noneorlabq( "im_draw_mask", im ) ||
im_incheck( mask_im ) ||
im_check_mono( "im_draw_mask", mask_im ) ||
im_check_uncoded( "im_draw_mask", mask_im ) ||
im_check_format( "im_draw_mask", mask_im, IM_BANDFMT_UCHAR ) ||
!(mask = IM_NEW( NULL, Mask )) )
return( NULL );
if( !im__draw_init( DRAW( mask ), im, ink ) ) {
mask_free( mask );
return( NULL );
}
mask->x = x;
mask->y = y;
mask->mask_im = mask_im;
/* Find the area we draw on the image.
*/
area.left = x;
area.top = y;
area.width = mask_im->Xsize;
area.height = mask_im->Ysize;
image.left = 0;
image.top = 0;
image.width = im->Xsize;
image.height = im->Ysize;
im_rect_intersectrect( &area, &image, &mask->image_clip );
/* And the area of the mask image we use.
*/
mask->mask_clip = mask->image_clip;
mask->mask_clip.left -= x;
mask->mask_clip.top -= y;
return( mask );
}
/**
* im_profile:
* @in: input image
* @out: output image
* @dir: search direction
*
* im_profile() searches inward from the edge of @in and finds the
* first non-zero pixel. It outputs an image containing a list of the offsets
* for each row or column.
*
* If @dir == 0, then im_profile() searches down from the top edge, writing an
* image as wide as the input image, but only 1 pixel high, containing the
* number of pixels down to the first non-zero pixel for each column of input
* pixels.
*
* If @dir == 1, then im_profile() searches across from the left edge,
* writing an image as high as the input image, but only 1 pixel wide,
* containing the number of pixels across to the
* first non-zero pixel for each row of input pixels.
*
* See also: im_cntlines().
*
* Returns: 0 on success, -1 on error
*/
int
im_profile( IMAGE *in, IMAGE *out, int dir )
{
int sz;
unsigned short *buf;
int x, y, b;
/* If in is not uchar, do (!=0) to make a uchar image.
*/
if( in->BandFmt != IM_BANDFMT_UCHAR ) {
IMAGE *t;
if( !(t = im_open_local( out, "im_profile", "p" )) ||
im_notequalconst( in, t, 0 ) )
return( -1 );
in = t;
}
/* Check im.
*/
if( im_iocheck( in, out ) ||
im_check_uncoded( "im_profile", in ) ||
im_check_format( "im_profile", in, IM_BANDFMT_UCHAR ) )
return( -1 );
if( dir != 0 &&
dir != 1 ) {
im_error( "im_profile", "%s", _( "dir not 0 or 1" ) );
return( -1 );
}
if( im_cp_desc( out, in ) )
return( -1 );
out->Type = IM_TYPE_HISTOGRAM;
if( dir == 0 ) {
out->Xsize = in->Xsize;
out->Ysize = 1;
}
else {
out->Xsize = 1;
out->Ysize = in->Ysize;
}
out->BandFmt = IM_BANDFMT_USHORT;
if( im_setupout( out ) )
return( -1 );
sz = IM_IMAGE_N_ELEMENTS( out );
if( !(buf = IM_ARRAY( out, sz, unsigned short )) )
return( -1 );
if( dir == 0 ) {
/* Find vertical lines.
*/
for( x = 0; x < sz; x++ ) {
PEL *p = (PEL *) IM_IMAGE_ADDR( in, 0, 0 ) + x;
int lsk = IM_IMAGE_SIZEOF_LINE( in );
for( y = 0; y < in->Ysize; y++ ) {
if( *p )
break;
p += lsk;
}
buf[x] = y;
}
if( im_writeline( 0, out, (PEL *) buf ) )
return( -1 );
}
else {
/* Search horizontal lines.
*/
for( y = 0; y < in->Ysize; y++ ) {
PEL *p = (PEL *) IM_IMAGE_ADDR( in, 0, y );
for( b = 0; b < in->Bands; b++ ) {
PEL *p1;
p1 = p + b;
for( x = 0; x < in->Xsize; x++ ) {
if( *p1 )
break;
p1 += in->Bands;
}
buf[b] = x;
}
if( im_writeline( y, out, (PEL *) buf ) )
return( -1 );
}
}
return( 0 );
}
static Morph *
morph_new( IMAGE *in, IMAGE *out, INTMASK *mask, MorphOp op )
{
const int n_mask = mask->xsize * mask->ysize;
Morph *morph;
int i;
/* If in is not uchar, do (!=0) to make a uchar image.
*/
if( in->BandFmt != IM_BANDFMT_UCHAR ) {
IMAGE *t;
if( !(t = im_open_local( out, "morph_new", "p" )) ||
im_notequalconst( in, t, 0 ) )
return( NULL );
in = t;
}
if( im_piocheck( in, out ) ||
im_check_uncoded( "morph", in ) ||
im_check_format( "morph", in, IM_BANDFMT_UCHAR ) ||
im_check_imask( "morph", mask ) )
return( NULL );
for( i = 0; i < n_mask; i++ )
if( mask->coeff[i] != 0 &&
mask->coeff[i] != 128 &&
mask->coeff[i] != 255 ) {
im_error( "morph",
_( "bad mask element (%d "
"should be 0, 128 or 255)" ),
mask->coeff[i] );
return( NULL );
}
if( !(morph = IM_NEW( out, Morph )) )
return( NULL );
morph->in = in;
morph->out = out;
morph->mask = NULL;
morph->op = op;
morph->n_pass = 0;
for( i = 0; i < MAX_PASS; i++ )
morph->pass[i].vector = NULL;
if( im_add_close_callback( out,
(im_callback_fn) morph_close, morph, NULL ) ||
!(morph->mask = im_dup_imask( mask, "morph" )) )
return( NULL );
/* Generate code for this mask / image, if possible.
*/
if( vips_vector_isenabled() ) {
if( pass_compile( morph ) )
pass_free( morph );
}
return( morph );
}
