Laporan Proyek Akhir

Pengolahan Deteksi Kecepatan Kendaraan dengan menggunakan

Kamera dan pemrosesan gambar perangkat lunak

Josephine 1606903085
M. Syafieq Ridho 1606895051
Naufal Alharits S. 1606874173

Departemen Fisika
Fakultas Matematika Dan Ilmu Pengetahuan Alam
Universitas Indonesia
2019
 DAFTAR ISI

DAFTAR ISI ................................................................................................................. i

BAB 1 PENDAHULUAN ........................................................................................... 2
1.1. Latar Belakang ............................................................................................. 2
1.2. Perumusan Masalah ..................................................................................... 3
BAB 2 TINJAUAN PUSTAKA DAN METODE ..................................................... 4
2.1. Tinjauan Pustaka dan Metode .................................................................... 4
2.1. Kriteria Evaluasi .......................................................................................... 9
2.2. Pendekatan Masalah .................................................................................. 10
BAB 3 HASIL DAN PEMBAHASAN ..................................................................... 13
3.1. Hasil ............................................................................................................. 13
3.2. Pembahasan ................................................................................................ 15
BAB 4 KESIMPULAN DAN SARAN ..................................................................... 16
5.1. Kesimpulan ................................................................................................. 16
5.2. Saran ............................................................................................................ 16
DAFTAR REFERENSI ............................................................................................ 17

i
 2

BAB 1
PENDAHULUAN
1.1. Latar Belakang
Pemantauan kecepatan kendaraan digunakan oleh polisi untuk melakukan
penegakan hukum lalu lintas. Dengan meningkatnya kebutuhan di kehidupan
perkotaan sehari-hari, dengan bertambahnya jumlah orang dan juga meningkatnya
jumlah kendaraan maka over speeding menjadi alasan utama kecelakaan.
Pengendalikan kecepatan kendaraan telah menjadi salah satu masalah yang sangat
penting untuk manajemen lalu lintas.
Dari beberapa dekade terakhir, alat yang digunakan untuk mengukur kecepatan
kendaraan bergerak adalah radar Doppler. Radar Doppler sendiri adalah sebuah
perangkat genggam yang mengirim sinar radio ke Gerakan kendaraan lalu menghitung
kecepatan kendaraan dengan mengukur perubahan frekuensi gelombang yang
dipantulkan. Itu merupakan perangkat andal selama tidak ada kendaraan lain di bidang
pandang.

Gambar 1. Handheld Radar Gun

Terdapat kekurangan dari penggunaan system radar Doppler ini. Pertama, jika
pistol radar tidak berhadapan. Gangguan radio juga harus dipertimbangkan karena
 3

kesalahan yang disebabkan pada deteksi kecepatan. Pembayangan yang merupakan

pantulan gelombang radar dari 2 kendaraan dengan ketinggian berbeda juga
menyebabkan kesalahan deteksi kecepatan.
Sebelum ini telah dikembangkan teknik pemrosesan video dan pemrosesan
gambar digunakan untuk kecepatan kendaraan deteksi. Pengukuran kecepatan ini
didasarkan pada perbedaan tiap gambar, kamera terkalibrasi dan optik dan gambar
video digital.
Dalam proposal proyek akhir mata kuliah digital signal processing yang
diusulkan ini, setiap kendaraan yang bergerak di dalam video dari kamera video atau
sumber seluler apa pun dimanfaatkan. Kami menggunakan OpenCV, Dlib dan python
sebagai dasar untuk membuat sistem pemogramam. Sistem awal dikembangkan
dengan laptop dan webcam yang memiliki tujuan untuk membawa perangkat lunak
yang dikembangkan ke platform seluler seperti pintar telepon atau ke komputer
sederhana untuk menghasilkan detektor kecepatan kendaraan di waktu yang nyata.

1.2. Perumusan Masalah

Dari Proyek berjudul ‘Pengolahan Deteksi Kecepatan Kendaraan dengan
menggunakan Kamera dan pemrosesan gambar perangkat lunak’ ini dapat diturunkan
dalam perumusan masalah yaitu:
1. Bagaimana cara mendeteksi kecepatan kendaraan dengan menggunakan
kamera?
2. Parameter apa saja yang digunakan sebagai metode kalkulasi untuk
kecepatan kendaraan berdasarkan video dari kamera?
3. Apakah hasil pendeteksi kecepatan kendaraan berdasarkan pemprosesan
video sesuai dengan kecepatan aslinya?
 4

