Final tests andre

README.md

@@ -1,2 +1,13 @@
 # BlendHunter
 Deep learning tool for identifying blended galaxy images in survey images.
+
+### blendhunter 
+Find the codes for the data preparation and the network in that folder.
+
+### notebooks
+Find the jupyter notebooks for results visualization.
+
+### sextractor
+Find the scripts to run SExtractor.
+
+

blendhunter/config.py

@@ -0,0 +1,28 @@
+import os
+import yaml
+
+
+class BHConfig:
+
+    def __init__(self, config_file='data/bhconfig.yml'):
+
+        self.config_file = config_file
+        self._read_config()
+
+    def _read_config(self):
+
+        if os.path.isfile(self.config_file):
+            with open(self.config_file) as file:
+                self.config = yaml.load(file, Loader=yaml.FullLoader)
+        else:
+            self.config = {}
+
+    def _update_config(self):
+
+        with open(self.config_file, 'w') as file:
+            yaml.dump(self.config, file)
+
+    def _add_params(self, params):
+
+        self.config = {**self.config, **params}
+        self._update_config()

blendhunter/data.py

@@ -11,7 +11,7 @@
 import os
 import numpy as np
 import cv2
-from .blend import Blender
+from blendhunter.blend import Blender
 
 
 class CreateTrainData(object):
@@ -26,7 +26,7 @@ class CreateTrainData(object):
     output_path : str
         Path to where the data will be saved
     train_fractions : tuple, optional
-        Fraction of trainig, validation and testing samples from the input
+        Fraction of training, validation and testing samples from the input
         images, default is (0.45, 0.45, .1)
     classes : tuple, optional
         Names of the various data classes, default is ('blended',
@@ -44,7 +44,7 @@ class CreateTrainData(object):
 
     """
 
-    def __init__(self, images, output_path, train_fractions=(0.45, 0.45, .1),
+    def __init__(self, images, output_path, train_fractions=(0.45, 0.45, 0.1),
                  classes=('blended', 'not_blended'),
                  class_fractions=(0.5, 0.5), blend_images=True,
                  blend_fractions=(0.5, 0.5), blend_method='sf'):
@@ -61,7 +61,6 @@ def __init__(self, images, output_path, train_fractions=(0.45, 0.45, .1),
         self.blend_images = blend_images
         self.blend_fractions = blend_fractions
         self.blend_method = blend_method
-        self._image_num = 0
 
         self._make_output_dirs()
 
@@ -122,7 +121,7 @@ def _make_output_dirs(self):
     def _get_slices(array, fractions):
         """ Get Slices
 
-        This method converts sample fractions into slice elemets for a given
+        This method converts sample fractions into slice elements for a given
         array.
 
         Parameters
@@ -230,8 +229,9 @@ def _write_images(self, images, path):
         """
 
         min_shape = np.array([48, 48])
+        zero_pad = np.log10(images.shape[0]).astype(int) + 1
 
-        for image in images:
+        for image_num, image in enumerate(images):
 
             image = self._rescale(image)
 
@@ -240,8 +240,8 @@ def _write_images(self, images, path):
             if np.sum(shape_diff) > 0:
                 image = self._pad(image, shape_diff)
 
-            cv2.imwrite('{}/image_{}.png'.format(path, self._image_num), image)
-            self._image_num += 1
+            cv2.imwrite('{0}/image_{2:0{1}d}.png'.format(path, zero_pad,
+                        image_num), image)
 
     def _write_data_set(self, data_list, path_list):
         """ Write Data Set
@@ -360,19 +360,67 @@ def generate(self):
                 test_set = np.vstack(test_set)
             self._write_images(test_set, self._test_path)
 
-    def prep_axel(self):
+    def prep_axel(self, path_to_output=None, psf=None, param_1=None,
+                  param_2=None, map=None):
+        # Can add parameters : psf, param_1, param_2, map
 
-        self.images[0] = np.random.permutation(self.images[0])
-        self.images[1] = np.random.permutation(self.images[1])
+        # self.images[0] = np.random.permutation(self.images[0])
+        # self.images[1] = np.random.permutation(self.images[1])
 
         split1 = self._split_array(self.images[0], self.train_fractions)
         split2 = self._split_array(self.images[1], self.train_fractions)
 
+        # Split fwhm
+        train_fractions = (0.45, 0.45, 0.1)
+        # psf_split1 = CreateTrainData._split_array(psf[0], train_fractions)
+        # psf_split2 = CreateTrainData._split_array(psf[1], train_fractions)
+
+        # Split shift params
+        # x_split = CreateTrainData._split_array(param_1[0], train_fractions)
+        # y_split = CreateTrainData._split_array(param_2[0], train_fractions)
+
+        # Split segmentation map
+        # map_split = CreateTrainData._split_array(map[0], train_fractions)
+
         train_set = split1[0], split2[0]
         valid_set = split1[1], split2[1]
         test_set = split1[2], split2[2]
 
+        # test_psf = psf_split1[2], psf_split2[2]
+        # test_param_x = x_split[2]
+        # test_param_y = y_split[2]
+        # test_im_blended = split1[2] #blended test images
+        # test_im_nb = split2[2]
+        # test_map = map_split[2]
+
         self._write_data_set(train_set, self._train_paths)
         self._write_data_set(valid_set, self._valid_paths)
         self._write_labels(test_set)
         self._write_images(np.vstack(test_set), self._test_path)
+
+        # Save test_psf
+        # np.save(path_to_output+'/test_psf.npy', test_psf)
+
+        # Save test_params
+        # np.save(path_to_output+'/test_param_x.npy', test_param_x)
+        # np.save(path_to_output+'/test_param_y.npy', test_param_y)
+
+        # Save blended test images
+        # np.save(path_to_output+'/gal_im_blended.npy', test_im_blended)
+        # np.save(path_to_output+'/gal_im_nb.npy', test_im_nb)
+        # np.save(path_to_output+'/test_images.npy', test_set)
+
+        # Save seg_map
+        # np.save(path_to_output+'/test_seg_map.npy', test_map)
+
+    def prep_cosmos(self):
+
+        split1 = self._split_array(self.images[0], self.train_fractions)
+        split2 = self._split_array(self.images[1], self.train_fractions)
+
+        train_set = split1[0], split2[0]
+        valid_set = split1[1], split2[1]
+        test_set = split1[2], split2[2]
+
+        self._write_labels(test_set)
+        self._write_images(np.vstack(test_set), self._test_path)