Procedures.c File Reference

DAS high level functions. More...

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

Include dependency graph for Procedures.c:

Go to the source code of this file.

Functions
double	AutoR_No_Shutt (void)
void	AutoR_SetND_Filter (void)
double	AutoR_TestMeas (int mod, double texpmin, double texpar, float level, float levelinf)
double	AutoR_With_Shutt ()
double	AutoRange (int mod)
	Calculate the exposure time The optimum exposure time (TExp) is calculated with an initial TExpAR=0.1 s, and assuming the linearity between the CCD signal and the exposure time. If TExp calculated is lower than the minimum TExp allowed (0.02s) (meaning a saturation of the CCD), the appropriate filter is positioned and the procedure is repeated. If with TExpAR the delta(CCD(x,y))=Max(CCD(x,y))-Min(CCD(x,y)) is lower than 2000 counts (meaning very low radiation intensity) TExpAR is increased and the procedure repeated for at least 4 times (Max TExpAR ~ 5 s) More...
void	D_Average (int mod)
	Performs averaged measurements . More...
void	D_AverageTFix (void)
	NOT Used . More...
void	D_BuildH (int mod, int s)
	Build Header of the measurements . . More...
int	D_Calibra (void)
	Spectral Calibration Procedure for the spectral calibration with HG lamp. Shift of HG spectral line at 4358.4 on pixel 512. More...
void	D_Measure (void)
void	D_Plot (void)
	ViewPlot callback . More...
void	D_Saving (void)
	Saving image. Procedure for saving the CCD Image Used since version 2.1.0. The coiche between binary and ASCII saving mode is obtained with the mode Flag optionini. More...
void	DB_DefectPixCorr ()
	Apply thew pixel correction. . More...
int	DB_GetCCD (int mod)
	Get CCD Image. . More...
void	DB_MirrorX (int w)
double	DB_ScanMaxMin (int w, float *mx, float *mi, int bp)
	Find Max and Min values for the buffer of order w. More...
int	Lookfor4358 (void)
	function to scan the wl() array in order to identify the position of the 4358 reference wavelength return value: er = -1 –> value 4358 not encountered er >= 0 –> value 4358 found at er position More...
int	LookforWl_X (int x)
void	MaskCol (int a, int b, int c, int d, int e)
void	MaskPix (int a, int b, int c, int d, int e, int f)
void	MaskRow (int a, int b, int c, int d, int e)
void	RemoveBlindPixels (void)
void	SaveCalib (int mod)
void	ShutterOpening (int mod)

Variables
AzimuthSt	AST
bil	BIL
config	Cfg
das	DAS
	DAS structure. More...
ccd	DC_CCD
ptf	DC_HP
d_geo	DGEO
	geographical coordinates structure More...
int	ExeREM
int	fftprh = 1
int	fftsavecal = 1
flag	FLAG
	flags structure More...
FilterWheelSt	FWS
	Filter Wheel. More...
GratingSt	GRS
	Grating. More...
hdrsp	HDRSP
float	maxar
float	maxtt
float	minar
float	mintt
MirrorSt	MIS
	Mirror. More...
NDFilterWheelSt	NDFWS
	ND Filter Wheel. More...
paramini	PARAM
	Param.ini. More...
int	SaveCnt = 1
int	ShuttDelay = 0
ZenithSt	ZST

Detailed Description

DAS high level functions.

Author

Daniele Bortoli

Definition in file Procedures.c.

Function Documentation

AutoR_No_Shutt()

double AutoR_No_Shutt

(

void

)

Definition at line 468 of file Procedures.c.

References AutoR_SetND_Filter(), BlindPix, DB_GetCCD(), DB_ScanMaxMin(), DI_Regen(), DIL, das::DOption, ccd::dx, ccd::dy, FDOUBLE, optionini::filtertype, GetDateTime(), img::High, img::IHigh, img::ILow, dil::Img, img::Low, image::Mat, maxar, optionini::maxlvlar, paramini::maxtexp, maxtt, minar, mintt, das::Paramini, Server, TExp, and paramini::VBin.

Referenced by AutoRange().

{

    double TExpAutoR = 0.2;
    double TExpMin=0.05;
//  double TExpTest;
    float treshold = 2;
    float Level = 55000;
    float LevelInf = 1000;
    int numrip, maxrep;
    struct time ACTime;
    struct date ACDate;
    struct tm today;
    double TExpZero;
    double TExpLast;


    GetDateTime(&ACDate, &ACTime, &today);


/*  if (S_zenetr>= 85 & S_zenetr<= 93) // &  ACTime.ti_hour <12)
        Level = 55000;
    else
        Level = 55000;
*/

    /******************************************************************************************
    If the Shutter Uniblitz VS25 is present the minimum Exposure time is 0.02 sec 
    otherwise (if the shutter is NOT installed) the minimum exposure time depends on the CCD 
    Reading Time. This last is a function of the binning parameters and it can be calculated 
    according to the formula (for HIRES_IV):
    
        RT (in ms)= (vp/vb)*Kv + (vp/vb)*(hp/hb)*Kh 
        where:
            vp = vertical pixels number
            vb = vertical binning
            Kv = 0.024 for hires
            hp = horizontal pixels number
            hb = horizontal binning
            Kh = 0.0125
    
     For High values of Vertical Binning the Reading Time (RT) is very short 
     (i.e for VertBin of41-the maximum supported by HiRESIV-RT is less than 0.09 sec)
     therefore the excess of signal due to the over-exposition of the sensor 
     can be neglected.
    ******************************************************************************************/
    //Set Minimum exposure time
    TExpMin = treshold * ((((float)DC_CCD.dy / (float)DAS.Paramini.VBin) * 0.024 + ((float)DC_CCD.dy / 
        (float)DAS.Paramini.VBin) * DC_CCD.dx * 0.0125) / 1000);
    

    
    if(DAS.DOption.filtertype == FDOUBLE)
        maxrep = 6;
    else 
        maxrep = 2;
    
    numrip = 1;
    
        
    /*************************************************/
    Level = (float) DAS.DOption.maxlvlar;   
    /*************************************************/
    /* zero measurement: with TExp = Tmin (No necessity for Loop over the time 
    since this is the minimum time). The cycle is repeated since when the maximum 
    is at least half of the MAXIMUM set signal (LEVEL=60000)*/
    TExp = TExpMin;

    do
    {
        //delay(ShuttDelay);
        DB_GetCCD(1);
        //delay(ShuttDelay);
        // Scan Max Min
        DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);
        DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
        DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
        // Regen the histogram
        DI_Regen(Server);
 
        if(DIL.Img.Mat[Server].IHigh >= Level/4)
        {           
            AutoR_SetND_Filter();
            numrip++;
        }

    }
    while ((DIL.Img.Mat[Server].IHigh >= Level/4) && numrip <= maxrep);

//  Offset = DIL.Img.Mat[Server].IHigh;// - DIL.Img.Mat[Server].ILow;
    maxtt = DIL.Img.Mat[Server].IHigh;
    mintt = DIL.Img.Mat[Server].ILow;
    TExpZero = TExp;



    //The Zero point is calculated and the filter positioned
    //Now the measure (It) for computation of TExp, with TExpAutoR.
    // decrease the Exposure time (till when the time is the double of the Minimum Exposure time)
    maxrep = 6;
    numrip = 1;
    TExpAutoR = 4*TExpMin;
    TExp = TExpAutoR;

    do
    {
        //delay(ShuttDelay);
        DB_GetCCD(1);
        //delay(ShuttDelay);
        // Scan Max Min
        DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);
        DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
        DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
        // Regen the histogram
        DI_Regen(Server);
        
        if(DIL.Img.Mat[Server].IHigh >= Level)  
        {
            TExp = TExp / 1.3;
            numrip++;
        }
        if(DIL.Img.Mat[Server].IHigh - DIL.Img.Mat[Server].ILow <= 100)
        {           
            TExp = TExp * 3;
            numrip++;
        }
    }
    while( (DIL.Img.Mat[Server].IHigh >= Level && numrip < maxrep) 
        || ((DIL.Img.Mat[Server].IHigh - DIL.Img.Mat[Server].ILow <= 100) && numrip < maxrep) );

//  Offset = DIL.Img.Mat[Server].IHigh;// - DIL.Img.Mat[Server].ILow;
    maxar = DIL.Img.Mat[Server].IHigh;
    minar = DIL.Img.Mat[Server].ILow;
    TExpLast = TExp;


    TExp = ( Level * ((1000*(TExpLast- TExpZero))/( maxar - maxtt )))/ 1000;

    if(TExp <= TExpMin)
        TExp = TExpMin;
    
    if( DAS.Paramini.maxtexp == 0.0 )
        TExp = TExp;
    else
    {
        if (TExp >= DAS.Paramini.maxtexp)
            TExp = DAS.Paramini.maxtexp;
        else
            TExp= TExp;
    }

    
    return TExp;




}

Here is the call graph for this function:

Here is the caller graph for this function:

AutoR_SetND_Filter()

void AutoR_SetND_Filter

(

void

)

Definition at line 261 of file Procedures.c.

References delay(), das::DOption, paramini::EqType, FDOUBLE, optionini::filtertype, FPLUS, FSIMPLE, GASCODNG3, das::Paramini, FilterWheelSt::Pos, NDFilterWheelSt::Pos, SD_FilterW(), SD_FNTorqueM(), SD_NDFilterW(), SPATRAM2, SPATRAM3, SPATRAMPLUS, wl, and GratingSt::Wl.

Referenced by AutoR_No_Shutt(), and AutoR_With_Shutt().

