Second test 16-Nov-2020

Author: haimadrian

Exams/2019-05-24.py

@@ -35,11 +35,11 @@ def countMyChars2(string):
 def myListHist(lst):
     def flattenList(lst_inner):
         result = []
-        for i in lst_inner:
-            if (isinstance(i, int)) or (isinstance(i, float) and i.is_integer()):
-                result.append(int(i))
-            elif isinstance(i, list):
-                result.extend(flattenList(i))
+        for j in lst_inner:
+            if (isinstance(j, int)) or (isinstance(j, float) and j.is_integer()):
+                result.append(int(j))
+            elif isinstance(j, list):
+                result.extend(flattenList(j))
         return result
 
     flattenedList = flattenList(lst)

Exams/ChangeColors.py Exams/A/ChangeColors.py

@@ -0,0 +1,35 @@
+# 305265514
+__author__ = "Haim Adrian"
+
+import numpy as np
+from matplotlib import pyplot as plt
+
+
+def FunctionPlotter(func='sqr'):
+    if func not in ['x^2', 'sqr', 'lnx', 'All']:
+        return None
+
+    def xSquare(xs):
+        return 0.5 * (xs ** 2) + 1.5 * xs + 7
+
+    def lnx(xs):
+        return 200 * np.log(xs - 3)
+
+    def sqr(xs):
+        return (0.01 * (xs ** 5) + 1.5) ** 0.5
+
+    x = np.arange(10, 50, 1/15)
+    plt.figure()
+    plt.title(func)
+    plt.xlabel('time[sec]')
+    plt.ylabel('amplitude')
+    if func == 'x^2' or func == 'All':
+        plt.plot(x, xSquare(x), 'red')
+
+    if func == 'lnx' or func == 'All':
+        plt.plot(x, lnx(x), 'black')
+
+    if func == 'sqr' or func == 'All':
+        plt.plot(x, sqr(x), 'blue')
+
+    plt.show()

Exams/DigitInMat.py Exams/A/DigitInMat.py

@@ -0,0 +1,23 @@
+# 305265514
+__author__ = "Haim Adrian"
+
+import numpy as np
+from numbers import Number
+
+
+def LetterInMat(thickness):
+    # thickness must be a positive integer
+    if thickness is None or not isinstance(thickness, Number) or thickness != np.int64(thickness) or thickness <= 0:
+        return None
+
+    thickness = np.int64(thickness)
+    mat = np.ones((6 * thickness, 5 * thickness), dtype=np.uint8)
+    dim = mat.shape
+
+    # Paint the horizontal parts of the letter C
+    mat[list(range(thickness, thickness * 2)) + list(range(dim[0] - thickness * 2, dim[0] - thickness)), thickness: dim[1] - thickness] = 0
+
+    # Paint the vertical part of the letter C, considering we've already painted some of the area while painting the horizontal parts
+    mat[thickness * 2: dim[0] - thickness * 2, thickness: thickness * 2] = 0
+
+    return mat

Exams/GetListStatistics.py Exams/A/GetListStatistics.py

@@ -0,0 +1,14 @@
+# 305265514
+__author__ = "Haim Adrian"
+
+from numbers import Number
+
+
+def ListObjectRemoval(myList):
+    # For None or not-a-list, just return what we've received
+    if myList is not None and isinstance(myList, list):
+        for item in myList:
+            if not isinstance(item, Number):
+                myList.remove(item)
+
+    return myList

Exams/InverseDictionary.py Exams/A/InverseDictionary.py

@@ -0,0 +1,31 @@
+# 305265514
+__author__ = "Haim Adrian"
+
+import numpy as np
+import operator
+
+
+def MostCommonColor(myImage):
+    if not isinstance(myImage, np.ndarray):
+        return None
+
+    if myImage.ndim == 2:
+        # For 2D image just count each scalar and return the maximum one
+        unique, counts = np.unique(myImage, return_counts=True)
+        return unique[np.argmax(counts)]
+    elif myImage.ndim == 3:
+        # Define a dictionary to count the occurrences of each color in the specified image
+        countsDic = {}
+
+        # Scan the whole matrix of colors, instead of sub-calling MostCommonColor, cause we need to count colors
+        # and not finding the maximum scalar in each level of z.
+        for row in range(myImage.shape[0]):
+            for col in range(myImage.shape[1]):
+                # Make current color a tuple so we can register it as key in a dictionary
+                currColor = (myImage[row, col, 0], myImage[row, col, 1], myImage[row, col, 2])
+                countsDic[currColor] = countsDic.get(currColor, 0) + 1
+
+        # Return the key where its value is the maximum one among all values in the dictionary
+        return max(countsDic.items(), key=operator.itemgetter(1))[0]
+    else:
+        return None

