# Many ways to create a chess-like image in Python/Numpy

This demonstration illustrates many different ways to create a chess-like image in Python. Each way has a different concept, but most of them uses the property that each pixel is 0 or 1 depending if the sum of its coordinates is even or odd. The most efficient way is the technique using slices and the most general one is the one that uses indices. These examples below is a good introduction to program Python efficiently for image processing applications and verify that processing arrays in Python is very efficient.

The image that we want to generate can be describe in the following equation: # Programming styles

We show below seven different programs, some very efficient as uses intrinsic implementation in Numpy, others not so efficient.

## C style programming

This is the traditional way that a C programmer would solve the problem - scan every pixel and apply the equation.

```1. def chessCstyle(H,W):
2.     f = empty((H,W),'uint8')
3.     for row in range(H):
4.       for col in range(W):
5.         f[row,col] = (row+col)%2
6.     return f
7.
8. print "C Style:\n", chessCstyle(4,8)```
```C Style:
[[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]]
```

## Image coordinates

This is a general way to create images when we can write the equation of each pixel value based on its coordinates. The function indices is very handy to create arrays of each coordinate make possible the array processing of the whole image without the explicit scanning of the pixels in the image.

```1. def chessIndice(H,W):
2.     row,col = indices((H,W), 'uint16')
3.     return (row+col)%2
4.
5. print "Indices:\n", chessIndice(4,8)```
```Indices:
[[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]]
```

## image coordinates and broadcast

In the previous indices example, the arrays row and col are two-dimensional arrays. It is possible to use the broadcast facility of NumPy. We create a row as one column 2D array and col as a one row 2D array and let the arithmetic operation create the full 2D array using broadcast.

```1. def chessIndiceBroad(H,W):
2.     row = arange(H).reshape(H,1).astype('uint16')
3.     col = arange(W).reshape(1,W).astype('uint16')
4.     return (row+col)%2
5.
6. print "IndiceBroad:\n", chessIndiceBroad(4,8)```
```IndiceBroad:
[[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]]
```

## List implicit loop (list comprehension)

This solution uses the native implicit loop in list generation. The list is then converted to array.

```1. import numpy as np
2. def chessIter(H,W):
3.     f = [[ (row+col)%2 for col in range(W) ] for row in range(H) ]
4.     return np.array(f,'uint8')
5.
6. print "Iter:\n", chessIter(4,8)```
```Iter:
[[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]]
```

## Slice

Slicing is a powerful index access to elements of an array available in numpy. This solution is one of the most efficient. The image is initially create with zeros and later filled with ones in the even lines and after in odd lines, always scanning the image every two pixels.

```1. def chessSlice(H,W):
2.     f = zeros((H,W), 'uint8')
3.     f[0::2,1::2] = 1
4.     f[1::2,0::2] = 1
5.     return f
6.
7. print "Slice:\n", chessSlice(4,8)```
```Slice:
[[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]]
```

## Line and column replication

This solution has three main parts: in the first a 4 pixel basic pattern is created; in the second this pattern is replicated line-wise and the last and third part, the replication is done column-wise. Use the functions vstack and hstack.

```01. def chessRep(H,W):
02.     p = array([[0,1],
03.                [1,0]],'uint8')
04.     fCol = p
05.
06.     # First column
07.     for row in range (1, H/2):
08.         fCol = vstack((fCol , p))
09.     f = fCol
10.     # Column replication
11.     for col in range (1, W/2):
12.         f = hstack((f, fCol))
13.     return f
14.
15. print "Replication:\n", chessRep(4,8)```
```Replication:
[[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]]
```

## Tile

This solution uses the properties of the Numpy function tile. It replicates the 4-pixel pattern over the image according to the number of replication in the vertical and horizontal directions.

```1. def chessTile(H,W):
2.     p = array([[0,1],
3.                [1,0]], 'uint8')
4.     f = tile(p, (H/2, W/2))
5.     return f
6.
7. print "Tiling:\n", chessTile(4,8)```
```Tiling:
[[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]]
```

## Resize

This solution uses the Numpy function resize to increase the image until the desired size, replicating the initial raster image contents. We first create two lines of the image and then rezise it until the final dimension.

```1. def chessResize(H,W):
2.      # create two lines and then apply resize
3.      row1 = arange(W).astype('uint8') % 2
4.      row2 = array([row1, 1 - row1])
5.      f = resize(row2, (H,W))
6.      return f
7.
8. print "Resize:\n", chessResize(4,8)```
```Resize:
[[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]]
```

# Comparing execution times

We compare the speed efficiency of the implementation above. We can see that slicing, tiling and resize are the most efficient implementations because it is intrinsic to Numpy. Slicing is very efficient and is very recommending in most image processing manipulation. Coordinate processing and replication have medium efficiency with coordinate processing being a very general way to create images. Lastly list processing and C style programming present the worst efficiency because of its explicit pixel scanning. For comparison, the result of the chess image is always of an array of type uint8, except for the coordinates method where the result is in uint16 as the coordinate values are greater than 255.

```01. from time import time
02. import ia636
03. print '.. csv-table:: Execution time'
04. print """    :header: 'Program', 'Time (ms)' """
05. print
06.
07. H,W = 2000,2000
08. funlist = (chessResize, chessSlice, chessTile, chessIndiceBroad, chessIndice,   chessIter,         chessRep,      chessCstyle)
09. fundesc = ("Resize",    "Slicing",  "Tiling",  "CoordBroad"    , "Coordinates", "List processing", "Replication", "C style")
10. i=0
11. for fun in funlist:
12.    t1 = time()
13.    f  = fun(H,W)
14.    t2 = time()
15.    print '   ',fundesc[i],',', round(1000*(t2-t1),2)
16.    i = i+1
17. adshow(f*255, title='Chess like image, dimensions: %s' % (f.shape,))```
Execution time
'Program' 'Time (ms)'
Resize 7.53
Slicing 10.7
Tiling 24.2
CoordBroad 69.09
Coordinates 118.47
List processing 1055.36
Replication 258.99
C style 815.43 Chess like image, dimensions: (2000, 2000)

# Conclusions

Numpy is very efficient for array processing and it is very suitable for image processing. The recommended way of programming are: avoid explicit pixel scanning; use slicing as much as possible and use array processing such as in the coordinates example. Pixel scanning programming style is not recommended.