def FFIC(domain_chunks, range_chunks, inpface):
############################################################################
# encode the range image using svd encoding
############################################################################
# encode image
start = time.time()
codebook = encode_svd(domain_chunks, range_chunks, verbose=False)
svd_encoding_time = time.time() - start
# for svd only we implement compression by
# dropping coefficients in the codebook
codebook[:, COMPRESSION_FACTOR:] = 0
# Use an input face to use as input for the reconstruction
domain_chunks = utils.Partition(inpface, mode=MODE)
# initialize psnr
psnr = np.zeros(10);
# decode image 100 times
start = time.time()
reconstructed_chunks = decode_svd(codebook, domain_chunks)
reconstructed_chunks_1 = copy.deepcopy(reconstructed_chunks)
psnr[0] = PSNR(range_image, reconstructed_chunks.image)
for i in range(9):
rec_dim = rescale(reconstructed_chunks.image, 0.5)
domain_chunks = utils.Partition(rec_dim, mode=MODE)
reconstructed_chunks = decode_svd(codebook, domain_chunks)
psnr[i+1] = PSNR(range_image, reconstructed_chunks.image)
svd_decoding_time = time.time()-start
# plot_image(reconstructed_chunks.image,
# title=f"Reconstructed Image (SVD Encoding) \n {reconstructed_chunks.image.shape[0]}x{reconstructed_chunks.image.shape[0]}, {COMPRESSION_FACTOR}/{BLOCK_SIZE} Compression",
# cmap='gray', y=0.97)
############################################################################
# encoding and decoding time results
############################################################################
print(f"svd mode encoding: {svd_encoding_time}")
print(f"svd mode decoding: {svd_decoding_time}")
############################################################################
# psnr results
############################################################################
# psnr = PSNR(range_image, reconstructed_chunks.image)
print(f"PSNR: {psnr} \t Coefficients Retained: {COMPRESSION_FACTOR}/{BLOCK_SIZE}")
return psnr
def decode_svd(codebook, domain_blocks):
# if domain_blocks.mode != 'equipartition4' or\
# domain_blocks.mode !=:
# raise Exception("encode_svd only supports 'equipartition4' partitioning")
num_weights = len(domain_blocks[0].ravel())
X = np.zeros([num_weights, len(domain_blocks)])
for i in range(len(domain_blocks)):
X[:, i] = np.ravel(domain_blocks[i])
u, s, vh = randomized_svd(X,
n_components=min(X.shape[1], 1000),
n_iter=5,
random_state=None)
N = int(np.sqrt(len(codebook)))
img = utils.init_range_image(N, domain_blocks)
range_blocks = utils.Partition(img, mode=domain_blocks.mode)
nrows = int(np.sqrt(num_weights))
ncols = nrows
for ridx, weights in enumerate(codebook):
range_blocks[ridx] = np.dot(u, weights[:, np.newaxis])\
.reshape(nrows, ncols)
return range_blocks
def decode_nmf(codebook, domain_blocks):
# if domain_blocks.mode != 'equipartition4' or\
# domain_blocks.mode !=:
# raise Exception("encode_svd only supports 'equipartition4' partitioning")
num_weights = len(domain_blocks[0].ravel())
X = np.zeros([num_weights, len(domain_blocks)])
for i in range(len(domain_blocks)):
X[:, i] = np.ravel(domain_blocks[i])
X = np.abs(X)
model = NMF(n_components=16, init='random', random_state=0)
_ = model.fit_transform(X)
u = model.components_[:,:16]
N = int(np.sqrt(len(codebook)))
img = utils.init_range_image(N, domain_blocks)
range_blocks = utils.Partition(img, mode=domain_blocks.mode)
nrows = int(np.sqrt(num_weights))
ncols = nrows
for ridx, weights in enumerate(codebook):
range_blocks[ridx] = np.dot(u, weights[:, np.newaxis])\
.reshape(nrows, ncols)
return range_blocks
def decode(codebook, domain_blocks):
"""Decodes the codebook into estimates of the range blocks"""
N = int(np.sqrt(len(codebook)))
if N != np.sqrt(len(codebook)):
raise Exception("Codebook size must correspond to a square range image")
# create a range block partition to populate
img = utils.init_range_image(N, domain_blocks)
range_blocks = utils.Partition(img, mode=domain_blocks.mode)
for ridx, (didx, permtype, alpha, t0) in enumerate(codebook):
permtype = int(permtype)
dref = domain_blocks[didx]
db = permute(dref)[permtype]
range_blocks[ridx] = (alpha * db) + t0
return range_blocks
title=f"Range Image {range_image.shape[0]}x{range_image.shape[1]}",
cmap='gray')
############################################################################
# divide up the first image into chunks
############################################################################
# domain image is a 50% downsampled range image
domain_image = images.get_image(0, scale_factor=1 / 2)
plot_image(
domain_image,
title=f"Domain Image {domain_image.shape[0]}x{domain_image.shape[1]}",
cmap='gray')
# each block is 4x4
domain_chunks = utils.Partition(domain_image, mode=MODE)
range_chunks = utils.Partition(range_image, mode=MODE)
print("partitioned")
############################################################################
# encode the range image
############################################################################
codebook = encode_svd(domain_chunks, range_chunks, verbose=False)
# codebook[:, 8:] = 0 # uncomment to compress representation
# facedir = Path(__file__).resolve().parent.parent / "data" / "faces"
if args.imagepath == 'mandrill.jpg':
facedir = Path(__file__).resolve().parent.parent / "data"
aaronface = Image.open(list(facedir.glob("lena_gray.jpg"))[0])
print(aaronface)
aaronface = np.asarray(aaronface.getdata()).reshape(512, 512)
plot_image(range_image,
title=f"Range Image {range_image.shape[0]}x{range_image.shape[1]}",
cmap='gray')
############################################################################
# divide up the first image into chunks
############################################################################
# domain image is a 50% downsampled range image
domain_image = images.get_image(0, scale_factor=SCALE/2)
plot_image(domain_image,
title=f"Domain Image {domain_image.shape[0]}x{domain_image.shape[1]}",
cmap='gray')
# each block is 4x4
domain_chunks = utils.Partition(domain_image, mode=MODE)
range_chunks = utils.Partition(range_image, mode=MODE)
compression_ratios = np.arange(1/16,16/16,1/16)
num_ratios = len(compression_ratios)
############################################################################
# Use Mandrill for reconstruction
############################################################################
# Initialize psnr matrix
psnr_all_mandrill = np.zeros((num_ratios,10))
# load an input face to use as input for the reconstruction
inpface = load_mandrill()
plot_image(inpface,
from context import fractal
from fractal import utils
import numpy as np
if __name__ == '__main__':
X = np.eye(20)
xp = utils.Partition(X, 'equipartition4')
for i in xp:
print(xp)
print(xp.shape)
print()
