Save.c

Go to the documentation of this file.

#include <io.h>
#include <fcntl.h>
#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "mgui.h"
#include "DAS_Spatram.h"
#include "dcl.h"
#include "dil.h"
#include "bil.h"
#include "DOAS.h"


// CCD & Camera vars
ccd     DC_CCD; // CCD settings
ptf     DC_HP;  // Platform settings
config  Cfg;    // Camera controls & Options
hdrsp   HDRSP;
GratingSt GRS;  //Grating
flag FLAG; //flags structure
bil BIL; //Bortul Library Structure
doas DOAS;

//void D_PrintH(int mod, FILE *fff);


void UPS_Status(void)
{

    
        SYSTEM_POWER_STATUS status;


        GetSystemPowerStatus( &status );

}

void GetDateTime(struct date *dp, struct time *tp, struct tm *when)
{

    time_t now;
    struct tm w;

    time(&now);

    //This code retrive the PC clock time as it is
    //(with or without the daylight saving time setted)
    w = *localtime(&now);

    //This code retrive the PC clock and check if the daylight
    //saving time is setted or not
    //the time stored in the Header of the measurement is always the LST (Local Solar Time)
    /**************************************************************/
    // Check if daylight saving time is in effect 
    // tm_isdst > 0 if daylight saving time is in effect
    // tm_isdst = 0 if daylight saving time is not in effect
    // tm_isdst < 0 if status of daylight saving time is unknown. 
    if (w.tm_isdst)
    {
        now = now - 3600; // 1 hour less
        w = *localtime( &now );

    }
    //Time for Header of Measurement (Local Solar Time)
    tp->ti_sec = w.tm_sec;
    tp->ti_min = w.tm_min;
    tp->ti_hour = w.tm_hour;
    tp->ti_hund = 0;

    //Date for Header of Measurement 
    dp->da_day = w.tm_mday;
    dp->da_mon = w.tm_mon + 1;
    dp->da_year = w.tm_year + 1900;

    when -> tm_sec = w.tm_sec;     /* seconds after the minute - [0,59] */
    when -> tm_min = w.tm_min;     /* minutes after the hour - [0,59] */
    when -> tm_hour = w.tm_hour;    /* hours since midnight - [0,23] */
    when -> tm_mday = w.tm_mday;    /* day of the month - [1,31] */
    when -> tm_mon = w.tm_mon;     /* months since January - [0,11] */
    when -> tm_year = w.tm_year;    /* years since 1900 */
    when -> tm_wday = w.tm_wday;    /* days since Sunday - [0,6] */
    when -> tm_yday = w.tm_yday;    /* days since January 1 - [0,365] */
    when -> tm_isdst = w.tm_isdst;   /* daylight savings time flag */

}

void gettime(struct time *tp)
{
    time_t now;
    struct tm w;

    time(&now);

    //This code retrive the PC clock time as it is
    //(with or without the daylight saving time setted)
    w = *localtime(&now);
    tp->ti_sec = w.tm_sec;
    tp->ti_min = w.tm_min;
    tp->ti_hour = w.tm_hour;
    tp->ti_hund = 0;

    //This code retrive the PC clock and check if the daylight
    //saving time is setted or not
    //the time stored in the Header of the measurement is always the LST (Local Solar Time)
    /**************************************************************/
    // Check if daylight saving time is in effect 
    // tm_isdst > 0 if daylight saving time is in effect
    // tm_isdst = 0 if daylight saving time is not in effect
    // tm_isdst < 0 if status of daylight saving time is unknown. 
    if (w.tm_isdst)
    {
        tp->ti_hour = w.tm_hour - 1;
    }
    //NOTE - In Daylight saving period on midnight the hours became -1 so...         
    //  if((newtime.tm_hour)  == -1)
    //{
        // Necessary for measurements performed at high latitude in summer seasons
    //  newtime.tm_hour = 23;
    //  newtime.tm_yday = newtime.tm_yday - 1;
    //}

    /**************************************************************/


}
void getdate(struct date *tp)
{
    time_t now;
    struct tm w;
    
    time(&now);
    w = *localtime(&now);
    tp->da_day = w.tm_mday;
    tp->da_mon = w.tm_mon + 1;
    tp->da_year = w.tm_year + 1900;
}


int D_WriteInitLog(char *str)
{
    FILE    *fc;
    char    datebuf[9];
    char    timebuf[9];

    _strdate(datebuf);
    _strtime(timebuf); 


    fc = fopen("LOG\\Devices.Log", "a");
    if(fc < 0) return 1;

    fprintf(fc, " %s %s %s\n",datebuf, timebuf, str);

    fclose(fc);
    return 0;

}


/*
 *  
 *
 *  Parameters:
 *
 *  f = file name (include path & extension)
 *  s = Image Number
 *
 *  Return codes:
 *  0 = No Error
 * -1 = Disk i/o error
 */
