Python / numpy: Supprimer la bordure vide (zéros) du tableau 3D

Essayez ceci: - c'est un algorithme principal. Je ne comprends pas exactement quels côtés vous voulez extraire de vos exemples, mais l'algorithme ci-dessous devrait être très facile à modifier en fonction de vos besoins

Remarque: Cet algorithme extrait CUBE où toutes les bordures de valeur zéro sont «supprimées». Donc de chaque côté du cube se trouve une valeur! = 0

import numpy as np


class ImageContainer(object):
    def __init__(self,first_image):
        self.container =  np.uint8(np.expand_dims(np.array(first_image), axis=0))

    def add_image(self,image):
        #print(image.shape)
        temp = np.uint8(np.expand_dims(np.array(image), axis=0))
        #print(temp.shape)
        self.container  = np.concatenate((self.container,temp),axis = 0)
        print('container shape',self.container.shape)

# Create image container storage

image = np.zeros(shape = [5,5,3]) # some image
image[2,2,1]=1 # put something random in it
container = ImageContainer(image)
image = np.zeros(shape = [5,5,3]) # some image
image[2,2,2]=1
container.add_image(image)
image = np.zeros(shape = [5,5,3]) # some image
image[2,3,0]=1    # if we set [2,2,0] = 1, we can expect all images will have just 1x1 pixel size
container.add_image(image)
image = np.zeros(shape = [5,5,3]) # some image
image[2,2,1]=1
container.add_image(image)
>>> container.container.shape
('container shape', (4, 5, 5, 3)) # 4 images, size 5x5, 3 channels


# remove borders to all images at once
xs,ys,zs,zzs = np.where(container.container!=0) 
# for 4D object

# extract cube with extreme limits of where are the values != 0
result = container.container[min(xs):max(xs)+1,min(ys):max(ys)+1,min(zs):max(zs)+1,min(zzs):max(zzs)+1]

>>> print('Final shape:',result.shape) 


('Final shape', (4, 1, 2, 3)) # 4 images, size: 1x2, 3 channels

Cas 1:

d = np.zeros(shape = [5,5,5]) # no values except zeros
>>> result.shape


Traceback (most recent call last):
  File "C:\Users\zzz\Desktop\py.py", line 7, in <module>
    result = d[min(xs):max(xs)+1,min(ys):max(ys)+1,min(zs):max(zs)+1]
ValueError: min() arg is an empty sequence

Cas 2: # erreur case - seulement des zéros - la 3D résultante n'a pas de dimensions -> erreur

d = np.zeros(shape = [5,5,5])

d[3,2,1]=1
# ...  just one value

>>> result.shape # works

(1,1,1)

EDIT: Parce que ma solution n'a pas reçu assez d'amour et de compréhension, je vais donner un exemple à la 4ème dimension body, où 3 dimensions sont libres pour l'image et la 4ème dimension est l'endroit où les images sont stockées

import numpy as np

# testing dataset
d = np.zeros(shape = [5,5,5]) 

# fill some values
d[3,2,1]=1
d[3,3,1]=1
d[1,3,1]=1
d[1,3,4]=1

# find indexes in all axis
xs,ys,zs = np.where(d!=0) 
# for 4D object
# xs,ys,zs,as = np.where(d!=0) 

# extract cube with extreme limits of where are the values != 0
result = d[min(xs):max(xs)+1,min(ys):max(ys)+1,min(zs):max(zs)+1] 
# for 4D object
# result = d[min(xs):max(xs)+1,min(ys):max(ys)+1,min(zs):max(zs)+1,min(as):max(as)+1]

>>> result.shape
(3, 2, 4)

Mise à jour:

Basé sur la solution de Martin utilisant min / max et np.where, mais en la généralisant à n'importe quelle dimension, vous pouvez le faire de cette manière:

def bounds_per_dimension(ndarray):
    return map(
        lambda e: range(e.min(), e.max() + 1),
        np.where(ndarray != 0)
    )

def zero_trim_ndarray(ndarray):
    return ndarray[np.ix_(*bounds_per_dimension(ndarray))]

d = np.array([[
    [0, 0, 0, 0, 0],
    [0, 1, 0, 0, 0],
    [0, 1, 1, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
], [
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 1, 0],
    [0, 0, 0, 1, 0],
]])

zero_trim_ndarray(d)

p>

Vous pourriez voir votre problème comme un ajustement pour une boîte englobante spécifique sur le tableau formé en rassemblant toutes les formes que vous avez dans un seul tableau.

Par conséquent, si vous avez une fonction d'ajustement à n dimensions, la solution est simplement appliquez-le.

Une façon de mettre en œuvre ceci serait:

trimmed_list = np.split(trimmed_arr, arr.shape[-1], -1)

Une solution légèrement plus flexible (où vous pourriez indiquer sur quel axe agir) est disponible dans FlyingCircus ( Clause de non-responsabilité : je suis l'auteur principal du package) .

Donc, si vous avez votre liste de tableaux n-dim (en arrs ), vous pouvez d'abord les empiler en utilisant np.stack () puis découpez le résultat:

import numpy as np

arr = np.stack(arrs, -1)
trimmed_arr = trim(arr, arr != 0)

qui pourrait ensuite être séparé en utilisant np.split () , par exemple:

import numpy as np

def trim(arr, mask):
    bounding_box = tuple(
        slice(np.min(indexes), np.max(indexes) + 1)
        for indexes in np.where(mask))
    return arr[bounding_box]

EDIT:

Je viens de réaliser que cela utilise beaucoup la même approche que les autres réponses, sauf que cela me semble beaucoup plus propre.