如何在numpy中制作棋盘格？

Question

我使用numpy将像素数组初始化为灰色棋盘（“无像素”或透明的经典表示）。好像有应该是一个whizzy方式与numpy的惊人阵列分配/切片/切割操作做到这一点，但是这是我想出来的最好的：

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 

它的工作原理，但我希望为了更简单一些。

Answer 1

你不能使用hstack和vstack吗？见here。 像这样：

>>> 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)) 

Answer 2

这应该做到这一点

你想（只是传递的宽度和高度，为w，h）的任何规模大小的棋盘;还使得一个任意值被传入我已经硬编码细胞高度/宽度为1时，虽然这当然也可以进行参数化：

>>> 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]]) 

与此2D阵列，它是简单的渲染的图像棋盘，像这样：

>>> import matplotlib.pyplot as PLT 

>>> fig, ax = PLT.subplots() 
>>> ax.imshow(checkerboard, cmap=PLT.cm.gray, interpolation='nearest') 
>>> PLT.show() 

Answer 3

我不知道这是否是比我有更好的：

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) 

Answer 4

这里的另一种方式做它用ogrid这是一个有点快：

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)) 

下面是使用timeit结果：

% 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 

Answer 5

较晚，但为后人：

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] 

Answer 6

最近我想相同的功能，我修改了道格的回答有点如下：

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) 

Answer 7

我修改过哈斯的答案如下。

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] 

Answer 8

我使用Kronecker productkron：

np.kron([[1, 0] * 4, [0, 1] * 4] * 4, np.ones((10, 10))) 

在本例中的棋盘具有2 * 4 = 8在每个方向上10×10的尺寸的字段。

Answer 9

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) 

Answer 10

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


[[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]]