556 lines
25 KiB
Python
556 lines
25 KiB
Python
from quart import Quart, render_template, Response, request,jsonify,send_from_directory
|
|
import cv2
|
|
import numpy as np
|
|
import aiomysql
|
|
from dotenv import load_dotenv
|
|
import os
|
|
import pandas as pd
|
|
import asyncio
|
|
import time
|
|
|
|
app = Quart(__name__, static_folder='assets')
|
|
|
|
video_list = []
|
|
|
|
cap = None
|
|
|
|
videonya = None
|
|
jumlah_kenderaan = 0
|
|
kenderaan_kiri = 0
|
|
kenderaan_kanan = 0
|
|
kenderaan_sekarang = 0
|
|
selesainya= False
|
|
total_kenderaan_sekarang = 0
|
|
|
|
MYSQL_HOST = os.getenv('MYSQL_HOST')
|
|
MYSQL_USER = os.getenv('MYSQL_USER')
|
|
MYSQL_PASSWORD = os.getenv('MYSQL_PASSWORD')
|
|
MYSQL_DB = os.getenv('MYSQL_DB')
|
|
|
|
async def get_db_connection():
|
|
return await aiomysql.connect(
|
|
host=MYSQL_HOST,
|
|
user=MYSQL_USER,
|
|
password=MYSQL_PASSWORD,
|
|
db=MYSQL_DB,
|
|
loop=asyncio.get_running_loop()
|
|
)
|
|
|
|
|
|
|
|
def hitung_kepadatan_kendaraan(jumlah_kendaraan, panjang_jalan):
|
|
|
|
if panjang_jalan <= 0:
|
|
raise ValueError("Panjang jalan harus lebih besar dari nol.")
|
|
kepadatan = jumlah_kendaraan / panjang_jalan
|
|
return kepadatan
|
|
|
|
async def insert_data(nama, waktu,waktu_sekarang ,kenderaan_kiri, kenderaan_kanan,status):
|
|
global total_kenderaan_sekarang
|
|
# get the datetime
|
|
now = time.strftime("%Y-%m-%d %H:%M:%S")
|
|
|
|
conn = await get_db_connection()
|
|
async with conn.cursor() as cursor:
|
|
# check if data already exists
|
|
sql = "SELECT * FROM tb_data WHERE nama = %s"
|
|
await cursor.execute(sql, (nama,))
|
|
result = await cursor.fetchone()
|
|
if result:
|
|
# print(waktu_sekarang)
|
|
# update existing data
|
|
# rount the waktu_sekarang
|
|
# rounded_waktu_sekarang = round(float(waktu_sekarang))
|
|
# if (rounded_waktu_sekarang == 0):
|
|
# rounded_waktu_sekarang = 1
|
|
# jumlah_kenderaan = int(kenderaan_kiri) + int(kenderaan_kanan)
|
|
# jumlah_kenderaan_per_menit = jumlah_kenderaan / rounded_waktu_sekarang * 60
|
|
# kepadatan = ""
|
|
# if(jumlah_kenderaan_per_menit < 20):
|
|
# kepadatan = "Kepadatan Sepi"
|
|
# elif(jumlah_kenderaan_per_menit < 40 and jumlah_kenderaan_per_menit >= 20):
|
|
# kepadatan = "Kepadatan Sedang"
|
|
# elif(jumlah_kenderaan_per_menit >= 40):
|
|
# kepadatan = "Kepadatan Tinggi"
|
|
|
|
# kepadatan= "Kepadatan Sepi"
|
|
|
|
if total_kenderaan_sekarang <= 2:
|
|
kepadatan = "Kepadatan Sepi"
|
|
elif total_kenderaan_sekarang > 2 and total_kenderaan_sekarang <= 4:
|
|
kepadatan = "Kepadatan Sedang"
|
|
else:
|
|
kepadatan = "Kepadatan Tinggi"
|
|
|
|
|
|
sql = "UPDATE tb_data SET waktu = %s, waktu_sekarang = %s, kenderaan_kiri = %s, kenderaan_kanan = %s , updated_at = %s , status = %s , kepadatan = %s WHERE nama = %s"
|
|
await cursor.execute(sql, (waktu, waktu_sekarang, kenderaan_kiri, kenderaan_kanan, now, status, kepadatan, nama))
|
|
else:
|
|
# insert new data
|
|
sql = "INSERT INTO tb_data (nama, waktu, waktu_sekarang, kenderaan_kiri, kenderaan_kanan) VALUES (%s, %s, %s, %s, %s)"
|
|
await cursor.execute(sql, (nama, waktu, waktu_sekarang, kenderaan_kiri, kenderaan_kanan))
|
|
await conn.commit()
|
|
conn.close()
|
|
|
|
|
|
|
|
|
|
async def generate_frames2(video, threshold,stat):
|
|
global jumlah_kenderaan
|
|
global kenderaan_kiri
|
|
global kenderaan_kanan
|
|
global cap,selesainya, kenderaan_sekarang , total_kenderaan_sekarang
|
|
|
|
jumlah_kenderaan = 0
|
|
kenderaan_kiri = 0
|
|
kenderaan_kanan = 0
|
|
|
|
cap = cv2.VideoCapture(video)
|
|
frames_count, fps, width, height = cap.get(cv2.CAP_PROP_FRAME_COUNT), cap.get(cv2.CAP_PROP_FPS), cap.get(
|
|
cv2.CAP_PROP_FRAME_WIDTH), cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
|
|
width = int(width)
|
|
height = int(height)
|
|
print(frames_count, fps, width, height)
|
|
|
|
# creates a pandas data frame with the number of rows the same length as frame count
|
|
df = pd.DataFrame(index=range(int(frames_count)))
|
|
df.index.name = "Frames"
|
|
|
|
framenumber = 0 # keeps track of current frame
|
|
carscrossedup = 0 # keeps track of cars that crossed up
|
|
carscrosseddown = 0 # keeps track of cars that crossed down
|
|
carids = [] # blank list to add car ids
|
|
caridscrossed = [] # blank list to add car ids that have crossed
|
|
totalcars = 0 # keeps track of total cars
|
|
|
|
fgbg = cv2.createBackgroundSubtractorMOG2() # create background subtractor
|
|
|
|
# information to start saving a video file
|
|
ret, frame = cap.read() # import image
|
|
ratio = .5 # resize ratio
|
|
image = cv2.resize(frame, (0, 0), None, ratio, ratio) # resize image
|
|
width2, height2, channels = image.shape
|
|
# video = cv2.VideoWriter('traffic_counter.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), fps, (height2, width2), 1)
|
|
|
|
while True:
|
|
|
|
ret, frame = cap.read() # import image
|
|
|
|
if ret: # if there is a frame continue with code
|
|
|
|
image = cv2.resize(frame, (0, 0), None, ratio, ratio) # resize image
|
|
|
|
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # converts image to gray
|
|
|
|
fgmask = fgbg.apply(gray) # uses the background subtraction
|
|
|
|
# applies different thresholds to fgmask to try and isolate cars
|
|
# just have to keep playing around with settings until cars are easily identifiable
|
|
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) # kernel to apply to the morphology
|
|
closing = cv2.morphologyEx(fgmask, cv2.MORPH_CLOSE, kernel)
|
|
opening = cv2.morphologyEx(closing, cv2.MORPH_OPEN, kernel)
|
|
dilation = cv2.dilate(opening, kernel)
|
|
retvalbin, bins = cv2.threshold(dilation, 220, 255, cv2.THRESH_BINARY) # removes the shadows
|
|
|
|
# creates contours
|
|
contours, hierarchy = cv2.findContours(bins, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[-2:]
|
|
|
|
# use convex hull to create polygon around contours
|
|
hull = [cv2.convexHull(c) for c in contours]
|
|
|
|
# draw contours
|
|
# cv2.drawContours(image, hull, -1, (0, 255, 0), 3)
|
|
|
|
# line created to stop counting contours, needed as cars in distance become one big contour
|
|
lineypos = 90
|
|
# cv2.line(image, (0, lineypos), (width, lineypos), (255, 0, 0), 5)
|
|
|
|
# line y position created to count contours
|
|
lineypos2 = 150
|
|
cv2.line(image, (0, lineypos2), (width, lineypos2), (0, 255, 0), 5)
|
|
|
|
cv2.line(image, (0, 225), (width, 225), (255, 255, 255), 2)
|
|
cv2.line(image, (0, lineypos), (width, lineypos), (255, 255, 255), 2)
|
|
|
|
# min area for contours in case a bunch of small noise contours are created
|
|
minarea = 200
|
|
|
|
# max area for contours, can be quite large for buses
|
|
maxarea = 50000
|
|
|
|
# vectors for the x and y locations of contour centroids in current frame
|
|
cxx = np.zeros(len(contours))
|
|
cyy = np.zeros(len(contours))
|
|
|
|
|
|
for i in range(len(contours)): # cycles through all contours in current frame
|
|
|
|
if hierarchy[0, i, 3] == -1: # using hierarchy to only count parent contours (contours not within others)
|
|
|
|
area = cv2.contourArea(contours[i]) # area of contour
|
|
|
|
if minarea < area < maxarea: # area threshold for contour
|
|
|
|
# calculating centroids of contours
|
|
cnt = contours[i]
|
|
M = cv2.moments(cnt)
|
|
cx = int(M['m10'] / M['m00'])
|
|
cy = int(M['m01'] / M['m00'])
|
|
|
|
if cy > lineypos: # filters out contours that are above line (y starts at top)
|
|
|
|
# gets bounding points of contour to create rectangle
|
|
# x,y is top left corner and w,h is width and height
|
|
x, y, w, h = cv2.boundingRect(cnt)
|
|
|
|
# creates a rectangle around contour
|
|
cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 2)
|
|
|
|
# Prints centroid text in order to double check later on
|
|
cv2.putText(image, str(cx) + "," + str(cy), (cx + 10, cy + 10), cv2.FONT_HERSHEY_SIMPLEX,
|
|
.3, (0, 0, 255), 1)
|
|
|
|
cv2.drawMarker(image, (cx, cy), (0, 0, 255), cv2.MARKER_STAR, markerSize=5, thickness=1,
|
|
line_type=cv2.LINE_AA)
|
|
|
|
# adds centroids that passed previous criteria to centroid list
|
|
cxx[i] = cx
|
|
cyy[i] = cy
|
|
|
|
# eliminates zero entries (centroids that were not added)
|
|
cxx = cxx[cxx != 0]
|
|
cyy = cyy[cyy != 0]
|
|
|
|
# empty list to later check which centroid indices were added to dataframe
|
|
minx_index2 = []
|
|
miny_index2 = []
|
|
|
|
# maximum allowable radius for current frame centroid to be considered the same centroid from previous frame
|
|
maxrad = 25
|
|
|
|
# The section below keeps track of the centroids and assigns them to old carids or new carids
|
|
|
|
# print("total centroids: " + str(len(cxx)))
|
|
total_kenderaan_sekarang = len(cxx)
|
|
|
|
|
|
|
|
if len(cxx): # if there are centroids in the specified area
|
|
|
|
if not carids: # if carids is empty
|
|
|
|
for i in range(len(cxx)): # loops through all centroids
|
|
|
|
carids.append(i) # adds a car id to the empty list carids
|
|
df[str(carids[i])] = "" # adds a column to the dataframe corresponding to a carid
|
|
|
|
# assigns the centroid values to the current frame (row) and carid (column)
|
|
df.at[int(framenumber), str(carids[i])] = [cxx[i], cyy[i]]
|
|
|
|
totalcars = carids[i] + 1 # adds one count to total cars
|
|
|
|
else: # if there are already car ids
|
|
|
|
dx = np.zeros((len(cxx), len(carids))) # new arrays to calculate deltas
|
|
dy = np.zeros((len(cyy), len(carids))) # new arrays to calculate deltas
|
|
|
|
|
|
for i in range(len(cxx)): # loops through all centroids
|
|
|
|
for j in range(len(carids)): # loops through all recorded car ids
|
|
|
|
# acquires centroid from previous frame for specific carid
|
|
oldcxcy = df.iloc[int(framenumber - 1)][str(carids[j])]
|
|
|
|
# acquires current frame centroid that doesn't necessarily line up with previous frame centroid
|
|
curcxcy = np.array([cxx[i], cyy[i]])
|
|
|
|
if not oldcxcy: # checks if old centroid is empty in case car leaves screen and new car shows
|
|
|
|
continue # continue to next carid
|
|
|
|
else: # calculate centroid deltas to compare to current frame position later
|
|
|
|
dx[i, j] = oldcxcy[0] - curcxcy[0]
|
|
dy[i, j] = oldcxcy[1] - curcxcy[1]
|
|
|
|
for j in range(len(carids)): # loops through all current car ids
|
|
|
|
sumsum = np.abs(dx[:, j]) + np.abs(dy[:, j]) # sums the deltas wrt to car ids
|
|
|
|
# finds which index carid had the min difference and this is true index
|
|
correctindextrue = np.argmin(np.abs(sumsum))
|
|
minx_index = correctindextrue
|
|
miny_index = correctindextrue
|
|
|
|
# acquires delta values of the minimum deltas in order to check if it is within radius later on
|
|
mindx = dx[minx_index, j]
|
|
mindy = dy[miny_index, j]
|
|
|
|
if mindx == 0 and mindy == 0 and np.all(dx[:, j] == 0) and np.all(dy[:, j] == 0):
|
|
# checks if minimum value is 0 and checks if all deltas are zero since this is empty set
|
|
# delta could be zero if centroid didn't move
|
|
|
|
continue # continue to next carid
|
|
|
|
else:
|
|
|
|
# if delta values are less than maximum radius then add that centroid to that specific carid
|
|
if np.abs(mindx) < maxrad and np.abs(mindy) < maxrad:
|
|
|
|
# adds centroid to corresponding previously existing carid
|
|
df.at[int(framenumber), str(carids[j])] = [cxx[minx_index], cyy[miny_index]]
|
|
minx_index2.append(minx_index) # appends all the indices that were added to previous carids
|
|
miny_index2.append(miny_index)
|
|
|
|
for i in range(len(cxx)): # loops through all centroids
|
|
|
|
# if centroid is not in the minindex list then another car needs to be added
|
|
if i not in minx_index2 and miny_index2:
|
|
|
|
df[str(totalcars)] = "" # create another column with total cars
|
|
totalcars = totalcars + 1 # adds another total car the count
|
|
t = totalcars - 1 # t is a placeholder to total cars
|
|
carids.append(t) # append to list of car ids
|
|
df.at[int(framenumber), str(t)] = [cxx[i], cyy[i]] # add centroid to the new car id
|
|
|
|
elif curcxcy[0] and not oldcxcy and not minx_index2 and not miny_index2:
|
|
# checks if current centroid exists but previous centroid does not
|
|
# new car to be added in case minx_index2 is empty
|
|
|
|
df[str(totalcars)] = "" # create another column with total cars
|
|
totalcars = totalcars + 1 # adds another total car the count
|
|
t = totalcars - 1 # t is a placeholder to total cars
|
|
carids.append(t) # append to list of car ids
|
|
df.at[int(framenumber), str(t)] = [cxx[i], cyy[i]] # add centroid to the new car id
|
|
|
|
# The section below labels the centroids on screen
|
|
|
|
currentcars = 0 # current cars on screen
|
|
currentcarsindex = [] # current cars on screen carid index
|
|
|
|
for i in range(len(carids)): # loops through all carids
|
|
|
|
if df.at[int(framenumber), str(carids[i])] != '':
|
|
# checks the current frame to see which car ids are active
|
|
# by checking in centroid exists on current frame for certain car id
|
|
|
|
currentcars = currentcars + 1 # adds another to current cars on screen
|
|
currentcarsindex.append(i) # adds car ids to current cars on screen
|
|
|
|
kenderaan_sekarang = currentcars
|
|
|
|
for i in range(currentcars): # loops through all current car ids on screen
|
|
|
|
# grabs centroid of certain carid for current frame
|
|
curcent = df.iloc[int(framenumber)][str(carids[currentcarsindex[i]])]
|
|
|
|
# grabs centroid of certain carid for previous frame
|
|
oldcent = df.iloc[int(framenumber - 1)][str(carids[currentcarsindex[i]])]
|
|
|
|
if curcent: # if there is a current centroid
|
|
|
|
# On-screen text for current centroid
|
|
cv2.putText(image, "Centroid" + str(curcent[0]) + "," + str(curcent[1]),
|
|
(int(curcent[0]), int(curcent[1])), cv2.FONT_HERSHEY_SIMPLEX, .5, (0, 255, 255), 2)
|
|
|
|
# cv2.putText(image, "ID:" + str(carids[currentcarsindex[i]]), (int(curcent[0]), int(curcent[1] - 15)),
|
|
# cv2.FONT_HERSHEY_SIMPLEX, .5, (0, 255, 255), 2)
|
|
|
|
cv2.drawMarker(image, (int(curcent[0]), int(curcent[1])), (0, 0, 255), cv2.MARKER_STAR, markerSize=5,
|
|
thickness=1, line_type=cv2.LINE_AA)
|
|
|
|
if oldcent: # checks if old centroid exists
|
|
# adds radius box from previous centroid to current centroid for visualization
|
|
xstart = oldcent[0] - maxrad
|
|
ystart = oldcent[1] - maxrad
|
|
xwidth = oldcent[0] + maxrad
|
|
yheight = oldcent[1] + maxrad
|
|
cv2.rectangle(image, (int(xstart), int(ystart)), (int(xwidth), int(yheight)), (0, 125, 0), 1)
|
|
|
|
# checks if old centroid is on or below line and curcent is on or above line
|
|
# to count cars and that car hasn't been counted yet
|
|
if oldcent[1] >= lineypos2 and curcent[1] <= lineypos2 and carids[
|
|
currentcarsindex[i]] not in caridscrossed:
|
|
|
|
carscrossedup = carscrossedup + 1
|
|
kenderaan_kiri = carscrossedup
|
|
cv2.line(image, (0, lineypos2), (width, lineypos2), (0, 0, 255), 5)
|
|
caridscrossed.append(
|
|
currentcarsindex[i]) # adds car id to list of count cars to prevent double counting
|
|
|
|
# checks if old centroid is on or above line and curcent is on or below line
|
|
# to count cars and that car hasn't been counted yet
|
|
elif oldcent[1] <= lineypos2 and curcent[1] >= lineypos2 and carids[
|
|
currentcarsindex[i]] not in caridscrossed:
|
|
|
|
carscrosseddown = carscrosseddown + 1
|
|
kenderaan_kanan = carscrosseddown
|
|
cv2.line(image, (0, lineypos2), (width, lineypos2), (0, 0, 125), 5)
|
|
caridscrossed.append(currentcarsindex[i])
|
|
jumlah_kenderaan = carscrossedup + carscrosseddown
|
|
|
|
# Top left hand corner on-screen text
|
|
#cv2.rectangle(image, (0, 0), (250, 100), (255, 0, 0), -1) # background rectangle for on-screen text
|
|
|
|
# insert data to database here using asyncio
|
|
await insert_data(video, str(round(frames_count / fps, 2)), str(round(framenumber / fps, 2)), kenderaan_kiri, kenderaan_kanan, "Belum Selesai")
|
|
|
|
cv2.putText(image, "Kenderaan Sebelah Kiri: " + str(carscrossedup), (0, 20), cv2.FONT_HERSHEY_SIMPLEX, .7, (255,255,255),
|
|
4)
|
|
|
|
cv2.putText(image, "Kenderaan Sebelah Kanan: " + str(carscrosseddown), (0, 45), cv2.FONT_HERSHEY_SIMPLEX, .7,
|
|
(255,255,255), 4)
|
|
|
|
# cv2.putText(image, "Total Cars Detected: " + str(len(carids)), (0, 60), cv2.FONT_HERSHEY_SIMPLEX, .5,
|
|
# (255,255,255), 1)
|
|
|
|
cv2.putText(image, "Frame: " + str(framenumber) + ' dari ' + str(frames_count), (0, 60), cv2.FONT_HERSHEY_SIMPLEX,
|
|
.5, (255,255,255), 1)
|
|
|
|
cv2.putText(image, 'Waktu: ' + str(round(framenumber / fps, 2)) + ' detik dari ' + str(round(frames_count / fps, 2))
|
|
+ ' detik', (0, 75), cv2.FONT_HERSHEY_SIMPLEX, .5, (255,255,255), 1)
|
|
|
|
|
|
frame = cv2.resize(frame, (int(width * ratio), int(height * ratio)))
|
|
cv2.imshow("Input", frame)
|
|
cv2.moveWindow("Input", 0, 0)
|
|
|
|
cv2.imshow("gray", gray)
|
|
cv2.moveWindow("gray", int(width * ratio), 0)
|
|
|
|
cv2.imshow("closing", bins)
|
|
cv2.moveWindow("closing", width, 0)
|
|
|
|
cv2.imshow("Output", image)
|
|
cv2.moveWindow("Output", width, int(height * ratio))
|
|
|
|
|
|
|
|
framenumber = framenumber + 1
|
|
|
|
k = cv2.waitKey(int(1000/fps)) & 0xff # int(1000/fps) is normal speed since waitkey is in ms
|
|
if k == 27:
|
|
await insert_data(video, str(round(frames_count / fps, 2)), str(round(framenumber / fps, 2)),kenderaan_kiri, kenderaan_kanan, "Belum Selesai")
|
|
cap.release()
|
|
cv2.destroyAllWindows()
|
|
break
|
|
|
|
else: # if video is finished then break loop
|
|
await insert_data(video, str(round(frames_count / fps, 2)),str(round(framenumber / fps, 2)), kenderaan_kiri, kenderaan_kanan, "Selesai")
|
|
selesainya = True
|
|
cap.release()
|
|
cv2.destroyAllWindows()
|
|
break
|
|
|
|
selesainya = True
|
|
cap.release()
|
|
cv2.destroyAllWindows()
|
|
|
|
|
|
|
|
async def update_video_list():
|
|
global video_list
|
|
# add "video/" to the video_list and only take video extensions
|
|
video_list = [f"video/{f}" for f in os.listdir("video") if f.endswith(".mp4")]
|
|
|
|
@app.route('/')
|
|
async def index():
|
|
global videonya,selesainya
|
|
selesainya = False
|
|
if (cap != None):
|
|
cap.release()
|
|
cv2.destroyAllWindows()
|
|
await update_video_list()
|
|
print("video_list:", video_list)
|
|
video = request.args.get('video', 'video/video.mp4')
|
|
videonya = video
|
|
the_threshold = request.args.get('threshold', 450)
|
|
minimal_kepadatan = request.args.get('minimal_kepadatan', 5)
|
|
threshold = int(the_threshold)
|
|
|
|
try:
|
|
query_select = "SELECT * FROM tb_data WHERE nama = %s "
|
|
|
|
conn = await get_db_connection()
|
|
async with conn.cursor() as cursor:
|
|
await cursor.execute(query_select, (video,))
|
|
result = await cursor.fetchall()
|
|
conn.close()
|
|
|
|
if len(result) == 0:
|
|
return await render_template('index2.html', video=video, threshold=threshold, video_list=video_list, stat="Belum Ada Data", selesainya=selesainya, minimal_kepadatan=minimal_kepadatan)
|
|
else :
|
|
print(result[0])
|
|
return await render_template('index2.html', video=video, threshold=threshold, video_list=video_list, stat=result[0], selesainya=selesainya, minimal_kepadatan=minimal_kepadatan)
|
|
|
|
|
|
except Exception as e:
|
|
return jsonify({'message': 'Failed to generate frames!', 'error': str(e)}), 500
|
|
|
|
# Pass the video file path and threshold value to the template
|
|
|
|
|
|
async def video_feed():
|
|
# Get the video file path, threshold value, and state from the URL parameters
|
|
video = request.args.get('video')
|
|
the_threshold = request.args.get('threshold', 450)
|
|
threshold = int(the_threshold)
|
|
stat = request.args.get('stat', 'color') # Default to 'color' if state is not specified
|
|
# Return the response with the generator function
|
|
print("ini semua variable:", video, threshold, stat)
|
|
await generate_frames2(video, threshold, stat)
|
|
# return Response( generate_frames2(video, threshold, stat), mimetype='multipart/x-mixed-replace; boundary=frame')
|
|
|
|
|
|
@app.route('/video_list')
|
|
async def video_list():
|
|
await update_video_list()
|
|
return await render_template('video_list.html', video_list=video_list)
|
|
|
|
@app.route('/videos/<path:video>')
|
|
async def video(video):
|
|
return send_from_directory('', video)
|
|
|
|
# Add route for the video feed
|
|
app.add_url_rule('/video_feed', 'video_feed', video_feed)
|
|
|
|
@app.route('/check_jumlah_kenderaan', methods=['GET'])
|
|
async def check_jumlah_kenderaan():
|
|
global jumlah_kenderaan , kenderaan_kiri, kenderaan_kanan ,videonya ,selesainya , kenderaan_sekarang,total_kenderaan_sekarang
|
|
if (videonya != None):
|
|
conn = await get_db_connection()
|
|
async with conn.cursor() as cursor:
|
|
sql = "SELECT * FROM tb_data WHERE nama = %s"
|
|
await cursor.execute(sql, (videonya,))
|
|
result = await cursor.fetchall()
|
|
conn.close()
|
|
if len(result) == 0:
|
|
return jsonify({'jumlah_kenderaan': 0, 'kenderaan_kiri': 0, 'kenderaan_kanan': 0})
|
|
else:
|
|
# print(result[0])
|
|
jumlah_kenderaan = result[0][4] + result[0][5]
|
|
kenderaan_kiri = result[0][4]
|
|
kenderaan_kanan = result[0][5]
|
|
waktu_sekarang = result[0][3]
|
|
kepadatan = result[0][7]
|
|
return jsonify({'jumlah_kenderaan': jumlah_kenderaan, 'kenderaan_kiri': kenderaan_kiri, 'kenderaan_kanan': kenderaan_kanan, 'waktu_sekarang':waktu_sekarang , "selesainya": selesainya , "kenderaan_sekarang": kenderaan_sekarang, "kepadatan":kepadatan , "total_kenderaan_sekarang":total_kenderaan_sekarang})
|
|
|
|
# return jsonify({'jumlah_kenderaan': jumlah_kenderaan, 'kenderaan_kiri': kenderaan_kiri, 'kenderaan_kanan': kenderaan_kanan})
|
|
|
|
UPLOAD_FOLDER = 'video'
|
|
@app.route('/upload', methods=['POST'])
|
|
async def upload_file():
|
|
file = request.files['file']
|
|
|
|
if file.filename == '':
|
|
return jsonify({'status': False, 'message': 'No file selected'})
|
|
|
|
if file:
|
|
filename = file.filename
|
|
file.save(os.path.join(UPLOAD_FOLDER, filename))
|
|
return jsonify({'status': True, 'message': 'File uploaded successfully', 'filename': filename})
|
|
|
|
if __name__ == "__main__":
|
|
app.run(debug=True)
|