/* Rotate an imask with a set of offsets.
*/
static INTMASK *
rotimask( offset_fn fn, INTMASK *m, const char *name )
{
INTMASK *out;
int size = m->xsize * m->ysize;
int *offsets;
int i;
if( m->xsize != m->ysize || (m->xsize % 2) == 0 ) {
im_errormsg( "im_rotate_*mask*: mask should "
"be square of even size" );
return( NULL );
}
if( !(offsets = fn( m->xsize )) )
return( NULL );
if( !(out = im_create_imask( name, m->xsize, m->ysize )) ) {
im_free( offsets );
return( NULL );
}
out->scale = m->scale;
out->offset = m->offset;
for( i = 0; i < size; i++ )
out->coeff[i] = m->coeff[offsets[i]];
im_free( offsets );
return( out );
}
void im_free_dmat(double **m, int nrl, int nrh, int ncl, int nch)
{
int i;
for (i=nrh; i>=nrl; i--)
im_free((char*) (m[i]+ncl));
im_free((char*) (m+nrl));
}
void im_free_fmat(float **m, int nrl, int nrh, int ncl, int nch)
{
int i;
for (i=nrh; i>=nrl; i--)
im_free((char*) (m[i]+ncl));
im_free((char*) (m+nrl));
}
static int gradcor_stop( void *vptr_seq, void *unrequired, void *unreq2 ){
gradcor_seq_t *seq= (gradcor_seq_t*) vptr_seq;
if( seq ){
im_free( (void*) seq-> region_xgrad );
im_free( (void*) seq-> region_ygrad );
im_region_free( seq-> reg );
seq-> region_xgrad= (int*) NULL;
seq-> region_ygrad= (int*) NULL;
seq-> reg= (REGION*) NULL;
im_free( (void*) seq );
}
return 0;
}
static void destroy(Link self){
BWindow win = self->value.vptr;
im_free( win->items);
bwindow_free(win);
if ( win->onClose) link_free(win->onClose);
object_destroy(self);
}
static int
mask_draw_labq( Mask *mask )
{
float *lab_buffer;
float ink_buffer[3];
int y;
if( !(lab_buffer = IM_ARRAY( NULL,
mask->image_clip.width * 3, float )) )
return( -1 );
imb_LabQ2Lab( DRAW( mask )->ink, ink_buffer, 1 );
for( y = 0; y < mask->image_clip.height; y++ ) {
PEL *to = (PEL *) IM_IMAGE_ADDR( DRAW( mask )->im,
mask->image_clip.left, y + mask->image_clip.top );
PEL *mask_line = (PEL *) IM_IMAGE_ADDR( mask->mask_im,
mask->mask_clip.left, y + mask->mask_clip.top );
imb_LabQ2Lab( to, lab_buffer, mask->image_clip.width );
DBLEND( float, lab_buffer, ink_buffer );
imb_Lab2LabQ( lab_buffer, to, mask->image_clip.width );
}
im_free( lab_buffer );
return( 0 );
}
/**
* Initialize the IM_DATA structure.
*
* @param im IM_DATA structure to initialize.
* @param lang LANG_* defined constant to initialize the structure with.
*/
void im_init(IM_DATA* im, int lang)
{
/* Free already allocated resources if initialized before */
if(im_initialized) {
im_free(im);
}
/* Initialize */
memset(im, 0, sizeof(IM_DATA));
im->lang = lang;
/* Setup static globals */
if(!im_initialized) {
/* ADD NEW LANGUAGE SUPPORT HERE */
im_event_fns[LANG_JA] = &im_event_ja;
im_event_fns[LANG_KO] = &im_event_ko;
im_event_fns[LANG_TH] = &im_event_th;
im_event_fns[LANG_ZH_TW] = &im_event_zh_tw;
im_initialized = 1;
}
#ifdef DEBUG
assert(0 <= im->lang && im->lang < NUM_LANGS);
if(im_event_fp) printf("Initializing IM for %s...\n", lang_prefixes[im->lang]);
#endif
/* Initialize the individual IM */
im_request(im, IM_REQ_INIT);
}
static void
vo_free( Vo *vo )
{
heap_unregister_element( vo->rc->heap, &vo->out );
VIPS_UNREF( vo->object );
im_free( vo );
}
/* Print header, or parts of header.
*/
static int
print_header( IMAGE *im, gboolean many )
{
if( !main_option_field ) {
printf( "%s: ", im->filename );
vips_object_print_summary( VIPS_OBJECT( im ) );
if( main_option_all )
(void) vips_image_map( im, print_field_fn, &many );
}
else if( strcmp( main_option_field, "getext" ) == 0 ) {
if( im__has_extension_block( im ) ) {
void *buf;
int size;
if( !(buf = im__read_extension_block( im, &size )) )
return( -1 );
printf( "%s", (char *) buf );
im_free( buf );
}
}
else if( strcmp( main_option_field, "Hist" ) == 0 )
printf( "%s", im_history_get( im ) );
else {
GValue value = { 0 };
GType type;
if( im_header_get( im, main_option_field, &value ) )
return( -1 );
/* Display the save form, if there is one. This way we display
* something useful for ICC profiles, xml fields, etc.
*/
type = G_VALUE_TYPE( &value );
if( g_value_type_transformable( type, IM_TYPE_SAVE_STRING ) ) {
GValue save_value = { 0 };
g_value_init( &save_value, IM_TYPE_SAVE_STRING );
if( !g_value_transform( &value, &save_value ) )
return( -1 );
printf( "%s\n", im_save_string_get( &save_value ) );
g_value_unset( &save_value );
}
else {
char *str_value;
str_value = g_strdup_value_contents( &value );
printf( "%s\n", str_value );
g_free( str_value );
}
g_value_unset( &value );
}
return( 0 );
}
static void
read_destroy( Read *read )
{
IM_FREE( read->filename );
IM_FREEF( Mat_VarFree, read->var );
IM_FREEF( Mat_Close, read->mat );
im_free( read );
}
static void
write_destroy( Write *write )
{
jpeg_destroy_compress( &write->cinfo );
IM_FREEF( im_close, write->in );
IM_FREEF( fclose, write->eman.fp );
IM_FREE( write->row_pointer );
IM_FREE( write->profile_bytes );
IM_FREEF( im_close, write->inverted );
im_free( write );
}
static void
read_destroy( Read *read )
{
IM_FREE( read->name );
IM_FREEF( fclose, read->fp );
if( read->pPng )
png_destroy_read_struct( &read->pPng, &read->pInfo, NULL );
IM_FREE( read->row_pointer );
IM_FREE( read->data );
im_free( read );
}
static void
read_destroy( Read *read )
{
IM_FREEF( g_mutex_free, read->lock );
while( read->cache ) {
Tile *tile = (Tile *) read->cache->data;
tile_destroy( tile );
}
im_free( read );
}
static void
tile_destroy( Tile *tile )
{
Read *read = tile->read;
read->cache = g_slist_remove( read->cache, tile );
read->ntiles -= 1;
g_assert( read->ntiles >= 0 );
tile->read = NULL;
IM_FREEF( im_region_free, tile->region );
im_free( tile );
}
int main(int argc, char **argv)
{
void *data;
mlog_init();
TopSaxParser parser1;
// Debugging if argc > 1
if(argc > 1) {
mlog_registerColorFormatter((color_formatter_func_t)sprintf_color);
mlog_addOutputFile((char *)"/dev/tty", 1);
mlog_setModuleLevel((char *)"top", LOG_DEBUG);
mlog_setModuleLevel((char *)"topparser", LOG_DEBUG);
}
// init
im_init(&data, NULL);
// sleep
sleep(1);
while(1) {
// update
im_update(data);
int i = 16000;
im_get(data, buff, &i);
//system("clear");
//printf("%s", buff);
//printf("\n");
processVecT v;
TopSaxParser parser;
parser.parse(std::string(buff), v);
std::cout << "================= Top Processes: " << v.size() << " ======================" << std::endl;
for(std::vector<ProcessStatusInfo>::iterator iter = v.begin() ; iter != v.end() ; iter++) {
ProcessStatusInfo *pi = &(*iter);
std::cout << "XML:" << std::endl << pi->getProcessXML();
}
sleep(3);
}
// free
im_free(&data);
free(buff);
return 0;
}
/**
* im_stop_many:
*
* Stop function for many images in. First client is a pointer to
* a %NULL-terminated array of input images.
*
* See also: im_generate().
*/
int
im_stop_many( void *seq, void *dummy1, void *dummy2 )
{
REGION **ar = (REGION **) seq;
if( ar ) {
int i;
for( i = 0; ar[i]; i++ )
im_region_free( ar[i] );
im_free( (char *) ar );
}
return( 0 );
}
int main(int argc, char **argv)
{
void *data;
mlog_init();
// MeminfoSaxParser parser1;
// Debugging if argc > 1
if(argc > 1) {
mlog_registerColorFormatter((color_formatter_func_t)sprintf_color);
mlog_addOutputFile((char *)"/dev/tty", 1);
mlog_setModuleLevel((char *)"meminfo", LOG_DEBUG);
mlog_setModuleLevel((char *)"meminfoparser", LOG_DEBUG);
}
// init
im_init(&data, NULL);
// sleep
sleep(1);
while(1) {
// update
im_update(data);
int i = 8192;
im_get(data, buff, &i);
//system("clear");
printf("%s", buff);
printf("\n");
MeminfoSaxParser parser;
Meminfo mi;
parser.parse(std::string(buff), mi);
std::cout << mi.get_xml();
std::cout << "====================================================" << std::endl << std::endl;
sleep(1);
}
// free
im_free(&data);
free(buff);
return 0;
}
/**
* im_region_free:
* @reg: #REGION to free
*
* Free a region and any resources it holds.
*
* If @im has previously been closed, then freeing the last #REGION on @in can
* cause @im to finally be freed as well.
*/
void
im_region_free( REGION *reg )
{
IMAGE *im;
if( !reg )
return;
im = reg->im;
/* Stop this sequence.
*/
im__call_stop( reg );
/* Free any attached memory.
*/
im_region_reset( reg );
/* Detach from image.
*/
g_mutex_lock( im->sslock );
im->regions = g_slist_remove( im->regions, reg );
g_mutex_unlock( im->sslock );
reg->im = NULL;
/* Was this the last region on an image with close_pending? If yes,
* close the image too.
*/
if( !im->regions && im->close_pending ) {
#ifdef DEBUG_IO
printf( "im_region_free: closing pending image \"%s\"\n",
im->filename );
#endif /*DEBUG_IO*/
/* Time to close the image.
*/
im->close_pending = 0;
im_close( im );
}
im_free( reg );
#ifdef DEBUG
g_mutex_lock( im__global_lock );
g_assert( g_slist_find( im__regions_all, reg ) );
im__regions_all = g_slist_remove( im__regions_all, reg );
printf( "%d regions in vips\n", g_slist_length( im__regions_all ) );
g_mutex_unlock( im__global_lock );
#endif /*DEBUG*/
}
static int
read_destroy( Read *read )
{
#ifdef DEBUG
printf( "im_magick2vips: read_destroy: %s\n", read->filename );
#endif /*DEBUG*/
IM_FREEF( DestroyImage, read->image );
IM_FREEF( DestroyImageInfo, read->image_info );
IM_FREE( read->frames );
IM_FREE( read->filename );
DestroyExceptionInfo( &read->exception );
IM_FREEF( g_mutex_free, read->lock );
im_free( read );
return( 0 );
}
static void
buffer_cache_list_free( im_buffer_cache_list_t *cache_list )
{
GSList *p;
/* Need to mark undone so we don't try and take them off this hash on
* unref.
*/
for( p = cache_list->buffers; p; p = p->next ) {
im_buffer_t *buffer = (im_buffer_t *) p->data;
buffer->done = FALSE;
}
g_slist_free( cache_list->buffers );
im_free( cache_list );
}
static int
attach_thumbnail( IMAGE *im, ExifData *ed )
{
if( ed->size > 0 ) {
char *thumb_copy;
thumb_copy = im_malloc( NULL, ed->size );
memcpy( thumb_copy, ed->data, ed->size );
if( im_meta_set_blob( im, "jpeg-thumbnail-data",
(im_callback_fn) im_free, thumb_copy, ed->size ) ) {
im_free( thumb_copy );
return( -1 );
}
}
return( 0 );
}
static void *gradcor_start( IMAGE *out, void *vptr_large, void *unrequired ){
gradcor_seq_t *seq= IM_NEW( NULL, gradcor_seq_t );
if( ! seq )
return NULL;
seq-> region_xgrad= (int*) NULL;
seq-> region_ygrad= (int*) NULL;
seq-> region_xgrad_area= 0;
seq-> region_ygrad_area= 0;
seq-> reg= im_region_create( (IMAGE*) vptr_large );
if( ! seq-> reg ){
im_free( (void*) seq );
return NULL;
}
return (void*) seq;
}
/**
* im_fav4:
* @in: array of 4 input #IMAGE s
* @out: output #IMAGE
*
* Average four identical images.
*
* Deprecated.
*/
int
im_fav4( IMAGE **in, IMAGE *out)
{
PEL *result, *buffer, *p1, *p2, *p3, *p4;
int x,y;
int linebytes, PICY;
/* check IMAGEs parameters
*/
if(im_iocheck(in[1], out)) return(-1);
/* BYTE images only!
*/
if( (in[0]->BandFmt != IM_BANDFMT_CHAR) && (in[0]->BandFmt != IM_BANDFMT_UCHAR)) return(-1);
if ( im_cp_desc(out, in[1]) == -1) /* copy image descriptors */
return(-1);
if ( im_setupout(out) == -1)
return(-1);
linebytes = in[0]->Xsize * in[0]->Bands;
PICY = in[0]->Ysize;
buffer = (PEL*)im_malloc(NULL,linebytes);
memset(buffer, 0, linebytes);
p1 = (PEL*)in[0]->data;
p2 = (PEL*)in[1]->data;
p3 = (PEL*)in[2]->data;
p4 = (PEL*)in[3]->data;
for (y = 0; y < PICY; y++)
{
result = buffer;
/* average 4 pels with rounding, for whole line*/
for (x = 0; x < linebytes; x++) {
*result++ = (PEL)((int)((int)*p1++ + (int)*p2++ + (int)*p3++ + (int)*p4++ +2) >> 2);
}
im_writeline(y,out, buffer);
}
im_free(buffer);
return(0);
}
/* Merge the sequence value back into the per-call state.
*/
static int
maxposavg_stop( void *seq, void *a, void *b )
{
Maxposavg *global_maxposavg = (Maxposavg *) b;
Maxposavg *maxposavg = (Maxposavg *) seq;
/* Merge.
*/
if( maxposavg->max > global_maxposavg->max )
*global_maxposavg = *maxposavg;
else if( maxposavg->max == global_maxposavg->max ) {
global_maxposavg->xpos += maxposavg->xpos;
global_maxposavg->ypos += maxposavg->ypos;
global_maxposavg->occurences += maxposavg->occurences;
}
im_free( seq );
return( 0 );
}
void
im_buffer_unref( im_buffer_t *buffer )
{
#ifdef DEBUG
printf( "** im_buffer_unref: left = %d, top = %d, "
"width = %d, height = %d (%p)\n",
buffer->area.left, buffer->area.top,
buffer->area.width, buffer->area.height,
buffer );
#endif /*DEBUG*/
g_assert( buffer->ref_count > 0 );
buffer->ref_count -= 1;
if( buffer->ref_count == 0 ) {
#ifdef DEBUG
if( !buffer->done )
printf( "im_buffer_unref: buffer was not done\n" );
#endif /*DEBUG*/
im_buffer_undone( buffer );
buffer->im = NULL;
IM_FREE( buffer->buf );
buffer->bsize = 0;
im_free( buffer );
#ifdef DEBUG
g_mutex_lock( im__global_lock );
g_assert( g_slist_find( im__buffers_all, buffer ) );
im__buffers_all = g_slist_remove( im__buffers_all, buffer );
printf( "%d buffers in vips\n",
g_slist_length( im__buffers_all ) );
g_mutex_unlock( im__global_lock );
#endif /*DEBUG*/
}
}
/* Merge the sequence value back into the per-call state.
*/
static int
stop_fn( void *vseq, void *a, void *b )
{
Seq *seq = (Seq *) vseq;
MinInfo *inf = (MinInfo *) a;
if( seq->valid ) {
if( !inf->valid )
/* Just copy.
*/
inf->value = seq->value;
else
/* Merge.
*/
inf->value = IM_MIN( inf->value, seq->value );
inf->valid = 1;
}
im_free( seq );
return( 0 );
}
int rrd_xport(
int argc,
char **argv,
int UNUSED(*xsize),
time_t *start,
time_t *end, /* which time frame do you want ?
* will be changed to represent reality */
unsigned long *step, /* which stepsize do you want?
* will be changed to represent reality */
unsigned long *col_cnt, /* number of data columns in the result */
char ***legend_v, /* legend entries */
rrd_value_t **data)
{ /* two dimensional array containing the data */
image_desc_t im;
time_t start_tmp = 0, end_tmp = 0;
rrd_time_value_t start_tv, end_tv;
char *parsetime_error = NULL;
struct optparse options;
optparse_init(&options, argc, argv);
struct optparse_long longopts[] = {
{"start", 's', OPTPARSE_REQUIRED},
{"end", 'e', OPTPARSE_REQUIRED},
{"maxrows",'m', OPTPARSE_REQUIRED},
{"step", 261, OPTPARSE_REQUIRED},
{"enumds", 262, OPTPARSE_NONE},
{"json", 263, OPTPARSE_NONE},
{"showtime", 't', OPTPARSE_NONE},
{"daemon", 'd', OPTPARSE_REQUIRED},
{0}
};
rrd_graph_init(&im);
rrd_parsetime("end-24h", &start_tv);
rrd_parsetime("now", &end_tv);
int enumds=0;
int json=0;
int showtime=0;
int opt;
while ((opt = optparse_long(&options,longopts,NULL)) != -1){
switch (opt) {
case 261:
im.step = atoi(options.optarg);
break;
case 262:
enumds=1;
break;
case 263:
json=1;
break;
case 't':
showtime=1;
break;
case 's':
if ((parsetime_error = rrd_parsetime(options.optarg, &start_tv))) {
rrd_set_error("start time: %s", parsetime_error);
return -1;
}
break;
case 'e':
if ((parsetime_error = rrd_parsetime(options.optarg, &end_tv))) {
rrd_set_error("end time: %s", parsetime_error);
return -1;
}
break;
case 'm':
im.xsize = atol(options.optarg);
if (im.xsize < 10) {
rrd_set_error("maxrows below 10 rows");
return -1;
}
break;
case 'd':
{
if (im.daemon_addr != NULL)
{
rrd_set_error ("You cannot specify --daemon "
"more than once.");
return (-1);
}
im.daemon_addr = strdup(options.optarg);
if (im.daemon_addr == NULL)
{
rrd_set_error("strdup error");
return -1;
}
break;
}
case '?':
rrd_set_error("%s", options.errmsg);
return -1;
}
}
if (rrd_proc_start_end(&start_tv, &end_tv, &start_tmp, &end_tmp) == -1) {
return -1;
}
if (start_tmp < 3600 * 24 * 365 * 10) {
rrd_set_error("the first entry to fetch should be after 1980 (%ld)",
start_tmp);
return -1;
}
if (end_tmp < start_tmp) {
rrd_set_error("start (%ld) should be less than end (%ld)",
start_tmp, end_tmp);
return -1;
}
im.start = start_tmp;
im.end = end_tmp;
im.step = max((long) im.step, (im.end - im.start) / im.xsize);
rrd_graph_script(options.argc, options.argv, &im, options.optind);
if (rrd_test_error()) {
im_free(&im);
return -1;
}
if (im.gdes_c == 0) {
rrd_set_error("can't make an xport without contents");
im_free(&im);
return (-1);
}
{ /* try to connect to rrdcached */
int status = rrdc_connect(im.daemon_addr);
if (status != 0) return status;
}
if (rrd_xport_fn(&im, start, end, step, col_cnt, legend_v, data,0) == -1) {
im_free(&im);
return -1;
}
/* and create the export */
if (!xsize) {
int flags=0;
if (json) { flags|=1; }
if (showtime) { flags|=2; }
if (enumds) { flags|=4; }
stringbuffer_t buffer={0,0,NULL,stdout};
rrd_xport_format_xmljson(flags,&buffer,&im,
*start, *end, *step,
*col_cnt, *legend_v,
*data);
}
im_free(&im);
return 0;
}
static void
mask_free( Mask *mask )
{
im__draw_free( DRAW( mask ) );
im_free( mask );
}
/* Helper function to write an image to a directory of DICOM files using C++ */
static int write_dcm_dir_cpp(const char *path, const Image *const im,
const Dcm_meta *const meta) {
Image slice;
// Initialize C intermediates
init_im(&slice);
// Initialize the metadata to defaults, if it is null
Dcm_meta meta_new;
set_meta_defaults(meta, &meta_new);
// Get the number of leading zeros for the file names
const int num_slices = im->nz;
const int num_zeros = static_cast<int>(ceil(log10(
static_cast<double>(num_slices))));
// Form the printf format string for file names
#define BUF_LEN 16
char format[BUF_LEN];
snprintf(format, BUF_LEN, "%%0%dd.%s", num_zeros, ext_dcm);
#undef BUF_LEN
// Resize the slice buffer
slice.nx = im->nx;
slice.ny = im->ny;
slice.nz = 1;
slice.nc = im->nc;
im_default_stride(&slice);
if (im_resize(&slice)) {
im_free(&slice);
return SIFT3D_FAILURE;
}
// Copy the units to the slice
memcpy(SIFT3D_IM_GET_UNITS(&slice), SIFT3D_IM_GET_UNITS(im),
IM_NDIMS * sizeof(double));
// Get the maximum absolute value of the whole image volume
const float max_val = im_max_abs(im);
// Write each slice
for (int i = 0; i < num_slices; i++) {
// Form the slice file name
#define BUF_LEN 1024
char buf[BUF_LEN];
snprintf(buf, BUF_LEN, format, i);
// Form the full file path
std::string fullfile(path + sepStr + buf);
// Copy the data to the slice
int x, y, z, c;
SIFT3D_IM_LOOP_START_C(&slice, x, y, z, c)
SIFT3D_IM_GET_VOX(&slice, x, y, z, c) =
SIFT3D_IM_GET_VOX(im, x, y, i, c);
SIFT3D_IM_LOOP_END_C
// Generate a new SOPInstanceUID
dcmGenerateUniqueIdentifier(meta_new.instance_uid,
SITE_INSTANCE_UID_ROOT);
// Set the instance number
const unsigned int instance = static_cast<unsigned int>(i + 1);
meta_new.instance_num = instance;
// Write the slice to a file
if (write_dcm(fullfile.c_str(), &slice, &meta_new, max_val)) {
im_free(&slice);
return SIFT3D_FAILURE;
}
}
// Clean up
im_free (&slice);
return SIFT3D_SUCCESS;
}
int main(int argc, char *argv[]) {
SIFT3D sift3d;
Reg_SIFT3D reg;
Image src, ref;
Mat_rm match_src, match_ref;
void *tform, *tform_arg;
char *src_path, *ref_path, *warped_path, *match_path, *tform_path,
*concat_path, *keys_path, *lines_path;
tform_type type;
double thresh;
int num_args, c, have_match, have_tform;
const struct option longopts[] = {
{"matches", required_argument, NULL, MATCHES},
{"transform", required_argument, NULL, TRANSFORM},
{"warped", required_argument, NULL, WARPED},
{"concat", required_argument, NULL, CONCAT},
{"keys", required_argument, NULL, KEYS},
{"lines", required_argument, NULL, LINES},
{"thresh", required_argument, NULL, THRESH},
{"type", required_argument, NULL, TYPE},
{0, 0, 0, 0}
};
const char str_affine[] = "affine";
SIFT3D_Descriptor_store *const desc_src = ®.desc_src;
SIFT3D_Descriptor_store *const desc_ref = ®.desc_ref;
// Parse the GNU standard options
switch (parse_gnu(argc, argv)) {
case SIFT3D_HELP:
puts(help_msg);
print_opts_SIFT3D();
return 0;
case SIFT3D_VERSION:
return 0;
case SIFT3D_FALSE:
break;
default:
err_msgu("Unexpected return from parse_gnu \n");
return 1;
}
// Initialize the data
init_im(&src);
init_im(&ref);
init_Reg_SIFT3D(®);
init_SIFT3D(&sift3d);
if (init_Mat_rm(&match_src, 0, 0, DOUBLE, SIFT3D_FALSE) ||
init_Mat_rm(&match_ref, 0, 0, DOUBLE, SIFT3D_FALSE)) {
err_msgu("Failed basic initialization.");
return 1;
}
// Initialize parameters to defaults
type = type_default;
// Parse the SIFT3D options
if ((argc = parse_args_SIFT3D(&sift3d, argc, argv, SIFT3D_FALSE)) < 0)
return 1;
set_SIFT3D_Reg_SIFT3D(®, &sift3d);
// Parse the remaining options
opterr = 1;
have_match = have_tform = SIFT3D_FALSE;
match_path = tform_path = warped_path = concat_path = keys_path =
lines_path = NULL;
while ((c = getopt_long(argc, argv, "", longopts, NULL)) != -1) {
switch (c) {
case MATCHES:
match_path = optarg;
have_match = SIFT3D_TRUE;
break;
case TRANSFORM:
tform_path = optarg;
have_tform = SIFT3D_TRUE;
break;
case WARPED:
warped_path = optarg;
have_tform = SIFT3D_TRUE;
break;
case CONCAT:
concat_path = optarg;
have_match = SIFT3D_TRUE;
break;
case KEYS:
keys_path = optarg;
have_match = SIFT3D_TRUE;
break;
case LINES:
lines_path = optarg;
have_match = SIFT3D_TRUE;
break;
case THRESH:
thresh = atof(optarg);
if (set_nn_thresh_Reg_SIFT3D(®, thresh)) {
err_msg("Invalid value for thresh.");
return 1;
}
break;
case TYPE:
if (!strcmp(optarg, str_affine)) {
type = AFFINE;
} else {
char msg[1024];
sprintf(msg,
"Unrecognized transformation "
"type: %s\n", optarg);
err_msg(msg);
return 1;
}
break;
case '?':
default:
return 1;
}
}
// Ensure that at least one output was specified
if (!have_match && !have_tform) {
err_msg("No outputs were specified.");
return 1;
}
// Parse the required arguments
num_args = argc - optind;
if (num_args < 2) {
err_msg("Not enough arguments.");
return 1;
} else if (num_args > 2) {
err_msg("Too many arguments.");
return 1;
}
src_path = argv[optind];
ref_path = argv[optind + 1];
// Allocate memory for the transformation
if ((tform = malloc(tform_type_get_size(type))) == NULL) {
err_msg("Out of memory.");
return 1;
}
// Initialize the transformation
if (init_tform(tform, type))
return 1;
// Read the images
if (read_nii(src_path, &src)) {
char msg[1024];
sprintf(msg, "Failed to read the source image \"%s\"",
src_path);
err_msg(msg);
return 1;
}
if (read_nii(ref_path, &ref)) {
char msg[1024];
sprintf(msg, "Failed to read the reference image \"%s\"",
ref_path);
err_msg(msg);
return 1;
}
// Set the images
if (set_src_Reg_SIFT3D(®, &src)) {
err_msgu("Failed to set the source image.");
return 1;
}
if (set_ref_Reg_SIFT3D(®, &ref)) {
err_msgu("Failed to set the reference image.");
return 1;
}
// Match the features, optionally registering the images
tform_arg = have_tform ? tform : NULL;
if (register_SIFT3D(®, tform_arg)) {
err_msgu("Failed to register the images.");
return 1;
}
// Convert the matches to matrices
if (get_matches_Reg_SIFT3D(®, &match_src, &match_ref)) {
err_msgu("Failed to convert matches to coordinates.");
return 1;
}
// Write the outputs
if (match_path != NULL) {
Mat_rm matches;
int i, j;
// Initialize intermediates
init_Mat_rm(&matches, 0, 0, DOUBLE, SIFT3D_FALSE);
// Form a combined matrix for both sets of matches
if (concat_Mat_rm(&match_src, &match_ref, &matches, 1)) {
err_msgu("Failed to concatenate the matches.");
return 1;
}
if (write_Mat_rm(match_path, &matches)) {
char msg[1024];
sprintf(msg, "Failed to write the matches \"%s\"",
match_path);
err_msg(msg);
return 1;
}
// Clean up
cleanup_Mat_rm(&matches);
}
if (tform_path != NULL && write_tform(tform_path, tform)) {
char msg[1024];
sprintf(msg, "Failed to write the transformation parameters "
"\"%s\"", tform_path);
err_msg(msg);
return 1;
}
// Optionally warp the source image
if (warped_path != NULL) {
Image warped;
// Initialize intermediates
init_im(&warped);
// Warp
if (im_inv_transform(tform, &src, &warped, interp)) {
err_msgu("Failed to warp the source image.");
return 1;
}
// Write the warped image
if (write_nii(warped_path, &warped)) {
char msg[1024];
sprintf(msg, "Failed to write the warped image \"%s\"",
warped_path);
err_msg(msg);
return 1;
}
// Clean up
im_free(&warped);
}
// Optionally draw the matches
if (concat_path != NULL || keys_path != NULL || lines_path != NULL) {
Image concat, keys, lines;
Mat_rm keys_src, keys_ref;
Image *concat_arg, *keys_arg, *lines_arg;
// Initialize intermediates
init_im(&concat);
init_im(&keys);
init_im(&lines);
if (init_Mat_rm(&keys_src, 0, 0, DOUBLE, SIFT3D_FALSE) ||
init_Mat_rm(&keys_ref, 0, 0, DOUBLE, SIFT3D_FALSE)) {
err_msgu("Failed to initialize keypoint matrices.");
return 1;
}
// Set up the pointers for the images
concat_arg = concat_path == NULL ? NULL : &concat;
keys_arg = keys_path == NULL ? NULL : &keys;
lines_arg = lines_path == NULL ? NULL : &lines;
// Convert the keypoints to matrices
if (Keypoint_store_to_Mat_rm(®.kp_src, &keys_src) ||
Keypoint_store_to_Mat_rm(®.kp_ref, &keys_ref)) {
err_msgu("Failed to convert the keypoints to "
"matrices.");
return 1;
}
// Draw the matches
if (draw_matches(&src, &ref, &keys_src, &keys_ref,
&match_src, &match_ref, concat_arg, keys_arg,
lines_arg)) {
err_msgu("Failed to draw the matches.");
return 1;
}
// Optionally write a concatenated image
if (concat_path != NULL && write_nii(concat_path, &concat)) {
char msg[1024];
sprintf(msg, "Failed to write the concatenated image "
"\"%s\"", concat_path);
err_msg(msg);
return 1;
}
// Optionally write the keypoints
if (keys_path != NULL && write_nii(keys_path, &keys)) {
char msg[1024];
sprintf(msg, "Failed to write the keypoint image "
"\"%s\"", concat_path);
err_msg(msg);
return 1;
}
// Optionally write the matches
if (lines_path != NULL && write_nii(lines_path, &lines)) {
char msg[1024];
sprintf(msg, "Failed to write the line image "
"\"%s\"", concat_path);
err_msg(msg);
return 1;
}
// Clean up
im_free(&concat);
im_free(&keys);
im_free(&lines);
}
return 0;
}