Lossless JPEG Experimentation

Question: how effective is JPEG-LS at compressing our 1 second exposures?

This notebook compares the effectiveness of JPEG-LS compared to JPEG and JPEG-2000 for several simple parameterizations. The relevant metric here is just the ratio of the file size between the JPEG-LS files compared to other formats.

import pathlib
import tempfile

import numpy as np
import matplotlib.pyplot as plt
from astropy.visualization import ImageNormalize, LogStretch, AsymmetricPercentileInterval
import astropy.units as u

import PIL
import pillow_jpls

from overlappy.util import color_lat_lon_axes
from mocksipipeline.util import stack_components

def compare_jpeg_ls_compression(array, compare_format='JPEG2000', mode='I;16'):
    pil_image = PIL.Image.fromarray(array.astype(np.uint16)).convert(mode=mode)
    with tempfile.TemporaryDirectory() as tmpdir:
        tmpdir_p = pathlib.Path(tmpdir)
        jpls_path = tmpdir_p / 'image.jls'
        jp_path = tmpdir_p / 'image.jpg'
        pil_image.save(jpls_path, format='JPEG-LS')
        jpeg_ls_size = jpls_path.stat().st_size * u.byte
        print('JPEG-LS size: ',jpeg_ls_size.to('kilobyte'))
        if compare_format is None:
            other_size = np.product(array.shape) * 16 * u.bit
        else:
            pil_image.save(jp_path, format=compare_format)
            other_size = jp_path.stat().st_size * u.byte
        print('Other size: ',other_size.to('kilobyte'))
        ratio = other_size / jpeg_ls_size

    return ratio.decompose()

data_dir = pathlib.Path('data/')

files = data_dir.glob('overlappogram-ar-photons-order=*.fits')

overlappogram = stack_components(sorted(files), wcs_index=2)

fig = plt.figure(figsize=(15,5))
vmin,vmax = AsymmetricPercentileInterval(1,99.9).get_limits(overlappogram[0].data)
#vmin,vmax = None, None
norm = ImageNormalize(vmin=vmin, vmax=vmax, stretch=LogStretch())
ax = fig.add_subplot(projection=overlappogram[0].wcs)
overlappogram[0].plot(
    axes=ax,
    norm=norm,
    data_unit='photon / (pix s)',
    cmap='viridis',
)
color_lat_lon_axes(ax)
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x7fc568ac7370>

Everything is 1

overlappogram_ones = np.ones(overlappogram.data[0].shape)

plt.figure(figsize=(15,5))
vmin, vmax = AsymmetricPercentileInterval(0,100).get_limits(overlappogram_random)
plt.imshow(overlappogram_ones,
           origin='lower', norm=ImageNormalize(vmin=vmin, vmax=vmax, stretch=LogStretch()), interpolation='none', cmap='inferno')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x7fc5689c20b0>

compare_jpeg_ls_compression(overlappogram_ones, compare_format='JPEG', mode='L')

JPEG-LS size:  0.443 kbyte
Other size:  17.957 kbyte

$40.534989 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_ones, compare_format='JPEG2000', mode='I;16')

JPEG-LS size:  0.544 kbyte
Other size:  0.23700000000000002 kbyte

$0.43566176 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_ones, compare_format=None, mode='I;16')

JPEG-LS size:  0.544 kbyte
Other size:  3000.0 kbyte

$5514.7059 \; \mathrm{}$

Everything is 0

overlappogram_zeros = np.zeros(overlappogram.data[0].shape)

plt.figure(figsize=(15,5))
vmin, vmax = AsymmetricPercentileInterval(0,100).get_limits(overlappogram_random)
plt.imshow(overlappogram_zeros,
           origin='lower', norm=ImageNormalize(vmin=vmin, vmax=vmax, stretch=LogStretch()), interpolation='none', cmap='inferno')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x7fc5688a3430>

compare_jpeg_ls_compression(overlappogram_zeros, compare_format='JPEG', mode='L')

JPEG-LS size:  0.17500000000000002 kbyte
Other size:  17.957 kbyte

$102.61143 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_zeros, compare_format='JPEG2000', mode='I;16')

JPEG-LS size:  0.19 kbyte
Other size:  0.23800000000000002 kbyte

$1.2526316 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_zeros, compare_format=None, mode='I;16')

JPEG-LS size:  0.19 kbyte
Other size:  3000.0 kbyte

$15789.474 \; \mathrm{}$

Random Counts

Random distribution of counts over the detector

overlappogram_random = np.random.randint(0, high=5, size=overlappogram.data[0].shape, dtype=np.uint16)

plt.figure(figsize=(15,5))
vmin, vmax = AsymmetricPercentileInterval(0,100).get_limits(overlappogram_random)
plt.imshow(overlappogram_random,
           origin='lower', norm=ImageNormalize(vmin=vmin, vmax=vmax, stretch=LogStretch()), interpolation='none', cmap='inferno')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x7fc56879ece0>

