diff --git a/interface/cuvis.hpp b/interface/cuvis.hpp index 5ceefc3..53150dc 100644 --- a/interface/cuvis.hpp +++ b/interface/cuvis.hpp @@ -898,7 +898,19 @@ namespace cuvis * */ void refresh(); - private: + /** @brief Expert: Return the current handle of the wrapper class */ + CUVIS_MESU get_handle() const; + /** @brief Expert: Create a copy of the current handle of the wrapper class and return it. + * This handle needs to be also freed before the resource will be released by the sdk. + */ + CUVIS_MESU get_handle_copy() const; + + public: + /** @brief Expert: Create a wrapper class around a handle. + * This only allowed once per handle, otherwise the handle could be freed before all instances of the wrapper class are deleted. + * This can be useful if a previously a handle has been copied and now should be wrapped at another place in a program. + * Most of the time this is not necesarry and the wrapper class can be copied just as well + */ Measurement(CUVIS_MESU handle); @@ -972,6 +984,21 @@ namespace cuvis */ std::string get_id() const; + /** @brief Expert: Return the current handle of the wrapper class */ + CUVIS_CALIB get_handle() const; + /** @brief Expert: Create a copy of the current handle of the wrapper class and return it. + * This handle needs to be also freed before the resource will be released by the sdk. + */ + CUVIS_CALIB get_handle_copy() const; + + public: + /** @brief Expert: Create a wrapper class around a handle. + * This only allowed once per handle, otherwise the handle could be freed before all instances of the wrapper class are deleted. + * This can be useful if a previously a handle has been copied and now should be wrapped at another place in a program. + * Most of the time this is not necesarry and the wrapper class can be copied just as well + */ + Calibration(CUVIS_CALIB handle); + private: std::shared_ptr _calib; }; @@ -1010,6 +1037,21 @@ namespace cuvis */ CUVIS_OPERATION_MODE get_operation_mode() const; + /** @brief Expert: Return the current handle of the wrapper class */ + CUVIS_SESSION_FILE get_handle() const; + /** @brief Expert: Create a copy of the current handle of the wrapper class and return it. + * This handle needs to be also freed before the resource will be released by the sdk. + */ + CUVIS_SESSION_FILE get_handle_copy() const; + + public: + /** @brief Expert: Create a wrapper class around a handle. + * This only allowed once per handle, otherwise the handle could be freed before all instances of the wrapper class are deleted. + * This can be useful if a previously a handle has been copied and now should be wrapped at another place in a program. + * Most of the time this is not necesarry and the wrapper class can be copied just as well + */ + SessionFile(CUVIS_SESSION_FILE handle); + private: std::shared_ptr _session; }; @@ -1090,6 +1132,21 @@ namespace cuvis */ std::string get_calib_id() const; + /** @brief Expert: Return the current handle of the wrapper class */ + CUVIS_PROC_CONT get_handle() const; + /** @brief Expert: Create a copy of the current handle of the wrapper class and return it. + * This handle needs to be also freed before the resource will be released by the sdk. + */ + CUVIS_PROC_CONT get_handle_copy() const; + + public: + /** @brief Expert: Create a wrapper class around a handle. + * This only allowed once per handle, otherwise the handle could be freed before all instances of the wrapper class are deleted. + * This can be useful if a previously a handle has been copied and now should be wrapped at another place in a program. + * Most of the time this is not necesarry and the wrapper class can be copied just as well + */ + ProcessingContext(CUVIS_PROC_CONT handle); + private: std::shared_ptr _procCont; ProcessingArgs _procArgs; @@ -1260,7 +1317,21 @@ namespace cuvis ACQ_STUB_1b(component_integration_time_factor, cuvis_comp_integration_time_factor, double, double); #undef ACQ_STUB_1b + + /** @brief Expert: Return the current handle of the wrapper class */ CUVIS_ACQ_CONT get_handle() const; + /** @brief Expert: Create a copy of the current handle of the wrapper class and return it. + * This handle needs to be also freed before the resource will be released by the sdk. + */ + CUVIS_ACQ_CONT get_handle_copy() const; + + public: + /** @brief Expert: Create a wrapper class around a handle. + * This only allowed once per handle, otherwise the handle could be freed before all instances of the wrapper class are deleted. + * This can be useful if a previously a handle has been copied and now should be wrapped at another place in a program. + * Most of the time this is not necesarry and the wrapper class can be copied just as well + */ + AcquisitionContext(CUVIS_ACQ_CONT handle); private: std::shared_ptr _acqCont; @@ -1283,6 +1354,21 @@ namespace cuvis Viewer(ViewArgs const& args); view_data_t apply(Measurement const& mesu); + /** @brief Expert: Return the current handle of the wrapper class */ + CUVIS_VIEWER get_handle() const; + /** @brief Expert: Create a copy of the current handle of the wrapper class and return it. + * This handle needs to be also freed before the resource will be released by the sdk. + */ + CUVIS_VIEWER get_handle_copy() const; + + public: + /** @brief Expert: Create a wrapper class around a handle. + * This only allowed once per handle, otherwise the handle could be freed before all instances of the wrapper class are deleted. + * This can be useful if a previously a handle has been copied and now should be wrapped at another place in a program. + * Most of the time this is not necesarry and the wrapper class can be copied just as well + */ + Viewer(CUVIS_VIEWER handle); + private: std::shared_ptr _viewer; static view_data_t create_view_data(CUVIS_VIEW); @@ -1459,6 +1545,7 @@ namespace cuvis refresh(); } + inline Measurement::Measurement(CUVIS_MESU handle) : _gps_data(std::make_shared()), _string_data(std::make_shared()), @@ -1677,6 +1764,15 @@ namespace cuvis return res; } + inline CUVIS_MESU Measurement::get_handle() const { return *_mesu; } + + inline CUVIS_MESU Measurement::get_handle_copy() const + { + CUVIS_MESU new_handle; + chk(cuvis_measurement_copy_handle(*_mesu, &new_handle)); + return new_handle; + } + inline std::string Calibration::get_id() const { CUVIS_CHAR id[CUVIS_MAXBUF]; @@ -1742,6 +1838,23 @@ namespace cuvis delete handle; }); } + + inline Calibration::Calibration(CUVIS_CALIB handle) + : _calib(std::shared_ptr(new CUVIS_CALIB{handle}, [](CUVIS_CALIB* handle) { + cuvis_calib_free(handle); + delete handle; + })) + {} + + inline CUVIS_CALIB Calibration::get_handle() const { return *_calib; } + + inline CUVIS_CALIB Calibration::get_handle_copy() const + { + CUVIS_CALIB new_handle; + chk(cuvis_calib_copy_handle(*_calib, &new_handle)); + return new_handle; + } + inline ProcessingContext::ProcessingContext(Calibration const& calib) { CUVIS_PROC_CONT procCont; @@ -1772,6 +1885,13 @@ namespace cuvis }); } + inline ProcessingContext::ProcessingContext(CUVIS_CALIB handle) + : _procCont(std::shared_ptr(new CUVIS_PROC_CONT{handle}, [](CUVIS_PROC_CONT* handle) { + cuvis_proc_cont_free(handle); + delete handle; + })) + {} + inline Measurement& ProcessingContext::apply(Measurement& mesu) const { chk(cuvis_proc_cont_apply(*_procCont, *mesu._mesu)); @@ -1840,6 +1960,15 @@ namespace cuvis inline ProcessingArgs const& ProcessingContext::get_processingArgs() const { return _procArgs; } + inline CUVIS_PROC_CONT ProcessingContext::get_handle() const { return *_procCont; } + + inline CUVIS_PROC_CONT ProcessingContext::get_handle_copy() const + { + CUVIS_PROC_CONT new_handle; + chk(cuvis_proc_cont_copy_handle(*_procCont, &new_handle)); + return new_handle; + } + inline Worker::Worker(WorkerArgs const& args) : _worker_poll_thread_run(false) { @@ -2120,6 +2249,22 @@ namespace cuvis }); } + inline Viewer::Viewer(CUVIS_VIEWER handle) + : _viewer(std::shared_ptr(new CUVIS_VIEWER{handle}, [](CUVIS_VIEWER* handle) { + cuvis_viewer_free(handle); + delete handle; + })) + {} + + inline CUVIS_VIEWER Viewer::get_handle() const { return *_viewer; } + + inline CUVIS_VIEWER Viewer::get_handle_copy() const + { + CUVIS_VIEWER new_handle; + chk(cuvis_viewer_copy_handle(*_viewer, &new_handle)); + return new_handle; + } + inline Viewer::view_data_t Viewer::apply(Measurement const& mesu) { CUVIS_VIEW current_view; @@ -2193,8 +2338,6 @@ namespace cuvis } inline AcquisitionContext::~AcquisitionContext() { reset_state_change_callback(); } - inline CUVIS_ACQ_CONT AcquisitionContext::get_handle() const { return *_acqCont; } - inline AcquisitionContext::AcquisitionContext(Calibration const& calib) : _state_poll_thread_run(false) { CUVIS_ACQ_CONT acqCont; @@ -2216,6 +2359,22 @@ namespace cuvis }); } + inline AcquisitionContext::AcquisitionContext(CUVIS_VIEWER handle) + : _acqCont(std::shared_ptr(new CUVIS_ACQ_CONT{handle}, [](CUVIS_ACQ_CONT* handle) { + cuvis_acq_cont_free(handle); + delete handle; + })) + {} + + inline CUVIS_ACQ_CONT AcquisitionContext::get_handle() const { return *_acqCont; } + + inline CUVIS_ACQ_CONT AcquisitionContext::get_handle_copy() const + { + CUVIS_ACQ_CONT new_handle; + chk(cuvis_acq_cont_copy_handle(*_acqCont, &new_handle)); + return new_handle; + } + inline void AcquisitionContext::register_state_change_callback(state_callback_t callback, bool output_initial_state) { @@ -2700,6 +2859,15 @@ namespace cuvis return op_mode; } + inline CUVIS_SESSION_FILE SessionFile::get_handle() const { return *_session; } + + inline CUVIS_SESSION_FILE SessionFile::get_handle_copy() const + { + CUVIS_SESSION_FILE new_handle; + chk(cuvis_session_file_copy_handle(*_session, &new_handle)); + return new_handle; + } + template inline data_t const& common_image_t::get(std::size_t x, std::size_t y, std::size_t z) const {