MaterialRaster.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/ImageFactory.h>
#include <NDEVR/VectorFunctions.h>
#include <NDEVR/RGBColor.h>
#include <NDEVR/INIInterface.h>
namespace NDEVR
{
    struct RasterInfo : public INIInterface
    {
        RasterInfo()
            : INIInterface(File())
        {}

        RasterInfo(const File& ini_file)
            : INIInterface(ini_file)
        {}

        bool isEnabled() const
        {
            return is_enabled && pixel_size > 0U;
        }
        Vector<2, uint04> pixel_size = Vector<2, uint04>(0, 0);                 
        fltp08 radial_distortion_scale = 0.2;                                       
        fltp08 radial_distortion_offset = 0;                                        
        Vector<2, Angle<fltp08>> camera_drape_move_angle = Vector<2, Angle<fltp08>>(Angle<fltp08>(DEGREES, 45.0));  
        Vector<2, Angle<fltp08>> angle_offset = Vector<2, Angle<fltp08>>(Angle<fltp08>(DEGREES, 0.0));              
        uint04 side_crop = 5;                                                       
        bool is_enabled = false;                                                    
        virtual void getINI(INIFactory& factory) override
        {
            factory.addOption("pixel_size", pixel_size);
            factory.addOption("radial_distortion_scale", radial_distortion_scale);
            factory.addOption("radial_distortion_offset", radial_distortion_offset);
            factory.addOption("side_crop", side_crop);
            factory.addOption("camera_drape_move_angle", camera_drape_move_angle);
            factory.addOption("angle_offset", angle_offset);
            factory.addOption("is_enabled", is_enabled);
        }
    };

    class MaterialRasterBase
    {
    public:
        MaterialRasterBase(const RasterInfo& raster_info)
            : m_raster_info(raster_info)
        {}

        virtual void updateImage() = 0;
        virtual void addImageBuffer(const Buffer<uint01>& pixels, const Vector<2, uint04>& size, const Matrix<fltp08>& camera_matrix) = 0;
        virtual StringView imageID() const = 0;
        virtual void addPixelInfo(const RGBColor& pixel, const Vector<2, fltp08>& location, uint04 weight) = 0;
        virtual void addPixelInfo(const RGBColor& pixel, const Vector<2, uint04>& location, uint08 weight) = 0;
        virtual void addPixelInfo(const Vector<4, fltp04>& pixel, const Vector<2, fltp08>& location, uint08 weight) = 0;
        virtual void addPixelInfo(const Vector<4, fltp04>& pixel, const Vector<2, uint04>& location, uint08 weight) = 0;
    protected:
        RasterInfo m_raster_info;   
    };

    class MaterialRaster : public MaterialRasterBase
    {
    public:
        MaterialRaster(const String& image_id, const RasterInfo& raster_info)
            : MaterialRasterBase(raster_info)
            , m_image_id(image_id)
            , m_color_channels(raster_info.pixel_size[X] * raster_info.pixel_size[Y], Vector<3, uint08>(0))
            , m_color_channel_average_count(raster_info.pixel_size[X] * raster_info.pixel_size[Y], 0)
            , m_pixels(4 * raster_info.pixel_size[X] * raster_info.pixel_size[Y], 255)
            , m_update_bounds(Constant<Bounds<2, uint04>>::Min)
        {
            ImageFactory::DefaultFactory().addImageUncompressed(m_image_id, m_pixels, raster_info.pixel_size, true);
        }

        StringView imageID() const override
        {
            return m_image_id;
        }

        virtual void clearRaster()
        {
            m_color_channels.setAllToValue(Vector<3, uint08>(0));
            m_color_channel_average_count.setAllToValue(0);
        }

        virtual void setUnsetColor(RGBColor color)
        {
            for (uint04 y = m_update_bounds[MIN][Y]; y < m_update_bounds[MAX][Y]; y++)
            {
                for (uint04 x = m_update_bounds[MIN][X]; x < m_update_bounds[MAX][X]; x++)
                {
                    uint04 pixel_index = convertToIndex({ x,y });
                    if (m_color_channel_average_count[pixel_index] == 0)
                    {
                        m_pixels[4 * pixel_index + RGBColor::r_pos] = color[RGBColor::r_pos];
                        m_pixels[4 * pixel_index + RGBColor::g_pos] = color[RGBColor::g_pos];
                        m_pixels[4 * pixel_index + RGBColor::b_pos] = color[RGBColor::b_pos];
                    }
                }
            }
        }

