Viability of Custom Software Solutions for Infrared Camera

Data Acquisition and Analysis in Plastic Recycling Simulations

I. Introduction
The integration of infrared (IR) thermography into process simulations, particularly for
applications like plastic recycling, presents unique challenges and opportunities for
data acquisition and analysis. Plastic recycling processes often involve monitoring
thermal signatures to differentiate between polymer types, assess contamination, or
understand material degradation. While commercial software packages, such as those
offered by National Instruments (NI), provide comprehensive environments for these
tasks, their use may not always be feasible or optimal, especially in academic research
settings where budgetary constraints, the need for deep algorithmic customization, or
specific simulation requirements might favor alternative approaches.

This report investigates the feasibility of utilizing infrared cameras for simulations in
plastic recycling processes without relying on proprietary software suites like NI
LabVIEW with its associated "snap-ins" (e.g., Vision Development Module, Vision
Acquisition Software). It explores the capabilities of custom and open-source
development pathways, focusing on leveraging standardized communication
protocols, manufacturer-provided Software Development Kits (SDKs), and
open-source libraries, particularly within the Python ecosystem. The analysis
encompasses direct data acquisition techniques, methods for data transfer and
storage, custom data analysis strategies pertinent to plastic characterization, and
essential calibration considerations for accurate thermal analysis. A comparative
analysis of the NI suite versus custom/open-source solutions will be presented,
evaluating aspects such as development time, cost, flexibility, performance, and
reliability. The ultimate aim is to provide a comprehensive assessment and
recommendations for researchers and developers considering custom solutions for IR
camera integration in their simulation environments.

II. Approaches to Infrared Camera Data Acquisition and Analysis

The decision of how to interface with an infrared camera and process its data hinges
on a balance between pre-packaged convenience and the flexibility offered by
custom development. Two primary avenues exist: utilizing integrated software suites
from vendors like National Instruments, or adopting a custom development approach
that leverages standardized protocols, manufacturer SDKs, and open-source libraries.

A. The National Instruments (NI) Software Ecosystem

National Instruments provides a suite of software tools designed for data acquisition,
control, and analysis, which are widely used in industrial and research settings. For
vision applications, including those involving infrared cameras, key components
include the Vision Development Module (VDM) and Vision Acquisition Software (VAS).
●​ 1. Overview of NI Vision Development Module (VDM) and Vision Acquisition
Software (VAS):​
The NI Vision Development Module is an add-on software package for LabVIEW,
C, C++, and C# that offers a comprehensive library of functions for machine
vision and image processing applications. It allows users to configure cameras,
customize image analysis, and generate results for production and validation
tests.1 VDM includes hundreds of image processing algorithms, intellectual
property (IP) for targeting both processors and Field-Programmable Gate Arrays
(FPGAs), and model importers for deploying deep learning models developed in
frameworks like TensorFlow.1​
Vision Acquisition Software (VAS) serves as the driver software layer, enabling the
acquisition, display, and saving of images from a wide array of camera types and
interfaces, including GigE Vision, USB3 Vision, and Camera Link.3 It also provides
capabilities for controlling digital I/O on NI vision hardware.3 NI positions these
tools as facilitating ease of use for applications such as taking thermal
measurements on the manufacturing floor and for systems requiring high-speed,
high-accuracy image acquisition.5
●​ 2. Functionalities for Infrared Camera Interfacing and Data Handling:​
NI software is designed to streamline the process of interfacing with cameras,
including infrared models. The Vision Development Module, in conjunction with
LabVIEW, allows for camera configuration, image acquisition, and subsequent
analysis tailored for production and validation tasks.1 Specifically for thermal
imaging, LabVIEW and IMAQ Vision (a component often associated with VDM and
VAS) are highlighted as suitable tools.5 National Instruments also offers IMAQ
hardware modules for PXI/CompactPCI systems, which are designed to acquire
images from various camera types, including those used for thermal
measurements.5 These IMAQ modules can provide high-speed, high-accuracy
image acquisition with features like region-of-interest acquisition to speed up
processing.5
●​ 3. Advantages of the NI Approach:​
The primary advantages of using the NI ecosystem often revolve around
integration and ease of use. NI actively promotes a streamlined workflow,
sometimes described as taking users from sensor to spreadsheet with minimal
programming effort, particularly with tools like FlexLogger.6 LabVIEW's graphical
 programming environment is frequently cited for its intuitive nature, which can
accelerate development cycles and reduce errors, especially for engineers who
may not be text-based coding experts.8​
A comprehensive toolset is another significant benefit. VDM and associated
software provide a vast array of pre-built functions for image processing, pattern
matching, classification, and hardware control.1 This can save considerable
development time for standard tasks.​
Hardware compatibility is strong, particularly with NI's own extensive range of
data acquisition hardware, frame grabbers, and vision systems.4 This tight
integration can lead to more predictable performance and easier system setup.​
Finally, as an established vendor, NI offers support infrastructure, including
documentation, training, and technical assistance, which can be valuable for
complex projects.1
●​ 4. Disadvantages and Limitations:​
Despite the advantages, the NI approach has notable drawbacks. Cost is a
significant factor; NI software licenses (e.g., VDM development licenses starting
from over $2,000 per year 1) and hardware can be expensive, which can be a
barrier for academic research budgets or smaller projects.11​
The flexibility and "black box" nature of the system can be a limitation. While
powerful for standard applications, it may be less adaptable for highly custom or
novel algorithm development where direct access to underlying processes or
source code is required. The abstraction that provides ease of use can sometimes
obscure the finer details of operations.​
Vendor lock-in is another consideration, as users become reliant on NI's
ecosystem for software updates, hardware compatibility, and support.​
Regarding performance for certain tasks, while LabVIEW is capable of high-speed
operations, particularly with FPGAs, some developers find Python preferable for
more "complicated" algorithmic tasks, and text-based languages can offer more
granular control in specific, performance-critical scenarios.11

The "ease of use" marketed by NI, while a clear advantage for rapid deployment in
standard industrial applications, can translate into a "limitation in depth" for research
scenarios. Academic research, particularly in evolving fields like advanced material
sorting in plastic recycling using thermal imaging, often necessitates the development
of novel algorithms or the significant adaptation of existing ones in non-standard
ways.15 Proprietary environments, even with extensive function libraries like LabVIEW
VDM 1, might not offer the source-level access, transparency, or the specific granular
building blocks required for such cutting-edge research as readily as open-source
libraries (e.g., Python with OpenCV, SciPy). The ability to inspect and modify core
components, a hallmark of open-source methodologies 18, is often paramount for
researchers. Thus, what constitutes a strength (ease of use through abstraction) in
one context (e.g., deploying a known inspection task in industry) can become a
constraint (lack of deep control and transparency) in another (e.g., developing a new
thermal signature analysis method for mixed plastics). This inherent tension often
motivates researchers to explore more transparent and flexible custom solutions.

B. The Custom and Open-Source Development Approach

An alternative to proprietary software suites involves building custom solutions by
leveraging standardized communication protocols, camera manufacturer SDKs, and
open-source libraries. This approach offers greater flexibility and control, often at a
lower direct software cost.
●​ 1. Leveraging Standardized Communication Protocols:​
Industry standards for camera communication are pivotal in enabling
interoperability and simplifying the development of custom vision applications.
Key standards include GenICam, GigE Vision, and USB3 Vision.
○​ GenICam (Generic Interface for Cameras):​
GenICam is a crucial global standard that provides a generic programming
interface for all kinds of cameras and vision devices, irrespective of the
underlying physical interface technology (e.g., GigE Vision, USB3 Vision,
Camera Link).20 Its primary goal is to decouple the camera hardware from
the application software, allowing developers to write generic code that can
work with a wide range of compliant devices.21​
GenICam consists of several main components: GenApi (Generic Application
Programming Interface) defines how camera features (like exposure time,
gain, pixel format) are described and controlled, typically through an XML
device description file provided by the camera manufacturer.20 This XML file
acts as a standardized "datasheet" that software can read to understand and
manipulate camera functionalities. GenTL (Generic Transport Layer) provides
a standardized interface for enumerating devices, acquiring image data, and
managing data streams between the camera and the host computer.21 GenTL
producers (drivers provided by camera or frame grabber manufacturers)
implement this interface, and GenTL consumers (application software or
libraries) use it to communicate with the hardware.​
This architecture promotes manufacturer independence and simplifies the
integration of diverse cameras into a single software application.21 For
developers using Python, libraries such as the official genicam module (which
includes bindings for GenApi and GenTL) and higher-level frameworks like
 Harvester facilitate direct interaction with GenICam-compliant devices,