int D_save_bin(char *f, int s) 
{
    U32     info = 0, palet = 0;
    U16     t, l;
    int     fd, c;
    char    ffile[1024];

    

    // Find char \ if present clear it
    l = strlen(f);
    while(f[l--] != 0x5C);
    l += 2;
    strcpy(ffile, &f[l]);

    //fd = open(f, O_WRONLY | O_BINARY | O_CREAT, S_IWRITE);
    fd = open(f, O_WRONLY | O_BINARY | O_CREAT | O_APPEND, S_IWRITE);
    if(fd < 0)  return(-1);

//  info += write(fd, &info, 4);

    info += write(fd, &palet, 4);

    info += write(fd, &DIL.Img.Idx[s], 2);
    info += write(fd, &DIL.Img.Idy[s], 2);

    t = 0;
    // Exp. code
    info += write(fd, &t, 2);
    // Image type
    info += write(fd, &DIL.Img.Mat[s].type, 2);

    if(DIL.Img.Mat[s].col)
        for(c = 0; c < DIL.Img.Idy[s]; c++)
        {
            info += write(fd, &DIL.Img.Mat[s].Rmat[c * DIL.Img.Idx[s]], DIL.Img.Idx[s] * 2);
            info += write(fd, &DIL.Img.Mat[s].Gmat[c * DIL.Img.Idx[s]], DIL.Img.Idx[s] * 2);
            info += write(fd, &DIL.Img.Mat[s].Bmat[c * DIL.Img.Idx[s]], DIL.Img.Idx[s] * 2);
        }
    if(DIL.Img.Mat[s].type == INTIMG)
        for(c = 0; c < DIL.Img.Idy[s]; c++)
            info += write(fd, &DIL.Img.Mat[s].Imat[c * DIL.Img.Idx[s]], DIL.Img.Idx[s] * 2);
    if(DIL.Img.Mat[s].type == FLTIMG)
        for(c = 0; c < DIL.Img.Idy[s]; c++)
            info += write(fd, &DIL.Img.Mat[s].Fmat[c * DIL.Img.Idx[s]], DIL.Img.Idx[s] * 4);
    // Image statistics
    l = DIF_STAT;               // Keyword
    write(fd, &l, sizeof(U16));
    {
        write(fd, &DIL.Img.Mat[s].Ctrst, sizeof(char));
        write(fd, &DIL.Img.Mat[s].Low, sizeof(float));
        write(fd, &DIL.Img.Mat[s].High, sizeof(float));
        write(fd, &DIL.Img.Mat[s].ILow, sizeof(float));
        write(fd, &DIL.Img.Mat[s].IHigh, sizeof(float));
        write(fd, &DIL.Img.Mat[s].Media, sizeof(float));
        write(fd, &DIL.Img.Mat[s].Sigma, sizeof(float));
        write(fd, &DIL.Img.Mat[s].MaxNumbers, sizeof(float));
    }
    if(DIL.Img.Mat[s].InfoPar)
    {
        // Camera parameter
        l = DIF_CAMERA;             // Keyword
        write(fd, &l, sizeof(U16));
        {
            write(fd, &DIL.Img.Mat[s].CCDName, 20);
            write(fd, &DIL.Img.Mat[s].CamName, 20);
            write(fd, &DIL.Img.Mat[s].off, sizeof(S16));
            write(fd, &DIL.Img.Mat[s].gain, sizeof(double));
            write(fd, &DIL.Img.Mat[s].range, sizeof(S16));
            write(fd, &DIL.Img.Mat[s].SExp, sizeof(double));
            write(fd, &DIL.Img.Mat[s].TAMB, sizeof(S16));
            write(fd, &DIL.Img.Mat[s].TCCD, sizeof(S16));
            write(fd, &DIL.Img.Mat[s].HBin, sizeof(U16));
            write(fd, &DIL.Img.Mat[s].VBin, sizeof(U16));
            write(fd, &DIL.Img.Mat[s].Sx, sizeof(U16));
            write(fd, &DIL.Img.Mat[s].Sy, sizeof(U16));
            write(fd, &DIL.Img.Mat[s].Wx, sizeof(U16));
            write(fd, &DIL.Img.Mat[s].Wy, sizeof(U16));
        }
        // Time date
        l = DIF_TIME;           // Keyword
        write(fd, &l, sizeof(U16));
        {
            
            write(fd, &DIL.Img.Mat[s].TIME, sizeof(struct time));
            write(fd, &DIL.Img.Mat[s].DATE, sizeof(struct date));
        }
    }

    close(fd);

    if(DIL.Img.Mat[s].InfoPar)
    {
        // Write info position
        fd = open(f, O_WRONLY | O_BINARY, S_IWRITE);
        write(fd, &info, 4);
        close(fd);
    }
    return 0;
}


void AssignNewH()
{

}

void D_Print_BIL_H_BIN(int mod, int fd)
{
    unsigned long info = 0;

    
    info += write(fd, &BIL.SPH.location, sizeof(BIL.SPH.location));
    info += write(fd, &BIL.SPH.latitude, sizeof(BIL.SPH.latitude));
    info += write(fd, &BIL.SPH.longitude, sizeof(BIL.SPH.longitude));
    info += write(fd, &BIL.SPH.altitude, sizeof(BIL.SPH.altitude));
    info += write(fd, &BIL.SPH.sza, sizeof(BIL.SPH.sza));

    info += write(fd, &BIL.SPH.DATE, sizeof(struct ddate));
    info += write(fd, &BIL.SPH.TIME, sizeof(struct dtime));

    info += write(fd, &BIL.SPH.mirpos, sizeof(BIL.SPH.mirpos));
    info += write(fd, &BIL.SPH.wavelen, sizeof(BIL.SPH.wavelen));

    info += write(fd, &BIL.SPH.filpos, sizeof(BIL.SPH.filpos));
    info += write(fd, &BIL.SPH.ccdtemp, sizeof(BIL.SPH.ccdtemp));
    info += write(fd, &BIL.SPH.ccdtexp, sizeof(BIL.SPH.ccdtexp));
    info += write(fd, &BIL.SPH.ccdmax, sizeof(BIL.SPH.ccdmax));

    info += write(fd, &BIL.SPH.imgtype, sizeof(BIL.SPH.imgtype));
    info += write(fd, &BIL.SPH.ccdwx, sizeof(BIL.SPH.ccdwx));
    info += write(fd, &BIL.SPH.ccdwy, sizeof(BIL.SPH.ccdwy));
    info += write(fd, &BIL.SPH.ccdsx, sizeof(BIL.SPH.ccdsx));
    info += write(fd, &BIL.SPH.ccdsy, sizeof(BIL.SPH.ccdsy));
    info += write(fd, &BIL.SPH.ccdex, sizeof(BIL.SPH.ccdex));
    info += write(fd, &BIL.SPH.ccdey, sizeof(BIL.SPH.ccdey));
    info += write(fd, &BIL.SPH.ccdvb, sizeof(BIL.SPH.ccdvb));
    info += write(fd, &BIL.SPH.ccdnr, sizeof(BIL.SPH.ccdnr));
    info += write(fd, &BIL.SPH.dummy1, sizeof(BIL.SPH.dummy1));
    info += write(fd, &BIL.SPH.dummy2, sizeof(BIL.SPH.dummy2));
    info += write(fd, &BIL.SPH.dummy3, sizeof(BIL.SPH.dummy3));
    info += write(fd, &BIL.SPH.dummy4, sizeof(BIL.SPH.dummy4));
    info += write(fd, &BIL.SPH.comment, sizeof(BIL.SPH.comment));

}

void D_PrintH_BIN(int mod, int fd)
{
    unsigned long info = 0;

    
    info += write(fd, &HDRSP.s_name, sizeof(HDRSP.s_name));
    info += write(fd, &HDRSP.s_latitude, sizeof(HDRSP.s_latitude));
    info += write(fd, &HDRSP.s_longitude, sizeof(HDRSP.s_longitude));
    info += write(fd, &HDRSP.s_alt, sizeof(HDRSP.s_alt));
    info += write(fd, &HDRSP.s_sza, sizeof(HDRSP.s_sza));

    info += write(fd, &HDRSP.DATE, sizeof(struct date));
    info += write(fd, &HDRSP.TIME, sizeof(struct time));

    info += write(fd, &HDRSP.binmirpos, sizeof(HDRSP.binmirpos));
    info += write(fd, &HDRSP.lambda, sizeof(HDRSP.lambda));

    info += write(fd, &HDRSP.binfilpos, sizeof(HDRSP.binfilpos));
    info += write(fd, &HDRSP.ccdtemp, sizeof(HDRSP.ccdtemp));
    info += write(fd, &HDRSP.ccdtexp, sizeof(HDRSP.ccdtexp));
    info += write(fd, &HDRSP.imgmax, sizeof(HDRSP.imgmax));

    info += write(fd, &HDRSP.imgfmt, sizeof(HDRSP.imgfmt));
    info += write(fd, &HDRSP.ccdwx, sizeof(HDRSP.ccdwx));
    info += write(fd, &HDRSP.ccdwy, sizeof(HDRSP.ccdwy));
    info += write(fd, &HDRSP.ccdxs, sizeof(HDRSP.ccdxs));
    info += write(fd, &HDRSP.ccdys, sizeof(HDRSP.ccdys));
    info += write(fd, &HDRSP.ccdxe, sizeof(HDRSP.ccdxe));
    info += write(fd, &HDRSP.ccdye, sizeof(HDRSP.ccdye));
    info += write(fd, &HDRSP.ccdvbin, sizeof(HDRSP.ccdvbin));
    info += write(fd, &HDRSP.ccdnr, sizeof(HDRSP.ccdnr));
    info += write(fd, &HDRSP.dummy1, sizeof(HDRSP.dummy1));
    info += write(fd, &HDRSP.dummy2, sizeof(HDRSP.dummy2));
    info += write(fd, &HDRSP.dummy3, sizeof(HDRSP.dummy3));
    info += write(fd, &HDRSP.dummy4, sizeof(HDRSP.dummy4));
    info += write(fd, &HDRSP.bincomment, sizeof(HDRSP.bincomment));

}

void D_PrintH_ASCII(int mod, FILE *fff)
{

    fprintf(fff, "LOC: %s ", HDRSP.s_name); //Name of the station
    fprintf(fff, "LAT: %.2lf ", HDRSP.s_latitude);//Station latitude
    fprintf(fff, "LON: %.2lf ", HDRSP.s_longitude);//Station longitude
    fprintf(fff, "ALT[m/asl]: %u ", HDRSP.s_alt);//Station altitude
    fprintf(fff, "SZA: %.2lf\n", HDRSP.s_sza);//SZA
    fprintf(fff, "%d/%02d/%02d ", HDRSP.DATE.da_year, HDRSP.DATE.da_mon, HDRSP.DATE.da_day);
    fprintf(fff, "%02d:%02d:%02d LT ",HDRSP.TIME.ti_hour, HDRSP.TIME.ti_min,HDRSP.TIME.ti_sec);
    fprintf(fff, "%s ", HDRSP.mirpos);
    fprintf(fff, "%d ", HDRSP.lambda);
    fprintf(fff, "%s ", HDRSP.filpos);
    fprintf(fff, "%.2lf ", HDRSP.ccdtemp); 
    fprintf(fff, "%.2lf ", HDRSP.ccdtexp);
    fprintf(fff, "%5u ", HDRSP.imgmax);
    fprintf(fff, "%5u\n", HDRSP.imgmin);

    fprintf(fff, "%d ", HDRSP.imgfmt); //Image Format
    fprintf(fff, "%d ", HDRSP.ccdwx); //X Pixel Tot Number
    fprintf(fff, "%d ", HDRSP.ccdwy); //Y Pixel Tot Number
    fprintf(fff, "%d ", HDRSP.ccdxs); //Window X Start
    fprintf(fff, "%d ", HDRSP.ccdys); //Window Y Start
    fprintf(fff, "%d ", HDRSP.ccdxe); //Window X End
    fprintf(fff, "%d ", HDRSP.ccdye); //Window Y End
    fprintf(fff, "%d ", HDRSP.ccdvbin); // Vertical Binning
    fprintf(fff, "%d ", HDRSP.ccdnr); // rows number

    fprintf(fff, "%d ", HDRSP.dummy1);
    fprintf(fff, "%d ", HDRSP.dummy2);
    fprintf(fff, "%d ", HDRSP.dummy3);
    fprintf(fff, "%d\n", HDRSP.dummy4);
    fprintf(fff, "%s\n", HDRSP.comment);

}

int D_save_bif(char *f, int s) 
{
    unsigned long       info = 0;
    long        l;
    int     fd, x, y;
    char    ffile[1024];

    double pi = 3.1415926535;
    double raddeg = 57.29747;


//  char *buf;
    

    
    // Find char "\" if present clear it
    l = strlen(f);
    while(f[l--] != 0x5C);
    l += 2;
    strcpy(ffile, &f[l]);

    
    //fd = open(ffile, O_WRONLY | O_BINARY | O_CREAT, S_IWRITE);
    fd = open(f, O_WRONLY | O_BINARY | O_CREAT | O_APPEND, S_IWRITE);
    if(fd < 0)  return(-1);
    
        
    // Print on file the header
    D_PrintH_BIN(0, fd);



    if(DIL.Img.Mat[s].type == INTIMG)

        for(x = 0; x < DIL.Img.Idx[s]; x++)
        {
            for(y = 0; y < DIL.Img.Idy[s]; y++)
            {
                //temp = 10000 * sin((x+10)/raddeg);
                //if(temp>= 0)
                //  URdMat(s, x, y) = 30000 - temp;
                //else
                //  URdMat(s, x, y) = -temp + 30000;
                info += write(fd, &URdMat(s, x, y), 2);
            }
        }
    close(fd);

    return 0;
}



int D_save_asc(char *fname, int s)
{
    int     x, y;
    FILE    *fd;
    fd = fopen(fname, "a");
    if(fd < 0) return 1;
    VRange("Export as ASCII", 0);
    // Print on file the header
    D_PrintH_ASCII(0, fd);
    
    for(y = 0; y < DIL.Img.Idy[s]; y++)
    {
        for(x = 0; x < DIL.Img.Idx[s]; x++)
        {
            if((x % 10) == 0)
            {
                if(y == 0 && x == 0)
                {
                }
                else
                    fprintf(fd, "\n", NULL);
            }   
            if(DIL.Img.Mat[s].type == INTIMG)
                fprintf(fd, "%5u ", URdMat(s, x, y));
            if(DIL.Img.Mat[s].type == FLTIMG)
                fprintf(fd, "%f ", FRdMat(s, x, y));
        }
        
        if((y % 40) == 0 && y > 0)
            VRange(NULL, (long) y * 100 / DIL.Img.Idy[s]);
    }
    fprintf(fd, "\n", NULL);
    fclose(fd);
    VRange(NULL, 100);
    return 0;
}






int SaveDataOffLine(char *fname, int mod)
{

    unsigned long       info = 0;
    long        l;
    int     fd;
    char    ffile[1024];
    FILE    *fn;


    double pi = 3.1415926535;
    double raddeg = 57.29747;


//  char *buf;
    

    
    // Find char "\" if present clear it
    l = strlen(fname);
    while(fname[l--] != 0x5C);
    l += 2;
    strcpy(ffile, &fname[l]);

    if(mod) //save in binary mode
    {
        fd = open(fname, O_WRONLY | O_BINARY | O_CREAT | O_APPEND, S_IWRITE);
        if(fd < 0)  return(-1);
    
        D_Print_BIL_H_BIN(0, fd);

        WriteIMG_BIN(fd, BIL.DPLOT.ImatOrig, IDX, IDY);

        close(fd);



    }
    else //save in ASCII mode
    {

        fn = fopen(fname, "a");
        if(fn < 0) return 1;
        // Print on file the header
        D_Print_BIL_H_ASCII(0, fn);

        WriteIMG(fn, BIL.DPLOT.ImatOrig, IDX, IDY);

        fclose(fn);



    }
        
    return 0;

}


void DB_Save(char *tit, int mod)
{
    int er;
    struct tm today;

    if((DAS.Flag.exemode == OFFLINEPLOT) | (DAS.Flag.exemode == DOASMODE))
    {
        SaveDataOffLine(tit, mod);
    }
    else
    {
        GetDateTime(&DIL.Img.Mat[Server].DATE, &DIL.Img.Mat[Server].TIME, &today);
    //  gettime( &DIL.Img.Mat[Server].TIME );
    //  getdate( &DIL.Img.Mat[Server].DATE );

        D_BuildH(mod, Server);

        if(mod) //save in binary mode
            er = D_save_bif(tit, Server);
        else    //save in ASCII mode
            er = D_save_asc(tit, Server);
    }



}