BAB 2
TINJAUAN PUSTAKA DAN METODE
2.1. Tinjauan Pustaka dan Metode
Haarcascade classifier untuk mengidentifikasi kendaraan
Haarcascade adalah sebuah algoritma machine learning yang dapat digunakan
untuk mendeteksi obyek pada gambar ataupun video. Algoritma ini juga menggunakan
konsep dari fitur yang diajukan oleh Paul Viola dan Michael Jones pada paper mereka
dengan judul “Rapid Object Detection using a Boosted Cascade od Simple Features”
yang dipublikasikan pada tahun 2001. Metode machine learning ini memiliki dasar
pendekatan dimana fungsi cascade dilatih dengan gambar positif dan negatif.
Selanjutnya digunakan untuk mendeteksi obyek di gambar yang lain. Biasanya metode
ini digunakan untuk mendeteksi wajah dan bagian tubuh pada suatu gambar tetapi dapat
juga digunakan untuk obyek lain.

Algoritma ini memiliki 4 tahapan yaitu:

1. Haar feature selection
2. Adaboost training
3. Cascade classifier

Haar Feature Selection

Fitur haar adalah daerah persegi panjang yang akan bekerja pada foto yang akan
dideteksi keberadaan obyeknya. Nilai dari intensitas pixel yang ada pada daerah
tersebut akan dijumlahkan dan hitung perbedaan dari setiap penjumlahan yang ada.
Integral images dapat melakukan hal ini dengan cepat.
 5

Gambar 2. Haar feature

Antara semua fitur yang dikalkukasi, hampir semua akan mendapatkan hasil
yang irelevan. Contohnya dapat dilihat pada gambar dibawah. Pada gambar kiri, fitur
yang dipilih fokus pada properti bahwa biasanya daerah mata akan cenderung memiliki
warna yang lebih gelap dibandingkan bagian pipi. Pada gambar kanan, fitur yang
dipilih fokus pada properti bahwa biasanya daerah mata akan cenderung memiliki
warna yang lebih gelap dibandingkan batang hidung. Tetapi jika fitur ini diaplikasikan
pada daerah pipi, maka hasil yang didapatkan akan menjadi irelevan.

Gambar 3. Contoh cara kerja haar feature

Bagaimana caranya untuk memilih fitur yang terbaik dari sekian banyak fitur
yang didapatkan dari 1 gambar? hal ini dapat dicapai dengan menggunakan konsep
yang disebut dengan adaboost.
 6

Adaboost training
Boosting adalah pembelajaran metode ensemble meta algoritma untuk terutama
mengurangi bias, dan juga varians. Berbeda halnya dengan bagging dan random forest
yang mendapatkan hasil prediksi dari proses bootsrap, boosting mengacu pada
kumpulan algoritma yang dapat mengkorversi weak learners untuk strong learners.
Prinsip utama dari boosting adalah menyesuaikan urutan weak learners hanya sedikit
lebih baik daripada tebakan acak, sementara strong learners dekat dengan kinerja
sempurna seperti pohon keputusan kecil. Setiap kali pembuatan pohon, data yang
digunakan tetap seperti semula tetapi memiliki sebaran bobot yang berbeda dalam tiap
iterasi. Penggunaan bobot juga dilakukan pada saat proses penggabungan prediksi
akhir dari banyak pohon yang dihasilkan melalui klasifikasi atau penjumlahan regresi.
Boosting juga dikenal dengan sebutan AdaBoost. Pada proses deteksi, terdapat kotak
dari ukuran target yang dipindahkan ke seluruh gambar dan untuk setiap daerah dari
gambar, nilai haar feature akan dihitung. Perbedaan ini lalu akan dibandingkan dengan
threshold yang sudah dipelajari yang memisahkan obyek dan non obyek. Karena haar
feature adalah classifier lemah, dibutuhkan banyak haar feature untuk mendeskripsikan
obyek dengan akurasi yang tinggi dan disusun menjadi cascade classifier untuk
membentuk classifier yang lebih kuat.