Exams/NeighborElections.py Exams/A/NeighborElections.py

@@ -0,0 +1,16 @@
+# 305265514
+__author__ = "Haim Adrian"
+
+
+# 24-05-2019 exam.
+def countMyStrings(string):
+    if string is None or not isinstance(string, str):
+        return None
+
+    # First, lowercase the string so we will count characters ignoring case
+    string = string.lower()
+
+    # Second, make the characters of a string into set so we will count each character without repeating ourselves
+    counts = {c: string.count(c) for c in set(string)}
+
+    return counts

Exams/PercentileFilter.py Exams/A/PercentileFilter.py

@@ -0,0 +1,13 @@
+# 305265514
+__author__ = "Haim Adrian"
+
+import numpy as np
+
+
+def my_unique_mat(size):
+    if size != np.uint64(size):
+        return None
+
+    myMat, myMat[np.eye(size) == 1], myMat[np.eye(size)[::-1] == 1], myMat[int(np.round(size / 2 - 0.5)), int(np.round(size / 2 - 0.5))] = np.ones((size, size), dtype=np.uint8), 0, 2, (1 if size % 2 == 1 else 0)
+
+    return myMat

Exams/B/FunctionPlotter.py

@@ -1,5 +1,7 @@
 __author__ = "Haim Adrian"
 
+from operator import itemgetter
+
 from matplotlib import pyplot as plt
 import numpy as np
 import cv2
@@ -57,29 +59,57 @@ def myMasking(myImage, myMask):
 
 
 # ex8
-img = cv2.imread('eagle.jpeg', 0)
+img = cv2.imread('img.jpg', 0)
+img2 = cv2.imread('img.jpg')
 # img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 SharpenMask = np.array([[-1, -2, -1],
                         [-2, 13, -2],
                         [-1, -2, -1]], dtype=np.float64)
+Sharpen2Mask = np.array([[2, 2, 2],
+                         [2, 16, 2],
+                         [2, 2, 2]], dtype=np.float64)
 GausMask = (1.0 / 273) * np.array([[1, 4, 7, 4, 1],
                                    [4, 16, 26, 16, 4],
                                    [7, 26, 41, 26, 7],
                                    [4, 16, 26, 16, 4],
                                    [1, 4, 7, 4, 1]],
                                   dtype=np.float64)
-my_sol = mmyMaskKernel(img, SharpenMask)
-print(np.min(my_sol), np.max(my_sol))
-my_sol = np.uint8((my_sol - np.min(my_sol)) / np.max(my_sol) * 255)
-masked = myMaskKernel(img, SharpenMask)
-masked = np.uint8((masked - np.min(masked)) / np.max(masked) * 255)
-third = myMasking(img, SharpenMask)
-print(np.min(third), np.max(third))
-third = np.uint8((third - np.min(third)) / np.max(third) * 255)
-plt.subplot(131)
-plt.imshow(masked, CMAP='gray')
-plt.subplot(132)
-plt.imshow(my_sol, CMAP='gray')
-plt.subplot(133)
-plt.imshow(third, CMAP='gray')
-plt.show()
+
+
+def MostCommonColor(myImage):
+    if not isinstance(myImage, np.ndarray):
+        return None
+
+    if myImage.ndim == 2:
+        unique, counts = np.unique(myImage, return_counts=True)
+        return unique[np.argmax(counts)]
+    elif myImage.ndim == 3:
+        countsDic = {}
+
+        for row in range(myImage.shape[0]):
+            for col in range(myImage.shape[1]):
+                currColor = (myImage[row, col, 0], myImage[row, col, 1], myImage[row, col, 2])
+                countsDic[currColor] = countsDic.get(currColor, 0) + 1
+
+        return max(countsDic.items(), key=itemgetter(1))[0]
+    else:
+        return None
+
+
+print(MostCommonColor(img))
+print(MostCommonColor(img2))
+# my_sol = myMasking(img, Sharpen2Mask)
+# print(np.min(my_sol), np.max(my_sol))
+# my_sol = np.uint8((my_sol - np.min(my_sol)) / np.max(my_sol) * 255)
+# masked = myMaskKernel(img, SharpenMask)
+# masked = np.uint8((masked - np.min(masked)) / np.max(masked) * 255)
+# third = myMasking(img, SharpenMask)
+# print(np.min(third), np.max(third))
+# third = np.uint8((third - np.min(third)) / np.max(third) * 255)
+# plt.subplot(131)
+# plt.imshow(masked, CMAP='gray')
+# plt.subplot(132)
+# plt.imshow(my_sol, CMAP='gray')
+# plt.subplot(133)
+# plt.imshow(third, CMAP='gray')
+# plt.show()