Compter le nombre de carré dans une image PNG en utilisant Numpy et en évitant les boucles imbriquées

Je veux être plus efficace avec mon code. J'ai un PNG et je veux découper l'image en boîtes. Le but est de compter le nombre de boîtes où j'ai au moins un pixel non noir. Je n'ai qu'une seule variable N.
Cette variable définit la longueur de chaque boîte. Si nous laissons P être la plus grande longueur de mon image, alors la longueur de chaque boîte est P/N.
Nous découpons également l'image de manière à ce qu'il y ait une boîte dans le coin supérieur gauche. De plus, il se peut ,par la taille de l'image, que mes cases ne soient pas carrés.
Dans ce cas-là, on les considère toujours comme des boîtes dont une partie est totalement noir.

Voici mon programme :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

from skimage import io import numpy as np   def nombre_boite(img, N): t=0 i,j,k = img.shape step=int(max(i,j)/N) for k1 in range(0, i, step): for k2 in range(0, j, step): if (img[k1:k1+step,k2:k2+step] == 0).any(): t += 1 return N

---

Pour moi, c'est lent. Le gros problème, ce sont mes deux boucles imbriquées. Je veux m'en débarrasser mais je ne sais pas comment y parvenir.
Je dirais que le broadcasting de Numpy pourrait m'aider mais je ne vois pas comment dans cette situation. Merci pour votre aide !

Bonjour

Citation:

---

Envoyé par Jotadiolne

Le gros problème, ce sont mes deux boucles imbriquées.!

---

Non, déjà le gros problème c'est que ta fonction reçoit N, n'y touche pas et le renvoie tel quel. De là on peut se demande à quoi elle sert.

Sinon pour optimiser des boucles imbriquées qui cherchent "un" truc, tu peux sortir de la boucle dès que le truc est trouvé (cf compter le nb de boites où tu as au-moins un pixel noir => dès que tu trouves un pixel tu peux passer à la boite suivante).

Et enfin il y a le module "itertools" qui permet de créer des boucles. Comme il a probablement été écrit en C, il sera plus rapide que les boucles Python

Code:

---

1 2 3 4 5 6 7 8 9 10

#!/usr/bin/env python3 # coding: utf-8   for i in range(5): for j in range(7): print("(%d, %d)," % (i, j), end=' ') print()   import itertools print(tuple(itertools.product(range(5), range(7))))

---

Oui effectivement je viens d'écrire une erreur quand j'ai voulu réécrire mon algorithme. Pardonnez-moi.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

from skimage import io import numpy as np   def nombre_boite(img, N): t=0 i,j,k = img.shape step=int(max(i,j)/N) for k1 in range(0, i, step): for k2 in range(0, j, step): if (img[k1:k1+step,k2:k2+step] != 0).any(): t += 1 return t

---

Le programme doit renvoyer t pas N.
Je ne vois pas comment itertools pourrait m'aider dans cette situation. Parce que pour le test, c'est déjà assez rapide.
Mais pour une image grande et une valeur de N grande, les boucles imbriquées posent problèmes.

Citation:

---

Envoyé par Jotadiolne

Oui effectivement je viens d'écrire une erreur quand j'ai voulu réécrire mon algorithme

---

Et ça fonctionne (img[k1:k1+step,k2:k2+step] != 0).any() ??? A première vue, (img[k1:k1+step,k2:k2+step] != 0) c'est un booléen et un booléen n'a pas de méthode "any()"...

Citation:

---

Envoyé par Jotadiolne

Je ne vois pas comment itertools pourrait m'aider dans cette situation. Parce que pour le test, c'est déjà assez rapide.

---

Code:

---

1 2 3 4

def nombre_boite(img, N): i,j,k = img.shape step=max(i, j) // N return len(tuple(filter(lambda k: img[k[0]:k[0]+step, k[1]:k[1]+step] != 0, itertools.product(range(0, i, step), range(0, j, step)))))

---

Après il n'y a pas de miracle. Une image c'est de la 2D et pour balayer un tableau 2D il faut 2 boucles...

Et bien img[k1:k1+step,k2:k2+step] est un tableau de tableau d'entiers (C'est un PNG). Donc quand img[k1:k1+step,k2:k2+step] != 0 est un tableau de tableau de bouléen.
Le .any() est nécessaire pour vérifier si j'ai au moins un TRUE dans mon tableau de tableau.