Cascade classifier
Cascade calssifier terdiri dari beberapa tahap yang adalah gabungan dari weak
learners. Weak learners yang ada adalah pengklasifikasi sederhana yang dapat disebut
decision stumps. Setiap tahap dilatih tengan teknik yang disebut dengan boosting.
Boosting memiliki kemampuan untuk melatih klasifikasi dengan akurasi tinggi dengan
mengambil rata-rata yang ada pada keputusan yang dibuat oleh weak learners. Setiap
tahap dari klasifikasi menglabel daerah yang ditentukan dari lokasi kotak yang
bergerak dengan nilai positif atau negatif. Nilai positif mengindikasikan bahwa obyek
telah ditemukan dan negatif mengindikasikan bahwa tidak ada obyek yang ditemukan.
Jika dinilai negatif, maka klasifikasi dari daerah tersebut sudah selesai dan detektor
akan bergerak ke daerah selanjutnya. Jika dinilai positif, maka klasifikasi akan
 7

dilanjutkan ke langkah selanjutnya. Detektor akan melaporkan bahwa obyek berhasil

ditemukan pada saat tahap terakhir sudah dilakukan.

Terdapat beberapa istilah yang harus dimengerti:

1.true positive: sampel positif telah ditentukan dengan benar
2.false positive: sampel negatif salah diartikan sebagai positif
3.false negative: sampel positif salah diartikan sebagai negatif

Agar sistem dapat bekerja dengan baik, setiap tahap harus memiliki persentase
false negatif yang rendah. Pada saat sebuah tahap salah melabel obyek sebagai negatif,
maka klasifikasi akan berhenti dan kesalahan tidak bisa diperbaiki lagi. Tetapi, setiap
tahap boleh memiliki persentase false positif yang tinggi. Karena walaupun detektor
salah menglabel non obyek sebagai positif, kesalahan ini dapat diperbaiki di tahap
selanjutnya. Menambah tahap dapat mengurangi persentase dari false positive tetapi
juga mengurangi persentase dari true positif.

Cascade classifier training membutuhkan set dari sampel positif dan negatif.
Set positif harus disediakan dengan menandai daerah yang ingin dijadian nilai positif
tersebut. Hal ini dapat dilakukan dengan menggunakan image labeler untuk menglabel
obyek dengan batasnya. Selanjutnya, image labeler akan memberikan tabel output yang
dapat digunakan untuk mengidentifikasi sampel positif. Untuk mendapatkan akurasi
detektor yang dapat diterima, jumlah tahap, jenis fitur, dan parameter yang lain harus
ditentukan.

Gambar 4. Cascade classifier

 8

Tracker korelasi dari dilib library

Correlation Tracker adalah alat untuk melacak objek bergerak dalam aliran
video. Anda memberinya kotak pembatas objek di bingkai pertama dan ia mencoba
melacak objek di dalam kotak dari bingkai ke bingkai. Correlation Tracker cenderung
lebih stabil jika dibandingkan dengan Camshift tracker. Correlation tracker bekerja
dengan mengambil koordinat awal dari object yang di track, kemudian melihat
perubahan posisi dari object yang di track dengan sebuah frame dan memperkirakan
posisi objek dalam bentuk (x,y,w,h)

Contoh program object tracking :

import dlib
import numpy as np
class CorrelationTracker(object):
def __init__(self,roiPts):
#set initial points
self.roiPts = np.array(roiPts)
self.tracker = None
def orderPoints(self):
assert len(self.roiPts)==2
return self.roiPts[np.argsort(self.roiPts.sum(axis=1))]
def track(self,image):
#create a new tracker
if self.tracker is None:
self.tracker = dlib.correlation_tracker()
pts = self.orderPoints().tolist()
tl, br = pts
(x,y,w,h) = (tl[0],tl[1],br[0]-tl[0],br[1]-tl[1])
roi_pts = [x,y,x+w,y+h]
self.tracker.start_track(image,dlib.rectangle(*roi_pts))
#update the tracker with current frame and get the current estimated position
 9

self.tracker.update(image)
pts = self.tracker.get_position()
(x,y,xb,yb) = (pts.left(),pts.top(),pts.right(),pts.bottom())
#return the points of the form (x,y,w,h)
return np.int0((x,y,(xb-x),(yb-y)))