abstracting some of the lower-level complexities.25
○​ GigE Vision:​
GigE Vision is a widely adopted interface standard built upon Gigabit Ethernet,
designed for high-speed image data transfer and device control in machine
vision applications.20 It defines protocols for device discovery, configuration,
data streaming, and event handling over standard Ethernet networks.24​
Key elements of GigE Vision include the GVCP (GigE Vision Control Protocol),
which handles the sending of control commands to the camera and receiving
status information, and the GVSP (GigE Vision Stream Protocol), which defines
how image data is packetized and transmitted efficiently over Ethernet,
typically using UDP/IP.24 GigE Vision leverages GenICam for describing and
accessing camera features, ensuring a consistent programming model across
different GigE Vision cameras.24​
The benefits of GigE Vision include the ability to use long cable lengths (up to
100 meters with standard copper Ethernet, or longer with fiber optics),
network flexibility (multiple cameras on a network, distributed systems), and
high data throughput (1 Gbps for GigE, and higher for 10 GigE, etc.).24
However, considerations for GigE Vision include potential network latency,
which can range from 100 to 500 µs for software triggers depending on
implementation quality 28, and the need to configure network interfaces for
optimal performance, such as enabling jumbo frames (Ethernet frames larger
than the standard 1500 bytes) to reduce CPU overhead during
high-bandwidth streaming.10 Version 2.0 introduced support for IEEE 1588
Precision Time Protocol for precise multi-camera synchronization.28
○​ USB3 Vision:​
The USB3 Vision standard utilizes the ubiquitous USB 3.0 (and subsequent
versions like 3.1/3.2) interface to provide high bandwidth and a plug-and-play
user experience for machine vision cameras.20 It defines a transport layer for
device detection, register access, data streaming, and event handling.30​
Similar to GigE Vision, USB3 Vision relies on the GenICam standard for camera
feature description and control, ensuring a consistent API for developers.27
The primary advantages of USB3 Vision include its high bandwidth (up to 5
Gbps for USB 3.0, enabling high-resolution and high-frame-rate imaging),
ease of use with standard USB ports found on most computers, and the ability
to power many cameras directly over the USB cable, simplifying system
setup.27 Cable lengths are typically shorter than GigE Vision (up to 5 meters
for passive cables, extendable with active cables or hubs).27
●​ 2. Utilizing Camera Manufacturer SDKs (Software Development Kits):​
Most infrared camera manufacturers provide SDKs that offer direct programming
access to their hardware. These SDKs are often the most optimized way to control
specific camera features, access raw sensor data, and manage image acquisition.
They typically support popular programming languages like C++, C#, and
increasingly, Python.
○​ Optris SDKs: Optris offers a suite of SDKs, including the Connect SDK,
EasyComm, and DirectSDK.32 The Connect SDK integrates cameras into
Windows applications, requiring the PIX Connect software for interprocess
communication, and allows embedding of color, temperature, and ADU values
via a DLL but doesn't directly handle radiometric data itself.32 EasyComm is a
simpler UDP-based interface for direct access to radiometric temperature
data from specific autonomous camera models (Xi80/Xi410/Xi1M) without PIX
Connect dependency, supporting any OS.32 The DirectSDK provides more
comprehensive direct access, allowing thermal image acquisition from the API
without PIX Connect, and supports C, C++, C#, Matlab, LabVIEW, and Python,
with compatibility for Windows and Linux (Ubuntu/Debian) across various
architectures.32 It enables access to thermal images and control over features
like focus motor and flag state.
○​ FLIR SDKs: Teledyne FLIR provides the Spinnaker SDK for controlling their
machine vision cameras (including many that are GenICam compliant) and
acquiring images.33 For post-processing and analysis of recorded thermal
data, the FLIR Science File SDK allows users to access temperatures from
factory-calibrated cameras as well as raw data from various file formats. It
supports C/C++, C#/.NET, Python, and MATLAB (file reading only) across
Windows, Linux, and macOS.35 Additionally, third-party Python libraries like
flirpy have emerged to provide a convenient interface for interacting with FLIR
cameras, capturing raw images, converting file formats (SEQ, FFF, etc.),
performing raw-to-radiometric conversions, and even extracting GPS data
from image sequences.36
○​ Teledyne DALSA SDK: The Sapera LT SDK is a comprehensive toolkit for
Teledyne DALSA cameras and frame grabbers, supporting standards like GigE
Vision, CameraLink, and USB3 Vision.38 It offers libraries for image acquisition
and control, supporting C++, C#, and C on Windows and Linux. The SDK
includes demos for various functionalities like color conversion, flat-field
correction, metadata access, and 3D data handling.39
○​ Seek Thermal SDKs: Seek Thermal provides an official C API for controlling
their cameras and accessing data.40 For users preferring other environments,
unofficial documentation and community-driven Python examples and
libraries also exist, demonstrating methods to interact with Seek Thermal
 hardware.41
Manufacturer SDKs generally provide the most direct and optimized pathway to
harness the full capabilities of specific hardware, including features that might not be
exposed through generic interfaces. Data is typically provided as raw memory buffers
or SDK-specific image objects, which can then be converted into formats suitable for
processing with standard libraries like OpenCV.The following table provides a
comparative overview of SDKs from major IR camera manufacturers:Table 1:
Comparison of Major IR Camera Manufacturer SDKs for Direct Access
Manufactur SDK Key Supported OS Typical
er Name(s) Features for Programmin Compatibilit Data
Direct g y Output/For
Access Languages mats

Optris Connect Raw data C++, C#, Windows, Raw data,

SDK, stream Python (via Linux Temperature
EasyComm, (DirectSDK, DirectSDK), (DirectSDK, values, ADU
DirectSDK, ExpertAPI), LabVIEW ExpertAPI) values
ExpertAPI Radiometric
temperature
data
(EasyComm,
DirectSDK,
ExpertAPI),
Camera
control API,
Triggering

Teledyne Spinnaker Raw data C++, C#, Windows, SDK-specific

FLIR SDK, Science stream Python Linux, image
File SDK (Spinnaker), macOS objects (e.g.,
Radiometric ImagePtr),
data FLIR file
(Science File formats
SDK, (SEQ, RLC,
Spinnaker FFF),
with Raw/Temper
radiometry), ature arrays
Camera
control API
(Spinnaker)

Teledyne Sapera LT Raw data C++, C#, C Windows, SDK-specific

DALSA SDK stream, Linux buffer
Camera formats,
 control API, standard
Triggering, image
Metadata formats via
access conversion

Seek Seek Raw thermal C (official), Windows, Raw sensor

Thermal Thermal SDK data, Python Linux data,
(C API), Camera (unofficial) (varies) Calibrated
Unofficial control image data
Python (limited by (depending
unofficial on
nature for SDK/library)
Python)

*Sources: [32, 33, 35, 38, 39, 40, 41]*​

●​ 3. Employing Open-Source Libraries (Python Focus):​

The Python ecosystem offers a rich collection of open-source libraries that are
highly suitable for developing custom infrared image processing and analysis
applications.
○​ OpenCV (Open Source Computer Vision Library):​
OpenCV is a cornerstone library for computer vision, providing a vast array of
algorithms for image processing, object detection, image segmentation,
feature extraction, filtering, and more.42 In the context of infrared imaging,
OpenCV can be used in conjunction with camera SDKs; typically, the SDK
acquires the raw image data, which is then converted into OpenCV's primary
data structure, the cv::Mat (or its Python equivalent, a NumPy array that
OpenCV functions can operate on), for subsequent processing.34 Some
cameras might also offer DirectShow support, allowing OpenCV to interface
with them more directly on Windows systems.27 When working with thermal
images, it's important to consider the data types, which are often 16-bit
grayscale (e.g., CV_16UC1 in OpenCV terms) representing raw sensor counts
or scaled temperature values. Many standard OpenCV functions can be
applied to these images, though care must be taken with operations that
assume 8-bit data or specific color spaces.44 OpenCV can also be used for
tasks like visualizing thermal data and, with custom logic, for extracting
temperature measurements from thermal images or video streams.46
○​ NumPy & SciPy:​
NumPy is fundamental for numerical computing in Python, providing support
for large, multi-dimensional arrays and matrices, along with a collection of
high-level mathematical functions to operate on these arrays. Since images
are essentially arrays of pixel values, NumPy is intrinsically linked with image
processing in Python.42 SciPy builds upon NumPy and provides a large
number of functions for scientific and technical computing, including signal
processing, optimization, statistics, and more.47 The scipy.ndimage
submodule is particularly relevant for multi-dimensional image processing
tasks such as filtering, morphological operations, and measurements on
image regions.42 For thermal data analysis, SciPy's statistical functions can
be used for analyzing temperature distributions, trends, and performing more
advanced computations.47
○​ Matplotlib (and other plotting libraries):​
Matplotlib is a comprehensive library for creating static, animated, and
interactive visualizations in Python. For thermal imaging applications, it is
invaluable for plotting thermal maps (heatmaps), temperature profiles across
lines or regions, histograms of temperature distributions, and other graphical
representations of analyzed data.47 Libraries like Seaborn, built on Matplotlib,
can provide more statistically oriented visualizations.
○​ Specialized Python Libraries for Thermal/Radiometric Analysis:​
Beyond general-purpose libraries, several Python packages cater specifically
to thermal imaging and radiometric processing:
■​ flirpy: This library facilitates interaction with FLIR cameras (Tau 2, Boson,
Lepton, Duo Pro R), enabling serial communication, raw image capture,
conversion of FLIR-specific file formats (e.g., SEQ, FFF) to readable
images, conversion of raw images to radiometric temperature images, and
extraction of GPS traces from sequences.36 It incorporates knowledge of
FLIR's TLinear mode and aspects of the radiometric chain, including
atmospheric parameter considerations.37
■​ PyTirCam: Developed for managing thermal infrared camera data,
particularly in volcanology, PyTirCam includes pyTirTran, a radiative
transfer model using the HITRAN database and camera spectral response,
and pyTirConv, an algorithm to recover radiometric thermal data
(brightness temperatures) from compressed JPEG images that include a
colorbar.49
■​ pyradi: This toolkit is designed for optical and infrared computational
radiometry. It offers functionalities for modeling physical radiators
(Planck's Law), various radiometric calculations (spectral integrals,
 convolutions), detector modeling (including noise analysis for staring
arrays), and reading MODTRAN (MODerate resolution atmospheric
TRANsmission) tape7 files.50 While powerful and actively maintained, it has
a steeper learning curve and is intended for users with a solid
understanding of radiometry.
■​ IRimage: Although primarily an ImageJ script, IRimage embodies the
concept of open-source processing for consumer thermal cameras. It
focuses on extracting raw data and calculating temperature values using
documented algorithms, and it utilizes Exiftool for metadata and, in its UAV
version, the DJI Thermal SDK.18 Its principles are relevant to custom
Python development.
■​ Python for GenICam/GigE Vision: The official genicam Python binding
provides low-level access to GenApi and GenTL producers.25 Harvester is
a higher-level GenICam client framework built on these bindings,
simplifying device discovery, data acquisition, and feature control for
GenICam-compliant cameras.26 Wrappers for libraries like Aravis (which
supports GigE Vision and USB3 Vision on Linux) also exist, enabling
Python integration.51
○​ Python for Machine Learning in Plastic Sorting:​
Python's extensive machine learning ecosystem, including libraries like
TensorFlow, Keras, PyTorch, and Scikit-learn, can be readily applied to
thermal data for tasks such as plastic type classification or defect detection in
recycling streams.16 Thermal images, once converted to appropriate
numerical formats (e.g., NumPy arrays of temperature values or raw counts),
can serve as input to train and deploy machine learning models.15
The following table provides an overview of key Python libraries relevant to IR image
acquisition and analysis:Table 2: Overview of Key Python Libraries for IR Image
Acquisition, Processing, and Analysis

