FABIEN_VAUCLIN

README.md

@@ -5,6 +5,9 @@ Algorithms, code writing and continuous integration @ DIM Bachelor, Université
 Those lessons are addressed to the "Développeur Informatique Multisupports" (DIM) Bachelor proposed at Université Savoie Mont Blanc in France.
 Students are expected to be familiar with programming. The aim is to get more familiar with code quality, maintainability and efficacy... and Python.
 
+# Coveralls Badge 
+[![Coverage Status](https://coveralls.io/repos/github/Fabien-Vauclin/BachelorDIM-Lectures-Algorithms-2020/badge.svg?branch=master)](https://coveralls.io/github/Fabien-Vauclin/BachelorDIM-Lectures-Algorithms-2020?branch=master)
+
 **Lessons organisation draft :**
 
 1. Get familiar with maintainable codes using git, sonarcloud and doxygen. *Introduction* slides [here](https://docs.google.com/presentation/d/1xXrdokfxOUP-3b1fEPRfieUhOEez7FJeUtauMpjV4bk/edit?usp=sharing)

assignements/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-pro
+repo_token: z9ivIKMPKpXWWp1TiUR46oKvPMzRXqclQ

assignements/.travis.yml

@@ -0,0 +1,14 @@
+language: python
+python:
+  - "3.8"
+# command to install dependencies
+install:
+  - pip install -r requirements.txt
+addons:
+  sonarcloud:
+    organization: Fabien-Vauclin-github
+# command to run tests
+script:
+  - pytest -v --cov
+  #- sonar-scanner
+  - coveralls

assignements/S1_algotools.py

@@ -0,0 +1,142 @@
+# Average
+def average(tab):
+    """
+    Calculate the average of a list
+    Parameters
+        tab
+    Returns the average of the list
+    """
+    som = 0
+    n = 0
+    for i in range(len(tab)):
+        if tab[i] > 0:
+            som = som + tab[i]
+            n = n + 1
+    moy = som / n
+    print(moy)
+
+
+average([100, 20, 30])
+
+
+# Maximum value
+def max_value_in_tab(tab):
+    """
+    Get the maximum value of a tab
+    Parameters
+        tab
+    Returns the maximum value of a tab
+    """
+    max = tab[0]
+    for a in tab:
+        if a > max:
+            max = a
+    return max
+
+
+print(max_value_in_tab([1, 12, -8, 300]))
+
+
+# Reverse a table
+tab = [100, 'abc', 437, 'def', 123]
+tab.reverse()
+print(tab)
+
+# Reverse a table V2
+def reverse_table(tab):
+    """
+        Reverse a table
+        Parameters
+            table of numbers
+        Returns reversed table
+    """
+    for i in range(len(tab)//2):
+        list_len = len(tab)
+        tmp = tab[i]
+        endid = list_len - i - 1
+        tab[i] = tab[list_len - 1]
+        tab[i] = tab[endid]
+        tab[endid] = tmp
+    return tab
+
+
+print(reverse_table([100, 200, 300, 400]))
+
+
+# Bounding box
+
+import numpy as np
+
+def bounding_box(matrix):
+    """
+    Compute the bounding box coordinates of an object
+    Parameters
+        matrix
+    Returns numpy array of shape 4x2 filled with the four 2d coordinates
+    """
+    w = matrix.shape[1]
+    h = matrix.shape[0]
+    x1 = w
+    y1 = h
+    x2 = 0
+    y2 = 0
+    for x in range(w):
+        for y in range(h):
+            if matrix[y, x]:
+                if x < x1:
+                    x1 = x
+                    print("bound entry x1: ", x1)
+                if y < y1:
+                    y1 = y
+                    print("bound entry y1: ", y1)
+                if x2 < x:
+                    x2 = x
+                    print("bound entry x2: ", x2)
+                if y2 < y:
+                    y2 = y
+                    print("bound entry y2: ", y2)
+
+    return (x1, y1, x2, y2)
+
+# Random array filling
+
+#Remove whitespace characters in a string:
+def remove_whitespace(string):
+    """
+        Parse a string and remove all its whitespace
+        Parameters
+            string
+        Returns string without whitespaces
+    """
+    return string.replace(" ", "")
+
+
+string = ' l p d i m '
+print(remove_whitespace(string))
+
+# Random item selection
+import random
+
+def random_item(list:any):
+
+    """
+         Randomly select item of a list
+         Parameters
+             list
+         Returns one item of the list
+    """
+    return random.choice(list)
+
+
+list = 1, 6, "b", 12, "k", 8, "LP DIM", 2020, "Overkiz", "Hr Team"
+print(random_item(list))
+
+# Personal test for testing numpy with Pycharm
+a = np.array([1, 2, 4])
+print(a)
+
+# My Addition function
+def my_addition(a, b):
+    return a+b
+
+print('10+2=12 ?',my_addition(10,2))

assignements/S1_dice.py

@@ -0,0 +1,56 @@
+"""
+@author: fabien-v
+"""
+
+# Dice Game
+
+
+def shuffle():
+
+    import random
+    user_score = 0
+    computer_score = 0
+    minimum = 1
+    maximum = 6
+    user_roll = random.randint(minimum, maximum)
+    computer_roll = random.randint(minimum, maximum)
+
+    if user_roll == 1:
+        user_score += 1
+    elif user_roll == 2:
+        user_score += 2
+    elif user_roll == 3:
+        user_score += 3
+    elif user_roll == 4:
+        user_score += 4
+    elif user_roll == 5:
+        user_score += 5
+    elif user_roll == 6:
+        user_score += 6
+
+    if user_score  == 100:
+        print("user win !")
+    if computer_score == 100:
+        print("computer win !")
+
+# idea / in progress
+
+# boucle avec
+# Tant que user_try > 1
+#    roll_again (continue ?)
+
+# Si user_try == 1
+#    alors c'est au tour de à computer_try et ainsi de suite
+
+
+
+
+
+
+
+
+
+
+
+
+

assignements/S3_imgproc_tools.py

@@ -0,0 +1,55 @@
+import cv2
+import numpy as np
+img = cv2.imread('/home/fabien/Pictures/algo_img.jpg')
+
+print("input image shape", img.shape)
+
+cv2.imshow('input', img)
+cv2.waitKey()
+
+img_out = np.zeros(img.shape, dtype=np.uint8)
+
+for row in range(img.shape[0]):
+    for col in range(img.shape[1]):
+        for channel in range (img.shape[2]):
+            img_out[row, col, channel] = 255-img[row, col, channel]
+
+cv2.imshow("output", img_out)
+cv2.waitKey()
+
+
+def invert_colors_numpy(input_img):
+    '''
+
+    This function reverse the color of an image
+    Parameters:
+        input_img: an image
+    Returns: a reversed image. It's the optimal solution.
+
+    '''
+    return 255 - input_img
+
+
+img_gray = cv2.imread("/home/fabien/Pictures/algo_img.jpg", 0)
+img_bgr = cv2.imread("/home/fabien/Pictures/algo_img.jpg", 1)
+img_bgr_reversed = invert_colors_numpy(cv2.imread("/home/fabien/Pictures/algo_img.jpg", 1))
+
+cv2.imshow("Gray levels image", img_gray)
+cv2.imshow("BGR image", img_bgr)
+cv2.imshow("BGR image inverted", img_bgr_reversed)
+cv2.waitKey()
+
+
+img = cv2.imread("/home/fabien/Pictures/algo_img.jpg")
+def inv_gray_levels(img):
+    if img is None:
+        raise ValueError("expected an uint8 and array")
+    if not (isinstance(img, np.ndarray)):
+        raise TypeError("expected and nd array")
+    if img.dtype!=np.dtype(np.uint8):
+        raise TypeError("expected uint8 typed nd array")
+    return 255-img
+print(inv_gray_levels(img))
+
+
+

assignements/queue_publish_read.py

@@ -0,0 +1,22 @@
+import argparse
+import pika, os
+from assignements import simple_queue_publish
+from assignements import simple_queue_read
+from assignements import mykey
+
+url = os.environ.get('CLOUDAMQP_URL', mykey.myKey)
+params = pika.URLParameters(url)
+params.socket_timeout = 5
+connection = pika.BlockingConnection(params)
+channel = connection.channel() # start a channel
+channel.queue_declare(queue='hello') # Declare a queue
+
+parser = argparse.ArgumentParser(description='How to')
+parser.add_argument('-read', action='store_true')
+flags = parser.parse_args()
+
+if(flags.read):
+    simple_queue_read.read_queue(channel)
+else:
+    simple_queue_publish.publish_queue(channel)
+connection.close()

assignements/requirements.txt

@@ -0,0 +1,9 @@
+matplotlib>=3.3.2
+numpy>=1.19.2
+pika>=1.1.0
+pytest>=6.0.2
+python-dateutil>=2.8.1
+scipy>=1.5.2
+urllib3>=1.25.10
+pytest-cov>=2.10.1
+coveralls>=2.1.2

assignements/simple_queue_publish.py

@@ -0,0 +1,20 @@
+# publish.py
+import pika
+import os
+from assignements import mykey
+
+
+# Access the CLODUAMQP_URL environment variable and parse it (fallback to localhost)
+
+
+url = os.environ.get('CLOUDAMQP_URL', mykey.myKey)
+params = pika.URLParameters(url)
+connection = pika.BlockingConnection(params)
+channel = connection.channel() # start a channel
+channel.queue_declare(queue='hello') # Declare a queue
+channel.basic_publish(exchange='',
+                      routing_key='hello',
+                      body='Hello CloudAMQP!')
+
+print(" [x] Sent 'Hello World!'")
+connection.close()

assignements/simple_queue_read.py

@@ -0,0 +1,21 @@
+# consume.py
+import pika, os
+
+# Access the CLODUAMQP_URL environment variable and parse it (fallback to localhost)
+from assignements import mykey
+
+url = os.environ.get('CLOUDAMQP_URL', mykey.myKey)
+params = pika.URLParameters(url)
+connection = pika.BlockingConnection(params)
+channel = connection.channel() # start a channel
+channel.queue_declare(queue='hello') # Declare a queue
+def callback(ch, method, properties, body):
+  print(" [x] Received " + str(body))
+
+channel.basic_consume('hello',
+                      callback,
+                      auto_ack=True)
+
+print(' [*] Waiting for messages:')
+channel.start_consuming()
+connection.close()

assignements/test_S2.py

@@ -0,0 +1,15 @@
+import S1_algotools as tobetested
+import pytest
+
+def test_myaddition_integers_1():
+    assert tobetested.my_addition(10,2) == 12
+
+def test_myaddition_integers_2():
+    assert tobetested.my_addition(-1,2) == 1
+
+def test_myaddition_wrong_input():
+    with pytest.raises(TypeError):
+        tobetested.my_addition('a',2)
+
+def test_remove_whitespace():
+    assert tobetested.remove_whitespace("t e s t m y f u n c t i o n")

assignements/test_S3_imgproc_tools.py

@@ -0,0 +1,17 @@
+import numpy as np
+import pytest
+import S3_imgproc_tools as algo
+null_matrix = np.zeros((10, 10), dtype = bool)
+
+def test_invert_colors_numpy_None():
+    with pytest.raises(ValueError):
+        algo.inv_gray_levels(None)
+
+
+def test_invert_colors_numpy_Aray():
+    with pytest.raises(TypeError):
+        algo.inv_gray_levels(1)
+
+def test_invert_colors_numpy_uint8():
+    with pytest.raises(TypeError):
+        algo.inv_gray_levels(null_matrix)