Kalkukasi kecepatan
Untuk menghitung kecepatan kendaraan(mobil), dilakukan dengan metode
berdasarkan perpindahan objek pada video yang bergantung pada frame per second dan
pixel per meter, sehingga dalam kalkulasi tersebut didapatkan sebuah estimasi untuk
menentukan kecepatan mobil. Terdapat ppm (pixels per meter), d_pixel(perpindahan
jarak dari suatu pixel ke pixel lain pada suatu frame dalam video) dan d_meters(jarak).
Nilai dari ppm dapat bervariasi pada setiap jalan, dan harus disesuaikan jika ingin
mengukur kecepatan mobil pada jalan yang berbeda. Untuk menghitung nilai ppm,
terdapat beberapa informasi yang harus diketahui yaitu panjang jalan sesungguhnya
dan jumlah pixel dari input video. Dari kedua informasi tersebut, ppm dapat diketahui
dengan membagi jumlah pixel dengan jarak sesungguhnya.
D_pixel akan menggambarkan jarak dalam satuan pixel yang sudah ditempuh
oleh kendaraan pada satu frame dari video processing. Untuk mengestimasi kecepatan
dengan satuan yang standar, maka satuan d_pixel harus dikonversikan ke d_meter
dengan menggunakan nilai ppm yang sudah didapatkan sebelumnya. Selanjutnya,
kecepatan dapat dihitung dengan persamaan speed = d_meters * fps * 3.6. satuan yang
akan didapatkan dari persamaan ini adalah kecepatan dalam km/jam. Konstanta 3.6
digunakan untuk mengkonversikan nilai m/s menjadi km/jam.

2.2. Kriteria Evaluasi

Kriteria untuk evaluasi yang digunakan adalah analisis data hasil pengolahan
berdasarkan hasil deteksi kecepatan kendaraan secara pemprosesan video dibantu
perangkat lunak yang digunakan dengan melihat keadaan jalan yang mempengaruhi
kecepatan rata-rata mobil mobil pada kondisi aslinya secara kasat mata.
 10

2.3. Pendekatan Masalah

Pengolahan deteksi kecepatan kendaraan dilakukan input menggunakan input video
dari kamera dan pemrosesan gambar dengan menggunakan OpenCV dan python.
Pengambilan video menggunakan kamera handphone dan pengambilan video
dilakukan dari sisi atas kendaraan. Dalam proyek ini, digunakan metode haarcascade
untuk mendeteksi mobil dan corelation tracker untuk mengukur perpindahan object dan
object tracking pada gambar video.

Gambar 5. Video Properties

Video yang dihasilkan memiliki ukuran 540 x 960 pixel dengan frame rate
29.85 frames/second dimana jalan didalam video adalah jalan Margonda Raya, Depok
dengan jarak total jalan sekitar 65 meter. Sehingga didapatkan ppm yang dihitung
 11

berdasarkan panjang jalan dibagi dengan frame height video, Sehingga didapatkan
konstanta dari ppm yaitu 14,7.

Gambar 6. Object Tracking

Kemudian dilakukan object detection dengan indikator frame kotak berwarna
hijau, jika ada object yang dideteksi maka proses kalkulasi akan dilakukan, dimulai
dengan menyalakan timer waktu untuk menentukan waktu yang diperlukan untuk
mengeksekusi program dibawahya yang nantinya berdampak pada perhitungan
kecepatan mobil itu sendiri.
 12

Gambar 7. Hasil BGR to Gray

Setelah itu image pada video akan diambil sesuai bentuk aslinya, dan kemudian
jika frame sudah mencapai kelipatan 10, gambar akan di ubah dari RGB ke Gray.
Gambar diubah menjadi grey agar lebih mudah untuk diklasifikasi dan di tracking,
kemudian setelah itu object akan di tracking perpindahannya dari suatu titik(posisi
awal) ke suatu titik tertentu. Perpindahan dan waktu inilah yang nantinya digunakan
untuk mengkalkulasi kecepatan mobil dari video. Setelah itu kecepatan mobil hasil
kalkulasi akan ditampilkan pada output video dengan satuan km/hr.
 13

BAB 3
HASIL DAN PEMBAHASAN
3.1. Hasil

Gambar 8. Hasil Video Processing Kecepatan Mobil 1

 14

Gambar 9. Hasil Video Processing Kecepatan Mobil 2

 15

3.2. Pembahasan
Seperti yang dapat dilihat pada gambar 8 dan 9, bahwa gambar tersebut
merupakan hasil video processing kecepatan mobil dengan menggunakan OpenCV dan
Python. Pada hasil pengujian ini, menurut kami dapat merepresentasikan kecepatan asli
dari mobil yang dapat diperkirakan dari kecepatan mobil rata-rata pada daerah
margonda jika jalanan dalam kondisi ramai lancar, walaupun kami tidak dapat
membuktikannya karena kami tidak mencobanya dengan menggunakan mobil sendiri
yang diatur kecepatannya. Object tracking pada video sudah bekerja dengan sangat
baik, tidak ada mobil satu pun yang tidak terdeteksi, akan tetapi ada motor yang
dideteksi sebagai mobil, hal ini disebabkan oleh object motor dalam video tidak dalam
resolusi yang baik atau objek yang terdeteksi memiliki ukuran yang hampir sama
dengan data set mobil yang ada pada haarcascade classifier yang digunakan. Dan
mungkin ada beberapa kecepatan yang kurang tepat terdeteksi(atau tidak sesuai dengan
keadaan aslinya), hal ini dipengaruhi oleh pengambilan video dari kamera, angle dari
kamera dan obstacle seperti pohon, banguan, akan mempengaruhi object detection
maupun hasil kalkulasi perhitungan kecepatan mobil itu sendiri.
 16

