Comment faire un damier dans numpy?

Je suis en utilisant numpy pour initialiser un réseau de pixels gris damier (la représentation classique de "pas de pixels", ou transparent). Il semble qu'il devrait y avoir un whizzy façon de le faire avec numpy est étonnant tableau d'affectation ou de découpage en tranches ou en dés opérations, mais c'est le meilleur que j'ai trouvé:

w, h = 600, 800
sq = 15    # width of each checker-square
self.pix = numpy.zeros((w, h, 3), dtype=numpy.uint8)
# Make a checkerboard
row = [[(0x99,0x99,0x99),(0xAA,0xAA,0xAA)][(i//sq)%2] for i in range(w)]
self.pix[[i for i in range(h) if (i//sq)%2 == 0]] = row
row = [[(0xAA,0xAA,0xAA),(0x99,0x99,0x99)][(i//sq)%2] for i in range(w)]
self.pix[[i for i in range(h) if (i//sq)%2 == 1]] = row

Il fonctionne, mais je m'attendais à quelque chose de plus simple.

Je pense que tu veux dire numpy.zeros((h, w, 3), ...) (retournement w et h).

OriginalL'auteur Ned Batchelder | 2010-01-30

numpy python

10

cela devrait le faire

toute taille damier vous voulez (il suffit de passer en largeur et en hauteur, w, h); j'ai également codé en dur cellule hauteur/largeur de 1, même si bien sûr il peut aussi en être paramétré de sorte qu'une valeur arbitraire est passé:
```
>>> import numpy as NP
>>> def build_checkerboard(w, h) :
re = NP.r_[ w*[0,1] ]              # even-numbered rows
ro = NP.r_[ w*[1,0] ]              # odd-numbered rows
return NP.row_stack(h*(re, ro))
>>> checkerboard = build_checkerboard(5, 5)
>>> checkerboard
Out[3]: array([[0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0, 1, 0]])
```
avec ce tableau 2D, il est simple de rendre une image d'un damier, comme suit:
```
>>> import matplotlib.pyplot as PLT
>>> fig, ax = PLT.subplots()
>>> ax.imshow(checkerboard, cmap=PLT.cm.gray, interpolation='nearest')
>>> PLT.show()
```
C'est très proche, même si vous devez faire attention à certaines choses: je voulais que le contrôle soit plus de 1 pixel de travers (je les avais 15), et vous ne pouvez pas supposer que les chèques ne soient réparties de manière uniforme sur la largeur et la hauteur de l'damier désiré.
Nice! ro peut être écrit simplement comme re^1. (juste XORing re avec 1)
Cela fonctionne pour les même et non même largeur / hauteur: import numpy def checkerboard(w, h, a=0, b=1): row0 = numpy.r_[ int(w/2.0) * [a,b] + (w % 2) * [a] ] row1 = row0^1 return numpy.row_stack( int(h/2.0) * (row0, row1) + (h % 2) * (row0,) )

OriginalL'auteur doug
8

J'utiliserais Produit de Kronecker kron:
```
np.kron([[1, 0] * 4, [0, 1] * 4] * 4, np.ones((10, 10)))
```
Le damier dans cet exemple a 2*4=8 champs de taille 10x10 dans chaque direction.

Élégant & algébrique réponse! Une amélioration possible (comme avec la plupart des autres réponses) serait d'utiliser les OP d'origine de niveaux de gris pour illustrer la généralité.

OriginalL'auteur Falko

Voici une autre façon de faire à l'aide de ogrid qui est un peu plus rapide:

import numpy as np
import Image
w, h = 600, 800
sq = 15
color1 = (0xFF, 0x80, 0x00)
color2 = (0x80, 0xFF, 0x00)
def use_ogrid():
coords = np.ogrid[0:w, 0:h]
idx = (coords[0] // sq + coords[1] // sq) % 2
vals = np.array([color1, color2], dtype=np.uint8)
img = vals[idx]
return img
def use_fromfunction():
img = np.zeros((w, h, 3), dtype=np.uint8)
c = np.fromfunction(lambda x, y: ((x // sq) + (y // sq)) % 2, (w, h))
img[c == 0] = color1
img[c == 1] = color2
return img
if __name__ == '__main__':
for f in (use_ogrid, use_fromfunction):
img = f()
pilImage = Image.fromarray(img, 'RGB')
pilImage.save('{0}.png'.format(f.func_name))

Voici les timeit résultats:

% python -mtimeit -s"import test" "test.use_fromfunction()"
10 loops, best of 3: 307 msec per loop
% python -mtimeit -s"import test" "test.use_ogrid()"
10 loops, best of 3: 129 msec per loop

Vous pouvez adapter ce donc que cela ne fonctionne pas si mes couleurs des pixels ne sont pas gris pur? Supposons que je voulais que les deux couleurs (0xFF,0x80,0x00) et (0x80,0xFF,0x00)
Assurez-vous. C'était un mauvais choix de ma part d'assumer la couleur devait être gris...

OriginalL'auteur unutbu

En retard, mais pour la postérité:

def check(w, h, c0, c1, blocksize):
tile = np.array([[c0,c1],[c1,c0]]).repeat(blocksize, axis=0).repeat(blocksize, axis=1)
grid = np.tile(tile, ( h/(2*blocksize)+1, w/(2*blocksize)+1, 1))
return grid[:h,:w]

OriginalL'auteur Ben Kirwin

Je ne sais pas si c'est mieux que ce que j'avais:

c = numpy.fromfunction(lambda x,y: ((x//sq) + (y//sq)) % 2, (w,h))
self.chex = numpy.array((w,h,3))
self.chex[c == 0] = (0xAA, 0xAA, 0xAA)
self.chex[c == 1] = (0x99, 0x99, 0x99)

OriginalL'auteur Ned Batchelder

2

Ne pouvez-vous pas utiliser hstack et vstack? Voir ici.
Comme ceci:
```
>>> import numpy as np
>>> b = np.array([0]*4)
>>> b.shape = (2,2)
>>> w = b + 0xAA
>>> r1 = np.hstack((b,w,b,w,b,w,b))
>>> r2 = np.hstack((w,b,w,b,w,b,w))
>>> board = np.vstack((r1,r2,r1,r2,r1,r2,r1))
```
Je n'ai pas plus de respect ici, mais c'est correct. telliott99.blogspot.com/2010/01/...
Ce n'est pas un tableau de la bonne taille, mais il semblerait que vous avez élargi votre réponse dans votre blog. Mais nous ne pouvons pas voter le blog! 🙂 Sheesh!

OriginalL'auteur telliott99
2
```
def checkerboard(shape):
return np.indices(shape).sum(axis=0) % 2
```
Plus compact, probablement le plus rapide, et aussi la seule solution posté qui généralise à n-dimensions.

OriginalL'auteur Eelco Hoogendoorn

import numpy as np
a=np.array(([1,0]*4+[0,1]*4)*4).reshape((8,8))
print(a)
[[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]]

OriginalL'auteur geoffLangenderfer

J'ai modifié hass de répondre comme suit.

import math
import numpy as np
def checkerboard(w, h, c0, c1, blocksize):
tile = np.array([[c0,c1],[c1,c0]]).repeat(blocksize, axis=0).repeat(blocksize, axis=1)
grid = np.tile(tile,(int(math.ceil((h+0.0)/(2*blocksize))),int(math.ceil((w+0.0)/(2*blocksize)))))
return grid[:h,:w]

Idéalement, vous souhaitez indiquer quels sont les avantages de cette réponse a sur l'autre, plutôt que de simplement nous dire que vous avez modifié.

OriginalL'auteur pizzaslice

import numpy as np
x = np.ones((3,3))
print("Checkerboard pattern:")
x = np.zeros((8,8),dtype=int)
x[1::2,::2] = 1
x[::2,1::2] = 1
print(x)

OriginalL'auteur priya_03

J'ai récemment veux la même fonction et j'ai modifié doug réponse un peu comme suit:

def gen_checkerboard(grid_num, grid_size):
row_even = grid_num/2 * [0,1]
row_odd = grid_num/2 * [1,0]
checkerboard = numpy.row_stack(grid_num/2*(row_even, row_odd))
return checkerboard.repeat(grid_size, axis = 0).repeat(grid_size, axis = 1)

OriginalL'auteur shelper

Vous devez vous connecter pour publier un commentaire.