Library Name Primary Purpose Key Features Example Use Case

Relevant to Thermal in Thermal/Plastics
Imaging Analysis

OpenCV General Image Handles 16-bit Pre-processing

(opencv-python) Processing, grayscale images thermal images,
Computer Vision (CV_16UC1), filtering, identifying plastic
feature detection, flakes, measuring
segmentation, object size/shape, tracking
tracking, items on a conveyor.
 cv::Mat/NumPy 42

interoperability.

NumPy Numerical Efficient Storing and

Operations, Array N-dimensional array manipulating pixel
Manipulation operations, data (temperatures,
mathematical raw counts),
functions, core data statistical
structure for image calculations. 42
data in Python.

SciPy Scientific and Advanced image Filtering thermal

Technical Computing processing noise, analyzing
(scipy.ndimage), temperature
statistical analysis, distributions, fitting
signal processing, thermal decay
optimization. curves. 42

Matplotlib Data Visualization Plotting 2D Visualizing

heatmaps, line temperature maps of
profiles (temperature plastic samples,
gradients), plotting
histograms, creating heating/cooling
publication-quality curves. 47
figures.

genicam (Python Low-level GenICam Direct access to Acquiring raw data

binding) Interface GenApi features streams from a
(camera control) and GenICam-compliant
GenTL producers IR camera for custom
(data streaming) for processing. 25
compliant cameras.

Harvester High-level GenICam Simplifies GenICam Setting up and

Client Framework device discovery, acquiring images
configuration, and from various
image acquisition; GenICam IR cameras
manages GenTL with a unified Python
producers. API. 26

flirpy FLIR Camera Control Serial Controlling a FLIR

& Data Processing communication, raw Tau2/Boson,
image capture, FLIR converting recorded
file format conversion SEQ files to
 (SEQ, FFF), raw to temperature arrays
radiometric for analysis. 36
conversion, TLinear
mode awareness.

PyTirCam Radiometric Radiative transfer Correcting thermal

Processing, modeling (pyTirTran), measurements for
Atmospheric conversion of JPGs atmospheric effects
Correction with colorbars to (if applicable),
brightness extracting
temperature temperatures from
(pyTirConv). archived thermal
JPEGs. 49

pyradi Advanced Optical/IR Planck's law Detailed radiometric

Computational calculations, detector modeling of the IR
Radiometry modeling, noise camera system,
analysis, MODTRAN sensor noise
interface, spectral characterization. 50
operations.

Scikit-learn, Machine Learning Classification, Training a model to

TensorFlow, PyTorch regression, clustering classify plastic types
algorithms, deep based on their
learning model thermal signatures or
development. heating/cooling
profiles. 52

*Sources: [25, 26, 36, 37, 42, 46, 47, 48, 49, 50, 52, 53, 58]*​

The increasing availability and sophistication of standardized interfaces like GenICam

and GigE Vision, coupled with manufacturer SDKs that offer cross-language support
(especially C++ and Python bindings), have effectively created a "middleware" layer.
This layer democratizes access to specialized hardware such as infrared cameras.
Historically, interfacing with such hardware demanded deep, vendor-specific
knowledge and often relied on proprietary tools. However, standards like GenICam aim
to decouple software from specific hardware interfaces, fostering interoperability.20
Camera manufacturers are increasingly providing SDKs that support common
high-level languages 32, and these SDKs often build upon or expose functionalities
compliant with these industry standards.24 Consequently, a researcher or student no
longer necessarily needs to master the deepest hardware registers or intricate
transport layer packet structures to acquire data. The SDK or a GenICam-compliant
library (like Harvester 26) handles much of this underlying complexity. This abstraction
layer allows developers to concentrate on the application logic—such as the
algorithms for plastic sorting—rather than on low-level hardware communication,
significantly lowering the barrier to entry for custom application development and
making such projects more feasible for a wider range of individuals, including those in
academic settings.

While open-source libraries and SDKs provide immense power and flexibility, the
responsibility for robust system integration, comprehensive error handling, and
ensuring the integrity of the acquired data (particularly for maintaining radiometric
accuracy) shifts significantly to the developer in a custom solution. This is a burden
often managed by the vendor within a proprietary, integrated system. Proprietary
systems like NI's VDM/VAS are marketed for their cohesive integration and reliability,
where the vendor handles many of the complexities at the driver level and in
hardware-software interactions.1 In contrast, when assembling a custom solution from
SDKs and open-source libraries, the developer takes on the role of system integrator.
Although individual libraries like OpenCV or NumPy are generally robust, ensuring
their seamless interoperability, managing dependencies, and addressing
camera-specific quirks or communication timeouts becomes the developer's
responsibility. For radiometric data, meticulous attention to the correct interpretation
of raw sensor values, the precise application of calibration parameters (such as
Non-Uniformity Correction (NUC) and emissivity values), and a thorough
understanding of the camera's internal processing pipelines (e.g., FLIR's TLinear mode
37
) are critical. These aspects require careful implementation by the developer, often
relying heavily on detailed SDK documentation or specialized libraries like flirpy or
pyradi. Furthermore, robust error handling mechanisms—for instance, to manage
camera disconnects, corrupted data frames 21, or network issues inherent with GigE
Vision 28—must be explicitly coded into a custom solution. Therefore, the "freedom"
afforded by open-source tools comes with an increased "responsibility" for
system-level engineering, validation, and ongoing maintenance.

III. Implementing Data Transfer and Analysis without Proprietary

"Snap-ins"
To bypass proprietary software "snap-ins" for transferring and analyzing infrared
camera data, one must implement a custom pipeline that handles data acquisition
directly from the camera, manages its transfer and storage, and then performs the
necessary analysis using appropriate libraries and algorithms.

A. Direct Data Acquisition Techniques

Directly acquiring data from an infrared camera without relying on intermediary
software like NI VAS involves using either the manufacturer's SDK or
GenICam-compliant libraries.
●​ 1. Using Manufacturer SDKs:​
As detailed previously (Section II.B.2), camera manufacturers provide SDKs that
contain Application Programming Interfaces (APIs), often available for C++,
Python, C#, or other languages. These APIs allow a custom program to establish
a connection with the camera, configure its parameters (such as exposure time,
frame rate, trigger modes, and resolution), initiate the data streaming process,
and retrieve image frames.32 The data is typically provided to the application as
raw memory buffers containing pixel data or as SDK-specific image objects. For
example, the FLIR Spinnaker SDK might return an ImagePtr object, which
encapsulates the image data and metadata.34 Similarly, the Optris DirectSDK
enables direct acquisition of thermal images from its API.32 The application code
is then responsible for interpreting these buffers or objects based on the
camera's pixel format and image dimensions.
●​ 2. Using GenICam-compliant Libraries (e.g., Harvester with Python genicam
bindings):​
For cameras that adhere to the GenICam standard, libraries that implement a
GenTL consumer interface can be used for direct data acquisition. In Python, the
genicam package provides the necessary bindings to the GenApi and GenTL
standards 25, while Harvester offers a more user-friendly, higher-level Pythonic
interface to manage this process.26 The typical workflow involves:
1.​ Discovering available GenTL producers (these are essentially the camera
drivers that expose the GenTL interface).
2.​ Enumerating connected devices that are managed by the selected GenTL
producer.
3.​ Opening a specific device and creating a data stream.
4.​ Configuring camera parameters using GenApi features (e.g., setting pixel
format, width, height, exposure).
5.​ Allocating memory buffers for image data.
6.​ Starting the acquisition and retrieving filled buffers from the data stream.21
The data obtained through GenICam is usually in the form of raw byte buffers.
 The application must then interpret this data based on the pixel format (e.g.,
Mono12, Mono14, Mono16, RGB8), image width, height, and stride (bytes per
line), all of which are typically available as readable features via GenApi.

B. Data Transfer and Storage

