Sadie_Classify.c Source File

00001 /*
00002    ##########################################
00003    # Sadie_Classify.c -
00004    #   Set of routines for linking SADIE classify routines to tcl/tk.
00005    #
00006    # RCS: $Id: Sadie_Classify.c,v 2.4 1999/02/11 14:31:30 conner Exp $ 
00007    # 
00008    # Digital Image Analysis Lab
00009    # Dept. of Electrical and Computer Engineering
00010    # University of Arizona
00011    ##########################################
00012    */
00013 
00014 #include <tcl.h>
00015 #include <tk.h>
00016 #include <stdio.h>
00017 #include <string.h>
00018 #include "sadie.h"
00019 
00020 
00021 /* RCS Indentification information */
00022 static char rcsid[] = "$Id: Sadie_Classify.c,v 2.4 1999/02/11 14:31:30 conner Exp $";
00023 
00024 
00025 /*-------------------------------------------------------------*/
00026 /* Global Sadie variables that must be set from within Tcl/Tk  */
00027 /*-------------------------------------------------------------*/
00028 extern  short   nlev;
00029 extern  short   csize;
00030 extern  double  weight;
00031 extern  double  *count;
00032 extern  PIXEL   gain;
00033 extern  PIXEL   bias;
00034 extern  PIXEL   gmin;
00035 extern  PIXEL   gmax;
00036 extern  PIXEL   thresh;
00037 extern  PIXEL   gbrk[2][4];
00038 extern  PIXEL   *table;
00039 /* -------------------------------------------------------------------------- */
00040 
00041 
00042 
00043 
00044 /*-Copyright Information------------------------------------------------------*/
00045 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00046 /*----------------------------------------------------------------------------*/
00047 /*-General Information--------------------------------------------------------*/
00048 /*                                                                            */
00049 /*   This procedure provides an interface to the SADIE function               */
00050 /*   LVLSLICE from Tcl/Tk.  It expects a tcl global array                     */
00051 /*   with these indices to exist:                                             */
00052 /*      array(inimg,addr)         --  SADIE image address                     */
00053 /*      array(numclasses)         --  int                                     */
00054 /*      array(thresh)             --  PIXEL                                   */
00055 /*      array(imgarray)           --  char*                                   */
00056 /*      array(outname)            --  char*                                   */
00057 /*      imgarray(class,1-numclasses,1-numregions) --  int                     */
00058 /*                                                                            */
00059 /*----------------------------------------------------------------------------*/
00060 /*-Interface Information------------------------------------------------------*/
00061 int Sadie_Classify_LvlSliceCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00062 {
00063     short i,j,k,l;
00064     Tcl_Obj* tclobj=NULL;
00065     Tcl_Obj* tclarrayname = NULL;
00066     Tcl_Obj* tclindexname = NULL;
00067     char msg[SLEN];
00068     char* array=NULL;
00069     char* tempstr=NULL;
00070     char* imgarray=NULL;
00071     int strlen;
00072     int inimgaddr;
00073     IMAGE* inimg=NULL;
00074     int outimgaddr;
00075     IMAGE* outimg=NULL;
00076     char* outname=NULL;
00077     int numclasses, included;
00078     PIXEL thresh;
00079     double tempdouble;
00080     PIXEL *grng=NULL;
00081     ROIPtr r=NULL;
00082     char index[20];
00083     long m;
00084     
00085     if( argc != 2 ) {
00086         Tcl_AppendResult(interp,"wrong # args: should be \"",
00087         argv[0], " arrayname\"", (char *) NULL);
00088         return TCL_ERROR;
00089     }
00090     array=argv[1];
00091             
00092 
00093     /* Read input image array(inimg,addr) */
00094     tclarrayname = Tcl_NewStringObj(array,-1);
00095     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00096     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00097 
00098 
00099         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00100         if (strlen <= 0) return TCL_ERROR;
00101         sscanf(tempstr,"%x",&inimgaddr);
00102         inimg = (IMAGE *) inimgaddr;
00103     } else {
00104         return TCL_ERROR;
00105     }
00106     Tcl_DecrRefCount(tclarrayname);
00107     Tcl_DecrRefCount(tclindexname);
00108                 
00109 
00110     /* Read the input integer array(numclasses) */
00111     tclarrayname = Tcl_NewStringObj(array,-1);
00112     tclindexname = Tcl_NewStringObj("numclasses",-1);
00113     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00114 
00115 
00116         if (Tcl_GetIntFromObj(interp,tclobj,&numclasses) == TCL_ERROR) return TCL_ERROR;
00117     } else {
00118         return TCL_ERROR;
00119     }
00120     Tcl_DecrRefCount(tclarrayname);
00121     Tcl_DecrRefCount(tclindexname);
00122                                 
00123 
00124     /* Read the input PIXEL array(thresh) */
00125     tclarrayname = Tcl_NewStringObj(array,-1);
00126     tclindexname = Tcl_NewStringObj("thresh",-1);
00127     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00128 
00129 
00130         if (Tcl_GetDoubleFromObj(interp,tclobj,&tempdouble) == TCL_ERROR) return TCL_ERROR;
00131         thresh = (PIXEL)tempdouble;
00132     } else {
00133         return TCL_ERROR;
00134     }
00135     Tcl_DecrRefCount(tclarrayname);
00136     Tcl_DecrRefCount(tclindexname);
00137                 
00138 
00139     /* Read the input image array name */
00140     tclarrayname = Tcl_NewStringObj(array,-1);
00141     tclindexname = Tcl_NewStringObj("inimg,array",-1);
00142     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00143 
00144 
00145         imgarray = Tcl_GetStringFromObj(tclobj,&strlen);
00146         if (strlen <= 0) return TCL_ERROR;
00147     } else {
00148         return TCL_ERROR;
00149     }
00150     Tcl_DecrRefCount(tclarrayname);
00151     Tcl_DecrRefCount(tclindexname);
00152 
00153     /* Read the output image 1 name */
00154     tclarrayname = Tcl_NewStringObj(array,-1);
00155     tclindexname = Tcl_NewStringObj("outname",-1);
00156     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00157 
00158 
00159         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00160         if (strlen <= 0) return TCL_ERROR;
00161     } else {
00162         return TCL_ERROR;
00163     }
00164     Tcl_DecrRefCount(tclarrayname);
00165     Tcl_DecrRefCount(tclindexname);
00166                 
00167 
00168     /* Allocate space for the class boundary array */
00169     if (!(grng=(PIXEL *)malloc(numclasses*inimg->nbnd*2*sizeof(PIXEL)))) {
00170         Tcl_AppendResult(interp,"Could not allocate memory!", (char *) NULL);
00171         return TCL_ERROR;
00172     }                                                                         
00173   
00174 
00175     /* Get the class boundary information */
00176     for (i = 0; i < numclasses*inimg->nbnd*2; i++) {
00177         grng[i] = 0.0;
00178     }
00179 
00180     for (i = 0; i < numclasses; i++) {
00181         m = 0L;
00182         for (l=0,r = inimg->regions; r != NULL; r = r->next,l++) {
00183             sprintf(index,"class,%d,%d",i+1,l+1);
00184             /* Read the input integer array(class,i,l) */
00185             tclarrayname = Tcl_NewStringObj(imgarray,-1);
00186             tclindexname = Tcl_NewStringObj(index,-1);
00187             if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00188 
00189 
00190                 if (Tcl_GetIntFromObj(interp,tclobj,&included) == TCL_ERROR) return TCL_ERROR;
00191             } else {
00192                 return TCL_ERROR;
00193             }
00194             Tcl_DecrRefCount(tclarrayname);
00195             Tcl_DecrRefCount(tclindexname);
00196             if (included) {
00197                 for (j = 0; j < inimg->nbnd; j++) {
00198                     grng[i*inimg->nbnd*2+j*2+0] += r->nval * r->mean[j];
00199                     grng[i*inimg->nbnd*2+j*2+1] += r->nval * (r->mean[j]*r->mean[j] + r->dev[j]*r->dev[j]);
00200                 }
00201                 m += r->nval;
00202             }
00203         }
00204         if (m > 0L) {
00205             for (j = 0; j < inimg->nbnd; j++) {
00206                 grng[i*inimg->nbnd*2+j*2+0] /= m;
00207                 grng[i*inimg->nbnd*2+j*2+1]  = sqrt(grng[i*inimg->nbnd*2+j*2+1]/m - grng[i*inimg->nbnd*2+j*2+0]*grng[i*inimg->nbnd*2+j*2+0]);
00208                 gmin = grng[i*inimg->nbnd*2+j*2+0] - thresh*grng[i*inimg->nbnd*2+j*2+1];
00209                 gmax = grng[i*inimg->nbnd*2+j*2+0] + thresh*grng[i*inimg->nbnd*2+j*2+1];
00210                 grng[i*inimg->nbnd*2+j*2+0] = gmin;
00211                 grng[i*inimg->nbnd*2+j*2+1] = gmax;
00212             }
00213         } else {
00214             sprintf(msg," No training area defined for class %d.",i+1);
00215             MESSAGE('E',msg);
00216             goto the_end;
00217         }
00218     }
00219 
00220     
00221     LVLSLICE(inimg,grng,numclasses,&outimg);
00222 
00223             
00224 
00225     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00226     outimgaddr = (int) outimg;
00227                 
00228 
00229     sprintf(msg, "%x", outimgaddr);
00230     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00231 
00232  the_end:
00233     if (grng) free(grng);
00234 
00235     return TCL_OK;
00236 }
00237 
00238 
00239 
00240 
00241 
00242 
00243 /*-Copyright Information------------------------------------------------------*/
00244 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00245 /*----------------------------------------------------------------------------*/
00246 /*-General Information--------------------------------------------------------*/
00247 /*                                                                            */
00248 /*   This procedure provides an interface to the SADIE function               */
00249 /*   MINDIST from Tcl/Tk.  It expects a tcl global array                      */
00250 /*   with these indices to exist:                                             */
00251 /*      array(inimg,addr)         --  SADIE image address                     */
00252 /*      array(numclasses)         --  int                                     */
00253 /*      array(option)             --  int                                     */
00254 /*      array(inimg,array)        --  char*                                   */
00255 /*      array(outname)            --  char*                                   */
00256 /*      imgarray(class,1-numclasses,1-numregions) --  int                     */
00257 /*                                                                            */
00258 /*----------------------------------------------------------------------------*/
00259 /*-Interface Information------------------------------------------------------*/
00260 int Sadie_Classify_MinDistCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00261 {
00262     short i,j,k,l;
00263     long m,n;
00264     Tcl_Obj* tclobj=NULL;
00265     Tcl_Obj* tclarrayname = NULL;
00266     Tcl_Obj* tclindexname = NULL;
00267     char msg[SLEN];
00268     char* array=NULL;
00269     char* tempstr=NULL;
00270     char* imgarray=NULL;
00271     int strlen;
00272     int inimgaddr;
00273     IMAGE* inimg=NULL;
00274     int outimgaddr;
00275     IMAGE* outimg=NULL;
00276     char* outname=NULL;
00277     int numclasses, option, included;
00278     char index[20];
00279     ROIPtr r=NULL;
00280     double *mean=NULL, *cov=NULL;
00281 
00282     if( argc != 2 ) {
00283         Tcl_AppendResult(interp,"wrong # args: should be \"",
00284         argv[0], " arrayname\"", (char *) NULL);
00285         return TCL_ERROR;
00286     }
00287     array=argv[1];
00288             
00289 
00290     /* Read input image array(inimg,addr) */
00291     tclarrayname = Tcl_NewStringObj(array,-1);
00292     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00293     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00294 
00295 
00296         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00297         if (strlen <= 0) return TCL_ERROR;
00298         sscanf(tempstr,"%x",&inimgaddr);
00299         inimg = (IMAGE *) inimgaddr;
00300     } else {
00301         return TCL_ERROR;
00302     }
00303     Tcl_DecrRefCount(tclarrayname);
00304     Tcl_DecrRefCount(tclindexname);
00305                 
00306 
00307     /* Read the input integer array(numclasses) */
00308     tclarrayname = Tcl_NewStringObj(array,-1);
00309     tclindexname = Tcl_NewStringObj("numclasses",-1);
00310     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00311 
00312 
00313         if (Tcl_GetIntFromObj(interp,tclobj,&numclasses) == TCL_ERROR) return TCL_ERROR;
00314     } else {
00315         return TCL_ERROR;
00316     }   
00317     Tcl_DecrRefCount(tclarrayname);
00318     Tcl_DecrRefCount(tclindexname);
00319         
00320 
00321     /* Read the input integer array(option) */
00322     tclarrayname = Tcl_NewStringObj(array,-1);
00323     tclindexname = Tcl_NewStringObj("option",-1);
00324     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00325 
00326 
00327         if (Tcl_GetIntFromObj(interp,tclobj,&option) == TCL_ERROR) return TCL_ERROR;
00328     } else {
00329         return TCL_ERROR;
00330     }
00331     Tcl_DecrRefCount(tclarrayname);
00332     Tcl_DecrRefCount(tclindexname);
00333                 
00334 
00335     /* Read the input image array name */
00336     tclarrayname = Tcl_NewStringObj(array,-1);
00337     tclindexname = Tcl_NewStringObj("inimg,array",-1);
00338     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00339 
00340 
00341         imgarray = Tcl_GetStringFromObj(tclobj,&strlen);
00342         if (strlen <= 0) return TCL_ERROR;
00343     } else {
00344         return TCL_ERROR;
00345     }
00346     Tcl_DecrRefCount(tclarrayname);
00347     Tcl_DecrRefCount(tclindexname);
00348 
00349     /* Read the output image 1 name */
00350     tclarrayname = Tcl_NewStringObj(array,-1);
00351     tclindexname = Tcl_NewStringObj("outname",-1);
00352     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00353 
00354 
00355         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00356         if (strlen <= 0) return TCL_ERROR;
00357     } else {
00358         return TCL_ERROR;
00359     }
00360     Tcl_DecrRefCount(tclarrayname);
00361     Tcl_DecrRefCount(tclindexname);
00362                 
00363 
00364     /* Allocate space for the mean array */
00365     if (!(mean=(double *)malloc((inimg->nbnd*numclasses)*sizeof(double)))) {
00366         Tcl_AppendResult(interp,"Memory request failed!", (char *) NULL);
00367         return TCL_ERROR;
00368     }                                                                          
00369 
00370     /* Allocate space for the covariance array */
00371     if (!(cov=(double *)malloc((inimg->nbnd*inimg->nbnd)*sizeof(double)))) {
00372         Tcl_AppendResult(interp,"Memory request failed!", (char *) NULL);
00373         return TCL_ERROR;
00374     }                                                                          
00375 
00376 
00377     /* Get the class boundary information */
00378     for (i = 0; i < numclasses*inimg->nbnd; i++) {
00379         mean[i] = 0.0;
00380     }
00381     for (i = 0; i < inimg->nbnd*inimg->nbnd; i++) {
00382         cov[i] = 0.0;
00383     }
00384 
00385     m = 0L;
00386     for (i = 0; i < numclasses; i++) {
00387         n = 0L;
00388         for (l=0,r = inimg->regions; r != NULL; r = r->next,l++) {
00389             sprintf(index,"class,%d,%d",i+1,l+1);
00390             /* Read the input integer array(class,i,l) */
00391             tclarrayname = Tcl_NewStringObj(imgarray,-1);
00392             tclindexname = Tcl_NewStringObj(index,-1);
00393             if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00394 
00395 
00396                 if (Tcl_GetIntFromObj(interp,tclobj,&included) == TCL_ERROR) return TCL_ERROR;
00397             } else {
00398                 return TCL_ERROR;
00399             }
00400             Tcl_DecrRefCount(tclarrayname);
00401             Tcl_DecrRefCount(tclindexname);
00402       
00403             if (included) {
00404                 for (j = 0; j < inimg->nbnd; j++) {
00405                     mean[i*inimg->nbnd+j] += r->nval * r->mean[j];
00406                 }
00407                 n += r->nval;
00408                 for (j = 0; j < inimg->nbnd*inimg->nbnd; j++) {
00409                     cov[j] += r->nval * r->cov[j];
00410                 }
00411                 m += r->nval;
00412             }
00413         }
00414         if (n > 0L) {
00415             for (j = 0; j < inimg->nbnd; j++) {
00416                 mean[i*inimg->nbnd+j] /= n;
00417             }
00418         } else {
00419             sprintf(msg," No training area defined for class %d.",i+1);
00420             MESSAGE('E',msg);
00421             goto the_end;
00422         }
00423     }
00424     if (m > 0L) {
00425         for (i = 0; i < inimg->nbnd*inimg->nbnd; i++) {
00426             cov[i] /= m;
00427         }
00428     } else {
00429         MESSAGE('E'," No classes defined.");
00430         goto the_end;
00431     }
00432 
00433 
00434     MINDIST(inimg,option,numclasses,mean,cov,&outimg);
00435             
00436     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00437     outimgaddr = (int) outimg;
00438                 
00439 
00440     sprintf(msg, "%x", outimgaddr);
00441     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00442 
00443  the_end:           
00444     if (mean) free(mean);
00445     if (cov) free(cov);
00446     
00447     return TCL_OK;
00448 }
00449 
00450 
00451 
00452 
00453 /*-Copyright Information------------------------------------------------------*/
00454 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00455 /*----------------------------------------------------------------------------*/
00456 /*-General Information--------------------------------------------------------*/
00457 /*                                                                            */
00458 /*   This procedure provides an interface to the SADIE function               */
00459 /*   MAXLIKE from Tcl/Tk.  It expects a tcl global array                      */
00460 /*   with these indices to exist:                                             */
00461 /*      array(inimg,addr)         --  SADIE image address                     */
00462 /*      array(numclasses)         --  int                                     */
00463 /*      array(prob)               --  double                                  */
00464 /*      array(inimg,array)        --  char*                                   */
00465 /*      array(outname)            --  char*                                   */
00466 /*      imgarray(class,1-numclasses,1-numregions) --  int                     */
00467 /*                                                                            */
00468 /*----------------------------------------------------------------------------*/
00469 /*-Interface Information------------------------------------------------------*/
00470 int Sadie_Classify_MaxLikeCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00471 {
00472     short i,j,k,l;
00473     Tcl_Obj* tclobj=NULL;
00474     Tcl_Obj* tclarrayname = NULL;
00475     Tcl_Obj* tclindexname = NULL;
00476     char msg[SLEN];
00477     char* array=NULL;
00478     char* tempstr=NULL;
00479     char* imgarray=NULL;
00480     int strlen;
00481     int inimgaddr;
00482     IMAGE* inimg=NULL;
00483     int outimgaddr;
00484     IMAGE* outimg=NULL;
00485     char* outname=NULL;
00486     int numclasses, included;
00487     double theprob;
00488     double *prob=NULL, *cov=NULL;
00489     ROIPtr r = NULL;
00490     char index[20];
00491     long n;
00492 
00493     if( argc != 2 ) {
00494         Tcl_AppendResult(interp,"wrong # args: should be \"",
00495         argv[0], " arrayname\"", (char *) NULL);
00496         return TCL_ERROR;
00497     }
00498     array=argv[1];
00499             
00500 
00501     /* Read input image array(inimg,addr) */
00502     tclarrayname = Tcl_NewStringObj(array,-1);
00503     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00504     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00505 
00506 
00507         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00508         if (strlen <= 0) return TCL_ERROR;
00509         sscanf(tempstr,"%x",&inimgaddr);
00510         inimg = (IMAGE *) inimgaddr;
00511     } else {
00512         return TCL_ERROR;
00513     }
00514     Tcl_DecrRefCount(tclarrayname);
00515     Tcl_DecrRefCount(tclindexname);
00516                 
00517 
00518     /* Read the input integer array(numclasses) */
00519     tclarrayname = Tcl_NewStringObj(array,-1);
00520     tclindexname = Tcl_NewStringObj("numclasses",-1);
00521     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00522 
00523 
00524         if (Tcl_GetIntFromObj(interp,tclobj,&numclasses) == TCL_ERROR) return TCL_ERROR;
00525     } else {
00526         return TCL_ERROR;
00527     }
00528     Tcl_DecrRefCount(tclarrayname);
00529     Tcl_DecrRefCount(tclindexname);
00530                 
00531     /* Read the input double array(prob) */
00532     tclarrayname = Tcl_NewStringObj(array,-1);
00533     tclindexname = Tcl_NewStringObj("prob",-1);
00534     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00535 
00536 
00537         if (Tcl_GetDoubleFromObj(interp,tclobj,&theprob) == TCL_ERROR) return TCL_ERROR;
00538     } else {
00539         return TCL_ERROR;
00540     }
00541     Tcl_DecrRefCount(tclarrayname);
00542     Tcl_DecrRefCount(tclindexname);
00543                 
00544     /* Allocate space for the prob array */
00545     if (!(prob=(double *)malloc(numclasses*sizeof(double)))) {
00546         Tcl_AppendResult(interp,"Memory request failed!", (char *) NULL);
00547         return TCL_ERROR;
00548     }                                                                          
00549 
00550     /* Allocate space for the covariance array */
00551     if (!(cov=(double *)malloc((numclasses*inimg->nbnd*inimg->nbnd)*sizeof(double)))) {
00552         Tcl_AppendResult(interp,"Memory request failed!", (char *) NULL);
00553         return TCL_ERROR;
00554     }                                                                          
00555 
00556     
00557     /* Get the class boundary information */
00558     for (i = 0; i < numclasses*inimg->nbnd*inimg->nbnd; i++) {
00559         cov[i] = 0.0;
00560     }
00561 
00562     /* Read the input image array name */
00563     tclarrayname = Tcl_NewStringObj(array,-1);
00564     tclindexname = Tcl_NewStringObj("inimg,array",-1);
00565     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00566 
00567 
00568         imgarray = Tcl_GetStringFromObj(tclobj,&strlen);
00569         if (strlen <= 0) return TCL_ERROR;
00570     } else {
00571         return TCL_ERROR;
00572     }
00573     Tcl_DecrRefCount(tclarrayname);
00574     Tcl_DecrRefCount(tclindexname);
00575     
00576     for (i = 0; i < numclasses; i++) {
00577         prob[i] = theprob;
00578 
00579         n = 0L;
00580         for (l=0,r = inimg->regions; r != NULL; r = r->next,l++) {
00581             sprintf(index,"class,%d,%d",i+1,l+1);
00582             /* Read the input integer array(class,i,l) */
00583             tclarrayname = Tcl_NewStringObj(imgarray,-1);
00584             tclindexname = Tcl_NewStringObj(index,-1);
00585             if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00586 
00587 
00588                 if (Tcl_GetIntFromObj(interp,tclobj,&included) == TCL_ERROR) return TCL_ERROR;
00589             } else {
00590                 return TCL_ERROR;
00591             }
00592             Tcl_DecrRefCount(tclarrayname);
00593             Tcl_DecrRefCount(tclindexname);
00594       
00595             if (included) {
00596                 n += r->nval;
00597                 for (j = 0; j < inimg->nbnd*inimg->nbnd; j++) {
00598                     cov[i*inimg->nbnd*inimg->nbnd+j] += r->nval * r->cov[j];
00599                 }
00600             }
00601         }
00602         if (n > 0L) {
00603             for (j = 0; j < inimg->nbnd*inimg->nbnd; j++) {
00604                 cov[i*inimg->nbnd*inimg->nbnd+j] /= n;
00605             }
00606         } else {
00607             sprintf(msg," No training area defined for class %d.",i+1);
00608             MESSAGE('E',msg);
00609             goto the_end;
00610         }
00611     }
00612 
00613 
00614     /* Read the output image 1 name */
00615     tclarrayname = Tcl_NewStringObj(array,-1);
00616     tclindexname = Tcl_NewStringObj("outname",-1);
00617     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00618 
00619 
00620         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00621         if (strlen <= 0) return TCL_ERROR;
00622     } else {
00623         return TCL_ERROR;
00624     }
00625     Tcl_DecrRefCount(tclarrayname);
00626     Tcl_DecrRefCount(tclindexname);
00627                 
00628 
00629     MAXLIKE(inimg,numclasses,cov,prob,&outimg);
00630             
00631 
00632     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00633     outimgaddr = (int) outimg;
00634                 
00635 
00636     sprintf(msg, "%x", outimgaddr);
00637     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00638             
00639  the_end:
00640     if (prob) free(prob);
00641     if (cov) free(cov);
00642     
00643     return TCL_OK;
00644 }
00645 
00646 
00647 
00648 
00649 
00650 
00651 /*-Copyright Information------------------------------------------------------*/
00652 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00653 /*----------------------------------------------------------------------------*/
00654 /*-General Information--------------------------------------------------------*/
00655 /*                                                                            */
00656 /*   This procedure provides an interface to the SADIE function               */
00657 /*   CLUSTER from Tcl/Tk.  It expects a tcl global array                      */
00658 /*   with these indices to exist:                                             */
00659 /*      array(inimg,addr)         --  SADIE image address                     */
00660 /*      array(iter)               --  int                                     */
00661 /*      array(classes)            --  int                                     */
00662 /*      array(min)                --  int                                     */
00663 /*      array(incr)               --  int                                     */
00664 /*      array(merging)            --  PIXEL                                   */
00665 /*      array(outlier)            --  PIXEL                                   */
00666 /*      array(outname)            --  char*                                   */
00667 /*                                                                            */
00668 /*----------------------------------------------------------------------------*/
00669 /*-Interface Information------------------------------------------------------*/
00670 int Sadie_Classify_ClusterCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00671 {
00672     Tcl_Obj* tclobj=NULL;
00673     Tcl_Obj* tclarrayname = NULL;
00674     Tcl_Obj* tclindexname = NULL;
00675     char msg[SLEN];
00676     char* array=NULL;
00677     char* tempstr=NULL;
00678     int strlen;
00679     int inimgaddr;
00680     IMAGE* inimg=NULL;
00681     int outimgaddr;
00682     IMAGE* outimg=NULL;
00683     char* outname=NULL;
00684     int iter, classes, min, incr;
00685     PIXEL merging, outlier;
00686     double tempdouble;
00687 
00688     if( argc != 2 ) {
00689         Tcl_AppendResult(interp,"wrong # args: should be \"",
00690         argv[0], " arrayname\"", (char *) NULL);
00691         return TCL_ERROR;
00692     }
00693     array=argv[1];
00694             
00695 
00696     /* Read input image array(inimg,addr) */
00697     tclarrayname = Tcl_NewStringObj(array,-1);
00698     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00699     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00700 
00701 
00702         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00703         if (strlen <= 0) return TCL_ERROR;
00704         sscanf(tempstr,"%x",&inimgaddr);
00705         inimg = (IMAGE *) inimgaddr;
00706     } else {
00707         return TCL_ERROR;
00708     }
00709     Tcl_DecrRefCount(tclarrayname);
00710     Tcl_DecrRefCount(tclindexname);
00711                 
00712 
00713     /* Read the input integer array(iter) */
00714     tclarrayname = Tcl_NewStringObj(array,-1);
00715     tclindexname = Tcl_NewStringObj("iter",-1);
00716     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00717 
00718 
00719         if (Tcl_GetIntFromObj(interp,tclobj,&iter) == TCL_ERROR) return TCL_ERROR;
00720     } else {
00721         return TCL_ERROR;
00722     }
00723     Tcl_DecrRefCount(tclarrayname);
00724     Tcl_DecrRefCount(tclindexname);
00725                 
00726 
00727     /* Read the input integer array(classes) */
00728     tclarrayname = Tcl_NewStringObj(array,-1);
00729     tclindexname = Tcl_NewStringObj("classes",-1);
00730     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00731 
00732 
00733         if (Tcl_GetIntFromObj(interp,tclobj,&classes) == TCL_ERROR) return TCL_ERROR;
00734     } else {
00735         return TCL_ERROR;
00736     }
00737     Tcl_DecrRefCount(tclarrayname);
00738     Tcl_DecrRefCount(tclindexname);
00739                 
00740 
00741     /* Read the input integer array(min) */
00742     tclarrayname = Tcl_NewStringObj(array,-1);
00743     tclindexname = Tcl_NewStringObj("min",-1);
00744     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00745 
00746 
00747         if (Tcl_GetIntFromObj(interp,tclobj,&min) == TCL_ERROR) return TCL_ERROR;
00748     } else {
00749         return TCL_ERROR;
00750     }
00751     Tcl_DecrRefCount(tclarrayname);
00752     Tcl_DecrRefCount(tclindexname);
00753                 
00754 
00755     /* Read the input integer array(incr) */
00756     tclarrayname = Tcl_NewStringObj(array,-1);
00757     tclindexname = Tcl_NewStringObj("incr",-1);
00758     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00759 
00760 
00761         if (Tcl_GetIntFromObj(interp,tclobj,&incr) == TCL_ERROR) return TCL_ERROR;
00762     } else {
00763         return TCL_ERROR;
00764     }
00765     Tcl_DecrRefCount(tclarrayname);
00766     Tcl_DecrRefCount(tclindexname);
00767                 
00768 
00769     /* Read the input PIXEL array(merging) */
00770     tclarrayname = Tcl_NewStringObj(array,-1);
00771     tclindexname = Tcl_NewStringObj("merging",-1);
00772     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00773 
00774 
00775         if (Tcl_GetDoubleFromObj(interp,tclobj,&tempdouble) == TCL_ERROR) return TCL_ERROR;
00776         merging = (PIXEL)tempdouble;
00777     } else {
00778         return TCL_ERROR;
00779     }
00780     Tcl_DecrRefCount(tclarrayname);
00781     Tcl_DecrRefCount(tclindexname);
00782                 
00783 
00784     /* Read the input PIXEL array(outlier) */
00785     tclarrayname = Tcl_NewStringObj(array,-1);
00786     tclindexname = Tcl_NewStringObj("outlier",-1);
00787     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00788 
00789 
00790         if (Tcl_GetDoubleFromObj(interp,tclobj,&tempdouble) == TCL_ERROR) return TCL_ERROR;
00791         outlier = (PIXEL)tempdouble;
00792     } else {
00793         return TCL_ERROR;
00794     }
00795     Tcl_DecrRefCount(tclarrayname);
00796     Tcl_DecrRefCount(tclindexname);
00797                 
00798 
00799     /* Read the output image 1 name */
00800     tclarrayname = Tcl_NewStringObj(array,-1);
00801     tclindexname = Tcl_NewStringObj("outname",-1);
00802     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00803 
00804 
00805         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00806         if (strlen <= 0) return TCL_ERROR;
00807     } else {
00808         return TCL_ERROR;
00809     }
00810     Tcl_DecrRefCount(tclarrayname);
00811     Tcl_DecrRefCount(tclindexname);
00812                 
00813 
00814     CLUSTER(inimg,iter,classes,min,merging,1,incr,incr,outlier,&outimg);
00815             
00816 
00817     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00818     outimgaddr = (int) outimg;
00819                 
00820 
00821     sprintf(msg, "%x", outimgaddr);
00822     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00823             
00824     return TCL_OK;
00825 }
00826 
00827 
00828 
00829 
00830 
00831 
00832 /*-Copyright Information------------------------------------------------------*/
00833 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00834 /*----------------------------------------------------------------------------*/
00835 /*-General Information--------------------------------------------------------*/
00836 /*                                                                            */
00837 /*   This procedure provides an interface to the SADIE function               */
00838 /*   SEGMENT from Tcl/Tk.  It expects a tcl global array                      */
00839 /*   with these indices to exist:                                             */
00840 /*      array(inimg,addr)         --  SADIE image address                     */
00841 /*      array(steps)              --  int                                     */
00842 /*      array(sigma)              --  double                                  */
00843 /*      array(thresh)             --  PIXEL                                   */
00844 /*      array(outname)            --  char*                                   */
00845 /*                                                                            */
00846 /*----------------------------------------------------------------------------*/
00847 /*-Interface Information------------------------------------------------------*/
00848 int Sadie_Classify_SegmentCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00849 {
00850     Tcl_Obj* tclobj=NULL;
00851     Tcl_Obj* tclarrayname = NULL;
00852     Tcl_Obj* tclindexname = NULL;
00853     char msg[SLEN];
00854     char* array=NULL;
00855     char* tempstr=NULL;
00856     int strlen;
00857     int inimgaddr;
00858     IMAGE* inimg=NULL;
00859     int outimgaddr;
00860     IMAGE* outimg=NULL;
00861     char* outname=NULL;
00862     int steps;
00863     double sigma;
00864     PIXEL thresh;
00865     double tempdouble;
00866 
00867     if( argc != 2 ) {
00868         Tcl_AppendResult(interp,"wrong # args: should be \"",
00869         argv[0], " arrayname\"", (char *) NULL);
00870         return TCL_ERROR;
00871     }
00872     array=argv[1];
00873             
00874 
00875     /* Read input image array(inimg,addr) */
00876     tclarrayname = Tcl_NewStringObj(array,-1);
00877     tclindexname = Tcl_NewStringObj("inimg,addr",-1);
00878     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00879 
00880 
00881         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
00882         if (strlen <= 0) return TCL_ERROR;
00883         sscanf(tempstr,"%x",&inimgaddr);
00884         inimg = (IMAGE *) inimgaddr;
00885     } else {
00886         return TCL_ERROR;
00887     }
00888     Tcl_DecrRefCount(tclarrayname);
00889     Tcl_DecrRefCount(tclindexname);
00890                 
00891 
00892     /* Read the input integer array(steps) */
00893     tclarrayname = Tcl_NewStringObj(array,-1);
00894     tclindexname = Tcl_NewStringObj("steps",-1);
00895     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00896 
00897 
00898         if (Tcl_GetIntFromObj(interp,tclobj,&steps) == TCL_ERROR) return TCL_ERROR;
00899     } else {
00900         return TCL_ERROR;
00901     }
00902     Tcl_DecrRefCount(tclarrayname);
00903     Tcl_DecrRefCount(tclindexname);
00904                 
00905 
00906     /* Read the input double array(sigma) */
00907     tclarrayname = Tcl_NewStringObj(array,-1);
00908     tclindexname = Tcl_NewStringObj("sigma",-1);
00909     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00910 
00911 
00912         if (Tcl_GetDoubleFromObj(interp,tclobj,&sigma) == TCL_ERROR) return TCL_ERROR;
00913     } else {
00914         return TCL_ERROR;
00915     }
00916     Tcl_DecrRefCount(tclarrayname);
00917     Tcl_DecrRefCount(tclindexname);
00918                 
00919 
00920     /* Read the input PIXEL array(thresh) */
00921     tclarrayname = Tcl_NewStringObj(array,-1);
00922     tclindexname = Tcl_NewStringObj("thresh",-1);
00923     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00924 
00925 
00926         if (Tcl_GetDoubleFromObj(interp,tclobj,&tempdouble) == TCL_ERROR) return TCL_ERROR;
00927         thresh = (PIXEL)tempdouble;
00928     } else {
00929         return TCL_ERROR;
00930     }
00931     Tcl_DecrRefCount(tclarrayname);
00932     Tcl_DecrRefCount(tclindexname);
00933                 
00934 
00935     /* Read the output image 1 name */
00936     tclarrayname = Tcl_NewStringObj(array,-1);
00937     tclindexname = Tcl_NewStringObj("outname",-1);
00938     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
00939 
00940 
00941         outname = Tcl_GetStringFromObj(tclobj,&strlen);
00942         if (strlen <= 0) return TCL_ERROR;
00943     } else {
00944         return TCL_ERROR;
00945     }
00946     Tcl_DecrRefCount(tclarrayname);
00947     Tcl_DecrRefCount(tclindexname);
00948                 
00949 
00950     SEGMENT(inimg,steps,sigma,thresh,&outimg);
00951             
00952 
00953     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
00954     outimgaddr = (int) outimg;
00955                 
00956 
00957     sprintf(msg, "%x", outimgaddr);
00958     Tcl_SetResult(interp, msg, TCL_VOLATILE);
00959             
00960     return TCL_OK;
00961 }
00962 
00963 
00964 
00965 
00966 
00967 
00968 /*-Copyright Information------------------------------------------------------*/
00969 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
00970 /*----------------------------------------------------------------------------*/
00971 /*-General Information--------------------------------------------------------*/
00972 /*                                                                            */
00973 /*   This procedure provides an interface to the SADIE function               */
00974 /*   SIGMAP from Tcl/Tk.  It expects a tcl global array                       */
00975 /*   with these indices to exist:                                             */
00976 /*      array(lblmap,addr)        --  SADIE image address                     */
00977 /*      array(origimg,addr)       --  SADIE image address                     */
00978 /*      array(outname)            --  char*                                   */
00979 /*                                                                            */
00980 /*----------------------------------------------------------------------------*/
00981 /*-Interface Information------------------------------------------------------*/
00982 int Sadie_Classify_SigMapCmd(ClientData client_data, Tcl_Interp* interp, int argc, char *argv[])
00983 {
00984     Tcl_Obj* tclobj=NULL;
00985     Tcl_Obj* tclarrayname = NULL;
00986     Tcl_Obj* tclindexname = NULL;
00987     char msg[SLEN];
00988     char* array=NULL;
00989     char* tempstr=NULL;
00990     int strlen;
00991     int lblmapaddr, origimgaddr;
00992     IMAGE *lblmap=NULL, *origimg=NULL;
00993     int outimgaddr;
00994     IMAGE* outimg=NULL;
00995     char* outname=NULL;
00996 
00997     if( argc != 2 ) {
00998         Tcl_AppendResult(interp,"wrong # args: should be \"",
00999         argv[0], " arrayname\"", (char *) NULL);
01000         return TCL_ERROR;
01001     }
01002     array=argv[1];
01003             
01004 
01005     /* Read input image array(lblmap,addr) */
01006     tclarrayname = Tcl_NewStringObj(array,-1);
01007     tclindexname = Tcl_NewStringObj("lblmap,addr",-1);
01008     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01009 
01010 
01011         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01012         if (strlen <= 0) return TCL_ERROR;
01013         sscanf(tempstr,"%x",&lblmapaddr);
01014         lblmap = (IMAGE *) lblmapaddr;
01015     } else {
01016         return TCL_ERROR;
01017     }
01018     Tcl_DecrRefCount(tclarrayname);
01019     Tcl_DecrRefCount(tclindexname);
01020                 
01021 
01022     /* Read input image array(origimg,addr) */
01023     tclarrayname = Tcl_NewStringObj(array,-1);
01024     tclindexname = Tcl_NewStringObj("origimg,addr",-1);
01025     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01026 
01027 
01028         tempstr = Tcl_GetStringFromObj(tclobj,&strlen);
01029         if (strlen <= 0) return TCL_ERROR;
01030         sscanf(tempstr,"%x",&origimgaddr);
01031         origimg = (IMAGE *) origimgaddr;
01032     } else {
01033         return TCL_ERROR;
01034     }
01035     Tcl_DecrRefCount(tclarrayname);
01036     Tcl_DecrRefCount(tclindexname);
01037                 
01038 
01039     /* Read the output image 1 name */
01040     tclarrayname = Tcl_NewStringObj(array,-1);
01041     tclindexname = Tcl_NewStringObj("outname",-1);
01042     if (tclobj = Tcl_ObjGetVar2(interp,  tclarrayname , tclindexname , TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG)) {
01043 
01044 
01045         outname = Tcl_GetStringFromObj(tclobj,&strlen);
01046         if (strlen <= 0) return TCL_ERROR;
01047     } else {
01048         return TCL_ERROR;
01049     }           
01050     Tcl_DecrRefCount(tclarrayname);
01051     Tcl_DecrRefCount(tclindexname);
01052 
01053     SIGMAP(lblmap,origimg,&outimg);
01054             
01055 
01056     if (CHECKIMG(outimg))  sprintf(outimg->text, "%s", outname);
01057     outimgaddr = (int) outimg;
01058                 
01059 
01060     sprintf(msg, "%x", outimgaddr);
01061     Tcl_SetResult(interp, msg, TCL_VOLATILE);
01062             
01063     return TCL_OK;
01064 }
01065 
01066 
01067 
01068 
01069 
01070 
01071 /*-Copyright Information------------------------------------------------------*/
01072 /* Copyright (c) 1999 by the University of Arizona Digital Image Analysis Lab */
01073 /*----------------------------------------------------------------------------*/
01074 /*-General Information--------------------------------------------------------*/
01075 /*                                                                            */
01076 /*   This procedure initializes the all of the procedures                     */
01077 /*   in this file by registering them with Tcl.                               */
01078 /*                                                                            */
01079 /*----------------------------------------------------------------------------*/
01080 /*-Interface Information------------------------------------------------------*/
01081 int Sadie_Classify_Init(Tcl_Interp *interp)
01082 {
01083     Tcl_CreateCommand(interp, "Sadie_Classify_LvlSlice", Sadie_Classify_LvlSliceCmd,(ClientData) NULL, NULL);
01084     Tcl_CreateCommand(interp, "Sadie_Classify_MinDist", Sadie_Classify_MinDistCmd,(ClientData) NULL, NULL);
01085     Tcl_CreateCommand(interp, "Sadie_Classify_MaxLike", Sadie_Classify_MaxLikeCmd,(ClientData) NULL, NULL);
01086     Tcl_CreateCommand(interp, "Sadie_Classify_Cluster", Sadie_Classify_ClusterCmd,(ClientData) NULL, NULL);
01087     Tcl_CreateCommand(interp, "Sadie_Classify_Segment", Sadie_Classify_SegmentCmd,(ClientData) NULL, NULL);
01088     Tcl_CreateCommand(interp, "Sadie_Classify_SigMap", Sadie_Classify_SigMapCmd,(ClientData) NULL, NULL);
01089     return TCL_OK;
01090 }
01091