domaci3_17_263

March 1, 2021

0.1 Digitalna obrada slike - treći domaći

0.1.1 Student: Katarina Ristić 0263/2017

[ ]: from pylab import *

%matplotlib inline
import imageio
import numpy
import time

from ipywidgets import interact, interactive, fixed, interact_manual

import ipywidgets as widgets

import skimage #scikit-image

from skimage import *

from skimage.color import *
from skimage.exposure import *
from skimage.filters import *

import scipy
from scipy import ndimage
from scipy import *
from pylab import *

0.1.2 Zadatak 1

U zadatku 1 potrebno je izvršiti segementaciju slike tako da izlazna slika ima izdvojene kolovozne
trake u beloj boji a ostatak slike treba da bude crne boje. Za segmentaciju slike korišćen je HSV
model boja. Kreirana je maska istih dimenzija kao i ulazna slika u kojoj vrednost 1 imaju oni
pikseli čiji intenziteti odgovaraju potrebnoj nijansi žute i beloj boji. Nakon što primenimo masku
možemo primetiti regione slike koji sadrže neki šum nalik ”so i biber” šumu koji smo probali da
uklonimo tako što smo izvršili medijan filtriranje. Za veličinu medijan filtra uzeta je vrednost 4.
Isprobavanjem je utvrđeno da ukoliko uzemomo veći medijan, neke slike će biti lepše segmentovane
ali ćemo na nekim drugim slikama izgubiti region od značaja.

1
[6]: #zadatak 1
def segment_lanes(img_in):
from scipy import ndimage, misc
import matplotlib.pyplot as plt
fig = plt.figure(figsize=[20,20])
#ucitavamo sliku, prebacimo je u opseg od 0 do 1
ax1 = fig.add_subplot(131) # prikazemo ulaznu sliku
ax1.imshow(img_in)
ax1.set_title('Ulazna slika')
ax1.axis('off')

img_in= img_in/max(img_in.flatten())

#napravimo matricu istog oblika kao img_in u koju smestamo hsv sliku
img_hsv = zeros(shape(img_in));
img_hsv = matplotlib.colors.rgb_to_hsv(img_in)
M,N,k = shape(img_hsv)

##izdvojimo prvu,drugu i trecu dimenziju hsv slike u zasebne matrice

hplane = img_hsv[:,:,0]
splane = img_hsv[:,:,1]
vplane = img_hsv[:,:,2]

mask = np.zeros(shape = [M,N])

#odredimo parametre maske
mask [ (hplane>0.1)&(hplane<0.18)&(vplane>0.75)] = 1
mask [(splane<0.1)&(vplane>0.9)] = 1
mask [mask>0] = 1
g = mask

ax1 = fig.add_subplot(132) # prikazemo izdvojene regione bez medijan filtra

ax1.imshow(g, cmap ='gray')
ax1.set_title('Segmentacija bez medijan filtra')
ax1.axis('off')

#medijan filtriranje
from scipy import ndimage, misc
import matplotlib.pyplot as plt

result = ndimage.median_filter(g, size=4)

ax1 = fig.add_subplot(133) # prikazemo izdvojene regione bez medijan filtra

ax1.imshow(result, cmap ='gray')
ax1.set_title('Segmentacija nakon primene medijan filtra')
ax1.axis('off')
plt.show()
return result

2
[7]: #primenimo funkciju segment_lanes() na svih 6 frejmova

frame1= imageio.imread('../sekvence/test1.jpg')
result1=segment_lanes(frame1)

frame2= imageio.imread('../sekvence/test2.jpg')
result2=segment_lanes(frame2)

frame3= imageio.imread('../sekvence/test3.jpg')
result3=segment_lanes(frame3)

frame4= imageio.imread('../sekvence/test4.jpg')
result4=segment_lanes(frame4)

frame5= imageio.imread('../sekvence/test5.jpg')
result5=segment_lanes(frame5)

frame6= imageio.imread('../sekvence/test6.jpg')
result6=segment_lanes(frame6)

3
0.1.3 Zadatak 2

U drugom zadatku detektovanje ivica izvršeno je primenom Kanijevog algoritma sprovođenjem