Je vais tester ton code !

Citation:

---

Envoyé par Jotadiolne

Et bien img[k1:k1+step,k2:k2+step] est un tableau de tableau d'entiers (C'est un PNG). Donc quand img[k1:k1+step,k2:k2+step] != 0 est un tableau de tableau de bouléen.

---

Ben... non. Comparer un tableau avec 0 donne un booléen, pas un tableau de booléen

Code:

---

1 2 3

>>> a=[1, 2, 3, 4] >>> a != 0 True

---

Et même un tableau rempli de 0 n'est pas égal à 0

Code:

---

1 2 3 4 5

>>> a=[0,] * 5 >>> a [0, 0, 0, 0, 0] >>> a != 0 True

---

Après, peut-être que "img" c'est un objet particulier qui a redéfini l'opérateur __eq__ et dans ce cas ok, tout est possible.

Citation:

---

Envoyé par Jotadiolne

Je vais tester ton code !

---

Je l'ai écrit en partant du principe que "img" était un simple tableau. Mais si c'est un objet spécifique, rajoute-lui alors le ".any()" que je n'ai pas mis (tu devrais arriver à l'adapter)

Pardon pour la probable erreur de ma part, mais ce ne sont pas des listes mais des tableaux Numpy. Donc normalement, j'obtiens un tableau de bouléens. Enfin c'est ce que je reçois en tout cas.

J'ai testé ton code avec le module Time pour voir si il est plus performant que le programme de base et pour une image assez grande et pour N = 1000, mon programme va plus vite.
Je vais chercher des façons d'améliorer le temps de calcul. Merci de ton aide !

Hello,
je ne sais pas si le but de la manip est de trouver le moyen le plus efficace de trouver des formes dans une image où si c'est de répondre à un exercice en utilisant un algorithme personnel. Mais si c'est le premier cas et cela dépendant de la complexité de l'image source (ex : carrés avec des textures) on peut alors utiliser la détection de contour d'opencv.
Exemple pour détecter des carrés et des rectangles dans une image.
Image Source :
Pièce jointe 639357

Code (seuil et traitement image à ajuster suivant la complexité de l'image) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

import cv2   img = cv2.imread('d:/tmp/formes.png') gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)   ret,thresh = cv2.threshold(gray,120,255,0) contours,hierarchy = cv2.findContours(thresh, 1, 2) print("Nombre de contours détectés : ", len(contours)) nbsquares = 0 for cnt in contours: x1,y1 = cnt[0][0] approx = cv2.approxPolyDP(cnt, 0.01*cv2.arcLength(cnt, True), True) if len(approx) == 4: x, y, w, h = cv2.boundingRect(cnt) ratio = float(w)/h if ratio >= 0.9 and ratio <= 1.1: img = cv2.drawContours(img, [cnt], -1, (255,255,0), 1) cv2.putText(img, 'Square', (x1, y1 -10 ), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 1) nbsquares += 1 else: cv2.putText(img, 'Rectangle', (x1, y1 -10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1) img = cv2.drawContours(img, [cnt], -1, (0,255,0), 1) print ("Nombre de carrés détectés : " + str(nbsquares)) cv2.imshow("Formes", img) cv2.waitKey(0) cv2.destroyAllWindows()

---

Résultat :
Pièce jointe 639358

Citation:

---

Nombre de contours détectés : 6
Nombre de carrés détectés : 4

---

Ami calmant, J.P

Merci pour ce point de vue ! Le but de la manipulation est de calculer la dimension fractale d'une image.
La méthode la plus utilisée est le "box-counting" où à partir d'un facteur d'échelle on calcule le nombre de cases qui sont en intersection avec l'image.
Le problème est que mon programme va être dans une boucle pour différents facteurs d'échelles. C'est pour cela que cela me prend trop de temps, je vais prendre des valeurs de N=1 à N=P/2 avec P la longueur la plus grande l'image.

Citation:

---

Envoyé par Jotadiolne

on calcule le nombre de cases qui sont en intersection avec l'image.

---

Si ce calcul entre dans le domaine des "intersections entre différentes images", tu as OpenCV qui fait le job... => ici un exemple...