def generate_image():
global counter, add, substract
img = np.zeros((height, width, 3), np.uint8)
for i in range(len(objs)):
obj = objs[i]
obj['x'] += 1
if i % 2 == 0:
obj['y'] += 1
xc = obj['x']
yc = obj['y']
dist, pnt = pnt2line((xc, yc), line1[0], line1[1])
# cv2.line(img, pnt, (xc, yc), (0, 255, 25), 1)
c = (255, 25, 160)
if (dist < 5):
c = (0, 255, 160)
if obj['pass1'] == False:
obj['pass1'] = True
counter += 1
substract += obj['label']
# cv2.circle(img, (xc,yc), 16, c, 1)
if (yc < height - 14 and yc > 14 and xc > 14 and xc < width - 14):
img[yc - 14:yc + 14, xc - 14:xc + 14, 0] = obj['img']
img[yc - 14:yc + 14, xc - 14:xc + 14, 1] = obj['img']
img[yc - 14:yc + 14, xc - 14:xc + 14, 2] = obj['img']
dist, pnt = pnt2line((xc, yc), line2[0], line2[1])
# cv2.line(img, pnt, (xc, yc), (0, 255, 25), 1)
c = (255, 25, 160)
if (dist < 5):
c = (0, 255, 160)
if obj['pass2'] == False:
obj['pass2'] = True
counter += 1
add += obj['label']
# cv2.circle(img, (xc,yc), 16, c, 1)
if (yc < height - 14 and yc > 14 and xc > 14 and xc < width - 14):
img[yc - 14:yc + 14, xc - 14:xc + 14, 0] = obj['img']
img[yc - 14:yc + 14, xc - 14:xc + 14, 1] = obj['img']
img[yc - 14:yc + 14, xc - 14:xc + 14, 2] = obj['img']
for i in range(50):
xc = random.randint(0, width)
yc = random.randint(0, height)
cv2.circle(img, (xc, yc), 1, (0, 255, 25), -1)
cv2.line(img, line1[0], line1[1], (255, 0, 0), 3)
cv2.line(img, line2[0], line2[1], (0, 255, 0), 3)
font = cv2.FONT_HERSHEY_COMPLEX
cv2.rectangle(img, (390, 5), (610, 50), (128, 128, 128), -1)
cv2.putText(img, 'add: ' + str(add) + 'sub: ' + str(substract), (300, 40),
font, 1, (90, 90, 255), 2)
return img
elements.append(elem)
elif nn == 1:
lst[0]['center'] = elem['center']
lst[0]['t'] = t
lst[0]['history'].append({
'center': (xc, yc),
'size': (dxc, dyc),
't': t
})
lst[0]['future'] = []
for el in elements:
tt = t - el['t']
if (tt < 3):
dist, pnt, r = pnt2line(el['center'], line[0], line[1])
c = (25, 25, 255)
if r > 0:
cv2.line(img, pnt, el['center'], (0, 255, 25), 1)
c = (25, 25, 255)
if (dist < 9): # 9
c = (0, 255, 160)
if el['pass'] == False:
el['pass'] = True
print el['center']
momenti.append(t)
counter += 1
prelazeci.append(el)
print t
def resenje(path):
cap = cv2.VideoCapture(path)
ret, firstFrame = cap.read()
blueLine = l.get_blue(firstFrame)
greenLine = l.get_green(firstFrame)
kernel = np.ones((2, 2), np.uint8)
lower = np.array([230, 230, 230])
upper = np.array([255, 255, 255])
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('images/output-rezB.avi', fourcc, 20.0, (640, 480))
elements = []
t = 0
counter = 0
times = []
while 1:
start_time = time.time()
ret, img = cap.read()
if ret == False:
break
# create NumPy arrays from the boundaries
lower = np.array(lower, dtype="uint8")
upper = np.array(upper, dtype="uint8")
mask = cv2.inRange(img, lower, upper)
img0 = 1.0 * mask
img0 = cv2.dilate(img0, kernel) # cv2.erode(img0,kernel)
img0 = cv2.dilate(img0, kernel)
labeled, nr_objects = ndimage.label(img0)
objects = ndimage.find_objects(labeled)
for i in range(nr_objects):
loc = objects[i]
(xc, yc) = ((loc[1].stop + loc[1].start) / 2,
(loc[0].stop + loc[0].start) / 2)
(dxc, dyc) = ((loc[1].stop - loc[1].start),
(loc[0].stop - loc[0].start))
(xc, yc) = (int(xc), int(yc))
(dxc, dyc) = (int(dxc), int(dyc))
cv2.circle(img, (xc, yc), 16, (25, 25, 255), 1)
if (dxc > 11 or dyc > 11):
cv2.circle(img, (xc, yc), 16, (25, 25, 255), 1)
elem = {'center': (xc, yc), 'size': (dxc, dyc), 't': t}
# find in range
lst = inRange(18, elem, elements)
nn = len(lst)
(x, y) = (loc[1].start, loc[0].start)
if nn == 0:
elem['id'] = nextId()
elem['t'] = t
elem['bluePass'] = False
elem['greenPass'] = False
pred = predict(img[y:y + dyc, x:x + dxc])
elem['history'] = [{
'center': (xc, yc),
'size': (dxc, dyc),
't': t,
'val': pred
}]
elem['value'] = pred
elements.append(elem)
elif nn == 1:
if (t % 1 == 0):
pred = predict(img[y:y + dyc, x:x + dxc])
else:
pred = -1
lst[0]['value'] = pred
lst[0]['center'] = elem['center']
lst[0]['t'] = t
lst[0]['history'].append({
'center': (xc, yc),
'size': (dxc, dyc),
't': t,
'val': pred
})
lst[0]['future'] = []
for el in elements:
tt = t - el['t']
if (tt < 3):
dist, pnt, r = pnt2line(el['center'], blueLine[0], blueLine[1])
c = (25, 25, 255)
if r > 0:
cv2.line(img, pnt, el['center'], (0, 255, 25), 1)
if (dist < 14):
c = (0, 255, 160)
if el['bluePass'] == False:
el['bluePass'] = True
valueHistory = [a['val'] for a in el['history']]
history = [a[0] for a in valueHistory if a != -1]
val = np.argmax(np.bincount(history))
counter += val
dist, pnt, r = pnt2line(el['center'], greenLine[1],
greenLine[0])
c = (25, 25, 255)
if r > 0:
cv2.line(img, pnt, el['center'], (0, 255, 25), 1)
if (dist < 14):
c = (0, 255, 160)
if el['greenPass'] == False:
el['greenPass'] = True
valueHistory = [a['val'] for a in el['history']]
history = [a[0] for a in valueHistory if a != -1]
val = np.argmax(np.bincount(history))
counter -= val
print('-' + str(val))
cv2.circle(img, el['center'], 16, c, 2)
id = el['id']
cv2.putText(img, str(el['id']),
(el['center'][0] + 10, el['center'][1] + 10),
cv2.FONT_HERSHEY_SIMPLEX, 1, 255)
# for hist in el['history']:
# ttt = t - hist['t']
# if (ttt < 100):
# cv2.circle(img, hist['center'], 1, (0, 255, 255), 1)
elapsed_time = time.time() - start_time
times.append(elapsed_time * 1000)
cv2.putText(img, 'Counter: ' + str(counter), (400, 90),
cv2.FONT_HERSHEY_SIMPLEX, 1, (90, 90, 255), 2)
# print nr_objects
t += 1
if t % 10 == 0:
print
t
# cv2.imshow('frame', img)
# k = cv2.waitKey(30) & 0xff
# if k == 27:
# break
# out.write(img)
out.release()
cap.release()
cv2.destroyAllWindows()
print(path)
# for el in elements:
# valueHistory = [a['val'] for a in el['history']]
# history = [a[0] for a in valueHistory if a != -1]
# val = np.argmax(np.bincount(history))
# if el['greenPass'] == True:
# counter -= val
# print('-' + str(val))
# if el['bluePass'] == True:
# counter += val
# print('-' + str(val))
print(counter)
et = np.array(times)
return counter
elements.append(elem)
elif nn == 1:
lst[0]['center'] = elem['center']
lst[0]['t'] = t
lst[0]['history'].append({
'center': (xc, yc),
'size': (dxc, dyc),
't': t
})
lst[0]['future'] = []
for el in elements:
tt = t - el['t']
if (tt < 3):
result1 = pnt2line(el['center'], line1[0], line1[1])
result2 = pnt2line(el['center'], line2[0], line2[1])
dist1 = result1[0]
dist2 = result2[0]
pnt1 = result1[1]
pnt2 = result2[1]
r1 = 0
r2 = 0
if (len(result1) > 2):
r1 = result1[2]
if (len(result2) > 2):
r2 = result2[2]
#cv2.line(img, pnt1, el['center'], (0, 255, 25), 1)
c = (25, 25, 255)
def main():
global jezgro
name = 'video-' + str(sys.argv[1]) + '.avi'
video = cv2.VideoCapture(name)
#video = cv2.VideoCapture('video-0.avi')
ret, frame = video.read()
shape = (28, 28, 1)
class_number = 10
klasifikator = neural_network_model(shape , class_number)
klasifikator.load_weights(''
'neuralModel.h5')
crvena = [6, 19, 216]
zelena = (0, 255, 0)
plava = (255, 153, 0)
frameNum = 0
allNum = [] # svi brojevi koji su bili na sceni
sum = 0
presao = True
nijePresao = False
kernel = jezgro
linija = detektujLiniju(cv2.morphologyEx(frame, cv2.MORPH_OPEN, kernel=kernel))
while ret:
ret, frame = video.read()
if not ret:
break
minTacka = linija[0]
maxTacka = linija[1]
konture = contoursOfNumbers(frame)
for kontura in konture:
cx, cy = centerOfPoints(kontura)
element = {'point': (cx, cy), 'brFrame': frameNum, 'history': []}
founded = detectNumbers(allNum, element)
if len(founded) == 0:
element['value'] = recognizeNumber(frame, kontura, klasifikator)
element['presaoLiniju'] = nijePresao
allNum.append(element)
elif len(founded) == 1:
i = founded[0]
histo = {'brFrame': frameNum, 'point': element['point']}
allNum[i]['history'].append(histo)
allNum[i]['brFrame'] = frameNum
allNum[i]['point'] = element['point']
#ispitujemo da li je linija predjena
for element in allNum:
subb = frameNum - element['brFrame']
rast = 3
if (subb > rast):
continue
if not element['presaoLiniju']:
distanca, _, r = vector.pnt2line(element['point'], minTacka, maxTacka)
if r == 1 and distanca < 11.0:
#saberi brojeve
brojevi = element['value']
sum += int(brojevi)
element['presaoLiniju'] = presao
cv2.circle(frame, element['point'], 18,crvena, 2)
cv2.putText(frame, str(element['value']), (element['point'][0] + 12, element['point'][1] + 12),
cv2.FONT_HERSHEY_SIMPLEX, 1,zelena, 3)
#Ispis teksta na ekranu
#===============================================================================
cv2.putText(frame,"Stefan Milovic RA164/2014", (15, 13), cv2.FONT_HERSHEY_SIMPLEX,
0.45, plava, 1)
text = 'Sum: '
cv2.putText(frame, text + str(sum), (15, 28), cv2.FONT_HERSHEY_SIMPLEX,
0.45,plava, 1)
text1 = 'Number of curent frame: '
cv2.putText(frame, text1 + str(frameNum), (15, 42), cv2.FONT_HERSHEY_SIMPLEX,
0.45,plava, 1)
for history in element['history']:
sub = frameNum - history['brFrame']
dis = 70
if (sub < dis):
cv2.circle(frame, history['point'], 1, (200, 200, 200), 1)
cv2.imshow('Frame', frame)
if cv2.waitKey(1) == 13:
break
counter = 1
frameNum += counter
cv2.destroyAllWindows()
video.release()
print ("Ukupan broj frejmova:", (frameNum))
print ("Ukupan zbir brojeva:", str(sum))
f = open('out.txt', 'a')
f.write('\n' + name + '\t' + str(sum))
f.close()
def main(filename):
video = cv2.VideoCapture(filename)
frmCount = 0
ukupnaSuma = 0
#ova lista predstavlja sve brojeve koji su bili na sceni
all = []
#stari nacin
#model = models.load_model('model.h5')
classifier = neur.napravi_model((28, 28, 1), 10)
classifier.load_weights('' 'model.h5')
linija = nadjiLiniju(filename)
print(linija)
minTacka = linija[0]
maxTacka = linija[1]
while True:
ret, frame = video.read()
if not ret:
break
lista_kontura = konture(frame)
#ovo je bilo za stari nacin
#kropovani = crop(frame, lista_kontura)
for kontura in lista_kontura:
(x, y, w, h) = kontura
xCenterDot = int(x + w / 2)
yCenterDot = int(y + h / 2)
xLeftDot = x
yLeftDot = y
xRightDot = x + w
yRightDot = y + h
#ovo ce biti recnik koji sadrzi koordinate trenutne konture
dictNumber = {
'dot': (xCenterDot, yCenterDot),
'frameNum': frmCount,
'previousStates': [],
'kontura': kontura
}
closeNumbers = nadjiBroj(all, dictNumber)
if len(closeNumbers) == 0:
# dodajemo nove key-value u recnik
# jos nije prosao liniju
dictNumber['presaoLiniju'] = False
# moramo ga dodati u listu poznatih brojeva
all.append(dictNumber)
#staro sto nije precizno
#dictNumber['value'] = predicted(model, kropovani)
kropovani = prepoznaj(kontura, frame, classifier)
dictNumber['value'] = kropovani
elif len(closeNumbers) == 1:
prev = {
'frameNum': frmCount,
'dot': dictNumber['dot'],
'kontura': dictNumber['kontura']
}
#posto je close numbers lista koja ima samo jedan element ovde uzmemo bas indeks broja za koji zelimo da azuriramo
all[closeNumbers[0]]['previousStates'].append(prev)
all[closeNumbers[0]]['frameNum'] = frmCount
all[closeNumbers[0]]['dot'] = dictNumber['dot']
all[closeNumbers[0]]['kontura'] = dictNumber['kontura']
#cv2.circle(frame, (xCenterDot, yCenterDot), 5, (0, 0, 255), -1)
cv2.putText(frame, "Trenutni video: " + str(videoName), (35, 40),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 255), 1)
cv2.putText(frame, "Suma: " + str(ukupnaSuma), (35, 80),
cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 255), 1)
for number in all:
(x, y, w, h) = number['kontura']
width = int(video.get(3))
height = int(video.get(4))
if x < width and y < height:
if number['presaoLiniju']:
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0),
2)
else:
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255),
2)
#for prev in number['previousStates']:
#if frmCount - prev['frameNum'] < 40:
#cv2.circle(frame, prev['dot'], 1, (0, 255, 255), 1)
#ako nije presao liniju racunamo udaljenost ako je blizu setujemo da je presao
if not number['presaoLiniju']:
distanca, _, r = vector.pnt2line(number['dot'], minTacka,
maxTacka)
if distanca < 10.0 and r == 1:
if not number['value'] == None:
ukupnaSuma += int(number['value'])
print(ukupnaSuma)
number['presaoLiniju'] = True
cv2.imshow("frame", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
frmCount += 1
video.release()
cv2.destroyAllWindows()
dopisiSumuUFajl(filename, ukupnaSuma)
def findObject(image):
global total
global i
global listaBr
global stap
global line
boundaries = [([230, 230, 230], [255, 255, 255])]
img_org = image.copy()
gray = cv2.cvtColor(img_org, cv2.COLOR_BGR2GRAY)
(lower, upper) = boundaries[0]
lower = np.array(lower, dtype="uint8")
upper = np.array(upper, dtype="uint8")
mask = cv2.inRange(image, lower, upper)
m = 1.0 * mask
img0 = m
img0 = cv2.dilate(img0, kernel) #cv2.erode(img0,kernel)
img0 = cv2.dilate(img0, kernel)
labeled, nr_objects = ndimage.label(img0)
objects = ndimage.find_objects(labeled)
if stap == 1:
line = houghTrans(gray, image)
stap = 2
x1 = line[0]
y1 = line[1]
x2 = line[2]
y2 = line[3]
for i in range(nr_objects):
loc = objects[i]
(xc, yc) = ((loc[1].stop + loc[1].start) / 2,
(loc[0].stop + loc[0].start) / 2)
(dxc, dyc) = ((loc[1].stop - loc[1].start),
(loc[0].stop - loc[0].start))
if (dxc > 10 or dyc > 10):
x = xc
y = yc
dx = dxc
dy = dyc
cv2.circle(image, (x, y), 16, (25, 25, 255), 1)
elem = {'center': (x, y), 'size': (dx, dy), 't': t}
lst = inRange(20, elem, elements)
nn = len(lst)
if nn == 0:
elem['id'] = nextId()
elem['t'] = t
elem['pass'] = False
elem['history'] = [{
'center': (xc, yc),
'size': (dxc, dyc),
't': t
}]
elem['number'] = None
elements.append(elem)
elif nn == 1:
lst[0]['center'] = elem['center']
lst[0]['t'] = t
lst[0]['history'].append({
'center': (xc, yc),
'size': (dxc, dyc),
't': t
})
for el in elements:
et = el['t']
tt = t - et
if (tt < 3):
if el['number'] is None:
a, b = findReg(img_org, el['center'])
br = returnNum(b)
if videoName == 'video/video-0.avi':
dist, pnt, r = pnt2line(el['center'], (x1, y1),
(x2 + 10, y2 - 8))
else:
dist, pnt, r = pnt2line(el['center'], (x1, y1), (x2, y2))
i = 0
if r > 0:
cv2.line(img_org, pnt, el['center'], (0, 255, 25), 1)
if (dist < 9):
if el['pass'] == False:
el['pass'] = True
total += br
#print('Broj %d' %br)
print('Suma %d' % total)
i += 1
def main():
prepare_out_file(student)
model = models.load_model('model.h5')
for i in range(0,10):
reset_id()
step = 1
# pomocni brojac
step_counter = 1
# Konacna suma brojeva koji su presli preko linija
sum = 0
elements = []
t = 0
counter = 0
times = []
# color filter koristi se za uklanje suma i linija u boji sa frejma
kernel = np.ones((3, 3), np.uint8)
lower = np.array([150, 150, 150])
upper = np.array([255, 255, 255])
video_file = video_path + video_name + str(i) + video_extension
print('Ucitava se %s' %(video_name + str(i)))
capture = cv2.VideoCapture(video_file)
# prvi frejm sa video snimka, koristi se kod pronalazenja linija
first_frame = capture.read()[1]
frame_number = 1
# Pronalazenje linija sa prvog frejma Houhg metodom
# lueLine, plava linija. sabiraju se brojevi koji prodju preko nje
# greenLine, zelena linija, oduzimaju se brojevi koji predju preko nje
blue_line, green_line = find_lines(first_frame)
# ovde otvara video
while(capture.isOpened()):
# cita jedan frejm video snimka
ret, frame = capture.read()
if ret == False:
break
# step_counter += 1
if step_counter != 1 or frame_number != 1:
if step_counter <= step:
step_counter += 1
frame_number += 1
continue
# print('Obradjujem frejm %s' % frame_number)
frame_number += 1
# ovde se radi obrada frejma
start_time = time.time()
lower = np.array(lower, dtype="uint8")
upper = np.array(upper, dtype="uint8")
mask = cv2.inRange(frame, lower, upper) #izdvaja samo brojeve sa frejma
#mask = cv2.dilate(mask, kernel)
#mask = cv2.erode(mask, kernel)
white_image = cv2.bitwise_and(frame, frame, mask=mask)
white_image = cv2.cvtColor(white_image, cv2.COLOR_BGR2GRAY)
binary_image = cv2.threshold(white_image, 1, 255, cv2.THRESH_BINARY)[1]
binary_image = cv2.dilate(binary_image, kernel)
contours, _ = cv2.findContours(binary_image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE,)
#cv2.putText(imgC2, 'Br Cont: ' + str(len(contours)), (450, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (90, 90, 255), 2)
frame = draw_line(frame, np.reshape(blue_line,(1,4)))
frame = draw_line(frame, np.reshape(green_line,(1,4)))
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)
xc = x + w//2
yc = y + h//2
dxc = w
dyc = h
if (dxc > 11 or dyc > 11) and (dxc < 28 and dyc < 28):
# cv2.circle(frame, (xc, yc), 14, (25, 25, 255), 1)
cv2.rectangle(frame, (xc - dxc//2, yc-dyc//2), (xc + dxc//2, yc+dyc//2), (0, 255, 0), 1)
elem = {'center': (xc, yc), 'size': (dxc, dyc), 't': t}
# find in range
lst = in_range(16, elem, elements)
nn = len(lst)
if nn == 0:
elem['id'] = next_id()
elem['t'] = t
elem['pass_blue'] = False
elem['pass_green'] = False
elem['history'] = [{'center': (xc, yc), 'size': (dxc, dyc), 't': t}]
elem['number'] = -1
elem['contours'] = []
contour_image = get_contour(white_image, elem['center'], elem['size'])
elem['contours'].append(contour_image)
elements.append(elem)
elif nn == 1:
lst[0]['center'] = elem['center']
lst[0]['t'] = t
lst[0]['history'].append({'center': (xc, yc), 'size': (dxc, dyc), 't': t})
contour_image = get_contour(white_image, elem['center'], elem['size'])
lst[0]['contour'] = contour_image
# Na odredjeni broj frejmova cuva sliku konture
if t % frame_num_get_contour == 0:
lst[0]['contours'].append(contour_image)
for el in elements:
tt = t - el['t']
if tt < 3:
dist_blue_line, pnt_blue, r_b = pnt2line(el['center'], blue_line[0], blue_line[1])
dist_green_line, pnt_green, r_g = pnt2line(el['center'], green_line[0], green_line[1])
cv2.line(frame, pnt_blue, el['center'], (255, 0, 0), 1)
cv2.line(frame, pnt_green, el['center'], (0, 255, 0), 1)
if r_b > 0:
if dist_blue_line < 8:
if not el['pass_blue']:
el['pass_blue'] = True
counter += 1
cv2.circle(frame, el['center'], 11, colors['blue'], 1)
contours = el['contours']
number = number_winner(contours, 10, model)
el['number'] = number
sum += number
if r_g > 0:
if dist_green_line < 8:
if not el['pass_green']:
counter += 1
el['pass_green'] = True
if not el['pass_blue']:
cv2.circle(frame, el['center'], 11, colors['green'], 1)
contours = el['contours']
number = number_winner(contours, 10, model)
el['number'] = number
else:
number = el['number']
sum -= number
id = el['id']
cv2.putText(frame, str(el['id']),
(el['center'][0] + 10, el['center'][1] + 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, colors['white'])
cv2.putText(frame, str(el['number']),
(el['center'][0] - 20, el['center'][1] + 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, colors['white'])
elapsed_time = time.time() - start_time
times.append(elapsed_time * 1000)
cv2.putText(frame, 'Suma: ' + str(sum), (450, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
# print nr_objects
t += 1
# resized = cv2.resize(frame, (1280, 960), interpolation=cv2.INTER_NEAREST)
cv2.imshow(video_name + str(i), frame)
if cv2.waitKey(25) & 0xFF == ord('q'):
break
capture.release()
cv2.destroyAllWindows()
write_result(video_name + str(i) + video_extension, sum)
print('Rezultat za ' + video_name + str(i) + video_extension + ' je ' + str(sum) + '\n\n')
def trackObjects(img, linesFinal, classifier):
start_time = time.time()
origImg = img.copy()
#(lower, upper) = boundaries[0]
# create NumPy arrays from the boundaries
global elements
global counter
global times
global subtract
global addition
global t
kernel = np.ones((2, 2), np.uint8)
lower = np.array([230, 230, 230])
upper = np.array([255, 255, 255])
lineAdd = linesFinal['add']
lineSub = linesFinal['sub']
lower = np.array(lower, dtype="uint8")
upper = np.array(upper, dtype="uint8")
mask = cv2.inRange(img, lower, upper)
img0 = 1.0 * mask
img0 = cv2.dilate(img0, kernel)
img0 = cv2.dilate(img0, kernel)
#cv2.imshow('proba', img0)
labeled, nr_objects = ndimage.label(img0)
objects = ndimage.find_objects(labeled)
for i in range(nr_objects):
loc = objects[i]
(xc, yc) = ((loc[1].stop + loc[1].start) / 2,
(loc[0].stop + loc[0].start) / 2)
(dxc, dyc) = ((loc[1].stop - loc[1].start),
(loc[0].stop - loc[0].start))
if (dxc > 10 or dyc > 10):
xc = int(xc)
yc = int(yc)
dxc = int(dxc)
dyc = int(dyc)
cv2.circle(img, (xc, yc), 16, (25, 25, 255), 1)
elem = {'center': (xc, yc), 'size': (dxc, dyc), 't': t}
# find in range
lst = inRange(20, elem, elements)
nn = len(lst)
if nn == 0:
elem['id'] = nextId()
elem['t'] = t
elem['passAdd'] = False
elem['passSub'] = False
elem['history'] = [{
'center': (xc, yc),
'size': (dxc, dyc),
't': t
}]
#elem['number'] = classify(origImg, (xc, yc), classifier)
elem['number'] = None
elem['future'] = []
elements.append(elem)
elif nn == 1:
lst[0]['center'] = elem['center']
lst[0]['t'] = t
lst[0]['history'].append({
'center': (xc, yc),
'size': (dxc, dyc),
't': t
})
lst[0]['future'] = []
for el in elements:
tt = t - el['t']
if (tt < 3):
####
if el['number'] is None:
el['number'] = classify(origImg, el['center'], classifier)
dist, pnt, r = pnt2line(el['center'], lineAdd[0], lineAdd[1])
c = None
passed = False
if r > 0:
passed = True
cv2.line(img, pnt, el['center'], (0, 255, 25), 1)
c = (25, 25, 255)
if (dist < 9):
c = (0, 255, 160)
if el['passAdd'] == False:
el['passAdd'] = True
counter += 1
addition += el['number']
addArray.append(el['number'])
#cv2.circle(img, el['center'], 16, c, 2)
dist, pnt, r = pnt2line(el['center'], lineSub[0], lineSub[1])
if r > 0:
passed = True
cv2.line(img, pnt, el['center'], (255, 25, 0), 1)
c = (25, 25, 255)
if (dist < 9):
c = (0, 255, 160)
if el['passSub'] == False:
el['passSub'] = True
counter += 1
subtract -= el['number']
subArray.append(el['number'])
if passed:
cv2.circle(img, el['center'], 16, c, 2)
id = el['id']
#####
if el['number'] is not None:
cv2.putText(img,
text=str(el['number']),
org=(el['center'][0] + 15, el['center'][1] + 20),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.6,
color=(0, 0, 255))
for hist in el['history']:
ttt = t - hist['t']
if (ttt < 100):
cv2.circle(img, hist['center'], 1, (0, 255, 255), 1)
for fu in el['future']:
ttt = fu[0] - t
if (ttt < 100):
cv2.circle(img, (fu[1], fu[2]), 1, (255, 255, 0), 1)
elapsed_time = time.time() - start_time
times.append(elapsed_time * 1000)
cv2.putText(img,
text='Add: ' + str(addition),
org=(480, 40),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.5,
color=(90, 90, 255))
cv2.putText(img,
text='Sub: ' + str(subtract),
org=(480, 60),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.5,
color=(90, 90, 255))
cv2.putText(img,
text='Sum: ' + str(addition + subtract),
org=(480, 80),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.5,
color=(90, 90, 255))
cv2.putText(img,
text='Counter: ' + str(counter),
org=(480, 100),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.5,
color=(90, 90, 255))
t += 1
def izdvojBrojeve(nazivVideo, x1z, y1z, x2z, y2z, x1p, y1p, x2p, y2p):
kernel = np.ones((2,2),np.uint8)
lower = np.array([230, 230, 230])
upper = np.array([255, 255, 255])
elements = []
t =0
counterZ = 0
counterP = 0
times = []
passedDigitsZ = []
passedDigitsP = []
cap = cv2.VideoCapture(nazivVideo)
while(cap.isOpened()):
ret, img = cap.read()
if ret:
#l = np.array(lower, dtype = "uint8")
#u = np.array(upper, dtype = "uint8")
#mask = cv2.inRange(img, l, u)
#img0 = 1.0*mask
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, img0 = cv2.threshold(gray, 167, 255, 0)
img0 = cv2.dilate(img0,kernel) #cv2.erode(img0,kernel)
img0 = cv2.dilate(img0,kernel)
labeled, nr_objects = ndimage.label(img0)
objects = ndimage.find_objects(labeled)
for i in range(nr_objects):
loc = objects[i]
(xc,yc) = ((loc[1].stop + loc[1].start)/2,
(loc[0].stop + loc[0].start)/2)
(dxc,dyc) = ((loc[1].stop - loc[1].start),
(loc[0].stop - loc[0].start))
if(dxc>11 or dyc>11):
cv2.circle(img, (xc,yc), 16, (25, 25, 255), 1)
elem = {'center':(xc,yc), 'size':(dxc,dyc), 't':t}
# find in range
lst = inRange(20, elem, elements)
nn = len(lst)
if nn == 0:
elem['id'] = nextId()
elem['t'] = t
elem['passZ'] = False
elem['passP'] = False
elem['history'] = [{'center':(xc,yc), 'size':(dxc,dyc), 't':t}]
elem['future'] = []
#img0 = cv2.erode(img0, np.ones((2,2),np.uint8))
#img0 = cv2.erode(img0, np.ones((2,2),np.uint8))
isecena = img0[yc-dyc/2 : yc+dyc/2, xc-dxc/2 : xc+dxc/2]
resized = cv2.resize(isecena, (28, 28))
#resized = cv2.erode(resized, np.ones((3,3),np.uint8))
resized = cv2.erode(resized, np.ones((4,4),np.uint8))
elem['digitContour'] = resized
elements.append(elem)
elif nn == 1:
lst[0]['center'] = elem['center']
lst[0]['t'] = t
lst[0]['history'].append({'center':(xc,yc), 'size':(dxc,dyc), 't':t})
lst[0]['future'] = []
for el in elements:
tt = t - el['t']
if(tt<3):
linijaZ = [(x1z,y1z), (x2z, y2z)]
distZ, pntZ, rZ = pnt2line(el['center'], linijaZ[0], linijaZ[1])
cz = (25, 25, 255)
if rZ>0:
cv2.line(img, pntZ, el['center'], (0, 255, 25), 1)
if(distZ<9):
cz = (0, 255, 160)
if el['passZ'] == False:
el['passZ'] = True
counterZ += 1
passedDigitsZ.append(el['digitContour'])
#cv2.circle(img, el['center'], 16, cz, 2)
id = el['id']
#cv2.putText(img, str(el['id']),
# (el['center'][0]+10, el['center'][1]+10),
# cv2.FONT_HERSHEY_SIMPLEX, 1, 255)
for hist in el['history']:
ttt = t-hist['t']
# if(ttt<100):
# cv2.circle(img, hist['center'], 1, (0, 255, 255), 1)
for fu in el['future']:
ttt = fu[0]-t
# if(ttt<100):
# cv2.circle(img, (fu[1], fu[2]), 1, (255, 255, 0), 1)
if(tt<3):
linijaP = [(x1p,y1p), (x2p, y2p)]
distP, pntP, rP = pnt2line(el['center'], linijaP[0], linijaP[1])
cp = (25, 25, 255)
if rP>0:
cv2.line(img, pntP, el['center'], (255, 0, 25), 1)
if(distP<9):
cp = (0, 255, 160)
if el['passP'] == False:
el['passP'] = True
counterP += 1
passedDigitsP.append(el['digitContour'])
#cv2.circle(img, el['center'], 16, cp, 2)
id = el['id']
#cv2.putText(img, str(el['id']),
# (el['center'][0]+10, el['center'][1]+10),
# cv2.FONT_HERSHEY_SIMPLEX, 1, 255)
for hist in el['history']:
ttt = t-hist['t']
# if(ttt<100):
# cv2.circle(img, hist['center'], 1, (0, 255, 255), 1)
for fu in el['future']:
ttt = fu[0]-t
# if(ttt<100):
# cv2.circle(img, (fu[1], fu[2]), 1, (255, 255, 0), 1)
#elapsed_time = time.time() - start_time
#times.append(elapsed_time*1000)
#cv2.putText(img, 'Z: '+str(counterZ), (100, 90), cv2.FONT_HERSHEY_SIMPLEX, 1,(90,90,255),2)
#cv2.putText(img, 'P: '+str(counterP), (400, 90), cv2.FONT_HERSHEY_SIMPLEX, 1,(90,90,255),2)
#print nr_objects
t += 1
#if t%10==0:
# print t
#cv2.imshow('bla', img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
else:
break
cap.release()
cv2.destroyAllWindows()
return passedDigitsZ, passedDigitsP
def obradi(self, image):
img_org = image.copy()
gray = cv2.cvtColor(img_org, cv2.COLOR_BGR2GRAY) #greyscale
if self.prviFrejm:
line = self.houghTrans(gray, image) #da detektuje liniju
self.prviFrejm = 1
#provjerava da li se elementi array matrice(image) nalaze izmedju elemenata dvaju drigih array matrica ili polja(dolje i gore)
mask = cv2.inRange(image, self.dolje, self.gore)
img = 1.0 * mask
img = cv2.dilate(
img, self.kernel
) #dilatiranje(sirenje slike) slike pomocu odredjenog elementa struktuiranja koji odredjuje
img = cv2.dilate(
img, self.kernel
) #oblik susjednih piksela preko kojih se uzima maksimum
labeled, nmbr_of_objects = ndimage.label(
img) #radi se labeliranje slike predstavljenog kao niz(array)
objects = ndimage.find_objects(
labeled) #pronalazenje objekata u labeliranom nizu
for i in range(nmbr_of_objects):
location = objects[i]
x1 = location[1].stop
y1 = location[1].start
xc = int((x1 + y1) / 2)
x2 = location[0].stop
y2 = location[0].start
yc = int((x2 + y2) / 2)
c1 = x1 - y1
c2 = x2 - y2
if (c1 > 10 or c2 > 10):
cv2.circle(image, (xc, yc), 16, (25, 25, 255), 1)
element = {'center': (xc, yc), 'size': (c1, c2)}
lista = self.da_li_le_u_Rasponu(element)
duzina = len(lista)
if duzina == 0:
self.id += 1
element['id'] = self.id
element['pass'] = False
xc1 = xc
yc1 = yc
element['history'] = [{
'center': (xc1, yc1),
'size': (c1, c2)
}]
element['future'] = []
element['number'] = None
self.elements.append(element)
elif duzina == 1:
lista[0]['center'] = element['center']
xc1 = xc
yc1 = yc
lista[0]['history'].append({
'center': (xc1, yc1),
'size': (c1, c2)
})
lista[0]['future'] = []
for el in self.elements:
if el['number'] is None:
b = self.selectReg(img_org, el['center'])
br = self.vratiBroj(b)
dist, pnt, greska = pnt2line(el['center'], (line[0], line[1]),
(line[2], line[3]))
erorr = greska
if erorr > 0:
if (dist < 9):
if el['pass'] == False:
el['pass'] = True
b = self.selectReg(img_org, el['center'])
brr = self.vratiBroj(b)
self.zbirBrojeva += brr
def findObject(image):
global stap
global sumaBrojeva
global line
global cc
global t
img_org = image.copy()
start_time = time.time()
gray = cv2.cvtColor(img_org, cv2.COLOR_BGR2GRAY)
if stap == 1:
line = houghTrans(gray, image)
stap = 2
mask = cv2.inRange(image, lower, upper)
img0 = 1.0 * mask
img0 = cv2.dilate(img0, kernel) #cv2.erode(img0,kernel)
img0 = cv2.dilate(img0, kernel)
labeled, nr_objects = ndimage.label(img0)
objects = ndimage.find_objects(labeled)
for i in range(nr_objects):
loc = objects[i]
a1 = loc[1].stop
b1 = loc[1].start
xc = (a1 + b1) / 2
a2 = loc[0].stop
b2 = loc[0].start
yc = (a2 + b2) / 2
c1 = a1 - b1
c2 = a2 - b2
dxc = c1
dyc = c2
if (dxc > 10 or dyc > 10):
cv2.circle(image, (xc, yc), 16, (25, 25, 255), 1)
elem = {'center': (xc, yc), 'size': (dxc, dyc), 't': t}
# find in range
lst = inRange(20, elem, elements)
nn = len(lst)
if nn == 0:
cc = cc + 1
elem['id'] = cc
elem['t'] = t
elem['pass'] = False
xc1 = xc
yc1 = yc
elem['history'] = [{
'center': (xc1, yc1),
'size': (dxc, dyc),
't': t
}]
elem['future'] = []
elem['number'] = None
elements.append(elem)
elif nn == 1:
lst[0]['center'] = elem['center']
lst[0]['t'] = t
xc1 = xc
yc1 = yc
lst[0]['history'].append({
'center': (xc1, yc1),
'size': (dxc, dyc),
't': t
})
lst[0]['future'] = []
for el in elements:
tt = t - el['t']
if (tt < 3):
if el['number'] is None:
a, b = selectReg(img_org, el['center'])
br = vratiBroj(b, loaded_model)
if nameVideo == 'video/video-0.avi':
a = line[0]
b = line[1]
c = line[2] + 10
d = line[3] - 8
dist, pnt, r = pnt2line(el['center'], (a, b), (c, d))
else:
dist, pnt, r = pnt2line(el['center'], (line[0], line[1]),
(line[2], line[3]))
passed = False
er = r
if er > 0:
passed = True
if (dist < 9):
if el['pass'] == False:
el['pass'] = True
a, b = selectReg(img_org, el['center'])
sumaBrojeva += br
#print('Suma %d' % sumaBrojeva)
elapsed_time = time.time() - start_time
times.append(elapsed_time * 1000)
t += 1
gray_labeled = label(img0)
regions = regionprops(gray_labeled)
for region in regions:
number = {'center': region.centroid, 'frame': frameNumber}
result = inRange(20, number, numbers)
if len(result) == 0:
number['id'] = nextId()
number['pass'] = False
numbers.append(number)
elif len(result) == 1:
result[0]['center'] = number['center']
result[0]['frame'] = frameNumber
for el in numbers:
t = frameNumber - el['frame']
if (t < 3):
dist, pnt, r = pnt2line(el['center'], begin, end)
if (r > 0):
if (dist < 6):
if el['pass'] == False:
el['pass'] = True
blok_size = (28, 28)
blok_center = el['center']
blok_loc = (blok_center[0] - blok_size[0] / 2,
blok_center[1] - blok_size[1] / 2)
imgB = img0[blok_loc[0]:blok_loc[0] + blok_size[0],
blok_loc[1]:blok_loc[1] + blok_size[1]]
imgB_test = imgB.reshape(784)
imgB_test = imgB_test / 255.
tt = model.predict(np.array([imgB_test]), verbose=1)
rez_t = tt.argmax(axis=1)
suma += rez_t[0]
'center': (xc, yc),
'size': (dxc, dyc),
't': t
})
lst[0]['future'] = []
for el in elements:
tt = t - el['t']
if tt >= 3:
continue
for le in range(
len(linesEndpoints)
): # [[(100, 200), (300, 400)], [(50, 100), (200, 300)]]
dist, pnt, r = pnt2line(el['center'], linesEndpoints[le][0],
linesEndpoints[le][1])
if r == -1:
continue
c = (25, 25, 255)
if dist >= 9:
continue
c = (0, 255, 160)
cv2.circle(img, el['center'], 16, c, 2)
if el['pass'][le] == True:
continue
elem['t'] = t
value = prepare_predict(frame1[y:y + dyc, x:x + dxc])
elem['history'] = [{
'center': (xc, yc),
'size': (dxc, dyc),
't': t,
'val': value
}]
elem['value'] = value
elem['future'] = []
elements.append(elem)
for el in elements:
tt = t - el['t']
if (tt < 3):
dist, pnt, r = pnt2line(el['center'], bline[0], bline[1])
c = (25, 25, 255)
if r > 0 and dist < 9:
c = (0, 255, 160)
if el['passB'] == False:
el['passB'] = True
# if (dist > 9 & el['passB'] == True):
c = (0, 255, 255)
valH = [i['val'] for i in el['history']]
h = [i[0] for i in valH]
counter += np.argmax(np.bincount(h))
cv2.circle(frame1, el['center'], 16, c, 2)
dist, pnt, r = pnt2line(el['center'], gline[0], gline[1])
c = (25, 25, 255)
if r > 0 and dist < 9:
def findPassedElements(videoName, Blueline, Greenline):
elements = []
t = 0
counterBlue = 0
counterGreen = 0
blueElements = []
greenElements = []
kernel = np.ones((2, 2), np.uint8)
cap = cv2.VideoCapture(videoName)
while (1):
ret, img = cap.read()
if ret == False:
break
img0 = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
ret, img0 = cv2.threshold(img0, 168, 255, cv2.THRESH_BINARY)
img0 = cv2.dilate(
img0, kernel
) # radimo 2 puta za redom dilataciju jer su neki brojevi tanje ispisani,
img0 = cv2.dilate(
img0, kernel) # pa ih ne registruje kada prodju preko linije
labeled, nr_objects = ndimage.label(img0)
objects = ndimage.find_objects(labeled)
for i in range(nr_objects):
loc = objects[i]
(xc, yc) = ((loc[1].stop + loc[1].start) / 2,
(loc[0].stop + loc[0].start) / 2)
(dxc, dyc) = ((loc[1].stop - loc[1].start),
(loc[0].stop - loc[0].start))
if (dxc > 11 or dyc > 11):
cv2.circle(img, (xc, yc), 16, (25, 25, 255), 1)
elem = {'center': (xc, yc), 'size': (dxc, dyc), 't': t}
# proverava da li ima jos elemenata u okolini trenutnog elementa
lst = inRange(
20, elem,
elements) # vraca listu nadjenih elemenata u okolini
nn = len(lst)
if nn == 0: # ako je lista prazna, znaci da je trenutni element novi, pa ga dodajemo
elem['id'] = nextId()
elem['t'] = t
elem['passBlue'] = False
elem['passGreen'] = False
elem['history'] = [{
'center': (xc, yc),
'size': (dxc, dyc),
't': t
}]
elem['future'] = []
img1 = cv2.erode(img0, kernel)
#img1 = cv2.erode(img1,kernel)
contour = img1[yc - dyc / 2:yc + dyc / 2,
xc - dxc / 2:xc + dxc / 2]
elem['img'] = cv2.resize(
contour,
(28, 28)) # cuvam za svaki element njegovu slicicu
elements.append(elem)
elif nn == 1: # ako u listi ima 1 element, znaci ta je to trenutni element iz proslog frejma
lst[0]['center'] = elem[
'center'] # pa mu menjamo koordinate ventra, broj frejma itd..
lst[0]['t'] = t
lst[0]['history'].append({
'center': (xc, yc),
'size': (dxc, dyc),
't': t
})
lst[0]['future'] = []
for el in elements:
tt = t - el['t']
if (tt < 3):
dist, pnt, r = pnt2line(el['center'], Blueline[0], Blueline[1])
if r > 0:
cv2.line(img, pnt, el['center'], (0, 255, 25), 1)
c = (25, 25, 255)
if (dist < 9):
c = (0, 255, 160)
if el['passBlue'] == False:
el['passBlue'] = True
counterBlue += 1
blueElements.append(el)
dist2, pnt2, r2 = pnt2line(el['center'], Greenline[0],
Greenline[1])
if r2 > 0:
cv2.line(img, pnt2, el['center'], (0, 255, 25), 1)
c = (25, 25, 255)
if (dist2 < 9):
c = (0, 255, 160)
if el['passGreen'] == False:
el['passGreen'] = True
counterGreen += 1
greenElements.append(el)
c = (25, 25, 255)
cv2.circle(img, el['center'], 16, c, 2)
id = el['id']
cv2.putText(img, str(el['id']),
(el['center'][0] + 10, el['center'][1] + 10),
cv2.FONT_HERSHEY_SIMPLEX, 1, 255)
for hist in el['history']:
ttt = t - hist['t']
if (ttt < 100):
cv2.circle(img, hist['center'], 1, (0, 255, 255), 1)
for fu in el['future']:
ttt = fu[0] - t
if (ttt < 100):
cv2.circle(img, (fu[1], fu[2]), 1, (255, 255, 0), 1)
cv2.putText(img, 'CounterBlue: ' + str(counterBlue), (380, 90),
cv2.FONT_HERSHEY_SIMPLEX, 1, (90, 90, 255), 2)
cv2.putText(img, 'CounterGreen: ' + str(counterGreen), (5, 90),
cv2.FONT_HERSHEY_SIMPLEX, 1, (90, 90, 255), 2)
t += 1
cv2.imshow('video', img)
k = cv2.waitKey(1) & 0xff
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
return blueElements, greenElements