{

    if(DAS.DOption.filtertype == FDOUBLE)
    {
        if(DAS.Paramini.EqType == SPATRAM2 || DAS.Paramini.EqType == SPATRAMPLUS || DAS.Paramini.EqType == SPATRAM3)
        {
            if (NDFWS.Pos == 0)
                SD_NDFilterW(1); //ND1
            else if (NDFWS.Pos == 1)
                SD_NDFilterW(2); //ND2
            else if (NDFWS.Pos == 2)
                SD_NDFilterW(3); //ND3
            else if (NDFWS.Pos == 3)
                SD_NDFilterW(4); //ND4
        }
    }
    if(DAS.DOption.filtertype == FPLUS)
    {
//      if(DAS.Paramini.EqType == GASCODNG1)
//      {
            SD_FNTorqueM(1);//ND1
            delay(700);
//      }
    }
    if(DAS.DOption.filtertype == FSIMPLE)
    {
        if  (DAS.Paramini.EqType == GASCODNG3 )
        {
        //*Fil_CodeNG[] = {{"NULL"}, {"B12 "}, {"B12F"}, {"B39 "}, {"B39F"}, {"UG5 "}};
            if ((wl[GRS.Wl] == 3850))
            {
                if ( FWS.Pos == 1); //B12
                    SD_FilterW(2); //B12F
                if ( FWS.Pos == 3); //B39
                    SD_FilterW(4); //B39F
            }
            if (wl[GRS.Wl] == 4358)
            {
            //The Wl 4358 can be used with 2 different filters:BG12 and BG39, with the ND filters also 
                if (FWS.Pos == 0) //B12
                    SD_FilterW(2); //B12F
                if (FWS.Pos == 1) //B12
                    SD_FilterW(2); //B12F
                if (FWS.Pos == 3) //B39
                    SD_FilterW(4); //B39F
            }
            if (wl[GRS.Wl] == 4861)
            { 
                if ((FWS.Pos == 1)) //B12
                    SD_FilterW(2); //B12F
                if ((FWS.Pos == 3)) //B39
                    SD_FilterW(4); //B39F
            }
            if ((wl[GRS.Wl] == 5332) )
            {
                if ((FWS.Pos == 1)) //B12
                    SD_FilterW(2); //B12F
                if ((FWS.Pos == 3)) //B39
                    SD_FilterW(4); //B39F
            }
            if ((wl[GRS.Wl] == 4610) )
            {
                if ((FWS.Pos == 1)) //B12
                    SD_FilterW(2); //B12F
                if ((FWS.Pos == 3)) //B39
                    SD_FilterW(4); //B39F
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

AutoR_TestMeas()

double AutoR_TestMeas	(	int	mod,
		double	texpmin,
		double	texpar,
		float	level,
		float	levelinf
	)

Definition at line 334 of file Procedures.c.

References controlpanel::Albl_IE, BlindPix, paramini::ccdWx, gui::ContrPanel, DB_GetCCD(), DB_ScanMaxMin(), DI_Regen(), DIL, ccd::dx, FlagTExp, das::Gui, img::High, img::IHigh, img::ILow, dil::Img, img::Low, image::Mat, MObjectSetText(), das::Paramini, Server, Status(), and TExp.

Referenced by AutoR_With_Shutt().

{

    char    buf[80];
    int k;
    int FlgSat = 1;

    double FlagTExp = 2.0;

//  double TExpLast;
    double temp = 0;
    int Lim_supinf = 0;

    float treshold = 2;

    float lowval = 700; 
    float Offset = 0;
    int numrip = 0;


    /****************************************************************************************/
    // To take into account the Blind Pixels
    //RC = IDY/2;
    if (DC_CCD.dx - (DAS.Paramini.ccdWx +1) != 0)
    {
        BlindPix  = DC_CCD.dx - DAS.Paramini.ccdWx-1 ;
    }
    /*****************************************************************************************/

    
    if (mod)
        TExp = texpar;
    else
        TExp = texpmin;

    //delay(ShuttDelay);
    DB_GetCCD(1);
    //delay(ShuttDelay);
    // Scan Max Min
    DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);
    DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
    DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
    // Regen the histogram
    DI_Regen(Server);

//Check the obtained signal
    // Max value greater than the superior limit
    if (DIL.Img.Mat[Server].High >= level) 
    {
        // enter in the first do cicle where the exp. time is iteratively reduced 
        //(until TExpMin * treshold)
        do 
        {
            TExp = TExp / FlagTExp;

            sprintf(buf, "%.3lf", TExp);
            MObjectSetText(DAS.Gui.ContrPanel.Albl_IE[0], buf);
            Status("Autoranging >");

            //Measure
            //delay(ShuttDelay);
            DB_GetCCD(1);
            //delay(ShuttDelay);
            // Scan Max Min
            DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);
            DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
            DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
            // Regen the histogram
            DI_Regen(Server);
            
            if(DIL.Img.Mat[Server].High > level && numrip >= 4)
            {
                //Exit DO loop and IF condition with TExp = TExpMin 
                //in order to execute the following IF
                TExp = texpmin;
                return TExp;
            }
            // Increse FlagTExp (in order to reduce the TExp)
            FlagTExp = FlagTExp * 2.5;
            numrip++;
        
        } while(DIL.Img.Mat[Server].High > level ); 

    }
    // Max value lower than the inferior limit
    else if (DIL.Img.Mat[Server].High < levelinf)
    {
        // enter in the second do cicle where the exp. time is iteratively increased 
        // the cycle is repeted at maximum 5 times
        k=0;
        do 
        {
            TExp = TExp * FlagTExp;
            k++;
            sprintf(buf, "%.3lf", TExp);
            MObjectSetText(DAS.Gui.ContrPanel.Albl_IE[0], buf);
            Status("Autoranging >");
            //Measure
            DB_GetCCD(1);
            // Scan Max Min
            DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);
            DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
            DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
            // Regen the histogram
            DI_Regen(Server);
            // Increase FlagTExp (in order to increase the TExp)
            FlagTExp = FlagTExp * 2.5;
        } while((DIL.Img.Mat[Server].High < levelinf) && k < 5); 
        
        sprintf(buf, "%.3lf", TExp);
        MObjectSetText(DAS.Gui.ContrPanel.Albl_IE[0], buf);
    }
    else //No needs for others attempts
    {
        if (mod)
            TExp = TExp;
        else
            TExp = TExp;
        sprintf(buf, "%.3lf", TExp);
        MObjectSetText(DAS.Gui.ContrPanel.Albl_IE[0], buf);

    }
    return TExp;

}

Here is the call graph for this function:

Here is the caller graph for this function:

AutoR_With_Shutt()

double AutoR_With_Shutt

(

)

mha!!!!

Definition at line 627 of file Procedures.c.

References AutoR_SetND_Filter(), AutoR_TestMeas(), BlindPix, paramini::ccdWx, DB_GetCCD(), DB_ScanMaxMin(), DI_Regen(), DIL, das::DOption, ccd::dx, paramini::EqType, FDOUBLE, optionini::filtertype, GASCODNG2, GetDateTime(), img::High, img::IHigh, img::ILow, dil::Img, img::Low, image::Mat, maxar, optionini::maxlvlar, paramini::maxtexp, maxtt, minar, mintt, das::Paramini, ROTSHUT, Server, optionini::shuttertype, TExp, TORQUEM, TROPOGAS, and VS25.

Referenced by AutoRange().

{

    double TExpAutoR = 0.2;
    double TExpMin;
    double TExpZero;
    float Level = 62000;
    float LevelInf = 1000;
    int numrip, maxrep;
    float lowval = 700; 
    float Offset = 0;
    double  TExpLast;
//  double  TExpTest;
    
    struct time ACTime;
    struct date ACDate;
    struct tm today;

    GetDateTime(&ACDate, &ACTime, &today);


//  if ((S_zenetr>= 85 & S_zenetr<= 94)  &  ACTime.ti_hour <12)
//      Level = 57000;
//  else
        Level = 58000;
        if (DAS.Paramini.EqType == GASCODNG2 )
            Level = 54000;
        if (DAS.Paramini.EqType == TROPOGAS)
            Level = 50000;
        

    if (DAS.DOption.shuttertype == VS25) 
        TExpMin = 0.02;
    if(DAS.DOption.shuttertype == ROTSHUT)
        TExpMin = 0.045;
    if (DAS.DOption.shuttertype == TORQUEM)
        TExpMin = 0.08; //per NG2//0.1; //0.08;

    //depending on the installed filter module set the max number of repetition
    if(DAS.DOption.filtertype == FDOUBLE)
        maxrep = 6;
    else 
        maxrep = 2;
    
    numrip = 1;

    Level = (float)DAS.DOption.maxlvlar;


    /****************************************************************************************/
    // To take into account the Blind Pixels
    //RC = IDY/2;
    if (DC_CCD.dx - (DAS.Paramini.ccdWx +1) != 0)
    {
        BlindPix  = DC_CCD.dx - DAS.Paramini.ccdWx-1 ;
    }
    /*****************************************************************************************/


    /* zero measurement: with TExp = Tmin (No necessity for Loop over the time 
    since this is the minimum time). The cycle is repeated since when the maximum 
    is at least half of the MAXIMUM set signal (LEVEL=60000)*/
    TExp = TExpMin;

    do
    {
        //delay(ShuttDelay);
        DB_GetCCD(1);
        //delay(ShuttDelay);
        // Scan Max Min
        DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);
        DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
        DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
        // Regen the histogram
        DI_Regen(Server);
 
        if(DIL.Img.Mat[Server].IHigh >= Level/3)
        {           
            AutoR_SetND_Filter();
            numrip++;
        }
    }
    while ((DIL.Img.Mat[Server].IHigh >= Level/3) && numrip <= maxrep);

    Offset = DIL.Img.Mat[Server].IHigh;// - DIL.Img.Mat[Server].ILow;
    maxtt = DIL.Img.Mat[Server].IHigh;
    mintt = DIL.Img.Mat[Server].ILow;
    TExpZero = TExp;



    //The Zero point is calculated and the filter positioned
    //Now the measure (It) for computation of TExp, with TExpAutoR.
    // decrease the Exposure time (till when the time is the double of the Minimum Exposure time)
    maxrep = 6;
    numrip = 1;

    TExpAutoR = 3*TExpMin;
    
    if (DAS.Paramini.EqType == GASCODNG2 ) //with the torquemotor shutter
        TExpAutoR = 2*TExpMin;
    
    TExp = TExpAutoR;

    do
    {
        //delay(ShuttDelay);
        DB_GetCCD(1);
        //delay(ShuttDelay);
        // Scan Max Min
        DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);
        DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
        DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
        // Regen the histogram
        DI_Regen(Server);
        
        if(DIL.Img.Mat[Server].IHigh >= Level)  
        {
            TExp = TExp/1.3;
            numrip++;
        }
//      if(DIL.Img.Mat[Server].ILow <= LevelInf)        
//          TExp = TExp*1.1;
        else if( (DIL.Img.Mat[Server].IHigh -  maxtt) <= 800)
        {
            TExp = TExpMin * (4 + numrip);
            numrip++;
        }
    }
    while(  ((DIL.Img.Mat[Server].IHigh >= Level || (DIL.Img.Mat[Server].IHigh -  maxtt) <= 800 ) && (numrip < maxrep) ) );
    //while(DIL.Img.Mat[Server].IHigh >= Level && numrip < maxrep && (DIL.Img.Mat[Server].IHigh -  maxtt) <= 800 );
//  while (TExp >= 2* TExpMin || numrip < maxrep);

    Offset = DIL.Img.Mat[Server].IHigh;// - DIL.Img.Mat[Server].ILow;
    maxar = DIL.Img.Mat[Server].IHigh;
    minar = DIL.Img.Mat[Server].ILow;
    TExpLast = TExp;

    //Test 21/04/2015
    if ( (maxar - maxtt) > 0)
    {
        TExp = (double)( Level * ((10000*(TExpLast- TExpZero))/( fabs(maxar - maxtt) )))/ 10000;
        if( DAS.Paramini.maxtexp == 0.0 )
            TExp = TExp;
        else
        {
            if (TExp >= DAS.Paramini.maxtexp)
                TExp = DAS.Paramini.maxtexp;
            else
                TExp= TExp;
        }
    }
//  else if ( (maxar - maxtt) <=0)
//  {
//      TExp = TExpMin;
//  }

    else
    {
        if( DAS.Paramini.maxtexp != 0.0 )
            TExp = DAS.Paramini.maxtexp;
        else
            TExp = 1;
        
        //TExp = ( Level * ((10000*(TExpLast- TExpZero))/( maxar - maxtt+1 )))/ 10000;
    }


    if(TExp <= TExpMin )
        TExp = TExpMin;
    


    return TExp;




    /*****************************************************************************/
    //do the First test Measurement to fix the zero point (with TExpMin)
    TExpZero = AutoR_TestMeas(0, TExpMin, TExpAutoR, Level, LevelInf);
    if (DIL.Img.Mat[Server].High >= Level)
    {
        //depending on the installed filter module set the max number of repetition
        if(DAS.DOption.filtertype == FDOUBLE)
            maxrep = 6;
        else 
            maxrep = 2;
    
        numrip = 1;
        do
        {
            AutoR_SetND_Filter();
            TExpZero = AutoR_TestMeas(0, TExpMin, TExpAutoR, Level, LevelInf);
            numrip++;

            if(DIL.Img.Mat[Server].High<= Level && TExpZero >= TExpMin)
                break;
        }while ((TExpZero <= TExpMin) && (numrip < maxrep));
        Offset = DIL.Img.Mat[Server].IHigh;// - DIL.Img.Mat[Server].ILow;
        maxtt = DIL.Img.Mat[Server].IHigh;
        mintt = DIL.Img.Mat[Server].ILow;
    }
    else
    {
        Offset = DIL.Img.Mat[Server].IHigh;// - DIL.Img.Mat[Server].ILow;
        //TExpTest = TExp; 
        maxtt = DIL.Img.Mat[Server].IHigh;
        mintt = DIL.Img.Mat[Server].ILow;

    }
    /*****************************************************************************/

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


    /******************************************************************************/
    /******************************************************************************/
    //do the Test Measurement with TExpAutoR
    //TExpAutoR = 2 * TExpMin;
    if (TExpZero >=TExpAutoR)
        TExpAutoR= TExpZero*1.1;
    TExpLast = AutoR_TestMeas(1, TExpMin, TExpAutoR, Level, LevelInf);
    if (DIL.Img.Mat[Server].High >= 65535 || TExpLast <= TExpZero)
    {
        //depending on the installed filter module set the max number of repetition
        if(DAS.DOption.filtertype == FDOUBLE)
            maxrep = 6;
        else 
            maxrep = 2;
    
        numrip = 1;
        do
        {
            AutoR_SetND_Filter();
            TExpZero = AutoR_TestMeas(0, TExpMin, TExpAutoR, Level, LevelInf);
            maxtt = DIL.Img.Mat[Server].IHigh;
            mintt = DIL.Img.Mat[Server].ILow;

            TExpLast = AutoR_TestMeas(1, TExpMin, TExpAutoR, Level, LevelInf);
            numrip++;

        }while ((DIL.Img.Mat[Server].High >= Level || TExpLast <= TExpZero) && numrip < maxrep);
        Offset = DIL.Img.Mat[Server].IHigh;// - DIL.Img.Mat[Server].ILow;
        maxar = DIL.Img.Mat[Server].IHigh;
        minar = DIL.Img.Mat[Server].ILow;
    }
    else
    {
        Offset = DIL.Img.Mat[Server].IHigh;// - DIL.Img.Mat[Server].ILow;
        maxar = DIL.Img.Mat[Server].IHigh;
        minar = DIL.Img.Mat[Server].ILow;

    }

            LevelInf = lowval + Offset;


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

    //Final TExp Computation
    //TExpLast = TExp;

    TExp = ( Level * ((1000*(TExpLast- TExpZero))/( maxar - maxtt )))/ 1000;

    return TExp;

}

