Upload 5 files

Upload app.py file, and the logic to make inference

app.py

@@ -0,0 +1,33 @@
+import streamlit as st
+from prediction import smartcities
+
+# Streamlit Interface
+st.header("Smart City Cars and Bikes detection")
+st.markdown("Upload a video or select the example")
+
+## Select video to inference
+file_video = st.file_upload(" Upload a video ", type=["mp4"])
+example = open("test_video.mp4")
+st.video(example, width=250)
+if st.button("example"):
+    file_video = "test_video.mp4"
+
+## 
+if file_video is not None:
+    video = open(file_video)
+    video_bytes = video.read()
+    output = smartcities(video_bytes)
+    col1, col2 = st.columns(2)
+    
+    if output is not None:
+        with col1:
+            st.subheader("Input: ")
+            st.video(video_bytes)
+        with col2:
+            st.subheader("Output: ")
+            st.video(output)
+
+
+        
+
+

centroidtracker.py

@@ -0,0 +1,163 @@
+# import the necessary packages
+from scipy.spatial import distance as dist
+from collections import OrderedDict
+import numpy as np
+
+class CentroidTracker:
+	def __init__(self, maxDisappeared=50, maxDistance=50):
+		# initialize the next unique object ID along with two ordered
+		# dictionaries used to keep track of mapping a given object
+		# ID to its centroid and number of consecutive frames it has
+		# been marked as "disappeared", respectively
+		self.nextObjectID = 0
+		self.objects = OrderedDict()
+		self.disappeared = OrderedDict()
+
+		# store the number of maximum consecutive frames a given
+		# object is allowed to be marked as "disappeared" until we
+		# need to deregister the object from tracking
+		self.maxDisappeared = maxDisappeared
+
+		# store the maximum distance between centroids to associate
+		# an object -- if the distance is larger than this maximum
+		# distance we'll start to mark the object as "disappeared"
+		self.maxDistance = maxDistance
+
+	def register(self, centroid):
+		# when registering an object we use the next available object
+		# ID to store the centroid
+		self.objects[self.nextObjectID] = centroid
+		self.disappeared[self.nextObjectID] = 0
+		self.nextObjectID += 1
+
+	def deregister(self, objectID):
+		# to deregister an object ID we delete the object ID from
+		# both of our respective dictionaries
+		del self.objects[objectID]
+		del self.disappeared[objectID]
+
+	def update(self, rects):
+		# check to see if the list of input bounding box rectangles
+		# is empty
+		if len(rects) == 0:
+			# loop over any existing tracked objects and mark them
+			# as disappeared
+			for objectID in list(self.disappeared.keys()):
+				self.disappeared[objectID] += 1
+
+				# if we have reached a maximum number of consecutive
+				# frames where a given object has been marked as
+				# missing, deregister it
+				if self.disappeared[objectID] > self.maxDisappeared:
+					self.deregister(objectID)
+
+			# return early as there are no centroids or tracking info
+			# to update
+			return self.objects
+
+		# initialize an array of input centroids for the current frame
+		inputCentroids = np.zeros((len(rects), 2), dtype="int")
+
+		# loop over the bounding box rectangles
+		for (i, (startX, startY, endX, endY)) in enumerate(rects):
+			# use the bounding box coordinates to derive the centroid
+			cX = int((startX + endX) / 2.0)
+			cY = int((startY + endY) / 2.0)
+			inputCentroids[i] = (cX, cY)
+
+		# if we are currently not tracking any objects take the input
+		# centroids and register each of them
+		if len(self.objects) == 0:
+			for i in range(0, len(inputCentroids)):
+				self.register(inputCentroids[i])
+
+		# otherwise, are are currently tracking objects so we need to
+		# try to match the input centroids to existing object
+		# centroids
+		else:
+			# grab the set of object IDs and corresponding centroids
+			objectIDs = list(self.objects.keys())
+			objectCentroids = list(self.objects.values())
+
+			# compute the distance between each pair of object
+			# centroids and input centroids, respectively -- our
+			# goal will be to match an input centroid to an existing
+			# object centroid
+			D = dist.cdist(np.array(objectCentroids), inputCentroids)
+
+			# in order to perform this matching we must (1) find the
+			# smallest value in each row and then (2) sort the row
+			# indexes based on their minimum values so that the row
+			# with the smallest value as at the *front* of the index
+			# list
+			rows = D.min(axis=1).argsort()
+
+			# next, we perform a similar process on the columns by
+			# finding the smallest value in each column and then
+			# sorting using the previously computed row index list
+			cols = D.argmin(axis=1)[rows]
+
+			# in order to determine if we need to update, register,
+			# or deregister an object we need to keep track of which
+			# of the rows and column indexes we have already examined
+			usedRows = set()
+			usedCols = set()
+
+			# loop over the combination of the (row, column) index
+			# tuples
+			for (row, col) in zip(rows, cols):
+				# if we have already examined either the row or
+				# column value before, ignore it
+				if row in usedRows or col in usedCols:
+					continue
+
+				# if the distance between centroids is greater than
+				# the maximum distance, do not associate the two
+				# centroids to the same object
+				if D[row, col] > self.maxDistance:
+					continue
+
+				# otherwise, grab the object ID for the current row,
+				# set its new centroid, and reset the disappeared
+				# counter
+				objectID = objectIDs[row]
+				self.objects[objectID] = inputCentroids[col]
+				self.disappeared[objectID] = 0
+
+				# indicate that we have examined each of the row and
+				# column indexes, respectively
+				usedRows.add(row)
+				usedCols.add(col)
+
+			# compute both the row and column index we have NOT yet
+			# examined
+			unusedRows = set(range(0, D.shape[0])).difference(usedRows)
+			unusedCols = set(range(0, D.shape[1])).difference(usedCols)
+
+			# in the event that the number of object centroids is
+			# equal or greater than the number of input centroids
+			# we need to check and see if some of these objects have
+			# potentially disappeared
+			if D.shape[0] >= D.shape[1]:
+				# loop over the unused row indexes
+				for row in unusedRows:
+					# grab the object ID for the corresponding row
+					# index and increment the disappeared counter
+					objectID = objectIDs[row]
+					self.disappeared[objectID] += 1
+
+					# check to see if the number of consecutive
+					# frames the object has been marked "disappeared"
+					# for warrants deregistering the object
+					if self.disappeared[objectID] > self.maxDisappeared:
+						self.deregister(objectID)
+
+			# otherwise, if the number of input centroids is greater
+			# than the number of existing object centroids we need to
+			# register each new input centroid as a trackable object
+			else:
+				for col in unusedCols:
+					self.register(inputCentroids[col])
+
+		# return the set of trackable objects
+		return self.objects

