/* Given a pair of points, return scale, angle, dx, dy to resample the 2nd
* image with.
*/
int
im__coeff( int xr1, int yr1, int xs1, int ys1,
int xr2, int yr2, int xs2, int ys2,
double *a, double *b, double *dx, double *dy )
{
DOUBLEMASK *in, *out;
if( !(in = im_create_dmask( "in", 4, 4 )) ) {
im_errormsg( "im__coeff: unable to allocate matrix" );
return( -1 );
}
in->coeff[0] = (double)xs1;
in->coeff[1] = (double)-ys1;
in->coeff[2] = 1.0;
in->coeff[3] = 0.0;
in->coeff[4] = (double)ys1;
in->coeff[5] = (double)xs1;
in->coeff[6] = 0.0;
in->coeff[7] = 1.0;
in->coeff[8] = (double)xs2;
in->coeff[9] = (double)-ys2;
in->coeff[10] = 1.0;
in->coeff[11] = 0.0;
in->coeff[12] = (double)ys2;
in->coeff[13] = (double)xs2;
in->coeff[14] = 0.0;
in->coeff[15] = 1.0;
if( !(out = im_matinv( in, "out" )) ) {
im_free_dmask( in );
im_errormsg( "im__coeff: unable to invert matrix" );
return( -1 );
}
*a = out->coeff[0]*xr1 + out->coeff[1]*yr1 +
out->coeff[2]*xr2 + out->coeff[3]*yr2;
*b = out->coeff[4]*xr1 + out->coeff[5]*yr1 +
out->coeff[6]*xr2 + out->coeff[7]*yr2;
*dx= out->coeff[8]*xr1 + out->coeff[9]*yr1 +
out->coeff[10]*xr2 + out->coeff[11]*yr2;
*dy= out->coeff[12]*xr1 + out->coeff[13]*yr1 +
out->coeff[14]*xr2 + out->coeff[15]*yr2;
im_free_dmask( in );
im_free_dmask( out );
return( 0 );
}
INTMASK *
im_log_imask( const char *filename, double sigma, double min_ampl )
{
DOUBLEMASK *dm;
INTMASK *im;
if( !(dm = im_log_dmask( filename, sigma, min_ampl )) )
return( NULL );
if( !(im = im_scale_dmask( dm, dm->filename )) ) {
im_free_dmask( dm );
return( NULL );
}
im_free_dmask( dm );
return( im ) ;
}
/**
* im_read_imask:
* @filename: read matrix from this file
*
* Reads an integer matrix from a file.
*
* This function works exactly as im_read_dmask(), but the loaded matrix is
* checked for 'int-ness'. All coefficients must be integers, and scale and
* offset must be integers.
*
* See also: im_read_dmask().
*
* Returns: the loaded mask on success, or NULL on error.
*/
INTMASK *
im_read_imask( const char *filename )
{
DOUBLEMASK *dmask;
INTMASK *imask;
int i;
if( !(dmask = im_read_dmask( filename )) )
return( NULL );
if( ceil( dmask->scale ) != dmask->scale ||
ceil( dmask->offset ) != dmask->offset ) {
im_error( "im_read_imask",
"%s", _( "scale and offset should be int" ) );
im_free_dmask( dmask );
return( NULL );
}
for( i = 0; i < dmask->xsize * dmask->ysize; i++ )
if( ceil( dmask->coeff[i] ) != dmask->coeff[i] ) {
im_error( "im_read_imask", _( "ceofficient at "
"position (%d, %d) is not int" ),
i % dmask->xsize,
i / dmask->xsize );
im_free_dmask( dmask );
return( NULL );
}
if( !(imask = im_create_imask( filename,
dmask->xsize, dmask->ysize )) ) {
im_free_dmask( dmask );
return( NULL );
}
imask->scale = dmask->scale;
imask->offset = dmask->offset;
for( i = 0; i < dmask->xsize * dmask->ysize; i++ )
imask->coeff[i] = dmask->coeff[i];
im_free_dmask( dmask );
return( imask );
}
/* Calculate the inverse transformation.
*/
int
im__transform_calc_inverse( Transformation *trn )
{
DOUBLEMASK *msk, *msk2;
if( !(msk = im_create_dmaskv( "boink", 2, 2,
trn->a, trn->b, trn->c, trn->d )) )
return( -1 );
if( !(msk2 = im_matinv( msk, "boink2" )) ) {
(void) im_free_dmask( msk );
return( -1 );
}
trn->ia = msk2->coeff[0];
trn->ib = msk2->coeff[1];
trn->ic = msk2->coeff[2];
trn->id = msk2->coeff[3];
(void) im_free_dmask( msk );
(void) im_free_dmask( msk2 );
return( 0 );
}
/**
* im_create_dmask:
* @filename: set mask filename to this
* @xsize: mask width
* @ysize: mask height
*
* Create an empty dmask. You need to loop over @coeff to set the values.
*
* See also: im_create_dmaskv(), im_vips2mask().
*
* Returns: The newly-allocated mask.
*/
DOUBLEMASK *
im_create_dmask( const char *filename, int xsize, int ysize )
{
DOUBLEMASK *out;
int size = xsize * ysize;
/* Check args.
*/
if( xsize <= 0 || ysize <= 0 || filename == NULL ) {
im_error( "im_create_dmask", "%s", _( "bad arguments" ) );
return( NULL );
}
/* Allocate and initialise structure.
*/
if( !(out = IM_NEW( NULL, DOUBLEMASK )) )
return( NULL );
out->coeff = NULL;
out->filename = NULL;
out->scale = 1.0;
out->offset = 0.0;
out->xsize = 0;
out->ysize = 0;
if( !(out->coeff = IM_ARRAY( NULL, size, double )) ) {
im_free_dmask( out );
return( NULL );
}
(void) memset( (char *) out->coeff, 0, size * sizeof( double ) );
if( !(out->filename = im_strdup( NULL, filename )) ) {
im_free_dmask( out );
return( NULL );
}
out->xsize = xsize;
out->ysize = ysize;
return( out );
}
/* Make a DOUBLEMASK local to an image descriptor.
*/
static DOUBLEMASK *
local_mask( IMAGE *out, DOUBLEMASK *mask )
{
if( !mask )
return( NULL );
if( im_add_close_callback( out,
(im_callback_fn) im_free_dmask, mask, NULL ) ) {
im_free_dmask( mask );
return( NULL );
}
return( mask );
}
/* Normalise an image using the rules noted above.
*/
static int
normalise( IMAGE *in, IMAGE *out )
{
if( im_check_uncoded( "im_histplot", in ) ||
im_check_noncomplex( "im_histplot", in ) )
return( -1 );
if( vips_bandfmt_isuint( in->BandFmt ) ) {
if( im_copy( in, out ) )
return( -1 );
}
else if( vips_bandfmt_isint( in->BandFmt ) ) {
IMAGE *t1;
double min;
/* Move min up to 0.
*/
if( !(t1 = im_open_local( out, "im_histplot", "p" )) ||
im_min( in, &min ) ||
im_lintra( 1.0, in, -min, t1 ) )
return( -1 );
}
else {
/* Float image: scale min--max to 0--any. Output square
* graph.
*/
IMAGE *t1;
DOUBLEMASK *stats;
double min, max;
int any;
if( in->Xsize == 1 )
any = in->Ysize;
else
any = in->Xsize;
if( !(stats = im_stats( in )) )
return( -1 );
min = VIPS_MASK( stats, 0, 0 );
max = VIPS_MASK( stats, 1, 0 );
im_free_dmask( stats );
if( !(t1 = im_open_local( out, "im_histplot", "p" )) ||
im_lintra( any / (max - min), in,
-min * any / (max - min), out ) )
return( -1 );
}
return( 0 );
}
/**
* im_local_dmask:
* @out: image to make the mask local to
* @mask: mask to local-ize
*
* @out takes ownership of @mask: when @out is closed, @mask will be closed
* for you. If im_local_dmask() itself fails, the mask is also freed.
*
* See also: im_local_imask().
*
* Returns: the mask, or NULL on error.
*/
DOUBLEMASK *
im_local_dmask( VipsImage *out, DOUBLEMASK *mask )
{
if( im_check_dmask( "im_local_dmask", mask ) )
return( NULL );
if( im_add_close_callback( out,
(im_callback_fn) im_free_dmask, mask, NULL ) ) {
im_free_dmask( mask );
return( NULL );
}
return( mask );
}
/**
* im_read_dmask:
* @filename: read matrix from this file
*
* Reads a matrix from a file.
*
* Matrix files have a simple format that's supposed to be easy to create with
* a text editor or a spreadsheet.
*
* The first line has four numbers for width, height, scale and
* offset (scale and offset may be omitted, in which case they default to 1.0
* and 0.0). Scale must be non-zero. Width and height must be positive
* integers. The numbers are separated by any mixture of spaces, commas,
* tabs and quotation marks ("). The scale and offset fields may be
* floating-point, and must use '.'
* as a decimal separator.
*
* Subsequent lines each hold one line of matrix data, with numbers again
* separated by any mixture of spaces, commas,
* tabs and quotation marks ("). The numbers may be floating-point, and must
* use '.'
* as a decimal separator.
*
* Extra characters at the ends of lines or at the end of the file are
* ignored.
*
* See also: im_read_imask(), im_gauss_dmask().
*
* Returns: the loaded mask on success, or NULL on error.
*/
DOUBLEMASK *
im_read_dmask( const char *filename )
{
FILE *fp;
double sc, off;
int xs, ys;
DOUBLEMASK *out;
int x, y, i;
char buf[MAX_LINE];
if( !(fp = im__file_open_read( filename, NULL, TRUE )) )
return( NULL );
if( read_header( fp, &xs, &ys, &sc, &off ) ) {
fclose( fp );
return( NULL );
}
if( !(out = im_create_dmask( filename, xs, ys )) ) {
fclose( fp );
return( NULL );
}
out->scale = sc;
out->offset = off;
for( i = 0, y = 0; y < ys; y++ ) {
char *p;
if( get_line( fp, buf ) ) {
im_free_dmask( out );
fclose( fp );
return( NULL );
}
for( p = buf, x = 0; p && x < xs;
x++, i++, p = im_break_token( p, " \t,\";" ) )
out->coeff[i] = g_ascii_strtod( p, NULL );
}
fclose( fp );
return( out );
}