Jungfraujoch/broker/OpenAPIConvert.cpp

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#include "../common/JFJochMath.h"
#include "OpenAPIConvert.h"

// From https://en.cppreference.com/w/cpp/string/byte/tolower
std::string str_tolower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c){ return std::tolower(c); });
    return s;
}

SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding_settings &input) {
    SpotFindingSettings ret{};
    ret.signal_to_noise_threshold = input.getSignalToNoiseThreshold();
    ret.photon_count_threshold = input.getPhotonCountThreshold();
    ret.min_pix_per_spot = input.getMinPixPerSpot();
    ret.max_pix_per_spot = input.getMaxPixPerSpot();
    // Both limits are optional and unset means "no limit at that end". A value of 0 has meant the same
    // thing since rc.161 and clients still send it that way, so fold it into the unset case here - the
    // analysis code then has exactly one spelling for "no limit" and no zero to special-case.
    if (input.highResolutionLimitIsSet() && input.getHighResolutionLimit() > 0)
        ret.high_resolution_limit = input.getHighResolutionLimit();
    if (input.lowResolutionLimitIsSet() && input.getLowResolutionLimit() > 0)
        ret.low_resolution_limit = input.getLowResolutionLimit();
    ret.enable = input.isEnable();
    ret.indexing = input.isIndexing();
    ret.quick_integration = input.isQuickIntegration();
    ret.cutoff_spot_count_low_res = input.getHighResolutionLimitForSpotCountLowRes();
    ret.ice_ring_width_Q_recipA = input.getIceRingWidthQRecipA();
    if (input.highResGapQRecipAIsSet())
        ret.high_res_gap_Q_recipA = input.getHighResGapQRecipA();
    if (input.adaptiveThresholdIsSet())
        ret.adaptive_threshold = input.isAdaptiveThreshold();
    if (input.falsePixelsPerFrameIsSet())
        ret.false_pixels_per_frame = input.getFalsePixelsPerFrame();
    return ret;
}

org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindingSettings &input) {
    org::openapitools::server::model::Spot_finding_settings ret;
    ret.setSignalToNoiseThreshold(input.signal_to_noise_threshold);
    ret.setPhotonCountThreshold(input.photon_count_threshold);
    ret.setMinPixPerSpot(input.min_pix_per_spot.value_or(2));
    ret.setMaxPixPerSpot(input.max_pix_per_spot);
    if (input.high_resolution_limit.has_value())
        ret.setHighResolutionLimit(input.high_resolution_limit.value());
    if (input.low_resolution_limit.has_value())
        ret.setLowResolutionLimit(input.low_resolution_limit.value());
    ret.setEnable(input.enable);
    ret.setIndexing(input.indexing);
    ret.setHighResolutionLimitForSpotCountLowRes(input.cutoff_spot_count_low_res);
    ret.setQuickIntegration(input.quick_integration);
    ret.setIceRingWidthQRecipA(input.ice_ring_width_Q_recipA);
    if (input.high_res_gap_Q_recipA.has_value())
        ret.setHighResGapQRecipA(input.high_res_gap_Q_recipA.value());
    ret.setAdaptiveThreshold(input.adaptive_threshold);
    ret.setFalsePixelsPerFrame(input.false_pixels_per_frame);
    return ret;
}

org::openapitools::server::model::Measurement_statistics Convert(const MeasurementStatistics &input) {
    org::openapitools::server::model::Measurement_statistics ret{};

    if (!input.file_prefix.empty())
        ret.setFilePrefix(input.file_prefix);

    ret.setExperimentGroup(input.experiment_group);
    ret.setImagesExpected(input.images_expected);
    ret.setImagesCollected(input.images_collected);
    ret.setImagesSent(input.images_sent);
    ret.setImagesDiscardedLossyCompression(input.images_skipped);
    ret.setMaxImageNumberSent(input.max_image_number_sent);
    if (input.collection_efficiency)
        ret.setCollectionEfficiency(input.collection_efficiency.value());
    if (input.compression_ratio)
        ret.setCompressionRatio(input.compression_ratio.value());

    ret.setCancelled(input.cancelled);
    if (input.max_receive_delay)
        ret.setMaxReceiverDelay(input.max_receive_delay.value());

    ret.setDetectorWidth(input.detector_width);
    ret.setDetectorHeight(input.detector_height);
    ret.setDetectorPixelDepth(input.detector_pixel_depth);

    if (input.roi_beam_npixel)
        ret.setRoiBeamPixels(input.roi_beam_npixel.value());
    if (input.roi_beam_sum)
        ret.setRoiBeamSum(input.roi_beam_sum.value());

    if (input.error_pixels)
        ret.setErrorPixels(input.error_pixels.value());
    if (input.saturated_pixels)
        ret.setSaturatedPixels(input.saturated_pixels.value());

    if (input.indexing_rate)
        ret.setIndexingRate(input.indexing_rate.value());

    if (input.bkg_estimate)
        ret.setBkgEstimate(input.bkg_estimate.value());
    ret.setUnitCell(input.unit_cell);
    ret.setRunNumber(input.run_number);
    if (input.images_written)
        ret.setImagesWritten(input.images_written.value());
    return ret;
}

DetectorTiming Convert(const org::openapitools::server::model::Detector_timing& input) {
    switch (input.getValue()) {
        case org::openapitools::server::model::Detector_timing::eDetector_timing::AUTO:
            return DetectorTiming::Auto;
        case org::openapitools::server::model::Detector_timing::eDetector_timing::TRIGGER:
            return DetectorTiming::Trigger;
        case org::openapitools::server::model::Detector_timing::eDetector_timing::BURST:
            return DetectorTiming::Burst;
        case org::openapitools::server::model::Detector_timing::eDetector_timing::GATED:
            return DetectorTiming::Gated;
        default:
        case org::openapitools::server::model::Detector_timing::eDetector_timing::INVALID_VALUE_OPENAPI_GENERATED:
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "invalid input");
    }
}

org::openapitools::server::model::Detector_timing Convert(DetectorTiming input) {
    org::openapitools::server::model::Detector_timing val;
    switch (input) {

        case DetectorTiming::Auto:
            val.setValue(org::openapitools::server::model::Detector_timing::eDetector_timing::AUTO);
            break;
        case DetectorTiming::Trigger:
            val.setValue(org::openapitools::server::model::Detector_timing::eDetector_timing::TRIGGER);
            break;
        case DetectorTiming::Burst:
            val.setValue(org::openapitools::server::model::Detector_timing::eDetector_timing::BURST);
            break;
        case DetectorTiming::Gated:
            val.setValue(org::openapitools::server::model::Detector_timing::eDetector_timing::GATED);
            break;
        default:
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "invalid input");
    }
    return val;
}