BAB 4
KESIMPULAN DAN SARAN
5.1. Kesimpulan
Dari Proyek yang telah dijalankan, Kami dapat mengambil beberapa
kesimpulan yaitu sebagai berikut:
• Metode Haarcascade dapat digunakan untuk mengidentifikasi object pada suatu
video
• Deteksi kecepatan mobil dapat dilakukan dengan melihat perpindahan
mobil(objek) pada pixel dalam suatu frame, berdasarkan jarak yang diketahui
sebelumnya.
• Hasil kecepatan mobil yang diolah dengan menggunakan video processing
mendapatkan hasil yang dapat menggambarkan kondisi aslinya.

5.2. Saran
Dari Proyek yang telah dijalankan, Kami dapat memberikan beberapa saran untuk
dapat menghasilkan output yang lebih baik lagi, yaitu sebagai berikut:
• Pada proses pengambilan video, haruslah dikondisikan agar terhindar dari
obstacle yang dapat mempengaruhi object tracking, seperti pohon, rumah,
gedung, dan lainnya. Pengambilan video jugalah harus stabil dan angle diambil
dari atas agar object(mobil) dapat diidentifikasi dengan baik.

• Untuk mendapatkan hasil yang mendekati sempurna, kami menyarankan untuk

menggunakan metode perhitungan dengan FOV(Field Of View), dengan
melihat jarak horizontal dalam FOV yang sejajar dengan kamera, sehingga
didapatkan jarak vertical dari lensa kamera. Dengan metode ini tentunya dapat
meminimalisir kesalahan dalam menentukan jarak dalam keseluruhan pixel.
 17

DAFTAR REFERENSI
1. https://github.com/kraten/vehicle-speed-check diakses pada hari Senin 2
Desember 2019 pukul 8.00.
2. Wu, J., Liu, Z., Li, J., Gu, C., Si, M., & Tan, F. (2009, July). An algorithm for
automatic vehicle speed detection using video camera. In 2009 4th International
Conference on Computer Science & Education (pp. 193-196). IEEE.
3. https://docs.opencv.org/3.4.8/index.html diakses pada hari Senin 2 Desember
2019 pukul 10.00.
4. http://dlib.net/python/index.html diakses pada hari Jumat 13 Desember 2019 pukul
7.00
5. Karim, Mohamed Rehan, and Abbas Dehghani. "Vehicle speed detection in video
image sequences using CVS method." International journal of the Physical
Sciences 5.17 (2010): 2555-2563.
6. Koyuncu, Hakan, and Baki Koyuncu. "Vehicle Speed detection by using Camera
and image processing software."
7. http://www.willberger.org/cascade-haar-explained/ diakses pada hari Minggu 8
Desember 2019 pukul 14.00.
 18

LAMPIRAN
Main Program
import cv2
import dlib
import time
import math

carCascade = cv2.CascadeClassifier('./myhaar.xml')
video = cv2.VideoCapture('camera.mp4')
WIDTH = 540
HEIGHT = 960

def estimateSpeed(location1, location2):

d_pixels = math.sqrt(math.pow(location2[0] - location1[0], 2) + math.pow(location2[1] -
location1[1], 2))
ppm = 14.7
d_meters = d_pixels / ppm
#print("d_pixels=" + str(d_pixels), "d_meters=" + str(d_meters))
fps = 29.95
speed = d_meters * fps * 3.6
return speed

def trackMultipleObjects():
rectangleColor = (0, 255, 0)
frameCounter = 0
currentCarID = 0
fps = 0

carTracker = {}
carLocation1 = {}
carLocation2 = {}
speed = [None] * 1000

# Write output to video file

 19

out = cv2.VideoWriter('./outpy.avi',cv2.VideoWriter_fourcc('M','J','P','G'), 10,

(WIDTH,HEIGHT))

