/* Read a 1 bit binary file.
*/
static int
read_1bit_binary( FILE *fp, VipsImage *out )
{
int x, y, i;
int bits;
VipsPel *buf;
if( !(buf = VIPS_ARRAY( out, VIPS_IMAGE_SIZEOF_LINE( out ), VipsPel )) )
return( -1 );
bits = fgetc( fp );
for( i = 0, y = 0; y < out->Ysize; y++ ) {
for( x = 0; x < out->Xsize * out->Bands; x++, i++ ) {
buf[x] = (bits & 128) ? 255 : 0;
bits <<= 1;
if( (i & 7) == 7 )
bits = fgetc( fp );
}
if( vips_image_write_line( out, y, buf ) )
return( -1 );
}
return( 0 );
}
/* Read an ascii 1 bit file.
*/
static int
read_1bit_ascii( FILE *fp, VipsImage *out )
{
int x, y;
VipsPel *buf;
if( !(buf = VIPS_ARRAY( out, VIPS_IMAGE_SIZEOF_LINE( out ), VipsPel )) )
return( -1 );
for( y = 0; y < out->Ysize; y++ ) {
for( x = 0; x < out->Xsize * out->Bands; x++ ) {
int val;
if( read_int( fp, &val ) )
return( -1 );
if( val == 1 )
buf[x] = 0;
else
buf[x] = 255;
}
if( vips_image_write_line( out, y, buf ) )
return( -1 );
}
return( 0 );
}
static int
mat2vips_get_data( mat_t *mat, matvar_t *var, VipsImage *im )
{
int y;
VipsPel *buffer;
const int es = VIPS_IMAGE_SIZEOF_ELEMENT( im );
/* Matlab images are plane-separate, so we have to assemble bands in
* image-size chunks.
*/
const guint64 is = es * VIPS_IMAGE_N_PELS( im );
if( Mat_VarReadDataAll( mat, var ) ) {
vips_error( "mat2vips", "%s",
_( "Mat_VarReadDataAll failed" ) );
return( -1 );
}
/* Matlab images are in columns, so we have to transpose into
* scanlines with this buffer.
*/
if( !(buffer = VIPS_ARRAY( im,
VIPS_IMAGE_SIZEOF_LINE( im ), VipsPel )) )
return( -1 );
for( y = 0; y < im->Ysize; y++ ) {
const VipsPel *p = var->data + y * es;
int x;
VipsPel *q;
q = buffer;
for( x = 0; x < im->Xsize; x++ ) {
int b;
for( b = 0; b < im->Bands; b++ ) {
const VipsPel *p2 = p + b * is;
int z;
for( z = 0; z < es; z++ )
q[z] = p2[z];
q += es;
}
p += es * im->Ysize;
}
if( vips_image_write_line( im, y, buffer ) )
return( -1 );
}
return( 0 );
}
/* Read an ascii ppm/pgm file.
*/
static int
read_ascii( FILE *fp, VipsImage *out )
{
int x, y;
VipsPel *buf;
if( !(buf = VIPS_ARRAY( out, VIPS_IMAGE_SIZEOF_LINE( out ), VipsPel )) )
return( -1 );
for( y = 0; y < out->Ysize; y++ ) {
for( x = 0; x < out->Xsize * out->Bands; x++ ) {
int val;
if( read_int( fp, &val ) )
return( -1 );
switch( out->BandFmt ) {
case VIPS_FORMAT_UCHAR:
buf[x] = VIPS_CLIP( 0, val, 255 );
break;
case VIPS_FORMAT_USHORT:
((unsigned short *) buf)[x] =
VIPS_CLIP( 0, val, 65535 );
break;
case VIPS_FORMAT_UINT:
((unsigned int *) buf)[x] = val;
break;
default:
g_assert( 0 );
}
}
if( vips_image_write_line( out, y, buf ) )
return( -1 );
}
return( 0 );
}
static int
read_csv( FILE *fp, VipsImage *out,
int skip,
int lines,
const char *whitespace, const char *separator,
gboolean read_image )
{
int i;
char whitemap[256];
char sepmap[256];
const char *p;
fpos_t pos;
int columns;
int ch;
double d;
double *buf;
int y;
/* Make our char maps.
*/
for( i = 0; i < 256; i++ ) {
whitemap[i] = 0;
sepmap[i] = 0;
}
for( p = whitespace; *p; p++ )
whitemap[(int) *p] = 1;
for( p = separator; *p; p++ )
sepmap[(int) *p] = 1;
/* Skip first few lines.
*/
for( i = 0; i < skip; i++ )
if( !skip_line( fp ) ) {
vips_error( "csv2vips",
"%s", _( "end of file while skipping start" ) );
return( -1 );
}
/* Parse the first line to get number of columns. Only bother checking
* fgetpos() the first time we use it: assume it's working after this.
*/
if( fgetpos( fp, &pos ) ) {
vips_error_system( errno, "csv2vips",
"%s", _( "unable to seek" ) );
return( -1 );
}
for( columns = 0;
(ch = read_double( fp, whitemap, sepmap,
skip + 1, columns + 1, &d )) == 0;
columns++ )
;
fsetpos( fp, &pos );
if( columns == 0 ) {
vips_error( "csv2vips", "%s", _( "empty line" ) );
return( -1 );
}
/* If lines is -1, we have to scan the whole file to get the
* number of lines out.
*/
if( lines == -1 ) {
fgetpos( fp, &pos );
for( lines = 0; skip_line( fp ); lines++ )
;
fsetpos( fp, &pos );
}
vips_image_init_fields( out,
columns, lines, 1,
VIPS_FORMAT_DOUBLE,
VIPS_CODING_NONE, VIPS_INTERPRETATION_B_W, 1.0, 1.0 );
vips_demand_hint( out, VIPS_DEMAND_STYLE_THINSTRIP, NULL );
/* Just reading the header? We are done.
*/
if( !read_image )
return( 0 );
if( !(buf = VIPS_ARRAY( out,
VIPS_IMAGE_N_ELEMENTS( out ), double )) )
return( -1 );
for( y = 0; y < lines; y++ ) {
int x;
for( x = 0; x < columns; x++ ) {
int lineno = y + skip + 1;
int colno = x + 1;
ch = read_double( fp, whitemap, sepmap,
lineno, colno, &d );
if( ch == EOF ) {
vips_error( "csv2vips",
_( "unexpected EOF, line %d col %d" ),
lineno, colno );
return( -1 );
}
else if( ch == '\n' ) {
vips_error( "csv2vips",
_( "unexpected EOL, line %d col %d" ),
lineno, colno );
return( -1 );
}
else if( ch )
/* Parse error.
*/
return( -1 );
buf[x] = d;
}
if( vips_image_write_line( out, y, (VipsPel *) buf ) )
return( -1 );
/* Skip over the '\n' to the next line.
*/
skip_line( fp );
}
return( 0 );
}
static int
vips_histogram_build( VipsObject *object )
{
VipsHistogram *histogram = VIPS_HISTOGRAM( object );
VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( object );
VipsHistogramClass *hclass = VIPS_HISTOGRAM_GET_CLASS( histogram );
VipsImage **decode;
VipsImage **format;
VipsImage **band;
VipsImage **size;
VipsImage **memory;
VipsPel *outbuf;
VipsPel **inbuf;
int i;
#ifdef DEBUG
printf( "vips_histogram_build: " );
vips_object_print_name( object );
printf( "\n" );
#endif /*DEBUG*/
if( VIPS_OBJECT_CLASS( vips_histogram_parent_class )->build( object ) )
return( -1 );
g_assert( histogram->n > 0 );
/* Must be NULL-terminated.
*/
g_assert( !histogram->in[histogram->n] );
decode = (VipsImage **) vips_object_local_array( object, histogram->n );
format = (VipsImage **) vips_object_local_array( object, histogram->n );
band = (VipsImage **) vips_object_local_array( object, histogram->n );
size = (VipsImage **) vips_object_local_array( object, histogram->n );
memory = (VipsImage **) vips_object_local_array( object, histogram->n );
g_object_set( histogram, "out", vips_image_new(), NULL );
for( i = 0; i < histogram->n; i++ )
if( vips_image_decode( histogram->in[i], &decode[i] ) ||
vips_check_hist( class->nickname, decode[i] ) )
return( -1 );
/* Cast our input images up to a common format, bands and size. If
* input_format is set, cast to a fixed input type.
*/
if( hclass->input_format != VIPS_FORMAT_NOTSET ) {
for( i = 0; i < histogram->n; i++ )
if( vips_cast( decode[i], &format[i],
hclass->input_format, NULL ) )
return( -1 );
}
else {
if( vips__formatalike_vec( decode, format, histogram->n ) )
return( -1 );
}
if( vips__bandalike_vec( class->nickname,
format, band, histogram->n, 1 ) ||
vips__hist_sizealike_vec( band, size, histogram->n ) )
return( -1 );
if( vips_image_pipeline_array( histogram->out,
VIPS_DEMAND_STYLE_THINSTRIP, size ) )
return( -1 );
/* Need a copy of the inputs in memory.
*/
if( !(inbuf = VIPS_ARRAY( object, histogram->n + 1, VipsPel * )) )
return( -1 );
for( i = 0; i < histogram->n; i++ ) {
if( !(memory[i] = vips_image_copy_memory( size[i] )) )
return( -1 );
inbuf[i] = VIPS_IMAGE_ADDR( memory[i], 0, 0 );
}
inbuf[i] = NULL;
/* Keep a copy of the memory images here for subclasses.
*/
histogram->ready = memory;
histogram->out->Xsize = VIPS_IMAGE_N_PELS( histogram->ready[0] );
histogram->out->Ysize = 1;
if( hclass->format_table )
histogram->out->BandFmt =
hclass->format_table[histogram->ready[0]->BandFmt];
histogram->out->Type = VIPS_INTERPRETATION_HISTOGRAM;
if( !(outbuf = vips_malloc( object,
VIPS_IMAGE_SIZEOF_LINE( histogram->out ))) )
return( -1 );
hclass->process( histogram, outbuf, inbuf, histogram->ready[0]->Xsize );
if( vips_image_write_line( histogram->out, 0, outbuf ) )
return( -1 );
return( 0 );
}
