Dil.h

Go to the documentation of this file.

// ****************************************************************************
// ****************************************************************************
// **                                                                        **
// **                 D T A  I M A G I N G  L I B R A R Y                    **
// **                 -----------------------------------                    **
// **               (C) 1997-2002 DTA, All Rights Reserved                   **
// **                                                                        **
// **                                                                        **
// **   Develope contributes:    Manuele Turini                              **
// **                                                                        **
// **   Revision history:                                                    **
// **                                                                        **
// **   Rev. 2.14 Beta 29/11/2002                                            **
// **   Rev. 2.18 Beta 16/12/2002                                            **
// **   Rev. 2.20 Beta 24/12/2002                                            **
// **                                                                        **
// ****************************************************************************
// ****************************************************************************

#include    "dildef.h"

C_DEF   dil DIL;

// ****************************************************************************
// Basic & Control ************************************************************
// ****************************************************************************

C_DEF int   DI_Init(int mod);
        // Return the library revision
C_DEF int   DI_Ver(char *ver);
C_DEF void  DI_ColorPick(int mod, int *R, int *G, int *B);
C_DEF int   DI_LoadColor(char *name);
C_DEF int   DI_SaveColor(char *name);
C_DEF void  DI_MFore(int w, MOBJECT obj);
C_DEF void  DI_MBack(int w, MOBJECT obj);
C_DEF void  DI_MColor(int w, MOBJECT obj);
C_DEF void  DI_Color(MOBJECT obj);


// ****************************************************************************
// Handle of image file format ************************************************
// ****************************************************************************

C_DEF int   DI_RAWSave(char *fname, int s);
C_DEF int   DI_RAWLoad(char *fname, int dx, int dy, U32 head, int size, int byte);

        // Load a RAW image file
        //
        // Parameters:
        // s = image server
        // dx,dy = image dimension
        // head = offset to skip header
        // size = 0: byte, 1: word, 2: float
        // byte = 0: Low Byte - High Byte (PC), 1: High Byte - Low Byte (MAC)
C_DEF int   DI_RAWLoading(int s, int dx, int dy, U32 head, int size, int byte, char *fname);

C_DEF int   DI_ASCSave(char *fname, int s);
C_DEF int   DI_IMGLoad(char *f);
C_DEF int   DI_DIFSave(char *f, int s, int mod);
C_DEF int   DI_DIFLoad(char *f, int mod);

        // Load a DIF file into a specified server
        //
        // Return:
        // 0 = ok
        // 1 = error
C_DEF int   DI_DIFLoadBin(char *f, int s);
C_DEF int   DI_DIFLoadInfo(char *f, int s);

C_DEF int   DI_FITSLoad(char *fi, int mode, void *mat);
C_DEF int   DI_FITSSave(char *fname, int s);
C_DEF void  DI_FITSKey(void);
C_DEF int   DI_InputPGM_PPM(char *fname);
C_DEF int   DI_LoadImage(char *tit, int type);              // Generic image load procedure 
C_DEF int   DI_ImportImage(char *path, char *name, int type, int mode);


// ****************************************************************************
// Warning procedures *********************************************************
// ****************************************************************************

C_DEF void  DI_Warning(int w, char *tit);
C_DEF int   DI_WarnSel(char *tit);
C_DEF MOBJECT   DI_Message(char *tit, char *msg);
C_DEF void  DI_MsgClose(MOBJECT sh);
C_DEF void  DI_MsgRaise(MOBJECT sh);

        // Return codes
        // 1 = yes
        // 0 = no
C_DEF int   DI_QuestionSel(char *tit, char *quest, char *bmp);
C_DEF int   DI_QuestionSelXY(char *tit, char *quest, char *bmp, int x, int y);


// ****************************************************************************
// File procedures ************************************************************
// ****************************************************************************

C_DEF int   DI_FileCopy(char *src, char *dst);
C_DEF void  DI_FileShow(char *tit, char *file);
C_DEF MOBJECT DI_FileShowCreate(char *tit, char *file, WM_CLOSE_CB cb);
C_DEF int   DI_FileExist(char *tit);
            // Return: 1 if PATH exist, else return 0
