Sadie_Multi.c Source File

00001 /*
00002 ##########################################
00003 # Sadie_Multi.c -
00004 #   Set of routines for linking SADIE multi routines to tcl/tk.
00005 #
00006 # RCS: $Id: Sadie_Multi.c,v 2.4 1999/02/11 14:33:03 conner Exp $ 
00007 # 
00008 # Digital Image Analysis Lab
00009 # Dept. of Electrical and Computer Engineering
00010 # University of Arizona
00011 ##########################################
00012 */
00013 
00014 #include <tcl.h>
00015 #include <tk.h>
00016 #include <stdio.h>
00017 #include <string.h>
00018 #include "sadie.h"
00019 
00020 
00021 /* RCS Indentification information */
00022 static char rcsid[] = "$Id: Sadie_Multi.c,v 2.4 1999/02/11 14:33:03 conner Exp $";
00023 
00024 
00025 
00026 /*-------------------------------------------------------------*/
00027 /* Global Sadie variables that must be set from within Tcl/Tk  */
00028 /*-------------------------------------------------------------*/
00029 extern  short   nlev;
00030 extern  short   csize;
00031 extern  double  weight;
00032 extern  double  *count;
00033 extern  PIXEL   gain;
00034 extern  PIXEL   bias;
00035 extern  PIXEL   gmin;
00036 extern  PIXEL   gmax;
00037 extern  PIXEL   thresh;
00038 extern  PIXEL   gbrk[2][4];
00039 extern  PIXEL   *table;
00040 /* -------------------------------------------------------------------------- */
00041 
00042 
00043 /*-Copyright Information------------------------------------------------------*/
00044 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00045 /*----------------------------------------------------------------------------*/
00046 /*-General Information--------------------------------------------------------*/
00047 /*                                                                            */
00048 /*   This procedure provides an interface to the SADIE function               */
00049 /*   COMBINE from Tcl/Tk.  It expects a tcl global array                      */
00050 /*   with these indices to exist:                                             */
00051 /*      array(inimg,addr1)        --  SADIE image address                     */
00052 /*      array(inimg,addr2)        --  SADIE image address                     */
00053 /*      array(option)             --  int                                     */
00054 /*      array(weight1)            --  double                                  */
00055 /*      array(weight2)            --  double                                  */
00056 /*      array(outname)            --  char*                                   */
00057 /*                                                                            */
00058 /*----------------------------------------------------------------------------*/
00059 /*-Interface Information------------------------------------------------------*/
00060 int Sadie_Multi_CombineCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00061 {
00062     Tcl_Obj* tclobj=NULL;
00063     Tcl_Obj* tclarrayname = NULL;
00064     Tcl_Obj* tclindexname = NULL;
00065     char msg[SLEN];
00066     char* array=NULL;
00067     char* tempstr=NULL;
00068     int strlen;
00069     int inimgaddr1, inimgaddr2;
00070     IMAGE *inimg1=NULL, *inimg2=NULL;
00071     int outimgaddr;
00072     IMAGE* outimg=NULL;
00073     char* outname=NULL;
00074     int option;
00075     double weight1, weight2;
00076 
00077     if( argc != 2 ) {
00078         Tcl_AppendResult(interp,"wrong # args: should be \"",
00079         argv[0], " arrayname\"", (char *) NULL);
00080         return TCL_ERROR;
00081     }
00082     array=argv[1];
00083             
00084 
00085     /* Read input image array(inimg,addr1) */
00086     tclarrayname = Tcl_NewStringObj(array,-1);
00087     tclindexname = Tcl_NewStringObj("inimg,addr1",-1);
00088     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00089         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00090         if (strlen <= 0) return TCL_ERROR;
00091         sscanf(tempstr,"%x",&inimgaddr1);
00092         inimg1 = (IMAGE *) inimgaddr1;
00093     } else {
00094         return TCL_ERROR;
00095     }
00096     Tcl_DecrRefCount(tclarrayname);
00097     Tcl_DecrRefCount(tclindexname);
00098                 
00099 
00100     /* Read input image array(inimg,addr2) */
00101     tclarrayname = Tcl_NewStringObj(array,-1);
00102     tclindexname = Tcl_NewStringObj("inimg,addr2",-1);
00103     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00104         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00105         if (strlen <= 0) return TCL_ERROR;
00106         sscanf(tempstr,"%x",&inimgaddr2);
00107         inimg2 = (IMAGE *) inimgaddr2;
00108     } else {
00109         return TCL_ERROR;
00110     }
00111     Tcl_DecrRefCount(tclarrayname);
00112     Tcl_DecrRefCount(tclindexname);
00113                 
00114 
00115     /* Read the input integer array(option) */
00116     tclarrayname = Tcl_NewStringObj(array,-1);
00117     tclindexname = Tcl_NewStringObj("option",-1);
00118     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00119         if (Tcl_GetIntFromObj(interp,tclobj,&option) == TCL_ERROR) return TCL_ERROR;
00120     } else {
00121         return TCL_ERROR;
00122     }
00123     Tcl_DecrRefCount(tclarrayname);
00124     Tcl_DecrRefCount(tclindexname);
00125                 
00126 
00127     /* Read the input double array(weight1) */
00128     tclarrayname = Tcl_NewStringObj(array,-1);
00129     tclindexname = Tcl_NewStringObj("weight1",-1);
00130     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00131         if (Tcl_GetDoubleFromObj(interp,tclobj,&weight1) == TCL_ERROR) return TCL_ERROR;
00132     } else {
00133         return TCL_ERROR;
00134     }
00135     Tcl_DecrRefCount(tclarrayname);
00136     Tcl_DecrRefCount(tclindexname);
00137                 
00138 
00139     /* Read the input double array(weight2) */
00140     tclarrayname = Tcl_NewStringObj(array,-1);
00141     tclindexname = Tcl_NewStringObj("weight2",-1);
00142     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00143         if (Tcl_GetDoubleFromObj(interp,tclobj,&weight2) == TCL_ERROR) return TCL_ERROR;
00144     } else {
00145         return TCL_ERROR;
00146     }
00147     Tcl_DecrRefCount(tclarrayname);
00148     Tcl_DecrRefCount(tclindexname);
00149                 
00150 
00151     /* Read the output image 1 name */
00152     tclarrayname = Tcl_NewStringObj(array,-1);
00153     tclindexname = Tcl_NewStringObj("outname",-1);
00154     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00155         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00156         if (strlen <= 0) return TCL_ERROR;
00157     } else {
00158         return TCL_ERROR;
00159     }
00160     Tcl_DecrRefCount(tclarrayname);
00161     Tcl_DecrRefCount(tclindexname);
00162                 
00163 
00164     COMBINE(inimg1,inimg2,option,weight1,weight2,&outimg);
00165             
00166 
00167     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00168     outimgaddr = (int) outimg;
00169                 
00170 
00171     sprintf(msg, "%x", outimgaddr);
00172     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00173             
00174     return TCL_OK;
00175 }
00176 
00177 
00178 
00179 
00180 
00181 
00182 /*-Copyright Information------------------------------------------------------*/
00183 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00184 /*----------------------------------------------------------------------------*/
00185 /*-General Information--------------------------------------------------------*/
00186 /*                                                                            */
00187 /*   This procedure provides an interface to the SADIE function               */
00188 /*   COMPARE from Tcl/Tk.  It expects a tcl global array                      */
00189 /*   with these indices to exist:                                             */
00190 /*      array(inimg,addr1)        --  SADIE image address                     */
00191 /*      array(inimg,addr2)        --  SADIE image address                     */
00192 /*      array(option)             --  int                                     */
00193 /*      array(outname)            --  char*                                   */
00194 /*                                                                            */
00195 /*----------------------------------------------------------------------------*/
00196 /*-Interface Information------------------------------------------------------*/
00197 int Sadie_Multi_CompareCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00198 {
00199     Tcl_Obj* tclobj=NULL;
00200     Tcl_Obj* tclarrayname = NULL;
00201     Tcl_Obj* tclindexname = NULL;
00202     char msg[SLEN];
00203     char* array=NULL;
00204     char* tempstr=NULL;
00205     int strlen;
00206     int inimgaddr1, inimgaddr2;
00207     IMAGE *inimg1=NULL, *inimg2=NULL;
00208     int outimgaddr;
00209     IMAGE* outimg=NULL;
00210     char* outname=NULL;
00211     int option;
00212 
00213     if( argc != 2 ) {
00214         Tcl_AppendResult(interp,"wrong # args: should be \"",
00215         argv[0], " arrayname\"", (char *) NULL);
00216         return TCL_ERROR;
00217     }
00218     array=argv[1];
00219             
00220 
00221     /* Read input image array(inimg,addr1) */
00222     tclarrayname = Tcl_NewStringObj(array,-1);
00223     tclindexname = Tcl_NewStringObj("inimg,addr1",-1);
00224     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00225         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00226         if (strlen <= 0) return TCL_ERROR;
00227         sscanf(tempstr,"%x",&inimgaddr1);
00228         inimg1 = (IMAGE *) inimgaddr1;
00229     } else {
00230         return TCL_ERROR;
00231     }
00232     Tcl_DecrRefCount(tclarrayname);
00233     Tcl_DecrRefCount(tclindexname);
00234                 
00235 
00236     /* Read input image array(inimg,addr2) */
00237     tclarrayname = Tcl_NewStringObj(array,-1);
00238     tclindexname = Tcl_NewStringObj("inimg,addr2",-1);
00239     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00240         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00241         if (strlen <= 0) return TCL_ERROR;
00242         sscanf(tempstr,"%x",&inimgaddr2);
00243         inimg2 = (IMAGE *) inimgaddr2;
00244     } else {
00245         return TCL_ERROR;
00246     }
00247     Tcl_DecrRefCount(tclarrayname);
00248     Tcl_DecrRefCount(tclindexname);
00249                 
00250 
00251     /* Read the input integer array(option) */
00252     tclarrayname = Tcl_NewStringObj(array,-1);
00253     tclindexname = Tcl_NewStringObj("option",-1);
00254     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00255         if (Tcl_GetIntFromObj(interp,tclobj,&option) == TCL_ERROR) return TCL_ERROR;
00256     } else {
00257         return TCL_ERROR;
00258     }
00259     Tcl_DecrRefCount(tclarrayname);
00260     Tcl_DecrRefCount(tclindexname);
00261                 
00262 
00263     /* Read the output image 1 name */
00264     tclarrayname = Tcl_NewStringObj(array,-1);
00265     tclindexname = Tcl_NewStringObj("outname",-1);
00266     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00267         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00268         if (strlen <= 0) return TCL_ERROR;
00269     } else {
00270         return TCL_ERROR;
00271     }
00272     Tcl_DecrRefCount(tclarrayname);
00273     Tcl_DecrRefCount(tclindexname);
00274                 
00275 
00276     COMPARE(inimg1,inimg2,option,&outimg);
00277             
00278 
00279     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00280     outimgaddr = (int) outimg;
00281                 
00282 
00283     sprintf(msg, "%x", outimgaddr);
00284     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00285             
00286     return TCL_OK;
00287 }
00288 
00289 
00290 
00291 
00292 
00293 
00294 /*-Copyright Information------------------------------------------------------*/
00295 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00296 /*----------------------------------------------------------------------------*/
00297 /*-General Information--------------------------------------------------------*/
00298 /*                                                                            */
00299 /*   This procedure provides an interface to the SADIE function               */
00300 /*   PCT from Tcl/Tk.  It expects a tcl global array                          */
00301 /*   with these indices to exist:                                             */
00302 /*      array(inimg,addr)         --  SADIE image address                     */
00303 /*      array(incr)               --  int                                     */
00304 /*      array(outname)            --  char*                                   */
00305 /*                                                                            */
00306 /*----------------------------------------------------------------------------*/
00307 /*-Interface Information------------------------------------------------------*/
00308 int Sadie_Multi_PCTCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00309 {
00310     Tcl_Obj* tclobj=NULL;
00311     Tcl_Obj* tclarrayname = NULL;
00312     Tcl_Obj* tclindexname = NULL;
00313     char msg[SLEN];
00314     char* array=NULL;
00315     char* tempstr=NULL;
00316     int strlen;
00317     int inimgaddr;
00318     IMAGE* inimg=NULL;
00319     int outimgaddr;
00320     IMAGE* outimg=NULL;
00321     char* outname=NULL;
00322     int incr;
00323 
00324     if( argc != 2 ) {
00325         Tcl_AppendResult(interp,"wrong # args: should be \"",
00326         argv[0], " arrayname\"", (char *) NULL);
00327         return TCL_ERROR;
00328     }
00329     array=argv[1];
00330             
00331 
00332     /* Read input image array(inimg,addr) */
00333     tclarrayname = Tcl_NewStringObj(array,-1);
00334     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00335     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00336         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00337         if (strlen <= 0) return TCL_ERROR;
00338         sscanf(tempstr,"%x",&inimgaddr);
00339         inimg = (IMAGE *) inimgaddr;
00340     } else {
00341         return TCL_ERROR;
00342     }   
00343     Tcl_DecrRefCount(tclarrayname);
00344     Tcl_DecrRefCount(tclindexname);
00345         
00346 
00347     /* Read the input integer array(incr) */
00348     tclarrayname = Tcl_NewStringObj(array,-1);
00349     tclindexname = Tcl_NewStringObj("incr",-1);
00350     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00351         if (Tcl_GetIntFromObj(interp,tclobj,&incr) == TCL_ERROR) return TCL_ERROR;
00352     } else {
00353         return TCL_ERROR;
00354     }
00355     Tcl_DecrRefCount(tclarrayname);
00356     Tcl_DecrRefCount(tclindexname);
00357                 
00358 
00359     /* Read the output image 1 name */
00360     tclarrayname = Tcl_NewStringObj(array,-1);
00361     tclindexname = Tcl_NewStringObj("outname",-1);
00362     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00363         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00364         if (strlen <= 0) return TCL_ERROR;
00365     } else {
00366         return TCL_ERROR;
00367     }
00368     Tcl_DecrRefCount(tclarrayname);
00369     Tcl_DecrRefCount(tclindexname);
00370                 
00371 
00372     PCT(inimg,incr,&outimg);
00373             
00374 
00375     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00376     outimgaddr = (int) outimg;
00377                 
00378 
00379     sprintf(msg, "%x", outimgaddr);
00380     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00381             
00382     return TCL_OK;
00383 }
00384 
00385 
00386 
00387 
00388 
00389 
00390 /*-Copyright Information------------------------------------------------------*/
00391 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00392 /*----------------------------------------------------------------------------*/
00393 /*-General Information--------------------------------------------------------*/
00394 /*                                                                            */
00395 /*   This procedure provides an interface to the SADIE function               */
00396 /*   DECORSTR from Tcl/Tk.  It expects a tcl global array                     */
00397 /*   with these indices to exist:                                             */
00398 /*      array(inimg,addr)         --  SADIE image address                     */
00399 /*      array(incr)               --  int                                     */
00400 /*      array(outname)            --  char*                                   */
00401 /*                                                                            */
00402 /*----------------------------------------------------------------------------*/
00403 /*-Interface Information------------------------------------------------------*/
00404 int Sadie_Multi_PCSCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00405 {
00406     Tcl_Obj* tclobj=NULL;
00407     Tcl_Obj* tclarrayname = NULL;
00408     Tcl_Obj* tclindexname = NULL;
00409     char msg[SLEN];
00410     char* array=NULL;
00411     char* tempstr=NULL;
00412     int strlen;
00413     int inimgaddr;
00414     IMAGE* inimg=NULL;
00415     int outimgaddr;
00416     IMAGE* outimg=NULL;
00417     char* outname=NULL;
00418     int incr;
00419 
00420     if( argc != 2 ) {
00421         Tcl_AppendResult(interp,"wrong # args: should be \"",
00422         argv[0], " arrayname\"", (char *) NULL);
00423         return TCL_ERROR;
00424     }
00425     array=argv[1];
00426             
00427 
00428     /* Read input image array(inimg,addr) */
00429     tclarrayname = Tcl_NewStringObj(array,-1);
00430     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00431     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00432         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00433         if (strlen <= 0) return TCL_ERROR;
00434         sscanf(tempstr,"%x",&inimgaddr);
00435         inimg = (IMAGE *) inimgaddr;
00436     } else {
00437         return TCL_ERROR;
00438     }
00439     Tcl_DecrRefCount(tclarrayname);
00440     Tcl_DecrRefCount(tclindexname);
00441                 
00442 
00443     /* Read the input integer array(incr) */
00444     tclarrayname = Tcl_NewStringObj(array,-1);
00445     tclindexname = Tcl_NewStringObj("incr",-1);
00446     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00447         if (Tcl_GetIntFromObj(interp,tclobj,&incr) == TCL_ERROR) return TCL_ERROR;
00448     } else {
00449         return TCL_ERROR;
00450     }
00451     Tcl_DecrRefCount(tclarrayname);
00452     Tcl_DecrRefCount(tclindexname);
00453                 
00454 
00455     /* Read the output image 1 name */
00456     tclarrayname = Tcl_NewStringObj(array,-1);
00457     tclindexname = Tcl_NewStringObj("outname",-1);
00458     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00459         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00460         if (strlen <= 0) return TCL_ERROR;
00461     } else {
00462         return TCL_ERROR;
00463     }
00464     Tcl_DecrRefCount(tclarrayname);
00465     Tcl_DecrRefCount(tclindexname);
00466                 
00467 
00468     DECORSTR(inimg,incr,&outimg);
00469             
00470 
00471     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00472     outimgaddr = (int) outimg;
00473                 
00474 
00475     sprintf(msg, "%x", outimgaddr);
00476     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00477             
00478     return TCL_OK;
00479 }
00480 
00481 
00482 
00483 
00484 
00485 
00486 /*-Copyright Information------------------------------------------------------*/
00487 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00488 /*----------------------------------------------------------------------------*/
00489 /*-General Information--------------------------------------------------------*/
00490 /*                                                                            */
00491 /*   This procedure provides an interface to the SADIE function               */
00492 /*   RGBTOHSV from Tcl/Tk.  It expects a tcl global array                     */
00493 /*   with these indices to exist:                                             */
00494 /*      array(inimg,addr)         --  SADIE image address                     */
00495 /*      array(outname)            --  char*                                   */
00496 /*                                                                            */
00497 /*----------------------------------------------------------------------------*/
00498 /*-Interface Information------------------------------------------------------*/
00499 int Sadie_Multi_RGB2HSVCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00500 {
00501     Tcl_Obj* tclobj=NULL;
00502     Tcl_Obj* tclarrayname = NULL;
00503     Tcl_Obj* tclindexname = NULL;
00504     char msg[SLEN];
00505     char* array=NULL;
00506     char* tempstr=NULL;
00507     int strlen;
00508     int inimgaddr;
00509     IMAGE* inimg=NULL;
00510     int outimgaddr;
00511     IMAGE* outimg=NULL;
00512     char* outname=NULL;
00513 
00514     if( argc != 2 ) {
00515         Tcl_AppendResult(interp,"wrong # args: should be \"",
00516         argv[0], " arrayname\"", (char *) NULL);
00517         return TCL_ERROR;
00518     }
00519     array=argv[1];
00520             
00521 
00522     /* Read input image array(inimg,addr) */
00523     tclarrayname = Tcl_NewStringObj(array,-1);
00524     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00525     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00526         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00527         if (strlen <= 0) return TCL_ERROR;
00528         sscanf(tempstr,"%x",&inimgaddr);
00529         inimg = (IMAGE *) inimgaddr;
00530     } else {
00531         return TCL_ERROR;
00532     }
00533     Tcl_DecrRefCount(tclarrayname);
00534     Tcl_DecrRefCount(tclindexname);
00535                 
00536 
00537     /* Read the output image 1 name */
00538     tclarrayname = Tcl_NewStringObj(array,-1);
00539     tclindexname = Tcl_NewStringObj("outname",-1);
00540     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00541         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00542         if (strlen <= 0) return TCL_ERROR;
00543     } else {
00544         return TCL_ERROR;
00545     }
00546     Tcl_DecrRefCount(tclarrayname);
00547     Tcl_DecrRefCount(tclindexname);
00548                 
00549 
00550     RGBTOHSV(inimg,&outimg);
00551             
00552 
00553     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00554     outimgaddr = (int) outimg;
00555                 
00556 
00557     sprintf(msg, "%x", outimgaddr);
00558     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00559             
00560     return TCL_OK;
00561 }
00562 
00563 
00564 
00565 
00566 
00567 
00568 /*-Copyright Information------------------------------------------------------*/
00569 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00570 /*----------------------------------------------------------------------------*/
00571 /*-General Information--------------------------------------------------------*/
00572 /*                                                                            */
00573 /*   This procedure provides an interface to the SADIE function               */
00574 /*   HSVTORGB from Tcl/Tk.  It expects a tcl global array                     */
00575 /*   with these indices to exist:                                             */
00576 /*      array(inimg,addr)         --  SADIE image address                     */
00577 /*      array(outname)            --  char*                                   */
00578 /*                                                                            */
00579 /*----------------------------------------------------------------------------*/
00580 /*-Interface Information------------------------------------------------------*/
00581 int Sadie_Multi_HSV2RGBCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00582 {
00583     Tcl_Obj* tclobj=NULL;
00584     Tcl_Obj* tclarrayname = NULL;
00585     Tcl_Obj* tclindexname = NULL;
00586     char msg[SLEN];
00587     char* array=NULL;
00588     char* tempstr=NULL;
00589     int strlen;
00590     int inimgaddr;
00591     IMAGE* inimg=NULL;
00592     int outimgaddr;
00593     IMAGE* outimg=NULL;
00594     char* outname=NULL;
00595 
00596     if( argc != 2 ) {
00597         Tcl_AppendResult(interp,"wrong # args: should be \"",
00598         argv[0], " arrayname\"", (char *) NULL);
00599         return TCL_ERROR;
00600     }
00601     array=argv[1];
00602             
00603 
00604     /* Read input image array(inimg,addr) */
00605     tclarrayname = Tcl_NewStringObj(array,-1);
00606     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00607     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00608         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00609         if (strlen <= 0) return TCL_ERROR;
00610         sscanf(tempstr,"%x",&inimgaddr);
00611         inimg = (IMAGE *) inimgaddr;
00612     } else {
00613         return TCL_ERROR;
00614     }
00615     Tcl_DecrRefCount(tclarrayname);
00616     Tcl_DecrRefCount(tclindexname);
00617                 
00618 
00619     /* Read the output image 1 name */
00620     tclarrayname = Tcl_NewStringObj(array,-1);
00621     tclindexname = Tcl_NewStringObj("outname",-1);
00622     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00623         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00624         if (strlen <= 0) return TCL_ERROR;
00625     } else {
00626         return TCL_ERROR;
00627     }
00628     Tcl_DecrRefCount(tclarrayname);
00629     Tcl_DecrRefCount(tclindexname);
00630                 
00631 
00632     HSVTORGB(inimg,&outimg);
00633             
00634 
00635     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00636     outimgaddr = (int) outimg;
00637                 
00638 
00639     sprintf(msg, "%x", outimgaddr);
00640     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00641             
00642     return TCL_OK;
00643 }
00644 
00645 
00646 
00647 
00648 
00649 
00650 /*-Copyright Information------------------------------------------------------*/
00651 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00652 /*----------------------------------------------------------------------------*/
00653 /*-General Information--------------------------------------------------------*/
00654 /*                                                                            */
00655 /*   This procedure provides an interface to the SADIE function               */
00656 /*   BILTOBSQ from Tcl/Tk.  It expects a tcl global array                     */
00657 /*   with these indices to exist:                                             */
00658 /*      array(inimg,addr)         --  SADIE image address                     */
00659 /*      array(outname1)           --  char*                                   */
00660 /*      array(outname2)           --  char*                                   */
00661 /*      array(outname3)           --  char*                                   */
00662 /*                                                                            */
00663 /*----------------------------------------------------------------------------*/
00664 /*-Interface Information------------------------------------------------------*/
00665 int Sadie_Multi_BIL2BSQCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00666 {
00667     Tcl_Obj* tclobj=NULL;
00668     Tcl_Obj* tclarrayname = NULL;
00669     Tcl_Obj* tclindexname = NULL;
00670     char msg[SLEN];
00671     char* array=NULL;
00672     char* tempstr=NULL;
00673     int strlen;
00674     int inimgaddr;
00675     IMAGE* inimg=NULL;
00676     int outimgaddr1, outimgaddr2, outimgaddr3;
00677     IMAGE *outimg[3];
00678     char *outname1=NULL, *outname2=NULL, *outname3=NULL;
00679 
00680     if( argc != 2 ) {
00681         Tcl_AppendResult(interp,"wrong # args: should be \"",
00682         argv[0], " arrayname\"", (char *) NULL);
00683         return TCL_ERROR;
00684     }
00685     array=argv[1];
00686             
00687 
00688     /* Read input image array(inimg,addr) */
00689     tclarrayname = Tcl_NewStringObj(array,-1);
00690     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00691     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00692         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00693         if (strlen <= 0) return TCL_ERROR;
00694         sscanf(tempstr,"%x",&inimgaddr);
00695         inimg = (IMAGE *) inimgaddr;
00696     } else {
00697         return TCL_ERROR;
00698     }
00699     Tcl_DecrRefCount(tclarrayname);
00700     Tcl_DecrRefCount(tclindexname);
00701                 
00702 
00703     /* Read the output image 1 name */
00704     tclarrayname = Tcl_NewStringObj(array,-1);
00705     tclindexname = Tcl_NewStringObj("outname1",-1);
00706     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00707         outname1 = Tcl_GetStringFromObj(tclobj,&strlen);
00708         if (strlen <= 0) return TCL_ERROR;
00709     } else {
00710         return TCL_ERROR;
00711     }
00712     Tcl_DecrRefCount(tclarrayname);
00713     Tcl_DecrRefCount(tclindexname);
00714                 
00715 
00716     /* Read the output image 2 name */
00717     tclarrayname = Tcl_NewStringObj(array,-1);
00718     tclindexname = Tcl_NewStringObj("outname2",-1);
00719     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00720         outname2 = Tcl_GetStringFromObj(tclobj,&strlen);
00721         if (strlen <= 0) return TCL_ERROR;
00722     } else {
00723         return TCL_ERROR;
00724     }
00725     Tcl_DecrRefCount(tclarrayname);
00726     Tcl_DecrRefCount(tclindexname);
00727                 
00728 
00729     /* Read the output image 3 name */
00730     tclarrayname = Tcl_NewStringObj(array,-1);
00731     tclindexname = Tcl_NewStringObj("outname3",-1);
00732     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00733         outname3 = Tcl_GetStringFromObj(tclobj,&strlen);
00734         if (strlen <= 0) return TCL_ERROR;
00735     } else {
00736         return TCL_ERROR;
00737     }
00738     Tcl_DecrRefCount(tclarrayname);
00739     Tcl_DecrRefCount(tclindexname);
00740                 
00741 
00742     BILTOBSQ(inimg,(IMAGE **)&outimg);
00743             
00744 
00745     if (CHECKIMG(outimg[0]))  sprintf(outimg[0]->text, "%s", outname1);
00746     outimgaddr1 = (int) outimg[0];
00747                 
00748 
00749     if (CHECKIMG(outimg[1]))  sprintf(outimg[1]->text, "%s", outname2);
00750     outimgaddr2 = (int) outimg[1];
00751                 
00752 
00753     if (CHECKIMG(outimg[2]))  sprintf(outimg[2]->text, "%s", outname3);
00754     outimgaddr3 = (int) outimg[2];
00755                 
00756 
00757     sprintf(msg, "%x %x %x", outimgaddr1,outimgaddr2,outimgaddr3);
00758     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00759             
00760     return TCL_OK;
00761 }
00762 
00763 
00764 
00765 
00766 
00767 
00768 /*-Copyright Information------------------------------------------------------*/
00769 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00770 /*----------------------------------------------------------------------------*/
00771 /*-General Information--------------------------------------------------------*/
00772 /*                                                                            */
00773 /*   This procedure provides an interface to the SADIE function               */
00774 /*   BSQTOBIL from Tcl/Tk.  It expects a tcl global array                     */
00775 /*   with these indices to exist:                                             */
00776 /*      array(inimg,addr1)        --  SADIE image address                     */
00777 /*      array(inimg,addr2)        --  SADIE image address                     */
00778 /*      array(inimg,addr3)        --  SADIE image address                     */
00779 /*      array(outname)            --  char*                                   */
00780 /*                                                                            */
00781 /*----------------------------------------------------------------------------*/
00782 /*-Interface Information------------------------------------------------------*/
00783 int Sadie_Multi_BSQ2BILCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00784 {
00785     Tcl_Obj* tclobj=NULL;
00786     Tcl_Obj* tclarrayname = NULL;
00787     Tcl_Obj* tclindexname = NULL;
00788     char msg[SLEN];
00789     char* array=NULL;
00790     char* tempstr=NULL;
00791     int strlen;
00792     int inimgaddr1, inimgaddr2, inimgaddr3;
00793     IMAGE* inimg[3];
00794     int outimgaddr;
00795     IMAGE* outimg=NULL;
00796     char* outname=NULL;
00797 
00798     if( argc != 2 ) {
00799         Tcl_AppendResult(interp,"wrong # args: should be \"",
00800         argv[0], " arrayname\"", (char *) NULL);
00801         return TCL_ERROR;
00802     }
00803     array=argv[1];
00804             
00805 
00806     /* Read input image array(inimg,addr1) */
00807     tclarrayname = Tcl_NewStringObj(array,-1);
00808     tclindexname = Tcl_NewStringObj("inimg,addr1",-1);
00809     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00810         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00811         if (strlen <= 0) return TCL_ERROR;
00812         sscanf(tempstr,"%x",&inimgaddr1);
00813         inimg[0] = (IMAGE *) inimgaddr1;
00814     } else {
00815         return TCL_ERROR;
00816     }
00817     Tcl_DecrRefCount(tclarrayname);
00818     Tcl_DecrRefCount(tclindexname);
00819                 
00820 
00821     /* Read input image array(inimg,addr2) */
00822     tclarrayname = Tcl_NewStringObj(array,-1);
00823     tclindexname = Tcl_NewStringObj("inimg,addr2",-1);
00824     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00825         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00826         if (strlen <= 0) return TCL_ERROR;
00827         sscanf(tempstr,"%x",&inimgaddr2);
00828         inimg[1] = (IMAGE *) inimgaddr2;
00829     } else {
00830         return TCL_ERROR;
00831     }
00832     Tcl_DecrRefCount(tclarrayname);
00833     Tcl_DecrRefCount(tclindexname);
00834                 
00835 
00836     /* Read input image array(inimg,addr3) */
00837     tclarrayname = Tcl_NewStringObj(array,-1);
00838     tclindexname = Tcl_NewStringObj("inimg,addr3",-1);
00839     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00840         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00841         if (strlen <= 0) return TCL_ERROR;
00842         sscanf(tempstr,"%x",&inimgaddr3);
00843         inimg[2] = (IMAGE *) inimgaddr3;
00844     } else {
00845         return TCL_ERROR;
00846     }
00847     Tcl_DecrRefCount(tclarrayname);
00848     Tcl_DecrRefCount(tclindexname);
00849                 
00850 
00851     /* Read the output image 1 name */
00852     tclarrayname = Tcl_NewStringObj(array,-1);
00853     tclindexname = Tcl_NewStringObj("outname",-1);
00854     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00855         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00856         if (strlen <= 0) return TCL_ERROR;
00857     } else {
00858         return TCL_ERROR;
00859     }
00860     Tcl_DecrRefCount(tclarrayname);
00861     Tcl_DecrRefCount(tclindexname);
00862                 
00863 
00864     BSQTOBIL(inimg,3,&outimg);
00865             
00866 
00867     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00868     outimgaddr = (int) outimg;
00869                 
00870 
00871     sprintf(msg, "%x", outimgaddr);
00872     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00873             
00874     return TCL_OK;
00875 }
00876 
00877 
00878 
00879 
00880 
00881 
00882 /*-Copyright Information------------------------------------------------------*/
00883 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00884 /*----------------------------------------------------------------------------*/
00885 /*-General Information--------------------------------------------------------*/
00886 /*                                                                            */
00887 /*   This procedure provides an interface to the SADIE function               */
00888 /*   COM2REAL from Tcl/Tk.  It expects a tcl global array                     */
00889 /*   with these indices to exist:                                             */
00890 /*      array(inimg,addr)         --  SADIE image address                     */
00891 /*      array(option)             --  int                                     */
00892 /*      array(outname1)           --  char*                                   */
00893 /*      array(outname2)           --  char*                                   */
00894 /*                                                                            */
00895 /*----------------------------------------------------------------------------*/
00896 /*-Interface Information------------------------------------------------------*/
00897 int Sadie_Multi_Comp2RealCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00898 {
00899     Tcl_Obj* tclobj=NULL;
00900     Tcl_Obj* tclarrayname = NULL;
00901     Tcl_Obj* tclindexname = NULL;
00902     char msg[SLEN];
00903     char* array=NULL;
00904     char* tempstr=NULL;
00905     int strlen;
00906     int inimgaddr;
00907     IMAGE* inimg=NULL;
00908     int outimgaddr1, outimgaddr2;
00909     IMAGE *outimg1=NULL, *outimg2=NULL;
00910     char *outname1=NULL, *outname2=NULL;
00911     int option;
00912 
00913     if( argc != 2 ) {
00914         Tcl_AppendResult(interp,"wrong # args: should be \"",
00915         argv[0], " arrayname\"", (char *) NULL);
00916         return TCL_ERROR;
00917     }
00918     array=argv[1];
00919             
00920 
00921     /* Read input image array(inimg,addr) */
00922     tclarrayname = Tcl_NewStringObj(array,-1);
00923     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00924     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00925         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00926         if (strlen <= 0) return TCL_ERROR;
00927         sscanf(tempstr,"%x",&inimgaddr);
00928         inimg = (IMAGE *) inimgaddr;
00929     } else {
00930         return TCL_ERROR;
00931     }
00932     Tcl_DecrRefCount(tclarrayname);
00933     Tcl_DecrRefCount(tclindexname);
00934 
00935     /* Read the input integer array(option) */
00936     tclarrayname = Tcl_NewStringObj(array,-1);
00937     tclindexname = Tcl_NewStringObj("option",-1);
00938     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00939         if (Tcl_GetIntFromObj(interp,tclobj,&option) == TCL_ERROR) return TCL_ERROR;
00940     } else {
00941         return TCL_ERROR;
00942     }
00943     Tcl_DecrRefCount(tclarrayname);
00944     Tcl_DecrRefCount(tclindexname);
00945     
00946 
00947     /* Read the output image 1 name */
00948     tclarrayname = Tcl_NewStringObj(array,-1);
00949     tclindexname = Tcl_NewStringObj("outname1",-1);
00950     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00951         outname1 = Tcl_GetStringFromObj(tclobj,&strlen);
00952         if (strlen <= 0) return TCL_ERROR;
00953     } else {
00954         return TCL_ERROR;
00955     }
00956     Tcl_DecrRefCount(tclarrayname);
00957     Tcl_DecrRefCount(tclindexname);
00958                 
00959 
00960     /* Read the output image 2 name */
00961     tclarrayname = Tcl_NewStringObj(array,-1);
00962     tclindexname = Tcl_NewStringObj("outname2",-1);
00963     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00964         outname2 = Tcl_GetStringFromObj(tclobj,&strlen);
00965         if (strlen <= 0) return TCL_ERROR;
00966     } else {
00967         return TCL_ERROR;
00968     }
00969     Tcl_DecrRefCount(tclarrayname);
00970     Tcl_DecrRefCount(tclindexname);
00971                 
00972 
00973     COM2REAL(inimg,option,&outimg1,&outimg2);
00974             
00975 
00976     if (CHECKIMG(outimg1))  sprintf(outimg1->text, "%s", outname1);
00977     outimgaddr1 = (int) outimg1;
00978                 
00979 
00980     if (CHECKIMG(outimg2))  sprintf(outimg2->text, "%s", outname2);
00981     outimgaddr2 = (int) outimg2;
00982                 
00983 
00984     sprintf(msg, "%x %x", outimgaddr1,outimgaddr2);
00985     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00986             
00987     return TCL_OK;
00988 }
00989 
00990 
00991 
00992 
00993 
00994 
00995 /*-Copyright Information------------------------------------------------------*/
00996 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00997 /*----------------------------------------------------------------------------*/
00998 /*-General Information--------------------------------------------------------*/
00999 /*                                                                            */
01000 /*   This procedure provides an interface to the SADIE function               */
01001 /*   REAL2COM from Tcl/Tk.  It expects a tcl global array                     */
01002 /*   with these indices to exist:                                             */
01003 /*      array(inimg,addr1)        --  SADIE image address                     */
01004 /*      array(inimg,addr2)        --  SADIE image address                     */
01005 /*      array(option)             --  int                                     */
01006 /*      array(outname)            --  char*                                   */
01007 /*                                                                            */
01008 /*----------------------------------------------------------------------------*/
01009 /*-Interface Information------------------------------------------------------*/
01010 int Sadie_Multi_Real2CompCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01011 {
01012     Tcl_Obj* tclobj=NULL;
01013     Tcl_Obj* tclarrayname = NULL;
01014     Tcl_Obj* tclindexname = NULL;
01015     char msg[SLEN];
01016     char* array=NULL;
01017     char* tempstr=NULL;
01018     int strlen;
01019     int inimgaddr1, inimgaddr2;
01020     IMAGE *inimg1=NULL, *inimg2=NULL;
01021     int outimgaddr;
01022     IMAGE* outimg=NULL;
01023     char* outname=NULL;
01024     int option;
01025 
01026     if( argc != 2 ) {
01027         Tcl_AppendResult(interp,"wrong # args: should be \"",
01028         argv[0], " arrayname\"", (char *) NULL);
01029         return TCL_ERROR;
01030     }
01031     array=argv[1];
01032             
01033 
01034     /* Read input image array(inimg,addr1) */
01035     tclarrayname = Tcl_NewStringObj(array,-1);
01036     tclindexname = Tcl_NewStringObj("inimg,addr1",-1);
01037     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01038         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01039         if (strlen <= 0) return TCL_ERROR;
01040         sscanf(tempstr,"%x",&inimgaddr1);
01041         inimg1 = (IMAGE *) inimgaddr1;
01042     } else {
01043         return TCL_ERROR;
01044     }
01045     Tcl_DecrRefCount(tclarrayname);
01046     Tcl_DecrRefCount(tclindexname);
01047                 
01048 
01049     /* Read input image array(inimg,addr2) */
01050     tclarrayname = Tcl_NewStringObj(array,-1);
01051     tclindexname = Tcl_NewStringObj("inimg,addr2",-1);
01052     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01053         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01054         if (strlen <= 0) return TCL_ERROR;
01055         sscanf(tempstr,"%x",&inimgaddr2);
01056         inimg2 = (IMAGE *) inimgaddr2;
01057     } else {
01058         return TCL_ERROR;
01059     }
01060     Tcl_DecrRefCount(tclarrayname);
01061     Tcl_DecrRefCount(tclindexname);
01062                 
01063 
01064     /* Read the input integer array(option) */
01065     tclarrayname = Tcl_NewStringObj(array,-1);
01066     tclindexname = Tcl_NewStringObj("option",-1);
01067     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01068         if (Tcl_GetIntFromObj(interp,tclobj,&option) == TCL_ERROR) return TCL_ERROR;
01069     } else {
01070         return TCL_ERROR;
01071     }
01072     Tcl_DecrRefCount(tclarrayname);
01073     Tcl_DecrRefCount(tclindexname);
01074                 
01075 
01076     /* Read the output image 1 name */
01077     tclarrayname = Tcl_NewStringObj(array,-1);
01078     tclindexname = Tcl_NewStringObj("outname",-1);
01079     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01080         outname = Tcl_GetStringFromObj(tclobj,&strlen);
01081         if (strlen <= 0) return TCL_ERROR;
01082     } else {
01083         return TCL_ERROR;
01084     }
01085     Tcl_DecrRefCount(tclarrayname);
01086     Tcl_DecrRefCount(tclindexname);
01087                 
01088 
01089     REAL2COM(inimg1,inimg2,option,&outimg);
01090             
01091 
01092     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
01093     outimgaddr = (int) outimg;
01094                 
01095 
01096     sprintf(msg, "%x", outimgaddr);
01097     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01098             
01099     return TCL_OK;
01100 }
01101 
01102 
01103 
01104 
01105 
01106 
01107 /*-Copyright Information------------------------------------------------------*/
01108 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01109 /*----------------------------------------------------------------------------*/
01110 /*-General Information--------------------------------------------------------*/
01111 /*                                                                            */
01112 /*   This procedure provides an interface to the SADIE function               */
01113 /*   ROTATECUBE from Tcl/Tk.  It expects a tcl global array                   */
01114 /*   with these indices to exist:                                             */
01115 /*      array(inimg,addr)         --  SADIE image address                     */
01116 /*      array(x,sign)             --  int                                     */
01117 /*      array(y,sign)             --  int                                     */
01118 /*      array(z,sign)             --  int                                     */
01119 /*      array(x,cubedim)          --  int                                     */
01120 /*      array(y,cubedim)          --  int                                     */
01121 /*      array(z,cubedim)          --  int                                     */
01122 /*      array(outname)            --  char*                                   */
01123 /*                                                                            */
01124 /*----------------------------------------------------------------------------*/
01125 /*-Interface Information------------------------------------------------------*/
01126 int Sadie_Multi_RotateCubeCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01127 {
01128     Tcl_Obj* tclobj=NULL;
01129     Tcl_Obj* tclarrayname = NULL;
01130     Tcl_Obj* tclindexname = NULL;
01131     char msg[SLEN];
01132     char* array=NULL;
01133     char* tempstr=NULL;
01134     int strlen;
01135     int inimgaddr;
01136     IMAGE* inimg=NULL;
01137     int outimgaddr;
01138     IMAGE* outimg=NULL;
01139     char* outname=NULL;
01140     int xdir, ydir, zdir;
01141     int xaxis, yaxis, zaxis;
01142 
01143     if( argc != 2 ) {
01144         Tcl_AppendResult(interp,"wrong # args: should be \"",
01145         argv[0], " arrayname\"", (char *) NULL);
01146         return TCL_ERROR;
01147     }
01148     array=argv[1];    
01149 
01150     /* Read input image array(inimg,addr) */
01151     tclarrayname = Tcl_NewStringObj(array,-1);
01152     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
01153     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01154         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01155         if (strlen <= 0) return TCL_ERROR;
01156         sscanf(tempstr,"%x",&inimgaddr);
01157         inimg = (IMAGE *) inimgaddr;
01158     } else {
01159         return TCL_ERROR;
01160     }
01161     Tcl_DecrRefCount(tclarrayname);
01162     Tcl_DecrRefCount(tclindexname);
01163     
01164     /* Read the input integer array(x,sign) */
01165     tclarrayname = Tcl_NewStringObj(array,-1);
01166     tclindexname = Tcl_NewStringObj("x,sign",-1);
01167     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01168         if (Tcl_GetIntFromObj(interp,tclobj,&xdir) == TCL_ERROR) return TCL_ERROR;
01169     } else {
01170         return TCL_ERROR;
01171     }
01172     Tcl_DecrRefCount(tclarrayname);
01173     Tcl_DecrRefCount(tclindexname);
01174     
01175     /* Read the input integer array(y,sign) */
01176     tclarrayname = Tcl_NewStringObj(array,-1);
01177     tclindexname = Tcl_NewStringObj("y,sign",-1);
01178     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01179         if (Tcl_GetIntFromObj(interp,tclobj,&ydir) == TCL_ERROR) return TCL_ERROR;
01180     } else {
01181         return TCL_ERROR;
01182     }
01183     Tcl_DecrRefCount(tclarrayname);
01184     Tcl_DecrRefCount(tclindexname);
01185 
01186     /* Read the input integer array(z,sign) */
01187     tclarrayname = Tcl_NewStringObj(array,-1);
01188     tclindexname = Tcl_NewStringObj("z,sign",-1);
01189     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01190         if (Tcl_GetIntFromObj(interp,tclobj,&zdir) == TCL_ERROR) return TCL_ERROR;
01191     } else {
01192         return TCL_ERROR;
01193     }
01194     Tcl_DecrRefCount(tclarrayname);
01195     Tcl_DecrRefCount(tclindexname);
01196 
01197     /* Read the input integer array(x,sign) */
01198     tclarrayname = Tcl_NewStringObj(array,-1);
01199     tclindexname = Tcl_NewStringObj("x,cubedim",-1);
01200     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01201         if (Tcl_GetIntFromObj(interp,tclobj,&xaxis) == TCL_ERROR) return TCL_ERROR;
01202     } else {
01203         return TCL_ERROR;
01204     }
01205     Tcl_DecrRefCount(tclarrayname);
01206     Tcl_DecrRefCount(tclindexname);
01207     
01208     /* Read the input integer array(y,sign) */
01209     tclarrayname = Tcl_NewStringObj(array,-1);
01210     tclindexname = Tcl_NewStringObj("y,cubedim",-1);
01211     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01212         if (Tcl_GetIntFromObj(interp,tclobj,&yaxis) == TCL_ERROR) return TCL_ERROR;
01213     } else {
01214         return TCL_ERROR;
01215     }
01216     Tcl_DecrRefCount(tclarrayname);
01217     Tcl_DecrRefCount(tclindexname);
01218 
01219     /* Read the input integer array(z,sign) */
01220     tclarrayname = Tcl_NewStringObj(array,-1);
01221     tclindexname = Tcl_NewStringObj("z,cubedim",-1);
01222     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01223         if (Tcl_GetIntFromObj(interp,tclobj,&zaxis) == TCL_ERROR) return TCL_ERROR;
01224     } else {
01225         return TCL_ERROR;
01226     }
01227     Tcl_DecrRefCount(tclarrayname);
01228     Tcl_DecrRefCount(tclindexname);
01229 
01230         /* Read the output image name */
01231     tclarrayname = Tcl_NewStringObj(array,-1);
01232     tclindexname = Tcl_NewStringObj("outname",-1);
01233     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01234         outname = Tcl_GetStringFromObj(tclobj,&strlen);
01235         if (strlen <= 0) return TCL_ERROR;
01236     } else {
01237         return TCL_ERROR;
01238     }
01239     Tcl_DecrRefCount(tclarrayname);
01240     Tcl_DecrRefCount(tclindexname);
01241 
01242     ROTATECUBE (inimg,xdir,ydir,zdir,xaxis,yaxis,zaxis,&outimg);
01243     
01244 
01245     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
01246     outimgaddr = (int) outimg;
01247 
01248 
01249     sprintf(msg, "%x", outimgaddr);
01250     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01251             
01252     return TCL_OK;
01253 }
01254 
01255 
01256 
01257 
01258 
01259 /*-Copyright Information------------------------------------------------------*/
01260 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01261 /*----------------------------------------------------------------------------*/
01262 /*-General Information--------------------------------------------------------*/
01263 /*                                                                            */
01264 /*   This procedure initializes the all of the procedures                     */
01265 /*   in this file by registering them with Tcl.                               */
01266 /*                                                                            */
01267 /*----------------------------------------------------------------------------*/
01268 /*-Interface Information------------------------------------------------------*/
01269 int Sadie_Multi_Init(Tcl_Interp *interp)
01270 {
01271     Tcl_CreateCommand(interp, "Sadie_Multi_Combine", Sadie_Multi_CombineCmd,(ClientData) NULL, NULL);
01272     Tcl_CreateCommand(interp, "Sadie_Multi_Compare", Sadie_Multi_CompareCmd,(ClientData) NULL, NULL);
01273     Tcl_CreateCommand(interp, "Sadie_Multi_PCT", Sadie_Multi_PCTCmd,(ClientData) NULL, NULL);
01274     Tcl_CreateCommand(interp, "Sadie_Multi_PCS", Sadie_Multi_PCSCmd,(ClientData) NULL, NULL);
01275     Tcl_CreateCommand(interp, "Sadie_Multi_RGB2HSV", Sadie_Multi_RGB2HSVCmd,(ClientData) NULL, NULL);
01276     Tcl_CreateCommand(interp, "Sadie_Multi_HSV2RGB", Sadie_Multi_HSV2RGBCmd,(ClientData) NULL, NULL);
01277     Tcl_CreateCommand(interp, "Sadie_Multi_BIL2BSQ", Sadie_Multi_BIL2BSQCmd,(ClientData) NULL, NULL);
01278     Tcl_CreateCommand(interp, "Sadie_Multi_BSQ2BIL", Sadie_Multi_BSQ2BILCmd,(ClientData) NULL, NULL);
01279     Tcl_CreateCommand(interp, "Sadie_Multi_Comp2Real", Sadie_Multi_Comp2RealCmd,(ClientData) NULL, NULL);
01280     Tcl_CreateCommand(interp, "Sadie_Multi_Real2Comp", Sadie_Multi_Real2CompCmd,(ClientData) NULL, NULL);
01281     Tcl_CreateCommand(interp, "Sadie_Multi_RotateCube", Sadie_Multi_RotateCubeCmd,(ClientData) NULL, NULL);
01282     return TCL_OK;
01283 }
01284