boîte englobante de tableau numpy

Question

Supposons que vous disposiez d'un tableau numpy 2D avec des valeurs aléatoires et des zéros environnants.

Exemple de "rectangle incliné":

import numpy as np from skimage import transform img1 = np.zeros((100,100)) img1[25:75,25:75] = 1. img2 = transform.rotate(img1, 45)

Maintenant, je veux trouver le plus petit rectangle englobant pour toutes les données non nulles. Par exemple:

a = np.where(img2 != 0) bbox = img2[np.min(a[0]):np.max(a[0])+1, np.min(a[1]):np.max(a[1])+1]

Quelle serait la manière la plus rapide d'obtenir ce résultat? Je suis sûr qu'il existe un meilleur moyen puisque la fonction np.where prend un certain temps si je suis par exemple en utilisant des ensembles de données 1000x1000.

Edit: Devrait aussi fonctionner en 3D ...

ali_m · Accepted Answer

Vous pouvez réduire de moitié le temps d'exécution en utilisant np.any pour réduire les lignes et les colonnes qui contiennent des valeurs non nulles à des vecteurs 1D, plutôt que de rechercher les indices de toutes les valeurs non nulles à l'aide de np.where:

def bbox1(img): a = np.where(img != 0) bbox = np.min(a[0]), np.max(a[0]), np.min(a[1]), np.max(a[1]) return bbox def bbox2(img): rows = np.any(img, axis=1) cols = np.any(img, axis=0) rmin, rmax = np.where(rows)[0][[0, -1]] cmin, cmax = np.where(cols)[0][[0, -1]] return rmin, rmax, cmin, cmax

Quelques repères:

%timeit bbox1(img2) 10000 loops, best of 3: 63.5 µs per loop %timeit bbox2(img2) 10000 loops, best of 3: 37.1 µs per loop

L'extension de cette approche au cas 3D implique simplement d'effectuer la réduction le long de chaque paire d'axes:

def bbox2_3D(img): r = np.any(img, axis=(1, 2)) c = np.any(img, axis=(0, 2)) z = np.any(img, axis=(0, 1)) rmin, rmax = np.where(r)[0][[0, -1]] cmin, cmax = np.where(c)[0][[0, -1]] zmin, zmax = np.where(z)[0][[0, -1]] return rmin, rmax, cmin, cmax, zmin, zmax

