Как сделать шахматную доску в numpy?

Я использую numpy для инициализации массива пикселей на серой шахматной доске (классическое представление для "без пикселей" или прозрачное). Кажется, что должен быть какой-то свистящий способ сделать это с помощью numpy amazing array assign/slicing/dicing, но это лучшее, что я придумал:

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

Это работает, но я надеялся на что-то более простое.

Ответ 1

это должно это сделать

любой размер шахматной доски, который вы хотите (просто пройдите по ширине и высоте, как 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()

Ответ 2

Я бы использовал продукт Kronecker kron:

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

Шахматная доска в этом примере имеет 2 * 4 = 8 полей размером 10x10 в каждом направлении.

Ответ 3

Вот еще один способ сделать это, используя 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))

Вот результаты тайм-аута:

% 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

Ответ 4

def checkerboard(shape):
    return np.indices(shape).sum(axis=0) % 2

Самый компактный, возможно самый быстрый, а также единственное решение, которое обобщает на n-мерные размеры.

Ответ 5

Я не уверен, что это лучше, чем у меня:

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)

Ответ 6

Поздно, но для потомков:

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]

Ответ 7

Вы не можете использовать hstack и vstack? См. здесь. Вот так:

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

Ответ 8

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

Ответ 9

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

Ответ 10

Я изменил hass ответ следующим образом.

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]

Ответ 11

Недавно мне нужна одна и та же функция, и я модифицировал doug немного, чтобы ответить следующим образом:

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)

Ответ 12

Простейшая реализация того же.

import numpy as np

n = int(input())
checkerboard = np.tile(np.array([[0,1],[1,0]]), (n//2, n//2))
print(checkerboard)

Ответ 13

n = int(input())
import numpy as np
m=int(n/2)
a=np.array(([0,1]*m+[1,0]*m)*m).reshape((n,n))

print (a)

Так что если input равен n = 4, то результат будет таким:

[[0 1 0 1]
 [1 0 1 0]
 [0 1 0 1]
 [1 0 1 0]]

Ответ 14

Используя функцию плитки:

import numpy as np
n = int(input())
x = np.tile(arr,(n,n//2))
x[1::2, 0::2] = 1
x[0::2, 1::2] = 1
print(x)

Ответ 15

Здесь простое решение с некоторой проверкой, чтобы убедиться, что ширина и высота равномерно делятся на размер квадрата.

def make_checkerboard(w, h, sq, fore_color, back_color):
    """
    Creates a checkerboard pattern image
    :param w: The width of the image desired
    :param h: The height of the image desired
    :param sq: The size of the square for the checker pattern
    :param fore_color: The foreground color
    :param back_color: The background color
    :return:
    """
    w_rem = np.mod(w, sq)
    h_rem = np.mod(w, sq)
    if w_rem != 0 or h_rem != 0:
        raise ValueError('Width or height is not evenly divisible by square '
                         'size.')
    img = np.zeros((h, w, 3), dtype='uint8')
    x_divs = w // sq
    y_divs = h // sq
    fore_tile = np.ones((sq, sq, 3), dtype='uint8')
    fore_tile *= np.array([[fore_color]], dtype='uint8')
    back_tile = np.ones((sq, sq, 3), dtype='uint8')
    back_tile *= np.array([[back_color]], dtype='uint8')
    for y in np.arange(y_divs):
        if np.mod(y, 2):
            b = back_tile
            f = fore_tile
        else:
            b = fore_tile
            f = back_tile
        for x in np.arange(x_divs):
            if np.mod(x, 2) == 0:
                img[y * sq:y * sq + sq, x * sq:x * sq + sq] = f
            else:
                img[y * sq:y * sq + sq, x * sq:x * sq + sq] = b
    return img

Ответ 16

Функция Numpy Tile для получения массива шахматной доски размером n * n

import numpy

n = 4

list_0_1 = [ [ 0, 1], [ 1, 0] ]

checkerboard = numpy.tile( list_0_1, ( n//2, n//2) ) 

print( checkerboard)

[[0 1 0 1]
 [1 0 1 0]
 [0 1 0 1]
 [1 0 1 0]]

Ответ 17

Самый простой способ написать матрицу шахматной доски, используя tile()

array = np.tile([0,1],n//2)
array1 = np.tile([1,0],n//2)
finalArray = np.array([array, array1], np.int32)
finalArray = np.tile(finalArray,(n//2,1))

Ответ 18

Предположим, нам нужен скороговорка с длиной и шириной (четное число) как l, b.

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

Поскольку эта базовая матрица, которая будет использоваться в качестве плитки, уже имеет длину и ширину 2 X 2, нам необходимо разделить ее на 2.

print np.tile(base_matrix, (l/2, b/2))

print (np.tile(base,(4/2,6/2)))
[[0 1 0 1 0 1]
 [1 0 1 0 1 0]
 [0 1 0 1 0 1]
 [1 0 1 0 1 0]]

Ответ 19

n = int(input())
import numpy as np
a = np.array([0])
x = np.tile(a,(n,n))
x[1::2, ::2] = 1
x[::2, 1::2] = 1
print(x)

Я думаю, это прекрасно работает с помощью функции numpy.tile().

Ответ 20

Очень, очень поздно, но мне нужно было решение, которое учитывает размер контрольной единицы, не равной единице, на контрольной доске произвольного размера. Вот простое и быстрое решение:

import numpy as np

def checkerboard(shape, dw):
    """Create checkerboard pattern, each square having width ''dw''.

    Returns a numpy boolean array.
    """
    # Create individual block
    block = np.zeros((dw * 2, dw * 2), dtype=bool)
    block[dw:, :dw] = 1
    block[:dw, dw:] = 1

    # Tile until we exceed the size of the mask, then trim
    repeat = (np.array(shape) + dw * 2) // np.array(block.shape)
    trim = tuple(slice(None, s) for s in shape)
    checkers = np.tile(block, repeat)[trim]

    assert checkers.shape == shape
    return checkers

Чтобы преобразовать квадраты шахматной доски в цвета, вы можете сделать следующее:

checkers = checkerboard(shape, dw)
img = np.empty_like(checkers, dtype=np.uint8)
img[checkers] = 0xAA
img[~checkers] = 0x99

Ответ 21

Вот решение с использованием функции тайла в numpy.

import numpy as np

x = np.array([[0, 1], [1, 0]])
check = np.tile(x, (n//2, n//2))
# Print the created matrix
print(check)

для входа 2 выход

     [[0 1]
     [1 0]]

для входа 4 выход

Ответ 22

n = int(input())
oput=np.tile(0,(n,n))
oput[::2, 1::2] = 1
oput[1::2, ::2] = 1
print(oput)