实现RawBurstCapture
Matthew
9 months ago
parent
9c9a122034
commit
72f595b7a3
@ -0,0 +1,38 @@
|
||||
#pragma once
|
||||
|
||||
#include <vector>
|
||||
#include <utility> // std::pair
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include "hdrplus/burst.h"
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
class align
|
||||
{
|
||||
public:
|
||||
align() = default;
|
||||
~align() = default;
|
||||
|
||||
/**
|
||||
* @brief Run alignment on burst of images
|
||||
*
|
||||
* @param burst_images collection of burst images
|
||||
* @param aligements alignment in pixel value pair.
|
||||
* Outer most vector is per alternative image.
|
||||
* Inner most two vector is for horizontle & verticle tiles
|
||||
*/
|
||||
void process( const hdrplus::burst& burst_images, \
|
||||
std::vector<std::vector<std::vector<std::pair<int, int>>>>& aligements );
|
||||
|
||||
private:
|
||||
// From original image to coarse image
|
||||
const std::vector<int> inv_scale_factors = { 1, 2, 4, 4 };
|
||||
const std::vector<int> distances = { 1, 2, 2, 2 }; // L1 / L2 distance
|
||||
const std::vector<int> grayimg_search_radious = { 1, 4, 4, 4 };
|
||||
const std::vector<int> grayimg_tile_sizes = { 16, 16, 16, 8 };
|
||||
const int num_levels = 4;
|
||||
};
|
||||
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,35 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <utility> // std::pair
|
||||
#include <memory> // std::shared_ptr
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <libraw/libraw.h>
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
class bayer_image
|
||||
{
|
||||
public:
|
||||
explicit bayer_image( const std::string& bayer_image_path );
|
||||
~bayer_image() = default;
|
||||
|
||||
std::pair<double, double> get_noise_params() const;
|
||||
|
||||
std::shared_ptr<LibRaw> libraw_processor;
|
||||
cv::Mat raw_image;
|
||||
cv::Mat grayscale_image;
|
||||
int width;
|
||||
int height;
|
||||
int white_level;
|
||||
std::vector<int> black_level_per_channel;
|
||||
float iso;
|
||||
|
||||
private:
|
||||
float baseline_lambda_shot = 3.24 * pow( 10, -4 );
|
||||
float baseline_lambda_read = 4.3 * pow( 10, -6 );
|
||||
};
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,43 @@
|
||||
#pragma once
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include "hdrplus/bayer_image.h"
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
class burst
|
||||
{
|
||||
public:
|
||||
explicit burst( const std::string& burst_path, const std::string& reference_image_path );
|
||||
explicit burst(const std::vector<std::string>& burst_paths, int reference_image_index);
|
||||
|
||||
~burst() = default;
|
||||
|
||||
// Reference image index in the array
|
||||
int reference_image_idx;
|
||||
|
||||
// Source bayer images & grayscale unpadded image
|
||||
std::vector<hdrplus::bayer_image> bayer_images;
|
||||
|
||||
// Image padded to upper level tile size (16*2)
|
||||
// Use for alignment, merging, and finishing
|
||||
std::vector<cv::Mat> bayer_images_pad;
|
||||
|
||||
// Padding information
|
||||
std::vector<int> padding_info_bayer;
|
||||
|
||||
// Image padded to upper level tile size (16)
|
||||
// Use for alignment, merging, and finishing
|
||||
std::vector<cv::Mat> grayscale_images_pad;
|
||||
|
||||
// number of image (including reference) in burst
|
||||
int num_images;
|
||||
|
||||
// Bayer image after merging, stored as cv::Mat
|
||||
cv::Mat merged_bayer_image;
|
||||
};
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,240 @@
|
||||
#pragma once
|
||||
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <unordered_map>
|
||||
#include <hdrplus/bayer_image.h>
|
||||
#include <dirent.h>
|
||||
#include <hdrplus/params.h>
|
||||
#include <hdrplus/burst.h>
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
uint16_t uGammaCompress_1pix(float x, float threshold,float gainMin,float gainMax,float exponent);
|
||||
uint16_t uGammaDecompress_1pix(float x, float threshold,float gainMin,float gainMax,float exponent);
|
||||
cv::Mat uGammaCompress_(cv::Mat m,float threshold,float gainMin,float gainMax,float exponent);
|
||||
cv::Mat uGammaDecompress_(cv::Mat m,float threshold,float gainMin,float gainMax,float exponent);
|
||||
cv::Mat gammasRGB(cv::Mat img, bool mode);
|
||||
|
||||
|
||||
class finish
|
||||
{
|
||||
public:
|
||||
cv::Mat mergedBayer; // merged image from Merge Module
|
||||
std::string burstPath; // path to burst images
|
||||
std::vector<std::string> rawPathList; // a list or array of the path to all burst imgs under burst Path
|
||||
int refIdx; // index of the reference img
|
||||
Parameters params;
|
||||
cv::Mat rawReference;
|
||||
// LibRaw libraw_processor_finish;
|
||||
bayer_image* refBayer;
|
||||
|
||||
std::string mergedImgPath;
|
||||
finish() = default;
|
||||
|
||||
// please use this initialization after merging part finish
|
||||
finish(std::string burstPath, cv::Mat mergedBayer,int refIdx){
|
||||
this->refIdx = refIdx;
|
||||
this->burstPath = burstPath;
|
||||
this->mergedBayer = mergedBayer;
|
||||
}
|
||||
|
||||
// for local testing only
|
||||
finish(std::string burstPath, std::string mergedBayerPath,int refIdx){
|
||||
this->refIdx = refIdx;
|
||||
this->burstPath = burstPath;
|
||||
this->mergedBayer = loadFromCSV(mergedBayerPath, CV_16UC1);//
|
||||
load_rawPathList(burstPath);
|
||||
refBayer= new bayer_image(this->rawPathList[refIdx]);
|
||||
this->rawReference = refBayer->raw_image;//;grayscale_image
|
||||
|
||||
// initialize parameters in libraw_processor_finish
|
||||
setLibRawParams();
|
||||
showParams();
|
||||
|
||||
std::cout<<"Finish init() finished!"<<std::endl;
|
||||
}
|
||||
|
||||
|
||||
|
||||
~finish() = default;
|
||||
|
||||
// finish pipeline func
|
||||
// void process(std::string burstPath, cv::Mat mergedBayer,int refIdx);
|
||||
void process(const hdrplus::burst& burst_images, cv::Mat& finalOutputImage);
|
||||
|
||||
// replace Mat a with Mat b
|
||||
void copy_mat_16U(cv::Mat& A, cv::Mat B);
|
||||
void copy_rawImg2libraw(std::shared_ptr<LibRaw>& libraw_ptr, cv::Mat B);
|
||||
|
||||
// postprocess
|
||||
// cv::Mat postprocess(std::shared_ptr<LibRaw>& libraw_ptr);
|
||||
|
||||
void showImg(cv::Mat img)
|
||||
{
|
||||
int ch = CV_MAT_CN(CV_8UC1);
|
||||
|
||||
// cv::Mat tmp(4208,3120,CV_16UC1);
|
||||
cv::Mat tmp(img);
|
||||
// u_int16_t* ptr_tmp = (u_int16_t*)tmp.data;
|
||||
// u_int16_t* ptr_img = (u_int16_t*)img.data;
|
||||
// // col major to row major
|
||||
// for(int r = 0; r < tmp.rows; r++) {
|
||||
// for(int c = 0; c < tmp.cols; c++) {
|
||||
// *(ptr_tmp+r*tmp.cols+c) = *(ptr_img+c*tmp.rows+r)/2048.0*255.0;
|
||||
// }
|
||||
// }
|
||||
// std::cout<<"height="<<tmp.rows<<std::endl;
|
||||
// std::cout<<"width="<<tmp.cols<<std::endl;
|
||||
// cv::transpose(tmp, tmp);
|
||||
|
||||
u_int16_t* ptr = (u_int16_t*)tmp.data;
|
||||
for(int r = 0; r < tmp.rows; r++) {
|
||||
for(int c = 0; c < tmp.cols; c++) {
|
||||
*(ptr+r*tmp.cols+c) = *(ptr+r*tmp.cols+c)/2048.0*255.0;
|
||||
}
|
||||
}
|
||||
|
||||
tmp = tmp.reshape(ch);
|
||||
tmp.convertTo(tmp, CV_8UC1);
|
||||
cv::imshow("test",tmp);
|
||||
cv::imwrite("test2.jpg", tmp);
|
||||
cv::waitKey(0);
|
||||
std::cout<< this->mergedBayer.size()<<std::endl;
|
||||
}
|
||||
|
||||
void showMat(cv::Mat img){
|
||||
std::cout<<"size="<<img.size()<<std::endl;
|
||||
std::cout<<"type="<<img.type()<<std::endl;
|
||||
}
|
||||
|
||||
void showParams()
|
||||
{
|
||||
std::cout<<"Parameters:"<<std::endl;
|
||||
std::cout<<"tuning_ltmGain = "<<this->params.tuning.ltmGain<<std::endl;
|
||||
std::cout<<"tuning_gtmContrast = "<<this->params.tuning.gtmContrast<<std::endl;
|
||||
for(auto key_val:this->params.flags){
|
||||
std::cout<<key_val.first<<","<<key_val.second<<std::endl;
|
||||
}
|
||||
std::cout<<"demosaic_algorithm = "<<refBayer->libraw_processor->imgdata.params.user_qual<<std::endl;
|
||||
std::cout<<"half_size = "<<refBayer->libraw_processor->imgdata.params.half_size<<std::endl;
|
||||
std::cout<<"use_camera_wb = "<<refBayer->libraw_processor->imgdata.params.use_camera_wb<<std::endl;
|
||||
std::cout<<"use_auto_wb = "<<refBayer->libraw_processor->imgdata.params.use_auto_wb<<std::endl;
|
||||
std::cout<<"no_auto_bright = "<<refBayer->libraw_processor->imgdata.params.no_auto_bright<<std::endl;
|
||||
std::cout<<"output_color = "<<refBayer->libraw_processor->imgdata.params.output_color <<std::endl;
|
||||
std::cout<<"gamma[0] = "<<refBayer->libraw_processor->imgdata.params.gamm[0]<<std::endl;
|
||||
std::cout<<"gamma[1] = "<<refBayer->libraw_processor->imgdata.params.gamm[1]<<std::endl;
|
||||
std::cout<<"output_bps = "<<refBayer->libraw_processor->imgdata.params.output_bps<<std::endl;
|
||||
|
||||
// std::cout<<"demosaic_algorithm = "<<libraw_processor_finish.imgdata.params.user_qual<<std::endl;
|
||||
// std::cout<<"half_size = "<<libraw_processor_finish.imgdata.params.half_size<<std::endl;
|
||||
// std::cout<<"use_camera_wb = "<<libraw_processor_finish.imgdata.params.use_camera_wb<<std::endl;
|
||||
// std::cout<<"use_auto_wb = "<<libraw_processor_finish.imgdata.params.use_auto_wb<<std::endl;
|
||||
// std::cout<<"no_auto_bright = "<<libraw_processor_finish.imgdata.params.no_auto_bright<<std::endl;
|
||||
// std::cout<<"output_color = "<<libraw_processor_finish.imgdata.params.output_color <<std::endl;
|
||||
// std::cout<<"gamma[0] = "<<libraw_processor_finish.imgdata.params.gamm[0]<<std::endl;
|
||||
// std::cout<<"gamma[1] = "<<libraw_processor_finish.imgdata.params.gamm[1]<<std::endl;
|
||||
// std::cout<<"output_bps = "<<libraw_processor_finish.imgdata.params.output_bps<<std::endl;
|
||||
|
||||
std::cout<<"===================="<<std::endl;
|
||||
}
|
||||
|
||||
void showRawPathList(){
|
||||
std::cout<<"RawPathList:"<<std::endl;
|
||||
for(auto pth:this->rawPathList){
|
||||
std::cout<<pth<<std::endl;
|
||||
}
|
||||
std::cout<<"===================="<<std::endl;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
private:
|
||||
cv::Mat loadFromCSV(const std::string& path, int opencv_type)
|
||||
{
|
||||
cv::Mat m;
|
||||
std::ifstream csvFile (path);
|
||||
|
||||
std::string line;
|
||||
|
||||
while (getline(csvFile, line))
|
||||
{
|
||||
std::vector<int> dvals;
|
||||
std::stringstream ss(line);
|
||||
std::string val;
|
||||
// int count=0;
|
||||
while (getline(ss, val, ','))
|
||||
{
|
||||
dvals.push_back(stod(val));//*255.0/2048.0
|
||||
// count++;
|
||||
}
|
||||
// std::cout<<count<<std::endl;
|
||||
cv::Mat mline(dvals, true);
|
||||
cv::transpose(mline, mline);
|
||||
|
||||
m.push_back(mline);
|
||||
}
|
||||
int ch = CV_MAT_CN(opencv_type);
|
||||
|
||||
m = m.reshape(ch);
|
||||
m.convertTo(m, opencv_type);
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
void load_rawPathList(std::string burstPath){
|
||||
DIR *pDir; // pointer to root
|
||||
struct dirent *ptr;
|
||||
if (!(pDir = opendir(burstPath.c_str()))) {
|
||||
std::cout<<"root dir not found!"<<std::endl;
|
||||
return;
|
||||
}
|
||||
while ((ptr = readdir(pDir)) != nullptr) {
|
||||
// ptr will move to the next file automatically
|
||||
std::string sub_file = burstPath + "/" + ptr->d_name; // current filepath that ptr points to
|
||||
if (ptr->d_type != 8 && ptr->d_type != 4) { // not normal file or dir
|
||||
return;
|
||||
}
|
||||
// only need normal files
|
||||
if (ptr->d_type == 8) {
|
||||
if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
|
||||
if (strstr(ptr->d_name, ".dng")) {
|
||||
rawPathList.emplace_back(sub_file);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// close root dir
|
||||
closedir(pDir);
|
||||
}
|
||||
|
||||
void setLibRawParams(){
|
||||
refBayer->libraw_processor->imgdata.params.user_qual = params.rawpyArgs.demosaic_algorithm;
|
||||
refBayer->libraw_processor->imgdata.params.half_size = params.rawpyArgs.half_size;
|
||||
refBayer->libraw_processor->imgdata.params.use_camera_wb = params.rawpyArgs.use_camera_wb;
|
||||
refBayer->libraw_processor->imgdata.params.use_auto_wb = params.rawpyArgs.use_auto_wb;
|
||||
refBayer->libraw_processor->imgdata.params.no_auto_bright = params.rawpyArgs.no_auto_bright;
|
||||
refBayer->libraw_processor->imgdata.params.output_color = params.rawpyArgs.output_color;
|
||||
refBayer->libraw_processor->imgdata.params.gamm[0] = params.rawpyArgs.gamma[0];
|
||||
refBayer->libraw_processor->imgdata.params.gamm[1] = params.rawpyArgs.gamma[1];
|
||||
refBayer->libraw_processor->imgdata.params.output_bps = params.rawpyArgs.output_bps;
|
||||
|
||||
// libraw_processor_finish.imgdata.params.user_qual = params.rawpyArgs.demosaic_algorithm;
|
||||
// libraw_processor_finish.imgdata.params.half_size = params.rawpyArgs.half_size;
|
||||
// libraw_processor_finish.imgdata.params.use_camera_wb = params.rawpyArgs.use_camera_wb;
|
||||
// libraw_processor_finish.imgdata.params.use_auto_wb = params.rawpyArgs.use_auto_wb;
|
||||
// libraw_processor_finish.imgdata.params.no_auto_bright = params.rawpyArgs.no_auto_bright;
|
||||
// libraw_processor_finish.imgdata.params.output_color = params.rawpyArgs.output_color;
|
||||
// libraw_processor_finish.imgdata.params.gamm[0] = params.rawpyArgs.gamma[0];
|
||||
// libraw_processor_finish.imgdata.params.gamm[1] = params.rawpyArgs.gamma[1];
|
||||
// libraw_processor_finish.imgdata.params.output_bps = params.rawpyArgs.output_bps;
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,27 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include "hdrplus/burst.h"
|
||||
#include "hdrplus/align.h"
|
||||
#include "hdrplus/merge.h"
|
||||
#include "hdrplus/finish.h"
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
class hdrplus_pipeline
|
||||
{
|
||||
private:
|
||||
hdrplus::align align_module;
|
||||
hdrplus::merge merge_module;
|
||||
hdrplus::finish finish_module;
|
||||
|
||||
public:
|
||||
void run_pipeline( const std::string& burst_path, const std::string& reference_image_path );
|
||||
bool run_pipeline( const std::vector<std::string>& burst_paths, int reference_image_index, cv::Mat& finalImg );
|
||||
hdrplus_pipeline() = default;
|
||||
~hdrplus_pipeline() = default;
|
||||
};
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,184 @@
|
||||
#pragma once
|
||||
|
||||
#include <vector>
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <cmath>
|
||||
#include "hdrplus/burst.h"
|
||||
|
||||
#define TILE_SIZE 16
|
||||
#define TEMPORAL_FACTOR 75
|
||||
#define SPATIAL_FACTOR 0.1
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
class merge
|
||||
{
|
||||
public:
|
||||
int offset = TILE_SIZE / 2;
|
||||
float baseline_lambda_shot = 3.24 * pow( 10, -4 );
|
||||
float baseline_lambda_read = 4.3 * pow( 10, -6 );
|
||||
|
||||
merge() = default;
|
||||
~merge() = default;
|
||||
|
||||
/**
|
||||
* @brief Run alignment on burst of images
|
||||
*
|
||||
* @param burst_images collection of burst images
|
||||
* @param alignments alignment in pixel value pair.
|
||||
* Outer most vector is per alternative image.
|
||||
* Inner most two vector is for horizontal & vertical tiles
|
||||
*/
|
||||
void process( hdrplus::burst& burst_images, \
|
||||
std::vector<std::vector<std::vector<std::pair<int, int>>>>& alignments);
|
||||
|
||||
|
||||
/*
|
||||
std::vector<cv::Mat> get_other_tiles(); //return the other tile list T_1 to T_n
|
||||
|
||||
std::vector<cv::Mat> vector_math(string operation, reference_tile, other_tile_list); //for loop allowing operations across single element and list
|
||||
|
||||
std::vector<cv::Mat> scalar_vector_math(string operation, scalar num, std::vector<cv::Mat> tile_list); //for loop allowing operations across single element and list
|
||||
|
||||
std::vector<cv::Mat> average_vector(std::vector<cv::Mat> tile_list); //take average of vector elements
|
||||
|
||||
*/
|
||||
|
||||
private:
|
||||
float tileRMS(cv::Mat tile) {
|
||||
cv::Mat squared;
|
||||
cv::multiply(tile, tile, squared);
|
||||
return sqrt(cv::mean(squared)[0]);
|
||||
}
|
||||
|
||||
std::vector<float> getNoiseVariance(std::vector<cv::Mat> tiles, float lambda_shot, float lambda_read) {
|
||||
std::vector<float> noise_variance;
|
||||
for (auto tile : tiles) {
|
||||
noise_variance.push_back(lambda_shot * tileRMS(tile) + lambda_read);
|
||||
}
|
||||
return noise_variance;
|
||||
}
|
||||
|
||||
cv::Mat cosineWindow1D(cv::Mat input, int window_size = TILE_SIZE) {
|
||||
cv::Mat output = input.clone();
|
||||
for (int i = 0; i < input.cols; ++i) {
|
||||
output.at<float>(0, i) = 1. / 2. - 1. / 2. * cos(2 * M_PI * (input.at<float>(0, i) + 1 / 2.) / window_size);
|
||||
}
|
||||
return output;
|
||||
}
|
||||
|
||||
cv::Mat cosineWindow2D(cv::Mat tile) {
|
||||
int window_size = tile.rows; // Assuming square tile
|
||||
cv::Mat output_tile = tile.clone();
|
||||
|
||||
cv::Mat window = cv::Mat::zeros(1, window_size, CV_32F);
|
||||
for(int i = 0; i < window_size; ++i) {
|
||||
window.at<float>(i) = i;
|
||||
}
|
||||
|
||||
cv::Mat window_x = cosineWindow1D(window, window_size);
|
||||
window_x = cv::repeat(window_x, window_size, 1);
|
||||
cv::Mat window_2d = window_x.mul(window_x.t());
|
||||
|
||||
cv::Mat window_applied;
|
||||
cv::multiply(tile, window_2d, window_applied, 1, CV_32F);
|
||||
return window_applied;
|
||||
}
|
||||
|
||||
cv::Mat cat2Dtiles(std::vector<std::vector<cv::Mat>> tiles) {
|
||||
std::vector<cv::Mat> rows;
|
||||
for (auto row_tiles : tiles) {
|
||||
cv::Mat row;
|
||||
cv::hconcat(row_tiles, row);
|
||||
rows.push_back(row);
|
||||
}
|
||||
cv::Mat img;
|
||||
cv::vconcat(rows, img);
|
||||
return img;
|
||||
}
|
||||
|
||||
void circshift(cv::Mat &out, const cv::Point &delta)
|
||||
{
|
||||
cv::Size sz = out.size();
|
||||
|
||||
// error checking
|
||||
assert(sz.height > 0 && sz.width > 0);
|
||||
|
||||
// no need to shift
|
||||
if ((sz.height == 1 && sz.width == 1) || (delta.x == 0 && delta.y == 0))
|
||||
return;
|
||||
|
||||
// delta transform
|
||||
int x = delta.x;
|
||||
int y = delta.y;
|
||||
if (x > 0) x = x % sz.width;
|
||||
if (y > 0) y = y % sz.height;
|
||||
if (x < 0) x = x % sz.width + sz.width;
|
||||
if (y < 0) y = y % sz.height + sz.height;
|
||||
|
||||
|
||||
// in case of multiple dimensions
|
||||
std::vector<cv::Mat> planes;
|
||||
split(out, planes);
|
||||
|
||||
for (size_t i = 0; i < planes.size(); i++)
|
||||
{
|
||||
// vertical
|
||||
cv::Mat tmp0, tmp1, tmp2, tmp3;
|
||||
cv::Mat q0(planes[i], cv::Rect(0, 0, sz.width, sz.height - y));
|
||||
cv::Mat q1(planes[i], cv::Rect(0, sz.height - y, sz.width, y));
|
||||
q0.copyTo(tmp0);
|
||||
q1.copyTo(tmp1);
|
||||
tmp0.copyTo(planes[i](cv::Rect(0, y, sz.width, sz.height - y)));
|
||||
tmp1.copyTo(planes[i](cv::Rect(0, 0, sz.width, y)));
|
||||
|
||||
// horizontal
|
||||
cv::Mat q2(planes[i], cv::Rect(0, 0, sz.width - x, sz.height));
|
||||
cv::Mat q3(planes[i], cv::Rect(sz.width - x, 0, x, sz.height));
|
||||
q2.copyTo(tmp2);
|
||||
q3.copyTo(tmp3);
|
||||
tmp2.copyTo(planes[i](cv::Rect(x, 0, sz.width - x, sz.height)));
|
||||
tmp3.copyTo(planes[i](cv::Rect(0, 0, x, sz.height)));
|
||||
}
|
||||
|
||||
cv::merge(planes, out);
|
||||
}
|
||||
|
||||
void fftshift(cv::Mat &out)
|
||||
{
|
||||
cv::Size sz = out.size();
|
||||
cv::Point pt(0, 0);
|
||||
pt.x = (int) floor(sz.width / 2.0);
|
||||
pt.y = (int) floor(sz.height / 2.0);
|
||||
circshift(out, pt);
|
||||
}
|
||||
|
||||
void ifftshift(cv::Mat &out)
|
||||
{
|
||||
cv::Size sz = out.size();
|
||||
cv::Point pt(0, 0);
|
||||
pt.x = (int) ceil(sz.width / 2.0);
|
||||
pt.y = (int) ceil(sz.height / 2.0);
|
||||
circshift(out, pt);
|
||||
}
|
||||
|
||||
std::vector<cv::Mat> getReferenceTiles(cv::Mat reference_image);
|
||||
|
||||
cv::Mat mergeTiles(std::vector<cv::Mat> tiles, int rows, int cols);
|
||||
|
||||
cv::Mat processChannel( hdrplus::burst& burst_images, \
|
||||
std::vector<std::vector<std::vector<std::pair<int, int>>>>& alignments, \
|
||||
cv::Mat channel_image, \
|
||||
std::vector<cv::Mat> alternate_channel_i_list,\
|
||||
float lambda_shot, \
|
||||
float lambda_read);
|
||||
|
||||
//temporal denoise
|
||||
std::vector<cv::Mat> temporal_denoise(std::vector<cv::Mat> tiles, std::vector<std::vector<cv::Mat>> alt_tiles, std::vector<float> noise_variance, float temporal_factor);
|
||||
std::vector<cv::Mat> spatial_denoise(std::vector<cv::Mat> tiles, int num_alts, std::vector<float> noise_variance, float spatial_factor);
|
||||
|
||||
|
||||
};
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,69 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <memory> // std::shared_ptr
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <libraw/libraw.h>
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
class RawpyArgs{
|
||||
public:
|
||||
int demosaic_algorithm = 3;// 3 - AHD interpolation <->int user_qual
|
||||
bool half_size = false;
|
||||
bool use_camera_wb = true;
|
||||
bool use_auto_wb = false;
|
||||
bool no_auto_bright = true;
|
||||
int output_color = LIBRAW_COLORSPACE_sRGB;
|
||||
int gamma[2] = {1,1}; //# gamma correction not applied by rawpy (not quite understand)
|
||||
int output_bps = 16;
|
||||
};
|
||||
|
||||
class Options{
|
||||
public:
|
||||
std::string input = "";
|
||||
std::string output = "";
|
||||
std::string mode = "full"; //'full' 'align' 'merge' 'finish'
|
||||
int reference = 0;
|
||||
float temporalfactor=75.0;
|
||||
float spatialfactor = 0.1;
|
||||
int ltmGain=-1;
|
||||
double gtmContrast=0.075;
|
||||
int verbose=2; // (0, 1, 2, 3, 4, 5)
|
||||
|
||||
};
|
||||
|
||||
class Tuning{
|
||||
public:
|
||||
std::string ltmGain = "auto";
|
||||
double gtmContrast = 0.075;
|
||||
std::vector<float> sharpenAmount{1,0.5,0.5};
|
||||
std::vector<float> sharpenSigma{1,2,4};
|
||||
std::vector<float> sharpenThreshold{0.02,0.04,0.06};
|
||||
};
|
||||
|
||||
class Parameters{
|
||||
public:
|
||||
std::unordered_map<std::string,bool> flags;
|
||||
|
||||
RawpyArgs rawpyArgs;
|
||||
Options options;
|
||||
Tuning tuning;
|
||||
|
||||
Parameters()
|
||||
{
|
||||
const char* keys[] = {"writeReferenceImage", "writeGammaReference", "writeMergedImage", "writeGammaMerged",
|
||||
"writeShortExposure", "writeLongExposure", "writeFusedExposure", "writeLTMImage",
|
||||
"writeLTMGamma", "writeGTMImage", "writeReferenceFinal", "writeFinalImage"};
|
||||
for (int idx = 0; idx < sizeof(keys) / sizeof(const char*); idx++) {
|
||||
flags[keys[idx]] = true;
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
cv::Mat postprocess(std::shared_ptr<LibRaw>& libraw_ptr, RawpyArgs rawpyArgs);
|
||||
void setParams(std::shared_ptr<LibRaw>& libraw_ptr, RawpyArgs rawpyArgs);
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,326 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <stdexcept> // std::runtime_error
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <omp.h>
|
||||
|
||||
// https://stackoverflow.com/questions/63404539/portable-loop-unrolling-with-template-parameter-in-c-with-gcc-icc
|
||||
/// Helper macros for stringification
|
||||
#define TO_STRING_HELPER(X) #X
|
||||
#define TO_STRING(X) TO_STRING_HELPER(X)
|
||||
|
||||
// Define loop unrolling depending on the compiler
|
||||
#if defined(__ICC) || defined(__ICL)
|
||||
#define UNROLL_LOOP(n) _Pragma(TO_STRING(unroll (n)))
|
||||
#elif defined(__clang__)
|
||||
#define UNROLL_LOOP(n) _Pragma(TO_STRING(unroll (n)))
|
||||
#elif defined(__GNUC__) && !defined(__clang__)
|
||||
#define UNROLL_LOOP(n) _Pragma(TO_STRING(GCC unroll (16)))
|
||||
#elif defined(_MSC_BUILD)
|
||||
#pragma message ("Microsoft Visual C++ (MSVC) detected: Loop unrolling not supported!")
|
||||
#define UNROLL_LOOP(n)
|
||||
#else
|
||||
#warning "Unknown compiler: Loop unrolling not supported!"
|
||||
#define UNROLL_LOOP(n)
|
||||
#endif
|
||||
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
|
||||
template <typename T, int kernel>
|
||||
cv::Mat box_filter_kxk( const cv::Mat& src_image )
|
||||
{
|
||||
const T* src_image_ptr = (T*)src_image.data;
|
||||
int src_height = src_image.size().height;
|
||||
int src_width = src_image.size().width;
|
||||
int src_step = src_image.step1();
|
||||
|
||||
if ( kernel <= 0 )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return cv::Mat();
|
||||
#else
|
||||
throw std::runtime_error(std::string( __FILE__ ) + "::" + __func__ + " box filter only support kernel size >= 1");
|
||||
#endif
|
||||
}
|
||||
|
||||
// int(src_height / kernel) = floor(src_height / kernel)
|
||||
// When input size is not multiplier of kernel, take floor
|
||||
cv::Mat dst_image( src_height / kernel, src_width / kernel, src_image.type() );
|
||||
T* dst_image_ptr = (T*)dst_image.data;
|
||||
int dst_height = dst_image.size().height;
|
||||
int dst_width = dst_image.size().width;
|
||||
int dst_step = dst_image.step1();
|
||||
|
||||
for ( int row_i = 0; row_i < dst_height; ++row_i )
|
||||
{
|
||||
for ( int col_i = 0; col_i < dst_width; col_i++ )
|
||||
{
|
||||
// Take ceiling for rounding
|
||||
T box_sum = T( 0 );
|
||||
|
||||
UNROLL_LOOP( kernel )
|
||||
for ( int kernel_row_i = 0; kernel_row_i < kernel; ++kernel_row_i )
|
||||
{
|
||||
UNROLL_LOOP( kernel )
|
||||
for ( int kernel_col_i = 0; kernel_col_i < kernel; ++kernel_col_i )
|
||||
{
|
||||
box_sum += src_image_ptr[ ( row_i * kernel + kernel_row_i ) * src_step + ( col_i * kernel + kernel_col_i ) ];
|
||||
}
|
||||
}
|
||||
|
||||
// Average by taking ceiling
|
||||
T box_avg = box_sum / T( kernel * kernel );
|
||||
dst_image_ptr[ row_i * dst_step + col_i ] = box_avg;
|
||||
}
|
||||
}
|
||||
|
||||
return dst_image;
|
||||
}
|
||||
|
||||
|
||||
template <typename T, int kernel>
|
||||
cv::Mat downsample_nearest_neighbour( const cv::Mat& src_image )
|
||||
{
|
||||
const T* src_image_ptr = (T*)src_image.data;
|
||||
int src_height = src_image.size().height;
|
||||
int src_width = src_image.size().width;
|
||||
int src_step = src_image.step1();
|
||||
|
||||
// int(src_height / kernel) = floor(src_height / kernel)
|
||||
// When input size is not multiplier of kernel, take floor
|
||||
cv::Mat dst_image = cv::Mat( src_height / kernel, src_width / kernel, src_image.type() );
|
||||
T* dst_image_ptr = (T*)dst_image.data;
|
||||
int dst_height = dst_image.size().height;
|
||||
int dst_width = dst_image.size().width;
|
||||
int dst_step = dst_image.step1();
|
||||
|
||||
// -03 should be enough to optimize below code
|
||||
for ( int row_i = 0; row_i < dst_height; row_i++ )
|
||||
{
|
||||
UNROLL_LOOP( 32 )
|
||||
for ( int col_i = 0; col_i < dst_width; col_i++ )
|
||||
{
|
||||
dst_image_ptr[ row_i * dst_step + col_i ] = \
|
||||
src_image_ptr[ (row_i * kernel) * src_step + (col_i * kernel) ];
|
||||
}
|
||||
}
|
||||
|
||||
return dst_image;
|
||||
}
|
||||
|
||||
|
||||
template< typename T >
|
||||
void print_cvmat( cv::Mat image )
|
||||
{
|
||||
const T* img_ptr = (const T*)image.data;
|
||||
int height = image.size().height;
|
||||
int width = image.size().width;
|
||||
int step = image.step1();
|
||||
int chns = image.channels();
|
||||
|
||||
printf("print_cvmat()::Image of size height = %d, width = %d, step = %d\n", \
|
||||
height, width, step );
|
||||
|
||||
if ( chns == 1 )
|
||||
{
|
||||
for ( int row_i = 0; row_i < height; ++row_i )
|
||||
{
|
||||
int row_i_offset = row_i * step;
|
||||
for ( int col_i = 0; col_i < width; ++col_i )
|
||||
{
|
||||
printf("%3.d ", img_ptr[ row_i_offset + col_i ]);
|
||||
//printf("%3.d ", int( image.at<T>( row_i, col_i ) ) );
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
else if ( chns == 3 )
|
||||
{
|
||||
for ( int row_i = 0; row_i < height; ++row_i )
|
||||
{
|
||||
int row_i_offset = row_i * step;
|
||||
for ( int col_i = 0; col_i < width; ++col_i )
|
||||
{
|
||||
printf("[%3.d, %3.d, %3.d] ", img_ptr[ row_i_offset + col_i * 3 + 0 ], \
|
||||
img_ptr[ row_i_offset + col_i * 3 + 1 ], \
|
||||
img_ptr[ row_i_offset + col_i * 3 + 2 ] );
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
#else
|
||||
throw std::runtime_error("cv::Mat number of channel currently not support to print\n");
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Extract RGB channel seprately from bayer image
|
||||
*
|
||||
* @tparam T data tyoe of bayer image.
|
||||
* @return vector of RGB image. OpenCV internally maintain reference count.
|
||||
* Thus this step won't create deep copy overhead.
|
||||
*
|
||||
* @example extract_rgb_from_bayer<uint16_t>( bayer_img, rgb_vector_container );
|
||||
*/
|
||||
template <typename T>
|
||||
void extract_rgb_from_bayer( const cv::Mat& bayer_img, \
|
||||
cv::Mat& img_ch1, cv::Mat& img_ch2, cv::Mat& img_ch3, cv::Mat& img_ch4 )
|
||||
{
|
||||
const T* bayer_img_ptr = (const T*)bayer_img.data;
|
||||
int bayer_width = bayer_img.size().width;
|
||||
int bayer_height = bayer_img.size().height;
|
||||
int bayer_step = bayer_img.step1();
|
||||
|
||||
if ( bayer_width % 2 != 0 || bayer_height % 2 != 0 )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
#else
|
||||
throw std::runtime_error("Bayer image data size incorrect, must be multiplier of 2\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
// RGB image is half the size of bayer image
|
||||
int rgb_width = bayer_width / 2;
|
||||
int rgb_height = bayer_height / 2;
|
||||
img_ch1.create( rgb_height, rgb_width, bayer_img.type() );
|
||||
img_ch2.create( rgb_height, rgb_width, bayer_img.type() );
|
||||
img_ch3.create( rgb_height, rgb_width, bayer_img.type() );
|
||||
img_ch4.create( rgb_height, rgb_width, bayer_img.type() );
|
||||
int rgb_step = img_ch1.step1();
|
||||
|
||||
T* img_ch1_ptr = (T*)img_ch1.data;
|
||||
T* img_ch2_ptr = (T*)img_ch2.data;
|
||||
T* img_ch3_ptr = (T*)img_ch3.data;
|
||||
T* img_ch4_ptr = (T*)img_ch4.data;
|
||||
|
||||
#pragma omp parallel for
|
||||
for ( int rgb_row_i = 0; rgb_row_i < rgb_height; rgb_row_i++ )
|
||||
{
|
||||
int rgb_row_i_offset = rgb_row_i * rgb_step;
|
||||
|
||||
// Every RGB row corresbonding to two Bayer image row
|
||||
int bayer_row_i_offset0 = ( rgb_row_i * 2 + 0 ) * bayer_step; // For RG
|
||||
int bayer_row_i_offset1 = ( rgb_row_i * 2 + 1 ) * bayer_step; // For GB
|
||||
|
||||
for ( int rgb_col_j = 0; rgb_col_j < rgb_width; rgb_col_j++ )
|
||||
{
|
||||
// img_ch1/2/3/4 : (0,0), (1,0), (0,1), (1,1)
|
||||
int bayer_col_i_offset0 = rgb_col_j * 2 + 0;
|
||||
int bayer_col_i_offset1 = rgb_col_j * 2 + 1;
|
||||
|
||||
img_ch1_ptr[ rgb_row_i_offset + rgb_col_j ] = bayer_img_ptr[ bayer_row_i_offset0 + bayer_col_i_offset0 ];
|
||||
img_ch3_ptr[ rgb_row_i_offset + rgb_col_j ] = bayer_img_ptr[ bayer_row_i_offset0 + bayer_col_i_offset1 ];
|
||||
img_ch2_ptr[ rgb_row_i_offset + rgb_col_j ] = bayer_img_ptr[ bayer_row_i_offset1 + bayer_col_i_offset0 ];
|
||||
img_ch4_ptr[ rgb_row_i_offset + rgb_col_j ] = bayer_img_ptr[ bayer_row_i_offset1 + bayer_col_i_offset1 ];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Convert RGB image to gray image through same weight linear combination.
|
||||
* Also support implicit data type conversion.
|
||||
*
|
||||
* @tparam RGB_DTYPE rgb image type (e.g. uint16_t)
|
||||
* @tparam GRAY_DTYPE gray image type (e.g. uint16_t)
|
||||
* @tparam GRAY_CVTYPE opencv gray image type
|
||||
*/
|
||||
template< typename RGB_DTYPE, typename GRAY_DTYPE, int GRAY_CVTYPE >
|
||||
cv::Mat rgb_2_gray( const cv::Mat& rgb_img )
|
||||
{
|
||||
const RGB_DTYPE* rgb_img_ptr = (const RGB_DTYPE*)rgb_img.data;
|
||||
int img_width = rgb_img.size().width;
|
||||
int img_height = rgb_img.size().height;
|
||||
int rgb_img_step = rgb_img.step1();
|
||||
|
||||
// Create output gray cv::Mat
|
||||
cv::Mat gray_img( img_height, img_width, GRAY_CVTYPE );
|
||||
GRAY_DTYPE* gray_img_ptr = (GRAY_DTYPE*)gray_img.data;
|
||||
int gray_img_step = gray_img.step1();
|
||||
|
||||
#pragma omp parallel for
|
||||
for ( int row_i = 0; row_i < img_height; row_i++ )
|
||||
{
|
||||
int rgb_row_i_offset = row_i * rgb_img_step;
|
||||
int gray_row_i_offset = row_i * gray_img_step;
|
||||
|
||||
UNROLL_LOOP( 32 ) // multiplier of cache line size
|
||||
for ( int col_j = 0; col_j < img_width; col_j++ )
|
||||
{
|
||||
GRAY_DTYPE avg_ij(0);
|
||||
|
||||
avg_ij += rgb_img_ptr[ rgb_row_i_offset + (col_j * 3 + 0) ];
|
||||
avg_ij += rgb_img_ptr[ rgb_row_i_offset + (col_j * 3 + 1) ];
|
||||
avg_ij += rgb_img_ptr[ rgb_row_i_offset + (col_j * 3 + 2) ];
|
||||
|
||||
avg_ij /= 3;
|
||||
|
||||
gray_img_ptr[ gray_row_i_offset + col_j ] = avg_ij;
|
||||
}
|
||||
}
|
||||
|
||||
// OpenCV use reference count. Thus return won't create deep copy
|
||||
return gray_img;
|
||||
}
|
||||
|
||||
|
||||
template <typename T>
|
||||
void print_tile( const cv::Mat& img, int tile_size, int start_idx_row, int start_idx_col )
|
||||
{
|
||||
const T* img_ptr = (T*)img.data;
|
||||
int src_step = img.step1();
|
||||
|
||||
for ( int row = start_idx_row; row < tile_size + start_idx_row; ++row )
|
||||
{
|
||||
const T* img_ptr_row = img_ptr + row * src_step;
|
||||
for ( int col = start_idx_col; col < tile_size + start_idx_col; ++col )
|
||||
{
|
||||
printf("%u ", img_ptr_row[ col ] );
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
|
||||
template< typename T>
|
||||
void print_img( const cv::Mat& img, int img_height = -1, int img_width = -1 )
|
||||
{
|
||||
const T* img_ptr = (T*)img.data;
|
||||
if ( img_height == -1 && img_width == -1 )
|
||||
{
|
||||
img_height = img.size().height;
|
||||
img_width = img.size().width;
|
||||
}
|
||||
else
|
||||
{
|
||||
img_height = std::min( img.size().height, img_height );
|
||||
img_width = std::min( img.size().width, img_width );
|
||||
}
|
||||
printf("Image size (h=%d, w=%d), Print range (h=0-%d, w=0-%d)]\n", \
|
||||
img.size().height, img.size().width, img_height, img_width );
|
||||
|
||||
int img_step = img.step1();
|
||||
|
||||
for ( int row = 0; row < img_height; ++row )
|
||||
{
|
||||
const T* img_ptr_row = img_ptr + row * img_step;
|
||||
for ( int col = 0; col < img_width; ++col )
|
||||
{
|
||||
printf("%u ", img_ptr_row[ col ]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,990 @@
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <limits>
|
||||
#include <cstdio>
|
||||
#include <utility> // std::make_pair
|
||||
#include <stdexcept> // std::runtime_error
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <omp.h>
|
||||
#include "hdrplus/align.h"
|
||||
#include "hdrplus/burst.h"
|
||||
#include "hdrplus/utility.h"
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
// Function declration
|
||||
static void build_per_grayimg_pyramid( \
|
||||
std::vector<cv::Mat>& images_pyramid, \
|
||||
const cv::Mat& src_image, \
|
||||
const std::vector<int>& inv_scale_factors );
|
||||
|
||||
|
||||
template< int pyramid_scale_factor_prev_curr, int tilesize_scale_factor_prev_curr, int tile_size >
|
||||
static void build_upsampled_prev_aligement( \
|
||||
const std::vector<std::vector<std::pair<int, int>>>& src_alignment, \
|
||||
std::vector<std::vector<std::pair<int, int>>>& dst_alignment, \
|
||||
int num_tiles_h, int num_tiles_w, \
|
||||
const cv::Mat& ref_img, const cv::Mat& alt_img, \
|
||||
bool consider_nbr = false );
|
||||
|
||||
|
||||
template< typename data_type, typename return_type, int tile_size >
|
||||
static unsigned long long l1_distance( const cv::Mat& img1, const cv::Mat& img2, \
|
||||
int img1_tile_row_start_idx, int img1_tile_col_start_idx, \
|
||||
int img2_tile_row_start_idx, int img2_tile_col_start_idx );
|
||||
|
||||
|
||||
template< typename data_type, typename return_type, int tile_size >
|
||||
static return_type l2_distance( const cv::Mat& img1, const cv::Mat& img2, \
|
||||
int img1_tile_row_start_idx, int img1_tile_col_start_idx, \
|
||||
int img2_tile_row_start_idx, int img2_tile_col_start_idx );
|
||||
|
||||
|
||||
static void align_image_level( \
|
||||
const cv::Mat& ref_img, \
|
||||
const cv::Mat& alt_img, \
|
||||
std::vector<std::vector<std::pair<int, int>>>& prev_aligement, \
|
||||
std::vector<std::vector<std::pair<int, int>>>& curr_alignment, \
|
||||
int scale_factor_prev_curr, \
|
||||
int curr_tile_size, \
|
||||
int prev_tile_size, \
|
||||
int search_radiou, \
|
||||
int distance_type );
|
||||
|
||||
|
||||
// Function Implementations
|
||||
|
||||
|
||||
// static function only visible within file
|
||||
static void build_per_grayimg_pyramid( \
|
||||
std::vector<cv::Mat>& images_pyramid, \
|
||||
const cv::Mat& src_image, \
|
||||
const std::vector<int>& inv_scale_factors )
|
||||
{
|
||||
// #ifndef NDEBUG
|
||||
// printf("%s::%s build_per_grayimg_pyramid start with scale factor : ", __FILE__, __func__ );
|
||||
// for ( int i = 0; i < inv_scale_factors.size(); ++i )
|
||||
// {
|
||||
// printf("%d ", inv_scale_factors.at( i ));
|
||||
// }
|
||||
// printf("\n");
|
||||
// #endif
|
||||
|
||||
images_pyramid.resize( inv_scale_factors.size() );
|
||||
|
||||
for ( size_t i = 0; i < inv_scale_factors.size(); ++i )
|
||||
{
|
||||
cv::Mat blur_image;
|
||||
cv::Mat downsample_image;
|
||||
|
||||
switch ( inv_scale_factors[ i ] )
|
||||
{
|
||||
case 1:
|
||||
images_pyramid[ i ] = src_image.clone();
|
||||
// cv::Mat use reference count, will not create deep copy
|
||||
downsample_image = src_image;
|
||||
break;
|
||||
case 2:
|
||||
// printf("(2) downsample with gaussian sigma %.2f", inv_scale_factors[ i ] * 0.5 );
|
||||
// // Gaussian blur
|
||||
cv::GaussianBlur( images_pyramid.at( i-1 ), blur_image, cv::Size(0, 0), inv_scale_factors[ i ] * 0.5 );
|
||||
|
||||
// // Downsample
|
||||
downsample_image = downsample_nearest_neighbour<uint16_t, 2>( blur_image );
|
||||
// downsample_image = downsample_nearest_neighbour<uint16_t, 2>( images_pyramid.at( i-1 ) );
|
||||
|
||||
// Add
|
||||
images_pyramid.at( i ) = downsample_image.clone();
|
||||
|
||||
break;
|
||||
case 4:
|
||||
// printf("(4) downsample with gaussian sigma %.2f", inv_scale_factors[ i ] * 0.5 );
|
||||
cv::GaussianBlur( images_pyramid.at( i-1 ), blur_image, cv::Size(0, 0), inv_scale_factors[ i ] * 0.5 );
|
||||
downsample_image = downsample_nearest_neighbour<uint16_t, 4>( blur_image );
|
||||
// downsample_image = downsample_nearest_neighbour<uint16_t, 4>( images_pyramid.at( i-1 ) );
|
||||
images_pyramid.at( i ) = downsample_image.clone();
|
||||
break;
|
||||
default:
|
||||
#ifdef __ANDROID__
|
||||
|
||||
#else
|
||||
throw std::runtime_error("inv scale factor " + std::to_string( inv_scale_factors[ i ]) + "invalid" );
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static bool operator!=( const std::pair<int, int>& lhs, const std::pair<int, int>& rhs )
|
||||
{
|
||||
return lhs.first != rhs.first || lhs.second != rhs.second;
|
||||
}
|
||||
|
||||
|
||||
template< int pyramid_scale_factor_prev_curr, int tilesize_scale_factor_prev_curr, int tile_size >
|
||||
static void build_upsampled_prev_aligement( \
|
||||
const std::vector<std::vector<std::pair<int, int>>>& src_alignment, \
|
||||
std::vector<std::vector<std::pair<int, int>>>& dst_alignment, \
|
||||
int num_tiles_h, int num_tiles_w, \
|
||||
const cv::Mat& ref_img, const cv::Mat& alt_img, \
|
||||
bool consider_nbr )
|
||||
{
|
||||
int src_num_tiles_h = src_alignment.size();
|
||||
int src_num_tiles_w = src_alignment[ 0 ].size();
|
||||
|
||||
constexpr int repeat_factor = pyramid_scale_factor_prev_curr / tilesize_scale_factor_prev_curr;
|
||||
|
||||
// printf("build_upsampled_prev_aligement with scale factor %d, repeat factor %d, tile size factor %d\n", \
|
||||
// pyramid_scale_factor_prev_curr, repeat_factor, tilesize_scale_factor_prev_curr );
|
||||
|
||||
int dst_num_tiles_main_h = src_num_tiles_h * repeat_factor;
|
||||
int dst_num_tiles_main_w = src_num_tiles_w * repeat_factor;
|
||||
|
||||
if ( dst_num_tiles_main_h > num_tiles_h || dst_num_tiles_main_w > num_tiles_w )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("current level number of tiles smaller than upsampled tiles\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
// Allocate data for dst_alignment
|
||||
// NOTE: number of tiles h, number of tiles w might be different from dst_num_tiles_main_h, dst_num_tiles_main_w
|
||||
// For tiles between num_tile_h and dst_num_tiles_main_h, use (0,0)
|
||||
dst_alignment.resize( num_tiles_h, std::vector<std::pair<int, int>>( num_tiles_w, std::pair<int, int>(0, 0) ) );
|
||||
|
||||
// Upsample alignment
|
||||
#pragma omp parallel for collapse(2)
|
||||
for ( int row_i = 0; row_i < src_num_tiles_h; row_i++ )
|
||||
{
|
||||
for ( int col_i = 0; col_i < src_num_tiles_w; col_i++ )
|
||||
{
|
||||
// Scale alignment
|
||||
std::pair<int, int> align_i = src_alignment[ row_i ][ col_i ];
|
||||
align_i.first *= pyramid_scale_factor_prev_curr;
|
||||
align_i.second *= pyramid_scale_factor_prev_curr;
|
||||
|
||||
// repeat
|
||||
UNROLL_LOOP( repeat_factor )
|
||||
for ( int repeat_row_i = 0; repeat_row_i < repeat_factor; ++repeat_row_i )
|
||||
{
|
||||
int repeat_row_i_offset = row_i * repeat_factor + repeat_row_i;
|
||||
UNROLL_LOOP( repeat_factor )
|
||||
for ( int repeat_col_i = 0; repeat_col_i < repeat_factor; ++repeat_col_i )
|
||||
{
|
||||
int repeat_col_i_offset = col_i * repeat_factor + repeat_col_i;
|
||||
dst_alignment[ repeat_row_i_offset ][ repeat_col_i_offset ] = align_i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( consider_nbr )
|
||||
{
|
||||
// Copy consurtctor
|
||||
std::vector<std::vector<std::pair<int, int>>> upsampled_alignment{ dst_alignment };
|
||||
|
||||
// Distance function
|
||||
unsigned long long (*distance_func_ptr)(const cv::Mat&, const cv::Mat&, int, int, int, int) = \
|
||||
&l1_distance<uint16_t, unsigned long long, tile_size>;
|
||||
|
||||
#pragma omp parallel for collapse(2)
|
||||
for ( int tile_row_i = 0; tile_row_i < num_tiles_h; tile_row_i++ )
|
||||
{
|
||||
for ( int tile_col_i = 0; tile_col_i < num_tiles_w; tile_col_i++ )
|
||||
{
|
||||
const auto& curr_align_i = upsampled_alignment[ tile_row_i ][ tile_col_i ];
|
||||
|
||||
// Container for nbr alignment pair
|
||||
std::vector<std::pair<int, int>> nbrs_align_i;
|
||||
|
||||
// Consider 4 neighbour's alignment
|
||||
// Only compute distance if alignment is different
|
||||
if ( tile_col_i > 0 )
|
||||
{
|
||||
const auto& nbr1_align_i = upsampled_alignment[ tile_row_i + 0 ][ tile_col_i - 1 ];
|
||||
if ( curr_align_i != nbr1_align_i ) nbrs_align_i.emplace_back( nbr1_align_i );
|
||||
}
|
||||
|
||||
if ( tile_col_i < num_tiles_w - 1 )
|
||||
{
|
||||
const auto& nbr2_align_i = upsampled_alignment[ tile_row_i + 0 ][ tile_col_i + 1 ];
|
||||
if ( curr_align_i != nbr2_align_i ) nbrs_align_i.emplace_back( nbr2_align_i );
|
||||
}
|
||||
|
||||
if ( tile_row_i > 0 )
|
||||
{
|
||||
const auto& nbr3_align_i = upsampled_alignment[ tile_row_i - 1 ][ tile_col_i + 0 ];
|
||||
if ( curr_align_i != nbr3_align_i ) nbrs_align_i.emplace_back( nbr3_align_i );
|
||||
}
|
||||
|
||||
if ( tile_row_i < num_tiles_h - 1 )
|
||||
{
|
||||
const auto& nbr4_align_i = upsampled_alignment[ tile_row_i + 1 ][ tile_col_i + 0 ];
|
||||
if ( curr_align_i != nbr4_align_i ) nbrs_align_i.emplace_back( nbr4_align_i );
|
||||
}
|
||||
|
||||
// If there is a nbr alignment that need to be considered. Compute distance
|
||||
if ( ! nbrs_align_i.empty() )
|
||||
{
|
||||
int ref_tile_row_start_idx_i = tile_row_i * tile_size / 2;
|
||||
int ref_tile_col_start_idx_i = tile_col_i * tile_size / 2;
|
||||
|
||||
// curr_align_i's distance
|
||||
auto curr_align_i_distance = distance_func_ptr(
|
||||
ref_img, alt_img, \
|
||||
ref_tile_row_start_idx_i, \
|
||||
ref_tile_col_start_idx_i, \
|
||||
ref_tile_row_start_idx_i + curr_align_i.first, \
|
||||
ref_tile_col_start_idx_i + curr_align_i.second );
|
||||
|
||||
for ( const auto& nbr_align_i : nbrs_align_i )
|
||||
{
|
||||
auto nbr_align_i_distance = distance_func_ptr(
|
||||
ref_img, alt_img, \
|
||||
ref_tile_row_start_idx_i, \
|
||||
ref_tile_col_start_idx_i, \
|
||||
ref_tile_row_start_idx_i + nbr_align_i.first, \
|
||||
ref_tile_col_start_idx_i + nbr_align_i.second );
|
||||
|
||||
if ( nbr_align_i_distance < curr_align_i_distance )
|
||||
{
|
||||
#ifdef NDEBUG
|
||||
printf("tile [%d, %d] update align, prev align (%d, %d) curr align (%d, %d), prev distance %d curr distance %d\n", \
|
||||
tile_row_i, tile_col_i, \
|
||||
curr_align_i.first, curr_align_i.second, \
|
||||
nbr_align_i.first, nbr_align_i.second, \
|
||||
int(curr_align_i_distance), int(nbr_align_i_distance) );
|
||||
#endif
|
||||
|
||||
dst_alignment[ tile_row_i ][ tile_col_i ] = nbr_align_i;
|
||||
curr_align_i_distance = nbr_align_i_distance;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Set tilesize as template argument for better compiler optimization result.
|
||||
template< typename data_type, typename return_type, int tile_size >
|
||||
static unsigned long long l1_distance( const cv::Mat& img1, const cv::Mat& img2, \
|
||||
int img1_tile_row_start_idx, int img1_tile_col_start_idx, \
|
||||
int img2_tile_row_start_idx, int img2_tile_col_start_idx )
|
||||
{
|
||||
#define CUSTOME_ABS( x ) ( x ) > 0 ? ( x ) : - ( x )
|
||||
|
||||
const data_type* img1_ptr = (const data_type*)img1.data;
|
||||
const data_type* img2_ptr = (const data_type*)img2.data;
|
||||
|
||||
int img1_step = img1.step1();
|
||||
int img2_step = img2.step1();
|
||||
|
||||
int img1_width = img1.size().width;
|
||||
int img1_height = img1.size().height;
|
||||
|
||||
int img2_width = img2.size().width;
|
||||
int img2_height = img2.size().height;
|
||||
|
||||
// Range check for safety
|
||||
if ( img1_tile_row_start_idx < 0 || img1_tile_row_start_idx > img1_height - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return 0;
|
||||
#else
|
||||
throw std::runtime_error("l1 distance img1_tile_row_start_idx" + std::to_string( img1_tile_row_start_idx ) + \
|
||||
" out of valid range (0, " + std::to_string( img1_height - tile_size ) + ")\n" );
|
||||
#endif
|
||||
}
|
||||
|
||||
if ( img1_tile_col_start_idx < 0 || img1_tile_col_start_idx > img1_width - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return 0;
|
||||
#else
|
||||
throw std::runtime_error("l1 distance img1_tile_col_start_idx" + std::to_string( img1_tile_col_start_idx ) + \
|
||||
" out of valid range (0, " + std::to_string( img1_width - tile_size ) + ")\n" );
|
||||
#endif
|
||||
}
|
||||
|
||||
if ( img2_tile_row_start_idx < 0 || img2_tile_row_start_idx > img2_height - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return 0;
|
||||
#else
|
||||
throw std::runtime_error("l1 distance img2_tile_row_start_idx out of valid range\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
if ( img2_tile_col_start_idx < 0 || img2_tile_col_start_idx > img2_width - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return 0;
|
||||
#else
|
||||
throw std::runtime_error("l1 distance img2_tile_col_start_idx out of valid range\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
return_type sum(0);
|
||||
|
||||
UNROLL_LOOP( tile_size )
|
||||
for ( int row_i = 0; row_i < tile_size; ++row_i )
|
||||
{
|
||||
const data_type* img1_ptr_row_i = img1_ptr + (img1_tile_row_start_idx + row_i) * img1_step + img1_tile_col_start_idx;
|
||||
const data_type* img2_ptr_row_i = img2_ptr + (img2_tile_row_start_idx + row_i) * img2_step + img2_tile_col_start_idx;
|
||||
|
||||
UNROLL_LOOP( tile_size )
|
||||
for ( int col_i = 0; col_i < tile_size; ++col_i )
|
||||
{
|
||||
data_type l1 = CUSTOME_ABS( img1_ptr_row_i[ col_i ] - img2_ptr_row_i[ col_i ] );
|
||||
sum += l1;
|
||||
}
|
||||
}
|
||||
|
||||
#undef CUSTOME_ABS
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
|
||||
template< typename data_type, typename return_type, int tile_size >
|
||||
static return_type l2_distance( const cv::Mat& img1, const cv::Mat& img2, \
|
||||
int img1_tile_row_start_idx, int img1_tile_col_start_idx, \
|
||||
int img2_tile_row_start_idx, int img2_tile_col_start_idx )
|
||||
{
|
||||
#define CUSTOME_ABS( x ) ( x ) > 0 ? ( x ) : - ( x )
|
||||
|
||||
const data_type* img1_ptr = (const data_type*)img1.data;
|
||||
const data_type* img2_ptr = (const data_type*)img2.data;
|
||||
|
||||
int img1_step = img1.step1();
|
||||
int img2_step = img2.step1();
|
||||
|
||||
int img1_width = img1.size().width;
|
||||
int img1_height = img1.size().height;
|
||||
|
||||
int img2_width = img2.size().width;
|
||||
int img2_height = img2.size().height;
|
||||
|
||||
// Range check for safety
|
||||
if ( img1_tile_row_start_idx < 0 || img1_tile_row_start_idx > img1_height - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return 0;
|
||||
#else
|
||||
throw std::runtime_error("l2 distance img1_tile_row_start_idx" + std::to_string( img1_tile_row_start_idx ) + \
|
||||
" out of valid range (0, " + std::to_string( img1_height - tile_size ) + ")\n" );
|
||||
#endif
|
||||
}
|
||||
|
||||
if ( img1_tile_col_start_idx < 0 || img1_tile_col_start_idx > img1_width - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return 0;
|
||||
#else
|
||||
throw std::runtime_error("l2 distance img1_tile_col_start_idx" + std::to_string( img1_tile_col_start_idx ) + \
|
||||
" out of valid range (0, " + std::to_string( img1_width - tile_size ) + ")\n" );
|
||||
#endif
|
||||
}
|
||||
|
||||
if ( img2_tile_row_start_idx < 0 || img2_tile_row_start_idx > img2_height - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return 0;
|
||||
#else
|
||||
throw std::runtime_error("l2 distance img2_tile_row_start_idx out of valid range\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
if ( img2_tile_col_start_idx < 0 || img2_tile_col_start_idx > img2_width - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return 0;
|
||||
#else
|
||||
throw std::runtime_error("l2 distance img2_tile_col_start_idx out of valid range\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
// printf("Search two tile with ref : \n");
|
||||
// print_tile<data_type>( img1, tile_size, img1_tile_row_start_idx, img1_tile_col_start_idx );
|
||||
// printf("Search two tile with alt :\n");
|
||||
// print_tile<data_type>( img2, tile_size, img2_tile_row_start_idx, img2_tile_col_start_idx );
|
||||
|
||||
return_type sum(0);
|
||||
|
||||
UNROLL_LOOP( tile_size )
|
||||
for ( int row_i = 0; row_i < tile_size; ++row_i )
|
||||
{
|
||||
const data_type* img1_ptr_row_i = img1_ptr + (img1_tile_row_start_idx + row_i) * img1_step + img1_tile_col_start_idx;
|
||||
const data_type* img2_ptr_row_i = img2_ptr + (img2_tile_row_start_idx + row_i) * img2_step + img2_tile_col_start_idx;
|
||||
|
||||
UNROLL_LOOP( tile_size )
|
||||
for ( int col_i = 0; col_i < tile_size; ++col_i )
|
||||
{
|
||||
data_type l1 = CUSTOME_ABS( img1_ptr_row_i[ col_i ] - img2_ptr_row_i[ col_i ] );
|
||||
sum += ( l1 * l1 );
|
||||
}
|
||||
}
|
||||
|
||||
#undef CUSTOME_ABS
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
|
||||
template<typename T, int tile_size>
|
||||
static cv::Mat extract_img_tile( const cv::Mat& img, int img_tile_row_start_idx, int img_tile_col_start_idx )
|
||||
{
|
||||
const T* img_ptr = (const T*)img.data;
|
||||
int img_width = img.size().width;
|
||||
int img_height = img.size().height;
|
||||
int img_step = img.step1();
|
||||
|
||||
if ( img_tile_row_start_idx < 0 || img_tile_row_start_idx > img_height - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return cv::Mat();
|
||||
#else
|
||||
throw std::runtime_error("extract_img_tile img_tile_row_start_idx " + std::to_string( img_tile_row_start_idx ) + \
|
||||
" out of valid range (0, " + std::to_string( img_height - tile_size ) + ")\n" );
|
||||
#endif
|
||||
}
|
||||
|
||||
if ( img_tile_col_start_idx < 0 || img_tile_col_start_idx > img_width - tile_size )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return cv::Mat();
|
||||
#else
|
||||
throw std::runtime_error("extract_img_tile img_tile_col_start_idx " + std::to_string( img_tile_col_start_idx ) + \
|
||||
" out of valid range (0, " + std::to_string( img_width - tile_size ) + ")\n" );
|
||||
#endif
|
||||
}
|
||||
|
||||
cv::Mat img_tile( tile_size, tile_size, img.type() );
|
||||
T* img_tile_ptr = (T*)img_tile.data;
|
||||
int img_tile_step = img_tile.step1();
|
||||
|
||||
UNROLL_LOOP( tile_size )
|
||||
for ( int row_i = 0; row_i < tile_size; ++row_i )
|
||||
{
|
||||
const T* img_ptr_row_i = img_ptr + img_step * ( img_tile_row_start_idx + row_i );
|
||||
T* img_tile_ptr_row_i = img_tile_ptr + img_tile_step * row_i;
|
||||
|
||||
UNROLL_LOOP( tile_size )
|
||||
for ( int col_i = 0; col_i < tile_size; ++col_i )
|
||||
{
|
||||
img_tile_ptr_row_i[ col_i ] = img_ptr_row_i[ img_tile_col_start_idx + col_i ];
|
||||
}
|
||||
}
|
||||
|
||||
return img_tile;
|
||||
}
|
||||
|
||||
|
||||
void align_image_level( \
|
||||
const cv::Mat& ref_img, \
|
||||
const cv::Mat& alt_img, \
|
||||
std::vector<std::vector<std::pair<int, int>>>& prev_aligement, \
|
||||
std::vector<std::vector<std::pair<int, int>>>& curr_alignment, \
|
||||
int scale_factor_prev_curr, \
|
||||
int curr_tile_size, \
|
||||
int prev_tile_size, \
|
||||
int search_radiou, \
|
||||
int distance_type )
|
||||
{
|
||||
// Every align image level share the same distance function.
|
||||
// Use function ptr to reduce if else overhead inside for loop
|
||||
unsigned long long (*distance_func_ptr)(const cv::Mat&, const cv::Mat&, int, int, int, int) = nullptr;
|
||||
|
||||
if ( distance_type == 1 ) // l1 distance
|
||||
{
|
||||
if ( curr_tile_size == 8 )
|
||||
{
|
||||
distance_func_ptr = &l1_distance<uint16_t, unsigned long long, 8>;
|
||||
}
|
||||
else if ( curr_tile_size == 16 )
|
||||
{
|
||||
distance_func_ptr = &l1_distance<uint16_t, unsigned long long, 16>;
|
||||
}
|
||||
}
|
||||
else if ( distance_type == 2 ) // l2 distance
|
||||
{
|
||||
if ( curr_tile_size == 8 )
|
||||
{
|
||||
distance_func_ptr = &l2_distance<uint16_t, unsigned long long, 8>;
|
||||
}
|
||||
else if ( curr_tile_size == 16 )
|
||||
{
|
||||
distance_func_ptr = &l2_distance<uint16_t, unsigned long long, 16>;
|
||||
}
|
||||
}
|
||||
|
||||
// Every level share the same upsample function
|
||||
void (*upsample_alignment_func_ptr)(const std::vector<std::vector<std::pair<int, int>>>&, \
|
||||
std::vector<std::vector<std::pair<int, int>>>&, \
|
||||
int, int, const cv::Mat&, const cv::Mat&, bool) = nullptr;
|
||||
if ( scale_factor_prev_curr == 2 )
|
||||
{
|
||||
if ( curr_tile_size / prev_tile_size == 2 )
|
||||
{
|
||||
if ( curr_tile_size == 8 )
|
||||
{
|
||||
upsample_alignment_func_ptr = &build_upsampled_prev_aligement<2, 2, 8>;
|
||||
}
|
||||
else if ( curr_tile_size == 16 )
|
||||
{
|
||||
upsample_alignment_func_ptr = &build_upsampled_prev_aligement<2, 2, 16>;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("Something wrong with upsampling function setting\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
}
|
||||
else if ( curr_tile_size / prev_tile_size == 1 )
|
||||
{
|
||||
if ( curr_tile_size == 8 )
|
||||
{
|
||||
upsample_alignment_func_ptr = &build_upsampled_prev_aligement<2, 1, 8>;
|
||||
}
|
||||
else if ( curr_tile_size == 16 )
|
||||
{
|
||||
upsample_alignment_func_ptr = &build_upsampled_prev_aligement<2, 1, 16>;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("Something wrong with upsampling function setting\n");
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("Something wrong with upsampling function setting\n");
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else if ( scale_factor_prev_curr == 4 )
|
||||
{
|
||||
if ( curr_tile_size / prev_tile_size == 2 )
|
||||
{
|
||||
if ( curr_tile_size == 8 )
|
||||
{
|
||||
upsample_alignment_func_ptr = &build_upsampled_prev_aligement<4, 2, 8>;
|
||||
}
|
||||
else if ( curr_tile_size == 16 )
|
||||
{
|
||||
upsample_alignment_func_ptr = &build_upsampled_prev_aligement<4, 2, 16>;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("Something wrong with upsampling function setting\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
}
|
||||
else if ( curr_tile_size / prev_tile_size == 1 )
|
||||
{
|
||||
if ( curr_tile_size == 8 )
|
||||
{
|
||||
upsample_alignment_func_ptr = &build_upsampled_prev_aligement<4, 1, 8>;
|
||||
}
|
||||
else if ( curr_tile_size == 16 )
|
||||
{
|
||||
upsample_alignment_func_ptr = &build_upsampled_prev_aligement<4, 1, 16>;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("Something wrong with upsampling function setting\n");
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("Something wrong with upsampling function setting\n");
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Function to extract reference image tile for memory cache
|
||||
cv::Mat (*extract_ref_img_tile)(const cv::Mat&, int, int) = nullptr;
|
||||
if ( curr_tile_size == 8 )
|
||||
{
|
||||
extract_ref_img_tile = &extract_img_tile<uint16_t, 8>;
|
||||
}
|
||||
else if ( curr_tile_size == 16 )
|
||||
{
|
||||
extract_ref_img_tile = &extract_img_tile<uint16_t, 16>;
|
||||
}
|
||||
|
||||
// Function to extract search image tile for memory cache
|
||||
cv::Mat (*extract_alt_img_search)(const cv::Mat&, int, int) = nullptr;
|
||||
if ( curr_tile_size == 8 )
|
||||
{
|
||||
if ( search_radiou == 1 )
|
||||
{
|
||||
extract_alt_img_search = &extract_img_tile<uint16_t, 8+1*2>;
|
||||
}
|
||||
else if ( search_radiou == 4 )
|
||||
{
|
||||
extract_alt_img_search = &extract_img_tile<uint16_t, 8+4*2>;
|
||||
}
|
||||
}
|
||||
else if ( curr_tile_size == 16 )
|
||||
{
|
||||
if ( search_radiou == 1 )
|
||||
{
|
||||
extract_alt_img_search = &extract_img_tile<uint16_t, 16+1*2>;
|
||||
}
|
||||
else if ( search_radiou == 4 )
|
||||
{
|
||||
extract_alt_img_search = &extract_img_tile<uint16_t, 16+4*2>;
|
||||
}
|
||||
}
|
||||
|
||||
int num_tiles_h = ref_img.size().height / (curr_tile_size / 2) - 1;
|
||||
int num_tiles_w = ref_img.size().width / (curr_tile_size / 2 ) - 1;
|
||||
|
||||
/* Upsample pervious layer alignment */
|
||||
std::vector<std::vector<std::pair<int, int>>> upsampled_prev_aligement;
|
||||
|
||||
// Coarsest level
|
||||
// prev_alignment is invalid / empty, construct alignment as (0,0)
|
||||
if ( prev_tile_size == -1 )
|
||||
{
|
||||
upsampled_prev_aligement.resize( num_tiles_h, \
|
||||
std::vector<std::pair<int, int>>( num_tiles_w, std::pair<int, int>(0, 0) ) );
|
||||
}
|
||||
// Upsample previous level alignment
|
||||
else
|
||||
{
|
||||
upsample_alignment_func_ptr( prev_aligement, upsampled_prev_aligement, \
|
||||
num_tiles_h, num_tiles_w, ref_img, alt_img, false );
|
||||
|
||||
// printf("\n!!!!!Upsampled previous alignment\n");
|
||||
// for ( int tile_row = 0; tile_row < int(upsampled_prev_aligement.size()); tile_row++ )
|
||||
// {
|
||||
// for ( int tile_col = 0; tile_col < int(upsampled_prev_aligement.at(0).size()); tile_col++ )
|
||||
// {
|
||||
// const auto tile_start = upsampled_prev_aligement.at( tile_row ).at( tile_col );
|
||||
// printf("up tile (%d, %d) -> start idx (%d, %d)\n", \
|
||||
// tile_row, tile_col, tile_start.first, tile_start.second);
|
||||
// }
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
printf("%s::%s start: \n", __FILE__, __func__ );
|
||||
printf(" scale_factor_prev_curr %d, tile_size %d, prev_tile_size %d, search_radiou %d, distance L%d, \n", \
|
||||
scale_factor_prev_curr, curr_tile_size, prev_tile_size, search_radiou, distance_type );
|
||||
printf(" ref img size h=%d w=%d, alt img size h=%d w=%d, \n", \
|
||||
ref_img.size().height, ref_img.size().width, alt_img.size().height, alt_img.size().width );
|
||||
printf(" num tile h (upsampled) %d, num tile w (upsampled) %d\n", num_tiles_h, num_tiles_w);
|
||||
#endif
|
||||
|
||||
// allocate memory for current alignmenr
|
||||
curr_alignment.resize( num_tiles_h, std::vector<std::pair<int, int>>( num_tiles_w, std::pair<int, int>(0, 0) ) );
|
||||
|
||||
/* Pad alternative image */
|
||||
cv::Mat alt_img_pad;
|
||||
cv::copyMakeBorder( alt_img, \
|
||||
alt_img_pad, \
|
||||
search_radiou, search_radiou, search_radiou, search_radiou, \
|
||||
cv::BORDER_CONSTANT, cv::Scalar( UINT_LEAST16_MAX ) );
|
||||
|
||||
// printf("Reference image h=%d, w=%d: \n", ref_img.size().height, ref_img.size().width );
|
||||
// print_img<uint16_t>( ref_img );
|
||||
|
||||
// printf("Alter image pad h=%d, w=%d: \n", alt_img_pad.size().height, alt_img_pad.size().width );
|
||||
// print_img<uint16_t>( alt_img_pad );
|
||||
|
||||
// printf("!! enlarged tile size %d\n", curr_tile_size + 2 * search_radiou );
|
||||
|
||||
int alt_tile_row_idx_max = alt_img_pad.size().height - ( curr_tile_size + 2 * search_radiou );
|
||||
int alt_tile_col_idx_max = alt_img_pad.size().width - ( curr_tile_size + 2 * search_radiou );
|
||||
|
||||
// Dlete below distance vector, this is for debug only
|
||||
std::vector<std::vector<uint16_t>> distances( num_tiles_h, std::vector<uint16_t>( num_tiles_w, 0 ));
|
||||
|
||||
/* Iterate through all reference tile & compute distance */
|
||||
#pragma omp parallel for collapse(2)
|
||||
for ( int ref_tile_row_i = 0; ref_tile_row_i < num_tiles_h; ref_tile_row_i++ )
|
||||
{
|
||||
for ( int ref_tile_col_i = 0; ref_tile_col_i < num_tiles_w; ref_tile_col_i++ )
|
||||
{
|
||||
// Upper left index of reference tile
|
||||
int ref_tile_row_start_idx_i = ref_tile_row_i * curr_tile_size / 2;
|
||||
int ref_tile_col_start_idx_i = ref_tile_col_i * curr_tile_size / 2;
|
||||
|
||||
// printf("\nRef img tile [%d, %d] -> start idx [%d, %d] (row, col)\n", \
|
||||
// ref_tile_row_i, ref_tile_col_i, ref_tile_row_start_idx_i, ref_tile_col_start_idx_i );
|
||||
// printf("\nRef img tile [%d, %d]\n", ref_tile_row_i, ref_tile_col_i );
|
||||
// print_tile<uint16_t>( ref_img, curr_tile_size, ref_tile_row_start_idx_i, ref_tile_col_start_idx_i );
|
||||
|
||||
// Upsampled alignment at this tile
|
||||
// Alignment are relative displacement in pixel value
|
||||
int prev_alignment_row_i = upsampled_prev_aligement.at( ref_tile_row_i ).at( ref_tile_col_i ).first;
|
||||
int prev_alignment_col_i = upsampled_prev_aligement.at( ref_tile_row_i ).at( ref_tile_col_i ).second;
|
||||
|
||||
// Alternative image tile start idx
|
||||
int alt_tile_row_start_idx_i = ref_tile_row_start_idx_i + prev_alignment_row_i;
|
||||
int alt_tile_col_start_idx_i = ref_tile_col_start_idx_i + prev_alignment_col_i;
|
||||
|
||||
// Ensure alternative image tile within range
|
||||
if ( alt_tile_row_start_idx_i < 0 )
|
||||
alt_tile_row_start_idx_i = 0;
|
||||
if ( alt_tile_col_start_idx_i < 0 )
|
||||
alt_tile_col_start_idx_i = 0;
|
||||
if ( alt_tile_row_start_idx_i > alt_tile_row_idx_max )
|
||||
{
|
||||
// int before = alt_tile_row_start_idx_i;
|
||||
alt_tile_row_start_idx_i = alt_tile_row_idx_max;
|
||||
// printf("@@ change start x from %d to %d\n", before, alt_tile_row_idx_max);
|
||||
}
|
||||
if ( alt_tile_col_start_idx_i > alt_tile_col_idx_max )
|
||||
{
|
||||
// int before = alt_tile_col_start_idx_i;
|
||||
alt_tile_col_start_idx_i = alt_tile_col_idx_max;
|
||||
// printf("@@ change start y from %d to %d\n", before, alt_tile_col_idx_max );
|
||||
}
|
||||
|
||||
// Explicitly caching reference image tile
|
||||
cv::Mat ref_img_tile_i = extract_ref_img_tile( ref_img, ref_tile_row_start_idx_i, ref_tile_col_start_idx_i );
|
||||
cv::Mat alt_img_search_i = extract_alt_img_search( alt_img_pad, alt_tile_row_start_idx_i, alt_tile_col_start_idx_i );
|
||||
|
||||
// Because alternative image is padded with search radious.
|
||||
// Using same coordinate with reference image will automatically considered search radious * 2
|
||||
// printf("Alt image tile [%d, %d]-> start idx [%d, %d]\n", \
|
||||
// ref_tile_row_i, ref_tile_col_i, alt_tile_row_start_idx_i, alt_tile_col_start_idx_i );
|
||||
// printf("\nAlt image tile [%d, %d]\n", ref_tile_row_i, ref_tile_col_i );
|
||||
// print_tile<uint16_t>( alt_img_pad, curr_tile_size + 2 * search_radiou, alt_tile_row_start_idx_i, alt_tile_col_start_idx_i );
|
||||
|
||||
// Search based on L1/L2 distance
|
||||
unsigned long long min_distance_i = ULONG_LONG_MAX;
|
||||
int min_distance_row_i = -1;
|
||||
int min_distance_col_i = -1;
|
||||
for ( int search_row_j = 0; search_row_j < ( search_radiou * 2 + 1 ); search_row_j++ )
|
||||
{
|
||||
for ( int search_col_j = 0; search_col_j < ( search_radiou * 2 + 1 ); search_col_j++ )
|
||||
{
|
||||
// printf("\n--->tile at [%d, %d] search (%d, %d)\n", \
|
||||
// ref_tile_row_i, ref_tile_col_i, search_row_j - search_radiou, search_col_j - search_radiou );
|
||||
|
||||
// unsigned long long distance_j = distance_func_ptr( ref_img, alt_img_pad, \
|
||||
// ref_tile_row_start_idx_i, ref_tile_col_start_idx_i, \
|
||||
// alt_tile_row_start_idx_i + search_row_j, alt_tile_col_start_idx_i + search_col_j );
|
||||
|
||||
// unsigned long long distance_j = distance_func_ptr( ref_img_tile_i, alt_img_pad, \
|
||||
// 0, 0, \
|
||||
// alt_tile_row_start_idx_i + search_row_j, alt_tile_col_start_idx_i + search_col_j );
|
||||
|
||||
unsigned long long distance_j = distance_func_ptr( ref_img_tile_i, alt_img_search_i, \
|
||||
0, 0, \
|
||||
search_row_j, search_col_j );
|
||||
|
||||
// printf("<---tile at [%d, %d] search (%d, %d), new dis %llu, old dis %llu\n", \
|
||||
// ref_tile_row_i, ref_tile_col_i, search_row_j - search_radiou, search_col_j - search_radiou, distance_j, min_distance_i );
|
||||
|
||||
// If this is smaller distance
|
||||
if ( distance_j < min_distance_i )
|
||||
{
|
||||
min_distance_i = distance_j;
|
||||
min_distance_col_i = search_col_j;
|
||||
min_distance_row_i = search_row_j;
|
||||
}
|
||||
|
||||
// If same value, choose the one closer to the original tile location
|
||||
if ( distance_j == min_distance_i && min_distance_row_i != -1 && min_distance_col_i != -1 )
|
||||
{
|
||||
int prev_distance_row_2_ref = min_distance_row_i - search_radiou;
|
||||
int prev_distance_col_2_ref = min_distance_col_i - search_radiou;
|
||||
int curr_distance_row_2_ref = search_row_j - search_radiou;
|
||||
int curr_distance_col_2_ref = search_col_j - search_radiou;
|
||||
|
||||
int prev_distance_2_ref_sqr = prev_distance_row_2_ref * prev_distance_row_2_ref + prev_distance_col_2_ref * prev_distance_col_2_ref;
|
||||
int curr_distance_2_ref_sqr = curr_distance_row_2_ref * curr_distance_row_2_ref + curr_distance_col_2_ref * curr_distance_col_2_ref;
|
||||
|
||||
// previous min distance idx is farther away from ref tile start location
|
||||
if ( prev_distance_2_ref_sqr > curr_distance_2_ref_sqr )
|
||||
{
|
||||
// printf("@@@ Same distance %d, choose closer one (%d, %d) instead of (%d, %d)\n", \
|
||||
// distance_j, search_row_j, search_col_j, min_distance_row_i, min_distance_col_i);
|
||||
min_distance_col_i = search_col_j;
|
||||
min_distance_row_i = search_row_j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// printf("tile at (%d, %d) alignment (%d, %d)\n", \
|
||||
// ref_tile_row_i, ref_tile_col_i, min_distance_row_i, min_distance_col_i );
|
||||
|
||||
int alignment_row_i = prev_alignment_row_i + min_distance_row_i - search_radiou;
|
||||
int alignment_col_i = prev_alignment_col_i + min_distance_col_i - search_radiou;
|
||||
|
||||
std::pair<int, int> alignment_i( alignment_row_i, alignment_col_i );
|
||||
|
||||
// Add min_distance_i's corresbonding idx as min
|
||||
curr_alignment.at( ref_tile_row_i ).at( ref_tile_col_i ) = alignment_i;
|
||||
distances.at( ref_tile_row_i ).at( ref_tile_col_i ) = min_distance_i;
|
||||
}
|
||||
}
|
||||
|
||||
// printf("\n!!!!!Min distance for each tile \n");
|
||||
// for ( int tile_row = 0; tile_row < num_tiles_h; tile_row++ )
|
||||
// {
|
||||
// for ( int tile_col = 0; tile_col < num_tiles_w; ++tile_col )
|
||||
// {
|
||||
// printf("tile (%d, %d) distance %u\n", \
|
||||
// tile_row, tile_col, distances.at( tile_row).at(tile_col ) );
|
||||
// }
|
||||
// }
|
||||
|
||||
// printf("\n!!!!!Alignment at current level\n");
|
||||
// for ( int tile_row = 0; tile_row < num_tiles_h; tile_row++ )
|
||||
// {
|
||||
// for ( int tile_col = 0; tile_col < num_tiles_w; tile_col++ )
|
||||
// {
|
||||
// const auto tile_start = curr_alignment.at( tile_row ).at( tile_col );
|
||||
// printf("tile (%d, %d) -> start idx (%d, %d)\n", \
|
||||
// tile_row, tile_col, tile_start.first, tile_start.second);
|
||||
// }
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
void align::process( const hdrplus::burst& burst_images, \
|
||||
std::vector<std::vector<std::vector<std::pair<int, int>>>>& images_alignment )
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
printf("%s::%s align::process start\n", __FILE__, __func__ ); fflush(stdout);
|
||||
#endif
|
||||
|
||||
images_alignment.clear();
|
||||
images_alignment.resize( burst_images.num_images );
|
||||
|
||||
// image pyramid per image, per pyramid level
|
||||
std::vector<std::vector<cv::Mat>> per_grayimg_pyramid;
|
||||
|
||||
// printf("!!!!! ref bayer padded\n");
|
||||
// print_img<uint16_t>( burst_images.bayer_images_pad.at( burst_images.reference_image_idx) );
|
||||
// exit(1);
|
||||
|
||||
// printf("!!!!! ref gray padded\n");
|
||||
// print_img<uint16_t>( burst_images.grayscale_images_pad.at( burst_images.reference_image_idx) );
|
||||
// exit(1);
|
||||
|
||||
per_grayimg_pyramid.resize( burst_images.num_images );
|
||||
|
||||
#pragma omp parallel for
|
||||
for ( int img_idx = 0; img_idx < burst_images.num_images; ++img_idx )
|
||||
{
|
||||
// per_grayimg_pyramid[ img_idx ][ 0 ] is the original image
|
||||
// per_grayimg_pyramid[ img_idx ][ 3 ] is the coarsest image
|
||||
build_per_grayimg_pyramid( per_grayimg_pyramid.at( img_idx ), \
|
||||
burst_images.grayscale_images_pad.at( img_idx ), \
|
||||
this->inv_scale_factors );
|
||||
}
|
||||
|
||||
// #ifndef NDEBUG
|
||||
// printf("%s::%s build image pyramid of size : ", __FILE__, __func__ );
|
||||
// for ( int level_i = 0; level_i < num_levels; ++level_i )
|
||||
// {
|
||||
// printf("(%d, %d) ", per_grayimg_pyramid[ 0 ][ level_i ].size().height,
|
||||
// per_grayimg_pyramid[ 0 ][ level_i ].size().width );
|
||||
// }
|
||||
// printf("\n"); fflush(stdout);
|
||||
// #endif
|
||||
|
||||
// print image pyramid
|
||||
// for ( int level_i; level_i < num_levels; ++level_i )
|
||||
// {
|
||||
// printf("\n\n!!!!! ref gray pyramid level %d img : \n" , level_i );
|
||||
// print_img<uint16_t>( per_grayimg_pyramid[ burst_images.reference_image_idx ][ level_i ] );
|
||||
// }
|
||||
// exit(-1);
|
||||
|
||||
// Align every image
|
||||
const std::vector<cv::Mat>& ref_grayimg_pyramid = per_grayimg_pyramid[ burst_images.reference_image_idx ];
|
||||
for ( int img_idx = 0; img_idx < burst_images.num_images; ++img_idx )
|
||||
{
|
||||
// Do not align with reference image
|
||||
if ( img_idx == burst_images.reference_image_idx )
|
||||
continue;
|
||||
|
||||
const std::vector<cv::Mat>& alt_grayimg_pyramid = per_grayimg_pyramid[ img_idx ];
|
||||
|
||||
// Align every level from coarse to grain
|
||||
// level 0 : finest level, the original image
|
||||
// level 3 : coarsest level
|
||||
std::vector<std::vector<std::pair<int, int>>> curr_alignment;
|
||||
std::vector<std::vector<std::pair<int, int>>> prev_alignment;
|
||||
for ( int level_i = num_levels - 1; level_i >= 0; level_i-- ) // 3,2,1,0
|
||||
{
|
||||
// make curr alignment as previous alignment
|
||||
prev_alignment.swap( curr_alignment );
|
||||
curr_alignment.clear();
|
||||
|
||||
// printf("\n\n########################align level %d\n", level_i );
|
||||
align_image_level(
|
||||
ref_grayimg_pyramid[ level_i ], // reference image at current level
|
||||
alt_grayimg_pyramid[ level_i ], // alternative image at current level
|
||||
prev_alignment, // previous layer alignment
|
||||
curr_alignment, // current layer alignment
|
||||
( level_i == ( num_levels - 1 ) ? -1 : inv_scale_factors[ level_i + 1 ] ), // scale factor between previous layer and current layer. -1 if current layer is the coarsest layer, [-1, 4, 4, 2]
|
||||
grayimg_tile_sizes[ level_i ], // current level tile size
|
||||
( level_i == ( num_levels - 1 ) ? -1 : grayimg_tile_sizes[ level_i + 1 ] ), // previous level tile size
|
||||
grayimg_search_radious[ level_i ], // search radious
|
||||
distances[ level_i ] ); // L1/L2 distance
|
||||
|
||||
// printf("@@@Alignment at level %d is h=%d, w=%d", level_i, curr_alignment.size(), curr_alignment.at(0).size() );
|
||||
|
||||
|
||||
} // for pyramid level
|
||||
|
||||
// Alignment at grayscale image
|
||||
images_alignment.at( img_idx ).swap( curr_alignment );
|
||||
|
||||
// printf("\n!!!!!Alternative Image Alignment\n");
|
||||
// for ( int tile_row = 0; tile_row < images_alignment.at( img_idx ).size(); tile_row++ )
|
||||
// {
|
||||
// for ( int tile_col = 0; tile_col < images_alignment.at( img_idx ).at(0).size(); tile_col++ )
|
||||
// {
|
||||
// const auto tile_start = images_alignment.at( img_idx ).at( tile_row ).at( tile_col );
|
||||
// printf("tile (%d, %d) -> start idx (%d, %d)\n", \
|
||||
// tile_row, tile_col, tile_start.first, tile_start.second);
|
||||
// }
|
||||
// }
|
||||
|
||||
} // for alternative image
|
||||
|
||||
}
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,102 @@
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <utility> // std::pair, std::makr_pair
|
||||
#include <memory> // std::shared_ptr
|
||||
#include <stdexcept> // std::runtime_error
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <libraw/libraw.h>
|
||||
#include <exiv2/exiv2.hpp> // exiv2
|
||||
#include "hdrplus/bayer_image.h"
|
||||
#include "hdrplus/utility.h" // box_filter_kxk
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
bayer_image::bayer_image( const std::string& bayer_image_path )
|
||||
{
|
||||
libraw_processor = std::make_shared<LibRaw>();
|
||||
|
||||
// Open RAW image file
|
||||
int return_code;
|
||||
if ( ( return_code = libraw_processor->open_file( bayer_image_path.c_str() ) ) != LIBRAW_SUCCESS )
|
||||
{
|
||||
libraw_processor->recycle();
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("Error opening file " + bayer_image_path + " " + libraw_strerror( return_code ));
|
||||
#endif
|
||||
}
|
||||
|
||||
// Unpack the raw image
|
||||
if ( ( return_code = libraw_processor->unpack() ) != LIBRAW_SUCCESS )
|
||||
{
|
||||
#ifdef __ANDROID__
|
||||
return;
|
||||
#else
|
||||
throw std::runtime_error("Error unpack file " + bayer_image_path + " " + libraw_strerror( return_code ));
|
||||
#endif
|
||||
}
|
||||
|
||||
// Get image basic info
|
||||
width = int( libraw_processor->imgdata.rawdata.sizes.raw_width );
|
||||
height = int( libraw_processor->imgdata.rawdata.sizes.raw_height );
|
||||
|
||||
// Read exif tags
|
||||
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(bayer_image_path);
|
||||
assert(image.get() != 0);
|
||||
image->readMetadata();
|
||||
Exiv2::ExifData &exifData = image->exifData();
|
||||
if (exifData.empty()) {
|
||||
std::string error(bayer_image_path);
|
||||
error += ": No Exif data found in the file";
|
||||
std::cout << error << std::endl;
|
||||
}
|
||||
|
||||
white_level = exifData["Exif.Image.WhiteLevel"].toLong();
|
||||
black_level_per_channel.resize( 4 );
|
||||
black_level_per_channel.at(0) = exifData["Exif.Image.BlackLevel"].toLong(0);
|
||||
black_level_per_channel.at(1) = exifData["Exif.Image.BlackLevel"].toLong(1);
|
||||
black_level_per_channel.at(2) = exifData["Exif.Image.BlackLevel"].toLong(2);
|
||||
black_level_per_channel.at(3) = exifData["Exif.Image.BlackLevel"].toLong(3);
|
||||
iso = exifData["Exif.Image.ISOSpeedRatings"].toLong();
|
||||
|
||||
// Create CV mat
|
||||
// https://answers.opencv.org/question/105972/de-bayering-a-cr2-image/
|
||||
// https://www.libraw.org/node/2141
|
||||
raw_image = cv::Mat( height, width, CV_16U, libraw_processor->imgdata.rawdata.raw_image ).clone(); // changed the order of width and height
|
||||
|
||||
// 2x2 box filter
|
||||
grayscale_image = box_filter_kxk<uint16_t, 2>( raw_image );
|
||||
|
||||
#ifndef NDEBUG
|
||||
printf("%s::%s read bayer image %s with\n width %zu\n height %zu\n iso %.3f\n white level %d\n black level %d %d %d %d\n", \
|
||||
__FILE__, __func__, bayer_image_path.c_str(), width, height, iso, white_level, \
|
||||
black_level_per_channel[0], black_level_per_channel[1], black_level_per_channel[2], black_level_per_channel[3] );
|
||||
fflush( stdout );
|
||||
#endif
|
||||
}
|
||||
|
||||
std::pair<double, double> bayer_image::get_noise_params() const
|
||||
{
|
||||
// Set ISO to 100 if not positive
|
||||
double iso_ = iso <= 0 ? 100 : iso;
|
||||
|
||||
// Calculate shot noise and read noise parameters w.r.t ISO 100
|
||||
double lambda_shot_p = iso_ / 100.0f * baseline_lambda_shot;
|
||||
double lambda_read_p = (iso_ / 100.0f) * (iso_ / 100.0f) * baseline_lambda_read;
|
||||
|
||||
double black_level = (black_level_per_channel[0] + \
|
||||
black_level_per_channel[1] + \
|
||||
black_level_per_channel[2] + \
|
||||
black_level_per_channel[3]) / 4.0;
|
||||
|
||||
// Rescale shot and read noise to normal range
|
||||
double lambda_shot = lambda_shot_p * (white_level - black_level);
|
||||
double lambda_read = lambda_read_p * (white_level - black_level) * (white_level - black_level);
|
||||
|
||||
// return pair
|
||||
return std::make_pair(lambda_shot, lambda_read);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,181 @@
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <omp.h>
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include "hdrplus/burst.h"
|
||||
#include "hdrplus/utility.h"
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
burst::burst( const std::string& burst_path, const std::string& reference_image_path )
|
||||
{
|
||||
std::vector<cv::String> bayer_image_paths;
|
||||
// Search through the input path directory to get all input image path
|
||||
if ( burst_path.at( burst_path.size() - 1) == '/')
|
||||
cv::glob( burst_path + "*.dng", bayer_image_paths, false );
|
||||
else
|
||||
cv::glob( burst_path + "/*.dng", bayer_image_paths, false );
|
||||
|
||||
#ifndef NDEBUG
|
||||
for ( const auto& bayer_img_path_i : bayer_image_paths )
|
||||
{
|
||||
printf("img i path %s\n", bayer_img_path_i.c_str()); fflush(stdout);
|
||||
}
|
||||
printf("ref img path %s\n", reference_image_path.c_str()); fflush(stdout);
|
||||
#endif
|
||||
|
||||
// Number of images
|
||||
num_images = bayer_image_paths.size();
|
||||
|
||||
// Find reference image path in input directory
|
||||
// reference image path need to be absolute path
|
||||
reference_image_idx = -1;
|
||||
for ( size_t i = 0; i < bayer_image_paths.size(); ++i )
|
||||
{
|
||||
if ( bayer_image_paths[ i ] == reference_image_path )
|
||||
{
|
||||
reference_image_idx = i;
|
||||
}
|
||||
}
|
||||
|
||||
if ( reference_image_idx == -1 )
|
||||
{
|
||||
return;
|
||||
// throw std::runtime_error("Error unable to locate reference image " + reference_image_path );
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
for ( const auto& bayer_image_path_i : bayer_image_paths )
|
||||
{
|
||||
printf("%s::%s Find image %s\n", \
|
||||
__FILE__, __func__, bayer_image_path_i.c_str());
|
||||
}
|
||||
|
||||
printf("%s::%s reference image idx %d\n", \
|
||||
__FILE__, __func__, reference_image_idx );
|
||||
#endif
|
||||
|
||||
// Get source bayer image
|
||||
// Downsample original bayer image by 2x2 box filter
|
||||
for ( const auto& bayer_image_path_i : bayer_image_paths )
|
||||
{
|
||||
bayer_images.emplace_back( bayer_image_path_i );
|
||||
}
|
||||
|
||||
// Pad information
|
||||
int tile_size_bayer = 32;
|
||||
int padding_top = tile_size_bayer / 2;
|
||||
int padding_bottom = tile_size_bayer / 2 + \
|
||||
( (bayer_images[ 0 ].height % tile_size_bayer) == 0 ? \
|
||||
0 : tile_size_bayer - bayer_images[ 0 ].height % tile_size_bayer );
|
||||
int padding_left = tile_size_bayer / 2;
|
||||
int padding_right = tile_size_bayer / 2 + \
|
||||
( (bayer_images[ 0 ].width % tile_size_bayer) == 0 ? \
|
||||
0 : tile_size_bayer - bayer_images[ 0 ].width % tile_size_bayer );
|
||||
padding_info_bayer = std::vector<int>{ padding_top, padding_bottom, padding_left, padding_right };
|
||||
|
||||
// Pad bayer image
|
||||
for ( const auto& bayer_image_i : bayer_images )
|
||||
{
|
||||
cv::Mat bayer_image_pad_i;
|
||||
cv::copyMakeBorder( bayer_image_i.raw_image, \
|
||||
bayer_image_pad_i, \
|
||||
padding_top, padding_bottom, padding_left, padding_right, \
|
||||
cv::BORDER_REFLECT );
|
||||
|
||||
// cv::Mat use internal reference count
|
||||
bayer_images_pad.emplace_back( bayer_image_pad_i );
|
||||
grayscale_images_pad.emplace_back( box_filter_kxk<uint16_t, 2>( bayer_image_pad_i ) );
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
printf("%s::%s Pad bayer image from (%d, %d) -> (%d, %d)\n", \
|
||||
__FILE__, __func__, \
|
||||
bayer_images[ 0 ].height, \
|
||||
bayer_images[ 0 ].width, \
|
||||
bayer_images_pad[ 0 ].size().height, \
|
||||
bayer_images_pad[ 0 ].size().width );
|
||||
printf("%s::%s pad top %d, buttom %d, left %d, right %d\n", \
|
||||
__FILE__, __func__, \
|
||||
padding_top, padding_bottom, padding_left, padding_right );
|
||||
#endif
|
||||
}
|
||||
|
||||
burst::burst( const std::vector<std::string>& bayer_image_paths, int reference_image_index )
|
||||
{
|
||||
// Number of images
|
||||
num_images = bayer_image_paths.size();
|
||||
|
||||
// Find reference image path in input directory
|
||||
// reference image path need to be absolute path
|
||||
reference_image_idx = -1;
|
||||
if ( reference_image_index >= 0 && reference_image_index < bayer_image_paths.size() )
|
||||
{
|
||||
reference_image_idx = reference_image_index;
|
||||
}
|
||||
|
||||
if ( reference_image_idx == -1 )
|
||||
{
|
||||
return;
|
||||
// throw std::runtime_error("Error reference image index is out of range " );
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
for ( const auto& bayer_image_path_i : bayer_image_paths )
|
||||
{
|
||||
printf("%s::%s Find image %s\n", \
|
||||
__FILE__, __func__, bayer_image_path_i.c_str());
|
||||
}
|
||||
|
||||
printf("%s::%s reference image idx %d\n", \
|
||||
__FILE__, __func__, reference_image_idx );
|
||||
#endif
|
||||
|
||||
// Get source bayer image
|
||||
// Downsample original bayer image by 2x2 box filter
|
||||
for ( const auto& bayer_image_path_i : bayer_image_paths )
|
||||
{
|
||||
bayer_images.emplace_back( bayer_image_path_i );
|
||||
}
|
||||
|
||||
// Pad information
|
||||
int tile_size_bayer = 32;
|
||||
int padding_top = tile_size_bayer / 2;
|
||||
int padding_bottom = tile_size_bayer / 2 + \
|
||||
( (bayer_images[ 0 ].height % tile_size_bayer) == 0 ? \
|
||||
0 : tile_size_bayer - bayer_images[ 0 ].height % tile_size_bayer );
|
||||
int padding_left = tile_size_bayer / 2;
|
||||
int padding_right = tile_size_bayer / 2 + \
|
||||
( (bayer_images[ 0 ].width % tile_size_bayer) == 0 ? \
|
||||
0 : tile_size_bayer - bayer_images[ 0 ].width % tile_size_bayer );
|
||||
padding_info_bayer = std::vector<int>{ padding_top, padding_bottom, padding_left, padding_right };
|
||||
|
||||
// Pad bayer image
|
||||
for ( const auto& bayer_image_i : bayer_images )
|
||||
{
|
||||
cv::Mat bayer_image_pad_i;
|
||||
cv::copyMakeBorder( bayer_image_i.raw_image, \
|
||||
bayer_image_pad_i, \
|
||||
padding_top, padding_bottom, padding_left, padding_right, \
|
||||
cv::BORDER_REFLECT );
|
||||
|
||||
// cv::Mat use internal reference count
|
||||
bayer_images_pad.emplace_back( bayer_image_pad_i );
|
||||
grayscale_images_pad.emplace_back( box_filter_kxk<uint16_t, 2>( bayer_image_pad_i ) );
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
printf("%s::%s Pad bayer image from (%d, %d) -> (%d, %d)\n", \
|
||||
__FILE__, __func__, \
|
||||
bayer_images[ 0 ].height, \
|
||||
bayer_images[ 0 ].width, \
|
||||
bayer_images_pad[ 0 ].size().height, \
|
||||
bayer_images_pad[ 0 ].size().width );
|
||||
printf("%s::%s pad top %d, buttom %d, left %d, right %d\n", \
|
||||
__FILE__, __func__, \
|
||||
padding_top, padding_bottom, padding_left, padding_right );
|
||||
#endif
|
||||
}
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,784 @@
|
||||
#include <iostream>
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include "hdrplus/finish.h"
|
||||
#include "hdrplus/utility.h"
|
||||
#include <cmath>
|
||||
|
||||
#ifdef __ANDROID__
|
||||
#define DBG_OUTPUT_ROOT "/sdcard/com.xypower.mpapp/tmp/"
|
||||
#else
|
||||
#define DBG_OUTPUT_ROOT ""
|
||||
#endif
|
||||
// #include <type_traits>
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
|
||||
cv::Mat convert16bit2_8bit_(cv::Mat ans){
|
||||
if(ans.type()==CV_16UC3){
|
||||
cv::MatIterator_<cv::Vec3w> it, end;
|
||||
for( it = ans.begin<cv::Vec3w>(), end = ans.end<cv::Vec3w>(); it != end; ++it)
|
||||
{
|
||||
// std::cout<<sizeof (*it)[0] <<std::endl;
|
||||
(*it)[0] *=(255.0/USHRT_MAX);
|
||||
(*it)[1] *=(255.0/USHRT_MAX);
|
||||
(*it)[2] *=(255.0/USHRT_MAX);
|
||||
}
|
||||
ans.convertTo(ans, CV_8UC3);
|
||||
}else if(ans.type()==CV_16UC1){
|
||||
u_int16_t* ptr = (u_int16_t*)ans.data;
|
||||
int end = ans.rows*ans.cols;
|
||||
for(int i=0;i<end;i++){
|
||||
*(ptr+i) *=(255.0/USHRT_MAX);
|
||||
}
|
||||
ans.convertTo(ans, CV_8UC1);
|
||||
}else{
|
||||
std::cout<<"Unsupported Data Type"<<std::endl;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
cv::Mat convert8bit2_16bit_(cv::Mat ans){
|
||||
if(ans.type()==CV_8UC3){
|
||||
ans.convertTo(ans, CV_16UC3);
|
||||
cv::MatIterator_<cv::Vec3w> it, end;
|
||||
for( it = ans.begin<cv::Vec3w>(), end = ans.end<cv::Vec3w>(); it != end; ++it)
|
||||
{
|
||||
// std::cout<<sizeof (*it)[0] <<std::endl;
|
||||
(*it)[0] *=(65535.0/255.0);
|
||||
(*it)[1] *=(65535.0/255.0);
|
||||
(*it)[2] *=(65535.0/255.0);
|
||||
}
|
||||
|
||||
}else if(ans.type()==CV_8UC1){
|
||||
ans.convertTo(ans, CV_16UC1);
|
||||
u_int16_t* ptr = (u_int16_t*)ans.data;
|
||||
int end = ans.rows*ans.cols;
|
||||
for(int i=0;i<end;i++){
|
||||
*(ptr+i) *=(65535.0/255.0);
|
||||
}
|
||||
|
||||
}else{
|
||||
std::cout<<"Unsupported Data Type"<<std::endl;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
cv::Mat convert8bit2_12bit_(cv::Mat ans){
|
||||
// cv::Mat ans(I);
|
||||
cv::MatIterator_<cv::Vec3w> it, end;
|
||||
for( it = ans.begin<cv::Vec3w>(), end = ans.end<cv::Vec3w>(); it != end; ++it)
|
||||
{
|
||||
// std::cout<<sizeof (*it)[0] <<std::endl;
|
||||
(*it)[0] *=(2048.0/255.0);
|
||||
(*it)[1] *=(2048.0/255.0);
|
||||
(*it)[2] *=(2048.0/255.0);
|
||||
}
|
||||
ans.convertTo(ans, CV_16UC3);
|
||||
return ans;
|
||||
}
|
||||
|
||||
uint16_t uGammaCompress_1pix(float x, float threshold,float gainMin,float gainMax,float exponent){
|
||||
// Normalize pixel val
|
||||
x/=USHRT_MAX;
|
||||
// check the val against the threshold
|
||||
if(x<=threshold){
|
||||
x =gainMin*x;
|
||||
}else{
|
||||
x = gainMax* pow(x,exponent)-gainMax+1;
|
||||
}
|
||||
// clip
|
||||
if(x<0){
|
||||
x=0;
|
||||
}else{
|
||||
if(x>1){
|
||||
x = 1;
|
||||
}
|
||||
}
|
||||
|
||||
x*=USHRT_MAX;
|
||||
|
||||
return (uint16_t)x;
|
||||
}
|
||||
|
||||
uint16_t uGammaDecompress_1pix(float x, float threshold,float gainMin,float gainMax,float exponent){
|
||||
// Normalize pixel val
|
||||
x/=65535.0;
|
||||
// check the val against the threshold
|
||||
if(x<=threshold){
|
||||
x = x/gainMin;
|
||||
}else{
|
||||
x = pow((x+gainMax-1)/gainMax,exponent);
|
||||
}
|
||||
// clip
|
||||
if(x<0){
|
||||
x=0;
|
||||
}else{
|
||||
if(x>1){
|
||||
x = 1;
|
||||
}
|
||||
}
|
||||
x*=65535;
|
||||
|
||||
return (uint16_t)x;
|
||||
}
|
||||
|
||||
cv::Mat uGammaCompress_(cv::Mat m,float threshold,float gainMin,float gainMax,float exponent){
|
||||
if(m.type()==CV_16UC3){
|
||||
cv::MatIterator_<cv::Vec3w> it, end;
|
||||
for( it = m.begin<cv::Vec3w>(), end = m.end<cv::Vec3w>(); it != end; ++it)
|
||||
{
|
||||
(*it)[0] =uGammaCompress_1pix((*it)[0],threshold,gainMin,gainMax,exponent);
|
||||
(*it)[1] =uGammaCompress_1pix((*it)[1],threshold,gainMin,gainMax,exponent);
|
||||
(*it)[2] =uGammaCompress_1pix((*it)[2],threshold,gainMin,gainMax,exponent);
|
||||
}
|
||||
}else if(m.type()==CV_16UC1){
|
||||
u_int16_t* ptr = (u_int16_t*)m.data;
|
||||
int end = m.rows*m.cols;
|
||||
for(int i=0;i<end;i++){
|
||||
*(ptr+i) = uGammaCompress_1pix(*(ptr+i),threshold,gainMin,gainMax,exponent);
|
||||
}
|
||||
|
||||
}else{
|
||||
std::cout<<"Unsupported Data Type"<<std::endl;
|
||||
}
|
||||
return m;
|
||||
}
|
||||
|
||||
cv::Mat uGammaDecompress_(cv::Mat m,float threshold,float gainMin,float gainMax,float exponent){
|
||||
if(m.type()==CV_16UC3){
|
||||
cv::MatIterator_<cv::Vec3w> it, end;
|
||||
for( it = m.begin<cv::Vec3w>(), end = m.end<cv::Vec3w>(); it != end; ++it)
|
||||
{
|
||||
(*it)[0] =uGammaDecompress_1pix((*it)[0],threshold,gainMin,gainMax,exponent);
|
||||
(*it)[1] =uGammaDecompress_1pix((*it)[1],threshold,gainMin,gainMax,exponent);
|
||||
(*it)[2] =uGammaDecompress_1pix((*it)[2],threshold,gainMin,gainMax,exponent);
|
||||
}
|
||||
}else if(m.type()==CV_16UC1){
|
||||
u_int16_t* ptr = (u_int16_t*)m.data;
|
||||
int end = m.rows*m.cols;
|
||||
for(int i=0;i<end;i++){
|
||||
*(ptr+i) = uGammaDecompress_1pix(*(ptr+i),threshold,gainMin,gainMax,exponent);
|
||||
}
|
||||
|
||||
}else{
|
||||
std::cout<<"Unsupported Data Type"<<std::endl;
|
||||
}
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
cv::Mat gammasRGB(cv::Mat img, bool mode){
|
||||
if(mode){// compress
|
||||
return uGammaCompress_(img,0.0031308, 12.92, 1.055, 1. / 2.4);
|
||||
}else{ // decompress
|
||||
return uGammaDecompress_(img, 0.04045, 12.92, 1.055, 2.4);
|
||||
}
|
||||
}
|
||||
|
||||
void copy_mat_16U_2(u_int16_t* ptr_A, cv::Mat B){
|
||||
// u_int16_t* ptr_A = (u_int16_t*)A.data;
|
||||
u_int16_t* ptr_B = (u_int16_t*)B.data;
|
||||
for(int r = 0; r < B.rows; r++) {
|
||||
for(int c = 0; c < B.cols; c++) {
|
||||
*(ptr_A+r*B.cols+c) = *(ptr_B+r*B.cols+c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cv::Mat mean_(cv::Mat img){
|
||||
// initialize processedImg
|
||||
int H = img.rows;
|
||||
int W = img.cols;
|
||||
cv::Mat processedImg = cv::Mat(H,W,CV_16UC1);
|
||||
u_int16_t* ptr = (u_int16_t*)processedImg.data;
|
||||
|
||||
// traverse img
|
||||
int idx = 0;
|
||||
cv::MatIterator_<cv::Vec3w> it, end;
|
||||
for( it = img.begin<cv::Vec3w>(), end = img.end<cv::Vec3w>(); it != end; ++it)
|
||||
{
|
||||
uint32_t tmp = (*it)[0]+(*it)[1]+(*it)[2];
|
||||
uint16_t avg_val = tmp/3;
|
||||
*(ptr+idx) = avg_val;
|
||||
idx++;
|
||||
}
|
||||
|
||||
return processedImg;
|
||||
}
|
||||
|
||||
double getMean(cv::Mat img){
|
||||
u_int16_t* ptr = (u_int16_t*)img.data;
|
||||
int max_idx = img.rows*img.cols*img.channels();
|
||||
double sum=0;
|
||||
for(int i=0;i<max_idx;i++){
|
||||
sum += *(ptr+i);
|
||||
}
|
||||
sum/=max_idx;
|
||||
sum/=USHRT_MAX;
|
||||
return sum;
|
||||
}
|
||||
|
||||
cv::Mat matMultiply_scalar(cv::Mat img,float gain){
|
||||
u_int16_t* ptr = (u_int16_t*)img.data;
|
||||
int max_idx = img.rows*img.cols*img.channels();
|
||||
for(int i=0;i<max_idx;i++){
|
||||
double tmp = *(ptr+i)*gain;
|
||||
if(tmp<0){
|
||||
*(ptr+i)=0;
|
||||
}else if(tmp>USHRT_MAX){
|
||||
*(ptr+i) = USHRT_MAX;
|
||||
}else{
|
||||
*(ptr+i)=(u_int16_t)tmp;
|
||||
}
|
||||
}
|
||||
return img;
|
||||
}
|
||||
|
||||
double getSaturated(cv::Mat img, double threshold){
|
||||
threshold *= USHRT_MAX;
|
||||
double count=0;
|
||||
u_int16_t* ptr = (u_int16_t*)img.data;
|
||||
int max_idx = img.rows*img.cols*img.channels();
|
||||
for(int i=0;i<max_idx;i++){
|
||||
if(*(ptr+i)>threshold){
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count/(double)max_idx;
|
||||
|
||||
}
|
||||
|
||||
cv::Mat meanGain_(cv::Mat img,int gain){
|
||||
if(img.channels()!=3){
|
||||
std::cout<<"unsupport img type in meanGain_()"<<std::endl;
|
||||
return cv::Mat();
|
||||
}else{ // RGB img
|
||||
int H = img.rows;
|
||||
int W = img.cols;
|
||||
cv::Mat processedImg = cv::Mat(H,W,CV_16UC1);
|
||||
u_int16_t* ptr = (u_int16_t*)processedImg.data;
|
||||
int idx=0;
|
||||
|
||||
cv::MatIterator_<cv::Vec3w> it, end;
|
||||
for( it = img.begin<cv::Vec3w>(), end = img.end<cv::Vec3w>(); it != end; ++it)
|
||||
{
|
||||
double sum = 0;
|
||||
// R
|
||||
double tmp = (*it)[0]*gain;
|
||||
if(tmp<0) tmp=0;
|
||||
if(tmp>USHRT_MAX) tmp = USHRT_MAX;
|
||||
sum+=tmp;
|
||||
|
||||
// G
|
||||
tmp = (*it)[1]*gain;
|
||||
if(tmp<0) tmp=0;
|
||||
if(tmp>USHRT_MAX) tmp = USHRT_MAX;
|
||||
sum+=tmp;
|
||||
|
||||
// B
|
||||
tmp = (*it)[2]*gain;
|
||||
if(tmp<0) tmp=0;
|
||||
if(tmp>USHRT_MAX) tmp = USHRT_MAX;
|
||||
sum+=tmp;
|
||||
|
||||
// put into processedImg
|
||||
uint16_t avg_val = sum/3;
|
||||
*(ptr+idx) = avg_val;
|
||||
idx++;
|
||||
}
|
||||
return processedImg;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
cv::Mat applyScaling_(cv::Mat mergedImage, cv::Mat shortGray, cv::Mat fusedGray){
|
||||
cv::Mat result = mergedImage.clone();
|
||||
u_int16_t* ptr_shortg = (u_int16_t*)shortGray.data;
|
||||
u_int16_t* ptr_fusedg = (u_int16_t*)fusedGray.data;
|
||||
int count = 0;
|
||||
cv::MatIterator_<cv::Vec3w> it, end;
|
||||
for( it = result.begin<cv::Vec3w>(), end = result.end<cv::Vec3w>(); it != end; ++it)
|
||||
{
|
||||
double s = 1;
|
||||
if(*(ptr_shortg+count)!=0){
|
||||
s = *(ptr_fusedg+count);
|
||||
s/=*(ptr_shortg+count);
|
||||
}
|
||||
for(int c=0;c<mergedImage.channels();c++){
|
||||
double tmp = (*it)[c]*s;
|
||||
if(tmp<0){
|
||||
(*it)[c] = 0;
|
||||
}else if(tmp>USHRT_MAX){
|
||||
(*it)[c] = USHRT_MAX;
|
||||
}else{
|
||||
(*it)[c] = tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void localToneMap(cv::Mat& mergedImage, Options options, cv::Mat& shortg,
|
||||
cv::Mat& longg, cv::Mat& fusedg, int& gain){
|
||||
std::cout<<"HDR Tone Mapping..."<<std::endl;
|
||||
// # Work with grayscale images
|
||||
cv::Mat shortGray = rgb_2_gray<uint16_t, uint16_t, CV_16U>(mergedImage); //mean_(mergedImage);
|
||||
std::cout<<"--- Compute grayscale image"<<std::endl;
|
||||
|
||||
// compute gain
|
||||
gain = 0;
|
||||
if(options.ltmGain==-1){
|
||||
double dsFactor = 25;
|
||||
int down_height = round(shortGray.rows/dsFactor);
|
||||
int down_width = round(shortGray.cols/dsFactor);
|
||||
cv::Mat shortS;
|
||||
cv::resize(shortGray,shortS,cv::Size(down_height,down_width),cv::INTER_LINEAR);
|
||||
shortS = shortS.reshape(1,1);
|
||||
|
||||
bool bestGain = false;
|
||||
double compression = 1.0;
|
||||
double saturated = 0.0;
|
||||
cv::Mat shortSg = gammasRGB(shortS.clone(), true);
|
||||
double sSMean = getMean(shortSg);
|
||||
|
||||
while((compression < 1.9 && saturated < .95)||((!bestGain) && (compression < 6) && (gain < 30) && (saturated < 0.33))){
|
||||
gain += 2;
|
||||
cv::Mat longSg = gammasRGB(shortS.clone()*gain, true);
|
||||
double lSMean = getMean(longSg);
|
||||
compression = lSMean / sSMean;
|
||||
bestGain = lSMean > (1 - sSMean) / 2; // only works if burst underexposed
|
||||
saturated = getSaturated(longSg,0.95);
|
||||
if(options.verbose==4){
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}else{
|
||||
if(options.ltmGain>0){
|
||||
gain = options.ltmGain;
|
||||
}
|
||||
}
|
||||
std::cout<<"--- Compute gain"<<std::endl;
|
||||
// create a synthetic long exposure
|
||||
cv::Mat longGray = meanGain_(mergedImage.clone(),gain);
|
||||
std::cout<<"--- Synthetic long expo"<<std::endl;
|
||||
// apply gamma correction to both
|
||||
longg = gammasRGB(longGray.clone(), true);
|
||||
shortg = gammasRGB(shortGray.clone(),true);
|
||||
std::cout<<"--- Apply Gamma correction"<<std::endl;
|
||||
// perform tone mapping by exposure fusion in grayscale
|
||||
cv::Ptr<cv::MergeMertens> mergeMertens = cv::createMergeMertens();
|
||||
std::cout<<"--- Create Mertens"<<std::endl;
|
||||
// hack: cv2 mergeMertens expects inputs between 0 and 255
|
||||
// but the result is scaled between 0 and 1 (some values can actually be greater than 1!)
|
||||
std::vector<cv::Mat> src_expos;
|
||||
src_expos.push_back(convert16bit2_8bit_(shortg.clone()));
|
||||
src_expos.push_back(convert16bit2_8bit_(longg.clone()));
|
||||
mergeMertens->process(src_expos, fusedg);
|
||||
fusedg = fusedg*USHRT_MAX;
|
||||
fusedg.convertTo(fusedg, CV_16UC1);
|
||||
std::cout<<"--- Apply Mertens"<<std::endl;
|
||||
// undo gamma correction
|
||||
cv::Mat fusedGray = gammasRGB(fusedg.clone(), false);
|
||||
// cv::imwrite("fusedg_degamma.png", fusedGray);
|
||||
std::cout<<"--- Un-apply Gamma correction"<<std::endl;
|
||||
// scale each RGB channel of the short exposure accordingly
|
||||
mergedImage = applyScaling_(mergedImage, shortGray, fusedGray);
|
||||
std::cout<<"--- Scale channels"<<std::endl;
|
||||
}
|
||||
|
||||
u_int16_t enhanceContrast_1pix(u_int16_t pix_val,double gain){
|
||||
double x = pix_val;
|
||||
x/=USHRT_MAX;
|
||||
x = x - gain*sin(2*M_PI*x);
|
||||
if(x<0){
|
||||
x = 0;
|
||||
}else if(x>1){
|
||||
x = 1;
|
||||
}
|
||||
u_int16_t result = x*USHRT_MAX;
|
||||
return result;
|
||||
}
|
||||
|
||||
cv::Mat enhanceContrast(cv::Mat image, Options options){
|
||||
if(options.gtmContrast>=0 && options.gtmContrast<=1){
|
||||
u_int16_t* ptr = (u_int16_t*)image.data;
|
||||
int end = image.rows*image.cols*image.channels();
|
||||
for(int idx = 0;idx<end;idx++){
|
||||
*(ptr+idx) = enhanceContrast_1pix(*(ptr+idx),options.gtmContrast);
|
||||
}
|
||||
}else{
|
||||
std::cout<<"GTM ignored, expected a contrast enhancement ratio between 0 and 1"<<std::endl;
|
||||
}
|
||||
return image;
|
||||
}
|
||||
|
||||
cv::Mat distL1_(cv::Mat X, cv::Mat Y){
|
||||
int end_x = X.rows*X.cols*X.channels();
|
||||
int end_y = Y.rows*Y.cols*Y.channels();
|
||||
cv::Mat result = cv::Mat(X.rows,X.cols,X.type());
|
||||
if(end_x==end_y){
|
||||
u_int16_t* ptr_x = (u_int16_t*)X.data;
|
||||
u_int16_t* ptr_y = (u_int16_t*)Y.data;
|
||||
u_int16_t* ptr_r = (u_int16_t*)result.data;
|
||||
for(int i=0;i<end_x;i++){
|
||||
if(*(ptr_x+i)<*(ptr_y+i)){
|
||||
*(ptr_r+i) = *(ptr_y+i) - *(ptr_x+i);
|
||||
}else{
|
||||
*(ptr_r+i) = *(ptr_x+i) - *(ptr_y+i);
|
||||
}
|
||||
}
|
||||
}else{
|
||||
std::cout<<"Mat size not match. distL1_ failed!"<<std::endl;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
cv::Mat sharpenTriple_(cv::Mat image,
|
||||
cv::Mat blur0, cv::Mat low0, float th0, float k0,
|
||||
cv::Mat blur1, cv::Mat low1, float th1, float k1,
|
||||
cv::Mat blur2, cv::Mat low2, float th2, float k2){
|
||||
// create result mat
|
||||
cv::Mat result = cv::Mat(image.rows,image.cols,image.type());
|
||||
// initialize iteraters
|
||||
u_int16_t* ptr_r = (u_int16_t*)result.data;
|
||||
u_int16_t* ptr_img = (u_int16_t*)image.data;
|
||||
u_int16_t* ptr_blur0 = (u_int16_t*)blur0.data;
|
||||
u_int16_t* ptr_low0 = (u_int16_t*)low0.data;
|
||||
u_int16_t* ptr_blur1 = (u_int16_t*)blur1.data;
|
||||
u_int16_t* ptr_low1 = (u_int16_t*)low1.data;
|
||||
u_int16_t* ptr_blur2 = (u_int16_t*)blur2.data;
|
||||
u_int16_t* ptr_low2 = (u_int16_t*)low2.data;
|
||||
int n_channels = image.channels();
|
||||
int end = image.rows*image.cols*n_channels;
|
||||
// traverse Image
|
||||
for(int idx = 0;idx<end;idx++){
|
||||
double r, r0, r1, r2;
|
||||
double x = *(ptr_img+idx);
|
||||
double l0 = *(ptr_low0+idx)/(double)USHRT_MAX;
|
||||
double l1 = *(ptr_low1+idx)/(double)USHRT_MAX;
|
||||
double l2 = *(ptr_low2+idx)/(double)USHRT_MAX;
|
||||
double b0 = *(ptr_blur0+idx);
|
||||
double b1 = *(ptr_blur1+idx);
|
||||
double b2 = *(ptr_blur2+idx);
|
||||
r0 = l0<th0? x:x+k0*(x-b0);
|
||||
r1 = l1<th1? x:x+k1*(x-b1);
|
||||
r2 = l2<th2? x:x+k2*(x-b2);
|
||||
r = (r0+r1+r2)/3.0;
|
||||
if(r<0) r=0;
|
||||
if(r>USHRT_MAX) r = USHRT_MAX;
|
||||
*(ptr_r+idx) = (u_int16_t)r;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
cv::Mat sharpenTriple(cv::Mat image, Tuning tuning, Options options){
|
||||
// sharpen the image using unsharp masking
|
||||
std::vector<float> amounts = tuning.sharpenAmount;
|
||||
std::vector<float> sigmas = tuning.sharpenSigma;
|
||||
std::vector<float> thresholds = tuning.sharpenThreshold;
|
||||
// Compute all Gaussian blur
|
||||
cv::Mat blur0,blur1,blur2;
|
||||
cv::GaussianBlur(image,blur0,cv::Size(0,0),sigmas[0]);
|
||||
cv::GaussianBlur(image,blur1,cv::Size(0,0),sigmas[1]);
|
||||
cv::GaussianBlur(image,blur2,cv::Size(0,0),sigmas[2]);
|
||||
std::cout<<" --- gaussian blur"<<std::endl;
|
||||
// cv::imwrite("blur2.png", blur2);
|
||||
// Compute all low contrast images
|
||||
cv::Mat low0 = distL1_(blur0, image);
|
||||
cv::Mat low1 = distL1_(blur1, image);
|
||||
cv::Mat low2 = distL1_(blur2, image);
|
||||
std::cout<<" --- low contrast"<<std::endl;
|
||||
// cv::imwrite("low2.png", low2);
|
||||
// Compute the triple sharpen
|
||||
cv::Mat sharpImage = sharpenTriple_(image,
|
||||
blur0, low0, thresholds[0], amounts[0],
|
||||
blur1, low1, thresholds[1], amounts[1],
|
||||
blur2, low2, thresholds[2], amounts[2]);
|
||||
std::cout<<" --- sharpen"<<std::endl;
|
||||
return sharpImage;
|
||||
}
|
||||
|
||||
void copy_mat_16U_3(u_int16_t* ptr_A, cv::Mat B){
|
||||
// u_int16_t* ptr_A = (u_int16_t*)A.data;
|
||||
u_int16_t* ptr_B = (u_int16_t*)B.data;
|
||||
int H = B.rows;
|
||||
int W = B.cols;
|
||||
int end = H*W;
|
||||
for(int i=0;i<end;i++){
|
||||
*(ptr_A+i) = *(ptr_B+i);
|
||||
}
|
||||
}
|
||||
|
||||
// void copy_mat_16U_3(u_int16_t* ptr_A, cv::Mat B){
|
||||
// // u_int16_t* ptr_A = (u_int16_t*)A.data;
|
||||
// u_int16_t* ptr_B = (u_int16_t*)B.data;
|
||||
// for(int r = 0; r < B.rows; r++) {
|
||||
// for(int c = 0; c < B.cols; c++) {
|
||||
// *(ptr_A+r*B.cols+c) = *(ptr_B+r*B.cols+c);
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
cv::Mat processMergedMat(cv::Mat mergedImg, int opencv_type){
|
||||
cv::Mat m;
|
||||
uint16_t* ptr = (uint16_t*)mergedImg.data;
|
||||
for(int r = 0; r < mergedImg.rows; r++) {
|
||||
std::vector<int> dvals;
|
||||
for(int c = 0; c < mergedImg.cols; c++) {
|
||||
dvals.push_back(*(ptr+r*mergedImg.cols+c));
|
||||
}
|
||||
cv::Mat mline(dvals, true);
|
||||
cv::transpose(mline, mline);
|
||||
m.push_back(mline);
|
||||
}
|
||||
int ch = CV_MAT_CN(opencv_type);
|
||||
|
||||
m = m.reshape(ch);
|
||||
m.convertTo(m, opencv_type);
|
||||
|
||||
return m;
|
||||
|
||||
}
|
||||
|
||||
void show20_20(cv::Mat m){
|
||||
u_int16_t* ptr = (u_int16_t*)m.data;
|
||||
for(int i=0;i<20;i++){
|
||||
for(int j=0;j<20;j++){
|
||||
std::cout<<*(ptr+i*m.cols+j)<<", ";
|
||||
}
|
||||
std::cout<<std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void writeCSV(std::string filename, cv::Mat m)
|
||||
{
|
||||
std::ofstream myfile;
|
||||
myfile.open(filename.c_str());
|
||||
myfile<< cv::format(m, cv::Formatter::FMT_CSV) << std::endl;
|
||||
myfile.close();
|
||||
}
|
||||
|
||||
void finish::process(const hdrplus::burst& burst_images, cv::Mat& finalOutputImage){
|
||||
// copy mergedBayer to rawReference
|
||||
std::cout<<"finish pipeline start ..."<<std::endl;
|
||||
|
||||
// save merged Image value
|
||||
// #ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
writeCSV(DBG_OUTPUT_ROOT "merged.csv",burst_images.merged_bayer_image);
|
||||
// #endif
|
||||
|
||||
this->refIdx = burst_images.reference_image_idx;
|
||||
// this->burstPath = burstPath;
|
||||
// std::cout<<"processMerged:"<<std::endl;
|
||||
// show20_20(mergedB);
|
||||
|
||||
this->mergedBayer = loadFromCSV(DBG_OUTPUT_ROOT "merged.csv", CV_16UC1);
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
// this->mergedBayer = processMergedMat(mergedB,CV_16UC1);//loadFromCSV("merged.csv", CV_16UC1);
|
||||
// std::cout<<"processMerged:"<<std::endl;
|
||||
// show20_20(this->mergedBayer);
|
||||
// this->mergedBayer = loadFromCSV(DBG_OUTPUT_ROOT "merged.csv", CV_16UC1);
|
||||
// this->mergedBayer = processMergedMat(burst_images.merged_bayer_image, CV_16UC1);
|
||||
#else
|
||||
// this->mergedBayer = loadFromCSV(DBG_OUTPUT_ROOT "merged.csv", CV_16UC1);
|
||||
// this->mergedBayer = processMergedMat(burst_images.merged_bayer_image, CV_16UC1);
|
||||
// std::cout<<"processMerged:"<<std::endl;
|
||||
#endif
|
||||
// std::cout<<"csv:"<<std::endl;
|
||||
// show20_20(this->mergedBayer);
|
||||
// load_rawPathList(burstPath);
|
||||
|
||||
// read in ref img
|
||||
// bayer_image* ref = new bayer_image(rawPathList[refIdx]);
|
||||
bayer_image* ref = new bayer_image(burst_images.bayer_images[burst_images.reference_image_idx]);
|
||||
cv::Mat processedRefImage = postprocess(ref->libraw_processor,params.rawpyArgs);
|
||||
|
||||
std::cout<<"size ref: "<<processedRefImage.rows<<"*"<<processedRefImage.cols<<std::endl;
|
||||
|
||||
// write reference image
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeReferenceImage"]){
|
||||
std::cout<<"writing reference img ..."<<std::endl;
|
||||
cv::Mat outputImg = convert16bit2_8bit_(processedRefImage.clone());
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
// cv::imshow("test",processedImage);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "processedRef.jpg", outputImg);
|
||||
// cv::waitKey(0);
|
||||
}
|
||||
#endif
|
||||
|
||||
// write gamma reference
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeGammaReference"]){
|
||||
std::cout<<"writing Gamma reference img ..."<<std::endl;
|
||||
cv::Mat outputImg = gammasRGB(processedRefImage.clone(),true);
|
||||
outputImg = convert16bit2_8bit_(outputImg);
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "processedRefGamma.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
// get the bayer_image of the merged image
|
||||
// bayer_image* mergedImg = new bayer_image(rawPathList[refIdx]);
|
||||
bayer_image* mergedImg = new bayer_image(burst_images.bayer_images[this->refIdx]);
|
||||
mergedImg->libraw_processor->imgdata.rawdata.raw_image = (uint16_t*)this->mergedBayer.data;
|
||||
// copy_mat_16U_3(mergedImg->libraw_processor->imgdata.rawdata.raw_image,this->mergedBayer);
|
||||
cv::Mat processedMerge = postprocess(mergedImg->libraw_processor,params.rawpyArgs);
|
||||
|
||||
// write merged image
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeMergedImage"]){
|
||||
std::cout<<"writing Merged img ..."<<std::endl;
|
||||
cv::Mat outputImg = convert16bit2_8bit_(processedMerge.clone());
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "mergedImg.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
// write gamma merged image
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeMergedImage"]){
|
||||
std::cout<<"writing Gamma Merged img ..."<<std::endl;
|
||||
cv::Mat outputImg = gammasRGB(processedMerge.clone(),true);
|
||||
outputImg = convert16bit2_8bit_(outputImg);
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "mergedImgGamma.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
// step 5. HDR tone mapping
|
||||
// processedImage, gain, shortExposure, longExposure, fusedExposure = localToneMap(burstPath, processedImage, options)
|
||||
int gain;
|
||||
if(params.options.ltmGain){
|
||||
cv::Mat shortExposure, longExposure, fusedExposure;
|
||||
|
||||
localToneMap(processedMerge, params.options,shortExposure,longExposure,fusedExposure,gain);
|
||||
std::cout<<"gain="<< gain<<std::endl;
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeShortExposure"]){
|
||||
std::cout<<"writing ShortExposure img ..."<<std::endl;
|
||||
cv::Mat outputImg = convert16bit2_8bit_(shortExposure);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "shortg.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeLongExposure"]){
|
||||
std::cout<<"writing LongExposure img ..."<<std::endl;
|
||||
cv::Mat outputImg = convert16bit2_8bit_(longExposure);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "longg.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeFusedExposure"]){
|
||||
std::cout<<"writing FusedExposure img ..."<<std::endl;
|
||||
cv::Mat outputImg = convert16bit2_8bit_(fusedExposure);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "fusedg.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeLTMImage"]){
|
||||
std::cout<<"writing LTMImage ..."<<std::endl;
|
||||
cv::Mat outputImg = convert16bit2_8bit_(processedMerge.clone());
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "ltmGain.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeLTMGamma"]){
|
||||
std::cout<<"writing LTMImage Gamma ..."<<std::endl;
|
||||
cv::Mat outputImg = gammasRGB(processedMerge.clone(),true);
|
||||
outputImg = convert16bit2_8bit_(outputImg);
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "ltmGain_gamma.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// step 6 GTM: contrast enhancement / global tone mapping
|
||||
if(params.options.gtmContrast){
|
||||
processedMerge = enhanceContrast(processedMerge, params.options);
|
||||
std::cout<<"STEP 6 -- Apply GTM"<<std::endl;
|
||||
}
|
||||
|
||||
// apply the final sRGB gamma curve
|
||||
processedMerge = gammasRGB(processedMerge.clone(),true);
|
||||
std::cout<<"-- Apply Gamma"<<std::endl;
|
||||
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeGTMImage"]) {
|
||||
std::cout<<"writing GTMImage ..."<<std::endl;
|
||||
cv::Mat outputImg = convert16bit2_8bit_(processedMerge.clone());
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "GTM_gamma.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Step 7: sharpen
|
||||
finalOutputImage = sharpenTriple(processedMerge.clone(), params.tuning, params.options);
|
||||
cv::Mat& processedImage = finalOutputImage;
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeFinalImage"]){
|
||||
std::cout<<"writing FinalImage ..."<<std::endl;
|
||||
cv::Mat outputImg = convert16bit2_8bit_(processedImage.clone());
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "FinalImage.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
|
||||
// write final ref
|
||||
#ifndef HDRPLUS_NO_DETAILED_OUTPUT
|
||||
if(params.flags["writeReferenceFinal"]){
|
||||
std::cout<<"writing Final Ref Image ..."<<std::endl;
|
||||
if(params.options.ltmGain){
|
||||
params.options.ltmGain = gain;
|
||||
}
|
||||
cv::Mat shortExposureRef, longExposureRef, fusedExposureRef;
|
||||
localToneMap(processedRefImage, params.options,shortExposureRef,longExposureRef,fusedExposureRef,gain);
|
||||
if(params.options.gtmContrast){ // contrast enhancement / global tone mapping
|
||||
processedRefImage = enhanceContrast(processedRefImage, params.options);
|
||||
}
|
||||
processedRefImage = gammasRGB(processedRefImage.clone(),true);
|
||||
// sharpen
|
||||
processedRefImage = sharpenTriple(processedRefImage.clone(), params.tuning, params.options);
|
||||
cv::Mat outputImg = convert16bit2_8bit_(processedRefImage.clone());
|
||||
cv::cvtColor(outputImg, outputImg, cv::COLOR_RGB2BGR);
|
||||
|
||||
cv::imwrite(DBG_OUTPUT_ROOT "FinalReference.jpg", outputImg);
|
||||
}
|
||||
#endif
|
||||
// End of finishing
|
||||
}
|
||||
|
||||
void finish::copy_mat_16U(cv::Mat& A, cv::Mat B){
|
||||
u_int16_t* ptr_A = (u_int16_t*)A.data;
|
||||
u_int16_t* ptr_B = (u_int16_t*)B.data;
|
||||
for(int r = 0; r < A.rows; r++) {
|
||||
for(int c = 0; c < A.cols; c++) {
|
||||
*(ptr_A+r*A.cols+c) = *(ptr_B+r*B.cols+c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void finish::copy_rawImg2libraw(std::shared_ptr<LibRaw>& libraw_ptr, cv::Mat B){
|
||||
u_int16_t* ptr_A = (u_int16_t*)libraw_ptr->imgdata.rawdata.raw_image;
|
||||
u_int16_t* ptr_B = (u_int16_t*)B.data;
|
||||
for(int r = 0; r < B.rows; r++) {
|
||||
for(int c = 0; c < B.cols; c++) {
|
||||
*(ptr_A+r*B.cols+c) = *(ptr_B+r*B.cols+c);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,55 @@
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <utility> // std::pair
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include "hdrplus/hdrplus_pipeline.h"
|
||||
#include "hdrplus/burst.h"
|
||||
#include "hdrplus/align.h"
|
||||
#include "hdrplus/merge.h"
|
||||
#include "hdrplus/finish.h"
|
||||
#include <fstream>
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
void hdrplus_pipeline::run_pipeline( \
|
||||
const std::string& burst_path, \
|
||||
const std::string& reference_image_path )
|
||||
{
|
||||
// Create burst of images
|
||||
burst burst_images( burst_path, reference_image_path );
|
||||
std::vector<std::vector<std::vector<std::pair<int, int>>>> alignments;
|
||||
|
||||
// Run align
|
||||
align_module.process( burst_images, alignments );
|
||||
|
||||
// Run merging
|
||||
merge_module.process( burst_images, alignments );
|
||||
|
||||
// Run finishing
|
||||
cv::Mat finalImg;
|
||||
finish_module.process( burst_images, finalImg);
|
||||
}
|
||||
|
||||
bool hdrplus_pipeline::run_pipeline( \
|
||||
const std::vector<std::string>& burst_paths, \
|
||||
int reference_image_index, cv::Mat& finalImg )
|
||||
{
|
||||
// Create burst of images
|
||||
burst burst_images( burst_paths, reference_image_index );
|
||||
std::vector<std::vector<std::vector<std::pair<int, int>>>> alignments;
|
||||
|
||||
// Run align
|
||||
align_module.process( burst_images, alignments );
|
||||
|
||||
// Run merging
|
||||
merge_module.process( burst_images, alignments );
|
||||
|
||||
// Run finishing
|
||||
finish_module.process( burst_images, finalImg);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,333 @@
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
#include "hdrplus/merge.h"
|
||||
#include "hdrplus/burst.h"
|
||||
#include "hdrplus/utility.h"
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
void merge::process(hdrplus::burst& burst_images, \
|
||||
std::vector<std::vector<std::vector<std::pair<int, int>>>>& alignments)
|
||||
{
|
||||
// 4.1 Noise Parameters and RMS
|
||||
// Noise parameters calculated from baseline ISO noise parameters
|
||||
double lambda_shot, lambda_read;
|
||||
std::tie(lambda_shot, lambda_read) = burst_images.bayer_images[burst_images.reference_image_idx].get_noise_params();
|
||||
|
||||
// 4.2-4.4 Denoising and Merging
|
||||
|
||||
// Get padded bayer image
|
||||
cv::Mat reference_image = burst_images.bayer_images_pad[burst_images.reference_image_idx];
|
||||
cv::imwrite("ref.jpg", reference_image);
|
||||
|
||||
// Get raw channels
|
||||
std::vector<cv::Mat> channels(4);
|
||||
hdrplus::extract_rgb_from_bayer<uint16_t>(reference_image, channels[0], channels[1], channels[2], channels[3]);
|
||||
|
||||
std::vector<cv::Mat> processed_channels(4);
|
||||
// For each channel, perform denoising and merge
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
// Get channel mat
|
||||
cv::Mat channel_i = channels[i];
|
||||
// cv::imwrite("ref" + std::to_string(i) + ".jpg", channel_i);
|
||||
|
||||
//we should be getting the individual channel in the same place where we call the processChannel function with the reference channel in its arguments
|
||||
//possibly we could add another argument in the processChannel function which is the channel_i for the alternate image. maybe using a loop to cover all the other images
|
||||
|
||||
//create list of channel_i of alternate images:
|
||||
std::vector<cv::Mat> alternate_channel_i_list;
|
||||
for (int j = 0; j < burst_images.num_images; j++) {
|
||||
if (j != burst_images.reference_image_idx) {
|
||||
|
||||
//get alternate image
|
||||
cv::Mat alt_image = burst_images.bayer_images_pad[j];
|
||||
std::vector<cv::Mat> alt_channels(4);
|
||||
hdrplus::extract_rgb_from_bayer<uint16_t>(alt_image, alt_channels[0], alt_channels[1], alt_channels[2], alt_channels[3]);
|
||||
|
||||
alternate_channel_i_list.push_back(alt_channels[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// Apply merging on the channel
|
||||
cv::Mat merged_channel = processChannel(burst_images, alignments, channel_i, alternate_channel_i_list, lambda_shot, lambda_read);
|
||||
// cv::imwrite("merged" + std::to_string(i) + ".jpg", merged_channel);
|
||||
|
||||
// Put channel raw data back to channels
|
||||
merged_channel.convertTo(processed_channels[i], CV_16U);
|
||||
}
|
||||
|
||||
// Write all channels back to a bayer mat
|
||||
cv::Mat merged(reference_image.rows, reference_image.cols, CV_16U);
|
||||
int x, y;
|
||||
for (y = 0; y < reference_image.rows; ++y){
|
||||
uint16_t* row = merged.ptr<uint16_t>(y);
|
||||
if (y % 2 == 0){
|
||||
uint16_t* i0 = processed_channels[0].ptr<uint16_t>(y / 2);
|
||||
uint16_t* i1 = processed_channels[1].ptr<uint16_t>(y / 2);
|
||||
|
||||
for (x = 0; x < reference_image.cols;){
|
||||
//R
|
||||
row[x] = i0[x / 2];
|
||||
x++;
|
||||
|
||||
//G1
|
||||
row[x] = i1[x / 2];
|
||||
x++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
uint16_t* i2 = processed_channels[2].ptr<uint16_t>(y / 2);
|
||||
uint16_t* i3 = processed_channels[3].ptr<uint16_t>(y / 2);
|
||||
|
||||
for(x = 0; x < reference_image.cols;){
|
||||
//G2
|
||||
row[x] = i2[x / 2];
|
||||
x++;
|
||||
|
||||
//B
|
||||
row[x] = i3[x / 2];
|
||||
x++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remove padding
|
||||
std::vector<int> padding = burst_images.padding_info_bayer;
|
||||
cv::Range horizontal = cv::Range(padding[2], reference_image.cols - padding[3]);
|
||||
cv::Range vertical = cv::Range(padding[0], reference_image.rows - padding[1]);
|
||||
burst_images.merged_bayer_image = merged(vertical, horizontal);
|
||||
cv::imwrite("merged.jpg", burst_images.merged_bayer_image);
|
||||
}
|
||||
|
||||
std::vector<cv::Mat> merge::getReferenceTiles(cv::Mat reference_image) {
|
||||
std::vector<cv::Mat> reference_tiles;
|
||||
for (int y = 0; y < reference_image.rows - offset; y += offset) {
|
||||
for (int x = 0; x < reference_image.cols - offset; x += offset) {
|
||||
cv::Mat tile = reference_image(cv::Rect(x, y, TILE_SIZE, TILE_SIZE));
|
||||
reference_tiles.push_back(tile);
|
||||
}
|
||||
}
|
||||
return reference_tiles;
|
||||
}
|
||||
|
||||
cv::Mat merge::mergeTiles(std::vector<cv::Mat> tiles, int num_rows, int num_cols) {
|
||||
// 1. get all four subsets: original (evenly split), horizontal overlapped,
|
||||
// vertical overlapped, 2D overlapped
|
||||
std::vector<std::vector<cv::Mat>> tiles_original;
|
||||
for (int y = 0; y < num_rows / offset - 1; y += 2) {
|
||||
std::vector<cv::Mat> row;
|
||||
for (int x = 0; x < num_cols / offset - 1; x += 2) {
|
||||
row.push_back(tiles[y * (num_cols / offset - 1) + x]);
|
||||
}
|
||||
tiles_original.push_back(row);
|
||||
}
|
||||
|
||||
std::vector<std::vector<cv::Mat>> tiles_horizontal;
|
||||
for (int y = 0; y < num_rows / offset - 1; y += 2) {
|
||||
std::vector<cv::Mat> row;
|
||||
for (int x = 1; x < num_cols / offset - 1; x += 2) {
|
||||
row.push_back(tiles[y * (num_cols / offset - 1) + x]);
|
||||
}
|
||||
tiles_horizontal.push_back(row);
|
||||
}
|
||||
|
||||
std::vector<std::vector<cv::Mat>> tiles_vertical;
|
||||
for (int y = 1; y < num_rows / offset - 1; y += 2) {
|
||||
std::vector<cv::Mat> row;
|
||||
for (int x = 0; x < num_cols / offset - 1; x += 2) {
|
||||
row.push_back(tiles[y * (num_cols / offset - 1) + x]);
|
||||
}
|
||||
tiles_vertical.push_back(row);
|
||||
}
|
||||
|
||||
std::vector<std::vector<cv::Mat>> tiles_2d;
|
||||
for (int y = 1; y < num_rows / offset - 1; y += 2) {
|
||||
std::vector<cv::Mat> row;
|
||||
for (int x = 1; x < num_cols / offset - 1; x += 2) {
|
||||
row.push_back(tiles[y * (num_cols / offset - 1) + x]);
|
||||
}
|
||||
tiles_2d.push_back(row);
|
||||
}
|
||||
|
||||
// 2. Concatenate the four subsets
|
||||
cv::Mat img_original = cat2Dtiles(tiles_original);
|
||||
cv::Mat img_horizontal = cat2Dtiles(tiles_horizontal);
|
||||
cv::Mat img_vertical = cat2Dtiles(tiles_vertical);
|
||||
cv::Mat img_2d = cat2Dtiles(tiles_2d);
|
||||
|
||||
// 3. Add the four subsets together
|
||||
img_original(cv::Rect(offset, 0, num_cols - TILE_SIZE, num_rows)) += img_horizontal;
|
||||
img_original(cv::Rect(0, offset, num_cols, num_rows - TILE_SIZE)) += img_vertical;
|
||||
img_original(cv::Rect(offset, offset, num_cols - TILE_SIZE, num_rows - TILE_SIZE)) += img_2d;
|
||||
|
||||
return img_original;
|
||||
}
|
||||
|
||||
cv::Mat merge::processChannel(hdrplus::burst& burst_images, \
|
||||
std::vector<std::vector<std::vector<std::pair<int, int>>>>& alignments, \
|
||||
cv::Mat channel_image, \
|
||||
std::vector<cv::Mat> alternate_channel_i_list,\
|
||||
float lambda_shot, \
|
||||
float lambda_read) {
|
||||
// Get tiles of the reference image
|
||||
std::vector<cv::Mat> reference_tiles = getReferenceTiles(channel_image);
|
||||
|
||||
// Get noise variance (sigma**2 = lambda_shot * tileRMS + lambda_read)
|
||||
std::vector<float> noise_variance = getNoiseVariance(reference_tiles, lambda_shot, lambda_read);
|
||||
|
||||
// Apply FFT on reference tiles (spatial to frequency)
|
||||
std::vector<cv::Mat> reference_tiles_DFT;
|
||||
for (auto ref_tile : reference_tiles) {
|
||||
cv::Mat ref_tile_DFT;
|
||||
ref_tile.convertTo(ref_tile_DFT, CV_32F);
|
||||
cv::dft(ref_tile_DFT, ref_tile_DFT, cv::DFT_COMPLEX_OUTPUT);
|
||||
reference_tiles_DFT.push_back(ref_tile_DFT);
|
||||
}
|
||||
|
||||
// Acquire alternate tiles and apply FFT on them as well
|
||||
std::vector<std::vector<cv::Mat>> alt_tiles_list(reference_tiles.size());
|
||||
int num_tiles_row = alternate_channel_i_list[0].rows / offset - 1;
|
||||
int num_tiles_col = alternate_channel_i_list[0].cols / offset - 1;
|
||||
for (int y = 0; y < num_tiles_row; ++y) {
|
||||
for (int x = 0; x < num_tiles_col; ++x) {
|
||||
std::vector<cv::Mat> alt_tiles;
|
||||
// Get reference tile location
|
||||
int top_left_y = y * offset;
|
||||
int top_left_x = x * offset;
|
||||
|
||||
for (int i = 0; i < alternate_channel_i_list.size(); ++i) {
|
||||
// Get alignment displacement
|
||||
int displacement_y, displacement_x;
|
||||
std::tie(displacement_y, displacement_x) = alignments[i + 1][y][x];
|
||||
// Get tile
|
||||
cv::Mat alt_tile = alternate_channel_i_list[i](cv::Rect(top_left_x + displacement_x, top_left_y + displacement_y, TILE_SIZE, TILE_SIZE));
|
||||
// Apply FFT
|
||||
cv::Mat alt_tile_DFT;
|
||||
alt_tile.convertTo(alt_tile_DFT, CV_32F);
|
||||
cv::dft(alt_tile_DFT, alt_tile_DFT, cv::DFT_COMPLEX_OUTPUT);
|
||||
alt_tiles.push_back(alt_tile_DFT);
|
||||
}
|
||||
alt_tiles_list[y * num_tiles_col + x] = alt_tiles;
|
||||
}
|
||||
}
|
||||
|
||||
// 4.2 Temporal Denoising
|
||||
reference_tiles_DFT = temporal_denoise(reference_tiles_DFT, alt_tiles_list, noise_variance, TEMPORAL_FACTOR);
|
||||
|
||||
// 4.3 Spatial Denoising
|
||||
reference_tiles_DFT = spatial_denoise(reference_tiles_DFT, alternate_channel_i_list.size(), noise_variance, SPATIAL_FACTOR);
|
||||
//now reference tiles are temporally and spatially denoised
|
||||
|
||||
// Apply IFFT on reference tiles (frequency to spatial)
|
||||
std::vector<cv::Mat> denoised_tiles;
|
||||
for (auto dft_tile : reference_tiles_DFT) {
|
||||
cv::Mat denoised_tile;
|
||||
cv::divide(dft_tile, TILE_SIZE * TILE_SIZE, dft_tile);
|
||||
cv::dft(dft_tile, denoised_tile, cv::DFT_INVERSE | cv::DFT_REAL_OUTPUT);
|
||||
denoised_tiles.push_back(denoised_tile);
|
||||
}
|
||||
reference_tiles = denoised_tiles;
|
||||
|
||||
// 4.4 Cosine Window Merging
|
||||
// Process tiles through 2D cosine window
|
||||
std::vector<cv::Mat> windowed_tiles;
|
||||
for (auto tile : reference_tiles) {
|
||||
windowed_tiles.push_back(cosineWindow2D(tile));
|
||||
}
|
||||
|
||||
// Merge tiles
|
||||
return mergeTiles(windowed_tiles, channel_image.rows, channel_image.cols);
|
||||
}
|
||||
|
||||
std::vector<cv::Mat> merge::temporal_denoise(std::vector<cv::Mat> tiles, std::vector<std::vector<cv::Mat>> alt_tiles, std::vector<float> noise_variance, float temporal_factor) {
|
||||
// goal: temporially denoise using the weiner filter
|
||||
// input:
|
||||
// 1. array of 2D dft tiles of the reference image
|
||||
// 2. array of 2D dft tiles of the aligned alternate image
|
||||
// 3. estimated noise variance
|
||||
// 4. temporal factor
|
||||
// return: merged image patches dft
|
||||
|
||||
// calculate noise scaling
|
||||
double temporal_noise_scaling = (TILE_SIZE * TILE_SIZE * (2.0 / 16)) * TEMPORAL_FACTOR;
|
||||
|
||||
// loop across tiles
|
||||
std::vector<cv::Mat> denoised;
|
||||
for (int i = 0; i < tiles.size(); ++i) {
|
||||
// sum of pairwise denoising
|
||||
cv::Mat tile_sum = tiles[i].clone();
|
||||
double coeff = temporal_noise_scaling * noise_variance[i];
|
||||
|
||||
// Ref tile
|
||||
cv::Mat tile = tiles[i];
|
||||
// Alt tiles
|
||||
std::vector<cv::Mat> alt_tiles_i = alt_tiles[i];
|
||||
|
||||
for (int j = 0; j < alt_tiles_i.size(); ++j) {
|
||||
// Alt tile
|
||||
cv::Mat alt_tile = alt_tiles_i[j];
|
||||
// Tile difference
|
||||
cv::Mat diff = tile - alt_tile;
|
||||
|
||||
// Calculate absolute difference
|
||||
cv::Mat complexMats[2];
|
||||
cv::split(diff, complexMats); // planes[0] = Re(DFT(I)), planes[1] = Im(DFT(I))
|
||||
cv::magnitude(complexMats[0], complexMats[1], complexMats[0]); // planes[0] = magnitude
|
||||
cv::Mat absolute_diff = complexMats[0].mul(complexMats[0]);
|
||||
|
||||
// find shrinkage operator A
|
||||
cv::Mat shrinkage;
|
||||
cv::divide(absolute_diff, absolute_diff + coeff, shrinkage);
|
||||
cv::merge(std::vector<cv::Mat>{shrinkage, shrinkage}, shrinkage);
|
||||
|
||||
// Interpolation
|
||||
tile_sum += alt_tile + diff.mul(shrinkage);
|
||||
}
|
||||
// Average by num of frames
|
||||
cv::divide(tile_sum, alt_tiles_i.size() + 1, tile_sum);
|
||||
denoised.push_back(tile_sum);
|
||||
}
|
||||
|
||||
return denoised;
|
||||
}
|
||||
|
||||
std::vector<cv::Mat> merge::spatial_denoise(std::vector<cv::Mat> tiles, int num_alts, std::vector<float> noise_variance, float spatial_factor) {
|
||||
|
||||
double spatial_noise_scaling = (TILE_SIZE * TILE_SIZE * (1.0 / 16)) * spatial_factor;
|
||||
|
||||
// Calculate |w| using ifftshift
|
||||
cv::Mat row_distances = cv::Mat::zeros(1, TILE_SIZE, CV_32F);
|
||||
for(int i = 0; i < TILE_SIZE; ++i) {
|
||||
row_distances.at<float>(i) = i - offset;
|
||||
}
|
||||
row_distances = cv::repeat(row_distances.t(), 1, TILE_SIZE);
|
||||
cv::Mat col_distances = row_distances.t();
|
||||
cv::Mat distances;
|
||||
cv::sqrt(row_distances.mul(row_distances) + col_distances.mul(col_distances), distances);
|
||||
ifftshift(distances);
|
||||
|
||||
std::vector<cv::Mat> denoised;
|
||||
// Loop through all tiles
|
||||
for (int i = 0; i < tiles.size(); ++i) {
|
||||
cv::Mat tile = tiles[i];
|
||||
float coeff = noise_variance[i] / (num_alts + 1) * spatial_noise_scaling;
|
||||
|
||||
// Calculate absolute difference
|
||||
cv::Mat complexMats[2];
|
||||
cv::split(tile, complexMats); // planes[0] = Re(DFT(I)), planes[1] = Im(DFT(I))
|
||||
cv::magnitude(complexMats[0], complexMats[1], complexMats[0]); // planes[0] = magnitude
|
||||
cv::Mat absolute_diff = complexMats[0].mul(complexMats[0]);
|
||||
|
||||
// Division
|
||||
cv::Mat scale;
|
||||
cv::divide(absolute_diff, absolute_diff + distances * coeff, scale);
|
||||
cv::merge(std::vector<cv::Mat>{scale, scale}, scale);
|
||||
denoised.push_back(tile.mul(scale));
|
||||
}
|
||||
return denoised;
|
||||
}
|
||||
|
||||
|
||||
} // namespace hdrplus
|
||||
@ -0,0 +1,53 @@
|
||||
#include <iostream>
|
||||
#include <opencv2/opencv.hpp> // all opencv header
|
||||
#include <hdrplus/params.h>
|
||||
|
||||
namespace hdrplus
|
||||
{
|
||||
|
||||
void setParams(std::shared_ptr<LibRaw>& libraw_ptr, RawpyArgs rawpyArgs){
|
||||
libraw_ptr->imgdata.params.user_qual = rawpyArgs.demosaic_algorithm;
|
||||
libraw_ptr->imgdata.params.half_size = rawpyArgs.half_size;
|
||||
libraw_ptr->imgdata.params.use_camera_wb = rawpyArgs.use_camera_wb;
|
||||
libraw_ptr->imgdata.params.use_auto_wb = rawpyArgs.use_auto_wb;
|
||||
libraw_ptr->imgdata.params.no_auto_bright = rawpyArgs.no_auto_bright;
|
||||
libraw_ptr->imgdata.params.output_color = rawpyArgs.output_color;
|
||||
libraw_ptr->imgdata.params.gamm[0] = rawpyArgs.gamma[0];
|
||||
libraw_ptr->imgdata.params.gamm[1] = rawpyArgs.gamma[1];
|
||||
libraw_ptr->imgdata.params.output_bps = rawpyArgs.output_bps;
|
||||
}
|
||||
|
||||
cv::Mat postprocess(std::shared_ptr<LibRaw>& libraw_ptr, RawpyArgs rawpyArgs){
|
||||
std::cout<<"postprocessing..."<<std::endl;
|
||||
// set parameters
|
||||
setParams(libraw_ptr,rawpyArgs);
|
||||
|
||||
std::cout<<"conversion to 16 bit using black and white levels, demosaicking, white balance, color correction..."<<std::endl;
|
||||
|
||||
libraw_ptr->dcraw_process();
|
||||
int errorcode;
|
||||
|
||||
libraw_processed_image_t *ret_img = libraw_ptr->dcraw_make_mem_image(&errorcode);
|
||||
|
||||
int opencv_type = CV_16UC3; // 16bit RGB
|
||||
if(ret_img->colors==1){ // grayscale
|
||||
if(ret_img->bits == 8){ // uint8
|
||||
opencv_type = CV_8UC1;
|
||||
}else{ // uint16
|
||||
opencv_type = CV_16UC1;
|
||||
}
|
||||
}else{// RGB
|
||||
if(ret_img->bits == 8){ //8bit
|
||||
opencv_type = CV_8UC3;
|
||||
}else{ // 16bit
|
||||
opencv_type = CV_16UC3;
|
||||
}
|
||||
}
|
||||
|
||||
cv::Mat processedImg(ret_img->height,ret_img->width,opencv_type,ret_img->data);
|
||||
|
||||
std::cout<<"postprocess finished!"<<std::endl;
|
||||
return processedImg;
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue