diff --git a/demos/brqi.md b/demos/brqi.md new file mode 100644 index 0000000..94aceb4 --- /dev/null +++ b/demos/brqi.md @@ -0,0 +1,97 @@ + +# BRQI Demo + +This demo showcases the Bitplane Representation of Quantum Images (BRQI) using the piQture library. It demonstrates how to load an image, convert it to a quantum circuit using BRQI encoding, and visualize the results. + +## Prerequisites + +- Python 3.7+ +- piQture library +- Qiskit +- NumPy +- Pillow (PIL) +- Matplotlib + +## Installation + +1. Install the required libraries: + +``` +pip install piqture qiskit qiskit-aer numpy pillow matplotlib +``` + +2. Clone the piQture repository or ensure you have the BRQI module available. + +## Usage + +1. Place your input image in a known location. + +2. Update the `image_path` variable in the `main()` function: + + +``` +def main(): + # Path to your input image + image_path = '/Users/dylanmoraes/Downloads/image-1.png' +``` + + +3. Run the script: + +``` +python brqi_demo.py +``` + +## How it works + +The demo follows these steps: + +1. **Load and preprocess the image**: + - Opens the image file + - Converts it to grayscale + - Resizes it to a small dimension (default 4x4) + - Normalizes pixel values to the range [0, 255] + +2. **Create BRQI circuit**: + - Initializes a BRQI object with the image dimensions and pixel values + - Generates the quantum circuit representation of the image + +3. **Visualize results**: + - Displays the original image + - Simulates the quantum circuit using Qiskit's QASM simulator + - Plots a histogram of the measurement results + +## Customization + +- To change the target size of the image, modify the `target_size` parameter in the `load_and_preprocess_image()` function call: + + +```67:67:demos/brqi_demo.py + img_array = load_and_preprocess_image(image_path) +``` + + +- To adjust the number of shots in the quantum simulation, change the `shots` parameter in the `backend.run()` function: + + +``` + job = backend.run(transpiled_circuit, shots=1000) +``` + + +## Understanding the Output + +The script will display two plots: +1. The original grayscale image +2. A histogram of the measurement results from the quantum circuit simulation + +The histogram represents the probability distribution of different quantum states, which encodes the information from the original image in the BRQI format. + +## Troubleshooting + +If you encounter any issues: +- Ensure all required libraries are installed correctly +- Check that the image path is correct and the file exists +- Verify that the piQture library and BRQI module are properly imported + +For more information on the BRQI encoding method and the piQture library, refer to the main piQture documentation. diff --git a/demos/brqi_demo.py b/demos/brqi_demo.py new file mode 100644 index 0000000..fe1298d --- /dev/null +++ b/demos/brqi_demo.py @@ -0,0 +1,119 @@ +# pylint: disable=R0801 +"""Demo script for BRQI (Binary Representation of Quantum Images) encoding. + +This script demonstrates how to load an image, convert it to BRQI representation, +and visualize the results using quantum circuit simulation. +""" + +import matplotlib.pyplot as plt +import numpy as np +from PIL import Image +from qiskit import transpile +from qiskit.visualization import plot_histogram +from qiskit_aer import Aer + +from piqture.embeddings.image_embeddings.brqi import BRQI + + +def load_and_preprocess_image(image_path, target_size=(4, 4)): + """Load and preprocess an image for BRQI encoding. + + Args: + image_path (str): Path to the input image file + target_size (tuple): Desired dimensions for the resized image (default: (4, 4)) + + Returns: + numpy.ndarray: Preprocessed image array with normalized pixel values + """ + # Load the image + img = Image.open(image_path) + + # Convert to grayscale + img = img.convert("L") + + # Resize the image + img = img.resize(target_size) + + # Convert to numpy array + img_array = np.array(img) + + # Normalize pixel values to range [0, 255] + img_array = (img_array / img_array.max() * 255).astype(int) + + return img_array + + +def create_brqi_circuit(img_array): + """Create a quantum circuit using BRQI encoding for the input image. + + Args: + img_array (numpy.ndarray): Input image array with pixel values + + Returns: + QuantumCircuit: BRQI encoded quantum circuit + """ + img_dims = img_array.shape + pixel_vals = [img_array.flatten().tolist()] + + # Create BRQI object + brqi_object = BRQI(img_dims, pixel_vals) + + # Generate BRQI circuit + brqi_circuit = brqi_object.brqi() + + return brqi_circuit + + +def visualize_results(original_image, brqi_circuit): + """Visualize the original image and quantum circuit simulation results. + + Args: + original_image (numpy.ndarray): The original input image array + brqi_circuit (QuantumCircuit): The BRQI encoded quantum circuit + + Returns: + None: Displays plots of the original image and measurement results + """ + # Display original image + plt.figure(figsize=(10, 5)) + plt.subplot(1, 2, 1) + plt.imshow(original_image, cmap="gray") + plt.title("Original Image") + + # Simulate the quantum circuit + backend = Aer.get_backend("qasm_simulator") + transpiled_circuit = transpile(brqi_circuit, backend) + job = backend.run(transpiled_circuit, shots=1000) + result = job.result() + counts = result.get_counts() + + # Plot the histogram of measurement results + plt.subplot(1, 2, 2) + plot_histogram(counts) + plt.title("BRQI Measurement Results") + + plt.tight_layout() + plt.show() + + +def main(): + """Main function to demonstrate BRQI encoding on an image. + + This function serves as the entry point for the demo script. + It loads an image, creates a BRQI circuit, and visualizes the results. + """ + # Path to your input image + image_path = "/path/to/image.jpg" + + # Load and preprocess the image + img_array = load_and_preprocess_image(image_path) + + # Create BRQI circuit + brqi_circuit = create_brqi_circuit(img_array) + + # Visualize results + visualize_results(img_array, brqi_circuit) + + +if __name__ == "__main__": + main()