void DB_save_img(char *tit, int mod)
{
    int n;
    FILE    *fd;
    int     fh;
//  struct date d;
//  struct  time t;
    unsigned int y;
    
    
    char    tit1[64];
    char    datebuf[9];
    char    timebuf[9];
    int     Lambda;
    int     riga;
//  int Idx, Idy, x, k,t,j;
    int wl[] = {2823, 3337, 3850, 4358, 4861, 5332, 5814, 6282, 6734, 7201, 7677, 8195, 8622, 9023, 9405, 9758, 10066, 10358};
 // char   *filt[] = {{"NULL"},{"UG11"}, {"UG5 "}, {"BG25"}, {"BG39"}, {"GG45"}, {"BG12"}, {"NULL"}};


 // char   *PMirror[] = {{"PHOTOMETRIC"}, {"RADIOM. DX"}, {"DIRECT DX"},
 //                   {"DIRECT SX"}, {"RADIOM. SX"}};

    Lambda = wl[GRS.Wl];
//  Mirror = MIS.MirPos;

    //data e ora di memorizzazione dello spettro
    _strdate(datebuf);
    _strtime(timebuf); 

    Status("Save Image");
    
    
    if(mod) //binary mode
    {
        fh = open(tit, O_WRONLY | O_BINARY | O_CREAT | O_APPEND, S_IWRITE);
        if ( fh < 0) return;

        //Salva tutte le righe
        riga = 1;
        for(y = 0; y < (unsigned int)IDY; y++)
        //Salva solo 5 righe centrali
        //riga = 4;
        //for(y = 3; y < (DAS.Paramini.ccdWy / DAS.Paramini.VBin) - 3; y++)

        {
            write( fh, &datebuf, sizeof(datebuf));
            write( fh, &timebuf, sizeof(timebuf));
            write( fh, &MIS.Pos, sizeof(MIS.Pos));
            write( fh, &Lambda, sizeof(Lambda));
            write( fh, &FWS.Pos, sizeof(FWS.Pos));

            write( fh, &TExp, sizeof(TExp));
            write( fh, &riga, sizeof(riga));
        //          fwrite( Temp, 1, sizeof(Temp), fd );
            // Commento
            sprintf(tit1, "%s", "Default comment");
            write( fh, &tit1, sizeof(tit1));
            
            
            for(n = 0; n < IDX; n++)
            {
//              Imat[y * DAS.Paramini.ccdWx + n] = n*2;
//              write(fh, &Imat[y * DAS.Paramini.ccdWx + n], sizeof(Imat[y * DAS.Paramini.ccdWx + n]));
            }
            riga++;

        
        }

        close(fh);
    }   
    else
    {
        fd = fopen(tit, "a");
        if(fd == NULL)
        {
            Status("Error opening file");
            return;
        }
    
        //Salva tutte le righe
        riga = 1;
        for(y = 0; y < (unsigned int)IDY; y++)
        //Salva solo 5 righe centrali
        //riga = 4;
        //for(y = 3; y < (DAS.Paramini.ccdWy / DAS.Paramini.VBin) - 3; y++)

        {
            fprintf(fd, "%s   %s ", datebuf, timebuf);//data e ora  //RTC
            fprintf(fd, " %d ", MIS.Pos);   //Posizione specchio
            fprintf(fd, " %5d ", Lambda);       //lunghezza d'onda
            fprintf(fd, " %d ", FWS.Pos);   //Posizione RUOTA FILTRI
            fprintf(fd, " %.2lf ", TExp);   //tempo di integrazione
//          fprintf(fd, " %.1lf ", Temp);   //Temperatura del CCD
            fprintf(fd, " Riga:%d ", riga); //Numero riga
//          fprintf(fd, " %d\n ", VAna[7]); // Pressione esterna
            // Commento
            sprintf(tit1, "%s", "Default comment");
            fprintf(fd, " %s\n ", tit1 ); // Commento
            
            for(n = 0; n < IDX; n++)

            {
//              Imat[y * DAS.Paramini.ccdWx + n]=n * 2;
//              fprintf(fd, " %04u", Imat[y * DAS.Paramini.ccdWx + n]);
            }
            fprintf(fd,"\n");
            riga++;

        
        }
        fclose(fd);

    }




    return;
    
}