DetectorSettings Convert(const org::openapitools::server::model::Detector_settings &input) {
    DetectorSettings ret{};

    if (input.countTimeUsIsSet())
        ret.FrameTime(std::chrono::microseconds(input.getFrameTimeUs()),
                      std::chrono::microseconds(input.getCountTimeUs()));
    else
        ret.FrameTime(std::chrono::microseconds(input.getFrameTimeUs()));

    ret.InternalGeneratorEnable(input.isInternalFrameGenerator());
    ret.InternalGeneratorImages(input.getInternalFrameGeneratorImages());
    ret.DetectorDelay(std::chrono::nanoseconds(input.getDetectorTriggerDelayNs()));

    ret.StorageCells(input.getJungfrauStorageCellCount());
    ret.StorageCellDelay(std::chrono::nanoseconds(input.getJungfrauStorageCellDelayNs()));

    ret.FixGainG1(input.isJungfrauFixedGainG1());
    ret.UseGainHG0(input.isJungfrauUseGainHg0());

    ret.PedestalG0Frames(input.getJungfrauPedestalG0Frames());
    ret.PedestalG1Frames(input.getJungfrauPedestalG1Frames());
    ret.PedestalG2Frames(input.getJungfrauPedestalG2Frames());
    ret.PedestalMinImageCount(input.getJungfrauPedestalMinImageCount());

    if (input.eigerBitDepthIsSet())
            ret.EigerBitDepth(input.getEigerBitDepth());

    if (input.eigerThresholdKeVIsSet())
        ret.EigerThreshold_keV(input.getEigerThresholdKeV());

    if (input.timingIsSet())
        ret.Timing(Convert(input.getTiming()));
    else
        ret.Timing(DetectorTiming::Trigger);
    return ret;
}

org::openapitools::server::model::Detector_settings Convert(const DetectorSettings &input) {
    org::openapitools::server::model::Detector_settings ret{};

    ret.setFrameTimeUs(std::chrono::round<std::chrono::microseconds>(
        std::chrono::duration<float>(input.GetFrameTime())).count());
    if (input.GetCountTime().has_value())
        ret.setCountTimeUs(std::chrono::round<std::chrono::microseconds>(
            std::chrono::duration<float>(input.GetCountTime().value())
        ).count());
    ret.setDetectorTriggerDelayNs(input.GetDetectorDelay().count());
    ret.setInternalFrameGeneratorImages(input.GetInternalGeneratorImages());
    ret.setInternalFrameGenerator(input.IsInternalGeneratorEnable());

    ret.setJungfrauStorageCellCount(input.GetStorageCells());
    ret.setJungfrauFixedGainG1(input.IsFixGainG1());
    ret.setJungfrauUseGainHg0(input.IsUseGainHG0());

    ret.setJungfrauPedestalG0Frames(input.GetPedestalG0Frames());
    ret.setJungfrauPedestalG1Frames(input.GetPedestalG1Frames());
    ret.setJungfrauPedestalG2Frames(input.GetPedestalG2Frames());
    ret.setJungfrauPedestalMinImageCount(input.GetPedestalMinImageCount());

    ret.setJungfrauStorageCellDelayNs(input.GetStorageCellDelay().count());
    if (input.GetEigerThreshold_keV().has_value())
        ret.setEigerThresholdKeV(input.GetEigerThreshold_keV().value());
    if (input.GetEigerBitDepth().has_value())
        ret.setEigerBitDepth(input.GetEigerBitDepth().value());

    ret.setTiming(Convert(input.GetTiming()));
    return ret;
}

org::openapitools::server::model::Broker_status Convert(const BrokerStatus& input) {
    org::openapitools::server::model::Broker_status ret;

    switch (input.state) {
        case JFJochState::Inactive:
            ret.setState("Inactive");
            break;
        case JFJochState::Idle:
            ret.setState("Idle");
            break;
        case JFJochState::Measuring:
            ret.setState("Measuring");
            break;
        case JFJochState::Error:
            ret.setState("Error");
            break;
        case JFJochState::Busy:
            ret.setState("Busy");
            break;
        case JFJochState::Calibration:
            ret.setState("Pedestal");
            break;
    }

    if (input.message.has_value())
        ret.setMessage(input.message.value());

    switch (input.message_severity) {
        case BrokerStatus::MessageSeverity::Info:
            ret.setMessageSeverity("info");
            break;
        case BrokerStatus::MessageSeverity::Success:
            ret.setMessageSeverity("success");
            break;
        case BrokerStatus::MessageSeverity::Warning:
            ret.setMessageSeverity("warning");
            break;
        default:
            ret.setMessageSeverity("error");
            break;
    }
    if (input.progress.has_value())
        ret.setProgress(input.progress.value());

    ret.setGpuCount(input.gpu_count);
    ret.setBrokerVersion(input.broker_version);
    return ret;
}

org::openapitools::server::model::Calibration_statistics_inner Convert(const JFCalibrationModuleStatistics& input) {
    org::openapitools::server::model::Calibration_statistics_inner output;

    output.setModuleNumber(input.module_number);
    output.setMaskedPixels(input.bad_pixels);
    output.setStorageCellNumber(input.storage_cell_number);
    output.setGainG0Mean(input.gain_g0_mean);
    output.setGainG1Mean(input.gain_g1_mean);
    output.setGainG2Mean(input.gain_g2_mean);
    output.setPedestalG0Mean(input.pedestal_g0_mean);
    output.setPedestalG1Mean(input.pedestal_g1_mean);
    output.setPedestalG2Mean(input.pedestal_g2_mean);

    return output;
}

std::vector<org::openapitools::server::model::Calibration_statistics_inner> Convert(const std::vector<JFCalibrationModuleStatistics>& input) {
    std::vector<org::openapitools::server::model::Calibration_statistics_inner> ret;
    for (const auto &i: input)
        ret.push_back(Convert(i));
    return ret;
}


org::openapitools::server::model::Instrument_metadata Convert(const InstrumentMetadata& input) {
    org::openapitools::server::model::Instrument_metadata output;
    output.setInstrumentName(input.GetInstrumentName());
    output.setSourceName(input.GetSourceName());
    output.setSourceType(input.GetSourceType());
    output.setPulsedSource(input.IsPulsedSource());
    output.setElectronSource(input.IsElectronSource());
    return output;
}

InstrumentMetadata Convert(const org::openapitools::server::model::Instrument_metadata &input) {
    InstrumentMetadata output;
    output.InstrumentName(input.getInstrumentName())
            .SourceName(input.getSourceName())
            .SourceType(input.getSourceType())
            .PulsedSource(input.isPulsedSource())
            .ElectronSource(input.isElectronSource());
    return output;
}


