diff --git a/README.md b/README.md
index 6bf7c90c61d351f1121bc8807617cc34703f3d10..8b91d9b6dee06a93208a0d8c879d43e7f3793233 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,10 @@
- [Internet Of Things - Worksheet 2 part 1](#internet-of-things---worksheet-2-part-1)
- [Description](#description)
+ - [Task 1: Getting to know morse code](#task-1-getting-to-know-morse-code)
+ - [Task 2: Python encode / decode.](#task-2-python-encode--decode)
+ - [Task 3: Unit testing.](#task-3-unit-testing)
+ - [Task 4: Expanding capability.](#task-4-expanding-capability)
- [Getting Started](#getting-started)
- [Dependencies](#dependencies)
- [Installing](#installing)
@@ -20,29 +24,80 @@
## Description
- Morse code :: Worksheet(2 part 1)
- A program to encode and decode morse.
+Morse code :: Worksheet(2 part 1)
+A program to encode and decode morse.
+### Task 1: Getting to know morse code
+* *The CSCT cloud server has a port open on 10105 which contains a morse encoder and decoder. We are required to connect to the service and test its functionality*.
+* To connect to the port on the csct server we need to be able to access the port. Todo this we can port ford the port via VS Code. Using the command `Ctrl + Shift + P` we can bring up the command wind and open ports:  if we then add the port 10105  should be able to access that port on our local machine using a browser to access `localhost:10105` as we can see it has worked and we can now connect to the 10105 port on the csct cloud server: 
+* Here are a few example runs of testing the encoder / decoder service:
+ *  ***us*** encodes to ***..- ...***
+ *  ***.. --- - .. -. -- -.-- ..-. .- ...- --- ..- .-. .. - . -- --- -.. ..- .-.. . -.-.--*** decodes to ***iot is my favorite module!*** One this to node is the server does not deal with *Capitalisation* and will just return lower case text. This got me thinking. What else does the server not deal with?
+ *  entering ***£$%*^** yeilds not return from the encoder thus meaning the server must not be setup to deal with these special characters and are out of scope of the servers encoder / decoder.
+___
+### Task 2: Python encode / decode.
+* Task two requires use to create a python morse encoder / decoder using a binary tree.
+* Morse.py contains two functions **encode()** and **decode()**. They do what you might expect. encode() takes ascii string and returns a string of `_` or `.` for the corresponding letter. This is done with a binary tree implementation.
+* ***The binary tree:***
+ * The binary tree is stored in a class. Each instance of the class contains a value for **itself**, and a **left**, **right** node which both contain the same class. This allows for a binary tree data structure within python. We then can store
+* ***The node class***:
+ * node() contains a a few methods. Mainly getters and setter. ***setLeftChildNode()***, ***setRightChildNode()***, ***hasLeftChildNode()***, ***hasRightChildNode()***. The class also contains ***printNode()*** which prints out the binary tree and all of its branches. 
+* ***Populating the tree:***
+ * **def initTree()** function populates the class with the correct children for morse code. I choose to make a binary tree without having a hard coded decoder so I could alter the tree in the future or use it for other project. This function creates a parent object with the value start and populates the tree using an array of values in breadth first order. Creating this algorithm look some time as you need to remember each of the parent objects. I used a stack to be able to handle that.
+* ***The decoder:***
+ * The decoder takes a morse string for example: `.. --- - .. ... - .... . -... . ... -` and coverts it to the corresponding ascii string: `IOT IS THE BEST`.
+ * **def decode(value)** is the first function involved with decoding. Its purpose is very simple and just acts as an ease of use for our universal binary tree. It takes an input `value` and instantiates the a tree using `initTree()` and then initiates the decoder for the `value`. 
+ * **def words(Values)** is a method of the class `node()` this method sits over the decoder. Its job is to split each of the morse words into an array. 
+ * **def decode(values)** is a method of the class `node()` and takes a **single** morse word. It uses recursion calling its child depending on the value either `.` for left or `-` for right child. when no more strings exist it will return the value of the current node. 
+* ***The encoder:***
+ * The decoder take a string for example: `IOT IS THE BEST` and converts it to the corresponding morse string: `.. --- - .. ... - .... . -... . ... -`.
+ * **def encode(value)** is the first function involved with encoding. Its purpose is very simple and jst acts as an ease of use for the universal binary tree. It takes an input `value` and instantiates the a tree using `initTree()` and then initiates the encoder for the `value`. 
+ * **def encode(value)** is a method of the class `node()` this method sits over the encoder. Its job is is to clean the incoming string and send each letter to the encoder. 
+ * **def encoder(value, string ="")** Is a method of the class `node()` and takes **two** arguments. the first is the value of the letter it is searching for. The second is a default empty string. The method recursively searches through the binary tree depth first and appends its self the the empty string until the recursive function ends and finally returns the string of `-.---.-.-`. 
+* ***Main.py*** is a simple file that imports our class file and runs tests. 
+___
+### Task 3: Unit testing.
+
+* Unit testing is a useful method to test code. Its benefits lies with testing functionality of the program not against requirements of the program. It can test if the inputs and outputs correspond. We have used them in the program to test the encode and decode functions.
+* ***assert_tests.py*** is a basic way of unit testing. It uses the python function `assert`. It checks to see if an value is true and continues if so. However, if the value is not the expected value it will throw an exception, notifying the user. Its a fairly rudimentary way of testing and theres better ways of doing it which we will look at next. 
+* ***moreseunit.py*** unittest is an inbuilt Python library. Its a test runner and is specially design for running tests and debugging. This one contains a few useful tools that we are going to use. It works similarly to the assert function. We've written a few test cases to test things like: Correct, incorrect, invalid inputs for both encode and decode. After running the tests I had a couple unexpected results that I wasn't expecting, lets take a look further into the unexpected output. `IT DOESNT DO SPEXIAL XHARS` isn't the output I was expecting, I was expecting: `IT DOESNT DO SPECIAL CHARS` after debugging the problem I found that the program in its login ignores `""` as the binary tree wasn't full it was loosing index after an `""` however if we insert a character to represent Null like `*` it functions correctly.    
+___
+### Task 4: Expanding capability.
+* As we designed the binary tree to be universal adding to the tree is very easy in theory we just add a few more characters to the array in **initTree()** in breadth first order. However, when we dive into it we quickly see that the array becomes very long. This isn't efficient todo by hand. I have created a programme todo it for us.
+* ***inserter.py** is designed to take an heap string and add values to that heap. It also will add new layers by adding the correct amount of Null characters. This is what the tree looks like in heap form now.. The function to insert is very simple and the next worksheet builds on a similar method so it will be very useful.  When we run our new characters to be inserted  we get .
+* ***morse.py** To simple update the binary tree with new values we just add it to **initTree()** like this. 
+* ***unittesting*** after testing some of the new values we get no unexpected errors. 
-* Task 1
+## Getting Started
-* Task 2
+* To include it in another file:
+```
+import morse
-
-
-## Getting Started
+# to encode
+morse.encode('us')
+
+#to decode
+morse.decode('..- ...')
+```
+* Running the task files
+ * Task 2: `python3 main.py` or `python3 assert_tests.py`
+ * Task 3: `python3 morseunit.py`
+ * Task 4: `inserter.py`
### Dependencies
-*
+* None
### Installing
-* pip install -r requirments.txt
+* Nothing to install
### Executing program
```
-python3 morse.py
+python3 main.py
+# or
+python3 morseunit.py
```
## Authors
@@ -52,6 +107,9 @@ Contributors names and contact info
ex. Jack Holdsworth @ [my website](https://holdsworth.dev)
## Version History
+* 0.4
+ * README
+ * Unittesting
* 0.3
* task 2 done
* started task 3
diff --git a/assert_tests.py b/assert_tests.py
index 5e61e762d4595fd2cd8b4bcce2bc83939862fe89..9c50d2798ce9836a68d953792cdfd8f335a9b0bd 100644
--- a/assert_tests.py
+++ b/assert_tests.py
@@ -1,8 +1,11 @@
import morse
def test_encode_us():
- print(morse.encode('us'))
- assert morse.encode('us') == '..- ... ', "Should be ..- ..."
+ assert morse.encode('us') == '..- ...', "Should be ..- ..."
+
+def test_decode_us():
+ assert morse.decode('..- ...') == 'US', "Should be us"
if __name__ == "__main__":
test_encode_us()
+ test_decode_us()
print('Everything passed')
\ No newline at end of file
diff --git a/binaryHeap.py b/binaryHeap.py
index b9343e5233ecc72f3ebe167b68b9ee4e8c19c1f5..e54fc5923a7fc68c2ba712da4da54376718e09d1 100644
--- a/binaryHeap.py
+++ b/binaryHeap.py
@@ -1,7 +1,7 @@
tree = "-ETIANMSURWDKGOHVF*L*PJBXCYZQ**54*3*¿?2&*+****16=/***(*7***8*90*************_****\"**.********'**-********;!*)***¡*,****:****************$***********************************************************************************************************************"
-def decode(string):
+def decode_bt(string):
output = ""
parent = 1
@@ -24,4 +24,4 @@ def decode(string):
return output
-print(decode(".-. .---- -.. . ... .---- -...- .... .. -...- -.--."))
\ No newline at end of file
+print(decode_bt(".-. .---- -.. . ... .---- -...- .... .. -...- -.--."))
\ No newline at end of file
diff --git a/inserter.py b/inserter.py
index aa05641ea8f0b4fa8660aeeb274c675021f3c4ff..7d8590dc2f8bad36537f2c8190750767dbc3d392 100644
--- a/inserter.py
+++ b/inserter.py
@@ -2,9 +2,11 @@ tree = "-ETIANMSURWDKGOHVF*L*PJBXCYZQ**54*3***2**+****16=/*****7***8*90"
def decode(string):
+ #decoder to check correct position
global tree
output = ""
parent = 1
+ # heap string finder
for i in range(len(string)):
if i < len(string) - 1 :
if string[i] == " ":
@@ -26,15 +28,18 @@ def decode(string):
def add(string,addString):
- global tree
- string = string.replace(" ", "")
- print(pow(2,len(string))*2)
+ # function to add to binary tree (heap) in breadth first order
+ global tree # access the global tree.
+ string = string.replace(" ", "") # remove any spaces
+ print(pow(2,len(string))*2) # debug
print(len(tree))
- if len(tree) <= (pow(2,len(string)*2)):
+ # adds a new layer to the binary tree if required
+ if len(tree) <= (pow(2,len(string)*2)):
for i in range(pow(2,len(string))*2 - len(tree)):
- tree = tree + "*"
+ tree = tree + "*" # * is a Null character in the implementing
output = ""
parent = 1
+ # finds position in heap
for i in range(len(string)):
if i < len(string) - 1 :
if string[i] == ".":
@@ -46,7 +51,7 @@ def add(string,addString):
parent = 2 * parent
if string[i] == "-":
parent = 2 * parent + 1
- output = tree[:parent-1] + addString + tree[parent:]
+ output = tree[:parent-1] + addString + tree[parent:] # add new character in the middle and delete the existing one.
tree = output
print(output)
parent = 1
@@ -56,7 +61,7 @@ def add(string,addString):
print("error, insert fail")
return output
-# print(decode(".-. .---- -.. . ... .---- -...- .... .. -...- -.--."))
+# new characters to add.
print(add(".-.-.-","."))
print(add("-.--.","("))
print(add(".-.-.","+"))
diff --git a/main.py b/main.py
index 9d0aa489bb6a1cd45f223648b7e10b5b92254184..9eea7ab3931b655a486bd914868be549c2f1b240 100644
--- a/main.py
+++ b/main.py
@@ -4,5 +4,6 @@ if __name__ == "__main__":
e = morse.encode('us')
print('%s' % e)
d = morse.decode(e)
- assert morse.encode('us') == '..- ...', "Should be ..-"
- assert morse.decode('..- ...') == 'us', "Should be ..-"
+
+ assert morse.encode('us') == '..- ...', f"Should be: '..- ...', got {morse.decode('..- ...')}"
+ assert morse.decode('..- ...') == 'US', f"Should be: 'us', got {morse.decode('..- ...')} "
diff --git a/morse.py b/morse.py
index 8e138aab664609abcbe058d258e6d55e15af5116..5ea523c5f029bf0c68346c5448214c2aac560472 100644
--- a/morse.py
+++ b/morse.py
@@ -1,129 +1,146 @@
class node:
def __init__(self, value, left=None, right=None):
- self.value = value
- self.leftChildNode = left
- self.rightChildNode = right
+ self.value = value # Contains itself value
+ self.leftChildNode = left # a node object for the left default is None
+ self.rightChildNode = right # a node object to the right default
def setLeftChildNode(self,nodes):
+ # setter for left child
self.leftChildNode = nodes
def setRightChildNode(self,nodes):
+ # setter for right child
self.rightChildNode = nodes
def hasLeftChildNode(self):
+ # getter for left child
if self.leftChildNode != None:
return True
else:
return False
def hasRightChildNode(self):
+ # getter for right child
if self.rightChildNode != None:
return True
else:
return False
def printNode(self, level=1,direction="S"):
+ # prints child nodes with directions
+
+ # sets spaces for node level. E.I. a child with 3 parents will have 3 spaces
for x in range(level):
print(" ", end = '')
- print(direction + " " + str(self.value))
- if self.hasLeftChildNode() == True:
+ print(direction + " - " + str(self.value)) # Either (L)eft child or (R)ight child
+
+ # If has child then call recursion
+ if self.hasLeftChildNode() == True:
self.leftChildNode.printNode((level+1),"L")
if self.hasRightChildNode() == True:
self.rightChildNode.printNode((level+1), "R")
def words(self,values):
- ret = ""
- if values:
- x = values.split(" ")
- decodes = []
- for y in x:
- if y != "":
- decodes.append(self.decode(y))
+ # a method to splits morse words into an array of morse words and decode them.
+
+ if values: # stops recursion when NoneType is returned.
+ x = values.split(" ") # split string into array of words
+ output = []
+ for y in x: # for every word
+ if y != "": # call decode for each morse word if string isn't empty
+ output.append(self.decode(y))
else:
- decodes.append(" ")
-
- # ret = ret.join(decodes)
- # print(f"{values} Decoded: {ret}")
- # return f"{values} Decoded: {ret}"
- return "".join(decodes)
+ output.append(" ") # add a space back in output if empty
+ return "".join(output)
def decode(self,values):
- if values:
- if values[0] == ".":
+ # a method to decode morse suing recursion
+ if values: # if not end of string
+
+ # if . go to left child or is - go to right child and call recursion
+ if values[0] == ".":
return self.leftChildNode.decode(values[1:])
elif values[0] == "-":
return self.rightChildNode.decode(values[1:])
else:
- print("ERROR")
+ print("ERROR") # error checking
else:
- return self.value
+ return self.value # return the value of the object at end of string.
- def encode(self,word, string = ""):
- word = word.upper()
- ret2 = ""
- output = []
- for letter in word:
- ret = self.encoder(letter)
- if ret != "":
- output.append(ret)
+ def encode(self,word):
+ # a method to handle the encoder
+ word = word.upper() # cleans input
+ output = [] # output string
+ for letter in word: # for letters in words
+ if letter == " ": # spaces for words
output.append(" ")
- # ret2 = ret2.join(output)
- # return f"{word} encoded: {ret2}"
- return "".join(output)
+ continue
+ ret = self.encoder(letter) # calls the encoder function
+ if ret != "": # in not empty string for error check
+ output.append(ret) # append letter
+ output.append(" ") # append space
+ return "".join(output[:len(output)-1])
def encoder(self,letter, string = ""):
- if letter == self.value:
- return string
- else:
- if self.leftChildNode != None:
- if self.leftChildNode.encoder(letter,(string + "-")) != "":
- return self.leftChildNode.encoder(letter,(string + "."))
- if self.rightChildNode != None:
- if self.rightChildNode.encoder(letter,(string + ".")) != "":
- return self.rightChildNode.encoder(letter,(string + "-"))
- return ""
+ # a method to search the binary tree
+ if letter == self.value: # check is value has been found
+ return string
+ else: # if not found
+ if self.leftChildNode != None: # if left child exists
+ if self.leftChildNode.encoder(letter,(string + "-")) != "": # recursively check child's branch
+ return self.leftChildNode.encoder(letter,(string + ".")) # append '.' to the string variable if found (this applies to each parent of the child's branch making the -.-.-.-. string)
+ if self.rightChildNode != None: #if right child exists
+ if self.rightChildNode.encoder(letter,(string + ".")) != "": # recursively check child's branch
+ return self.rightChildNode.encoder(letter,(string + "-")) # append '-' to the string variable if found (this applies to each parent of the child's branch making the -.-.-.-. string)
+ return "" # if not found in branch
def initTree():
- # alphabet = ["E","T","I","A","N","M","S","U","R","W","D","K","G","O","H","V","F","","L","","P","","J","B","X","C","Y","Z","Q","",""]
- alphabet = ["E","T","I","A","N","M","S","U","R","W","D","K","G","O","H","V","F","*","L","*","P","J","B","X","C","Y","Z","Q","*","*","5","4","*","3","*","¿","?","2","&","*","+","*","*","*","*","1","6","=","/","*","*","*","(","*","7","*","*","*","8","*","9","0","*","*","*","*","*","*","*","*","*","*","*","*","*","_","*","*","*","*","\"","*","*",".","*","*","*","*","*","*","*","*","'","*","*","-","*","*","*","*","*","*","*","*",";","!","*",")","*","*","*","¡","*",",","*","*","*","*",":","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","$","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*"]
+ # Breadth-first array of strings
+ # alphabet = ["E","T","I","A","N","M","S","U","R","W","D","K","G","O","H","V","F","*","L","*","P","J","B","X","C","Y","Z","Q","*","*"]
+ alphabet = ["E","T","I","A","N","M","S","U","R","W","D","K","G","O","H","V","F","*","L","*","P","J","B","X","C","Y","Z","Q","*","*","5",
+ "4","*","3","*","¿","?","2","&","*","+","*","*","*","*","1","6","=","/","*","*","*","(","*","7","*","*","*","8","*","9","0",
+ "*","*","*","*","*","*","*","*","*","*","*","*","*","_","*","*","*","*","\"","*","*",".","*","*","*","*","*","*","*","*","'",
+ "*","*","-","*","*","*","*","*","*","*","*",";","!","*",")","*","*","*","¡","*",",","*","*","*","*",":","*","*","*","*","*",
+ "*","*","*","*","*","*","*","*","*","*","*","$","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*",
+ "*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*",
+ "*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*",
+ "*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*","*",
+ "*","*","*","*","*","*","*"]
+
+ # the stack
queue = []
+ #starting parent object
start = node("start")
+ # add to stack
queue.append(start)
count = 0
- while count < len(alphabet)-1:
- parent = queue.pop(0)
- childLeft = node(alphabet[count])
- parent.setLeftChildNode(childLeft)
- queue.append(childLeft)
- count += 1
- childRight = node(alphabet[count])
- parent.setRightChildNode(childRight)
- queue.append(childRight)
- count += 1
- # start.printNode()
+ # append add the children in the binary tree.
+ while count < len(alphabet)-1: # for each string in array
+ parent = queue.pop(0) # grab the current parent and pop as not needed again
+ childLeft = node(alphabet[count]) # make class with value from array
+ parent.setLeftChildNode(childLeft) # add to the left child of parent.
+ queue.append(childLeft) # add new child to parent stack
+ count += 1 # count
+ childRight = node(alphabet[count]) # make class with value from array
+ parent.setRightChildNode(childRight) # add to the right child of parent.
+ queue.append(childRight) # add new child to parent stack
+ count += 1 # count
- # print(start.words("..- ..-"))
-
- # print(start.encode("us"))
- return start
+ return start # return parent node
def encode(value):
+ # the encoder
tree = initTree()
return tree.encode(value)
def decode(value):
+ # the decoder
tree = initTree()
return tree.words(value)
-
-
-
-
-
-
diff --git a/morseunit.py b/morseunit.py
index bd4c3d07af5a3ca07eeda45773fcb7ab3e090c1d..a02124bb01c1a4d2df5f8c5b84409e3e8c220b84 100644
--- a/morseunit.py
+++ b/morseunit.py
@@ -1,8 +1,51 @@
import unittest
import morse
class TestMorse(unittest.TestCase):
+ # encode tests
def test_encode_us(self):
- self.assertEqual( morse.encode('us'), '..- ... ')
+ self.assertEqual( morse.encode('us'), '..- ...')
+ def test_encode_hello_again(self):
+ self.assertEqual( morse.encode('hello again'), '.... . .-.. .-.. --- .- --. .- .. -.')
+ def test_encode_IOt_IS_ThE_bESt(self):
+ self.assertEqual( morse.encode('IOt IS ThE bESt'), '.. --- - .. ... - .... . -... . ... -')
+ def test_encode_CAPITALS(self):
+ self.assertEqual( morse.encode('CAPITALS'), '-.-. .- .--. .. - .- .-.. ...')
+ def test_encode_incorrect(self):
+ self.assertEqual( morse.encode('correct'), '.. -. -.-. --- .-. .-. . -.-. -')
+ def test_encode_numbers(self):
+ self.assertEqual( morse.encode('123'), '.. - -.. --- . ... -. - -.. --- -. ..- -- -... . .-. ...')
+ def test_encode_special_chars(self):
+ self.assertEqual( morse.encode('@&%'), '.. - -.. --- . ... -. - -.. --- ... .--. . -.-. .. .- .-.. -.-. .... .- .-. ...')
+
+ # decode tests
+ def test_decode_us(self):
+ self.assertEqual( morse.decode('..- ...'), 'US')
+ def test_decode_hello_again(self):
+ self.assertEqual( morse.decode('.... . .-.. .-.. --- .- --. .- .. -.'), 'HELLO AGAIN')
+ def test_decode_IOt_IS_ThE_bESt(self):
+ self.assertEqual( morse.decode('.. --- - .. ... - .... . -... . ... -'), 'IOT IS THE BEST')
+ def test_decode_CAPITALS(self):
+ self.assertEqual( morse.decode('-.-. .- .--. .. - .- .-.. ...'), 'CAPITALS')
+ def test_decode_incorrect(self):
+ self.assertEqual( morse.decode('.. -. -.-. --- .-. .-. . -.-. -'), 'CORRECT')
+ def test_decode_numbers(self):
+ self.assertEqual( morse.decode('.. - -.. --- . ... -. - -.. --- -. ..- -- -... . .-. ...'), '123')
+ def test_decode_special_chars(self):
+ self.assertEqual( morse.decode('.. - -.. --- . ... -. - -.. --- ... .--. . -.-. .. .- .-.. -.-. .... .- .-. ...'), '@&%')
+
+ # task 4: addition tests.
+ def test_encode_question_mark(self):
+ self.assertEqual( morse.encode('?'), '..--.')
+ def test_encode_dollar(self):
+ self.assertEqual( morse.encode('$'), '...-..-')
+ def test_encode_colon(self):
+ self.assertEqual( morse.encode(':'), '---...')
+ def test_decode_question_mark(self):
+ self.assertEqual( morse.decode('..--.'), '?')
+ def test_decode_dollar(self):
+ self.assertEqual( morse.decode('...-..-'), '$')
+ def test_decode_colon(self):
+ self.assertEqual( morse.decode('---...'), ':')
if __name__ == '__main__':
unittest.main()
\ No newline at end of file
diff --git a/src/screenshot1.PNG b/src/screenshot1.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..87e4cb2768ef8d504f498f787537d3250adf1f89
Binary files /dev/null and b/src/screenshot1.PNG differ
diff --git a/src/screenshot10.PNG b/src/screenshot10.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..9271e4cf07d6a2933d6bfca65b3774482976d7e9
Binary files /dev/null and b/src/screenshot10.PNG differ
diff --git a/src/screenshot11.PNG b/src/screenshot11.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..bbd87842eed659b2e001e8f7e2ee92996e30bb8b
Binary files /dev/null and b/src/screenshot11.PNG differ
diff --git a/src/screenshot12.PNG b/src/screenshot12.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..c916174dfdecf3928ac710b173ffe335a3ff6da8
Binary files /dev/null and b/src/screenshot12.PNG differ
diff --git a/src/screenshot13.PNG b/src/screenshot13.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..8fca51b055b157466f09ef48dea3b94379c4d21f
Binary files /dev/null and b/src/screenshot13.PNG differ
diff --git a/src/screenshot14.PNG b/src/screenshot14.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..bd476330acd5ad5d10d11c1a79551d6385c9b569
Binary files /dev/null and b/src/screenshot14.PNG differ
diff --git a/src/screenshot15.PNG b/src/screenshot15.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..a1d316d345a45f71e39a17a42575d19d002987a6
Binary files /dev/null and b/src/screenshot15.PNG differ
diff --git a/src/screenshot16.PNG b/src/screenshot16.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..2e2142cc6ef3916a6903a4a882fe43e3e8c18f97
Binary files /dev/null and b/src/screenshot16.PNG differ
diff --git a/src/screenshot17.PNG b/src/screenshot17.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..9f828201dff730c90b12bf79ecd6773bce41e0ef
Binary files /dev/null and b/src/screenshot17.PNG differ
diff --git a/src/screenshot18.PNG b/src/screenshot18.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..ef6f00fd0e9d52e837a89d20c275d29ee3a450df
Binary files /dev/null and b/src/screenshot18.PNG differ
diff --git a/src/screenshot19.PNG b/src/screenshot19.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..f20179b3dc28842e7d10dd1d8d52aee252ed7a52
Binary files /dev/null and b/src/screenshot19.PNG differ
diff --git a/src/screenshot2.PNG b/src/screenshot2.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..d787258745dfc47a1f96e7f87f91f83837011123
Binary files /dev/null and b/src/screenshot2.PNG differ
diff --git a/src/screenshot20.PNG b/src/screenshot20.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..a22067447aed1fefa804340473d9d00f8cd8bc94
Binary files /dev/null and b/src/screenshot20.PNG differ
diff --git a/src/screenshot21.PNG b/src/screenshot21.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..61ca10406c34511de538e70dd2262a6e3e5a06f9
Binary files /dev/null and b/src/screenshot21.PNG differ
diff --git a/src/screenshot22.PNG b/src/screenshot22.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..7d912a58f7f2b04567312d5b883434837b37c37a
Binary files /dev/null and b/src/screenshot22.PNG differ
diff --git a/src/screenshot23.PNG b/src/screenshot23.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..80fa0f6bada66442b9859ac2d7a146c21e51d6eb
Binary files /dev/null and b/src/screenshot23.PNG differ
diff --git a/src/screenshot24.PNG b/src/screenshot24.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..7c6383592fa9213785682dc136d42f8903e82758
Binary files /dev/null and b/src/screenshot24.PNG differ
diff --git a/src/screenshot25.PNG b/src/screenshot25.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..70ef5a3e90fcbb6d377d42ce9f6b2e75ab7291be
Binary files /dev/null and b/src/screenshot25.PNG differ
diff --git a/src/screenshot26.PNG b/src/screenshot26.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..87f6c3926b1f2dff3b8d75399ef889857783caf8
Binary files /dev/null and b/src/screenshot26.PNG differ
diff --git a/src/screenshot27.PNG b/src/screenshot27.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..24e2facd26af97939a35000901ae31072fcbd953
Binary files /dev/null and b/src/screenshot27.PNG differ
diff --git a/src/screenshot3.PNG b/src/screenshot3.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..421e738f007b02d880055dff504e449de8e30dd3
Binary files /dev/null and b/src/screenshot3.PNG differ
diff --git a/src/screenshot4.PNG b/src/screenshot4.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..ad1e16fa380f5681ec727f560af5ffa3292faaa1
Binary files /dev/null and b/src/screenshot4.PNG differ
diff --git a/src/screenshot5.PNG b/src/screenshot5.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..fbd4f8c6c5197ac9be6c14ef64a159ab74c0e403
Binary files /dev/null and b/src/screenshot5.PNG differ
diff --git a/src/screenshot6.PNG b/src/screenshot6.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..fd82be037cb02fed97d7f5107e1efed0aa7472dd
Binary files /dev/null and b/src/screenshot6.PNG differ
diff --git a/src/screenshot7.PNG b/src/screenshot7.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..b5330880457e1bd91d38730b5e74fdef03debe99
Binary files /dev/null and b/src/screenshot7.PNG differ
diff --git a/src/screenshot8.PNG b/src/screenshot8.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..a6f25c9eecfe39c37970651960a47fc183e95203
Binary files /dev/null and b/src/screenshot8.PNG differ
diff --git a/src/screenshot9.PNG b/src/screenshot9.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..4e7981136dc1c98690ed30287355f09aaf27e9f6
Binary files /dev/null and b/src/screenshot9.PNG differ
diff --git a/src/uwe.png b/src/uwe.png
new file mode 100644
index 0000000000000000000000000000000000000000..e3c5878ecfa07bf72ea7239a678182a37bcb669e
Binary files /dev/null and b/src/uwe.png differ