Add files via upload

Author: sparshgarg23

data.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+
+import os
+import glob
+import random
+
+import cv2
+import numpy as np
+import h5py
+from sklearn.utils import shuffle
+
+
+class FileHDF5(object):
+    @staticmethod
+    def read(filename, db_name):
+        db = h5py.File(filename, "r")
+        np_data = np.array(db[db_name])
+        db.close()
+        
+        return np_data
+
+    @staticmethod
+    def write(data, filename, db_name, write_mode="w"):
+        """Write data to hdf5 format.
+
+        # Args
+            data : ndarray
+            filename : str
+                including full path
+            db_name : str
+                database name
+        """
+        def _check_directory(filename):
+            directory = os.path.dirname(filename)
+            if not os.path.exists(directory):
+                os.mkdir(directory)
+
+        _check_directory(filename)        
+        # todo : overwrite check
+        db = h5py.File(filename, write_mode)
+        dataset = db.create_dataset(db_name, data.shape, dtype="float")
+        dataset[:] = data[:]
+        db.close()
+
+
+def list_files(directory, pattern="*.*", n_files_to_sample=None, recursive_option=True, random_order=True):
+    """list files in a directory matched in defined pattern.
+
+    # Args
+        directory : str
+            filename of json file
+        pattern : str
+            regular expression for file matching
+        
+        n_files_to_sample : int or None
+            number of files to sample randomly and return.
+            If this parameter is None, function returns every files.
+        
+        recursive_option : boolean
+            option for searching subdirectories. If this option is True, 
+            function searches all subdirectories recursively.
+
+    # Returns
+        conf : dict
+            dictionary containing contents of json file
+    """
+
+    if recursive_option == True:
+        dirs = [path for path, _, _ in os.walk(directory)]
+    else:
+        dirs = [directory]
+    
+    files = []
+    for dir_ in dirs:
+        for p in glob.glob(os.path.join(dir_, pattern)):
+            files.append(p)
+    
+    if n_files_to_sample is not None:
+        if random_order:
+            files = random.sample(files, n_files_to_sample)
+        else:
+            files = files[:n_files_to_sample]
+    return files
+
+
+def files_to_images(files):
+    images = []
+    for filename in files:
+        image = cv2.imread(filename)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        images.append(image)
+    images = np.array(images)
+    return images
+
+
+def create_xy(pos_features, neg_features):
+    pos_ys = np.ones((len(pos_features)))
+    neg_ys = np.zeros((len(neg_features)))
+    xs = np.concatenate([pos_features, neg_features], axis=0)
+    ys = np.concatenate([pos_ys, neg_ys], axis=0)
+    xs, ys = shuffle(xs, ys, random_state=0)
+
+    from sklearn.model_selection import train_test_split
+    X_train, X_test, y_train, y_test = train_test_split(xs, ys, test_size=0.2, random_state=0)
+    return X_train, X_test, y_train, y_test

desc.py

@@ -0,0 +1,96 @@
+
+from skimage.feature import hog
+import numpy as np
+import abc
+
+class _Descriptor(object):
+
+    __metaclass__ = abc.ABCMeta
+    
+    def __init_(self, params):
+        pass
+    
+    @abc.abstractmethod
+    def get_features(self, images):
+        pass
+
+    @abc.abstractmethod
+    def get_params(self):
+        pass
+
+class HogDesc(_Descriptor):
+
+    def __init__(self, orientations=9, pix_per_cell=8, cell_per_block=2):
+        self._orientations = orientations
+        self._pix_per_cell = pix_per_cell
+        self._cell_per_block = cell_per_block
+
+    def get_features(self, images, feature_vector=True):
+        """
+        # Args
+            images : ndarray, shape of (N, n_rows, n_cols)
+                gray scale images
+    
+        # Returns
+            features :
+                if feature_vector == True:
+                    2d-array, shape of (N, (pix_per_cell - cell_per_block + 1)**2 * cell_per_block**2 * orientations)
+                else: 
+                    5d-array, shape of (N,
+                                       pix_per_cell - cell_per_block + 1,
+                                       pix_per_cell - cell_per_block + 1,
+                                       cell_per_block,
+                                       cell_per_block,
+                                       orientations)
+        """
+
+        features = []
+        for img in images:
+            feature_array = hog(img,
+                                orientations=self._orientations,
+                                pixels_per_cell=(self._pix_per_cell, self._pix_per_cell),
+                                cells_per_block=(self._cell_per_block, self._cell_per_block),
+                                visualise=False,
+                                feature_vector=feature_vector)
+            features.append(feature_array)
+    
+        features = np.array(features)
+        return features
+
+
+class HogMap(object):
+    
+    def __init__(self, hog_desc=HogDesc()):
+        self._img = None
+        self._desc = hog_desc
+
+    def _to_feature_map_point(self, x, y):
+        """
+        # Args
+            x : start x point in image
+            y : start y point in image
+
+        # Returns
+            x1 : x1 point in hog feature map
+            y1 : y1 point in hog feature map
+            x2
+            y2
+        """
+        unit_dim = self._desc._pix_per_cell - self._desc._cell_per_block + 1
+        x1 = x // self._desc._pix_per_cell
+        y1 = y // self._desc._pix_per_cell
+        x2 = x1 + unit_dim
+        y2 = y1 + unit_dim
+        return x1, y1, x2, y2
+
+    def set_features(self, gray):
+        self._img = gray
+        self._feature_map = self._desc.get_features([gray], feature_vector=False)
+    
+    def get_features(self, x, y):
+        x1, y1, x2, y2 = self._to_feature_map_point(x, y)
+        feature_vector = self._feature_map[:, y1:y2, x1:x2, :, :, :].ravel().reshape(1, -1)
+        return feature_vector
+
+
+