Here is the call graph for this function:

Here is the caller graph for this function:

AutoRange()

double AutoRange

(

int

mod

)

Calculate the exposure time
The optimum exposure time (TExp) is calculated with an initial TExpAR=0.1 s, and assuming the linearity between the CCD signal and the exposure time.
If TExp calculated is lower than the minimum TExp allowed (0.02s) (meaning a saturation of the CCD), the appropriate filter is positioned and the procedure is repeated.
If with TExpAR the delta(CCD(x,y))=Max(CCD(x,y))-Min(CCD(x,y)) is lower than 2000 counts (meaning very low radiation intensity) TExpAR is increased and the procedure repeated for at least 4 times (Max TExpAR ~ 5 s)

Parameters

mod	0 = first attempt (with no filter) 1 = second attempt (with the filter positioned

Returns

double = exposure time (x.xx sec)

Definition at line 899 of file Procedures.c.

References controlpanel::Albl_IE, AutoR_No_Shutt(), AutoR_With_Shutt(), gui::ContrPanel, DB_GetCCD(), DBDEMO, delay(), das::DOption, optionini::emshutter, paramini::EqType, flag::exemode, das::Flag, FlagTExp, GASCODNG1, das::Gui, MObjectSetText(), das::Paramini, MirrorSt::Pos, S_zenetr, ShuttDelay, Status(), TESTSZAMODE, and TExp.

Referenced by D_Average(), D_AverageTFix(), D_Calibra(), D_Measure(), DB_HorComm_CB(), DB_KeyB_CB(), E_AutoRange(), E_ChkExLamp(), E_HgScan(), E_QjScan(), GetDefPix(), and PerformMeas().

{
    char    buf[80];
    int i;
    int FlgSat = 1;
    double FlagTExp = 2.0;
    double TExpAutoR = 0.2;
    //double TExpMin=0;
//  double TExpLast;
    double temp = 0;
    int Lim_supinf = 0;

    float Level = 55000;
//  float LevelInf;
    float lowval = 700; 
    float Offset = 0;
    static int numrip = 0;

    /*****************************************************************************************/
    // For DEMO Mode 
    if(DAS.Flag.exemode == DBDEMO || DAS.Flag.exemode == TESTSZAMODE)
    {
        for(i=0;i<3; i++)
        {
            delay(ShuttDelay);
            TExp =(float) (3 - i);
            DB_GetCCD(1);
            
        }
        TExp = 1.2;
        return TExp;
    }
    /*****************************************************************************************/



    /******************************************************************************************
    If the Shutter Uniblitz VS25 is present the minimum Exposure time is 0.02 sec 
    otherwise (if the shutter is NOT installed) the minimum exposure time depends on the CCD 
    Reading Time. This last is a function of the binning parameters and it can be calculated 
    according to the formula (for HIRES_IV):
    
        RT (in ms)= (vp/vb)*Kv + (vp/vb)*(hp/hb)*Kh 
        where:
            vp = vertical pixels number
            vb = vertical binning
            Kv = 0.024 for hires
            hp = horizontal pixels number
            hb = horizontal binning
            Kh = 0.0125
    
     For High values of Vertical Binning the Reading Time (RT) is very short 
     (i.e for VertBin of41-the maximum supported by HiRESIV-RT is less than 0.09 sec)
     therefore the excess of signal due to the over-exposition of the sensor 
     can be neglected.
    ******************************************************************************************/
    Status("Autoranging");
if (S_zenetr>= 100 & DAS.Paramini.EqType == GASCODNG1 & MIS.Pos != 2)
{
    TExp = 300.0; 
}
else
{
    if (DAS.DOption.emshutter)
    {
        TExp = AutoR_With_Shutt();
    }   
    else
    {
        TExp = AutoR_No_Shutt();
    }
}
    /*****************************************************************************************/
    
    
    sprintf(buf, "%.3lf", TExp);
    MObjectSetText(DAS.Gui.ContrPanel.Albl_IE[0], buf);
    
    Status("Autoranging DONE");
    return TExp;    


}

Here is the call graph for this function:

Here is the caller graph for this function:

D_Average()

void D_Average

(

int

mod

)

Performs averaged measurements
.

Parameters

mod	= 1 –> perform AutoRanging, = 0 –> DO NOT PERFORM AutoRange

Definition at line 2655 of file Procedures.c.

References AutoRange(), optionini::avgautor, marconi::AVGmat, optionini::avgmode, BlindPix, DB_GetCCD(), DB_ScanMaxMin(), delay(), DI_Regen(), DIL, das::DOption, HGFlg, img::High, IDX, IDY, img::IHigh, img::ILow, img::Imat, dil::Img, img::Low, das::Marconi, image::Mat, MLoopWhileEvents(), MMessageDialog(), N_AVG, N_RM, QJFlg, Server, ShuttDelay, st, Status(), TExp, and TOTTEXP.

Referenced by DB_HorComm_CB(), DB_KeyB_CB(), and PerformMeas().

{
    char    buf[64];
    int     c;
//  int fd;
    long    n, np;
    double TT, DeadTime,availabletime;
    int NM; //Number of calculated/setted measurements 
    //int NRM; // Number of measurements effectively obtained (without the saturated measurements that can occur
    int tmpnavg = 0;
        
    MOBJECT sh;
    int t, j;       
    unsigned long   st, et, x;
    struct tm today;


    
    if(mod) // perform autoranging
    {
        if(DAS.DOption.avgautor)
            AutoRange(0);
        else
        {
            if (TExp==0)
                MMessageDialog("DAS information", "TExp = 0\nThe Average procedure can NOT be executed\nPlease provide a valid TExp\n(Executing a GetCCD or Autoranging)!!", " Ok ", NULL); 
                return ;
        }
    }

    //DAS.Marconi.AVGmat  = AllocFloatMat(IDX, IDY);
    np = IDX * IDY;// * 2;
    //memset(DAS.Marconi.AVGmat, 0, np);
        for(n = 0; n < np; n++)
            DAS.Marconi.AVGmat[n] = 0;
    
    // Fix Number of Measurements
    if(DAS.DOption.avgmode == 0)
    {

        tmpnavg = N_AVG;
        if(TExp > 0.5 && TExp <= 1.0) tmpnavg = 10;
        else
            if(TExp > 1.0) tmpnavg = 2;

        for(c = 0; c < tmpnavg; c++)
        {
            DB_GetCCD(1);
            MLoopWhileEvents(0);
            sprintf(buf,"Averaging #: %d", c+1);
            Status(buf);


            for(n = 0; n < np; n++)
                DAS.Marconi.AVGmat[n] += DIL.Img.Mat[Server].Imat[n];
                //AVGmat[n] += (long) DIL.Img.Mat[Server].Imat[n];
            delay(50);
        }

        for(n = 0; n < np; n++)
            DIL.Img.Mat[Server].Imat[n] = (DAS.Marconi.AVGmat[n] / tmpnavg);
            //DIL.Img.Mat[Server].Imat[n] = AVGmat[n] / tmpnavg;



//      if(DAS.DOption.measmode == 0) //Single
//      {
            DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);           
            DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
            DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
            DI_Regen(Server);
//      }
            Status("Ready");

    }
    //Fix TOT Exposure Time 
    else if(DAS.DOption.avgmode == 1)
    {
        NM = 0;
        if(QJFlg)
            TT = 1;
        if(HGFlg)
            TT = 2;
        if(!HGFlg & !QJFlg)
            TT = TOTTEXP;
        
        //If there is a delay in the shutter opening, this is accounted for 
        //in the computation of the number of measurements 
        if(ShuttDelay > 0)
            DeadTime = (TT *  (double) ShuttDelay/1000 );
        else
            DeadTime = 0;
        
        
        availabletime = TT - DeadTime;

        if (availabletime > 0)
            TT = availabletime;
        else
            TT = TT;

        //First computation of number of measurement
        NM = (int)(TT / (TExp + 0.5));  //0.5 is the average download time for each measurement
        // This is tested for SPATRAM2 instrument


/*
        Computation of CCD reading time 
        DTA Formula: RT (in ms)= (vp/vb)*Kv + (vp/vb)*(hp/hb)*Kh 
        where:
            vp = vertical pixels number
            vb = vertical binning
            Kv = 0.024 for hires
            hp = horizontal pixels number
            hb = horizontal binning
            Kh = 0.0125

*/
/*      RT = (((float)DC_CCD.dy / (float)DAS.Paramini.VBin) * 0.024 +  ((float)DC_CCD.dy / (float)DAS.Paramini.VBin) * DC_CCD.dx * 0.0125)/1000;

        
        if(TExp > RT)
        {
            RTot = NM * RT;
            TT = TT - RTot;
            //Second computation of number of measurement (after the correction due to the reading time     
            NM = (int)(TT / TExp);
        }
        

/*
        Computation of CCD downloading time ( in ms)
        DT = ((vp/vb)*(hp/hb))/KCCD  
        where:
            vp = vertical pixels number
            vb = vertical binning
            hp = horizontal pixels number
            hb = horizontal binning
            KCCD = frequency of the CCD (Front = 40Khz; Back = 60Khz) 
*/
/*      DT = (((float)DC_CCD.dy / (float)DAS.Paramini.VBin) * DC_CCD.dx) / 60000;

//      if(TExp > DT)
//      {
            DTot = NM * DT;
            TT = TT - DTot;
//      }
        
        //Third computation of number of measurement (after the correction due to the Downloading time      
        NM = (int)(TT / TExp);

*/
        N_RM = NM;
        if(NM > 1) 
        {   
            for(c = 0; c < NM; c++)
            {
            
                //st = GetTickCount();

                DB_GetCCD(1);
                MLoopWhileEvents(0);
                
                //et = GetTickCount();
            
                //x = labs(et - st);

                //sprintf(buf, "%6.3lf",  x - (TExp * 1000.0) );
                sprintf(buf,"Avg #: %d on %d. TotTExp: %d s", c+1, NM, TOTTEXP);

                Status(buf);
                // If the spectrum is saturated 
                if ((DIL.Img.Mat[Server].IHigh > 65000) & (c != 0)) 
                {
                    N_RM = N_RM - 1;
                }
                else
                {
                
                    for(n = 0; n < np; n++)
                        DAS.Marconi.AVGmat[n] += DIL.Img.Mat[Server].Imat[n];
                }
            }

            for(n = 0; n < np; n++)
                DIL.Img.Mat[Server].Imat[n] = ( DAS.Marconi.AVGmat[n] / N_RM);



//          if(DAS.DOption.measmode == 0) //Single
//          {
                DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);           
                DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
                DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
                DI_Regen(Server);
//          }

        }
        else //if(NM == 0 or NM ==1)
        {
/*          if(TExp > .5)
            {
                sh = MDCreateExpo("EXPOSURE");
                sprintf(buf, "%6.1lf", TExp);
                DI_WriteDigit(DAS.Marconi.LblExpP, buf);
                DI_WriteDigit(DAS.Marconi.LblExpD, buf);
            }
*/
            sprintf(buf,"Measuring with TExp = %3.1lf" , TExp);
            Status(buf);

            DB_GetCCD(1);

/*          GetDateTime(&DIL.Img.Mat[Server].DATE, &DIL.Img.Mat[Server].TIME, &today);

            st = GetTickCount();
            do
            {
                et = GetTickCount();
                x = labs(et - st);
                MLoopWhileEvents(1);
            //if((x % 10) == 0 && x > 0)
                if(x > 0)
                {
                    sprintf(buf, "%6.1lf", TExp - x / 1000.0 );
                //sprintf(TTot, "%6.1lf", TExp );
                //ShowDown(buf, TTot);
                
                    ShowDown(buf, 0);

                
                }
            }while(labs(et - st) < (TExp * 1000));
*/      
/*          if(TExp > .5)
            {
                MShellUnrealize(sh);
                MShellDestroy(sh);
            }
*/
            N_RM = 1;
        }
    }

    Status("Ready");