Once acquired, the infrared data needs to be handled appropriately for transfer (if
necessary, e.g., from a data acquisition computer to a processing server, though often
they are the same machine in a lab setup) and storage.
●​ 1. Nature of Transferred Data:​
The data acquired from an infrared camera can vary in nature:
○​ Raw Sensor Data: This often consists of digital numbers (DNs) or counts
directly from the analog-to-digital converter (ADC) associated with each
pixel, typically with bit depths like 14-bit or 16-bit.37 This data is uncalibrated
and requires further processing to derive meaningful temperature values.
○​ Radiometric Data: Some cameras or SDKs can output data that is already
processed to represent radiometric quantities, such as radiance or directly as
temperature values (often scaled). For instance, FLIR cameras in TLinear
mode output data linear in scene temperature.37 Optris SDKs can provide
direct access to radiometric temperature data.32 This data has undergone
some level of internal calibration.
○​ Metadata: Alongside pixel data, crucial metadata is often transferred. This
can include camera settings used during acquisition (exposure, gain, frame
rate), timestamps for each frame, and potentially GPS coordinates if the
camera system is equipped with a GPS receiver (common in aerial
thermography).18 GenICam also defines mechanisms for accessing extensive
metadata associated with image streams and individual frames.21
●​ 2. Data Formats for Storage:​
The choice of storage format depends on the nature of the data and the
requirements of subsequent analysis:
○​ Standard Image Formats: For visual inspection or when bit depth is critical,
formats like TIFF (Tagged Image File Format) are preferred as they can store
16-bit (or higher) grayscale data without loss, unlike JPEG which is typically
8-bit and lossy.18 PNG (Portable Network Graphics) can also store grayscale
data losslessly, including 16-bit.
○​ Raw Binary Files: Storing the unaltered byte stream as received from the
camera is an option, often accompanied by a separate header file or
metadata file describing the image dimensions, pixel format, etc. This
preserves the data in its most original form.
 ○​ CSV (Comma-Separated Values): Useful for storing metadata, extracted
temperature values from specific ROIs, or time-series data.
○​ Specialized Formats: Some camera manufacturers or older systems use
proprietary file formats (e.g., FLIR's SEQ, FFF, RLC files). Libraries like flirpy
can often convert these to more open formats.36
○​ NumPy Array Formats: In Python-based workflows, saving NumPy arrays
directly using .npy (for a single array) or .npz (for multiple arrays in one file) is
highly efficient for both storage space and I/O speed when reloading into
Python for analysis.58

C. Custom Data Analysis (Focus on Python/OpenCV)

With the data acquired and stored, custom analysis can be performed, typically
leveraging Python and its rich scientific computing ecosystem.
●​ 1. Pre-processing:​
The first step in analysis is often pre-processing:
○​ Data Conversion: If data is in an SDK-specific format or raw buffer, it needs
to be converted into a usable structure, such as a NumPy array for
Python-based processing or a cv::Mat object if using OpenCV's C++ API
directly.34
○​ Noise Reduction and Filtering: Thermal images can be susceptible to noise.
Standard image processing filters (e.g., Gaussian blur, median filter available
in OpenCV or SciPy) can be applied to reduce noise, though care must be
taken not to excessively blur important thermal details.42
●​ 2. Temperature Extraction (Radiometric Conversion):​
If the acquired data consists of raw sensor counts, it must be converted to
temperature values. This is a critical step for quantitative thermal analysis.
○​ This process involves applying calibration equations, which can range from
simple linear scaling to more complex non-linear functions based on Planck's
law of blackbody radiation or polynomial fits derived during camera
characterization.37 The specific formulas and calibration coefficients (e.g.,
gain, offset, response curves for different sensor temperatures) are usually
provided by the camera manufacturer in documentation or accessible via the
SDK.
○​ Specialized libraries like flirpy for FLIR cameras 36 or PyTirCam 49 often
encapsulate these conversion routines or provide access to the necessary
parameters.
○​ It's also important to understand the camera's internal processing modes. For
example, FLIR cameras operating in "TLinear mode" output digital data that is
 already linear with scene temperature, simplifying the conversion.37 Other
modes might output data linear in radiometric flux, requiring a more involved
conversion.
●​ 3. Feature Extraction and Analysis for Plastic Recycling:​
For a plastic recycling simulation, the analysis will focus on extracting features
that help differentiate plastic types or assess their condition based on thermal
properties.
○​ Region of Interest (ROI) Identification: Defining specific areas in the image
corresponding to individual plastic pieces or regions of interest for analysis.
○​ Thermal Signature Analysis: Different plastics may exhibit distinct thermal
behaviors (e.g., different emissivities leading to apparent temperature
differences under uniform heating, or different heating/cooling rates when
subjected to thermal stimuli). Algorithms can be developed to quantify these
signatures. This might involve texture analysis, blob analysis to identify and
characterize individual plastic flakes, or shape analysis using OpenCV
functions.42
○​ Statistical Analysis: Calculating statistics (mean, median, standard deviation,
histograms) of temperature distributions within ROIs using NumPy and SciPy
can provide quantitative measures for comparison.47
○​ Machine Learning: For more complex differentiation, machine learning
models (e.g., support vector machines, neural networks) can be trained on
extracted thermal features to classify plastic types.15
●​ 4. Visualization:​
Effective visualization is key to understanding the thermal data and analysis
results.
○​ Libraries like Matplotlib and Seaborn in Python, or OpenCV's built-in display
functions (imshow), can be used to create false-color thermal maps
(heatmaps), plot temperature profiles along lines, display temperature
histograms, and overlay analysis results (like detected object boundaries or
temperature readings) onto the images.44

The process of "transfer and analyse" in a custom solution, as opposed to an

integrated proprietary system, is not a single, monolithic operation. Instead, it
comprises a chain of discrete, developer-managed stages. This chain begins with
low-level data grabbing, typically achieved via the manufacturer's SDK or a
GenICam-compliant library. This is followed by data marshalling, which involves
converting the acquired raw or semi-processed data into formats that are usable by
standard analysis libraries, such as NumPy arrays in a Python environment. A crucial
subsequent step is radiometric calibration. This involves applying corrections for
Non-Uniformity Correction (NUC), accounting for the emissivity of the observed
materials (especially critical for diverse plastics), and compensating for the sensor's
specific response characteristics. Finally, the application-specific analysis is
performed, which in the context of plastic recycling, might involve algorithms for
material differentiation or quality assessment. Each link in this intricate chain—from
initial data acquisition through calibration to final analysis—introduces potential points
of failure or sources of error if not meticulously handled and validated by the
developer. While proprietary software like NI's often presents a more integrated
"acquire and analyze" experience by managing these internal handoffs 1, a custom
solution places the responsibility for the integrity of data flow and transformations
squarely on the developer. This highlights both the inherent flexibility of custom
solutions, offering granular control over each step, and their increased complexity,
demanding careful engineering and validation at each stage of the pipeline.21

IV. Key Considerations for Your Plastic Recycling Simulation

When developing a simulation for plastic recycling using infrared cameras, several key
factors related to the nature of the data, calibration, and processing needs must be
carefully considered to ensure meaningful and accurate results.

A. Nature of Infrared Data Required for Plastic Characterization

The type of infrared data needed will depend on the specific goals of the plastic
characterization within the simulation.
●​ Raw Sensor Values (Digital Numbers/Counts): Accessing the raw, uncalibrated
output from the sensor (often 14-bit or 16-bit digital counts) provides the
maximum level of control over the entire processing pipeline.36 This is
advantageous if the project involves developing novel calibration techniques,
requires a deep understanding of sensor behavior, or needs to bypass any
proprietary "black-box" processing done by the camera. However, it also places
the full burden of radiometric calibration on the developer.
●​ Radiometric Temperature Maps: Many modern infrared cameras or their SDKs
can output data that has been internally processed to represent actual
temperature values, or values that can be easily converted to temperature using
supplied calibration parameters.32 This can simplify the workflow if the camera's
internal calibration is deemed sufficiently accurate for the simulation's needs.
However, it's crucial to understand the assumptions and corrections (e.g.,
assumed emissivity) applied by the camera.
●​ Spectral Information: While many common thermal cameras are broadband
(detecting radiation over a wide range, e.g., 8-14 µm), some specialized infrared
 systems, such as hyperspectral or multispectral IR cameras, provide data across
multiple, narrower infrared wavelength bands. Near-Infrared (NIR) spectroscopy
(typically 0.78-2.5 µm) is a well-established technique for plastic identification
due to characteristic absorption features of different polymers in this range.15 If
the "infrared camera" in the simulation refers to such a system, the data will
consist of spectral curves or multi-band intensity values for each pixel, requiring
different analytical approaches than broadband thermal data. The distinction
between broadband thermal imaging (measuring emitted heat) and NIR
spectroscopy (measuring reflected/absorbed light for material composition) is
important.
●​ Dynamic Thermal Behavior: For simulating processes like sorting based on
differential heating or cooling, time-series thermal data is essential. Analyzing the
heating and cooling profiles of different plastics when subjected to a controlled
thermal stimulus can reveal material-dependent properties.62 This requires the
ability to capture sequences of thermal images at appropriate frame rates.

B. Calibration Essentials for Accurate Thermal Analysis of Plastics

