Sadie_Geometry.c Source File

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