MaterialRaster.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/ImageFactory.h>
#include <NDEVR/VectorFunctions.h>
#include <NDEVR/RGBColor.h>
#include <NDEVR/INIInterface.h>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief Stores information for painting pixels at a time into a 2D texture used with MaterialRaster.
    **/
    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);
        }
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Base class for painting pixels at a time into a 2D texture.
    **/
    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 const String& 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;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores information for painting pixels at a time into a 2D texture.
    **/
    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);
        }
        const String& 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;
        /*void addImageBuffer(const Buffer<uint01>& pixels, Camera* camera, const Model& model)
        {
            Vector<2, uint04> size = camera->getWindowSize().span();
            Vector<2, fltp08> flt_size = size.as<2, fltp08>();
            Vector<2, fltp08> half_flt_size = size.as<2, fltp08>() / 2.0;
            Vertex<3, fltp08> last_nearest = Constant<Vertex<3, fltp08>>::Invalid;
            if (size[X] < m_side_crop)
                return;
            if (size[Y] < m_side_crop)
                return;
            SelectionInfo info = camera->createSelectionInfo();
            //info.allow_inverse_trans = true;
            info.model_filter = [this](const Model& model)->bool
            {
                bool ignore = false;
                ignore |= !model.getProperty<bool>(Model::e_allow_interactions);
                //ignore |= model.getProperty<bool>(Model::e_is_application_owned);
                ignore |= !model.getProperty<bool>(Model::e_3D_visible);
                return !ignore;
            };
            //info.allow_inverse_trans = true;
            Matrix<fltp08> inv_mat = info.current_selection.projectionTransform().invert();;
            for (uint04 y = m_side_crop; y < size[Y] - m_side_crop; y++)
            {
                for (uint04 x = m_side_crop; x < size[X] - m_side_crop; x++)
                {
                    info.clearLastSelection();
                    uint04 source_pixel_location = y * size[X] + x;
 
                    Vertex<2, fltp04> loc(x, y);
 
                    const Vector<2, fltp08> corrected_space = camera->toScreenSpace(loc);
                    const Matrix<fltp08> mat = inv_mat.invert();
                    const LineSegment<3, fltp08> selection(Vector<3, fltp08>(corrected_space, 0.0), Vector<3, fltp08>(corrected_space, 1.0));
                    info.current_selection.setSelection(mat * selection);
 
 
                    info.nearest_line.screen_distance = 0.0;
 
                    info.parseAll({ model });
                    if (!IsInvalid(info.nearest_solid.nearest_index))
                    {
 
                        //record.position =  info.nearest_solid.screen_location;
                        last_nearest = info.nearestScreenLocation();
 
                    }
                }
            }
        }*/
        Vector<2, uint04> convertLocation(const Vector<2, fltp08>& location) const
        {
            Vector<2, fltp08> loc = location;
            if (loc[Y] < 0.0)//wrap around x axis
            {
                loc[Y] = -loc[Y];
                loc[X] += 0.5;
            }
            if (loc[Y] > 1.0)//wrap around x axis
            {
                loc[Y] = 2.0 - loc[Y];
                loc[X] += 0.5;
            }
            loc[X] = fmod(loc[X], 1.0);
            if (loc[X] < 0.0)
                loc[X] += 1;
            return (loc * (m_raster_info.pixel_size - 1U).as<2, fltp08>()).as<2, uint04>();
        }
        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;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Creates rasters for converting points and directions into 2D images.
    **/
    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;
    };
}