potrebnih koraka. * Korak 1 Primena Gausovog filtra: korišćenjem Gausovog filtra uklanjamo šum
i time dobijamo lepšu sliku za dalju obradu * Korak 2 Odrediti gradijente po x i y osi: Korišćenjem
Sobelovog operatora i primenom korelacije izračunali smo vertikalni i horizontalni gradijent slike.
* Korak 3 Odrediti magnitudu i ugao gradijenta: Magnituda gradijenta jednaka je kvadratnom
korenu zbira kvadrata horizontalnog i vertikalnog gradijenta. Prilikom određivanja ugla korišćena
je arctan funkcija koja daje uglove u opsegu od -pi/2 do pi/2 i ne vodi račun o eventualno nultoj
vrednsoti u imeniocu. Kako bismo izbegli nulu u imeniocu potrebno je dodefinisati funkciju tako
da opseg uglova bude od pi do pi. * Korak 4 Kvantizacija gradijenta na jedan od četiri pravca:
0,45,90,-45
* Korak 5 Potiskivanje vrednosti gradijenta koji ne predstavaljuju lokalne maksimume: potiskivanje
je izvršeno tako što smo u pravcu normalnom na pravac gradijenta proveravali da li je intenzitet
piksela pozicioniranog pre ili posle piksela koga ispitujemo veći od njegovog intenziteta. Ukoliko
piksel jeste lokalni maksimum on se sadržava, ukoliko nije odbacuje se. * Korak 6 i 7 Određivanje
mapa jakih i slabih ivica i njihovo povezivanje: Pikseli matrice gradijenta se upoređuju sa vrednošću
višeg i nižeg praga. Ukoliko piksel ima vrednost ispod donje granice on se odbacuje. Pikseli koji
imaju vrednosti između granica smeštaju se u matricu slabih ivica. Jaka ivica je onaj element

4
 matrice slabih ivica koji u svom susedstvu jaku ivicu, ostali se odbacuju.
[23]: # zadatak 2
# kanijev algoritam

def canny_edge_detection(img_in,sigma,treshold_low,treshold_high):

#KORAK 1: GAUSOV FILTAR

img_in = skimage.img_as_float(img_in)
################################################################
truncate = sigma*6-1
img_gauss = skimage.filters.gaussian(img_in, sigma=sigma, truncate=truncate/
,→sigma)

################################################################

#KORAK 2: ODREDJIVANJE HORIZONTALNIH I VERTIKALNIH GRADIJENATA

###############################################################
Hx = np.array([[-1, -2, -1],[0, 0, 0],[1, 2, 1]])
# transponovanje matrice
Hy = Hx.transpose()
# izracunavanje vertikalnog i horizontalnog gradijenta slike
Gx = scipy.ndimage.correlate(img_gauss, Hx, mode='nearest')
Gy = scipy.ndimage.correlate(img_gauss, Hy, mode='nearest')
###############################################################

#KORAK 3: ODREDJIVANJE MAGNITUDE I UGLA GRADIJENTA

################################################################
# magnituda gradijenta
mag = np.sqrt(np.square(Gx) + np.square(Gy))
# ugao gradijenta
# ako koristimo np.arctan funkciju trebalo bi da obezbedimo
# da imenilac nije jednak 0 jer je za te tacke potrebno dodefinisati␣
,→funkciju

# Ukoliko to ne uradimo funkcija ce i dalje raditi ali ce davati upozorenja

# o deljenju sa nulom i nedozvoljenim vrednostim
# kreiramo Gx_fix matricu koja sadrzi 1 na mestima gde Gx ima nulu
Gx_fix = np.copy(Gx)
Gx_fix[Gx_fix==0] = 1
# funkcija np.arctan daje vrednosti ugla u opsegu -pi/2 do pi/2
# sto nam omogucava da odredimo pravac ali ne i smer gradijenta
angle = np.arctan(np.divide(Gy,Gx_fix))
# zatim resavamo slucajeve gde je Gx == 0
angle[(Gx==0)&(Gy>0)] = np.pi/2

5
 angle[(Gx==0)&(Gy<0)] = -np.pi/2
angle[(Gx==0) & (Gy==0)] = 0
angle = np.rad2deg(angle)
# funkcija np.arctan daje vrednosti ugla u opsegu -pi do pi
# i omogucava odredjivanje i smera gradijenta
angle2 = np.rad2deg(np.arctan2(Gy, Gx))
######################################################################

#KORAK 4: KVANTIZACIJA GRADIJENTA NA JEDAN OD 4 PRAVACA: 0,-45,45,90