prediction.py

@@ -0,0 +1,203 @@
+
+import tensorflow as tf
+import numpy as np
+import imutils
+import time
+import dlib
+import cv2
+from PIL import Image
+import matplotlib.pyplot as plt
+from imutils.video import VideoStream
+from imutils.video import FPS
+from centroidtracker import CentroidTracker
+from trackableobject import TrackableObject
+# import base64
+
+
+class smartcities:
+    def __init__(self):
+        detect_fn = tf.saved_model.load("model/saved_model")
+        self.detect_fn = detect_fn
+
+    def predict(self):
+        # Ruta del video (Se debe cargar de manera manual)
+        PATH_VIDEO = "/tmp/in_video.mp4"
+        video_result = open(PATH_VIDEO, "wb")
+        # video_result.write(base64.b64decode(image_64_decode))
+
+        # Ruta del video en donde almacenaremos los resultados
+        PATH_OUTPUT = "/tmp/video_out.mp4"
+
+        # Cuántos frames vamos a saltarnos (Durante estos frames nuestro algoritmo de seguimiento funciona)
+        SKIP_FPS = 30
+
+        # Cuál será el umbral mínimo par que se considere una detección
+        TRESHOLD = 0.5
+
+        # Cargamos el video
+        vs = cv2.VideoCapture(PATH_VIDEO)
+
+        # Inicializamos el writer para poder guardar el video
+        writer = None
+
+        # Definimos ancho y alto
+        W = int(vs.get(cv2.CAP_PROP_FRAME_WIDTH))
+        H = int(vs.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+        # Inicializamos la clase centroid tracker con dos variable fundamentales
+        # maxDissapared (Si pasa ese tiempo y no se detecta más el centroide lo elimina)
+        # Si la distancia es mayor a maxDistance no lo podra asociar como si fuera el mismo objecto.
+        ct = CentroidTracker(maxDisappeared= 40, maxDistance = 50)
+
+        # Inicializamos variables principales
+        trackers = []
+        trackableObjects = {}
+
+        totalFrame = 0
+        totalDown = 0
+        totalUp = 0
+
+        DIRECTION_PEOPLE = True
+
+        # Creamos un umbral para sabre si el carro paso de izquierda a derecha o viceversa
+        # En este caso lo deje fijo pero se pudiese configurar según la ubicación de la cámara.
+        POINT = [0, int((H/2)-H*0.1), W, int(H*0.1)]
+
+        # Los FPS nos van a permitir ver el rendimiento de nuestro modelo y si funciona en tiempo real.
+        fps = FPS().start()
+
+        # Definimos el formato del archivo resultante y las rutas.
+        fourcc = cv2.VideoWriter_fourcc(*'MP4V')
+        writer = cv2.VideoWriter(PATH_OUTPUT, fourcc, 20.0, (W, H), True)
+
+        # Bucle que recorre todo el video
+        while True:
+            # Leemos el primer frame
+            ret, frame = vs.read()
+
+            # Si ya no hay más frame, significa que el video termino y por tanto se sale del bucle
+            if frame is None:
+                break
+
+            status = "Waiting"
+            rects = []
+
+            # Nos saltamos los frames especificados.
+            if totalFrame % SKIP_FPS == 0:
+                status = "Detecting"
+                trackers = []
+                # Tomamos la imagen la convertimos a array luego a tensor
+                image_np = np.array(frame)
+
+                input_tensor = tf.convert_to_tensor(image_np)
+                input_tensor = input_tensor[tf.newaxis, ...]
+
+                # Predecimos los objectos y clases de la imagen
+                detections = self.detect_fn(input_tensor)
+
+                detection_scores = np.array(detections["detection_scores"][0])
+                # Realizamos una limpieza para solo obtener las clasificaciones mayores al umbral.
+                detection_clean = [x for x in detection_scores if x >= TRESHOLD]
+
+                # Recorremos las detecciones
+                for x in range(len(detection_clean)):
+                    idx = int(detections['detection_classes'][0][x])
+                    # Tomamos los bounding box 
+                    ymin, xmin, ymax, xmax = np.array(detections['detection_boxes'][0][x])
+                    box = [xmin, ymin, xmax, ymax] * np.array([W,H, W, H])
+
+                    (startX, startY, endX, endY) = box.astype("int")
+
+                    # Con la función de dlib empezamos a hacer seguimiento de los boudiung box obtenidos
+                    tracker = dlib.correlation_tracker()
+                    rect = dlib.rectangle(startX, startY, endX, endY)
+                    tracker.start_track(frame, rect)
+
+                    trackers.append(tracker)
+            else:
+                # En caso de que no hagamos detección haremos seguimiento
+                # Recorremos los objetos que se les está realizando seguimiento
+                for tracker in trackers:
+                    status = "Tracking"
+                    # Actualizamos y buscamos los nuevos bounding box
+                    tracker.update(frame)
+                    pos = tracker.get_position()
+
+                    startX = int(pos.left())
+                    startY = int(pos.top())
+                    endX = int(pos.right())
+                    endY = int(pos.bottom())
+
+                    rects.append((startX, startY, endX, endY))
+
+            # Dibujamos el umbral de conteo
+            cv2.rectangle(frame, (POINT[0], POINT[1]), (POINT[0]+ POINT[2], POINT[1] + POINT[3]), (255, 0, 255), 2)
+
+            objects = ct.update(rects)
+
+            # Recorremos cada una de las detecciones
+            for (objectID, centroid) in objects.items():
+                # Revisamos si el objeto ya se ha contado
+                to = trackableObjects.get(objectID, None)
+                if to is None:
+                    to = TrackableObject(objectID, centroid)
+
+                else:
+                # Si no se ha contado, analizamos la dirección del objeto
+                    y = [c[1] for c in to.centroids]
+                    direction = centroid[1] - np.mean(y)
+                    to.centroids.append(centroid)
+                    if not to.counted:
+                        if centroid[0] > POINT[0] and centroid[0] < (POINT[0]+ POINT[2]) and centroid[1] > POINT[1] and centroid[1] < (POINT[1]+POINT[3]):
+                            if DIRECTION_PEOPLE:
+                                if direction >0:
+                                    totalUp += 1
+                                    to.counted = True
+                                else:
+                                    totalDown +=1
+                                    to.counted = True
+                            else:
+                                if direction <0:
+                                    totalUp += 1
+                                    to.counted = True
+                                else:
+                                    totalDown +=1
+                                    to.counted = True
+
+                trackableObjects[objectID] = to
+
+                # Dibujamos el centroide y el ID de la detección encontrada
+                text = "ID {}".format(objectID)
+                cv2.putText(frame, text, (centroid[0]-10, centroid[1]-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 2)
+                cv2.circle(frame, (centroid[0], centroid[1]), 4, (0,255,0), -1)
+
+            # Totalizamos los resultados finales
+            info = [
+                    ("Subiendo", totalUp),
+                    ("Bajando", totalDown),
+                    ("Estado", status),
+            ]
+
+            for (i, (k,v)) in enumerate(info):
+                text = "{}: {}".format(k,v)
+                cv2.putText(frame, text, (10, H - ((i*20) + 20)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,0,255), 2)
+
+            # Almacenamos el framme en nuestro video resultante.
+            writer.write(frame)
+            totalFrame += 1
+            fps.update()
+
+        # Terminamos de analizar FPS y mostramos resultados finales
+        fps.stop()
+
+        print("Tiempo completo {}".format(fps.elapsed()))
+        print("Tiempo aproximado por frame {}".format(fps.fps()))
+
+        # Cerramos el stream the almacenar video y de consumir el video.
+        writer.release()
+        vs.release()
+
+        video = open(PATH_OUTPUT, "rb")
+        video_read = video.read()
+
+        return video_read

requirements.txt

@@ -0,0 +1,13 @@
+tf_slim
+tf-models-official
+lvis
+Cython 
+contextlib2 
+pillow 
+lxml 
+matplotlib
+pycocotools
+imutils
+numpy
+dlib
+opencv-contrib-python

trackableobject.py

@@ -0,0 +1,11 @@
+
+class TrackableObject:
+	def __init__(self, objectID, centroid):
+		# store the object ID, then initialize a list of centroids
+		# using the current centroid
+		self.objectID = objectID
+		self.centroids = [centroid]
+
+		# initialize a boolean used to indicate if the object has
+		# already been counted or not
+		self.counted = False