# Abstract This work is an extension of the project https://github.com/ablanco1950/LicensePlate_Yolov8_Filters_PaddleOCR adding the possibility to detect the speed, tracking and counting cars --DIVIDER--# Introduction Installation: The requirements are exactly the same as those indicated in the aforementioned project: https://github.com/ablanco1950/LicensePlate_Yolov8_Filters_PaddleOCR A model yolov8: best.pt from that project, is used as number plate detector. For that, an environment python and ultralytics yolov8 is required.--DIVIDER-- The following parameters are used depending on the video in question: fps=25 #frames per second of video, see its properties fpsReal= fps/SpeedUpFrames # To speed up the process only one of SpeedUpFrames # is considered, SpeedUpFrames=5 lengthRegion=4.5 #the depth of the considered region corresponds # to the length of a parking space which is usually 4.5m From this parameters is got: From snapshots detected in the video region Speed (Km/hour)=lenthRegion * fpsReal * 3.6 / Snapshots Where 3.6 = (3600 sec./ 1 hour) * (1Km/ 1000m) This formula depends on the number of snapshots detected, which depends on the quality and speed of the plate detector, so in any case it has to be adjusted with practical tests in the field. The tracking and counting method is asigning as identifier of the car the license plate. --DIVIDER--# Experiments To test de project execute the pythom program VIDEODetectSpeed_and_ Counter_LicensePlate_Yolov8_Filters_PaddleOCR.py The test program VIDEODetectSpeed_and_ Counter_LicensePlate_Yolov8_Filters_PaddleOCR.py is only prepared to work with Traffic IP Camera video.mp4 test video, dowloaded from https://github.com/anmspro/Traffic-Signal-Violation-Detection-System/tree/master/Resources, since speed detection is performed over a region of the video, marked with a green rectangle, whose depth coincides with the length of a parking space that appears in the video . The code of that program is: # -*- coding: utf-8 -*- """ Created on Mon Apr 25 20:1 7:29 2022 @author: Alfonso Blanco """ ###################################################################### # PARAMETERS ##################################################################### ###################################################### # Video from https://github.com/anmspro/Traffic-Signal-Violation-Detection-System/tree/master/Resources dirVideo="Traffic IP Camera video.mp4" # in 14 minutes = 800 seconds finish TimeLimit=800 # Max number of Snapshots to consider a image LimitSnapshot=1 # Max number of Snapshots to consider a image # lower 3 snapshots is consider noisy # to increase the speed of the process, # even if some license plates are lost, # only one snapshot out of every SpeedUpFrames is processed SpeedUpFrames=5 # to increase speed, jump frames ContFramesJumped=0 fps=25 #frames per second of video dirvideo, see its properties fpsReal= fps/SpeedUpFrames # To speed up the process only one of SpeedUpFrames # is considered lenthRegion=4.5 #the depth of the considered region corresponds # to the length of a parking space which is usually 4.5m ############################################################## # DOWNLOAD VIDEOS TO TEST ############################################################### # video from https://github.com/hasaan21/Car-Number-Plate-Recognition-Sysytem #dirVideo="vid.mp4" #dirVideo="video12.mp4" #dirVideo="C:\\Car_Speed_Detection\\Comma.ai.Data.and.Model\\Comma.ai Model\\train.mp4" # from https://www.pexels.com/video/video-of-famous-landmark-on-a-city-during-daytime-1721294/ #dirVideo="Pexels Videos 1721294.mp4" dirnameYolo="best.pt" # https://docs.ultralytics.com/python/ from ultralytics import YOLO model = YOLO(dirnameYolo) class_list = model.model.names #print(class_list) ###################################################################### from paddleocr import PaddleOCR # Paddleocr supports Chinese, English, French, German, Korean and Japanese. # You can set the parameter `lang` as `ch`, `en`, `french`, `german`, `korean`, `japan` # to switch the language model in order. # https://pypi.org/project/paddleocr/ # # supress anoysing logging messages parameter show_log = False # https://github.com/PaddlePaddle/PaddleOCR/issues/2348 ocr = PaddleOCR(use_angle_cls=True, lang='en', show_log = False) # need to run only once to download and load model into memory import numpy as np import cv2 import time TimeIni=time.time() X_resize=220 Y_resize=70 import imutils #Poligono=[[200,500],[200,700],[1250,700],[1250,500]] Poligono=[[200,485],[200,655],[1250,655],[1250,485]] from shapely.geometry import Point from shapely.geometry.polygon import Polygon polygon1 = Polygon(Poligono) #TabTotHitsFilter=[] #TabTotFailuresFilter=[] #for j in range(7): # TabTotHitsFilter.append(0) # TabTotFailuresFilter.append(0) ##################################################################### """ Copied from https://gist.github.com/endolith/334196bac1cac45a4893# other source: https://stackoverflow.com/questions/46084476/radon-transformation-in-python """ from skimage.transform import radon import numpy from numpy import mean, array, blackman, sqrt, square from numpy.fft import rfft try: # More accurate peak finding from # https://gist.github.com/endolith/255291#file-parabolic-py from parabolic import parabolic def argmax(x): return parabolic(x, numpy.argmax(x))[0] except ImportError: from numpy import argmax def GetRotationImage(image): I=image I = I - mean(I) # Demean; make the brightness extend above and below zero # Do the radon transform and display the result sinogram = radon(I) # Find the RMS value of each row and find "busiest" rotation, # where the transform is lined up perfectly with the alternating dark # text and white lines # rms_flat does no exist in recent versions #r = array([mlab.rms_flat(line) for line in sinogram.transpose()]) r = array([sqrt(mean(square(line))) for line in sinogram.transpose()]) rotation = argmax(r) #print('Rotation: {:.2f} degrees'.format(90 - rotation)) #plt.axhline(rotation, color='r') # Plot the busy row row = sinogram[:, rotation] N = len(row) # Take spectrum of busy row and find line spacing window = blackman(N) spectrum = rfft(row * window) frequency = argmax(abs(spectrum)) return rotation, spectrum, frequency ##################################################################### def ThresholdStable(image): # -*- coding: utf-8 -*- """ Created on Fri Aug 12 21:04:48 2022 Author: Alfonso Blanco García Looks for the threshold whose variations keep the image STABLE (there are only small variations with the image of the previous threshold). Similar to the method followed in cv2.MSER https://datasmarts.net/es/como-usar-el-detector-de-puntos-clave-mser-en-opencv/https://felipemeganha.medium.com/detecting-handwriting-regions-with-opencv-and-python-ff0b1050aa4e """ thresholds=[] Repes=[] Difes=[] gray=image grayAnt=gray ContRepe=0 threshold=0 for i in range (255): ret, gray1=cv2.threshold(gray,i,255, cv2.THRESH_BINARY) Dife1 = grayAnt - gray1 Dife2=np.sum(Dife1) if Dife2 < 0: Dife2=Dife2*-1 Difes.append(Dife2) if Dife2<22000: # Case only image of license plate #if Dife2<60000: ContRepe=ContRepe+1 threshold=i grayAnt=gray1 continue if ContRepe > 0: thresholds.append(threshold) Repes.append(ContRepe) ContRepe=0 grayAnt=gray1 thresholdMax=0 RepesMax=0 for i in range(len(thresholds)): #print ("Threshold = " + str(thresholds[i])+ " Repeticiones = " +str(Repes[i])) if Repes[i] > RepesMax: RepesMax=Repes[i] thresholdMax=thresholds[i] #print(min(Difes)) #print ("Threshold Resultado= " + str(thresholdMax)+ " Repeticiones = " +str(RepesMax)) return thresholdMax # Copied from https://learnopencv.com/otsu-thresholding-with-opencv/ def OTSU_Threshold(image): # Set total number of bins in the histogram bins_num = 256 # Get the image histogram hist, bin_edges = np.histogram(image, bins=bins_num) # Get normalized histogram if it is required #if is_normalized: hist = np.divide(hist.ravel(), hist.max()) # Calculate centers of bins bin_mids = (bin_edges[:-1] + bin_edges[1:]) / 2. # Iterate over all thresholds (indices) and get the probabilities w1(t), w2(t) weight1 = np.cumsum(hist) weight2 = np.cumsum(hist[::-1])[::-1] # Get the class means mu0(t) mean1 = np.cumsum(hist * bin_mids) / weight1 # Get the class means mu1(t) mean2 = (np.cumsum((hist * bin_mids)[::-1]) / weight2[::-1])[::-1] inter_class_variance = weight1[:-1] * weight2[1:] * (mean1[:-1] - mean2[1:]) ** 2 # Maximize the inter_class_variance function val index_of_max_val = np.argmax(inter_class_variance) threshold = bin_mids[:-1][index_of_max_val] #print("Otsu's algorithm implementation thresholding result: ", threshold) return threshold ######################################################################### def ApplyCLAHE(gray): #https://towardsdatascience.com/image-enhancement-techniques-using-opencv-and-python-9191d5c30d45 gray_img_eqhist=cv2.equalizeHist(gray) hist=cv2.calcHist(gray_img_eqhist,[0],None,[256],[0,256]) clahe=cv2.createCLAHE(clipLimit=200,tileGridSize=(3,3)) gray_img_clahe=clahe.apply(gray_img_eqhist) return gray_img_clahe def GetPaddleOcr(img): """ Created on Tue Mar 7 10:31:09 2023 @author: https://pypi.org/project/paddleocr/ (adapted from) """ cv2.imwrite("gray.jpg",img) img_path = 'gray.jpg' result = ocr.ocr(img_path, cls=True) # draw result #from PIL import Image result = result[0] #image = Image.open(img_path).convert('RGB') boxes = [line[0] for line in result] txts = [line[1][0] for line in result] scores = [line[1][1] for line in result] licensePlate= "" accuracy=0.0 #print("RESULTADO "+ str(txts)) #print("confiabilidad "+ str(scores)) if len(txts) > 0: licensePlate= txts[0] accuracy=float(scores[0]) #print(licensePlate) #print(accuracy) return licensePlate, accuracy ######################################################################### def FindLicenseNumber (gray, x_offset, y_offset, License, x_resize, y_resize, \ Resize_xfactor, Resize_yfactor, BilateralOption): ######################################################################### gray = cv2.cvtColor(gray, cv2.COLOR_BGR2GRAY) TotHits=0 X_resize=x_resize Y_resize=y_resize gray=cv2.resize(gray,None,fx=Resize_xfactor,fy=Resize_yfactor,interpolation=cv2.INTER_CUBIC) gray = cv2.resize(gray, (X_resize,Y_resize), interpolation = cv2.INTER_AREA) rotation, spectrum, frquency =GetRotationImage(gray) rotation=90 - rotation #print("Car" + str(NumberImageOrder) + " Brillo : " +str(SumBrightnessLic) + # " Desviacion : " + str(DesvLic)) if (rotation > 0 and rotation < 30) or (rotation < 0 and rotation > -30): print(License + " rotate "+ str(rotation)) gray=imutils.rotate(gray,angle=rotation) TabLicensesFounded=[] ContLicensesFounded=[] X_resize=x_resize Y_resize=y_resize print("gray.shape " + str(gray.shape)) Resize_xfactor=1.5 Resize_yfactor=1.5 TabLicensesFounded=[] ContLicensesFounded=[] AccuraccyMin=0.7 TotHits=0 # https://medium.com/practical-data-science-and-engineering/image-kernels-88162cb6585d #kernel = np.array([[0, -1, 0], # [-1, 5, -1], # [0, -1, 0]]) kernel = np.array([[0, -1, 0], [-1,10, -1], [0, -1, 0]]) dst = cv2.filter2D(gray, -1, kernel) img_concat = cv2.hconcat([gray, dst]) text, Accuraccy = GetPaddleOcr(img_concat) if Accuraccy < AccuraccyMin: text="" text = ''.join(char for char in text if char.isalnum()) text=ProcessText(text) if ProcessText(text) != "": TabLicensesFounded, ContLicensesFounded =ApendTabLicensesFounded (TabLicensesFounded, ContLicensesFounded, text) if text==License: print(text + " Hit with image concat ") TotHits=TotHits+1 else: print(License + " detected with Filter image concat "+ text) """ kernel = np.ones((3,3),np.float32)/90 gray1 = cv2.filter2D(gray,-1,kernel) #gray_clahe = cv2.GaussianBlur(gray, (5, 5), 0) gray_img_clahe=ApplyCLAHE(gray1) th=OTSU_Threshold(gray_img_clahe) max_val=255 ret, o3 = cv2.threshold(gray_img_clahe, th, max_val, cv2.THRESH_TOZERO) text, Accuraccy = GetPaddleOcr(o3) if Accuraccy < AccuraccyMin: text="" text = ''.join(char for char in text if char.isalnum()) text=ProcessText(text) if ProcessText(text) != "": TabLicensesFounded, ContLicensesFounded =ApendTabLicensesFounded (TabLicensesFounded, ContLicensesFounded, text) if text==License: print(text + " Hit with CLAHE and THRESH_TOZERO" ) #TotHits=TotHits+1 else: print(License + " detected with CLAHE and THRESH_TOZERO as "+ text) """ for z in range(5,6): kernel = np.array([[0,-1,0], [-1,z,-1], [0,-1,0]]) gray1 = cv2.filter2D(gray, -1, kernel) text, Accuraccy = GetPaddleOcr(gray1) if Accuraccy < AccuraccyMin: text="" text = ''.join(char for char in text if char.isalnum()) text=ProcessText(text) if ProcessText(text) != "": ApendTabLicensesFounded (TabLicensesFounded, ContLicensesFounded, text) if text==License: print(text + " Hit with Sharpen filter z= " +str(z)) TotHits=TotHits+1 else: print(License + " detected with Sharpen filter z= " +str(z) + " as "+ text) """ gray_img_clahe=ApplyCLAHE(gray) th=OTSU_Threshold(gray_img_clahe) max_val=255 # Otsu's thresholding ret2,gray1 = cv2.threshold(gray,0,255,cv2.THRESH_TRUNC+cv2.THRESH_OTSU) #gray1 = cv2.GaussianBlur(gray1, (1, 1), 0) text, Accuraccy = GetPaddleOcr(gray1) if Accuraccy < AccuraccyMin: text="" text = ''.join(char for char in text if char.isalnum()) text=ProcessText(text) if ProcessText(text) != "": #if Detect_International_LicensePlate(text)== 1: TabLicensesFounded, ContLicensesFounded =ApendTabLicensesFounded (TabLicensesFounded, ContLicensesFounded, text) if text==License: print(text + " Hit with Otsu's thresholding of cv2 and THRESH_TRUNC" ) TotHits=TotHits+1 else: print(License + " detected with Otsu's thresholding of cv2 and THRESH_TRUNC as "+ text) """ threshold=ThresholdStable(gray) ret, gray1=cv2.threshold(gray,threshold,255, cv2.THRESH_TRUNC) #gray1 = cv2.GaussianBlur(gray1, (1, 1), 0) text, Accuraccy = GetPaddleOcr(gray1) if Accuraccy < AccuraccyMin: text="" text = ''.join(char for char in text if char.isalnum()) text=ProcessText(text) if ProcessText(text) != "": #if Detect_International_LicensePlate(text)== 1: ApendTabLicensesFounded (TabLicensesFounded, ContLicensesFounded, text) if text==License: print(text + " Hit with Stable and THRESH_TRUNC" ) TotHits=TotHits+1 else: print(License + " detected with Stable and THRESH_TRUNC as "+ text) #################################################### # experimental formula based on the brightness # of the whole image #################################################### SumBrightness=np.sum(gray) threshold=(SumBrightness/177600.00) ##################################################### ret, gray1=cv2.threshold(gray,threshold,255, cv2.THRESH_TOZERO) #gray1 = cv2.GaussianBlur(gray1, (1, 1), 0) text, Accuraccy = GetPaddleOcr(gray1) if Accuraccy < AccuraccyMin: text="" text = ''.join(char for char in text if char.isalnum()) text=ProcessText(text) if ProcessText(text) != "": #if Detect_International_LicensePlate(text)== 1: ApendTabLicensesFounded (TabLicensesFounded, ContLicensesFounded, text) if text==License: print(text + " Hit with Brightness and THRESH_TOZERO" ) TotHits=TotHits+1 else: print(License + " detected with Brightness and THRESH_TOZERO as "+ text) ################################################################ return TabLicensesFounded, ContLicensesFounded def Detect_International_LicensePlate(Text): if len(Text) < 3 : return -1 for i in range(len(Text)): if (Text[i] >= "0" and Text[i] <= "9" ) or (Text[i] >= "A" and Text[i] <= "Z" ): continue else: return -1 return 1 def ProcessText(text): if len(text) > 10: text=text[len(text)-10] if len(text) > 9: text=text[len(text)-9] else: if len(text) > 8: text=text[len(text)-8] else: if len(text) > 7: text=text[len(text)-7:] if Detect_International_LicensePlate(text)== -1: return "" else: return text def ApendTabLicensesFounded (TabLicensesFounded, ContLicensesFounded, text): SwFounded=0 for i in range( len(TabLicensesFounded)): if text==TabLicensesFounded[i]: ContLicensesFounded[i]=ContLicensesFounded[i]+1 SwFounded=1 break if SwFounded==0: TabLicensesFounded.append(text) ContLicensesFounded.append(1) return TabLicensesFounded, ContLicensesFounded # ttps://medium.chom/@chanon.krittapholchai/build-object-detection-gui-with-yolov8-and-pysimplegui-76d5f5464d6c def DetectLicenseWithYolov8 (img): TabcropLicense=[] y=[] yMax=[] x=[] xMax=[] results = model.predict(img) for i in range(len(results)): # may be several plates in a frame result=results[i] xyxy= result.boxes.xyxy.numpy() confidence= result.boxes.conf.numpy() class_id= result.boxes.cls.numpy().astype(int) # Get Class name class_name = [class_list[z] for z in class_id] # Pack together for easy use sum_output = list(zip(class_name, confidence,xyxy)) # Copy image, in case that we need original image for something out_image = img.copy() for run_output in sum_output : # Unpack #print(class_name) label, con, box = run_output if label == "vehicle":continue cropLicense=out_image[int(box[1]):int(box[3]),int(box[0]):int(box[2])] #cv2.imshow("Crop", cropLicense) #cv2.waitKey(0) TabcropLicense.append(cropLicense) y.append(int(box[1])) yMax.append(int(box[3])) x.append(int(box[0])) xMax.append(int(box[2])) return TabcropLicense, y,yMax,x,xMax ########################################################### # MAIN ########################################################## TabLicensesmax=[] ContLicensesmax=[] TimeIniLicensesmax=[] TimeEndLicensesmax=[] ContDetected=0 ContNoDetected=0 TotHits=0 TotFailures=0 with open( "VIDEOLicenseResults.txt" ,"w") as w: cap = cv2.VideoCapture(dirVideo) # https://levelup.gitconnected.com/opencv-python-reading-and-writing-images-and-videos-ed01669c660c fourcc = cv2.VideoWriter_fourcc(*'MP4V') fps=5.0 frame_width = 680 frame_height = 480 cap.set(cv2.CAP_PROP_FRAME_WIDTH, frame_width) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, frame_height) size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))) video_writer = cv2.VideoWriter('demonstration.mp4',fourcc,fps, size) ContCars=0 while (cap.isOpened()): ret, img = cap.read() if ret != True: break else: #print(ret) # cv2.imshow('original video', img) # # if cv2.waitKey(25) & 0xFF == ord('q'): # break gray=img # speed up a little ContFramesJumped=ContFramesJumped+1 if ContFramesJumped < SpeedUpFrames: continue else: ContFramesJumped=0 pts1=np.array(Poligono,np.int32) pts1=pts1.reshape((-1,1,2)) cv2.polylines(gray,[pts1],1,(0,255,255)) License="License" TabImgSelect, y, yMax, x, xMax =DetectLicenseWithYolov8(gray) if TabImgSelect==[]: print(License + " NON DETECTED") ContNoDetected=ContNoDetected+1 continue else: ContDetected=ContDetected+1 print(License + " DETECTED ") for i in range(len(TabImgSelect)): gray=TabImgSelect[i] #if len(TabImgSelect) > 1: # gray=TabImgSelect[1] #cv2.imshow('Frame', gray) if(polygon1.contains(Point(int((x[i]+xMax[i])/2),int((y[i]+yMax[i])/2)))): pp=0 else: cv2.imshow('Frame', img) # Press Q on keyboard to exit if cv2.waitKey(25) & 0xFF == ord('q'): break # saving video video_writer.write(img) continue #cv2.waitKey(0) x_off=3 y_off=2 x_resize=220 y_resize=70 Resize_xfactor=1.78 Resize_yfactor=1.78 ContLoop=0 SwFounded=0 BilateralOption=0 TabLicensesFounded=[] ContLicensesFounded=[] TabLicensesFounded, ContLicensesFounded= FindLicenseNumber (gray, x_off, y_off, License, x_resize, y_resize, \ Resize_xfactor, Resize_yfactor, BilateralOption) print(TabLicensesFounded) print(ContLicensesFounded) ymax=-1 contmax=0 licensemax="" for z in range(len(TabLicensesFounded)): if ContLicensesFounded[z] > contmax: contmax=ContLicensesFounded[z] licensemax=TabLicensesFounded[z] if licensemax == License: print(License + " correctly recognized") TotHits+=1 else: #print(License + " Detected but not correctly recognized") TotFailures +=1 print ("") lineaw=[] lineaw.append(License) lineaw.append(licensemax) lineaWrite =','.join(lineaw) lineaWrite=lineaWrite + "\n" w.write(lineaWrite) #if len(licensemax) < 2: continue SwFounded=0 for f in range( len(TabLicensesmax)): if licensemax==TabLicensesmax[f]: ContLicensesmax[f]=ContLicensesmax[f]+1 TimeEndLicensesmax[f]=time.time() SwFounded=1 break if SwFounded ==0: TabLicensesmax.append(licensemax) ContLicensesmax.append(1) ContCars+=1 TimeIniLicensesmax.append(time.time()) TimeEndLicensesmax.append(time.time()) #y-limitY:y+limitY,x-limitX:x+limitX #print("Y="+str(y)) start_point=(x[i],y[i]) end_point=(xMax[i], yMax[i]) color=(0,0,255) # Using cv2.rectangle() method # Draw a rectangle with blue line borders of thickness of 2 px img = cv2.rectangle(img, start_point, end_point,(36,255,12), 1) # Put text text_location = (20, 20) textCounter=" COUNTER : " + str(ContCars) text_color = (255,255,255) cv2.putText(img, textCounter ,text_location , cv2.FONT_HERSHEY_SIMPLEX , 1 , text_color, 2 ,cv2.LINE_AA) text_location = (x[i], y[i]) text_color = (255,255,255) cv2.putText(img, licensemax ,text_location , cv2.FONT_HERSHEY_SIMPLEX , 1 , text_color, 2 ,cv2.LINE_AA) cv2.imshow('Frame', img) # Press Q on keyboard to exit if cv2.waitKey(25) & 0xFF == ord('q'): break # saving video video_writer.write(img) # a los 10 minutos = 600 segundos acaba if time.time() - TimeIni > TimeLimit: break #print(TabLicensesmax) #print(ContLicensesmax) #break cap.release() video_writer.release() cv2.destroyAllWindows() w.close() with open( "VIDEOLicenseSummary.txt" ,"w") as w1: for j in range (len(TabLicensesmax)): if ContLicensesmax[j] < LimitSnapshot:continue if TabLicensesmax[j] == "":continue Duration=TimeEndLicensesmax[j]-TimeIniLicensesmax[j] #Duration=Duration/ContLicensesmax[j] """ SpeedUpFrames=5 # to increase speed, jump frames ContFramesJumped=0 fps=25 #frames per second of video dirvideo, see its properties fpsReal= fps/SpeedUpFrames # To speed up the process only one of SpeedUpFrames # is considered lenthRegion=4.5 #the depth of the considered region corresponds # to the length of a parking space which is usually 4.5m """ Snapshots= ContLicensesmax[j] Speed=lenthRegion * fpsReal * 3.6 / Snapshots #print(TabLicensesmax[j] + " snapshots: "+ str(ContLicensesmax[j]) + " Duration = "+str(Duration)) print(TabLicensesmax[j] + " Speed: "+ str(Speed) + "Km/h " + " snapshots: "+ str(Snapshots) ) lineaw1=[] lineaw1.append(TabLicensesmax[j]) lineaw1.append(str(ContLicensesmax[j])) lineaw1.append(str(TimeIniLicensesmax[j])) lineaw1.append(str(TimeEndLicensesmax[j])) lineaw1.append(str(Speed)) lineaWrite =','.join(lineaw1) lineaWrite=lineaWrite + "\n" w1.write(lineaWrite) w1.close() print(" COUNTER : " + str(ContCars)) print("") print( " Time in seconds "+ str(time.time()- TimeIni)) print("") --DIVIDER--# Results As a result, the console gets the following output, appart from video display with counter and licences plates: AR606L Speed: 27.0Km/h snapshots: 3 AE670S Speed: 40.5Km/h snapshots: 2 APHI88 Speed: 81.0Km/h snapshots: 1 A3K96 Speed: 40.5Km/h snapshots: 2 A968B6 Speed: 40.5Km/h snapshots: 2 AV6190 Speed: 27.0Km/h snapshots: 3 In which it is verified that the speed is determined by the number of snapshots in the delimited region of interest. There is one error from false detections of plate A3K961 that is detected as A3k96 Adjustments would be necessary with real and verifiable cases. You also get a logging file VIDEOLicenseResults.txt with the detected license plates and a summary file: VIDEOLicenseSummary.txt with the following fields: - License detected - number of snapshots in the region of interest - time of first snapshot - last snapshot time - estimated speed And the car`s counter--DIVIDER--# Conclusion The main advantage of this method is that it seems to be insensitive to the load that the computer that executes it is supporting, which allows the observed values to be adjusted. With respect the tracking method, depends directly on the detection of the license plate. It is more precise but produces errors if the license plate is detected incorrectly. REFERENCES: the program that apeears in: https://docs.ultralytics.com/guides/speed-estimation/ in which the speeds vary at different execution times of the program. https://www.ultralytics.com/es/blog/ultralytics-yolov8-for-speed-estimation-in-computer-vision-projects It is indicated that the results depend on the speed of the GPU Program in recent article: https://www.ultralytics.com/blog/how-to-use-ultralytics-yolo11-for-object-tracking?utm_source=newsletter&utm_medium=email&utm_term=2024-11-29&utm_campaign=+Ultralytics+Unplugged+-+Snapshot+2 It is expected to improve the results in subsequent versions by applying the specifications that appear in https://blog.roboflow.com/estimate-speed-computer-vision/ and others Other References: https://github.com/amanraja/vehicle-speed-detection- https://www.ijcseonline.org/pub_paper/124-IJCSE-06271.pdf https://medium.com/@raja_8462/an-efficient-approach-for-vehicle-speed-detection-1fce82aacaf2 https://pypi.org/project/paddleocr/ https://learnopencv.com/ultralytics-yolov8/#How-to-Use-YOLOv8? https://public.roboflow.com/object-detection/license-plates-us-eu/3 https://docs.ultralytics.com/python/ https://medium.com/@chanon.krittapholchai/build-object-detection-gui-with-yolov8-and-pysimplegui-76d5f5464d6c https://medium.com/@alimustoofaa/how-to-load-model-yolov8-onnx-cv2-dnn-3e176cde16e6 https://medium.com/adevinta-tech-blog/text-in-image-2-0-improving-ocr-service-with-paddleocr-61614c886f93 https://machinelearningprojects.net/number-plate-detection-using-yolov7/ https://github.com/ablanco1950/LicensePlate_Yolov8_MaxFilters https://docs.ultralytics.com/guides/speed-estimation/ https://www.ultralytics.com/es/blog/ultralytics-yolov8-for-speed-estimation-in-computer-vision-projects https://blog.roboflow.com/estimate-speed-computer-vision/ citations and thanks: @article{akyon2022sahi, title={Slicing Aided Hyper Inference and Fine-tuning for Small Object Detection}, author={Akyon, Fatih Cagatay and Altinuc, Sinan Onur and Temizel, Alptekin}, journal={2022 IEEE International Conference on Image Processing (ICIP)}, doi={10.1109/ICIP46576.2022.9897990}, pages={966-970}, year={2022} } Tracking and Counting: https://github.com/pderrenger/pderrenger https://github.com/pderrenger?tab=repositories https://github.com/orgs/ultralytics/discussions/8112 (example from pderrenger) https://towardsdatascience.com/mastering-object-counting-in-videos-3d49a9230bd2 https://docs.ultralytics.com/es/guides/sahi-tiled-inference/ Filters: https://gist.github.com/endolith/334196bac1cac45a4893# https://stackoverflow.com/questions/46084476/radon-transformation-in-python https://gist.github.com/endolith/255291#file-parabolic-py https://learnopencv.com/otsu-thresholding-with-opencv/ https://towardsdatascience.com/image-enhancement-techniques-using-opencv-and-python-9191d5c30d45 https://blog.katastros.com/a?ID=01800-4bf623a1-3917-4d54-9b6a-775331ebaf05 https://programmerclick.com/article/89421544914/ https://anishgupta1005.medium.com/building-an-optical-character-recognizer-in-python-bbd09edfe438 https://datasmarts.net/es/como-usar-el-detector-de-puntos-clave-mser-en-opencv/ https://felipemeganha.medium.com/detecting-handwriting-regions-with-opencv-and-python-ff0b1050aa4e https://github.com/victorgzv/Lighting-correction-with-OpenCV https://medium.com/@yyuanli19/using-mnist-to-visualize-basic-conv-filtering-95d24679643e https://www.ultralytics.com/blog/how-to-use-ultralytics-yolo11-for-object-tracking?utm_source=newsletter&utm_medium=email&utm_term=2024-11-29&utm_campaign=+Ultralytics+Unplugged+-+Snapshot+2