//  D_Plot();
    //free(DAS.Marconi.AVGmat);

}

Here is the call graph for this function:

Here is the caller graph for this function:

D_AverageTFix()

void D_AverageTFix

(

void

)

NOT Used
.

Definition at line 2597 of file Procedures.c.

References AutoRange(), marconi::AVGmat, D_Plot(), DB_GetCCD(), DIL, HGFlg, IDX, IDY, img::Imat, dil::Img, das::Marconi, image::Mat, QJFlg, Server, Status(), and TExp.

{

    char    buf[64];
    int     c;
//  int fd;
    long    n, np;
    double TT;
    int NM;

    NM = 0;

    if(QJFlg)
        TT = 1;
    if(HGFlg)
        TT = 2;
    if(!HGFlg & !QJFlg)
        TT = 15;


    AutoRange(0);


    NM = (int)(TT / TExp);

    np = (long) IDX * IDY * 2;

    DAS.Marconi.AVGmat = malloc(np * 4);
    memset(DAS.Marconi.AVGmat, 0, np * 4);


    if(NM > 0) 
    {
        for(c = 0; c < NM; c++)
        {
            DB_GetCCD(1);
            sprintf(buf,"Averaging #: %d on %d", c, NM);
            Status(buf);
            for(n = 0; n < np; n++)
                DAS.Marconi.AVGmat[n] += (long) DIL.Img.Mat[Server].Imat[n];
        }

        for(n = 0; n < np; n++)
            DIL.Img.Mat[Server].Imat[n] = (unsigned short) DAS.Marconi.AVGmat[n] / NM;

    }
    if(NM == 0)
    {
        DB_GetCCD(1);
    }

    D_Plot();

    free(DAS.Marconi.AVGmat);

}

Here is the call graph for this function:

D_BuildH()

void D_BuildH	(	int	mod,
		int	s
	)

Build Header of the measurements .
.

Parameters

mod	0 = ASCII Header 1 = BINARY Header
s	0, 1 = Buffer ccd identifier

Definition at line 63 of file Procedures.c.

References d_geo::alititude, optionini::avgmode, hdrsp::bincomment, hdrsp::binfilpos, hdrsp::binmirpos, hdrsp::ccdnr, marconi::CCDTemp, hdrsp::ccdtemp, hdrsp::ccdtexp, hdrsp::ccdvbin, paramini::ccdWx, hdrsp::ccdwx, paramini::ccdWy, hdrsp::ccdwy, hdrsp::ccdxe, paramini::ccdXoff, hdrsp::ccdxs, hdrsp::ccdye, paramini::ccdYoff, hdrsp::ccdys, hdrsp::comment, img::DATE, hdrsp::DATE, das::DGeo, DIL, das::DOption, hdrsp::dummy1, hdrsp::dummy2, hdrsp::dummy3, hdrsp::dummy4, ccd::dx, ccd::dy, paramini::EqType, FDOUBLE, Fil_Code, Fil_Code8H, Fil_CodeNG, Fil_CodeNG1, Fil_CodeTropo, hdrsp::filpos, optionini::filtertype, FPLUS, GASCODNG1, GASCODNG2, GASCODNG3, GASCODNG4, img::High, dil::Img, hdrsp::imgfmt, hdrsp::imgmax, hdrsp::imgmin, hdrsp::lambda, d_geo::latitude, LIS_, d_geo::longitude, img::Low, das::Marconi, image::Mat, optionini::measmode, Mir_Code, Mir_CodeTropo, hdrsp::mirpos, N_AVG, N_RM, das::Paramini, FilterWheelSt::Pos, NDFilterWheelSt::Pos, MirrorSt::Pos, AzimuthSt::realazpos, ZenithSt::realzenpos, hdrsp::s_alt, hdrsp::s_latitude, hdrsp::s_longitude, d_geo::s_name, hdrsp::s_name, hdrsp::s_sza, S_zenetr, optionini::savingmode, Server, SPATRAM3, TExp, img::TIME, hdrsp::TIME, TMFlg, TROPOGAS, paramini::VBin, wl, and GratingSt::Wl.

Referenced by DB_GetCCD(), and DB_Save().

{
    
    char buf[16];
    // Image format
    if(DAS.DOption.savingmode)
        HDRSP.imgfmt=1;         
    else
        HDRSP.imgfmt=0;

    HDRSP.ccdwx = DC_CCD.dx; //X Pixel Number    
    HDRSP.ccdwy = DC_CCD.dy; //Y Pixel Number


    HDRSP.ccdxs = DAS.Paramini.ccdXoff; // window X Start
    HDRSP.ccdys = DAS.Paramini.ccdYoff; // windowY Start
    HDRSP.ccdxe = DAS.Paramini.ccdWx; // windowX End
    HDRSP.ccdye = DAS.Paramini.ccdWy; // windowY End

    HDRSP.ccdvbin = DAS.Paramini.VBin; //Vertical Binning
    HDRSP.ccdnr = (DAS.Paramini.ccdWy  - DAS.Paramini.ccdYoff) / DAS.Paramini.VBin; //Row Number
    HDRSP.DATE = DIL.Img.Mat[Server].DATE;
    HDRSP.TIME = DIL.Img.Mat[Server].TIME;
    
    
    if(mod) //binary
    {
        if (DAS.Paramini.EqType == TROPOGAS || DAS.Paramini.EqType == SPATRAM3 || DAS.Paramini.EqType == GASCODNG4)
            sprintf(buf, "%s",Mir_CodeTropo[MIS.Pos]);
        else
            sprintf(buf, "%s",Mir_Code[MIS.Pos]);


        sprintf(HDRSP.binmirpos, buf);
    }
    else
    {
        if (DAS.Paramini.EqType == TROPOGAS || DAS.Paramini.EqType == SPATRAM3 || DAS.Paramini.EqType == GASCODNG4)
            sprintf(buf, "%s",Mir_CodeTropo[MIS.Pos]);
        else
            sprintf(buf, "%s",Mir_Code[MIS.Pos]);


        sprintf(HDRSP.mirpos, buf);
    }
    HDRSP.lambda = wl[GRS.Wl];
    
    if(mod)
    {
        if(DAS.Paramini.EqType == LIS_)
            sprintf(HDRSP.binfilpos, Fil_Code8H[FWS.Pos]);
        else
        {
            if(DAS.Paramini.EqType == TROPOGAS)
                sprintf(HDRSP.binfilpos, Fil_CodeTropo[FWS.Pos]);
            else if (DAS.Paramini.EqType == GASCODNG2 || DAS.Paramini.EqType == GASCODNG3 || DAS.Paramini.EqType == GASCODNG4)
                sprintf(HDRSP.binfilpos, Fil_CodeNG[FWS.Pos]);
            else if (DAS.Paramini.EqType == GASCODNG1)
                sprintf(HDRSP.binfilpos, Fil_CodeNG1[FWS.Pos]);
            else
                sprintf(HDRSP.binfilpos, Fil_Code[FWS.Pos]);
        }
    }
    else
    {
        if(DAS.Paramini.EqType == LIS_)
            HDRSP.filpos = Fil_Code8H[FWS.Pos];
        else
        {
            if(DAS.Paramini.EqType == TROPOGAS)
                HDRSP.filpos = Fil_CodeTropo[FWS.Pos];
            else if (DAS.Paramini.EqType == GASCODNG2 || DAS.Paramini.EqType == GASCODNG3 || DAS.Paramini.EqType == GASCODNG4)
                HDRSP.filpos = Fil_CodeNG[FWS.Pos];
            else if (DAS.Paramini.EqType == GASCODNG1)
                sprintf(HDRSP.binfilpos, Fil_CodeNG1[FWS.Pos]);
            else
                HDRSP.filpos = Fil_Code[FWS.Pos];
        }
    }

    HDRSP.ccdtemp = DAS.Marconi.CCDTemp;

    HDRSP.ccdtexp = (float) TExp;
    HDRSP.imgmax = (unsigned int) DIL.Img.Mat[s].High;
    HDRSP.imgmin = (unsigned int) DIL.Img.Mat[s].Low;
/*  HDRSP.imgavg =
    HDRSP.imgsig =
*/
    HDRSP.dummy1 = (int)(ZST.realzenpos * 100); //elevation angle
    HDRSP.dummy2 = (int)(AST.realazpos * 100); //azimuth angle 
    
    
    if(DAS.DOption.filtertype == FDOUBLE)
        HDRSP.dummy3 = NDFWS.Pos;
    else if(DAS.DOption.filtertype == FPLUS)
        HDRSP.dummy3 = TMFlg;
    else
        HDRSP.dummy3 = 0;
    
    if(DAS.DOption.measmode == 1) //measuring with average
    {
        if(DAS.DOption.avgmode == 0)
            HDRSP.dummy4 = N_AVG; // number of measurements in fixed number of measurements
        else
            HDRSP.dummy4 = N_RM; // number of measurements in fixed exposure time
    }
    else
        HDRSP.dummy4 = 0;
    
    if(mod) //binary
        sprintf(HDRSP.bincomment, "Default Comment");
    else
        HDRSP.comment = "Default Comment                                                                                                                                                                                                                                                ";
    
    sprintf(HDRSP.s_name, "%s", DAS.DGeo.s_name);
    HDRSP.s_latitude = (float)DAS.DGeo.latitude;
    HDRSP.s_longitude = (float)DAS.DGeo.longitude;
    HDRSP.s_alt = (unsigned int) DAS.DGeo.alititude;
    HDRSP.s_sza = (float)S_zenetr;

    
    //Image Type, Camera Type, CCD Type, CCDWx, CCDWy, CCDXoff, CCDYoff, VBin
    //Date, Time, MirrorPos, Lambda, Filter, TempCCD, T_Exp, 
    //Max, Min, Media, Deviazione, Dummy1, Dummy2, Dummy3, Dummy4
    //Riga di commento

}

Here is the caller graph for this function:

D_Calibra()

int D_Calibra

(

void

)

Spectral Calibration
Procedure for the spectral calibration with HG lamp. Shift of HG spectral line at 4358.4 on pixel 512.

Definition at line 2313 of file Procedures.c.

References controlpanel::Albl_LS, AMS1, AutoRange(), BlindPix, gui::ContrPanel, D_Plot(), DB_GetCCD(), DB_StepMotor(), DBDEMO, delay(), DIL, GratingSt::dp, paramini::EqType, flag::exec, flag::exemode, ExeREM, das::Flag, GASCODNG1, GASCODNG2, GASCODNG3, GASCODNG4, das::Gui, HgLamp(), IDX, IDY, img::Imat, dil::Img, controlpanel::LedSM, LookforWl_X(), MANUAL, image::Mat, MMessageDialog(), MObjectSetText(), MPixmapSetImageFile(), das::Paramini, flag::plotW, PRGFILE, SaveCalib(), SD_FilterW(), SD_Grating(), SD_Mirror(), Server, stepm::SM_B, SM_stepr(), SPATRAM2, SPATRAM3, SPATRAMPLUS, Status(), stepm::step, das::StepM, SZAMODE, TESTSZAMODE, TROPOGAS, wl, and GratingSt::Wl.

Referenced by DB_HorComm_CB(), DB_KeyB_CB(), E_Calibra(), and E_HGratCal().