Il est facile de généraliser ceci aux dimensions [~ # ~] n [~ # ~] en utilisant itertools.combinations pour itérer sur chaque combinaison unique d'axes pour effectuer la réduction sur:

import itertools def bbox2_ND(img): N = img.ndim out = [] for ax in itertools.combinations(reversed(range(N)), N - 1): nonzero = np.any(img, axis=ax) out.extend(np.where(nonzero)[0][[0, -1]]) return Tuple(out)

Si vous connaissez les coordonnées des coins du cadre de délimitation d'origine, l'angle de rotation et le centre de rotation, vous pouvez obtenir directement les coordonnées des coins du cadre de délimitation transformés en calculant la matrice de transformation affine affine correspondante et en le pointant avec les coordonnées d'entrée:

def bbox_rotate(bbox_in, angle, centre): rmin, rmax, cmin, cmax = bbox_in # bounding box corners in homogeneous coordinates xyz_in = np.array(([[cmin, cmin, cmax, cmax], [rmin, rmax, rmin, rmax], [ 1, 1, 1, 1]])) # translate centre to Origin cr, cc = centre cent2ori = np.eye(3) cent2ori[:2, 2] = -cr, -cc # rotate about the Origin theta = np.deg2rad(angle) rmat = np.eye(3) rmat[:2, :2] = np.array([[ np.cos(theta),-np.sin(theta)], [ np.sin(theta), np.cos(theta)]]) # translate from Origin back to centre ori2cent = np.eye(3) ori2cent[:2, 2] = cr, cc # combine transformations (rightmost matrix is applied first) xyz_out = ori2cent.dot(rmat).dot(cent2ori).dot(xyz_in) r, c = xyz_out[:2] rmin = int(r.min()) rmax = int(r.max()) cmin = int(c.min()) cmax = int(c.max()) return rmin, rmax, cmin, cmax

Cela revient à être très légèrement plus rapide que d'utiliser np.any pour votre petit exemple de tableau:

%timeit bbox_rotate([25, 75, 25, 75], 45, (50, 50)) 10000 loops, best of 3: 33 µs per loop

Cependant, comme la vitesse de cette méthode est indépendante de la taille du tableau d'entrée, elle peut être beaucoup plus rapide pour les tableaux plus grands.

L'extension de l'approche de transformation à la 3D est légèrement plus compliquée, dans la mesure où la rotation a maintenant trois composants différents (un autour de l'axe x, un autour de l'axe y et un autour de l'axe z), mais la méthode de base est la même :

def bbox_rotate_3d(bbox_in, angle_x, angle_y, angle_z, centre): rmin, rmax, cmin, cmax, zmin, zmax = bbox_in # bounding box corners in homogeneous coordinates xyzu_in = np.array(([[cmin, cmin, cmin, cmin, cmax, cmax, cmax, cmax], [rmin, rmin, rmax, rmax, rmin, rmin, rmax, rmax], [zmin, zmax, zmin, zmax, zmin, zmax, zmin, zmax], [ 1, 1, 1, 1, 1, 1, 1, 1]])) # translate centre to Origin cr, cc, cz = centre cent2ori = np.eye(4) cent2ori[:3, 3] = -cr, -cc -cz # rotation about the x-axis theta = np.deg2rad(angle_x) rmat_x = np.eye(4) rmat_x[1:3, 1:3] = np.array([[ np.cos(theta),-np.sin(theta)], [ np.sin(theta), np.cos(theta)]]) # rotation about the y-axis theta = np.deg2rad(angle_y) rmat_y = np.eye(4) rmat_y[[0, 0, 2, 2], [0, 2, 0, 2]] = ( np.cos(theta), np.sin(theta), -np.sin(theta), np.cos(theta)) # rotation about the z-axis theta = np.deg2rad(angle_z) rmat_z = np.eye(4) rmat_z[:2, :2] = np.array([[ np.cos(theta),-np.sin(theta)], [ np.sin(theta), np.cos(theta)]]) # translate from Origin back to centre ori2cent = np.eye(4) ori2cent[:3, 3] = cr, cc, cz # combine transformations (rightmost matrix is applied first) tform = ori2cent.dot(rmat_z).dot(rmat_y).dot(rmat_x).dot(cent2ori) xyzu_out = tform.dot(xyzu_in) r, c, z = xyzu_out[:3] rmin = int(r.min()) rmax = int(r.max()) cmin = int(c.min()) cmax = int(c.max()) zmin = int(z.min()) zmax = int(z.max()) return rmin, rmax, cmin, cmax, zmin, zmax

Je viens essentiellement de modifier la fonction ci-dessus en utilisant les expressions de la matrice de rotation de ici - Je n'ai pas encore eu le temps d'écrire un cas de test, alors utilisez-le avec prudence.

rth · Answer

Voici un algorithme pour calculer la boîte englobante pour les tableaux à N dimensions,

def get_bounding_box(x): """ Calculates the bounding box of a ndarray""" mask = x == 0 bbox = [] all_axis = np.arange(x.ndim) for kdim in all_axis: nk_dim = np.delete(all_axis, kdim) mask_i = mask.all(axis=Tuple(nk_dim)) dmask_i = np.diff(mask_i) idx_i = np.nonzero(dmask_i)[0] if len(idx_i) != 2: raise ValueError('Algorithm failed, {} does not have 2 elements!'.format(idx_i)) bbox.append(slice(idx_i[0]+1, idx_i[1]+1)) return bbox

qui peut être utilisé avec les tableaux 2D, 3D, etc. comme suit,

In [1]: print((img2!=0).astype(int)) ...: bbox = get_bounding_box(img2) ...: print((img2[bbox]!=0).astype(int)) ...: [[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 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 0 0 0 1 1 0 0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0] [0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0] [0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0] [0 0 0 0 0 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 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 0 0 0 0 0 0 0 0 0 0 0 0]] [[0 0 0 0 0 0 1 1 0 0 0 0 0 0] [0 0 0 0 0 1 1 1 1 0 0 0 0 0] [0 0 0 0 1 1 1 1 1 1 0 0 0 0] [0 0 0 1 1 1 1 1 1 1 1 0 0 0] [0 0 1 1 1 1 1 1 1 1 1 1 0 0] [0 1 1 1 1 1 1 1 1 1 1 1 1 0] [1 1 1 1 1 1 1 1 1 1 1 1 1 1] [1 1 1 1 1 1 1 1 1 1 1 1 1 1] [0 1 1 1 1 1 1 1 1 1 1 1 1 0] [0 0 1 1 1 1 1 1 1 1 1 1 0 0] [0 0 0 1 1 1 1 1 1 1 1 0 0 0] [0 0 0 0 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 1 1 0 0 0 0 0 0]]

Bien que remplaçant le np.diff et np.nonzero appels par un np.where pourrait être mieux.

Allan Zelener · Answer

J'ai pu obtenir un peu plus de performances en remplaçant np.where avec np.argmax et travailler sur un masque booléen.

 def bbox (img): img = (img> 0) row = np.any (img, axis = 1) cols = np.any (img, axe = 0) rmin, rmax = np.argmax (lignes), img.shape [0] - 1 - np.argmax (np.flipud (lignes)) cmin, cmax = np.argmax (cols), img.shape [1] - 1 - np.argmax (np.flipud (cols)) return rmin, rmax, cmin, cmax

C'était environ 10µs plus rapide pour moi que la solution bbox2 ci-dessus sur le même benchmark. Il devrait également y avoir un moyen d'utiliser simplement le résultat d'argmax pour trouver les lignes et les colonnes non nulles, en évitant la recherche supplémentaire effectuée en utilisant np.any, mais cela peut nécessiter une indexation délicate que je n'ai pas pu utiliser efficacement avec du code vectorisé simple.