C_DEF int   DI_PathExist(char *path);
C_DEF char * DI_FullName(char *dir, char *name);
C_DEF void  DI_SplitName(char *fullname, char *fpath, char *fname);
C_DEF void  DI_FindExtName(char *fullname, char *fext);
C_DEF void  DI_FindDirName(char *fullname, char *fdir);
C_DEF int   DI_FindDrive(char *fullname);
C_DEF int   DI_ExtNameCode(char *fext);
C_DEF int   DI_FileManager(char *dir, char *_fname, U16 *fmt, int mode);
C_DEF void  DI_FileObjectOpen(MOBJECT shell, const char *ext, char *fname, char *dname);
C_DEF void  DI_FileObjectGetFullName(char *name);
C_DEF void  DI_FileObjectGetPath(char *path);
C_DEF void  DI_FileObjectGetFile(char *fname);
C_DEF void  DI_FileObjectUpdate(void);

// ****************************************************************************
// Math functions on Image ****************************************************
// ****************************************************************************
       /*
        * Open a ghost image (used only as matrix).
        * dx = X matrix dimension
        * dy = Y matrix dimension
        * ifmt = matrix format
        *       0 = 16 bit unsigned
        *       1 = 16 bit RGB 
        *       2 = float (4 bytes) 
        * Return an image identifier (id) 0 to n
        * A negative value indicate an error
        * Errors:
        *       -1 = Memory allocation error
        *       -2 = Type inexistent/Format inexistent
        *       -3 = Too matrix open at the same time
        */
C_DEF int   DI_OpenMatrix(U16 dx, U16 dy, U16 ifmt);
        
        // Close the selected matrix
C_DEF void      DI_CloseMatrix(int s);

C_DEF double    DI_Sigma(double media, int w);
C_DEF double    DI_ScanMaxMin(int w, float *mx, float *mi);
C_DEF void      DI_ScanMaxMinColor(int w);

        // Math operation between images, also with different types and size
        // Parameters:
        // dst = destination and first operand image
        // src = 2nd operand image
        // op = math operation to be prform
        // xof, yof = requested shift for the 2nd operand
        // dscal, sscal = scale factor for 1st and 2nd operand
        // Return:
        // 0 = ok, operation performed
        // 1 = error, 2nd operand don't exist
        // 2 = error, 1st operand don't exist
C_DEF int   DI_MathMerge(int dst, int src, int op, int xof, int yof, float dscal, float sscal);

C_DEF int   DI_Centroid(int s, float *px, float *py, int w, int h, float *dvx);
C_DEF float DI_PeakMedia(int s, int x, int y, int wx, int wy);
C_DEF void  DI_AddMultiply(int srv, double add, double mul);
C_DEF void  DI_Log(int srv);

        // Build a color image from 3 monochrome images
        // Parameters:
        // type = image type: DIF, FIT, IMG, .....
        // _abuf = Filename of the red part
        // _bbuf = Filename of the green part
        // _cbuf = Filename of the blue part
        // rx, ry = shift value for red image
        // gx, gy = shift value for green image
        // bx, by = shift value for blue image
        // kr, kg, kb = constant multiplier for each channel
        // Return:
        // >= 0 Build done, return image server
        // < -10 Loading error
        // -10 different size in image channel
C_DEF int   DI_BuildRGBMerge(int type, char *_abuf, char *_bbuf, char *_cbuf, int rx, int ry, int gx, int gy, int bx, int by, float kr, float kg, float kb);

C_DEF void  DI_ROIAnalyze(int srv, roi *r);
C_DEF int   DI_GaussFitBuffer(int srv, float *i0, float *sigma, int x0, int y0, int wi, int he, float bgvalue);
C_DEF void  DI_Statistics(int server);

        // Set coefficent (com = 1), Execute range adjustment (com = 0)
C_DEF float DI_DataAdj(int s, int com, float data);

        // Return the media value of the selected image