{


    long    n;
//  unsigned v;
    int x, y, px, DirCal,  er = 0, c;
    int k;
    int PxHg;
    int exm;
//  int count, i;
    int PosRefWl;

    char    buf[256];
    unsigned int mx;

    Status("Hg Calibration");

    if(DAS.Paramini.EqType == SPATRAMPLUS || DAS.Paramini.EqType == SPATRAM2) 
        SD_FilterW(0); //Hole
    if(DAS.Paramini.EqType == GASCODNG2 || DAS.Paramini.EqType == GASCODNG3)
        SD_FilterW(1); //BG12
    if(DAS.Paramini.EqType == GASCODNG1)
        SD_FilterW(0); //Hole
    if(DAS.Paramini.EqType == GASCODNG4)
        SD_FilterW(2); //BG12F



    BlindPix = 0;
//  SaveCalib();
    if (IDX>=1024)
        BlindPix = IDX - 1024; 

    PxHg = (IDX - BlindPix) / 2;

    exm = DAS.Flag.exemode;

    
    //PosRefWl = Lookfor4358();
    PosRefWl = LookforWl_X(4358);
    /************************************************************/
    if ((exm == DBDEMO) || 
        (exm == MANUAL) ||
        (FLAG.exec == 0 && exm == PRGFILE))
    {

        if (GRS.Wl != PosRefWl)
        {
            //If is not the 4358 spectral window
            sprintf(buf, "You are performing HG calibration in the %.1lf nm spectral window!!!\nUsually this operation is performed in the 435.8 nm window \nDo you want to continue ?", (double)wl[GRS.Wl]/10);
            er = MMessageDialog("DAS information", buf, "Yes, in this window", "Yes, but go to 435.8!", "Cancel Calibration", NULL);
            //if it was chosen to calibrate in the actual spectral window the filter is removed
            if (er==0)
            {
                SD_FilterW(0); //Hole
            }

            if (er == 1)
            {
                
                SD_Grating(PosRefWl); //Positioning at 4358 A

            }
            else if (er == 2)
                return 1;
        }
    }
    else if ((exm == DBDEMO)                        ||
            (exm == MANUAL)                         || 
            (FLAG.exec == 1 && exm == PRGFILE)      ||
            (FLAG.exec == 1 && exm == TESTSZAMODE)  ||
            (FLAG.exec == 1 && exm == SZAMODE))

    {
            ExeREM = 0; 
            SD_Grating(PosRefWl); //Positioning at 4358 A
            ExeREM = 1; 
        

    }
    /************************************************************/

    HgLamp(1);
    if (DAS.Paramini.EqType == TROPOGAS || DAS.Paramini.EqType == SPATRAM3 || DAS.Paramini.EqType == GASCODNG4)
        SD_Mirror(0);
    else
        SD_Mirror(2);

    sprintf(buf, "Wait 5 sec. for HG lamp Heating");
    Status(buf);
    delay(5000);
//  FlagCalibra = 1;




    for(c = 0; c < 10; c++)
    {
        sprintf(buf, "Guess %d", c+1);
        Status(buf);
        
        
        AutoRange(0);

        DB_GetCCD(1);

        //Save Calibration
        if (c==0)
            SaveCalib(0);
        
        y = IDY / 2 ;
        
        
        px = (IDX - BlindPix) / 2;
        mx = 5000;
        for(x = PxHg - 200; x < PxHg + 200; x++)
        {
            if(DIL.Img.Mat[Server].Imat[x + y * IDX] > mx)
            {
                px = x;
                mx = DIL.Img.Mat[Server].Imat[x + y * IDX];
            }
        }
            sprintf(buf, "Hg: %u, found at: %d", mx, px);
            Status(buf);
            delay(1000);
            if((px > (PxHg + 1)) || (px < (PxHg - 1))) //grosso
            {
                
                k=SM_stepr(DAS.StepM.step[AMS1][DAS.StepM.SM_B]);
                n = (PxHg - px) * (k/200-5) * 4; //4 e' il rapporto di riduzione
                                          // il 60  

                if(n < 0)
                    DirCal = 1; 
                else
                    DirCal = 0; 
                
                n = labs(n);
                if(n & DirCal == 0) //si va verso l'UV
                    n += GRS.dp;  // add fixed step number for backlash recovery 
                // Eseguo NStep
                if(n)
                {
                    er = DB_StepMotor(AMS1, 1, n, DirCal);
                    if (er)
                    {
                        MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[AMS1][1], "SYS\\ledGreen.bmp");        
                    }
                }

                //Se ci si e' mossi verso l'UV si fa il recupero del gioco

                if(n & DirCal == 0)       // faccio recupero gioco
                {
                    er=DB_StepMotor(AMS1, 1, GRS.dp, 1);
                    if (er)
                    {
                        MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[AMS1][1], "SYS\\ledGreen.bmp");        
                    }
                }
            
            }

            else break;
        }


    HgLamp(0);
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[1], "4358");
    
    SaveCalib(0);

//  er = AMS_AzzeraCoord(AMS1, 1);
//      if(er)  { Message("No Zero Coord Grating", er); }


    if(DAS.Flag.plotW)
        D_Plot();



    sprintf(buf, "Hg: %u, found at: %d", mx, px);
    Status(buf);
    delay(500);

    return 0;

}

Here is the call graph for this function:

Here is the caller graph for this function:

D_Measure()

void D_Measure

(

void

)

Definition at line 2504 of file Procedures.c.

References AutoRange(), D_Plot(), D_Saving(), DB_GetCCD(), E_REM(), PrgCnt, Program, SD_FilterW(), SD_Grating(), SD_Mirror(), and TExp.

{
    int er=0;
    int l, f, m, a, d, s, g, ss;
    double t;
    extern struct date dok;

//  char buf[80];
//  PrgCnt += 7;


    sscanf(&Program[PrgCnt], "%d%d%d%d%lf%d%d%d", &m, &l, &f, &a, &t, &d, &s, &g);
    


    //Posiziona specchio
    SD_Mirror(m);
    //Posiziona reticolo    
    SD_Grating(l);
    //Posiziona Ruota dei filtri
    SD_FilterW(f);


//  ExeREM = 0;
    if(a)
    {

        AutoRange(0);

         // Ciclo ottimale per Autoranging;
         //Controlla che il valore ottenuto sia compreso tra 1000 e 50000,
         //inoltre esegue l'autoranging fino a che il min-max e' maggiore
         //di 1000
         //oppure il contatore ss sia maggiore di 8
         ss=0;

/*       while ((Low < 1000) || (High > 50000) || (((High-Low) < 400) && (ss < 8) ))
         {
            E_AutoRange();
            if(((TExp && 0.01) == 1) && (High > 50000) && (Low > 1000)) goto Salta;
            while ((High-Low) < 400 && ss < 8)
            {
                FlagTExp = FlagTExp * 3;
                E_AutoRange();
                if((Low < 1000) || (High > 50000) && ss > 0)
                      {
                    ss--;
                      }
                else
                      {
                    ss++;
                      }
            }
            FlagTExp = 1.0;
          }

          FlagTExp = 1.0;
*/


    }
    else
    {
        TExp = t;   
    }
    
    //Measure (d=1) or dark (d=0)
    if(d)
    {
            DB_GetCCD(1);
    }
    else
    {
            DB_GetCCD(0);
    }

    
    if(s)
    {
        D_Saving();
    }
    if(g)
    {
        D_Plot();
    }
//  ExeREM = 1;
    E_REM();


}

Here is the call graph for this function:

D_Plot()

void D_Plot

(

void

)

ViewPlot callback
.

Definition at line 192 of file Procedures.c.

References ViewPlot().

Referenced by D_AverageTFix(), D_Calibra(), D_Measure(), E_HgScan(), E_Meashor(), E_Meashor2(), E_QjScan(), and PerformMeas().

{

    
    ViewPlot(1);
    //MDCreateSh_Plot();

}

Here is the call graph for this function:

Here is the caller graph for this function:

D_Saving()

void D_Saving

(

void

)

Saving image.
Procedure for saving the CCD Image Used since version 2.1.0. The coiche between binary and ASCII saving mode is obtained with the mode Flag optionini.

Returns

void

Definition at line 1369 of file Procedures.c.

References _MAX_PATH, controlpanel::Albl_CS, gui::ContrPanel, d_fileman::DAILYDATADIRECTORY, d_fileman::DATADIRECTORY, DB_Save(), bil::DFILEM, das::DGeo, das::DOption, fftprh, das::Gui, MObjectSetText(), spectrumheader::newdate, spectrumheader::olddate, d_geo::s_name, SaveCnt, SAVECNT, optionini::savingmode, bil::SPH, and Total.

Referenced by D_Measure(), DB_HorComm_CB(), DB_KeyB_CB(), E_Meashor(), E_Meashor2(), E_Save(), GetDefPix(), and PerformMeas().

{

    char tmpbuf[128] ;
    static char tit[_MAX_PATH];
    char    tit1[80];
    time_t ltime;
    struct tm *today;
    int fd, er = 0;


    

    if(fftprh) //flag first time program run here
        {
            /* Get UNIX-style time */
            time( &ltime );
            /* Use time structure to build a customized time string. */
            today = localtime( &ltime );
            /* Use strftime to build a customized time string. */
            strftime( tmpbuf, 7,"%y%m%d", today );
            
            sprintf(BIL.DFILEM.DAILYDATADIRECTORY,"%s\\%s",BIL.DFILEM.DATADIRECTORY,tmpbuf);
            
            //_chdir( BIL.DFILEM.DATADIRECTORY ); 
            
            er = _mkdir( BIL.DFILEM.DAILYDATADIRECTORY );
/*
            if ( er )  //error in creating dir
            {
                if(EEXIST)
                    _chdir( BIL.DFILEM.DAILYDATADIRECTORY ); 
                else if (ENOENT)


            }
            else
            {
                _chdir( BIL.DFILEM.DAILYDATADIRECTORY ); 
            }
*/
            fftprh=0;   
            if(DAS.DOption.savingmode) // Binary saving
            {
                do
                {
                    Total++;
                    //sprintf(tit, "DATA\\%s%s%03d.bif", DGEO.s_name, tmpbuf, Total);
                    sprintf(tit, "%s\\%s%s%03d.bif",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf, Total);
                    fd = access(tit, 0);        
                }while(!fd);
                DB_Save(tit, 1);
            }
            else  //ASCII saving
            {
                do
                {
                    Total++;
                    //sprintf(tit, "DATA\\%s%s%03d.dat", DGEO.s_name, tmpbuf, Total);
                    sprintf(tit, "%s\\%s%s%03d.dat",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf, Total);
                    sprintf(tit1, "%s", tit+5);
                    fd = access(tit, 0);        
                }while(!fd);
                DB_Save(tit, 0);
            }
            sprintf(BIL.SPH.olddate, "%s",tmpbuf);

        }
    else
        {
        
        
            /* Get UNIX-style time */
            time( &ltime );
            /* Use time structure to build a customized time string. */
            today = localtime( &ltime );
            /* Use strftime to build a customized time string. */
            strftime( BIL.SPH.newdate, 7,"%y%m%d", today );
            /* Use strftime to build a customized time string. */
            strftime( tmpbuf, 7,"%y%m%d", today );


        
        
        // Se e' cambiata la data rimette a 1 il contatore del numero dei files 
        if(strcmp(BIL.SPH.newdate, BIL.SPH.olddate) != 0)
            {
                sprintf(BIL.SPH.olddate, "%s",BIL.SPH.newdate);
                Total = 0;
    
                sprintf(BIL.DFILEM.DAILYDATADIRECTORY,"%s\\%s",BIL.DFILEM.DATADIRECTORY,tmpbuf);
                er = _mkdir( BIL.DFILEM.DAILYDATADIRECTORY );

                /*****************************/
                    if(DAS.DOption.savingmode) // Binary saving
                    {
                        do
                        {
                            Total++;
//                          sprintf(tit, "DATA\\%s%s%03d.bif", DGEO.s_name, tmpbuf, Total);
                            sprintf(tit, "%s\\%s%s%03d.bif",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf, Total);         
                            fd = access(tit, 0);        
                        }while(!fd);
                        DB_Save(tit, 1);
                    }
                    else  //ASCII saving
                    {
                        do
                        {
                            Total++;
//                          sprintf(tit, "DATA\\%s%s%03d.dat", DGEO.s_name, tmpbuf, Total);
                            sprintf(tit, "%s\\%s%s%03d.dat",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf, Total);
                            sprintf(tit1, "%s", tit+5);
                            fd = access(tit, 0);        
                        }while(!fd);
                        DB_Save(tit, 0);
                    }
/*****************************/
            }
        //Se ha raggiunto il numero di acquisizioni SAVECNT=50
        if((SaveCnt % SAVECNT) == 0)
            {
            if(DAS.DOption.savingmode)
                {
//              sprintf(tit, "DATA\\%s%s%03d.bif", DGEO.s_name, tmpbuf, Total);
                sprintf(tit, "%s\\%s%s%03d.bif",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf, Total);         
                Total++;
                DB_Save(tit, 1);
                }
            else
                {
                //sprintf(tit, "DATA\\%s%s%03d.dat", DGEO.s_name, tmpbuf, Total);
                sprintf(tit, "%s\\%s%s%03d.dat",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf, Total);
                Total++;
                DB_Save(tit, 0);
                }
            }
        else
            {
            if(DAS.DOption.savingmode)
                {
                //sprintf(tit, "DATA\\%s%s%03d.bif", DGEO.s_name, tmpbuf, Total);
                sprintf(tit, "%s\\%s%s%03d.bif",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf, Total);         
                DB_Save(tit, 1);
                }
            else
                {
                //sprintf(tit, "DATA\\%s%s%03d.dat", DGEO.s_name, tmpbuf, Total);
                sprintf(tit, "%s\\%s%s%03d.dat",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf, Total);
                DB_Save(tit, 0);
                }
            }
        }
    

    
    sprintf(tit1, "%s%s%03d.bif",DAS.DGeo.s_name, tmpbuf, Total);   
    MObjectSetText(DAS.Gui.ContrPanel.Albl_CS[3], tit1);
    sprintf(tit1, "%05d", SaveCnt);
    MObjectSetText(DAS.Gui.ContrPanel.Albl_CS[2], tit1);

    SaveCnt++;  



}

