calibration_converter.h

Go to the documentation of this file.

#pragma once

 
#include "calibration_units.h"
 
#include "common/calibration.h"
#include "projection/projection.h"
 
namespace satdump
{
    namespace calibration
    {
        class UnitConverter; // Fwd declaration

        class ConverterBase
        {
        public:
            virtual double convert(const UnitConverter *c, double x, double y, double val);

            virtual bool convert_range(const UnitConverter *c, double &min, double &max);
        };

        struct ConverterRequestEvent
        {
            std::vector<std::shared_ptr<ConverterBase>> &c;
            std::string itype;
            std::string otype;
        };

        std::vector<std::shared_ptr<ConverterBase>> getAvailableConverters(std::string itype, std::string otype);

        struct ConversionRequestEvent
        {
            std::string itype;
            std::vector<std::string> &otypes;
        };

        std::vector<std::string> getAvailableConversions(std::string itype);

        class UnitConverter
        {
        public:
            projection::Projection proj;
            bool proj_valid = false;
            double wavenumber = -1;
 
        private:
            bool unitEqual = false;
            std::shared_ptr<ConverterBase> converter;
 
        public:
            UnitConverter() {}

            UnitConverter(void *product, std::string channel_name);

            void set_proj(nlohmann::json p);

            void set_wavenumber(double w);

            void set_conversion(std::string itype, std::string otype);

            inline double convert(double x, double y, double val)
            {
                if (unitEqual)
                    return val;
                else if (converter)
                    return converter->convert(this, x, y, val);
                else
                    return CALIBRATION_INVALID_VALUE;
            }

            bool convert_range(double &min, double &max)
            {
                if (unitEqual)
                    return true;
                else if (converter)
                    return converter->convert_range(this, min, max);
                else
                    return false;
            }
        };
    } // namespace calibration
} // namespace satdump