C_DEF float DI_ImageMedia(int s);

        // Calibrate an image (s)
        // dark = image server of the dark image
        // flat = image server of the flat image
        // df   = image server of the dark of the flat image
        // kdark, kflat, kdflat = Constant multiplier for each calibration images
        // Return:
        // 0 = ok
        // 1 = error
C_DEF int   DI_ImageCalibrate(int s, int dark, int flat, int df, float kdark, float kflat, float kdflat);

        // Perform a math operation between two operands
C_DEF float DI_MathOperand(int oper, float dv, float sv);

        // Perform a math operation between value and contents of the memory at x,y coord
        // Parameters:
        // oper:    math operation
        // server:  image server where the first parameter and the result will be place
        // tdata:   data type
        // x,y:     location in the image
        // value:   2nd operand
C_DEF void  DI_WrMath(int oper, int server, int tdata, int x, int y, float value);

        // Normalize image server [s] to [0 - norm] value
C_DEF int   DI_ImageNormalize(int s, float norm);

        // Execute vertical binning of a selected area
        // Parameters:
        // s = image server
        // sx, sy = start of window
        // dx, dy = window dimension
        // data = output of the line
        //
        // Return:
        // 0 = done
        // 1 = error
C_DEF int   DI_VertBin(int s, int sx, int sy, int dx, int dy, double *data);

        // Read a segment of image
        // Parameters:
        // s = Image server
        // mod = 0: Horiz., 1: Vert. direction
        // sx, sy = start of window
        // dx, dy = window dimension
        // data = output of the line
        //
        // Return:
        // 0 = done
        // 1 = error
C_DEF int   DI_ReadSegment(int s, int mod, int sx, int sy, int dx, int dy, double *data);

        // Rotate an image clockwise or counterclockwise
        // Parameters:
        // rot = 0: CW, 1: CCW, rotation
        // s = image server
        //
        // Return:
        // Image server of the rotated image
        // < 0 error
C_DEF int   DI_ImageRotate90(int s, int rot);

        // Rotate an image some arbitrary angle
        // New pixels are generated using bilinear interpolation
        // Parameters:
        // s = Image server
        // ang = angle of rotation 0 - 360
        // xc, yc = Center of rotation
        // fill = Filling value
        // Return:
        // >= 0: Image server, < 0 Error
C_DEF int   DI_ImageRotate(int s, int xc, int yc, float ang, float fill);

        // Build a histogram of an image region
        // data is compressed into 16 bit
        // Return:
        // 0 = ok
        // 1 = fail
C_DEF int   DI_ImageHistogram(int s, int sx, int sy, int dx, int dy, double range, double *data);

        // Perform vertical or horizontal profile projection 
        // Parameters:
        // s = image server 
        // dir = 0: horizontal, 1: vertical
        // sx, sy = start coordinates
        // dx, dy = window dimension
        // data = output of the profile
        // Return:
        // 0 = ok
        // 1 = error
C_DEF int   DI_ProjProfile(int s, int dir, int sx, int sy, int dx, int dy, double *data);

        // Build a density map
        // Parameters:
        // s = image server 
        // sx, sy = start coordinates
        // dx, dy = window dimension
        // Return:
        // >= 0 Image server of the map
        // < 0 error
C_DEF int   DI_ImageDensity(int s, int sx, int sy, int dx, int dy);

C_DEF int   DI_ImageScanMaxMin(int s, float *hig, float *low, int sx, int sy, int dx, int dy);

        // Build an isophotal image form a source image server
        // Parameters:
        // s = image server
        // kfilt = Set kernel filter 0: No filter
        // sx, sy: Start of window
        // dx, dy: Window dimension
        // qtz : Quantization level, accepted range 2-256
        // max,min: min/max value for the range
        // Return:
        // < 0 : error
        // >= 0: Image server with isophotal
C_DEF   int DI_ImageIsophotal(int s, int kfilt, int sx, int sy, int dx, int dy, int qtz, float min, float max);

        // Image convolution
        // Parameters:
        // s = image server
        // kdx,kdy = kernel dimension
        // kern = kernel pointer
        // sx,sy = source of window
        // dx,dy = window dimension
        // Return:
        // 0 = Operation performed
        // 1 = Image don't exist
        // 2 = Kernel is bigger then image
        // 3 = Kernel have not odd dimension
        // 4 = Can't open temporary matrix
