Enhance and restructure source code files

Author: AbdallahHemdan

classifier-elghalaba.ipynb

@@ -1,17 +1,9 @@
-from sklearn.neighbors import KNeighborsClassifier
-from sklearn.neural_network import MLPClassifier  # MLP is an NN
-from sklearn import svm, tree
-import numpy as np
-import argparse
-import imutils
 import cv2
 import os
-import skimage.io as io
 import random
-from skimage.transform import rotate
-from sklearn.model_selection import train_test_split
-import pickle
-import matplotlib.pyplot as plt
+import argparse
+import numpy as np
+from sklearn import svm
 
 
 ########## Variables ##########
@@ -22,32 +14,11 @@
 np.random.seed(random_seed)
 
 classifiers = {
-    'SVM': svm.LinearSVC(random_state=random_seed),
-    'KNN': KNeighborsClassifier(n_neighbors=7),
-    'NN': MLPClassifier(solver='sgd', random_state=random_seed, hidden_layer_sizes=(500,), max_iter=200, verbose=1),
-    'TREE': tree.DecisionTreeClassifier(random_state=0, max_depth=10)
+    'SVM': svm.LinearSVC(random_state=random_seed)
 }
 
 ########## Methods ##########
 
-
-def extract_raw_pixels(img):
-    return cv2.resize(img, target_img_size).flatten()
-
-
-def extract_sift_features(img):
-    img = cv2.resize(img, target_img_size)
-
-    sift = cv2.SIFT_create()
-    _, features = sift.detectAndCompute(img, None)
-
-    try:
-        return features.flatten()
-    except:
-        io.imshow(img)
-        io.show()
-
-
 def extract_hog_features(img):
     img = cv2.resize(img, target_img_size)
     win_size = (32, 32)
@@ -64,15 +35,8 @@ def extract_hog_features(img):
     h = h.flatten()
     return h.flatten()
 
-
 def extract_features(img, feature_set='hog'):
-    if feature_set == 'hog':
-        return extract_hog_features(img)
-    elif feature_set == 'sift':
-        return extract_sift_features(img)
-    else:
-        return extract_raw_pixels(img)
-
+    return extract_hog_features(img)
 
 def get_directories():
     directories = []
@@ -83,7 +47,6 @@ def get_directories():
 
     return directories
 
-
 def load_dataset(feature_set='hog'):
     labels = []
     features = []
@@ -105,7 +68,6 @@ def load_dataset(feature_set='hog'):
 
     return features, labels
 
-
 def run_experiment(train_features, test_features, train_labels, test_labels, model_name):
     model = classifiers[model_name]
     print('############## Training', model_name, "##############")

classifier.py

@@ -1,7 +1,19 @@
-import numpy as np
 import cv2
+import random
+import numpy as np
+from sklearn import svm
 
 # List of maps and needed variables #
+
+########## Variables ##########
+random_seed = 42
+random.seed(random_seed)
+target_img_size = (32, 32)
+np.random.seed(random_seed)
+classifiers = {
+    'SVM': svm.LinearSVC(random_state=random_seed)
+}
+
 direct_labels = ['x', 'b', 'clef', 'dot', 'hash', 'd', 't_2', 't_4', 'symbol_bb', 'barline']
 direct_texts = {'x':'##', 'b':'&', 'hash':'#', 'd':'', 'symbol_bb':'&&', 'dot':'.', 'clef':'', 't_2':'2', 't_4':'4', 'barline':''}
 
@@ -140,3 +152,19 @@ def preprocess_img(img_path):
     # 4. Return image shape (width, height) and processed image # 
     n, m = img.shape
     return n, m, img
+
+def extract_hog_features(img):
+    img = cv2.resize(img, target_img_size)
+    win_size = (32, 32)
+    cell_size = (4, 4)
+    block_size_in_cells = (2, 2)
+
+    block_size = (block_size_in_cells[1] * cell_size[1],
+                  block_size_in_cells[0] * cell_size[0])
+    block_stride = (cell_size[1], cell_size[0])
+    nbins = 9
+    hog = cv2.HOGDescriptor(win_size, block_size,
+                            block_stride, cell_size, nbins)
+    h = hog.compute(img)
+    h = h.flatten()
+    return h.flatten()

helper_methods.py

@@ -1,14 +1,13 @@
-from classifier import *
 from preprocessing import *
 from staff_removal import *
 from helper_methods import *
 
 import argparse
 import os
 import datetime
+
 # Initialize parser
 parser = argparse.ArgumentParser()
-
 parser.add_argument("inputfolder", help = "Input File")
 parser.add_argument("outputfolder", help = "Output File")
 
@@ -22,11 +21,9 @@
 
 # Threshold for line to be considered as an initial staff line #
 threshold = 0.8
-accidentals = ['x', 'hash', 'b', 'symbol_bb', 'd']
-
-
 filename = 'model/model.sav'
 model = pickle.load(open(filename, 'rb'))
+accidentals = ['x', 'hash', 'b', 'symbol_bb', 'd']
 
 def preprocessing(inputfolder, fn, f):
       # Get image and its dimensions #
@@ -46,58 +43,63 @@ def preprocessing(inputfolder, fn, f):
 
     return cutted, ref_lines, lines_spacing
 