int ReadHeaderOnly(FILE *fd)
{

        int     er = 0;
    char    str[128], temp[12];
    int NewnR = 0;

    if(feof( fd ))
    {
        return 1;
    }
    else
    {
/*
    er = fscanf(fd, "%s%s%s%f%s%f%s%u%s%f", temp, BIL.SPH.location, temp, &BIL.SPH.latitude,
        temp, &BIL.SPH.longitude, temp, &BIL.SPH.altitude, temp, &BIL.SPH.sza);

    er = fscanf(fd, "%s %s %s %s %d %s %f %f %u %u", BIL.SPH.StrDate, BIL.SPH.StrTime, temp, BIL.SPH.mirpos, &BIL.SPH.wavelen,
        BIL.SPH.filpos, &BIL.SPH.ccdtemp, &BIL.SPH.ccdtexp, &BIL.SPH.ccdmax,
        &BIL.SPH.ccdmin);

    er = fscanf(fd, "%d%d%d%d%d%d%d%d%d%d%d%d%d", &BIL.SPH.imgtype, &BIL.SPH.ccdwx, &BIL.SPH.ccdwy,
        &BIL.SPH.ccdsx, &BIL.SPH.ccdsy, &BIL.SPH.ccdex, &BIL.SPH.ccdey, &BIL.SPH.ccdvb,
        &BIL.SPH.ccdnr, &BIL.SPH.dummy1, &BIL.SPH.dummy2, &BIL.SPH.dummy3, &BIL.SPH.dummy4);


  */

    er = fscanf(fd, "%s%s%s%lf%s%lf%s%lf%s%lf", temp, BIL.SPH.location, temp, &BIL.SPH.latitude,
        temp, &BIL.SPH.longitude, temp, &BIL.SPH.altitude, temp, &BIL.SPH.sza);

    er = fscanf(fd, "%i/%2u/%2u%2u:%2u:%2u%s%s%d%s%lf%lf%lu%lu", &BIL.SPH.DATE.da_year,
        &BIL.SPH.DATE.da_mon, &BIL.SPH.DATE.da_day, &BIL.SPH.TIME.ti_hour,
        &BIL.SPH.TIME.ti_min, &BIL.SPH.TIME.ti_sec, temp, BIL.SPH.mirpos, &BIL.SPH.wavelen,
        BIL.SPH.filpos, &BIL.SPH.ccdtemp, &BIL.SPH.ccdtexp, &BIL.SPH.ccdmax,&BIL.SPH.ccdmin );

    er = fscanf(fd, "%d%d%d%d%d%d%d%d%d%d%d%d%d", &BIL.SPH.imgtype, &BIL.SPH.ccdwx, &BIL.SPH.ccdwy,
        &BIL.SPH.ccdsx, &BIL.SPH.ccdsy, &BIL.SPH.ccdex, &BIL.SPH.ccdey, &BIL.SPH.ccdvb,
        &BIL.SPH.ccdnr, &BIL.SPH.dummy1, &BIL.SPH.dummy2, &BIL.SPH.dummy3, &BIL.SPH.dummy4);

    er = fscanf(fd, "%s", BIL.SPH.comment); 
    fgets(str, 80, fd);
    }

    return 0;
}
/**********************************/
int ReadHeaderOldF(FILE *fd)
{

    int     er = 0;
    char    str[128], temp[4];



    if(feof( fd ))
    {
        return 1;
    }
    else
    {
        er = fscanf(fd, "%s%s%s%lf%s%lf%s%lf%s%lf", temp, BIL.SPH.location, temp, &BIL.SPH.latitude,
            temp, &BIL.SPH.longitude, temp, &BIL.SPH.altitude, temp, &BIL.SPH.sza);

        er = fscanf(fd, "%i/%u/%u%u:%u:%u%s%s%d%s%lf%lf%lu%lu", &BIL.SPH.DATE.da_year,&BIL.SPH.DATE.da_mon, 
            &BIL.SPH.DATE.da_day, &BIL.SPH.TIME.ti_hour, &BIL.SPH.TIME.ti_min, &BIL.SPH.TIME.ti_sec, temp, 
            BIL.SPH.mirpos, &BIL.SPH.wavelen, BIL.SPH.filpos, &BIL.SPH.ccdtemp, &BIL.SPH.ccdtexp, &BIL.SPH.ccdmax,
            &BIL.SPH.ccdmin);

        er = fscanf(fd, "%d%d%d%d%d%d%d%d%d%d%d", &BIL.SPH.imgtype,
            &BIL.SPH.ccdsx, &BIL.SPH.ccdsy,
            &BIL.SPH.ccdex, &BIL.SPH.ccdey,
            &BIL.SPH.ccdvb, &BIL.SPH.ccdnr,
            &BIL.SPH.dummy1, 
            &BIL.SPH.dummy2,
            &BIL.SPH.dummy3, 
            &BIL.SPH.dummy4);

        er = fscanf(fd, "%s", BIL.SPH.comment); 
        fgets(str, 80, fd);

    }
    
    return 0;
}

void D_PrintHMod(FILE *fff)
{
    
//      spectrumheader pe;
        
/*
        er = fscanf(fd, "%s%s%s%lf%s%lf%s%lf%s%lf", temp, BIL.SPH.location, temp, &BIL.SPH.latitude,
            temp, &BIL.SPH.longitude, temp, &BIL.SPH.altitude, temp, &BIL.SPH.sza);

        er = fscanf(fd, "%i/%u/%u%u:%u:%u%s%s%d%s%lf%lf%lu%lu", &BIL.SPH.DATE.da_year,&BIL.SPH.DATE.da_mon, 
            &BIL.SPH.DATE.da_day, &BIL.SPH.TIME.ti_hour, &BIL.SPH.TIME.ti_min, &BIL.SPH.TIME.ti_sec, temp, 
            BIL.SPH.mirpos, &BIL.SPH.wavelen, BIL.SPH.filpos, &BIL.SPH.ccdtemp, &BIL.SPH.ccdtexp, &BIL.SPH.ccdmax,
            &BIL.SPH.ccdmin);

        er = fscanf(fd, "%d%d%d%d%d%d%d%d%d%d%d", &BIL.SPH.imgtype, &BIL.SPH.ccdsx, &BIL.SPH.ccdsy, &BIL.SPH.ccdex, 
            &BIL.SPH.ccdey, &BIL.SPH.ccdvb, &BIL.SPH.ccdnr, &BIL.SPH.dummy1, &BIL.SPH.dummy2, &BIL.SPH.dummy3, &BIL.SPH.dummy4);

        er = fscanf(fd, "%s", BIL.SPH.comment); 
*/


    fprintf(fff, "LOC: %s ", BIL.SPH.location); //Name of the station
    fprintf(fff, "LAT: %.2lf ", BIL.SPH.latitude);//Station latitude
    fprintf(fff, "LON: %.2lf ", BIL.SPH.longitude);//Station latitude
    fprintf(fff, "ALT[m/asl]: %u ", BIL.SPH.altitude);//Station altitude
    fprintf(fff, "SZA: %.2lf\n", BIL.SPH.sza);//SZA

    fprintf(fff, "%d/%02d/%02d ", BIL.SPH.DATE.da_year, BIL.SPH.DATE.da_mon, BIL.SPH.DATE.da_day);
    fprintf(fff, "%02d:%02d:%02d LT ",BIL.SPH.TIME.ti_hour, BIL.SPH.TIME.ti_min,BIL.SPH.TIME.ti_sec);
    fprintf(fff, "%s ", BIL.SPH.mirpos);
    fprintf(fff, "%d ", BIL.SPH.wavelen);
    fprintf(fff, "%s ", BIL.SPH.filpos);
    fprintf(fff, "%.2lf ", BIL.SPH.ccdtemp); 
    fprintf(fff, "%.2lf ", BIL.SPH.ccdtexp);
    fprintf(fff, "%5u ", BIL.SPH.ccdmax);
    fprintf(fff, "%5u\n", BIL.SPH.ccdmin);
    
    
    // Image format
    fprintf(fff, "%d ", BIL.SPH.imgtype);
//  BIL.SPH.imgtype = 
//  BIL.SPH.camtype =
//  BIL.SPH.ccdtype =
    fprintf(fff, "%d ", BIL.SPH.ccdsx);
    fprintf(fff, "%d ", BIL.SPH.ccdsy);
    fprintf(fff, "%d ", BIL.SPH.ccdex);
    fprintf(fff, "%d ", BIL.SPH.ccdey);
    fprintf(fff, "%d ", BIL.SPH.ccdvb);
    fprintf(fff, "%d ", BIL.SPH.ccdnr);
    fprintf(fff, "%d ", BIL.SPH.dummy1);
    fprintf(fff, "%d ", BIL.SPH.dummy2);
    fprintf(fff, "%d ", BIL.SPH.dummy3);
    fprintf(fff, "%d\n", BIL.SPH.dummy4);
    fprintf(fff, "%s\n", BIL.SPH.comment);


}