C_DEF   int DI_ImageConvolution(int s, int kdx, int kdy, float *kern[], int sx, int sy, int dx, int dy);

        // Collection of kernels
        // Parameter:
        // kern = kernel identifier
        // Return:
        // size: kernel size
        // kernel: convolution matrix
C_DEF   int DI_ConvolutionList(int kern, int *size, float *kernel[]);

        // Perform a matrix convolution on the selected image server
        // Parameters:
        // s: Image server
        // kern: Kernel to be used
        // sx,sy: Source window, if set it -1 operation will be performed on full image
        // dx,dy: Window dimension
        // Return: 
C_DEF   int DI_Convolution(int s, int kern, int sx, int sy, int dx, int dy);

        // Build a test pattern image
        // Parameters:
        // dx, dy: Image dimension
        // type: INTIMG, RGBIMG, FLTIMG
        // function: SQUARE, SIN, LOG, ...
        // period: Period of the function, for trigonometric function this value is an angle (degree)
        // rotation: Angle of view (0-359)
        // Return:
        // >= 0 Image server
C_DEF   int DI_ImageTest(int dx, int dy, int type, int function, float period, float rotation);

        // Slow Fourier transform procedures 
C_DEF   void    DI_SFTcexp(COMPLEX z1, COMPLEX *res);
C_DEF   void    DI_SFTcmult(COMPLEX z1, COMPLEX z2, COMPLEX *res);
C_DEF   void    DI_SFTcsum(COMPLEX z1, COMPLEX z2, COMPLEX *res);
C_DEF   void    DI_SFTcmplx(double rp, double ip, COMPLEX *z);
C_DEF   double  DI_SFTcnorm(COMPLEX z);
C_DEF   void    DI_SlowFT(double *data, COMPLEX *dft, int num);
        
        // Convert a REAL/COMPLEX into real number with log for display 
        // mode = 1: Log output, 0: Lin output
C_DEF   void    DI_SlowFTConvert(int mode, double *data, COMPLEX *dft, int num, double vmin, double vmax);

        // Find max/min value into specified array
C_DEF   void DI_ArrayScanMaxMin(double *data, int num, double *dmin, double *dmax);

        // Calc the frequency response of selected filter kernel
C_DEF   int DI_FrequencyResponse(int kernel);

        // Build an image mediana from an image sequence
        // Use AlfaTrim filter
        // Parameters:
        // prefix  = file name prefix (with path name)
        // imgtype = image file format
        // num     = number of frames
        // media   = num. of frame of central window, to be used in media
        // Return:
        // >= 0    = Image server of the mediana 
        // -10     = Num. of frames ecceeds max num. of opened images at the same time
        // -11     = Can't open image mediana
C_DEF   int DI_Mediana(char *prefix, int imgtype, int num, int media);

C_DEF   int DI_Mandelbrot(char *tit, int xd, int yd, int depth, double infx, double supx, double infy, double supy);


// ****************************************************************************
// Direct acces to the image or matrix ****************************************
// ****************************************************************************

C_DEF float DI_RdMat(int server, int tdata, int x, int y);
C_DEF void  DI_WrMat(int server, int tdata, int x, int y, float value);

/* Useful macros defined in dildef.h for matrix access
 *
 * void UWrMat(int server, int x, int y, U16 v); Write for INTIMG
 * void RWrMat(int server, int x, int y, U16 v); Write for RED channel RGBIMG
 * void GWrMat(int server, int x, int y, U16 v); Write for GREEN channel RGBIMG
 * void BWrMat(int server, int x, int y, U16 v); Write for BLUE channel RGBIMG
 * void FWrMat(int server, int x, int y, float v); Write for FLTIMG
 * void _WrMat(int server, int x, int y, float v); Write for complex in FLTIMG
 *
 * Simmetrical macros for read
 *
 * U16  URdMat(int server, int x, int y);
 * U16  RRdMat(int server, int x, int y);
 * U16  GRdMat(int server, int x, int y);
 * U16  BRdMat(int server, int x, int y);
 * float FRdMat(int server, int x, int y);
 * float _RdMat(int server, int x, int y);
 */