org::openapitools::server::model::Detector_state Convert(DetectorState input) {
    org::openapitools::server::model::Detector_state ret;
    switch (input) {
        case DetectorState::IDLE:
            ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::IDLE);
            break;
        case DetectorState::ERROR:
            ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::ERROR);
            break;
        case DetectorState::BUSY:
            ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::BUSY);
            break;
        case DetectorState::WAITING:
            ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::WAITING);
            break;
        default:
        case DetectorState::NOT_CONNECTED:
            ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::NOT_CONNECTED);
            break;
    }
    return ret;
}

org::openapitools::server::model::Detector_power_state Convert(DetectorPowerState input) {
    org::openapitools::server::model::Detector_power_state ret;
    switch (input) {
        case DetectorPowerState::ON:
            ret.setValue(org::openapitools::server::model::Detector_power_state::eDetector_power_state::POWERON);
            break;
        case DetectorPowerState::PARTIAL:
            ret.setValue(org::openapitools::server::model::Detector_power_state::eDetector_power_state::PARTIAL);
            break;
        default:
        case DetectorPowerState::OFF:
            ret.setValue(org::openapitools::server::model::Detector_power_state::eDetector_power_state::POWEROFF);
            break;
    }
    return ret;
}

org::openapitools::server::model::Detector_status Convert(const DetectorStatus &input) {
    org::openapitools::server::model::Detector_status output;
    output.setServerVersion(input.detector_server_version);
    output.setNumberOfTriggersLeft(input.remaining_triggers);
    output.setFpgaTempDegC(input.temperature_fpga_degC);
    output.setHighVoltageV(input.high_voltage_V);
    output.setPowerchip(Convert(input.power_state));
    output.setState(Convert(input.detector_state));
    return output;
}

org::openapitools::server::model::Detector_type Convert(const DetectorType &input) {
    org::openapitools::server::model::Detector_type dt;
    switch (input) {
        case DetectorType::EIGER:
            dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::EIGER);
            break;
        case DetectorType::JUNGFRAU:
            dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::JUNGFRAU);
            break;
        case DetectorType::DECTRIS:
            dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::DECTRIS);
            break;
    }
    return dt;
}

org::openapitools::server::model::Detector_list Convert(const DetectorList &input) {
    org::openapitools::server::model::Detector_list ret;
    std::vector<org::openapitools::server::model::Detector_list_element> dets;
    for (int i = 0; i < input.detector.size(); i++) {
        org::openapitools::server::model::Detector_list_element d;
        d.setId(i);
        d.setDescription(input.detector[i].description);
        d.setNmodules(input.detector[i].nmodules);
        d.setHeight(input.detector[i].height);
        d.setWidth(input.detector[i].width);
        d.setSerialNumber(input.detector[i].serial_number);
        d.setBaseIpv4Addr(input.detector[i].base_ipv4_addr);
        d.setUdpInterfaceCount(input.detector[i].udp_interface_count);
        d.setMinFrameTimeNs(input.detector[i].min_frame_time.count());
        d.setMinCountTimeNs(input.detector[i].min_count_time.count());
        d.setReadoutTimeNs(input.detector[i].readout_time.count());
        d.setPixelSizeMm(input.detector[i].pixel_size_mm);
        d.setType(Convert(input.detector[i].detector_type));
        dets.emplace_back(std::move(d));
    }
    ret.setDetectors(dets);
    ret.setCurrentId(input.current_id);
    return ret;
}

org::openapitools::server::model::Plots Convert(const MultiLinePlot& input) {
    std::vector<org::openapitools::server::model::Plot> tmp(input.GetPlots().size());
    for (int i = 0; i < input.GetPlots().size(); i++) {
        tmp[i].setTitle(input.GetPlots()[i].title);
        tmp[i].setX(input.GetPlots()[i].x);
        tmp[i].setY(input.GetPlots()[i].y);
        tmp[i].setZ(input.GetPlots()[i].z);
    }

    org::openapitools::server::model::Plots output;
    output.setPlot(tmp);

    org::openapitools::server::model::Plot_unit_x unit;
    switch (input.GetUnits()) {
        case MultiLinePlotUnits::ImageNumber:
            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::IMAGE_NUMBER);
            break;
        case MultiLinePlotUnits::Angle_deg:
            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::ANGLE_DEG);
            break;
        case MultiLinePlotUnits::Q_recipA:
            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::Q_RECIPA);
            break;
        case MultiLinePlotUnits::ADU:
            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::ADU);
            break;
        case MultiLinePlotUnits::d_A:
            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::D_A);
            break;
        case MultiLinePlotUnits::Grid_um:
            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::GRID_UM);
            break;
        default:
            break;
    }
    output.setUnitX(unit);

    if (input.GetSizeX().has_value())
        output.setSizeX(input.GetSizeX().value());

    if (input.GetSizeY().has_value())
        output.setSizeY(input.GetSizeY().value());

    return output;
}

AzimuthalIntegrationSettings Convert(const org::openapitools::server::model::Azim_int_settings& input) {
    AzimuthalIntegrationSettings ret{};
    ret.SolidAngleCorrection(input.isSolidAngleCorr());
    ret.PolarizationCorrection(input.isPolarizationCorr());
    ret.QSpacing_recipA(input.getQSpacing());
    ret.QRange_recipA(input.getLowQRecipA(),
                      input.highQRecipAIsSet() ? std::optional<float>(input.getHighQRecipA())
                                               : std::nullopt);
    ret.AzimuthalBinCount(input.getAzimuthalBins());
    ret.ForceCPUinFPGAWorkflow(input.isForceCpu());
    return ret;
}

org::openapitools::server::model::Azim_int_settings Convert(const AzimuthalIntegrationSettings& settings) {
    org::openapitools::server::model::Azim_int_settings ret{};
    ret.setSolidAngleCorr(settings.IsSolidAngleCorrection());
    ret.setPolarizationCorr(settings.IsPolarizationCorrection());
    if (const auto high_q = settings.GetRequestedHighQ_recipA())
        ret.setHighQRecipA(high_q.value());
    ret.setLowQRecipA(settings.GetLowQ_recipA());
    ret.setQSpacing(settings.GetQSpacing_recipA());
    ret.setAzimuthalBins(settings.GetAzimuthalBinCount());
    ret.setForceCpu(settings.IsForceCPUinFPGAWorkflow());
    return ret;
}