void WriteColumn(int mod, FILE *fd)
{

    int     x, y;
//  FILE    *fd;
//  fd = fopen(fname, "a");
//  if(fd < 0) return 1;
//  D_VRange("Column FORMAT processing", 0, 128, 254, 128);

    // Print on file the header
    D_PrintHMod(fd);
    
    if(mod)
        Pix2Wl(0, BIL.SPH.wavelen, DAS.Paramini.ccdXoff, DAS.Paramini.ccdWx + 1, &DOAS);

    for(x = 0; x < IDX; x++)
    {
        
        if(mod)
            fprintf(fd, " %9.4lf", DOAS.lambda[x]);
        else
            fprintf(fd, " %04d", x);
        for(y = 0; y < IDY; y++)
        {   
                fprintf(fd, " %05u", BIL.DPLOT.ImatGraf[y * IDX + x]);
        }
        fprintf(fd, "\n", NULL);
//      if((x % 40) == 0 && x > 0)
//          D_VRange(NULL, (long) x * 100 / IDX, 128, 254, 128);
    }
    fprintf(fd, "\n", NULL);
//  fclose(fd);
//  D_VRange(NULL, 100, 128, 254, 128);
//  return 0;




}

int SmoothFloatData(float *source, float *destination, int horpix, int verpix,
                     int filw, int bp)
{

    int x, y, n ;
    FILE *fd;
    double *avect;
    unsigned long eln = (unsigned long)(2 * (horpix - bp + 1 ))  ;
    
    avect = (double *) calloc( eln, sizeof(double));
    if( avect == NULL )
        return 1;

    for(y = 0; y < verpix; y++)
    {
        n=1;
        for(x = 0; x < horpix; x++)
        {
            if ((x <= horpix - bp ) & (x > 1))
                {
                    avect[n] = (double)source[y * (horpix) + x];
                    n++;
                }       
        }

        SmoothingF(avect, n - 1, filw);
        
        for(x = 0; x < horpix; x++)
        {
            if ((x <= horpix - bp ) & (x > 1))
            {
                destination[y * horpix + x] = (float) avect[x-1] ;
            }

        }
    }
    
    free(avect);

    fd = fopen("SmoothFL_In.tmp", "w");
    if(fd < 0) return 1;
    for(x = 0; x < horpix + 1; x++)
    {
        if ((x <= horpix - bp ) & (x > 1))
        {
            fprintf(fd, "%04u ", x);
    
            for(y = 0; y < verpix; y++)
            {   
                fprintf(fd, "%10.5lf ", source[y * IDX + x]);
            }
            fprintf(fd, "\n", NULL);
        }
    }
    fprintf(fd, "\n", NULL);
    fclose(fd);


    fd = fopen("SmoothFL_Out.tmp", "w");
    if(fd < 0) return 1;

    for(x = 0; x < horpix + 1; x++)
    {
        if ((x <= horpix - bp ) & (x > 1))
        {
            fprintf(fd, "%04u ", x);
    
            for(y = 0; y < verpix; y++)
            {   
                fprintf(fd, "%10.5lf ", destination[y * IDX + x]);
            }
            fprintf(fd, "\n", NULL);
        }
    }
    fprintf(fd, "\n", NULL);
    fclose(fd);

    return 0;
}




int SmoothData(unsigned short *source, float *destination, int horpix, int verpix,
                int filw, int bp)
{

    int x, y, n ;
    double *avect;
    unsigned long eln = (unsigned long)(2 * (horpix - bp + 1 ))  ;
    FILE *fd;
    
    avect = (double *) calloc( eln, sizeof(double));
    if( avect == NULL )
        return 1;

    for(y = 0; y < verpix; y++)
    {
        n=1;
        for(x = 0; x < horpix; x++)
        {
            if ((x <= horpix - bp ) & (x > 1))
                {
                    avect[n] = (double)source[y * (horpix) + x];
                    n++;
                }       
        }

        SmoothingF(avect, n - 1, filw);
        
        for(x = 0; x < horpix; x++)
        {
            if ((x <= horpix - bp ) & (x > 1))
            {
                destination[y * horpix + x] = (float) avect[x-1] ;
            }

        }
    }
    
    free(avect);

    fd = fopen("SmoothUS_In.tmp", "w");
    if(fd < 0) return 1;
//  for(x = 0; x < horpix + 1; x++)
    for(x = 0; x < horpix ; x++)

    {
        if ((x <= horpix - bp ) & (x > 1))
        {
            fprintf(fd, "%04u ", x);
    
            for(y = 0; y < verpix; y++)
            {   
                fprintf(fd, "%05u ", source[y * IDX + x]);
            }
            fprintf(fd, "\n", NULL);
        }
    }
    fprintf(fd, "\n", NULL);
    fclose(fd);


    fd = fopen("SmoothUS_Out.tmp", "w");
    if(fd < 0) return 1;

//  for(x = 0; x < horpix + 1; x++)
    for(x = 0; x < horpix; x++)

    {
        if ((x <= horpix - bp ) & (x > 1))
        {
            fprintf(fd, "%04u ", x);
    
            for(y = 0; y < verpix; y++)
            {   
                fprintf(fd, "%10.5lf ", destination[y * IDX + x]);
            }
            fprintf(fd, "\n", NULL);
        }
    }
    fprintf(fd, "\n", NULL);
    fclose(fd);

    return 0;

}