// ****************************************************************************
// Image control **************************************************************
// ****************************************************************************

C_DEF void  DI_RunHisto(void);
C_DEF void  DI_Regen(int s);
C_DEF void  DI_SetName(int s, char *name);
C_DEF void  DI_ImgActivate(int s);
C_DEF int   DI_OpenImage(U16 dx, U16 dy, U16 ifmt, U16 type, char *tit);
        /*
         * pix = pixel zoom (only integer values)
         * mode = 0: 1:1, 1 = forced size, 2 = Fit from frame window
         * wx,wy = requested image dimension
         */
C_DEF int   DI_ImageProperties(int srv, U16 dx, U16 dy, U16 wx, U16 wy, U16 ifmt, U16 sts, char *tit, int pix, int pixy, int mode);
        /*
         * pix = pixel zoom (only integer values)
         * mode = 0: 1:1, 1 = forced size, 2 = Fit from frame window
         * wx,wy = requested image dimension
         * lx, ly = Window position into the screen
         */
C_DEF int   DI_ImagePropertiesPos(int srv, U16 dx, U16 dy, U16 wx, U16 wy, U16 ifmt, U16 sts, char *tit, int pixx, int pixy, int mode, int lx, int ly);
C_DEF void  DI_ImageDraw(int srv, int mode, MIMAGE mim, MOBJECT img, int startx, int starty, int dimx, int dimy, int pixx, int pixy);

        // Protected close image
C_DEF int   DI_CloseImage(int s);

        // Unprotected close image
C_DEF int   DI_UnpCloseImage(int s);

        // Lens operation
C_DEF void  DI_Lens(void);
        // Return: 1 = Lens active, 0 = Lens off
C_DEF int   DI_LensStatus(void);
        // Redraw lens contents
C_DEF void  DI_LensRedraw(void);
C_DEF void  DI_LensClose(void);

C_DEF void  DI_GraphExec(int srv);
C_DEF void  DI_ImageEditInfo(int s);
C_DEF void  DI_ImagesManager(void);
        
        // Check the presence of the selected image server, 1 = present, 0 = absent
C_DEF int   DI_ImageExist(int s);
        
        // Check the size of two image server, 0 = same size, 1 = different
C_DEF int   DI_ImageSizeCheck(int dst, int src);
        
        // Return (x & y) the image server dimension, return code specify the error (1)
C_DEF int   DI_ImageSize(int s, int *x, int *y);
        
        // Copy the contents of src image server into dst image server. Return 1 for an error
        // The image server must have the same size, but different types are accepted
C_DEF int   DI_ImageCopy(int dst, int src);

        // Copy partial image contents to another image with automatic channel select
C_DEF int   DI_ImageCopyPar(int dst, int src, int sx, int sy, int dx, int dy);

        // Return the image type
        //      INTIMG      0   16 bit unsigned image
        //      RGBIMG      1   Color image (RGB)
        //      FLTIMG      2   float image
C_DEF int   DI_ImageType(int s);

        // From image type to default channel, s = image server
C_DEF int   DI_ImageChan(int s);

        // From image chan return the possible image type
C_DEF int   DI_ChanToType(int chan);

        // Save selected image in undo directory
C_DEF int   DI_DoUndo(int s);

        // Restore selected image from undo directory
C_DEF int   DI_DoRedo(int s);

        // Check if two images have the same dimension
        // Return:
        // 0 = ok, same size
        // 1 = different
C_DEF int   DI_CheckImageSize(int s, int d);

        // Arrange all image windows
C_DEF void  DI_ImageArrange(void);


// ****************************************************************************
// Window operations on the image *********************************************
// ****************************************************************************

        // Procedure to retrive window parameters
