from IPMatrix import Matrix

import numpy
from PIL import Image

def bitmap2image(file):
    ''' convert format .bitmap image to .jpg/.bmp '''
    im = Matrix.load(file)
    n,m = im.dim()
    ar = numpy.zeros((n,m)) #an nXm array of zeros
    for i in range(n):
        for j in range(m):
            ar[i,j] = im[i,j]
    image = Image.fromarray(numpy.uint8(ar))
    image.save(file.split(".")[0] + ".bmp")

def image2bitmap(file):
    ''' convert .jpg/.bmp file to format .bitmap
        which can be loaded into class Matrix using Matrix.load() ''' 
    image = Image.open(file).convert("L") # converts to 8 bit black and white image
    im = numpy.asarray(image)             # stores image in an array
    im.setflags(write=1)                  # makes array writeable
    n,m = im.shape[0], im.shape[1]        # image dimensions

    new_file_name = file.split(".")[0] + ".bitmap"
    new_file = open(new_file_name, 'w')

    print(n,m, file=new_file)
    for i in range(n):
        for j in range(m):
            print(int(im[i,j]), end=" ", file = new_file)
        print("", file=new_file)#newline
    new_file.close()

im = Matrix.load("eiffel.bitmap")
im

def mult(im,k):
    return im * k

mult(im, 2)

def add(im, k):
    n,m = im.dim()
    im2 = Matrix(n,m)
    for i in range(n):
        for j in range(m):
            im2[i,j] = (im[i,j] + k) % 256
    return im2

add(im,50)

add(im,-50)

def pixelwise_operation(im, op):
    n,m = im.dim()
    im2 = Matrix(n,m)
    for i in range(n):
        for j in range(m):
            im2[i,j] = op(im, i, j)
    return im2

def add(im, k):
    op = lambda im,i,j: im[i,j] + k
    return pixelwise_operation(im, op)

add(im, 100)

secret(im) # SHHHHH, the code is below

def secret(im):
    n,m = im.dim()
    im2 = Matrix(n,m)
    for i in range(n):
        im2.rows[i] = sorted(im.rows[i])
    return im2

def negate(im):
    op = lambda im,i,j: 255 - im[i,j]
    return pixelwise_operation(im, op)

negate(im)

def shift(im, v_shift, h_shift):
    op = lambda im,i,j: im[(i - v_shift) % im.dim()[0], (j - h_shift) % im.dim()[1]]
    return pixelwise_operation(im, op)

shift(im, 100, 0)

shift(im, 0, 100)

shift(im, 50, 50)

def upside_down(im):
    op = lambda im,i,j: im[im.dim()[0] - i - 1, j]
    return pixelwise_operation(im, op)    

upside_down(im)

def concatenate(im1, im2):
    n1,m1 = im1.dim()
    n2,m2 = im2.dim()
    n = max(n1,n2)
    im3 = Matrix(n,m1+m2)
    im3[:n1,:m1] = im1
    im3[:n2, m1:m1+m2] = im2
    return im3

concatenate(im,im)

def strech(im, ratio=1):
    n,m = im.dim()
    im2 = Matrix(n * ratio, m)
    for i in range(n):
        for j in range(m):
            for k in range(ratio):
                im2[ratio * i + k , j] = im[i,j]
    return im2

strech(im,3)

X = 5
im[50:50 + X,50:50 + X] = Matrix(X, X, 255)
im

def items(mat):
  lst = []
  n,m = mat.dim()
  for i in range(n):
    lst = lst + [mat[i,j] for j in range(m)]
  return lst

def median(lst):
    return sorted(lst)[len(lst) // 2]

def local_medians(A, k=1):
  n,m = A.dim()
  res = A.copy()
  for i in range(k,n-k):
    for j in range(k,m-k):
      neighborhood = items(A[i-k:i+k+1,j-k:j+k+1])
      res[i,j] = median(neighborhood)
  return res

local_medians(im)

local_medians(im, k=3)

local_medians(im, k=5)

def local_medians_bounded(A, k=1, black=10, white=250):
  n,m = A.dim()
  res1 = A.copy()
  #fix white
  for i in range(k,n-k):
    for j in range(k,m-k):
      neighborhood = items(A[i-k:i+k+1,j-k:j+k+1])
      res1[i,j] = fix_white(neighborhood, white)
  #fix black        
  res2 = res1.copy()
  for i in range(k,n-k):
    for j in range(k,m-k):
      neighborhood = items(res1[i-k:i+k+1,j-k:j+k+1])
      res2[i,j] = fix_black(neighborhood, black)

  return res2

def fix_white(lst, white_thr):
  center = len(lst)//2
  if lst[center] > white_thr:
    new_lst = [i for i in lst if i <= white_thr]
    if new_lst != []:
      return median(new_lst)
  return lst[center]  #either center was not extreme
                      #or all its neighbors are extreme

def fix_black(lst, black_thr):
  center = len(lst)//2
  if lst[center] < black_thr:
    new_lst = [i for i in lst if i >= black_thr]
    if new_lst != []:
      return median(new_lst)
  return lst[center]  #either center was not extreme
                      #or all its neighbors are extreme

local_medians_bounded(im, k=3)

def add_SP(mat, p=0.01):
  ''' Generates salt and pepper noise: Each pixel is "hit" indep.
      with prob. p. If hit, it has fifty fifty chance of becoming
      white or black. '''
  n,m = mat.dim()
  new = Matrix(n,m)
  for i in range (n):
      for j in range (m):
          rand = random.randint(0,20000)
          if rand < p * 20000:
              if rand % 2 == 1:
                  new[i,j] = 0
              elif rand % 2 == 0:
                  new[i,j] = 255
          else: 
              new[i,j] = mat[i,j]
  return new

person = Matrix.load("person.bitmap")
person_noise = add_SP(person, p=0.7)
person_noise

local_medians(person_noise)

person_denoised = local_medians_bounded(person_noise)
person_denoised

local_medians_bounded(person_denoised)

person