heatmap.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+from scipy.ndimage.measurements import label
+
+
+def separate(boxes_):
+    """separate heat boxes by aspect ratio"""
+    def _separate_box(box, axis="x"):
+        x1, y1, x2, y2 = box
+        
+        if axis == "x":
+            px = (x1 + x2) / 2
+            box1 = np.array([x1, y1, px, y2]).astype(int)
+            box2 = np.array([px, y1, x2, y2]).astype(int)
+        elif axis == "y":
+            py = (y1 + y2) / 2
+            box1 = np.array([x1, y1, x2, py]).astype(int)
+            box2 = np.array([x1, py, x2, y2]).astype(int)
+        return box1, box2
+    
+    boxes = np.array(boxes_).tolist()
+    for box in boxes[:]:
+        x1, y1, x2, y2 = box
+        w = x2-x1
+        h = y2-y1
+        
+        if w / h >= 1.85:
+            print("separation x", w / h)
+            box1, box2 = _separate_box(box, axis="x")
+            boxes.remove(box)
+            boxes.append(box1)
+            boxes.append(box2)
+
+        elif h / w >= 1.85:
+            print("separation y")
+            box1, box2 = _separate_box(box, axis="y")
+            boxes.remove(box)
+            boxes.append(box1)
+            boxes.append(box2)
+            
+    return boxes
+
+
+class HeatMap(object):
+    def __init__(self, threshold=2):
+        self._threshold = threshold
+        self._heat_map = None
+        self._heat_bin = None
+        
+    def get_boxes(self, boxes, w, h):
+        """
+        # Args
+            boxes : list of tuple (x1, y1, x2, y2)
+                detected boxes
+            w : int
+            h : int
+        
+        # Returns
+            heat_boxes : list of tuple (x1, y1, x2, y2)
+        """
+
+        self._heat_map = np.zeros((h, w)).astype(float)
+    
+        for box in boxes:
+            x1, y1, x2, y2 = box
+            self._heat_map[y1:y2, x1:x2] += 1
+            
+        self._heat_bin = self._get_bin()
+        heat_boxes = self._extract_boxes()
+        return heat_boxes
+
+    
+
+    def _get_bin(self):
+        heat_map_bin = np.zeros_like(self._heat_map)
+        heat_map_bin[self._heat_map >= self._threshold] = 255
+        return heat_map_bin
+
+    def _extract_boxes(self):
+        """
+        # Args
+            heat_map : ndarray
+                binary image
+        """
+        def _box(ccl_map, car_number):
+            # Find pixels with each car_number label value
+            nonzero = (ccl_map == car_number).nonzero()
+            # Identify x and y values of those pixels
+            nonzeroy = np.array(nonzero[0])
+            nonzerox = np.array(nonzero[1])
+            # Define a bounding box based on min/max x and y
+            x1 = np.min(nonzerox)
+            y1 = np.min(nonzeroy)
+            x2 = np.max(nonzerox)
+            y2 = np.max(nonzeroy)
+            return (x1, y1, x2, y2)
+            
+        boxes = []
+        ccl_map, n_labels = label(self._heat_bin)
+        for car_number in range(1, n_labels+1):
+            box = _box(ccl_map, car_number)
+            boxes.append(box)
+        return boxes
+
+
+if __name__ == '__main__':
+    pass
+    
+