C_DEF int   DI_WindowPar(char *tit, int *ixs, int *iys, int *ixd, int *iyd);
        
        // Return the active window
C_DEF int   DI_ActiveWindow(int s);

        // Find the first available window identifier
C_DEF int   DI_LookFreeWindow(int s);

        // Find the first created window identifier
C_DEF int   DI_LookFirstWindow(int s);

        // Num. of present windows
C_DEF int   DI_NumOfWindow(int s);

        // Create a new window
C_DEF int   DI_SetNewWindow(int s, int sx, int sy, int dx, int dy);

        // Change the parameter of a window
C_DEF int   DI_ChangeWindow(int s, int win, int sx, int sy, int dx, int dy);

        // Delete a window
C_DEF int   DI_DeleteWindow(int s, int win);

        // Delete all windows
C_DEF void  DI_ClearAllWindow(int s);

        // Retrive window parameters
C_DEF int   DI_GetWindowPar(int s, int win, int *sx, int *sy, int *dx, int *dy);

        // Check the presence of windows (ok = 1, No = 0)
C_DEF int   DI_WinOn(int s);

        // Duplicate a window
C_DEF int   DI_DupWindow(int s, int win);

        // Activate a created window
C_DEF int   DI_ActivateWindow(int s, int win);

        // Copy window parameters into the clipboard
C_DEF int   DI_CopyWindow(int s, int win);

        // Paste window, from clipboard info, into selected image
C_DEF int   DI_PasteWindow(int s);

        // Copy the contents of the selected window
C_DEF int   DI_CopyWindowContents(int s, int win);

        // Paste the window contents
C_DEF int   DI_PasteWindowContents(int s, int oper, int win, int chan);

        // Edit the window data
C_DEF int   DI_EditWindowContents(int s, int win);

        // Paste the window contents to an image
C_DEF int   DI_PasteWindowToImage(void);

        // Glue selected windo
C_DEF int   DI_GlueWindow(int s, int win);

        // UnGlue selected windo
C_DEF int   DI_UnGlueWindow(int s, int win);

        // Fill the window with data
C_DEF int   DI_FillWindow(int s, int win, int chan, float data);

        
// ****************************************************************************
// Flag procedures ************************************************************
// ****************************************************************************

        // Plot a flag on the image
C_DEF void  DI_PlotFlag(int x, int y, int num, MOBJECT draw, MTColor col, MTFont font, int mode);

        // Create a new flag
C_DEF int   DI_SetNewFlag(int s, int x, int y);

        // Return the active flag on specified image
C_DEF int   DI_ActiveFlag(int s);

        // Remove all flags from selected image server
C_DEF void  DI_ClearAllFlag(int s);

        // Delete selected flag
C_DEF int   DI_DeleteFlag(int s, int f);

        // Return the num. of active flag on the selected image server
C_DEF int   DI_NumOfFlag(int s);

        // Return location of selected flag
C_DEF int   DI_LocationFlag(int s, int f, int *x, int *y);



// ****************************************************************************
// Image Edit functions *******************************************************
// ****************************************************************************

C_DEF void  DI_Shift(int w, int vx, int vy, float med);
C_DEF int   DI_Dup(int s);  // Duplicate selected image
        
        // Copy the image info from source server (s) to destination server (d)
C_DEF int   DI_CopyImageInfo(int d, int s);

        // Copy all image attributes from an image server to another
        // Info & palettes
C_DEF void  DI_ImageCopyAttribute(int dst, int src);

        
        // Change the aspect ratio of the image
C_DEF int   DI_ImageFloatResize(int srv, double ix, double iy);
C_DEF int   DI_ImageResize(int s, int x, int y, int w, int h, int dx, int dy, int ox, int oy, float vm);
C_DEF int   DI_DilContr(int s, int vx, int vy, float fill);
C_DEF void  DI_MirrorX(int w);
C_DEF void  DI_MirrorY(int w);
C_DEF void  DI_Negate(int w);

        // Horiz. rotation of a line
        // Parameters:
        // s = image server
        // y = selected row
        // dir = 0 left, 1 right
        // shift = num of shift
        // Return:
        // 0 = ok
        // 1 = error
