static Cell_handle findBestCell(const Vector_3 &direction,
const Vertex_handle &infinity,
const Cell_handle &startingCell)
{
DEBUG_START;
/* FIXME: Maybe some hint will be useful here */
ASSERT(startingCell->has_vertex(infinity) && "Wrong input");
Cell_handle bestCell = startingCell;
Cell_handle nextCell = bestCell;
double maxProduct = calculateProduct(direction, bestCell, infinity);
unsigned numIterations = 0;
do
{
++numIterations;
bestCell = nextCell;
ASSERT(bestCell->has_vertex(infinity) && "Wrong iteration");
int infinityIndex = bestCell->index(infinity);
for (int i = 0; i < NUM_CELL_VERTICES; ++i)
{
if (i == infinityIndex)
continue;
Cell_handle neighbor = bestCell->neighbor(i);
double product = calculateProduct(direction,
neighbor, infinity);
if (product > maxProduct)
{
nextCell = neighbor;
maxProduct = product;
}
}
} while (nextCell != bestCell);
ASSERT(bestCell->has_vertex(infinity) && "Wrong result");
DEBUG_END;
return bestCell;
}
void process(InputArray _src, OutputArray _dst)
{
Mat src = _src.getMat();
CV_Assert(!src.empty());
_dst.create(src.size(), CV_32FC3);
Mat img = _dst.getMat();
Ptr<Tonemap> linear = createTonemap(1.0f);
linear->process(src, img);
Mat gray_img;
cvtColor(img, gray_img, COLOR_RGB2GRAY);
Mat log_img;
log(gray_img, log_img);
std::vector<Mat> x_contrast, y_contrast;
getContrast(log_img, x_contrast, y_contrast);
for(size_t i = 0; i < x_contrast.size(); i++) {
mapContrast(x_contrast[i]);
mapContrast(y_contrast[i]);
}
Mat right(src.size(), CV_32F);
calculateSum(x_contrast, y_contrast, right);
Mat p, r, product, x = log_img;
calculateProduct(x, r);
r = right - r;
r.copyTo(p);
const float target_error = 1e-3f;
float target_norm = static_cast<float>(right.dot(right)) * powf(target_error, 2.0f);
int max_iterations = 100;
float rr = static_cast<float>(r.dot(r));
for(int i = 0; i < max_iterations; i++)
{
calculateProduct(p, product);
float alpha = rr / static_cast<float>(p.dot(product));
r -= alpha * product;
x += alpha * p;
float new_rr = static_cast<float>(r.dot(r));
p = r + (new_rr / rr) * p;
rr = new_rr;
if(rr < target_norm) {
break;
}
}
exp(x, x);
mapLuminance(img, img, gray_img, x, saturation);
linear = createTonemap(gamma);
linear->process(img, img);
}
double DualPolyhedron_3::calculateFunctional() const
{
DEBUG_START;
double functional = 0;
unsigned iItem = 0;
for (const SupportItem &item : items)
{
std::vector<double> products;
for (const Cell_handle &cell : item.associations)
{
double product = calculateProduct(item.direction, cell,
infinite_vertex());
products.push_back(product);
}
double productMin = products[0];
double productMax = products[0];
for (double product : products)
{
productMin = std::min(productMin, product);
productMax = std::max(productMax, product);
}
double error = productMax - productMin;
#ifndef NDEBUG
std::cout << "Item #" << iItem << std::endl;
std::cout << std::setprecision(16);
std::cout << " Product minimal: " << productMin << std::endl;
std::cout << " Product maximal: " << productMax << std::endl;
std::cout << " Error: " << error << std::endl;
#endif
ASSERT(error < EPS_PRODUCT_TOLERANCE && "Bad structure");
double difference = productMax - item.value;
functional += difference * difference;
++iItem;
}
DEBUG_END;
return functional;
}