Jungfraujoch/common/DiffractionSpot.cpp

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

#include "DiffractionSpot.h"
#include "DiffractionGeometry.h"
#include "RawToConvertedGeometry.h"

DiffractionSpot::DiffractionSpot(uint32_t col, uint32_t line, int64_t in_photons) {
    if (in_photons < 0) in_photons = 0;
    x = col * static_cast<float>(in_photons);
    y = line * static_cast<float>(in_photons);
    pixel_count = 1;
    photons = in_photons;
    max_photons = in_photons;
}

DiffractionSpot& DiffractionSpot::operator+=(const DiffractionSpot &other) {
    this->x += other.x;
    this->y += other.y;
    this->photons += other.photons;
    this->max_photons = std::max(this->max_photons, other.max_photons);
    this->pixel_count += other.pixel_count;
    return *this;
}

DiffractionSpot::DiffractionSpot(const SpotToSave &save) {
    x = save.x * static_cast<float>(save.intensity);
    y = save.y * static_cast<float>(save.intensity);
    pixel_count = 1;
    photons = std::lround(save.intensity);
    max_photons = save.maxc;
}

int64_t DiffractionSpot::Count() const {
    return photons;
}

int64_t DiffractionSpot::MaxCount() const {
    return max_photons;
}

Coord DiffractionSpot::RawCoord() const {
    if (photons == 0)
        return {0, 0, 0};
    return {x / (float)photons, y / (float)photons, 0};
}

int64_t DiffractionSpot::PixelCount() const {
    return pixel_count;
}

void DiffractionSpot::AddPixel(uint32_t col, uint32_t line, int64_t photons) {
    this->x += col * (float) photons;
    this->y += line * (float) photons;
    this->photons += photons;
    this->max_photons = std::max(this->max_photons, photons);
    this->pixel_count += 1;
}

void DiffractionSpot::ConvertToImageCoordinates(const DiffractionExperiment &experiment, uint16_t module_number) {
    auto c_out = RawToConvertedCoordinate(experiment, module_number, RawCoord());
    this->x = c_out.x * (float) photons;
    this->y = c_out.y * (float) photons;
}

std::optional<SpotToSave> DiffractionSpot::Export(const DiffractionGeometry &geometry, int64_t image_num) const {
    if (photons == 0)
        return std::nullopt;

    auto d = geometry.PxlToRes(x / (float) photons, y / (float) photons);

    float phi = 0.0f;
    if (geometry.GetRotation()) {
        // Rotation angle is considered as increment + half wedge.
        // It ignores the starting angle.
        phi = geometry.GetRotation()->GetAngle_deg(image_num) + geometry.GetRotation()->GetWedge_deg() / 2.0f;
    }

    return SpotToSave{
        .x = x / static_cast<float>(photons),
        .y = y / static_cast<float>(photons),
        .phi = phi,
        .intensity = static_cast<float>(photons),
        .maxc = max_photons,
        .lattice = -1,
        .image = image_num,
        .d_A = d,
        .ice_ring = false,
        .indexed = false
    };
}