C_DEF int   DI_LineRotate(int s, int y, int dir, int shift);

        // Block of Horiz. line rotation
        // Parameters:
        // s = image server
        // sy = start row
        // dy = end row
        // dir = 0 left, 1 right
        // shift = num of shift
        // Return:
        // 0 = ok
        // 1 = error
C_DEF int   DI_LineBlockRotate(int s, int sy, int dy, int dir, int shift);

        
        // Split a color image into 3 image components
C_DEF int   DI_SplitImage(int s);

        // Merge a color image into a monochrome
        // mod = 0 Average (R + G + B) / 3
        // mod = 1 NTSC (R * 0.299 + G * 0.587 + B * 0.114)
C_DEF int   DI_MergeColorToMono(int s, int mod);

        // Edit data of a region of interest
C_DEF int   DI_ImageEdit(int s, int xs, int ys, int wx, int wy);
    
        // Image square for FFT
        // s = Image server
        // win = Selected window
        // com = 1: Upper full image, 2: Lower full image, 3: Upper window, 4: Lower window
        // Return: 
        // -10 = window not present
        // -11 = image dimension out of range
C_DEF int   DI_ImageSquare(int s, int win, int com, float media);

        // Convert a selected image (s) to a new data format (type).
        // Parameter chan is used when the new type is an RGB image,
        // you can choose a selective channel (RGB) or in average mode.
C_DEF int   DI_ImageConvert(int s, int type, int schan, int tchan);

        // Fill an image region
        // Parameters:
        // s: Image server
        // ch: Image channel
        // sx,sy = source of window
        // dx,dy = window dimension
        // Return:
        // 0 = Operation performed
        // 1 = Image don't exist
C_DEF int   DI_ImageFill(int s, int ch, int sx, int sy, int dx, int dy, float data);

        // Copy partial image contents to another image with selected channel
        // Parameters:
        // dst = Destination image server
        // src = Source image server
        // schan = Source channel
        // dchan = Destination channel
        // sx,sy = Source of window
        // dx,dy = Window dimension
C_DEF int   DI_ImageCopyParChan(int dst, int src, int dchan, int schan, int sx, int sy, int dx, int dy);

// ***************************************************************************
// Status bar ****************************************************************
// ***************************************************************************

C_DEF void VRange( char *str, int val);


// ***************************************************************************
// Generic Input/Output Functions ********************************************
// ***************************************************************************

C_DEF int   DI_MInput(char *tit, int x, int y, int *len, char *name[], char *pre[], char *out[]);
C_DEF int   DI_Ask(char *tit, char *bmp, char *label, char *pre, int len);
C_DEF void  DI_Grab(MOBJECT w, int type, void *out);
C_DEF void  DI_VarSetRes(int num, char *tit, char *label[], U32 *var);
C_DEF int   DI_ExcelExport(int num, double *data, char *title, char *format, char *fname);
C_DEF char * DI_Parse(FILE *fd, char tok);
C_DEF void  DI_HexEdit(char *fname);

        // Build a radio button list,
        // n = number of items
        // x = number of horizonthal items
        // list = list of name for each item
        // sel = associated code for each item (-1 are reserved)
        // return = -1 if items > 64, else the selected item
C_DEF int   DI_RadioButton(int n, int x, char *title, char *list[], int sel[]);
        
        // Select an RGB channel
        // RMAT     1   Red channel matrix
        // GMAT     2   Green channel matrix
        // BMAT     3   Blue channel matrix
        // ARGB     6    RGB average
C_DEF int   DI_RGB_SelectChannel(void);

        // Select an image type
        // Return:
        // INTIMG = 0   16 bit unsigned image
        // RGBIMG = 1   Color image (RGB)
        // FLTIMG = 2   float image
C_DEF int   DI_SelectImageType(void);

        // Choosing menu for math operations
        // Return:
        // 0 = Adding
        // 1 = Subtract
        // 2 = Dark mode
        // 3 = Average
        // 4 = Multiply
        // 5 = Divide
        // 6 = And
        // 7 = Or
        // 8 = Xor
        // 9 = Move
