Examples
Loading a Measurment
This example demonstrates how to load and process hyperspectral measurement data using the cuvis SDK.
#include "cuvis.h"
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
int main(int argc, char* argv[])
{
if (argc != 3)
{
printf("To few Arguments! Please provide:\n");
printf("user settings directory\n");
printf("sessionfile (.cu3s)\n");
return -1;
}
char* const userSettingsDir = argv[1];
char* const sessionLoc = argv[2];
CUVIS_SESSION_FILE sess;
CUVIS_MESU mesu1;
unsigned chn;
unsigned x;
unsigned y;
const uint16_t* cube16bit;
//const uint16_t* info_ptr;
printf("Example 01 load measurement\n");
printf("\nUser Settings Dir: ");
printf(userSettingsDir);
printf("\nsessionfile (.cu3s): ");
printf(sessionLoc);
printf("\nloading user settings...\n");
CUVIS_CHECK(cuvis_init(userSettingsDir, loglevel_debug));
CUVIS_CHECK(cuvis_set_log_level(loglevel_info));
printf("loading session...\n");
CUVIS_CHECK(cuvis_session_file_load(sessionLoc, &sess));
printf("loading measurement...\n");
CUVIS_CHECK(cuvis_session_file_get_mesu(
sess, 0, session_item_type_frames_no_gaps, &mesu1));
CUVIS_MESU_METADATA mesu_data;
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu1, &mesu_data));
printf(
"data 1 %s %.2f ms mode=%d flags=%d\n",
mesu_data.name,
mesu_data.integration_time,
mesu_data.processing_mode,
mesu_data.measurement_flags);
assert(
mesu_data.processing_mode == Cube_Raw &&
"This example requires raw mode");
CUVIS_IMBUFFER cube;
CUVIS_CHECK(
cuvis_measurement_get_data_image(mesu1, CUVIS_MESU_CUBE_KEY, &cube));
CUVIS_IMBUFFER iminfo;
cuvis_measurement_get_data_image(mesu1, CUVIS_MESU_CUBE_INFO_KEY, &iminfo);
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu1, &mesu_data));
if (mesu_data.measurement_flags & CUVIS_MESU_FLAG_OVERILLUMINATED)
{
printf("-- is overilluminated --\n");
}
else
{
printf("-- is NOT overilluminated --\n");
}
if (mesu_data.measurement_flags & CUVIS_MESU_FLAG_POOR_REFERENCE)
{
printf("-- has poor reference --\n");
}
else
{
printf("-- has GOOD reference --\n");
}
printf("INFO cube No of channels: %d\n", iminfo.channels);
printf("INFO cube width: %d\n", iminfo.width);
printf("INFO cube height: %d\n", iminfo.height);
printf("DATA cube width: %d\n", cube.width);
printf("DATA cube height: %d\n", cube.height);
printf("INFO cube type: %d\n", iminfo.format);
printf("INFO cube bytes: %d\n", iminfo.bytes);
printf("DATA cube type: %d\n", cube.format);
printf("DATA cube bytes: %d\n", cube.bytes);
assert(
cube.format == imbuffer_format_uint16 &&
"16 bit cube required for this example");
//reinterpret as uint16
cube16bit = (const uint16_t*)(cube.raw);
//info_ptr = (const uint16_t*)(iminfo.raw);
x = 120;
y = 200;
assert(x < cube.width && "x index exceeds cube width");
assert(y < cube.height && "x index exceeds cube width");
printf("lambda [nm]; raw counts [au]; pixel info \n");
for (chn = 0; chn < cube.channels; chn++)
{
// memory layout:
//unsigned index = (y * cube.width + x) * cube.channels + chn;
//uint16_t value = cube16bit[index];
uint16_t value = IMBUFFER_GET(cube16bit, x, y, chn, cube);
//only works with v3.X CUVIS data
//auto pixel_info = IMBUFFER_GET(info_ptr, x, y, 0, iminfo);
unsigned lambda = cube.wavelength[chn];
printf(
"%d; %d \n",
//"%d; %d; %d \n",
lambda,
value
//pixel_info);
);
}
printf(" \n");
//for (x = 0; x < cube.width; x++)
//{
// for (y = 0; y < cube.height; y++)
// {
// memory layout:
//unsigned index = (y * cube.width + x) * cube.channels + chn;
//uint16_t value = cube16bit[index];
//auto pixel_info = IMBUFFER_GET(info_ptr, x, y, 0, iminfo);
//printf("%d; ", pixel_info);
// }
// printf(" \n");
//}
cuvis_measurement_free(&mesu1);
cuvis_session_file_free(&sess);
cuvis_shutdown();
printf("finished.\n");
}
#include "cuvis.hpp"
#include <cassert>
#include <iostream>
//#include <opencv/opencv.hpp>
int main(int argc, char* argv[])
{
if (argc != 3)
{
std::cout << "Too few Arguments! Please provide:" << std::endl;
std::cout << "user settings directory" << std::endl;
std::cout << "sessionfile (.cu3s)" << std::endl;
return -1;
}
char* const userSettingsDir = argv[1];
char* const sessionLoc = argv[2];
std::cout << "Example 01 load measurement cpp " << std::endl;
std::cout << "User Settings Dir: " << userSettingsDir << std::endl;
std::cout << "sessionfile (.cu3s): " << sessionLoc << std::endl;
std::cout << "loading user settings..." << std::endl;
cuvis::General::init(userSettingsDir);
cuvis::General::set_log_level(loglevel_info);
std::cout << "loading session... " << std::endl;
cuvis::SessionFile sess(sessionLoc);
std::cout << "loading measurement... " << std::endl;
auto optmesu = sess.get_mesu(0);
assert(optmesu.has_value());
cuvis::Measurement mesu = optmesu.value();
std::cout << "Data 1" << mesu.get_meta()->name << " "
<< "t=" << mesu.get_meta()->integration_time << " ms "
<< "mode=" << mesu.get_meta()->processing_mode << " " << std::endl;
if (mesu.get_meta()->measurement_flags.size() > 0)
{
std::cout << " Flags" << std::endl;
for (auto const& flags : mesu.get_meta()->measurement_flags)
{
std::cout << " - " << flags.first << " (" << flags.second << ")"
<< std::endl;
}
}
assert(
mesu.get_meta()->processing_mode == Cube_Raw &&
"This example requires raw mode");
auto const& cube_it = mesu.get_imdata()->find(CUVIS_MESU_CUBE_KEY);
assert(cube_it != mesu.get_imdata()->end() && "Cube not found");
auto cube = std::get<cuvis::image_t<std::uint16_t>>(cube_it->second);
//uncomment to show a single channel with openCV
/*
cv::Mat img(
cv::Size(cube._width, cube._height),
CV_16UC(cube._channels),
const_cast<void*>(reinterpret_cast<const void*>(cube._data)),
cv::Mat::AUTO_STEP);
cv::Mat singleChannel;
cv::extractChannel(
img, singleChannel, 25); // extract channel 25 as an example
singleChannel.convertTo(singleChannel, CV_8U, 1 / 16.0);
cv::imshow("channel 25", singleChannel);
cv::waitKey(0);
*/
std::size_t x = 120;
std::size_t y = 200;
assert(x < cube._width && "x index exceeds cube width");
assert(y < cube._height && "y index exceeds cube height");
std::cout << "lambda [nm]; raw counts [au] " << std::endl;
for (std::size_t chn = 0; chn < cube._channels; chn++)
{
// memory layout:
//unsigned index = (y * cube.width + x) * cube.channels + chn;
//uint16_t value = cube16bit[index];
auto const value = cube.get(x, y, chn);
unsigned lambda = cube._wavelength[chn];
std::cout << lambda << "; " << value << std::endl;
}
cuvis::General::shutdown();
std::cout << "finished. " << std::endl;
}
import os
import platform
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
import cuvis
def run_example_loadMeasurement(
userSettingsDir,
measurementLoc):
print("loading user settings...")
cuvis.init(userSettingsDir)
cuvis.set_log_level("info")
print("loading session...")
session = cuvis.SessionFile(measurementLoc)
print("loading measurement file...")
mesu = session[0]
assert mesu._handle
print("Data 1 {} t={}ms mode={}".format(mesu.name,
mesu.integration_time,
mesu.processing_mode.name,
))
if isinstance(mesu.measurement_flags, cuvis.MeasurementFlags):
print(f"Flags: {mesu.measurement_flags}")
for v in cuvis.MeasurementFlags.supremum():
print(f'{v}: {v in mesu.measurement_flags}')
cube = mesu.cube
if cube is None:
raise Exception("Cube not found")
x = 120
y = 200
assert x < cube.width, "x index exceeds cube width!"
assert y < cube.height, "y index exceeds cube height!"
lambda_wl = []
raw_counts = []
for chn in np.arange(cube.channels):
lambda_wl.append(cube.wavelength[chn])
raw_counts.append(cube.array[x, y, chn])
plt.plot(lambda_wl, raw_counts)
plt.xlabel("lambda [nm]")
plt.ylabel("raw counts [au]")
plt.title("Spectrum of {} for x={}, y={}".format(mesu.name, x, y))
plt.show()
cuvis.shutdown()
print("finished.")
if __name__ == "__main__":
if platform.system() == "Windows":
data_dir = Path(os.getenv("CUVIS")).parent / "sdk" / \
"sample_data" / "set_examples"
elif platform.system() == "Linux":
data_dir = Path(os.getenv("CUVIS_DATA")) / \
"sample_data" / "set_examples"
# default image
loc_file = data_dir / "set0_single" / "single.cu3s"
# default settings
loc_settings = data_dir / "settings"
print("Example 01: Load Measurement. Please provide:")
userSettingsDir = input(
"User settings directory (default: {}): ".format(loc_settings))
if userSettingsDir.strip().lower() in ["", "default"]:
userSettingsDir = loc_settings
measurementLoc = input(
"Measurement file (.cu3s) (default: {}): ".format(loc_file))
if measurementLoc.strip().lower() in ["", "default"]:
measurementLoc = loc_file
run_example_loadMeasurement(str(userSettingsDir), str(measurementLoc))
Reprocessing a Measurement
This example demonstrates the process of reprocessing hyperspectral measurement data using the cuvis SDK.
#include "cuvis.h"
#include <stdio.h>
int main(int argc, char* argv[])
{
if (argc != 7)
{
printf("To few Arguments! Please provide:\n");
printf("user settings directory\n");
printf("measurement file (.cu3s)\n");
printf("dark file (.cu3s)\n");
printf("white file (.cu3s)\n");
printf("distance file (.cu3s)\n");
printf("Name of output directory\n");
return -1;
}
char* const userSettingsDir = argv[1];
char* const measurementLoc = argv[2];
char* const darkLoc = argv[3];
char* const whiteLoc = argv[4];
char* const distanceLoc = argv[5];
char* const outDir = argv[6];
printf("Example 02 reprocess measurement \n");
printf("user Settings Dir: ");
printf(userSettingsDir);
printf("\nmeasurement file (.cu3s): ");
printf(measurementLoc);
printf("\ndark file (.cu3s): ");
printf(darkLoc);
printf("\nwhite file (.cu3s): ");
printf(whiteLoc);
printf("\ndistance file (.cu3s): ");
printf(distanceLoc);
printf("\noutput Dir: ");
printf(outDir);
CUVIS_SESSION_FILE sessMesu;
CUVIS_SESSION_FILE sessDark;
CUVIS_SESSION_FILE sessWhite;
CUVIS_SESSION_FILE sessDistance;
CUVIS_MESU mesu;
CUVIS_MESU_METADATA mesu_data;
CUVIS_MESU dark;
CUVIS_MESU white;
CUVIS_MESU distance;
CUVIS_PROC_CONT procCont;
CUVIS_INT is_capable;
printf("\nloading settings... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_init(userSettingsDir, loglevel_debug));
printf("loading sessionfiles... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_session_file_load(measurementLoc, &sessMesu));
CUVIS_CHECK(cuvis_session_file_load(darkLoc, &sessDark));
CUVIS_CHECK(cuvis_session_file_load(whiteLoc, &sessWhite));
CUVIS_CHECK(cuvis_session_file_load(distanceLoc, &sessDistance));
printf("loading measurement... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_session_file_get_mesu(sessMesu, 0, session_item_type_frames_no_gaps, &mesu));
CUVIS_CHECK(cuvis_session_file_get_mesu(sessDark, 0, session_item_type_frames_no_gaps, &dark));
CUVIS_CHECK(cuvis_session_file_get_mesu(sessWhite, 0, session_item_type_frames_no_gaps, &white));
CUVIS_CHECK(cuvis_session_file_get_mesu(sessDistance, 0, session_item_type_frames_no_gaps, &distance));
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf(
"data 1 %s %.2f ms mode=%d flags=%d\n",
mesu_data.name,
mesu_data.integration_time,
mesu_data.processing_mode,
mesu_data.measurement_flags);
fflush(stdout);
printf("Load processing context...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_create_from_session_file(sessMesu, &procCont));
printf("Set references ...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_set_reference(procCont, dark, Reference_Dark));
CUVIS_CHECK(cuvis_proc_cont_set_reference(procCont, white, Reference_White));
CUVIS_CHECK(cuvis_proc_cont_set_reference(procCont, distance, Reference_Distance));
printf("Prepare processing and export ...\n");
CUVIS_PROC_ARGS args;
args.processing_mode = Cube_Raw;
args.allow_recalib = 0;
CUVIS_CHECK(cuvis_proc_cont_is_capable(procCont, mesu, args, &is_capable));
CUVIS_EXPORT_GENERAL_SETTINGS general_settings = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
CUVIS_EXPORT_CUBE_SETTINGS cube_settings;
cube_settings.allow_fragmentation = 0;
cube_settings.allow_overwrite = 1;
cube_settings.allow_session_file = 1;
cube_settings.operation_mode = OperationMode_Internal;
cube_settings.allow_info_file = 0;
if (1 == is_capable)
{
printf("reprocess measurement to Cube_Raw mode...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_set_args(procCont, args));
CUVIS_CHECK(cuvis_proc_cont_apply(procCont, mesu));
printf(" done. \n");
fflush(stdout);
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf(
"data 1 %s %.2f ms mode=%d flags=%d\n",
mesu_data.name,
mesu_data.integration_time,
mesu_data.processing_mode,
mesu_data.measurement_flags);
fflush(stdout);
char exportDirRAW[CUVIS_MAXBUF];
strcpy(exportDirRAW, outDir);
strcat(exportDirRAW, "/RAW");
strcpy(general_settings.export_dir, exportDirRAW);
CUVIS_EXPORTER cube_exporter;
CUVIS_CHECK(cuvis_exporter_create_cube(
&cube_exporter, general_settings, cube_settings));
CUVIS_CHECK(cuvis_exporter_apply(cube_exporter, mesu));
cuvis_exporter_free(&cube_exporter);
}
else
{
printf("Cannot process to Cube_Raw mode.\n");
fflush(stdout);
}
args.processing_mode = Cube_DarkSubtract;
CUVIS_CHECK(cuvis_proc_cont_is_capable(procCont, mesu, args, &is_capable));
if (1 == is_capable)
{
printf("reprocess measurement to Cube_DarkSubtract mode...");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_set_args(procCont, args));
CUVIS_CHECK(cuvis_proc_cont_apply(procCont, mesu));
printf(" done. \n");
fflush(stdout);
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf(
"data 1 %s %.2f ms mode=%d flags=%d\n",
mesu_data.name,
mesu_data.integration_time,
mesu_data.processing_mode,
mesu_data.measurement_flags);
fflush(stdout);
char exportDirDS[CUVIS_MAXBUF];
strcpy(exportDirDS, outDir);
strcat(exportDirDS, "/DS");
strcpy(general_settings.export_dir, exportDirDS);
CUVIS_EXPORTER cube_exporter;
CUVIS_CHECK(cuvis_exporter_create_cube(
&cube_exporter, general_settings, cube_settings));
CUVIS_CHECK(cuvis_exporter_apply(cube_exporter, mesu));
cuvis_exporter_free(&cube_exporter);
}
else
{
printf("Cannot process to Cube_DarkSubtract mode.\n");
fflush(stdout);
}
args.processing_mode = Cube_Reflectance;
CUVIS_CHECK(cuvis_proc_cont_is_capable(procCont, mesu, args, &is_capable));
if (1 == is_capable)
{
printf("reprocess measurement to Cube_Reflectance mode...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_set_args(procCont, args));
CUVIS_CHECK(cuvis_proc_cont_apply(procCont, mesu));
printf(" done. \n");
fflush(stdout);
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf(
"data 1 %s %.2f ms mode=%d flags=%d\n",
mesu_data.name,
mesu_data.integration_time,
mesu_data.processing_mode,
mesu_data.measurement_flags);
fflush(stdout);
char exportDirREF[CUVIS_MAXBUF];
strcpy(exportDirREF, outDir);
strcat(exportDirREF, "/REF");
strcpy(general_settings.export_dir, exportDirREF);
CUVIS_EXPORTER cube_exporter;
CUVIS_CHECK(cuvis_exporter_create_cube(
&cube_exporter, general_settings, cube_settings));
CUVIS_CHECK(cuvis_exporter_apply(cube_exporter, mesu));
cuvis_exporter_free(&cube_exporter);
}
else
{
printf("Cannot process to Cube_Reflectance mode.\n");
fflush(stdout);
}
args.processing_mode = Cube_SpectralRadiance;
CUVIS_CHECK(cuvis_proc_cont_is_capable(procCont, mesu, args, &is_capable));
if (1 == is_capable)
{
printf("reprocess measurement to Cube_SpectralRadiance mode...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_set_args(procCont, args));
CUVIS_CHECK(cuvis_proc_cont_apply(procCont, mesu));
printf(" done. \n");
fflush(stdout);
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf(
"data 1 %s %.2f ms mode=%d flags=%d\n",
mesu_data.name,
mesu_data.integration_time,
mesu_data.processing_mode,
mesu_data.measurement_flags);
fflush(stdout);
char exportDirSPRAD[CUVIS_MAXBUF];
strcpy(exportDirSPRAD, outDir);
strcat(exportDirSPRAD, "/SPRAD");
strcpy(general_settings.export_dir, exportDirSPRAD);
CUVIS_EXPORTER cube_exporter;
CUVIS_CHECK(cuvis_exporter_create_cube(
&cube_exporter, general_settings, cube_settings));
CUVIS_CHECK(cuvis_exporter_apply(cube_exporter, mesu));
cuvis_exporter_free(&cube_exporter);
}
else
{
printf("Cannot process to Cube_SpectralRadiance mode.\n");
fflush(stdout);
}
cuvis_proc_cont_free(&procCont);
cuvis_measurement_free(&mesu);
cuvis_measurement_free(&dark);
cuvis_measurement_free(&white);
cuvis_measurement_free(&distance);
cuvis_session_file_free(&sessMesu);
cuvis_session_file_free(&sessDark);
cuvis_session_file_free(&sessWhite);
cuvis_session_file_free(&sessDistance);
cuvis_shutdown();
}
#include "cuvis.hpp"
#include <cassert>
#include <iostream>
int main(int argc, char* argv[])
{
if (argc != 7)
{
std::cout << std::endl << "Too few Arguments! Please provide:" << std::endl;
std::cout << "user settings directory" << std::endl;
std::cout << "measurement file (.cu3s)" << std::endl;
std::cout << "dark file (.cu3s)" << std::endl;
std::cout << "white file (.cu3s)" << std::endl;
std::cout << "distance file (.cu3s)" << std::endl;
std::cout << "Name of output directory" << std::endl;
return -1;
}
char* const userSettingsDir = argv[1];
char* const measurementLoc = argv[2];
char* const darkLoc = argv[3];
char* const whiteLoc = argv[4];
char* const distanceLoc = argv[5];
char* const outDir = argv[6];
std::cout << "Example 02 reprocess measurement cpp " << std::endl;
std::cout << "User Settings Dir: " << userSettingsDir << std::endl;
std::cout << "measurement file (.cu3s): " << measurementLoc << std::endl;
std::cout << "dark file (.cu3s): " << darkLoc << std::endl;
std::cout << "white file (.cu3s): " << whiteLoc << std::endl;
std::cout << "distance file (.cu3s): " << distanceLoc << std::endl;
std::cout << "output Dir: " << outDir << std::endl;
std::cout << "loading settings... " << std::endl;
cuvis::General::init(userSettingsDir);
cuvis::General::set_log_level(loglevel_info);
std::cout << "loading measurement... " << std::endl;
cuvis::SessionFile sessMesu(measurementLoc);
auto optMesu = sessMesu.get_mesu(0);
assert(optMesu.has_value());
cuvis::Measurement mesu = optMesu.value();
std::cout << "loading dark... " << std::endl;
cuvis::SessionFile sessDark(darkLoc);
auto optDark = sessDark.get_mesu(0);
assert(optDark.has_value());
cuvis::Measurement dark = optDark.value();
std::cout << "loading white... " << std::endl;
cuvis::SessionFile sessWhite(whiteLoc);
auto optWhite = sessWhite.get_mesu(0);
assert(optWhite.has_value());
cuvis::Measurement white = optWhite.value();
std::cout << "loading distance... " << std::endl;
cuvis::SessionFile sessDistance(distanceLoc);
auto optDistance = sessDistance.get_mesu(0);
assert(optDistance.has_value());
cuvis::Measurement distance = optDistance.value();
std::cout << "Data 1" << mesu.get_meta()->name << " "
<< "t=" << mesu.get_meta()->integration_time << " ms "
<< "mode=" << mesu.get_meta()->processing_mode << " " << std::endl;
std::cout << "Loading processing context" << std::endl;
cuvis::ProcessingContext proc(sessMesu);
std::cout << "Set references" << std::endl;
proc.set_reference(dark, cuvis::reference_type_t::Reference_Dark);
proc.set_reference(white, cuvis::reference_type_t::Reference_White);
proc.set_reference(distance, cuvis::reference_type_t::Reference_Distance);
cuvis::ProcessingArgs procArgs;
cuvis::SaveArgs saveArgs;
saveArgs.allow_overwrite = true;
saveArgs.allow_session_file = true;
saveArgs.allow_info_file = false;
std::map<std::string, cuvis::processing_mode_t> target_modes = {
{"Raw", cuvis::processing_mode_t::Cube_Raw},
{"DS", cuvis::processing_mode_t::Cube_DarkSubtract},
{"Ref", cuvis::processing_mode_t::Cube_Reflectance},
{"RAD", cuvis::processing_mode_t::Cube_SpectralRadiance}};
for (auto const& mode : target_modes)
{
procArgs.processing_mode = mode.second;
if (proc.is_capable(mesu, procArgs))
{
std::cout << "processing to mode " << mode.first << std::endl;
proc.set_processingArgs(procArgs);
proc.apply(mesu);
saveArgs.export_dir = std::filesystem::path(outDir) / mode.first;
cuvis::CubeExporter exporter(saveArgs);
exporter.apply(mesu);
}
else
{
std::cout << "cannot process to mode " << mode.first << std::endl;
}
}
cuvis::General::shutdown();
std::cout << "finished." << std::endl;
}
import os
import platform
from pathlib import Path
import cuvis
def run_example_reprocessMeasurement(
userSettingsDir,
measurementLoc,
darkLoc,
whiteLoc,
distanceLoc,
outDir):
print("loading user settings...")
cuvis.init(userSettingsDir)
cuvis.set_log_level("info")
print("loading measurement file...")
sessionM = cuvis.SessionFile(measurementLoc)
mesu = sessionM[0]
assert mesu._handle
print("loading dark...")
sessionDk = cuvis.SessionFile(darkLoc)
dark = sessionDk[0]
assert dark._handle
print("loading white...")
sessionWt = cuvis.SessionFile(whiteLoc)
white = sessionWt[0]
assert white._handle
print("loading distance...")
sessionDc = cuvis.SessionFile(distanceLoc)
distance = sessionDc[0]
assert distance._handle
print("Data 1 {} t={}ms mode={}".format(mesu.name,
mesu.integration_time,
mesu.processing_mode.name,
))
print("loading processing context...")
processingContext = cuvis.ProcessingContext(sessionM)
print("set references...")
processingContext.set_reference(dark, cuvis.ReferenceType.Dark)
processingContext.set_reference(white, cuvis.ReferenceType.White)
processingContext.set_reference(distance, cuvis.ReferenceType.Distance)
procArgs = cuvis.ProcessingArgs()
saveArgs = cuvis.SaveArgs(allow_overwrite=True,
allow_session_file=True,
allow_info_file=False)
modes = [cuvis.ProcessingMode.Raw,
cuvis.ProcessingMode.DarkSubtract,
cuvis.ProcessingMode.Reflectance,
cuvis.ProcessingMode.SpectralRadiance
]
for mode in modes:
procArgs.processing_mode = mode
if processingContext.is_capable(mesu, procArgs):
print("processing to mode {}...".format(mode))
processingContext.set_processing_args(procArgs)
mesu = processingContext.apply(mesu)
mesu.set_name(mode.name)
saveArgs.export_dir = str(Path(outDir) / mode.name)
exporter = cuvis.Export.CubeExporter(saveArgs)
exporter.apply(mesu)
else:
print("Cannot process to {} mode!".format(mode))
cuvis.shutdown()
print("finished.")
if __name__ == "__main__":
if platform.system() == "Windows":
data_dir = Path(os.getenv("CUVIS")).parent / "sdk" / \
"sample_data" / "set_examples"
elif platform.system() == "Linux":
data_dir = Path(os.getenv("CUVIS_DATA")) / \
"sample_data" / "set_examples"
# default images
loc_file = data_dir / "set0_single" / "single_raw.cu3s"
loc_dark = data_dir / "set0_single" / "single_dark.cu3s"
loc_white = data_dir / "set0_single" / "single_white.cu3s"
loc_distance = data_dir / "set0_single" / "single_distance.cu3s"
# default settings
loc_settings = data_dir / "settings"
# default output
loc_output = Path(os.getcwd()) / "EX02_reprocessed"
print(
"Example 02: Reprocess Measurement. Please provide:")
userSettingsDir = input(
"User settings directory (default: {}): ".format(loc_settings))
if userSettingsDir.strip().lower() in ["", "default"]:
userSettingsDir = loc_settings
measurementLoc = input(
"Measurement file (.cu3s) (default: {}): ".format(loc_file))
if measurementLoc.strip().lower() in ["", "default"]:
measurementLoc = loc_file
darkLoc = input("Dark file (.cu3s) (default: {}): ".format(loc_dark))
if darkLoc.strip().lower() in ["", "default"]:
darkLoc = loc_dark
whiteLoc = input("White file (.cu3s) (default: {}): ".format(loc_white))
if whiteLoc.strip().lower() in ["", "default"]:
whiteLoc = loc_white
distanceLoc = input(
"Distance file (.cu3s) (default: {}): ".format(loc_distance))
if distanceLoc.strip().lower() in ["", "default"]:
distanceLoc = loc_distance
outDir = input(
"Name of output directory (default: {}): ".format(loc_output))
if outDir.strip().lower() in ["", "default"]:
outDir = loc_output
run_example_reprocessMeasurement(str(userSettingsDir),
str(measurementLoc),
str(darkLoc),
str(whiteLoc),
str(distanceLoc),
str(outDir))
Exporting a Measurement
This example demonstrates exporting hyperspectral measurement data into various formats using the cuvis SDK.
#include "cuvis.h"
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char* argv[])
{
if (argc != 5)
{
printf("To few Arguments! Please provide:\n");
printf("user settings directory\n");
printf("sessionfile (.cu3s)\n");
printf("user plugin file (.xml)\n");
printf("Name of export directory\n");
fflush(stdout);
return -1;
}
const char* userSettingsDir = argv[1];
const char* sessionLoc = argv[2];
const char* pluginLoc = argv[3];
const char* exportDir = argv[4];
printf("Example 03 export measurement\n");
printf("User Settings Dir: ");
printf(userSettingsDir);
printf("\nsessionfile (.cu3s): ");
printf(sessionLoc);
printf("\nuser plugin file (.xml): ");
printf(pluginLoc);
printf("\nExport Dir: ");
printf(exportDir);
fflush(stdout);
CUVIS_SESSION_FILE sess;
CUVIS_MESU mesu;
CUVIS_EXPORTER envi_exporter;
CUVIS_EXPORTER single_tiff_exporter;
CUVIS_EXPORT_TIFF_SETTINGS single_tiff_settings;
CUVIS_EXPORTER multi_tiff_exporter;
CUVIS_EXPORT_TIFF_SETTINGS multi_tiff_settings;
CUVIS_EXPORTER view_exporter;
CUVIS_EXPORT_VIEW_SETTINGS view_settings;
CUVIS_EXPORTER cube_exporter;
char* buffer = 0;
long length;
FILE* f;
printf("\nloading user settings...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_init(userSettingsDir, loglevel_debug));
#ifdef _DEBUG
CUVIS_CHECK(cuvis_set_log_level(loglevel_debug));
#else
CUVIS_CHECK(cuvis_set_log_level(loglevel_info));
#endif
CUVIS_EXPORT_GENERAL_SETTINGS general_settings_envi = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
char exportDirEnvi[CUVIS_MAXBUF];
strcpy(exportDirEnvi, exportDir);
strcat(exportDirEnvi, "/envi");
strcpy(general_settings_envi.export_dir, exportDirEnvi);
CUVIS_EXPORT_GENERAL_SETTINGS general_settings_single = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
char exportDirSingle[CUVIS_MAXBUF];
strcpy(exportDirSingle, exportDir);
strcat(exportDirSingle, "/single");
strcpy(general_settings_single.export_dir, exportDirSingle);
CUVIS_EXPORT_GENERAL_SETTINGS general_settings_multi = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
char exportDirMulti[CUVIS_MAXBUF];
strcpy(exportDirMulti, exportDir);
strcat(exportDirMulti, "/multi");
strcpy(general_settings_multi.export_dir, exportDirMulti);
CUVIS_EXPORT_GENERAL_SETTINGS general_settings_view = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
char exportDirView[CUVIS_MAXBUF];
strcpy(exportDirView, exportDir);
strcat(exportDirView, "/view");
strcpy(general_settings_view.export_dir, exportDirView);
CUVIS_EXPORT_CUBE_SETTINGS cube_settings_session = {
0, 1, 0, 1, 1, OperationMode_Software, 1.0, 64, 128, 60000};
CUVIS_EXPORT_GENERAL_SETTINGS general_settings_session = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
char exportDirSession[CUVIS_MAXBUF];
strcpy(exportDirSession, exportDir);
strcat(exportDirSession, "/session");
strcpy(general_settings_session.export_dir, exportDirSession);
printf("loading session ...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_session_file_load(sessionLoc, &sess));
printf("loading measurement ...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_session_file_get_mesu(
sess, 0, session_item_type_frames_no_gaps, &mesu));
printf("creating envi exporter ...\n");
fflush(stdout);
CUVIS_CHECK(
cuvis_exporter_create_envi(&envi_exporter, general_settings_envi));
printf(" done.\n");
fflush(stdout);
printf("creating single tiff exporter ...\n");
fflush(stdout);
single_tiff_settings.compression_mode = tiff_compression_mode_None;
single_tiff_settings.format = tiff_format_Single;
CUVIS_CHECK(cuvis_exporter_create_tiff(
&single_tiff_exporter, general_settings_single, single_tiff_settings));
printf(" done.\n");
fflush(stdout);
printf("creating multi tiff exporter ...\n");
fflush(stdout);
multi_tiff_settings.compression_mode = tiff_compression_mode_None;
multi_tiff_settings.format = tiff_format_MultiChannel;
CUVIS_CHECK(cuvis_exporter_create_tiff(
&multi_tiff_exporter, general_settings_multi, multi_tiff_settings));
printf(" done.\n");
fflush(stdout);
printf("creating view exporter ...\n");
printf("loading plugin ...\n");
fflush(stdout);
f = fopen(pluginLoc, "rb");
if (f)
{
fseek(f, 0, SEEK_END);
length = ftell(f);
fseek(f, 0, SEEK_SET);
buffer = malloc(length);
if (buffer)
{
fread(buffer, 1, length, f);
}
fclose(f);
}
if (!buffer)
{
printf("failed to load plugin file\n");
fflush(stdout);
return 0;
}
view_settings.userplugin = buffer;
CUVIS_CHECK(cuvis_exporter_create_view(
&view_exporter, general_settings_view, view_settings));
printf(" done.\n");
fflush(stdout);
printf("creating cube exporter (session) ...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_exporter_create_cube(
&cube_exporter, general_settings_session, cube_settings_session));
printf(" done.\n");
fflush(stdout);
printf("export envi...");
fflush(stdout);
CUVIS_CHECK(cuvis_exporter_apply(envi_exporter, mesu));
printf(" done.\n");
fflush(stdout);
printf("export single tiff...");
fflush(stdout);
CUVIS_CHECK(cuvis_exporter_apply(single_tiff_exporter, mesu));
printf(" done.\n");
fflush(stdout);
printf("export multi tiff...");
fflush(stdout);
CUVIS_CHECK(cuvis_exporter_apply(multi_tiff_exporter, mesu));
printf(" done.\n");
fflush(stdout);
printf("export view...");
fflush(stdout);
CUVIS_CHECK(cuvis_exporter_apply(view_exporter, mesu));
printf("done.\n");
fflush(stdout);
printf("export cube (session)...");
fflush(stdout);
CUVIS_CHECK(cuvis_exporter_apply(cube_exporter, mesu));
printf("done.\n");
fflush(stdout);
cuvis_measurement_free(&mesu);
cuvis_session_file_free(&sess);
cuvis_exporter_free(&envi_exporter);
cuvis_exporter_free(&single_tiff_exporter);
cuvis_exporter_free(&multi_tiff_exporter);
cuvis_exporter_free(&view_exporter);
cuvis_exporter_free(&cube_exporter);
cuvis_shutdown();
free(buffer);
printf("finished.\n");
fflush(stdout);
return 0;
}
#include "cuvis.hpp"
#include <cassert>
#include <fstream>
#include <iostream>
int main(int argc, char* argv[])
{
if (argc != 5)
{
std::cout << std::endl << "Too few Arguments! Please provide:" << std::endl;
std::cout << "user settings directory" << std::endl;
std::cout << "sessionfile (.cu3s)" << std::endl;
std::cout << "user plugin file (.xml)" << std::endl;
std::cout << "Name of export directory" << std::endl;
return -1;
}
char* const userSettingsDir = argv[1];
char* const sessionLoc = argv[2];
char* const pluginLoc = argv[3];
char* const exportDir = argv[4];
std::cout << "Example 03 export measurement" << std::endl;
std::cout << "User Settings Dir: " << userSettingsDir << std::endl;
std::cout << "sessionfile (.cu3s): " << sessionLoc << std::endl;
std::cout << "user plugin file (.xml): " << pluginLoc << std::endl;
std::cout << "Export Dir: " << exportDir << std::endl;
std::cout << "loading settings... " << std::endl;
cuvis::General::init(userSettingsDir);
cuvis::General::set_log_level(loglevel_info);
std::cout << "loading session... " << std::endl;
cuvis::SessionFile sess(sessionLoc);
std::cout << "loading measurement... " << std::endl;
auto optmesu = sess.get_mesu(0);
assert(optmesu.has_value());
cuvis::Measurement mesu = optmesu.value();
assert(mesu.get_meta()->processing_mode != cuvis::processing_mode_t::Preview);
{
std::cout << "Export to Envi" << std::endl;
cuvis::EnviArgs args;
char exportDirEnvi[CUVIS_MAXBUF];
strcpy(exportDirEnvi, exportDir);
strcat(exportDirEnvi, "/envi");
args.export_dir = exportDirEnvi;
cuvis::EnviExporter exporter(args);
exporter.apply(mesu);
}
{
std::cout << "Export to Multi-Channel Tiff" << std::endl;
cuvis::TiffArgs args;
char exportDirMulti[CUVIS_MAXBUF];
strcpy(exportDirMulti, exportDir);
strcat(exportDirMulti, "/multi");
args.export_dir = exportDirMulti;
args.format = cuvis::tiff_format_t::tiff_format_MultiChannel;
cuvis::TiffExporter exporter(args);
exporter.apply(mesu);
}
{
std::cout << "Export to separate Tiffs" << std::endl;
cuvis::TiffArgs args;
char exportDirSingle[CUVIS_MAXBUF];
strcpy(exportDirSingle, exportDir);
strcat(exportDirSingle, "/single");
args.export_dir = exportDirSingle;
args.format = cuvis::tiff_format_t::tiff_format_Single;
cuvis::TiffExporter exporter(args);
exporter.apply(mesu);
}
{
std::cout << "Export View to file" << std::endl;
cuvis::ViewArgs args;
char exportDirView[CUVIS_MAXBUF];
strcpy(exportDirView, exportDir);
strcat(exportDirView, "/view");
args.export_dir = exportDirView;
std::cout << "Load plugin" << std::endl;
std::ifstream file(pluginLoc);
args.userplugin = std::string(
(std::istreambuf_iterator<char>(file)),
std::istreambuf_iterator<char>());
cuvis::ViewExporter exporter(args);
exporter.apply(mesu);
}
{
std::cout << "Export to sessionfile" << std::endl;
char exportDirView[CUVIS_MAXBUF];
strcpy(exportDirView, exportDir);
strcat(exportDirView, "/session");
cuvis::SaveArgs saveArgs;
saveArgs.export_dir = exportDirView;
saveArgs.allow_overwrite = true;
saveArgs.allow_session_file = true;
cuvis::CubeExporter exporter(saveArgs);
exporter.apply(mesu);
}
cuvis::General::shutdown();
std::cout << "finished." << std::endl;
}
import os
import platform
from pathlib import Path
import cuvis
def run_example_exportMeasurement(userSettingsDir,
measurementLoc,
pluginLoc,
exportDir):
print("loading user settings...")
cuvis.init(userSettingsDir)
cuvis.set_log_level("info")
print("loading session file...")
session = cuvis.SessionFile(measurementLoc)
mesu = session[0]
assert mesu._handle
assert mesu.processing_mode != cuvis.ProcessingMode.Preview, "Wrong processing mode: {}".format(
mesu.processing_mode.name)
print("Export to Envi...")
envi_settings = cuvis.EnviExportSettings(
export_dir=os.path.join(exportDir, "envi"))
enviExporter = cuvis.EnviExporter(envi_settings)
enviExporter.apply(mesu)
print("Export to Multi-Channel Tiff...")
multi_tiff_settings = cuvis.TiffExportSettings(
export_dir=os.path.join(exportDir, "multi"), format=cuvis.TiffFormat.MultiChannel)
multiTiffExporter = cuvis.TiffExporter(multi_tiff_settings)
multiTiffExporter.apply(mesu)
print("Export to separate Tiffs...")
single_tiff_settings = cuvis.TiffExportSettings(
export_dir=os.path.join(exportDir, "single"), format=cuvis.TiffFormat.Single)
singleTiffExporter = cuvis.TiffExporter(single_tiff_settings)
singleTiffExporter.apply(mesu)
print("Export View to file...")
print("load plugin...")
with open(pluginLoc) as f:
userpluginCai = f.readlines()
userpluginCai = "".join(userpluginCai)
view_export_settings = cuvis.ViewExportSettings(
export_dir=os.path.join(exportDir, "view"), userplugin=userpluginCai)
# also view_export_settings = cuvis.ViewExportSettings(ExportDir=os.path.join(exportDir, "view"),
# Userplugin=pluginLoc) works!
viewExporter = cuvis.ViewExporter(view_export_settings)
viewExporter.apply(mesu)
cuvis.shutdown()
print("finished.")
if __name__ == "__main__":
if platform.system() == "Windows":
lib_dir = Path(os.getenv("CUVIS"))
data_dir = lib_dir.parent / "sdk" / \
"sample_data" / "set_examples"
plugin_dir = lib_dir.parent / "user" / "plugin"
elif platform.system() == "Linux":
lib_dir = Path(os.getenv("CUVIS_DATA"))
data_dir = lib_dir / \
"sample_data" / "set_examples"
plugin_dir = lib_dir / "user" / "plugin"
# default images
loc_file = data_dir / "set0_single" / "single.cu3s"
loc_plugin = plugin_dir / "ref" / "cai.xml"
# default settings
loc_settings = data_dir / "settings"
# default output
loc_output = Path(os.getcwd()) / "EX03_export"
print("Example 03: Export Measurement. Please provide:")
userSettingsDir = input(
"User settings directory (default: {}): ".format(loc_settings))
if userSettingsDir.strip().lower() in ["", "default"]:
userSettingsDir = loc_settings
measurementLoc = input(
"Measurement file (.cu3) (default: {}): ".format(loc_file))
if measurementLoc.strip().lower() in ["", "default"]:
measurementLoc = loc_file
pluginLoc = input(
"User plugin file (.xml) (default: {}): ".format(loc_plugin))
if pluginLoc.strip().lower() in ["", "default"]:
pluginLoc = loc_plugin
exportDir = input(
"Name of export directory (default: {}): ".format(loc_output))
if exportDir.strip().lower() in ["", "default"]:
exportDir = loc_output
run_example_exportMeasurement(str(userSettingsDir), str(measurementLoc), str(pluginLoc),
str(exportDir))
Changing the Distance of a Measurement
This example demonstrates how to update the distance parameter in hyperspectral measurement data using the cuvis SDK.
#include "cuvis.h"
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char* argv[])
{
if (argc != 5)
{
printf("To few Arguments! Please provide:\n");
printf("user settings directory\n");
printf("sessionfile (.cu3s)\n");
printf("new distance\n");
printf("Name of export directory\n");
fflush(stdout);
return -1;
}
char* const userSettingsDir = argv[1];
char* const sessionLoc = argv[2];
char* const distanceString = argv[3];
char* const exportDir = argv[4];
int distance = atoi(distanceString); //in mm
printf("Example 04 change distance cpp \n");
printf(userSettingsDir);
printf("\nsessionfile (.cu3s): ");
printf(sessionLoc);
printf("\nNew Distance: %d\n", distance);
printf("Export Dir: ");
printf(exportDir);
fflush(stdout);
CUVIS_SESSION_FILE sess;
CUVIS_MESU mesu;
CUVIS_MESU_METADATA mesu_data;
CUVIS_PROC_CONT procCont;
CUVIS_INT is_capable;
printf("\nloading settings... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_init(userSettingsDir, loglevel_debug));
#ifdef _DEBUG
CUVIS_CHECK(cuvis_set_log_level(loglevel_debug));
#else
CUVIS_CHECK(cuvis_set_log_level(loglevel_info));
#endif
printf("\nloading session... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_session_file_load(sessionLoc, &sess));
printf("\nloading measurement... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_session_file_get_mesu(
sess, 0, session_item_type_frames_no_gaps, &mesu));
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf(
"data 1 %s %.2f ms mode=%d flags=%d\n",
mesu_data.name,
mesu_data.integration_time,
mesu_data.processing_mode,
mesu_data.measurement_flags);
fflush(stdout);
printf("Load calibration and processing context...");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_create_from_session_file(sess, &procCont));
printf(" done. \n");
fflush(stdout);
printf("prepare saving of measurements... \n");
fflush(stdout);
CUVIS_EXPORTER cube_exporter;
CUVIS_EXPORT_GENERAL_SETTINGS general_settings = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
strcpy(general_settings.export_dir, exportDir);
CUVIS_EXPORT_CUBE_SETTINGS cube_settings;
cube_settings.allow_fragmentation = 0;
cube_settings.allow_overwrite = 1;
cube_settings.allow_session_file = 1;
cuvis_exporter_create_cube(&cube_exporter, general_settings, cube_settings);
printf("Set distance ...");
fflush(stdout);
//CUVIS_CHECK(cuvis_proc_cont_calc_distance(procCont, distance)); // throws error on pan image
cuvis_proc_cont_calc_distance(procCont, distance);
printf(" done. \n");
fflush(stdout);
CUVIS_PROC_ARGS args;
args.processing_mode = Cube_Raw;
CUVIS_CHECK(cuvis_proc_cont_is_capable(procCont, mesu, args, &is_capable));
if (1 == is_capable)
{
printf("reprocess measurement to Cube_Raw with custom distance mode...");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_set_args(procCont, args));
CUVIS_CHECK(cuvis_proc_cont_apply(procCont, mesu));
printf(" done. \n");
fflush(stdout);
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf(
"data 1 %s %.2f ms mode=%d flags=%d\n",
mesu_data.name,
mesu_data.integration_time,
mesu_data.processing_mode,
mesu_data.measurement_flags);
fflush(stdout);
cuvis_exporter_apply(cube_exporter, mesu);
}
else
{
printf("Cannot process to Cube_Raw mode.\n");
fflush(stdout);
}
cuvis_exporter_free(&cube_exporter);
cuvis_proc_cont_free(&procCont);
cuvis_measurement_free(&mesu);
cuvis_shutdown();
printf("finished.");
fflush(stdout);
}
#include "cuvis.hpp"
#include <cassert>
#include <iostream>
int main(int argc, char* argv[])
{
if (argc != 5)
{
std::cout << std::endl << "Too few Arguments! Please provide:" << std::endl;
std::cout << "user settings directory" << std::endl;
std::cout << "sessionfile (.cu3s)" << std::endl;
std::cout << "new distance in mm" << std::endl;
std::cout << "Name of export directory" << std::endl;
return -1;
}
char* const userSettingsDir = argv[1];
char* const sessionLoc = argv[2];
char* const distanceString = argv[3];
char* const exportDir = argv[4];
int distance = std::stoi(distanceString);
std::cout << "Example 04 change distance cpp " << std::endl;
std::cout << "User Settings Dir: " << userSettingsDir << std::endl;
std::cout << "sessionfile (.cu3s): " << sessionLoc << std::endl;
std::cout << "New Distance in mm: " << distance << std::endl;
std::cout << "Export Dir: " << exportDir << std::endl;
std::cout << "loading settings... " << std::endl;
cuvis::General::init(userSettingsDir);
cuvis::General::set_log_level(loglevel_info);
std::cout << "loading session... " << std::endl;
cuvis::SessionFile sess(sessionLoc);
std::cout << "loading measurement... " << std::endl;
auto optmesu = sess.get_mesu(0);
assert(optmesu.has_value());
cuvis::Measurement mesu = optmesu.value();
std::cout << "Data 1" << mesu.get_meta()->name << " "
<< "t=" << mesu.get_meta()->integration_time << " ms "
<< "mode=" << mesu.get_meta()->processing_mode << " " << std::endl;
std::cout << "Loading Calibration and processing context..." << std::endl;
cuvis::ProcessingContext proc(sess);
cuvis::SaveArgs saveArgs;
saveArgs.allow_overwrite = true;
saveArgs.export_dir = exportDir;
saveArgs.allow_session_file = true;
cuvis::CubeExporter exporter(saveArgs);
std::cout << "setting distance..." << std::endl;
proc.calc_distance(distance);
cuvis::ProcessingArgs procArgs = proc.get_processingArgs();
procArgs.processing_mode = cuvis::processing_mode_t::Cube_Raw;
assert(proc.is_capable(mesu, procArgs));
std::cout << "changing distance..." << std::endl;
proc.apply(mesu);
std::cout << "saving..." << std::endl;
exporter.apply(mesu);
cuvis::General::shutdown();
std::cout << "finished." << std::endl;
}
import os
import platform
from pathlib import Path
import cuvis
def run_example_changeDistance(userSettingsDir,
measurementLoc,
distance,
exportDir):
print("loading user settings...")
cuvis.init(userSettingsDir)
cuvis.set_log_level("info")
print("loading session file...")
session = cuvis.SessionFile(measurementLoc)
mesu = session[0]
assert mesu._handle
print("Data 1 {} t={}ms mode={}".format(mesu.name,
mesu.integration_time,
mesu.processing_mode.name,
))
print("loading calibration and processing context (factory)...")
processingContext = cuvis.ProcessingContext(session)
print("setting distance...")
processingContext.calc_distance(distance)
processingContext.processing_mode = cuvis.ProcessingMode.Raw
saveArgs = cuvis.SaveArgs(export_dir=exportDir, allow_overwrite=True)
assert processingContext.is_capable(mesu,
processingContext.get_processing_args())
print("changing distance...")
print("original distance...")
print(mesu.distance)
processingContext.apply(mesu)
print("new distance...")
print(mesu.distance)
print("saving...")
mesu.save(saveArgs)
cuvis.shutdown()
print("finished.")
if __name__ == "__main__":
if platform.system() == "Windows":
data_dir = Path(os.getenv("CUVIS")).parent / "sdk" / \
"sample_data" / "set_examples"
elif platform.system() == "Linux":
data_dir = Path(os.getenv("CUVIS_DATA")) / \
"sample_data" / "set_examples"
# default image
loc_file = data_dir / "set0_single" / "single.cu3s"
# default settings
loc_settings = data_dir / "settings"
loc_distance = int(1000)
# default output
loc_output = Path(os.getcwd()) / "EX04_distance_changed"
print("Example 04: Change distance. Please provide:")
userSettingsDir = input(
"User settings directory (default: {}): ".format(loc_settings))
if userSettingsDir.strip().lower() in ["", "default"]:
userSettingsDir = loc_settings
measurementLoc = input(
"Measurement file (.cu3) (default: {}): ".format(loc_file))
if measurementLoc.strip().lower() in ["", "default"]:
measurementLoc = loc_file
distance = input("New distance in mm (default: {}): ".format(loc_distance))
if distance.strip().lower() in ["", "default"]:
distance = loc_distance
distance = int(distance)
exportDir = input(
"Name of export directory (default: {}): ".format(loc_output))
if exportDir.strip().lower() in ["", "default"]:
exportDir = loc_output
run_example_changeDistance(str(userSettingsDir), str(measurementLoc),
distance, str(exportDir))
Recording single Measurements
This example demonstrates how to capture single hyperspectral images using the cuvis SDK, with user-defined settings and parameters.
#include "cuvis.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef WIN32
#include <Windows.h>
#else
#include <unistd.h>
#endif
int main(int argc, char* argv[])
{
if (argc != 6)
{
printf("To few Arguments! Please provide:\n");
printf("user settings directory\n");
printf("factory directory\n");
printf("path of recording directory\n");
printf("exposure time in ms\n");
printf("number of images\n");
return -1;
}
char* const userSettingsDir = argv[1];
char* const factoryDir = argv[2];
char* const recDir = argv[3];
char* const exposureString = argv[4]; //in ms
char* const nrImagesString = argv[5];
int exposure_ms = atoi(exposureString);
int nrImages = atoi(nrImagesString);
printf("Example 05 record single image\n");
printf("User Settings directory: ");
printf(userSettingsDir);
printf("\nFactory directory: ");
printf(factoryDir);
printf("\nRecording directory: ");
printf(recDir);
printf("\nExposure in ms: %d\n", exposure_ms);
printf("Number of images: %d\n", nrImages);
CUVIS_CALIB calib;
CUVIS_ACQ_CONT acqCont;
CUVIS_PROC_CONT procCont;
printf("load user settings...\n");
CUVIS_CHECK(cuvis_init(userSettingsDir, loglevel_debug));
cuvis_set_log_level(loglevel_info);
printf("load calibration...\n");
CUVIS_CHECK(cuvis_calib_create_from_path(factoryDir, &calib));
printf("initialize processing context...\n");
CUVIS_CHECK(cuvis_proc_cont_create_from_calib(calib, &procCont));
printf("initialize acquisition context...\n");
CUVIS_CHECK(cuvis_acq_cont_create_from_calib(calib, &acqCont));
printf("initialize measurement exporter...\n");
CUVIS_EXPORTER cube_exporter;
// Export settings: General processing of measurements
CUVIS_EXPORT_GENERAL_SETTINGS general_settings = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
strcpy(general_settings.export_dir, recDir);
// Cube exporter specific settings
CUVIS_EXPORT_CUBE_SETTINGS cube_settings;
cube_settings.allow_fragmentation = 0;
cube_settings.allow_overwrite = 1;
cube_settings.allow_session_file = 1;
cube_settings.allow_info_file = 1;
cube_settings.hard_limit = 4;
cube_settings.soft_limit = 2;
// Settings for worker (processing pipeline)
CUVIS_WORKER_SETTINGS worker_settings;
worker_settings.can_drop_results = 0;
worker_settings.can_skip_measurements = 0;
worker_settings.can_skip_supplementary_steps = 0;
worker_settings.input_queue_size = 10;
worker_settings.output_queue_size = 5;
worker_settings.mandatory_queue_size = 2;
worker_settings.supplementary_queue_size = 2;
cuvis_exporter_create_cube(&cube_exporter, general_settings, cube_settings);
printf("initialize processing pipeline worker...\n");
CUVIS_WORKER worker;
cuvis_worker_create(&worker, worker_settings);
CUVIS_PROC_ARGS procArgs;
procArgs.allow_recalib = 0;
procArgs.processing_mode = Cube_Raw;
printf("waiting for camera to become online...\n");
while (1)
{
CUVIS_HARDWARE_STATE state;
cuvis_acq_cont_get_state(acqCont, &state);
if (state == hardware_state_online)
{
printf("\ncamera online\n");
break;
}
if (state == hardware_state_partially_online)
{
printf("\ncamera partially online\n");
break;
}
#ifdef WIN32
Sleep(1000);
#else
usleep(1000000);
#endif
printf(".");
fflush(stdout);
}
printf("camera components details:\n");
CUVIS_INT compCount;
CUVIS_CHECK(cuvis_acq_cont_get_component_count(acqCont, &compCount));
for (int compIdx = 0; compIdx < compCount; compIdx++)
{
CUVIS_INT online;
CUVIS_COMPONENT_INFO cinfo;
CUVIS_CHECK(cuvis_acq_cont_get_component_info(acqCont, compIdx, &cinfo));
CUVIS_CHECK(cuvis_comp_online_get(acqCont, compIdx, &online));
printf(" - component '%s' is ", cinfo.displayname);
if (online != 0)
{
printf("online\n");
}
else
{
printf("offline\n");
}
printf(" -- info: %s\n", cinfo.sensorinfo);
printf(" -- use: %s\n", cinfo.userfield);
printf(" -- pixelformat: %s\n", cinfo.pixelformat);
}
printf("configuring camera components...\n");
// Configure exposure / integration time and software trigger
CUVIS_CHECK(cuvis_acq_cont_integration_time_set(acqCont, exposure_ms));
CUVIS_CHECK(cuvis_acq_cont_operation_mode_set(acqCont, OperationMode_Software));
// Assign contexts to worker
CUVIS_CHECK(cuvis_worker_set_acq_cont(worker, acqCont));
CUVIS_CHECK(cuvis_worker_set_proc_cont(worker, procCont));
CUVIS_CHECK(cuvis_worker_set_exporter(worker, cube_exporter));
printf("start recording now\n");
CUVIS_CHECK(cuvis_worker_start(worker));
for (int k = 0; k < nrImages; k++)
{
printf("trigger image nr. %d/%d\n", k + 1, nrImages);
CUVIS_CHECK(cuvis_acq_cont_capture_async(acqCont, NULL));
printf("waiting for processing...\n");
CUVIS_CHECK(cuvis_worker_get_next_result(worker, NULL, NULL, exposure_ms + 2000));
}
CUVIS_CHECK(cuvis_worker_stop(worker));
printf("done. cleaning up...\n");
cuvis_exporter_free(&cube_exporter);
cuvis_proc_cont_free(&procCont);
cuvis_acq_cont_free(&acqCont);
cuvis_calib_free(&calib);
cuvis_worker_free(&worker);
cuvis_shutdown();
printf("finished.\n");
}
#include "cuvis.hpp"
#include <cassert>
#include <iostream>
int main(int argc, char* argv[])
{
if (argc != 6)
{
std::cout << std::endl << "Too few Arguments! Please provide:" << std::endl;
std::cout << "user settings directory" << std::endl;
std::cout << "factory directory" << std::endl;
std::cout << "name of recording directory" << std::endl;
std::cout << "exposure time in ms" << std::endl;
std::cout << "number of images" << std::endl;
return -1;
}
char* const userSettingsDir = argv[1];
char* const factoryDir = argv[2];
char* const recDir = argv[3];
char* const exposureString = argv[4];
char* const nrImagesString = argv[5];
int exposure_ms = std::stoi(exposureString);
int nrImages = std::stoi(nrImagesString);
std::cout << "Example 05 record single image " << std::endl;
std::cout << "User Settings Dir: " << userSettingsDir << std::endl;
std::cout << "Factory Dir: " << factoryDir << std::endl;
std::cout << "Recording Dir: " << recDir << std::endl;
std::cout << "Exposure in ms: " << exposure_ms << std::endl;
std::cout << "Number of Images: " << nrImages << std::endl;
std::cout << "loading user settings..." << std::endl;
cuvis::General::init(userSettingsDir);
cuvis::General::set_log_level(loglevel_info);
std::cout << "Loading Calibration and processing context..." << std::endl;
cuvis::Calibration calib(factoryDir);
cuvis::ProcessingContext proc(calib);
cuvis::AcquisitionContext acq(calib);
cuvis::SaveArgs saveArgs;
saveArgs.allow_overwrite = true;
saveArgs.export_dir = recDir;
saveArgs.allow_session_file = true;
cuvis::CubeExporter exporter(saveArgs);
while (cuvis::hardware_state_t::hardware_state_offline == acq.get_state())
{
std::this_thread::sleep_for(std::chrono::seconds(1));
}
std::cout << "Camera is online" << std::endl;
acq.set_operation_mode(cuvis::operation_mode_t::OperationMode_Software).get();
acq.set_integration_time(exposure_ms).get();
std::cout << "Start recording now" << std::endl;
for (int k = 0; k < nrImages; k++)
{
std::cout << "Record image #" << k << "... (async) ";
auto async_mesu = acq.capture();
auto mesu_res = async_mesu.get(std::chrono::milliseconds(500));
if (mesu_res.first == cuvis::async_result_t::done &&
mesu_res.second.has_value())
{
auto& mesu = mesu_res.second.value();
proc.apply(mesu);
exporter.apply(mesu);
std::cout << "done" << std::endl;
}
else
{
std::cout << "failed" << std::endl;
}
}
//uncomment for recording in queue mode
/*
for (int k = 0; k < nrImages; k++)
{
std::cout << "Record image #" << k << "... (queue)";
acq.capture_queue();
auto mesu = acq.get_next_measurement(std::chrono::milliseconds(500));
if (mesu)
{
proc.apply(mesu.value());
exporter.apply(mesu.value());
std::cout << "done" << std::endl;
}
else
{
std::cout << "failed" << std::endl;
}
std::cout << "done" << std::endl;
}
*/
cuvis::General::shutdown();
std::cout << "finished." << std::endl;
}
import os
import platform
import time
from datetime import timedelta
from pathlib import Path
import cuvis
def run_example_recordSingleImage(
userSettingsDir,
factoryDir,
recDir,
exposure,
nrImgs):
print("loading user settings...")
cuvis.init(userSettingsDir)
cuvis.set_log_level("info")
print(
"loading calibration, processing and acquisition context (factory)...")
calibration = cuvis.Calibration(factoryDir)
processingContext = cuvis.ProcessingContext(calibration)
acquisitionContext = cuvis.AcquisitionContext(calibration)
saveArgs = cuvis.SaveArgs(export_dir=recDir, allow_overwrite=True,
allow_session_file=True)
cubeExporter = cuvis.CubeExporter(saveArgs)
while acquisitionContext.state == cuvis.HardwareState.Offline:
print(".", end="")
time.sleep(1)
print("\n")
print("Camera is online")
acquisitionContext.operation_mode = cuvis.OperationMode.Software
acquisitionContext.integration_time = exposure
print("Start recoding now")
for i in range(nrImgs):
print("Record image #{}/{} ... (async)".format(i + 1, nrImgs))
am = acquisitionContext.capture()
mesu, res = am.get(timedelta(milliseconds=500))
if mesu is not None:
processingContext.apply(mesu)
cubeExporter.apply(mesu)
print("done")
else:
print("failed")
cuvis.shutdown()
print("finished.")
if __name__ == "__main__":
if platform.system() == "Windows":
lib_dir = Path(os.getenv("CUVIS"))
data_dir = lib_dir.parent / "sdk" / \
"sample_data" / "set_examples"
elif platform.system() == "Linux":
lib_dir = os.getenv("CUVIS_DATA")
data_dir = lib_dir / \
"sample_data" / "set_examples"
# default factory
loc_factory = lib_dir.parent / "factory"
# default settings
loc_settings = data_dir / "settings"
# default output
loc_output = Path(os.getcwd()) / "EX05_images"
# parameters
loc_exptime = 100 # in msw
loc_nimgs = 10
print("Example 05: Record single image. Please provide:")
userSettingsDir = input(
"User settings directory (default: {}): ".format(loc_settings))
if userSettingsDir.strip().lower() in ["", "default"]:
userSettingsDir = loc_settings
factoryDir = input("Factory directory (default: {}): ".format(loc_factory))
if factoryDir.strip().lower() in ["", "default"]:
factoryDir = loc_factory
recDir = input(
"Name of recording directory (default: {}): ".format(loc_output))
if recDir.strip().lower() in ["", "default"]:
recDir = loc_output
exposure = input(
"Exposure/Integration time in ms (default: {}): ".format(loc_exptime))
if exposure.strip().lower() in ["", "default"]:
exposure = loc_exptime
exposure = int(exposure)
nrImgs = input("Number of Images (default: {}): ".format(loc_nimgs))
if nrImgs.strip().lower() in ["", "default"]:
nrImgs = loc_nimgs
nrImgs = int(nrImgs)
run_example_recordSingleImage(str(userSettingsDir), str(factoryDir), str(recDir), exposure,
nrImgs)
Recording a video
This example demonstrates how to record a video sequence of hyperspectral data using the cuvis SDK.
#include "cuvis.h"
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef WIN32
#include <Windows.h>
#else
#include <unistd.h>
#endif
int keepRunning = 1;
void signal_handler(int sig)
{
printf("\nsignal received. Stopping acquisiton...\n");
fflush(stdout);
(void)sig;
keepRunning = 0;
}
int main(int argc, char* argv[])
{
if (argc != 7)
{
printf("To few Arguments! Please provide:\n");
printf("user settings directory\n");
printf("factory directory\n");
printf("name of recording directory\n");
printf("exposure time in ms\n");
printf("auto exposure [1/0]\n");
printf("target fps\n");
fflush(stdout);
return -1;
}
char* const userSettingsDir = argv[1];
char* const factoryDir = argv[2];
char* const recDir = argv[3];
char* const exposureString = argv[4];
char* const autoExpString = argv[5];
char* const fpsString = argv[6];
int exposure_ms = atoi(exposureString); //in ms
bool autoExp = false;
if (atoi(autoExpString) == 1)
{
autoExp = true;
}
double fps = atof(fpsString);
printf("Example 06 video");
printf("\nUser Settings Dir: ");
printf(userSettingsDir);
printf("\nFactory Dir: ");
printf(factoryDir);
printf("\nRecording Dir: ");
printf(recDir);
printf("\nExposure in ms: %d\n", exposure_ms);
printf("Auto Exposure: %d\n", autoExp);
printf("Target FPS: %4.2f\n", fps);
fflush(stdout);
CUVIS_CALIB calib;
CUVIS_ACQ_CONT acqCont;
CUVIS_PROC_CONT procCont;
printf("loading user settings...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_init(userSettingsDir, loglevel_debug));
printf("loading calibration...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_calib_create_from_path(factoryDir, &calib));
printf("loading acquisition context... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_acq_cont_create_from_calib(calib, &acqCont));
printf("load processing context \n");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_create_from_calib(calib, &procCont));
printf("prepare saving of measurements... \n");
fflush(stdout);
CUVIS_EXPORTER cube_exporter;
CUVIS_EXPORT_GENERAL_SETTINGS general_settings = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
strcpy(general_settings.export_dir, recDir);
CUVIS_EXPORT_CUBE_SETTINGS cube_settings;
cube_settings.allow_fragmentation = 0;
cube_settings.allow_overwrite = 1;
cube_settings.allow_session_file = 1;
cube_settings.fps = fps;
cube_settings.operation_mode = OperationMode_Internal;
cube_settings.allow_info_file = 1;
cube_settings.hard_limit = 4;
cube_settings.soft_limit = 2;
CUVIS_CHECK(cuvis_exporter_create_cube(
&cube_exporter, general_settings, cube_settings));
CUVIS_PROC_ARGS procArgs;
procArgs.allow_recalib = 0;
procArgs.processing_mode = Cube_Raw;
CUVIS_SESSION_INFO sess = {"video", 0, 0};
CUVIS_CHECK(cuvis_acq_cont_set_session_info(acqCont, &sess));
printf("waiting for camera to become online...\n");
fflush(stdout);
for (;;)
{
CUVIS_HARDWARE_STATE state;
CUVIS_CHECK(cuvis_acq_cont_get_state(acqCont, &state));
if (state == hardware_state_online)
{
printf("\ncamera online\n");
fflush(stdout);
break;
}
if (state == hardware_state_partially_online)
{
printf("\ncamera partially online\n");
fflush(stdout);
break;
}
#ifdef WIN32
Sleep(1000);
#else
usleep(1000000);
#endif
printf(".");
}
printf("component details:\n");
fflush(stdout);
CUVIS_INT compCount;
CUVIS_CHECK(cuvis_acq_cont_get_component_count(acqCont, &compCount));
for (int compIdx = 0; compIdx < compCount; compIdx++)
{
CUVIS_INT online;
CUVIS_COMPONENT_INFO cinfo;
CUVIS_CHECK(cuvis_acq_cont_get_component_info(acqCont, compIdx, &cinfo));
CUVIS_CHECK(cuvis_comp_online_get(acqCont, compIdx, &online));
printf(" - component '%s' is ", cinfo.displayname);
fflush(stdout);
if (online != 0)
{
printf("online\n");
fflush(stdout);
}
else
{
printf("offline\n");
fflush(stdout);
}
printf(" -- info: %s\n", cinfo.sensorinfo);
printf(" -- use: %s\n", cinfo.userfield);
printf(" -- pixelformat: %s\n", cinfo.pixelformat);
fflush(stdout);
}
printf("initializing hardware...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_acq_cont_integration_time_set(acqCont, exposure_ms));
CUVIS_CHECK(
cuvis_acq_cont_operation_mode_set(acqCont, OperationMode_Internal));
CUVIS_CHECK(cuvis_acq_cont_fps_set(acqCont, fps));
CUVIS_CHECK(cuvis_acq_cont_queue_size_set(acqCont, 10));
CUVIS_CHECK(cuvis_acq_cont_continuous_set(acqCont, 0));
CUVIS_CHECK(cuvis_proc_cont_set_args(procCont, procArgs));
cuvis_acq_cont_binning_set(acqCont, 1);
CUVIS_WORKER worker;
CUVIS_WORKER_SETTINGS worker_settings;
worker_settings.can_skip_measurements = 0; // Worker cannot skip exporting measurements
worker_settings.can_skip_supplementary_steps = 1; // Worker can skip view generation
worker_settings.can_drop_results = 1; // Worker can drop results from the output queue, if it is full
worker_settings.input_queue_size = 10;
worker_settings.output_queue_size = 5;
worker_settings.mandatory_queue_size = 2;
worker_settings.supplementary_queue_size = 2;
cuvis_worker_create(&worker, worker_settings);
cuvis_worker_set_acq_cont(worker, acqCont);
cuvis_worker_set_proc_cont(worker, procCont);
cuvis_worker_set_exporter(worker, cube_exporter);
printf("registering signal for CTRL+c (cancel recording) \n");
fflush(stdout);
signal(SIGINT, signal_handler);
printf("recording...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_acq_cont_continuous_set(acqCont, 1));
CUVIS_CHECK(cuvis_worker_start(worker));
CUVIS_INT used_queue;
CUVIS_INT queue_limit;
while (0 != keepRunning)
{
CUVIS_MESU mesu = 0;
queue_limit = 4;
cuvis_worker_get_threads_busy(worker, &used_queue);
if (used_queue == queue_limit)
{
printf("Worker queue is full! Main() loop can not keep up!");
fflush(stdout);
}
cuvis_acq_cont_queue_size_get(acqCont, &used_queue);
cuvis_acq_cont_queue_used_get(acqCont, &used_queue);
if (used_queue == queue_limit)
{
printf("Acquisition queue is full! Worker can not keep up!");
fflush(stdout);
}
CUVIS_STATUS ret;
ret = cuvis_worker_get_next_result(worker, &mesu, NULL, exposure_ms + 200);
if (ret == status_not_available) {
printf("Worker has no measurement ready yet...");
}
else if (ret != status_ok)
{
printf("Worker error, details: %s\n", cuvis_get_last_error_msg());
fflush(stdout);
}
if (mesu)
{
CUVIS_MESU_METADATA mesu_data;
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf(
"\rcurrent handle index: %04d", mesu_data.session_info_sequence_no);
fflush(stdout);
cuvis_measurement_free(&mesu);
}
}
signal(SIGINT, SIG_DFL);
printf("cleaning up\n");
fflush(stdout);
CUVIS_CHECK(cuvis_acq_cont_continuous_set(acqCont, 0));
CUVIS_CHECK(cuvis_worker_stop(worker));
CUVIS_CHECK(cuvis_worker_drop_all_queued(worker));
cuvis_worker_free(&worker);
cuvis_exporter_free(&cube_exporter);
cuvis_acq_cont_free(&acqCont);
cuvis_proc_cont_free(&procCont);
cuvis_calib_free(&calib);
cuvis_shutdown();
printf("finished \n");
fflush(stdout);
}
#include "cuvis.hpp"
#include <cassert>
#include <chrono>
#include <cmath>
#include <csignal>
#include <ctime>
#include <iostream>
using namespace std::literals::chrono_literals;
int keepRunning = 1;
void signal_handler(int sig)
{
(void)sig;
std::cout << std::endl
<< "CTRL+C received. Stopping acquisiton..." << std::endl;
keepRunning = 0;
}
int main(int argc, char* argv[])
{
if (argc != 7)
{
std::cout << std::endl << "Too few Arguments! Please provide:" << std::endl;
std::cout << "user settings directory" << std::endl;
std::cout << "factory directory" << std::endl;
std::cout << "name of recording directory" << std::endl;
std::cout << "exposure time in ms" << std::endl;
std::cout << "auto exposure [1/0]" << std::endl;
std::cout << "target fps" << std::endl;
return -1;
}
char* userSettingsDir = argv[1];
char* factoryDir = argv[2];
char* recDir = argv[3];
char* exposureString = argv[4];
char* autoExpString = argv[5];
char* fpsString = argv[6];
int exposure_ms = std::stoi(exposureString);
bool autoExp = std::stoi(autoExpString);
double fps = std::stod(fpsString);
std::cout << "Example 06 video cpp " << std::endl;
std::cout << "User Settings Dir: " << userSettingsDir << std::endl;
std::cout << "Factory Dir: " << factoryDir << std::endl;
std::cout << "Recording Dir: " << recDir << std::endl;
std::cout << "Exposure in ms: " << exposure_ms << std::endl;
std::cout << "Auto Exposure: " << autoExp << std::endl;
std::cout << "Target FPS: " << fps << std::endl;
std::cout << "loading user settings..." << std::endl;
cuvis::General::init(userSettingsDir);
//register log message output
cuvis::General::register_log_callback(
[](char const* msg, cuvis::loglevel_t lvl) -> void {
static std::map<cuvis::loglevel_t, std::string> log_prefix = {
{loglevel_info, "info: "},
{loglevel_warning, "warning: "},
{loglevel_error, "error: "},
{loglevel_fatal, "fatal: "}};
std::cout << " - " << log_prefix.at(lvl) << msg << std::endl;
},
loglevel_info);
std::cout << "loading calibration..." << std::endl;
cuvis::Calibration calib(factoryDir);
std::cout << "loading acquisition context..." << std::endl;
cuvis::AcquisitionContext acq(calib);
CUVIS_SESSION_INFO sess = {"video", 0, 0};
acq.set_session_info(sess);
std::cout << "prepare saving of measurements..." << std::endl;
cuvis::SaveArgs sargs;
sargs.fps = fps;
sargs.operation_mode = OperationMode_Internal;
sargs.allow_overwrite = true;
sargs.allow_session_file = true;
sargs.export_dir = std::filesystem::path(recDir);
std::cout << "Writing Files to: " << sargs.export_dir << std::endl;
cuvis::CubeExporter exporter(sargs);
std::cout << "prepare processing of measurements..." << std::endl;
cuvis::ProcessingContext proc(calib);
cuvis::ProcessingArgs args;
args.processing_mode = Cube_Raw;
proc.set_processingArgs(args);
std::cout << "waiting for camera to become online ...";
acq.register_state_change_callback(
[](cuvis::hardware_state_t state,
std::map<int, cuvis::AcquisitionContext::component_state_info_t>
comp_states) -> void {
std::cout << std::endl;
switch (state)
{
case hardware_state_online:
std::cout << "camera online" << std::endl;
break;
case hardware_state_partially_online:
std::cout << "camera partially online" << std::endl;
break;
case hardware_state_offline:
std::cout << "camera offline" << std::endl;
break;
}
std::cout << " components: " << std::endl;
for (auto const& comp : comp_states)
{
std::cout << " #" << comp.first << " " << comp.second.display_name
<< " is " << (comp.second.is_online ? "online" : "offline")
<< std::endl;
}
});
while (acq.get_state() == hardware_state_offline)
{
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << ".";
}
std::cout << std::endl;
std::cout << "initializing hardware..." << std::endl;
acq.set_integration_time(exposure_ms).get();
acq.set_operation_mode(OperationMode_Internal).get();
acq.set_fps(fps).get();
acq.set_auto_exp(autoExp);
acq.set_continuous(true);
std::cout << "registering signal for CTRL+c (cancel recording)..."
<< std::endl;
std::signal(SIGINT, signal_handler);
std::cout << "configuring worker..." << std::endl;
cuvis::WorkerArgs worker_settings;
worker_settings.can_skip_measurements = false; // Worker cannot skip exporting measurements
worker_settings.can_skip_supplementary_steps = true; // Worker can skip view generation
worker_settings.can_drop_results = true; // Worker can drop results from the output queue, if it is full
worker_settings.input_queue_size = 10;
worker_settings.output_queue_size = 5;
worker_settings.mandatory_queue_size = 2;
worker_settings.supplementary_queue_size = 2;
cuvis::Worker worker(worker_settings);
worker.set_acq_cont(&acq);
//comment out the following line to prevent processing
worker.set_proc_cont(&proc);
//comment out the following line to prevent saving to disk
worker.set_exporter(&exporter);
std::cout << "configuring FPS Analysis Stuff" << std::endl;
using std::chrono::duration;
using std::chrono::duration_cast;
using std::chrono::high_resolution_clock;
using std::chrono::milliseconds;
auto t1 = high_resolution_clock::now();
std::vector<long long> frametimes;
int fpsAveraging = 200;
std::cout << "recording...! " << std::endl;
worker.start_processing();
while (0 != keepRunning)
{
auto workerContainer = worker.get_next_result(100ms);
// maybe we're already cancelling
if (keepRunning == 0)
continue;
if (workerContainer.mesu.has_value())
{
auto t2 = t1;
t1 = high_resolution_clock::now();
std::cout
<< "current handle index: "
<< workerContainer.mesu.value().get_meta()->session_info.sequence_no
<< std::endl;
auto ms_int = duration_cast<milliseconds>(t1 - t2);
if (frametimes.size() >= fpsAveraging)
{
frametimes.erase(frametimes.begin());
}
frametimes.push_back(ms_int.count());
long long totalFrametime = 0;
for (int i = 0; i < frametimes.size(); i++)
{
totalFrametime += frametimes[i];
}
double actualFps =
1 / (((double)totalFrametime / (double)frametimes.size()) / 1000);
if (abs(actualFps - fps) > 0.5 &&
frametimes.size() ==
fpsAveraging) //fps is significantly different from user setting and averaging vector is full
{
std::cout << "WARNING: FPS was set to " << fps
<< " but on average we only get " << actualFps << std::endl;
}
if (worker.get_threads_busy() == 4)
{
std::cout << "worker queue is full! Main() loop can not keep up!"
<< std::endl;
}
if (acq.get_queue_size() == acq.get_queue_used())
{
std::cout << "Acquisition queue is full! Worker can not keep up!"
<< std::endl;
}
}
}
signal(SIGINT, SIG_DFL);
std::cout << "acquisition stopped." << std::endl;
acq.set_continuous(false);
acq.reset_state_change_callback();
cuvis::General::shutdown();
cuvis::General::reset_log_callback();
std::cout << std::endl << "finished." << std::endl;
}
import os
import platform
import time
from datetime import datetime, timedelta
from pathlib import Path
import cuvis
def run_example_recordVideo(userSettingsDir,
factoryDir,
recDir,
exposure,
autoExp,
fps):
print("loading user settings...")
cuvis.init(userSettingsDir)
cuvis.set_log_level("info")
print("loading calibration (factory)...")
calibration = cuvis.Calibration(factoryDir)
print("loading acquisition context...")
acquisitionContext = cuvis.AcquisitionContext(calibration)
session_info = cuvis.SessionData("video", 0, 0)
acquisitionContext.session_info = session_info
print("prepare saving of measurements...")
saveArgs = cuvis.SaveArgs(export_dir=recDir,
allow_overwrite=True,
allow_session_file=True,
fps=fps,
operation_mode=cuvis.OperationMode.Software)
print("writing files to: {}".format(recDir))
cubeExporter = cuvis.CubeExporter(saveArgs)
print("prepare processing of measurements...")
processingContext = cuvis.ProcessingContext(calibration)
processingContext.processing_mode = cuvis.ProcessingMode.Raw
print("Waiting for camera to come online...")
while acquisitionContext.state == cuvis.HardwareState.Offline:
print(".", end="")
time.sleep(1)
print("\n")
print("Component details:")
for i, comp in enumerate(acquisitionContext.components()):
print("Component #{} {} is {}".format(i, comp.info.display_name,
"online" if comp.online else "offline"))
print(" -- info: {}".format(comp.info.sensor_info))
print(" -- use: {}".format(comp.info.user_field))
print(" -- pixelformat: {}".format(comp.info.pixel_format))
print("initializing hardware...")
acquisitionContext.integration_time = exposure
acquisitionContext.operation_mode = cuvis.OperationMode.Internal
acquisitionContext.fps = fps
acquisitionContext.auto_exp = autoExp
acquisitionContext.set_continuous(True)
print("configuring worker...")
workerSettings = cuvis.WorkerSettings()
worker = cuvis.Worker(workerSettings)
worker.set_acquisition_context(acquisitionContext)
worker.set_processing_context(processingContext)
worker.set_exporter(cubeExporter)
worker.start_processing()
print("recording...! (will stop after 2 minutes)")
start = datetime.now()
while (datetime.now() - start) < timedelta(minutes=2):
while 1:
if worker.has_next_result():
break
else:
time.sleep(0.001)
workerContainer = worker.get_next_result(1000) # in ms
if workerContainer.mesu.data is not None:
print("current handle index: {}".format(
workerContainer.mesu.session_info.sequence_number))
workerState = worker.state
if workerState.resultsInQueue == worker.output_queue_limit:
print("worker output queue is full! Main() loop can not keep up!")
break
if workerState.measurementsInQueue == worker.mandatory_queue_limit:
print("acquisition queue is full! Worker can not keep up!")
break
print("acquisition stopped...")
acquisitionContext.set_continuous(False)
worker.stop_processing()
cuvis.shutdown()
print("finished.")
if __name__ == "__main__":
if platform.system() == "Windows":
lib_dir = Path(os.getenv("CUVIS"))
data_dir = lib_dir.parent / "sdk" / \
"sample_data" / "set_examples"
elif platform.system() == "Linux":
lib_dir = os.getenv("CUVIS_DATA")
data_dir = lib_dir / \
"sample_data" / "set_examples"
# default factory
loc_factory = lib_dir.parent / "factory"
# default settings
loc_settings = data_dir / "settings"
# default output
loc_output = Path(os.getcwd()) / "EX06_video"
# parameters
loc_exptime = 100 # in ms
loc_autoexp = False
loc_fps = 2
print("Example 06: Record video file. Please provide:")
userSettingsDir = input(
"User settings directory (default: {}): ".format(loc_settings))
if userSettingsDir.strip().lower() in ["", "default"]:
userSettingsDir = loc_settings
factoryDir = input("Factory directory (default: {}): ".format(loc_factory))
if factoryDir.strip().lower() in ["", "default"]:
factoryDir = loc_factory
recDir = input(
"Name of recording directory (default: {}): ".format(loc_output))
if recDir.strip().lower() in ["", "default"]:
recDir = loc_output
exposure = input(
"Exposure/Integration time in ms (default: {}): ".format(loc_exptime))
if exposure.strip().lower() in ["", "default"]:
exposure = loc_exptime
exposure = int(exposure)
autoExp = input(
"Auto-exposure time [True/False] (default: {}): ".format(loc_autoexp))
if autoExp.strip().lower() in ["", "default"]:
autoExp = loc_autoexp
autoExp = int(autoExp)
fps = input(
"Target frames per second (fps) (default: {}): ".format(loc_fps))
if fps.strip().lower() in ["", "default"]:
fps = loc_fps
fps = int(fps)
run_example_recordVideo(str(userSettingsDir), str(factoryDir), str(recDir), exposure,
autoExp, fps)
Rerecording a video from already recorded data
This example demonstrates how to simulate recording a hyperspectral video sequence using data from a pre-existing session file. It replicates the process of live video recording without requiring an actual camera.
#include "cuvis.h"
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef WIN32
#include <Windows.h>
#else
#include <unistd.h>
#endif
int keepRunning = 1;
void signal_handler(int sig)
{
printf("\nsignal received. Stopping acquisiton...\n");
fflush(stdout);
(void)sig;
keepRunning = 0;
}
int main(int argc, char* argv[])
{
if (argc != 7)
{
printf("To few Arguments! Please provide:\n");
printf("user settings directory\n");
printf("sessionfile\n");
printf("name of recording directory\n");
printf("exposure time in ms\n");
printf("auto exposure [1/0]\n");
printf("target fps\n");
fflush(stdout);
return -1;
}
char* const userSettingsDir = argv[1];
char* const sessionfile = argv[2];
char* const recDir = argv[3];
char* const exposureString = argv[4]; //in ms
char* const autoExpString = argv[5];
char* const fpsString = argv[6];
int exposure_ms = atoi(exposureString); //in ms
bool autoExp = false;
if (atoi(autoExpString) == 1)
{
autoExp = true;
}
double fps = atof(fpsString);
printf("Example 06 video");
printf("\nUser Settings Dir: ");
printf(userSettingsDir);
printf("\nSessionfile: ");
printf(sessionfile);
printf("\nRecording Dir: ");
printf(recDir);
printf("\nExposure in ms: %d\n", exposure_ms);
printf("Auto Exposure: %d\n", autoExp);
printf("Target FPS: %4.2f\n", fps);
fflush(stdout);
CUVIS_SESSION_FILE sessFile;
CUVIS_ACQ_CONT acqCont;
CUVIS_PROC_CONT procCont;
printf("loading user settings...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_init(userSettingsDir, loglevel_debug));
printf("loading session file... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_session_file_load(sessionfile, &sessFile));
printf("loading acquisition context... \n");
fflush(stdout);
CUVIS_CHECK(cuvis_acq_cont_create_from_session_file(sessFile, 1,
&acqCont)); // simulating = true --> use frames from sessionfile instead of real camera
printf("load processing context \n");
fflush(stdout);
CUVIS_CHECK(cuvis_proc_cont_create_from_session_file(sessFile, &procCont));
printf("prepare saving of measurements... \n");
fflush(stdout);
CUVIS_EXPORTER cube_exporter;
CUVIS_EXPORT_GENERAL_SETTINGS general_settings = {
"", //initializer list only takes const char*, leave empty and modify afterwards.
"all",
1,
0.0,
pan_sharpening_interpolation_type_NearestNeighbor,
pan_sharpening_algorithm_Noop,
0,
0};
strcpy(general_settings.export_dir, recDir);
CUVIS_EXPORT_CUBE_SETTINGS cube_settings;
cube_settings.allow_fragmentation = 0;
cube_settings.allow_overwrite = 1;
cube_settings.allow_session_file = 1;
cube_settings.fps = fps;
cube_settings.operation_mode = OperationMode_Internal;
cube_settings.allow_info_file = 1;
CUVIS_CHECK(cuvis_exporter_create_cube(&cube_exporter, general_settings, cube_settings));
CUVIS_PROC_ARGS procArgs;
procArgs.allow_recalib = 0;
procArgs.processing_mode = Cube_Raw;
CUVIS_SESSION_INFO sess = {"video", 0, 0};
CUVIS_CHECK(cuvis_acq_cont_set_session_info(acqCont, &sess));
printf("waiting for simulated camera to become ready...\n");
fflush(stdout);
for (;;)
{
CUVIS_HARDWARE_STATE state;
CUVIS_CHECK(cuvis_acq_cont_get_state(acqCont, &state));
if (state == hardware_state_online)
{
printf("\ncamera online\n");
fflush(stdout);
break;
}
if (state == hardware_state_partially_online)
{
printf("\ncamera partially online\n");
fflush(stdout);
break;
}
#ifdef WIN32
Sleep(1000);
#else
usleep(1000000);
#endif
printf(".");
}
printf("component details:\n");
fflush(stdout);
CUVIS_INT compCount;
CUVIS_CHECK(cuvis_acq_cont_get_component_count(acqCont, &compCount));
for (int compIdx = 0; compIdx < compCount; compIdx++)
{
CUVIS_INT online;
CUVIS_COMPONENT_INFO cinfo;
CUVIS_CHECK(cuvis_acq_cont_get_component_info(acqCont, compIdx, &cinfo));
CUVIS_CHECK(cuvis_comp_online_get(acqCont, compIdx, &online));
printf(" - component '%s' is ", cinfo.displayname);
fflush(stdout);
if (online != 0)
{
printf("online\n");
fflush(stdout);
}
else
{
printf("offline\n");
fflush(stdout);
}
printf(" -- info: %s\n", cinfo.sensorinfo);
printf(" -- use: %s\n", cinfo.userfield);
printf(" -- pixelformat: %s\n", cinfo.pixelformat);
fflush(stdout);
}
printf("initializing hardware...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_acq_cont_integration_time_set(acqCont, 100));
CUVIS_CHECK(cuvis_acq_cont_operation_mode_set(acqCont, OperationMode_Internal));
CUVIS_CHECK(cuvis_acq_cont_fps_set(acqCont, fps));
CUVIS_CHECK(cuvis_acq_cont_queue_size_set(acqCont, 10));
CUVIS_CHECK(cuvis_acq_cont_continuous_set(acqCont, 0));
CUVIS_CHECK(cuvis_proc_cont_set_args(procCont, procArgs));
cuvis_acq_cont_binning_set(acqCont, 1);
CUVIS_WORKER worker;
CUVIS_WORKER_SETTINGS worker_settings;
worker_settings.can_skip_measurements = 0; // Worker cannot skip exporting measurements
worker_settings.can_skip_supplementary_steps = 1; // Worker can skip view generation
worker_settings.can_drop_results = 1; // Worker can drop results from the output queue, if it is full
worker_settings.input_queue_size = 10;
worker_settings.output_queue_size = 5;
worker_settings.mandatory_queue_size = 2;
worker_settings.supplementary_queue_size = 2;
cuvis_worker_create(&worker, worker_settings);
cuvis_worker_set_acq_cont(worker, acqCont);
cuvis_worker_set_proc_cont(worker, procCont);
cuvis_worker_set_exporter(worker, cube_exporter);
printf("registering signal for CTRL+c (cancel recording) \n");
fflush(stdout);
signal(SIGINT, signal_handler);
printf("recording...\n");
fflush(stdout);
CUVIS_CHECK(cuvis_acq_cont_continuous_set(acqCont, 1));
CUVIS_CHECK(cuvis_worker_start(worker));
CUVIS_INT used_queue;
CUVIS_INT queue_limit;
while (0 != keepRunning)
{
CUVIS_MESU mesu = 0;
queue_limit = worker_settings.mandatory_queue_size + worker_settings.supplementary_queue_size;
cuvis_worker_get_threads_busy(worker, &used_queue);
if (used_queue == queue_limit)
{
printf("Worker queue is full! Main() loop can not keep up!");
fflush(stdout);
}
cuvis_acq_cont_queue_size_get(acqCont, &used_queue);
cuvis_acq_cont_queue_used_get(acqCont, &used_queue);
if (used_queue == queue_limit)
{
printf("Acquisition queue is full! Worker can not keep up!");
fflush(stdout);
}
CUVIS_STATUS ret = cuvis_worker_get_next_result(acqCont, &mesu, NULL, 1000);
if (ret == status_not_available)
{
printf("Worker has no measurement ready yet...");
}
else if (ret != status_ok)
{
printf("Worker error, details: %s\n", cuvis_get_last_error_msg());
fflush(stdout);
}
if (mesu)
{
CUVIS_MESU_METADATA mesu_data;
CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data));
printf("\rcurrent handle index: %04d", mesu_data.session_info_sequence_no);
fflush(stdout);
cuvis_measurement_free(&mesu);
}
}
signal(SIGINT, SIG_DFL);
printf("cleaning up\n");
fflush(stdout);
CUVIS_CHECK(cuvis_acq_cont_continuous_set(acqCont, 0));
CUVIS_CHECK(cuvis_worker_stop(worker));
CUVIS_CHECK(cuvis_worker_drop_all_queued(worker));
cuvis_worker_free(&worker);
cuvis_exporter_free(&cube_exporter);
cuvis_acq_cont_free(&acqCont);
cuvis_proc_cont_free(&procCont);
cuvis_session_file_free(&sessFile);
cuvis_shutdown();
printf("finished \n");
fflush(stdout);
}
#include "cuvis.hpp"
#include <cassert>
#include <chrono>
#include <cmath>
#include <csignal>
#include <ctime>
#include <iostream>
using namespace std::literals::chrono_literals;
int keepRunning = 1;
void signal_handler(int sig)
{
(void)sig;
std::cout << std::endl
<< "CTRL+C received. Stopping acquisiton..." << std::endl;
keepRunning = 0;
}
int main(int argc, char* argv[])
{
if (argc != 7)
{
std::cout << std::endl << "To few Arguments! Please provide:" << std::endl;
std::cout << "user settings directory" << std::endl;
std::cout << "sessionfile" << std::endl;
std::cout << "name of recording directory" << std::endl;
std::cout << "exposure time in ms" << std::endl;
std::cout << "auto exposure [1/0]" << std::endl;
std::cout << "target fps" << std::endl;
return -1;
}
char* userSettingsDir = argv[1];
char* sessionfile = argv[2];
char* recDir = argv[3];
char* exposureString = argv[4];
char* autoExpString = argv[5];
char* fpsString = argv[6];
int exposure_ms = std::stoi(exposureString);
bool autoExp = std::stoi(autoExpString);
double fps = std::stod(fpsString);
std::cout << "Example 06 video cpp " << std::endl;
std::cout << "User Settings Dir: " << userSettingsDir << std::endl;
std::cout << "Sessionfile: " << sessionfile << std::endl;
std::cout << "Recording Dir: " << recDir << std::endl;
std::cout << "Exposure in ms: " << exposure_ms << std::endl;
std::cout << "Auto Exposure: " << autoExp << std::endl;
std::cout << "Target FPS: " << fps << std::endl;
std::cout << "loading user settings..." << std::endl;
cuvis::General::init(userSettingsDir);
//register log message output
cuvis::General::register_log_callback(
[](char const* msg, cuvis::loglevel_t lvl) -> void {
static std::map<cuvis::loglevel_t, std::string> log_prefix = {
{loglevel_info, "info: "},
{loglevel_warning, "warning: "},
{loglevel_error, "error: "},
{loglevel_fatal, "fatal: "}};
std::cout << " - " << log_prefix.at(lvl) << msg << std::endl;
},
loglevel_info);
std::cout << "loading sessionfile..." << std::endl;
cuvis::SessionFile sess(sessionfile);
std::cout << "loading acquisition context..." << std::endl;
cuvis::AcquisitionContext acq(
sess,
true); // simulating = true --> use frames from sessionfile instead of real camera
CUVIS_SESSION_INFO sessinfo = {"video", 0, 0};
acq.set_session_info(sessinfo);
std::cout << "prepare saving of measurements..." << std::endl;
cuvis::SaveArgs sargs;
sargs.fps = fps;
sargs.operation_mode = OperationMode_Internal;
sargs.allow_overwrite = true;
sargs.allow_session_file = true;
sargs.export_dir = std::filesystem::path(recDir);
std::cout << "Writing Files to: " << sargs.export_dir << std::endl;
cuvis::CubeExporter exporter(sargs);
std::cout << "prepare processing of measurements..." << std::endl;
cuvis::ProcessingContext proc(sess);
cuvis::ProcessingArgs args;
args.processing_mode = Cube_Raw;
proc.set_processingArgs(args);
std::cout << "waiting for camera to become online ...";
acq.register_state_change_callback(
[](cuvis::hardware_state_t state,
std::map<int, cuvis::AcquisitionContext::component_state_info_t>
comp_states) -> void {
std::cout << std::endl;
switch (state)
{
case hardware_state_online:
std::cout << "camera online" << std::endl;
break;
case hardware_state_partially_online:
std::cout << "camera partially online" << std::endl;
break;
case hardware_state_offline:
std::cout << "camera offline" << std::endl;
break;
}
std::cout << " components: " << std::endl;
for (auto const& comp : comp_states)
{
std::cout << " #" << comp.first << " " << comp.second.display_name
<< " is " << (comp.second.is_online ? "online" : "offline")
<< std::endl;
}
});
while (acq.get_state() == hardware_state_offline)
{
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << ".";
}
std::cout << std::endl;
std::cout << "initializing simulated hardware..." << std::endl;
acq.set_integration_time(exposure_ms).get();
acq.set_operation_mode(OperationMode_Internal).get();
acq.set_fps(fps).get();
acq.set_auto_exp(autoExp);
acq.set_continuous(true);
std::cout << "registering signal for CTRL+c (cancel recording)..."
<< std::endl;
std::signal(SIGINT, signal_handler);
std::cout << "configuring worker..." << std::endl;
cuvis::WorkerArgs worker_settings;
worker_settings.can_skip_measurements = false; // Worker cannot skip exporting measurements
worker_settings.can_skip_supplementary_steps = true; // Worker can skip view generation
worker_settings.can_drop_results = true; // Worker can drop results from the output queue, if it is full
worker_settings.input_queue_size = 10;
worker_settings.output_queue_size = 5;
worker_settings.mandatory_queue_size = 2;
worker_settings.supplementary_queue_size = 2;
cuvis::Worker worker(worker_settings);
worker.set_acq_cont(&acq);
//comment out the following line to prevent processing
worker.set_proc_cont(&proc);
//comment out the following line to prevent saving to disk
worker.set_exporter(&exporter);
std::cout << "configuring FPS Analysis Stuff" << std::endl;
using std::chrono::duration;
using std::chrono::duration_cast;
using std::chrono::high_resolution_clock;
using std::chrono::milliseconds;
auto t1 = high_resolution_clock::now();
std::vector<long long> frametimes;
int fpsAveraging = 200;
std::cout << "recording...! " << std::endl;
worker.start_processing();
while (keepRunning)
{
auto workerContainer = worker.get_next_result(100ms);
if (workerContainer.mesu.has_value())
{
auto t2 = t1;
t1 = high_resolution_clock::now();
std::cout
<< "current handle index: "
<< workerContainer.mesu.value().get_meta()->session_info.sequence_no
<< std::endl;
auto ms_int = duration_cast<milliseconds>(t1 - t2);
if (frametimes.size() >= fpsAveraging)
{
frametimes.erase(frametimes.begin());
}
frametimes.push_back(ms_int.count());
long long totalFrametime = 0;
for (int i = 0; i < frametimes.size(); i++)
{
totalFrametime += frametimes[i];
}
double actualFps =
1 / (((double)totalFrametime / (double)frametimes.size()) / 1000);
if (abs(actualFps - fps) > 0.5 &&
frametimes.size() ==
fpsAveraging) //fps is significantly different from user setting and averaging vector is full
{
std::cout << "WARNING: FPS was set to " << fps
<< " but on average we only get " << actualFps << std::endl;
}
if (worker.get_threads_busy() == 4)
{
std::cout << "worker queue is full! Main() loop can not keep up!"
<< std::endl;
}
if (acq.get_queue_size() == acq.get_queue_used())
{
std::cout << "Acquisition queue is full! Worker can not keep up!"
<< std::endl;
}
}
}
signal(SIGINT, SIG_DFL);
std::cout << "acquisition stopped." << std::endl;
acq.set_continuous(false);
worker.stop_processing();
worker.drop_all_queued();
acq.reset_state_change_callback();
cuvis::General::reset_log_callback();
cuvis::General::shutdown();
std::cout << std::endl << "finished." << std::endl;
}
import os
import platform
import time
from datetime import datetime, timedelta
from pathlib import Path
import cuvis
def run_example_recordVideoFromSessionFile(userSettingsDir,
measurementLoc,
recDir,
exposure,
autoExp,
fps):
print("loading user settings...")
cuvis.init(userSettingsDir)
cuvis.set_log_level("info")
print("loading session file ...")
session = cuvis.SessionFile(measurementLoc)
print("loading acquisition context...")
acquisitionContext = cuvis.AcquisitionContext(session, simulate=True) #
# using images from session file instead of camera
session_info = cuvis.SessionData("video", 0, 0)
acquisitionContext.session_info = session_info
print("prepare saving of measurements...")
saveArgs = cuvis.SaveArgs(export_dir=recDir,
allow_overwrite=True,
allow_session_file=True,
fps=fps,
operation_mode=cuvis.OperationMode.Internal)
print("writing files to: {}".format(recDir))
cubeExporter = cuvis.CubeExporter(saveArgs)
print("prepare processing of measurements...")
processingContext = cuvis.ProcessingContext(session)
processingContext.processing_mode = cuvis.ProcessingMode.Raw
print("Waiting for camera to come online...")
while acquisitionContext.state == cuvis.HardwareState.Offline:
print(".", end="")
time.sleep(1)
print("\n")
print("Component details:")
print("Component details:")
for i, (info, is_online) in enumerate(acquisitionContext.components()):
print("Component #{} {} is {}".format(i, info.display_name,
"online" if is_online else "offline"))
print(" -- info: {}".format(info.sensor_info))
print(" -- use: {}".format(info.user_field))
print(" -- pixelformat: {}".format(info.pixel_format))
print("initializing simulated hardware...")
acquisitionContext.integration_time = exposure
acquisitionContext.operation_mode = cuvis.OperationMode.Internal
acquisitionContext.fps = fps
acquisitionContext.auto_exp = autoExp
acquisitionContext.set_continuous(True)
print("configuring worker...")
workerSettings = cuvis.WorkerSettings()
worker = cuvis.Worker(workerSettings)
worker.set_acquisition_context(acquisitionContext)
worker.set_processing_context(processingContext)
worker.set_exporter(cubeExporter)
worker.start_processing()
print("recording...! (will stop after 2 minutes)")
start = datetime.now()
while (datetime.now() - start) < timedelta(minutes=2):
while 1:
if worker.has_next_result():
break
else:
time.sleep(0.001)
workerContainer = worker.get_next_result(0)
if workerContainer.mesu.data is not None:
print("current handle index: {}".format(
workerContainer.mesu.session_info.sequence_number))
workerState = worker.state
if workerState.resultsInQueue == worker.output_queue_limit:
print("worker output queue is full! Main() loop can not keep up!")
break
if workerState.measurementsInQueue == worker.mandatory_queue_limit:
print("acquisition queue is full! Worker can not keep up!")
break
print("acquisition stopped...")
acquisitionContext.set_continuous(False)
worker.stop_processing()
cuvis.shutdown()
print("finished.")
if __name__ == "__main__":
if platform.system() == "Windows":
lib_dir = Path(os.getenv("CUVIS"))
data_dir = lib_dir.parent / "sdk" / \
"sample_data" / "set_examples"
elif platform.system() == "Linux":
lib_dir = os.getenv("CUVIS_DATA")
data_dir = lib_dir / \
"sample_data" / "set_examples"
# default video
loc_file = data_dir / "set1_video" / "video.cu3s"
# default settings
loc_settings = data_dir / "settings"
# default output
loc_output = Path(os.getcwd()) / "EX07_video"
# parameters
loc_exptime = 100 # in ms
loc_autoexp = False
loc_fps = 2
print("Example 07: Record video from session file. Please provide:")
userSettingsDir = input(
"User settings directory (default: {}): ".format(loc_settings))
if userSettingsDir.strip().lower() in ["", "default"]:
userSettingsDir = loc_settings
factoryDir = input("Session file (default: {}): ".format(
loc_file))
if factoryDir.strip().lower() in ["", "default"]:
factoryDir = loc_file
recDir = input(
"Name of recording directory (default: {}): ".format(loc_output))
if recDir.strip().lower() in ["", "default"]:
recDir = loc_output
exposure = input(
"Exposure/Integration time in ms (default: {}): ".format(loc_exptime))
if exposure.strip().lower() in ["", "default"]:
exposure = loc_exptime
exposure = int(exposure)
autoExp = input(
"Auto-exposure time [True/False] (default: {}): ".format(loc_autoexp))
if autoExp.strip().lower() in ["", "default"]:
autoExp = loc_autoexp
fps = input(
"Target frames per second (fps) (default: {}): ".format(loc_fps))
if fps.strip().lower() in ["", "default"]:
fps = loc_fps
fps = int(fps)
run_example_recordVideoFromSessionFile(str(userSettingsDir), str(factoryDir), str(recDir), exposure,
autoExp, fps)
Applying Pan-Sharpening to recorded Data
This example demonstrates how to apply Pan-Sharpening on recorded data. For this to work the camera needs an additional pan-sensor.
import os
import platform
from pathlib import Path
import time
import cuvis
import tifffile
def run_example_pansharpening(userSettingsDir,
measurementLoc,
panToCube,
panScale,
exportDir):
print("loading user settings...")
cuvis.init(userSettingsDir)
cuvis.set_log_level("info")
print("loading session file...")
session = cuvis.SessionFile(measurementLoc)
mesu = session[0]
assert mesu._handle
if 'pan' not in mesu.data.keys():
raise ValueError('The measurement does not contain a Pan Image.')
# settings pansharpening
'''
cuvis.PansharpeningAlgorithm:
Defines, which algorithm is used to calculate the pansharpened image. Available options are:
- Noop:
"dummy" algorithm, only applies scaling.
- CubertMacroPixel:
Generates intensity scaling values for the spectral data from the panimage. Can operate without
reference measurements.
- CubertPanRatio:
Preferred algorithm for reflectance measurements. The measurement's and white calibration's panimages
are used to generate the panratio (or „panchromatic reflectance“ image). The panratio is then applied
to the hyperspectral cube to scale the intensity of the spectra without changing their shape.
- AlphaBlendOverlay:
Technically not a pan-sharpening algorithm. Quick workaround to display correlation results on top of
the pan image using an opacity value selected by the user.
'''
panAlgo = cuvis.PanSharpeningAlgorithm.CubertPanRatio # algorithm for pansharpening
'''
cuvis.PanSharpeningInterpolationType:
This setting controls which conventional algorithm is utilized for upscaling the hyperspectral data cube.
Available options are: Nearest Neighbor, Linear, Cubic and Lanczos
'''
panInterp = cuvis.PanSharpeningInterpolationType.Cubic # interpolation method
multi_tiff_settings = cuvis.TiffExportSettings(
export_dir = str(exportDir),
format = cuvis.TiffFormat.MultiChannel,
pan_sharpening_algorithm = panAlgo,
pan_sharpening_interpolation_type = panInterp,
pan_scale = panScale,
add_pan = panToCube
)
print("size before pansharpening: ", mesu.cube.width, "x", mesu.cube.height, "x", mesu.cube.channels)
print("Pansharpening and tiff export in progress...")
multiTiffExporter = cuvis.TiffExporter(multi_tiff_settings)
multiTiffExporter.apply(mesu)
time.sleep(5)
exportPath= Path(exportDir) / "x20p_flight_data_0000_raw.tiff"
pansharpened_mesu = tifffile.imread(str(exportPath))
print("size after pansharpening: ", pansharpened_mesu.shape[0], "x", pansharpened_mesu.shape[1], "x", pansharpened_mesu.shape[2] )
print("algorithm used:", str(panAlgo).split('.')[-1])
print("Interpolation method used:", str(panInterp).split('.')[-1])
print("Pansharpening amount:", panScale)
print("Panimage saved as 0th channel:", panToCube)
cuvis.shutdown()
print("finished.")
if __name__ == "__main__":
if platform.system() == "Windows":
data_dir = Path(os.getenv("CUVIS")).parent / "sdk" / \
"sample_data" / "set_examples"
elif platform.system() == "Linux":
data_dir = Path(os.getenv("CUVIS_DATA")) / \
"sample_data" / "set_examples"
loc_file = data_dir / "set2_x20p_flight_data" / "x20p_flight_data.cu3s"
loc_settings = data_dir / "settings"
pan_to_cube = True
pan_size = 1
loc_output = Path(os.getcwd()) / "EX08_pansharpened_measurement"
print("Example 08: Pansharpen X20 Plus measurement. Please provide:")
userSettingsDir = input(
"User settings directory (default: {}): ".format(loc_settings))
if userSettingsDir.strip().lower() in ["", "default"]:
userSettingsDir = loc_settings
measurementLoc = input(
"Measurement file (.cu3s) (default: {}): ".format(loc_file))
if measurementLoc.strip().lower() in ["", "default"]:
measurementLoc = loc_file
panToCube = input(
"Save panimage as 0th channel - True/False? (default: {}): ".format(pan_to_cube))
if panToCube.lower() in ["", "default"]:
panToCube = pan_to_cube # use the default boolean value
elif panToCube.lower() == "true":
panToCube = True
elif panToCube.lower() == "false":
panToCube = False
else:
raise ValueError("Invalid input. Please enter True or False.")
panScale = input(
"Define the amount of pansharpening between 0 and 1 in respect to the size of the panimage (default: {}): ".format(pan_size))
if panScale.strip().lower() in ["", "default"]:
panScale = pan_size
exportDir = input(
"Name of export directory (default: {}): ".format(loc_output))
if exportDir.strip().lower() in ["", "default"]:
exportDir = loc_output
run_example_pansharpening(str(userSettingsDir), str(measurementLoc), panToCube, panScale, exportDir)