Merge branch 'dev' of https://gitlab.irap.omp.eu/pyros-irap/pyros into dev

Alexis Koralewski
2 parents 7cc13fec 6438ef81
Showing 2 changed files with 625 additions and 123 deletions Show diff stats
config/pyros_observatory/general/schemas/schema_observatory-2.0.yml
src/core/pyros_django/img_process/A_ImgProcessor.py
@@ -135,6 +135,34 @@ schema;schema_FN_CONTEXTS:
   type: map
   required: False
   mapping:
+    cal_L0:
+      type: map 
+      required: False
+      mapping:
+        root_dir:
+          type: str
+        description:
+          type: str
+        extension:
+          type: str 
+        naming: 
+          type: str
+        pathnaming:
+          type: str 
+    cal_L1:
+      type: map 
+      required: False
+      mapping:
+        root_dir:
+          type: str
+        description:
+          type: str
+        extension:
+          type: str 
+        naming: 
+          type: str
+        pathnaming:
+          type: str 
     img_L0:
       type: map 
       required: False
@@ -162,7 +190,77 @@ schema;schema_FN_CONTEXTS:
         naming: 
           type: str
         pathnaming:
+          type: str 
+    img_L1a:
+      type: map 
+      required: False
+      mapping:
+        root_dir:
+          type: str
+        description:
+          type: str
+        extension:
+          type: str 
+        naming: 
+          type: str
+        pathnaming:
+          type: str
+    img_L1b:
+      type: map 
+      required: False
+      mapping:
+        root_dir:
+          type: str
+        description:
           type: str
+        extension:
+          type: str 
+        naming: 
+          type: str
+        pathnaming:
+          type: str
+    img_L1c:
+      type: map 
+      required: False
+      mapping:
+        root_dir:
+          type: str
+        description:
+          type: str
+        extension:
+          type: str 
+        naming: 
+          type: str
+        pathnaming:
+          type: str
+    img_L1d:
+      type: map 
+      required: False
+      mapping:
+        root_dir:
+          type: str
+        description:
+          type: str
+        extension:
+          type: str 
+        naming: 
+          type: str
+        pathnaming:
+          type: str
+    img_L2:
+      type: map 
+      required: False
+      mapping:
+        root_dir:
+          type: str
+        description:
+          type: str
+        extension:
+          type: str 
+        naming: 
+          type: str
+        pathnaming:
+          type: str 
     img_tmp:
       type: map 
       required: False
@@ -63,7 +63,7 @@ class A_ImgProcessor(Agent):
     # AgentCmd.CMD_STATUS_CODE.CMD_EXECUTED
     _TEST_COMMANDS_LIST = [
         # Format : ("self cmd_name cmd_args", timeout, "expected_result", expected_status),
-        (True, "self do_create_test_images_1", 500, "", Agent.CMD_STATUS.CMD_EXECUTED),
+        (True, "self do_create_test_images_2", 500, "", Agent.CMD_STATUS.CMD_EXECUTED),
         (True, "self do_stop asap", 500, "STOPPING", Agent.CMD_STATUS.CMD_EXECUTED),
     ]
  
@@ -80,7 +80,7 @@ class A_ImgProcessor(Agent):
  
     def _init(self):
         super()._init()
-        log.debug("end super init()")
+        log.debug("End super init()")
         log.info(f"self.TEST_MODE = {self.TEST_MODE}")
  
         # === Get the config object
@@ -105,6 +105,7 @@ class A_ImgProcessor(Agent):
         if channel == None:
             raise Exception(f"{agent_alias} has no channel file contexts {channel=}")
         #log.info(f"{channel=}")
+        self._channel = channel
  
         # === Get all file contexts from the channel config
         self._fn = channel['fn_contexts']
@@ -117,8 +118,7 @@ class A_ImgProcessor(Agent):
         log.info(f"{longitude=}")
         self._ima.longitude(longitude)
  
-        # === Copy the channel file context into the Ima object
-        # --- TODO make a Filenames function to do that
+        # === Copy the channel file contexts into the Ima object
         self._ima.fcontext_replace(self._fn)
         log.info(f"=== List of file name contexts available for the channel {channel['name']} ({channel['symbol']})")
         for fcname in self._ima.fcontexts:
@@ -174,6 +174,15 @@ class A_ImgProcessor(Agent):
     """
  
     def glob_images_to_process(self):
+        """Get the list of L0A (and L1A or L1B) files compatibles with the unit and the channel.
+
+        The list is sorted to have the oldest file at the first place.
+        Files are FITS format. 
+        The context file is 'img_L0'
+        
+        Returns:
+            The list of files sorted from the oldest to the earlier. If L1A or L1B files exist the only the list of these files is returned.
+        """
  
         # - select the incoming directory file context
         fcontext = "img_L0"
@@ -181,138 +190,308 @@ class A_ImgProcessor(Agent):
             self._ima.fcontext = fcontext
         except Exception as e:
             raise Exception(f"glob_images_to_process: {e}")
-        # - Compute the wildcard for glob
-        # TODO fix the bug of * in the file name
-        # wildcard = self.ima.join("*")
-        # The current solution is:
-        wildcard = os.path.join(self._ima.rootdir,"*"+self._ima.extension)
-        print(f"{wildcard}")
+        # - Get the fcontext naming wildcard
+        wildcard = self._ima.naming_wildcard()
+        # - Get param dict from the fcontext naming wildcard
+        param = self._ima.naming_get(wildcard)
+        # - Set the constraints of the wildcard
+        param['unit'] = self.config.unit_name
+        param['channel'] = self._channel['symbol']
+        wildcard = self._ima.naming_set(param)
+        wildcard = self._ima.join(wildcard)
         # - glob the incoming directory contents:
+        log.debug(f"glob_images_to_process: {wildcard=}")
         fitsfiles = glob.glob(wildcard)
         # - Please sort list of files in increasing dates (TODO)
         fitsfiles.sort()
+        # - Get only L1? file types if exist
+        fics = []
+        for fitsfile in fitsfiles:
+            param = self._ima.naming_get(fitsfile)
+            if param['ftype'][:1] == "L1":
+                fics.append(fitsfile)
+        if len(fics):
+            fitsfiles = fics
         return fitsfiles
  
     def bias_correction(self):
-
-        # - Search the bias
-        path_bias = os.path.join( self._paths['ima_bias'], self._date_night )
-        fitsbiasfiles = glob.glob(f"{path_bias}/*.fit")
-        log.info(f"fitsbiasfiles = {fitsbiasfiles}")
-        if len(fitsbiasfiles) > 0:
-
-            # - Select the bias
-            pass
+        """Process bias correction.
+        """
+        log.info("No correction needed")
  
     def dark_correction(self):
+        """Process dark correction.
+        
+        This method is called by process_one_image().
+        Consider the file contexts 'img_tmp' and 'cal_L1'. Consider the <night> and <filter>.
+        The processing is performed with all files lying only in the directory 'img_tmp'.
+        
+        Prerequesite: The method process_one_image() copied a science image from the directory 'img_L0' to a file named img_<channel>_<filter>.fit in the directory 'img_tmp'.
+
+        Algorithm:
+        
+            * Check if the file dark_<channel>_<night> exists in the directory 'img_tmp'. 
+            * If not, check if a DA1 superdark file exists in the directory 'cal_L1'/<night> and copy it in the directory 'img_tmp' as the name dark_<channel_<night>.
+            * Load the image img_<channel>_<filter> (= self._fimg)
+            * Sub the image dark_<channel>_<night>
+        """
  
-        # - Search the dark
-        path_darks = os.path.join( self._paths['ima_darks'], self._date_night )
-        fitsdarkfiles = glob.glob(f"{path_darks}/*.fit")
-        log.info(f"fitsdarkfiles = {fitsdarkfiles}")
-        if len(fitsdarkfiles) > 0:
-
-            # - Select two darks and compute the therm using exposure
-            # - Correction of dark
-            pass
+        # - Dark file name in tmp of this night
+        self._ima.fcontext = "img_tmp"
+        fdark = "dark_" + self._channel['symbol'] + "_" + self._datedict['night']
+        fdark_out = self._ima.join(fdark)
+        
+        # - Delete dark files in tmp that are not of this night
+        # This action prevents orphan files in the tmp folder
+        wildcard = self._ima.join("dark_" + self._channel['symbol'] + "_*")
+        fdarkes = glob.glob(wildcard)
+        for fdarke in fdarkes:
+            if fdarke != fdark_out:
+                log.info(f"Clean temporary file {fdarke}")
+                os.remove(fdarke)
+        
+        # - Place the night dark in tmp if needed
+        fdark_in = None
+        if not os.path.exists(fdark_out):
+            # - The night dark does not exists in tmp
+            self._ima.fcontext = "cal_L1"
+            # - Get the fcontext naming wildcard
+            wildcard = self._ima.naming_wildcard()
+            # - Get param dict from the fcontext naming wildcard
+            param_dark = self._ima.naming_get(wildcard)
+            # - Set the constraints of the wildcard
+            param_dark['ftype'] = 'DA1'
+            param_dark['unit'] = self.config.unit_name
+            param_dark['channel'] = self._channel['symbol']
+            wildcard = self._ima.naming_set(param_dark)
+            wildcard = os.path.join( self._ima.rootdir, self._datedict['night'], wildcard + self._ima.extension)
+            # - glob the incoming directory contents:
+            #log.info(f"dark glob : {wildcard=}")
+            fitsfiles = glob.glob(wildcard)
+            #log.info(f"dark files : {fitsfiles=}")
+            if len(fitsfiles) > 0:
+                fdark_in = fitsfiles[0]
+                # - Copy the night dark into tmp
+                #log.info(f"{fdark_in=}")
+                #log.info(f"{fdark_out=}")
+                shutil.copyfile(fdark_in, fdark_out)
+
+        # - Dark correction if dark exists
+        if os.path.exists(fdark_out):
+            # - Load img and get infos
+            self._ima.fcontext = "img_tmp"
+            self._ima.load(self._fimg)
+            # - Dark correction
+            log.info(f"Dark used: {fdark}")
+            self._ima.sub(fdark)
+            self._ima.save(self._fimg)
+            log.info("Dark correction done")
+        else:
+            log.info("No dark correction")
  
     def flat_correction(self):
+        """Process flat correction.
+        
+        This method is called by process_one_image().
+        Consider the file contexts 'img_tmp' and 'cal_L1'. Consider the <night> and <filter>.
+        The processing is performed with all files lying only in the directory 'img_tmp'.
+        
+        Prerequesite: The method process_one_image() copied a science image from the directory 'img_L0' to a file named img_<channel>_<filter>.fit in the directory 'img_tmp'. The image must be corrected by bias and dark.
+
+        Algorithm:
+        
+            * Check if the file flat_<channel>_<night>_<filter> exists in the directory 'img_tmp'.
+            * If not, check if a FL1 superdark file exists in the directory 'cal_L1'/<night> and copy it in the directory 'img_tmp' as the name flat_<channel_<night>_<filter>.
+            * Load the image img_<channel>_<filter> (= self._fimg)
+            * Div the image flat_<channel>_<night>_<filter>
+        """
  
-        # - Search the flat
-        path_flats = os.path.join( self._paths['ima_flats'], self._date_night )
-        fitsflatfiles = glob.glob(f"{path_flats}/*.fit")
-        log.info(f"fitsflatfiles = {fitsflatfiles}")
-        if len(fitsflatfiles) > 0:
-
-            # - Select the flat (with the filter)
-            # - Correction of flat
-            pass
+        # - Flat file name in tmp of this night
+        self._ima.fcontext = "img_tmp"
+        fflat = "flat_" + self._channel['symbol'] + "_" + self._datedict['night'] + "_" + self._filter_symbol
+
+        fflat_out = self._ima.join(fflat)
+        
+        # - Delete flat files in tmp that are not of this night
+        # This action prevents orphan files in the tmp folder
+        wildcard = self._ima.join("flat_" + self._channel['symbol'] + "_" + self._filter_symbol + "_*")
+        fflates = glob.glob(wildcard)
+        for fflate in fflates:
+            if fflate != fflat_out:
+                log.info(f"Clean temporary file {fflate}")
+                os.remove(fflate)
+        
+        # - Place the night flat in tmp if needed
+        fflat_in = None
+        if not os.path.exists(fflat_out):
+            # - The night flat does not exists in tmp
+            self._ima.fcontext = "cal_L1"
+            # - Get the fcontext naming wildcard
+            wildcard = self._ima.naming_wildcard()
+            # - Get param dict from the fcontext naming wildcard
+            param_flat = self._ima.naming_get(wildcard)
+            # - Set the constraints of the wildcard
+            param_flat['ftype'] = 'FL1'
+            param_flat['unit'] = self.config.unit_name
+            param_flat['channel'] = self._channel['symbol']
+            param_flat['filter'] = self._filter_symbol
+            wildcard = self._ima.naming_set(param_flat)
+            wildcard = os.path.join( self._ima.rootdir, self._datedict['night'], wildcard + self._ima.extension)
+            # - glob the incoming directory contents:
+            #log.info(f"flat glob : {wildcard=}")
+            fitsfiles = glob.glob(wildcard)
+            #log.info(f"flat files : {fitsfiles=}")
+            if len(fitsfiles) > 0:
+                fflat_in = fitsfiles[0]
+                # - Copy the night flat into tmp
+                #log.info(f"{fflat_in=}")
+                #log.info(f"{fflat_out=}")
+                shutil.copyfile(fflat_in, fflat_out)
+
+        # - Flat correction if flat exists
+        if os.path.exists(fflat_out):
+            # - Load img and get infos
+            self._ima.fcontext = "img_tmp"
+            #self._ima.load(self._fimg)
+            # - Flat correction
+            log.info(f"Flat used: {fflat}")
+            self._ima.div(fflat, 10000)
+            self._ima.save(self._fimg)
+            log.info("Flat correction done")
+        else:
+            log.info("No flat correction")
  
     def inversion_correction(self):
-        pass
+        """Process inversion corrections.
+        """
+        log.info("No inversion correction needed")
  
     def cosmetic_correction(self):
-        pass
+        """Process cosmetic correction.
+        """
+        log.info("No cosmetic correction needed")
  
     def wcs_calibration(self):
-        return 0
+        """Process WCS calibration.
+        
+        This method is called by process_one_image().
+        Consider the file context 'img_tmp'. Consider the <night> and <filter>.
+        The processing is performed with all files lying only in the directory 'img_tmp'.
+        
+        Prerequesite: The method process_one_image() copied a science image from the directory 'img_L0' to a file named img_<channel>_<filter>.fit in the directory 'img_tmp'. The image must be corrected by bias, dark and flat.
+
+        Algorithm:
+        
+            * Load the image img_<channel>_<filter> (= self._fimg)
+            * Set the current working directory to the 'img_tmp' rootdir.
+            * Create the dictionary of settings to prepare the calibration call.
+            * Call the method of calibwcs.
+        """
+        method = ""
+        #method = "upload"
+        if method == "upload":
+            self._ima.fcontext = "img_tmp"
+            os.chdir(self._ima.rootdir)
+            self._ima.config("astrometrynet", API_KEY = "amxbkytvjishmehq")
+            settings = {}
+            settings["center_ra"] = self._ima.getkwd('RA')
+            settings["center_dec"] = self._ima.getkwd('DEC')
+            settings["radius"] = 1.0
+            success, comment, detail = self._ima.calibwcs("upload", **settings)    
+            log.info(f"WCS {success=}")
+            log.info(f"WCS {comment=}")
+            log.info(f"WCS {detail=}")
+            log.info("WCS correction done")
+        else:
+            log.info("No WCS correction needed")
  
     def process_one_image(self, fitsfile: str):
-        """This is the general algorithm of processing
+        """This is the general algorithm of processing to transform L0 to L1b
+
+        The processing consists to make corrections of dark, flat, inversions, cosmetic (L1a) and perform WCS calibration (L1b).
  
-        The processing consists to make corrections of dark, flat, inversions, cosmetic
-        and perform WCS calibration.
+        This method is called by the method _routine_process_iter_end_body().
+        The method _routine_process_iter_end_body() first call the method glob_images_to_process() to get the list of file names to process.
+        The list of file names can be L0A images of L1A, L1B, ...
+        The normal use of process_one_image() is to process L0A but it is possible to copy by hand L1A or L1B files in the incoming directory to force a new WCS calibration if needed.
  
         Args:
-            fitsfile: The file of the FITS file to process.
+            fitsfile: The file name of the FITS file to process. The file name must be contains path, name, extension.
  
         """
  