        virtual void updateImage() override
        {
            for (uint04 y = m_update_bounds[MIN][Y]; y <= m_update_bounds[MAX][Y]; y++)
            {
                for (uint04 x = m_update_bounds[MIN][X]; x <= m_update_bounds[MAX][X]; x++)
                {
                    uint04 pixel_index = convertToIndex({ x,y });
                    if (m_color_channel_average_count[pixel_index] > 0)
                    {
                        m_pixels[4 * pixel_index + RGBColor::r_pos] = cast<uint01>(m_color_channels[pixel_index][RGBColor::r_pos] / m_color_channel_average_count[pixel_index]);
                        m_pixels[4 * pixel_index + RGBColor::g_pos] = cast<uint01>(m_color_channels[pixel_index][RGBColor::g_pos] / m_color_channel_average_count[pixel_index]);
                        m_pixels[4 * pixel_index + RGBColor::b_pos] = cast<uint01>(m_color_channels[pixel_index][RGBColor::b_pos] / m_color_channel_average_count[pixel_index]);
                    }
                }
            }
            ImageFactory::DefaultFactory().addImageUncompressed(m_image_id, m_pixels, true);
        }

        static uint04 Weight(const Vertex<2, fltp08>& location, fltp08 y_dist)
        {
            uint04 weight = getMax(1U, cast<uint04>(1.0 / getMax(0.001, y_dist * location.magnitudeSquared())));
            return weight;
        }

        virtual void addImageBuffer(const Buffer<uint01>& pixels, const Vector<2, uint04>& size, const Matrix<fltp08>& camera_matrix) override;
        Vector<2, uint04> convertLocation(const Vector<2, fltp08>& location) const;
        uint04 convertToIndex(const Vector<2, uint04>& location) const
        {
            return location[Y] * m_raster_info.pixel_size[X] + location[X];
        }

        void addPixelInfo(const RGBColor& pixel, const Vector<2, fltp08>& location, uint04 weight) override
        {
            if (weight > 0)
            {
                addPixelInfo(pixel, convertLocation(location), weight);
            }
        }

        void addPixelInfo(const RGBColor& pixel, const Vector<2, uint04>& location, uint08 weight) override
        {
            if (weight > 0)
            {
                m_update_bounds.addToBounds(location);
                uint04 pixel_index = convertToIndex(location);
 
                m_color_channels[pixel_index] += (weight * pixel.as<3, uint08>());
                m_color_channel_average_count[pixel_index] += weight;
            }
        }

        void addPixelInfo(const Vector<4, fltp04>& pixel, const Vector<2, fltp08>& location, uint08 weight) override
        {
            if(weight > 0)
                addPixelInfo(pixel, convertLocation(location), weight);
        }

        void addPixelInfo(const Vector<4, fltp04>& pixel, const Vector<2, uint04>& location, uint08 weight) override
        {
            m_update_bounds.addToBounds(location);
            uint04 pixel_index = convertToIndex(location);
            if (weight != Constant<uint08>::Max)
            {
                m_color_channels[pixel_index] += (weight * (pixel * 255.0f).as<3, uint08>());
                m_color_channel_average_count[pixel_index] += weight;
            }
            else
            {
                m_color_channels[pixel_index] = (pixel * 255.0f).as<3, uint08>();
                m_color_channel_average_count[pixel_index] = 1;
            }
        }
    protected:
        String m_image_id;                                  
        Buffer<Vector<3, uint08>> m_color_channels;         
        Buffer<uint08> m_color_channel_average_count;       
        Buffer<uint01> m_pixels;                            
        Bounds<2, uint04> m_update_bounds;                  
    };

    class NDEVR_DESIGN_API MaterialRasterFactory
    {
    public:
        static MaterialRasterBase* CreateRaster(const String& image_id, const RasterInfo& info);
        static void SetDefaultMaterialRasterFactory(MaterialRasterFactory* factory);
    protected:
        virtual MaterialRasterBase* createRaster(const String& image_id, const RasterInfo& info) = 0;
        static MaterialRasterFactory* s_default_raster_factory; 
    };
}