Here is the call graph for this function:

Here is the caller graph for this function:

DB_DefectPixCorr()

void DB_DefectPixCorr

(

void

)

Apply thew pixel correction.
.

Choose the buttons to enable/disable. Repaced with DB_KB_ButtonActive();
.

Definition at line 1568 of file Procedures.c.

References CItem, MaskCol(), MaskedCol, MaskedPix, MaskedRow, MaskPix(), MaskRow(), PItem, and RItem.

Referenced by DB_GetCCD(), and E_Dark().

{
    int i;


    for(i=0;i<PItem;i++)
    {

        MaskPix(MaskedPix[i][0], MaskedPix[i][1], MaskedPix[i][2], MaskedPix[i][3], MaskedPix[i][4], MaskedPix[i][5]);

    }


    for(i=0;i<CItem;i++)
    {

        MaskCol(MaskedCol[i][0], MaskedCol[i][1], MaskedCol[i][2], MaskedCol[i][3], MaskedCol[i][4]);
        
    }


    for(i=0;i<RItem;i++)
    {

        MaskRow(MaskedRow[i][0], MaskedRow[i][1], MaskedRow[i][2], MaskedRow[i][3], MaskedRow[i][4]);
        

    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

DB_GetCCD()

int DB_GetCCD

(

int

mod

)

Get CCD Image.
.

Parameters

mod	0 –> Dark measurement 1 –> Light measurement

Returns

er = 0

Definition at line 1749 of file Procedures.c.

References img::BHigh, BlindPix, img::BLow, countsopsh, D_BuildH(), optionini::darkremove, optionini::darksource, img::DATE, DB_DefectPixCorr(), DB_MirrorX(), DB_ScanMaxMin(), DBDEMO, DC_GetCCD(), delay(), DI_Regen(), DI_ScanMaxMin(), DI_WriteDigit(), DIL, das::DOption, flag::exemode, das::Flag, GetDateTime(), img::GHigh, img::GLow, img::High, IDX, IDY, img::IHigh, img::ILow, img::Imat, ImatDark, dil::Img, optionini::imgtype, INTIMG, marconi::LblExpD, marconi::LblExpP, img::Low, das::Marconi, image::Mat, MDCreateExpo(), optionini::measmode, optionini::mirrorimg, MLoopWhileEvents(), MShellDestroy(), MShellUnrealize(), optionini::pixcorr, RemoveBlindPixels(), RGBIMG, img::RHigh, img::RLow, optionini::savingmode, Server, ShowDown(), ShuttDelay, st, TESTSZAMODE, TExp, img::TIME, img::type, and XAX.

Referenced by AutoR_No_Shutt(), AutoR_TestMeas(), AutoR_With_Shutt(), AutoRange(), D_Average(), D_AverageTFix(), D_Calibra(), D_Measure(), DB_AskCB(), DB_HorComm_CB(), DB_KeyB_CB(), E_GetCCD(), E_HgScan(), E_Meashor(), E_Meashor2(), E_QjScan(), GetDefPix(), and PerformMeas().

{

    char buf[80];
    MOBJECT sh;
    int t, j;       
    unsigned long   st, et, x;
    struct tm today;

                        

if(DAS.DOption.measmode == 0) //Single
{
    if(TExp > .5)
    {
        sh = MDCreateExpo("EXPOSURE");
        sprintf(buf, "%6.1lf", TExp);
        
        DI_WriteDigit(DAS.Marconi.LblExpP, buf);
        DI_WriteDigit(DAS.Marconi.LblExpD, buf);

    
    }

}
/*************************************************************************/
    // DEMO mode
    if((DAS.Flag.exemode == DBDEMO) | (DAS.Flag.exemode == TESTSZAMODE))
    {

        
        GetDateTime(&DIL.Img.Mat[Server].DATE, &DIL.Img.Mat[Server].TIME, &today);
        //gettime( &DIL.Img.Mat[Server].TIME );

        st = GetTickCount();
        do
        {
            et = GetTickCount();
            x = labs(et - st);
            MLoopWhileEvents(1);
            //if((x % 10) == 0 && x > 0)
            if(x > 0)
            {
                sprintf(buf, "%6.1lf", TExp - x / 1000.0 );
                //sprintf(TTot, "%6.1lf", TExp );
                //ShowDown(buf, TTot);
                
                    ShowDown(buf, 0);

                
            }
        }while(labs(et - st) < (TExp * 1000));
        
        if(DAS.DOption.measmode == 0) //Single Measurement
        {
            if(TExp > .5)
            {
                MShellUnrealize(sh);
                MShellDestroy(sh);
            }
        }
        
        return 0;
    }

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

/*      
void DC_GetWinCCD(int mode, double expos, int sx, int sy, int, dx, int dy, Unsigned *mat, int camera);
Descrizione:
Procedura che permette di leggere un’immagine selezionando un’area definita del ccd.
I parametri che devono essere specificati sono:
1. mode, Impostandolo a 0 si effettua una dark, con 1 si riprende l’immagine.
2. expos, Tempo di esposizione espresso in secondi.
3. sx, sy, Coordinate di origine della finestra.
4. dx, dy Dimensione in pixel della finestra.
5. mat, Array lineare dove viene memorizzata l’immagine. L’array mat deve essere dimensionato secondo:
dimx x dimy x 2.
6. camera, specifica quale camera dell’array viene utilizzata (se questa modalita’ e’ attiva).
*/



    if(!DAS.DOption.imgtype)   //Mono image 
    /*******  MONO IMAGE ***************/   
    {       
        DIL.Img.Mat[Server].type = INTIMG;
        if(mod) // Light Measurement
        {
/*
                sx = DAS.Paramini.ccdXoff;
                sy = DAS.Paramini.ccdYoff;
                dx = DAS.Paramini.ccdWx - DAS.Paramini.ccdXoff;
                dy = DAS.Paramini.ccdWy - DAS.Paramini.ccdYoff;
                DC_StopNow;
                DC_FGetWinCCD(1, TExp, sx, sy, dx, dy, Mat[Server].Imat, 0);
*/
            if(DAS.DOption.darkremove) // Remove Dark from Measurements
            {
                if(DAS.DOption.darksource) // Dark Source = Full Frame
                {
                    /*******************************/
                    //Dark Measurement
                    DC_GetCCD(0, TExp, DIL.Img.Mat[Server].Imat, 0);
                    if (DAS.DOption.mirrorimg[XAX] == 1)
                        DB_MirrorX(Server); //Mirror X axis
                    if (DAS.DOption.pixcorr)
                        DB_DefectPixCorr();
                    for(t = 0; t < IDY; t++)
                    {
                        for(j = 0; j < IDX ; j++)
                        {
                            ImatDark[t * IDX + j] = (unsigned short) DIL.Img.Mat[Server].Imat[t * IDX + j]; 
                        }
                    }
                    /********************************/
                    // Light Measurement
                    // count opening shutter
                    countsopsh++;
                    delay(ShuttDelay);
                    DC_GetCCD(1, TExp, DIL.Img.Mat[Server].Imat, 0);
                    //Image Rotation
                    /*  if (DAS.Paramini.EqType == SPATRAM2)
                        {
                            U16 sav[3];
                            U32 len = (unsigned long) IDX * (unsigned long) IDY; //DC_CCD.dx * DC_CCD.dy; // dimX e dimY = dimensione immagine

                            sav[0] = DIL.Img.Mat[Server].Imat[0];
                            sav[1] = DIL.Img.Mat[Server].Imat[1];
                            memcpy(&DIL.Img.Mat[Server].Imat[0], &DIL.Img.Mat[Server].Imat[2], (IDX << 1)  );
                         
                            DIL.Img.Mat[Server].Imat[len - 1] = sav[1];
                            DIL.Img.Mat[Server].Imat[len ] = sav[0];

                            sav[0] = DIL.Img.Mat[Server].Imat[IDX-3];
                            sav[1] = DIL.Img.Mat[Server].Imat[IDX-2];

                            DIL.Img.Mat[Server].Imat[IDX-1] = sav[0];
                            DIL.Img.Mat[Server].Imat[IDX-3] = sav[1];
                        }

                      */ 
                     
                        delay(ShuttDelay);
                        if (DAS.DOption.mirrorimg[XAX] == 1)
                            DB_MirrorX(Server); //Mirror X axis
                        if (DAS.DOption.pixcorr)
                            DB_DefectPixCorr();
                    //sottrae la dark alla misura
                    //ATTENZIONE quando la dark e' maggiore della misura 
                    //la sottrazione non funziona RIVEDERE
                    //RIVISTO - si aggiunge 100 alla misura!!!! (Manuele Dixit)
                    for(t = 0; t < IDY; t++)
                    {
                        for(j = 0; j < IDX ; j++)
                        {
                            DIL.Img.Mat[Server].Imat[t * IDX + j] = (unsigned short) (DIL.Img.Mat[Server].Imat[t * IDX + j] + 100) - ImatDark[t * IDX + j]; 
                        }
                    }
                }
                else // Dark Source = Blind Pixels
                {
                    // Light Measurement
                    // count opening shutter
                    countsopsh++;
                    delay(ShuttDelay);
                    DC_GetCCD(1, TExp, DIL.Img.Mat[Server].Imat, 0);
                        //Image Rotation
                    /*  if (DAS.Paramini.EqType == SPATRAM2)
                        {
                            U16 sav[3];
                            U32 len = (unsigned long) IDX * (unsigned long) IDY; //DC_CCD.dx * DC_CCD.dy; // dimX e dimY = dimensione immagine

                            sav[0] = DIL.Img.Mat[Server].Imat[0];
                            sav[1] = DIL.Img.Mat[Server].Imat[1];
                            memcpy(&DIL.Img.Mat[Server].Imat[0], &DIL.Img.Mat[Server].Imat[2], (IDX << 1)  );
                         
                            DIL.Img.Mat[Server].Imat[len - 1] = sav[1];
                            DIL.Img.Mat[Server].Imat[len ] = sav[0];

                            sav[0] = DIL.Img.Mat[Server].Imat[IDX-3];
                            sav[1] = DIL.Img.Mat[Server].Imat[IDX-2];

                            DIL.Img.Mat[Server].Imat[IDX-1] = sav[0];
                            DIL.Img.Mat[Server].Imat[IDX-3] = sav[1];
                        }

                      */ 
                    delay(ShuttDelay);
                        if (DAS.DOption.mirrorimg[XAX] == 1)
                        DB_MirrorX(Server); //Mirror X axis
                        if (DAS.DOption.pixcorr)
                            DB_DefectPixCorr();
                    RemoveBlindPixels();
                }
            }
            else // NOT Remove Dark from Measurements
            {
                // count opening shutter
                countsopsh++;
                delay(ShuttDelay);
                DC_GetCCD(1, TExp, DIL.Img.Mat[Server].Imat, 0);
                        //Image Rotation
                        /*if (DAS.Paramini.EqType == SPATRAM2)
                        {
                            U16 sav[3];
                            U32 len = (unsigned long) IDX * (unsigned long) IDY; //DC_CCD.dx * DC_CCD.dy; // dimX e dimY = dimensione immagine

                            sav[0] = DIL.Img.Mat[Server].Imat[0];
                            sav[1] = DIL.Img.Mat[Server].Imat[1];
                            memcpy(&DIL.Img.Mat[Server].Imat[0], &DIL.Img.Mat[Server].Imat[2], (IDX << 1)  );
                         
                            DIL.Img.Mat[Server].Imat[len - 1] = sav[1];
                            DIL.Img.Mat[Server].Imat[len ] = sav[0];

                            sav[0] = DIL.Img.Mat[Server].Imat[IDX-3];
                            sav[1] = DIL.Img.Mat[Server].Imat[IDX-2];

                            DIL.Img.Mat[Server].Imat[IDX-1] = sav[0];
                            DIL.Img.Mat[Server].Imat[IDX-3] = sav[1];
                        }

                       */
                delay(ShuttDelay);
                if (DAS.DOption.mirrorimg[XAX] == 1)
                    DB_MirrorX(Server); //Mirror X axis
                if (DAS.DOption.pixcorr)
                    DB_DefectPixCorr();
            }

        }
        else // Make Dark Measurement
        {
/*
                sx = DAS.Paramini.ccdXoff;
                sy = DAS.Paramini.ccdYoff;
                dx = DAS.Paramini.ccdWx - DAS.Paramini.ccdXoff;
                dy = DAS.Paramini.ccdWy - DAS.Paramini.ccdYoff;
                DC_StopNow;
                DC_FGetWinCCD(0, TExp, sx, sy, dx, dy, Mat[Server].Imat, 0);
*/
            DC_GetCCD(0, TExp, DIL.Img.Mat[Server].Imat, 0);
            //Image Rotation
            /*if (DAS.Paramini.EqType == SPATRAM2)
            {
                U16 sav[3];
                U32 len = (unsigned long) IDX * (unsigned long) IDY; //DC_CCD.dx * DC_CCD.dy; // dimX e dimY = dimensione immagine

                sav[0] = DIL.Img.Mat[Server].Imat[0];
                sav[1] = DIL.Img.Mat[Server].Imat[1];
                memcpy(&DIL.Img.Mat[Server].Imat[0], &DIL.Img.Mat[Server].Imat[2], (IDX << 1)  );
                DIL.Img.Mat[Server].Imat[len - 1] = sav[1];
                DIL.Img.Mat[Server].Imat[len ] = sav[0];

                sav[0] = DIL.Img.Mat[Server].Imat[IDX-3];
                sav[1] = DIL.Img.Mat[Server].Imat[IDX-2];

                DIL.Img.Mat[Server].Imat[IDX-1] = sav[0];
                DIL.Img.Mat[Server].Imat[IDX-3] = sav[1];
            }
            */
            if (DAS.DOption.mirrorimg[XAX] == 1)
                DB_MirrorX(Server); //Mirror X axis
            if (DAS.DOption.pixcorr)
                DB_DefectPixCorr();

        }

        DB_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low, BlindPix);           
        DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
        DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;
        DI_Regen(Server);

        GetDateTime(&DIL.Img.Mat[Server].DATE, &DIL.Img.Mat[Server].TIME, &today);
    //  gettime( &DIL.Img.Mat[Server].TIME );
    //  getdate( &DIL.Img.Mat[Server].DATE );

        if(DAS.DOption.savingmode)
            D_BuildH(1, Server);
        else
            D_BuildH(0, Server);
        /*******  END MONO IMAGE ***************/   
    }
    if(DAS.DOption.imgtype) //RGB image     
    {       
            DIL.Img.Mat[Server].type = RGBIMG;
            if(mod)
            {
                if(DAS.DOption.darkremove)
                {
                    /*******************************/
                    //Dark Measurement
                    DC_GetCCD(0, TExp, DIL.Img.Mat[Server].Imat, 0);
                    if (DAS.DOption.mirrorimg[XAX] == 1)
                        DB_MirrorX(Server); //Mirror X axis
                    if (DAS.DOption.pixcorr)
                        DB_DefectPixCorr();

                    for(t = 0; t < IDY; t++)
                    {
                        for(j = 0; j < IDX ; j++)
                        {
                            ImatDark[t * IDX + j] = (unsigned short) DIL.Img.Mat[Server].Imat[t * IDX + j]; 
                        }
                    }
                    /********************************/
                    // Light Measurement
                    // count opening shutter
                    countsopsh++;
                    delay(ShuttDelay);
                    DC_GetCCD(1, TExp, DIL.Img.Mat[Server].Imat, 0);
                    delay(ShuttDelay);
                        if (DAS.DOption.mirrorimg[XAX] == 1)
                            DB_MirrorX(Server); //Mirror X axis
                        if (DAS.DOption.pixcorr)
                            DB_DefectPixCorr();
                        //sottrae la dark alla misura
                    //ATTENZIONE quando la dark e' maggiore della misura 
                    //la sottrazione non funziona RIVEDERE
                    //RIVISTO - si aggiunge 100 alla misura!!!! (Manuele Dixit)
                    for(t = 0; t < IDY; t++)
                    {
                        for(j = 0; j < IDX ; j++)
                        {
                            DIL.Img.Mat[Server].Imat[t * IDX + j] = (unsigned short) (DIL.Img.Mat[Server].Imat[t * IDX + j] + 50) - ImatDark[t * IDX + j];  
                        }
                    }
                }
                else
                {
                    // count opening shutter
                    countsopsh++;
                    delay(ShuttDelay);
                    DC_GetCCD(1, TExp, DIL.Img.Mat[Server].Imat, 0);
                    delay(ShuttDelay);
                    if (DAS.DOption.mirrorimg[XAX] == 1)
                        DB_MirrorX(Server); //Mirror X axis
                    if (DAS.DOption.pixcorr)
                        DB_DefectPixCorr();
                }
            }
            else
            {
                DC_GetCCD(0, TExp,DIL.Img.Mat[Server].Imat, 0);
                if (DAS.DOption.mirrorimg[XAX] == 1)
                    DB_MirrorX(Server); //Mirror X axis
                if (DAS.DOption.pixcorr)
                    DB_DefectPixCorr();
            }
    
        
        
            DI_ScanMaxMin(Server, &DIL.Img.Mat[Server].RHigh, &DIL.Img.Mat[Server].RLow);
            DI_ScanMaxMin(Server, &DIL.Img.Mat[Server].GHigh, &DIL.Img.Mat[Server].GLow);
            DI_ScanMaxMin(Server, &DIL.Img.Mat[Server].BHigh, &DIL.Img.Mat[Server].BLow);

            
            
//          Mat[Server].ILow = Mat[Server].Low ;
//          Mat[Server].IHigh = Mat[Server].High ;

            DI_Regen(Server);

  }

if(DAS.DOption.measmode == 0) //Single
{
    if(TExp > .5)
    {
        MShellUnrealize(sh);
        MShellDestroy(sh);
    }
}
    return 0;


    
}

Here is the call graph for this function:

Here is the caller graph for this function:

DB_MirrorX()

void DB_MirrorX

(

int

w

)

Definition at line 201 of file Procedures.c.

References D_VRange(), DIL, das::DOption, FLTIMG, img::Fmat, image::Idx, image::Idy, img::Imat, dil::Img, image::Mat, optionini::measmode, and img::type.

Referenced by DB_GetCCD().

{
    int     x, y, mx = DIL.Img.Idx[w] - 30;
    U16     *m, t;
    float   *M, T;

    if(DAS.DOption.measmode == 0) //Single
        D_VRange("Mirroring X axis..", 0, 0, 222, 235);

    if(DIL.Img.Mat[w].type == FLTIMG)
        for(y = 0; y < DIL.Img.Idy[w]; y++)
        {
            M = &DIL.Img.Mat[w].Fmat[(long) y * (mx + 30)]; 
            for(x = 0; x <= mx / 2; x++)
            {
                T = M[x];
                M[x] = M[mx - x];
                M[mx - x] = T;
            }
            if(DAS.DOption.measmode == 0) //Single
            {
                if((y % 20) == 0 && y > 0)
                    D_VRange(NULL, (long) y * 100 / DIL.Img.Idy[w],0, 222, 235);
            }
            
        }
    else
        for(y = 0; y < DIL.Img.Idy[w]; y++)
        {
            m = &DIL.Img.Mat[w].Imat[(long) y * (mx + 30)]; 
            for(x = 0; x <= mx / 2; x++)
            {
                t = m[x];
                m[x] = m[mx - x];
                m[mx - x] = t;
            }
            if(DAS.DOption.measmode == 0) //Single
            {
                if((y % 20) == 0 && y > 0)
                    D_VRange(NULL, (long) y * 100 / DIL.Img.Idy[w],0, 222, 235);
            }
        }
        if(DAS.DOption.measmode == 0) //Single
            D_VRange(NULL, 100, 0,0,0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DB_ScanMaxMin()

double DB_ScanMaxMin	(	int	w,
		float *	mx,
		float *	mi,
		int	bp
	)

Find Max and Min values for the buffer of order w.

Parameters

w	= index of the image (0 or 1) .
bp	= number of the CCD blind pixels .

Returns

l = sum of the image values

Definition at line 1632 of file Procedures.c.

References D_VRange(), DIL, das::DOption, FLTIMG, img::Fmat, image::Idx, image::Idy, img::Imat, dil::Img, INTIMG, image::Mat, img::MaxNumbers, optionini::measmode, RGBIMG, and img::type.

Referenced by AutoR_No_Shutt(), AutoR_TestMeas(), AutoR_With_Shutt(), D_Average(), and DB_GetCCD().

{
    double  l = 0;
    int     x, y, xi = DIL.Img.Idx[w] - bp , yi = DIL.Img.Idy[w];
    U16     *m = DIL.Img.Mat[w].Imat;
    float   *f = DIL.Img.Mat[w].Fmat;


    *mx = 0; *mi = DIL.Img.Mat[w].MaxNumbers;
    if(DAS.DOption.measmode == 0) //Single Measurement
        D_VRange("Find Max/Min..", 0, 192, 195, 192);
    //VRange("Find Max/Min", 0);

    if(DIL.Img.Mat[w].type == INTIMG || DIL.Img.Mat[w].type == RGBIMG)
        for(y = 0; y < yi-1; y++)
        {
            for(x = 2; x < xi; x++)
            {
                //l += (double) *m;
                *mi = min(*mi, m[y * DIL.Img.Idx[w] + x]);
                *mx = max(*mx, m[y * DIL.Img.Idx[w] + x]);
                //m++;
            }
            if(DAS.DOption.measmode == 0) //Single Measurement
                if((y % 32) == 0 && y > 0)
                    D_VRange(NULL, (long) y * 100 / DIL.Img.Idy[w], 192, 195, 192);
                //VRange(NULL, (long) y * 100 / DIL.Img.Idy[w]);
        }
    if(DIL.Img.Mat[w].type == FLTIMG)
        for(y = 0; y < yi; y++)
        {
            for(x = 2; x < xi; x++)
            {
                l += (double) *f;
                *mi = min(*mi, *m);
                *mx = max(*mx, *m);
                f++;
            }
            if(DAS.DOption.measmode == 0) //Single Measurement
            if((y % 32) == 0 && y > 0)
                D_VRange(NULL, (long) y * 100 / DIL.Img.Idy[w], 192, 195, 192);

//              VRange(NULL, (long) y * 100 / DIL.Img.Idy[w]);
        }
    //VRange(NULL, 100);
    if(DAS.DOption.measmode == 0) //Single Measurement
        D_VRange(NULL, 100 , 192, 195, 192);

    return l;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Lookfor4358()

int Lookfor4358

(

void

)

function to scan the wl() array in order to identify the position of the 4358 reference wavelength return value: er = -1 –> value 4358 not encountered er >= 0 –> value 4358 found at er position

Definition at line 2270 of file Procedures.c.

References wl.

{

    int i, er = 0;

    for (i=0; i<17; i++)
    {
        if (wl[i] == 4358)
            {
                er = i;
                return er;
            }
    }

    return -1;
}

LookforWl_X()

int LookforWl_X

(

int

x

)

Definition at line 2295 of file Procedures.c.

References wl.

Referenced by D_Calibra(), DemoInitMotor(), E_AAMeasure(), E_Almucantar(), E_Average(), E_AvgCCDHor(), E_DFMeasure(), E_DirectSun(), E_IRefSun(), E_Lambda(), E_Meashor(), E_Meashor2(), E_Measure(), HomeGratingFast(), PRG_ChkGrating(), and WinRes().

{

    int i, er = 0;

    for (i=0; i<18; i++)
    {
        if (wl[i] == x)
            {
                er = i;
                return er;
            }
    }

    return -10;
}

Here is the caller graph for this function:

MaskCol()

void MaskCol	(	int	a,
		int	b,
		int	c,
		int	d,
		int	e
	)

Definition at line 1548 of file Procedures.c.

References DIL, IDX, img::Imat, dil::Img, image::Mat, and Server.

Referenced by DB_DefectPixCorr().

{
    int k;

    for(k=b;k<c;k++)
        DIL.Img.Mat[Server].Imat[a + k * IDX] = (DIL.Img.Mat[Server].Imat[a + k * IDX - d] / 2) + (DIL.Img.Mat[Server].Imat[a + k * IDX + e] / 2);              

}

Here is the caller graph for this function:

MaskPix()

void MaskPix	(	int	a,
		int	b,
		int	c,
		int	d,
		int	e,
		int	f
	)

Definition at line 1538 of file Procedures.c.

References DIL, IDX, img::Imat, dil::Img, image::Mat, and Server.

Referenced by DB_DefectPixCorr().

{

    if (c!=0 && d!=0)
        DIL.Img.Mat[Server].Imat[a + b * IDX] = (int)(DIL.Img.Mat[Server].Imat[a + b * IDX - c] + DIL.Img.Mat[Server].Imat[a + b * IDX + d])/2;                 
    if (e!=0 && f!=0)
        DIL.Img.Mat[Server].Imat[a + b * IDX] = (int)(DIL.Img.Mat[Server].Imat[a + (b-e) * IDX ] + DIL.Img.Mat[Server].Imat[a + (b+f) * IDX ])/2;               

}

Here is the caller graph for this function:

MaskRow()

void MaskRow	(	int	a,
		int	b,
		int	c,
		int	d,
		int	e
	)

Definition at line 1557 of file Procedures.c.

References DIL, IDX, img::Imat, dil::Img, image::Mat, and Server.

Referenced by DB_DefectPixCorr().

{

    int k;

    for(k=a;k<b;k++)
        DIL.Img.Mat[Server].Imat[k + c * IDX] = (DIL.Img.Mat[Server].Imat[k + c * IDX - (IDX * d)] / 2) + (DIL.Img.Mat[Server].Imat[k + c * IDX + (IDX * e)] / 2);              

}

Here is the caller graph for this function:

RemoveBlindPixels()

void RemoveBlindPixels

(

void

)

Definition at line 1600 of file Procedures.c.

References BlindPix, DIL, IDX, IDY, img::Imat, dil::Img, image::Mat, and Server.

Referenced by DB_GetCCD().

{

    double  l = 0;
    int     t, j;
    
    BlindPix  = 0;
    if(IDX > 1024)
        BlindPix  = IDX - 1024;


    for(t = 0; t < IDY; t++)
    {
        for(j = IDX - BlindPix + 1  ; j < IDX; j++)
        {
                l = l + (double) DIL.Img.Mat[Server].Imat[t * IDX + j];
        }
    }
    l = l / (IDY * (BlindPix)); 

    for(t = 0; t < IDY; t++)
    {
        for(j = 0; j < IDX  ; j++)
        {
            DIL.Img.Mat[Server].Imat[t * IDX + j] = (unsigned short) (DIL.Img.Mat[Server].Imat[t * IDX + j] ) - (unsigned short) l; 
        }
    }



}

Here is the caller graph for this function:

SaveCalib()

void SaveCalib

(

int

mod

)

Definition at line 2130 of file Procedures.c.

References _MAX_PATH, d_fileman::DAILYDATADIRECTORY, d_fileman::DATADIRECTORY, DB_Save(), bil::DFILEM, das::DGeo, das::DOption, fftsavecal, spectrumheader::newdate, spectrumheader::olddate, d_geo::s_name, optionini::savingmode, bil::SPH, and Total.

Referenced by D_Calibra(), E_HgScan(), and E_QjScan().

{


    char tmpbuf[128] ;
    static char tit[_MAX_PATH];
    char    tit1[80];
    time_t ltime;
    struct tm *today;
    int er = 0;


    

    if(fftsavecal) //flag first time program run here
    {
        /* Get UNIX-style time */
        time( &ltime );
        /* Use time structure to build a customized time string. */
        today = localtime( &ltime );
        /* Use strftime to build a customized time string. */
        strftime( tmpbuf, 7,"%y%m%d", today );
            
        //Build name of Daily data directory
        sprintf(BIL.DFILEM.DAILYDATADIRECTORY,"%s\\%s",BIL.DFILEM.DATADIRECTORY,tmpbuf);
        //Create Daily data dir
        er = _mkdir( BIL.DFILEM.DAILYDATADIRECTORY );

        fftsavecal=0;   
        if(DAS.DOption.savingmode) // Binary saving
        {
                
            if (mod)
                sprintf(tit, "%s\\%s%s.bqj",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
            else
                sprintf(tit, "%s\\%s%s.bhg",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
            DB_Save(tit, 1);
        }
        else  //ASCII saving
        {
            if (mod)
                sprintf(tit, "%s\\%s%s.aqj",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
            else
            {
                sprintf(tit, "%s\\%s%s.ahg",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
                sprintf(tit1, "%s", tit+5);
            }
            DB_Save(tit, 0);
        }
        sprintf(BIL.SPH.olddate, "%s",tmpbuf);
    }
    else
    {
        
        /* Get UNIX-style time */
        time( &ltime );
        /* Use time structure to build a customized time string. */
        today = localtime( &ltime );
        /* Use strftime to build a customized time string. */
        strftime( BIL.SPH.newdate, 7,"%y%m%d", today );
        /* Use strftime to build a customized time string. */
        strftime( tmpbuf, 7,"%y%m%d", today );
        
        
        // Se e' cambiata la data rimette a 1 il contatore del numero dei files 
        if(strcmp(BIL.SPH.newdate, BIL.SPH.olddate) != 0)
        {
            sprintf(BIL.SPH.olddate, "%s",BIL.SPH.newdate);
            Total = 0;
    
            sprintf(BIL.DFILEM.DAILYDATADIRECTORY,"%s\\%s",BIL.DFILEM.DATADIRECTORY,tmpbuf);
            er = _mkdir( BIL.DFILEM.DAILYDATADIRECTORY );

            /*****************************/
            if(DAS.DOption.savingmode) // Binary saving
            {
                if (mod)
                    sprintf(tit, "%s\\%s%s.bqj",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
                else
                    sprintf(tit, "%s\\%s%s.bhg",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
                DB_Save(tit, 1);
            }
            else  //ASCII saving
            {
                if (mod)
                    sprintf(tit, "%s\\%s%s.aqj",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
                else
                {
                    sprintf(tit, "%s\\%s%s.ahg",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
                    sprintf(tit1, "%s", tit+5);
                }

                DB_Save(tit, 0);
            }
        }
/*****************************/
        

            if(DAS.DOption.savingmode)
            {
                if (mod)
                    sprintf(tit, "%s\\%s%s.bqj",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
                else
                    sprintf(tit, "%s\\%s%s.bhg",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
        
                DB_Save(tit, 1);
            }
            else
            {
                if (mod)
                    sprintf(tit, "%s\\%s%s.aqj",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
                else
                {
                    sprintf(tit, "%s\\%s%s.ahg",BIL.DFILEM.DAILYDATADIRECTORY, DAS.DGeo.s_name, tmpbuf);
                    sprintf(tit1, "%s", tit+5);
                }
                DB_Save(tit, 0);
            }
            
        }


    //sprintf(tit1, "%s", tit+5);
    //MObjectSetText(DAS.Gui.ContrPanel.Albl_CS[3], tit1);
    //sprintf(tit1, "%05d", SaveCnt);
    //MObjectSetText(DAS.Gui.ContrPanel.Albl_CS[2], tit1);

    //SaveCnt++;    


}

Here is the call graph for this function:

Here is the caller graph for this function:

ShutterOpening()

void ShutterOpening

(

int

mod

)

Definition at line 1685 of file Procedures.c.

References _MAX_PATH, d_fileman::CONFIGDIREQUIPMENT, countsopsh, bil::DFILEM, and MMessageDialog().

Referenced by InitCCD_AMS(), ShutCB(), Task_LOG(), and WinRes().

{

    int     fd, er;
    char    buff[_MAX_PATH];
    FILE    *fs;


    sprintf(buff,"%s\\Shutter.ini", BIL.DFILEM.CONFIGDIREQUIPMENT);
    
    if(mod == 0) //read or create file
    {
        fd = access(buff, 0);
        if (fd == 0) //file exist
        {
            fs = fopen(buff, "r");
            if(fs == NULL)
            {
                MMessageDialog("DAS information", "Problems in opening file", " Ok ", NULL);
                return ;    
            }
            er = fscanf(fs, "%ul", &countsopsh);

            fclose(fs);
        }
        else
        {
            fs = fopen(buff, "w");
            if(fs == NULL)
            {
                MMessageDialog("DAS information", "Problems in opening file", " Ok ", NULL);
                return ;    
            }
            fprintf(fs, "%u\n", 1);
            fclose(fs);
        }

    }
    else //mod == 1 write file
    {
        fs = fopen(buff, "w");
        if(fs == NULL)
        {
            MMessageDialog("DAS information", "Problems in opening file", " Ok ", NULL);
            return ;    
        }
        fprintf(fs, "%u\n", countsopsh);
        fclose(fs);
    }





}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

AST

AzimuthSt AST

Definition at line 45 of file Procedures.c.

BIL

bil BIL

Definition at line 42 of file Procedures.c.

Cfg

config Cfg

Definition at line 31 of file Procedures.c.

DAS

das DAS

DAS structure.

Definition at line 47 of file Procedures.c.

DC_CCD

ccd DC_CCD

Definition at line 29 of file Procedures.c.

DC_HP

ptf DC_HP

Definition at line 30 of file Procedures.c.

DGEO

d_geo DGEO

geographical coordinates structure

Definition at line 41 of file Procedures.c.

ExeREM

int ExeREM

Definition at line 143 of file DAS_Spat.c.

Referenced by D_Calibra().

fftprh

int fftprh = 1

Definition at line 50 of file Procedures.c.

Referenced by D_Saving().

fftsavecal

int fftsavecal = 1

Definition at line 51 of file Procedures.c.

Referenced by SaveCalib().

FLAG

flag FLAG

flags structure

Definition at line 37 of file Procedures.c.

FWS

FilterWheelSt FWS

Filter Wheel.

Definition at line 34 of file Procedures.c.

GRS

GratingSt GRS

Grating.

Definition at line 36 of file Procedures.c.

HDRSP

hdrsp HDRSP

Definition at line 32 of file Procedures.c.

maxar

float maxar

Definition at line 252 of file Procedures.c.

Referenced by AutoR_No_Shutt(), and AutoR_With_Shutt().

maxtt

float maxtt

Definition at line 252 of file Procedures.c.

Referenced by AutoR_No_Shutt(), and AutoR_With_Shutt().

minar

float minar

Definition at line 252 of file Procedures.c.

Referenced by AutoR_No_Shutt(), and AutoR_With_Shutt().

mintt

float mintt

Definition at line 252 of file Procedures.c.

Referenced by AutoR_No_Shutt(), and AutoR_With_Shutt().

MIS

MirrorSt MIS

Mirror.

Definition at line 33 of file Procedures.c.

NDFWS

NDFilterWheelSt NDFWS

ND Filter Wheel.

Definition at line 35 of file Procedures.c.

PARAM

paramini PARAM

Param.ini.

Definition at line 39 of file Procedures.c.

SaveCnt

int SaveCnt = 1

Definition at line 49 of file Procedures.c.

Referenced by D_Saving(), DB_HorComm_CB(), DB_KeyB_CB(), E_QjScan(), and ExMaster().

ShuttDelay

int ShuttDelay = 0

Definition at line 255 of file Procedures.c.

Referenced by AutoRange(), D_Average(), and DB_GetCCD().

ZST

ZenithSt ZST

Definition at line 44 of file Procedures.c.