Sadie_Proto.c Source File

00001 /*
00002 ##########################################
00003 # Sadie_Proto.c -
00004 #   Set of routines for linking SADIE prototype routines to tcl/tk.
00005 #
00006 # RCS: $Id: Sadie_Proto.c,v 1.5 1999/05/24 21:54:51 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 "sadie.h"
00017 #include "proto.h"
00018 
00019 /* RCS Indentification information */
00020 static char rcsid[] = "$Id: Sadie_Proto.c,v 1.5 1999/05/24 21:54:51 conner Exp $";
00021 
00022 
00023 /*-------------------------------------------------------------*/
00024 /* Global Sadie variables that must be set from within Tcl/Tk  */
00025 /*-------------------------------------------------------------*/
00026 extern  short   nlev;
00027 extern  short   csize;
00028 extern  double  weight;
00029 extern  double  *count;
00030 extern  PIXEL   gain;
00031 extern  PIXEL   bias;
00032 extern  PIXEL   gmin;
00033 extern  PIXEL   gmax;
00034 extern  PIXEL   thresh;
00035 extern  PIXEL   gbrk[2][4];
00036 extern  PIXEL   *table;
00037  
00038 /* -------------------------------------------------------------------------- */
00039 
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 /*   IMG2ASCII from Tcl/Tk.  It expects a tcl global array                    */
00050 /*   with these indices to exist:                                             */
00051 /*      array(inimg,addr)         --  SADIE image address                     */
00052 /*                                                                            */
00053 /*----------------------------------------------------------------------------*/
00054 /*-Interface Information------------------------------------------------------*/
00055 int Sadie_Proto_Img2AsciiCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00056 {  
00057     Tcl_Obj* tclobj=NULL;
00058     Tcl_Obj* tclarrayname = NULL;
00059     Tcl_Obj* tclindexname = NULL;
00060     char msg[SLEN];
00061     char* array=NULL;
00062     char* tempstr=NULL;
00063     int strlen;
00064     int inimgaddr;
00065     IMAGE* inimg=NULL;
00066  
00067     if( argc != 2 ) {
00068         Tcl_AppendResult(interp,"wrong # args: should be \"",
00069         argv[0], " arrayname\"", (char *) NULL);
00070         return TCL_ERROR;
00071     }
00072     array=argv[1];
00073             
00074     /* Read input image array(inimg,addr) */
00075     tclarrayname = Tcl_NewStringObj(array,-1);
00076     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00077     if (tclobj = Tcl_ObjGetVar2(interp, tclarrayname, tclindexname, TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00078         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00079         if (strlen <= 0) return TCL_ERROR;
00080         sscanf(tempstr,"%x",&inimgaddr);
00081         inimg = (IMAGE *) inimgaddr;
00082     } else {
00083         return TCL_ERROR;
00084     }
00085     Tcl_DecrRefCount(tclarrayname);
00086     Tcl_DecrRefCount(tclindexname);
00087 
00088     IMG2ASCII(inimg);
00089   
00090     return TCL_OK;
00091 
00092 }  
00093 
00094 
00095 
00096 /*-Copyright Information------------------------------------------------------*/
00097 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00098 /*----------------------------------------------------------------------------*/
00099 /*-General Information--------------------------------------------------------*/
00100 /*                                                                            */
00101 /*   This procedure provides an interface to the SADIE function               */
00102 /*   BINGRID from Tcl/Tk.  It expects a tcl global array                      */
00103 /*   with these indices to exist:                                             */
00104 /*      array(inimg,addr)         --  SADIE image address                     */
00105 /*      array(outname)            --  char*                                   */
00106 /*                                                                            */
00107 /*----------------------------------------------------------------------------*/
00108 /*-Interface Information------------------------------------------------------*/
00109 int Sadie_Proto_BinGridCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00110 {  
00111     Tcl_Obj* tclobj=NULL;
00112     Tcl_Obj* tclarrayname = NULL;
00113     Tcl_Obj* tclindexname = NULL;
00114     char msg[SLEN];
00115     char* array=NULL;
00116     char* tempstr=NULL;
00117     int strlen;
00118     int inimgaddr;
00119     IMAGE* inimg=NULL;
00120     int outimgaddr;
00121     IMAGE* outimg=NULL;
00122     char* outname=NULL;
00123 
00124     if( argc != 2 ) {
00125         Tcl_AppendResult(interp,"wrong # args: should be \"",
00126         argv[0], " arrayname\"", (char *) NULL);
00127         return TCL_ERROR;
00128     }
00129     array=argv[1];
00130             
00131 
00132     /* Read input image array(inimg,addr) */
00133     tclarrayname = Tcl_NewStringObj(array,-1);
00134     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00135     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00136 
00137 
00138         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00139         if (strlen <= 0) return TCL_ERROR;
00140         sscanf(tempstr,"%x",&inimgaddr);
00141         inimg = (IMAGE *) inimgaddr;
00142     } else {
00143         return TCL_ERROR;
00144     }
00145     Tcl_DecrRefCount(tclarrayname);
00146     Tcl_DecrRefCount(tclindexname);
00147                 
00148 
00149     /* Read the output image 1 name */
00150     tclarrayname = Tcl_NewStringObj(array,-1);
00151     tclindexname = Tcl_NewStringObj("outname",-1);
00152     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00153 
00154 
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     BINGRID(inimg, &outimg);
00165 
00166     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00167 
00168     outimgaddr = (int) outimg;
00169     sprintf(msg, "%x", outimgaddr);
00170     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00171   
00172     return TCL_OK;
00173 
00174 }  
00175 
00176 
00177 
00178 /*-Copyright Information------------------------------------------------------*/
00179 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00180 /*----------------------------------------------------------------------------*/
00181 /*-General Information--------------------------------------------------------*/
00182 /*                                                                            */
00183 /*   This procedure provides an interface to the SADIE function               */
00184 /*   SECTOR from Tcl/Tk.  It expects a tcl global array                       */
00185 /*   with these indices to exist:                                             */
00186 /*      array(inimg,addr)         --  SADIE image address                     */
00187 /*      array(outname)            --  char*                                   */
00188 /*                                                                            */
00189 /*----------------------------------------------------------------------------*/
00190 /*-Interface Information------------------------------------------------------*/
00191 int Sadie_Proto_SectorCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00192 {  
00193     Tcl_Obj* tclobj=NULL;
00194     Tcl_Obj* tclarrayname = NULL;
00195     Tcl_Obj* tclindexname = NULL;
00196     char msg[SLEN];
00197     char* array=NULL;
00198     char* tempstr=NULL;
00199     int strlen;
00200     int inimgaddr;
00201     IMAGE* inimg=NULL;
00202     int outimgaddr;
00203     IMAGE* outimg=NULL;
00204     char* outname=NULL;
00205 
00206     if( argc != 2 ) {
00207         Tcl_AppendResult(interp,"wrong # args: should be \"",
00208         argv[0], " arrayname\"", (char *) NULL);
00209         return TCL_ERROR;
00210     }
00211     array=argv[1];
00212             
00213 
00214     /* Read input image array(inimg,addr) */
00215     tclarrayname = Tcl_NewStringObj(array,-1);
00216     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00217     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00218 
00219 
00220         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00221         if (strlen <= 0) return TCL_ERROR;
00222         sscanf(tempstr,"%x",&inimgaddr);
00223         inimg = (IMAGE *) inimgaddr;
00224     } else {
00225         return TCL_ERROR;
00226     }
00227     Tcl_DecrRefCount(tclarrayname);
00228     Tcl_DecrRefCount(tclindexname);
00229                 
00230 
00231     /* Read the output image 1 name */
00232     tclarrayname = Tcl_NewStringObj(array,-1);
00233     tclindexname = Tcl_NewStringObj("outname",-1);
00234     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00235 
00236 
00237         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00238         if (strlen <= 0) return TCL_ERROR;
00239     } else {
00240         return TCL_ERROR;
00241     }   
00242     Tcl_DecrRefCount(tclarrayname);
00243     Tcl_DecrRefCount(tclindexname);
00244         
00245 
00246     SECTOR(inimg, &outimg);
00247 
00248     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00249 
00250     outimgaddr = (int) outimg;
00251     sprintf(msg, "%x", outimgaddr);
00252     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00253   
00254     return TCL_OK;
00255 
00256 }  
00257 
00258 
00259 /*-Copyright Information------------------------------------------------------*/
00260 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00261 /*----------------------------------------------------------------------------*/
00262 /*-General Information--------------------------------------------------------*/
00263 /*                                                                            */
00264 /*   This procedure provides an interface to the SADIE function               */
00265 /*   SECTOR8 from Tcl/Tk.  It expects a tcl global array                      */
00266 /*   with these indices to exist:                                             */
00267 /*      array(inimg,addr)         --  SADIE image address                     */
00268 /*      array(outname)            --  char*                                   */
00269 /*                                                                            */
00270 /*----------------------------------------------------------------------------*/
00271 /*-Interface Information------------------------------------------------------*/
00272 int Sadie_Proto_Sector8Cmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00273 {  
00274     Tcl_Obj* tclobj=NULL;
00275     Tcl_Obj* tclarrayname = NULL;
00276     Tcl_Obj* tclindexname = NULL;
00277     char msg[SLEN];
00278     char* array=NULL;
00279     char* tempstr=NULL;
00280     int strlen;
00281     int inimgaddr;
00282     IMAGE* inimg=NULL;
00283     int outimgaddr;
00284     IMAGE* outimg=NULL;
00285     char* outname=NULL;
00286 
00287     if( argc != 2 ) {
00288         Tcl_AppendResult(interp,"wrong # args: should be \"",
00289         argv[0], " arrayname\"", (char *) NULL);
00290         return TCL_ERROR;
00291     }
00292     array=argv[1];
00293             
00294 
00295     /* Read input image array(inimg,addr) */
00296     tclarrayname = Tcl_NewStringObj(array,-1);
00297     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00298     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00299 
00300 
00301         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00302         if (strlen <= 0) return TCL_ERROR;
00303         sscanf(tempstr,"%x",&inimgaddr);
00304         inimg = (IMAGE *) inimgaddr;
00305     } else {
00306         return TCL_ERROR;
00307     }
00308     Tcl_DecrRefCount(tclarrayname);
00309     Tcl_DecrRefCount(tclindexname);
00310                 
00311 
00312     /* Read the output image 1 name */
00313     tclarrayname = Tcl_NewStringObj(array,-1);
00314     tclindexname = Tcl_NewStringObj("outname",-1);
00315     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00316 
00317 
00318         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00319         if (strlen <= 0) return TCL_ERROR;
00320     } else {
00321         return TCL_ERROR;
00322     }   
00323     Tcl_DecrRefCount(tclarrayname);
00324     Tcl_DecrRefCount(tclindexname);
00325         
00326 
00327     SECTOR8(inimg, &outimg);
00328 
00329     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00330 
00331     outimgaddr = (int) outimg;
00332     sprintf(msg, "%x", outimgaddr);
00333     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00334   
00335     return TCL_OK;
00336 
00337 }  
00338 
00339 
00340 
00341 /*-Copyright Information------------------------------------------------------*/
00342 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00343 /*----------------------------------------------------------------------------*/
00344 /*-General Information--------------------------------------------------------*/
00345 /*                                                                            */
00346 /*   This procedure provides an interface to the SADIE function               */
00347 /*   ISOLATE from Tcl/Tk.  It expects a tcl global array                      */
00348 /*   with these indices to exist:                                             */
00349 /*      array(inimg,addr)         --  SADIE image address                     */
00350 /*      array(value)              --  double                                  */
00351 /*      array(outname)            --  char*                                   */
00352 /*                                                                            */
00353 /*----------------------------------------------------------------------------*/
00354 /*-Interface Information------------------------------------------------------*/
00355 int Sadie_Proto_IsolateCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00356 {  
00357     Tcl_Obj* tclobj=NULL;
00358     Tcl_Obj* tclarrayname = NULL;
00359     Tcl_Obj* tclindexname = NULL;
00360     char msg[SLEN];
00361     char* array=NULL;
00362     char* tempstr=NULL;
00363     int strlen;
00364     int inimgaddr;
00365     IMAGE* inimg=NULL;
00366     int outimgaddr;
00367     IMAGE* outimg=NULL;
00368     char* outname=NULL;
00369     double value;
00370 
00371     if( argc != 2 ) {
00372         Tcl_AppendResult(interp,"wrong # args: should be \"",
00373         argv[0], " arrayname\"", (char *) NULL);
00374         return TCL_ERROR;
00375     }
00376     array=argv[1];
00377             
00378 
00379     /* Read input image array(inimg,addr) */
00380     tclarrayname = Tcl_NewStringObj(array,-1);
00381     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00382     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00383         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00384         if (strlen <= 0) return TCL_ERROR;
00385         sscanf(tempstr,"%x",&inimgaddr);
00386         inimg = (IMAGE *) inimgaddr;
00387     } else {
00388         return TCL_ERROR;
00389     }
00390     Tcl_DecrRefCount(tclarrayname);
00391     Tcl_DecrRefCount(tclindexname);
00392                 
00393 
00394     /* Read the input integer array(value) */
00395     tclarrayname = Tcl_NewStringObj(array,-1);
00396     tclindexname = Tcl_NewStringObj("value",-1);
00397     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00398         if (Tcl_GetDoubleFromObj(interp,tclobj,&value) == TCL_ERROR) return TCL_ERROR;
00399     } else {
00400         return TCL_ERROR;
00401     }
00402     Tcl_DecrRefCount(tclarrayname);
00403     Tcl_DecrRefCount(tclindexname);
00404                 
00405 
00406     /* Read the output image 1 name */
00407     tclarrayname = Tcl_NewStringObj(array,-1);
00408     tclindexname = Tcl_NewStringObj("outname",-1);
00409     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00410         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00411         if (strlen <= 0) return TCL_ERROR;
00412     } else {
00413         return TCL_ERROR;
00414     }
00415     Tcl_DecrRefCount(tclarrayname);
00416     Tcl_DecrRefCount(tclindexname);
00417                 
00418 
00419     ISOLATE(inimg,value,&outimg);
00420             
00421 
00422     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00423     outimgaddr = (int) outimg;
00424                 
00425 
00426     sprintf(msg, "%x", outimgaddr);
00427     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00428             
00429     return TCL_OK;
00430 }  
00431 
00432 
00433 
00434 
00435 
00436 
00437 /*-Copyright Information------------------------------------------------------*/
00438 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00439 /*----------------------------------------------------------------------------*/
00440 /*-General Information--------------------------------------------------------*/
00441 /*                                                                            */
00442 /*   This procedure provides an interface to the SADIE function               */
00443 /*   SIZEFILTER from Tcl/Tk.  It expects a tcl global array                   */
00444 /*   with these indices to exist:                                             */
00445 /*      array(inimg,addr)         --  SADIE image address                     */
00446 /*      array(thresh)                --  int                                  */
00447 /*      array(outname)            --  char*                                   */
00448 /*                                                                            */
00449 /*----------------------------------------------------------------------------*/
00450 /*-Interface Information------------------------------------------------------*/
00451 int Sadie_Proto_SizeThreshCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00452 {  
00453     Tcl_Obj* tclobj=NULL;
00454     Tcl_Obj* tclarrayname = NULL;
00455     Tcl_Obj* tclindexname = NULL;
00456     char msg[SLEN];
00457     char* array=NULL;
00458     char* tempstr=NULL;
00459     int strlen;
00460     int inimgaddr;
00461     IMAGE* inimg=NULL;
00462     int outimgaddr;
00463     IMAGE* outimg=NULL;
00464     char* outname=NULL;
00465     int thresh;
00466 
00467     if( argc != 2 ) {
00468         Tcl_AppendResult(interp,"wrong # args: should be \"",
00469         argv[0], " arrayname\"", (char *) NULL);
00470         return TCL_ERROR;
00471     }
00472     array=argv[1];
00473             
00474 
00475     /* Read input image array(inimg,addr) */
00476     tclarrayname = Tcl_NewStringObj(array,-1);
00477     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00478     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00479         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00480         if (strlen <= 0) return TCL_ERROR;
00481         sscanf(tempstr,"%x",&inimgaddr);
00482         inimg = (IMAGE *) inimgaddr;
00483     } else {
00484         return TCL_ERROR;
00485     }
00486     Tcl_DecrRefCount(tclarrayname);
00487     Tcl_DecrRefCount(tclindexname);
00488                 
00489 
00490     /* Read the input integer array(thresh) */
00491     tclarrayname = Tcl_NewStringObj(array,-1);
00492     tclindexname = Tcl_NewStringObj("thresh",-1);
00493     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00494         if (Tcl_GetIntFromObj(interp,tclobj,&thresh) == TCL_ERROR) return TCL_ERROR;
00495     } else {
00496         return TCL_ERROR;
00497     }
00498     Tcl_DecrRefCount(tclarrayname);
00499     Tcl_DecrRefCount(tclindexname);
00500                 
00501 
00502     /* Read the output image 1 name */
00503     tclarrayname = Tcl_NewStringObj(array,-1);
00504     tclindexname = Tcl_NewStringObj("outname",-1);
00505     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00506         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00507         if (strlen <= 0) return TCL_ERROR;
00508     } else {
00509         return TCL_ERROR;
00510     }
00511     Tcl_DecrRefCount(tclarrayname);
00512     Tcl_DecrRefCount(tclindexname);
00513                 
00514 
00515     SIZEFILTER(inimg,thresh,&outimg);
00516             
00517 
00518     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00519     outimgaddr = (int) outimg;
00520                 
00521 
00522     sprintf(msg, "%x", outimgaddr);
00523     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00524             
00525     return TCL_OK;
00526 }  
00527 
00528 
00529 
00530 /*-Copyright Information------------------------------------------------------*/
00531 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00532 /*----------------------------------------------------------------------------*/
00533 /*-General Information--------------------------------------------------------*/
00534 /*                                                                            */
00535 /*   This procedure provides an interface to the SADIE function               */
00536 /*   CREATEGAUSS from Tcl/Tk.  It expects a tcl global array                  */
00537 /*   with these indices to exist:                                             */
00538 /*      array(size)               --  int                                     */
00539 /*      array(sigma)              --  double                                  */
00540 /*      array(outname)            --  char*                                   */
00541 /*                                                                            */
00542 /*----------------------------------------------------------------------------*/
00543 /*-Interface Information------------------------------------------------------*/
00544 int Sadie_Proto_CreateGaussCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00545 {  
00546     Tcl_Obj* tclobj=NULL;
00547     Tcl_Obj* tclarrayname = NULL;
00548     Tcl_Obj* tclindexname = NULL;
00549     char msg[SLEN];
00550     char* array=NULL;
00551     char* tempstr=NULL;
00552     int strlen;
00553     int outimgaddr;
00554     IMAGE* outimg=NULL;
00555     char* outname=NULL;
00556     double sigma;
00557     int size;
00558 
00559     if( argc != 2 ) {
00560         Tcl_AppendResult(interp,"wrong # args: should be \"",
00561         argv[0], " arrayname\"", (char *) NULL);
00562         return TCL_ERROR;
00563     }
00564     array=argv[1];
00565             
00566 
00567     /* Read the input integer array(size) */
00568     tclarrayname = Tcl_NewStringObj(array,-1);
00569     tclindexname = Tcl_NewStringObj("size",-1);
00570     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00571         if (Tcl_GetIntFromObj(interp,tclobj,&size) == TCL_ERROR) return TCL_ERROR;
00572     } else {
00573         return TCL_ERROR;
00574     }
00575     Tcl_DecrRefCount(tclarrayname);
00576     Tcl_DecrRefCount(tclindexname);
00577                 
00578 
00579     /* Read the input integer array(sigma) */
00580     tclarrayname = Tcl_NewStringObj(array,-1);
00581     tclindexname = Tcl_NewStringObj("sigma",-1);
00582     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00583         if (Tcl_GetDoubleFromObj(interp,tclobj,&sigma) == TCL_ERROR) return TCL_ERROR;
00584     } else {
00585         return TCL_ERROR;
00586     }
00587     Tcl_DecrRefCount(tclarrayname);
00588     Tcl_DecrRefCount(tclindexname);
00589                 
00590 
00591     /* Read the output image 1 name */
00592     tclarrayname = Tcl_NewStringObj(array,-1);
00593     tclindexname = Tcl_NewStringObj("outname",-1);
00594     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00595         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00596         if (strlen <= 0) return TCL_ERROR;
00597     } else {
00598         return TCL_ERROR;
00599     }
00600     Tcl_DecrRefCount(tclarrayname);
00601     Tcl_DecrRefCount(tclindexname);
00602                 
00603 
00604     CREATEGAUSS(size,sigma,&outimg);
00605             
00606 
00607     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00608     outimgaddr = (int) outimg;
00609                 
00610 
00611     sprintf(msg, "%x", outimgaddr);
00612     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00613             
00614     return TCL_OK;
00615 }  
00616 
00617 
00618 
00619 /*-Copyright Information------------------------------------------------------*/
00620 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00621 /*----------------------------------------------------------------------------*/
00622 /*-General Information--------------------------------------------------------*/
00623 /*                                                                            */
00624 /*   This procedure provides an interface to the SADIE function               */
00625 /*   NONMAXSUPRX from Tcl/Tk.  It expects a tcl global array                      */
00626 /*   with these indices to exist:                                             */
00627 /*      array(inimg,addr)         --  SADIE image address                     */
00628 /*      array(outname)            --  char*                                   */
00629 /*                                                                            */
00630 /*----------------------------------------------------------------------------*/
00631 /*-Interface Information------------------------------------------------------*/
00632 int Sadie_Proto_NonMaxSuppressXCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00633 {  
00634     Tcl_Obj* tclobj=NULL;
00635     Tcl_Obj* tclarrayname = NULL;
00636     Tcl_Obj* tclindexname = NULL;
00637     char msg[SLEN];
00638     char* array=NULL;
00639     char* tempstr=NULL;
00640     int strlen;
00641     int inimgaddr;
00642     IMAGE* inimg=NULL;
00643     int outimgaddr;
00644     IMAGE* outimg=NULL;
00645     char* outname=NULL;
00646 
00647     if( argc != 2 ) {
00648         Tcl_AppendResult(interp,"wrong # args: should be \"",
00649         argv[0], " arrayname\"", (char *) NULL);
00650         return TCL_ERROR;
00651     }
00652     array=argv[1];
00653             
00654 
00655     /* Read input image array(inimg,addr) */
00656     tclarrayname = Tcl_NewStringObj(array,-1);
00657     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00658     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00659 
00660 
00661         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00662         if (strlen <= 0) return TCL_ERROR;
00663         sscanf(tempstr,"%x",&inimgaddr);
00664         inimg = (IMAGE *) inimgaddr;
00665     } else {
00666         return TCL_ERROR;
00667     }
00668     Tcl_DecrRefCount(tclarrayname);
00669     Tcl_DecrRefCount(tclindexname);
00670                 
00671 
00672     /* Read the output image 1 name */
00673     tclarrayname = Tcl_NewStringObj(array,-1);
00674     tclindexname = Tcl_NewStringObj("outname",-1);
00675     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00676 
00677 
00678         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00679         if (strlen <= 0) return TCL_ERROR;
00680     } else {
00681         return TCL_ERROR;
00682     }   
00683     Tcl_DecrRefCount(tclarrayname);
00684     Tcl_DecrRefCount(tclindexname);
00685         
00686 
00687     NONMAXSUPRX(inimg, &outimg);
00688 
00689     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00690 
00691     outimgaddr = (int) outimg;
00692     sprintf(msg, "%x", outimgaddr);
00693     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00694   
00695     return TCL_OK;
00696 }  
00697 
00698 
00699 
00700 
00701 /*-Copyright Information------------------------------------------------------*/
00702 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00703 /*----------------------------------------------------------------------------*/
00704 /*-General Information--------------------------------------------------------*/
00705 /*                                                                            */
00706 /*   This procedure provides an interface to the SADIE function               */
00707 /*   CANNY from Tcl/Tk.  It expects a tcl global array                        */
00708 /*   with these indices to exist:                                             */
00709 /*      array(inimg,addr)         --  SADIE image address                     */
00710 /*      array(size)               --  int                                     */
00711 /*      array(sigma)              --  double                                  */
00712 /*      array(outname)            --  char*                                   */
00713 /*                                                                            */
00714 /*----------------------------------------------------------------------------*/
00715 /*-Interface Information------------------------------------------------------*/
00716 int Sadie_Proto_CannyCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00717 {  
00718     Tcl_Obj* tclobj=NULL;
00719     Tcl_Obj* tclarrayname = NULL;
00720     Tcl_Obj* tclindexname = NULL;
00721     char msg[SLEN];
00722     char* array=NULL;
00723     char* tempstr=NULL;
00724     int strlen;
00725     int inimgaddr;
00726     IMAGE* inimg=NULL;
00727     int outimgaddr;
00728     IMAGE* outimg=NULL;
00729     char* outname=NULL;
00730     int size;
00731     double sigma;
00732     
00733     if( argc != 2 ) {
00734         Tcl_AppendResult(interp,"wrong # args: should be \"",
00735         argv[0], " arrayname\"", (char *) NULL);
00736         return TCL_ERROR;
00737     }
00738     array=argv[1];
00739             
00740 
00741     /* Read input image array(inimg,addr) */
00742     tclarrayname = Tcl_NewStringObj(array,-1);
00743     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00744     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00745         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00746         if (strlen <= 0) return TCL_ERROR;
00747         sscanf(tempstr,"%x",&inimgaddr);
00748         inimg = (IMAGE *) inimgaddr;
00749     } else {
00750         return TCL_ERROR;
00751     }
00752     Tcl_DecrRefCount(tclarrayname);
00753     Tcl_DecrRefCount(tclindexname);
00754                 
00755 
00756     /* Read the input integer array(size) */
00757     tclarrayname = Tcl_NewStringObj(array,-1);
00758     tclindexname = Tcl_NewStringObj("size",-1);
00759     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00760         if (Tcl_GetIntFromObj(interp,tclobj,&size) == TCL_ERROR) return TCL_ERROR;
00761     } else {
00762         return TCL_ERROR;
00763     }
00764     Tcl_DecrRefCount(tclarrayname);
00765     Tcl_DecrRefCount(tclindexname);
00766                 
00767 
00768     /* Read the input integer array(sigma) */
00769     tclarrayname = Tcl_NewStringObj(array,-1);
00770     tclindexname = Tcl_NewStringObj("sigma",-1);
00771     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00772         if (Tcl_GetDoubleFromObj(interp,tclobj,&sigma) == TCL_ERROR) return TCL_ERROR;
00773     } else {
00774         return TCL_ERROR;
00775     }
00776     Tcl_DecrRefCount(tclarrayname);
00777     Tcl_DecrRefCount(tclindexname);
00778                 
00779 
00780     /* Read the output image 1 name */
00781     tclarrayname = Tcl_NewStringObj(array,-1);
00782     tclindexname = Tcl_NewStringObj("outname",-1);
00783     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00784         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00785         if (strlen <= 0) return TCL_ERROR;
00786     } else {
00787         return TCL_ERROR;
00788     }
00789     Tcl_DecrRefCount(tclarrayname);
00790     Tcl_DecrRefCount(tclindexname);
00791                 
00792 
00793     CANNY(inimg, sigma, size, &outimg);
00794             
00795 
00796     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00797     outimgaddr = (int) outimg;
00798                 
00799 
00800     sprintf(msg, "%x", outimgaddr);
00801     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00802             
00803     return TCL_OK;
00804 }  
00805 
00806 
00807 /*-Copyright Information------------------------------------------------------*/
00808 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00809 /*----------------------------------------------------------------------------*/
00810 /*-General Information--------------------------------------------------------*/
00811 /*                                                                            */
00812 /*   This procedure provides an interface to the SADIE function               */
00813 /*   CMPLBL8 from Tcl/Tk.  It expects a tcl global array                      */
00814 /*   with these indices to exist:                                             */
00815 /*      array(inimg,addr)         --  SADIE image address                     */
00816 /*      array(outname)            --  char*                                   */
00817 /*                                                                            */
00818 /*----------------------------------------------------------------------------*/
00819 /*-Interface Information------------------------------------------------------*/
00820 int Sadie_Proto_CCL8Cmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00821 {  
00822     Tcl_Obj* tclobj=NULL;
00823     Tcl_Obj* tclarrayname = NULL;
00824     Tcl_Obj* tclindexname = NULL;
00825     char msg[SLEN];
00826     char* array=NULL;
00827     char* tempstr=NULL;
00828     int strlen;
00829     int inimgaddr;
00830     IMAGE* inimg=NULL;
00831     int outimgaddr;
00832     IMAGE* outimg=NULL;
00833     char* outname=NULL;
00834 
00835     if( argc != 2 ) {
00836         Tcl_AppendResult(interp,"wrong # args: should be \"",
00837         argv[0], " arrayname\"", (char *) NULL);
00838         return TCL_ERROR;
00839     }
00840     array=argv[1];
00841             
00842 
00843     /* Read input image array(inimg,addr) */
00844     tclarrayname = Tcl_NewStringObj(array,-1);
00845     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00846     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00847 
00848 
00849         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00850         if (strlen <= 0) return TCL_ERROR;
00851         sscanf(tempstr,"%x",&inimgaddr);
00852         inimg = (IMAGE *) inimgaddr;
00853     } else {
00854         return TCL_ERROR;
00855     }
00856     Tcl_DecrRefCount(tclarrayname);
00857     Tcl_DecrRefCount(tclindexname);
00858                 
00859 
00860     /* Read the output image 1 name */
00861     tclarrayname = Tcl_NewStringObj(array,-1);
00862     tclindexname = Tcl_NewStringObj("outname",-1);
00863     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00864 
00865 
00866         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00867         if (strlen <= 0) return TCL_ERROR;
00868     } else {
00869         return TCL_ERROR;
00870     }   
00871     Tcl_DecrRefCount(tclarrayname);
00872     Tcl_DecrRefCount(tclindexname);
00873         
00874 
00875     CMPLBL8(inimg, &outimg);
00876 
00877     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00878 
00879     outimgaddr = (int) outimg;
00880     sprintf(msg, "%x", outimgaddr);
00881     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00882   
00883     return TCL_OK;
00884 
00885 }  
00886 
00887 
00888 
00889 /*-Copyright Information------------------------------------------------------*/
00890 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00891 /*----------------------------------------------------------------------------*/
00892 /*-General Information--------------------------------------------------------*/
00893 /*                                                                            */
00894 /*   This procedure provides an interface to the SADIE function               */
00895 /*   CHAINCODE from Tcl/Tk.  It expects a tcl global array                    */
00896 /*   with these indices to exist:                                             */
00897 /*      array(inimg,addr)         --  SADIE image address                     */
00898 /*      array(outname)            --  char*                                   */
00899 /*                                                                            */
00900 /*----------------------------------------------------------------------------*/
00901 /*-Interface Information------------------------------------------------------*/
00902 int Sadie_Proto_ChainCodeCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00903 {  
00904     Tcl_Obj* tclobj=NULL;
00905     Tcl_Obj* tclarrayname = NULL;
00906     Tcl_Obj* tclindexname = NULL;
00907     char msg[SLEN];
00908     char* array=NULL;
00909     char* tempstr=NULL;
00910     int strlen;
00911     int inimgaddr;
00912     IMAGE* inimg=NULL;
00913     int outimgaddr;
00914     IMAGE* outimg=NULL;
00915     char* outname=NULL;
00916 
00917     if( argc != 2 ) {
00918         Tcl_AppendResult(interp,"wrong # args: should be \"",
00919         argv[0], " arrayname\"", (char *) NULL);
00920         return TCL_ERROR;
00921     }
00922     array=argv[1];
00923             
00924 
00925     /* Read input image array(inimg,addr) */
00926     tclarrayname = Tcl_NewStringObj(array,-1);
00927     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00928     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00929 
00930 
00931         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00932         if (strlen <= 0) return TCL_ERROR;
00933         sscanf(tempstr,"%x",&inimgaddr);
00934         inimg = (IMAGE *) inimgaddr;
00935     } else {
00936         return TCL_ERROR;
00937     }
00938     Tcl_DecrRefCount(tclarrayname);
00939     Tcl_DecrRefCount(tclindexname);
00940                 
00941 
00942     /* Read the output image 1 name */
00943     tclarrayname = Tcl_NewStringObj(array,-1);
00944     tclindexname = Tcl_NewStringObj("outname",-1);
00945     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00946 
00947 
00948         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00949         if (strlen <= 0) return TCL_ERROR;
00950     } else {
00951         return TCL_ERROR;
00952     }   
00953     Tcl_DecrRefCount(tclarrayname);
00954     Tcl_DecrRefCount(tclindexname);
00955         
00956 
00957     CHAINCODE(inimg, &outimg);
00958 
00959     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00960 
00961     outimgaddr = (int) outimg;
00962     sprintf(msg, "%x", outimgaddr);
00963     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00964   
00965     return TCL_OK;
00966 }  
00967 
00968 
00969 /*-Copyright Information------------------------------------------------------*/
00970 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00971 /*----------------------------------------------------------------------------*/
00972 /*-General Information--------------------------------------------------------*/
00973 /*                                                                            */
00974 /*   This procedure provides an interface to the SADIE function               */
00975 /*   FOURIERDESC from Tcl/Tk.  It expects a tcl global array                  */
00976 /*   with these indices to exist:                                             */
00977 /*      array(inimg,addr)         --  SADIE image address                     */
00978 /*                                                                            */
00979 /*----------------------------------------------------------------------------*/
00980 /*-Interface Information------------------------------------------------------*/
00981 int Sadie_Proto_FourierDescCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00982 {  
00983     Tcl_Obj* tclobj=NULL;
00984     Tcl_Obj* tclarrayname = NULL;
00985     Tcl_Obj* tclindexname = NULL;
00986     char msg[SLEN];
00987     char* array=NULL;
00988     char* tempstr=NULL;
00989     int strlen;
00990     int inimgaddr;
00991     IMAGE* inimg=NULL;
00992  
00993     if( argc != 2 ) {
00994         Tcl_AppendResult(interp,"wrong # args: should be \"",
00995         argv[0], " arrayname\"", (char *) NULL);
00996         return TCL_ERROR;
00997     }
00998     array=argv[1];
00999             
01000     /* Read input image array(inimg,addr) */
01001     tclarrayname = Tcl_NewStringObj(array,-1);
01002     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
01003     if (tclobj = Tcl_ObjGetVar2(interp, tclarrayname, tclindexname, TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01004         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01005         if (strlen <= 0) return TCL_ERROR;
01006         sscanf(tempstr,"%x",&inimgaddr);
01007         inimg = (IMAGE *) inimgaddr;
01008     } else {
01009         return TCL_ERROR;
01010     }
01011     Tcl_DecrRefCount(tclarrayname);
01012     Tcl_DecrRefCount(tclindexname);
01013 
01014     FOURIERDESC(inimg);
01015   
01016     return TCL_OK;
01017 }  
01018 
01019 
01020 
01021 /*-Copyright Information------------------------------------------------------*/
01022 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01023 /*----------------------------------------------------------------------------*/
01024 /*-General Information--------------------------------------------------------*/
01025 /*                                                                            */
01026 /*   This procedure provides an interface to the SADIE function               */
01027 /*   HOUGH from Tcl/Tk.  It expects a tcl global array                        */
01028 /*   with these indices to exist:                                             */
01029 /*      array(inimg,addr)         --  SADIE image address                     */
01030 /*      array(thresh)             --  int                                     */
01031 /*      array(rhobins)            --  int                                     */
01032 /*      array(thetabins)          --  int                                     */
01033 /*      array(outname1)           --  char*                                   */
01034 /*      array(outname2)           --  char*                                   */
01035 /*                                                                            */
01036 /*----------------------------------------------------------------------------*/
01037 /*-Interface Information------------------------------------------------------*/
01038 int Sadie_Proto_HoughCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01039 {  
01040     Tcl_Obj* tclobj=NULL;
01041     Tcl_Obj* tclarrayname = NULL;
01042     Tcl_Obj* tclindexname = NULL;
01043     char msg[SLEN];
01044     char* array=NULL;
01045     char* tempstr=NULL;
01046     int strlen;
01047     int inimgaddr;
01048     IMAGE* inimg=NULL;
01049     int outimgaddr1, outimgaddr2;
01050     IMAGE *outimg1=NULL, *outimg2=NULL;
01051     char *outname1=NULL, *outname2;
01052     int thresh, rhobins, thetabins;
01053 
01054     if( argc != 2 ) {
01055         Tcl_AppendResult(interp,"wrong # args: should be \"",
01056         argv[0], " arrayname\"", (char *) NULL);
01057         return TCL_ERROR;
01058     }
01059     array=argv[1];
01060             
01061 
01062     /* Read input image array(inimg,addr) */
01063     tclarrayname = Tcl_NewStringObj(array,-1);
01064     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
01065     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01066         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01067         if (strlen <= 0) return TCL_ERROR;
01068         sscanf(tempstr,"%x",&inimgaddr);
01069         inimg = (IMAGE *) inimgaddr;
01070     } else {
01071         return TCL_ERROR;
01072     }
01073     Tcl_DecrRefCount(tclarrayname);
01074     Tcl_DecrRefCount(tclindexname);
01075                 
01076 
01077     /* Read the input integer array(thresh) */
01078     tclarrayname = Tcl_NewStringObj(array,-1);
01079     tclindexname = Tcl_NewStringObj("thresh",-1);
01080     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01081         if (Tcl_GetIntFromObj(interp,tclobj,&thresh) == TCL_ERROR) return TCL_ERROR;
01082     } else {
01083         return TCL_ERROR;
01084     }
01085     Tcl_DecrRefCount(tclarrayname);
01086     Tcl_DecrRefCount(tclindexname);
01087                 
01088 
01089     /* Read the input integer array(rhobins) */
01090     tclarrayname = Tcl_NewStringObj(array,-1);
01091     tclindexname = Tcl_NewStringObj("rhobins",-1);
01092     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01093         if (Tcl_GetIntFromObj(interp,tclobj,&rhobins) == TCL_ERROR) return TCL_ERROR;
01094     } else {
01095         return TCL_ERROR;
01096     }
01097     Tcl_DecrRefCount(tclarrayname);
01098     Tcl_DecrRefCount(tclindexname);
01099                 
01100 
01101     /* Read the input integer array(thetabins) */
01102     tclarrayname = Tcl_NewStringObj(array,-1);
01103     tclindexname = Tcl_NewStringObj("thetabins",-1);
01104     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01105         if (Tcl_GetIntFromObj(interp,tclobj,&thetabins) == TCL_ERROR) return TCL_ERROR;
01106     } else {
01107         return TCL_ERROR;
01108     }
01109     Tcl_DecrRefCount(tclarrayname);
01110     Tcl_DecrRefCount(tclindexname);
01111                 
01112 
01113     /* Read the output image 1 name */
01114     tclarrayname = Tcl_NewStringObj(array,-1);
01115     tclindexname = Tcl_NewStringObj("outname1",-1);
01116     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01117         outname1 = Tcl_GetStringFromObj(tclobj,&strlen);
01118         if (strlen <= 0) return TCL_ERROR;
01119     } else {
01120         return TCL_ERROR;
01121     }
01122     Tcl_DecrRefCount(tclarrayname);
01123     Tcl_DecrRefCount(tclindexname);
01124                 
01125 
01126     /* Read the output image 2 name */
01127     tclarrayname = Tcl_NewStringObj(array,-1);
01128     tclindexname = Tcl_NewStringObj("outname2",-1);
01129     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01130         outname2 = Tcl_GetStringFromObj(tclobj,&strlen);
01131         if (strlen <= 0) return TCL_ERROR;
01132     } else {
01133         return TCL_ERROR;
01134     }
01135     Tcl_DecrRefCount(tclarrayname);
01136     Tcl_DecrRefCount(tclindexname);
01137                 
01138 
01139     HOUGH(inimg, thresh, rhobins, thetabins, &outimg1, &outimg2);
01140             
01141 
01142     if (CHECKIMG(outimg1))  sprintf(outimg1->text, "%s", outname1);
01143     outimgaddr1 = (int) outimg1;
01144                 
01145     if (CHECKIMG(outimg2))  sprintf(outimg2->text, "%s", outname2);
01146     outimgaddr2 = (int) outimg2;
01147                 
01148 
01149     sprintf(msg, "%x %x", outimgaddr1, outimgaddr2);
01150     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01151             
01152     return TCL_OK;
01153 }  
01154 
01155 
01156 
01157 
01158 /*-Copyright Information------------------------------------------------------*/
01159 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01160 /*----------------------------------------------------------------------------*/
01161 /*-General Information--------------------------------------------------------*/
01162 /*                                                                            */
01163 /*   This procedure provides an interface to the SADIE function               */
01164 /*   PERIODOGRAM from Tcl/Tk.  It expects a tcl global array                  */
01165 /*   with these indices to exist:                                             */
01166 /*      array(inimg,addr)         --  SADIE image address                     */
01167 /*      array(outname)            --  char*                                   */
01168 /*                                                                            */
01169 /*----------------------------------------------------------------------------*/
01170 /*-Interface Information------------------------------------------------------*/
01171 int Sadie_Proto_PeriodogramCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01172 {  
01173     Tcl_Obj* tclobj=NULL;
01174     Tcl_Obj* tclarrayname = NULL;
01175     Tcl_Obj* tclindexname = NULL;
01176     char msg[SLEN];
01177     char* array=NULL;
01178     char* tempstr=NULL;
01179     int strlen;
01180     int inimgaddr;
01181     IMAGE* inimg=NULL;
01182     int outimgaddr;
01183     IMAGE* outimg=NULL;
01184     char* outname=NULL;
01185 
01186     if( argc != 2 ) {
01187         Tcl_AppendResult(interp,"wrong # args: should be \"",
01188         argv[0], " arrayname\"", (char *) NULL);
01189         return TCL_ERROR;
01190     }
01191     array=argv[1];
01192             
01193 
01194     /* Read input image array(inimg,addr) */
01195     tclarrayname = Tcl_NewStringObj(array,-1);
01196     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
01197     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01198 
01199 
01200         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01201         if (strlen <= 0) return TCL_ERROR;
01202         sscanf(tempstr,"%x",&inimgaddr);
01203         inimg = (IMAGE *) inimgaddr;
01204     } else {
01205         return TCL_ERROR;
01206     }
01207     Tcl_DecrRefCount(tclarrayname);
01208     Tcl_DecrRefCount(tclindexname);
01209                 
01210 
01211     /* Read the output image 1 name */
01212     tclarrayname = Tcl_NewStringObj(array,-1);
01213     tclindexname = Tcl_NewStringObj("outname",-1);
01214     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01215 
01216 
01217         outname = Tcl_GetStringFromObj(tclobj,&strlen);
01218         if (strlen <= 0) return TCL_ERROR;
01219     } else {
01220         return TCL_ERROR;
01221     }   
01222     Tcl_DecrRefCount(tclarrayname);
01223     Tcl_DecrRefCount(tclindexname);
01224         
01225 
01226     PERIODOGRAM(inimg, &outimg);
01227 
01228     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
01229 
01230     outimgaddr = (int) outimg;
01231     sprintf(msg, "%x", outimgaddr);
01232     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01233   
01234     return TCL_OK;
01235 }  
01236 
01237 
01238 /*-Copyright Information------------------------------------------------------*/
01239 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01240 /*----------------------------------------------------------------------------*/
01241 /*-General Information--------------------------------------------------------*/
01242 /*                                                                            */
01243 /*   This procedure provides an interface to the SADIE function               */
01244 /*   FINDBESTFOCUS from Tcl/Tk.  It expects a tcl global array                */
01245 /*   with these indices to exist:                                             */
01246 /*      array(inimg,addr[1-nimg]) --  SADIE image address                     */
01247 /*      array(nimg)               --  int                                   */
01248 /*                                                                            */
01249 /*----------------------------------------------------------------------------*/
01250 /*-Interface Information------------------------------------------------------*/
01251 int Sadie_Proto_FindBestFocusCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01252 {  
01253     Tcl_Obj* tclobj=NULL;
01254     Tcl_Obj* tclarrayname = NULL;
01255     Tcl_Obj* tclindexname = NULL;
01256     char msg[SLEN];
01257     char* array=NULL;
01258     char* tempstr=NULL;
01259     int strlen;
01260     int inimgaddr;
01261     IMAGE **inimg=NULL;
01262     int i, nimg, best;
01263 
01264     if( argc != 2 ) {
01265         Tcl_AppendResult(interp,"wrong # args: should be \"",
01266         argv[0], " arrayname\"", (char *) NULL);
01267         return TCL_ERROR;
01268     }
01269     array=argv[1];
01270                 
01271 
01272     /* Read the input integer array(nimg) */
01273     tclarrayname = Tcl_NewStringObj(array,-1);
01274     tclindexname = Tcl_NewStringObj("nimg",-1);
01275     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01276         if (Tcl_GetIntFromObj(interp,tclobj,&nimg) == TCL_ERROR) return TCL_ERROR;
01277     } else {
01278         return TCL_ERROR;
01279     }
01280     Tcl_DecrRefCount(tclarrayname);
01281     Tcl_DecrRefCount(tclindexname);
01282 
01283 
01284     inimg = (IMAGE **) malloc(nimg * sizeof(IMAGE *));
01285     
01286     /* Read input image array(inimg,addr[1-nimg]) */
01287     for (i=0; i<nimg; i++) {
01288         tclarrayname = Tcl_NewStringObj(array,-1);
01289         sprintf(msg,"inimg,addr%d",i+1);
01290         tclindexname = Tcl_NewStringObj(msg,-1);
01291         if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01292             tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01293             if (strlen <= 0) return TCL_ERROR;
01294             sscanf(tempstr,"%x",&inimgaddr);
01295             inimg[i] = (IMAGE *) inimgaddr;
01296         } else {
01297             return TCL_ERROR;
01298         }
01299         Tcl_DecrRefCount(tclarrayname);
01300         Tcl_DecrRefCount(tclindexname);
01301     }
01302 
01303 
01304     FINDBESTFOCUS(inimg,nimg,&best);
01305     printf("best focus = %d\n",best);
01306 
01307     sprintf(msg, "%d", best);
01308     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01309     
01310     if (inimg) free(inimg);
01311 
01312     return TCL_OK;
01313 }  
01314 
01315 
01316 
01317 
01318 /*-Copyright Information------------------------------------------------------*/
01319 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01320 /*----------------------------------------------------------------------------*/
01321 /*-General Information--------------------------------------------------------*/
01322 /*                                                                            */
01323 /*   This procedure provides an interface to the SADIE function               */
01324 /*   COLOR_OVERLAY from Tcl/Tk.  It expects a tcl global array                */
01325 /*   with these indices to exist:                                             */
01326 /*      array(inimg,addr)         --  SADIE image address                     */
01327 /*      array(binimg,addr)        --  SADIE image address                     */
01328 /*      array(color)              --  int                                     */
01329 /*      array(outname)            --  char*                                   */
01330 /*                                                                            */
01331 /*----------------------------------------------------------------------------*/
01332 /*-Interface Information------------------------------------------------------*/
01333 int Sadie_Proto_ColorOverlayCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01334 {
01335     Tcl_Obj* tclobj=NULL;
01336     Tcl_Obj* tclarrayname = NULL;
01337     Tcl_Obj* tclindexname = NULL;
01338     char msg[SLEN];
01339     char* array=NULL;
01340     char* tempstr=NULL;
01341     int strlen;
01342     int inimgaddr, binimgaddr;
01343     IMAGE *inimg=NULL, *binimg=NULL;
01344     int outimgaddr;
01345     IMAGE* outimg=NULL;
01346     char* outname=NULL;
01347     int color;
01348 
01349     if( argc != 2 ) {
01350         Tcl_AppendResult(interp,"wrong # args: should be \"",
01351         argv[0], " arrayname\"", (char *) NULL);
01352         return TCL_ERROR;
01353     }
01354     array=argv[1];
01355             
01356 
01357     /* Read input image array(inimg,addr) */
01358     tclarrayname = Tcl_NewStringObj(array,-1);
01359     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
01360     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01361         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01362         if (strlen <= 0) return TCL_ERROR;
01363         sscanf(tempstr,"%x",&inimgaddr);
01364         inimg = (IMAGE *) inimgaddr;
01365     } else {
01366         return TCL_ERROR;
01367     }
01368     Tcl_DecrRefCount(tclarrayname);
01369     Tcl_DecrRefCount(tclindexname);
01370                 
01371 
01372     /* Read input image array(binimg,addr) */
01373     tclarrayname = Tcl_NewStringObj(array,-1);
01374     tclindexname = Tcl_NewStringObj("binimg,addr",-1);
01375     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01376         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01377         if (strlen <= 0) return TCL_ERROR;
01378         sscanf(tempstr,"%x",&binimgaddr);
01379         binimg = (IMAGE *) binimgaddr;
01380     } else {
01381         return TCL_ERROR;
01382     }
01383     Tcl_DecrRefCount(tclarrayname);
01384     Tcl_DecrRefCount(tclindexname);
01385                 
01386 
01387     /* Read the input integer array(color) */
01388     tclarrayname = Tcl_NewStringObj(array,-1);
01389     tclindexname = Tcl_NewStringObj("color",-1);
01390     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01391         if (Tcl_GetIntFromObj(interp,tclobj,&color) == TCL_ERROR) return TCL_ERROR;
01392     } else {
01393         return TCL_ERROR;
01394     }
01395     Tcl_DecrRefCount(tclarrayname);
01396     Tcl_DecrRefCount(tclindexname);
01397                 
01398 
01399     /* Read the output image 1 name */
01400     tclarrayname = Tcl_NewStringObj(array,-1);
01401     tclindexname = Tcl_NewStringObj("outname",-1);
01402     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01403         outname = Tcl_GetStringFromObj(tclobj,&strlen);
01404         if (strlen <= 0) return TCL_ERROR;
01405     } else {
01406         return TCL_ERROR;
01407     }
01408     Tcl_DecrRefCount(tclarrayname);
01409     Tcl_DecrRefCount(tclindexname);
01410                 
01411 
01412     COLOR_OVERLAY(inimg, binimg, color, &outimg);
01413             
01414 
01415     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
01416     outimgaddr = (int) outimg;
01417                 
01418 
01419     sprintf(msg, "%x", outimgaddr);
01420     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01421             
01422     return TCL_OK;
01423 }
01424 
01425 
01426 
01427 
01428 
01429 /*-Copyright Information------------------------------------------------------*/
01430 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01431 /*----------------------------------------------------------------------------*/
01432 /*-General Information--------------------------------------------------------*/
01433 /*                                                                            */
01434 /*   This procedure provides an interface to the SADIE function               */
01435 /*   TREERINGMAG from Tcl/Tk.  It expects a tcl global array                  */
01436 /*   with these indices to exist:                                             */
01437 /*      array(inimg,addr)         --  SADIE image address                     */
01438 /*      array(size)               --  int                                     */
01439 /*      array(sigma)              --  double                                  */
01440 /*      array(outname)            --  char*                                   */
01441 /*                                                                            */
01442 /*----------------------------------------------------------------------------*/
01443 /*-Interface Information------------------------------------------------------*/
01444 int Sadie_Proto_TreeRingCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01445 {  
01446     Tcl_Obj* tclobj=NULL;
01447     Tcl_Obj* tclarrayname = NULL;
01448     Tcl_Obj* tclindexname = NULL;
01449     char msg[SLEN];
01450     char* array=NULL;
01451     char* tempstr=NULL;
01452     int strlen;
01453     int inimgaddr;
01454     IMAGE* inimg=NULL;
01455     int outimgaddr;
01456     IMAGE* outimg=NULL;
01457     char* outname=NULL;
01458     int size;
01459     double sigma;
01460     
01461     if( argc != 2 ) {
01462         Tcl_AppendResult(interp,"wrong # args: should be \"",
01463         argv[0], " arrayname\"", (char *) NULL);
01464         return TCL_ERROR;
01465     }
01466     array=argv[1];
01467             
01468 
01469     /* Read input image array(inimg,addr) */
01470     tclarrayname = Tcl_NewStringObj(array,-1);
01471     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
01472     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01473         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01474         if (strlen <= 0) return TCL_ERROR;
01475         sscanf(tempstr,"%x",&inimgaddr);
01476         inimg = (IMAGE *) inimgaddr;
01477     } else {
01478         return TCL_ERROR;
01479     }
01480     Tcl_DecrRefCount(tclarrayname);
01481     Tcl_DecrRefCount(tclindexname);
01482                 
01483 
01484     /* Read the input integer array(size) */
01485     tclarrayname = Tcl_NewStringObj(array,-1);
01486     tclindexname = Tcl_NewStringObj("size",-1);
01487     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01488         if (Tcl_GetIntFromObj(interp,tclobj,&size) == TCL_ERROR) return TCL_ERROR;
01489     } else {
01490         return TCL_ERROR;
01491     }
01492     Tcl_DecrRefCount(tclarrayname);
01493     Tcl_DecrRefCount(tclindexname);
01494                 
01495 
01496     /* Read the input integer array(sigma) */
01497     tclarrayname = Tcl_NewStringObj(array,-1);
01498     tclindexname = Tcl_NewStringObj("sigma",-1);
01499     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01500         if (Tcl_GetDoubleFromObj(interp,tclobj,&sigma) == TCL_ERROR) return TCL_ERROR;
01501     } else {
01502         return TCL_ERROR;
01503     }
01504     Tcl_DecrRefCount(tclarrayname);
01505     Tcl_DecrRefCount(tclindexname);
01506                 
01507 
01508     /* Read the output image 1 name */
01509     tclarrayname = Tcl_NewStringObj(array,-1);
01510     tclindexname = Tcl_NewStringObj("outname",-1);
01511     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01512         outname = Tcl_GetStringFromObj(tclobj,&strlen);
01513         if (strlen <= 0) return TCL_ERROR;
01514     } else {
01515         return TCL_ERROR;
01516     }
01517     Tcl_DecrRefCount(tclarrayname);
01518     Tcl_DecrRefCount(tclindexname);
01519                 
01520 
01521     TREERINGMAG(inimg, sigma, size, &outimg);
01522             
01523 
01524     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
01525     outimgaddr = (int) outimg;
01526                 
01527 
01528     sprintf(msg, "%x", outimgaddr);
01529     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01530             
01531     return TCL_OK;
01532 }  
01533 
01534 
01535 /*-Copyright Information------------------------------------------------------*/
01536 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01537 /*----------------------------------------------------------------------------*/
01538 /*-General Information--------------------------------------------------------*/
01539 /*                                                                            */
01540 /*   This procedure provides an interface to the SADIE function               */
01541 /*   LINK_DOUBLETHRESH from Tcl/Tk.  It expects a tcl global array            */
01542 /*   with these indices to exist:                                             */
01543 /*      array(thresh1,addr)       --  SADIE image address                     */
01544 /*      array(thresh2,addr)       --  SADIE image address                     */
01545 /*      array(maxlinkdist)        --  int                                     */
01546 /*      array(outlinksname)       --  char*                                   */
01547 /*      array(outedgesname)       --  char*                                   */
01548 /*                                                                            */
01549 /*----------------------------------------------------------------------------*/
01550 /*-Interface Information------------------------------------------------------*/
01551 int Sadie_Proto_LinkDoubleThreshCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01552 {
01553     Tcl_Obj* tclobj=NULL;
01554     Tcl_Obj* tclarrayname = NULL;
01555     Tcl_Obj* tclindexname = NULL;
01556     char msg[SLEN];
01557     char* array=NULL;
01558     char* tempstr=NULL;
01559     int strlen;
01560     int thresh1addr, thresh2addr;
01561     IMAGE *thresh1=NULL, *thresh2=NULL;
01562     int outlinksaddr, outedgesaddr;
01563     IMAGE *outlinks=NULL, *outedges=NULL;
01564     char *outlinksname=NULL, *outedgesname=NULL;
01565     int maxlinkdist;
01566 
01567     if( argc != 2 ) {
01568         Tcl_AppendResult(interp,"wrong # args: should be \"",
01569         argv[0], " arrayname\"", (char *) NULL);
01570         return TCL_ERROR;
01571     }
01572     array=argv[1];
01573             
01574 
01575     /* Read input image array(thresh1,addr) */
01576     tclarrayname = Tcl_NewStringObj(array,-1);
01577     tclindexname = Tcl_NewStringObj("thresh1,addr",-1);
01578     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01579         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01580         if (strlen <= 0) return TCL_ERROR;
01581         sscanf(tempstr,"%x",&thresh1addr);
01582         thresh1 = (IMAGE *) thresh1addr;
01583     } else {
01584         return TCL_ERROR;
01585     }
01586     Tcl_DecrRefCount(tclarrayname);
01587     Tcl_DecrRefCount(tclindexname);
01588                 
01589 
01590     /* Read input image array(thresh2,addr) */
01591     tclarrayname = Tcl_NewStringObj(array,-1);
01592     tclindexname = Tcl_NewStringObj("thresh2,addr",-1);
01593     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01594         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01595         if (strlen <= 0) return TCL_ERROR;
01596         sscanf(tempstr,"%x",&thresh2addr);
01597         thresh2 = (IMAGE *) thresh2addr;
01598     } else {
01599         return TCL_ERROR;
01600     }
01601     Tcl_DecrRefCount(tclarrayname);
01602     Tcl_DecrRefCount(tclindexname);
01603                 
01604 
01605     /* Read the input integer array(maxlinkdist) */
01606     tclarrayname = Tcl_NewStringObj(array,-1);
01607     tclindexname = Tcl_NewStringObj("maxlinkdist",-1);
01608     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01609         if (Tcl_GetIntFromObj(interp,tclobj,&maxlinkdist) == TCL_ERROR) return TCL_ERROR;
01610     } else {
01611         return TCL_ERROR;
01612     }
01613     Tcl_DecrRefCount(tclarrayname);
01614     Tcl_DecrRefCount(tclindexname);
01615 
01616 
01617     /* Read the output image 1 name */
01618     tclarrayname = Tcl_NewStringObj(array,-1);
01619     tclindexname = Tcl_NewStringObj("outlinksname",-1);
01620     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01621         outlinksname = Tcl_GetStringFromObj(tclobj,&strlen);
01622         if (strlen <= 0) return TCL_ERROR;
01623     } else {
01624         return TCL_ERROR;
01625     }
01626     Tcl_DecrRefCount(tclarrayname);
01627     Tcl_DecrRefCount(tclindexname);
01628                 
01629 
01630     /* Read the output image 2 name */
01631     tclarrayname = Tcl_NewStringObj(array,-1);
01632     tclindexname = Tcl_NewStringObj("outedgesname",-1);
01633     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01634         outedgesname = Tcl_GetStringFromObj(tclobj,&strlen);
01635         if (strlen <= 0) return TCL_ERROR;
01636     } else {
01637         return TCL_ERROR;
01638     }
01639     Tcl_DecrRefCount(tclarrayname);
01640     Tcl_DecrRefCount(tclindexname);
01641                 
01642 
01643     LINK_DOUBLETHRESH(thresh1, thresh2, maxlinkdist, &outlinks, &outedges);
01644             
01645 
01646     if (CHECKIMG(outlinks))  sprintf(outlinks->text, "%s", outlinksname);
01647     outlinksaddr = (int) outlinks;
01648     if (CHECKIMG(outedges))  sprintf(outedges->text, "%s", outedgesname);
01649     outedgesaddr = (int) outedges;
01650                 
01651 
01652     sprintf(msg, "%x %x", outlinksaddr, outedgesaddr);
01653     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01654             
01655     return TCL_OK;
01656 }
01657 
01658 
01659 
01660 /*-Copyright Information------------------------------------------------------*/
01661 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01662 /*----------------------------------------------------------------------------*/
01663 /*-General Information--------------------------------------------------------*/
01664 /*                                                                            */
01665 /*   This procedure provides an interface to the SADIE function               */
01666 /*   LINK_TREERINGS from Tcl/Tk.  It expects a tcl global array               */
01667 /*   with these indices to exist:                                             */
01668 /*      array(input,addr)         --  SADIE image address                     */
01669 /*      array(discardedges)       --  int                                     */
01670 /*      array(outlinksname)       --  char*                                   */
01671 /*      array(outedgesname)       --  char*                                   */
01672 /*                                                                            */
01673 /*----------------------------------------------------------------------------*/
01674 /*-Interface Information------------------------------------------------------*/
01675 int Sadie_Proto_LinkTreeRingsCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01676 {  
01677     Tcl_Obj* tclobj=NULL;
01678     Tcl_Obj* tclarrayname = NULL;
01679     Tcl_Obj* tclindexname = NULL;
01680     char msg[SLEN];
01681     char* array=NULL;
01682     char* tempstr=NULL;
01683     int strlen;
01684     int inputaddr;
01685     IMAGE *inimg=NULL;
01686     int outlinksaddr, outedgesaddr;
01687     IMAGE *outlinks=NULL, *outedges=NULL;
01688     char *outlinksname=NULL, *outedgesname=NULL;
01689     int discardedges;
01690 
01691     if( argc != 2 ) {
01692         Tcl_AppendResult(interp,"wrong # args: should be \"",
01693         argv[0], " arrayname\"", (char *) NULL);
01694         return TCL_ERROR;
01695     }
01696     array=argv[1];
01697             
01698 
01699     /* Read input image array(input,addr) */
01700     tclarrayname = Tcl_NewStringObj(array,-1);
01701     tclindexname = Tcl_NewStringObj("input,addr",-1);
01702     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01703         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01704         if (strlen <= 0) return TCL_ERROR;
01705         sscanf(tempstr,"%x",&inputaddr);
01706         inimg = (IMAGE *) inputaddr;
01707     } else {
01708         return TCL_ERROR;
01709     }
01710     Tcl_DecrRefCount(tclarrayname);
01711     Tcl_DecrRefCount(tclindexname);
01712                 
01713 
01714     /* Read the input integer array(discardedges) */
01715     tclarrayname = Tcl_NewStringObj(array,-1);
01716     tclindexname = Tcl_NewStringObj("discardedges",-1);
01717     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01718         if (Tcl_GetIntFromObj(interp,tclobj,&discardedges) == TCL_ERROR) return TCL_ERROR;
01719     } else {
01720         return TCL_ERROR;
01721     }
01722     Tcl_DecrRefCount(tclarrayname);
01723     Tcl_DecrRefCount(tclindexname);
01724 
01725 
01726     /* Read the output image 1 name */
01727     tclarrayname = Tcl_NewStringObj(array,-1);
01728     tclindexname = Tcl_NewStringObj("outlinksname",-1);
01729     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01730         outlinksname = Tcl_GetStringFromObj(tclobj,&strlen);
01731         if (strlen <= 0) return TCL_ERROR;
01732     } else {
01733         return TCL_ERROR;
01734     }
01735     Tcl_DecrRefCount(tclarrayname);
01736     Tcl_DecrRefCount(tclindexname);
01737                 
01738 
01739     /* Read the output image 2 name */
01740     tclarrayname = Tcl_NewStringObj(array,-1);
01741     tclindexname = Tcl_NewStringObj("outedgesname",-1);
01742     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01743         outedgesname = Tcl_GetStringFromObj(tclobj,&strlen);
01744         if (strlen <= 0) return TCL_ERROR;
01745     } else {
01746         return TCL_ERROR;
01747     }
01748     Tcl_DecrRefCount(tclarrayname);
01749     Tcl_DecrRefCount(tclindexname);
01750                 
01751 
01752     LINK_TREERINGS(inimg, discardedges, &outlinks, &outedges);
01753             
01754 
01755     if (CHECKIMG(outlinks))  sprintf(outlinks->text, "%s", outlinksname);
01756     outlinksaddr = (int) outlinks;
01757     if (CHECKIMG(outedges))  sprintf(outedges->text, "%s", outedgesname);
01758     outedgesaddr = (int) outedges;
01759                 
01760 
01761     sprintf(msg, "%x %x", outlinksaddr, outedgesaddr);
01762     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01763             
01764     return TCL_OK;
01765 }  
01766 
01767 
01768 /*-Copyright Information------------------------------------------------------*/
01769 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01770 /*----------------------------------------------------------------------------*/
01771 /*-General Information--------------------------------------------------------*/
01772 /*                                                                            */
01773 /*   This procedure provides an interface to the SADIE function               */
01774 /*   TREERING_DETECT from Tcl/Tk.  It expects a tcl global array              */
01775 /*   with these indices to exist:                                             */
01776 /*      array(inimg,addr)         --  SADIE image address                     */
01777 /*      array(outname)            --  char*                                   */
01778 /*                                                                            */
01779 /*----------------------------------------------------------------------------*/
01780 /*-Interface Information------------------------------------------------------*/
01781 int Sadie_Proto_Detect_TreeRingsCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01782 {  
01783     Tcl_Obj* tclobj=NULL;
01784     Tcl_Obj* tclarrayname = NULL;
01785     Tcl_Obj* tclindexname = NULL;
01786     char msg[SLEN];
01787     char* array=NULL;
01788     char* tempstr=NULL;
01789     int strlen;
01790     int inimgaddr;
01791     IMAGE* inimg=NULL;
01792     int outimgaddr;
01793     IMAGE* outimg=NULL;
01794     char* outname=NULL;
01795 
01796     if( argc != 2 ) {
01797         Tcl_AppendResult(interp,"wrong # args: should be \"",
01798         argv[0], " arrayname\"", (char *) NULL);
01799         return TCL_ERROR;
01800     }
01801     array=argv[1];
01802             
01803 
01804     /* Read input image array(inimg,addr) */
01805     tclarrayname = Tcl_NewStringObj(array,-1);
01806     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
01807     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01808 
01809 
01810         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01811         if (strlen <= 0) return TCL_ERROR;
01812         sscanf(tempstr,"%x",&inimgaddr);
01813         inimg = (IMAGE *) inimgaddr;
01814     } else {
01815         return TCL_ERROR;
01816     }
01817     Tcl_DecrRefCount(tclarrayname);
01818     Tcl_DecrRefCount(tclindexname);
01819                 
01820 
01821     /* Read the output image 1 name */
01822     tclarrayname = Tcl_NewStringObj(array,-1);
01823     tclindexname = Tcl_NewStringObj("outname",-1);
01824     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01825 
01826 
01827         outname = Tcl_GetStringFromObj(tclobj,&strlen);
01828         if (strlen <= 0) return TCL_ERROR;
01829     } else {
01830         return TCL_ERROR;
01831     }   
01832     Tcl_DecrRefCount(tclarrayname);
01833     Tcl_DecrRefCount(tclindexname);
01834         
01835 
01836     TREERING_DETECT(inimg, &outimg);
01837 
01838     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
01839 
01840     outimgaddr = (int) outimg;
01841     sprintf(msg, "%x", outimgaddr);
01842     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01843   
01844     return TCL_OK;
01845 }  
01846 
01847 
01848 
01849 
01850 /*-Copyright Information------------------------------------------------------*/
01851 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01852 /*----------------------------------------------------------------------------*/
01853 /*-General Information--------------------------------------------------------*/
01854 /*                                                                            */
01855 /*   This procedure provides an interface to the SADIE function               */
01856 /*   RINGWIDTHS from Tcl/Tk.  It expects a tcl global array                   */
01857 /*   with these indices to exist:                                             */
01858 /*      array(inimg,addr)         --  SADIE image address                     */
01859 /*      array(ringsimg,addr)      --  SADIE image address                     */
01860 /*      array(graddirimg,addr)    --  SADIE image address                     */
01861 /*      array(outname)            --  char*                                   */
01862 /*                                                                            */
01863 /*----------------------------------------------------------------------------*/
01864 /*-Interface Information------------------------------------------------------*/
01865 int Sadie_Proto_RingWidthsCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01866 {
01867     Tcl_Obj* tclobj=NULL;
01868     Tcl_Obj* tclarrayname = NULL;
01869     Tcl_Obj* tclindexname = NULL;
01870     char msg[SLEN];
01871     char* array=NULL;
01872     char* tempstr=NULL;
01873     int strlen;
01874     int inimgaddr, ringsimgaddr, graddirimgaddr;
01875     IMAGE *inimg=NULL, *ringsimg=NULL, *graddirimg=NULL;
01876     int outimgaddr;
01877     IMAGE* outimg=NULL;
01878     char* outname=NULL;
01879 
01880     if( argc != 2 ) {
01881         Tcl_AppendResult(interp,"wrong # args: should be \"",
01882         argv[0], " arrayname\"", (char *) NULL);
01883         return TCL_ERROR;
01884     }
01885     array=argv[1];
01886             
01887 
01888     /* Read input image array(inimg,addr) */
01889     tclarrayname = Tcl_NewStringObj(array,-1);
01890     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
01891     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01892         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01893         if (strlen <= 0) return TCL_ERROR;
01894         sscanf(tempstr,"%x",&inimgaddr);
01895         inimg = (IMAGE *) inimgaddr;
01896     } else {
01897         return TCL_ERROR;
01898     }
01899     Tcl_DecrRefCount(tclarrayname);
01900     Tcl_DecrRefCount(tclindexname);
01901                 
01902 
01903     /* Read input image array(ringsimg,addr) */
01904     tclarrayname = Tcl_NewStringObj(array,-1);
01905     tclindexname = Tcl_NewStringObj("ringsimg,addr",-1);
01906     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01907         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01908         if (strlen <= 0) return TCL_ERROR;
01909         sscanf(tempstr,"%x",&ringsimgaddr);
01910         ringsimg = (IMAGE *) ringsimgaddr;
01911     } else {
01912         return TCL_ERROR;
01913     }
01914     Tcl_DecrRefCount(tclarrayname);
01915     Tcl_DecrRefCount(tclindexname);
01916                 
01917 
01918     /* Read input image array(graddirimg,addr) */
01919     tclarrayname = Tcl_NewStringObj(array,-1);
01920     tclindexname = Tcl_NewStringObj("graddirimg,addr",-1);
01921     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01922         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01923         if (strlen <= 0) return TCL_ERROR;
01924         sscanf(tempstr,"%x",&graddirimgaddr);
01925         graddirimg = (IMAGE *) graddirimgaddr;
01926     } else {
01927         return TCL_ERROR;
01928     }
01929     Tcl_DecrRefCount(tclarrayname);
01930     Tcl_DecrRefCount(tclindexname);
01931                 
01932 
01933     /* Read the output image 1 name */
01934     tclarrayname = Tcl_NewStringObj(array,-1);
01935     tclindexname = Tcl_NewStringObj("outname",-1);
01936     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01937         outname = Tcl_GetStringFromObj(tclobj,&strlen);
01938         if (strlen <= 0) return TCL_ERROR;
01939     } else {
01940         return TCL_ERROR;
01941     }
01942     Tcl_DecrRefCount(tclarrayname);
01943     Tcl_DecrRefCount(tclindexname);
01944                 
01945 
01946     RINGWIDTHS(inimg, ringsimg, graddirimg, &outimg);
01947             
01948 
01949     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
01950     outimgaddr = (int) outimg;
01951                 
01952 
01953     sprintf(msg, "%x", outimgaddr);
01954     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01955             
01956     return TCL_OK;
01957 }
01958 
01959 
01960 /*-Copyright Information------------------------------------------------------*/
01961 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01962 /*----------------------------------------------------------------------------*/
01963 /*-General Information--------------------------------------------------------*/
01964 /*                                                                            */
01965 /*   This procedure provides an interface to the SADIE function               */
01966 /*   RINGWIDTHS_NOCHECK from Tcl/Tk.  It expects a tcl global array           */
01967 /*   with these indices to exist:                                             */
01968 /*      array(inimg,addr)         --  SADIE image address                     */
01969 /*      array(ringsimg,addr)      --  SADIE image address                     */
01970 /*      array(graddirimg,addr)    --  SADIE image address                     */
01971 /*      array(outname)            --  char*                                   */
01972 /*                                                                            */
01973 /*----------------------------------------------------------------------------*/
01974 /*-Interface Information------------------------------------------------------*/
01975 int Sadie_Proto_RingWidths_NoCheckCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
01976 {
01977     Tcl_Obj* tclobj=NULL;
01978     Tcl_Obj* tclarrayname = NULL;
01979     Tcl_Obj* tclindexname = NULL;
01980     char msg[SLEN];
01981     char* array=NULL;
01982     char* tempstr=NULL;
01983     int strlen;
01984     int inimgaddr, ringsimgaddr, graddirimgaddr;
01985     IMAGE *inimg=NULL, *ringsimg=NULL, *graddirimg=NULL;
01986     int outimgaddr;
01987     IMAGE* outimg=NULL;
01988     char* outname=NULL;
01989 
01990     if( argc != 2 ) {
01991         Tcl_AppendResult(interp,"wrong # args: should be \"",
01992         argv[0], " arrayname\"", (char *) NULL);
01993         return TCL_ERROR;
01994     }
01995     array=argv[1];
01996             
01997 
01998     /* Read input image array(inimg,addr) */
01999     tclarrayname = Tcl_NewStringObj(array,-1);
02000     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
02001     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02002         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02003         if (strlen <= 0) return TCL_ERROR;
02004         sscanf(tempstr,"%x",&inimgaddr);
02005         inimg = (IMAGE *) inimgaddr;
02006     } else {
02007         return TCL_ERROR;
02008     }
02009     Tcl_DecrRefCount(tclarrayname);
02010     Tcl_DecrRefCount(tclindexname);
02011                 
02012 
02013     /* Read input image array(ringsimg,addr) */
02014     tclarrayname = Tcl_NewStringObj(array,-1);
02015     tclindexname = Tcl_NewStringObj("ringsimg,addr",-1);
02016     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02017         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02018         if (strlen <= 0) return TCL_ERROR;
02019         sscanf(tempstr,"%x",&ringsimgaddr);
02020         ringsimg = (IMAGE *) ringsimgaddr;
02021     } else {
02022         return TCL_ERROR;
02023     }
02024     Tcl_DecrRefCount(tclarrayname);
02025     Tcl_DecrRefCount(tclindexname);
02026                 
02027 
02028     /* Read input image array(graddirimg,addr) */
02029     tclarrayname = Tcl_NewStringObj(array,-1);
02030     tclindexname = Tcl_NewStringObj("graddirimg,addr",-1);
02031     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02032         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02033         if (strlen <= 0) return TCL_ERROR;
02034         sscanf(tempstr,"%x",&graddirimgaddr);
02035         graddirimg = (IMAGE *) graddirimgaddr;
02036     } else {
02037         return TCL_ERROR;
02038     }
02039     Tcl_DecrRefCount(tclarrayname);
02040     Tcl_DecrRefCount(tclindexname);
02041                 
02042 
02043     /* Read the output image 1 name */
02044     tclarrayname = Tcl_NewStringObj(array,-1);
02045     tclindexname = Tcl_NewStringObj("outname",-1);
02046     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02047         outname = Tcl_GetStringFromObj(tclobj,&strlen);
02048         if (strlen <= 0) return TCL_ERROR;
02049     } else {
02050         return TCL_ERROR;
02051     }
02052     Tcl_DecrRefCount(tclarrayname);
02053     Tcl_DecrRefCount(tclindexname);
02054                 
02055 
02056     RINGWIDTHS_NOCHECK(inimg, ringsimg, graddirimg, &outimg);
02057             
02058 
02059     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
02060     outimgaddr = (int) outimg;
02061                 
02062 
02063     sprintf(msg, "%x", outimgaddr);
02064     Tcl_SetResult(interp, msg, TCL_VOLATILE);
02065             
02066     return TCL_OK;
02067 }
02068 
02069 
02070 /*-Copyright Information------------------------------------------------------*/
02071 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
02072 /*----------------------------------------------------------------------------*/
02073 /*-General Information--------------------------------------------------------*/
02074 /*                                                                            */
02075 /*   This procedure provides an interface to the SADIE function               */
02076 /*   REGISTER from Tcl/Tk.  It expects a tcl global array                     */
02077 /*   with these indices to exist:                                             */
02078 /*      array(inimg1,addr)        --  SADIE image address                     */
02079 /*      array(inimg2,addr)        --  SADIE image address                     */
02080 /*      array(est_x_offset)       --  int                                     */
02081 /*      array(est_y_offset)       --  int                                     */
02082 /*      array(outtargetname)      --  char*                                   */
02083 /*      array(outsearchname)      --  char*                                   */
02084 /*      array(outcorrname)        --  char*                                   */
02085 /*      array(outimgname)         --  char*                                   */
02086 /*                                                                            */
02087 /*----------------------------------------------------------------------------*/
02088 /*-Interface Information------------------------------------------------------*/
02089 int Sadie_Proto_RegisterCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
02090 {
02091     Tcl_Obj* tclobj=NULL;
02092     Tcl_Obj* tclarrayname = NULL;
02093     Tcl_Obj* tclindexname = NULL;
02094     char msg[SLEN];
02095     char* array=NULL;
02096     char* tempstr=NULL;
02097     int strlen;
02098     int inimg1addr, inimg2addr;
02099     IMAGE *inimg1=NULL, *inimg2=NULL;
02100     int outtargetaddr, outsearchaddr, outcorraddr, outimgaddr;
02101     IMAGE *outtarget=NULL, *outsearch=NULL, *outcorr=NULL, *outimg=NULL;
02102     char *outtargetname=NULL, *outsearchname=NULL, *outcorrname=NULL, *outimgname=NULL;
02103     int est_x_offset, est_y_offset;
02104 
02105     if( argc != 2 ) {
02106         Tcl_AppendResult(interp,"wrong # args: should be \"",
02107         argv[0], " arrayname\"", (char *) NULL);
02108         return TCL_ERROR;
02109     }
02110     array=argv[1];
02111             
02112 
02113     /* Read input image array(inimg1,addr) */
02114     tclarrayname = Tcl_NewStringObj(array,-1);
02115     tclindexname = Tcl_NewStringObj("inimg1,addr",-1);
02116     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02117         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02118         if (strlen <= 0) return TCL_ERROR;
02119         sscanf(tempstr,"%x",&inimg1addr);
02120         inimg1 = (IMAGE *) inimg1addr;
02121     } else {
02122         return TCL_ERROR;
02123     }
02124     Tcl_DecrRefCount(tclarrayname);
02125     Tcl_DecrRefCount(tclindexname);
02126                 
02127 
02128     /* Read input image array(inimg2,addr) */
02129     tclarrayname = Tcl_NewStringObj(array,-1);
02130     tclindexname = Tcl_NewStringObj("inimg2,addr",-1);
02131     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02132         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02133         if (strlen <= 0) return TCL_ERROR;
02134         sscanf(tempstr,"%x",&inimg2addr);
02135         inimg2 = (IMAGE *) inimg2addr;
02136     } else {
02137         return TCL_ERROR;
02138     }
02139     Tcl_DecrRefCount(tclarrayname);
02140     Tcl_DecrRefCount(tclindexname);
02141                 
02142 
02143     /* Read the input integer array(est_x_offset) */
02144     tclarrayname = Tcl_NewStringObj(array,-1);
02145     tclindexname = Tcl_NewStringObj("est_x_offset",-1);
02146     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02147         if (Tcl_GetIntFromObj(interp,tclobj,&est_x_offset) == TCL_ERROR) return TCL_ERROR;
02148     } else {
02149         return TCL_ERROR;
02150     }
02151     Tcl_DecrRefCount(tclarrayname);
02152     Tcl_DecrRefCount(tclindexname);
02153 
02154 
02155     /* Read the input integer array(est_y_offset) */
02156     tclarrayname = Tcl_NewStringObj(array,-1);
02157     tclindexname = Tcl_NewStringObj("est_y_offset",-1);
02158     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02159         if (Tcl_GetIntFromObj(interp,tclobj,&est_y_offset) == TCL_ERROR) return TCL_ERROR;
02160     } else {
02161         return TCL_ERROR;
02162     }
02163     Tcl_DecrRefCount(tclarrayname);
02164     Tcl_DecrRefCount(tclindexname);
02165 
02166 
02167     /* Read the output image 1 name */
02168     tclarrayname = Tcl_NewStringObj(array,-1);
02169     tclindexname = Tcl_NewStringObj("outtargetname",-1);
02170     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02171         outtargetname = Tcl_GetStringFromObj(tclobj,&strlen);
02172         if (strlen <= 0) return TCL_ERROR;
02173     } else {
02174         return TCL_ERROR;
02175     }
02176     Tcl_DecrRefCount(tclarrayname);
02177     Tcl_DecrRefCount(tclindexname);
02178                 
02179 
02180     /* Read the output image 2 name */
02181     tclarrayname = Tcl_NewStringObj(array,-1);
02182     tclindexname = Tcl_NewStringObj("outsearchname",-1);
02183     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02184         outsearchname = Tcl_GetStringFromObj(tclobj,&strlen);
02185         if (strlen <= 0) return TCL_ERROR;
02186     } else {
02187         return TCL_ERROR;
02188     }
02189     Tcl_DecrRefCount(tclarrayname);
02190     Tcl_DecrRefCount(tclindexname);
02191                 
02192 
02193     /* Read the output image 3 name */
02194     tclarrayname = Tcl_NewStringObj(array,-1);
02195     tclindexname = Tcl_NewStringObj("outcorrname",-1);
02196     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02197         outcorrname = Tcl_GetStringFromObj(tclobj,&strlen);
02198         if (strlen <= 0) return TCL_ERROR;
02199     } else {
02200         return TCL_ERROR;
02201     }
02202     Tcl_DecrRefCount(tclarrayname);
02203     Tcl_DecrRefCount(tclindexname);
02204                 
02205 
02206     /* Read the output image 4 name */
02207     tclarrayname = Tcl_NewStringObj(array,-1);
02208     tclindexname = Tcl_NewStringObj("outimgname",-1);
02209     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02210         outimgname = Tcl_GetStringFromObj(tclobj,&strlen);
02211         if (strlen <= 0) return TCL_ERROR;
02212     } else {
02213         return TCL_ERROR;
02214     }
02215     Tcl_DecrRefCount(tclarrayname);
02216     Tcl_DecrRefCount(tclindexname);
02217                 
02218 
02219     REGISTER(inimg1, inimg2, est_x_offset, est_y_offset, &outtarget, &outsearch, &outcorr, &outimg);
02220             
02221 
02222     if (CHECKIMG(outtarget))  sprintf(outtarget->text, "%s", outtargetname);
02223     outtargetaddr = (int) outtarget;
02224     if (CHECKIMG(outsearch))  sprintf(outsearch->text, "%s", outsearchname);
02225     outsearchaddr = (int) outsearch;
02226     if (CHECKIMG(outcorr))  sprintf(outcorr->text, "%s", outcorrname);
02227     outcorraddr = (int) outcorr;
02228     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outimgname);
02229     outimgaddr = (int) outimg;
02230                 
02231 
02232     sprintf(msg, "%x %x %x %x", outtargetaddr, outsearchaddr, outcorraddr, outimgaddr);
02233     Tcl_SetResult(interp, msg, TCL_VOLATILE);
02234             
02235     return TCL_OK;
02236 }
02237 
02238 
02239 /*-Copyright Information------------------------------------------------------*/
02240 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
02241 /*----------------------------------------------------------------------------*/
02242 /*-General Information--------------------------------------------------------*/
02243 /*                                                                            */
02244 /*   This procedure provides an interface to the SADIE function               */
02245 /*   FIND_REGISTER from Tcl/Tk.  It expects a tcl global array                */
02246 /*   with these indices to exist:                                             */
02247 /*      array(inimg1,addr)        --  SADIE image address                     */
02248 /*      array(inimg2,addr)        --  SADIE image address                     */
02249 /*      array(est_x_offset)       --  int                                     */
02250 /*      array(est_y_offset)       --  int                                     */
02251 /*                                                                            */
02252 /*----------------------------------------------------------------------------*/
02253 /*-Interface Information------------------------------------------------------*/
02254 int Sadie_Proto_FindRegisterCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
02255 {
02256     Tcl_Obj* tclobj=NULL;
02257     Tcl_Obj* tclarrayname = NULL;
02258     Tcl_Obj* tclindexname = NULL;
02259     char msg[SLEN];
02260     char* array=NULL;
02261     char* tempstr=NULL;
02262     int strlen;
02263     int inimg1addr, inimg2addr;
02264     IMAGE *inimg1=NULL, *inimg2=NULL;
02265     int est_x_offset, est_y_offset;
02266     int x_offset, y_offset;
02267     PIXEL bias_adj, gain_adj;
02268 
02269     if( argc != 2 ) {
02270         Tcl_AppendResult(interp,"wrong # args: should be \"",
02271         argv[0], " arrayname\"", (char *) NULL);
02272         return TCL_ERROR;
02273     }
02274     array=argv[1];
02275             
02276 
02277     /* Read input image array(inimg1,addr) */
02278     tclarrayname = Tcl_NewStringObj(array,-1);
02279     tclindexname = Tcl_NewStringObj("inimg1,addr",-1);
02280     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02281         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02282         if (strlen <= 0) return TCL_ERROR;
02283         sscanf(tempstr,"%x",&inimg1addr);
02284         inimg1 = (IMAGE *) inimg1addr;
02285     } else {
02286         return TCL_ERROR;
02287     }
02288     Tcl_DecrRefCount(tclarrayname);
02289     Tcl_DecrRefCount(tclindexname);
02290                 
02291 
02292     /* Read input image array(inimg2,addr) */
02293     tclarrayname = Tcl_NewStringObj(array,-1);
02294     tclindexname = Tcl_NewStringObj("inimg2,addr",-1);
02295     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02296         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02297         if (strlen <= 0) return TCL_ERROR;
02298         sscanf(tempstr,"%x",&inimg2addr);
02299         inimg2 = (IMAGE *) inimg2addr;
02300     } else {
02301         return TCL_ERROR;
02302     }
02303     Tcl_DecrRefCount(tclarrayname);
02304     Tcl_DecrRefCount(tclindexname);
02305                 
02306 
02307     /* Read the input integer array(est_x_offset) */
02308     tclarrayname = Tcl_NewStringObj(array,-1);
02309     tclindexname = Tcl_NewStringObj("est_x_offset",-1);
02310     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02311         if (Tcl_GetIntFromObj(interp,tclobj,&est_x_offset) == TCL_ERROR) return TCL_ERROR;
02312     } else {
02313         return TCL_ERROR;
02314     }
02315     Tcl_DecrRefCount(tclarrayname);
02316     Tcl_DecrRefCount(tclindexname);
02317 
02318 
02319     /* Read the input integer array(est_y_offset) */
02320     tclarrayname = Tcl_NewStringObj(array,-1);
02321     tclindexname = Tcl_NewStringObj("est_y_offset",-1);
02322     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02323         if (Tcl_GetIntFromObj(interp,tclobj,&est_y_offset) == TCL_ERROR) return TCL_ERROR;
02324     } else {
02325         return TCL_ERROR;
02326     }
02327     Tcl_DecrRefCount(tclarrayname);
02328     Tcl_DecrRefCount(tclindexname);
02329                 
02330 
02331     FIND_REGISTER(inimg1, inimg2, est_x_offset, est_y_offset, &x_offset, &y_offset, &bias_adj, &gain_adj);
02332 
02333     sprintf(msg, "%d %d %f %f", x_offset, y_offset, bias_adj, gain_adj);
02334     Tcl_SetResult(interp, msg, TCL_VOLATILE);
02335             
02336     return TCL_OK;
02337 }
02338 
02339 
02340 
02341 /*-Copyright Information------------------------------------------------------*/
02342 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
02343 /*----------------------------------------------------------------------------*/
02344 /*-General Information--------------------------------------------------------*/
02345 /*                                                                            */
02346 /*   This procedure provides an interface to the SADIE function               */
02347 /*   CREATEMOSAIC from Tcl/Tk.  It expects a tcl global array                 */
02348 /*   with these indices to exist:                                             */
02349 /*      array(nimg)               --  int                                     */
02350 /*      array(height)             --  int                                     */
02351 /*      array(width)              --  int                                     */
02352 /*      array(imgname,[1-nimg])   --  char*                                   */
02353 /*      array(yoffset,[1-nimg])   --  int                                     */
02354 /*      array(xoffset,[1-nimg])   --  int                                     */
02355 /*      array(gain,[1-nimg])      --  PIXEL                                   */
02356 /*      array(bias,[1-nimg])      --  PIXEL                                   */
02357 /*      array(outname)            --  char*                                   */
02358 /*                                                                            */
02359 /*----------------------------------------------------------------------------*/
02360 /*-Interface Information------------------------------------------------------*/
02361 int Sadie_Proto_CreateMosaicCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
02362 {
02363     Tcl_Obj* tclobj=NULL;
02364     Tcl_Obj* tclarrayname = NULL;
02365     Tcl_Obj* tclindexname = NULL;
02366     char msg[SLEN];
02367     char* array=NULL;
02368     char* tempstr=NULL;
02369     int strlen;
02370     int i;
02371     char* imgname[200];
02372     int width, height, nimg;
02373     int yoffset[200], xoffset[200];
02374     PIXEL gain[200], bias[200];
02375     PIXEL fillvalue;
02376     double tempdouble;
02377     int outimgaddr;
02378     IMAGE* outimg=NULL;
02379     char* outname=NULL;
02380 
02381     if( argc != 2 ) {
02382         Tcl_AppendResult(interp,"wrong # args: should be \"",
02383         argv[0], " arrayname\"", (char *) NULL);
02384         return TCL_ERROR;
02385     }
02386     array=argv[1];
02387                 
02388 
02389     /* Read the input integer array(nimg) */
02390     tclarrayname = Tcl_NewStringObj(array,-1);
02391     tclindexname = Tcl_NewStringObj("nimg",-1);
02392     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02393         if (Tcl_GetIntFromObj(interp,tclobj,&nimg) == TCL_ERROR) return TCL_ERROR;
02394     } else {
02395         return TCL_ERROR;
02396     }
02397     Tcl_DecrRefCount(tclarrayname);
02398     Tcl_DecrRefCount(tclindexname);
02399 
02400     /* Read the input integer array(height) */
02401     tclarrayname = Tcl_NewStringObj(array,-1);
02402     tclindexname = Tcl_NewStringObj("height",-1);
02403     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02404         if (Tcl_GetIntFromObj(interp,tclobj,&height) == TCL_ERROR) return TCL_ERROR;
02405     } else {
02406         return TCL_ERROR;
02407     }
02408     Tcl_DecrRefCount(tclarrayname);
02409     Tcl_DecrRefCount(tclindexname);
02410 
02411     /* Read the input integer array(width) */
02412     tclarrayname = Tcl_NewStringObj(array,-1);
02413     tclindexname = Tcl_NewStringObj("width",-1);
02414     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02415         if (Tcl_GetIntFromObj(interp,tclobj,&width) == TCL_ERROR) return TCL_ERROR;
02416     } else {
02417         return TCL_ERROR;
02418     }
02419     Tcl_DecrRefCount(tclarrayname);
02420     Tcl_DecrRefCount(tclindexname);
02421 
02422 
02423     /* Read input image array(inimg,addr[1-nimg]) */
02424     for (i=0; i<nimg; i++) {
02425         /* Read the input image name */
02426         tclarrayname = Tcl_NewStringObj(array,-1);
02427         sprintf(msg,"imgname,%d",i+1);
02428         tclindexname = Tcl_NewStringObj(msg,-1);
02429         if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02430             imgname[i] = Tcl_GetStringFromObj(tclobj,&strlen);
02431             if (strlen <= 0) return TCL_ERROR;
02432         } else {
02433             return TCL_ERROR;
02434         }
02435         Tcl_DecrRefCount(tclarrayname);
02436         Tcl_DecrRefCount(tclindexname);
02437         
02438         /* Read the xoffset */
02439         tclarrayname = Tcl_NewStringObj(array,-1);
02440         sprintf(msg,"xoffset,%d",i+1);
02441         tclindexname = Tcl_NewStringObj(msg,-1);
02442         if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02443             if (Tcl_GetIntFromObj(interp,tclobj,&xoffset[i]) == TCL_ERROR) return TCL_ERROR;
02444         } else {
02445             return TCL_ERROR;
02446         }
02447         Tcl_DecrRefCount(tclarrayname);
02448         Tcl_DecrRefCount(tclindexname);
02449         
02450         /* Read the yoffset */
02451         tclarrayname = Tcl_NewStringObj(array,-1);
02452         sprintf(msg,"yoffset,%d",i+1);
02453         tclindexname = Tcl_NewStringObj(msg,-1);
02454         if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02455             if (Tcl_GetIntFromObj(interp,tclobj,&yoffset[i]) == TCL_ERROR) return TCL_ERROR;
02456         } else {
02457             return TCL_ERROR;
02458         }
02459         Tcl_DecrRefCount(tclarrayname);
02460         Tcl_DecrRefCount(tclindexname);
02461         
02462         /* Read the gain */
02463         tclarrayname = Tcl_NewStringObj(array,-1);
02464         sprintf(msg,"gain,%d",i+1);
02465         tclindexname = Tcl_NewStringObj(msg,-1);
02466         if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02467             if (Tcl_GetDoubleFromObj(interp,tclobj,&tempdouble) == TCL_ERROR) return TCL_ERROR;
02468             gain[i] = (PIXEL) tempdouble;
02469         } else {
02470             return TCL_ERROR;
02471         }
02472         Tcl_DecrRefCount(tclarrayname);
02473         Tcl_DecrRefCount(tclindexname);
02474 
02475         /* Read the bias */
02476         tclarrayname = Tcl_NewStringObj(array,-1);
02477         sprintf(msg,"bias,%d",i+1);
02478         tclindexname = Tcl_NewStringObj(msg,-1);
02479         if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02480             if (Tcl_GetDoubleFromObj(interp,tclobj,&tempdouble) == TCL_ERROR) return TCL_ERROR;
02481             bias[i] = (PIXEL) tempdouble;
02482         } else {
02483             return TCL_ERROR;
02484         }
02485         Tcl_DecrRefCount(tclarrayname);
02486         Tcl_DecrRefCount(tclindexname);
02487     }
02488 
02489     /* Read the output image 1 name */
02490     tclarrayname = Tcl_NewStringObj(array,-1);
02491     tclindexname = Tcl_NewStringObj("outname",-1);
02492     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02493         outname = Tcl_GetStringFromObj(tclobj,&strlen);
02494         if (strlen <= 0) return TCL_ERROR;
02495     } else {
02496         return TCL_ERROR;
02497     }
02498     Tcl_DecrRefCount(tclarrayname);
02499     Tcl_DecrRefCount(tclindexname);
02500                 
02501 
02502     CREATEMOSAIC((char **)imgname,nimg,height,width,(int *)xoffset,(int *)yoffset,(PIXEL *)bias,(PIXEL *)gain,fillvalue,(IMAGE **)&outimg);
02503             
02504 
02505     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
02506     outimgaddr = (int) outimg;
02507                 
02508 
02509     sprintf(msg, "%x", outimgaddr);
02510     Tcl_SetResult(interp, msg, TCL_VOLATILE);
02511             
02512     return TCL_OK;
02513 }
02514 
02515 
02516 /*-Copyright Information------------------------------------------------------*/
02517 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
02518 /*----------------------------------------------------------------------------*/
02519 /*-General Information--------------------------------------------------------*/
02520 /*                                                                            */
02521 /*   This procedure provides an interface to the SADIE function               */
02522 /*   FINDCENTER from Tcl/Tk.  It expects a tcl global array                   */
02523 /*   with these indices to exist:                                             */
02524 /*      array(inimg,addr)         --  SADIE image address                     */
02525 /*                                                                            */
02526 /*----------------------------------------------------------------------------*/
02527 /*-Interface Information------------------------------------------------------*/
02528 int Sadie_Proto_FindCenterCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
02529 {  
02530     Tcl_Obj* tclobj=NULL;
02531     Tcl_Obj* tclarrayname = NULL;
02532     Tcl_Obj* tclindexname = NULL;
02533     char msg[SLEN];
02534     char* array=NULL;
02535     char* tempstr=NULL;
02536     int strlen;
02537     int inimgaddr;
02538     IMAGE* inimg=NULL;
02539  
02540     if( argc != 2 ) {
02541         Tcl_AppendResult(interp,"wrong # args: should be \"",
02542         argv[0], " arrayname\"", (char *) NULL);
02543         return TCL_ERROR;
02544     }
02545     array=argv[1];
02546             
02547     /* Read input image array(inimg,addr) */
02548     tclarrayname = Tcl_NewStringObj(array,-1);
02549     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
02550     if (tclobj = Tcl_ObjGetVar2(interp, tclarrayname, tclindexname, TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02551         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02552         if (strlen <= 0) return TCL_ERROR;
02553         sscanf(tempstr,"%x",&inimgaddr);
02554         inimg = (IMAGE *) inimgaddr;
02555     } else {
02556         return TCL_ERROR;
02557     }
02558     Tcl_DecrRefCount(tclarrayname);
02559     Tcl_DecrRefCount(tclindexname);
02560 
02561     FINDCENTER(inimg);
02562   
02563     return TCL_OK;
02564 }  
02565 
02566 
02567 
02568 /*-Copyright Information------------------------------------------------------*/
02569 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
02570 /*----------------------------------------------------------------------------*/
02571 /*-General Information--------------------------------------------------------*/
02572 /*                                                                            */
02573 /*   This procedure provides an interface to the SADIE function               */
02574 /*   SETMEAN from Tcl/Tk.  It expects a tcl global array                      */
02575 /*   with these indices to exist:                                             */
02576 /*      array(inimg,addr)         --  SADIE image address                     */
02577 /*      array(mean)               --  double                                  */
02578 /*      array(outname)            --  char*                                   */
02579 /*                                                                            */
02580 /*----------------------------------------------------------------------------*/
02581 /*-Interface Information------------------------------------------------------*/
02582 int Sadie_Proto_SetMeanCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
02583 {  
02584     Tcl_Obj* tclobj=NULL;
02585     Tcl_Obj* tclarrayname = NULL;
02586     Tcl_Obj* tclindexname = NULL;
02587     char msg[SLEN];
02588     char* array=NULL;
02589     char* tempstr=NULL;
02590     int strlen;
02591     int inimgaddr;
02592     IMAGE* inimg=NULL;
02593     int outimgaddr;
02594     IMAGE* outimg=NULL;
02595     char* outname=NULL;
02596     double mean;
02597     
02598     if( argc != 2 ) {
02599         Tcl_AppendResult(interp,"wrong # args: should be \"",
02600         argv[0], " arrayname\"", (char *) NULL);
02601         return TCL_ERROR;
02602     }
02603     array=argv[1];
02604             
02605 
02606     /* Read input image array(inimg,addr) */
02607     tclarrayname = Tcl_NewStringObj(array,-1);
02608     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
02609     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02610         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
02611         if (strlen <= 0) return TCL_ERROR;
02612         sscanf(tempstr,"%x",&inimgaddr);
02613         inimg = (IMAGE *) inimgaddr;
02614     } else {
02615         return TCL_ERROR;
02616     }
02617     Tcl_DecrRefCount(tclarrayname);
02618     Tcl_DecrRefCount(tclindexname);
02619                 
02620 
02621     /* Read the input integer array(mean) */
02622     tclarrayname = Tcl_NewStringObj(array,-1);
02623     tclindexname = Tcl_NewStringObj("mean",-1);
02624     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02625         if (Tcl_GetDoubleFromObj(interp,tclobj,&mean) == TCL_ERROR) return TCL_ERROR;
02626     } else {
02627         return TCL_ERROR;
02628     }
02629     Tcl_DecrRefCount(tclarrayname);
02630     Tcl_DecrRefCount(tclindexname);
02631                 
02632 
02633     /* Read the output image 1 name */
02634     tclarrayname = Tcl_NewStringObj(array,-1);
02635     tclindexname = Tcl_NewStringObj("outname",-1);
02636     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
02637         outname = Tcl_GetStringFromObj(tclobj,&strlen);
02638         if (strlen <= 0) return TCL_ERROR;
02639     } else {
02640         return TCL_ERROR;
02641     }
02642     Tcl_DecrRefCount(tclarrayname);
02643     Tcl_DecrRefCount(tclindexname);
02644                 
02645 
02646     SETMEAN(inimg, (PIXEL)mean, &outimg);
02647             
02648 
02649     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
02650     outimgaddr = (int) outimg;
02651                 
02652 
02653     sprintf(msg, "%x", outimgaddr);
02654     Tcl_SetResult(interp, msg, TCL_VOLATILE);
02655             
02656     return TCL_OK;
02657 }  
02658 
02659 
02660 
02661 
02662 
02663 /*************************************************************************
02664  *
02665  * This procedure initializes the the Sadie_Proto procedures when
02666  * this package is loaded.
02667  *
02668  *************************************************************************/
02669 int Sadie_Proto_Init(Tcl_Interp *interp) {
02670   Tcl_CreateCommand(interp, "Sadie_Proto_Img2Ascii", Sadie_Proto_Img2AsciiCmd,
02671         (ClientData) NULL, NULL);
02672   Tcl_CreateCommand(interp, "Sadie_Proto_BinGrid", Sadie_Proto_BinGridCmd,
02673         (ClientData) NULL, NULL);
02674 
02675   Tcl_CreateCommand(interp, "Sadie_Proto_Sector", Sadie_Proto_SectorCmd, 
02676         (ClientData) NULL, NULL);
02677   Tcl_CreateCommand(interp, "Sadie_Proto_Sector8", Sadie_Proto_Sector8Cmd, 
02678         (ClientData) NULL, NULL);
02679   Tcl_CreateCommand(interp, "Sadie_Proto_Isolate", Sadie_Proto_IsolateCmd, 
02680         (ClientData) NULL, NULL);
02681   Tcl_CreateCommand(interp, "Sadie_Proto_SizeThresh", Sadie_Proto_SizeThreshCmd, 
02682         (ClientData) NULL, NULL);
02683 
02684   Tcl_CreateCommand(interp, "Sadie_Proto_CreateGauss", Sadie_Proto_CreateGaussCmd, 
02685         (ClientData) NULL, NULL);
02686   Tcl_CreateCommand(interp, "Sadie_Proto_NonMaxSuppressX", Sadie_Proto_NonMaxSuppressXCmd, 
02687         (ClientData) NULL, NULL);
02688   Tcl_CreateCommand(interp, "Sadie_Proto_Canny", Sadie_Proto_CannyCmd, 
02689         (ClientData) NULL, NULL);
02690   Tcl_CreateCommand(interp, "Sadie_Proto_ColorOverlay", Sadie_Proto_ColorOverlayCmd, 
02691         (ClientData) NULL, NULL);
02692 
02693   Tcl_CreateCommand(interp, "Sadie_Proto_CCL8", Sadie_Proto_CCL8Cmd,
02694         (ClientData) NULL, NULL);
02695   Tcl_CreateCommand(interp, "Sadie_Proto_ChainCode", Sadie_Proto_ChainCodeCmd,
02696         (ClientData) NULL, NULL);
02697   Tcl_CreateCommand(interp, "Sadie_Proto_FourierDesc", Sadie_Proto_FourierDescCmd,
02698         (ClientData) NULL, NULL);
02699 
02700   Tcl_CreateCommand(interp, "Sadie_Proto_Hough", Sadie_Proto_HoughCmd, 
02701         (ClientData) NULL, NULL);
02702 
02703   Tcl_CreateCommand(interp, "Sadie_Proto_Periodogram", Sadie_Proto_PeriodogramCmd,
02704         (ClientData) NULL, NULL);
02705   Tcl_CreateCommand(interp, "Sadie_Proto_FindBestFocus", Sadie_Proto_FindBestFocusCmd,
02706         (ClientData) NULL, NULL);
02707 
02708   Tcl_CreateCommand(interp, "Sadie_Proto_TreeRing", Sadie_Proto_TreeRingCmd, 
02709         (ClientData) NULL, NULL);
02710 
02711   Tcl_CreateCommand(interp, "Sadie_Proto_LinkTreeRings", Sadie_Proto_LinkTreeRingsCmd, 
02712         (ClientData) NULL, NULL);
02713   Tcl_CreateCommand(interp, "Sadie_Proto_LinkDoubleThresh", Sadie_Proto_LinkDoubleThreshCmd, 
02714         (ClientData) NULL, NULL);
02715 
02716   Tcl_CreateCommand(interp, "Sadie_Proto_Detect_TreeRings", Sadie_Proto_Detect_TreeRingsCmd, 
02717         (ClientData) NULL, NULL);
02718   Tcl_CreateCommand(interp, "Sadie_Proto_RingWidths", Sadie_Proto_RingWidthsCmd, 
02719         (ClientData) NULL, NULL);
02720   Tcl_CreateCommand(interp, "Sadie_Proto_RingWidths_NoCheck", Sadie_Proto_RingWidths_NoCheckCmd, 
02721         (ClientData) NULL, NULL);
02722 
02723   Tcl_CreateCommand(interp, "Sadie_Proto_Register", Sadie_Proto_RegisterCmd, 
02724         (ClientData) NULL, NULL);
02725   Tcl_CreateCommand(interp, "Sadie_Proto_FindRegister", Sadie_Proto_FindRegisterCmd, 
02726         (ClientData) NULL, NULL);
02727 
02728   Tcl_CreateCommand(interp, "Sadie_Proto_CreateMosaic", Sadie_Proto_CreateMosaicCmd, 
02729         (ClientData) NULL, NULL);
02730 
02731 
02732   Tcl_CreateCommand(interp, "Sadie_Proto_FindCenter", Sadie_Proto_FindCenterCmd, 
02733         (ClientData) NULL, NULL);
02734   Tcl_CreateCommand(interp, "Sadie_Proto_SetMean", Sadie_Proto_SetMeanCmd, 
02735         (ClientData) NULL, NULL);
02736 
02737   return TCL_OK;
02738 }
02739