+        log.info("\n" + "="*70 + f"\n=== Start process an image for L0->L1\n" + "="*70 + "\n")
+
         # - Get informations from the file name according the fcontext
-        log.info(f"{self._ima.fcontext} : {self._ima.fdescription} {self._ima.rootdir}/[{self._ima.pathing()}]/[{self._ima.naming()}]{self._ima.extension}")
-        infos = self._ima.naming_get(fitsfile)
-        print(f"{infos=}")
+        self._ima.fcontext = "img_L0"
+        #log.info(f"{self._ima.fcontext} : {self._ima.fdescription} {self._ima.rootdir}/[{self._ima.pathing()}]/[{self._ima.naming()}]{self._ima.extension}")
+        param_img = self._ima.naming_get(fitsfile)        
+        #log.info(f"{param_img=}")
  
         # - Load file in memory
-        log.info("Load the file in memory")
-        infos = self._ima.load(fitsfile)
-        print(f"{infos=}")
-        #f = self._ima.genename(self._ima.load(fitsfile))
-        #log.info(f"{f=}")
+        log.info(f"Image to process {fitsfile}")
+        self._ima.load(fitsfile)
  
-        # - Save as tmp
+        # - Get datedict from DATE-OBS of img
+        date_obs = self._ima.getkwd("DATE-OBS")
+        log.info(f"DATE-OBS: {date_obs}")
+        self._datedict = self._ima.naming_date(date_obs)
+        log.info(f"night: {self._datedict['night']}")
+        
+        # - Get filter
+        self._filter_symbol = self._ima.getkwd("FILTER")
+
+        # - Save as img in tmp
+        self._fimg = "img_" + self._channel['symbol'] + "_" + self._filter_symbol
         self._ima.fcontext = "img_tmp"
