Numpy-Array-Manipulation innerhalb des Bereichs von Spalten und Zeilen

Question

Ich habe eine boolesche 2D-Matrix, die ein Graustufenbild darstellt, das im Wesentlichen eine ungefüllte Form (Dreieck, Quadrat, Kreis) True für weiße Pixel und False für schwarze Pixel darstellt. Ich möchte eine schwarze Füllung hinzufügen, indem ich die weißen Pixel zu schwarzen Pixeln modifiziere.

array([[True, True, True, False, False, False, False, False, True, True, True], 
     [True, True, True, False, True, True, True, False, True, True, True], 
     [True, True, True, False, True, True, True, False, True, True, True], 
     [True, True, True, False, True, True, True, False, True, True, True], 
     [True, True, True, False, False, False, False, False, True, True, True]]) 

(Die 9 True Werte in einem Quadrat in der Mitte dieses Arrays sollten False werden.)

Gibt es eine numpy slice-Methode, die diese leicht/schnell machen? Etwas, das ich alle True s jederzeit ändern kann, ist ein False gefolgt von einem True bis zur nächsten Instanz eines False?

Answer 1

Basierend auf Ihrer Logik, können Sie alle Werte zwischen dem ersten und dem letzten Falsch Falsch mit Falsch ersetzen:

def mutate(A): 
    ind = np.where(~A)[0] 
    if len(ind) != 0: 
     A[ind.min():ind.max()] = False 
    return A 


np.apply_along_axis(mutate, 1, arr) 

# array([[ True, True, True, False, False, False, False, False, True, 
#   True, True], 
#  [ True, True, True, False, False, False, False, False, True, 
#   True, True], 
#  [ True, True, True, False, False, False, False, False, True, 
#   True, True], 
#  [ True, True, True, False, False, False, False, False, True, 
#   True, True], 
#  [ True, True, True, False, False, False, False, False, True, 
#   True, True]], dtype=bool) 

Answer 2

Hier ist eine Idee, die einfach zu implementieren und sollte einigermaßen schnell durchführen.

Ich werde 0s und 1s verwenden, so dass es ein wenig klarer zu betrachten ist.

Hier ist das Ausgang Array:

>>> a 
array([[1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1], 
     [1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1], 
     [1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1], 
     [1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1], 
     [1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1]]) 

Akkumulieren von links nach rechts np.logical_and.accumulate verwenden, von links nach rechts kippen, hat das gleiche wieder, Flip zurück, und die „oder“ die zwei Arrays zusammen:

>>> andacc = np.logical_and.accumulate 
>>> (andacc(a, axis=1) | andacc(a[:, ::-1], axis=1)[:, ::-1]).astype(int) 
array([[1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1], 
     [1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1], 
     [1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1], 
     [1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1], 
     [1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1]]) 

(Lassen Sie .astype(int) aus statt von 0 und 1 einen boolean-Array zu halten.)

Hier ist ein Dreieck:

>>> b 
array([[1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1], 
     [1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1], 
     [1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1], 
     [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0]]) 

>>> (andacc(b, axis=1) | andacc(b[:, ::-1], axis=1)[:, ::-1]).astype(int) 
array([[1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1], 
     [1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1], 
     [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], 
     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])