Struct QuantumImageEncoder 

pub struct QuantumImageEncoder {
    pub method: ImageEncodingMethod,
    pub num_qubits: usize,
    pub encoding_circuits: Vec<Circuit<16>>,
    pub parameters: Array1<f64>,
}

Quantum image encoder

Fields

method: ImageEncodingMethod

Encoding method

num_qubits: usize

Number of qubits

encoding_circuits: Vec<Circuit<16>>

Encoding circuits

parameters: Array1<f64>

Encoding parameters

Implementations

impl QuantumImageEncoder

pub fn new(method: ImageEncodingMethod, num_qubits: usize) -> Result<Self>

Create new quantum image encoder

Examples found in repository

examples/computer_vision.rs (line 89)

fn image_encoding_demo() -> Result<()> {
    println!("   Testing quantum image encoding methods...");

    let encoding_methods = vec![
        ("Amplitude Encoding", ImageEncodingMethod::AmplitudeEncoding),
        (
            "Angle Encoding",
            ImageEncodingMethod::AngleEncoding {
                basis: "y".to_string(),
            },
        ),
        ("FRQI", ImageEncodingMethod::FRQI),
        ("NEQR", ImageEncodingMethod::NEQR { gray_levels: 256 }),
        ("QPIE", ImageEncodingMethod::QPIE),
        (
            "Hierarchical",
            ImageEncodingMethod::HierarchicalEncoding { levels: 3 },
        ),
    ];

    // Create test image
    let test_image = create_test_image(1, 3, 64, 64)?;

    for (name, method) in encoding_methods {
        println!("\n   --- {name} ---");

        let encoder = QuantumImageEncoder::new(method, 12)?;

        // Encode image
        let encoded = encoder.encode(&test_image)?;

        println!("   Original shape: {:?}", test_image.dim());
        println!("   Encoded shape: {:?}", encoded.dim());

        // Analyze encoding properties
        let encoding_stats = analyze_encoding(&test_image, &encoded)?;
        println!("   Encoding statistics:");
        println!(
            "   - Information retention: {:.2}%",
            encoding_stats.info_retention * 100.0
        );
        println!(
            "   - Compression ratio: {:.2}x",
            encoding_stats.compression_ratio
        );
        println!(
            "   - Quantum advantage: {:.2}x",
            encoding_stats.quantum_advantage
        );

        // Check specific properties for each encoding
        match name {
            "Amplitude Encoding" => {
                println!("   ✓ Efficient for low-resolution grayscale images");
            }
            "Angle Encoding" => {
                println!("   ✓ Preserves spatial correlations");
            }
            "FRQI" => {
                println!("   ✓ Flexible representation with position-color encoding");
            }
            "NEQR" => {
                println!("   ✓ Enhanced representation with multi-level gray encoding");
            }
            "QPIE" => {
                println!("   ✓ Probability-based encoding for quantum processing");
            }
            "Hierarchical" => {
                println!("   ✓ Multi-scale encoding for feature hierarchy");
            }
            _ => {}
        }
    }

    Ok(())
}

pub fn encode(&self, images: &Array4<f64>) -> Result<Array4<f64>>

Encode images to quantum states

Examples found in repository

examples/computer_vision.rs (line 92)

fn image_encoding_demo() -> Result<()> {
    println!("   Testing quantum image encoding methods...");

    let encoding_methods = vec![
        ("Amplitude Encoding", ImageEncodingMethod::AmplitudeEncoding),
        (
            "Angle Encoding",
            ImageEncodingMethod::AngleEncoding {
                basis: "y".to_string(),
            },
        ),
        ("FRQI", ImageEncodingMethod::FRQI),
        ("NEQR", ImageEncodingMethod::NEQR { gray_levels: 256 }),
        ("QPIE", ImageEncodingMethod::QPIE),
        (
            "Hierarchical",
            ImageEncodingMethod::HierarchicalEncoding { levels: 3 },
        ),
    ];

    // Create test image
    let test_image = create_test_image(1, 3, 64, 64)?;

    for (name, method) in encoding_methods {
        println!("\n   --- {name} ---");

        let encoder = QuantumImageEncoder::new(method, 12)?;

        // Encode image
        let encoded = encoder.encode(&test_image)?;

        println!("   Original shape: {:?}", test_image.dim());
        println!("   Encoded shape: {:?}", encoded.dim());

        // Analyze encoding properties
        let encoding_stats = analyze_encoding(&test_image, &encoded)?;
        println!("   Encoding statistics:");
        println!(
            "   - Information retention: {:.2}%",
            encoding_stats.info_retention * 100.0
        );
        println!(
            "   - Compression ratio: {:.2}x",
            encoding_stats.compression_ratio
        );
        println!(
            "   - Quantum advantage: {:.2}x",
            encoding_stats.quantum_advantage
        );

        // Check specific properties for each encoding
        match name {
            "Amplitude Encoding" => {
                println!("   ✓ Efficient for low-resolution grayscale images");
            }
            "Angle Encoding" => {
                println!("   ✓ Preserves spatial correlations");
            }
            "FRQI" => {
                println!("   ✓ Flexible representation with position-color encoding");
            }
            "NEQR" => {
                println!("   ✓ Enhanced representation with multi-level gray encoding");
            }
            "QPIE" => {
                println!("   ✓ Probability-based encoding for quantum processing");
            }
            "Hierarchical" => {
                println!("   ✓ Multi-scale encoding for feature hierarchy");
            }
            _ => {}
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for QuantumImageEncoder

fn clone(&self) -> QuantumImageEncoder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QuantumImageEncoder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.