--- a
+++ b/Filter.h
@@ -0,0 +1,898 @@
+#ifndef FILTER_H
+#define FILTER_H
+
+/* Panorama_Tools   -   Generate, Edit and Convert Panoramic Images
+   Copyright (C) 1998,1999 - Helmut Dersch  der@fh-furtwangen.de
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*------------------------------------------------------------*/
+
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <limits.h>
+
+#include "panorama.h"
+//#include "tiffio.h"
+
+#ifndef TRUE
+    #define TRUE 1
+#endif
+
+#ifndef FALSE
+    #define FALSE 0
+#endif
+
+
+//---------------------- Types ---------------------------------------------
+
+#define UCHAR   unsigned char
+#define USHORT  unsigned short
+#define ULONG   unsigned long
+
+enum{
+    _UCHAR,
+    _USHORT,
+    _ULONG
+    };
+
+//---------------------- Some useful math defines --------------------------
+
+#ifndef PI
+    #define PI 3.14159265358979323846
+#endif
+
+// Normalize an angle to +/-180degrees
+
+#define NORM_ANGLE( x )  while( x >180.0 ) x -= 360.0; while( x < -180.0 ) x += 360.0;
+
+// Convert degree to radian
+
+#define DEG_TO_RAD( x )     ( (x) * 2.0 * PI / 360.0 )
+
+// and reverse
+
+#define RAD_TO_DEG( x )     ( (x) * 360.0 / ( 2.0 * PI ) )
+
+// Convert double x to unsigned char/short c
+
+
+
+#define DBL_TO_UC( c, x )   if(x>255.0) c=255U;                             \
+                                else if(x<0.0) c=0;                         \
+                                else c=(unsigned char)floor(x+0.5);
+
+#define DBL_TO_US( c, x )   if(x>65535.0) c=65535U;                         \
+                                else if(x<0.0) c=0;                         \
+                                else c=(unsigned short)floor(x+0.5);
+
+
+
+#define MAX_FISHEYE_FOV     160.0
+
+extern int JavaUI; // Flag to indicate use of java dialogs
+void JPrintError( char* text );
+
+
+
+struct PTPoint
+{
+    double x;
+    double y;
+};
+
+typedef struct PTPoint PTPoint;
+
+#define CopyPTPoint( to, from )       memcpy( &to, &from, sizeof( PTPoint ))
+#define SamePTPoint( p, s )           ((p).x == (s).x && (p).y == (s).y)
+
+struct PTLine
+{
+    PTPoint v[2];
+};
+
+typedef struct PTLine PTLine;
+
+
+struct PTTriangle
+{
+    PTPoint v[3];
+};
+
+typedef struct PTTriangle PTTriangle;
+
+
+
+
+// Maximum number of controlpoints in a pair of images, which can be read
+// via Barcodes
+
+#define NUMPTS 21
+
+// Randomization of feather in stitching tools
+
+#define BLEND_RANDOMIZE     0.1
+
+
+
+
+//----------------------- Structures -------------------------------------------
+
+struct remap_Prefs{                             // Preferences Structure for remap
+        long            magic;                  //  File validity check, must be 30
+        int             from;                   // Image format source image
+        int             to;                     // Image format destination image
+        double          hfov;                   // horizontal field of view /in degrees
+        double          vfov;                   // vertical field of view (usually ignored)
+        } ;
+
+typedef struct remap_Prefs rPrefs;
+
+struct perspective_Prefs{                       //  Preferences structure for tool perspective
+        long            magic;                  //  File validity check, must be 40
+        int             format;                 //  rectilinear or fisheye?
+        double          hfov;                   //  Horizontal field of view (in degree)
+        double          x_alpha;                //  New viewing direction (x coordinate or angle)
+        double          y_beta;                 //  New viewing direction (y coordinate or angle)
+        double          gamma;                  //  Angle of rotation
+        int             unit_is_cart;           //  true, if viewing direction is specified in coordinates
+        int             width;                  //  new width
+        int             height;                 //  new height
+        } ;
+        
+typedef struct perspective_Prefs pPrefs;
+
+
+struct optVars{                                 //  Indicate to optimizer which variables to optimize
+        int hfov;                               //  optimize hfov? 0-no 1-yes , etc
+        int yaw;                
+        int pitch;              
+        int roll;               
+        int a;
+        int b;
+        int c;                  
+        int d;
+        int e;
+        };
+        
+typedef struct optVars optVars;
+
+
+enum{                                       // Enumerates for stBuf.seam
+    _middle,                                // seam is placed in the middle of the overlap
+    _dest                                   // seam is places at the edge of the image to be inserted
+    };
+
+enum{                                       // Enumerates for colcorrect
+    _colCorrectImage    = 1,
+    _colCorrectBuffer   = 2,
+    _colCorrectBoth     = 3,
+    };
+
+struct stitchBuffer{                        // Used describe how images should be merged
+    char                srcName[256];       // Buffer should be merged to image; 0 if not.
+    char                destName[256];      // Converted image (ie pano) should be saved to buffer; 0 if not
+    int             feather;        // Width of feather
+    int             colcorrect;     // Should the images be color corrected?
+    int             seam;           // Where to put the seam (see above)
+    };
+
+typedef struct stitchBuffer stBuf;
+
+struct panControls{                         // Structure for realtime Panoeditor
+        double panAngle;                    // The amount by which yaw/pitch are changed per click
+        double zoomFactor;                  // The percentage for zoom in/out
+        };
+        
+        
+typedef struct panControls panControls;
+
+
+
+enum{                                       // Enumerates for aPrefs.mode
+        _readControlPoints,
+        _runOptimizer,
+        _insert,
+        _extract,
+        _useScript = 8,                     // else use options
+    };
+
+struct adjust_Prefs{        //  Preferences structure for tool adjust
+        long    magic;  //  File validity check, must be 50
+        long    mode;   //  What to do: create Panorama etc?
+        Image   im; //  Image to be inserted/extracted
+        Image   pano;   //  Panorama to be created/ used for extraction
+        
+        stBuf   sBuf;
+        fullPath scriptFile;    // On Mac: Cast to FSSpec; else: full path to scriptFile
+        int     nt; // morphing triangles
+        PTTriangle  *ts; // Source triangles
+        PTTriangle  *td; // Destination triangles
+
+        int interpolator;
+        double gamma;       
+};
+        
+        
+typedef struct adjust_Prefs aPrefs;
+        
+
+
+union panoPrefs{
+        cPrefs  cP;
+        pPrefs  pP;
+        rPrefs  rP;
+        aPrefs  aP;
+        panControls pc;
+        };
+        
+typedef union panoPrefs panoPrefs;
+
+
+struct size_Prefs{                              // Preferences structure for 'pref' dialog
+        long            magic;                  //  File validity check; must be 70
+        int             displayPart;            // Display cropped/framed image ?
+        int             saveFile;               // Save to tempfile? 0-no, 1-yes
+        fullPath        sFile;                  // Full path to file (short name)
+        int             launchApp;              // Open sFile ?
+        fullPath        lApp;                   // the Application to launch
+        int             interpolator;           // Which interpolator to use 
+        double          gamma;                  // Gamma correction value
+        int             noAlpha;                // If new file is created: Don't save mask (Photoshop LE)
+        int             optCreatePano;          // Optimizer creates panos? 0  no/ 1 yes
+        } ;
+
+typedef struct size_Prefs sPrefs;
+        
+        
+
+#if 0
+struct controlPoint{                            // Control Points to adjust images
+        int  num[2];                            // Indices of Images 
+        int  x[2];                              // x - Coordinates 
+        int  y[2];                              // y - Coordinates 
+        int  type;                              // What to optimize: 0-r, 1-x, 2-y
+        } ;
+#endif
+struct controlPoint{                            // Control Points to adjust images
+        int  num[2];                            // Indices of Images 
+        double x[2];                                // x - Coordinates 
+        double y[2];                                // y - Coordinates 
+        int  type;                              // What to optimize: 0-r, 1-x, 2-y
+        } ;
+
+typedef struct controlPoint controlPoint;
+
+struct CoordInfo{                               // Real World 3D coordinates
+        int  num;                               // auxilliary index
+        double x[3];
+        int  set[3];
+        };
+        
+typedef struct CoordInfo CoordInfo;
+
+// Some useful macros for vectors
+
+#define SCALAR_PRODUCT( v1, v2 )    ( (v1)->x[0]*(v2)->x[0] + (v1)->x[1]*(v2)->x[1] + (v1)->x[2]*(v2)->x[2] ) 
+#define ABS_SQUARED( v )            SCALAR_PRODUCT( v, v )
+#define ABS_VECTOR( v )             sqrt( ABS_SQUARED( v ) )
+#define CROSS_PRODUCT( v1, v2, r )  { (r)->x[0] = (v1)->x[1] * (v2)->x[2] - (v1)->x[2]*(v2)->x[1];  \
+                                      (r)->x[1] = (v1)->x[2] * (v2)->x[0] - (v1)->x[0]*(v2)->x[2];  \
+                                      (r)->x[2] = (v1)->x[0] * (v2)->x[1] - (v1)->x[1]*(v2)->x[0]; }
+#define DIFF_VECTOR( v1, v2, r )    {   (r)->x[0] = (v1)->x[0] - (v2)->x[0];  \
+                                        (r)->x[1] = (v1)->x[1] - (v2)->x[1];  \
+                                        (r)->x[2] = (v1)->x[2] - (v2)->x[2]; }
+#define DIST_VECTOR( v1, v2 )       sqrt( ((v1)->x[0] - (v2)->x[0]) * ((v1)->x[0] - (v2)->x[0]) + \
+                                          ((v1)->x[1] - (v2)->x[1]) * ((v1)->x[1] - (v2)->x[1]) + \
+                                          ((v1)->x[2] - (v2)->x[2]) * ((v1)->x[2] - (v2)->x[2]) )
+
+struct transformCoord{                          // 
+        int nump;                               // Number of p-coordinates
+        CoordInfo  *p;                          // Coordinates "as is"
+        int numr;                               // Number of r-coordinates
+        CoordInfo  *r;                          // Requested values for coordinates
+        } ;
+    
+typedef struct transformCoord transformCoord;
+
+struct  tMatrix{
+        double alpha;
+        double beta;
+        double gamma;
+        double x_shift[3];
+        double scale;
+        };
+        
+typedef struct tMatrix tMatrix;
+
+        
+        
+    
+    
+
+
+struct MakeParams{                              // Actual parameters used by Xform functions for pano-creation
+    double  scale[2];                           // scaling factors for resize;
+    double  shear[2];                           // shear values
+    double  rot[2];                             // horizontal rotation params
+    void    *perspect[2];                       // Parameters for perspective control functions
+    double  rad[6];                             // coefficients for polynomial correction (0,...3) and source width/2 (4) and correction radius (5) 
+    double  mt[3][3];                           // Matrix
+    double  distance;
+    double  horizontal;
+    double  vertical;
+    };
+
+struct LMStruct{                                // Parameters used by the Levenberg Marquardt-Solver
+    int         m;                              
+    int         n;
+    double      *x;
+    double      *fvec;
+    double      ftol;
+    double      xtol;
+    double      gtol;
+    int         maxfev; 
+    double      epsfcn;
+    double      *diag;
+    int         mode;   
+    double      factor;
+    int         nprint;
+    int         info;
+    int         nfev;
+    double      *fjac;
+    int         ldfjac;
+    int         *ipvt;
+    double      *qtf;
+    double      *wa1;
+    double      *wa2;
+    double      *wa3;
+    double      *wa4;
+    };
+
+// function to minimize in Levenberg-Marquardt solver
+
+typedef     int (*lmfunc)();    
+
+struct triangle
+{
+    int vert[3];    // Three vertices from list
+    int nIm;        // number of image for texture mapping
+};
+
+typedef struct triangle triangle;
+
+
+
+
+struct AlignInfo{                           // Global data structure used by alignment optimization
+    Image               *im;                // Array of Pointers to Image Structs
+    optVars             *opt;               // Mark variables to optimize
+    int             numIm;              // Number of images 
+    controlPoint            *cpt;               // List of Control points
+    triangle            *t;             // List of triangular faces
+    int             nt;             // Number of triangular faces
+    int                 numPts;             // Number of Control Points
+    int             numParam;           // Number of parameters to optimize
+    Image               pano;               // Panoramic Image decription
+    stBuf               st;             // Info on how to stitch the panorama
+    void                *data;
+    lmfunc              fcn;
+    sPrefs              sP; 
+    CoordInfo           *cim;               // Real World coordinates
+    };  
+
+typedef struct AlignInfo AlignInfo;
+
+struct OptInfo{
+    int numVars;                // Number of variables to fit
+    int numData;                // Number of data to fit to
+    int (*SetVarsToX)(double *x);       // Translate variables to x-values
+    int (*SetXToVars)(double *x);       // and reverse
+    lmfunc fcn;             // Levenberg Marquardt function measuring quality
+    char message[256];          // info returned by LM-optimizer
+};
+    
+typedef struct OptInfo OptInfo;
+
+
+
+struct VRPanoOptions{
+    int     width;
+    int     height;
+    double      pan;
+    double      tilt;
+    double      fov;
+    int         codec;
+    int         cquality;
+    int         progressive;
+};
+
+typedef struct VRPanoOptions VRPanoOptions;
+
+
+struct MultiLayerImage{
+    int numLayers;
+    Image   *Layer;
+    PTRect  selection;
+};
+
+typedef struct MultiLayerImage MultiLayerImage;
+
+
+    
+    
+
+
+// Transformation function type (we have only one...)
+
+typedef     void (*trfn)( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );
+
+
+// Function descriptor to be executed by exec_function
+struct fDesc {
+    trfn    func;           // The function to be called
+    void    *param;         // The parameters to be used
+    };      
+
+typedef struct fDesc fDesc;
+
+#define SetDesc(fD,f,p)     fD.func = f; fD.param = p
+
+// Panorama tool type
+
+typedef     void (*fnPtr)(TrformStr *TrPtr);
+
+
+// Filter function type
+
+typedef unsigned char (*flfn)( unsigned char srcPixel, int xc, int yc, void *params );
+
+
+// Interpolating functions for resampler
+
+typedef     void (*intFunc)( unsigned char *dst,    unsigned char **rgb,
+                            register double Dx, 
+                            register double Dy,
+                            int SamplesPerPixel);
+
+
+
+
+
+// Gamma Correction
+
+struct PTGamma{
+    double *DeGamma;
+    unsigned short *Gamma;
+    int     ChannelSize;
+    int     ChannelStretch;
+    int     GammaSize;
+    };
+
+typedef struct PTGamma PTGamma;
+
+extern PTGamma glu;
+
+
+// Some macros to find out more about images
+
+#define GetBitsPerChannel( im, x )      switch( (im)->bitsPerPixel )    \
+                                    {                                   \
+                                        case 24:    x =  8; break;      \
+                                        case 32:    x =  8; break;      \
+                                        case 48:    x = 16; break;      \
+                                        case 64:    x = 16; break;      \
+                                        default:    x =  8; break;      \
+                                    }                                               
+
+#define GetChannels( im, x )        switch( (im)->bitsPerPixel )        \
+                                    {                                   \
+                                        case 24:    x =  3; break;      \
+                                        case 32:    x =  4; break;      \
+                                        case 48:    x =  3; break;      \
+                                        case 64:    x =  4; break;      \
+                                        default:    x =  3; break;      \
+                                    }                                               
+
+                                    
+
+//---------------------------------- Functions identical in all platforms ------------------------
+
+
+void    dispatch    (TrformStr *TrPtr, sPrefs *s);     // Entry into platform independent code
+// void    DoTransForm (TrformStr *TrPtr, panoPrefs *p );
+
+void setLibToResFile  ( void );         // MacOS: Get resources from shared lib
+void unsetLibToResFile( void );         // MacOS: Don't get resources from shared lib
+
+enum{                   // Enumerates used by Progress and infoDlg
+    _initProgress,      // display message "argument"
+    _setProgress,       // display progress (argument is percentage converted to string)
+    _disposeProgress,   // dispose progress indicator
+    _idleProgress       // do nothing; on Mac: call waitnextevent;
+    };
+
+int     Progress( int command, char* argument );    // Progress Reporting 
+int     infoDlg ( int command, char* argument );    // Display info: same argumenmts as progress
+void    PrintError( char* fmt, ...);                // Error Reporting
+
+int     ccommand( char ***argvPtr);                 // Shell for standalone programs
+
+
+//  Panorama Tool functions
+
+
+void    perspective (TrformStr *TrPtr, pPrefs *p);  
+void    correct     (TrformStr *TrPtr, cPrefs *c);  
+void    remap       (TrformStr *TrPtr, rPrefs *r); 
+void    adjust      (TrformStr *TrPtr, aPrefs *a); 
+void    pan         (TrformStr *TrPtr, panControls *pc);
+
+
+
+
+// Set Struct defaults
+
+void    SetPrefDefaults         (panoPrefs *prPtr,  int selector);
+void    SetCorrectDefaults      ( cPrefs *p );
+void    SetAdjustDefaults       ( aPrefs *p );
+void    SetRemapDefaults        ( rPrefs *p );
+void    SetPerspectiveDefaults  ( pPrefs *p );
+void    SetImageDefaults        ( Image *im);
+void    SetOptDefaults          ( optVars *opt );
+void    SetPanDefaults          ( panControls *pc);
+void    SetSizeDefaults         ( sPrefs *pref);
+void    SetStitchDefaults       ( stBuf *sbuf);
+void    SetVRPanoOptionsDefaults( VRPanoOptions *v);
+void    SettMatrixDefaults      ( tMatrix *t );
+void    SetCoordDefaults        ( CoordInfo *c, int num);
+
+int     SetAlignParams          ( double *x );
+int     SetLMParams             ( double *x );
+void    SetGlobalPtr            ( AlignInfo *p );
+
+
+
+// Dialogs
+int     SetPrefs        ( panoPrefs *p );
+int SetPanPrefs     ( panControls *p );
+int     SetCorrectPrefs     ( cPrefs *p );
+int     SetRadialOptions    ( cPrefs *p );
+int     SetHorizontalOptions    ( cPrefs *p );
+int     SetVerticalOptions  ( cPrefs *p );
+int     SetShearOptions     ( cPrefs *p );
+int     SetScaleOptions     ( cPrefs *p );
+int     SetLumOptions       ( cPrefs *p );
+int     setSizePrefs        ( sPrefs *p, int can_resize );
+int     SetRemapPrefs       ( rPrefs *p );
+int     SetPerspectivePrefs ( pPrefs *p );
+int     SetAdjustPrefs      ( aPrefs *p );
+int     SetInterpolator     ( sPrefs *p );
+int     SetCreateOptions    ( aPrefs *p );
+int     SetCutOptions       ( cPrefs *p );
+int     SetFourierOptions   ( cPrefs *p );
+
+
+
+// File I/O
+
+int     readPrefs           (char* p, int selector );               // Preferences, same selector as dispatch
+void    writePrefs          (char* p, int selector );               // Preferences, same selector as dispatch
+
+int LoadBufImage        ( Image *image, char *fname, int mode);
+int SaveBufImage        ( Image *image, char *fname );
+int writeTIFF           ( Image *im, fullPath* fname);          // On Mac: fname is FSSpec*             
+void    SaveOptions         ( struct correct_Prefs * thePrefs );
+int     LoadOptions         ( struct correct_Prefs * thePrefs );
+void    FindScript          ( struct adjust_Prefs *thePrefs );
+char*   LoadScript          ( fullPath* scriptFile  );
+int     WriteScript         ( char* res, fullPath* scriptFile, int launch );
+int     writePSD            ( Image *im, fullPath* fname);          // On Mac: fname is FSSpec* 
+int     readPSD             ( Image *im, fullPath* fname, int mode);
+int     FindFile            ( fullPath *fname );
+int     SaveFileAs          ( fullPath *fname, char *prompt, char *name );
+void    ConvFileName        ( fullPath *fname,char *string);
+int     writePSDwithLayer   ( Image *im, fullPath *fname);
+int     addLayerToFile      ( Image *im, fullPath* sfile, fullPath* dfile, stBuf *sB);
+void    showScript          ( fullPath* scriptFile );
+void    MakeTempName        ( fullPath *fspec, char *fname );
+void    makePathForResult   ( fullPath *path );
+int     makePathToHost      ( fullPath *path );
+void    open_selection      ( fullPath *path );
+int     readPSDMultiLayerImage( MultiLayerImage *mim, fullPath* sfile);
+int     GetFullPath         (fullPath *path, char *filename); // Somewhat confusing, for compatibility easons
+int     StringtoFullPath    (fullPath *path, char *filename);
+int     IsTextFile          ( char* fname );
+int     readPositions       ( char* script, transformCoord *tP );
+int     readImage           ( Image *im, fullPath *sfile );
+int readJPEG            ( Image *im, fullPath *sfile );
+int readTIFF            ( Image *im, fullPath *sfile );
+int     writeImage          ( Image *im, fullPath *sfile );
+int     writeJPEG           ( Image *im, fullPath *sfile,   int quality, int progressive );
+int     makeTempPath        ( fullPath *path );
+int     writePNG            ( Image *im, fullPath *sfile );
+int     readPNG             ( Image *im, fullPath *sfile );
+int     LaunchAndSendScript(char* application, char* script);
+aPrefs* readAdjustLine( fullPath *theScript );
+//int   readtif(Image *im, TIFF* tif);
+
+#define FullPathtoString( path, string )        GetFullPath( path, string)
+
+
+int     ReadMorphPoints( char *script, AlignInfo *gl, int nIm );
+
+// Image manipulation
+
+#ifdef definitions
+void    addAlpha            ( Image *im ); 
+void    transForm           ( TrformStr *TrPtr, fDesc *fD, int color);
+void    filter              ( TrformStr *TrPtr, flfn func, void* params, int color);        
+void    CopyImageData       ( Image *dest, Image *src );
+void    laplace             ( Image *im );
+void    blurr               ( Image *im );
+void    MakePano            ( TrformStr *TrPtr, aPrefs *aP);
+void    ExtractStill        ( TrformStr *TrPtr , aPrefs *p );
+int     HaveEqualSize       ( Image *im1, Image *im2 );
+int     merge               ( Image *dst, Image *src, int feather, int showprogress, int seam );
+void    mergeAlpha          ( Image *im, unsigned char *alpha, int feather, PTRect *theRect );
+void    SetEquColor         ( cPrefs *p );
+void    CopyPosition        ( Image *to, Image *from );
+int     isColorSpecific     ( cPrefs *p );
+void    ThreeToFourBPP      ( Image *im );
+void    FourToThreeBPP      ( Image *im );
+int     SetUpGamma          ( double pgamma, int psize);
+int     cutTheFrame         ( Image *dest, Image *src, int width, int height, int showprogress );
+int     PositionCmp         ( Image *im1, Image *im2 );
+int     MorphImage          ( Image *src, Image *dst, PTTriangle *ts, PTTriangle *td, int nt );
+int     MorphImageFile      ( fullPath *sfile, fullPath *dfile, AlignInfo *g,int nIm );
+int     blendImages         ( fullPath *f0,  fullPath *f1, fullPath *result, double s );
+int     InterpolateImage    ( Image *src, Image *dst, PTTriangle *ts, PTTriangle *td, int nt );
+int     InterpolateTrianglesPerspective( AlignInfo *g, int nIm, double s, PTTriangle** t  );
+int     InterpolateImageFile( fullPath *sfile, fullPath *dfile, AlignInfo *g,int nIm );
+void    OneToTwoByte        ( Image *im );
+void    TwoToOneByte        ( Image *im );
+void    SetMakeParams       ( struct fDesc *stack, struct MakeParams *mp, Image *im , Image *pn, int color );
+void    SetInvMakeParams    ( struct fDesc *stack, struct MakeParams *mp, Image *im , Image *pn, int color );
+void    GetControlPointCoordinates(int i, double *x, double *y, AlignInfo *gl );
+void    ARGBtoRGBA(UCHAR* buf, int width, int bitsPerPixel);
+void    RGBAtoARGB(UCHAR* buf, int width, int bitsPerPixel);
+int     CropImage(Image *im, PTRect *r);
+void    DoColorCorrection( Image *im1, Image *im2, int mode );
+
+// Script Reading/Parsing/Writing
+
+int     ParseScript         ( char* script, AlignInfo *gl );
+void    WriteResults        ( char* script, fullPath *sfile, AlignInfo *g, double ds( int i) , int launch);
+int     readAdjust      ( aPrefs *p,  fullPath* sfile, int insert, sPrefs *sP );
+void    readControlPoints   (char* script, controlPoint *c );
+int getVRPanoOptions    ( VRPanoOptions *v, char *line );
+void    nextWord            ( register char* word, char** ch );
+void    nextLine            ( register char* line, char** ch );
+int     numLines            ( char* script, char first );
+
+// Memory
+
+void    DisposeAlignInfo    ( AlignInfo *g );
+void**  mymalloc            ( long numBytes );                  // Memory allocation, use Handles
+void    myfree              ( void** Hdl );                     // free Memory, use Handles
+int     SetDestImage        ( TrformStr *TrPtr, int width, int height) ;
+void    DisposeMultiLayerImage( MultiLayerImage *mim );
+
+
+// Math
+
+void    RunLMOptimizer      ( OptInfo   *g);
+void    RunBROptimizer      ( OptInfo   *g, double minStepWidth);
+void    RunOverlapOptimizer ( AlignInfo *g);
+
+void    SetMatrix           ( double a, double b, double c , double m[3][3], int cl );
+void    matrix_mult         ( double m[3][3], double vector[3] );
+void    matrix_inv_mult     ( double m[3][3], double vector[3] );
+double  smallestRoot        ( double *p );
+void    SetCorrectionRadius ( cPrefs *cP );
+int     lmdif               ();
+void    fourier             ( TrformStr *TrPtr, cPrefs *cP );
+unsigned short  gamma_correct( double pix );
+int     EqualCPrefs( cPrefs *c1, cPrefs *c2 );
+double  OverlapRMS          ( MultiLayerImage *mim );
+double  distSquared         ( int num ); 
+int     fcnPano();
+void    doCoordinateTransform( CoordInfo *c, tMatrix *t );
+void    findOptimumtMatrix( transformCoord *tP, tMatrix *tM, lmfunc f);
+int     SolveLinearEquation2( double a[2][2], double b[2], double x[2] );
+void    SortControlPoints( AlignInfo *g , int nIm);
+void    noisefilter         ( Image *dest, Image *src );    
+void    fwiener             ( TrformStr *TrPtr, Image *nf, Image *psf, double gamma, double frame );
+
+
+// Triangulation
+int     PointInTriangle( double x, double y, PTTriangle *T, double c[2] );
+int     SetSourceTriangles( AlignInfo *g, int nIm, PTTriangle** t  );
+int     SetDestTriangles( AlignInfo *g, int nIm, PTTriangle** t  );
+int     InterpolateTriangles( AlignInfo *g, int nIm, double s, PTTriangle** t  );
+int     DelaunayIteration( AlignInfo *g, int nIm );
+int     PointInCircumcircle( double x, double y, PTTriangle *tC );
+int     TriangulatePoints( AlignInfo *g, int nIm );
+int     AddTriangle( triangle *t, AlignInfo *g );
+int     RemoveTriangle( int nt, AlignInfo *g );
+void    OrderVerticesInTriangle( int nt, AlignInfo *g );
+void    SetTriangleCoordinates( triangle *t, PTTriangle *tC, AlignInfo *g );
+int     TrianglesOverlap( PTTriangle *t0, PTTriangle *t1 );
+int     LinesIntersect( PTLine *s0, PTLine *s1) ; 
+double  PTDistance( PTPoint *s0, PTPoint *s1 );
+int     PTPointInRectangle(  PTPoint *p, PTLine *r );
+int     PTElementOf(  double x, double a, double b );
+int     PTNormal( double *a, double *b, double *c, PTLine *s );
+int     PTGetLineCrossing( PTLine *s0, PTLine *s1, PTPoint *ps );
+int     ReduceTriangles( AlignInfo *g, int nIm );
+double  PTAreaOfTriangle( PTTriangle *t );
+int     normalToTriangle( CoordInfo *n, CoordInfo *v, triangle *t );
+
+
+
+
+double GetBlendfactor( int d, int s, int feather );
+
+
+
+
+
+void execute_stack      ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+
+void resize             ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );       
+void shear              ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void horiz              ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void vert               ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void radial             ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+
+
+void persp_sphere       ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void persp_rect         ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+
+
+void rect_pano          ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void pano_rect          ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void pano_erect         ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void erect_pano         ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void sphere_cp_erect    ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void sphere_tp_erect    ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void erect_sphere_cp    ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void rect_sphere_tp     ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void sphere_tp_rect     ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void sphere_cp_pano     ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void rect_erect         ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void erect_rect         ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void erect_sphere_tp    ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void mirror_erect       ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );    
+void mirror_sphere_cp   ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void mirror_pano        ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void sphere_cp_mirror   ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );   
+void sphere_tp_pano     ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );
+
+void pano_sphere_tp     ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );
+
+void rotate_erect       ( double x_dest, double y_dest, double* x_src, double* y_src, void* params );
+void inv_radial         ( double x_dest, double y_dest, double* x_src, double* y_src, void* params );
+
+void vertical           ( double x_dest, double y_dest, double* x_src, double* y_src, void* params );
+void inv_vertical       ( double x_dest, double y_dest, double* x_src, double* y_src, void* params );
+void deregister         ( double x_dest, double y_dest, double* x_src, double* y_src, void* params );
+void tmorph             ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );
+
+void shift_scale_rotate ( double x_dest,double  y_dest, double* x_src, double* y_src, void* params );
+
+
+
+unsigned char radlum    ( unsigned char srcPixel, int xc, int yc, void *params );
+
+
+extern TrformStr        *gTrPtr;
+extern sPrefs           *gsPrPtr;
+#endif // definitions
+
+
+
+// Endian stuff: Read and write numbers from and to memory (ptr)
+
+#ifdef BIGENDIAN
+    #define LONGNUMBER( number, ptr )                   *ptr++ = ((char*)(&number))[0]; \
+                                                        *ptr++ = ((char*)(&number))[1]; \
+                                                        *ptr++ = ((char*)(&number))[2]; \
+                                                        *ptr++ = ((char*)(&number))[3]; 
+
+    #define NUMBERLONG( number, ptr )                   ((char*)(&number))[0] = *ptr++; \
+                                                        ((char*)(&number))[1] = *ptr++; \
+                                                        ((char*)(&number))[2] = *ptr++; \
+                                                        ((char*)(&number))[3] = *ptr++; 
+
+    #define SHORTNUMBER( number, ptr )                  *ptr++ = ((char*)(&number))[0]; \
+                                                        *ptr++ = ((char*)(&number))[1]; \
+
+    #define NUMBERSHORT( number, ptr )                  ((char*)(&number))[0] = *ptr++; \
+                                                        ((char*)(&number))[1] = *ptr++; \
+
+#else
+    #define LONGNUMBER( number, ptr )                   *ptr++ = ((char*)(&number))[3]; \
+                                                        *ptr++ = ((char*)(&number))[2]; \
+                                                        *ptr++ = ((char*)(&number))[1]; \
+                                                        *ptr++ = ((char*)(&number))[0]; 
+
+    #define NUMBERLONG( number, ptr )                   ((char*)(&number))[3] = *ptr++; \
+                                                        ((char*)(&number))[2] = *ptr++; \
+                                                        ((char*)(&number))[1] = *ptr++; \
+                                                        ((char*)(&number))[0] = *ptr++; 
+
+    #define SHORTNUMBER( number, ptr )                  *ptr++ = ((char*)(&number))[1]; \
+                                                        *ptr++ = ((char*)(&number))[0]; \
+
+    #define NUMBERSHORT( number, ptr )                  ((char*)(&number))[1] = *ptr++; \
+                                                        ((char*)(&number))[0] = *ptr++; \
+
+
+
+#endif // BIGENDIAN
+
+// Cross platform file functions
+
+#ifdef __Mac__
+
+    #include <Files.h>
+    #include "sys_mac.h"
+    
+    #define         file_spec                           short
+    #define         myopen( path, perm, fspec )         ( FSpOpenDF( path, perm, &fspec ) != noErr )
+    #define         mywrite( fspec, count, data )       FSWrite (fspec, &count, data) 
+    #define         myread(  fspec, count, data )       FSRead  (fspec, &count, data) 
+    #define         myclose( fspec )                    FSClose (fspec )
+    #define         mycreate( path, creator, type )     FSpCreate( path, creator, type,0)
+    #define         mydelete( path )                    FSpDelete( path )
+    #define         myrename( path, newpath )           FSpRename (path, (newpath)->name)
+    #define         write_text                          fsWrPerm
+    #define         write_bin                           fsWrPerm
+    #define         read_text                           fsRdPerm
+    #define         read_bin                            fsRdPerm
+    #define         read_write_text                     fsRdWrPerm
+            
+#else // __Mac__, use ANSI-filefunctions
+    #define     file_spec           FILE*
+    #define     myopen( path, perm, fspec ) ( (fspec = fopen( (path)->name, perm )) == NULL)
+    #define     mywrite( fspec, count, data )   count = fwrite( data, 1, count, fspec)
+    #define     myread( fspec, count, data )    count = fread( data, 1, count, fspec ) 
+    #define         myclose( fspec )        fclose (fspec )
+    #define     mycreate( path, creator, type )     
+    #define     mydelete( path )        remove((path)->name )
+    #define     myrename( path, newpath )   rename ((path)->name, (newpath)->name)
+    #define     write_text          "w"
+    #define     write_bin           "wb"
+    #define     read_text           "r"
+    #define     read_bin            "rb"
+    #define     read_write_text         "rw"
+    #define     append_bin          "ab"
+    #define     p2cstr( x ) 
+    #define     c2pstr( x )
+                                                            
+
+#endif
+
+
+
+
+#endif
+
+