void WriteSelColandSmoothed(int mod, FILE *fd, int selcol)
{

    int     x, BlindPix_1;
//  FILE    *fd;
//  fd = fopen(fname, "a");
//  if(fd < 0) return 1;
//  D_VRange("Column FORMAT processing", 0, 128, 254, 128);

    BlindPix_1 = 0;
    if (BIL.SPH.ccdwx - (BIL.SPH.ccdex +1) != 0) // se i pixel del sensore sono piu' di quelli in param.ini
        BlindPix_1  = BIL.SPH.ccdwx - (BIL.SPH.ccdex +1) ;

    BIL.ANALYSIS.ImatSmooth = AllocFloatMat(IDX, IDY);

    
    SmoothData(BIL.DPLOT.ImatOrig, BIL.ANALYSIS.ImatSmooth, IDX, IDY, DOAS.FFTFilter, BlindPix_1);

    // Print on file the header
    D_PrintHMod(fd);
    
    for(x = 0; x < IDX - BlindPix_1 + 1; x++)
    {
        
        if(mod)
            fprintf(fd, " %9.4lf", DOAS.lambda[x]);
        else
            fprintf(fd, " %04u", x);
//      for(y = selcol; y < IDY; y++)
//      {   
                fprintf(fd, " %05u %9.4lf", BIL.DPLOT.ImatOrig[selcol * IDX + x],BIL.ANALYSIS.ImatSmooth[selcol * IDX + x]);
//      }
        fprintf(fd, "\n", NULL);
//      if((x % 40) == 0 && x > 0)
//          D_VRange(NULL, (long) x * 100 / IDX, 128, 254, 128);
    }
    fprintf(fd, "\n", NULL);
//  fclose(fd);
//  D_VRange(NULL, 100, 128, 254, 128);
//  return 0;

    BIL.ANALYSIS.ImatSmooth = DeallocFloatMat(BIL.ANALYSIS.ImatSmooth);




}


int DB_Column(char *sourcefilename)
{


    FILE    *fs, *fd;
    char buf[256];
    int er = 0, k = 0;
    char string[4] = ".COL";
    int lunstr;
    char fext[4];

    int fb;
     fext[0] = '\0';

//  MMessageDialog("Full FileName:", nomefile, "ok", NULL);

    lunstr = strlen(sourcefilename);
    strcpy(buf,sourcefilename);
 
    strncpy( buf + (lunstr - 4), string, 4 );
   
    fd = fopen(buf, "a");
    if(fd < 0) return 1;


    DI_FindExtName(sourcefilename, fext);

    D_VRange("Column FORMAT processing", 0, 128, 254, 128);


    if( (strcmp(fext,".dat") == 0) |(strcmp(fext,".Dat") == 0) )
    {
        fs = fopen(sourcefilename, "r");
        if(fs < 0) return 1;


        while( !feof( fs ) )
        {
            /*
            mod = 1 --> Assign Header to plot labels
            mod = 0 --> Read header only
            */
            ReadHeader_ASCII(0, fs);
            if(BIL.DPLOT.ImatGraf == 0)
                BIL.DPLOT.ImatGraf = AllocUSMat(IDX, IDY);

            ReadIMG(fs, BIL.DPLOT.ImatGraf, IDX, IDY);

            if(TOOLS.FlagFilter)
                FilterData(BIL.DPLOT.ImatGraf, IDX, IDY, DOAS.FFTFilter, 30);

            WriteColumn( FLAG.Wl, fd);
            k++;
            if((k % 5) == 0 && k > 0)
                D_VRange(NULL, (long) k * 100 / SAVECNT , 128, 254, 128);
        }
        
//      D_VRange(NULL, 100, 128, 254, 128);
        fclose(fs);
    }
    else if( (strcmp(fext,".bif") == 0) | (strcmp(fext,".Bif") == 0) )
    {
        fb = open(sourcefilename,  O_RDONLY | O_BINARY, S_IREAD );

        while( !eof( fb ) )
        {

            er = ReadHeader_BIN(fb);

            if(BIL.DPLOT.ImatGraf == 0)
                BIL.DPLOT.ImatGraf = AllocUSMat(IDX, IDY);

            ReadIMG_BIN(fb, BIL.DPLOT.ImatGraf, IDX, IDY);

            if(TOOLS.FlagFilter)
                FilterData(BIL.DPLOT.ImatGraf, IDX, IDY, DOAS.FFTFilter, 30);

        WriteColumn( FLAG.Wl, fd);
        k++;
        if((k % 5) == 0 && k > 0)
            D_VRange(NULL, (long) k * 100 / SAVECNT , 128, 254, 128);

        }
//      D_VRange(NULL, 100, 128, 254, 128);
        close (fb);

    }
    D_VRange(NULL, 100, 128, 254, 128);
    fclose(fd);

    return 0;
}