2016-04-22 7 views
2

Ich bin schon eine Weile auf dieses Problem gestoßen und habe mich gefragt, ob jemand helfen könnte. Nehmen wir an, ich habe ein Binärbild wie unten gezeigt und möchte die schwarzen Elemente zählen (zero). Das Problem ist, dass ich die Anzahl der Elemente, die mit 'background' und 'trapezoid' in der Mitte verbunden sind, einzeln kennen möchte, also gebe zwei Werte aus. Was wäre der einfachste Weg, um das zu erreichen? Ich habe versucht, es ohne eine mask zu tun, aber ist das überhaupt möglich? Ich habe die numpy und scipy Bibliotheken, wenn das hilft.Berechne die Fläche zweier separater Geometrien in Python

enter image description here

+0

Eine handgemachte numpy Lösung wird über die Form/Anzahl der Regionen auf den Annahmen abhängen ... – Benjamin

Antwort

2

Sie zwei Funktionen aus scipy.ndimage.measurements verwenden können: label und find_objects.

Zuerst invertieren Sie das Array, weil die label Funktion Null als Hintergrund betrachtet.

inverted = 1 - binary_image_array 

Sie dann label rufen die verschiedenen Regionen zu finden:

labeled_array, num_features = scipy.ndimage.measurements.label(inverted) 

Also, für diese besondere Anordnung, wo Sie bereits wissen es exactely zwei schwarzen Flecken sind, haben Sie die beiden Regionen in labeled_array.

+0

Wie würde die Größe der einzelnen Blob zugreifen? Würde ich 'find_objects' verwenden? –

+1

Sie können etwas wie folgt verwenden: 'count = etikettierter_array [etikettierter_array == etikettennummer] .astype (int) .sum()'. Dadurch wird ein boolesches Array erstellt, in int konvertiert und alle Vorkommen summiert. – heltonbiker

1

Offensichtlich ist der scipy Ansatz eine gute Antwort.

Ich dachte, dass Sie möglicherweise mit numpy.cumsum und numpy.diff arbeiten können, um einen umschlossenen Bereich zu finden.

Die kumulative Summe Null sein wird, während Sie im schwarzen Bereich sind, dann in dem weißen Bereich für jedes Pixel um eins erhöht, wieder stabil, während Sie den geschlossenen Raum durchqueren, dann beginnt wieder zu erhöhen, usw.

Der Unterschied zweiter Ordnung findet dann Orte, wo die Sprünge auftreten, und Sie haben eine "klassifizierte" Karte übrig. Keine Garantie, dass dies verallgemeinert, nur eine Idee.

a = numpy.zeros((10,10)) 
a[3:7,3:7] = 1 
a[4:6, 4:6] = 0 

y = numpy.cumsum(a, axis=0) 
x = numpy.cumsum(a, axis=1) 

yy= numpy.diff(y, n=2, axis=0) 
xx = numpy.diff(x, n=2, axis=1) 

numpy.dot(xx,yy) 

array([[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
     [ 0., 0., 0., 2., 2., 2., 2., 0., 0., 0.], 
     [ 0., 0., 0., 2., 4., 4., 2., 0., 0., 0.], 
     [ 0., 0., 0., 2., 4., 4., 2., 0., 0., 0.], 
     [ 0., 0., 0., 2., 2., 2., 2., 0., 0., 0.], 
     [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]) 
Verwandte Themen