C_DEF int   DI_ChooseMathOper(void);

        // Select a dynamic range
        // Return:
        // 1 = 8 bit
        // 2 = 10 bit
        // 3 = 12 bit
        // 4 = 14 bit
        // 5 = 15 bit
        // 6 = 16 bit
C_DEF int   DI_SelectRange(void);

        // Build a radio button list,
        // n = number of items
        // x = number of horizonthal items
        // list = list of name for each item
        // return = -1 if items > 64, else the selected item
C_DEF int DI_PushButton(int n, int x, char *title, char *label, char *list[]);


// ****************************************************************************
// Graphics *******************************************************************
// ****************************************************************************

C_DEF int   DI_2DPlotOpen(char *title, int num, double *data, int dx, int dy, char *config, int mode);
C_DEF void  DI_2DPlotRegen(int plot);
C_DEF void  DI_2DPlotLoad(int plot, double *data);
C_DEF void  DI_2DPlotClose(int plot);
C_DEF int   DI_AnimateOpen(char *prefix, int type, int num, MOBJECT pix, int sx, int sy, int width, int height, int dx, int dy);
C_DEF void  DI_AnimateStart(void);
C_DEF void  DI_AnimateClose(void);
C_DEF int   DI_2DLoadConfig(char *name, int p);
C_DEF void  DI_WriteDigit(MOBJECT *pix, char *fmt);


// ****************************************************************************
// Console operation **********************************************************
// ****************************************************************************

C_DEF int   DI_ConsoleOpen(char *title, int col, int row, int display, int scroll);
C_DEF void  DI_ConsoleClear(int n);
C_DEF void  DI_ConsoleRaise(int n);
C_DEF void  DI_ConsoleClose(int n);
C_DEF void  DI_ConsoleScroll(int n);
C_DEF void  DI_ConsolePrint(char *str, int n);
            // Enable (dsp = 1) or disable (dsp = 0) display
C_DEF void  DI_ConsoleMode(int n, int dsp);
C_DEF void  DI_ConsoleDisplay(int n);
C_DEF void  DI_ConsoleLocate(int x, int y, int n);
C_DEF void  DI_ConsoleInput(char *title, int type, int n, void *out);

// ****************************************************************************
// Palette operation **********************************************************
// ****************************************************************************

// Call palette editor
C_DEF void  DI_PaletteMan(void);

// Deallocate MTColor for image palette
C_DEF void  DI_PaletteDeAlloc(MTColor *iPAL);

// Allocate a palette (MTColor)
C_DEF void  DI_PaletteAlloc(MTColor *iPAL, pal *Pal);

// Create a new palette from math function
C_DEF void  DI_PaletteCreate(pal *Pal, int *seed, int func, int level);

// Copy a palette from one source to another
C_DEF void  DI_PaletteCopy(pal *dst, pal *src);

// Invert palette position
C_DEF void  DI_PaletteReverse(pal *src);

// Rotate of n position (with direction +/- shift) a palette
C_DEF void  DI_PaletteRotate(pal *src, int shift, int chan);

// Load a palette from file
C_DEF int   DI_PaletteLoad(pal *Pal, char *dir);

// Load a palette from a binary file
C_DEF int   DI_PaletteLoadBin(pal *Pal, int fd);

// Save a palette to a file
C_DEF int   DI_PaletteSave(pal *Pal, char *dir);

// Save a palette to a binary file
C_DEF int   DI_PaletteSaveBin(pal *Pal, int fd);

// ****************************************************************************
// DIL Internal use ***********************************************************
// ****************************************************************************

C_DEF int   MWriteGIFFile(int s, char *fname);
C_DEF void  DI_ShowMIM(MIMAGE mpd, char *name); // Show bitmap
C_DEF void  DI_MObjectSetPopupHelp(MOBJECT obj, const char *str, int delay, int duration);
C_DEF int   FindKEY(char *buf);
C_DEF void  DI_OpenDigit(void);
C_DEF void  HistoClose(void);