while True:
start_time = time.time()
rc, image = video.read()
if type(image) == type(None):
break

image = cv2.resize(image, (WIDTH, HEIGHT))

resultImage = image.copy()

frameCounter = frameCounter + 1

carIDtoDelete = []

for carID in carTracker.keys():

trackingQuality = carTracker[carID].update(image)

if trackingQuality < 7:
carIDtoDelete.append(carID)

for carID in carIDtoDelete:

print ('Removing carID ' + str(carID) + ' from list of trackers.')
print ('Removing carID ' + str(carID) + ' previous location.')
print ('Removing carID ' + str(carID) + ' current location.')
carTracker.pop(carID, None)
carLocation1.pop(carID, None)
carLocation2.pop(carID, None)

if not (frameCounter % 10):

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cars = carCascade.detectMultiScale(gray, 1.1, 13, 18, (24, 24))

for (_x, _y, _w, _h) in cars:

x = int(_x)
 20

y = int(_y)
w = int(_w)
h = int(_h)

x_bar = x + 0.5 * w
y_bar = y + 0.5 * h

matchCarID = None

for carID in carTracker.keys():

trackedPosition = carTracker[carID].get_position()

t_x = int(trackedPosition.left())
t_y = int(trackedPosition.top())
t_w = int(trackedPosition.width())
t_h = int(trackedPosition.height())

t_x_bar = t_x + 0.5 * t_w

t_y_bar = t_y + 0.5 * t_h

if ((t_x <= x_bar <= (t_x + t_w)) and (t_y <= y_bar <=
(t_y + t_h)) and (x <= t_x_bar <= (x + w)) and (y <= t_y_bar <= (y + h))):
matchCarID = carID

if matchCarID is None:
print ('Creating new tracker ' + str(currentCarID))

tracker = dlib.correlation_tracker()
tracker.start_track(image, dlib.rectangle(x, y, x + w, y +
h))

carTracker[currentCarID] = tracker
carLocation1[currentCarID] = [x, y, w, h]

currentCarID = currentCarID + 1
 21

for carID in carTracker.keys():

trackedPosition = carTracker[carID].get_position()

t_x = int(trackedPosition.left())
t_y = int(trackedPosition.top())
t_w = int(trackedPosition.width())
t_h = int(trackedPosition.height())

cv2.rectangle(resultImage, (t_x, t_y), (t_x + t_w, t_y + t_h), rectangleColor,

4)

# speed estimation
carLocation2[carID] = [t_x, t_y, t_w, t_h]

end_time = time.time()

if not (end_time == start_time):

fps = 1.0/(end_time - start_time)

#cv2.putText(resultImage, 'FPS: ' + str(int(fps)), (620,

30),cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2)

for i in carLocation1.keys():
if frameCounter % 1 == 0:
[x1, y1, w1, h1] = carLocation1[i]
[x2, y2, w2, h2] = carLocation2[i]

# print 'previous location: ' + str(carLocation1[i]) + ', current

location: ' + str(carLocation2[i])
carLocation1[i] = [x2, y2, w2, h2]

# print 'new previous location: ' + str(carLocation1[i])

if [x1, y1, w1, h1] != [x2, y2, w2, h2]:
 22

if (speed[i] == None or speed[i] == 0) and y1 >= 275 and

y1 <= 285:
speed[i] = estimateSpeed([x1, y1, w1, h1], [x2,
y2, w2, h2])

#if y1 > 275 and y1 < 285:

if speed[i] != None and y1 >= 180:
cv2.putText(resultImage, str(int(speed[i])) + "
km/hr", (int(x1 + w1/2), int(y1-5)),cv2.FONT_HERSHEY_SIMPLEX, 0.75, (255, 255, 255), 2)

#print ('CarID ' + str(i) + ': speed is ' + str("%.2f" %

round(speed[i], 0)) + ' km/h.\n')

#else:
# cv2.putText(resultImage, "Far Object", (int(x1 +
w1/2), int(y1)),cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)

#print ('CarID ' + str(i) + ' Location1: ' +

str(carLocation1[i]) + ' Location2: ' + str(carLocation2[i]) + ' speed is ' + str("%.2f" %
round(speed[i], 0)) + ' km/h.\n')
cv2.imshow('result', resultImage)
# Write the frame into the file 'output.avi'
#out.write(resultImage)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

cv2.destroyAllWindows()

if __name__ == '__main__':
trackMultipleObjects()