Image retrieve functions

geqie/cli.py

@@ -52,6 +52,13 @@ def _get_encoding_functions(params: Dict):
     return EncodingFunctions(init_function, data_function, map_function)
 
 
+def _get_retrive_function(params: Dict):
+    encoding_path = params.get("encoding")
+    retrieve_path = f"{encoding_path}/retrieve.py"
+    retrieve_function = getattr(_import_module("retrieve", retrieve_path), "retrieve")
+    return retrieve_function
+
+
 def _parse_image(params):
     image = Image.open(params.get("image"))
     if params.get("grayscale"):
@@ -89,6 +96,15 @@ def wrapper(*args, **kwargs):
     return wrapper
 
 
+def retrive_options(func):
+    @cloup.option("--encoding", required=True, type=str, help="Name of the encoding from 'encodings' directory")   
+    @cloup.option("--result", required=True, type=str, help="Result from simulation")   
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    return wrapper
+
+
 @cli.command()
 @encoding_options
 def encode(**params):
@@ -117,6 +133,15 @@ def simulate(ctx: cloup.Context, **params):
     print(json.dumps(main.simulate(circuit, **cli_params)))
 
 
+@cli.command()
+@retrive_options
+def retrieve(**params):
+    print('Retrieve CLI')
+    print(f'Params.get("result"): {params.get("result")}')
+    retrieve_function = _get_retrive_function(params)
+    print(retrieve_function(params.get("result")))
+
+
 if __name__ == '__main__':
     cli()
 

geqie/encodings/frqi/__init__.py

@@ -1,3 +1,4 @@
 from .init import init as init_function
 from .data import data as data_function
-from .map import map as map_function
+from .map import map as map_function
+from .retrieve import retrieve as retrieve_function

geqie/encodings/frqi/retrieve.py

@@ -0,0 +1,41 @@
+import numpy as np
+import json
+
+def retrieve(results: str) -> np.ndarray:
+    """
+    Decodes an image from quantum state measurement results.
+
+    Parameters:
+    results (dict): A dictionary where keys are binary strings representing quantum states,
+                         and values are their respective occurrence counts.
+
+    Returns:
+    np.ndarray: A NumPy array representing the decoded image.
+    """
+    state_length = len(next(iter(results)))
+    color_qubits = 1
+    number_of_position_qubits = state_length - color_qubits
+    x_qubits = number_of_position_qubits // 2
+    y_qubits = number_of_position_qubits // 2
+
+    image_shape = (2**x_qubits, 2**y_qubits)
+
+    reconstructed_image = np.zeros((image_shape[0], image_shape[1]))
+
+    ones = np.zeros_like(reconstructed_image)
+    total = np.zeros_like(reconstructed_image)
+
+    for state, n in results.items():
+        b = state[:-1]
+        c = state[-1]
+
+        m = int(b, base=2)
+        total.flat[m] += n
+        if c == "1":
+            ones.flat[m] += n
+
+    reconstructed_image = ones / total
+    reconstructed_image = np.where(total > 0, ones / total, 0)
+
+
+    return reconstructed_image

geqie/encodings/ifrqi/__init__.py

@@ -1,3 +1,4 @@
 from .init import init as init_function
 from .data import data as data_function
-from .map import map as map_function
+from .map import map as map_function
+from .retrieve import retrieve as retrieve_function

geqie/encodings/ifrqi/retrieve.py

@@ -0,0 +1,59 @@
+import numpy as np
+import json
+
+def retrieve(results: str) -> np.ndarray:
+    """
+    Decodes an image from quantum state measurement results.
+
+    Parameters:
+    results (dict): A dictionary where keys are binary strings representing quantum states,
+                         and values are their respective occurrence counts.
+
+    Returns:
+    np.ndarray: A NumPy array representing the decoded image.
+    """
+    state_length = len(next(iter(results)))
+    color_qubits = 4
+    number_of_position_qubits = state_length - color_qubits
+    x_qubits = number_of_position_qubits // 2
+    y_qubits = number_of_position_qubits // 2
+
+    image_shape = (2**x_qubits, 2**y_qubits)
+
+    reconstructed_image = np.zeros((image_shape[0], image_shape[1]))
+
+    reconstructed_image_counts_total = np.zeros((image_shape[0], image_shape[1]), dtype=int)
+    reconstructed_image_counts_ones = np.zeros((image_shape[0], image_shape[1], color_qubits), dtype=int)
+
+    for state, n in results.items():  
+        x = state[0: x_qubits]
+        y = state[y_qubits: number_of_position_qubits]
+
+        c = state[number_of_position_qubits: number_of_position_qubits + color_qubits][::-1]
+
+        x_dec = int(x, base=2)
+        y_dec = int(y, base=2)
+
+        reconstructed_image_counts_total[x_dec, y_dec] += n
+
+        for count in range(len(c)):
+            if c[count] == "1":
+                reconstructed_image_counts_ones[x_dec, y_dec, count] += n
+
+    for x in range(reconstructed_image_counts_ones.shape[0]):
+        for y in range(reconstructed_image_counts_ones.shape[1]):
+            color_bit_string = ""
+            for c in range(color_qubits):
+                coeff = reconstructed_image_counts_ones[x, y, c]/reconstructed_image_counts_total[x, y]
+                if coeff > .75:
+                    color_bit_string += "11"
+                elif .5 < coeff < .75:
+                    color_bit_string += "10"
+                elif .25 < coeff < .5:
+                    color_bit_string += "01"
+                elif coeff < .25:
+                    color_bit_string += "00"
+
+            reconstructed_image[x, y] = int(color_bit_string[::-1], base=2)
+
+    return reconstructed_image

