shaynali / voronoi-compression

A lossy compression algorithm using Voronoi cells to encode information.

Voronoi Compression

Uses Voronoi cells to compress and decompress an image.

Usage

compression.py [-h] -i IN_IMAGE -o OUT_IMAGE

arguments:
  -h, --help            show this help message and exit
  -i IN_IMAGE, --in-image IN_IMAGE
                        the filepath to read an image from, this image will be
                        compressed
  -o OUT_IMAGE, --out-image OUT_IMAGE
                        the filepath to write the compressed image to

voronoi-compression's Issues

Profile and optimize

This should be done before #7.

Profile the code and identify area of slowdown.

Speed up the slow areas and/or create follow up issues as needed.

Readability pass on grid_neighbour_indices_within_distance

The grid_neighbour_indices_within_distance function in utils is not readable in it's current state, and also has optimization potential.

Consider using R-trees to speed up rasterization

Currently we use grid neighborhoods to determine the closest cells to a given pixel, for large images we may see a speed up when using R, R*, etc trees.

Add graph serialization

Should maximize compression: store nodes once, make edges as compact as possible, etc.

Keep in mind that edges will be augmented with additional info in the future.

Compare to pickle and other serialization libraries and approaches.

Expose an API as needed and harden the existing API.

Extend to n-dimensional data

Currently some code relies on data being 2D, we should implement compression for N-D data.

Rasterize based on intermediate colour values

Determine if each edge is a hard edge (drastic colour difference), or a soft edge (subtle colour difference). Then while rasterizing, for each pixel determine the closest set of softly-connected cells and colour the pixel based on a weighted average of the colours of these cells. The weight average should consider the weights of the cells and their proximity to the pixel.

For now, we can implement an n colour system in which we use the closest cell (already implemented) and search through it's soft edges for the next n-1 closest cells to the pixel, then colour the pixel based on a weight average.

Improve compression quality

Investigate ways to improve the compression quality.
Take a look at algorithms like H264, H265, and more.

Parallelize

Many components can be parallelized.

First, profile and inspect the code to find out which code would benefit the most from parallelization, then implement parallelism.