image_product.h

Go to the documentation of this file.

#pragma once

 
#include "image/channel_transform.h"
#include "image/image.h"
#include "product.h"
#include "utils/stats.h"
 
#include "common/physics_constants.h"
#include "image/calibration_units.h" // TODOREWORK MOVE!!!! + Conversion
 
// TODOREWORK MOVE
#include "common/calibration.h"
#include "utils/unit_parser.h"
#include <string>
 
namespace satdump
{
    namespace products
    {
        class ImageProduct : public Product
        {
        public:
            struct ImageHolder
            {
                int abs_index = -1;
                std::string filename;
                std::string channel_name;
                image::Image image;
                int bit_depth = 16;
                ChannelTransform ch_transform = ChannelTransform().init_none();
                double wavenumber = -1;
                std::string calibration_type = "";
            };
 
            std::vector<ImageHolder> images;
 
            bool save_as_matrix = false;
 
        public:
            void set_proj_cfg(nlohmann::json cfg)
            {
                contents["projection_cfg"] = cfg;
                if (cfg.contains("tle") && cfg["tle"].contains("name"))
                    if (!has_product_source())
                        set_product_source(cfg["tle"]["name"]);
                if (cfg.contains("timestamps") && !has_product_timestamp())
                    set_product_timestamp(get_median(cfg["timestamps"].get<std::vector<double>>()));
            }

            void set_proj_cfg_tle_timestamps(nlohmann::json cfg, nlohmann::json tle, nlohmann::json timestamps)
            {
                cfg["tle"] = tle;
                cfg["timestamps"] = timestamps;
                set_proj_cfg(cfg);
            }

            nlohmann::json get_proj_cfg(int channel)
            {
                // TODO CHANNEL SPECIFICS
                auto cfg = contents["projection_cfg"];
                if (channel != -1)
                {
                    cfg["transform"] = get_channel_image(channel).ch_transform;
                    cfg["width"] = get_channel_image(channel).image.width();
                    cfg["height"] = get_channel_image(channel).image.height();
                }
                if (has_product_timestamp())
                    cfg["proj_timestamp"] = get_product_timestamp();
                return cfg;
            }

            bool has_proj_cfg() { return contents.contains("projection_cfg"); }
 
        public:
            void set_calibration(std::string calibrator, nlohmann::json cfg)
            {
                contents["calibration"] = cfg;
                contents["calibration"]["calibrator"] = calibrator;
            }
 
            std::pair<std::string, nlohmann::json> get_calibration() { return {contents["calibration"]["calibrator"], contents["calibration"]}; }

            bool has_calibration() { return contents.contains("calibration"); }
 
            // TODOREWORK DOCUMENT
            nlohmann::json get_calibration_raw() { return contents.contains("calibration") ? contents["calibration"] : nlohmann::json(); }
 
        public:
            ImageHolder &get_channel_image(int index)
            {
                for (auto &img : images)
                    if (img.abs_index == index)
                        return img;
                throw satdump_exception("Product Channel Index " + std::to_string(index) + " is not present!");
            }

            ImageHolder &get_channel_image(std::string name)
            {
                for (auto &img : images)
                    if (img.channel_name == name)
                        return img;
                throw satdump_exception("Product Channel Name " + name + " is not present!");
            }

            ImageHolder &get_channel_image_by_wavenumber(double wavenumber)
            {
                double best = 1e40;
                ImageHolder *out = nullptr;
                for (auto &img : images)
                {
                    if (img.wavenumber != -1 && best > abs(img.wavenumber - wavenumber))
                    {
                        out = &img;
                        best = abs(img.wavenumber - wavenumber);
                    }
                }
                if (out == nullptr)
                    throw satdump_exception("Product Channel Close to Wavelength " + std::to_string(wavenumber) + " is not present!");
                return *out;
            }

            ImageHolder &get_channel_image_by_unitstr(std::string str)
            {
                double val = 0;
 
                if (parseUnitFromString(str, val, UNIT_METER))
                    val = freq_to_wavenumber(SPEED_OF_LIGHT_M_S / val);
                else if (parseUnitFromString(str, val, UNIT_HERTZ))
                    val = freq_to_wavenumber(val);
                else
                    throw satdump_exception("Couldn't parse unit and value from " + str);
 
                return get_channel_image_by_wavenumber(val);
            }

            int get_channel_image_idx(std::string name)
            {
                for (int i = 0; i < (int)images.size(); i++)
                    if (images[i].channel_name == name)
                        return i;
                throw satdump_exception("Product Channel Name " + name + " is not present!");
            }

            inline int get_raw_channel_val(int idx, int x, int y)
            {
                auto &i = images[idx];
                int depth_diff = i.bit_depth - i.image.depth();
                if (depth_diff > 0)
                    return i.image.get(0, x, y) << depth_diff;
                else
                    return i.image.get(0, x, y) >> -depth_diff;
            }

            void set_channel_wavenumber(int index, double wavenumber)
            {
                for (auto &img : images)
                    if (img.abs_index == index)
                    {
                        img.wavenumber = wavenumber;
                        return;
                    }
                throw satdump_exception("Product Channel Index " + std::to_string(index) + " is not present!");
            }

            void set_channel_frequency(int index, double frequency) { set_channel_wavenumber(index, freq_to_wavenumber(frequency)); }

            double get_channel_wavenumber(int index)
            {
                for (auto &img : images)
                    if (img.abs_index == index)
                        return img.wavenumber;
                throw satdump_exception("Product Channel Index " + std::to_string(index) + " is not present!");
            }

            double get_channel_frequency(int index) { return wavenumber_to_freq(get_channel_wavenumber(index)); }

            void set_channel_unit(int index, std::string type_or_unit)
            {
                // TODOREWORK, may want to enforce unit automatically?
                for (auto &img : images)
                    if (img.abs_index == index)
                    {
                        img.calibration_type = type_or_unit;
                        return;
                    }
                throw satdump_exception("Product Channel Index " + std::to_string(index) + " is not present!");
            }
 
        public:
            bool d_no_not_save_images = false;
            bool d_no_not_load_images = false;
            virtual void save(std::string directory);
            virtual void load(std::string file);
 
            ImageProduct() { type = "image"; }
            virtual ~ImageProduct();
        };
    } // namespace products
} // namespace satdump