######################################################################
angle[(angle>=-22.5) & (angle<22.5)]= 0
angle[(angle>=22.5) & (angle<67.5)] = 45
angle[(angle>=67.5) & (angle< - 67.5)] = 90
angle[(angle>=-67.5) & (angle<-22.5)] = -45
######################################################################

#KORAK 5: POTISKIVANJE VREDNOSTI GRADIJENATA KOJI NE PREDSTAVLJAJU LOKALNE␣

,→MAKSIMUME

###########################################################
M, N = shape(img_in)
maximum = np.zeros(shape = [M,N])

for i in range(1,M-1):
for j in range(1,N-1):

q = 1
r = 1

#angle -45
if (angle[i,j] == -45):
q = mag[i-1, j+1]
r = mag[i+1, j-1]

#angle 0
elif (angle[i,j] == 0):
q = mag[i+1, j]
r = mag[i-1, j]
#angle 90
elif (angle[i,j] == 90):
q = mag[i, j+1]
r = mag[i, j-1]
#angle 45
elif ( angle[i,j] == 45):
q = mag[i-1, j-1]
r = mag[i+1, j+1]

6
 if (mag[i,j] >= q) and (mag[i,j] >= r):
maximum[i,j] = mag[i,j]
else:
maximum[i,j] = 0;

#######################################################

#KORAK 6: ODREDJIVANJE MAPA JAKIH I SLABIH IVICA

jaka = np.zeros(shape= [M,N])

slaba = np.zeros(shape= [M,N])
jaka[maximum>=treshold_high] = 1
slaba[(maximum<treshold_high) & (maximum>=treshold_low)] = 1

#KORAK 7 povezivanje jakih i slabih piksela pomocu ugla gradijenta

for k in range (0,1):
for i in range (1,M-1):
for j in range (1,N-1):

if(slaba[i,j] == 1):
# 0 stepeni
if(angle[i,j]==0):
q = jaka[i+1, j]
r = jaka[i-1, j]
#45 stepeni
if(angle[i,j]==45):
q = jaka[i-1, j-1]
r = jaka[i+1, j+1]
#90 stepeni
if(angle[i,j]==90):
q = jaka[i, j+1]
r = jaka[i, j-1]
#-45 stepeni
if(angle[i,j]==-45):
q = jaka[i-1, j+1]
r = jaka[i+1, j-1]
if (q == 1) or (r == r):
jaka[i,j] = 1
else:
jaka[i,j] = 0

return img_gauss,mag,angle,maximum,jaka

7
 0.1.4 Zadatak 2

Prikaz rezultata za sigma=12, treshold_low=0.03 i treshold_high = 0.7.

[223]: # zadatak 2
#plotovanje rezultata z
#print(shape(result1))
img_gauss,mag,angle,maximum,jaka = canny_edge_detection(result1,12,0.03,0.7)

fig=plt.figure(figsize=(20,20), dpi=80)
plt.subplots_adjust(bottom=0.5, hspace = 0.6)
ax1=fig.add_subplot(121)
ax1.imshow(img_gauss, cmap='gray')
ax1.set_title('Ulaz nakon Gausovog filtriranja',fontsize=16)
ax1.axis('off')

fig=plt.figure(figsize=(20,20), dpi=80)
ax1=fig.add_subplot(111)
magnituda=ax1.imshow(mag, cmap='gray')
figure.colorbar(magnituda, ax=ax1, fraction=0.03, pad=0.04)
ax1.set_title('Magnituda gradijenta',fontsize=24)
ax1.axis('off')

fig=plt.figure(figsize=(20,20), dpi=80)
ax1=fig.add_subplot(111)
ugao=ax1.imshow(angle, cmap='jet')
figure.colorbar(ugao, ax=ax1, fraction=0.03, pad=0.04)
ax1.set_title('Ugao gradijenta',fontsize=24)
ax1.axis('off')