ROIDefinition Convert(const org::openapitools::server::model::Roi_definitions& input) {
    ROIDefinition output{};
    for (const auto &i: input.getBox().getRois())
        output.boxes.emplace_back(ROIBox(i.getName(), i.getMinXPxl(), i.getMaxXPxl(), i.getMinYPxl(), i.getMaxYPxl()));
    for (const auto &i: input.getCircle().getRois())
        output.circles.emplace_back(ROICircle(i.getName(), i.getCenterXPxl(), i.getCenterYPxl(), i.getRadiusPxl()));
    for (const auto &i: input.getAzim().getRois()) {
        // A sector needs both bounds; if only one is given, treat it as a full ring.
        float phi_min = 0, phi_max = 0;
        if (i.phiMinDegIsSet() && i.phiMaxDegIsSet()) {
            phi_min = i.getPhiMinDeg();
            phi_max = i.getPhiMaxDeg();
        }
        output.azimuthal.emplace_back(ROIAzimuthal(i.getName(),
                                                   (i.getQMaxRecipA() == 0.0) ? 0.0 : 2.0f * PI / i.getQMaxRecipA(),
                                                   (i.getQMinRecipA() == 0.0) ? 0.0 : 2.0f * PI / i.getQMinRecipA(),
                                                   phi_min, phi_max));
    }
    return output;
}

org::openapitools::server::model::Roi_circle_list Convert(const std::vector<ROICircle> &input) {
    org::openapitools::server::model::Roi_circle_list ret{};
    std::vector<org::openapitools::server::model::Roi_circle> tmp;
    for (const auto &i: input) {
        org::openapitools::server::model::Roi_circle elem;
        elem.setName(i.GetName());
        elem.setCenterXPxl(i.GetX());
        elem.setCenterYPxl(i.GetY());
        elem.setRadiusPxl(i.GetRadius_pxl());
        tmp.emplace_back(elem);
    }
    ret.setRois(tmp);
    return ret;
}

org::openapitools::server::model::Roi_azim_list Convert(const std::vector<ROIAzimuthal> &input) {
    org::openapitools::server::model::Roi_azim_list ret{};
    std::vector<org::openapitools::server::model::Roi_azimuthal> tmp;
    for (const auto &i: input) {
        org::openapitools::server::model::Roi_azimuthal elem;
        elem.setName(i.GetName());
        elem.setQMinRecipA(i.GetQMin_recipA());
        elem.setQMaxRecipA(i.GetQMax_recipA());
        if (i.HasPhi()) {
            elem.setPhiMinDeg(i.GetPhiMin_deg());
            elem.setPhiMaxDeg(i.GetPhiMax_deg());
        }
        tmp.emplace_back(elem);
    }
    ret.setRois(tmp);
    return ret;
}

org::openapitools::server::model::Roi_box_list Convert(const std::vector<ROIBox> &input) {
    org::openapitools::server::model::Roi_box_list ret{};
    std::vector<org::openapitools::server::model::Roi_box> tmp;
    for (const auto &i: input) {
        org::openapitools::server::model::Roi_box elem;
        elem.setName(i.GetName());
        elem.setMinXPxl(i.GetXMin());
        elem.setMaxXPxl(i.GetXMax());
        elem.setMinYPxl(i.GetYMin());
        elem.setMaxYPxl(i.GetYMax());
        tmp.emplace_back(elem);
    }
    ret.setRois(tmp);
    return ret;
}

org::openapitools::server::model::Roi_definitions Convert(const ROIDefinition &input) {
    org::openapitools::server::model::Roi_definitions ret{};
    ret.setCircle(Convert(input.circles));
    ret.setBox(Convert(input.boxes));
    ret.setAzim(Convert(input.azimuthal));
    return ret;
}

ImageFormatSettings Convert(const org::openapitools::server::model::Image_format_settings& input) {
    ImageFormatSettings ret{};
    ret.GeometryTransformed(input.isGeometryTransform());
    ret.AutoSummation(input.isSummation());
    ret.JungfrauConversion(input.isJungfrauConversion());
    ret.MaskChipEdges(input.isMaskChipEdges());
    ret.MaskModuleEdges(input.isMaskModuleEdges());
    ret.ApplyPixelMask(input.isApplyMask());
    ret.PedestalG0RMSLimit(input.getJungfrauPedestalG0RmsLimit());
    ret.MaskPixelsWithoutG0(input.isJungfrauMaskPixelsWithoutG0());
    if (input.signedOutputIsSet())
        ret.PixelSigned(input.isSignedOutput());
    if (input.jungfrauConversionFactorKeVIsSet())
        ret.JungfrauConvFactor_keV(input.getJungfrauConversionFactorKeV());
    if (input.bitDepthImageIsSet())
        ret.BitDepthImage(input.getBitDepthImage());
    return ret;
}

org::openapitools::server::model::Image_format_settings Convert(const ImageFormatSettings& input) {
    org::openapitools::server::model::Image_format_settings ret{};
    ret.setGeometryTransform(input.IsGeometryTransformed());
    ret.setSummation(input.IsAutoSummation());
    ret.setJungfrauConversion(input.IsJungfrauConversion());
    ret.setMaskChipEdges(input.IsMaskChipEdges());
    ret.setMaskModuleEdges(input.IsMaskModuleEdges());
    ret.setApplyMask(input.IsApplyPixelMask());
    ret.setJungfrauMaskPixelsWithoutG0(input.IsMaskPixelsWithoutG0());
    ret.setJungfrauPedestalG0RmsLimit(input.GetPedestalG0RMSLimit());
    if (input.IsPixelSigned().has_value())
        ret.setSignedOutput(input.IsPixelSigned().value());
    if (input.GetJungfrauConvFactor_keV().has_value())
        ret.setJungfrauConversionFactorKeV(input.GetJungfrauConvFactor_keV().value());
    if (input.GetBitDepthImage().has_value())
        ret.setBitDepthImage(input.GetBitDepthImage().value());
    return ret;
}

Coord ConvertOpenAPI(const std::vector<float> &input) {
    if (input.size() != 3)
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Wrong size of Coord array");
    return {input[0], input[1], input[2]};
}

GoniometerAxis Convert(const org::openapitools::server::model::Rotation_axis& input) {
    std::optional<Coord> helical;
    if (input.helicalStepUmIsSet())
        helical = ConvertOpenAPI(input.getHelicalStepUm());

    GoniometerAxis axis{input.getName(), input.getStart(), input.getStep(),
            ConvertOpenAPI(input.getVector()), helical};
    if (input.screeningWedgeDegIsSet())
        axis.ScreeningWedge(input.getScreeningWedgeDeg());
    return axis;
}

GridScanSettings Convert(const org::openapitools::server::model::Grid_scan& input) {
    return {input.getNFast(), input.getStepXUm(), input.getStepYUm(), input.isSnake(), input.isVertical()};
}

DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings& input) {
    DatasetSettings ret;

    ret.ImagesPerTrigger(input.getImagesPerTrigger());
    ret.NumTriggers(input.getNtrigger());

    if (input.runNumberIsSet())
        ret.RunNumber(input.getRunNumber());
    if (input.runNameIsSet())
        ret.RunName(input.getRunName());

    ret.ExperimentGroup(input.getExperimentGroup());

    if (input.imageTimeUsIsSet())
        ret.ImageTime(std::chrono::microseconds(input.getImageTimeUs()));
    ret.BeamX_pxl(input.getBeamXPxl());
    ret.BeamY_pxl(input.getBeamYPxl());
    ret.DetectorDistance_mm(input.getDetectorDistanceMm());
    ret.PhotonEnergy_keV(input.getIncidentEnergyKeV());

    ret.FilePrefix(input.getFilePrefix());

    if (!input.compressionIsSet())
        ret.Compression(CompressionAlgorithm::BSHUF_LZ4);
    else {
        std::string compr = str_tolower(input.getCompression());
        if (compr == "bslz4")
            ret.Compression(CompressionAlgorithm::BSHUF_LZ4);
        else if (compr == "bszstd")
            ret.Compression(CompressionAlgorithm::BSHUF_ZSTD);
        else if (compr == "bszstd_rle")
            ret.Compression(CompressionAlgorithm::BSHUF_ZSTD_RLE);
        else if (compr == "bszstd_rlehuf")
            ret.Compression(CompressionAlgorithm::BSHUF_ZSTD_RLE_HUFF);
        else if (compr == "none")
            ret.Compression(CompressionAlgorithm::NO_COMPRESSION);
        else
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown compression");
    }
    if (input.poissonCompressionIsSet())
        ret.LossyCompressionPoisson(input.getPoissonCompression());

    if (input.unitCellIsSet())
        ret.SetUnitCell(UnitCell{
                .a = input.getUnitCell().getA(),
                .b = input.getUnitCell().getB(),
                .c = input.getUnitCell().getC(),
                .alpha = input.getUnitCell().getAlpha(),
                .beta = input.getUnitCell().getBeta(),
                .gamma = input.getUnitCell().getGamma()
        });

    if (input.totalFluxIsSet())
        ret.TotalFlux(input.getTotalFlux());
    if (input.transmissionIsSet())
        ret.AttenuatorTransmission(input.getTransmission());
    if (input.goniometerIsSet())
        ret.Goniometer(Convert(input.getGoniometer()));
    else if (input.gridScanIsSet())
        ret.GridScan(Convert(input.getGridScan()));

    if (input.spaceGroupNumberIsSet())
        ret.SpaceGroupNumber(input.getSpaceGroupNumber());
    ret.SampleName(input.getSampleName());
    ret.HeaderAppendix(input.getHeaderAppendix());
    ret.ImageAppendix(input.getImageAppendix());
    ret.ImagesPerFile(input.getImagesPerFile());

    if (input.dataReductionFactorSerialmxIsSet())
        ret.LossyCompressionSerialMX(input.getDataReductionFactorSerialmx());

    if (input.pixelValueLowThresholdIsSet())
        ret.PixelValueLowThreshold(input.getPixelValueLowThreshold());

    if (input.saveCalibrationIsSet())
        ret.SaveCalibration(input.isSaveCalibration());

    ret.WriteNXmxHDF5Master(input.isWriteNxmxHdf5Master());

    if (input.polarizationFactorIsSet())
        ret.PolarizationFactor(input.getPolarizationFactor());

    ret.PoniRot1_rad(input.getPoniRot1Rad());
    ret.PoniRot2_rad(input.getPoniRot2Rad());
    ret.PoniRot3_rad(input.getPoniRot3Rad());

    if (input.ringCurrentMAIsSet())
        ret.RingCurrent_mA(input.getRingCurrentMA());
    if (input.sampleTemperatureKIsSet())
        ret.SampleTemperature_K(input.getSampleTemperatureK());

    ret.SpotFindingEnable(input.isSpotFinding());
    ret.MaxSpotCount(input.getMaxSpotCount());

    ret.DetectIceRings(input.isDetectIceRings());

    if (input.xrayFluorescenceSpectrumIsSet()) {
        auto fl = input.getXrayFluorescenceSpectrum();
        ret.FluorescenceSpectrum({fl.getEnergyEV(), fl.getData()});
    }

    if (input.smargonIsSet()) {
        auto sm = input.getSmargon();
        SmargonPosition smargon;
        smargon.phi_deg = sm.getPhiDeg();
        smargon.chi_deg = sm.getChiDeg();
        if (sm.phiAxisIsSet())
            smargon.phi_axis = ConvertOpenAPI(sm.getPhiAxis());
        if (sm.chiAxisIsSet())
            smargon.chi_axis = ConvertOpenAPI(sm.getChiAxis());
        ret.Smargon(smargon);
    }

    return ret;
}

std::vector<org::openapitools::server::model::Fpga_status_inner> Convert(const std::vector<DeviceStatus> &input) {
    std::vector<org::openapitools::server::model::Fpga_status_inner>  ret;
    for (const auto &d: input) {
        org::openapitools::server::model::Fpga_status_inner tmp;
        tmp.setPciDevId(d.device_number);
        tmp.setSerialNumber(d.serial_number);
        tmp.setFwVersion(d.fpga_firmware_version);
        tmp.setBaseMacAddr(MacAddressToStr(d.fpga_default_mac_addr));
        tmp.setPacketsSls(d.packets_sls);
        tmp.setPacketsUdp(d.packets_udp);
        tmp.setEthLinkCount(d.eth_link_count);
        tmp.setEthLinkStatus(d.eth_link_status);
        tmp.setFpgaTempC(static_cast<float>(d.fpga_temp_C));
        tmp.setHbmTempC(static_cast<float>(d.hbm_0_temp_C));
        tmp.setPowerUsageW(static_cast<float>(d.fpga_pcie_12V_I_mA * d.fpga_pcie_12V_V_mV + d.fpga_pcie_3p3V_I_mA
        * d.fpga_pcie_3p3V_V_mV) / (1000.0f * 1000.0f));
        tmp.setIdle(d.idle);
        tmp.setPcieLinkSpeed(d.pcie_link_speed);
        tmp.setPcieLinkWidth(d.pcie_link_width);
        ret.emplace_back(std::move(tmp));
    }
    return ret;
}

ZMQPreviewSettings Convert(const org::openapitools::server::model::Zeromq_preview_settings &input) {
    ZMQPreviewSettings ret;
    if (input.isEnabled())
        ret.period = std::chrono::milliseconds(input.getPeriodMs());
    else
        ret.period = {};
    ret.address = "";
    return ret;
}

ZMQMetadataSettings Convert(const org::openapitools::server::model::Zeromq_metadata_settings &input) {
    ZMQMetadataSettings ret;
    if (input.isEnabled())
        ret.period = std::chrono::milliseconds(input.getPeriodMs());
    else
        ret.period = {};
    ret.address = "";
    return ret;
}