geqie/encodings/mcqi/__init__.py

@@ -1,3 +1,4 @@
 from .init import init as init_function
 from .data import data as data_function
-from .map import map as map_function
+from .map import map as map_function
+from .retrieve import retrieve as retrieve_function

geqie/encodings/mcqi/retrieve.py

@@ -0,0 +1,53 @@
+import numpy as np
+import json
+
+def retrieve(results: str) -> np.ndarray:
+    """
+    Decodes an image from quantum state measurement results.
+
+    Parameters:
+    results (dict): A dictionary where keys are binary strings representing quantum states,
+                         and values are their respective occurrence counts.
+
+    Returns:
+    np.ndarray: A NumPy array representing the decoded image.
+    """
+    state_length = len(next(iter(results)))
+    number_of_position_qubits = state_length - 3
+    x_qubits = number_of_position_qubits // 2
+    y_qubits = number_of_position_qubits // 2
+
+    image_shape = (2**x_qubits, 2**y_qubits)
+
+    reconstructed_image = np.zeros((image_shape[0], image_shape[1], 3))
+
+    ones = np.zeros((image_shape[0], image_shape[1], 3))
+    total = np.zeros((image_shape[0], image_shape[1], 3))
+
+    for state, n in results.items():
+        if n > 0:
+            x = state[0:x_qubits]
+            y = state[x_qubits: 2*y_qubits]
+            x_dec = int(x, base=2)
+            y_dec = int(y, base=2)
+            c = state[2*y_qubits: 2*y_qubits+3]
+
+            # if Red:
+            if c[0:2] == "00":
+                if c[-1] == "1":
+                    ones[x_dec, y_dec, 0] = n
+                total[x_dec, y_dec, 0] += n
+            # if Green:
+            if c[0:2] == "01":
+                if c[-1] == "1":
+                    ones[x_dec, y_dec, 1] = n
+                total[x_dec, y_dec, 1] += n
+            # if Blue:
+            if c[0:2] == "10":
+                if c[-1] == "1":
+                    ones[x_dec, y_dec, 2] = n
+                total[x_dec, y_dec, 2] += n
+
+    reconstructed_image = ones / total
+
+    return (reconstructed_image*255).astype(np.uint8)

geqie/encodings/ncqi/__init__.py

@@ -1,3 +1,4 @@
 from .init import init as init_function
 from .data import data as data_function
-from .map import map as map_function
+from .map import map as map_function
+from .retrieve import retrieve as retrieve_function

geqie/encodings/ncqi/retrieve.py

@@ -0,0 +1,38 @@
+import numpy as np
+import json
+
+def retrieve(results: str) -> np.ndarray:
+    """
+    Decodes an image from quantum state measurement results.
+
+    Parameters:
+    results (dict): A dictionary where keys are binary strings representing quantum states,
+                         and values are their respective occurrence counts.
+
+    Returns:
+    np.ndarray: A NumPy array representing the decoded image.
+    """
+    state_length = len(next(iter(results)))
+    color_qubits = 10
+    number_of_position_qubits = state_length - color_qubits
+    x_qubits = number_of_position_qubits // 2
+    y_qubits = number_of_position_qubits // 2
+
+    image_shape = (2**x_qubits, 2**y_qubits)
+    reconstructed_image = np.zeros((image_shape[0], image_shape[1], 3))
+
+    for state, n in results.items():
+        if n > 0:
+            x = state[0:x_qubits]
+            y = state[y_qubits: number_of_position_qubits]
+            c = state[number_of_position_qubits: number_of_position_qubits+color_qubits+1] # It's 10+1 because of python array indexing
+            x_dec = int(x, base=2)
+            y_dec = int(y, base=2)
+            if c[8:10] == "00":
+                reconstructed_image[x_dec, y_dec, 0] = int(c[0:8], base=2)
+            elif c[8:10] == "01":
+                reconstructed_image[x_dec, y_dec, 1] = int(c[0:8], base=2)
+            elif c[8:10] == "10":
+                reconstructed_image[x_dec, y_dec, 2] = int(c[0:8], base=2)
+
+    return reconstructed_image.astype(np.uint8)