fig=plt.figure(figsize=(20,20), dpi=80)
ax1=fig.add_subplot(111)
ax1.imshow(maximum, cmap='gray')
ax1.set_title('Magnituda gradijent nakon potiskivanja lokalnih␣
,→nemaksimuma',fontsize=24)

ax1.axis('off')

matplotlib.pyplot.tight_layout()

fig=plt.figure(figsize=(20,20), dpi=80)
ax1=fig.add_subplot(121)
ax1.imshow(jaka, cmap='gray')
ax1.set_title('Detektovane ivice ',fontsize=24)

8
ax1.axis('off')

plt.show()

(720, 1280)

9
10
[228]: img_gauss,mag,angle,maximum,jaka = canny_edge_detection(result1,12,0.03,0.7)

fig=plt.figure(figsize=(20,20), dpi=80)
plt.subplots_adjust(bottom=0.5, hspace = 0.6)
ax1=fig.add_subplot(121)
ax1.imshow(jaka, cmap='gray')
ax1.set_title('Izdvojene ivice frame1',fontsize=16)
ax1.axis('off')

img_gauss,mag,angle,maximum,jaka = canny_edge_detection(result2,12,0.03,0.7)

fig=plt.figure(figsize=(20,20), dpi=80)
plt.subplots_adjust(bottom=0.5, hspace = 0.6)
ax1=fig.add_subplot(121)
ax1.imshow(jaka, cmap='gray')
ax1.set_title('Izdvojene ivice frame2',fontsize=16)
ax1.axis('off')

img_gauss,mag,angle,maximum,jaka = canny_edge_detection(result3,12,0.03,0.7)

fig=plt.figure(figsize=(20,20), dpi=80)
plt.subplots_adjust(bottom=0.5, hspace = 0.6)
ax1=fig.add_subplot(121)
ax1.imshow(jaka, cmap='gray')
ax1.set_title('Izdvojene ivice frame3',fontsize=16)

11
 ax1.axis('off')

img_gauss,mag,angle,maximum,jaka = canny_edge_detection(result4,12,0.03,0.7)

fig=plt.figure(figsize=(20,20), dpi=80)
plt.subplots_adjust(bottom=0.5, hspace = 0.6)
ax1=fig.add_subplot(121)
ax1.imshow(jaka, cmap='gray')
ax1.set_title('Izdvojene ivice frame4',fontsize=16)
ax1.axis('off')

img_gauss,mag,angle,maximum,jaka = canny_edge_detection(result5,12,0.03,0.7)

fig=plt.figure(figsize=(20,20), dpi=80)
plt.subplots_adjust(bottom=0.5, hspace = 0.6)
ax1=fig.add_subplot(121)
ax1.imshow(jaka, cmap='gray')
ax1.set_title('Izdvojene ivice frame5',fontsize=16)
ax1.axis('off')

img_gauss,mag,angle,maximum,jaka = canny_edge_detection(result6,12,0.03,0.7)

fig=plt.figure(figsize=(20,20), dpi=80)
plt.subplots_adjust(bottom=0.5, hspace = 0.6)
ax1=fig.add_subplot(121)
ax1.imshow(jaka, cmap='gray')
ax1.set_title('Izdvojene ivice frame6',fontsize=16)
ax1.axis('off')

[228]: (-0.5, 1279.5, 719.5, -0.5)

12
13
14
15
 0.1.5 Zadatak 3

Potrebno je napisati funkciju koja će na osnovu prosleđenih ivica iscrtati odgovarajuće duži. Na
osnovu ulaznih parametara rho i theta korišćenjem funkcije polar_to_XY dobijamo jednačinu u xy
domenu. Funkcija vraća koordinantni početak i dve tačke na toj pravoj. Potrebno je da iteriramo
kroz sve vrednosti x i da ispitujemo da li se u lokalnom susedstvu elementa matrice nalazi neki ivični
piksel. Prvi ivični piksel je prva tačka duži itd. Poslednja tačka duži je ona koja ima rastojanje od
susedne tačke veće od maksimalne dužine prekida i čija prethodna sekvenca zadovoljava minimalnu
potrebnu dužinu duži.
[25]: def polar_to_XY(img_edges,line):
origin = np.array((0, img_edges.shape[1]))
y0, y1 = (line[0] - origin * np.cos(line[1])) / np.sin(line[1])
x0, x1 = (line[0] - origin * np.sin(line[1])) / np.cos(line[1])
return origin,y0,y1,x0,x1

[48]: def proveraSusedstva(img,x,y, tolerancy):

edges = np.pad(img, pad_width=((tolerancy,tolerancy) ,␣
,→(tolerancy,tolerancy)), mode='edge')

k = 0
for i in range(x-tolerancy, x+tolerancy+1):
for j in range(y-tolerancy,y+tolerancy+1):
k=k+1
if(edges[i,j] == 1):
return True
return False

[248]: def get_line_segments(img_edges, line, min_size, max_gap, tolerancy):

M, N = shape(img_edges)
origin,y0_pom,y1_pom,x0_pom,x1_pom = polar_to_XY (img_edges,line)

koeficijent = (y1_pom-y0_pom)/(origin[1]-origin[0])

line_segments = []

prvaTacka = (-1,-1)
poslednjaTacka = (0,0)
if(koeficijent<0): # posmatram levu liniju
#ispitujemo da li su koordinate van dimenzija slike
if(y0_pom>M):
y2 = int(M)
x2 = int(abs((y0_pom-M)/koeficijent));

else:
y2 = int(y0_pom)
x2 = 0;

16
 if(x0_pom>N):
x1 = int(N)
else:
x1 = int(x0_pom)

if(y1_pom<0):
y1 = 0;
else:
y1 = int(y1_pom)

duzina_duzi = 0
prekid = 0

for i in range (x2,x1): #prolazimo kroz sve x

Y = y1+koeficijent*(i - x1) #jednacina prave kroz dve tacke

Y = int(Y)
img_edges[Y-1,i] = 0
if(proveraSusedstva(img_edges,Y,i,tolerancy) == True):
if(prvaTacka ==(-1,-1)):
prekid=0
duzina_duzi = 0
prvaTacka = (i,Y)#nova prva tacka na duzi
if(prekid <= max_gap):#proverimo da li je dostignuta max␣
,→velicina prekida

duzina_duzi = duzina_duzi+1
prekid = 0

continue
elif(prvaTacka !=(-1,-1)):#nema ivice u susedstvu
prekid = prekid+1#uvecava trenutnu duzinu prekida
if((prekid > max_gap)):#da li je prekid veci od max dozvoljenog
if(duzina_duzi>min_size):#da li imamo min duzinu duzi
poslednjaTacka = (i,Y)
segment = (prvaTacka,poslednjaTacka)
line_segments.append(segment)
duzina_duzi = 0
prekid = 0
prvaTacka=(-1,-1)
poslednjaTacka=(0,0)
else:
duzina_duzi = 0
prekid = 0
prvaTacka=(-1,-1)
poslednjaTacka=(0,0)

17
prvaTacka = (0,0)
poslednjaTacka = (0,0)
if(koeficijent>0): #desna linija
if(y1_pom>M):
x2 =int( N - abs((y1_pom-M)/koeficijent));
y2 = int(M)
else:
y2 = int(y1_pom);
x2 = int(N)
if(x0_pom<0):
if(y0_pom>0):
x1 = 0;
y1 = int(y0_pom)
else:
x1 = int(abs((y0_pom/koeficijent)));
y1 = 0

duzina_duzi = 0
prekid = 0

for i in range (x1,x2):

Y = int(y1+koeficijent*(i - x1))
if(proveraSusedstva(img_edges,Y,i,tolerancy) == True):
if(prvaTacka ==(0,0)):
prvaTacka = (i,Y)
prekid=0
if(prekid <= max_gap):
duzina_duzi = duzina_duzi+1
prekid = 0

elif( prvaTacka !=(0,0)):

prekid = prekid+1
if((prekid > max_gap)):
if(duzina_duzi>min_size):
poslednjaTacka = (i,Y)
segment = (prvaTacka,poslednjaTacka)
line_segments.append(segment)
prvaTacka = (0,0)
poslednjaTacka =(3,3)
duzina_duzi = 0
prekid = 0
else:

18
 duzina_duzi = 0;
prekid = 0;
prvaTacka = (0,0)
poslednjaTacka =(0,0)
i = i+1
if(i == x2):#ukoliko petlja dosla do kraja
if( duzina_duzi> min_size ): #detektovana je neka duz duza od␣
,→min dozvoljene

poslednjaTacka = (i,Y)
segment = (prvaTacka,poslednjaTacka)
line_segments.append(segment)
duzina_duzi = 0;
prekid = 0;
prvaTacka = (0,0)
poslednjaTacka =(0,0)
else:
duzina_duzi = 0;
prekid = 0;
prvaTacka = (0,0)
poslednjaTacka =(0,0)

return line_segments

0.1.6 Iscrtavanje rezultata za svaki frame

[249]: left1 = (711.742, 0.907)

right1 = (-50.517, -1.047)
left2 = (732.749, 0.855)
right2 = (-96.533,-1.099)
left3 = (733.759, 0.944)
right3 = (-7.505,-1.012)
left4 = (719.744, 0.907)
right4 = (-95.532, -1.099)
left5 = (707.740, 1.012)
right5 = (-16.515, -1.012)
left6 = (721.745, 0.942)
right6 = (-9.502, -1.029)

leva = [];
leva.append(left1)
leva.append(left2)
leva.append(left3)
leva.append(left4)
leva.append(left5)

19
leva.append(left6)

desna = [];
desna.append(right1)
desna.append(right2)
desna.append(right3)
desna.append(right4)
desna.append(right5)
desna.append(right6)

result = [];
result.append(result1)
result.append(result2)
result.append(result3)
result.append(result4)
result.append(result5)
result.append(result6)
fig, axes = plt.subplots(nrows=3, ncols=2, figsize = (20,20), dpi = 80)
ax = axes.ravel()
for i in range(0,6):
img_gauss,mag,angle,maximum,edges = canny_edge_detection(result[i],12, 0.
,→03, 0.7)

left = get_line_segments(edges,leva[i], min_size = 3, max_gap =␣

,→15,tolerancy = 10)

right = get_line_segments(edges,desna[i], min_size = 3, max_gap =␣

,→15,tolerancy = 8)

ax[i].imshow(edges, cmap = 'gray');

ax[i].set_axis_off()
ax[i].set_title("Frame" + str(i+1))
for j in range(0, len(left)):
ax[i].plot((left[j][0][0],left[j][1][0]),(left[j][0][1],left[j][1][1]),␣
,→'green')

for j in range(0, len(right)):

ax[i].
,→plot((right[j][0][0],right[j][1][0]),(right[j][0][1],right[j][1][1]),␣

,→'green')

20
 0.1.7 Zadatak 4

Funkcija lane_detection koja kao jedini ulazni argument prihvata sliku (jedan video frejm) i vraća
dva niza od po 4 elementa [xl1, yl1, xl2, yl2], [xr1, yr1, xr2, yr2] koji predstavljaju koordinate tačaka
koje jednoznačno određuju levu i desnu liniju trake u kojoj se automobil kreće. KOrišćenjem Hafove
transformacije za svaku tačku pronalaze se sve prave koje prolaze kroz tu tačku.
[239]: # cetvrti zadatak

def lane_detection(img_in):
img_in = skimage.img_as_float(img_in)

#korak 1: segmentacija

21
 img_segment = segment_lanes(img_in)

#korak 2: Kanijev algoritam:

img_gauss,mag,angle,maximum,img_edges =␣
,→canny_edge_detection(img_segment,12,0.03,0.7)
M,N = shape(img_edges)
#korak 3: Hafova transformacija
ang = np.array(double(list(range(-75, -45))))
ang = ang*np.pi/180
[out, angles, distances] = skimage.transform.hough_line(img_edges,theta=ang)
[intensity, peak_angles, peak_distances] = skimage.transform.
,→hough_line_peaks(out, angles, distances, threshold=None, num_peaks=1)

if(len(peak_angles)>0):
dist = peak_distances[len(peak_distances)-1]
ang = peak_angles[len(peak_angles)-1]
line = (dist, ang)
M,N = shape(img_edges)
origin,y0_pom,y1_pom,x0_pom,x1_pom = polar_to_XY (img_edges,line)
koeficijent = (y1_pom-y0_pom)/(origin[1]-origin[0])
x2 = int(N - abs((y1_pom-M)/koeficijent));
y2 = int(M)
y1 = 500;
x1 = int((y1 -y2 + koeficijent*x2)/koeficijent)
right = [];
tacka1 = (x2,y2)
tacka2 = (x1,y1)
right.append(tacka1)
right.append(tacka2)
else:
right = [(0,0),(0,M)]
ang = np.array(double(list(range(45, 75))))
ang = ang*np.pi/180
[out, angles, distances] = skimage.transform.hough_line(img_edges,theta=ang)
[intensity, peak_angles, peak_distances] = skimage.transform.
,→hough_line_peaks(out, angles, distances, threshold=None, num_peaks=1)

if(len(peak_angles)>0):
dist = peak_distances[len(peak_distances)-1]
ang = peak_angles[len(peak_angles)-1]
line = (dist, ang)
M,N = shape(img_edges)
origin,y0_pom,y1_pom,x0_pom,x1_pom = polar_to_XY (img_edges,line)
koeficijent = (y1_pom-y0_pom)/(origin[1]-origin[0])
x2 = int(N - abs((y1_pom-M)/koeficijent));
y2 = int(M)

22
 y1 = 500;
x1 = int((y1 -y2 + koeficijent*x2)/koeficijent)
left = []
tacka1 = (x2,y2)
tacka2 = (x1,y1)
left.append(tacka1)
left.append(tacka2)
else:
left = [(0,0),(0,M)]
return left,right

0.1.8 Zadatak 4-prikaz konačnih rezultata

[241]: img = imread('../sekvence/test1.jpg')

left, right = lane_detection(img)

fig=plt.figure( figsize=[20,20])

ax1=fig.add_subplot(111)
ax1.imshow(img, cmap='gray')
ax1.set_title('Konacna detekcija kolovoznih traka'), ax1.axis('off')
ax1.plot((left[0][0],left[1][0]), (left[0][1],left[1][1]),'red')
ax1.plot((right[0][0],right[1][0]), (right[0][1],right[1][1]),'red')

plt.show()

23
[247]: img3 = imread('../sekvence/test2.jpg')
left3, right3 = lane_detection(img3)
fig=plt.figure( figsize=[20,20])
ax1=fig.add_subplot(111)
ax1.imshow(img, cmap='gray')
ax1.set_title('Konacna detekcija kolovoznih traka'), ax1.axis('off')
ax1.plot((left3[0][0],left3[1][0]), (left3[0][1],left3[1][1]),'red')
ax1.plot((right3[0][0],right3[1][0]), (right3[0][1],right3[1][1]),'red')

[247]: [<matplotlib.lines.Line2D at 0x7f5661fd01d0>]

24
[243]: img3 = imread('../sekvence/test3.jpg')
left3, right3 = lane_detection(img3)
fig=plt.figure( figsize=[20,20])
ax1=fig.add_subplot(111)
ax1.imshow(img, cmap='gray')
ax1.set_title('Konacna detekcija kolovoznih traka'), ax1.axis('off')
ax1.plot((left3[0][0],left3[1][0]), (left3[0][1],left3[1][1]),'red')
ax1.plot((right3[0][0],right3[1][0]), (right3[0][1],right3[1][1]),'red')

[243]: [<matplotlib.lines.Line2D at 0x7f5664d2bcc0>]

25
[244]: img3 = imread('../sekvence/test4.jpg')
left3, right3 = lane_detection(img3)
fig=plt.figure( figsize=[20,20])
ax1=fig.add_subplot(111)
ax1.imshow(img, cmap='gray')
ax1.set_title('Konacna detekcija kolovoznih traka'), ax1.axis('off')
ax1.plot((left3[0][0],left3[1][0]), (left3[0][1],left3[1][1]),'red')
ax1.plot((right3[0][0],right3[1][0]), (right3[0][1],right3[1][1]),'red')

[244]: [<matplotlib.lines.Line2D at 0x7f5661e56a58>]

26
[245]: img3 = imread('../sekvence/test5.jpg')
left3, right3 = lane_detection(img3)
fig=plt.figure( figsize=[20,20])
ax1=fig.add_subplot(111)
ax1.imshow(img, cmap='gray')
ax1.set_title('Konacna detekcija kolovoznih traka'), ax1.axis('off')
ax1.plot((left3[0][0],left3[1][0]), (left3[0][1],left3[1][1]),'red')
ax1.plot((right3[0][0],right3[1][0]), (right3[0][1],right3[1][1]),'red')

[245]: [<matplotlib.lines.Line2D at 0x7f5662039a90>]

27
[246]: img3 = imread('../sekvence/test6.jpg')
left3, right3 = lane_detection(img3)
fig=plt.figure( figsize=[20,20])
ax1=fig.add_subplot(111)
ax1.imshow(img, cmap='gray')
ax1.set_title('Konacna detekcija kolovoznih traka'), ax1.axis('off')
ax1.plot((left3[0][0],left3[1][0]), (left3[0][1],left3[1][1]),'red')
ax1.plot((right3[0][0],right3[1][0]), (right3[0][1],right3[1][1]),'red')

[246]: [<matplotlib.lines.Line2D at 0x7f56523cbe48>]

28
[ ]:

29