Mathesis Wiki

Bild von der Kamera einlesen:

capture= cv2.VideoCapture(0)  
res,bild=capture.read()

Bild in grau umwandeln:

bild_grau=cv2.cvtColor(bild,cv2.cv.CV_BGR2GRAY)

Kopie eines Bildes erstellen:

bild_kopie=bild.copy()

Bildgröße anzeigen (Zeilen, Spalten, (Anzahl der Farbkanäle)):

print "Shape ", bild.shape

Definieren der Zeilen und Spalten (Anzahl der Variablen muss gleich sein):

zeilen, spalten=bild.shape

Wenn man einen Punkt im array verändert, verändert man seine Farbe:

bild[j,i] = (255 , 255 , 255) --> "Weiß" 

j entspricht der Zeile, i der Spalte.

Faltung (abstrakt):

bild=sig.convolve2d(A, B, Parameter)/255. 

(→ /255,da Grauwerte mit einem Wert nicht zwischen 255 und 0 sondern zwischen 0 und 1 gespeichert werden, „.“ damit es als double interpretiert wird(muss so sein)) Dafür muss man scipy.signal importieren, z.B als sig (s. oben)

• A ist das Bild, was man „falten“ will.
• B ist die Faltungsmatrix/Filtermatrix.
• Es gibt drei Parameter. Wenn man sie nicht erwähnt, setzt der default ein. Die drei Parameter sind:
  • „mode“
  • „boundary“
  • „fillvalue“.

speziell: „Entrauschungs-faltung“:

bild_neu=sig.convolve2d(bild, 0.1*np.array([[1,1,1],[1,2,1],[1,1,1]]),mode='valid')/255. 

Beispiel für eine 5×5 entrauschungsmatrix:

bild_neu=sig.convolve2d(bild, (1/256.)*np.array([[1,4,6,4,1],[4,16,24,16,4],[6,24,36,24,6],[4,16,24,16,4],[1,4,6,4,1]])  
                                ,mode='valid')/255. 

Schwellenwert finden (Graubild → Schwarz-Weiß-Bild)

bild_schwarzweiss=bild_grau.copy()
zeilen, spalten=bild_schwarzweiss.shape
for i in range(0,zeilen):
	for j in range(0,spalten):
		if(bild_grau[i][j] < 0.3):
			bild_schwarzweiss[i][j] = 0
		else:
			bild_schwarzweiss[i][j] = 1

Es gib 2 for-Schleifen, damit jeder Pixel in jeder Zeile und Spalte einzeln abgegangen wird. Für jeden Pixel wird abgewägt, ob der Grauwert über oder unter dem Schwellenwert (hier 0.3) liegt. Liegt er darunter, wird der Pixel schwarz (Grauwert 0), ist er darüber, wird er weiß (1).

Punkt suchen:

gefunden = False
for i in range(0,spalten):
	for j in range(0,zeilen):
		 if(bild[i][j] == 1):
			breite = i
			laenge = j
			gefunden = True
			break
	if gefunden:
		break

breite entspricht der Spalte in der der Punkt gefunden wurde, länge der zeile, statt „1“ kann jeder andere Wert genommen werden. „gefunden“ stellt sicher, ob ein Punkt gefunden wurde.

Konturensuche in eine bestimmte Richtung:

p = [breite,laenge]
contour.append(p)
v = [1,0]
fertig = False
while (not fertig):
	if(bild[(p[0]+v[0])]    [(p[1]+v[1])]):
		p1 = [(p[0]+v[0]),(p[1]+v[1])]
		contour.append(p1)
		p = p1

Es werden nur die Punkte ein Array eingetragen*seufz*

Konturensuche in alle Richtungen:

gefunden = False
if( bild_schwarzweiss[(p[0] + 1)][(p[1]+1)]):
	p1 = [(p[0] + 1)][(p[1]+1)]
	v  = [1][1]
	gefunden = True
	contour.append(p1)
	p = p1
	break
if(bild[(p[0])]    [(p[1]+1)]):
	p1 = [(p[0])]    [(p[1]+1)]
	v = [0][1]
	gefunden = True
	contour.append(p1)
	p = p1
	break
if(bild[(p[0] - 1)][(p[1]+1)]):
	p1 = [(p[0] - 1)][(p[1]+1)]
	v = [-1][1]
	gefunden = True
	contour.append(p1)
	p = p1
	break
if(bild[(p[0] + 1)][(p[1])]):
	p1 = [(p[0] + 1)][(p[1])]	
	v = [1][0]
	gefunden = True
	contour.append(p1)
	p = p1
	break
if(Richtung == 4 and bild[(p[0] - 1)][(p[1])]):
	p1 = [(p[0] - 1)][(p[1])]
	v = [-1][0]
	gefunden = True
	contour.append(p1)
	p = p1
	break
if(bild[(p[0] + 1)][(p[1] - 1)]):
	p1 = [(p[0] + 1)][(p[1] - 1)]
	v = [1][-1]
	gefunden = True
	contour.append(p1)
	p = p1
	break
if(bild[(p[0])]    [(p[1]) - 1]):
	p1 = [(p[0])]    [(p[1]) - 1]
	v = [0][-1]
	gefunden = True
	contour.append(p1)
	p = p1
	break
if(bild[(p[0]-1)]  [(p[1] - 1)]):
	p1 = [(p[0]-1)]  [(p[1] - 1)]
	v = [-1][-1]
	gefunden = True
	contour.append(p1)
	p = p1
	break

Wieder wird durch „gefunden“ sichergestellt, dass etwas gefunden wurde. Jede Richtung wird untersucht, wird etwas gefunden, gibt es einen Abbruch. die Richtung in die gegangen wurde wird unter der Variable „v“ gespeichert. Der neue Punkt ist „p1“, der alte Punkt heisst „p“. Am Ende wird „p“ verändert, damit die Prozedur von neuem beginnen kann.

Hier eine kleine Vereinfachung:

def Nebenstellen(bild ,v ,p ):
	gefunden = False
	if(bild[(p[0] + v[0])]   [(p[1]+v[1])]):
		p1 = [(p[0] + v[0]),(p[1]+v[1])]
		gefunden = True
		p = p1
	if gefunden:
		return p, v, gefunden
	return False
if Nebenstellen(bild ,[1,1] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)
if Nebenstellen(bild ,[0,1] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)
if Nebenstellen(bild ,[-1,1] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)
if Nebenstellen(bild ,[1,0] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)
if Nebenstellen(bild ,[0,0] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)
if Nebenstellen(bild ,[-1,0] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)
if Nebenstellen(bild ,[1,-1] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)
if Nebenstellen(bild ,[0,-1] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)
if Nebenstellen(bild ,[-1,-1] ,p ):
	p, v, gefunden = Nebenstellen(bild ,[1,1] ,p )
	contour.append(p)