Accurate quantitative thermal analysis, especially for materials as diverse as plastics,
hinges on proper calibration.
●​ 1. Non-Uniformity Correction (NUC):​
Infrared focal plane arrays (FPAs) inherently exhibit pixel-to-pixel variations in
response, even when viewing a uniform temperature scene. This spatial noise is
known as fixed-pattern noise (FPN). NUC is the process of correcting these
non-uniformities to ensure that each pixel provides a consistent response.63
Most thermal cameras perform NUC internally, often involving a mechanical
shutter that periodically presents a uniform temperature source to the sensor.
This process might be automatic or require manual triggering via the camera's
interface or SDK. Some SDKs may provide access to NUC tables or allow for
user-defined NUC procedures. For advanced applications or if using very basic
sensor cores, implementing custom NUC algorithms might be necessary.
Open-source research and code examples for NUC exist, though they may
require adaptation.63
●​ 2. Emissivity Correction:​
Emissivity (ϵ) is a critical surface property that describes how efficiently a material
radiates thermal energy compared to an ideal blackbody (ϵ=1).67 Plastics exhibit a
wide range of emissivity values depending on their type, color, surface texture,
and any additives present.68 Inaccurate emissivity settings are a primary source
of error in temperature measurement with IR cameras.70​
 Methods for emissivity correction include:
○​ Assigning Known Values: If the types of plastics in the simulation are known
and their emissivities have been characterized (e.g., through laboratory
measurements or reliable literature values), these can be manually input into
the temperature calculation formula.
○​ Reference Materials/Coatings: Applying a coating of known high emissivity
(e.g., specific paints or tapes) to the surface of interest can ensure uniform
and known emissivity, but this is generally impractical for diverse, unsorted
plastic waste streams.67
○​ Multi-Wavelength Pyrometry/Spectroscopy: Advanced instruments that
measure IR radiation at multiple specific wavelengths can sometimes estimate
both temperature and emissivity simultaneously. However, these are typically
more complex and expensive than standard broadband thermal cameras and
may have limited spatial resolution.68
○​ RGB-Image-Based Emissivity Mapping: Emerging research explores using
a registered RGB image of the scene to segment different materials. Once
materials are identified (e.g., using a Convolutional Neural Network - CNN),
pre-determined emissivity values for each material class can be assigned on a
pixel-wise basis to create an emissivity map. This map is then used to correct
the corresponding thermal image.67 This approach could be a sophisticated
project within a Python-based simulation, leveraging computer vision and
machine learning.
●​ 3. Atmospheric and Distance Correction:​
For highly precise temperature measurements, especially when viewing targets
over significant distances or in environments with high humidity or airborne
particulates, the intervening atmosphere can absorb, emit, and scatter infrared
radiation, affecting the signal received by the camera.37 The distance to the
target also influences the amount of radiation collected. Some advanced thermal
analysis software and libraries (e.g., pyTirTran within PyTirCam 49, or
functionalities within flirpy 37) attempt to model and correct for these effects,
typically requiring inputs like ambient temperature, humidity, and distance. For
close-range laboratory simulations, these effects are often considered negligible
or can be minimized through controlled conditions.
●​ 4. General Calibration Procedures:​
If absolute temperature accuracy is paramount for the simulation, the infrared
camera itself should be calibrated against traceable temperature standards (e.g.,
blackbody calibrators certified by NIST or equivalent metrology institutes).5
Cameras typically undergo factory calibration, but their accuracy can drift over
time or with environmental changes. External calibration by a metrology lab
 re-establishes this traceability.72 Many cameras also feature a self-calibration or
internal calibration routine, which adjusts the camera's response relative to an
internal reference source, helping to compensate for short-term drifts.72 While
many open-source camera calibration tools focus on geometric calibration for
visual cameras (e.g., lvt2calib 73, Autoware tools 74), the principles of radiometric
calibration involve characterizing the sensor's response to known radiance inputs.

C. Real-time vs. Offline Processing Needs for Simulation

The processing requirements for the simulation will dictate the approach to data
handling and analysis.
●​ Defining "Real-time": In the context of a simulation, "real-time" can have
different meanings. It might imply live visualization of thermal processes as they
are simulated, immediate feedback for interactive parameter adjustments, or
rapid iteration of simulation runs. It is unlikely to mean the hard real-time control
constraints of an operational industrial plant (e.g., microsecond or
millisecond-level responses).
●​ Performance Trade-offs: Custom solutions, particularly those implemented
primarily in Python, may exhibit different performance characteristics compared
to highly optimized, compiled environments like LabVIEW or dedicated C++
applications. While Python itself is an interpreted language and can be slower for
raw computational loops, many of its scientific libraries (NumPy, SciPy, OpenCV)
have performance-critical sections implemented in C or Fortran, offering good
execution speed for vectorized operations.11 LabVIEW, especially when leveraging
NI hardware and FPGA capabilities, can achieve very high performance for data
acquisition and real-time control.1 However, for complex data processing tasks,
MATLAB has been shown to sometimes outperform LabVIEW, while Python's
performance was slower but it excelled in interfacing speed and RAM usage in
one study.75
●​ Suitability for Simulation: For many simulation scenarios, "fast enough" offline
processing or near-real-time feedback for visualization and interaction is often
sufficient. The rapid development lifecycle and extensive analytical libraries
offered by Python can be a significant advantage in such research contexts,
allowing for quick prototyping and implementation of complex models.11 If the
simulation involves interfacing with physical hardware in a closed loop with tight
timing constraints, then language and platform choices become more critical, and
Python's standard implementation might introduce unacceptable latencies
without specific optimizations or extensions (e.g., MicroPython for
microcontrollers 77). GigE Vision itself has inherent latency factors related to
 network transmission and packet processing that need to be considered
irrespective of the software environment.28

For a simulation of a plastic recycling process, the primary emphasis is likely to be on

the accurate modeling of thermal phenomena and the effective differentiation of
materials based on these phenomena, rather than on hard real-time control as would
be required in an operational industrial plant. This shift in priorities potentially relaxes
the most stringent constraints on processing speed. Consequently, Python-based
custom solutions become more viable and attractive. Their inherent flexibility in
implementing complex analytical models, sophisticated calibration routines (such as
those required for handling the varying emissivity of diverse plastics 67), and
integrating machine learning approaches 15 can be particularly beneficial. While
Python's raw execution speed for certain types of computation might be lower than
that of compiled languages like those used in LabVIEW 11, its rapid development
capabilities and rich ecosystem of scientific libraries 19 often provide a decisive
advantage in a research and simulation context. The need for precise thermal data
and sophisticated, adaptable analysis algorithms may well outweigh the requirement
for the absolute lowest processing latency, making Python a strong contender for
developing the simulation.

V. Comparative Analysis: NI Suite vs. Custom/Open-Source

Solutions
Choosing between an integrated proprietary suite like National Instruments' and a
custom/open-source approach for infrared camera data acquisition and analysis
involves weighing several factors. The optimal choice depends on the specific
requirements of the project, available resources, and desired outcomes.

Table 3: Comparative Summary: NI Software Suite vs. Custom/Open-Source

Approach for IR Camera Data

Criterion NI Software Suite (e.g., Custom/Open-Source

LabVIEW VDM/VAS) Approach (e.g., Python with
SDKs/GenICam/OpenCV)

Initial Cost High (software licenses, Low to Medium (open-source

potentially NI hardware) 1 software is free; camera cost
varies) 12
Recurring Costs Medium to High (annual Low (primarily developer time
subscriptions/maintenance for for maintenance if
software) 1 self-managed) 78

Development Time Potentially Shorter (graphical Medium (requires coding,

(Standard Tasks) programming, pre-built library integration)
functions) 6

Development Time Medium to Longer (may hit Potentially Shorter to Medium

(Novel/Complex Tasks) flexibility limits) (high flexibility, rich libraries
for complex math/AI) 76

Flexibility & Customization Medium (extensive library, but Very High (full control over
1
within NI framework) algorithms and pipeline) 19

Control over Data Pipeline Medium (some abstraction Very High (direct
layers) management of each
processing step)

Real-time Performance High (especially with NI Medium to High (depends on

1 implementation; Python can
hardware/FPGAs)
have higher latency for
control) 75

Processing Speed Generally Good (compiled Medium (Python interpreted,

11
(CPU-bound) LabVIEW) but core libraries in C/C++) 11

Accuracy (if implemented High (relies on NI calibration High (developer responsible

correctly) 71 for rigorous calibration and
tools and implementation)
validation)

Reliability (out-of-the-box) High (mature, tested industrial Developer-Dependent

platform) (requires robust coding and
testing)

Learning Curve (core Medium to High (LabVIEW Low to Medium (Python

environment) 9 widely known; specific
paradigm)
libraries require learning) 19

Community Support Good (NI forums, Excellent (vast online

resources for Python,
 documentation) 11 OpenCV, etc.) 11

Hardware Interoperability Best with NI hardware; good Broad (via SDKs, GenICam,
4 GigE, USB3); quality can vary
with standards (GigE, USB3)
20

Suitability for Deep Medium (can be constrained Very High (ideal for novel
Algorithm Research by framework) algorithm development and
testing)

Ease of GUI Development High (LabVIEW's strength) 9 Medium (Python has GUI
libraries like PyQt, Tkinter, but
often more effort than
LabVIEW)