+def get_target_boundaries(label, cur_symbol, y2):
+    if label == 'b_8':
+        cutted_boundaries = cut_boundaries(cur_symbol, 2, y2)
+        label = 'a_8'
+    elif label == 'b_8_flipped':
+        cutted_boundaries = cut_boundaries(cur_symbol, 2, y2)
+        label = 'a_8_flipped'
+    elif label == 'b_16':
+        cutted_boundaries = cut_boundaries(cur_symbol, 4, y2)
+        label = 'a_16'
+    elif label == 'b_16_flipped':
+        cutted_boundaries = cut_boundaries(cur_symbol, 4, y2)
+        label = 'a_16_flipped'
+    else: 
+        cutted_boundaries = cut_boundaries(cur_symbol, 1, y2)
+
+    return label, cutted_boundaries
+
+def get_label_cutted_boundaries(boundary, height_before, cutted):
+    # Get the current symbol #
+    x1, y1, x2, y2 = boundary
+    cur_symbol = cutted[y1-height_before:y2+1-height_before, x1:x2+1]
+
+    # Clean and cut #
+    cur_symbol = clean_and_cut(cur_symbol)
+    cur_symbol = 255 - cur_symbol
+
+    # Start prediction of the current symbol #
+    feature = extract_hog_features(cur_symbol)
+    label = str(model.predict([feature])[0])
+
+    return get_target_boundaries(label, cur_symbol, y2)
+
 def process_image(inputfolder, fn, f):
     cutted, ref_lines, lines_spacing = preprocessing(inputfolder, fn, f)
 
     last_acc = ''
     last_num = ''
     height_before = 0
 
-
     if len(cutted) > 1:
         f.write('{\n')
 
 
     for it in range(len(cutted)):
         f.write('[')
         is_started = False
-        cur_img = cutted[it].copy()
 
-                
-        symbols_boundries = segmentation(height_before, cutted[it])
-        symbols_boundries.sort(key = lambda x: (x[0], x[1]))
+
+        symbols_boundaries = segmentation(height_before, cutted[it])
+        symbols_boundaries.sort(key = lambda x: (x[0], x[1]))
 
-        symbols = []
-        for boundry in symbols_boundries:
-            # Get the current symbol #
-            x1, y1, x2, y2 = boundry
-            cur_symbol = cutted[it][y1-height_before:y2+1-height_before, x1:x2+1]
-            
-            # Clean and cut #
-            cur_symbol = clean_and_cut(cur_symbol)
-            cur_symbol = 255 - cur_symbol
+        for boundary in symbols_boundaries:
+            label, cutted_boundaries = get_label_cutted_boundaries(boundary, height_before, cutted[it])
 
-            # Start prediction of the current symbol #
-            feature = extract_features(cur_symbol, 'hog')
-            label = str(model.predict([feature])[0])
-            
             if label == 'clef':
                 is_started = True
-
-            if label == 'b_8':
-                cutted_boundaries = cut_boundaries(cur_symbol, 2, y2)
-                label = 'a_8'
-            elif label == 'b_8_flipped':
-                cutted_boundaries = cut_boundaries(cur_symbol, 2, y2)
-                label = 'a_8_flipped'
-            elif label == 'b_16':
-                cutted_boundaries = cut_boundaries(cur_symbol, 4, y2)
-                label = 'a_16'
-            elif label == 'b_16_flipped':
-                cutted_boundaries = cut_boundaries(cur_symbol, 4, y2)
-                label = 'a_16_flipped'
-            else: 
-                cutted_boundaries = cut_boundaries(cur_symbol, 1, y2)
 
             for cutted_boundary in cutted_boundaries:
                 _, y1, _, y2 = cutted_boundary
@@ -126,29 +128,29 @@ def process_image(inputfolder, fn, f):
     if len(cutted) > 1:
         f.write('}')
 
-for i in [args.inputfolder]:
+def main():
     try: 
         os.mkdir(args.outputfolder) 
-    except OSError as error: 
+    except OSError as error:
         pass
-    
 
     list_of_images = os.listdir(args.inputfolder)
-
-    for i, fn in enumerate(list_of_images):
-      # Open the output text file #
-      file_prefix = fn.split('.')[0]
-      f = open(f"{args.outputfolder}/{file_prefix}.txt", "w")
-
-
-      # Process each image separately #
-      try:
-        process_image(args.inputfolder, fn, f)
-      except:
-        print(f'{args.inputfolder}-{fn} has been failed !!')
-        pass
-
-      f.close()  
+    for _, fn in enumerate(list_of_images):
+        # Open the output text file #
+        file_prefix = fn.split('.')[0]
+        f = open(f"{args.outputfolder}/{file_prefix}.txt", "w")
+
+        # Process each image separately #
+        try:
+            process_image(args.inputfolder, fn, f)
+        except Exception as e:
+            print(e)
+            print(f'{args.inputfolder}-{fn} has been failed !!')
+            pass
+        
+        f.close()  
+    print('Finished !!') 
 
 
-print('Finished !!') 
+if __name__ == "__main__":
+    main()

input/01.PNG

@@ -1 +1 @@
-Input Folder: ./inputOutput Folder: ./outputDate: 2021-01-12 00:08:22.493123
+Input Folder: ./inputOutput Folder: ./outputDate: 2021-01-12 00:56:23.465829

input/02.PNG

@@ -1,4 +1,5 @@
 import numpy as np
+import pickle
 from numpy.linalg import norm
 from skimage.filters import *
 from skimage.color import rgb2gray
@@ -71,4 +72,4 @@ def display(img):
     cv.resizeWindow('image', 1920, 1080)
     cv.imshow('image', img)
     if cv.waitKey(0) == 27:
-        cv2.destoyAllWindows() 
+        cv2.destoyAllWindows()