diff --git a/C/Applications/Examples/.gitkeep b/C/Applications/Examples/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/C/Applications/Examples/loadMeasurement/CMakeLists.txt b/C/Applications/Examples/01_loadMeasurement/CMakeLists.txt similarity index 100% rename from C/Applications/Examples/loadMeasurement/CMakeLists.txt rename to C/Applications/Examples/01_loadMeasurement/CMakeLists.txt diff --git a/C/Applications/Examples/loadMeasurement/main.c b/C/Applications/Examples/01_loadMeasurement/main.c similarity index 100% rename from C/Applications/Examples/loadMeasurement/main.c rename to C/Applications/Examples/01_loadMeasurement/main.c diff --git a/C/Applications/Examples/02_reprocessMeasurement/CMakeLists.txt b/C/Applications/Examples/02_reprocessMeasurement/CMakeLists.txt new file mode 100644 index 0000000..6ba7f0a --- /dev/null +++ b/C/Applications/Examples/02_reprocessMeasurement/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example C) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(Cuvis REQUIRED) +add_executable(main main.c) +target_link_libraries(main PRIVATE cuvis::c) \ No newline at end of file diff --git a/C/Applications/Examples/02_reprocessMeasurement/main.c b/C/Applications/Examples/02_reprocessMeasurement/main.c new file mode 100644 index 0000000..8ffd341 --- /dev/null +++ b/C/Applications/Examples/02_reprocessMeasurement/main.c @@ -0,0 +1,264 @@ +#include "cuvis.h" + +#include + + +int main(int argc, char* argv[]) +{ + if (argc != 8) + { + printf("To few Arguments! Please provide:\n"); + printf("user settings directory\n"); + printf("measurement file (.cu3)\n"); + printf("dark file (.cu3)\n"); + printf("white file (.cu3)\n"); + printf("distance file (.cu3)\n"); + printf("factory directory\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 factoryDir = argv[6]; + char* const outDir = argv[7]; + + printf("Example 02 reprocess measurement \n"); + printf("user Settings Dir: "); + printf(userSettingsDir); + printf("\nmeasurement file: "); + printf(measurementLoc ); + printf("\ndark file (.cu3): "); + printf(darkLoc ); + printf("\nwhite file (.cu3): "); + printf(whiteLoc ); + printf("\ndistance file (.cu3): "); + printf(distanceLoc ); + printf("\nFactory Dir: "); + printf(factoryDir); + printf("\noutput Dir: " ); + printf(outDir ); + + + + CUVIS_MESU mesu; + CUVIS_MESU_METADATA mesu_data; + + CUVIS_MESU dark; + CUVIS_MESU white; + CUVIS_MESU distance; + + CUVIS_CALIB calib; + CUVIS_PROC_CONT procCont; + + CUVIS_INT is_capable; + + CUVIS_SAVE_ARGS save_args; + + + printf("\nloading settings... \n"); + fflush(stdout); + + CUVIS_CHECK(cuvis_init(userSettingsDir)); + + printf("loading measurement... \n"); + fflush(stdout); + + CUVIS_CHECK(cuvis_measurement_load(measurementLoc, + &mesu)); + CUVIS_CHECK(cuvis_measurement_load(darkLoc, &dark)); + CUVIS_CHECK(cuvis_measurement_load(whiteLoc, &white)); + CUVIS_CHECK(cuvis_measurement_load(distanceLoc, + &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 calibration and processing context...\n"); + fflush(stdout); + + CUVIS_CHECK( + cuvis_calib_create_from_path(factoryDir, &calib)); + CUVIS_CHECK(cuvis_proc_cont_create_from_calib(calib, &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)); + + 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)); + + save_args.allow_fragmentation = 0; + save_args.allow_overwrite = 1; + + 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"); + CUVIS_CHECK(cuvis_measurement_save(mesu, exportDirRAW, save_args)); + } + 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"); + + CUVIS_CHECK(cuvis_measurement_save(mesu, exportDirDS, save_args)); + } + 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"); + CUVIS_CHECK(cuvis_measurement_save(mesu, exportDirREF, save_args)); + } + 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"); + CUVIS_CHECK(cuvis_measurement_save(mesu, exportDirSPRAD, save_args)); + } + else + { + printf("Cannot process to Cube_SpectralRadiance mode.\n"); + fflush(stdout); + + } + + + cuvis_calib_free(&calib); + cuvis_proc_cont_free(&procCont); + cuvis_measurement_free(&mesu); + cuvis_measurement_free(&dark); + cuvis_measurement_free(&white); + cuvis_measurement_free(&distance); + ; +} diff --git a/C/Applications/Examples/03_exportMeasurement/CMakeLists.txt b/C/Applications/Examples/03_exportMeasurement/CMakeLists.txt new file mode 100644 index 0000000..6ba7f0a --- /dev/null +++ b/C/Applications/Examples/03_exportMeasurement/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example C) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(Cuvis REQUIRED) +add_executable(main main.c) +target_link_libraries(main PRIVATE cuvis::c) \ No newline at end of file diff --git a/C/Applications/Examples/03_exportMeasurement/main.c b/C/Applications/Examples/03_exportMeasurement/main.c new file mode 100644 index 0000000..181b13b --- /dev/null +++ b/C/Applications/Examples/03_exportMeasurement/main.c @@ -0,0 +1,248 @@ +#include "cuvis.h" + +#include +#include +#include +#include + + + +int main(int argc, char* argv[]) +{ + + if (argc != 5) + { + printf("To few Arguments! Please provide:\n"); + printf("user settings directory\n"); + printf("measurement file (.cu3)\n"); + printf("user plugin file (.xml)\n"); + printf("Name of export directory\n"); + fflush(stdout); + + return -1; + } + const char* userSettingsDir = argv[1]; + const char* measurementLoc = 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("\nmeasurement file: "); + printf(measurementLoc); + printf("\nuser plugin file: " ); + printf(pluginLoc); + printf("\nExport Dir: " ); + printf(exportDir); + fflush(stdout); + + + + + 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; + + char* buffer = 0; + long length; + FILE* f; + + printf("\nloading user settings...\n"); + fflush(stdout); + + CUVIS_CHECK(cuvis_init(userSettingsDir)); +#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.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.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.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.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); + + + printf("loading measurement ...\n"); + fflush(stdout); + + CUVIS_CHECK(cuvis_measurement_load(measurementLoc, + &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("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); + + + + cuvis_measurement_free(&mesu); + cuvis_exporter_free(&envi_exporter); + cuvis_exporter_free(&single_tiff_exporter); + cuvis_exporter_free(&multi_tiff_exporter); + cuvis_exporter_free(&view_exporter); + + free(buffer); + printf("finished.\n"); + fflush(stdout); + + return 0; +} diff --git a/C/Applications/Examples/04_changeDistance/CMakeLists.txt b/C/Applications/Examples/04_changeDistance/CMakeLists.txt new file mode 100644 index 0000000..6ba7f0a --- /dev/null +++ b/C/Applications/Examples/04_changeDistance/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example C) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(Cuvis REQUIRED) +add_executable(main main.c) +target_link_libraries(main PRIVATE cuvis::c) \ No newline at end of file diff --git a/C/Applications/Examples/04_changeDistance/main.c b/C/Applications/Examples/04_changeDistance/main.c new file mode 100644 index 0000000..613cc91 --- /dev/null +++ b/C/Applications/Examples/04_changeDistance/main.c @@ -0,0 +1,141 @@ +#include "cuvis.h" + +#include + +int main(int argc, char* argv[]) +{ + if (argc != 6) + { + printf("To few Arguments! Please provide:\n"); + printf("user settings directory\n"); + printf("measurement file (.cu3)\n"); + printf("factory directory\n"); + printf("new distance\n"); + printf("Name of export directory\n"); + fflush(stdout); + + return -1; + } + char* const userSettingsDir = argv[1]; + char* const measurementLoc = argv[2]; + char* const factoryDir = argv[3]; + char* const distanceString = argv[4]; + char* const exportDir = argv[5]; + + + int distance = atoi(distanceString); + + printf("Example 04 change distance cpp \n"); + printf(userSettingsDir); + printf("\nmeasurement file: "); + printf(measurementLoc ); + printf( "\nFactory Dir: "); + printf(factoryDir); + printf("\nNew Distance: %d\n", distance); + printf("Export Dir: "); + printf(exportDir); + fflush(stdout); + + + + + + + + CUVIS_MESU mesu; + CUVIS_MESU_METADATA mesu_data; + + CUVIS_CALIB calib; + CUVIS_PROC_CONT procCont; + + CUVIS_INT is_capable; + + printf("\nloading settings... \n"); + fflush(stdout); + + CUVIS_CHECK(cuvis_init(userSettingsDir)); +#ifdef _DEBUG + CUVIS_CHECK(cuvis_set_log_level(loglevel_debug)); +#else + CUVIS_CHECK(cuvis_set_log_level(loglevel_info)); +#endif + + + printf("\nloading measurement... \n"); + fflush(stdout); + + CUVIS_CHECK(cuvis_measurement_load(measurementLoc, &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_calib_create_from_path(factoryDir, &calib)); + CUVIS_CHECK(cuvis_proc_cont_create_from_calib(calib, &procCont)); + printf(" done. \n"); + fflush(stdout); + + printf("Set distance ..."); + fflush(stdout); + + CUVIS_CHECK(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_SAVE_ARGS save_args; + save_args.allow_fragmentation = 0; + save_args.allow_overwrite = 1; + + CUVIS_CHECK(cuvis_measurement_save(mesu, exportDir, save_args)); + } + else + { + printf("Cannot process to Cube_Raw mode.\n"); + fflush(stdout); + + } + + + cuvis_calib_free(&calib); + cuvis_proc_cont_free(&procCont); + cuvis_measurement_free(&mesu); + printf("finished."); + fflush(stdout); +} diff --git a/C/Applications/Examples/05_recordSingleImages/CMakeLists.txt b/C/Applications/Examples/05_recordSingleImages/CMakeLists.txt new file mode 100644 index 0000000..6ba7f0a --- /dev/null +++ b/C/Applications/Examples/05_recordSingleImages/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example C) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(Cuvis REQUIRED) +add_executable(main main.c) +target_link_libraries(main PRIVATE cuvis::c) \ No newline at end of file diff --git a/C/Applications/Examples/05_recordSingleImages/main.c b/C/Applications/Examples/05_recordSingleImages/main.c new file mode 100644 index 0000000..58eef08 --- /dev/null +++ b/C/Applications/Examples/05_recordSingleImages/main.c @@ -0,0 +1,243 @@ +#include "cuvis.h" +#include +#include +#include +#ifdef WIN32 +#include +#else +#include +#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("name of recording directory\n"); + printf("exposure time in ms\n"); + printf("number of images\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 nrImagesString = argv[5]; + + + int exposure_ms = atoi(exposureString); + int nrImages = atoi(nrImagesString); + + printf("Example 05 record single image\n"); + printf("User Settings Dir: "); + printf(userSettingsDir); + printf("\nFactory Dir: "); + printf(factoryDir); + printf("\nRecording Dir: "); + printf(recDir); + printf("\nExposure in ms: %d\n", exposure_ms); + printf("Number of Images: %d\n", nrImages); + 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)); + + + printf("load calibration...\n"); + fflush(stdout); + CUVIS_CHECK(cuvis_calib_create_from_path(factoryDir, &calib)); + + printf("loading processing context... \n"); + fflush(stdout); + CUVIS_CHECK(cuvis_proc_cont_create_from_calib(calib, &procCont)); + + printf("load acquisition context...\n"); + fflush(stdout); + CUVIS_CHECK(cuvis_acq_cont_create_from_calib(calib, &acqCont)); + + + 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.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 = 0; + + CUVIS_WORKER_SETTINGS worker_settings; + worker_settings.keep_out_of_sequence = 1; + worker_settings.poll_interval = 0; + worker_settings.worker_count = 0; + worker_settings.worker_queue_size = 0; + + cuvis_exporter_create_cube(&cube_exporter, general_settings, cube_settings); + + 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"); + fflush(stdout); + for (;;) + { + CUVIS_HARDWARE_STATE state; + 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("."); + fflush(stdout); + } + + printf("component details:\n"); + fflush(stdout); + CUVIS_INT compCount; + CUVIS_CHECK(cuvis_acq_cont_get_component_count(acqCont, &compCount)); + for (unsigned 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_acq_cont_integration_time_set(acqCont, exposure_ms); + cuvis_acq_cont_operation_mode_set(acqCont, OperationMode_Software); + ACQ_SET_SINGLE_VALUE(cuvis_acq_cont_auto_exp, CUVIS_INT, 1); + + + printf("start recording now\n"); + fflush(stdout); + + for (int k = 0; k < nrImages; k++) + { + CUVIS_MESU mesu; + CUVIS_VIEW view; + + + printf("trigger image nr. %d/10 (software) \n", k + 1); + fflush(stdout); + cuvis_worker_set_acq_cont(worker, acqCont); + cuvis_worker_set_proc_cont(worker, procCont); + cuvis_worker_set_exporter(worker, cube_exporter); + + CUVIS_INT hasNext; + cuvis_worker_has_next_result(worker, &hasNext); + + if (hasNext) + { + cuvis_worker_get_next_result(worker, &mesu, &view); + printf("recorded mesu (id %d)\n", k); + printf("process mesu (id %d)\n", k); + fflush(stdout); + CUVIS_CHECK(cuvis_proc_cont_set_args(procCont, procArgs)); + CUVIS_CHECK(cuvis_proc_cont_apply(procCont, mesu)); + + + + printf("save to cu3 (id %d) \n", k); + fflush(stdout); + //the cube exporter exports the measurement and sets the path in the measurement's meta-data + cuvis_exporter_apply(cube_exporter, mesu); + + CUVIS_MESU_METADATA mesu_data; + CUVIS_CHECK(cuvis_measurement_get_metadata(mesu, &mesu_data)); + + printf("location: %s/%s.cu3\n", mesu_data.path, mesu_data.name); + + printf("release mesu (id %d)\n", k); + fflush(stdout); + cuvis_measurement_free(&mesu); + } + else + { +#ifdef WIN32 + Sleep(500); +#else + usleep(50000); +#endif + } + } + printf("done. cleaning up...\n"); + fflush(stdout); + + + cuvis_exporter_free(&cube_exporter); + cuvis_proc_cont_free(&procCont); + cuvis_acq_cont_free(&acqCont); + cuvis_calib_free(&calib); + cuvis_worker_free(&worker); + printf("finished.\n"); + fflush(stdout); +} diff --git a/C/Applications/Examples/06_recordVideo/CMakeLists.txt b/C/Applications/Examples/06_recordVideo/CMakeLists.txt new file mode 100644 index 0000000..6ba7f0a --- /dev/null +++ b/C/Applications/Examples/06_recordVideo/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example C) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(Cuvis REQUIRED) +add_executable(main main.c) +target_link_libraries(main PRIVATE cuvis::c) \ No newline at end of file diff --git a/C/Applications/Examples/06_recordVideo/main.c b/C/Applications/Examples/06_recordVideo/main.c new file mode 100644 index 0000000..388c1dd --- /dev/null +++ b/C/Applications/Examples/06_recordVideo/main.c @@ -0,0 +1,312 @@ +#include "cuvis.h" +#include +#include +#include +#include +#ifdef WIN32 +#include +#else +#include +#endif + +int keepRunning = 1; + +void singal_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); + 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)); + + + + 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.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 = 0; //set to 0 to produce *.cu3 files instead of *.cu3s files. *.cu3s files are currently not yet supported in Cuvis Touch. + 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 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 (unsigned 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_preview_mode_set(acqCont, 1); + CUVIS_WORKER worker; + CUVIS_WORKER_SETTINGS worker_settings; + worker_settings.keep_out_of_sequence = 0; + worker_settings.poll_interval = 10; + #ifdef _DEBUG + worker_settings.worker_count = 1; + #else + worker_settings.worker_count = 0; // =0 automatically sets the worker to the systems number of V-Cores + #endif + + worker_settings.worker_queue_size = 10; + 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, singal_handler); + + printf("recording...\n"); + fflush(stdout); + CUVIS_CHECK(cuvis_acq_cont_continuous_set(acqCont, 1)); + + CUVIS_INT used_queue; + CUVIS_INT queue_limit; + + while (0 != keepRunning) + { + CUVIS_MESU mesu; + CUVIS_INT hasNext = 0; + do + { + cuvis_worker_has_next_result(worker, &hasNext); + + if (hasNext != 0) + { + break; + } +#ifdef WIN32 + Sleep(10); +#else + usleep(10000); +#endif + + } while (0 != keepRunning); + + + cuvis_worker_get_queue_limit(worker, &queue_limit); + cuvis_worker_get_queue_used(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); + } + + if (cuvis_worker_get_next_result(acqCont, &mesu, NULL) != 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_worker_free(&worker); + cuvis_exporter_free(&cube_exporter); + cuvis_acq_cont_free(&acqCont); + cuvis_proc_cont_free(&procCont); + cuvis_calib_free(&calib); + printf("finished \n"); + fflush(stdout); +} diff --git a/C/Applications/Examples/readme.md b/C/Applications/Examples/readme.md new file mode 100644 index 0000000..2fb9949 --- /dev/null +++ b/C/Applications/Examples/readme.md @@ -0,0 +1,17 @@ +## 01_loadMeasurement +Load measurement from disk and print the value (count) for all available channels (wavelength) for one specific pixel. + +## 02_reprocessMeasurement +Load measurement as well as references (dark, white, distance) from disk and reprocess the measurement to e.g. reflectance. + +## 03_exportMeasurement +Load measurement from disk and save to different file formats. + +## 04_changeDistance +Load measurement from disk and reprocess to a new distance. + +## 05_recordSingleImages +Setup camera and record measurements via software trigger, aka "single shot mode" or "software mode". + +## 06_recordVideo +Setup camera and record measurements via internal clock triggering, aka "video mode". In this example the worker is used to make use of multithreading (cuvis_worker_create). \ No newline at end of file diff --git a/Cpp/Applications/Examples/.gitkeep b/Cpp/Applications/Examples/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/Cpp/Applications/Examples/loadMeasurement/CMakeLists.txt b/Cpp/Applications/Examples/01_loadMeasurement_cpp/CMakeLists.txt similarity index 100% rename from Cpp/Applications/Examples/loadMeasurement/CMakeLists.txt rename to Cpp/Applications/Examples/01_loadMeasurement_cpp/CMakeLists.txt diff --git a/Cpp/Applications/Examples/loadMeasurement/main.cpp b/Cpp/Applications/Examples/01_loadMeasurement_cpp/main.cpp similarity index 100% rename from Cpp/Applications/Examples/loadMeasurement/main.cpp rename to Cpp/Applications/Examples/01_loadMeasurement_cpp/main.cpp diff --git a/Cpp/Applications/Examples/02_reprocessMeasurement_cpp/CMakeLists.txt b/Cpp/Applications/Examples/02_reprocessMeasurement_cpp/CMakeLists.txt new file mode 100644 index 0000000..5ccd5af --- /dev/null +++ b/Cpp/Applications/Examples/02_reprocessMeasurement_cpp/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(CuvisCpp REQUIRED) +add_executable(main main.cpp) +target_link_libraries(main PRIVATE cuvis::cpp) \ No newline at end of file diff --git a/Cpp/Applications/Examples/02_reprocessMeasurement_cpp/main.cpp b/Cpp/Applications/Examples/02_reprocessMeasurement_cpp/main.cpp new file mode 100644 index 0000000..46e9ec7 --- /dev/null +++ b/Cpp/Applications/Examples/02_reprocessMeasurement_cpp/main.cpp @@ -0,0 +1,95 @@ +#include "cuvis.hpp" + +#include +#include + +int main(int argc, char* argv[]) +{ + + if (argc != 8) + { + std::cout << std::endl << "To few Arguments! Please provide:" << std::endl; + std::cout << "user settings directory" << std::endl; + std::cout << "measurement file (.cu3)" << std::endl; + std::cout << "dark file (.cu3)" << std::endl; + std::cout << "white file (.cu3)" << std::endl; + std::cout << "distance file (.cu3)" << std::endl; + std::cout << "factory directory" << 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 factoryDir = argv[6]; + char* const outDir = argv[7]; + + std::cout << "Example 02 reprocess measurement cpp " << std::endl; + std::cout << "User Settings Dir: " << userSettingsDir << std::endl; + std::cout << "measurement file: " << measurementLoc << std::endl; + std::cout << "dark file (.cu3): " << darkLoc << std::endl; + std::cout << "white file (.cu3): " << whiteLoc << std::endl; + std::cout << "distance file (.cu3): " << distanceLoc << std::endl; + std::cout << "Factory Dir: " << factoryDir << 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 measurment... " << std::endl; + cuvis::Measurement mesu(measurementLoc); + + std::cout << "loading dark... " << std::endl; + cuvis::Measurement dark(darkLoc); + std::cout << "loading white... " << std::endl; + cuvis::Measurement white(whiteLoc); + std::cout << "loading distance... " << std::endl; + cuvis::Measurement distance(distanceLoc); + + + 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 (factory)" << std::endl; + cuvis::Calibration calib(factoryDir); + cuvis::ProcessingContext proc(calib); + + 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; + + std::map 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; + mesu.save(saveArgs); + } + else + { + std::cout << "cannot process to mode " << mode.first << std::endl; + } + } + std::cout << "finished." << std::endl; +} diff --git a/Cpp/Applications/Examples/03_exportMeasurement_cpp/CMakeLists.txt b/Cpp/Applications/Examples/03_exportMeasurement_cpp/CMakeLists.txt new file mode 100644 index 0000000..5ccd5af --- /dev/null +++ b/Cpp/Applications/Examples/03_exportMeasurement_cpp/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(CuvisCpp REQUIRED) +add_executable(main main.cpp) +target_link_libraries(main PRIVATE cuvis::cpp) \ No newline at end of file diff --git a/Cpp/Applications/Examples/03_exportMeasurement_cpp/main.cpp b/Cpp/Applications/Examples/03_exportMeasurement_cpp/main.cpp new file mode 100644 index 0000000..bba54fd --- /dev/null +++ b/Cpp/Applications/Examples/03_exportMeasurement_cpp/main.cpp @@ -0,0 +1,93 @@ +#include "cuvis.hpp" + +#include +#include +#include + +int main(int argc, char* argv[]) +{ + + + if (argc != 5) + { + std::cout << std::endl << "To few Arguments! Please provide:" << std::endl; + std::cout << "user settings directory" << std::endl; + std::cout << "measurement file (.cu3)" << 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 measurementLoc = 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 << "measurement file: " << measurementLoc << std::endl; + std::cout << "user plugin file: " << 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 measurement... " << std::endl; + cuvis::Measurement mesu(measurementLoc); + + 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(file)), + std::istreambuf_iterator()); + + cuvis::ViewExporter exporter(args); + exporter.apply(mesu); + } + std::cout << "finished." << std::endl; +} diff --git a/Cpp/Applications/Examples/04_changeDistance_cpp/CMakeLists.txt b/Cpp/Applications/Examples/04_changeDistance_cpp/CMakeLists.txt new file mode 100644 index 0000000..5ccd5af --- /dev/null +++ b/Cpp/Applications/Examples/04_changeDistance_cpp/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(CuvisCpp REQUIRED) +add_executable(main main.cpp) +target_link_libraries(main PRIVATE cuvis::cpp) \ No newline at end of file diff --git a/Cpp/Applications/Examples/04_changeDistance_cpp/main.cpp b/Cpp/Applications/Examples/04_changeDistance_cpp/main.cpp new file mode 100644 index 0000000..d72fa21 --- /dev/null +++ b/Cpp/Applications/Examples/04_changeDistance_cpp/main.cpp @@ -0,0 +1,76 @@ +#include "cuvis.hpp" + +#include +#include + +int main(int argc, char* argv[]) +{ + + if (argc != 6) + { + std::cout << std::endl << "To few Arguments! Please provide:" << std::endl; + std::cout << "user settings directory" << std::endl; + std::cout << "measurement file (.cu3)" << std::endl; + std::cout << "factory directory" << std::endl; + std::cout << "new distance" << std::endl; + std::cout << "Name of export directory" << std::endl; + + return -1; + } + char* const userSettingsDir = argv[1]; + char* const measurementLoc = argv[2]; + char* const factoryDir = argv[3]; + char* const distanceString = argv[4]; + char* const exportDir = argv[5]; + + int distance = std::stoi(distanceString); + + std::cout << "Example 04 change distance cpp " << std::endl; + std::cout << "User Settings Dir: " << userSettingsDir << std::endl; + std::cout << "measurement file: " << measurementLoc << std::endl; + std::cout << "Factory Dir: " << factoryDir << std::endl; + std::cout << "New Distance: " << 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 measurement... " << std::endl; + cuvis::Measurement mesu(measurementLoc); + + 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::Calibration calib(factoryDir); + cuvis::ProcessingContext proc(calib); + + 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; + + cuvis::SaveArgs saveArgs; + saveArgs.allow_overwrite = true; + saveArgs.export_dir = exportDir; + + assert(proc.is_capable(mesu,procArgs)); + + std::cout << "changing Distance..." << std::endl; + proc.apply(mesu); + std::cout << "saving..." << std::endl; + mesu.save(saveArgs); + std::cout << "finished." << std::endl; + + + +} diff --git a/Cpp/Applications/Examples/05_recordSingleImages_cpp/CMakeLists.txt b/Cpp/Applications/Examples/05_recordSingleImages_cpp/CMakeLists.txt new file mode 100644 index 0000000..5ccd5af --- /dev/null +++ b/Cpp/Applications/Examples/05_recordSingleImages_cpp/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(CuvisCpp REQUIRED) +add_executable(main main.cpp) +target_link_libraries(main PRIVATE cuvis::cpp) \ No newline at end of file diff --git a/Cpp/Applications/Examples/05_recordSingleImages_cpp/main.cpp b/Cpp/Applications/Examples/05_recordSingleImages_cpp/main.cpp new file mode 100644 index 0000000..02557c3 --- /dev/null +++ b/Cpp/Applications/Examples/05_recordSingleImages_cpp/main.cpp @@ -0,0 +1,108 @@ +#include "cuvis.hpp" + +#include +#include + +int main(int argc, char* argv[]) +{ + + if (argc != 6) + { + std::cout << std::endl << "To 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 = false; //comment to produce *.cu3s files instead of *.cu3 files. *.cu3s files are currently not yet supported in Cuvis Touch. + + 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; + } + */ + std::cout << "finished." << std::endl; +} diff --git a/Cpp/Applications/Examples/06_recordVideo_cpp/CMakeLists.txt b/Cpp/Applications/Examples/06_recordVideo_cpp/CMakeLists.txt new file mode 100644 index 0000000..5ccd5af --- /dev/null +++ b/Cpp/Applications/Examples/06_recordVideo_cpp/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.20.0) +project(Example) +list(APPEND CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/../../../SDK/cmake/") +find_package(CuvisCpp REQUIRED) +add_executable(main main.cpp) +target_link_libraries(main PRIVATE cuvis::cpp) \ No newline at end of file diff --git a/Cpp/Applications/Examples/06_recordVideo_cpp/main.cpp b/Cpp/Applications/Examples/06_recordVideo_cpp/main.cpp new file mode 100644 index 0000000..e762844 --- /dev/null +++ b/Cpp/Applications/Examples/06_recordVideo_cpp/main.cpp @@ -0,0 +1,251 @@ +#include "cuvis.hpp" + +#include +#include +#include +#include +#include +#include + +#ifdef WIN32 + #include + +#else + #include +#endif + + +int keepRunning = 1; + +void singal_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 << "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 "< void { + static std::map 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 = false; //comment to produce *.cu3 file instead of *.cu3s files. *.cu3s files are currently not yet supported in Cuvis Touch. + 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 + 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, singal_handler); + + std::cout << "configuring worker..." << std::endl; + cuvis::WorkerArgs worker_settings; + worker_settings.keep_out_of_sequence = 0; + worker_settings.poll_interval = std::chrono::milliseconds(10); + worker_settings.worker_count = 0; // =0 automatically sets the worker to the systems number of V-Cores + worker_settings.worker_queue_size = 100; + 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::high_resolution_clock; + using std::chrono::duration_cast; + using std::chrono::duration; + using std::chrono::milliseconds; + auto t1 = high_resolution_clock::now(); + std::vector frametimes; + int fpsAveraging = 200; + + std::cout << "recording...! " << std::endl; + + while (0 != keepRunning) + { + + CUVIS_INT hasNext = 0; + do + { + hasNext = worker.has_next_result(); + + if (hasNext != 0) + { + break; + } +#ifdef WIN32 + Sleep(1); +#else + usleep(1000); +#endif + + } while (0 != keepRunning); + + + + auto workerContainer = worker.get_next_result(); + 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(t1 - t2); + + if (frametimes.size() >= fpsAveraging) { + frametimes.erase(frametimes.begin()); + } + frametimes.push_back(ms_int.count()); + int 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_queue_size() == worker.get_queue_used()) { + 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::reset_log_callback(); + std::cout << std::endl << "finished." << std::endl; +} diff --git a/Cpp/Applications/Examples/readme.md b/Cpp/Applications/Examples/readme.md new file mode 100644 index 0000000..2fb9949 --- /dev/null +++ b/Cpp/Applications/Examples/readme.md @@ -0,0 +1,17 @@ +## 01_loadMeasurement +Load measurement from disk and print the value (count) for all available channels (wavelength) for one specific pixel. + +## 02_reprocessMeasurement +Load measurement as well as references (dark, white, distance) from disk and reprocess the measurement to e.g. reflectance. + +## 03_exportMeasurement +Load measurement from disk and save to different file formats. + +## 04_changeDistance +Load measurement from disk and reprocess to a new distance. + +## 05_recordSingleImages +Setup camera and record measurements via software trigger, aka "single shot mode" or "software mode". + +## 06_recordVideo +Setup camera and record measurements via internal clock triggering, aka "video mode". In this example the worker is used to make use of multithreading (cuvis_worker_create). \ No newline at end of file diff --git a/SampleData/README.md b/SampleData/README.md index 7ed8d88..8e12355 100644 --- a/SampleData/README.md +++ b/SampleData/README.md @@ -4,7 +4,11 @@ You can download sample data from Cubert Hyperspectral Cameras with the followin https://cloud.cubert-gmbh.de/index.php/s/3oECVGWpC1NpNqC -## Available Datasets: + +__sample_data__: Use this dataset to work with the examples given in C/Cpp/Python/Csharp/Matlab + + +## Other datasets for classification tasks: ### S5 - __Lentils__: This dataset was recorded in the lab and features 6 different types of lentils on black background. @@ -21,3 +25,4 @@ https://cloud.cubert-gmbh.de/index.php/s/3oECVGWpC1NpNqC ### X50P - + \ No newline at end of file