Sources: 1
●​ A. Development Time, Effort, and Cost:​
The NI suite, with LabVIEW's graphical programming and extensive built-in
function libraries, can offer faster initial setup and development for standard data
acquisition and analysis tasks.6 However, this comes at a significant upfront cost
for software licenses (e.g., VDM annual license around $2,102 1) and potentially
for NI-specific hardware, which can be substantial.11 There is also a learning
curve associated with mastering LabVIEW's unique G programming paradigm if
developers are not already familiar with it.9​
Custom and open-source solutions, particularly those centered around Python,
generally have lower direct software costs, as the core libraries (Python, OpenCV,
NumPy, SciPy) are free.78 Hardware costs are dictated by the choice of camera,
which can be more varied. However, the development effort can be considerable.
Setting up the environment, integrating various libraries, and writing robust code
for data acquisition, calibration, analysis, and visualization requires solid
programming skills and can be time-consuming, especially for complex or novel
applications.11 While development can be accelerated by leveraging existing SDKs
and libraries, the integration and validation effort rests with the developer.
●​ B. Flexibility, Customization, and Control:​
This is a key area where custom/open-source solutions typically excel. They offer
maximum flexibility to design the entire data processing pipeline from scratch,
select or develop specific algorithms tailored to the research problem, and
maintain granular control over data at every stage of processing.19 This includes
the ability to integrate with a vast ecosystem of other specialized tools and
 libraries, such as advanced machine learning frameworks or custom simulation
environments. Furthermore, with custom software, the developer or institution
owns the code and has full rights to modify and extend it.78​
The NI suite, while offering a wide range of functionalities, operates within its own
integrated framework. This can sometimes limit flexibility if a project requires
implementing entirely novel algorithms not easily expressed in LabVIEW G code,
or if very low-level access to camera parameters or data streams not exposed by
VDM or VAS is needed.
●​ C. Performance (Real-time Capabilities, Processing Speed):​
For true real-time applications with stringent timing requirements (e.g.,
high-speed control loops), LabVIEW, especially when paired with NI's real-time
operating systems and FPGA hardware, generally offers excellent and predictable
performance.1 Studies have shown LabVIEW can outperform Python in raw data
acquisition and real-time control tasks without significant data processing.75​
Python, being an interpreted language, can be inherently slower for
CPU-intensive raw processing loops compared to compiled languages like C++
(which LabVIEW ultimately compiles to).11 However, this is often mitigated by the
fact that many critical Python libraries (e.g., NumPy, OpenCV, SciPy) have their
core algorithms implemented in C or C++ for speed. For many research and
simulation tasks where "fast enough" processing or offline analysis is acceptable,
Python's performance is often adequate, and its rapid development capabilities
become a significant advantage.11 Real-time control latencies with standard
Python can be higher, though specialized solutions like MicroPython on
microcontrollers can achieve low latencies for specific I/O tasks.77 It's also
important to note that the communication protocol itself, like GigE Vision, has
inherent latency factors (e.g., network packet transmission, processing) that
affect system responsiveness regardless of the software stack.28
●​ D. Accuracy and Reliability:​
The NI suite benefits from NI's established presence in test and measurement,
with tools and procedures for device calibration and a focus on measurement
accuracy.71 Their software and hardware are generally mature and have been
tested in numerous industrial applications, offering a certain level of
out-of-the-box reliability.​
In custom/open-source solutions, the accuracy and reliability of the entire system
are heavily dependent on the developer's expertise and diligence. This includes
the correct implementation of data acquisition routines, rigorous application of
calibration procedures (especially NUC and emissivity correction for thermal
data), thorough error handling, and comprehensive testing of the entire pipeline.
While open-source radiometric libraries like pyradi or flirpy aim to provide
 accurate calculations, their correct usage and integration are paramount.36 The
developer bears the full responsibility for validating the system's output.
●​ E. Learning Curve, Community Support, and Hardware Compatibility:​
LabVIEW's graphical programming is unique and requires a dedicated learning
effort if one is not already proficient.9 NI provides extensive documentation,
training resources, and has a dedicated user community that can offer support.11
Hardware compatibility is strongest with NI's own hardware, although support for
third-party cameras adhering to standards like GigE Vision and USB3 Vision is
also generally good through VAS.​
Python is often considered to have a gentler learning curve for basic
programming concepts compared to specialized environments like LabVIEW.19
However, mastering the intricacies of specific advanced libraries (e.g., OpenCV, or
the details of GenICam interfaces) still requires significant effort. The community
support for Python and its major libraries is vast and highly active, with abundant
online resources such as Stack Overflow, GitHub issue trackers, forums, and
tutorials.11 In terms of hardware compatibility, custom solutions can interface with
a broader range of cameras, provided the cameras adhere to common standards
(GenICam, GigE Vision, USB3 Vision) or offer well-documented SDKs with
bindings for the chosen programming language.20 However, the quality and
completeness of third-party drivers or SDKs can vary, and compatibility issues or
bugs can arise, requiring developer effort to resolve.79

The decision between a proprietary, integrated system and a custom/open-source

solution is not merely a technical one; it is strategic. It involves a fundamental
trade-off. On one hand, there is the "managed certainty" offered by a system like NI's,
where many components are designed for interoperability and are backed by vendor
support.1 This path often comes with higher direct costs and potentially less flexibility
for deep, unconventional customization, but provides a degree of assurance regarding
functionality and reliability for common tasks. On the other hand, the
custom/open-source route offers "empowered uncertainty." This path provides
maximal flexibility, control, and typically lower direct software costs 12, but places the
full responsibility for successful integration, rigorous validation, and long-term
maintenance squarely on the developer. The developer is empowered with
unparalleled control but also assumes the full risk of development challenges and
system performance. For a student project or academic research, the learning
experience derived from deep customization and problem-solving, inherent in custom
solutions, might be valued as highly as, or even more than, the rapid deployment
capabilities of off-the-shelf tools, provided the "uncertainty" associated with
development challenges can be effectively managed.

VI. Recommendations and Conclusion

A. Feasibility Assessment for Avoiding NI Software
Based on the extensive availability of standardized communication protocols
(GenICam, GigE Vision, USB3 Vision), comprehensive manufacturer-provided SDKs,
and powerful open-source libraries, it is entirely feasible to acquire, transfer, and
analyze infrared camera data for a plastic recycling simulation without relying on
NI-specific software like LabVIEW VDM or VAS. Numerous cameras support these
open standards, and SDKs often provide Python or C++ bindings, enabling direct
interaction.20 The Python ecosystem, in particular, offers a rich suite of tools like
OpenCV, NumPy, SciPy, and specialized packages for thermal and radiometric
analysis (flirpy, PyTirCam, pyradi), making it a strong candidate for building custom
solutions.36

B. Recommended Strategies for a Plastic Recycling Simulation Project (Academic

Context)
For an academic project focused on simulating plastic recycling processes using
infrared cameras, the following strategies are recommended:
1.​ Prioritize Python with Manufacturer SDKs and/or GenICam Libraries:​
Given the academic context, the flexibility, low cost, extensive community
support, and rich library ecosystem of Python make it a highly attractive
platform.19
○​ If the selected infrared camera comes with a well-supported Python SDK
(e.g., from manufacturers like FLIR or Optris), this often provides the most
straightforward and optimized path for direct camera control and data
acquisition.32 These SDKs are typically tailored to the specific hardware and
can expose unique features.
○​ If a Python SDK is not available or if broader camera compatibility is desired
(e.g., to allow for future use with different camera models), leveraging Python
with GenICam-compliant libraries is a robust alternative. Tools like the
genicam Python binding 25 or the Harvester framework 26 allow interaction
with any GenICam-compliant camera, regardless of the manufacturer or
physical interface (GigE Vision, USB3 Vision).
2.​ Leverage OpenCV for Core Image Processing:​
OpenCV should be the workhorse for fundamental image processing tasks. This
includes image manipulation (resizing, cropping), filtering (noise reduction),
feature extraction (edges, corners, textures), blob analysis (for identifying
 individual plastic pieces), and potentially initial steps in material characterization
based on visual or thermal-textural properties.42
3.​ Focus on Robust and Custom Calibration Procedures:​
This is a critical aspect for accurate thermal analysis of plastics and an area
where a custom solution can truly shine by allowing tailored approaches.
○​ Non-Uniformity Correction (NUC): Understand how the chosen camera
handles NUC. If necessary, implement or trigger NUC routines via the SDK.
For advanced simulations, custom NUC implementation might be explored
using libraries or published algorithms.63
○​ Emissivity Correction: This is paramount for plastics due to their wide
variability in emissivity.67 The simulation should incorporate methods to
account for this. This could range from:
■​ Using a library of known emissivity values for different plastic types
identified by other means (e.g., a parallel visual classification system).
■​ Implementing more advanced techniques, such as those involving
registered RGB images and machine learning (e.g., CNNs) to create
dynamic emissivity maps for pixel-wise correction.67 This could be a
significant research component of the project.
○​ Utilize specialized Python libraries like flirpy, PyTirCam, or pyradi if their
functionalities for radiometric conversion, atmospheric correction (if
relevant), or detailed sensor modeling align with the project's needs.36
4.​ Adopt an Iterative Development Approach:​
Begin by focusing on robust data acquisition and offline analysis. Capture
datasets of thermal images of various plastics under controlled conditions.
Develop and validate the calibration and analysis algorithms offline first. Once
these are established, then consider integration into a more dynamic or
near-real-time simulation environment if required.
5.​ Acknowledge and Plan for Development Effort:​
While powerful, this custom path requires solid programming skills in Python and
a good understanding of image processing and thermal principles. The
development effort will likely be greater than using an off-the-shelf, integrated
solution, especially regarding the implementation and validation of custom
calibration routines and analysis algorithms.11 Adequate time should be allocated
for learning specific libraries, SDKs, and for debugging the integrated system.

