image.h

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <cstdint>
#include <vector>
 
namespace satdump
{
    namespace image
    {
        class Image
        {
        protected:
            // Image buffer
            size_t data_size = 0;
            size_t type_size = 0;
            void *d_data = nullptr;
 
            // Size and parameters
            int d_depth = 0;
            int d_maxv = 0;
            size_t d_width = 0;
            size_t d_height = 0;
            int d_channels = 0;
 
        public:
            // Metadata stuff
            void *metadata_obj = nullptr; // DO NOT USE DIRECTLY!
        protected:
            void copy_meta(const Image &img);
 
        public:
            Image();

            Image(int bit_depth, size_t width, size_t height, int channels);

            Image(void *buffer, int bit_depth, size_t width, size_t height, int channels);
 
            Image(const Image &img); // Copy constructor
            ~Image();                // Destructor
 
            Image &operator=(const Image &img);
 
        public:
            void to_rgb();

            void to_rgba();

            Image to8bits();

            Image to16bits();

            Image to_depth(int bit_depth);
 
        public:
            void draw_image(int channel, Image image, int x = 0, int y = 0);

            void draw_image_alpha(Image image, int x = 0, int y = 0);

            void draw_pixel(size_t x, size_t y, std::vector<double> color);

            void draw_line(int x0, int y0, int x1, int y1, std::vector<double> color);

            void draw_circle(int x0, int y0, int radius, std::vector<double> color, bool fill = false);

            void draw_rectangle(int x0, int y0, int x1, int y1, std::vector<double> color, bool fill = true);
 
        public:
            void init(int bit_depth, size_t width, size_t height, int channels);

            void clear();
 
        public:
            int clamp(int input);

            double clampf(double input);

            void *raw_data() const { return d_data; }

            int depth() const { return d_depth; }

            int typesize() const { return type_size; }

            size_t width() const { return d_width; }

            size_t height() const { return d_height; }

            int channels() const { return d_channels; }

            size_t size() const { return data_size; }

            int maxval() const { return d_maxv; }
 
        public:
            void crop(int x0, int y0, int x1, int y1);

            void crop(int x0, int x1);

            Image crop_to(int x0, int y0, int x1, int y1);

            Image crop_to(int x0, int x1);
 
        public:
            void mirror(bool x, bool y);
 
        public:
            void resize(int width, int height);

            Image resize_to(int width, int height);

            void resize_bilinear(int width, int height, bool text_mode = false);

            int get_pixel_bilinear(int channel, double x, double y);
 
        public:
            void fill(int val);

            void fill_color(std::vector<double> color);
 
        public:
            void set(size_t p, int v)
            {
                if (d_depth > 8)
                    ((uint16_t *)d_data)[p] = v;
                else
                    ((uint8_t *)d_data)[p] = v;
            }

            int get(size_t p)
            {
                if (d_depth > 8)
                    return ((uint16_t *)d_data)[p];
                else
                    return ((uint8_t *)d_data)[p];
            }

            void setf(size_t p, double v)
            {
                if (d_depth > 8)
                    ((uint16_t *)d_data)[p] = v * (double)d_maxv;
                else
                    ((uint8_t *)d_data)[p] = v * (double)d_maxv;
            }

            double getf(size_t p)
            {
                if (d_depth > 8)
                    return (double)((uint16_t *)d_data)[p] / (double)d_maxv;
                else
                    return (double)((uint8_t *)d_data)[p] / (double)d_maxv;
            }
 
            // Easier int set/get
            void set(size_t channel, size_t p, int v) { set(channel * d_width * d_height + p, v); }
            int get(size_t channel, size_t p) { return get(channel * d_width * d_height + p); }
            void set(size_t channel, size_t x, size_t y, int v) { set(channel * d_width * d_height + y * d_width + x, v); }
            int get(size_t channel, size_t x, size_t y) { return get(channel * d_width * d_height + y * d_width + x); }
 
            // Easier double setf/getf
            void setf(size_t channel, size_t p, double v) { setf(channel * d_width * d_height + p, v); }
            double getf(size_t channel, size_t p) { return getf(channel * d_width * d_height + p); }
            void setf(size_t channel, size_t x, size_t y, double v) { setf(channel * d_width * d_height + y * d_width + x, v); }
            double getf(size_t channel, size_t x, size_t y) { return getf(channel * d_width * d_height + y * d_width + x); }
        };

        void imemcpy(Image &img1, size_t pos1, Image &img2, size_t pos2, size_t px_size);

        void image_to_rgba(Image &img, uint32_t *output);
    } // namespace image
} // namespace satdump
 
// TODOREWORK!!!!! REMOVE. Temporary namespace hack until everything is moved over!
namespace image
{
    using namespace satdump::image;
} // namespace image