-        f = self._ima.join("tmp.fit")
-        log.info("Save the temporary file as tmp name")
+        #log.info(f"{self._ima.fcontext} : {self._ima.fdescription} {self._ima.rootdir}/[{self._ima.pathing()}]/[{self._ima.naming()}]{self._ima.extension}")
+        f = self._ima.join(self._fimg)
+        log.info(f"Save the temporary file as {f}")
         self._ima.save(f)
  
-        # - Load tmp and get infos
-        self._ima.load("tmp")
-        date_obs = self._ima.getkwd("DATE-OBS")
-        self._date_night = self._ima.get_night(date_obs)
-        log.info(f"Date_obs = {date_obs}")
-        log.info(f"Night = {self._date_night}")
-        exposure = self._ima.getkwd("EXPOSURE")
-        log.info(f"Exposure = {exposure}")
-
-        # - Bias correction
-        self.bias_correction()
-
-        # - Dark correction
-        self.dark_correction()
-
-        # - Flat correction
-        self.flat_correction()
-
-        # - Save tmp corrected by dark and flat
-        self._ima.path(self._paths['ima_tmp'])
-        self._ima.save("tmp")
-
-        # - Inversion of mirrors or mirorxy
-        self.inversion_correction()
-
-        # - Cosmetic correction
-        self.cosmetic_correction()
-
-        # - WCS calibration
-        nmatched = self.wcs_calibration()
-
-        # - Prepare the output file name
-        log.info("Decode the filename")
-        fgen_in = f['genename'] + f['sep'] + f['indexes'][0] + f['suffix']
-        fext_in = f['file_extension']
-        fext_out = ".fits"
-
-        # - Save in processed
-        yyyy = self._date_night[0:4]
-        mm = self._date_night[4:6]
-        dd = self._date_night[6:8]
-        path_processed = os.path.join( self._paths['ima_processed'], yyyy, mm, dd )
-        self._ima.path(path_processed)
-        fname_out = fgen_in + fext_out
-        fname = self._ima.save(fname_out)
-        log.info(f"Save the processed image {fname}")
-
+        if param_img['ftype'] == "L0A":
+            # - Bias correction
+            log.info("\n" + "-"*60 + f"\n--- Bias correction\n" + "-"*60 + "\n")
+            self.bias_correction()
+
+            # - Dark correction
+            log.info("\n" + "-"*60 + f"\n--- Dark correction\n" + "-"*60 + "\n")
+            self.dark_correction()
+
+            # - Flat correction
+            log.info("\n" + "-"*60 + f"\n--- Flat correction\n" + "-"*60 + "\n")
+            self.flat_correction()
+
+            # - Inversion of mirrors or mirorxy
+            log.info("\n" + "-"*60 + f"\n--- Mirror correction\n" + "-"*60 + "\n")
+            self.inversion_correction()
+
+            # - Cosmetic correction
+            log.info("\n" + "-"*60 + f"\n--- Cosmetic correction\n" + "-"*60 + "\n")
+            self.cosmetic_correction()
+
+            # - Save the L1a file name
+            self._ima.fcontext = "img_L1a"
+            param_img['ftype'] = 'L1A'
+            fname = self._ima.naming_set(param_img)
+            fname = self._ima.join(fname)
+            self._ima.save(fname)
+
+        if param_img['ftype'] == "L1A" or param_img['ftype'] == "L1B":
+
+            # - WCS calibration
+            log.info("\n" + "-"*60 + f"\n--- WCS calibration\n" + "-"*60 + "\n")
+            nmatched = self.wcs_calibration()
+
+            # - Save the L1a file name
+            self._ima.fcontext = "img_L1b"
+            param_img['ftype'] = 'L1B'
+            fname = self._ima.naming_set(param_img)
+            fname = self._ima.join(fname)
+            self._ima.save(fname)
+
+        # - TODO Resampling (img_L1c)
+        
         # - Delete the file in incoming directory
         os.remove(fitsfile)
         log.info(f"Delete the raw image {fitsfile}")