C. Concluding Thoughts: Balancing Power, Flexibility, and Effort

The decision to avoid proprietary software "snap-ins" like those from National
Instruments for an infrared camera-based plastic recycling simulation is indeed viable
and, in many academic research contexts, advantageous. While integrated proprietary
solutions offer convenience, rapid deployment for standard tasks, and a degree of
managed reliability, they often come with higher costs and limitations in flexibility and
deep customization.

A custom approach, particularly one built around Python, manufacturer SDKs, and
GenICam-compliant libraries, provides unparalleled flexibility, control over the entire
data pipeline, and cost-effectiveness in terms of software. This pathway empowers
researchers to implement novel algorithms, tailor calibration procedures specifically
for the complexities of plastic materials (e.g., varying emissivities), and integrate with
a vast ecosystem of open-source tools for advanced analysis and machine learning.

The choice ultimately hinges on the specific priorities of the project. If the primary
goal is rapid deployment of a well-defined, standard thermal imaging task with an
available budget, a solution like NI's might be efficient. However, for a
research-oriented simulation project like the one described—where learning, deep
understanding of the underlying processes, development of novel analytical methods
for plastic characterization, and budget constraints are likely key considerations—the
benefits of a custom Python-based solution are compelling. The transparency of
open-source tools, the ability to adapt and extend algorithms, and the direct
engagement with data at every stage foster a deeper understanding and can lead to
more innovative outcomes. While this path demands greater development effort and
programming expertise, the resulting system can be precisely tailored to the unique
challenges of simulating and analyzing the thermal behavior of plastics in recycling
processes.

The optimal strategy for such a project likely involves a hybrid methodology:
leveraging standardized protocols like GenICam for a degree of hardware abstraction,
utilizing manufacturer SDKs for the most efficient and feature-rich data acquisition
from the specific camera chosen, and then employing the powerful and flexible
open-source ecosystem of Python (with libraries like OpenCV, NumPy, SciPy, and
specialized thermal packages) for the custom calibration, analysis, and simulation
logic. This approach avoids complete vendor lock-in while also obviating the need to
reinvent fundamental camera communication protocols from scratch, striking a
practical balance between leveraging existing robust components and building highly
specialized, research-focused functionalities.

Works cited

1.​ What Is the NI Vision Development Module - NI, accessed on June 6, 2025,
https://www.ni.com/en/shop/data-acquisition-and-control/add-ons-for-data-acq
uisition-and-control/what-is-vision-development-module.html
2.​ NI Vision Development Module 2019 Readme - National Instruments, accessed on
June 6, 2025, https://www.ni.com/pdf/manuals/375127k.html
3.​ Vision Acquisition Software - NI, accessed on June 6, 2025,
https://www.ni.com/da-dk/shop/product/vision-acquisition-software.html
4.​ Differences Between NI Vision Acquisition Software, NI Vision Builder, and the NI
Vision Development Module - NI - Support, accessed on June 6, 2025,
https://knowledge.ni.com/KnowledgeArticleDetails?id=kA00Z000000P6OASA0
5.​ Acquire Images Quickly with New PXI/CompactPCI Modules Use LabVIEW and
IMAQ Vision for Thermal Imaging - CiteSeerX, accessed on June 6, 2025,
https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=777ecc94f574
45c738040fe2799aa8b3de24c056
6.​ Mechanical and Sensor Based Test Solution Brochure - Yotta Volt, accessed on
June 6, 2025,
https://www.yottavolt.com/wp-content/uploads/2024/06/NI-TM-Mechanical-and-
Sensor-Based-Test-Solution-Brochure.pdf
7.​ What data logging setups do you use at work? : r/AskEngineers - Reddit,
accessed on June 6, 2025,
https://www.reddit.com/r/AskEngineers/comments/10pglmk/what_data_logging_s
etups_do_you_use_at_work/
8.​ A Webcam and LabVIEW-based System for Efficient Object Recognition based on
Colour and Shape Features - ResearchGate, accessed on June 6, 2025,
https://www.researchgate.net/publication/371144593_A_Webcam_and_LabVIEW-
based_System_for_Efficient_Object_Recognition_based_on_Colour_and_Shape_F
eatures
9.​ Labview Arduino - SimLab Solutions, accessed on June 6, 2025,
https://ftp.simlab-soft.com/HomePages/9936413/LabviewArduino.pdf
10.​NI Vision Acquisition Software Release Notes, accessed on June 6, 2025,
http://cfd.rit.edu/products/manuals/National%20Instruments/NI-IMAQ/Docs/visio
nAcqReleaseNotes.html
11.​ Switching from LabVIEW to Python: Pros and Cons - Reddit, accessed on June 6,
2025,
https://www.reddit.com/r/LabVIEW/comments/1h4zbvc/switching_from_labview_t
o_python_pros_and_cons/
12.​Custom vs. Off-the-Shelf Software: Cost Comparison | News - Essential Designs,
accessed on June 6, 2025,
https://www.essentialdesigns.net/news/custom-vs-off-the-shelf-software-cost-c
omparison
13.​How often is LabVIEW and NI hardware actually used in industrial applications? -
Reddit, accessed on June 6, 2025,
https://www.reddit.com/r/LabVIEW/comments/pbshux/how_often_is_labview_and
_ni_hardware_actually/
14.​LabVIEW vs Python: Why not Both | MeasureIT, accessed on June 6, 2025,
https://measureit.eu/wp-content/uploads/2025/02/LabVIEW-vs-Python-Why-Not-
Both.pdf
15.​Mid-Infrared Spectrometer for Black Plastics Sorting Using a Broadband
 Uncooled Micro-Bolometer Array - MDPI, accessed on June 6, 2025,
https://www.mdpi.com/2813-446X/3/2/13
16.​Material Detection with Thermal Imaging and Computer Vision: Potentials and
Limitations - ScholarWorks@UARK, accessed on June 6, 2025,
https://scholarworks.uark.edu/cgi/viewcontent.cgi?article=5749&context=etd
17.​Analytical Methods for In-Depth Assessment of Recycled Plastics: A Review -
MDPI, accessed on June 6, 2025, https://www.mdpi.com/2076-3298/12/5/154
18.​gpereyrairujo/IRimage: IRimage: Open source software for ... - GitHub, accessed
on June 6, 2025, https://github.com/gpereyrairujo/IRimage
19.​Exploring Image Processing with Python - IRJET, accessed on June 6, 2025,
https://www.irjet.net/archives/V11/i2/IRJET-V11I248.pdf
20.​Camera EMVA standards: GenICam, GigEVision, USB3Vision | Opto ..., accessed
on June 6, 2025,
https://www.opto-e.com/en/basics/Camera-EMVA-standards-GenICam-GigEVisi
on-USB3Vision
21.​GenICam Standard and CVB Driver Structure - Common Vision Blox, accessed on
June 6, 2025,
https://help.commonvisionblox.com/NextGen/14.1/md_theory_of_operation_hard
ware__genicam_standard.html
22.​(PDF) Cloud2IR an infrared and environmental SHM information system -
ResearchGate, accessed on June 6, 2025,
https://www.researchgate.net/publication/305631816_Cloud2IR_an_infrared_and_
environmental_SHM_information_system
23.​CVB GenICam User Guide - Common Vision Blox, accessed on June 6, 2025,
https://help.commonvisionblox.com/NextGen/14.0/md_theory_of_operation_hard
ware__gen_i_cam__c_v_b__user_guide.html
24.​GigE Vision - Pleora Technologies, accessed on June 6, 2025,
https://www.pleora.com/about-us/standards-leadership/gige-vision/
25.​genicam - PyPI, accessed on June 6, 2025, https://pypi.org/project/genicam/
26.​harvesters-util - PyPI, accessed on June 6, 2025,
https://pypi.org/project/harvesters-util/
27.​USB3 Vision, GigE & GenICam Integration Guide | VisioForge Help, accessed on
June 6, 2025,
https://www.visioforge.com/help/docs/dotnet/videocapture/video-sources/usb3v-
gige-genicam/
28.​GigE Vision for Real-Time Machine Vision, accessed on June 6, 2025,
https://nstx.pppl.gov/nstxhome/DragNDrop/Operations/Diagnostics_&_Support_S
ys/D1CCD/GigE_Vision_for_Realtime_MV_11052010.pdf
29.​OpenCV with GigE Vision Cameras [closed] - Stack Overflow, accessed on June
6, 2025,
https://stackoverflow.com/questions/3345467/opencv-with-gige-vision-cameras
30.​USB3 Vision - Common Vision Blox - Software for Machine Vision, accessed on
June 6, 2025,
https://help.commonvisionblox.com/NextGen/14.1/md_theory_of_operation_hard
ware__u_s_b3_vision.html
31.​USB3 Vision Standard | Automate, accessed on June 6, 2025,
https://www.automate.org/vision/vision-standards/usb3-vision-standard
32.​APIs & SDKs for Easy IR Cameras Integration - Optris, accessed on June 6, 2025,
https://optris.com/us/software/apis-sdks/
33.​Spinnaker SDK C++: Getting Started - FLIR, accessed on June 6, 2025,
https://softwareservices.flir.com/spinnaker/latest/index.html
34.​Getting Started with OpenCV | Teledyne Vision Solutions, accessed on June 6,
2025,
https://www.teledynevisionsolutions.com/support/support-center/application-not
e/iis/getting-started-with-opencv/
35.​FLIR Science File SDK: File Transfer Tool | Teledyne FLIR, accessed on June 6,
2025,
https://www.flir.com/products/flir-science-file-sdk?vertical=science&segment=so
lutions
36.​flirpy - PyPI, accessed on June 6, 2025, https://pypi.org/project/flirpy/
37.​flirpy Documentation, accessed on June 6, 2025,
https://flirpy.readthedocs.io/_/downloads/en/latest/pdf/
38.​Software Development Kits - Teledyne DALSA, accessed on June 6, 2025,
https://www.teledynedalsa.com/en/support/downloads-center/software-develop
ment-kits/
39.​Sapera LT SDK | Teledyne Vision Solutions, accessed on June 6, 2025,
https://www.teledynevisionsolutions.com/products/sapera-lt-sdk?vertical=tvs-dal
sa-oem&segment=tvs
40.​Seek Thermal SDK C Programming Guide | PDF | Directory (Computing) - Scribd,
accessed on June 6, 2025,
https://www.scribd.com/document/605753897/Seek-Thermal-SDK-C-Programmi
ng-Guide
41.​lod/seek-thermal-documentation - GitHub, accessed on June 6, 2025,
https://github.com/lod/seek-thermal-documentation
42.​Top 8 Image-Processing Python Libraries Used in Machine Learning - Neptune.ai,
accessed on June 6, 2025,
https://neptune.ai/blog/image-processing-python-libraries-for-machine-learning
43.​OpenCV: Computer Vision Projects with Python - hlevkin, accessed on June 6,
2025,
https://hlevkin.com/hlevkin/45pythonImageProc/Howse-Joshi-Beyeler_opencv_c
omputer_vision_projects_with_python.pdf
44.​infrared image processing in openCV edit, accessed on June 6, 2025,
https://answers.opencv.org/question/182050/infrared-image-processing-in-open
cv/
45.​How to obtain infra red / heat vision using opencv - Stack Overflow, accessed on
June 6, 2025,
https://stackoverflow.com/questions/30483149/how-to-obtain-infra-red-heat-visi
on-using-opencv
46.​How to Measure Temperature Using Python and OpenCV - Toolify.ai, accessed on
June 6, 2025,
 https://www.toolify.ai/ai-news/how-to-measure-temperature-using-python-and-