org::openapitools::server::model::Zeromq_preview_settings Convert(const ZMQPreviewSettings &settings) {
    org::openapitools::server::model::Zeromq_preview_settings ret;
    ret.setEnabled(settings.period.has_value());
    if (settings.period.has_value())
        ret.setPeriodMs(std::chrono::round<std::chrono::milliseconds>(settings.period.value()).count());
    ret.setSocketAddress(settings.address);
    return ret;
}

org::openapitools::server::model::Zeromq_metadata_settings Convert(const ZMQMetadataSettings &settings) {
    org::openapitools::server::model::Zeromq_metadata_settings ret;
    ret.setEnabled(settings.period.has_value());
    if (settings.period.has_value())
        ret.setPeriodMs(std::chrono::round<std::chrono::milliseconds>(settings.period.value()).count());
    ret.setSocketAddress(settings.address);
    return ret;
}

org::openapitools::server::model::Pixel_mask_statistics Convert(const PixelMaskStatistics& input) {
    org::openapitools::server::model::Pixel_mask_statistics ret;
    ret.setUserMask(input.user_mask);
    ret.setWrongGain(input.error_pixel);
    ret.setTooHighPedestalRms(input.noisy_pixel);
    return ret;
}

org::openapitools::server::model::Image_buffer_status Convert(const ImageBufferStatus& input) {
    org::openapitools::server::model::Image_buffer_status ret;
    ret.setAvailableSlots(input.available_slots);
    ret.setTotalSlots(input.total_slots);
    ret.setImageNumbers(input.images_in_the_buffer);
    ret.setMaxImageNumber(input.max_image_number);
    ret.setMinImageNumber(input.min_image_number);
    ret.setInPreparationSlots(input.preparation_slots);
    ret.setInSendingSlots(input.sending_slots);

    if (input.current_counter.has_value())
        ret.setCurrentCounter(input.current_counter.value());
    return ret;
}

ImageBufferStatus Convert(const org::openapitools::server::model::Image_buffer_status& input) {
    ImageBufferStatus ret;
    ret.available_slots = input.getAvailableSlots();
    ret.total_slots = input.getTotalSlots();
    ret.images_in_the_buffer = input.getImageNumbers();
    ret.max_image_number = input.getMaxImageNumber();
    ret.min_image_number = input.getMinImageNumber();
    ret.sending_slots = input.getInSendingSlots();
    ret.preparation_slots = input.getInPreparationSlots();

    if (input.currentCounterIsSet())
        ret.current_counter = input.getCurrentCounter();
    return ret;
}

org::openapitools::server::model::File_writer_settings Convert(const FileWriterSettings& input) {
    org::openapitools::server::model::File_writer_settings ret;
    ret.setFormat(Convert(input.GetFileFormat()));
    ret.setOverwrite(input.IsOverwriteExistingFiles());
    return ret;
}

FileWriterSettings Convert(const org::openapitools::server::model::File_writer_settings &input) {
    FileWriterSettings ret;
    ret.OverwriteExistingFiles(input.isOverwrite());
    ret.FileFormat(Convert(input.getFormat()));
    return ret;
}

org::openapitools::server::model::File_writer_format Convert(FileWriterFormat input) {
    org::openapitools::server::model::File_writer_format ret;
    switch (input) {
        case FileWriterFormat::DataOnly:
            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXONLYDATA);
            break;
        case FileWriterFormat::NXmxLegacy:
            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXLEGACY);
            break;
        case FileWriterFormat::NXmxVDS:
            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXVDS);
            break;
        case FileWriterFormat::NXmxIntegrated:
            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXINTEGRATED);
            break;
        case FileWriterFormat::NoFile:
            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NOFILEWRITTEN);
            break;
        default:
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown file writer format enum value");
    }
    return ret;
}

FileWriterFormat Convert(const org::openapitools::server::model::File_writer_format& input) {
    switch (input.getValue()) {
        case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXONLYDATA:
            return FileWriterFormat::DataOnly;
        case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXLEGACY:
            return FileWriterFormat::NXmxLegacy;
        case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXVDS:
            return FileWriterFormat::NXmxVDS;
        case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXINTEGRATED:
            return FileWriterFormat::NXmxIntegrated;
        case org::openapitools::server::model::File_writer_format::eFile_writer_format::CBF:
        case org::openapitools::server::model::File_writer_format::eFile_writer_format::TIFF:
            // Deprecated, kept in the OpenAPI enum for back compatibility only - only HDF5 is written now.
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                                  "CBF and TIFF file formats are no longer supported");
        case org::openapitools::server::model::File_writer_format::eFile_writer_format::NOFILEWRITTEN:
            return FileWriterFormat::NoFile;
        default:
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                                  "Unknown file writer format enum value");
    }
}

PlotType ConvertPlotType(const std::optional<std::string>& input) {
    if (!input.has_value())
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                              "Plot type is compulsory paramater");
    if (input == "bkg_estimate") return PlotType::BkgEstimate;
    if (input == "ice_ring_score") return PlotType::IceRingScore;
    if (input == "azint") return PlotType::AzInt;
    if (input == "azint_1d") return PlotType::AzInt1D;
    if (input == "spot_count") return PlotType::SpotCount;
    if (input == "spot_count_low_res") return PlotType::SpotCountLowRes;
    if (input == "spot_count_indexed") return PlotType::SpotCountIndexed;
    if (input == "spot_count_ice") return PlotType::SpotCountIceRing;
    if (input == "indexing_rate") return PlotType::IndexingRate;
    if (input == "indexing_unit_cell_length") return PlotType::IndexingUnitCellLength;
    if (input == "profile_radius") return PlotType::ProfileRadius;
    if (input == "mosaicity") return PlotType::Mosaicity;
    if (input == "b_factor") return PlotType::BFactor;
    if (input == "indexing_unit_cell_angle") return PlotType::IndexingUnitCellAngle;
    if (input == "error_pixels") return PlotType::ErrorPixels;
    if (input == "strong_pixels") return PlotType::StrongPixels;
    if (input == "saturated_pixels") return PlotType::SaturatedPixels;
    if (input == "image_collection_efficiency") return PlotType::ImageCollectionEfficiency;
    if (input == "receiver_delay") return PlotType::ReceiverDelay;
    if (input == "receiver_free_send_buf") return PlotType::ReceiverFreeSendBuf;
    if (input == "roi_sum") return PlotType::ROISum;
    if (input == "roi_mean") return PlotType::ROIMean;
    if (input == "roi_max_count") return PlotType::ROIMaxCount;
    if (input == "roi_pixels") return PlotType::ROIPixels;
    if (input == "roi_weighted_x") return PlotType::ROIWeightedX;
    if (input == "roi_weighted_y") return PlotType::ROIWeightedY;
    if (input == "packets_received") return PlotType::PacketsReceived;
    if (input == "max_pixel_value") return PlotType::MaxValue;
    if (input == "resolution_estimate") return PlotType::ResolutionEstimate;
    if (input == "pixel_sum") return PlotType::PixelSum;
    if (input == "processing_time") return PlotType::ImageProcessingTime;
    if (input == "beam_center_x") return PlotType::RefinementBeamX;
    if (input == "beam_center_y") return PlotType::RefinementBeamY;
    if (input == "integrated_reflections") return PlotType::IntegratedReflections;
    if (input == "image_scale_factor") return PlotType::ImageScaleFactor;
    if (input == "image_scale_cc") return PlotType::ImageScaleCC;
    if (input == "compression_ratio") return PlotType::CompressionRatio;
    if (input == "indexing_lattice_count") return PlotType::IndexingLatticeCount;
    throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                          "Plot type not recognized");
}

