Jungfraujoch/common/ROIMap.cpp

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

#include "JFJochMath.h"
#include "ROIMap.h"
#include "JFJochException.h"

std::vector<uint16_t> ROIMap::GetROIMap(const DiffractionGeometry &geom, size_t xpixel, size_t ypixel) const {
    std::vector<uint16_t> map(xpixel * ypixel, 0);
    std::vector<float> resolution_map(xpixel * ypixel, 0);
    std::vector<float> phi_map;
    if (!rois.azimuthal.empty()) {
        phi_map.resize(xpixel * ypixel, 0);
        for (int y = 0; y < ypixel; y++) {
            for (int x = 0; x < xpixel; x++) {
                resolution_map[y * xpixel + x] = geom.PxlToRes(static_cast<float>(x), static_cast<float>(y));
                phi_map[y * xpixel + x] = geom.Phi_rad(static_cast<float>(x), static_cast<float>(y))
                                          * 180.0f / static_cast<float>(PI);
            }
        }
    }

    uint16_t roi_id = 0;

    for (const auto & box : rois.boxes) {
        box.MarkROI(map, roi_id, xpixel, ypixel, resolution_map, phi_map);
        roi_id++;
    }

    for (const auto & circle : rois.circles) {
        circle.MarkROI(map, roi_id, xpixel, ypixel, resolution_map, phi_map);
        roi_id++;
    }

    for (const auto &az : rois.azimuthal) {
        az.MarkROI(map, roi_id, xpixel, ypixel, resolution_map, phi_map);
        roi_id++;
    }

    return map;
}

std::map<std::string, uint16_t> ROIMap::GetROINameMap() const {
    std::map<std::string, uint16_t> roi_name_map;

    uint16_t roi_id = 0;

    for (auto & box : rois.boxes) {
        roi_name_map[box.GetName()] = roi_id;
        roi_id++;
    }

    for (auto & circle : rois.circles) {
        roi_name_map[circle.GetName()] = roi_id;
        roi_id++;
    }

    for (auto & az : rois.azimuthal) {
        roi_name_map[az.GetName()] = roi_id;
        roi_id++;
    }
    return roi_name_map;
}

void ROIMap::SetROI(const ROIDefinition &input) {
    if (input.boxes.size() + input.circles.size() + input.azimuthal.size() > roi_limit)
        throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds, "Limit of box ROIs exceeded");

    rois = input;
}

const ROIDefinition &ROIMap::GetROIDefinition() const {
    return rois;
}

bool ROIMap::empty() const {
    return rois.boxes.empty() && rois.circles.empty() && rois.azimuthal.empty();
}

size_t ROIMap::size() const {
    return rois.boxes.size() + rois.circles.size() + rois.azimuthal.size();
}

std::vector<ROIConfig> ROIMap::ExportMetadata() const {
    std::vector<ROIConfig> ret;
    for (auto &r : rois.boxes)
        ret.emplace_back(r.ExportMetadata());

    for (auto &r : rois.circles)
        ret.emplace_back(r.ExportMetadata());

    for (auto &r : rois.azimuthal)
        ret.emplace_back(r.ExportMetadata());

    return ret;
}