[1]Francesca Santoro [2,3]Gianlorenzo Massaro These authors contributed
equally to this work. These authors contributed equally to this work. These
authors jointly supervised this work.

1]Planetek Italia s.r.l., Bari, I-70132, Italy 2]Dipartimento Interateneo di
Fisica, Università degli Studi di Bari, Bari, I-70125, Italy 3]INFN - Sezione
di Bari, Bari, I-70125, Italy 4]Planetek Hellas E.P.E., Athens, 15125,
Marousi, Greece 5]École polytechnique fédérale de Lausanne (EPFL), Neuchâtel,
2002, Switzerland

# GPU-based data processing for speeding-up correlation plenoptic imaging

<EMAIL_ADDRESS>Isabella Petrelli<EMAIL_ADDRESS>George
Filios  Francesco V. Pepe  Leonardo Amoruso  Maria Ieronymaki  Samuel Burri
Edoardo Charbon  Paul Mos  Arin Ulku  Michael Wayne  Cristoforo Abbattista
Claudio Bruschini  Milena D’Angelo  [  [  [  [  [

###### Abstract

Correlation Plenoptic Imaging (CPI) is a novel technological imaging modality
enabling to overcome drawbacks of standard plenoptic devices, while preserving
their advantages. However, a major challenge in view of real-time application
of CPI is related with the relevant amount of required frames and the
consequent computational-intensive processing algorithm. In this work, we
describe the design and implementation of an optimized processing algorithm
that is portable to an efficient computational environment and exploits the
highly parallel algorithm offered by GPUs. Improvements by a factor ranging
from 20x, for correlation measurement, to 500x, for refocusing, are
demonstrated. Exploration of the relation between the improvement in
performance achieved and actual GPU capabilities, also indicates the
feasibility of near-real time processing capability, opening up to the
potential use of CPI for practical real-time application.

###### keywords:

GPU, optimization, Correlation Plenoptic Imaging

##  1 Introduction

Correlation Plenoptic Imaging (CPI) is a novel imaging modality exploiting
spatio-temporal intensity correlations of light to enable plenoptic (or light-
field) imaging at the diffraction limit [1, 2, 3, 4, 5, 6, 7, 8]. In
traditional plenoptic imaging techniques, based on direct intensity
measurement, information on light spatial distribution and direction are
encoded in a single detector [9, 10, 11], thus entailing spatial resolution
reduction. Based on the different physical mechanism that underlies the
standard and the correlation approach to light-field imaging, CPI considerably
extends the accessible volumetric resolution [5, 12, 13, 14]. Several
alternative configurations of CPI have so far been proposed [4, 15, 16, 17,
7], working with the intrinsic correlations of either chaotic light [1] or
entangled photon pairs [3]. However, measuring light spatio-temporal
correlations imposes the typical drawback of correlation imaging, namely the
need to collect a statistically relevant number of frames to reconstruct the
pixel-by-pixel correlation function with acceptable signal-to-noise ratio
[18]; this potentially limits the acquisition and elaboration speed, imposing
a challenge in view of real time applications (see, e.g., [19, 20, 21]).

In Ref. [8], correlation photon imaging at a rate of 10 volumetric images per
second was achieved, thanks to the combination of chaotic light and the use of
ultra-fast detectors: SwissSPAD2, an array of single photon avalanche
photodiodes (SPAD) capable of capturing up to $10^{5}$ binary frames per
second with ns resolution, while combining an extremely low noise and high
detection efficiency [22, 23, 24, 7]. However, even if the overall measurement
time benefits from the speed of the SPAD arrays, the binary nature of the
acquired frames imposes the need to acquire an even larger number of frames
with respect to previous CMOS-based CPI experiments [8], leading to a critical
extension of the computational time [25, 26]. To address this challenge, in
this article, we explore the adoption of ultra-fast computing platforms based
on Graphic Processing Units (GPUs), and demonstrate a 20x to 500x improvement
in elaboration time over the conventional CPU-based approach so far employed.

The paper is organized as follows: in Section 2, we provide a description of
the sample dataset used for benchmarking the optimized CPI software (SW)
version exploiting GPU. In Section 4, we present the software architecture
developed in the frame of this activity as well as some specific software
development kit (SDK) functionalities made available to facilitate CPI data
management. In Section 5, we present the results obtained by optimizing the
CPI algorithm for GPU-related environment, and in Section 6, we discuss the
conclusions and future perspectives.

##  2 Input Dataset

The GPU-optimized software solution presented in this work assumes that the
relevant amount of input data needed for CPI processing has been already
acquired and stored on file-system, formatted as binary data. The adopted data
format is in line with the output interface (I/F) foreseen by SwissSPAD2
acquisition sensor boards [22], in order to facilitate the future perspective
of concatenating easily the data acquisition and the data processing chains.
The sample dataset used in our experiments, as shown in Fig. 1, is detailed as
follows:

  * •

Dataset(s):

    * –

Full Dataset: Set of 7808 .bin files, 8MiB each

    * –

Subset: Set of 20 .bin files, 8MiB each

  * •

Each file contains a fixed amount of frames $N_{\text{file}}$ (i.e. 512 binary
frames)

  * •

Frame size: $256\times 512$ px

  * •

Bit-depth = 1 bit

Each of the $N_{\text{file}}$ frames within a .bit file is composed of two
$256\times 256$ side-by-side images, as shown in Fig. 2, which shows an
overview (cumulative sum of binary frames) of the used dataset. Hence, the
leftmost part of each frame (from pixel 1 to pixel 256) represents one image
$A^{i}_{j\,k}$, and the rightmost part (pixel 257 to 512) represents a second
image $B^{i}_{j\,k}$, where the index $i=1,\dots,N_{\text{files}}$ identifies
the frame within the .bin file, and $j,k=1,\dots,256$ represent pixels
coordinates along the horizontal and vertical, respectively. By considering
that the dataset consists of many .bin files ($N$), the total number of images
$A$ and $B$ is $N_{\text{TOT}}=N\times N_{\text{files}}$.

Since our work only deals with the computational aspects related to the
analysis of such datasets, further experimental details (e.g. optical design,
imaging parameters, noise performance) will not be reported. Detailed
discussion about the experimental aspects can be found in Ref. [8].

Figure 1: Experimental setup and acquired data architecture. Further details
about the experiment are available in Ref. [8]. Figure 2: Input Data preview:
grey-scale image resulting from the cumulative sum of 512 sample binary frames
acquired during the experiment using SwissSPAD2.

##  3 CPI algorithm

The algorithm for extracting the 3D stack of axial images from the dataset
consists of two main blocks:

  1. 1.

Evaluation of the correlation function. A four-dimensional correlation
function $\Gamma$ is evaluated from the $N_{\text{TOT}}$ images $A$ and $B$.
$\Gamma$ is obtained by averaging the tensor product between corresponding
images $A^{i}\otimes B^{i}$, and subtracting the tensor product of the two
average images from that quantity:

$\Gamma_{j\,k\,m\,n}=\frac{1}{N_{\text{TOT}}}\sum_{i=1}^{N_{\text{TOT}}}A^{i}_{j\,m}\,B^{i}_{k\,n}-\left(\frac{1}{N_{\text{TOT}}}\sum_{i=1}^{N_{\text{TOT}}}A^{i}_{j\,m}\right)\left(\frac{1}{N_{\text{TOT}}}\sum_{i=1}^{N_{\text{TOT}}}B^{i}_{k\,n}\right).$
(1)

The computational cost of this process depends on the pixel size of the images
and on the number of images;

  2. 2.

Refocusing. The 4D correlation function is then processed through an algorithm
based on Radon transformations [12, 26], which extracts the 3D stack of axial
sections. Since it is applied after averaging over the number of planes, the
computational requirements of this step only depend on the pixel size of the
correlation function [25].

##  4 Software Architecture

###  4.1 Overview

The development of our optimized SW solution relies on a pre-existing
proprietary software framework, designed and developed within the Planetek
group, whose functionalities were customized to respond to requirements of
improving CPI timing performances in a GPU-based environment. The CPI software
architecture depicted in Fig. 3 is focused on the exploitation of a dedicated
GPU-based acceleration device, and can be decomposed into two main categories
of SW components:

  1. 1.

Low-level kernel-mode software components, aimed at direct interfacing the HW
setup responsible for data acquisition from sensor boards; it can be further
divided into:

    1. (a)

HW PCIe Sensor Connection

    2. (b)

Linux Kernel Driver

    3. (c)

Linux Kernel

    4. (d)

Linux Kernel API for User Space

  2. 2.

User-mode software components, responsible for the actual algorithmic
processing and data delivery; it consists of:

    1. (a)

Frame Capture Sub-System

    2. (b)

Frame Processor

    3. (c)

Output Stage

A detailed overview of the Frame Processor SW component is then provided in
Fig. 3 (top-right), in which main steps of Correlation Plenoptic Imaging (CPI)
algorithmic workflow are listed in sequence, highlighting those one identified
as characterized by critical performances, and thus presented as good
candidates for a GPU-based implementation.

Figure 3: High-level SW Architecture for CPI applications based on GPU
acceleration.

###  4.2 Software Development Kit (SDK)

The software framework considered as the baseline for this activity provides a
multi-platform C++17 [27] development environment (an SDK) for the creation of
software applications ranging from console-based data processors to
interactive graphics tools, mainly dedicated to image processing and
visualisation. Its main goal is to provide a cross-platform development
environment and runtime for creating general purpose applications that can run
on desktop, server and embedded systems with a single code base. It achieves
this goal by combining a rich set of dedicated classes with the functionality
provided by the C++17 runtime library. As a framework, it is composed of a
collection of dynamic libraries, and their respective include files, organized
according to a hierarchical approach, based on the following three foundation
libraries:

  * •

CORE, which is responsible for abstracting the underlying operating system
services for the upper layers of any application, so that access to the
filesystem, some inter-process communication facilities, and other low-level
services become cross-platform the user of the framework;

  * •

MATH, which provides basic mathematics functions and structures, such as
vectors, matrices, simple algorithms;

  * •

ACC, which provides image manipulation and processing capabilities,
abstraction of acceleration facilities (such as those based on OpenCL), and
implementations of thread schedulers for multi-processing architectures.

On top of these three libraries, we have created other libraries with further
specialisations and a rich ecosystem of plugins that extend the capabilities
of the overall framework in terms of:

  1. 1.

Support for 3rd party image formats (such as jpeg, tiff, png, hdf5, etc.) both
in reading and in writing;

  2. 2.

Support for more algorithms, both of general usage and very specialized,
encapsulated into entities named engines, i.e. a special-purpose plugins;

  3. 3.

Support for more acceleration devices and APIs. In this context, for example,
the OpenCL engine provides an implementation of the Accelerator interface
found in ACC, thus allowing access to a GPU or a CPU-based OpenCL platform,
then widely used in the development of the CPI optimized application.

The diagram in Fig. 4 shows an overview of the basic libraries and their
respective functionalities, detailed in Section 4.2.1.

####  4.2.1 SDK Core Functionalities

In this section, we provide a high-level description of the core
functionalities offered by the aforementioned SDK, implicitly exploited in
designing and developing the optimized SW version of CPI application.

Figure 4: Map of lower-level SDK functionalities.

##### Memory Management

The framework is designed by considering the typical memory management
practice (including the type of allocations) developers face when writing
C/C++ programs, i.e. static allocations in the data segment, allocation of
dynamic memory (heap memory), and automatic allocation, implying the use of
the stack. To this end, the framework provides a set of abstractions of the
allocation/de-allocation functionalities, which proved to be relevant in
handling the large volumes of data required by the CPI approach.

##### Dynamic Loading of Code

The use of Dynamic-Link Library (DLL) allows the implementation of extensible
applications by using the concept of a plugin. There are specialized classes
responsible for interfacing with the operating system for using the capability
of opening DLLs, searching for specific symbols (mostly representing
functions), and creating a sort of binding between the application and the
code these functions contain. This allows the application to be extended with
functionality on the fly, assuming that the overall architecture of the
application is appropriately designed through the use of specific concept
modelling.

##### Type System

The SDK has its internal type-system to allow easy management of data and
their conversion functions to one another and any suitable string
representation. The type-system is used in any part of the framework, mostly
for attributes management, hierarchical data handling and generic
serialization/deserialization to/from buffers and strings.

##### Abort Management

The SDK allows to manage eventual issues in software application behaviour
coming from e.g. incomplete input validation code, incorrect memory management
in terms of allocation and de-allocation, error in the implementation, and
Hardware (HW) errors, that can cause a degraded SW behaviour. To manage these
issues, always present in the SW lifecycle as a result of the development,
testing, and validation process, the framework introduces the concept of
“degraded execution mode” and “predictive bug management” through the Abort
Management sub-system.

Figure 5: SDK functionalities specifically devoted to Image Processing
(improc).

####  4.2.2 SDK CPI-specific Functionalities

The current section provides a high-level description of some relevant
functionalities included in the SDK and strictly related to activities of SW
development and optimization customized for the CPI application.

##### Image Processing

The improc library provides functionalities and classes related to multi-
dimensional image processing, spanning from low-level pixel-based operations
(e.g. thresholding, subtraction, multiplication etc) to more elaborated
filtering (e.g. convolution, derivative, gaussian, etc), as resumed in Fig. 5.
The following two types of image data made available within the SDK were
largely adopted during the CPI algorithm refactoring to represent bi-
dimensional and 3-dimensional image data, respectively.

Image 2D -  The CImage2D class of ACC is an abstraction of an ordered sequence
of pixel of the same type laid out in main memory or on file system through
the memory-mapping API of the operating system. ACC provides access classes
(readers and writers) for performing operations on a CImage2D instance.

Image 3D -  The CImage3D class of ACC is an abstraction of a vector of
CImage2D of pixels of the same type laid out as determined by the CImage2D
instances inside it. ACC provides access classes (readers and writers) for
performing operations on a CImage3D instance. The pixel of a CImage3D is a
vector of D components of the same type, each representing the pixel in the
corresponding layer.

##### Acceleration Abstraction: multi-thread analysers and GPU

The SDK infrastructure related to Abstract Acceleration provides support for
multi-CPU, multi-GPU and multi-core architectures, as sketched in Fig. 6. A
central role in this context is covered by the SDK-related concept of
Analyser.

Figure 6: Multi-core acceleration managed by the SDK. Figure 7: The Analyzer
mechanics (multi GPU). Figure 8: The Analyzer mechanics applied to an
instantiated CImage3D.

The Analyser is an entity of the framework that implements a map/reduce
paradigm for performing computations on images of any size, preferably large
images, where the paradigm can offer a relevant improvement in terms of
computational performances. More specifically, the framework entities related
to Analysers will get the input image, divide it in tiles and then schedule a
thread for each tile always limiting the number of concurrent threads to the
hardware-concurrency of the host system. The processing on the specified
element can be activated on the whole image, or onto a set of sub-images of
the main image. Consider Fig. 7 for a schematic of the Analyzer mechanics
augmented by the use of GPU, while Fig. 8 shows the case of accelerator
applied to a CImage3D object.

OpenCL (Open Computing Language) is an open standard for writing programs that
execute across heterogeneous platforms consisting of central processing units
(CPUs), graphics processing units (GPUs), and other processors or hardware
accelerators from different vendors. In this context, particular attention has
been provided in empowering the CPI-relate framework with OpenCL-based
functionalities in order to ensure cross-vendor portability and cross-device
compatibility. To this end, the ACC library provides the capability, through
the pkacc::CAbstractAccelerator related infrastructure, for building
acceleration engines based on OpenCL. As presented in Fig. 9, the COpenCL
Service provides instances of CAbstractAccelerator, one for each detected
OpenCL capable device found on the system and presented by the operating
system and its device drivers. The abstraction adapts entities of the SDK,
such as Image2D, Image3D and Buffer to what the OpenCL standard expects to
exchange with the GPU or any supported accelerator. This is done concretely
into the OpenCL engine named en_opencl, which shall be built by linking the
Vendor specific SDKs, and loaded by the runtime environment of the SDK
framework.

Figure 9: OpenCL specialization of ACC Abstract Accelerator.

##  5 Results and Discussion

###  5.1 CPI enhancement in GPU-based environment

The results discussed here were aimed at optimising CPI computational
performance by applying an algorithm refactoring focused on the implementation
of customised OpenCL features for execution on parallel computing
accelerators. A strategy based on a hybrid solution involving both CPU-based
and GPU devices has been followed, implementing an OpenCL-based processing
kernel. In detail, several features offered by our SDK have been exploited to
develop programs that can be executed on heterogeneous platforms while being
device-agnostic. In this context, the OpenCL standard ensures that the
complexity of translating entities of the SDK (such as CImage2D, CImage3D,
buffers, etc.) to what is expected to be exchanged with the accelerator device
(e.g. a GPU) is left to the infrastructure Abstraction Layer, and this removes
the need for the end user to explicitly manage the processing devices.

The considered algorithmic procedure consists of the following two main steps
to be optimized: (i) calculation of the Cross-Correlation matrix between two
Regions-of-Interest (RoI), and (ii) the Refocusing of the image for a specific
refocusing plane. For benchmarking purposes, the selected use case is
considered to analyze and cross-correlate two images, each of 256x256 pixels.

##### Cross-correlation Optimization

In the original version of the prototypal code, considered as a baseline for
performance comparison, the files containing the frames/images of the input
are read, bit-unpacking is performed, and the cross-correlation between the
two ROIs is computed by matrix multiplication (Eq. (1)). More specifically,
the refactoring of this step relies on the fact that the input binary data are
formatted as binary information (i.e. each pixel of the acquired images can
assume only 0 or 1 value alternatively). In this scenario, a strategy based on
bit-packing has been adopted, then implementing the cross-correlation
multiplication as a bit-by-bit AND operation, thus exploiting capabilities of
parallel processing (i.e. performing the same operation on multiple data
points simultaneously). In the optimized OpenCL solution, bit unpacking and
cross-correlation calculation occur jointly in the same kernel by bitwise
operations. Moreover, since the size of the cross-correlation matrix may not
fit entirely into the memory of the specific device, the computation is
divided into a dynamic number of blocks, depending on the memory available.

##### Refocusing Optimization

Considering the refocusing step, the prototypal implementation include a 4D
multilinear interpolation of the resulting cross-correlation matrix. The
points of interpolation vary according to the selected refocusing plane and
are usually computed images for multiple refocusing planes. Moreover, the
prototypal implementation of the algorithm requires a relevant quantity of RAM
($\sim 100$ GB) to run on 256x256 images, and is therefore unusable on more
modest hardware. In the optimized OpenCL solution, refocusing requires little
more than the memory required to keep the same cross-correlation matrix and
output files in RAM, as the interpolation coordinates are computed on-the-fly
in the main refocusing kernel. Again, for reasons similar to the cross-
correlation calculation, the algorithm proceeds by blocks. The number of
blocks is determined dynamically based on the memory available on the device
used for acceleration, thus improving the achievable overall computing
performances, based on the actual hardware available for processing.

###  5.2 SW benchmarks

In the current section, we present a comparison of the execution times of the
algorithm in its original version, and in the optimized version (w OpenCL-
based kernel). Since in both cases the algorithm consists of two independent
parts (cross-correlation and refocusing), whose execution times scale based on
different factors, the benchmarks have been reported separately for the two
sections of the algorithm in both prototypal code and OpenCL. Note that
because the data and the output data format is different in the two
implementations, the times for writing the data to disk have been excluded
from the comparison.

Table 1: HW specifications of platform(s) used for benchmarks. Left: Test Platform specs. Right: Target Platform specs.  | Test Platform | Target Platform
---|---|---
OS | Ubuntu 20.04 | Ubuntu 18.04
CPU | Intel(R) i7-9700k @3.60GHz | AMD Ryzen Threadripper PRO3955WX @3.90GHz
RAM | 64 GB | 256 GB
GPU | NVIDIA RTX 2080Ti [11GB] | NVIDIA RTX4090 [24 GB]
|  |

Relevant specifications of the HW test platform used for benchmarking are
reported in Table 1. In detail, results presented in Figs. 10–12 were obtained
using the Test Platform (Table 1).

##### Cross-correlation

Benchmarks for cross-correlation were performed on areas of interest of size
256x256. Since the execution time for cross-correlation scales according to
the number of frames (and thus files) as input, benchmarks were performed
using the following incremental number of files: 11, 100, 500, 7808 (size of
the full dataset). Given the long run times, benchmarks have been omitted for
prototypal runs for 256x256 images with 500 and 7808 files, but the
extrapolation of the time elapsed in these cases was performed and shown in
Fig. 10. Results obtained in terms of average execution time are presented in
graphical format in Fig. 10.

Figure 10: CPI Cross Correlation: running time benchmark of prototypal
implementation VS Open-CL optimization.

##### Refocusing

Benchmarks for refocusing were performed on both 128x128 and 256x256 images
for OpenCL, but only 128x128 in the case of prototypal implementation, since
the latter requires an amount of RAM memory not available on the workstation
used. Since the execution time of the refocusing step is independent of the
number of input files input, but depends only on the amount of output images
to be produced (i.e., it varies according to the amount of refocusing planes
desired), the benchmarks were performed with a fixed number of files (11
files) and with a variable number of refocusing planes: 100, 261, 1000.
Results are presented for 128x128 and 256x256 RoI in Figs. 11-12,
respectively.

Figure 11: CPI Refocusing: running time benchmark of Open-CL optimization
(RoI: 128x128). Figure 12: CPI Refocusing: running time benchmark of Open-CL
optimization (RoI: 256x256).

####  5.2.1 Performance VS GPU-memory

As an additional experiment, we tested the OpenCL-based optimized version of
the Cross-Correlation processing using different platforms mounting NVIDIA
GPUs with increasing available memory. The activity described above is aimed
at investigating the potential in achieving near-realtime computation when a
processing device with a powerful GPU is available. In this case, the analysis
is performed for cross-correlation only, being this step the most challenging
in terms of computational times, and thus the potentially limiting factor for
future perspective going towards the design of a near-real time CPI device.

Figure 13 shows the total amount of time for Cross-Correlation processing
(expressed in seconds) as a function of the nominal GPU memory made available
by the processing device. Benchmarks reported here were performed using a
significant subset of the input dataset (see Section 2), that can be
considered representative of a typical use case for CPI application.

Figure 13: Optimized Performance achieved in CrossCorr computation versus GPU
device memory. Experiment performed using the following configuration of
parameters: RoI 256x256, input data subset made of $\sim$ 10 thousand binary
frames.

##  6 Conclusion

Achievements presented in previous sections demonstrate the actual ability to
improve the CPI processing capabilities when moving from the baseline
prototypal version (entry point of the activity) to the final GPU-optimized
implementation. Benchmarks presented in Section 4 show that the optimized
OpenCL-based implementation provides relevant improvements in the
computational time elapsed for the target CPI algorithm, quantified as 10x to
20x for the Cross-correlation step, up to the impressive result of >500x for
the Refocusing part. In addition, it has been proved that the proposed
implementation is able to scale performance according to the HW available,
thus leaving open the possibility of including a better performing HW (i.e.
GPU with larger memory) in order to achieve the desired computing
performances.

Data availability statement All data are available upon request to the
corresponding authors.

Acknowledgements Activity funded within the frame of Qu3D Project, supported
by the Italian Istituto Nazionale di Fisica Nucleare, the Swiss National
Science Foundation (grant 20QT21 187716 “Quantum 3D Imaging at high speed and
high resolution”), the Greek General Secretariat for Research and Technology,
the Czech Ministry of Education, Youth and Sports, under the QuantERA
programme, which has received funding from the European Union’s Horizon 2020
research and innovation programme.

## References

  *   * D’Angelo et al. [2016] D’Angelo, M., Pepe, F.V., Garuccio, A., Scarcelli, G.: Correlation plenoptic imaging. Phys. Rev. Lett. 116, 223602 (2016)
  * Pepe et al. [2016a] Pepe, F.V., Scarcelli, G., Garuccio, A., D’Angelo, M.: Plenoptic imaging with second-order correlations of light. Quantum Measurements and Quantum Metrology 3(1), 20–26 (2016)
  * Pepe et al. [2016b] Pepe, F.V., Di Lena, F., Garuccio, A., Scarcelli, G., D’Angelo, M.: Correlation plenoptic imaging with entangled photons. Technologies 4, 17 (2016)
  * Pepe et al. [2017a] Pepe, F.V., Vaccarelli, O., Garuccio, A., Scarcelli, G., D’Angelo, M.: Exploring plenoptic properties of correlation imaging with chaotic light. Journal of Optics 19(11), 114001 (2017)
  * Pepe et al. [2017b] Pepe, F.V., Di Lena, F., Mazzilli, A., Edrei, E., Garuccio, A., Scarcelli, G., D’Angelo, M.: Diffraction-limited plenoptic imaging with correlated light. Phys. Rev. Lett. 119, 243602 (2017)
  * Massaro et al. [2022] Massaro, G., Giannella, D., Scagliola, A., Di Lena, F., Scarcelli, G., Garuccio, A., Pepe, F.V., D’Angelo, M.: Light-field microscopy with correlated beams for high-resolution volumetric imaging. Scientific Reports 12, 16823 (2022)
  * Abbattista et al. [2021] Abbattista, C., Amoruso, L., Burri, S., Charbon, E., Di Lena, F., Garuccio, A., Giannella, D., Hradil, Z., Iacobellis, M., Massaro, G., et al.: Towards quantum 3d imaging devices. Applied Sciences 11(14), 6414 (2021) https://doi.org/10.3390/app11146414
  * Massaro et al. [2023] Massaro, G., Mos, P., Vasiukov, S., Di Lena, F., Scattarella, F., Pepe, F.V., Ulku, A., Giannella, D., Charbon, E., Bruschini, C., D’Angelo, M.: Correlated-photon imaging at 10 volumetric images per second. Scientific Reports 13(1), 12813 (2023) https://doi.org/10.1038/s41598-023-39416-8
  * Lippmann [1908] Lippmann, G.: Épreuves réversibles donnant la sensation du relief. J. Phys. Theor. Appl. 7(1), 821–825 (1908)
  * Adelson and Wang [1992] Adelson, E.H., Wang, J.Y.: Single lens stereo with a plenoptic camera. IEEE transactions on pattern analysis and machine intelligence 14(2), 99–106 (1992)
  * Ng et al. [2005] Ng, R., Levoy, M., Brédif, M., Duval, G., Horowitz, M., Hanrahan, P.: Light field photography with a hand-held plenoptic camera. Computer Science Technical Report CSTR 2, 1–11 (2005)
  * Massaro [2024] Massaro, G.: Assessing the 3D resolution of refocused correlation plenoptic images using a general-purpose image quality estimator (2024). https://arxiv.org/abs/2406.13501
  * Scattarella et al. [2022] Scattarella, F., D’Angelo, M., Pepe, F.V.: Resolution limit of correlation plenoptic imaging between arbitrary planes. Optics 3, 138–149 (2022)
  * Scattarella et al. [2023] Scattarella, F., Massaro, G., Stoklasa, B., D’Angelo, M., Pepe, F.V.: Periodic patterns for resolution limit characterization of correlation plenoptic imaging. The European Physical Journal Plus 138(8), 710 (2023) https://doi.org/10.1140/epjp/s13360-023-04322-5
  * Scagliola et al. [2020] Scagliola, A., Di Lena, F., Garuccio, A., D’Angelo, M., Pepe, F.V.: Correlation plenoptic imaging for microscopy applications. Phys. Lett. A, 126472 (2020)
  * Di Lena et al. [2018] Di Lena, F., Pepe, F.V., Garuccio, A., D’Angelo, M.: Correlation Plenoptic Imaging: An Overview. Appl. Sci. 8, 1958 (2018)
  * Di Lena et al. [2020] Di Lena, F., Massaro, G., Lupo, A., Garuccio, A., Pepe, F.V., D’Angelo, M.: Correlation plenoptic imaging between arbitrary planes. Opt. Express 28, 35857–35868 (2020)
  * Massaro et al. [2022] Massaro, G., Scala, G., D’Angelo, M., Pepe, F.V.: Comparative analysis of signal-to-noise ratio in correlation plenoptic imaging architectures. The European Physical Journal Plus 137(10), 1123 (2022) https://doi.org/10.1140/epjp/s13360-022-03295-1
  * Cassano et al. [2017] Cassano, M., D’Angelo, M., Garuccio, A., Peng, T., Shih, Y., Tamma, V.: Spatial interference between pairs of disjoint optical paths with a single chaotic source. Opt. Express 25, 6589–6603 (2017)
  * D’Angelo et al. [2018] D’Angelo, M., Mazzilli, A., Pepe, F.V., Garuccio, A., Tamma, V.: Characterization of two distant double-slits by chaotic light second-order interference. Scientific Reports 7, 2247 (2018)
  * Pepe et al. [2022] Pepe, F.V., Scala, G., Chilleri, G., Triggiani, D., Kim, Y.-H., Tamma, V.: Distance sensitivity of thermal light second-order interference beyond spatial. The European Physical Journal Plus 137 (2022)
  * Ulku et al. [2019] Ulku, A.C., Bruschini, C., Antolovic, I.M., Kuo, Y., Ankri, R., Weiss, S., Michalet, X., Charbon, E.: A 512×512 SPAD Image Sensor with Integrated Gating for Widefield FLIM. IEEE J. Sel. Top. Quantum Electron 25, 6801212 (2019)
  * Ulku et al. [2020] Ulku, A.C., Ardelean, A., Antolovic, I.M., Weiss, S., Charbon, E., Bruschini, C., Michalet, X.: Wide-field time-gated SPAD imager for phasor-based FLIM applications. Methods Appl. Fluoresc. 98, 024002 (2020)
  * Antolovic et al. [2016] Antolovic, I.M., Burri, S., Hoebe, R.A., Maruyama, Y., Bruschini, C., Charbon, E.: Photon-counting arrays for time-resolved imaging. Sensors 16, 1005 (2016)
  * Massaro et al. [2022a] Massaro, G., Di Lena, F., D’Angelo, M., Pepe, F.V.: Effect of finite-sized optical components and pixels on light-field imaging through correlated light. Sensors 22(7) (2022) https://doi.org/10.3390/s22072778
  * Massaro et al. [2022b] Massaro, G., Pepe, F.V., D’Angelo, M.: Refocusing algorithm for correlation plenoptic imaging. Sensors 22, 6665 (2022)
  * ISO [2017] ISO: ISO/IEC 14882:2017: Programming Languages — C++, (2017)