@@ -320,50 +499,276 @@ class A_ImgProcessor(Agent):
         # - Update the running state
         self._routine_running = self.RUNNING_NOTHING
  
-        time.sleep(5)
-        print("\n ...End of image calibration\n")
+        log.info("\n" + "="*70 + f"\n=== End process an image for L0->L1\n" + "="*70 + "\n")
  
     """
     =================================================================
-        Internal methods
+        Protected methods
     =================================================================
     """
  
     def _create_test_images_1(self):
-        # === Define an image to test the processing and copy it in incoming directory
-        file_in = os.path.join(os.environ['PROJECT_ROOT_PATH'],"vendor","guitastro","tests","data","m57.fit")
+        """Copy the image m57.fit of Guitastro as a test image.
+        
+        A filter C is assumed.
+        Create bias, dark and flat calibration images.
+        
+        This method does not need external internal call.
+        """
+    
+        try:
+            self._ima.fcontext = "default"
+        except Exception as e:
+            raise Exception(f"_create_test_images_1: {e}")
+        self._ima.rootdir = os.path.join(os.environ['PROJECT_ROOT_PATH'],"vendor","guitastro","tests","data")
+        self._ima.extension = ".fit"
+        file_in = self._ima.join("m57")
+        # --- Load the image
+        log.info(f"{file_in=}")
+        self._ima.load(file_in)
+        log.info("Load test image OK")
+        # --- Get image shape
+        naxis1, naxis2 = self._ima._array.shape
+        log.info(f"Test image shape is: {naxis1=} {naxis2=}")
+        # --- Get datedict
+        date_obs = self._ima.getkwd("DATE-OBS")
+        log.info(f"Test image DATE-OBS: {date_obs}")
+        datedict = self._ima.naming_date(date_obs)
+        log.info(f"Test image night: {datedict['night']}")
+        # --- Get other infos
+        filter_symbol = "C"
+        id_sequence = 123456789
+        
+        # --- Rename the image file name when copying to be compatible with the img_L0 file context
         try:
             self._ima.fcontext = "img_L0"
         except Exception as e:
             raise Exception(f"_create_test_images_1: {e}")
         param = {}
         param['ftype'] = "L0A"
