CODEWITHSUNDEEP
pythonmatrixresize
Juan Gallostra
Juan Gallostra

Reputation: 301

A particular way of resizing a matrix

Having a nxn (6x6 in the example below) matrix filled only with 0 and 1:

old_matrix=[[0,0,0,1,1,0],
            [1,1,1,1,0,0],
            [0,0,1,0,0,0],
            [1,0,0,0,0,1],
            [0,1,1,1,1,0],
            [1,0,0,1,1,0]]

I want to resize it in a particular way. Taking (2x2) sub-matrice and checking if there are more ones or zeros. This means the new matrix will be (3x3) If there are more 1 than 0 un the sub-matrice a 1 value will be assigned in the new matrix. Otherwise, (if there are less or equal) its new value will be 0.

new_matrix=[[0,1,0],
            [0,0,0],
            [0,1,0]]

I've tried to achieve this by using lots of whiles. However it doesn seem to work. Here's what I got so far: 

 def convert_track(a):

   #converts original map to a 8x8 tile Track

   NEW_TRACK=[]
   w=0 #matrix width
   h=0 #matrix heigth
   t_w=0 #submatrix width
   t_h=0 #submatrix heigth
   BLACK=0 #number of ones in submatrix
   WHITE=0 #number of zeros in submatrix
   while h<=6:
       while w<=6:
           l=[]
           while t_h<=2 and h<=6:
               t_w=0
               while t_w<=2 and w<=6:
                   if a[h][w]==1:
                       BLACK+=1
                   else:
                       WHITE+=1
                   t_w+=1
                   w+=1
                   h+=1
                   t_h+=1
               t_w=0
               t_h+=1
           if BLACK<=WHITE:
               l.append(0)
           else:
               l.append(1)
           BLACK=0
           WHITE=0
           t_h=0     
       NEW_TRACK.append(l)
   return NEW_TRACK

Raises the error list index out of range or returns the list

[[0]]

is there an easier way to achieve this? What am i doing wrong?

Upvotes: 0

Views: 259

Answers (1)

YXD
YXD

Reputation: 32511

If you are willing/able to use NumPy you can do something like this. If you're working with anything like the data you've shown it's well worth your time to learn as operations like these can be done very efficiently and with very little code.

import numpy as np
from scipy.signal import convolve2d

old_matrix=[[0,0,0,1,1,0],
            [1,1,1,1,0,0],
            [0,0,1,0,0,0],
            [1,0,0,0,0,1],
            [0,1,1,1,1,0],
            [1,0,0,1,1,0]]

a = np.array(old_matrix)
k = np.ones((2,2))

# compute sums at each submatrix
local_sums = convolve2d(a, k, mode='valid')

# restrict to sums corresponding to non-overlapping
# sub-matrices with local_sums[::2, ::2] and check if
# there are more 1 than 0 elements
result = local_sums[::2, ::2] > 2

# convert back to Python list if needed
new_matrix = result.astype(np.int).tolist()

Result:

>>> result.astype(np.int).tolist()
[[0, 1, 0], [0, 0, 0], [0, 1, 0]]

Here I've used convolve2d to compute the sums at each submatrix. From what I can tell you are only interested in non-overlapping sub-matrices, so the part local_sums[::2, ::2] chops out only the sums corresponding to those.

Upvotes: 1

Related Questions