ColorScaleEnum ConvertColorScale(const std::optional<std::string> &input) {
    std::string color = input.value_or("indigo");

    if (color == "viridis")
        return ColorScaleEnum::Viridis;
    if (color == "bw")
        return ColorScaleEnum::BW;
    if (color == "wb")
        return ColorScaleEnum::WB;
    if (color == "green")
        return ColorScaleEnum::Green;
    if (color == "heat")
        return ColorScaleEnum::Heat;
    if (color == "indigo")
        return ColorScaleEnum::Indigo;
    if (color == "magma")
        return ColorScaleEnum::Magma;
    if (color == "inferno")
        return ColorScaleEnum::Inferno;
    throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                          "Color scale unknown");
}

IndexingSettings Convert(const org::openapitools::server::model::Indexing_settings &input) {
    IndexingSettings ret;
    switch (input.getAlgorithm().getValue()) {
        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFT:
            ret.Algorithm(IndexingAlgorithmEnum::FFT);
            break;
        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFTW:
            ret.Algorithm(IndexingAlgorithmEnum::FFTW);
            break;
        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::NONE:
            ret.Algorithm(IndexingAlgorithmEnum::None);
            break;
        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX:
            ret.Algorithm(IndexingAlgorithmEnum::FFBIDX);
            break;
        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::AUTO:
            ret.Algorithm(IndexingAlgorithmEnum::Auto);
            break;
        default:
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown indexing algorithm");
    }

    switch (input.getGeomRefinementAlgorithm().getValue()) {
        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::INVALID_VALUE_OPENAPI_GENERATED:
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown refinement algorithm");
            break;
        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER:
            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenter);
            break;
        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::ORIENTATIONONLY:
            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::OrientationOnly);
            break;
        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::FLEX:
            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::Flex);
            break;
        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE:
            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::None);
            break;
    }

    ret.FFT_HighResolution_A(input.getFftHighResolutionA());
    ret.FFT_MaxUnitCell_A(input.getFftMaxUnitCellA());
    ret.FFT_MinUnitCell_A(input.getFftMinUnitCellA());
    ret.FFT_NumVectors(input.getFftNumVectors());
    ret.Tolerance(input.getTolerance());
    ret.IndexingThreads(input.getThreadCount());
    ret.UnitCellDistTolerance(input.getUnitCellDistTolerance());
    ret.ViableCellMinSpots(input.getViableCellMinSpots());
    ret.IndexIceRings(input.isIndexIceRings());
    ret.RotationIndexing(input.isRotationIndexing());
    ret.RotationIndexingAngularStride_deg(input.getRotationIndexingAngularStrideDeg());
    ret.RotationIndexingMinAngularRange_deg(input.getRotationIndexingMinAngularRangeDeg());
    ret.BlockingBehavior(input.isBlocking());
    return ret;
}

org::openapitools::server::model::Indexing_settings Convert(const IndexingSettings &input) {
    org::openapitools::server::model::Indexing_settings ret;

    ret.setFftHighResolutionA(input.GetFFT_HighResolution_A());
    ret.setFftMinUnitCellA(input.GetFFT_MinUnitCell_A());
    ret.setFftMaxUnitCellA(input.GetFFT_MaxUnitCell_A());
    ret.setFftNumVectors(input.GetFFT_NumVectors());
    ret.setTolerance(input.GetTolerance());
    ret.setThreadCount(input.GetIndexingThreads());
    ret.setUnitCellDistTolerance(input.GetUnitCellDistTolerance());
    ret.setViableCellMinSpots(input.GetViableCellMinSpots());
    ret.setRotationIndexing(input.GetRotationIndexing());
    ret.setRotationIndexingAngularStrideDeg(input.GetRotationIndexingAngularStride_deg());
    ret.setRotationIndexingMinAngularRangeDeg(input.GetRotationIndexingMinAngularRange_deg());
    ret.setBlocking(input.GetBlockingBehavior());

    org::openapitools::server::model::Geom_refinement_algorithm refinement;
    switch (input.GetGeomRefinementAlgorithm()) {

        case GeomRefinementAlgorithmEnum::None:
            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE);
            break;
        case GeomRefinementAlgorithmEnum::BeamCenter:
            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER);
            break;
        case GeomRefinementAlgorithmEnum::OrientationOnly:
            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::ORIENTATIONONLY);
            break;
        case GeomRefinementAlgorithmEnum::Flex:
            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::FLEX);
            break;
    }

    ret.setGeomRefinementAlgorithm(refinement);

    org::openapitools::server::model::Indexing_algorithm tmp;
    switch (input.GetAlgorithm()) {
        case IndexingAlgorithmEnum::Auto:
            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::AUTO);
            break;
        case IndexingAlgorithmEnum::FFBIDX:
            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX);
            break;
        case IndexingAlgorithmEnum::FFT:
            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFT);
            break;
        case IndexingAlgorithmEnum::FFTW:
            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFTW);
            break;
        case IndexingAlgorithmEnum::None:
            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::NONE);
            break;
    }
    ret.setAlgorithm(tmp);
    ret.setIndexIceRings(input.GetIndexIceRings());
    return ret;
}

BraggIntegrationSettings Convert(const org::openapitools::server::model::Bragg_integration_settings &input) {
    BraggIntegrationSettings ret;
    switch (input.getIntegrationModel().getValue()) {
        case org::openapitools::server::model::Integration_model::eIntegration_model::PROFILEGAUSSIAN:
            ret.Integrator(IntegratorMode::ProfileGaussian);
            break;
        case org::openapitools::server::model::Integration_model::eIntegration_model::PROFILEEMPIRICAL:
            ret.Integrator(IntegratorMode::ProfileEmpirical);
            break;
        case org::openapitools::server::model::Integration_model::eIntegration_model::BOXSUM:
            ret.Integrator(IntegratorMode::BoxSum);
            break;
        default:
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown integration model");
    }
    // Always a concrete number online, never "derive it from the crystal": the generated model holds
    // the schema's default when the request omits the field, so an absent max_hkl arrives here as that
    // default rather than as an absent value. Deriving per crystal would make a live acquisition's
    // per-image cost depend on whichever sample is mounted.
    ret.MaxHKL(input.getMaxHkl());
    return ret;
}