-        param['date'] = "20000713"
-        param['time'] = "224045000000"
-        param['unit'] = "TNC"
+        param['date'] = datedict['yyyymmdd']
+        param['time'] = datedict['hhmmssssssss']
+        param['unit'] = self.config.unit_name
         param['version'] = 1
-        param['channel'] = "CH1"
-        param['id_seq'] = 123456789
+        param['channel'] = self._channel['symbol']
+        param['id_seq'] = id_sequence
         param['plane'] = 1
         param['frame'] = 1
         fname = self._ima.naming_set(param)
         file_out = self._ima.join(fname)
-        print(f"{file_in=}")
-        print(f"{file_out=}")
-        shutil.copyfile(file_in, file_out)
+        log.info(f"{file_out=}")
+        self._ima.setkwd("FILTER", filter_symbol)
+        self._ima.save(file_out)
+        
+        # --- Build a bias image filled by zeros
+        log.info("Build a test bias")
+        try:
+            self._ima.fcontext = "cal_L1"
+        except Exception as e:
+            raise Exception(f"_create_test_images_1: {e}")
+        self._ima.mult(0)
+        param = {}
+        param['ftype'] = "BI1"
+        param['date'] = datedict['yyyymmdd']
+        param['time'] = datedict['hhmmssssssss']
+        param['unit'] = self.config.unit_name
+        param['version'] = 1
+        param['channel'] = self._channel['symbol']
+        param['id_seq'] = id_sequence - 3
+        param['plane'] = 1
+        param['filter'] = filter_symbol
+        fname = self._ima.naming_set(param)
+        file_out = self._ima.join(fname)
+        log.info(f"{file_out=}")
+        self._ima.setkwd("FILTER", filter_symbol)
+        self._ima.save(file_out)
+        
+        # --- Build a dark image filled by zeros
+        log.info("Build a test dark")
+        param = {}
+        param['ftype'] = "DA1"
+        param['date'] = datedict['yyyymmdd']
+        param['time'] = datedict['hhmmssssssss']
+        param['unit'] = self.config.unit_name
+        param['version'] = 1
+        param['channel'] = self._channel['symbol']
+        param['id_seq'] = id_sequence - 2
+        param['plane'] = 1
+        param['filter'] = filter_symbol
+        fname = self._ima.naming_set(param)
+        file_out = self._ima.join(fname)
+        log.info(f"{file_out=}")
+        self._ima.setkwd("FILTER", filter_symbol)
+        self._ima.save(file_out)
+        
+        # --- Build a flat image filled by cst=10000
+        log.info("Build a test flat")
+        flatnorm = 10000
+        self._ima.offset(flatnorm)
+        self._ima.setkwd("FLATNORM", flatnorm, "Normalisation of the superflat")
+        param = {}
+        param['ftype'] = "FL1"
+        param['date'] = datedict['yyyymmdd']
+        param['time'] = datedict['hhmmssssssss']
+        param['unit'] = self.config.unit_name
+        param['version'] = 1
+        param['channel'] = self._channel['symbol']
+        param['id_seq'] = id_sequence - 1
+        param['plane'] = 1
+        param['filter'] = filter_symbol
+        fname = self._ima.naming_set(param)
+        file_out = self._ima.join(fname)
+        log.info(f"{file_out=}")
+        self._ima.setkwd("FILTER", filter_symbol)
+        self._ima.save(file_out)
  
     def _create_test_images_2(self):