geqie/encodings/neqr/__init__.py

@@ -1,3 +1,4 @@
 from .init import init as init_function
 from .data import data as data_function
-from .map import map as map_function
+from .map import map as map_function
+from .retrieve import retrieve as retrieve_function

geqie/encodings/neqr/retrieve.py

@@ -0,0 +1,36 @@
+import numpy as np
+import json
+
+def retrieve(results: str) -> np.ndarray:
+    """
+    Decodes an image from quantum state measurement results.
+
+    Parameters:
+    results (dict): A dictionary where keys are binary strings representing quantum states,
+                         and values are their respective occurrence counts.
+
+    Returns:
+    np.ndarray: A NumPy array representing the decoded image.
+    """
+    state_length = len(next(iter(results)))
+    color_qubits = 8
+    number_of_position_qubits = state_length - color_qubits
+    x_qubits = number_of_position_qubits // 2
+    y_qubits = number_of_position_qubits // 2
+
+    image_shape = (2**x_qubits, 2**y_qubits)
+    reconstructed_image = np.zeros((image_shape[0], image_shape[1]))
+
+    for state, n in results.items():
+        if n > 0:
+            x = state[0:x_qubits]
+            y = state[x_qubits:number_of_position_qubits]
+
+            c = state[number_of_position_qubits:number_of_position_qubits+color_qubits+1]
+
+            x_dec = int(x, base=2)
+            y_dec = int(y, base=2)
+            c_dec = int(c, base=2)
+            reconstructed_image[x_dec, y_dec] = c_dec
+
+    return reconstructed_image.astype(np.uint8)

geqie/encodings/qrci/__init__.py

@@ -1,3 +1,4 @@
 from .init import init as init_function
 from .data import data as data_function
-from .map import map as map_function
+from .map import map as map_function
+from .retrieve import retrieve as retrieve_function

geqie/encodings/qrci/retrieve.py

@@ -0,0 +1,44 @@
+import numpy as np
+import json
+
+def retrieve(results: str) -> np.ndarray:
+    """
+    Decodes an image from quantum state measurement results.
+
+    Parameters:
+    results (dict): A dictionary where keys are binary strings representing quantum states,
+                         and values are their respective occurrence counts.
+
+    Returns:
+    np.ndarray: A NumPy array representing the decoded image.
+    """
+    state_length = len(next(iter(results)))
+    color_qubits = 3
+    lxy_qubits = 3
+    number_of_position_qubits = state_length - color_qubits - lxy_qubits
+    x_qubits = number_of_position_qubits // 2
+    y_qubits = number_of_position_qubits // 2
+
+    image_shape = (2**x_qubits, 2**y_qubits)
+    reconstructed_image = np.zeros((image_shape[0], image_shape[1], 3))
+
+    for state, n in results.items():
+        if n > 0:
+            x = state[0:x_qubits]
+            y = state[x_qubits:number_of_position_qubits]
+            lxy = state[number_of_position_qubits: number_of_position_qubits+lxy_qubits]
+            rgb = state[number_of_position_qubits+lxy_qubits: number_of_position_qubits+lxy_qubits+color_qubits]
+
+
+            lxy_dec = abs(int(lxy, base=2)-(lxy_qubits+color_qubits+1))
+            x_dec = int(x, base=2)
+            y_dec = int(y, base=2)
+
+            if rgb[0] == '1':
+                reconstructed_image[x_dec, y_dec, 0] += (2**(lxy_dec))
+            if rgb[1] == '1':
+                reconstructed_image[x_dec, y_dec, 1] += (2**(lxy_dec))
+            if rgb[2] == '1':
+                reconstructed_image[x_dec, y_dec, 2] += (2**(lxy_dec))
+
+    return reconstructed_image.astype(np.uint8)

geqie/encodings/qualpi/__init__.py

@@ -1,3 +1,4 @@
 from .init import init as init_function
 from .data import data as data_function
-from .map import map as map_function
+from .map import map as map_function
+from .retrieve import retrieve as retrieve_function