Sadie_Contrast.c Source File

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