Algorithm for packing images in increments of quality - algorithm

Question

I wish to pack an image as a low-quality image along with packets of "quality increments", such that patching the low-quality image with the "quality increments" increases its quality and brings it closer to the original image.
To put it more clearly,
I want to pack an image as a "base-image" (original image in poor quality, say 10%), and packets q1, q2, q3, .... qn
such that
base-image + q1 = original image at quality 20%
base-image + q1 + q2 = original image at quality 30%
...
base-image + q1 +q2 + .... qn = original image at quality 100%
My requirement is to pack an image and send it via a Single Board Computer (Raspberry Pi). I need to reduce the file size as much as possible, but the image should not be pixelized so much that it is unclear. Using this "Image quality in increments" approach, my idea is to get an image of low quality, and receive only a few increments (say till q3) and deem it "acceptable" so I can stop sending/receiving any more data packets.
Please guide me on how to approach this.

Answer 1

Here's a quick toy example of what I mentioned in the comments
Original:
Rebuilt at 0.2 compression
import cv2
import numpy as np
# load image
img = cv2.imread("image.jpg", cv2.IMREAD_GRAYSCALE);
height, width = img.shape[:2];
max_rank = min([width, height]);
# do svd
columns, diags, rows = np.linalg.svd(img, full_matrices = False);
# rebuild image with reduced rank
rank = int(max_rank * 0.2);
rebuilt = np.dot(columns[:,:rank] * diags[:rank], rows[:rank, :]);
rebuilt = rebuilt.astype(np.uint8)
# show image
cv2.imshow("Image", img);
cv2.imshow("Rebuilt", rebuilt);
cv2.waitKey(0);
The idea here is that you can send each column, diagonal, and row one at a time. The number of full sets you have whenever you decide to stop waiting is the rank that you'll use to reconstruct the image.
A more complete example
import cv2
import numpy as np
# receiver
client = [[], [], []]; # columns, diags, rows
def receive(column, value, row):
# grab global
global client;
# add new data
client[0].append(column);
client[1].append(value);
client[2].append(row);
# load image
img = cv2.imread("image.jpg", cv2.IMREAD_GRAYSCALE);
height, width = img.shape[:2];
max_rank = min([width, height]);
# do svd
columns, diags, rows = np.linalg.svd(img, full_matrices = False);
# "send" data to client one rank at a time
for a in range(max_rank):
# check progress
print("Total Ranks Sent: " + str(a + 1));
# get a single rank
column = columns[:,a];
value = diags[a];
row = rows[a,:];
# "send" to client
receive(column, value, row);
# rebuild image with current client side data
client_cols, client_diags, client_rows = client;
# convert to numpy
client_cols = np.array(client_cols);
client_diags = np.array(client_diags);
client_rows = np.array(client_rows);
client_cols = np.transpose(client_cols);
# rebuild
rebuilt = np.dot(client_cols * client_diags, client_rows);
rebuilt = rebuilt.astype(np.uint8);
# show
cv2.imshow("Rebuilt", rebuilt);
key = cv2.waitKey(0);
# early quit
if key == ord('q'):
break;