opencv-2050993
47.​Exploring Python's NumPy, SciPy, and Matplotlib for Scientific Insights - C#
Corner, accessed on June 6, 2025,
https://www.c-sharpcorner.com/article/exploring-pythons-numpy-scipy-and-mat
plotlib-for-scientific-insights/
48.​Heat map in python (scipy, numpy, matplotlib) : r/learnpython - Reddit, accessed
on June 6, 2025,
https://www.reddit.com/r/learnpython/comments/48d3m0/heat_map_in_python_
scipy_numpy_matplotlib/
49.​PyTirCam-1.0: A Python Model to Manage Thermal Infrared Camera Data - MDPI,
accessed on June 6, 2025, https://www.mdpi.com/2072-4292/12/24/4056
50.​NelisW/pyradi: a Python toolkit to perform optical and infrared computational
radiometry, accessed on June 6, 2025, https://github.com/NelisW/pyradi
51.​gige-vision · GitHub Topics, accessed on June 6, 2025,
https://github.com/topics/gige-vision
52.​Advanced Thermal Image Processing - Optris, accessed on June 6, 2025,
https://optris.com/lexicon/thermal-image-processing/
53.​How AI complements 4 common sensors - NIR, Digital Watermarking, X-ray, RGB,
accessed on June 6, 2025,
https://www.greyparrot.ai/resources/blog/waste-sensors-ai-analytics
54.​IoT-Enhanced Recycling: A Smart Low-Cost Solution for Sustainable Plastic Waste
Management - ResearchGate, accessed on June 6, 2025,
https://www.researchgate.net/publication/387588977_IoT-Enhanced_Recycling_A
_Smart_Low-Cost_Solution_for_Sustainable_Plastic_Waste_Management
55.​[2505.16513] Detailed Evaluation of Modern Machine Learning Approaches for
Optic Plastics Sorting - arXiv, accessed on June 6, 2025,
https://arxiv.org/abs/2505.16513
56.​Development, optimization, and deployment of thermal forward vision systems
for advance vehicular applications on edge devices. - arXiv, accessed on June 6,
2025, https://arxiv.org/pdf/2301.07613
57.​Identification of Aged Polypropylene with Machine Learning and Near–Infrared
Spectroscopy for Improved Recycling - PMC, accessed on June 6, 2025,
https://pmc.ncbi.nlm.nih.gov/articles/PMC11902415/
58.​diminDDL/IR-Py-Thermal: Python Thermal Camera Library - GitHub, accessed on
June 6, 2025, https://github.com/diminDDL/IR-Py-Thermal
59.​Thermal Raw Data — Spot 5.0.0 documentation - Spot SDK - Boston Dynamics,
accessed on June 6, 2025,
https://dev.bostondynamics.com/docs/concepts/data_acquisition_thermal_raw.ht
ml
60.​Thermography - Wikipedia, accessed on June 6, 2025,
https://en.wikipedia.org/wiki/Thermography
61.​The Infrared Thermography Toolbox: An Open-access Semi-automated
Segmentation Tool for Extracting Skin Temperatures in the Thoracic Region
including Supraclavicular Brown Adipose Tissue, accessed on June 6, 2025,
 https://pmc.ncbi.nlm.nih.gov/articles/PMC9626432/
62.​(PDF) Low-Cost Open-Source Melt Flow Index System for Distributed Recycling
and Additive Manufacturing - ResearchGate, accessed on June 6, 2025,
https://www.researchgate.net/publication/384449945_Low-Cost_Open-Source_
Melt_Flow_Index_System_for_Distributed_Recycling_and_Additive_Manufacturin
g
63.​non-uniformity correction algorithm: Topics by Science.gov, accessed on June 6,
2025,
https://www.science.gov/topicpages/n/non-uniformity+correction+algorithm
64.​BDL_project_report | PDF - SlideShare, accessed on June 6, 2025,
https://www.slideshare.net/slideshow/bdlprojectreport-56460928/56460928
65.​beyondmetis/GSMPP: GSM-based IR non-uniformity denoising algorithm -
GitHub, accessed on June 6, 2025, https://github.com/beyondmetis/GSMPP
66.​leswright1977/PyThermalCamera: Python Software to use the Topdon TC001
Thermal Camera on Linux and the Raspberry Pi - GitHub, accessed on June 6,
2025, https://github.com/leswright1977/PyThermalCamera
67.​Correction of emissivity in thermograms with neural networks - Taylor & Francis
Online: Peer-reviewed Journals, accessed on June 6, 2025,
https://www.tandfonline.com/doi/pdf/10.1080/17686733.2025.2479949
68.​A Camera Calibration Method for Temperature Measurements of Incandescent
Objects Based on Quantum Efficiency Estimation - MDPI, accessed on June 6,
2025, https://www.mdpi.com/1424-8220/25/10/3094
69.​How to Compensate for Emissivity Variation - Williamson IR, accessed on June 6,
2025,
https://www.williamsonir.com/blog/how-to-compensate-for-emissivity-variation/
70.​Full article: Correction of emissivity in thermograms with neural networks,
accessed on June 6, 2025,
https://www.tandfonline.com/doi/full/10.1080/17686733.2025.2479949
71.​Accuracy - NI - National Instruments, accessed on June 6, 2025,
https://www.ni.com/docs/en-US/bundle/ni-dmm/page/accuracy.html
72.​Device Calibration - NI - National Instruments, accessed on June 6, 2025,
https://www.ni.com/docs/en-US/bundle/ni-daqmx/page/devcalibrate.html
73.​Clothooo/lvt2calib: A unified calibration for 3D LiDARs, visual cameras and
thermal cameras, accessed on June 6, 2025,
https://github.com/Clothooo/lvt2calib
74.​Calibrating your sensors - Autoware Documentation, accessed on June 6, 2025,
https://autowarefoundation.github.io/autoware-documentation/main/how-to-gui
des/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensor
s/
75.​(PDF) Performance comparison of instrument automation pipelines using
different programming languages - ResearchGate, accessed on June 6, 2025,
https://www.researchgate.net/publication/375082463_Performance_comparison_
of_instrument_automation_pipelines_using_different_programming_languages
76.​The advantage of Python in GIS - Reddit, accessed on June 6, 2025,
https://www.reddit.com/r/gis/comments/1b7c7vo/the_advantage_of_python_in_gi
 s/
77.​Syntalos: a software for precise synchronization of simultaneous multi-modal
data acquisition and closed-loop interventions - PubMed Central, accessed on
June 6, 2025, https://pmc.ncbi.nlm.nih.gov/articles/PMC11736130/
78.​Comparing Off-the-Shelf and Custom Software - Blue Coding, accessed on June
6, 2025,
https://www.bluecoding.com/post/custom-software-vs-off-the-shelf-software
79.​roleoroleo/yi-hack-MStar: Custom firmware for Yi 1080p camera based on MStar
platform - GitHub, accessed on June 6, 2025,
https://github.com/roleoroleo/yi-hack-MStar
80.​Hardware Compatibility List - ZoneMinder Wiki, accessed on June 6, 2025,
https://wiki.zoneminder.com/Hardware_Compatibility_List