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