OpenCVImageRaster.h

#pragma once
#include "Design/Headers/MaterialRaster.h"
#include "Design/Headers/ImageFactory.h"
#include "Design/Headers/Camera.h"
#include "Design/Headers/SelectionController.h"
#include "Base/Headers/MatrixFunctions.h"
#include "Base/Headers/VectorFunctions.hpp"
#include "Base/Headers/RGBColor.h"
#include <opencv2/stitching.hpp>
#include <opencv2/core/hal/interface.h>
namespace NDEVR
{
    class OpenCVImageRaster : public MaterialRasterBase
    {
    public:
        OpenCVImageRaster(const String& image_id, const Vector<2, uint04>& size)
            : m_image_id(image_id)
            , m_stitcher(cv::Stitcher::create())
            , m_size(size)
        {
            setup();
        }

        OpenCVImageRaster(const String& image_id, const Vector<2, uint04>& size, const RGBColor& background_color)
            : m_image_id(image_id)
            , m_stitcher(cv::Stitcher::create())
            , m_size(size)
        {
            if (background_color != RGBColor(255, 255, 255, 255))
                setUnsetColor(background_color);
            setup();
        }

        void setup()
        {
            //m_stitcher->setGP(true);
            Buffer<uint01> pixels(4 * m_size[X] * m_size[Y], 255);
            ImageFactory::DefaultFactory().addImageUncompressed(m_image_id, pixels, m_size, true);
            m_stitcher->setRegistrationResol(0.5);
            m_stitcher->setSeamEstimationResol(0.1);
            //m_stitcher->setCompositingResol(cv::Stitcher::ORIG_RESOL);
            /*m_stitcher->setPanoConfidenceThresh(0.5);
            m_stitcher->setWaveCorrection(true);
            m_stitcher->setWaveCorrectKind(cv::detail::WAVE_CORRECT_HORIZ);*/
            m_stitcher->setFeaturesMatcher(new cv::detail::BestOf2NearestMatcher(true));
            m_stitcher->setBundleAdjuster(new cv::detail::BundleAdjusterRay());
 
        }

        const String& imageID() const override
        {
            return m_image_id;
        }

        void clearRaster()
        {
            imgs.clear();
        }

        void setUnsetColor(RGBColor color)
        {
        }

        void updateImage() override
        {
            cv::Mat pano;// (cv::Size(m_size[X], m_size[Y]), CV_8UC3);
            cv::Stitcher::Status status = m_stitcher->stitch(imgs, pano);
            if (status == cv::Stitcher::Status::OK)
            {
                Buffer<uint01> data((uint01*)pano.data, pano.dataend - pano.datastart);
 
                Buffer<uint01> new_pixels(4 * pano.cols * pano.rows, 255U);
                uint8_t* pixelPtr = (uint8_t*)pano.data;
                int cn = pano.channels();
                for (int i = 0; i < pano.rows; i++)
                {
                    for (int j = 0; j < pano.cols; j++)
                    {
                        for (int dim = 0; dim < 3; dim++)
                            new_pixels[(i * pano.cols + j) * 4 + dim] = pixelPtr[(i * pano.cols + j) * 3 + dim];
                    }
                }
                ImageFactory::DefaultFactory().addImageUncompressed(m_image_id, new_pixels, Vector<2, uint04>(pano.cols, pano.rows), true);
            }
            
        }

        void addImageBuffer(const Buffer<uint01>& pixels, const Vector<2, uint04>& size, const Matrix<fltp08>& camera_matrix) override
        {
            
            
            /*if (imgs.size() == 0)
            {
                Buffer<uint01> new_pixels(3 * m_size[X] * m_size[Y], 0);
                for (int i = 0; i < size[X]; i++)
                {
                    for (int j = 0; j < size[Y]; j++)
                    {
                        for (int dim = 0; dim < 3; dim++)
                            new_pixels[(i * size[X] + j) * 3 + dim] = pixels[(i * size[X] + j) * 4 + dim];
                    }
                }
                cv::Mat mat(cv::Size(m_size[X], m_size[Y]), CV_8UC3, (void*)new_pixels.ptr(), cv::Mat::AUTO_STEP);
                imgs.push_back(mat.clone());
            }
            else*/
            {
                uint04 index_size = size[X] * size[Y];
                Buffer<uint01> new_pixels(3 * index_size, 0);
                for (uint04 i = 0; i < index_size; i++)
                {
                    for (uint04 n = 0; n < 3; n++)
                        new_pixels[3 * i + n] = pixels[4 * i + n];
                }
                cv::Mat mat(cv::Size(size[X], size[Y]), CV_8UC3, (void*)new_pixels.ptr(), cv::Mat::AUTO_STEP);
                imgs.push_back(mat.clone());
            }
        }
    protected:
        cv::Ptr<cv::Stitcher> m_stitcher;   
        std::vector<cv::Mat> imgs;          
        String m_image_id;                  
        Vector<2, uint04> m_size;           
    };

    class OpenCVMaterialRasterFactory : public MaterialRasterFactory
    {
        static void setDefaultMaterialRasterFactory(MaterialRasterFactory* factory)
        {
            s_default_raster_factory = factory;
        }
    protected:
        virtual MaterialRasterBase* createRaster(const String& image_id, const RasterInfo& info)
        {
            return new OpenCVImageRaster(image_id, info);
        }
        static MaterialRasterFactory* s_default_raster_factory; 
    };
}