File size: 4,888 Bytes
6142a25 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@author: Tu Bui @surrey.ac.uk
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from scipy import fftpack
import sys, os
from pathlib import Path
import numpy as np
import random
import glob
import json
import time
import importlib
import pandas as pd
from tqdm import tqdm
# from IPython.display import display
# import seaborn as sns
import matplotlib
# matplotlib.use('Agg') # headless run
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
from PIL import Image, ImageDraw, ImageFont
cmap = plt.get_cmap("tab10") # cmap as function
cmap = plt.rcParams['axes.prop_cycle'].by_key()['color'] # cmap
FONT = '/vol/research/tubui1/_base/utils/FreeSans.ttf'
# def imshow(im):
# if type(im) is np.ndarray:
# im = Image.fromarray(im)
# display(im)
def make_grid(array_list, gsize=(3,3)):
"""
make a grid image from a list of image array (RGB)
return: array RGB
"""
assert len(gsize)==2 and gsize[0]*gsize[1]==len(array_list)
h,w,c = array_list[0].shape
out = np.array(array_list).reshape(gsize[0], gsize[1], h, w, c).transpose(0, 2, 1, 3, 4).reshape(gsize[0]*h, gsize[1]*w, c)
return out
def collage(im_list, size=None, pad=0, color=255):
"""
generalised function of make_grid()
work on PIL/numpy images of arbitrary size
"""
if size is None:
size=(1, len(im_list))
assert len(size)==2
if isinstance(im_list[0], np.ndarray):
im_list = [Image.fromarray(im) for im in im_list]
h, w = size
n = len(im_list)
canvas = []
for i in range(h):
start, end = i*w, min((i+1)*w, n)
row = combine_horz(im_list[start:end], pad, color)
canvas.append(row)
canvas = combine_vert(canvas, pad, color)
return canvas
def combine_horz(pil_ims, pad=0, c=255):
"""
Combines multiple pil_ims into a single side-by-side PIL image object.
"""
widths, heights = zip(*(i.size for i in pil_ims))
total_width = sum(widths) + (len(pil_ims)-1) * pad
max_height = max(heights)
color = (c,c,c)
new_im = Image.new('RGB', (total_width, max_height), color)
x_offset = 0
for im in pil_ims:
new_im.paste(im, (x_offset,0))
x_offset += (im.size[0] + pad)
return new_im
def combine_vert(pil_ims, pad=0, c=255):
"""
Combines multiple pil_ims into a single vertical PIL image object.
"""
widths, heights = zip(*(i.size for i in pil_ims))
max_width = max(widths)
total_height = sum(heights) + (len(pil_ims)-1)*pad
color = (c,c,c)
new_im = Image.new('RGB', (max_width, total_height), color)
y_offset = 0
for im in pil_ims:
new_im.paste(im, (0,y_offset))
y_offset += (im.size[1] + pad)
return new_im
def make_text_image(img_shape=(100,20), text='hello', font_path=FONT, offset=(0,0), font_size=16):
"""
make a text image with given width/height and font size
Args:
img_shape, offset tuple (width, height)
font_path path to font file (TrueType)
font_size max font size, actual may smaller
Return:
pil image
"""
im = Image.new('RGB', tuple(img_shape), (255,255,255))
draw = ImageDraw.Draw(im)
def get_font_size(max_font_size):
font = ImageFont.truetype(font_path, max_font_size)
text_size = font.getsize(text) # (w,h)
start_w = int((img_shape[0] - text_size[0]) / 2)
start_h = int((img_shape[1] - text_size[1])/2)
if start_h <0 or start_w < 0:
return get_font_size(max_font_size-2)
else:
return font, (start_w, start_h)
font, pos = get_font_size(font_size)
pos = (pos[0]+offset[0], pos[1]+offset[1])
draw.text(pos, text, font=font, fill=0)
return im
def log_scale(array, epsilon=1e-12):
"""Log scale the input array.
"""
array = np.abs(array)
array += epsilon # no zero in log
array = np.log(array)
return array
def dct2(array):
"""2D DCT"""
array = fftpack.dct(array, type=2, norm="ortho", axis=0)
array = fftpack.dct(array, type=2, norm="ortho", axis=1)
return array
def idct2(array):
"""inverse 2D DCT"""
array = fftpack.idct(array, type=2, norm="ortho", axis=0)
array = fftpack.idct(array, type=2, norm="ortho", axis=1)
return array
class DCT(object):
def __init__(self, log=True):
self.log = log
def __call__(self, x):
x = np.array(x)
x = dct2(x)
if self.log:
x = log_scale(x)
# normalize
x = np.clip((x - x.min())/(x.max() - x.min()) * 255, 0, 255).astype(np.uint8)
return Image.fromarray(x)
def __repr__(self):
s = f'(Discrete Cosine Transform, logarithm={self.log})'
return self.__class__.__name__ + s |