mirror of
https://github.com/opencv/opencv.git
synced 2024-12-16 18:39:12 +08:00
547 lines
16 KiB
C++
547 lines
16 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * The name of the copyright holders may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// This software is provided by the copyright holders and contributors "as is" and
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage.
|
|
//
|
|
//M*/
|
|
|
|
#include "precomp.hpp"
|
|
#include "opencv2/photo.hpp"
|
|
#include "opencv2/imgproc.hpp"
|
|
#include "hdr_common.hpp"
|
|
|
|
namespace cv
|
|
{
|
|
|
|
class AlignMTBImpl : public AlignMTB
|
|
{
|
|
public:
|
|
AlignMTBImpl(int max_bits, int exclude_range, bool cut) :
|
|
max_bits(max_bits),
|
|
exclude_range(exclude_range),
|
|
cut(cut),
|
|
name("AlignMTB")
|
|
{
|
|
}
|
|
|
|
void process(InputArrayOfArrays src, std::vector<Mat>& dst,
|
|
const std::vector<float>& times, InputArray response)
|
|
{
|
|
process(src, dst);
|
|
}
|
|
|
|
void process(InputArrayOfArrays _src, std::vector<Mat>& dst)
|
|
{
|
|
std::vector<Mat> src;
|
|
_src.getMatVector(src);
|
|
|
|
checkImageDimensions(src);
|
|
dst.resize(src.size());
|
|
|
|
size_t pivot = src.size() / 2;
|
|
dst[pivot] = src[pivot];
|
|
Mat gray_base;
|
|
cvtColor(src[pivot], gray_base, COLOR_RGB2GRAY);
|
|
std::vector<Point> shifts;
|
|
|
|
for(size_t i = 0; i < src.size(); i++) {
|
|
if(i == pivot) {
|
|
shifts.push_back(Point(0, 0));
|
|
continue;
|
|
}
|
|
Mat gray;
|
|
cvtColor(src[i], gray, COLOR_RGB2GRAY);
|
|
Point shift;
|
|
calculateShift(gray_base, gray, shift);
|
|
shifts.push_back(shift);
|
|
shiftMat(src[i], dst[i], shift);
|
|
}
|
|
if(cut) {
|
|
Point max(0, 0), min(0, 0);
|
|
for(size_t i = 0; i < shifts.size(); i++) {
|
|
if(shifts[i].x > max.x) {
|
|
max.x = shifts[i].x;
|
|
}
|
|
if(shifts[i].y > max.y) {
|
|
max.y = shifts[i].y;
|
|
}
|
|
if(shifts[i].x < min.x) {
|
|
min.x = shifts[i].x;
|
|
}
|
|
if(shifts[i].y < min.y) {
|
|
min.y = shifts[i].y;
|
|
}
|
|
}
|
|
Point size = dst[0].size();
|
|
for(size_t i = 0; i < dst.size(); i++) {
|
|
dst[i] = dst[i](Rect(max, min + size));
|
|
}
|
|
}
|
|
}
|
|
|
|
void calculateShift(InputArray _img0, InputArray _img1, Point& shift)
|
|
{
|
|
Mat img0 = _img0.getMat();
|
|
Mat img1 = _img1.getMat();
|
|
CV_Assert(img0.channels() == 1 && img0.type() == img1.type());
|
|
CV_Assert(img0.size() == img0.size());
|
|
|
|
int maxlevel = static_cast<int>(log((double)max(img0.rows, img0.cols)) / log(2.0)) - 1;
|
|
maxlevel = min(maxlevel, max_bits - 1);
|
|
|
|
std::vector<Mat> pyr0;
|
|
std::vector<Mat> pyr1;
|
|
buildPyr(img0, pyr0, maxlevel);
|
|
buildPyr(img1, pyr1, maxlevel);
|
|
|
|
shift = Point(0, 0);
|
|
for(int level = maxlevel; level >= 0; level--) {
|
|
|
|
shift *= 2;
|
|
Mat tb1, tb2, eb1, eb2;
|
|
computeBitmaps(pyr0[level], tb1, eb1);
|
|
computeBitmaps(pyr1[level], tb2, eb2);
|
|
|
|
int min_err = pyr0[level].total();
|
|
Point new_shift(shift);
|
|
for(int i = -1; i <= 1; i++) {
|
|
for(int j = -1; j <= 1; j++) {
|
|
Point test_shift = shift + Point(i, j);
|
|
Mat shifted_tb2, shifted_eb2, diff;
|
|
shiftMat(tb2, shifted_tb2, test_shift);
|
|
shiftMat(eb2, shifted_eb2, test_shift);
|
|
bitwise_xor(tb1, shifted_tb2, diff);
|
|
bitwise_and(diff, eb1, diff);
|
|
bitwise_and(diff, shifted_eb2, diff);
|
|
int err = countNonZero(diff);
|
|
if(err < min_err) {
|
|
new_shift = test_shift;
|
|
min_err = err;
|
|
}
|
|
}
|
|
}
|
|
shift = new_shift;
|
|
}
|
|
}
|
|
|
|
void shiftMat(InputArray _src, OutputArray _dst, const Point shift)
|
|
{
|
|
Mat src = _src.getMat();
|
|
_dst.create(src.size(), src.type());
|
|
Mat dst = _dst.getMat();
|
|
|
|
Mat res = Mat::zeros(src.size(), src.type());
|
|
int width = src.cols - abs(shift.x);
|
|
int height = src.rows - abs(shift.y);
|
|
Rect dst_rect(max(shift.x, 0), max(shift.y, 0), width, height);
|
|
Rect src_rect(max(-shift.x, 0), max(-shift.y, 0), width, height);
|
|
src(src_rect).copyTo(res(dst_rect));
|
|
res.copyTo(dst);
|
|
}
|
|
|
|
int getMaxBits() const { return max_bits; }
|
|
void setMaxBits(int val) { max_bits = val; }
|
|
|
|
int getExcludeRange() const { return exclude_range; }
|
|
void setExcludeRange(int val) { exclude_range = val; }
|
|
|
|
bool getCut() const { return cut; }
|
|
void setCut(bool val) { cut = val; }
|
|
|
|
void write(FileStorage& fs) const
|
|
{
|
|
fs << "name" << name
|
|
<< "max_bits" << max_bits
|
|
<< "exclude_range" << exclude_range
|
|
<< "cut" << static_cast<int>(cut);
|
|
}
|
|
|
|
void read(const FileNode& fn)
|
|
{
|
|
FileNode n = fn["name"];
|
|
CV_Assert(n.isString() && String(n) == name);
|
|
max_bits = fn["max_bits"];
|
|
exclude_range = fn["exclude_range"];
|
|
int cut_val = fn["cut"];
|
|
cut = static_cast<bool>(cut_val);
|
|
}
|
|
|
|
void computeBitmaps(Mat& img, Mat& tb, Mat& eb)
|
|
{
|
|
int median = getMedian(img);
|
|
compare(img, median, tb, CMP_GT);
|
|
compare(abs(img - median), exclude_range, eb, CMP_GT);
|
|
}
|
|
|
|
protected:
|
|
String name;
|
|
int max_bits, exclude_range;
|
|
bool cut;
|
|
|
|
void downsample(Mat& src, Mat& dst)
|
|
{
|
|
dst = Mat(src.rows / 2, src.cols / 2, CV_8UC1);
|
|
|
|
int offset = src.cols * 2;
|
|
uchar *src_ptr = src.ptr();
|
|
uchar *dst_ptr = dst.ptr();
|
|
for(int y = 0; y < dst.rows; y ++) {
|
|
uchar *ptr = src_ptr;
|
|
for(int x = 0; x < dst.cols; x++) {
|
|
dst_ptr[0] = ptr[0];
|
|
dst_ptr++;
|
|
ptr += 2;
|
|
}
|
|
src_ptr += offset;
|
|
}
|
|
}
|
|
|
|
void buildPyr(Mat& img, std::vector<Mat>& pyr, int maxlevel)
|
|
{
|
|
pyr.resize(maxlevel + 1);
|
|
pyr[0] = img.clone();
|
|
for(int level = 0; level < maxlevel; level++) {
|
|
downsample(pyr[level], pyr[level + 1]);
|
|
}
|
|
}
|
|
|
|
int getMedian(Mat& img)
|
|
{
|
|
int channels = 0;
|
|
Mat hist;
|
|
int hist_size = LDR_SIZE;
|
|
float range[] = {0, LDR_SIZE} ;
|
|
const float* ranges[] = {range};
|
|
calcHist(&img, 1, &channels, Mat(), hist, 1, &hist_size, ranges);
|
|
float *ptr = hist.ptr<float>();
|
|
int median = 0, sum = 0;
|
|
int thresh = img.total() / 2;
|
|
while(sum < thresh && median < LDR_SIZE) {
|
|
sum += static_cast<int>(ptr[median]);
|
|
median++;
|
|
}
|
|
return median;
|
|
}
|
|
};
|
|
|
|
Ptr<AlignMTB> createAlignMTB(int max_bits, int exclude_range, bool cut)
|
|
{
|
|
return new AlignMTBImpl(max_bits, exclude_range, cut);
|
|
}
|
|
|
|
class floatIndexCmp {
|
|
public:
|
|
floatIndexCmp(std::vector<float> data) :
|
|
data(data)
|
|
{
|
|
}
|
|
|
|
bool operator() (int i,int j)
|
|
{
|
|
return data[i] < data[j];
|
|
}
|
|
protected:
|
|
std::vector<float> data;
|
|
};
|
|
|
|
class GhostbusterOrderImpl : public GhostbusterOrder
|
|
{
|
|
public:
|
|
GhostbusterOrderImpl(int underexp, int overexp) :
|
|
underexp(underexp),
|
|
overexp(overexp),
|
|
name("GhostbusterOrder")
|
|
{
|
|
}
|
|
|
|
void process(InputArrayOfArrays src, OutputArray dst, std::vector<float>& times, Mat response)
|
|
{
|
|
process(src, dst);
|
|
}
|
|
|
|
void process(InputArrayOfArrays src, OutputArray dst)
|
|
{
|
|
std::vector<Mat> unsorted_images;
|
|
src.getMatVector(unsorted_images);
|
|
checkImageDimensions(unsorted_images);
|
|
|
|
std::vector<Mat> images;
|
|
sortImages(unsorted_images, images);
|
|
|
|
int channels = images[0].channels();
|
|
dst.create(images[0].size(), CV_8U);
|
|
|
|
Mat res = Mat::zeros(images[0].size(), CV_8U);
|
|
|
|
std::vector<Mat> splitted(channels);
|
|
split(images[0], splitted);
|
|
for(size_t i = 0; i < images.size() - 1; i++) {
|
|
|
|
std::vector<Mat> next_splitted(channels);
|
|
split(images[i + 1], next_splitted);
|
|
|
|
for(int c = 0; c < channels; c++) {
|
|
Mat exposed = (splitted[c] >= underexp) & (splitted[c] <= overexp);
|
|
exposed &= (next_splitted[c] >= underexp) & (next_splitted[c] <= overexp);
|
|
Mat ghost = (splitted[c] > next_splitted[c]) & exposed;
|
|
res |= ghost;
|
|
}
|
|
splitted = next_splitted;
|
|
}
|
|
res.copyTo(dst.getMat());
|
|
}
|
|
|
|
int getUnderexp() {return underexp;}
|
|
void setUnderexp(int value) {underexp = value;}
|
|
|
|
int getOverexp() {return overexp;}
|
|
void setOverexp(int value) {overexp = value;}
|
|
|
|
void write(FileStorage& fs) const
|
|
{
|
|
fs << "name" << name
|
|
<< "overexp" << overexp
|
|
<< "underexp" << underexp;
|
|
}
|
|
|
|
void read(const FileNode& fn)
|
|
{
|
|
FileNode n = fn["name"];
|
|
CV_Assert(n.isString() && String(n) == name);
|
|
overexp = fn["overexp"];
|
|
underexp = fn["underexp"];
|
|
}
|
|
|
|
protected:
|
|
int overexp, underexp;
|
|
String name;
|
|
|
|
void sortImages(std::vector<Mat>& images, std::vector<Mat>& sorted)
|
|
{
|
|
std::vector<int>indices(images.size());
|
|
std::vector<float>means(images.size());
|
|
for(size_t i = 0; i < images.size(); i++) {
|
|
indices[i] = i;
|
|
means[i] = mean(mean(images[i]))[0];
|
|
}
|
|
sort(indices.begin(), indices.end(), floatIndexCmp(means));
|
|
sorted.resize(images.size());
|
|
for(size_t i = 0; i < images.size(); i++) {
|
|
sorted[i] = images[indices[i]];
|
|
}
|
|
}
|
|
};
|
|
|
|
Ptr<GhostbusterOrder> createGhostbusterOrder(int underexp, int overexp)
|
|
{
|
|
return new GhostbusterOrderImpl(underexp, overexp);
|
|
}
|
|
|
|
class GhostbusterPredictImpl : public GhostbusterPredict
|
|
{
|
|
public:
|
|
GhostbusterPredictImpl(int thresh, int underexp, int overexp) :
|
|
thresh(thresh),
|
|
underexp(underexp),
|
|
overexp(overexp),
|
|
name("GhostbusterPredict")
|
|
{
|
|
}
|
|
|
|
void process(InputArrayOfArrays src, OutputArray dst, std::vector<float>& times, Mat response)
|
|
{
|
|
std::vector<Mat> images;
|
|
src.getMatVector(images);
|
|
checkImageDimensions(images);
|
|
|
|
int channels = images[0].channels();
|
|
dst.create(images[0].size(), CV_8U);
|
|
|
|
Mat res = Mat::zeros(images[0].size(), CV_8U);
|
|
|
|
Mat radiance;
|
|
LUT(images[0], response, radiance);
|
|
std::vector<Mat> splitted(channels);
|
|
split(radiance, splitted);
|
|
std::vector<Mat> resp_split(channels);
|
|
split(response, resp_split);
|
|
for(size_t i = 0; i < images.size() - 1; i++) {
|
|
|
|
std::vector<Mat> next_splitted(channels);
|
|
LUT(images[i + 1], response, radiance);
|
|
split(radiance, next_splitted);
|
|
|
|
for(int c = 0; c < channels; c++) {
|
|
|
|
Mat predicted = splitted[c] / times[i] * times[i + 1];
|
|
|
|
Mat low = max(thresh, next_splitted[c]) - thresh;
|
|
Mat high = min(255 - thresh, next_splitted[c]) + thresh;
|
|
low.convertTo(low, CV_8U);
|
|
high.convertTo(high, CV_8U);
|
|
LUT(low, resp_split[c], low);
|
|
LUT(high, resp_split[c], high);
|
|
|
|
Mat exposed = (splitted[c] >= underexp) & (splitted[c] <= overexp);
|
|
exposed &= (next_splitted[c] >= underexp) & (next_splitted[c] <= overexp);
|
|
|
|
Mat ghost = (low < predicted) & (predicted < high);
|
|
ghost &= exposed;
|
|
res |= ghost;
|
|
}
|
|
splitted = next_splitted;
|
|
}
|
|
res.copyTo(dst.getMat());
|
|
}
|
|
|
|
virtual void process(InputArrayOfArrays src, OutputArray dst, std::vector<float>& times)
|
|
{
|
|
Mat response = linearResponse(3);
|
|
response.at<Vec3f>(0) = response.at<Vec3f>(1);
|
|
process(src, dst, times, response);
|
|
}
|
|
|
|
CV_WRAP virtual int getThreshold() {return thresh;}
|
|
CV_WRAP virtual void setThreshold(int value) {thresh = value;}
|
|
|
|
int getUnderexp() {return underexp;}
|
|
void setUnderexp(int value) {underexp = value;}
|
|
|
|
int getOverexp() {return overexp;}
|
|
void setOverexp(int value) {overexp = value;}
|
|
|
|
void write(FileStorage& fs) const
|
|
{
|
|
fs << "name" << name
|
|
<< "overexp" << overexp
|
|
<< "underexp" << underexp
|
|
<< "thresh" << thresh;
|
|
}
|
|
|
|
void read(const FileNode& fn)
|
|
{
|
|
FileNode n = fn["name"];
|
|
CV_Assert(n.isString() && String(n) == name);
|
|
overexp = fn["overexp"];
|
|
underexp = fn["underexp"];
|
|
thresh = fn["thresh"];
|
|
}
|
|
|
|
protected:
|
|
int thresh, underexp, overexp;
|
|
String name;
|
|
};
|
|
|
|
Ptr<GhostbusterPredict> createGhostbusterPredict(int thresh, int underexp, int overexp)
|
|
{
|
|
return new GhostbusterPredictImpl(thresh, underexp, overexp);
|
|
}
|
|
|
|
class GhostbusterBitmapImpl : public GhostbusterBitmap
|
|
{
|
|
public:
|
|
GhostbusterBitmapImpl(int exclude) :
|
|
exclude(exclude),
|
|
name("GhostbusterBitmap")
|
|
{
|
|
}
|
|
|
|
void process(InputArrayOfArrays src, OutputArray dst, std::vector<float>& times, Mat response)
|
|
{
|
|
process(src, dst);
|
|
}
|
|
|
|
void process(InputArrayOfArrays src, OutputArray dst)
|
|
{
|
|
std::vector<Mat> images;
|
|
src.getMatVector(images);
|
|
checkImageDimensions(images);
|
|
|
|
int channels = images[0].channels();
|
|
dst.create(images[0].size(), CV_8U);
|
|
|
|
Mat res = Mat::zeros(images[0].size(), CV_8U);
|
|
|
|
Ptr<AlignMTB> MTB = createAlignMTB();
|
|
MTB->setExcludeRange(exclude);
|
|
|
|
for(size_t i = 0; i < images.size(); i++) {
|
|
Mat gray;
|
|
if(channels == 1) {
|
|
gray = images[i];
|
|
} else {
|
|
cvtColor(images[i], gray, COLOR_RGB2GRAY);
|
|
}
|
|
|
|
Mat tb, eb;
|
|
MTB->computeBitmaps(gray, tb, eb);
|
|
tb &= eb & 1;
|
|
res += tb;
|
|
}
|
|
res = (res > 0) & (res < images.size());
|
|
res.copyTo(dst.getMat());
|
|
}
|
|
|
|
int getExclude() {return exclude;}
|
|
void setExclude(int value) {exclude = value;}
|
|
|
|
void write(FileStorage& fs) const
|
|
{
|
|
fs << "name" << name
|
|
<< "exclude" << exclude;
|
|
}
|
|
|
|
void read(const FileNode& fn)
|
|
{
|
|
FileNode n = fn["name"];
|
|
CV_Assert(n.isString() && String(n) == name);
|
|
exclude = fn["exclude"];
|
|
}
|
|
|
|
protected:
|
|
int exclude;
|
|
String name;
|
|
};
|
|
|
|
Ptr<GhostbusterBitmap> createGhostbusterBitmap(int exclude)
|
|
{
|
|
return new GhostbusterBitmapImpl(exclude);
|
|
}
|
|
|
|
}
|
|
|