def run(algorithm):
# Schwellwerte fuer die Segmentierung des Spielers
threshold_value = 40
depth_value = 170
skeleton = skeletonization.Skeleton()
while True:
# Tiefenbild erzeugen
depthvalues = depth.get_better_depth()
# Spielersegmentierung
depth_seg, depth_image = player_segmentation.player_segmentation(depthvalues, threshold_value, depth_value)
# Glaetten des segmentierten Bildes
cv.Smooth(depth_seg, depth_seg, smoothtype=cv.CV_MEDIAN, param1=5, param2=5)
# Distance Map berechnen und das Skelett daraus extrahieren
if algorithm == "distancetransform":
diff_img, dist_gradient = skeleton.distance_skeleton(depth_seg)
diff = image_conversion.cv2array(diff_img)
diff = 255.0 * numpy.logical_and(diff >= 0.2, diff <= 1)
diff = diff.astype(numpy.uint8)
diff_img = image_conversion.array2cv(diff)
# Skelettierung mittels Thinning. Innerhalb von Python-Wrapper
# wird ein C++-Programm aufgerufen, in dem das Thinning
# implementiert ist.
elif algorithm == "thinning":
greyscale_array = image_conversion.cv2array(depth_seg)
new_g = greyscale_array.reshape((480, 640))
new_g = pythonWrapper.reflectimage_band(new_g, 1)
# Anzeige des Spielers (segmentiert) und des Distanz-Skeletts
cv.ShowImage("Spieler", depth_seg)
cv.ShowImage("Distanz-Skeltt", diff_img)
if cv.WaitKey(10) == 27:
break
def distance_skeleton(self, img):
# Ein Zielbild bereitstellen, um das Ergebnis der Distance
# Transformation zu speichern
dist_img = cv.CreateImage(cv.GetSize(img), 32, 1)
# Distanztransformation
cv.DistTransform(img, dist_img, distance_type=cv.CV_DIST_L2)
# Konvertierung von CV-Bildobjekt zu Numpy-Array
dist_img_mat = image_conversion.cv2array(dist_img)
# Normalisierung der Distance Map
max_of_dist = dist_img_mat.max()
dist_img_mat = dist_img_mat / max_of_dist
# Zurueck konvertieren
dist_img = image_conversion.array2cv(dist_img_mat)
# Erste Stufe fuer das Pruning: Gradientbild berechnen und
# segmentieren des Gradientenbildes
dist_gradient = self.pruning(dist_img, 1)
dist_gradient_mat = image_conversion.cv2array(dist_gradient)
dist_img_mat = image_conversion.cv2array(dist_img)
# Zweite Stufe fuer das Pruning: Differenzbild aus Distanzbild und
# segmentiertem Gradientenbild
diff = dist_img_mat - dist_gradient_mat
diff = diff * 1.0
diff_img = image_conversion.array2cv(diff)
return diff_img, dist_img
def player_segmentation(depth_image_input,threshold_value,depth_value):
#Umwandlung in ein Numpy-Array
depth = image_conversion.cv2array(depth_image_input)
#Schwellwerte
threshold = threshold_value
current_depth = depth_value
#Segmentierung
depth = 255 * np.logical_and(depth >= current_depth - threshold,
depth <= current_depth + threshold)
#depth in ein Bild umwandeln (ist bis hierhin ein Numpy-Array)
depth = depth.astype(np.uint8)
depth_image = cv.CreateImageHeader((depth.shape[1], depth.shape[0]), cv.IPL_DEPTH_8U,1)
#Mit den Daten aus dem Array fuellen
cv.SetData(depth_image, depth.tostring(),
depth.dtype.itemsize * depth.shape[1])
#Glaetten
cv.Smooth(depth_image, depth_image, smoothtype=cv.CV_GAUSSIAN, param1=3, param2=0, param3=0, param4=0)
#Dilatation um Loecher und Rauschen zu mindern
depth_seg = dilate_image(depth_image)
return depth_seg, depth_image
def static():
#Invertierung der Farbe, damit Objekt weiss und Hintergrund schwarz
img = cv.LoadImage("hand.jpg")
grey_img = cv.CreateImage(cv.GetSize(img),8,1)
grey_img_mat = image_conversion.cv2array(grey_img)
for i in xrange(len(grey_img_mat[:,1])):
for j in xrange(len(grey_img_mat[1,:])):
if grey_img_mat[i,j] == 255:
grey_img_mat[i,j] = 0
else:
grey_img_mat[i,j] = 1
print(lib.static_function(grey_img_mat,grey_img_mat.shape[1],grey_img_mat.shape[0]))
def test(image):
grey_img = cv.CreateImage(cv.GetSize(image),8,1)
dist_img = cv.CreateImage(cv.GetSize(image),32,1)
cv.CvtColor(image,grey_img,cv.CV_BGR2GRAY)
#Invertierung der Farbe, damit Objekt weiss und Hintergrund schwarz
grey_img_mat = image_conversion.cv2array(grey_img)
for i in xrange(len(grey_img_mat[:,1])):
for j in xrange(len(grey_img_mat[1,:])):
if grey_img_mat[i,j] == 255:
grey_img_mat[i,j] = 0
else:
grey_img_mat[i,j] = 1
grey_img = image_conversion.array2cv(grey_img_mat)
#Distance Transform
dist_img, dist_map = skeleton.distance_skeleton(grey_img)
#Pruning/Segmentierung des Skeletts
dist_gradient = skeleton.pruning(dist_img,1)
dist_gradient_thresh_mat = image_conversion.cv2array(dist_gradient)
#Differenz der Distance-Map und dem segmentierten Gradientbild
dist_img_mat = image_conversion.cv2array(dist_img)
diff = dist_img_mat - dist_gradient_thresh_mat
#Schwellwertbasierte Segmentierung des Differenzbildes. Ergibt ein schoenes Skelett
diff = 255.0 * numpy.logical_and(diff >= 0.2, diff <=1)
#diff = diff.astype(numpy.float32)
diff = diff.astype(numpy.uint8)
diff_img = image_conversion.array2cv(diff)
features = skeleton_improvement.calcGoodFeatures(diff_img)
#return features, image, dist_img, diff_img, drawImage
return diff_img, features, dist_gradient, dist_map
def pruning(self, skeleton_img, sigma):
skeleton_img_mat = image_conversion.cv2array(skeleton_img)
# Ausgabe-Array fuer das Ergebnis der Gradientberechnung
gradient_output = numpy.empty_like(skeleton_img_mat)
# Gradienten-Berechnung
ndimage.gaussian_gradient_magnitude(skeleton_img_mat, sigma, gradient_output)
# Normalisierung
gradient_output /= gradient_output.max()
# Array ins Bild umwandeln
grad_img = image_conversion.array2cv(gradient_output)
# Schwellwertbasierte Segmentierung des Gradientbildes
dist_gradient_thresh = cv.CreateImage(cv.GetSize(grad_img), 8, 1)
cv.InRangeS(grad_img, 0.6, 1, dist_gradient_thresh)
return dist_gradient_thresh
liste = png + jpg
skeleton = skeletonization.Skeleton()
descriptor = []
for i in liste:
print os.path.join(workdir,i)
img = cv.LoadImage(os.path.join(workdir,i))
grey_img = cv.CreateImage(cv.GetSize(img),8,1)
bin_img = cv.CreateImage(cv.GetSize(img),8,1)
dist_img = cv.CreateImage(cv.GetSize(img),32,1)
cv.CvtColor(img,grey_img,cv.CV_BGR2GRAY)
#Invertierung der Farbe, damit Objekt weiss und Hintergrund schwarz
grey_img_mat = image_conversion.cv2array(grey_img)
for i in xrange(len(grey_img_mat[:,1])):
for j in xrange(len(grey_img_mat[1,:])):
if grey_img_mat[i,j] == 255:
grey_img_mat[i,j] = 0
else:
grey_img_mat[i,j] = 1
grey_img = image_conversion.array2cv(grey_img_mat)
#Distance Transform
dist_img = skeleton.distance_skeleton(grey_img)
#Pruning/Segmentierung des Skeletts
dist_gradient = skeleton.pruning(dist_img,1)
dist_gradient_thresh_mat = image_conversion.cv2array(dist_gradient)
#Differenz der Distance-Map und dem segmentierten Gradientbild
dist_img_mat = image_conversion.cv2array(dist_img)
def multipleCalls(num,features,img):
i = 0
while i < num:
skeleton_improvement.startConnect(features,20,img)
i = i + 1
img = cv.LoadImage("person.jpg")
#img2 = cv.LoadImage("person.jpg")
#corners1, image1, dist_img1, diff_img1, drawImage = test(img)
#corners2, image2, dist_img2, diff_img2 = test(img2)
diff_img, features, dist_gradient, dist_img = test(img)
skeleton_improvement.drawFeatures(features,diff_img)
#comparison.connectFeatures(diff_img,features,10)
#neighbours = skeleton_improvement.startConnect(features,20,img)
cProfile.run('skeleton_improvement.startConnect(features,20,img)')
cProfile.run('test(img)')
#skeleton_improvement.connectDFS(features)
print img.depth
diff_img_arr = image_conversion.cv2array(diff_img)
diff_img = image_conversion.array2cv(diff_img_arr)
cv.ShowImage("Diff-Image", diff_img)
cv.ShowImage("Image",img)
cv.SaveImage("hand-bfs.png",img)
cv.ShowImage("Gradient", dist_gradient)
cv.ShowImage("Distance", dist_img)
cv.WaitKey()
