From 8151fff436c0686132fee42abd3312c3ee35bae6 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 15:27:25 +0100 Subject: [PATCH 01/13] jfjoch_viewer: Auto load moved to worker object --- viewer/JFJochImageReadingWorker.cpp | 64 +++++++++++++- viewer/JFJochImageReadingWorker.h | 24 +++++- viewer/JFJochViewerImageROIStatistics.cpp | 1 + viewer/JFJochViewerWindow.cpp | 6 +- viewer/toolbar/JFJochViewerToolbarImage.cpp | 95 +++++---------------- viewer/toolbar/JFJochViewerToolbarImage.h | 16 ++-- 6 files changed, 112 insertions(+), 94 deletions(-) diff --git a/viewer/JFJochImageReadingWorker.cpp b/viewer/JFJochImageReadingWorker.cpp index 43adccef..7a7d7cf3 100644 --- a/viewer/JFJochImageReadingWorker.cpp +++ b/viewer/JFJochImageReadingWorker.cpp @@ -18,6 +18,10 @@ JFJochImageReadingWorker::JFJochImageReadingWorker(const SpotFindingSettings& se indexing = std::make_unique(indexing_settings); http_reader.Experiment(experiment); file_reader.Experiment(experiment); + + autoload_timer = new QTimer(this); + autoload_timer->setInterval(autoload_interval); + connect(autoload_timer, &QTimer::timeout, this, &JFJochImageReadingWorker::AutoLoadTimerExpired); } void JFJochImageReadingWorker::LoadFile(const QString &filename, qint64 image_number, qint64 summation) { @@ -36,15 +40,15 @@ void JFJochImageReadingWorker::LoadFile(const QString &filename, qint64 image_nu total_images = http_reader.GetNumberOfImages(); dataset = http_reader.GetDataset(); if (image_number < 0) - emit setToolbarMode(JFJochViewerToolbarImage::ToolbarMode::Autoload); + setAutoLoadMode_i(AutoloadMode::HTTPSync); else - emit setToolbarMode(JFJochViewerToolbarImage::ToolbarMode::None); + setAutoLoadMode_i(AutoloadMode::None); } else { http_mode = false; file_reader.ReadFile(filename.toStdString()); total_images = file_reader.GetNumberOfImages(); dataset = file_reader.GetDataset(); - emit setToolbarMode(JFJochViewerToolbarImage::ToolbarMode::None); + setAutoLoadMode_i(AutoloadMode::None); } current_image.reset(); current_summation = 1; @@ -84,6 +88,7 @@ void JFJochImageReadingWorker::CloseFile() { void JFJochImageReadingWorker::LoadImage(int64_t image_number, int64_t summation) { QMutexLocker ul(&m); + setAutoLoadMode_i(AutoloadMode::None); if ((image_number == current_image) && (current_summation == summation)) return; LoadImage_i(image_number, summation); @@ -403,3 +408,56 @@ void JFJochImageReadingWorker::LoadCalibration(QString dataset) { } else logger.Info("HTTP mode doesn't allow to read calibration (at the moment"); } + +void JFJochImageReadingWorker::AutoLoadTimerExpired() { + QMutexLocker locker(&m); + switch (autoload_mode) { + case AutoloadMode::HTTPSync: + if (http_mode) + LoadImage_i(-1 , 1); + break; + case AutoloadMode::Movie: { + if (total_images == 0 || !current_image) + return; + int64_t new_image = (current_image.value() + jump_value) % total_images; + LoadImage_i(new_image, current_summation); + break; + } + case AutoloadMode::None: + break; + } +} + +void JFJochImageReadingWorker::setAutoLoadMode_i(AutoloadMode in_mode) { + autoload_mode = in_mode; + if (autoload_mode == AutoloadMode::None) + autoload_timer->stop(); + else + autoload_timer->start(); + emit autoloadChanged(autoload_mode); +} + +void JFJochImageReadingWorker::setAutoLoadMode(AutoloadMode mode) { + QMutexLocker ul(&m); + + switch (mode) { + case AutoloadMode::HTTPSync: + if (http_mode) + setAutoLoadMode_i(mode); + else + setAutoLoadMode_i(AutoloadMode::None); + break; + case AutoloadMode::Movie: + setAutoLoadMode_i(mode); + break; + case AutoloadMode::None: + setAutoLoadMode_i(mode); + break; + } +} + +void JFJochImageReadingWorker::setAutoLoadJump(int64_t val) { + QMutexLocker ul(&m); + if (val > 0) + jump_value = val; +} diff --git a/viewer/JFJochImageReadingWorker.h b/viewer/JFJochImageReadingWorker.h index 96ea60a0..6e2f1927 100644 --- a/viewer/JFJochImageReadingWorker.h +++ b/viewer/JFJochImageReadingWorker.h @@ -9,8 +9,7 @@ #include #include #include - -#include "toolbar/JFJochViewerToolbarImage.h" +#include #include "../reader/JFJochHDF5Reader.h" #include "../common/Logger.h" @@ -29,9 +28,15 @@ Q_DECLARE_METATYPE(std::shared_ptr) class JFJochImageReadingWorker : public QObject { Q_OBJECT +public: + enum class AutoloadMode {HTTPSync, Movie, None}; + Q_ENUM(AutoloadMode) +private: mutable QMutex m; bool http_mode = false; + AutoloadMode autoload_mode = AutoloadMode::None; + JFJochHDF5Reader file_reader; JFJochHttpReader http_reader; @@ -52,27 +57,38 @@ class JFJochImageReadingWorker : public QObject { std::optional current_image; int64_t current_summation = 1; int64_t total_images = 0; + int64_t jump_value = 1; Logger logger{"jfjoch_viewer"}; bool auto_reanalyze = false; + QTimer *autoload_timer; + int autoload_interval = 500; // milliseconds + void LoadImage_i(int64_t image_number, int64_t summation); void CalcROI_i(); void ReanalyzeImage_i(); void UpdateDataset_i(const DiffractionExperiment& experiment); void UpdateAzint_i(const JFJochReaderDataset *dataset); void UpdateUserMask_i(const std::vector &mask); + void setAutoLoadMode_i(AutoloadMode mode); + signals: void datasetLoaded(std::shared_ptr); void imageLoaded(std::shared_ptr); void imageStatsUpdated(std::shared_ptr); void imageNumberChanged(int64_t total_images, int64_t current_image); - void setToolbarMode(JFJochViewerToolbarImage::ToolbarMode input); void setRings(const QVector &v); void simpleImageLoaded(std::shared_ptr image); + void autoloadChanged(AutoloadMode mode); + public: JFJochImageReadingWorker(const SpotFindingSettings &settings, const DiffractionExperiment& experiment, QObject *parent = nullptr); ~JFJochImageReadingWorker() override = default; + +private slots: + void AutoLoadTimerExpired(); + public slots: void LoadFile(const QString &filename, qint64 image_number, qint64 summation); void CloseFile(); @@ -96,6 +112,8 @@ public slots: void ClearUserMask(); void LoadCalibration(QString dataset); + void setAutoLoadMode(AutoloadMode mode); + void setAutoLoadJump(int64_t val); }; diff --git a/viewer/JFJochViewerImageROIStatistics.cpp b/viewer/JFJochViewerImageROIStatistics.cpp index 164cac62..e7756223 100644 --- a/viewer/JFJochViewerImageROIStatistics.cpp +++ b/viewer/JFJochViewerImageROIStatistics.cpp @@ -3,6 +3,7 @@ #include "JFJochViewerImageROIStatistics.h" +#include #include #include diff --git a/viewer/JFJochViewerWindow.cpp b/viewer/JFJochViewerWindow.cpp index d69a3757..333c689e 100644 --- a/viewer/JFJochViewerWindow.cpp +++ b/viewer/JFJochViewerWindow.cpp @@ -224,8 +224,12 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString connect(tableWindow, &JFJochViewerImageListWindow::imageSelected, reading_worker, &JFJochImageReadingWorker::LoadImage); - connect(reading_worker, &JFJochImageReadingWorker::setToolbarMode, + connect(reading_worker, &JFJochImageReadingWorker::autoloadChanged, toolBarImage, &JFJochViewerToolbarImage::setAutoloadMode); + connect(toolBarImage, &JFJochViewerToolbarImage::autoLoadButtonPressed, + reading_worker, &JFJochImageReadingWorker::setAutoLoadMode); + connect(toolBarImage, &JFJochViewerToolbarImage::imageJumpChanged, + reading_worker, &JFJochImageReadingWorker::setAutoLoadJump); connect(side_panel, &JFJochViewerSidePanel::analyze, reading_worker, &JFJochImageReadingWorker::Analyze); diff --git a/viewer/toolbar/JFJochViewerToolbarImage.cpp b/viewer/toolbar/JFJochViewerToolbarImage.cpp index 7ffcfc21..0375726c 100644 --- a/viewer/toolbar/JFJochViewerToolbarImage.cpp +++ b/viewer/toolbar/JFJochViewerToolbarImage.cpp @@ -58,18 +58,16 @@ JFJochViewerToolbarImage::JFJochViewerToolbarImage(QWidget *parent) : QToolBar(p movie_button = new QPushButton("Movie ▶"); movie_button->setCheckable(true); + movie_button->setChecked(false); addWidget(movie_button); - movie_timer = new QTimer(this); - movie_timer->setInterval(movie_interval); - autoload_button = new QPushButton("Sync 🔄"); autoload_button->setCheckable(true); + autoload_button->setChecked(false); addWidget(autoload_button); connect(movie_button, &QPushButton::clicked, this, &JFJochViewerToolbarImage::movieButtonPressed); connect(autoload_button, &QPushButton::clicked, this, &JFJochViewerToolbarImage::autoloadButtonPressed); - connect(movie_timer, &QTimer::timeout, this, &JFJochViewerToolbarImage::movieTimerTimeout); auto *stretch = new QWidget(this); stretch->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred); @@ -120,11 +118,6 @@ void JFJochViewerToolbarImage::updateButtons() { } void JFJochViewerToolbarImage::setImageNumber(int64_t total_images, int64_t current_image) { - if (image_count_in_dataset != total_images && mode == ToolbarMode::Movie) { - mode = ToolbarMode::None; - updateAutoload(); - } - image_count_in_dataset = total_images; curr_image = current_image; updateButtons(); @@ -133,35 +126,25 @@ void JFJochViewerToolbarImage::setImageNumber(int64_t total_images, int64_t curr void JFJochViewerToolbarImage::leftButtonPressed() { if (curr_image >= jump_value) { emit loadImage(curr_image - jump_value, sum); - mode = ToolbarMode::None; - updateAutoload(); } } void JFJochViewerToolbarImage::rightButtonPressed() { if (curr_image < image_count_in_dataset - jump_value) { emit loadImage(curr_image + jump_value, sum); - mode = ToolbarMode::None; - updateAutoload(); } } void JFJochViewerToolbarImage::rightmostButtonPressed() { emit loadImage(image_count_in_dataset - 1, sum); - mode = ToolbarMode::None; - updateAutoload(); } void JFJochViewerToolbarImage::leftmostButtonPressed() { emit loadImage(0, sum); - mode = ToolbarMode::None; - updateAutoload(); } void JFJochViewerToolbarImage::imageNumberSliderPressed() { image_number_slider_manual = true; - mode = ToolbarMode::None; - updateAutoload(); } void JFJochViewerToolbarImage::imageNumberSliderReleased() { @@ -183,8 +166,6 @@ void JFJochViewerToolbarImage::editFinalized() { if (ok && editedValue >= 0 && editedValue <= image_count_in_dataset - 1) { emit loadImage(editedValue, sum); - mode = ToolbarMode::None; - updateAutoload(); } } @@ -192,8 +173,7 @@ void JFJochViewerToolbarImage::editFinalized() { void JFJochViewerToolbarImage::setImageJump(int val) { jump_value = val; updateButtons(); - mode = ToolbarMode::None; - updateAutoload(); + emit imageJumpChanged(jump_value); } void JFJochViewerToolbarImage::setSummation(int val) { @@ -203,72 +183,35 @@ void JFJochViewerToolbarImage::setSummation(int val) { updateButtons(); emit loadImage(curr_image, sum); - - mode = ToolbarMode::None; - updateAutoload(); } void JFJochViewerToolbarImage::autoloadButtonPressed() { - if (mode == ToolbarMode::Autoload) - mode = ToolbarMode::None; + if (autoload_button->isChecked()) + emit autoLoadButtonPressed(JFJochImageReadingWorker::AutoloadMode::HTTPSync); else - mode = ToolbarMode::Autoload; - updateAutoload(); + emit autoLoadButtonPressed(JFJochImageReadingWorker::AutoloadMode::None); } void JFJochViewerToolbarImage::movieButtonPressed() { - if (mode == ToolbarMode::Movie) - mode = ToolbarMode::None; + if (movie_button->isChecked()) + emit autoLoadButtonPressed(JFJochImageReadingWorker::AutoloadMode::Movie); else - mode = ToolbarMode::Movie; - updateAutoload(); + emit autoLoadButtonPressed(JFJochImageReadingWorker::AutoloadMode::None); } -void JFJochViewerToolbarImage::movieTimerTimeout() { - switch (mode) { - case ToolbarMode::Autoload: - emit loadImage(-1, 1); - break; - case ToolbarMode::Movie: - if (curr_image < image_count_in_dataset - jump_value) - emit loadImage(curr_image + jump_value, sum); - else - emit loadImage(0, sum); - break; - case ToolbarMode::None: - // Do nothing - break; - } -} - -void JFJochViewerToolbarImage::updateAutoload() { - switch (mode) { - case ToolbarMode::None: - autoload_button->setChecked(false); - movie_button->setChecked(false); - movie_timer->stop(); - break; - case ToolbarMode::Autoload: +void JFJochViewerToolbarImage::setAutoloadMode(JFJochImageReadingWorker::AutoloadMode input) { + switch (input) { + case JFJochImageReadingWorker::AutoloadMode::HTTPSync: autoload_button->setChecked(true); movie_button->setChecked(false); - movie_timer->start(); break; - case ToolbarMode::Movie: - if (image_count_in_dataset > 0) { - autoload_button->setChecked(false); - movie_button->setChecked(true); - movie_timer->start(); - } else { - autoload_button->setChecked(false); - movie_button->setChecked(false); - movie_timer->stop(); - mode = ToolbarMode::None; - } + case JFJochImageReadingWorker::AutoloadMode::Movie: + autoload_button->setChecked(false); + movie_button->setChecked(true); + break; + case JFJochImageReadingWorker::AutoloadMode::None: + autoload_button->setChecked(false); + movie_button->setChecked(false); break; } } - -void JFJochViewerToolbarImage::setAutoloadMode(JFJochViewerToolbarImage::ToolbarMode input) { - mode = input; - updateAutoload(); -} diff --git a/viewer/toolbar/JFJochViewerToolbarImage.h b/viewer/toolbar/JFJochViewerToolbarImage.h index e54d3099..7ec0b758 100644 --- a/viewer/toolbar/JFJochViewerToolbarImage.h +++ b/viewer/toolbar/JFJochViewerToolbarImage.h @@ -12,15 +12,12 @@ #include "../widgets/NumberLineEdit.h" #include "../widgets/NumericComboBox.h" +#include "../JFJochImageReadingWorker.h" class JFJochViewerToolbarImage : public QToolBar { Q_OBJECT -public: - enum class ToolbarMode {Autoload, Movie, None}; - Q_ENUM(ToolbarMode) -private: - ToolbarMode mode = ToolbarMode::None; + JFJochImageReadingWorker::AutoloadMode autoload_mode = JFJochImageReadingWorker::AutoloadMode::None; size_t image_count_in_dataset; int64_t curr_image; @@ -45,18 +42,16 @@ private: NumericComboBox *jump; - QTimer *movie_timer; - int movie_interval = 500; // milliseconds - void updateButtons(); - void updateAutoload(); signals: void loadImage(int64_t number, int summation); + void autoLoadButtonPressed(JFJochImageReadingWorker::AutoloadMode mode); + void imageJumpChanged(int64_t val); public: explicit JFJochViewerToolbarImage(QWidget *parent = nullptr); public slots: void setImageNumber(int64_t total_images, int64_t current_image); - void setAutoloadMode(ToolbarMode input); + void setAutoloadMode(JFJochImageReadingWorker::AutoloadMode input); private slots: void leftButtonPressed(); void rightButtonPressed(); @@ -73,7 +68,6 @@ private slots: void movieButtonPressed(); void autoloadButtonPressed(); - void movieTimerTimeout(); }; #endif //JFJOCH_JFJOCHVIEWERTOOLBARIMAGE_H \ No newline at end of file -- 2.49.1 From 96df48582295d16e1a20126d4377b1b1f2866cd9 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 16:04:07 +0100 Subject: [PATCH 02/13] jfjoch_viewer: Add azimuthal integration settings window --- viewer/CMakeLists.txt | 2 + viewer/JFJochImageReadingWorker.cpp | 25 +++- viewer/JFJochImageReadingWorker.h | 7 +- viewer/JFJochViewerWindow.cpp | 7 ++ viewer/windows/JFJochAzIntWindow.cpp | 171 +++++++++++++++++++++++++++ viewer/windows/JFJochAzIntWindow.h | 47 ++++++++ 6 files changed, 252 insertions(+), 7 deletions(-) create mode 100644 viewer/windows/JFJochAzIntWindow.cpp create mode 100644 viewer/windows/JFJochAzIntWindow.h diff --git a/viewer/CMakeLists.txt b/viewer/CMakeLists.txt index e4fd92fd..a375906f 100644 --- a/viewer/CMakeLists.txt +++ b/viewer/CMakeLists.txt @@ -71,6 +71,8 @@ ADD_EXECUTABLE(jfjoch_viewer jfjoch_viewer.cpp JFJochViewerWindow.cpp JFJochView windows/JFJochHelperWindow.h widgets/JFJochImage.cpp widgets/JFJochImage.h + windows/JFJochAzIntWindow.cpp + windows/JFJochAzIntWindow.h ) TARGET_LINK_LIBRARIES(jfjoch_viewer Qt6::Core Qt6::Gui Qt6::Widgets Qt6::Charts Qt6::DBus diff --git a/viewer/JFJochImageReadingWorker.cpp b/viewer/JFJochImageReadingWorker.cpp index 7a7d7cf3..1b21e29f 100644 --- a/viewer/JFJochImageReadingWorker.cpp +++ b/viewer/JFJochImageReadingWorker.cpp @@ -11,8 +11,11 @@ #include "../preview/JFJochTIFF.h" -JFJochImageReadingWorker::JFJochImageReadingWorker(const SpotFindingSettings& settings, - const DiffractionExperiment& experiment, QObject *parent) : QObject(parent), indexing_settings(experiment.GetIndexingSettings()) { +JFJochImageReadingWorker::JFJochImageReadingWorker(const SpotFindingSettings &settings, + const DiffractionExperiment &experiment, QObject *parent) + : QObject(parent), + indexing_settings(experiment.GetIndexingSettings()), + azint_settings(experiment.GetAzimuthalIntegrationSettings()) { spot_finding_settings = settings;; indexing = std::make_unique(indexing_settings); @@ -55,6 +58,7 @@ void JFJochImageReadingWorker::LoadFile(const QString &filename, qint64 image_nu current_file = filename; curr_experiment = dataset->experiment; curr_experiment.ImportIndexingSettings(indexing_settings); + curr_experiment.ImportAzimuthalIntegrationSettings(azint_settings); UpdateAzint_i(dataset.get()); emit datasetLoaded(dataset); } @@ -185,20 +189,24 @@ void JFJochImageReadingWorker::SetROICircle(double x, double y, double radius) { } } -void JFJochImageReadingWorker::UpdateDataset_i(const DiffractionExperiment &experiment) { +void JFJochImageReadingWorker::UpdateDataset_i(const std::optional &experiment) { if (!current_image_ptr) return; std::shared_ptr dataset; + if (http_mode) { - http_reader.UpdateGeomMetadata(experiment); + if (experiment) + http_reader.UpdateGeomMetadata(experiment.value()); dataset = http_reader.GetDataset(); } else { - file_reader.UpdateGeomMetadata(experiment); + if (experiment) + file_reader.UpdateGeomMetadata(experiment.value()); dataset = file_reader.GetDataset(); } curr_experiment = dataset->experiment; curr_experiment.ImportIndexingSettings(indexing_settings); + curr_experiment.ImportAzimuthalIntegrationSettings(azint_settings); UpdateAzint_i(dataset.get()); emit datasetLoaded(dataset); @@ -224,6 +232,7 @@ void JFJochImageReadingWorker::ReanalyzeImage_i() { auto new_image_dataset = new_image->CreateMutableDataset(); new_image_dataset->experiment.ImportIndexingSettings(indexing_settings); + new_image_dataset->experiment.ImportAzimuthalIntegrationSettings(azint_settings); new_image_dataset->az_int_bin_to_phi = azint_mapping->GetBinToPhi(); new_image_dataset->az_int_bin_to_q = azint_mapping->GetBinToQ(); new_image_dataset->azimuthal_bins = azint_mapping->GetAzimuthalBinCount(); @@ -304,6 +313,12 @@ void JFJochImageReadingWorker::UpdateSpotFindingSettings(const SpotFindingSettin } } +void JFJochImageReadingWorker::UpdateAzintSettings(const AzimuthalIntegrationSettings &settings) { + QMutexLocker locker(&m); + azint_settings = settings; + UpdateDataset_i(std::nullopt); +} + void JFJochImageReadingWorker::UpdateUserMask_i(const std::vector &mask) { std::shared_ptr dataset; if (http_mode) { diff --git a/viewer/JFJochImageReadingWorker.h b/viewer/JFJochImageReadingWorker.h index 6e2f1927..f929034d 100644 --- a/viewer/JFJochImageReadingWorker.h +++ b/viewer/JFJochImageReadingWorker.h @@ -22,6 +22,8 @@ Q_DECLARE_METATYPE(std::shared_ptr) Q_DECLARE_METATYPE(DiffractionExperiment) Q_DECLARE_METATYPE(SpotFindingSettings) Q_DECLARE_METATYPE(IndexingSettings) +Q_DECLARE_METATYPE(AzimuthalIntegrationSettings) + Q_DECLARE_METATYPE(UnitCell) Q_DECLARE_METATYPE(std::shared_ptr) @@ -44,6 +46,7 @@ private: DiffractionExperiment curr_experiment; IndexingSettings indexing_settings; + AzimuthalIntegrationSettings azint_settings; std::unique_ptr indexing; std::shared_ptr current_image_ptr; @@ -68,7 +71,7 @@ private: void LoadImage_i(int64_t image_number, int64_t summation); void CalcROI_i(); void ReanalyzeImage_i(); - void UpdateDataset_i(const DiffractionExperiment& experiment); + void UpdateDataset_i(const std::optional& experiment); void UpdateAzint_i(const JFJochReaderDataset *dataset); void UpdateUserMask_i(const std::vector &mask); void setAutoLoadMode_i(AutoloadMode mode); @@ -103,7 +106,7 @@ public slots: void Analyze(); void UpdateSpotFindingSettings(const SpotFindingSettings &settings, const IndexingSettings &indexing, int64_t max_spots, bool reanalyze); - + void UpdateAzintSettings(const AzimuthalIntegrationSettings& settings); void AddROIToUserMask(); void SubtractROIFromUserMask(); diff --git a/viewer/JFJochViewerWindow.cpp b/viewer/JFJochViewerWindow.cpp index 333c689e..e95659a4 100644 --- a/viewer/JFJochViewerWindow.cpp +++ b/viewer/JFJochViewerWindow.cpp @@ -20,6 +20,7 @@ #include "windows/JFJochCalibrationWindow.h" #include "toolbar/JFJochViewerToolbarDisplay.h" #include "toolbar/JFJochViewerToolbarImage.h" +#include "windows/JFJochAzIntWindow.h" JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString &file) : QMainWindow(parent) { menuBar = new JFJochViewerMenu(this); @@ -52,6 +53,7 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString indexing_settings.FFT_NumVectors(8 * 1024); } indexing_settings.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenter); + DiffractionExperiment experiment; experiment.ImportIndexingSettings(indexing_settings); experiment.DetectIceRings(true); @@ -95,12 +97,14 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString auto reflectionWindow = new JFJochViewerReflectionListWindow(this); auto processingWindow = new JFJochViewerProcessingWindow(spot_finding_settings, indexing_settings, this); auto calibrationWindow = new JFJochCalibrationWindow(this); + auto azintWindow = new JFJochAzIntWindow(experiment.GetAzimuthalIntegrationSettings(), this); menuBar->AddWindowEntry(tableWindow, "Image list"); menuBar->AddWindowEntry(spotWindow, "Spot list"); menuBar->AddWindowEntry(reflectionWindow, "Reflection list"); menuBar->AddWindowEntry(metadataWindow, "Metadata edit"); menuBar->AddWindowEntry(processingWindow, "Image processing settings"); + menuBar->AddWindowEntry(azintWindow, "Azimuthal integration"); menuBar->AddWindowEntry(calibrationWindow, "Calibration image viewer"); if (dbus) { @@ -293,6 +297,9 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString connect(reading_worker, &JFJochImageReadingWorker::simpleImageLoaded, calibrationWindow, &JFJochCalibrationWindow::calibrationLoaded); + connect(azintWindow, &JFJochAzIntWindow::settingsChanged, + reading_worker, &JFJochImageReadingWorker::UpdateAzintSettings); + if (!file.isEmpty()) LoadFile(file, 0, 1); } diff --git a/viewer/windows/JFJochAzIntWindow.cpp b/viewer/windows/JFJochAzIntWindow.cpp new file mode 100644 index 00000000..af86e3f2 --- /dev/null +++ b/viewer/windows/JFJochAzIntWindow.cpp @@ -0,0 +1,171 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#include "JFJochAzIntWindow.h" +#include +#include +#include + +JFJochAzIntWindow::JFJochAzIntWindow( + const AzimuthalIntegrationSettings &settings, + QWidget *parent) + : JFJochHelperWindow(parent), + m_settings(settings) +{ + setWindowTitle("Azimuthal integration settings"); + QWidget *centralWidget = new QWidget(this); + setCentralWidget(centralWidget); + + auto mainLayout = new QVBoxLayout(centralWidget); + + // Group box similar to TS Paper + stacked inputs + auto group = new QGroupBox("Azimuthal integration", this); + auto formLayout = new QFormLayout(group); + + // Q spacing + m_qSpacing = new SliderPlusBox(0.01, 1.0, 0.001, 3, this); + m_qSpacing->setValue(m_settings.GetQSpacing_recipA()); + formLayout->addRow(tr("Q spacing [Å⁻¹]:"), m_qSpacing); + + // Low Q + m_lowQ = new SliderPlusBox(0.001, 10.0, 0.001, 3, this); + m_lowQ->setValue(m_settings.GetLowQ_recipA()); + formLayout->addRow(tr("Low Q [Å⁻¹]:"), m_lowQ); + + // High Q + m_highQ = new SliderPlusBox(0.001, 10.0, 0.001, 3, this); + m_highQ->setValue(m_settings.GetHighQ_recipA()); + formLayout->addRow(tr("High Q [Å⁻¹]:"), m_highQ); + + // Solid angle / polarization correction checkboxes + m_solidAngleCheckBox = new QCheckBox(tr("Solid angle correction"), this); + m_solidAngleCheckBox->setChecked(m_settings.IsSolidAngleCorrection()); + formLayout->addRow(QString(), m_solidAngleCheckBox); + + m_polarizationCheckBox = new QCheckBox(tr("Polarization correction"), this); + m_polarizationCheckBox->setChecked(m_settings.IsPolarizationCorrection()); + formLayout->addRow(QString(), m_polarizationCheckBox); + + // Azimuthal bins (radio buttons like TS frontend) + auto azimGroupBox = new QGroupBox(tr("Azimuthal bins"), this); + auto azimLayout = new QHBoxLayout(azimGroupBox); + m_azimuthalBinsGroup = new QButtonGroup(this); + + const QList binOptions = {1, 2, 4, 8, 16, 32, 64, 128}; + const int currentBins = m_settings.GetAzimuthalBinCount(); + + for (int bins : binOptions) { + auto *btn = new QRadioButton(QString::number(bins), azimGroupBox); + m_azimuthalBinsGroup->addButton(btn, bins); + m_azimuthalBinButtons.push_back(btn); + azimLayout->addWidget(btn); + if (bins == currentBins) { + btn->setChecked(true); + } + } + + group->setLayout(formLayout); + mainLayout->addWidget(group); + mainLayout->addWidget(azimGroupBox); + + // Error label at bottom (no buttons) + m_errorLabel = new QLabel(this); + m_errorLabel->setStyleSheet("color: rgb(200, 0, 0);"); // red-ish text for errors + m_errorLabel->setWordWrap(true); + mainLayout->addWidget(m_errorLabel); + + // Connections – on change, update errors, settings, and emit + connect(m_qSpacing, &SliderPlusBox::valueChanged, [this](double val) { + m_qSpacingError = (val < 0.01); + Update(); + }); + + connect(m_lowQ, &SliderPlusBox::valueChanged, [this](double val) { + m_lowQError = (val < 0.001 || val > 10.0); + Update(); + }); + + connect(m_highQ, &SliderPlusBox::valueChanged, [this](double val) { + m_highQError = (val < 0.001 || val > 10.0); + Update(); + }); + + connect(m_solidAngleCheckBox, &QCheckBox::toggled, [this](bool /*checked*/) { + Update(); + }); + + connect(m_polarizationCheckBox, &QCheckBox::toggled, [this](bool /*checked*/) { + Update(); + }); + + connect(m_azimuthalBinsGroup, + QOverload::of(&QButtonGroup::buttonClicked), + [this](QAbstractButton * /*btn*/) { + Update(); + }); + + Update(); +} + + +void JFJochAzIntWindow::UpdateErrorLabel() { + const double lowQ = m_lowQ->value(); + const double highQ = m_highQ->value(); + + QStringList messages; + + if (m_qSpacingError) { + messages << tr("Q spacing must be ≥ 0.01 Å⁻¹."); + } + if (m_lowQError) { + messages << tr("Low Q must be between 0.001 and 10 Å⁻¹."); + } + if (m_highQError) { + messages << tr("High Q must be between 0.001 and 10 Å⁻¹."); + } + if (highQ <= lowQ) { + messages << tr("High Q must be greater than Low Q."); + } + + if (messages.isEmpty()) { + m_errorLabel->clear(); + } else { + m_errorLabel->setText(messages.join(' ')); + } +} + +void JFJochAzIntWindow::ApplyToSettings() { + const float lowQ = static_cast(m_lowQ->value()); + const float highQ = static_cast(m_highQ->value()); + const float qSpacing = static_cast(m_qSpacing->value()); + + m_settings.SolidAngleCorrection(m_solidAngleCheckBox->isChecked()); + m_settings.PolarizationCorrection(m_polarizationCheckBox->isChecked()); + m_settings.QRange_recipA(lowQ, highQ); + m_settings.QSpacing_recipA(qSpacing); + + const int bins = m_azimuthalBinsGroup->checkedId(); + if (bins > 0) { + m_settings.AzimuthalBinCount(bins); + } +} + +void JFJochAzIntWindow::Update() { + // Update error label first + UpdateErrorLabel(); + + // If there are validation errors, do not update settings / emit + const double lowQ = m_lowQ->value(); + const double highQ = m_highQ->value(); + const bool rangeError = (highQ <= lowQ); + const bool anyError = m_lowQError || m_highQError || m_qSpacingError || rangeError; + + if (anyError) + return; + + // Update internal settings from widgets + ApplyToSettings(); + + // Emit updated settings when valid + emit settingsChanged(m_settings); +} \ No newline at end of file diff --git a/viewer/windows/JFJochAzIntWindow.h b/viewer/windows/JFJochAzIntWindow.h new file mode 100644 index 00000000..22ad6995 --- /dev/null +++ b/viewer/windows/JFJochAzIntWindow.h @@ -0,0 +1,47 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#ifndef JFJOCH_JFJOCHAZINTWINDOW_H +#define JFJOCH_JFJOCHAZINTWINDOW_H + +#include "JFJochHelperWindow.h" +#include "../widgets/SliderPlusBox.h" +#include +#include +#include + +class JFJochAzIntWindow : public JFJochHelperWindow { + Q_OBJECT + + AzimuthalIntegrationSettings m_settings; + + SliderPlusBox *m_qSpacing; + SliderPlusBox *m_lowQ; + SliderPlusBox *m_highQ; + + QCheckBox *m_solidAngleCheckBox; + QCheckBox *m_polarizationCheckBox; + + QButtonGroup *m_azimuthalBinsGroup; + QList m_azimuthalBinButtons; + + QLabel *m_errorLabel; + + bool m_lowQError = false; + bool m_highQError = false; + bool m_qSpacingError = false; + + void UpdateErrorLabel(); + void ApplyToSettings(); + void Update(); +public: + explicit JFJochAzIntWindow( + const AzimuthalIntegrationSettings &settings, + QWidget *parent = nullptr + ); + +signals: + void settingsChanged(const AzimuthalIntegrationSettings &settings); +}; + +#endif //JFJOCH_JFJOCHAZINTWINDOW_H \ No newline at end of file -- 2.49.1 From a4b6231ed805d83be83a3a247919354bfc376c8d Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 16:53:49 +0100 Subject: [PATCH 03/13] jfjoch_viewer: Add azimuthal integration 2D viewer --- viewer/CMakeLists.txt | 2 + viewer/JFJochViewerSidePanel.cpp | 8 -- viewer/JFJochViewerSidePanel.h | 2 - viewer/JFJochViewerSidePanelChart.cpp | 25 ----- viewer/JFJochViewerSidePanelChart.h | 5 - viewer/JFJochViewerWindow.cpp | 17 ++- viewer/widgets/JFJochAzIntImage.cpp | 117 +++++++++++--------- viewer/widgets/JFJochAzIntImage.h | 19 ++-- viewer/windows/JFJoch2DAzintImageWindow.cpp | 66 +++++++++++ viewer/windows/JFJoch2DAzintImageWindow.h | 36 ++++++ 10 files changed, 191 insertions(+), 106 deletions(-) create mode 100644 viewer/windows/JFJoch2DAzintImageWindow.cpp create mode 100644 viewer/windows/JFJoch2DAzintImageWindow.h diff --git a/viewer/CMakeLists.txt b/viewer/CMakeLists.txt index a375906f..ca14bfc9 100644 --- a/viewer/CMakeLists.txt +++ b/viewer/CMakeLists.txt @@ -73,6 +73,8 @@ ADD_EXECUTABLE(jfjoch_viewer jfjoch_viewer.cpp JFJochViewerWindow.cpp JFJochView widgets/JFJochImage.h windows/JFJochAzIntWindow.cpp windows/JFJochAzIntWindow.h + windows/JFJoch2DAzintImageWindow.cpp + windows/JFJoch2DAzintImageWindow.h ) TARGET_LINK_LIBRARIES(jfjoch_viewer Qt6::Core Qt6::Gui Qt6::Widgets Qt6::Charts Qt6::DBus diff --git a/viewer/JFJochViewerSidePanel.cpp b/viewer/JFJochViewerSidePanel.cpp index c3d58b33..f5bf49ea 100644 --- a/viewer/JFJochViewerSidePanel.cpp +++ b/viewer/JFJochViewerSidePanel.cpp @@ -116,10 +116,6 @@ JFJochViewerSidePanel::JFJochViewerSidePanel(QWidget *parent) : QWidget(parent) connect(this, &JFJochViewerSidePanel::imageLoaded, chart, &JFJochViewerSidePanelChart::loadImage); - connect(chart, &JFJochViewerSidePanelChart::writeStatusBar, - [&] (QString string, int timeout_ms) { - emit writeStatusBar(string, timeout_ms); - }); layout->addWidget(new TitleLabel("ROI", this)); @@ -321,7 +317,3 @@ void JFJochViewerSidePanel::SetROIBox(QRect box) { void JFJochViewerSidePanel::SetROICircle(double x, double y, double radius) { roi->SetROICircle(x, y, radius); } - -void JFJochViewerSidePanel::setColorMap(int color_map) { - chart->setColorMap(color_map); -} diff --git a/viewer/JFJochViewerSidePanel.h b/viewer/JFJochViewerSidePanel.h index 8ebb8088..b46e4f35 100644 --- a/viewer/JFJochViewerSidePanel.h +++ b/viewer/JFJochViewerSidePanel.h @@ -47,14 +47,12 @@ signals: void ROICircleConfigured(double center_x, double center_y, double radius); void AddROIToUserMask(); void SubtractROIFromUserMask(); - void writeStatusBar(QString string, int timeout_ms = 0); public: JFJochViewerSidePanel(QWidget *parent); public slots: void loadImage(std::shared_ptr image); void SetROIBox(QRect box); void SetROICircle(double x, double y, double radius); - void setColorMap(int color_map); private slots: void editingFinished(); void enableResRings(bool input); diff --git a/viewer/JFJochViewerSidePanelChart.cpp b/viewer/JFJochViewerSidePanelChart.cpp index 5001eb2e..b297f0af 100644 --- a/viewer/JFJochViewerSidePanelChart.cpp +++ b/viewer/JFJochViewerSidePanelChart.cpp @@ -9,7 +9,6 @@ JFJochViewerSidePanelChart::JFJochViewerSidePanelChart(QWidget *parent) : QWidge combo_box = new QComboBox(this); combo_box->addItem("Azimuthal integration (1D)", 0); - combo_box->addItem("Azimuthal integration (2D)", 3); combo_box->addItem("Wilson plot", 1); combo_box->addItem("I/sigma", 2); combo_box->addItem("Spots (count)", 5); @@ -22,22 +21,16 @@ JFJochViewerSidePanelChart::JFJochViewerSidePanelChart(QWidget *parent) : QWidge this, &JFJochViewerSidePanelChart::comboBoxSelected); azint_plot = new JFJochSimpleChartView(this); - azint_image = new JFJochAzIntImage(this); one_over_d_sq_plot = new JFJochOneOverResSqChartView(this); stack = new QStackedWidget(this); stack->addWidget(azint_plot); // index 0 - stack->addWidget(azint_image); // index 1 stack->addWidget(one_over_d_sq_plot); // index 2 layout->addWidget(stack); setLayout(layout); - connect(azint_image, &JFJochAzIntImage::writeStatusBar, - [&](QString string, int timeout_ms) { - emit writeStatusBar(string, timeout_ms); - }); } void JFJochViewerSidePanelChart::comboBoxSelected(int val) { @@ -86,20 +79,6 @@ void JFJochViewerSidePanelChart::redrawPlot() { one_over_d_sq_plot->UpdateData(x, y, "d [Å]", "Count"); stack->setCurrentWidget(one_over_d_sq_plot); break; - case 3: { - // Render 2D azimuthal integration as an image - const auto &profile = image->ImageData().az_int_profile; - const auto &ds = image->Dataset(); - int az_bins = ds.azimuthal_bins; - int q_bins = ds.q_bins; - if (az_bins > 0 && q_bins > 0 && profile.size() == static_cast(az_bins * q_bins)) { - azint_image->SetData(profile, ds.az_int_bin_to_phi, ds.az_int_bin_to_q, az_bins); - } else { - azint_image->Clear(); - } - stack->setCurrentWidget(azint_image); - break; - } } } } @@ -108,7 +87,3 @@ void JFJochViewerSidePanelChart::loadImage(std::shared_ptrsetColorMap(color_map); -} diff --git a/viewer/JFJochViewerSidePanelChart.h b/viewer/JFJochViewerSidePanelChart.h index da2e485f..1515e922 100644 --- a/viewer/JFJochViewerSidePanelChart.h +++ b/viewer/JFJochViewerSidePanelChart.h @@ -18,16 +18,12 @@ class JFJochViewerSidePanelChart : public QWidget { QStackedWidget *stack = nullptr; JFJochSimpleChartView *azint_plot = nullptr; - JFJochAzIntImage *azint_image = nullptr; JFJochOneOverResSqChartView *one_over_d_sq_plot = nullptr; std::shared_ptr image; QComboBox *combo_box; void redrawPlot(); -signals: - void writeStatusBar(QString string, int timeout_ms = 0); - private slots: void comboBoxSelected(int val); @@ -36,7 +32,6 @@ public: public slots: void loadImage(std::shared_ptr image); - void setColorMap(int color_map); }; diff --git a/viewer/JFJochViewerWindow.cpp b/viewer/JFJochViewerWindow.cpp index e95659a4..603ca3ba 100644 --- a/viewer/JFJochViewerWindow.cpp +++ b/viewer/JFJochViewerWindow.cpp @@ -20,6 +20,7 @@ #include "windows/JFJochCalibrationWindow.h" #include "toolbar/JFJochViewerToolbarDisplay.h" #include "toolbar/JFJochViewerToolbarImage.h" +#include "windows/JFJoch2DAzintImageWindow.h" #include "windows/JFJochAzIntWindow.h" JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString &file) : QMainWindow(parent) { @@ -98,14 +99,16 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString auto processingWindow = new JFJochViewerProcessingWindow(spot_finding_settings, indexing_settings, this); auto calibrationWindow = new JFJochCalibrationWindow(this); auto azintWindow = new JFJochAzIntWindow(experiment.GetAzimuthalIntegrationSettings(), this); + auto azintImageWindow = new JFJoch2DAzintImageWindow(this); menuBar->AddWindowEntry(tableWindow, "Image list"); menuBar->AddWindowEntry(spotWindow, "Spot list"); menuBar->AddWindowEntry(reflectionWindow, "Reflection list"); menuBar->AddWindowEntry(metadataWindow, "Metadata edit"); menuBar->AddWindowEntry(processingWindow, "Image processing settings"); - menuBar->AddWindowEntry(azintWindow, "Azimuthal integration"); + menuBar->AddWindowEntry(azintWindow, "Azimuthal integration settings"); menuBar->AddWindowEntry(calibrationWindow, "Calibration image viewer"); + menuBar->AddWindowEntry(azintImageWindow, "2D Azimuthal integration image"); if (dbus) { // Create adaptor attached to this window @@ -156,8 +159,11 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString connect(toolBarDisplay, &JFJochViewerToolbarDisplay::colorMapChanged, viewer, &JFJochDiffractionImage::setColorMap); - connect(toolBarDisplay, &JFJochViewerToolbarDisplay::colorMapChanged, side_panel, - &JFJochViewerSidePanel::setColorMap); + connect(toolBarDisplay, &JFJochViewerToolbarDisplay::colorMapChanged, azintImageWindow, + &JFJoch2DAzintImageWindow::setColorMap); + + connect(reading_worker, &JFJochImageReadingWorker::imageLoaded, + azintImageWindow, &JFJoch2DAzintImageWindow::imageLoaded); connect(viewer, &JFJochDiffractionImage::foregroundChanged, toolBarDisplay, &JFJochViewerToolbarDisplay::updateForeground); @@ -277,8 +283,6 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString viewer, &JFJochDiffractionImage::setResolutionRing); connect(viewer, &JFJochDiffractionImage::writeStatusBar, statusbar, &JFJochViewerStatusBar::display); - connect(side_panel, &JFJochViewerSidePanel::writeStatusBar, - statusbar, &JFJochViewerStatusBar::display); connect(metadataWindow, &JFJochViewerMetadataWindow::datasetUpdated, reading_worker, &JFJochImageReadingWorker::UpdateDataset); @@ -300,6 +304,9 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString connect(azintWindow, &JFJochAzIntWindow::settingsChanged, reading_worker, &JFJochImageReadingWorker::UpdateAzintSettings); + connect(azintImageWindow, &JFJoch2DAzintImageWindow::zoomOnBin, + viewer, &JFJochDiffractionImage::centerOnSpot); + if (!file.isEmpty()) LoadFile(file, 0, 1); } diff --git a/viewer/widgets/JFJochAzIntImage.cpp b/viewer/widgets/JFJochAzIntImage.cpp index e9812d93..fa362c9c 100644 --- a/viewer/widgets/JFJochAzIntImage.cpp +++ b/viewer/widgets/JFJochAzIntImage.cpp @@ -18,65 +18,63 @@ void JFJochAzIntImage::Clear() { scene()->clear(); } -// data: size = azimuthal_bins * q_bins -// Layout: q varies fastest (i % q_bins == q index) -void JFJochAzIntImage::SetData(const std::vector &data, - const std::vector &in_phi, - const std::vector &in_q, - int azimuthal_bins) { - if (azimuthal_bins <= 0) { +void JFJochAzIntImage::imageLoaded(std::shared_ptr in_image) { + if (!in_image) { Clear(); - throw std::runtime_error("azimuthal_bins <= 0"); + return; } - int q_bins = data.size() / azimuthal_bins; + const auto &profile = in_image->ImageData().az_int_profile; + const auto &ds = in_image->Dataset(); + int az_bins = ds.azimuthal_bins; + int q_bins = ds.q_bins; - if (q_bins <= 0 || in_phi.size() != data.size() || in_q.size() != data.size()) { - Clear(); - throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, - "Mismatch in input size"); - } + if (az_bins > 0 && q_bins > 0 && profile.size() == static_cast(az_bins * q_bins) + && ds.az_int_bin_to_phi.size() == profile.size() && ds.az_int_bin_to_q.size() == profile.size()) { - float local_min = range_min, local_max = range_max; - if (auto_range) { - local_min = std::numeric_limits::infinity(); - local_max = -std::numeric_limits::infinity(); - for (float v : data) { - if (std::isfinite(v)) { - if (v < local_min) local_min = v; - if (v > local_max) local_max = v; + image = in_image; + float local_min = range_min, local_max = range_max; + if (auto_range) { + local_min = std::numeric_limits::infinity(); + local_max = -std::numeric_limits::infinity(); + for (float v : profile) { + if (std::isfinite(v)) { + if (v < local_min) local_min = v; + if (v > local_max) local_max = v; + } + } + if (!std::isfinite(local_min) || !std::isfinite(local_max) || local_max <= local_min) { + Clear(); + return; + } + } else { + if (!(std::isfinite(local_min) && std::isfinite(local_max) && local_max > local_min)) { + Clear(); + return; } } - if (!std::isfinite(local_min) || !std::isfinite(local_max) || local_max <= local_min) { - Clear(); - return; - } + + // Update base class members + W = q_bins; + H = az_bins; + image_fp = profile; + + // Update foreground/background for color mapping + background = local_min; + foreground = local_max; + emit backgroundChanged(background); + emit foregroundChanged(foreground); + + // Generate pixmap and redraw using base class functionality + GeneratePixmap(); + Redraw(); } else { - if (!(std::isfinite(local_min) && std::isfinite(local_max) && local_max > local_min)) { - Clear(); - return; - } + Clear(); } - - phi = in_phi; - q = in_q; - - // Update base class members - W = q_bins; - H = azimuthal_bins; - image_fp = data; - - // Update foreground/background for color mapping - background = local_min; - foreground = local_max; - - // Generate pixmap and redraw using base class functionality - GeneratePixmap(); - Redraw(); } void JFJochAzIntImage::mouseHover(QMouseEvent* event) { - if (!scene() || W == 0 || H == 0) return; + if (!scene() || !image || W == 0 || H == 0) return; QPointF scenePos = mapToScene(event->pos()); int x = static_cast(scenePos.x()); @@ -86,10 +84,29 @@ void JFJochAzIntImage::mouseHover(QMouseEvent* event) { size_t idx = y * W + x; QString statusText = QString("Q: %1 Å^-1 phi: %2° value: %3") - .arg(QString::number(q[idx], 'f', 3)) - .arg(QString::number(phi[idx], 'f', 3)) + .arg(QString::number(image->Dataset().az_int_bin_to_q[idx], 'f', 3)) + .arg(QString::number(image->Dataset().az_int_bin_to_phi[idx], 'f', 3)) .arg(QString::number(image_fp[idx], 'f', 3)); emit writeStatusBar(statusText, 0); } -} \ No newline at end of file +} + +void JFJochAzIntImage::mouseDoubleClickEvent(QMouseEvent *event) { + if (!scene() || !image || W == 0 || H == 0) return; + + QPointF scenePos = mapToScene(event->pos()); + int x = static_cast(scenePos.x()); + int y = static_cast(scenePos.y()); + + if (x >= 0 && x < static_cast(W) && y >= 0 && y < static_cast(H)) { + size_t idx = y * W + x; + + float q = image->Dataset().az_int_bin_to_q[idx]; + float phi = image->Dataset().az_int_bin_to_phi[idx]; + + auto geom = image->Dataset().experiment.GetDiffractionGeometry(); + auto coord = geom.ResPhiToPxl(2 * M_PI / q, phi / 180.0 * M_PI); + emit zoomOnBin(QPointF(coord.first, coord.second)); + } +} diff --git a/viewer/widgets/JFJochAzIntImage.h b/viewer/widgets/JFJochAzIntImage.h index 3fbc52bf..e1e66362 100644 --- a/viewer/widgets/JFJochAzIntImage.h +++ b/viewer/widgets/JFJochAzIntImage.h @@ -12,7 +12,7 @@ #include #include "JFJochImage.h" -#include "../../common/ColorScale.h" +#include "../../reader/JFJochReaderImage.h" class JFJochAzIntImage : public JFJochImage { Q_OBJECT @@ -20,20 +20,17 @@ class JFJochAzIntImage : public JFJochImage { bool auto_range = true; float range_min = 0.0f; float range_max = 1.0f; - - std::vector data; - std::vector phi; - std::vector q; + std::shared_ptr image; void mouseHover(QMouseEvent* event) override; + void Clear(); + void mouseDoubleClickEvent(QMouseEvent *event) override; +signals: + void zoomOnBin(QPointF pos); +public slots: + void imageLoaded(std::shared_ptr image); public: explicit JFJochAzIntImage(QWidget *parent = nullptr); - void Clear(); - - void SetData(const std::vector &data, - const std::vector &phi, - const std::vector &q, - int azimuthal_bins); void SetRangeAuto(); void SetRange(float min_val, float max_val); diff --git a/viewer/windows/JFJoch2DAzintImageWindow.cpp b/viewer/windows/JFJoch2DAzintImageWindow.cpp new file mode 100644 index 00000000..b8f2277f --- /dev/null +++ b/viewer/windows/JFJoch2DAzintImageWindow.cpp @@ -0,0 +1,66 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#include +#include "JFJoch2DAzintImageWindow.h" + + +JFJoch2DAzintImageWindow::JFJoch2DAzintImageWindow(QWidget *parent) : JFJochHelperWindow(parent) { + QWidget *centralWidget = new QWidget(this); + setWindowTitle("2D azimuthal integration viewer"); + setCentralWidget(centralWidget); + + auto grid_layout = new QGridLayout(); + + viewer = new JFJochAzIntImage(this); + + background_slider = new SliderPlusBox(-100, 100, 1.0, 0, this, SliderPlusBox::ScaleType::Linear); + foreground_slider = new SliderPlusBox(1, 32768, 1.0, 0, this, SliderPlusBox::ScaleType::Logarithmic); + background_slider->setValue(0); + + auto background_row = new QHBoxLayout(); + auto foreground_row = new QHBoxLayout(); + background_row->addWidget(new QLabel("Background:")); + background_row->addWidget(background_slider); + foreground_row->addWidget(new QLabel("Foreground:")); + foreground_row->addWidget(foreground_slider); + + grid_layout->addLayout(background_row, 0, 0, 1, 2); + grid_layout->addLayout(foreground_row, 1, 0, 1, 2); + grid_layout->addWidget(viewer, 2, 0, 1, 2); + centralWidget->setLayout(grid_layout); + + connect(viewer, &JFJochAzIntImage::backgroundChanged, + [this](float val) { + QSignalBlocker blocker(background_slider); + background_slider->setValue(val); + }); + + connect(viewer, &JFJochAzIntImage::foregroundChanged, + [this](float val) { + QSignalBlocker blocker(foreground_slider); + foreground_slider->setValue(val); + }); + + connect(background_slider, &SliderPlusBox::valueChanged, viewer, &JFJochAzIntImage::changeBackground); + connect(foreground_slider, &SliderPlusBox::valueChanged, viewer, &JFJochAzIntImage::changeForeground); + + statusBar = new QStatusBar(this); + setStatusBar(statusBar); + + connect(viewer, &JFJochAzIntImage::writeStatusBar, + statusBar, &QStatusBar::showMessage); + connect(viewer, &JFJochAzIntImage::zoomOnBin, this, &JFJoch2DAzintImageWindow::viewerZoomOnBin); +} + +void JFJoch2DAzintImageWindow::viewerZoomOnBin(QPointF input) { + emit zoomOnBin(input); +} + +void JFJoch2DAzintImageWindow::imageLoaded(std::shared_ptr image) { + viewer->imageLoaded(std::move(image)); +} + +void JFJoch2DAzintImageWindow::setColorMap(int color_map) { + viewer->setColorMap(color_map); +} diff --git a/viewer/windows/JFJoch2DAzintImageWindow.h b/viewer/windows/JFJoch2DAzintImageWindow.h new file mode 100644 index 00000000..2c11ba1c --- /dev/null +++ b/viewer/windows/JFJoch2DAzintImageWindow.h @@ -0,0 +1,36 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#ifndef JFJOCH_JFJOCH2DAZINTIMAGEWINDOW_H +#define JFJOCH_JFJOCH2DAZINTIMAGEWINDOW_H + +#include + +#include "../widgets/SliderPlusBox.h" +#include "JFJochHelperWindow.h" +#include "../widgets/JFJochAzIntImage.h" + +class JFJoch2DAzintImageWindow : public JFJochHelperWindow { + Q_OBJECT + + SliderPlusBox *foreground_slider; + SliderPlusBox *background_slider; + + QStatusBar *statusBar; + + JFJochAzIntImage *viewer = nullptr; + +public: + JFJoch2DAzintImageWindow(QWidget *parent = nullptr); + +private slots: + void viewerZoomOnBin(QPointF); +signals: + void zoomOnBin(QPointF point); +public slots: + void imageLoaded(std::shared_ptr in_dataset) override; + void setColorMap(int color_map); +}; + + +#endif //JFJOCH_JFJOCH2DAZINTIMAGEWINDOW_H \ No newline at end of file -- 2.49.1 From 7608b93a0f2fec74a647fb9148e9fcd73e875a7e Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 17:24:47 +0100 Subject: [PATCH 04/13] jfjoch_viewer: Handle autocontrast better --- viewer/JFJochViewerWindow.cpp | 3 +++ viewer/toolbar/JFJochViewerToolbarDisplay.cpp | 18 ++++++++---------- viewer/toolbar/JFJochViewerToolbarDisplay.h | 1 + viewer/widgets/JFJochDiffractionImage.cpp | 9 ++++++++- viewer/widgets/JFJochDiffractionImage.h | 5 +++++ viewer/widgets/JFJochImage.h | 2 +- 6 files changed, 26 insertions(+), 12 deletions(-) diff --git a/viewer/JFJochViewerWindow.cpp b/viewer/JFJochViewerWindow.cpp index 603ca3ba..d128c6bd 100644 --- a/viewer/JFJochViewerWindow.cpp +++ b/viewer/JFJochViewerWindow.cpp @@ -153,6 +153,9 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString connect(toolBarDisplay, &JFJochViewerToolbarDisplay::setForeground, viewer, &JFJochDiffractionImage::changeForeground); + connect(viewer, &JFJochDiffractionImage::autoForegroundChanged, + toolBarDisplay, &JFJochViewerToolbarDisplay::updateAutoForeground); + connect(toolBarDisplay, &JFJochViewerToolbarDisplay::setAutoForeground, viewer, &JFJochDiffractionImage::setAutoForeground); diff --git a/viewer/toolbar/JFJochViewerToolbarDisplay.cpp b/viewer/toolbar/JFJochViewerToolbarDisplay.cpp index a0e03d52..fd8dd1b7 100644 --- a/viewer/toolbar/JFJochViewerToolbarDisplay.cpp +++ b/viewer/toolbar/JFJochViewerToolbarDisplay.cpp @@ -15,7 +15,7 @@ JFJochViewerToolbarDisplay::JFJochViewerToolbarDisplay(QWidget *parent) addWidget(foreground_slider); auto_foreground_button = new QPushButton("Auto"); auto_foreground_button->setCheckable(true); - auto_foreground_button->setChecked(auto_foreground); + auto_foreground_button->setChecked(false); addWidget(auto_foreground_button); addWidget(new QLabel("  Color map  ")); @@ -40,11 +40,6 @@ JFJochViewerToolbarDisplay::JFJochViewerToolbarDisplay(QWidget *parent) } void JFJochViewerToolbarDisplay::foregroundSet(double val) { - if (auto_foreground) { - auto_foreground = false; - auto_foreground_button->setChecked(false); - emit setAutoForeground(false); - } emit setForeground(static_cast(val)); } @@ -59,7 +54,10 @@ void JFJochViewerToolbarDisplay::colorComboBoxSet(int val) { void JFJochViewerToolbarDisplay::autoForegroundButtonPressed() { - auto_foreground = !auto_foreground; - auto_foreground_button->setChecked(auto_foreground); - emit setAutoForeground(auto_foreground); -} \ No newline at end of file + emit setAutoForeground(auto_foreground_button->isChecked()); +} + +void JFJochViewerToolbarDisplay::updateAutoForeground(bool val) { + QSignalBlocker blocker(auto_foreground_button); + auto_foreground_button->setChecked(val); +} diff --git a/viewer/toolbar/JFJochViewerToolbarDisplay.h b/viewer/toolbar/JFJochViewerToolbarDisplay.h index 782ec051..feaff257 100644 --- a/viewer/toolbar/JFJochViewerToolbarDisplay.h +++ b/viewer/toolbar/JFJochViewerToolbarDisplay.h @@ -28,6 +28,7 @@ signals: public slots: void updateForeground(float val); + void updateAutoForeground(bool val); private slots: void foregroundSet(double val); diff --git a/viewer/widgets/JFJochDiffractionImage.cpp b/viewer/widgets/JFJochDiffractionImage.cpp index 3b769e11..f8182c80 100644 --- a/viewer/widgets/JFJochDiffractionImage.cpp +++ b/viewer/widgets/JFJochDiffractionImage.cpp @@ -304,11 +304,12 @@ void JFJochDiffractionImage::loadImage(std::shared_ptr void JFJochDiffractionImage::setAutoForeground(bool input) { auto_fg = input; if (image && auto_fg) { - // If auto_foreground is not set, then view stays with the current settings till these are explicitely changed + // If auto_foreground is not set, then view stays with the current settings till these are explicitly changed foreground = image->GetAutoContrastValue(); emit foregroundChanged(foreground); Redraw(); } + emit autoForegroundChanged(auto_fg); } void JFJochDiffractionImage::setResolutionRing(QVector v) { @@ -376,3 +377,9 @@ void JFJochDiffractionImage::highlightIceRings(bool input) { highlight_ice_rings = input; updateOverlay(); } + +void JFJochDiffractionImage::changeForeground(float val) { + auto_fg = false; + emit autoForegroundChanged(false); + JFJochImage::changeForeground(val); +} diff --git a/viewer/widgets/JFJochDiffractionImage.h b/viewer/widgets/JFJochDiffractionImage.h index 919deb2f..b51e429b 100644 --- a/viewer/widgets/JFJochDiffractionImage.h +++ b/viewer/widgets/JFJochDiffractionImage.h @@ -43,6 +43,10 @@ private: float ice_ring_width_Q_recipA = 0.01; void mouseHover(QMouseEvent* event) override; + +signals: + void autoForegroundChanged(bool input); + public slots: void loadImage(std::shared_ptr image); void setAutoForeground(bool input); @@ -59,5 +63,6 @@ public slots: void showSaturation(bool input); void highlightIceRings(bool input); + void changeForeground(float val) override; }; diff --git a/viewer/widgets/JFJochImage.h b/viewer/widgets/JFJochImage.h index 7e7e9539..57340932 100644 --- a/viewer/widgets/JFJochImage.h +++ b/viewer/widgets/JFJochImage.h @@ -73,7 +73,7 @@ private slots: public slots: void setFeatureColor(QColor input); void setColorMap(int color_map); - void changeForeground(float val); + virtual void changeForeground(float val); void changeBackground(float val); void SetROIBox(QRect box); -- 2.49.1 From 8664c3f2c40a0a1621d479705ae9cdd27a29f472 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 17:53:39 +0100 Subject: [PATCH 05/13] jfjoch_viewer: Add vertical bar to the plots --- viewer/JFJochViewerSidePanel.cpp | 4 + viewer/JFJochViewerSidePanel.h | 1 + viewer/JFJochViewerSidePanelChart.cpp | 8 ++ viewer/JFJochViewerSidePanelChart.h | 3 + viewer/JFJochViewerWindow.cpp | 2 + .../widgets/JFJochOneOverResSqChartView.cpp | 22 ++++- viewer/widgets/JFJochOneOverResSqChartView.h | 2 + viewer/widgets/JFJochSimpleChartView.cpp | 81 ++++++++++++++++++- viewer/widgets/JFJochSimpleChartView.h | 7 ++ 9 files changed, 128 insertions(+), 2 deletions(-) diff --git a/viewer/JFJochViewerSidePanel.cpp b/viewer/JFJochViewerSidePanel.cpp index f5bf49ea..8a4b94c3 100644 --- a/viewer/JFJochViewerSidePanel.cpp +++ b/viewer/JFJochViewerSidePanel.cpp @@ -116,6 +116,10 @@ JFJochViewerSidePanel::JFJochViewerSidePanel(QWidget *parent) : QWidget(parent) connect(this, &JFJochViewerSidePanel::imageLoaded, chart, &JFJochViewerSidePanelChart::loadImage); + connect(chart, &JFJochViewerSidePanelChart::writeStatusBar, + [&] (QString string, int timeout_ms) { + emit writeStatusBar(string, timeout_ms); + }); layout->addWidget(new TitleLabel("ROI", this)); diff --git a/viewer/JFJochViewerSidePanel.h b/viewer/JFJochViewerSidePanel.h index b46e4f35..38a8d6a8 100644 --- a/viewer/JFJochViewerSidePanel.h +++ b/viewer/JFJochViewerSidePanel.h @@ -47,6 +47,7 @@ signals: void ROICircleConfigured(double center_x, double center_y, double radius); void AddROIToUserMask(); void SubtractROIFromUserMask(); + void writeStatusBar(QString string, int timeout_ms = 0); public: JFJochViewerSidePanel(QWidget *parent); public slots: diff --git a/viewer/JFJochViewerSidePanelChart.cpp b/viewer/JFJochViewerSidePanelChart.cpp index b297f0af..1dcf155b 100644 --- a/viewer/JFJochViewerSidePanelChart.cpp +++ b/viewer/JFJochViewerSidePanelChart.cpp @@ -81,6 +81,14 @@ void JFJochViewerSidePanelChart::redrawPlot() { break; } } + connect(azint_plot, &JFJochSimpleChartView::writeStatusBar, + [&](QString string, int timeout_ms) { + emit writeStatusBar(string, timeout_ms); + }); + connect(one_over_d_sq_plot, &JFJochSimpleChartView::writeStatusBar, + [&](QString string, int timeout_ms) { + emit writeStatusBar(string, timeout_ms); + }); } void JFJochViewerSidePanelChart::loadImage(std::shared_ptr in_image) { diff --git a/viewer/JFJochViewerSidePanelChart.h b/viewer/JFJochViewerSidePanelChart.h index 1515e922..84741359 100644 --- a/viewer/JFJochViewerSidePanelChart.h +++ b/viewer/JFJochViewerSidePanelChart.h @@ -24,6 +24,9 @@ class JFJochViewerSidePanelChart : public QWidget { QComboBox *combo_box; void redrawPlot(); +signals: + void writeStatusBar(QString string, int timeout_ms = 0); + private slots: void comboBoxSelected(int val); diff --git a/viewer/JFJochViewerWindow.cpp b/viewer/JFJochViewerWindow.cpp index d128c6bd..f5966672 100644 --- a/viewer/JFJochViewerWindow.cpp +++ b/viewer/JFJochViewerWindow.cpp @@ -286,6 +286,8 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString viewer, &JFJochDiffractionImage::setResolutionRing); connect(viewer, &JFJochDiffractionImage::writeStatusBar, statusbar, &JFJochViewerStatusBar::display); + connect(side_panel, &JFJochViewerSidePanel::writeStatusBar, + statusbar, &JFJochViewerStatusBar::display); connect(metadataWindow, &JFJochViewerMetadataWindow::datasetUpdated, reading_worker, &JFJochImageReadingWorker::UpdateDataset); diff --git a/viewer/widgets/JFJochOneOverResSqChartView.cpp b/viewer/widgets/JFJochOneOverResSqChartView.cpp index eae8a56f..d1309384 100644 --- a/viewer/widgets/JFJochOneOverResSqChartView.cpp +++ b/viewer/widgets/JFJochOneOverResSqChartView.cpp @@ -13,7 +13,17 @@ JFJochOneOverResSqChartView::JFJochOneOverResSqChartView (QWidget *parent) void JFJochOneOverResSqChartView::UpdateData(const std::vector &in_x, const std::vector &in_y, QString legend_x, QString legend_y) { - x = in_x; y = in_y; + x = in_x; + y = in_y; + + // Remove hover line if any + if (m_hoverLine) { + chart()->scene()->removeItem(m_hoverLine); + delete m_hoverLine; + m_hoverLine = nullptr; + } + m_series = nullptr; + chart()->removeAllSeries(); // Remove all axes to avoid duplicates for (auto ax : chart()->axes()) chart()->removeAxis(ax); @@ -26,6 +36,7 @@ void JFJochOneOverResSqChartView::UpdateData(const std::vector &in_x, con auto* series = new QLineSeries(this); for (size_t i = 0; i < x.size(); ++i) series->append(x[i], y[i]); chart()->addSeries(series); + m_series = series; auto* axY = new QValueAxis(); axY->setTitleText(legend_y); @@ -65,3 +76,12 @@ void JFJochOneOverResSqChartView::UpdateData(const std::vector &in_x, con chart()->addAxis(axXcat, Qt::AlignBottom); series->attachAxis(axXcat); } + +QString JFJochOneOverResSqChartView::getText(size_t idx) { + if (idx < x.size() && x[idx] > 0) + return QString("d = %1 Å, y = %2") + .arg(1 / sqrt(x[idx]), 0, 'g', 4) + .arg(y[idx], 0, 'g', 6); + return QString(); +} + diff --git a/viewer/widgets/JFJochOneOverResSqChartView.h b/viewer/widgets/JFJochOneOverResSqChartView.h index 51891190..c418ac2c 100644 --- a/viewer/widgets/JFJochOneOverResSqChartView.h +++ b/viewer/widgets/JFJochOneOverResSqChartView.h @@ -12,6 +12,8 @@ class JFJochOneOverResSqChartView : public JFJochSimpleChartView { Q_OBJECT + + QString getText(size_t idx) override; public: JFJochOneOverResSqChartView(QWidget *parent = nullptr); diff --git a/viewer/widgets/JFJochSimpleChartView.cpp b/viewer/widgets/JFJochSimpleChartView.cpp index b0254bdb..0a9303f3 100644 --- a/viewer/widgets/JFJochSimpleChartView.cpp +++ b/viewer/widgets/JFJochSimpleChartView.cpp @@ -13,6 +13,7 @@ JFJochSimpleChartView::JFJochSimpleChartView(QWidget *parent) chart()->legend()->hide(); setFixedHeight(300); setRenderHint(QPainter::Antialiasing); + setMouseTracking(true); //setRubberBand(QChartView::RubberBand::HorizontalRubberBand); } @@ -20,6 +21,15 @@ void JFJochSimpleChartView::UpdateData(const std::vector &in_x, const std QString legend_x, QString legend_y) { x = in_x; y = in_y; + + // Remove hover line if any + if (m_hoverLine) { + chart()->scene()->removeItem(m_hoverLine); + delete m_hoverLine; + m_hoverLine = nullptr; + } + m_series = nullptr; + chart()->removeAllSeries(); // Remove all axes to avoid duplicates for (auto ax: chart()->axes()) chart()->removeAxis(ax); @@ -29,6 +39,7 @@ void JFJochSimpleChartView::UpdateData(const std::vector &in_x, const std auto *series = new QLineSeries(this); for (size_t i = 0; i < x.size(); ++i) series->append(x[i], y[i]); chart()->addSeries(series); + m_series = series; auto *axY = new QValueAxis(); axY->setTitleText(legend_y); @@ -45,10 +56,17 @@ void JFJochSimpleChartView::UpdateData(const std::vector &in_x, const std axX->setTitleText(legend_x); chart()->addAxis(axX, Qt::AlignBottom); series->attachAxis(axX); - } void JFJochSimpleChartView::ClearData() { + x.clear(); + y.clear(); + m_series = nullptr; + if (m_hoverLine) { + chart()->scene()->removeItem(m_hoverLine); + delete m_hoverLine; + m_hoverLine = nullptr; + } chart()->removeAllSeries(); } @@ -71,3 +89,64 @@ void JFJochSimpleChartView::contextMenuEvent(QContextMenuEvent *event) { cb->setText(out); } } + +void JFJochSimpleChartView::mouseMoveEvent(QMouseEvent *event) { + QChartView::mouseMoveEvent(event); + if (!m_series || x.empty() || x.size() != y.size()) + return; + + // Map mouse position to chart coordinates + const QPointF chartPos = chart()->mapToValue(event->pos(), m_series); + const double xVal = chartPos.x(); + + // Find closest index in x[] + auto it = std::lower_bound(x.begin(), x.end(), static_cast(xVal)); + if (it == x.end() && !x.empty()) + it = std::prev(x.end()); + if (it == x.end()) + return; + + size_t idx = static_cast(std::distance(x.begin(), it)); + if (idx > 0) { + const float xPrev = x[idx - 1]; + if (std::abs(xPrev - xVal) < std::abs(x[idx] - xVal)) + --idx; + } + + const float xNearest = x[idx]; + const float yNearest = y[idx]; + + // Map that data point to scene coords to get the x position + const QPointF ptOnSeries = chart()->mapToPosition(QPointF(xNearest, yNearest), m_series); + const QRectF plotArea = chart()->plotArea(); + + if (!m_hoverLine) { + m_hoverLine = new QGraphicsLineItem; + m_hoverLine->setPen(QPen(QColor(200, 0, 0, 150), 1.0)); + chart()->scene()->addItem(m_hoverLine); + } + + m_hoverLine->setLine(QLineF(ptOnSeries.x(), plotArea.top(), + ptOnSeries.x(), plotArea.bottom())); + + // Send to status bar + emit writeStatusBar(getText(idx),6000); +} + +QString JFJochSimpleChartView::getText(size_t idx) { + if (idx < x.size()) + return QString("x = %1, y = %2") + .arg(x[idx], 0, 'g', 6) + .arg(y[idx], 0, 'g', 6); + return QString(); +} + +void JFJochSimpleChartView::leaveEvent(QEvent *event) { + QChartView::leaveEvent(event); + if (m_hoverLine) { + chart()->scene()->removeItem(m_hoverLine); + delete m_hoverLine; + m_hoverLine = nullptr; + } + emit writeStatusBar(QString(), 0); // clear status bar when leaving +} diff --git a/viewer/widgets/JFJochSimpleChartView.h b/viewer/widgets/JFJochSimpleChartView.h index 033a9d33..86e680f1 100644 --- a/viewer/widgets/JFJochSimpleChartView.h +++ b/viewer/widgets/JFJochSimpleChartView.h @@ -11,10 +11,17 @@ class JFJochSimpleChartView : public QChartView { Q_OBJECT +signals: + void writeStatusBar(QString string, int timeout_ms = 0); protected: + QLineSeries *m_series = nullptr; + QGraphicsLineItem *m_hoverLine = nullptr; void contextMenuEvent(QContextMenuEvent *event) override; + void mouseMoveEvent(QMouseEvent *event) override; + void leaveEvent(QEvent *event) override; std::vector x, y; + virtual QString getText(size_t idx); public: JFJochSimpleChartView(QWidget *parent = nullptr); -- 2.49.1 From 8b809e56090ee59019183ad1b4694c65fb28e34f Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 17:55:33 +0100 Subject: [PATCH 06/13] jfjoch_viewer: Remove emoji from toolbar (these are rendered very differently on different OS) --- viewer/toolbar/JFJochViewerToolbarImage.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/viewer/toolbar/JFJochViewerToolbarImage.cpp b/viewer/toolbar/JFJochViewerToolbarImage.cpp index 0375726c..033daf93 100644 --- a/viewer/toolbar/JFJochViewerToolbarImage.cpp +++ b/viewer/toolbar/JFJochViewerToolbarImage.cpp @@ -56,12 +56,12 @@ JFJochViewerToolbarImage::JFJochViewerToolbarImage(QWidget *parent) : QToolBar(p image_number_slider_timer->setSingleShot(true); - movie_button = new QPushButton("Movie ▶"); + movie_button = new QPushButton("Movie"); movie_button->setCheckable(true); movie_button->setChecked(false); addWidget(movie_button); - autoload_button = new QPushButton("Sync 🔄"); + autoload_button = new QPushButton("Online"); autoload_button->setCheckable(true); autoload_button->setChecked(false); addWidget(autoload_button); -- 2.49.1 From 6f3c7348ca83cb983f31ed8cd49428c2067b6043 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 20:20:19 +0100 Subject: [PATCH 07/13] jfjoch_viewer: ROI calculated inside image viewer --- common/JFJochMessages.h | 1 + reader/JFJochReaderImage.cpp | 45 +---------- reader/JFJochReaderImage.h | 8 -- viewer/JFJochImageReadingWorker.cpp | 21 +---- viewer/JFJochImageReadingWorker.h | 1 - viewer/JFJochViewerImageROIStatistics.cpp | 56 +++++++------- viewer/JFJochViewerImageROIStatistics.h | 3 +- viewer/JFJochViewerSidePanel.cpp | 5 +- viewer/JFJochViewerSidePanel.h | 1 + viewer/JFJochViewerWindow.cpp | 3 + viewer/widgets/JFJochImage.cpp | 93 ++++++++++++++++++++++- viewer/widgets/JFJochImage.h | 10 ++- 12 files changed, 140 insertions(+), 107 deletions(-) diff --git a/common/JFJochMessages.h b/common/JFJochMessages.h index 55afd02f..58403e6f 100644 --- a/common/JFJochMessages.h +++ b/common/JFJochMessages.h @@ -69,6 +69,7 @@ struct ROIMessage { uint64_t sum_square; int64_t max_count; uint64_t pixels; + uint64_t pixels_masked; // only used in the viewer for now int64_t x_weighted; int64_t y_weighted; }; diff --git a/reader/JFJochReaderImage.cpp b/reader/JFJochReaderImage.cpp index 3a4e8087..49aacd89 100644 --- a/reader/JFJochReaderImage.cpp +++ b/reader/JFJochReaderImage.cpp @@ -23,8 +23,7 @@ JFJochReaderImage::JFJochReaderImage(const JFJochReaderImage &other) message(other.message), saturated_pixel(other.saturated_pixel), error_pixel(other.error_pixel), - valid_pixel(other.valid_pixel), - roi(other.roi) { + valid_pixel(other.valid_pixel) { // Need to make image use local copy message.image = CompressedImage(image, dataset->experiment.GetXPixelsNum(), dataset->experiment.GetYPixelsNum()); @@ -201,48 +200,6 @@ void JFJochReaderImage::AddImage(const JFJochReaderImage &other) { CalcAutoContrast(); } -void JFJochReaderImage::CalcROI(const ROIElement *input) { - std::unique_lock ul(roi_mutex); - - if (!input) { - roi = {}; - return; - } - - int64_t width = dataset->experiment.GetXPixelsNum(); - int64_t height = dataset->experiment.GetYPixelsNum(); - - int64_t roi_val = 0; - uint64_t roi_val_2 = 0; - int64_t roi_max = INT64_MIN; - uint64_t roi_npixel = 0; - - for (int64_t y = 0; y < height; y++) { - for (int64_t x = 0; x < width; x++) { - int32_t val = image[x + width * y]; - if (input->CheckROI(x, y, 0.0) && (val != SATURATED_PXL_VALUE) - && (val != ERROR_PXL_VALUE) && (val != GAP_PXL_VALUE)) { - roi_val += val; - roi_val_2 += val * val; - if (val > roi_max) roi_max = val; - roi_npixel++; - } - } - } - - roi = ROIMessage{ - .sum = roi_val, - .sum_square = roi_val_2, - .max_count = roi_max, - .pixels = roi_npixel - }; -} - -const std::optional &JFJochReaderImage::GetROI() const { - std::unique_lock ul(roi_mutex); - return roi; -} - std::vector JFJochReaderImage::GetAzInt1D() const { if (dataset->azimuthal_bins <= 1) { return message.az_int_profile; diff --git a/reader/JFJochReaderImage.h b/reader/JFJochReaderImage.h index fc4c57c6..88073af2 100644 --- a/reader/JFJochReaderImage.h +++ b/reader/JFJochReaderImage.h @@ -25,8 +25,6 @@ class JFJochReaderImage { std::unordered_set saturated_pixel; std::unordered_set error_pixel; std::vector> valid_pixel; - std::optional roi; - mutable std::mutex roi_mutex; constexpr static float auto_foreground_range = 0.001f; int32_t auto_foreground; @@ -48,15 +46,9 @@ public: const std::vector> &ValidPixels() const; const JFJochReaderDataset &Dataset() const; - const std::optional &GetROI() const; - void AddImage(const JFJochReaderImage& other); std::vector GetAzInt1D() const; std::vector GetAzInt1D_BinToQ() const; - - // Functions that change the content - void CalcROI(const ROIElement *input); - std::shared_ptr CreateMutableDataset(); int32_t GetAutoContrastValue() const; diff --git a/viewer/JFJochImageReadingWorker.cpp b/viewer/JFJochImageReadingWorker.cpp index 1b21e29f..9e68e6dc 100644 --- a/viewer/JFJochImageReadingWorker.cpp +++ b/viewer/JFJochImageReadingWorker.cpp @@ -98,13 +98,6 @@ void JFJochImageReadingWorker::LoadImage(int64_t image_number, int64_t summation LoadImage_i(image_number, summation); } -void JFJochImageReadingWorker::CalcROI_i() { - if (current_image_ptr) { - if (roi) - current_image_ptr->CalcROI(roi.get()); - } -} - void JFJochImageReadingWorker::UpdateAzint_i(const JFJochReaderDataset *dataset) { if (dataset) { azint_mapping = std::make_unique(curr_experiment, dataset->pixel_mask); @@ -143,8 +136,6 @@ void JFJochImageReadingWorker::LoadImage_i(int64_t image_number, int64_t summati auto end = std::chrono::high_resolution_clock::now(); - CalcROI_i(); - if (auto_reanalyze) ReanalyzeImage_i(); @@ -168,11 +159,6 @@ void JFJochImageReadingWorker::SetROIBox(QRect box) { roi.reset(); roi = std::make_unique("roi1", box.left(), box.right(), box.bottom(), box.top()); - - if (current_image_ptr) { - current_image_ptr->CalcROI(roi.get()); - emit imageStatsUpdated(current_image_ptr); - } } void JFJochImageReadingWorker::SetROICircle(double x, double y, double radius) { @@ -182,11 +168,6 @@ void JFJochImageReadingWorker::SetROICircle(double x, double y, double radius) { roi.reset(); else roi = std::make_unique("roi1", x, y, radius); - - if (current_image_ptr) { - current_image_ptr->CalcROI(roi.get()); - emit imageStatsUpdated(current_image_ptr); - } } void JFJochImageReadingWorker::UpdateDataset_i(const std::optional &experiment) { @@ -212,7 +193,7 @@ void JFJochImageReadingWorker::UpdateDataset_i(const std::optional(current_image_ptr->ImageData(), dataset); - CalcROI_i(); + if (auto_reanalyze) ReanalyzeImage_i(); emit imageLoaded(current_image_ptr); diff --git a/viewer/JFJochImageReadingWorker.h b/viewer/JFJochImageReadingWorker.h index f929034d..0c70f1bf 100644 --- a/viewer/JFJochImageReadingWorker.h +++ b/viewer/JFJochImageReadingWorker.h @@ -69,7 +69,6 @@ private: int autoload_interval = 500; // milliseconds void LoadImage_i(int64_t image_number, int64_t summation); - void CalcROI_i(); void ReanalyzeImage_i(); void UpdateDataset_i(const std::optional& experiment); void UpdateAzint_i(const JFJochReaderDataset *dataset); diff --git a/viewer/JFJochViewerImageROIStatistics.cpp b/viewer/JFJochViewerImageROIStatistics.cpp index e7756223..2c1451f5 100644 --- a/viewer/JFJochViewerImageROIStatistics.cpp +++ b/viewer/JFJochViewerImageROIStatistics.cpp @@ -39,19 +39,24 @@ JFJochViewerImageROIStatistics::JFJochViewerImageROIStatistics(QWidget *parent) circle_settings->Disable(); box_radio->setChecked(true); - QHBoxLayout *label_row = new QHBoxLayout(); + QHBoxLayout *label_row_1 = new QHBoxLayout(); + QHBoxLayout *label_row_2 = new QHBoxLayout(); roi_sum = new QLabel("", this); - label_row->addWidget(roi_sum); + label_row_1->addWidget(roi_sum); roi_mean = new QLabel("", this); - label_row->addWidget(roi_mean); + label_row_1->addWidget(roi_mean); roi_var = new QLabel("", this); - label_row->addWidget(roi_var); + label_row_1->addWidget(roi_var); roi_max = new QLabel("", this); - label_row->addWidget(roi_max); + label_row_1->addWidget(roi_max); roi_npixel = new QLabel("", this); - label_row->addWidget(roi_npixel); - layout->addLayout(label_row); + label_row_2->addWidget(roi_npixel); + roi_masked = new QLabel("", this); + label_row_2->addWidget(roi_masked); + + layout->addLayout(label_row_1); + layout->addLayout(label_row_2); QPushButton *add_button = new QPushButton("Add ROI to user mask", this); connect(add_button, &QPushButton::clicked, [this]() { emit AddROIToUserMask(); }); @@ -68,36 +73,29 @@ JFJochViewerImageROIStatistics::JFJochViewerImageROIStatistics(QWidget *parent) } -void JFJochViewerImageROIStatistics::loadImage(std::shared_ptr image) { - if (!image) { +void JFJochViewerImageROIStatistics::SetROIResult(ROIMessage roi) { + if ( roi.pixels > 0) { + auto roi_npixel_val = static_cast(roi.pixels); + double roi_mean_val = static_cast(roi.sum) / roi_npixel_val; + double variance = static_cast(roi.sum_square) / roi_npixel_val - roi_mean_val * roi_mean_val; + + roi_sum->setText(QString("Sum %1").arg(roi.sum)); + roi_mean->setText(QString("Mean %1").arg(QString::number(roi_mean_val, 'f', 3))); + roi_var->setText(QString("Var %1").arg(QString::number(variance, 'f', 3))); + roi_max->setText(QString("Max %1").arg(roi.max_count)); + roi_npixel->setText(QString("Pixels %1").arg(roi.pixels)); + roi_masked->setText(QString("Masked %1").arg(roi.pixels_masked)); + } else { roi_sum->setText(""); roi_mean->setText(""); roi_var->setText(""); roi_max->setText(""); roi_npixel->setText(""); - } else { - auto roi = image->GetROI(); - - if (roi && roi->pixels > 0) { - auto roi_npixel_val = static_cast(roi->pixels); - double roi_mean_val = static_cast(roi->sum) / roi_npixel_val; - double variance = static_cast(roi->sum_square) / roi_npixel_val - roi_mean_val * roi_mean_val; - - roi_sum->setText(QString("Sum %1").arg(roi->sum)); - roi_mean->setText(QString("Mean %1").arg(QString::number(roi_mean_val, 'f', 3))); - roi_var->setText(QString("Var %1").arg(QString::number(variance, 'f', 3))); - roi_max->setText(QString("Max %1").arg(roi->max_count)); - roi_npixel->setText(QString("Pixels %1").arg(roi->pixels)); - } else { - roi_sum->setText(""); - roi_mean->setText(""); - roi_var->setText(""); - roi_max->setText(""); - roi_npixel->setText(""); - } + roi_masked->setText(""); } } + void JFJochViewerImageROIStatistics::SetROIBox(QRect box) { box_radio->setChecked(true); box_settings->ROIBoxConfigured(box); diff --git a/viewer/JFJochViewerImageROIStatistics.h b/viewer/JFJochViewerImageROIStatistics.h index e5ebed96..151fedae 100644 --- a/viewer/JFJochViewerImageROIStatistics.h +++ b/viewer/JFJochViewerImageROIStatistics.h @@ -30,15 +30,16 @@ class JFJochViewerImageROIStatistics : public QWidget { QLabel *roi_var; QLabel *roi_max; QLabel *roi_npixel; + QLabel *roi_masked; public: JFJochViewerImageROIStatistics(QWidget *parent); private slots: void BoxButtonClicked(); void CircleButtonClicked(); public slots: - void loadImage(std::shared_ptr image); void SetROIBox(QRect box); void SetROICircle(double x, double y, double radius); + void SetROIResult(ROIMessage msg); signals: void ROIBoxConfigured(QRect box); // Signal emitted when Box ROI is set void ROICircleConfigured(double center_x, double center_y, double radius); // Signal emitted when Circle ROI is set diff --git a/viewer/JFJochViewerSidePanel.cpp b/viewer/JFJochViewerSidePanel.cpp index 8a4b94c3..babf3348 100644 --- a/viewer/JFJochViewerSidePanel.cpp +++ b/viewer/JFJochViewerSidePanel.cpp @@ -125,7 +125,6 @@ JFJochViewerSidePanel::JFJochViewerSidePanel(QWidget *parent) : QWidget(parent) roi = new JFJochViewerImageROIStatistics(this); layout->addWidget(roi); - connect(this, &JFJochViewerSidePanel::imageLoaded, roi, &JFJochViewerImageROIStatistics::loadImage); connect(roi, &JFJochViewerImageROIStatistics::ROIBoxConfigured, [this] (QRect box) { emit ROIBoxConfigured(box); @@ -321,3 +320,7 @@ void JFJochViewerSidePanel::SetROIBox(QRect box) { void JFJochViewerSidePanel::SetROICircle(double x, double y, double radius) { roi->SetROICircle(x, y, radius); } + +void JFJochViewerSidePanel::SetROIResult(ROIMessage msg) { + roi->SetROIResult(msg); +} diff --git a/viewer/JFJochViewerSidePanel.h b/viewer/JFJochViewerSidePanel.h index 38a8d6a8..005db794 100644 --- a/viewer/JFJochViewerSidePanel.h +++ b/viewer/JFJochViewerSidePanel.h @@ -54,6 +54,7 @@ public slots: void loadImage(std::shared_ptr image); void SetROIBox(QRect box); void SetROICircle(double x, double y, double radius); + void SetROIResult(ROIMessage msg); private slots: void editingFinished(); void enableResRings(bool input); diff --git a/viewer/JFJochViewerWindow.cpp b/viewer/JFJochViewerWindow.cpp index f5966672..efd01417 100644 --- a/viewer/JFJochViewerWindow.cpp +++ b/viewer/JFJochViewerWindow.cpp @@ -183,6 +183,9 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString connect(viewer, &JFJochDiffractionImage::roiCircleUpdated, side_panel, &JFJochViewerSidePanel::SetROICircle); + connect(viewer, &JFJochDiffractionImage::roiCalculated, + side_panel, &JFJochViewerSidePanel::SetROIResult); + connect(side_panel, &JFJochViewerSidePanel::ROIBoxConfigured, reading_worker, &JFJochImageReadingWorker::SetROIBox); diff --git a/viewer/widgets/JFJochImage.cpp b/viewer/widgets/JFJochImage.cpp index 147eb8d8..a0f3dab9 100644 --- a/viewer/widgets/JFJochImage.cpp +++ b/viewer/widgets/JFJochImage.cpp @@ -23,6 +23,9 @@ JFJochImage::JFJochImage(QWidget *parent) : QGraphicsView(parent) { // Optional: a sensible default colormap color_scale.Select(ColorScaleEnum::Indigo); + + connect(this, &JFJochImage::roiBoxUpdated, this, &JFJochImage::CalcROIBox); + connect(this, &JFJochImage::roiCircleUpdated, this, &JFJochImage::CalcROICircle); } void JFJochImage::onScroll(int value) { @@ -575,7 +578,7 @@ void JFJochImage::writePixelLabels() { } void JFJochImage::updateOverlay() { - if (!scene() || W*H <= 0) return; + if (!scene() || W * H <= 0) return; scene()->clear(); scene()->addItem(new QGraphicsPixmapItem(pixmap)); @@ -583,10 +586,96 @@ void JFJochImage::updateOverlay() { if (scale_factor > 30.0) writePixelLabels(); - DrawROI(); addCustomOverlay(); } void JFJochImage::addCustomOverlay() {} + +ROIMessage JFJochImage::accumulateROI( + int64_t xmin, int64_t xmax, + int64_t ymin, int64_t ymax, + const std::function &inside) { + int64_t roi_val = 0; + uint64_t roi_val_2 = 0; + int64_t roi_max = INT64_MIN; + uint64_t roi_npixel = 0; + uint64_t roi_npixel_masked = 0; + float x_weighted = 0.0f; + float y_weighted = 0.0f; + + // Clamp bounds defensively to the image + xmin = std::max(0, xmin); + ymin = std::max(0, ymin); + xmax = std::min(W, xmax); + ymax = std::min(H, ymax); + + for (int64_t y = ymin; y < ymax; ++y) { + for (int64_t x = xmin; x < xmax; ++x) { + if (!inside(x, y)) continue; + + float val = image_fp[x + W * y]; + + if (std::isinf(val)) { + roi_npixel_masked++; + } else if (std::isfinite(val)) { + x_weighted += val * x; + y_weighted += val * y; + roi_val += val; + roi_val_2 += val * val; + if (val > roi_max) roi_max = val; + roi_npixel++; + } + } + } + + return ROIMessage{ + .sum = roi_val, + .sum_square = roi_val_2, + .max_count = roi_max, + .pixels = roi_npixel, + .pixels_masked = roi_npixel_masked, + .x_weighted = std::lroundf(x_weighted), + .y_weighted = std::lroundf(y_weighted), + }; +} + +void JFJochImage::CalcROIBox(QRect box) { + auto box_norm = box.normalized(); + + // Using the rectangle as-is; you can adjust inclusivity if needed + int64_t xmin = box_norm.left(); + int64_t xmax = box_norm.right(); + int64_t ymin = box_norm.top(); + int64_t ymax = box_norm.bottom(); + + ROIMessage msg = accumulateROI( + xmin, xmax, ymin, ymax, + [](int64_t, int64_t) { return true; } // everything in the rectangle + ); + emit roiCalculated(msg); +} + +void JFJochImage::CalcROICircle(double in_x, double in_y, double radius) { + const double margin = 1.0; + int64_t xmin = static_cast(std::floor(in_x - radius - margin)); + int64_t xmax = static_cast(std::ceil(in_x + radius + margin)); + int64_t ymin = static_cast(std::floor(in_y - radius - margin)); + int64_t ymax = static_cast(static_cast(std::ceil(in_y + radius + margin))); + + const float cx = static_cast(in_x); + const float cy = static_cast(in_y); + const float r2 = static_cast(radius * radius); + + ROIMessage msg = accumulateROI( + xmin, xmax, ymin, ymax, + [cx, cy, r2](int64_t x, int64_t y) { + const float dx = static_cast(x) - cx; + const float dy = static_cast(y) - cy; + const float dist2 = dx * dx + dy * dy; + return dist2 <= r2; + } + ); + emit roiCalculated(msg); +} diff --git a/viewer/widgets/JFJochImage.h b/viewer/widgets/JFJochImage.h index 57340932..846b3d1f 100644 --- a/viewer/widgets/JFJochImage.h +++ b/viewer/widgets/JFJochImage.h @@ -6,6 +6,9 @@ #include #include #include "../../common/ColorScale.h" +#include "../../common/JFJochMessages.h" + +// Q_DECLARE_METATYPE(ROIMessage) class JFJochImage : public QGraphicsView { Q_OBJECT @@ -20,6 +23,9 @@ class JFJochImage : public QGraphicsView { void mousePressEvent(QMouseEvent *event) override; void mouseMoveEvent(QMouseEvent *event) override; void mouseReleaseEvent(QMouseEvent *event) override; + + ROIMessage accumulateROI(int64_t xmin, int64_t xmax, int64_t ymin, int64_t ymax, + const std::function& inside); protected: bool show_saturation = false; @@ -67,9 +73,11 @@ signals: void writeStatusBar(QString string, int timeout_ms = 0); void roiBoxUpdated(QRect box); void roiCircleUpdated(double x, double y, double radius); - + void roiCalculated(ROIMessage &output); private slots: void onScroll(int value); + void CalcROIBox(QRect box); + void CalcROICircle(double x, double y, double radius); public slots: void setFeatureColor(QColor input); void setColorMap(int color_map); -- 2.49.1 From ac62f50707cc9a855260703b2d405008b1efb71e Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 20:32:25 +0100 Subject: [PATCH 08/13] jfjoch_viewer: Handle better ROI result --- viewer/CMakeLists.txt | 2 + viewer/JFJochViewerImageROIStatistics.cpp | 40 ++--------------- viewer/JFJochViewerImageROIStatistics.h | 9 ++-- viewer/JFJochViewerROIResult.cpp | 54 +++++++++++++++++++++++ viewer/JFJochViewerROIResult.h | 30 +++++++++++++ 5 files changed, 92 insertions(+), 43 deletions(-) create mode 100644 viewer/JFJochViewerROIResult.cpp create mode 100644 viewer/JFJochViewerROIResult.h diff --git a/viewer/CMakeLists.txt b/viewer/CMakeLists.txt index ca14bfc9..d5a78be5 100644 --- a/viewer/CMakeLists.txt +++ b/viewer/CMakeLists.txt @@ -75,6 +75,8 @@ ADD_EXECUTABLE(jfjoch_viewer jfjoch_viewer.cpp JFJochViewerWindow.cpp JFJochView windows/JFJochAzIntWindow.h windows/JFJoch2DAzintImageWindow.cpp windows/JFJoch2DAzintImageWindow.h + JFJochViewerROIResult.cpp + JFJochViewerROIResult.h ) TARGET_LINK_LIBRARIES(jfjoch_viewer Qt6::Core Qt6::Gui Qt6::Widgets Qt6::Charts Qt6::DBus diff --git a/viewer/JFJochViewerImageROIStatistics.cpp b/viewer/JFJochViewerImageROIStatistics.cpp index 2c1451f5..66ea26a0 100644 --- a/viewer/JFJochViewerImageROIStatistics.cpp +++ b/viewer/JFJochViewerImageROIStatistics.cpp @@ -39,24 +39,8 @@ JFJochViewerImageROIStatistics::JFJochViewerImageROIStatistics(QWidget *parent) circle_settings->Disable(); box_radio->setChecked(true); - QHBoxLayout *label_row_1 = new QHBoxLayout(); - QHBoxLayout *label_row_2 = new QHBoxLayout(); - - roi_sum = new QLabel("", this); - label_row_1->addWidget(roi_sum); - roi_mean = new QLabel("", this); - label_row_1->addWidget(roi_mean); - roi_var = new QLabel("", this); - label_row_1->addWidget(roi_var); - roi_max = new QLabel("", this); - label_row_1->addWidget(roi_max); - roi_npixel = new QLabel("", this); - label_row_2->addWidget(roi_npixel); - roi_masked = new QLabel("", this); - label_row_2->addWidget(roi_masked); - - layout->addLayout(label_row_1); - layout->addLayout(label_row_2); + roi_result = new JFJochViewerROIResult(this); + layout->addWidget(roi_result); QPushButton *add_button = new QPushButton("Add ROI to user mask", this); connect(add_button, &QPushButton::clicked, [this]() { emit AddROIToUserMask(); }); @@ -74,25 +58,7 @@ JFJochViewerImageROIStatistics::JFJochViewerImageROIStatistics(QWidget *parent) } void JFJochViewerImageROIStatistics::SetROIResult(ROIMessage roi) { - if ( roi.pixels > 0) { - auto roi_npixel_val = static_cast(roi.pixels); - double roi_mean_val = static_cast(roi.sum) / roi_npixel_val; - double variance = static_cast(roi.sum_square) / roi_npixel_val - roi_mean_val * roi_mean_val; - - roi_sum->setText(QString("Sum %1").arg(roi.sum)); - roi_mean->setText(QString("Mean %1").arg(QString::number(roi_mean_val, 'f', 3))); - roi_var->setText(QString("Var %1").arg(QString::number(variance, 'f', 3))); - roi_max->setText(QString("Max %1").arg(roi.max_count)); - roi_npixel->setText(QString("Pixels %1").arg(roi.pixels)); - roi_masked->setText(QString("Masked %1").arg(roi.pixels_masked)); - } else { - roi_sum->setText(""); - roi_mean->setText(""); - roi_var->setText(""); - roi_max->setText(""); - roi_npixel->setText(""); - roi_masked->setText(""); - } + roi_result->SetROIResult(roi); } diff --git a/viewer/JFJochViewerImageROIStatistics.h b/viewer/JFJochViewerImageROIStatistics.h index 151fedae..f20fe5c0 100644 --- a/viewer/JFJochViewerImageROIStatistics.h +++ b/viewer/JFJochViewerImageROIStatistics.h @@ -12,6 +12,7 @@ #include "JFJochImageReadingWorker.h" #include "JFJochViewerImageROIStatistics_Box.h" #include "JFJochViewerImageROIStatistics_Circle.h" +#include "JFJochViewerROIResult.h" #include "../reader/JFJochReaderImage.h" class JFJochViewerImageROIStatistics : public QWidget { @@ -25,12 +26,8 @@ class JFJochViewerImageROIStatistics : public QWidget { JFJochViewerImageROIStatistics_Box *box_settings; JFJochViewerImageROIStatistics_Circle *circle_settings; - QLabel *roi_sum; - QLabel *roi_mean; - QLabel *roi_var; - QLabel *roi_max; - QLabel *roi_npixel; - QLabel *roi_masked; + JFJochViewerROIResult *roi_result; + public: JFJochViewerImageROIStatistics(QWidget *parent); private slots: diff --git a/viewer/JFJochViewerROIResult.cpp b/viewer/JFJochViewerROIResult.cpp new file mode 100644 index 00000000..18d77762 --- /dev/null +++ b/viewer/JFJochViewerROIResult.cpp @@ -0,0 +1,54 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#include "JFJochViewerROIResult.h" +#include + +JFJochViewerROIResult::JFJochViewerROIResult(QWidget *parent) : QWidget(parent) { + QGridLayout *layout = new QGridLayout; + + roi_sum = new QLabel("", this); + roi_mean = new QLabel("", this); + roi_var = new QLabel("", this); + roi_max = new QLabel("", this); + roi_npixel = new QLabel("", this); + roi_masked = new QLabel("", this); + roi_x = new QLabel("", this); + roi_y = new QLabel("", this); + + layout->addWidget(roi_mean, 0, 0); + layout->addWidget(roi_var, 0, 1); + layout->addWidget(roi_sum, 0, 2); + layout->addWidget(roi_max, 0, 3); + layout->addWidget(roi_npixel, 1, 0); + layout->addWidget(roi_masked, 1, 1); + layout->addWidget(roi_x, 1, 2); + layout->addWidget(roi_y, 1, 3); + setLayout(layout); +} + +void JFJochViewerROIResult::SetROIResult(ROIMessage roi) { + if ( roi.pixels > 0) { + auto roi_npixel_val = static_cast(roi.pixels); + double roi_mean_val = static_cast(roi.sum) / roi_npixel_val; + double variance = static_cast(roi.sum_square) / roi_npixel_val - roi_mean_val * roi_mean_val; + + roi_sum->setText(QString("Sum %1").arg(roi.sum)); + roi_mean->setText(QString("Mean %1").arg(QString::number(roi_mean_val, 'f', 3))); + roi_var->setText(QString("Var %1").arg(QString::number(variance, 'f', 3))); + roi_max->setText(QString("Max %1").arg(roi.max_count)); + roi_npixel->setText(QString("Pixels %1").arg(roi.pixels)); + roi_masked->setText(QString("Masked %1").arg(roi.pixels_masked)); + roi_x->setText(QString("x: %1").arg(static_cast(roi.x_weighted) / roi.sum)); + roi_y->setText(QString("y: %1").arg(static_cast(roi.y_weighted) / roi.sum)); + } else { + roi_sum->setText(""); + roi_mean->setText(""); + roi_var->setText(""); + roi_max->setText(""); + roi_npixel->setText(""); + roi_masked->setText(""); + roi_x->setText(""); + roi_y->setText(""); + } +} diff --git a/viewer/JFJochViewerROIResult.h b/viewer/JFJochViewerROIResult.h new file mode 100644 index 00000000..1dec620c --- /dev/null +++ b/viewer/JFJochViewerROIResult.h @@ -0,0 +1,30 @@ +// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#ifndef JFJOCH_JFJOCHVIEWERROIRESULT_H +#define JFJOCH_JFJOCHVIEWERROIRESULT_H + +#include +#include +#include "../common/JFJochMessages.h" + +class JFJochViewerROIResult : public QWidget{ + Q_OBJECT + + QLabel *roi_sum; + QLabel *roi_mean; + QLabel *roi_var; + QLabel *roi_max; + QLabel *roi_npixel; + QLabel *roi_masked; + QLabel *roi_x; + QLabel *roi_y; + +public slots: + void SetROIResult(ROIMessage msg); +public: + JFJochViewerROIResult(QWidget *parent); +}; + + +#endif //JFJOCH_JFJOCHVIEWERROIRESULT_H \ No newline at end of file -- 2.49.1 From b74b6af60d3abb3002e4b63edfec9045eb6ae17b Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Fri, 14 Nov 2025 20:51:16 +0100 Subject: [PATCH 09/13] jfjoch_viewer: Handle better ROI result --- viewer/widgets/JFJochAzIntImage.cpp | 2 + viewer/widgets/JFJochDiffractionImage.cpp | 2 + viewer/widgets/JFJochImage.cpp | 75 ++++++++++++----------- viewer/widgets/JFJochImage.h | 3 +- viewer/widgets/JFJochSimpleImage.cpp | 2 + 5 files changed, 45 insertions(+), 39 deletions(-) diff --git a/viewer/widgets/JFJochAzIntImage.cpp b/viewer/widgets/JFJochAzIntImage.cpp index fa362c9c..9b4073fa 100644 --- a/viewer/widgets/JFJochAzIntImage.cpp +++ b/viewer/widgets/JFJochAzIntImage.cpp @@ -21,6 +21,7 @@ void JFJochAzIntImage::Clear() { void JFJochAzIntImage::imageLoaded(std::shared_ptr in_image) { if (!in_image) { Clear(); + CalcROI(); return; } @@ -68,6 +69,7 @@ void JFJochAzIntImage::imageLoaded(std::shared_ptr in_i // Generate pixmap and redraw using base class functionality GeneratePixmap(); Redraw(); + CalcROI(); } else { Clear(); } diff --git a/viewer/widgets/JFJochDiffractionImage.cpp b/viewer/widgets/JFJochDiffractionImage.cpp index f8182c80..c569b7bb 100644 --- a/viewer/widgets/JFJochDiffractionImage.cpp +++ b/viewer/widgets/JFJochDiffractionImage.cpp @@ -293,11 +293,13 @@ void JFJochDiffractionImage::loadImage(std::shared_ptr LoadImageInternal(); GeneratePixmap(); Redraw(); + CalcROI(); } else { image.reset(); W = 0; H = 0; if (scene()) scene()->clear(); + CalcROI(); } } diff --git a/viewer/widgets/JFJochImage.cpp b/viewer/widgets/JFJochImage.cpp index a0f3dab9..96d6408d 100644 --- a/viewer/widgets/JFJochImage.cpp +++ b/viewer/widgets/JFJochImage.cpp @@ -23,9 +23,6 @@ JFJochImage::JFJochImage(QWidget *parent) : QGraphicsView(parent) { // Optional: a sensible default colormap color_scale.Select(ColorScaleEnum::Indigo); - - connect(this, &JFJochImage::roiBoxUpdated, this, &JFJochImage::CalcROIBox); - connect(this, &JFJochImage::roiCircleUpdated, this, &JFJochImage::CalcROICircle); } void JFJochImage::onScroll(int value) { @@ -332,22 +329,23 @@ void JFJochImage::updateROI() { } emit roiBoxUpdated(roiBox.toRect()); } else { + double radius; if (mouse_event_type == MouseEventType::DrawingROI) { // Center at roiStartPos, radius from start->end QPointF delta = roiStartPos - roiEndPos; - double radius = std::sqrt(delta.x() * delta.x() + delta.y() * delta.y()); + radius = std::sqrt(delta.x() * delta.x() + delta.y() * delta.y()); roiBox = QRectF(roiStartPos.x() - radius, roiStartPos.y() - radius, 2 * radius, 2 * radius).normalized(); - emit roiCircleUpdated(roiStartPos.x(), roiStartPos.y(), radius); } else { // Moving/resizing: infer center/radius from roiBox const QPointF c = roiBox.center(); - const double radius = 0.5 * std::min(roiBox.width(), roiBox.height()); + radius = 0.5 * std::min(roiBox.width(), roiBox.height()); roiStartPos = c; // treat start as center for consistency roiEndPos = QPointF(c.x() + radius, c.y()); // arbitrary point on radius - emit roiCircleUpdated(c.x(), c.y(), radius); } + emit roiCircleUpdated(roiStartPos.x(), roiStartPos.y(), radius); } + CalcROI(); updateOverlay(); } @@ -641,8 +639,16 @@ ROIMessage JFJochImage::accumulateROI( }; } -void JFJochImage::CalcROIBox(QRect box) { - auto box_norm = box.normalized(); +void JFJochImage::CalcROI() { + if (W*H == 0) { + auto msg = ROIMessage{ + .pixels = 0, + .pixels_masked = 0}; + emit roiCalculated(msg); + return; + } + + auto box_norm = roiBox.normalized(); // Using the rectangle as-is; you can adjust inclusivity if needed int64_t xmin = box_norm.left(); @@ -650,32 +656,27 @@ void JFJochImage::CalcROIBox(QRect box) { int64_t ymin = box_norm.top(); int64_t ymax = box_norm.bottom(); - ROIMessage msg = accumulateROI( - xmin, xmax, ymin, ymax, - [](int64_t, int64_t) { return true; } // everything in the rectangle - ); - emit roiCalculated(msg); -} - -void JFJochImage::CalcROICircle(double in_x, double in_y, double radius) { - const double margin = 1.0; - int64_t xmin = static_cast(std::floor(in_x - radius - margin)); - int64_t xmax = static_cast(std::ceil(in_x + radius + margin)); - int64_t ymin = static_cast(std::floor(in_y - radius - margin)); - int64_t ymax = static_cast(static_cast(std::ceil(in_y + radius + margin))); - - const float cx = static_cast(in_x); - const float cy = static_cast(in_y); - const float r2 = static_cast(radius * radius); - - ROIMessage msg = accumulateROI( - xmin, xmax, ymin, ymax, - [cx, cy, r2](int64_t x, int64_t y) { - const float dx = static_cast(x) - cx; - const float dy = static_cast(y) - cy; - const float dist2 = dx * dx + dy * dy; - return dist2 <= r2; - } - ); - emit roiCalculated(msg); + ROIMessage msg{}; + if (roi_type == RoiType::RoiBox) + msg = accumulateROI( + xmin, xmax, ymin, ymax, + [](int64_t, int64_t) { return true; } // everything in the rectangle + ); + else { + QPointF delta = roiStartPos - roiEndPos; + double radius2 = delta.x() * delta.x() + delta.y() * delta.y(); + const float cx = static_cast(roiStartPos.x()); + const float cy = static_cast(roiStartPos.y()); + const float r2 = static_cast(radius2); + msg = accumulateROI( + xmin, xmax, ymin, ymax, + [cx, cy, r2](int64_t x, int64_t y) { + const float dx = static_cast(x) - cx; + const float dy = static_cast(y) - cy; + const float dist2 = dx * dx + dy * dy; + return dist2 <= r2; + } + ); + } + emit roiCalculated(msg); } diff --git a/viewer/widgets/JFJochImage.h b/viewer/widgets/JFJochImage.h index 846b3d1f..4ec8ab64 100644 --- a/viewer/widgets/JFJochImage.h +++ b/viewer/widgets/JFJochImage.h @@ -67,6 +67,7 @@ protected: void updateOverlay(); void GeneratePixmap(); void Redraw(); + void CalcROI(); signals: void foregroundChanged(float v); void backgroundChanged(float v); @@ -76,8 +77,6 @@ signals: void roiCalculated(ROIMessage &output); private slots: void onScroll(int value); - void CalcROIBox(QRect box); - void CalcROICircle(double x, double y, double radius); public slots: void setFeatureColor(QColor input); void setColorMap(int color_map); diff --git a/viewer/widgets/JFJochSimpleImage.cpp b/viewer/widgets/JFJochSimpleImage.cpp index 39e4e5cd..24101ef1 100644 --- a/viewer/widgets/JFJochSimpleImage.cpp +++ b/viewer/widgets/JFJochSimpleImage.cpp @@ -26,11 +26,13 @@ void JFJochSimpleImage::setImage(std::shared_ptr img) { loadImageInternal(); GeneratePixmap(); Redraw(); + CalcROI(); } else { image_.reset(); W = 0; H = 0; if (scene()) scene()->clear(); + CalcROI(); } } -- 2.49.1 From 489f7a827d345fcdda17b3ae9d9c50b70dc9c25d Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Sat, 15 Nov 2025 17:46:34 +0100 Subject: [PATCH 10/13] jfjoch_viewer: Add vertical line to dataset info chart and status bar information --- docs/CHANGELOG.md | 5 +++ viewer/JFJochViewerDatasetInfo.cpp | 5 +++ viewer/JFJochViewerDatasetInfo.h | 2 ++ viewer/JFJochViewerWindow.cpp | 3 ++ viewer/widgets/JFJochChartView.cpp | 50 ++++++++++++++++++++++++++++++ viewer/widgets/JFJochChartView.h | 18 ++++++++++- 6 files changed, 82 insertions(+), 1 deletion(-) diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 89d6e62d..b566940c 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -1,4 +1,9 @@ # Changelog +## 1.0.0-rc.101 +This is an UNSTABLE release. + +* jfjoch_viewer: Auto load is more + ## 1.0.0-rc.100 This is an UNSTABLE release. diff --git a/viewer/JFJochViewerDatasetInfo.cpp b/viewer/JFJochViewerDatasetInfo.cpp index 995873f2..644e190a 100644 --- a/viewer/JFJochViewerDatasetInfo.cpp +++ b/viewer/JFJochViewerDatasetInfo.cpp @@ -38,6 +38,11 @@ JFJochViewerDatasetInfo::JFJochViewerDatasetInfo(QWidget *parent) : QWidget(pare connect(combo_box, &QComboBox::currentIndexChanged, this, &JFJochViewerDatasetInfo::comboBoxSelected); + connect(chart_view, &JFJochChartView::writeStatusBar, + [this] (QString string, int timeout_ms) { + emit writeStatusBar(string, timeout_ms); + }); + setLayout(layout); } diff --git a/viewer/JFJochViewerDatasetInfo.h b/viewer/JFJochViewerDatasetInfo.h index a9b1e8b2..7d632f36 100644 --- a/viewer/JFJochViewerDatasetInfo.h +++ b/viewer/JFJochViewerDatasetInfo.h @@ -20,6 +20,8 @@ class JFJochViewerDatasetInfo : public QWidget { void UpdatePlot(); signals: void imageSelected(int64_t number, int64_t summation); + void writeStatusBar(QString string, int timeout_ms = 0); + public: explicit JFJochViewerDatasetInfo(QWidget *parent = nullptr); private slots: diff --git a/viewer/JFJochViewerWindow.cpp b/viewer/JFJochViewerWindow.cpp index efd01417..999a68da 100644 --- a/viewer/JFJochViewerWindow.cpp +++ b/viewer/JFJochViewerWindow.cpp @@ -315,6 +315,9 @@ JFJochViewerWindow::JFJochViewerWindow(QWidget *parent, bool dbus, const QString connect(azintImageWindow, &JFJoch2DAzintImageWindow::zoomOnBin, viewer, &JFJochDiffractionImage::centerOnSpot); + connect(dataset_info, &JFJochViewerDatasetInfo::writeStatusBar, + statusbar, &JFJochViewerStatusBar::display); + if (!file.isEmpty()) LoadFile(file, 0, 1); } diff --git a/viewer/widgets/JFJochChartView.cpp b/viewer/widgets/JFJochChartView.cpp index c97a1f79..0cbd8922 100644 --- a/viewer/widgets/JFJochChartView.cpp +++ b/viewer/widgets/JFJochChartView.cpp @@ -12,6 +12,7 @@ JFJochChartView::JFJochChartView(QWidget *parent) chart()->legend()->hide(); setRenderHint(QPainter::Antialiasing); setRubberBand(QChartView::RubberBand::RectangleRubberBand); + setMouseTracking(true); } void JFJochChartView::setImage(int64_t val) { @@ -43,6 +44,11 @@ void JFJochChartView::resetZoom() { void JFJochChartView::updateChart() { chart()->removeAllSeries(); + if (m_hoverLine) { + chart()->scene()->removeItem(m_hoverLine); + delete m_hoverLine; + m_hoverLine = nullptr; + } if (values.size() >= binning) { // At least one full point @@ -96,3 +102,47 @@ void JFJochChartView::contextMenuEvent(QContextMenuEvent *event) { cb->setText(out); } } + +void JFJochChartView::mouseMoveEvent(QMouseEvent *event) { + QChartView::mouseMoveEvent(event); + if (!series || values.empty()) + return; + + // Map mouse position to chart coordinates + const QPointF chartPos = chart()->mapToValue(event->pos(), series); + double xVal = chartPos.x(); + + // Convert x to closest image index + int64_t idx = std::lround(xVal); + if (idx < 0 || idx >= static_cast(values.size())) + return; + + // Map that x position to scene coords for the vertical line + const QRectF plotArea = chart()->plotArea(); + const QPointF ptOnChart = chart()->mapToPosition(QPointF(static_cast(idx), 0.0), series); + + if (!m_hoverLine) { + m_hoverLine = new QGraphicsLineItem; + m_hoverLine->setPen(QPen(QColor(200, 0, 0, 150), 1.0)); + chart()->scene()->addItem(m_hoverLine); + } + + m_hoverLine->setLine(QLineF(ptOnChart.x(), plotArea.top(), + ptOnChart.x(), plotArea.bottom())); + + // Status bar text + QString text = QString("image = %1, value = %2") + .arg(idx) + .arg(values[static_cast(idx)], 0, 'g', 6); + emit writeStatusBar(text, 6000); +} + +void JFJochChartView::leaveEvent(QEvent *event) { + QChartView::leaveEvent(event); + if (m_hoverLine) { + chart()->scene()->removeItem(m_hoverLine); + delete m_hoverLine; + m_hoverLine = nullptr; + } + emit writeStatusBar(QString(), 0); +} diff --git a/viewer/widgets/JFJochChartView.h b/viewer/widgets/JFJochChartView.h index 0884e7e5..b6545e64 100644 --- a/viewer/widgets/JFJochChartView.h +++ b/viewer/widgets/JFJochChartView.h @@ -10,22 +10,37 @@ #include #include + +#include +#include +#include +#include +#include +#include + class JFJochChartView : public QChartView { Q_OBJECT QLineSeries *series = nullptr; QScatterSeries *currentSeries = nullptr; + QGraphicsLineItem *m_hoverLine = nullptr; std::vector values; int64_t binning = 1; int64_t curr_image = 0; void updateChart(); + signals: void imageSelected(int64_t number); + void writeStatusBar(QString string, int timeout_ms = 0); + private: void mousePressEvent(QMouseEvent *event) override; + void mouseMoveEvent(QMouseEvent *event) override; + void leaveEvent(QEvent *event) override; void contextMenuEvent(QContextMenuEvent *event) override; + public: explicit JFJochChartView(QWidget *parent = nullptr); void setImage(int64_t val); @@ -33,8 +48,9 @@ public: public slots: void resetZoom(); void setBinning(int64_t val); + public: - template + template void loadValues(const std::vector &input, int64_t image) { values.resize(input.size()); for (int i = 0; i < input.size(); i++) -- 2.49.1 From 8671e9cb70a6684a9be6b92bd115595a2efbb138 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Sat, 15 Nov 2025 17:59:36 +0100 Subject: [PATCH 11/13] jfjoch_viewer: Handle ROI better --- viewer/JFJochViewerROIResult.cpp | 22 ++++++++++++++++----- viewer/JFJochViewerROIResult.h | 2 ++ viewer/windows/JFJoch2DAzintImageWindow.cpp | 7 ++++++- viewer/windows/JFJochCalibrationWindow.cpp | 6 ++++++ 4 files changed, 31 insertions(+), 6 deletions(-) diff --git a/viewer/JFJochViewerROIResult.cpp b/viewer/JFJochViewerROIResult.cpp index 18d77762..9c91297d 100644 --- a/viewer/JFJochViewerROIResult.cpp +++ b/viewer/JFJochViewerROIResult.cpp @@ -16,14 +16,22 @@ JFJochViewerROIResult::JFJochViewerROIResult(QWidget *parent) : QWidget(parent) roi_x = new QLabel("", this); roi_y = new QLabel("", this); + label_1 = new QLabel("", this); + label_2 = new QLabel("", this); + + label_1->setAlignment(Qt::AlignCenter); + label_2->setAlignment(Qt::AlignCenter); + layout->addWidget(roi_mean, 0, 0); layout->addWidget(roi_var, 0, 1); layout->addWidget(roi_sum, 0, 2); layout->addWidget(roi_max, 0, 3); - layout->addWidget(roi_npixel, 1, 0); - layout->addWidget(roi_masked, 1, 1); - layout->addWidget(roi_x, 1, 2); - layout->addWidget(roi_y, 1, 3); + layout->addWidget(label_1, 1,0,1,2); + layout->addWidget(roi_npixel, 1, 2); + layout->addWidget(roi_masked, 1, 3); + layout->addWidget(label_2, 2,0,1,2); + layout->addWidget(roi_x, 2, 2); + layout->addWidget(roi_y, 2, 3); setLayout(layout); } @@ -37,10 +45,12 @@ void JFJochViewerROIResult::SetROIResult(ROIMessage roi) { roi_mean->setText(QString("Mean %1").arg(QString::number(roi_mean_val, 'f', 3))); roi_var->setText(QString("Var %1").arg(QString::number(variance, 'f', 3))); roi_max->setText(QString("Max %1").arg(roi.max_count)); - roi_npixel->setText(QString("Pixels %1").arg(roi.pixels)); + roi_npixel->setText(QString("Valid %1").arg(roi.pixels)); roi_masked->setText(QString("Masked %1").arg(roi.pixels_masked)); roi_x->setText(QString("x: %1").arg(static_cast(roi.x_weighted) / roi.sum)); roi_y->setText(QString("y: %1").arg(static_cast(roi.y_weighted) / roi.sum)); + label_1->setText(QString("Pixel count")); + label_2->setText(QString("Center of mass")); } else { roi_sum->setText(""); roi_mean->setText(""); @@ -50,5 +60,7 @@ void JFJochViewerROIResult::SetROIResult(ROIMessage roi) { roi_masked->setText(""); roi_x->setText(""); roi_y->setText(""); + label_1->setText(""); + label_2->setText(""); } } diff --git a/viewer/JFJochViewerROIResult.h b/viewer/JFJochViewerROIResult.h index 1dec620c..e8e6663b 100644 --- a/viewer/JFJochViewerROIResult.h +++ b/viewer/JFJochViewerROIResult.h @@ -19,6 +19,8 @@ class JFJochViewerROIResult : public QWidget{ QLabel *roi_masked; QLabel *roi_x; QLabel *roi_y; + QLabel *label_1; + QLabel *label_2; public slots: void SetROIResult(ROIMessage msg); diff --git a/viewer/windows/JFJoch2DAzintImageWindow.cpp b/viewer/windows/JFJoch2DAzintImageWindow.cpp index b8f2277f..0a205a78 100644 --- a/viewer/windows/JFJoch2DAzintImageWindow.cpp +++ b/viewer/windows/JFJoch2DAzintImageWindow.cpp @@ -3,7 +3,7 @@ #include #include "JFJoch2DAzintImageWindow.h" - +#include "../JFJochViewerROIResult.h" JFJoch2DAzintImageWindow::JFJoch2DAzintImageWindow(QWidget *parent) : JFJochHelperWindow(parent) { QWidget *centralWidget = new QWidget(this); @@ -25,9 +25,12 @@ JFJoch2DAzintImageWindow::JFJoch2DAzintImageWindow(QWidget *parent) : JFJochHelp foreground_row->addWidget(new QLabel("Foreground:")); foreground_row->addWidget(foreground_slider); + auto roi_result = new JFJochViewerROIResult(this); + grid_layout->addLayout(background_row, 0, 0, 1, 2); grid_layout->addLayout(foreground_row, 1, 0, 1, 2); grid_layout->addWidget(viewer, 2, 0, 1, 2); + grid_layout->addWidget(roi_result, 3, 0, 1, 2); centralWidget->setLayout(grid_layout); connect(viewer, &JFJochAzIntImage::backgroundChanged, @@ -42,6 +45,8 @@ JFJoch2DAzintImageWindow::JFJoch2DAzintImageWindow(QWidget *parent) : JFJochHelp foreground_slider->setValue(val); }); + connect(viewer, &JFJochAzIntImage::roiCalculated, roi_result, &JFJochViewerROIResult::SetROIResult); + connect(background_slider, &SliderPlusBox::valueChanged, viewer, &JFJochAzIntImage::changeBackground); connect(foreground_slider, &SliderPlusBox::valueChanged, viewer, &JFJochAzIntImage::changeForeground); diff --git a/viewer/windows/JFJochCalibrationWindow.cpp b/viewer/windows/JFJochCalibrationWindow.cpp index e5a76124..04cca5e2 100644 --- a/viewer/windows/JFJochCalibrationWindow.cpp +++ b/viewer/windows/JFJochCalibrationWindow.cpp @@ -7,6 +7,8 @@ #include #include +#include "../JFJochViewerROIResult.h" + JFJochCalibrationWindow::JFJochCalibrationWindow(QWidget *parent) : JFJochHelperWindow(parent) { QWidget *centralWidget = new QWidget(this); setWindowTitle("Calibration image viewer"); @@ -35,11 +37,14 @@ JFJochCalibrationWindow::JFJochCalibrationWindow(QWidget *parent) : JFJochHelper foreground_row->addWidget(new QLabel("Foreground:")); foreground_row->addWidget(foreground_slider); + auto roi_result = new JFJochViewerROIResult(this); + grid_layout->addWidget(calibration_option, 0, 0); grid_layout->addWidget(color_map_select, 0, 1); grid_layout->addLayout(background_row, 1, 0, 1, 2); grid_layout->addLayout(foreground_row, 2, 0, 1, 2); grid_layout->addWidget(viewer, 3, 0, 1, 2); + grid_layout->addWidget(roi_result, 4, 0, 1, 2); connect(viewer, &JFJochSimpleImage::backgroundChanged, [this] (float val) { @@ -52,6 +57,7 @@ JFJochCalibrationWindow::JFJochCalibrationWindow(QWidget *parent) : JFJochHelper QSignalBlocker blocker(foreground_slider); foreground_slider->setValue(val); }); + connect(viewer, &JFJochSimpleImage::roiCalculated, roi_result, &JFJochViewerROIResult::SetROIResult); connect(background_slider, &SliderPlusBox::valueChanged, viewer, &JFJochSimpleImage::changeBackground); connect(foreground_slider, &SliderPlusBox::valueChanged, viewer, &JFJochSimpleImage::changeForeground); -- 2.49.1 From 12cde1cda9eca6bfa2156df19e5b578e1589eabd Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Sat, 15 Nov 2025 17:59:59 +0100 Subject: [PATCH 12/13] CHANGELOG --- docs/CHANGELOG.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index b566940c..1eb51db5 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -2,7 +2,10 @@ ## 1.0.0-rc.101 This is an UNSTABLE release. -* jfjoch_viewer: Auto load is more +* jfjoch_viewer: Auto load is better handling change of states +* jfjoch_viewer: Fix DBus registration +* jfjoch_viewer: Handle charts better with vertical lines on hover and status bar update +* jfjoch_viewer: Calculate ROI in a more efficient way ## 1.0.0-rc.100 This is an UNSTABLE release. -- 2.49.1 From 45c59973720067615a995d2fb8c3e12219fcc8e2 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Sat, 15 Nov 2025 18:21:57 +0100 Subject: [PATCH 13/13] VERSION: 1.0.0-rc.101 --- VERSION | 2 +- broker/gen/api/ApiBase.h | 2 +- broker/gen/api/DefaultApi.cpp | 2 +- broker/gen/api/DefaultApi.h | 2 +- broker/gen/model/Azim_int_settings.cpp | 2 +- broker/gen/model/Azim_int_settings.h | 2 +- broker/gen/model/Broker_status.cpp | 2 +- broker/gen/model/Broker_status.h | 2 +- broker/gen/model/Calibration_statistics_inner.cpp | 2 +- broker/gen/model/Calibration_statistics_inner.h | 2 +- broker/gen/model/Dark_mask_settings.cpp | 2 +- broker/gen/model/Dark_mask_settings.h | 2 +- broker/gen/model/Dataset_settings.cpp | 2 +- broker/gen/model/Dataset_settings.h | 2 +- .../gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp | 2 +- .../gen/model/Dataset_settings_xray_fluorescence_spectrum.h | 2 +- broker/gen/model/Detector.cpp | 2 +- broker/gen/model/Detector.h | 2 +- broker/gen/model/Detector_list.cpp | 2 +- broker/gen/model/Detector_list.h | 2 +- broker/gen/model/Detector_list_element.cpp | 2 +- broker/gen/model/Detector_list_element.h | 2 +- broker/gen/model/Detector_module.cpp | 2 +- broker/gen/model/Detector_module.h | 2 +- broker/gen/model/Detector_module_direction.cpp | 2 +- broker/gen/model/Detector_module_direction.h | 2 +- broker/gen/model/Detector_power_state.cpp | 2 +- broker/gen/model/Detector_power_state.h | 2 +- broker/gen/model/Detector_selection.cpp | 2 +- broker/gen/model/Detector_selection.h | 2 +- broker/gen/model/Detector_settings.cpp | 2 +- broker/gen/model/Detector_settings.h | 2 +- broker/gen/model/Detector_state.cpp | 2 +- broker/gen/model/Detector_state.h | 2 +- broker/gen/model/Detector_status.cpp | 2 +- broker/gen/model/Detector_status.h | 2 +- broker/gen/model/Detector_timing.cpp | 2 +- broker/gen/model/Detector_timing.h | 2 +- broker/gen/model/Detector_type.cpp | 2 +- broker/gen/model/Detector_type.h | 2 +- broker/gen/model/Error_message.cpp | 2 +- broker/gen/model/Error_message.h | 2 +- broker/gen/model/File_writer_format.cpp | 2 +- broker/gen/model/File_writer_format.h | 2 +- broker/gen/model/File_writer_settings.cpp | 2 +- broker/gen/model/File_writer_settings.h | 2 +- broker/gen/model/Fpga_status_inner.cpp | 2 +- broker/gen/model/Fpga_status_inner.h | 2 +- broker/gen/model/Geom_refinement_algorithm.cpp | 2 +- broker/gen/model/Geom_refinement_algorithm.h | 2 +- broker/gen/model/Grid_scan.cpp | 2 +- broker/gen/model/Grid_scan.h | 2 +- broker/gen/model/Helpers.cpp | 2 +- broker/gen/model/Helpers.h | 2 +- broker/gen/model/Image_buffer_status.cpp | 2 +- broker/gen/model/Image_buffer_status.h | 2 +- broker/gen/model/Image_format_settings.cpp | 2 +- broker/gen/model/Image_format_settings.h | 2 +- broker/gen/model/Image_pusher_type.cpp | 2 +- broker/gen/model/Image_pusher_type.h | 2 +- broker/gen/model/Indexing_algorithm.cpp | 2 +- broker/gen/model/Indexing_algorithm.h | 2 +- broker/gen/model/Indexing_settings.cpp | 2 +- broker/gen/model/Indexing_settings.h | 2 +- broker/gen/model/Instrument_metadata.cpp | 2 +- broker/gen/model/Instrument_metadata.h | 2 +- broker/gen/model/Jfjoch_settings.cpp | 2 +- broker/gen/model/Jfjoch_settings.h | 2 +- broker/gen/model/Jfjoch_settings_ssl.cpp | 2 +- broker/gen/model/Jfjoch_settings_ssl.h | 2 +- broker/gen/model/Jfjoch_statistics.cpp | 2 +- broker/gen/model/Jfjoch_statistics.h | 2 +- broker/gen/model/Measurement_statistics.cpp | 2 +- broker/gen/model/Measurement_statistics.h | 2 +- broker/gen/model/Pcie_devices_inner.cpp | 2 +- broker/gen/model/Pcie_devices_inner.h | 2 +- broker/gen/model/Pixel_mask_statistics.cpp | 2 +- broker/gen/model/Pixel_mask_statistics.h | 2 +- broker/gen/model/Plot.cpp | 2 +- broker/gen/model/Plot.h | 2 +- broker/gen/model/Plot_unit_x.cpp | 2 +- broker/gen/model/Plot_unit_x.h | 2 +- broker/gen/model/Plots.cpp | 2 +- broker/gen/model/Plots.h | 2 +- broker/gen/model/Roi_azim_list.cpp | 2 +- broker/gen/model/Roi_azim_list.h | 2 +- broker/gen/model/Roi_azimuthal.cpp | 2 +- broker/gen/model/Roi_azimuthal.h | 2 +- broker/gen/model/Roi_box.cpp | 2 +- broker/gen/model/Roi_box.h | 2 +- broker/gen/model/Roi_box_list.cpp | 2 +- broker/gen/model/Roi_box_list.h | 2 +- broker/gen/model/Roi_circle.cpp | 2 +- broker/gen/model/Roi_circle.h | 2 +- broker/gen/model/Roi_circle_list.cpp | 2 +- broker/gen/model/Roi_circle_list.h | 2 +- broker/gen/model/Roi_definitions.cpp | 2 +- broker/gen/model/Roi_definitions.h | 2 +- broker/gen/model/Rotation_axis.cpp | 2 +- broker/gen/model/Rotation_axis.h | 2 +- broker/gen/model/Scan_result.cpp | 2 +- broker/gen/model/Scan_result.h | 2 +- broker/gen/model/Scan_result_images_inner.cpp | 2 +- broker/gen/model/Scan_result_images_inner.h | 2 +- broker/gen/model/Spot_finding_settings.cpp | 2 +- broker/gen/model/Spot_finding_settings.h | 2 +- broker/gen/model/Standard_detector_geometry.cpp | 2 +- broker/gen/model/Standard_detector_geometry.h | 2 +- broker/gen/model/Unit_cell.cpp | 2 +- broker/gen/model/Unit_cell.h | 2 +- broker/gen/model/Zeromq_metadata_settings.cpp | 2 +- broker/gen/model/Zeromq_metadata_settings.h | 2 +- broker/gen/model/Zeromq_preview_settings.cpp | 2 +- broker/gen/model/Zeromq_preview_settings.h | 2 +- broker/gen/model/Zeromq_settings.cpp | 2 +- broker/gen/model/Zeromq_settings.h | 2 +- broker/jfjoch_api.yaml | 2 +- broker/redoc-static.html | 4 ++-- docs/conf.py | 2 +- docs/python_client/README.md | 4 ++-- fpga/hdl/action_config.v | 2 +- fpga/pcie_driver/dkms.conf | 2 +- fpga/pcie_driver/install_dkms.sh | 2 +- fpga/pcie_driver/jfjoch_drv.c | 2 +- fpga/pcie_driver/postinstall.sh | 2 +- fpga/pcie_driver/preuninstall.sh | 2 +- frontend/package-lock.json | 4 ++-- frontend/package.json | 2 +- frontend/src/openapi/core/OpenAPI.ts | 2 +- frontend/src/version.ts | 2 +- writer/gen/api/ApiBase.h | 2 +- writer/gen/api/DefaultApi.cpp | 2 +- writer/gen/api/DefaultApi.h | 2 +- writer/gen/model/Helpers.cpp | 2 +- writer/gen/model/Helpers.h | 2 +- writer/gen/model/Writer_statistics.cpp | 2 +- writer/gen/model/Writer_statistics.h | 2 +- writer/writer_api.yaml | 2 +- 138 files changed, 141 insertions(+), 141 deletions(-) diff --git a/VERSION b/VERSION index ff1b7acd..ee31b52a 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.0.0-rc.100 +1.0.0-rc.101 diff --git a/broker/gen/api/ApiBase.h b/broker/gen/api/ApiBase.h index 68a15faf..38ba1b82 100644 --- a/broker/gen/api/ApiBase.h +++ b/broker/gen/api/ApiBase.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/api/DefaultApi.cpp b/broker/gen/api/DefaultApi.cpp index 0b95d55f..f3f923eb 100644 --- a/broker/gen/api/DefaultApi.cpp +++ b/broker/gen/api/DefaultApi.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/api/DefaultApi.h b/broker/gen/api/DefaultApi.h index e8ad04d9..f6aa159d 100644 --- a/broker/gen/api/DefaultApi.h +++ b/broker/gen/api/DefaultApi.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Azim_int_settings.cpp b/broker/gen/model/Azim_int_settings.cpp index 5ecef7c5..f5f3cff4 100644 --- a/broker/gen/model/Azim_int_settings.cpp +++ b/broker/gen/model/Azim_int_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Azim_int_settings.h b/broker/gen/model/Azim_int_settings.h index dcf6a1ae..a1a0be8c 100644 --- a/broker/gen/model/Azim_int_settings.h +++ b/broker/gen/model/Azim_int_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Broker_status.cpp b/broker/gen/model/Broker_status.cpp index 2bd13cfa..bc08eb65 100644 --- a/broker/gen/model/Broker_status.cpp +++ b/broker/gen/model/Broker_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Broker_status.h b/broker/gen/model/Broker_status.h index d355f5d2..1337e6fa 100644 --- a/broker/gen/model/Broker_status.h +++ b/broker/gen/model/Broker_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Calibration_statistics_inner.cpp b/broker/gen/model/Calibration_statistics_inner.cpp index a73d9b72..5b12df7c 100644 --- a/broker/gen/model/Calibration_statistics_inner.cpp +++ b/broker/gen/model/Calibration_statistics_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Calibration_statistics_inner.h b/broker/gen/model/Calibration_statistics_inner.h index faf85913..b29a63a3 100644 --- a/broker/gen/model/Calibration_statistics_inner.h +++ b/broker/gen/model/Calibration_statistics_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dark_mask_settings.cpp b/broker/gen/model/Dark_mask_settings.cpp index 3225f67e..d1356c38 100644 --- a/broker/gen/model/Dark_mask_settings.cpp +++ b/broker/gen/model/Dark_mask_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dark_mask_settings.h b/broker/gen/model/Dark_mask_settings.h index 06a2ee90..dd27fe24 100644 --- a/broker/gen/model/Dark_mask_settings.h +++ b/broker/gen/model/Dark_mask_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings.cpp b/broker/gen/model/Dataset_settings.cpp index 37b53f4b..c07ee77f 100644 --- a/broker/gen/model/Dataset_settings.cpp +++ b/broker/gen/model/Dataset_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings.h b/broker/gen/model/Dataset_settings.h index c7abae3a..b6a7a919 100644 --- a/broker/gen/model/Dataset_settings.h +++ b/broker/gen/model/Dataset_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp index 7e7f9362..70d6abd0 100644 --- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp +++ b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h index c61319ba..18aad037 100644 --- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h +++ b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector.cpp b/broker/gen/model/Detector.cpp index 85ea9a95..cabefea9 100644 --- a/broker/gen/model/Detector.cpp +++ b/broker/gen/model/Detector.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector.h b/broker/gen/model/Detector.h index a4d68412..c1cd4b5e 100644 --- a/broker/gen/model/Detector.h +++ b/broker/gen/model/Detector.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list.cpp b/broker/gen/model/Detector_list.cpp index 4e79fa31..02fa19b4 100644 --- a/broker/gen/model/Detector_list.cpp +++ b/broker/gen/model/Detector_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list.h b/broker/gen/model/Detector_list.h index f44b1041..e2169b00 100644 --- a/broker/gen/model/Detector_list.h +++ b/broker/gen/model/Detector_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list_element.cpp b/broker/gen/model/Detector_list_element.cpp index 6220e32c..fc9b1623 100644 --- a/broker/gen/model/Detector_list_element.cpp +++ b/broker/gen/model/Detector_list_element.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list_element.h b/broker/gen/model/Detector_list_element.h index 79d2f358..38ab33d7 100644 --- a/broker/gen/model/Detector_list_element.h +++ b/broker/gen/model/Detector_list_element.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module.cpp b/broker/gen/model/Detector_module.cpp index 69a7af90..797b450d 100644 --- a/broker/gen/model/Detector_module.cpp +++ b/broker/gen/model/Detector_module.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module.h b/broker/gen/model/Detector_module.h index ff3e0247..dec63400 100644 --- a/broker/gen/model/Detector_module.h +++ b/broker/gen/model/Detector_module.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module_direction.cpp b/broker/gen/model/Detector_module_direction.cpp index 6755af7f..1b14bc83 100644 --- a/broker/gen/model/Detector_module_direction.cpp +++ b/broker/gen/model/Detector_module_direction.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module_direction.h b/broker/gen/model/Detector_module_direction.h index ba35c585..d81f1e50 100644 --- a/broker/gen/model/Detector_module_direction.h +++ b/broker/gen/model/Detector_module_direction.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_power_state.cpp b/broker/gen/model/Detector_power_state.cpp index 3d5914de..7c762da5 100644 --- a/broker/gen/model/Detector_power_state.cpp +++ b/broker/gen/model/Detector_power_state.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_power_state.h b/broker/gen/model/Detector_power_state.h index 96481a72..8950ef6f 100644 --- a/broker/gen/model/Detector_power_state.h +++ b/broker/gen/model/Detector_power_state.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_selection.cpp b/broker/gen/model/Detector_selection.cpp index f34451c7..5324e809 100644 --- a/broker/gen/model/Detector_selection.cpp +++ b/broker/gen/model/Detector_selection.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_selection.h b/broker/gen/model/Detector_selection.h index 8896b7b3..c53f586d 100644 --- a/broker/gen/model/Detector_selection.h +++ b/broker/gen/model/Detector_selection.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_settings.cpp b/broker/gen/model/Detector_settings.cpp index 090528cb..6e39464d 100644 --- a/broker/gen/model/Detector_settings.cpp +++ b/broker/gen/model/Detector_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_settings.h b/broker/gen/model/Detector_settings.h index da4b4bbb..755ceaaf 100644 --- a/broker/gen/model/Detector_settings.h +++ b/broker/gen/model/Detector_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_state.cpp b/broker/gen/model/Detector_state.cpp index 86d34eab..dcd8bd56 100644 --- a/broker/gen/model/Detector_state.cpp +++ b/broker/gen/model/Detector_state.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_state.h b/broker/gen/model/Detector_state.h index 9bde2801..83925152 100644 --- a/broker/gen/model/Detector_state.h +++ b/broker/gen/model/Detector_state.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_status.cpp b/broker/gen/model/Detector_status.cpp index 5f4d636e..f50ef24a 100644 --- a/broker/gen/model/Detector_status.cpp +++ b/broker/gen/model/Detector_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_status.h b/broker/gen/model/Detector_status.h index cf8c88fe..e30e6e96 100644 --- a/broker/gen/model/Detector_status.h +++ b/broker/gen/model/Detector_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_timing.cpp b/broker/gen/model/Detector_timing.cpp index 4958b72d..852e209d 100644 --- a/broker/gen/model/Detector_timing.cpp +++ b/broker/gen/model/Detector_timing.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_timing.h b/broker/gen/model/Detector_timing.h index 94533dab..9bb11b26 100644 --- a/broker/gen/model/Detector_timing.h +++ b/broker/gen/model/Detector_timing.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_type.cpp b/broker/gen/model/Detector_type.cpp index 46e3f520..e784287f 100644 --- a/broker/gen/model/Detector_type.cpp +++ b/broker/gen/model/Detector_type.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_type.h b/broker/gen/model/Detector_type.h index 08cb28db..09fcdea8 100644 --- a/broker/gen/model/Detector_type.h +++ b/broker/gen/model/Detector_type.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Error_message.cpp b/broker/gen/model/Error_message.cpp index 451e2e94..1310d6dd 100644 --- a/broker/gen/model/Error_message.cpp +++ b/broker/gen/model/Error_message.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Error_message.h b/broker/gen/model/Error_message.h index 2850d2a7..20b96c47 100644 --- a/broker/gen/model/Error_message.h +++ b/broker/gen/model/Error_message.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_format.cpp b/broker/gen/model/File_writer_format.cpp index cb117d9d..440137c8 100644 --- a/broker/gen/model/File_writer_format.cpp +++ b/broker/gen/model/File_writer_format.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_format.h b/broker/gen/model/File_writer_format.h index c38292c2..b9795ad2 100644 --- a/broker/gen/model/File_writer_format.h +++ b/broker/gen/model/File_writer_format.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_settings.cpp b/broker/gen/model/File_writer_settings.cpp index c087612b..e0c25cd3 100644 --- a/broker/gen/model/File_writer_settings.cpp +++ b/broker/gen/model/File_writer_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_settings.h b/broker/gen/model/File_writer_settings.h index 983dae1f..34f7d95b 100644 --- a/broker/gen/model/File_writer_settings.h +++ b/broker/gen/model/File_writer_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Fpga_status_inner.cpp b/broker/gen/model/Fpga_status_inner.cpp index 80232ff7..0a0b9839 100644 --- a/broker/gen/model/Fpga_status_inner.cpp +++ b/broker/gen/model/Fpga_status_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Fpga_status_inner.h b/broker/gen/model/Fpga_status_inner.h index 29c02418..7ec9d706 100644 --- a/broker/gen/model/Fpga_status_inner.h +++ b/broker/gen/model/Fpga_status_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Geom_refinement_algorithm.cpp b/broker/gen/model/Geom_refinement_algorithm.cpp index f5e42338..bc230afc 100644 --- a/broker/gen/model/Geom_refinement_algorithm.cpp +++ b/broker/gen/model/Geom_refinement_algorithm.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Geom_refinement_algorithm.h b/broker/gen/model/Geom_refinement_algorithm.h index bffc84f5..a03cc5f7 100644 --- a/broker/gen/model/Geom_refinement_algorithm.h +++ b/broker/gen/model/Geom_refinement_algorithm.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Grid_scan.cpp b/broker/gen/model/Grid_scan.cpp index be9f106a..2cf603d8 100644 --- a/broker/gen/model/Grid_scan.cpp +++ b/broker/gen/model/Grid_scan.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Grid_scan.h b/broker/gen/model/Grid_scan.h index ab5a5a99..af8ac182 100644 --- a/broker/gen/model/Grid_scan.h +++ b/broker/gen/model/Grid_scan.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Helpers.cpp b/broker/gen/model/Helpers.cpp index 3e71c242..cd9b67a4 100644 --- a/broker/gen/model/Helpers.cpp +++ b/broker/gen/model/Helpers.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Helpers.h b/broker/gen/model/Helpers.h index 1e6c8cf8..c91083c3 100644 --- a/broker/gen/model/Helpers.h +++ b/broker/gen/model/Helpers.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_buffer_status.cpp b/broker/gen/model/Image_buffer_status.cpp index be507dd0..6545c49f 100644 --- a/broker/gen/model/Image_buffer_status.cpp +++ b/broker/gen/model/Image_buffer_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_buffer_status.h b/broker/gen/model/Image_buffer_status.h index 0d68a510..fbb0d5e7 100644 --- a/broker/gen/model/Image_buffer_status.h +++ b/broker/gen/model/Image_buffer_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_format_settings.cpp b/broker/gen/model/Image_format_settings.cpp index 5a1e9764..89e27ab5 100644 --- a/broker/gen/model/Image_format_settings.cpp +++ b/broker/gen/model/Image_format_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_format_settings.h b/broker/gen/model/Image_format_settings.h index e33e7ede..a96f17b2 100644 --- a/broker/gen/model/Image_format_settings.h +++ b/broker/gen/model/Image_format_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_type.cpp b/broker/gen/model/Image_pusher_type.cpp index 10b194c6..d746af02 100644 --- a/broker/gen/model/Image_pusher_type.cpp +++ b/broker/gen/model/Image_pusher_type.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_type.h b/broker/gen/model/Image_pusher_type.h index a2136539..11f279bf 100644 --- a/broker/gen/model/Image_pusher_type.h +++ b/broker/gen/model/Image_pusher_type.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_algorithm.cpp b/broker/gen/model/Indexing_algorithm.cpp index 762a3f5a..2619ecb0 100644 --- a/broker/gen/model/Indexing_algorithm.cpp +++ b/broker/gen/model/Indexing_algorithm.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_algorithm.h b/broker/gen/model/Indexing_algorithm.h index 18e7ac86..329b5cc7 100644 --- a/broker/gen/model/Indexing_algorithm.h +++ b/broker/gen/model/Indexing_algorithm.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_settings.cpp b/broker/gen/model/Indexing_settings.cpp index b5944b1e..b47d6d4d 100644 --- a/broker/gen/model/Indexing_settings.cpp +++ b/broker/gen/model/Indexing_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_settings.h b/broker/gen/model/Indexing_settings.h index 9738a397..29cf9ddb 100644 --- a/broker/gen/model/Indexing_settings.h +++ b/broker/gen/model/Indexing_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Instrument_metadata.cpp b/broker/gen/model/Instrument_metadata.cpp index b62c9fce..2fc59c62 100644 --- a/broker/gen/model/Instrument_metadata.cpp +++ b/broker/gen/model/Instrument_metadata.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Instrument_metadata.h b/broker/gen/model/Instrument_metadata.h index 9be78fb3..51359e6e 100644 --- a/broker/gen/model/Instrument_metadata.h +++ b/broker/gen/model/Instrument_metadata.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings.cpp b/broker/gen/model/Jfjoch_settings.cpp index 149b4293..06f5c7ff 100644 --- a/broker/gen/model/Jfjoch_settings.cpp +++ b/broker/gen/model/Jfjoch_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings.h b/broker/gen/model/Jfjoch_settings.h index f06136a5..075f26d0 100644 --- a/broker/gen/model/Jfjoch_settings.h +++ b/broker/gen/model/Jfjoch_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings_ssl.cpp b/broker/gen/model/Jfjoch_settings_ssl.cpp index 22421054..e56de590 100644 --- a/broker/gen/model/Jfjoch_settings_ssl.cpp +++ b/broker/gen/model/Jfjoch_settings_ssl.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings_ssl.h b/broker/gen/model/Jfjoch_settings_ssl.h index 7660b0b1..e85f847c 100644 --- a/broker/gen/model/Jfjoch_settings_ssl.h +++ b/broker/gen/model/Jfjoch_settings_ssl.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_statistics.cpp b/broker/gen/model/Jfjoch_statistics.cpp index 18888e7f..2c84c1a3 100644 --- a/broker/gen/model/Jfjoch_statistics.cpp +++ b/broker/gen/model/Jfjoch_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_statistics.h b/broker/gen/model/Jfjoch_statistics.h index c36b108d..71027f28 100644 --- a/broker/gen/model/Jfjoch_statistics.h +++ b/broker/gen/model/Jfjoch_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Measurement_statistics.cpp b/broker/gen/model/Measurement_statistics.cpp index 132d110d..7a48b623 100644 --- a/broker/gen/model/Measurement_statistics.cpp +++ b/broker/gen/model/Measurement_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Measurement_statistics.h b/broker/gen/model/Measurement_statistics.h index 18d42773..13edf1d1 100644 --- a/broker/gen/model/Measurement_statistics.h +++ b/broker/gen/model/Measurement_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pcie_devices_inner.cpp b/broker/gen/model/Pcie_devices_inner.cpp index fce08eb2..cc6b178b 100644 --- a/broker/gen/model/Pcie_devices_inner.cpp +++ b/broker/gen/model/Pcie_devices_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pcie_devices_inner.h b/broker/gen/model/Pcie_devices_inner.h index cbd1d597..79ae3652 100644 --- a/broker/gen/model/Pcie_devices_inner.h +++ b/broker/gen/model/Pcie_devices_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pixel_mask_statistics.cpp b/broker/gen/model/Pixel_mask_statistics.cpp index 48310c6d..0cd444d1 100644 --- a/broker/gen/model/Pixel_mask_statistics.cpp +++ b/broker/gen/model/Pixel_mask_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pixel_mask_statistics.h b/broker/gen/model/Pixel_mask_statistics.h index 82c710bc..75fd8150 100644 --- a/broker/gen/model/Pixel_mask_statistics.h +++ b/broker/gen/model/Pixel_mask_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot.cpp b/broker/gen/model/Plot.cpp index 08a3d5db..2225e507 100644 --- a/broker/gen/model/Plot.cpp +++ b/broker/gen/model/Plot.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot.h b/broker/gen/model/Plot.h index 4b31e196..b190dbc3 100644 --- a/broker/gen/model/Plot.h +++ b/broker/gen/model/Plot.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot_unit_x.cpp b/broker/gen/model/Plot_unit_x.cpp index 6e10df71..7f1a586d 100644 --- a/broker/gen/model/Plot_unit_x.cpp +++ b/broker/gen/model/Plot_unit_x.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot_unit_x.h b/broker/gen/model/Plot_unit_x.h index d7eaf856..8ad197c4 100644 --- a/broker/gen/model/Plot_unit_x.h +++ b/broker/gen/model/Plot_unit_x.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plots.cpp b/broker/gen/model/Plots.cpp index 87914c07..c6ea4421 100644 --- a/broker/gen/model/Plots.cpp +++ b/broker/gen/model/Plots.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plots.h b/broker/gen/model/Plots.h index 9d0fe2ab..1afad672 100644 --- a/broker/gen/model/Plots.h +++ b/broker/gen/model/Plots.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azim_list.cpp b/broker/gen/model/Roi_azim_list.cpp index d94d5764..6367a1e9 100644 --- a/broker/gen/model/Roi_azim_list.cpp +++ b/broker/gen/model/Roi_azim_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azim_list.h b/broker/gen/model/Roi_azim_list.h index c40f4daa..6c1823cd 100644 --- a/broker/gen/model/Roi_azim_list.h +++ b/broker/gen/model/Roi_azim_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azimuthal.cpp b/broker/gen/model/Roi_azimuthal.cpp index 3a34d11e..5563bd3b 100644 --- a/broker/gen/model/Roi_azimuthal.cpp +++ b/broker/gen/model/Roi_azimuthal.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azimuthal.h b/broker/gen/model/Roi_azimuthal.h index c4f2e230..d1177323 100644 --- a/broker/gen/model/Roi_azimuthal.h +++ b/broker/gen/model/Roi_azimuthal.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box.cpp b/broker/gen/model/Roi_box.cpp index 51135936..dcc394c5 100644 --- a/broker/gen/model/Roi_box.cpp +++ b/broker/gen/model/Roi_box.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box.h b/broker/gen/model/Roi_box.h index 38670ed4..729c1033 100644 --- a/broker/gen/model/Roi_box.h +++ b/broker/gen/model/Roi_box.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box_list.cpp b/broker/gen/model/Roi_box_list.cpp index bc65625e..6fee5910 100644 --- a/broker/gen/model/Roi_box_list.cpp +++ b/broker/gen/model/Roi_box_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box_list.h b/broker/gen/model/Roi_box_list.h index 9ece4768..d440c137 100644 --- a/broker/gen/model/Roi_box_list.h +++ b/broker/gen/model/Roi_box_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle.cpp b/broker/gen/model/Roi_circle.cpp index df620311..cc2683ce 100644 --- a/broker/gen/model/Roi_circle.cpp +++ b/broker/gen/model/Roi_circle.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle.h b/broker/gen/model/Roi_circle.h index fe75586c..d8a42edd 100644 --- a/broker/gen/model/Roi_circle.h +++ b/broker/gen/model/Roi_circle.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle_list.cpp b/broker/gen/model/Roi_circle_list.cpp index 02b98ec2..96d7888c 100644 --- a/broker/gen/model/Roi_circle_list.cpp +++ b/broker/gen/model/Roi_circle_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle_list.h b/broker/gen/model/Roi_circle_list.h index 04dcf15b..0786e9ae 100644 --- a/broker/gen/model/Roi_circle_list.h +++ b/broker/gen/model/Roi_circle_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_definitions.cpp b/broker/gen/model/Roi_definitions.cpp index e45b88c7..e981e576 100644 --- a/broker/gen/model/Roi_definitions.cpp +++ b/broker/gen/model/Roi_definitions.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_definitions.h b/broker/gen/model/Roi_definitions.h index 6de6c5cf..86bab91e 100644 --- a/broker/gen/model/Roi_definitions.h +++ b/broker/gen/model/Roi_definitions.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Rotation_axis.cpp b/broker/gen/model/Rotation_axis.cpp index 2effdada..f6168626 100644 --- a/broker/gen/model/Rotation_axis.cpp +++ b/broker/gen/model/Rotation_axis.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Rotation_axis.h b/broker/gen/model/Rotation_axis.h index 3ecb439e..8aea9c0a 100644 --- a/broker/gen/model/Rotation_axis.h +++ b/broker/gen/model/Rotation_axis.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result.cpp b/broker/gen/model/Scan_result.cpp index 7a3048e2..4e376476 100644 --- a/broker/gen/model/Scan_result.cpp +++ b/broker/gen/model/Scan_result.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result.h b/broker/gen/model/Scan_result.h index 460c8b2e..55c274a6 100644 --- a/broker/gen/model/Scan_result.h +++ b/broker/gen/model/Scan_result.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result_images_inner.cpp b/broker/gen/model/Scan_result_images_inner.cpp index 36f0113d..7baf50cc 100644 --- a/broker/gen/model/Scan_result_images_inner.cpp +++ b/broker/gen/model/Scan_result_images_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result_images_inner.h b/broker/gen/model/Scan_result_images_inner.h index e01ecaa5..a53a7933 100644 --- a/broker/gen/model/Scan_result_images_inner.h +++ b/broker/gen/model/Scan_result_images_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Spot_finding_settings.cpp b/broker/gen/model/Spot_finding_settings.cpp index c487fcbf..6f7fd9e4 100644 --- a/broker/gen/model/Spot_finding_settings.cpp +++ b/broker/gen/model/Spot_finding_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Spot_finding_settings.h b/broker/gen/model/Spot_finding_settings.h index c5915e32..b0f07f12 100644 --- a/broker/gen/model/Spot_finding_settings.h +++ b/broker/gen/model/Spot_finding_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Standard_detector_geometry.cpp b/broker/gen/model/Standard_detector_geometry.cpp index 7200b438..8fc9b780 100644 --- a/broker/gen/model/Standard_detector_geometry.cpp +++ b/broker/gen/model/Standard_detector_geometry.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Standard_detector_geometry.h b/broker/gen/model/Standard_detector_geometry.h index d8a6ef52..e959e9e7 100644 --- a/broker/gen/model/Standard_detector_geometry.h +++ b/broker/gen/model/Standard_detector_geometry.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Unit_cell.cpp b/broker/gen/model/Unit_cell.cpp index ea0e071a..e8037ddc 100644 --- a/broker/gen/model/Unit_cell.cpp +++ b/broker/gen/model/Unit_cell.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Unit_cell.h b/broker/gen/model/Unit_cell.h index 4656c232..fccc453e 100644 --- a/broker/gen/model/Unit_cell.h +++ b/broker/gen/model/Unit_cell.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_metadata_settings.cpp b/broker/gen/model/Zeromq_metadata_settings.cpp index 4e8bf878..4983cf88 100644 --- a/broker/gen/model/Zeromq_metadata_settings.cpp +++ b/broker/gen/model/Zeromq_metadata_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_metadata_settings.h b/broker/gen/model/Zeromq_metadata_settings.h index 897cd475..a666ae77 100644 --- a/broker/gen/model/Zeromq_metadata_settings.h +++ b/broker/gen/model/Zeromq_metadata_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_preview_settings.cpp b/broker/gen/model/Zeromq_preview_settings.cpp index 364248f7..1148bc5e 100644 --- a/broker/gen/model/Zeromq_preview_settings.cpp +++ b/broker/gen/model/Zeromq_preview_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_preview_settings.h b/broker/gen/model/Zeromq_preview_settings.h index ae9c1c5c..f76e1448 100644 --- a/broker/gen/model/Zeromq_preview_settings.h +++ b/broker/gen/model/Zeromq_preview_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_settings.cpp b/broker/gen/model/Zeromq_settings.cpp index c97ed6f7..ffff8c22 100644 --- a/broker/gen/model/Zeromq_settings.cpp +++ b/broker/gen/model/Zeromq_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_settings.h b/broker/gen/model/Zeromq_settings.h index 9715f1f1..85b43a4c 100644 --- a/broker/gen/model/Zeromq_settings.h +++ b/broker/gen/model/Zeromq_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.100 +* The version of the OpenAPI document: 1.0.0-rc.101 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/jfjoch_api.yaml b/broker/jfjoch_api.yaml index e55b0d93..1df34f0a 100644 --- a/broker/jfjoch_api.yaml +++ b/broker/jfjoch_api.yaml @@ -22,7 +22,7 @@ info: requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. - version: 1.0.0-rc.100 + version: 1.0.0-rc.101 contact: name: Filip Leonarski (Paul Scherrer Institute) email: filip.leonarski@psi.ch diff --git a/broker/redoc-static.html b/broker/redoc-static.html index 12513dce..01837097 100644 --- a/broker/redoc-static.html +++ b/broker/redoc-static.html @@ -405,7 +405,7 @@ Get user mask of the detector (TIFF) 55.627 l 55.6165,55.627 -231.245496,231.24803 c -127.185,127.1864 -231.5279,231.248 -231.873,231.248 -0.3451,0 -104.688, -104.0616 -231.873,-231.248 z - " fill="currentColor">

Jungfraujoch (1.0.0-rc.100)

Download OpenAPI specification:

Filip Leonarski (Paul Scherrer Institute): filip.leonarski@psi.ch License: GPL-3.0

Jungfraujoch (1.0.0-rc.101)

Download OpenAPI specification:

Filip Leonarski (Paul Scherrer Institute): filip.leonarski@psi.ch License: GPL-3.0

API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). @@ -1395,7 +1395,7 @@ then image might be replaced in the buffer between calling /images and /image.cb " class="sc-eVqvcJ sc-fszimp kIppRw drqpJr">

Test Jungfraujoch system

http://localhost:5232/version