compare_jpeg_ls_compression(overlappogram_random, compare_format='JPEG', mode='L')

JPEG-LS size:  538.343 kbyte
Other size:  23.185 kbyte

$0.043067338 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_random, compare_format='JPEG2000', mode='I;16')

JPEG-LS size:  546.984 kbyte
Other size:  535.896 kbyte

$0.97972884 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_random, compare_format=None, mode='I;16')

JPEG-LS size:  546.984 kbyte
Other size:  3000.0 kbyte

$5.4846211 \; \mathrm{}$

Thresholding non-zero values

This just makes everything over some threshold value 1 and everything else 0

overlappogram_bool = (overlappogram.data[0] > 0.001).astype(np.uint16)

plt.figure(figsize=(15,5))
vmin, vmax = AsymmetricPercentileInterval(0,100).get_limits(overlappogram_bool)
plt.imshow(overlappogram_bool,
           origin='lower', norm=ImageNormalize(vmin=vmin, vmax=vmax, stretch=LogStretch()), interpolation='none', cmap='inferno')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x7fc568671e10>

compare_jpeg_ls_compression(overlappogram_bool, compare_format='JPEG', mode='L')

JPEG-LS size:  5.287 kbyte
Other size:  18.046 kbyte

$3.4132779 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_bool, compare_format='JPEG2000', mode='I;16')

JPEG-LS size:  6.008 kbyte
Other size:  7.162 kbyte

$1.1920772 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_bool, compare_format=None, mode='I;16')

JPEG-LS size:  6.008 kbyte
Other size:  3000.0 kbyte

$499.33422 \; \mathrm{}$

Sampling from a Poisson Distribution

Use the simulated image create a Poisson distribution for each pixel.

dt = 1 * u.s

probability_rate = overlappogram[0].data * overlappogram.unit * u.pix

counts = np.random.poisson(lam=(probability_rate*dt).to_value('photon'))

counts

array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]])

plt.figure(figsize=(15,5))
vmin, vmax = AsymmetricPercentileInterval(0,100).get_limits(counts)
plt.imshow(counts,
           origin='lower', norm=ImageNormalize(vmin=vmin, vmax=vmax, stretch=LogStretch()), interpolation='none', cmap='inferno')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x7fc5684077f0>

compare_jpeg_ls_compression(counts, compare_format='JPEG', mode='L')

JPEG-LS size:  0.589 kbyte
Other size:  17.957 kbyte

$30.487267 \; \mathrm{}$

compare_jpeg_ls_compression(counts, compare_format='JPEG2000', mode='I;16')

JPEG-LS size:  0.81 kbyte
Other size:  1.0110000000000001 kbyte

$1.2481481 \; \mathrm{}$

compare_jpeg_ls_compression(counts, compare_format=None, mode='I;16')

JPEG-LS size:  0.81 kbyte
Other size:  3000.0 kbyte

$3703.7037 \; \mathrm{}$

Scaling Up the Overlappogram Image

scaling_factor = 1 / overlappogram.data[0][np.nonzero(overlappogram.data[0])].min()

overlappogram_scaled = (overlappogram.data[0] * scaling_factor).astype(np.uint16)

plt.figure(figsize=(15,5))
vmin, vmax = AsymmetricPercentileInterval(0,100).get_limits(overlappogram_scaled)
plt.imshow(overlappogram_scaled,
           origin='lower', norm=ImageNormalize(vmin=vmin, vmax=vmax, stretch=LogStretch()), interpolation='none', cmap='inferno')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x7fc568378f10>

compare_jpeg_ls_compression(overlappogram_scaled, compare_format='JPEG', mode='L')

JPEG-LS size:  148.861 kbyte
Other size:  63.115 kbyte

$0.42398613 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_scaled, compare_format='JPEG2000', mode='I;16')

JPEG-LS size:  601.905 kbyte
Other size:  607.489 kbyte

$1.0092772 \; \mathrm{}$

compare_jpeg_ls_compression(overlappogram_scaled, compare_format=None, mode='I;16')

JPEG-LS size:  601.905 kbyte
Other size:  3000.0 kbyte

$4.9841752 \; \mathrm{}$

Conclusions

• JPEG2000 and JPEG-LS provide similar compression in nearly all cases

• JPEG-LS provides marginally better performance (factor of \(\approx1.2\)) than JPEG2000 for Poisson sampling case

• The noiser the image, the worse JPEG-LS does compared to normal JPEG–see uniform distribution case above

• The more areas of continuous tone the better the performance

• More zeros perform better than more non-zeros

• JPEG-LS provides a factor of \(\approx30\) better compression than JPEG for most realistic case of Poisson sampling

• The more photons we have, the worse JPEG-LS will do