Using NI Vision and Intel IPP Together From Rust — A Practical Guide

Many engineering teams inherit or maintain systems built on NI Vision (National Instruments Vision Development Module) and Intel IPP (Integrated Performance Primitives). These C libraries are widely used in industrial imaging, automation, robotics, and high‑performance signal processing.

Modern Rust projects often need to call into these older but highly optimized native libraries. In this AI-generated article, I’ll walk through how to:

• Integrate NI Vision and Intel IPP inside the same Rust project,
• Creating and manipulating an NI image buffer from Rust,
• Filling it with random U16 values,
• Scanning for the maximum pixel value using:
  • Pure Rust
  • Intel IPP’s highly optimized functions
• Handling pointer conversions, strides, ROIs, and NI’s image metadata.

This is a fully working example, runnable on Windows with NI Vision + Intel IPP installed.

Why Combine NI Vision and Intel IPP?

NI Vision provides:

• unified image representation (IMAQ_IMAGE_U8, IMAQ_IMAGE_U16, etc.)
• convenient APIs for loading, displaying, allocating, and disposing images
• ROI utilities
• pixel addressing and image metadata

Intel IPP provides:

• extremely fast pixel‑wise operations
• efficient vectorized algorithms (SSE/AVX)
• functions like ippiMaxIndx_16u_C1R that outperform manual loops

Using both allows you to:

• manage and display images with NI Vision
• run computationally heavy per‑pixel operations with Intel IPP

Rust serves as a safe “host language” that orchestrates both libraries.

FFI Bindings Setup

The example assumes you have:

mod ipp;       // Your Intel IPP FFI bindings
mod nivision;  // Your NI Vision FFI bindings

These modules contain function signatures generated via bindgen or manually written wrappers.

Full Example: NI Vision + IPP From Rust

Below is the complete minimal example that demonstrates:

1. Creating a U16 image via NI Vision
2. Filling it with random pixels
3. Finding the max value via:
   • Rust slice scan
   • Intel IPP optimized scan
4. Displaying the final image

#![allow(unused_imports)]

mod ipp;
mod nivision;

use crate::{ipp::*, nivision::*};
use std::io::{self, Read};
use std::os::raw::{c_int, c_void};
use std::slice;

fn main() {
    unsafe {
        let width = 500;
        let height = 500;

        let image = imaqCreateImage(ImageType_enum_IMAQ_IMAGE_U16, 0);
        imaqSetImageSize(image, width, height);

        // Fill NI image with random U16 values
        for y in 0..height {
            for x in 0..width {
                let value: u16 = rand::random();
                let pv = PixelValue {
                    grayscale: value as f32,
                };
                imaqSetPixel(image, Point { x, y }, pv);
            }
        }

        // ---------------------------------------------------------------------
        // Method 1: Rust max scan via imaqImageToArray
        // ---------------------------------------------------------------------
        let (mut cols, mut rows) = (0, 0);

        let arr = imaqImageToArray(
            image,
            imaqMakeRect(0, 0, i32::MAX, i32::MAX),
            &mut cols,
            &mut rows,
        );

        if arr.is_null() {
            panic!("imaqImageToArray returned null");
        }

        let pixel_count = (cols * rows) as usize;
        let src = slice::from_raw_parts(arr as *const u16, pixel_count);

        let (mut max_val1, mut max_x1, mut max_y1) = (0u16, 0, 0);

        for (i, &v) in src.iter().enumerate() {
            if v > max_val1 {
                max_val1 = v;
                max_x1 = (i as i32) % cols;
                max_y1 = (i as i32) / cols;
            }
        }

        println!("Rust scan max = {} at ({}, {})", max_val1, max_x1, max_y1);

        // ---------------------------------------------------------------------
        // Method 2: Intel IPP max scan (16u)
        // ---------------------------------------------------------------------
        let mut info: ImageInfo_struct = std::mem::zeroed();
        if imaqGetImageInfo(image, &mut info) == 0 {
            panic!("imaqGetImageInfo failed");
        }

        let src_step = info.pixelsPerLine * 2; // U16 -> 2 bytes per pixel

        let pix_ptr = imaqGetPixelAddress(image, Point { x: 0, y: 0 });
        if pix_ptr.is_null() {
            panic!("imaqGetPixelAddress returned null");
        }

        let p_src = pix_ptr as *const Ipp16u;

        let roi = IppiSize {
            width: info.xRes,
            height: info.yRes,
        };

        let (mut max_val2, mut max_x2, mut max_y2) = (0u16, 0, 0);

        let ipp_status = ippiMaxIndx_16u_C1R(
            p_src,
            src_step,
            roi,
            &mut max_val2,
            &mut max_x2,
            &mut max_y2,
        );

        if ipp_status != ippStsNoErr {
            panic!("ippiMaxIndx_16u_C1R failed: {}", ipp_status);
        }

        println!("IPP max = {} at ({}, {})", max_val2, max_x2, max_y2);

        // ---------------------------------------------------------------------

        imaqDisplayImage(image, 0, 0);

        println!("Press Enter to continue...");
        let _ = io::stdin().read(&mut [0]);

        imaqDispose(image as *mut c_void);
        imaqDispose(arr as *mut c_void);
    }
}

Understanding the Memory Model: NI Vision vs IPP

NI Vision Images

NI Vision stores image buffers using this struct:

• pixelsPerLine: row stride in BYTES
• xRes, yRes: actual width and height
• imageStart: pointer to pixel buffer
• optional “border” padding

Intel IPP

IPP functions require:

• pSrc: pointer to raw pixel data
• srcStep: stride in BYTES
• IppiSize { width, height }

So, to call IPP correctly:

srcStep = pixelsPerLine * bytes_per_pixel

For U16:

bytes_per_pixel = 2

This mapping is essential — incorrect stride causes image corruption, banding, or buffer overruns.

Comparing Performance

For large images (4MP+), IPP’s advantage becomes dramatic.

When Should You Use Rust, NI Vision, or IPP?

Lessons Learned

• Rust can interoperate efficiently with C FFIs like NI Vision and IPP.
• NI Vision provides excellent image management utilities but is not always optimal for large pixel‑wise operations.
• IPP provides extremely fast primitives — but only when stride and pixel format are correct.
• Rust’s safety guarantees still allow performant, controlled pointer usage inside isolated unsafe blocks.
• Combining all three creates a powerful, modern imaging pipeline.

Conclusion

This example demonstrates a complete and practical approach to mixing:

• NI Vision’s image management
• Intel IPP’s high‑performance pixel operations
• Rust’s memory safety, performance, and expressiveness

Whether you’re migrating a legacy LabVIEW/NIVision/IPP pipeline or building a new system, this pattern provides a robust way to leverage existing optimized native libraries while writing new code in Rust.

If you’d like a follow‑up article (e.g., zero-copy IPP ROI operations or vectorizing Rust loops), I’d be happy to draft part 2.