org::openapitools::server::model::Bragg_integration_settings Convert(const BraggIntegrationSettings &input) {
    org::openapitools::server::model::Bragg_integration_settings ret;
    org::openapitools::server::model::Integration_model tmp;
    switch (input.GetIntegrator()) {
        case IntegratorMode::ProfileGaussian:
            tmp.setValue(org::openapitools::server::model::Integration_model::eIntegration_model::PROFILEGAUSSIAN);
            break;
        case IntegratorMode::ProfileEmpirical:
            tmp.setValue(org::openapitools::server::model::Integration_model::eIntegration_model::PROFILEEMPIRICAL);
            break;
        case IntegratorMode::BoxSum:
            tmp.setValue(org::openapitools::server::model::Integration_model::eIntegration_model::BOXSUM);
            break;
    }
    ret.setIntegrationModel(tmp);
    if (const auto max_hkl = input.GetMaxHKL())
        ret.setMaxHkl(*max_hkl);
    return ret;
}

org::openapitools::server::model::Scan_result Convert(const ScanResult& input) {
    org::openapitools::server::model::Scan_result ret;
    ret.setFilePrefix(input.file_prefix);
    std::vector<org::openapitools::server::model::Scan_result_images_inner> v;
    for (const auto &i : input.images) {
        org::openapitools::server::model::Scan_result_images_inner tmp;
        tmp.setEfficiency(i.collection_efficiency);
        tmp.setNumber(i.number);
        if (i.x.has_value())
            tmp.setNx(i.x.value());
        if (i.y.has_value())
            tmp.setNy(i.y.value());

        if (i.bkg.has_value())
            tmp.setBkg(i.bkg.value());

        if (i.angle_deg.has_value())
            tmp.setAngle(i.angle_deg.value());
        if (i.pixel_sum.has_value())
            tmp.setPixelSum(i.pixel_sum.value());
        if (i.max_viable_pixel.has_value())
            tmp.setMax(i.max_viable_pixel.value());
        if (i.sat_pixels.has_value())
            tmp.setSat(i.sat_pixels.value());
        if (i.spot_count.has_value())
            tmp.setSpots(i.spot_count.value());
        if (i.spot_count_ice.has_value())
            tmp.setSpotsIce(i.spot_count_ice.value());
        if (i.ice_ring_score.has_value())
            tmp.setIce(i.ice_ring_score.value());
        if (i.spot_count_low_res.has_value())
            tmp.setSpotsLowRes(i.spot_count_low_res.value());
        if (i.spot_count_indexed.has_value())
            tmp.setSpotsIndexed(i.spot_count_indexed.value());
        if (i.indexing_solution.has_value())
            tmp.setIndex(i.indexing_solution.value());
        if (i.profile_radius.has_value())
            tmp.setPr(i.profile_radius.value());
        if (i.b_factor.has_value())
            tmp.setB(i.b_factor.value());
        if (i.uc.has_value()) {
            org::openapitools::server::model::Unit_cell uc;
            uc.setA(i.uc->a);
            uc.setB(i.uc->b);
            uc.setC(i.uc->c);
            uc.setAlpha(i.uc->alpha);
            uc.setBeta(i.uc->beta);
            uc.setGamma(i.uc->gamma);
            tmp.setUc(uc);
        }
        if (i.indexed_lattice_count.has_value())
            tmp.setLattCount(i.indexed_lattice_count.value());
        if (i.xfel_pulse_id.has_value())
            tmp.setXfelPulseid(i.xfel_pulse_id.value());
        if (i.res.has_value())
            tmp.setRes(i.res.value());
        v.emplace_back(std::move(tmp));
    }
    ret.setImages(v);
    if (input.rotation_lattice) {
        ret.setRotationCrystalLattice(input.rotation_lattice->GetVector());
        org::openapitools::server::model::Unit_cell uc;
        auto i_uc = input.rotation_lattice->GetUnitCell();

        uc.setA(i_uc.a);
        uc.setB(i_uc.b);
        uc.setC(i_uc.c);
        uc.setAlpha(i_uc.alpha);
        uc.setBeta(i_uc.beta);
        uc.setGamma(i_uc.gamma);
        ret.setRotationUnitCell(uc);
    }
    if (input.rotation_crystal_system && input.rotation_centering)
        ret.setRotationBravais(BravaisSymbol(*input.rotation_crystal_system, *input.rotation_centering));
    return ret;
}

org::openapitools::server::model::Dark_mask_settings Convert(const DarkMaskSettings &input) {
    org::openapitools::server::model::Dark_mask_settings ret{};
    ret.setDetectorThresholdKeV(input.GetThreshold_keV());
    ret.setFrameTimeUs(std::chrono::round<std::chrono::microseconds>(
        std::chrono::duration<float>(input.GetFrameTime())
    ).count());
    ret.setMaxFramesWithSignal(input.GetMaxFramesWithCounts());
    ret.setMaxAllowedPixelCount(input.GetMaxCounts());
    ret.setNumberOfFrames(input.GetNumberOfFrames());
    return ret;
}

DarkMaskSettings Convert(const org::openapitools::server::model::Dark_mask_settings &input) {
    DarkMaskSettings ret{};
    ret.FrameTime(std::chrono::microseconds(input.getFrameTimeUs()))
            .NumberOfFrames(input.getNumberOfFrames())
            .MaxCounts(input.getMaxAllowedPixelCount())
            .MaxFramesWithCounts(input.getMaxFramesWithSignal())
            .Threshold_keV(input.getDetectorThresholdKeV());
    return ret;
}

org::openapitools::server::model::Image_pusher_status Convert(const ImagePusherStatus& input) {
    org::openapitools::server::model::Image_pusher_status ret;
    ret.setAddr(input.address);
    ret.setConnectedWriters(input.connected_writers);
    org::openapitools::server::model::Image_pusher_type tmp;
    switch (input.pusher_type) {
        case ImagePusherType::HDF5:
            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::HDF5);
            break;
        case ImagePusherType::CBOR:
            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::CBOR);
            break;
        case ImagePusherType::TCP:
            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::TCP);
            break;
        case ImagePusherType::ZMQ:
            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::ZEROMQ);
            break;
        default:
            tmp.setValue(org::openapitools::server::model::Image_pusher_type::eImage_pusher_type::NONE);
            break;
    }
    ret.setPusherType(tmp);
    if (input.images_written)
        ret.setImagesWritten(input.images_written.value());
    if (input.images_write_error)
        ret.setImagesWriteError(input.images_write_error.value());
    ret.setWriterFifoUtilization(input.writer_fifo_utilization);
    return ret;
}