+        """Simulate an image centered on Messier 67 as a test image.
+
+        A filter C is assumed.
+        Create bias, dark and flat calibration images.
+        
+        This method needs external internal call.
+        """
+        
+        # --- Configure the simulator
         self._ima.etc.camera("Kepler 4040")
         self._ima.etc.optics("Takahashi_180ED")
-        self._ima.etc.params("msky",18)
+        bias_level = 1000
+
+        # --- Set the target coordinates
         ra = 132.84583
         dec = 11.81333
-        at = self._ima.simulation("GAIA", "PHOTOM", shutter_mode="closed", t=50, ra=ra, dec=dec)
-        file_out = os.path.join(self._paths['ima_tmp'], "m67.ecsv")
-        print(f"STEP TOTO 1 = {at}")
-        at.t.write(file_out, format='astrotable', overwrite=True)
-        print(f"STEP TOTO 2")
-        date_obs = self.getkwd("DATE-OBS")
+
+        # --- Get datedict
+        date_obs = guitastro.Date("now").iso(nb_subdigit=3)
+        log.info(f"Test image DATE-OBS: {date_obs}")
+        datedict = self._ima.naming_date(date_obs)
+        log.info(f"Test image night: {datedict['night']}")
+        
+        # --- Get the table of stars (simu_<channel>.ecsv)
+        shutter_mode = "synchro"
+        self._ima.etc.params("msky",19)
+        t = 10
+        log.info("Build a test image")
+        try:
+            self._ima.fcontext = "img_tmp"
+        except Exception as e:
+            raise Exception(f"_create_test_images_2: {e}")
+        ext = self._ima.extension
+        self._ima.extension = ".ecsv"
+        fsimu = "simu_" + self._channel['symbol']
+        fsimu = self._ima.join(fsimu)
+        self._ima.extension = ext
+        if os.path.exists(fsimu):
+            att = guitastro.AstroTable()
+            att.read(fsimu, format="ascii.ecsv")
+            at = self._ima.simulation("ASTROTABLE", att, shutter_mode=shutter_mode, t=t, ra=ra, dec=dec)
+        else:
+            at = self._ima.simulation("GAIA", "PHOTOM", shutter_mode=shutter_mode, t=t, ra=ra, dec=dec, column_filters = {"Gmag": "<14"})
+            at.t.write(fsimu, format='ascii.ecsv', overwrite=True)
+            att = at
+        # --- Get other infos
+        filter_symbol = "C"
+        id_sequence = 123452789
+
+        # --- Save the image file name to be compatible with the img_L0 file context
+        try:
+            self._ima.fcontext = "img_L0"
+        except Exception as e:
+            raise Exception(f"_create_test_images_2: {e}")
+        param = {}
+        param['ftype'] = "L0A"
+        param['date'] = datedict['yyyymmdd']
+        param['time'] = datedict['hhmmssssssss']
+        param['unit'] = self.config.unit_name
+        param['version'] = 1
+        param['channel'] = self._channel['symbol']
+        param['id_seq'] = id_sequence
+        param['plane'] = 1
+        param['frame'] = 1
+        fname = self._ima.naming_set(param)
+        file_out = self._ima.join(fname)
+        self._ima.setkwd("DATE-OBS", date_obs)
+        self._ima.setkwd("FILTER", filter_symbol)
+        self._ima.save(file_out)
+
+        # --- Build a bias image
+        log.info("Build a test bias")
+        shutter_mode = "closed"
+        self._ima.simulation("ASTROTABLE", att, shutter_mode=shutter_mode, t=0.01, ra=ra, dec=dec)
+        try:
+            self._ima.fcontext = "cal_L1"
+        except Exception as e:
+            raise Exception(f"_create_test_images_2: {e}")
+        param = {}
+        param['ftype'] = "BI1"
+        param['date'] = datedict['yyyymmdd']
+        param['time'] = datedict['hhmmssssssss']
+        param['unit'] = self.config.unit_name
+        param['version'] = 1
+        param['channel'] = self._channel['symbol']
+        param['id_seq'] = id_sequence - 3
+        param['plane'] = 1
+        param['filter'] = filter_symbol
+        fname = self._ima.naming_set(param)
+        file_out = self._ima.join(fname)
+        import numpy as np
+        log.info(f"{file_out=}")
+        self._ima.setkwd("DATE-OBS", date_obs)
+        self._ima.setkwd("FILTER", filter_symbol)
+        self._ima.save(file_out)
+        
+        # --- Build a dark image
+        log.info("Build a test dark")
+        shutter_mode = "closed"
+        self._ima.simulation("ASTROTABLE", att, shutter_mode=shutter_mode, t=t, ra=ra, dec=dec)
+        param = {}
+        param['ftype'] = "DA1"
+        param['date'] = datedict['yyyymmdd']
+        param['time'] = datedict['hhmmssssssss']
+        param['unit'] = self.config.unit_name
+        param['version'] = 1
+        param['channel'] = self._channel['symbol']
+        param['id_seq'] = id_sequence - 2
+        param['plane'] = 1
+        param['filter'] = filter_symbol
+        fname = self._ima.naming_set(param)
+        file_out = self._ima.join(fname)
+        log.info(f"{file_out=}")
+        self._ima.setkwd("DATE-OBS", date_obs)
+        self._ima.setkwd("FILTER", filter_symbol)
+        self._ima.save(file_out)
+        
+        # --- Build a flat image normalized by cst=10000
+        log.info("Build a test flat")
+        shutter_mode = "synchro"
+        self._ima.etc.params("msky",-1)
+        tf = t/1000000.0
+        #tf = t
+        self._ima.simulation("ASTROTABLE", att, shutter_mode=shutter_mode, t=tf, ra=ra, dec=dec)
+        log.info(f"MEAN={np.mean(self._ima._array)}")
+        self._ima.offset(-bias_level)
+        flatnorm = 10000.0
+        self._ima.ngain(flatnorm)
+        self._ima.setkwd("FLATNORM", flatnorm, "Normalisation of the superflat")
+        param = {}
+        param['ftype'] = "FL1"
+        param['date'] = datedict['yyyymmdd']
+        param['time'] = datedict['hhmmssssssss']
+        param['unit'] = self.config.unit_name
+        param['version'] = 1
+        param['channel'] = self._channel['symbol']
+        param['id_seq'] = id_sequence - 1
+        param['plane'] = 1
+        param['filter'] = filter_symbol
+        fname = self._ima.naming_set(param)
+        file_out = self._ima.join(fname)
+        log.info(f"{file_out=}")
+        self._ima.setkwd("DATE-OBS", date_obs)
+        self._ima.setkwd("FILTER", filter_symbol)
+        self._ima.save(file_out)
+
  
     def _plural(self, n: int) -> str:
         """Return "s" if n>1 for plurals.
@@ -382,7 +787,6 @@ class A_ImgProcessor(Agent):
  
 if __name__ == "__main__":
     args =  parse_args(sys.argv[1:])
-    #args = vars(parser.parse_args())
     agent = build_agent(A_ImgProcessor, param_constr=args)
     print(agent)
     agent.run()