{

bool enabled = false;

bool geometry = false;

bool vignetting = false;

bool chromaticAberration = false;

std::vector<float> gParams;

std::vector<float> vParams;

std::vector<float> caGParams;

std::vector<float> caRGParams;

std::vector<float> caBGParams;

RectilinearModel geometryModel = RectilinearModel();

RectilinearModel caGModel = RectilinearModel();

RectilinearModel caBGModel = RectilinearModel();

RectilinearModel caRGModel = RectilinearModel();

{

bool enabled;

int width;

float contrast;

float threshold;

{

bool enabled;

int distance;

float sigmaColor;

float sigmaSpace;

{

bool enabled;

float clipLimit;

int tileGridSize;

{

uniform,

gaussian,

salt

{

switch (noiseMethod)

{

case ENoiseMethod::uniform:

return "uniform";

case ENoiseMethod::gaussian:

return "gaussian";

case ENoiseMethod::salt:

return "salt";

}

throw std::invalid_argument("Invalid ENoiseMethod Enum");

{

boost::to_lower(noiseMethod);

if (noiseMethod == "uniform")

return ENoiseMethod::uniform;

if (noiseMethod == "gaussian")

return ENoiseMethod::gaussian;

if (noiseMethod == "salt")

return ENoiseMethod::salt;

throw std::invalid_argument("Unrecognized noise method '" + noiseMethod + "'");

{

bool enabled;

ENoiseMethod method;

float A;

float B;

bool mono;

{

RGBA,

RGB,

Grayscale

{

switch (imageFormat)

{

case EImageFormat::RGBA:

return "rgba";

case EImageFormat::RGB:

return "rgb";

case EImageFormat::Grayscale:

return "grayscale";

}

throw std::invalid_argument("Invalid EImageFormat Enum");

{

boost::to_lower(imageFormat);

if (imageFormat == "rgba")

return EImageFormat::RGBA;

if (imageFormat == "rgb")

return EImageFormat::RGB;

if (imageFormat == "grayscale")

return EImageFormat::Grayscale;

throw std::invalid_argument("Unrecognized image format '" + imageFormat + "'");

{

bool enabled;

float filterStrength;

float filterStrengthColor;

int templateWindowSize;

int searchWindowSize;

{

bool enabled;

bool rowDecimation;

float value;

{

const char* value = std::getenv("ALICEVISION_COLOR_PROFILE_DB");

return value ? value : "";

{

bool reconstructedViewsOnly = false;

bool keepImageFilename = false;

bool exposureCompensation = false;

bool rawAutoBright = false;

float rawExposureAdjust = 0.0;

EImageFormat outputFormat = EImageFormat::RGBA;

float scaleFactor = 1.0f;

unsigned int maxWidth = 0;

unsigned int maxHeight = 0;

float contrast = 1.0f;

int medianFilter = 0;

bool fillHoles = false;

bool fixNonFinite = false;

bool applyDcpMetadata = false;

bool useDCPColorMatrixOnly = false;

bool enableColorTempProcessing = false;

double correlatedColorTemperature = -1.0;

bool reorient = false;

LensCorrectionParams lensCorrection = {

false, // enable

false, // geometry

false, // vignetting

false // chromatic aberration

};

SharpenParams sharpen = {

false, // enable

3, // width

1.0f, // contrast

0.0f // threshold

};

BilateralFilterParams bilateralFilter = {

false, // enable

0, // distance

0.0f, // sigmaColor

0.0f // sigmaSpace

};

ClaheFilterParams claheFilter = {

false, // enable

4.0f, // clipLimit

8 // tileGridSize

};

NoiseFilterParams noise = {

false, // enable

ENoiseMethod::uniform, // method

0.0f, // A

1.0f, // B

true // mono

};

NLMeansFilterParams nlmFilter = {

false, // enable

5.0f, // filterStrength

10.0f, // filterStrengthColor

7, // templateWindowSize

21 // searchWindowSize

};

pixelAspectRatioParams par = {

false, // enable

false, // rowDecimation

1.0f // value

};

{

if (vparam.size() >= 7)

{

const float focX = vparam[0];

const float focY = vparam[1];

const float imageXCenter = vparam[2];

const float imageYCenter = vparam[3];

const float p1 = -vparam[4];

const float p2 = vparam[4] * vparam[4] - vparam[5];

const float p3 = -(vparam[4] * vparam[4] * vparam[4] - 2 * vparam[4] * vparam[5] + vparam[6]);

const float p4 =

vparam[4] * vparam[4] * vparam[4] * vparam[4] + vparam[5] * vparam[5] + 2 * vparam[4] * vparam[6] - 3 * vparam[4] * vparam[4] * vparam[5];

#pragma omp parallel for

for (int j = 0; j < img.height(); ++j)

for (int i = 0; i < img.width(); ++i)

{

const aliceVision::Vec2 p(i, j);

aliceVision::Vec2 np;

np(0) = ((p(0) / img.width()) - imageXCenter) / focX;

np(1) = ((p(1) / img.height()) - imageYCenter) / focY;

const float rsqr = np(0) * np(0) + np(1) * np(1);

const float gain = 1.f + p1 * rsqr + p2 * rsqr * rsqr + p3 * rsqr * rsqr * rsqr + p4 * rsqr * rsqr * rsqr * rsqr;

img(j, i) *= gain;

}

}

RectilinearModel& model,

aliceVision::image::Image<aliceVision::image::RGBAfColor>& img_ud,

const image::RGBAfColor fillcolor)

{

if (!model.isEmpty && model.FocalLengthX != 0.0 && model.FocalLengthY != 0.0)

{

img_ud.resize(img.width(), img.height(), true, fillcolor);

const image::Sampler2d<image::SamplerLinear> sampler;

const float maxWH = std::max(img.width(), img.height());

const float ppX = model.ImageXCenter * img.width();

const float ppY = model.ImageYCenter * img.height();

const float scaleX = model.FocalLengthX * maxWH;

const float scaleY = model.FocalLengthY * maxWH;

#pragma omp parallel for

for (int v = 0; v < img.height(); ++v)

for (int u = 0; u < img.width(); ++u)

{

// image to camera

const float x = (u - ppX) / scaleX;

const float y = (v - ppY) / scaleY;

// disto

float xd, yd;

model.distort(x, y, xd, yd);

// camera to image

const Vec2 distoPix(xd * scaleX + ppX, yd * scaleY + ppY);

// pick pixel if it is in the image domain

if (img.contains(distoPix(1), distoPix(0)))

{

img_ud(v, u) = sampler(img, distoPix(1), distoPix(0));

}

}

}

RectilinearModel& greenModel,

RectilinearModel& blueGreenModel,

RectilinearModel& redGreenModel,

aliceVision::image::Image<aliceVision::image::RGBAfColor>& img_ud,

const image::RGBAfColor fillcolor,

bool undistortGeometry = false)

{

if (!greenModel.isEmpty && greenModel.FocalLengthX != 0.0 && greenModel.FocalLengthY != 0.0)

{

img_ud.resize(img.width(), img.height(), true, fillcolor);

const image::Sampler2d<image::SamplerLinear> sampler;

const float maxWH = std::max(img.width(), img.height());

const float ppX = greenModel.ImageXCenter * img.width();

const float ppY = greenModel.ImageYCenter * img.height();

const float scaleX = greenModel.FocalLengthX * maxWH;

const float scaleY = greenModel.FocalLengthY * maxWH;

#pragma omp parallel for

for (int v = 0; v < img.height(); ++v)

for (int u = 0; u < img.width(); ++u)

{

// image to camera

const float x = (u - ppX) / scaleX;

const float y = (v - ppY) / scaleY;

// disto

float xdRed, ydRed, xdGreen, ydGreen, xdBlue, ydBlue;

if (undistortGeometry)

{

greenModel.distort(x, y, xdGreen, ydGreen);

}

else

{

xdGreen = x;

ydGreen = y;

}

redGreenModel.distort(xdGreen, ydGreen, xdRed, ydRed);

blueGreenModel.distort(xdGreen, ydGreen, xdBlue, ydBlue);

// camera to image

const Vec2 distoPixRed(xdRed * scaleX + ppX, ydRed * scaleY + ppY);

const Vec2 distoPixGreen(xdGreen * scaleX + ppX, ydGreen * scaleY + ppY);

const Vec2 distoPixBlue(xdBlue * scaleX + ppX, ydBlue * scaleY + ppY);

// pick pixel if it is in the image domain

if (img.contains(distoPixRed(1), distoPixRed(0)))

{

img_ud(v, u)[0] = sampler(img, distoPixRed(1), distoPixRed(0))[0];

}

if (img.contains(distoPixGreen(1), distoPixGreen(0)))

{

img_ud(v, u)[1] = sampler(img, distoPixGreen(1), distoPixGreen(0))[1];

}

if (img.contains(distoPixBlue(1), distoPixBlue(0)))

{

img_ud(v, u)[2] = sampler(img, distoPixBlue(1), distoPixBlue(0))[2];

}

}

}

ProcessingParams& pParams,

std::map<std::string, std::string>& imageMetadata,

std::shared_ptr<camera::IntrinsicBase> cam)

{

const unsigned int nchannels = 4;

// Fix non-finite pixels

// Note: fill holes needs to fix non-finite values first

if (pParams.fixNonFinite || pParams.fillHoles)

{

oiio::ImageBuf inBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), image.data());

int pixelsFixed = 0;

// Works inplace

oiio::ImageBufAlgo::fixNonFinite(inBuf, inBuf, oiio::ImageBufAlgo::NonFiniteFixMode::NONFINITE_BOX3, &pixelsFixed);

ALICEVISION_LOG_INFO("Fixed " << pixelsFixed << " non-finite pixels.");

}

if (pParams.lensCorrection.enabled)

{

if (pParams.lensCorrection.vignetting && !pParams.lensCorrection.vParams.empty())

{

undistortVignetting(image, pParams.lensCorrection.vParams);

}

else if (pParams.lensCorrection.vignetting && pParams.lensCorrection.vParams.empty())

{

ALICEVISION_LOG_WARNING("No distortion model available for lens vignetting correction.");

}

if (pParams.lensCorrection.chromaticAberration && !pParams.lensCorrection.caGModel.isEmpty)

{

const image::RGBAfColor FBLACK_A(.0f, .0f, .0f, 1.0f);

image::Image<image::RGBAfColor> image_ud;

undistortChromaticAberrations(

image, pParams.lensCorrection.caGModel, pParams.lensCorrection.caBGModel, pParams.lensCorrection.caRGModel, image_ud, FBLACK_A, false);

image = image_ud;

}

else if (pParams.lensCorrection.chromaticAberration && pParams.lensCorrection.caGModel.isEmpty)

{

ALICEVISION_LOG_WARNING("No distortion model available for lens chromatic aberration correction.");

}

if (pParams.lensCorrection.geometry && cam != NULL && cam->hasDistortion())

{

const image::RGBAfColor FBLACK_A(.0f, .0f, .0f, 1.0f);

image::Image<image::RGBAfColor> image_ud;

const image::Sampler2d<image::SamplerLinear> sampler;

image_ud.resize(image.width(), image.height(), true, FBLACK_A);

camera::UndistortImage(image, cam.get(), image_ud, FBLACK_A);

image = image_ud;

}

else if (pParams.lensCorrection.geometry && cam != NULL && !cam->hasDistortion())

{

ALICEVISION_LOG_WARNING("No distortion model available for lens geometry distortion correction.");

}

else if (pParams.lensCorrection.geometry && cam == NULL)

{

ALICEVISION_LOG_WARNING("No intrinsics data available for lens geometry distortion correction.");

}

}

const float sfw =

(pParams.maxWidth != 0 && pParams.maxWidth < image.width()) ? static_cast<float>(pParams.maxWidth) / static_cast<float>(image.width()) : 1.0;

const float sfh = (pParams.maxHeight != 0 && pParams.maxHeight < image.height())

? static_cast<float>(pParams.maxHeight) / static_cast<float>(image.height())

: 1.0;

const float scaleFactor = std::min(pParams.scaleFactor, std::min(sfw, sfh));

if (scaleFactor != 1.0f || pParams.par.enabled)

{

const bool parRowDecimation = pParams.par.enabled && pParams.par.rowDecimation;

const float widthRatio = scaleFactor * ((parRowDecimation || !pParams.par.enabled) ? 1.0 : pParams.par.value);

const float heightRatio = scaleFactor * (parRowDecimation ? (1.0 / pParams.par.value) : 1.0);

ALICEVISION_LOG_TRACE("widthRatio " << widthRatio);

ALICEVISION_LOG_TRACE("heightRatio " << heightRatio);

const unsigned int w = image.width();

const unsigned int h = image.height();

const unsigned int nw = static_cast<unsigned int>(floor(static_cast<float>(image.width()) * widthRatio));

const unsigned int nh = static_cast<unsigned int>(floor(static_cast<float>(image.height()) * heightRatio));

image::Image<image::RGBAfColor> rescaled(nw, nh);

const oiio::ImageSpec imageSpecResized(nw, nh, nchannels, oiio::TypeDesc::FLOAT);

const oiio::ImageSpec imageSpecOrigin(w, h, nchannels, oiio::TypeDesc::FLOAT);

const oiio::ImageBuf inBuf(imageSpecOrigin, image.data());

oiio::ImageBuf outBuf(imageSpecResized, rescaled.data());

oiio::ImageBufAlgo::resize(outBuf, inBuf);

image.swap(rescaled);

}

if ((pParams.reorient) && (imageMetadata.find("Orientation") != imageMetadata.end()))

{

oiio::ImageBuf inBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), image.data());

inBuf.set_orientation(std::stoi(imageMetadata["Orientation"]));

oiio::ImageBuf outBuf = oiio::ImageBufAlgo::reorient(inBuf);

if (outBuf.spec().get_int_attribute("orientation") != inBuf.spec().get_int_attribute("orientation"))

{

imageMetadata.at("Orientation") = std::to_string(outBuf.spec().get_int_attribute("orientation"));

image::Image<image::RGBAfColor> reoriented(outBuf.spec().width, outBuf.spec().height);

oiio::ROI exportROI = outBuf.roi();

exportROI.chbegin = 0;

exportROI.chend = nchannels;

outBuf.get_pixels(exportROI, oiio::TypeDesc::FLOAT, reoriented.data());

image.swap(reoriented);

}

}

if (pParams.contrast != 1.0f)

{

image::Image<image::RGBAfColor> filtered(image.width(), image.height());

const oiio::ImageBuf inBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), image.data());

oiio::ImageBuf outBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), filtered.data());

oiio::ImageBufAlgo::contrast_remap(outBuf, inBuf, 0.0f, 1.0f, 0.0f, 1.0f, pParams.contrast);

image.swap(filtered);

}

if (pParams.medianFilter >= 3)

{

image::Image<image::RGBAfColor> filtered(image.width(), image.height());

const oiio::ImageBuf inBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), image.data());

oiio::ImageBuf outBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), filtered.data());

oiio::ImageBufAlgo::median_filter(outBuf, inBuf, pParams.medianFilter);

image.swap(filtered);

}

if (pParams.sharpen.enabled)

{

image::Image<image::RGBAfColor> filtered(image.width(), image.height());

const oiio::ImageBuf inBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), image.data());

oiio::ImageBuf outBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), filtered.data());

oiio::ImageBufAlgo::unsharp_mask(outBuf, inBuf, "gaussian", pParams.sharpen.width, pParams.sharpen.contrast, pParams.sharpen.threshold);

image.swap(filtered);

}

if (pParams.bilateralFilter.enabled)

{

#if ALICEVISION_IS_DEFINED(ALICEVISION_HAVE_OPENCV)

// Create temporary OpenCV Mat (keep only 3 Channels) to handled Eigen data of our image

cv::Mat openCVMatIn = image::imageRGBAToCvMatBGR(image, CV_32FC3);

cv::Mat openCVMatOut(image.width(), image.height(), CV_32FC3);

cv::bilateralFilter(

openCVMatIn, openCVMatOut, pParams.bilateralFilter.distance, pParams.bilateralFilter.sigmaColor, pParams.bilateralFilter.sigmaSpace);

// Copy filtered data from openCV Mat(3 channels) to our image(keep the alpha channel unfiltered)

image::cvMatBGRToImageRGBA(openCVMatOut, image);

#else

throw std::invalid_argument("Unsupported mode! If you intended to use a bilateral filter, please add OpenCV support.");

#endif

}

// Contrast Limited Adaptive Histogram Equalization

if (pParams.claheFilter.enabled)

{

#if ALICEVISION_IS_DEFINED(ALICEVISION_HAVE_OPENCV)

// Convert alicevision::image to BGR openCV Mat

cv::Mat BGRMat = image::imageRGBAToCvMatBGR(image);

// Convert BGR format to Lab format

cv::Mat labImg;

cv::cvtColor(BGRMat, labImg, cv::COLOR_LBGR2Lab);

// Extract the L channel

cv::Mat L;

cv::extractChannel(labImg, L, 0);

// normalise L channel from [0, 100] to [0, 1]

std::for_each(L.begin<float>(), L.end<float>(), [](float& pixel) { pixel /= 100.0; });

// Convert float image to 16bit

L.convertTo(L, CV_16U, 65535.0);

// apply Clahe algorithm to the L channel

{

const cv::Ptr<cv::CLAHE> clahe =

cv::createCLAHE(pParams.claheFilter.clipLimit, cv::Size(pParams.claheFilter.tileGridSize, pParams.claheFilter.tileGridSize));

clahe->apply(L, L);

}

// Convert 16bit image to float

L.convertTo(L, CV_32F, 1.0 / 65535.0);

// normalise back L channel from [0, 1] to [0, 100]

std::for_each(L.begin<float>(), L.end<float>(), [](float& pixel) { pixel *= 100.0; });

// Merge back Lab colors channels

cv::insertChannel(L, labImg, 0);

// Convert Lab format to BGR format

cv::cvtColor(labImg, BGRMat, cv::COLOR_Lab2LBGR);

// Copy filtered data from openCV Mat to our alicevision image(keep the alpha channel unfiltered)

image::cvMatBGRToImageRGBA(BGRMat, image);

#else

throw std::invalid_argument("Unsupported mode! If you intended to use a Clahe filter, please add OpenCV support.");

#endif

}

if (pParams.fillHoles)

{

image::Image<image::RGBAfColor> filtered(image.width(), image.height());

oiio::ImageBuf inBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), image.data());

oiio::ImageBuf outBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), filtered.data());

// Premult necessary to ensure that the fill holes works as expected

oiio::ImageBufAlgo::premult(inBuf, inBuf);

oiio::ImageBufAlgo::fillholes_pushpull(outBuf, inBuf);

image.swap(filtered);

}

if (pParams.noise.enabled)

{

oiio::ImageBuf inBuf(oiio::ImageSpec(image.width(), image.height(), nchannels, oiio::TypeDesc::FLOAT), image.data());

oiio::ImageBufAlgo::noise(inBuf, ENoiseMethod_enumToString(pParams.noise.method), pParams.noise.A, pParams.noise.B, pParams.noise.mono);

}

if (pParams.nlmFilter.enabled)

{

#if ALICEVISION_IS_DEFINED(ALICEVISION_HAVE_OPENCV)

// Create temporary OpenCV Mat (keep only 3 channels) to handle Eigen data of our image

cv::Mat openCVMatIn = image::imageRGBAToCvMatBGR(image, CV_8UC3);

cv::Mat openCVMatOut(image.width(), image.height(), CV_8UC3);

cv::fastNlMeansDenoisingColored(openCVMatIn,

openCVMatOut,

pParams.nlmFilter.filterStrength,

pParams.nlmFilter.filterStrengthColor,

pParams.nlmFilter.templateWindowSize,

pParams.nlmFilter.searchWindowSize);

// Copy filtered data from OpenCV Mat(3 channels) to our image (keep the alpha channel unfiltered)

image::cvMatBGRToImageRGBA(openCVMatOut, image);

#else

throw std::invalid_argument("Unsupported mode! If you intended to use a non-local means filter, please add OpenCV support.");

#endif

}

if (pParams.applyDcpMetadata || (pParams.enableColorTempProcessing && pParams.correlatedColorTemperature <= 0.0))

{

bool dcpMetadataOK = map_has_non_empty_value(imageMetadata, "AliceVision:DCP:Temp1") &&

map_has_non_empty_value(imageMetadata, "AliceVision:DCP:Temp2") &&

map_has_non_empty_value(imageMetadata, "AliceVision:DCP:ForwardMatrixNumber") &&

map_has_non_empty_value(imageMetadata, "AliceVision:DCP:ColorMatrixNumber");

int colorMatrixNb;

int fwdMatrixNb;

if (dcpMetadataOK)

{

colorMatrixNb = std::stoi(imageMetadata.at("AliceVision:DCP:ColorMatrixNumber"));

fwdMatrixNb = std::stoi(imageMetadata.at("AliceVision:DCP:ForwardMatrixNumber"));

ALICEVISION_LOG_INFO("Matrix Number : " << colorMatrixNb << " ; " << fwdMatrixNb);

dcpMetadataOK = !((colorMatrixNb == 0) || ((colorMatrixNb > 0) && !map_has_non_empty_value(imageMetadata, "AliceVision:DCP:ColorMat1")) ||

((colorMatrixNb > 1) && !map_has_non_empty_value(imageMetadata, "AliceVision:DCP:ColorMat2")) ||

((fwdMatrixNb > 0) && !map_has_non_empty_value(imageMetadata, "AliceVision:DCP:ForwardMat1")) ||

((fwdMatrixNb > 1) && !map_has_non_empty_value(imageMetadata, "AliceVision:DCP:ForwardMat2")));

}

if (!dcpMetadataOK)

{

ALICEVISION_THROW_ERROR("Image Processing: All required DCP metadata cannot be found.\n" << imageMetadata);

}

image::DCPProfile dcpProf;

dcpProf.info.temperature_1 = std::stof(imageMetadata.at("AliceVision:DCP:Temp1"));

dcpProf.info.temperature_2 = std::stof(imageMetadata.at("AliceVision:DCP:Temp2"));

dcpProf.info.has_color_matrix_1 = colorMatrixNb > 0;

dcpProf.info.has_color_matrix_2 = colorMatrixNb > 1;

dcpProf.info.has_forward_matrix_1 = fwdMatrixNb > 0;

dcpProf.info.has_forward_matrix_2 = fwdMatrixNb > 1;

std::vector<std::string> v_str;

v_str.push_back(imageMetadata.at("AliceVision:DCP:ColorMat1"));

if (colorMatrixNb > 1)

{

v_str.push_back(imageMetadata.at("AliceVision:DCP:ColorMat2"));

}

dcpProf.setMatricesFromStrings("color", v_str);

v_str.clear();

if (fwdMatrixNb > 0)

{

v_str.push_back(imageMetadata.at("AliceVision:DCP:ForwardMat1"));

if (fwdMatrixNb > 1)

{

v_str.push_back(imageMetadata.at("AliceVision:DCP:ForwardMat2"));

}

dcpProf.setMatricesFromStrings("forward", v_str);

}

std::string cam_mul =

map_has_non_empty_value(imageMetadata, "raw:cam_mul") ? imageMetadata.at("raw:cam_mul") : imageMetadata.at("AliceVision:raw:cam_mul");

std::vector<float> v_mult;

size_t last = 0;

size_t next = 1;

while ((next = cam_mul.find(",", last)) != std::string::npos)

{

v_mult.push_back(std::stof(cam_mul.substr(last, next - last)));

last = next + 1;

}

v_mult.push_back(std::stof(cam_mul.substr(last, cam_mul.find("}", last) - last)));

image::DCPProfile::Triple neutral;

for (int i = 0; i < 3; i++)

{

neutral[i] = v_mult[i] / v_mult[1];

}

double cct = pParams.correlatedColorTemperature;

double tint;

if (pParams.enableColorTempProcessing)

{

dcpProf.getColorTemperatureAndTintFromNeutral(neutral, cct, tint);

}

if (pParams.applyDcpMetadata)

{

dcpProf.applyLinear(image, neutral, cct, true, pParams.useDCPColorMatrixOnly);

}

imageMetadata["AliceVision:ColorTemperature"] = std::to_string(cct);

}

else if (pParams.enableColorTempProcessing && pParams.correlatedColorTemperature > 0.0)

{

imageMetadata["AliceVision:ColorTemperature"] = std::to_string(pParams.correlatedColorTemperature);

}

const std::string& inputPath,

const std::string& outputPath,

std::map<std::string, std::string> inputMetadata,

const std::vector<std::string>& metadataFolders,

const EImageFormat outputFormat,

const image::ImageWriteOptions options)

{

// Read metadata path

std::string metadataFilePath;

const std::string filename = fs::path(inputPath).filename().string();

const std::string outExtension = boost::to_lower_copy(fs::path(outputPath).extension().string());

const bool isEXR = (outExtension == ".exr");

oiio::ParamValueList metadata;

if (!inputMetadata.empty()) // If metadata are provided as input

{

// metadata name in "raw" domain must be updated otherwise values are discarded by oiio when writing exr format

// we want to propagate them so we replace the domain "raw" with "AliceVision:raw"

for (const auto& meta : inputMetadata)

{

if (meta.first.compare(0, 3, "raw") == 0)

{

metadata.add_or_replace(oiio::ParamValue("AliceVision:" + meta.first, meta.second));

}

else

{

metadata.add_or_replace(oiio::ParamValue(meta.first, meta.second));

}

}

}

else if (!metadataFolders.empty()) // If metadataFolders is specified

{

// The file must match the file name and extension to be used as a metadata replacement.

const std::vector<std::string> metadataFilePaths =

utils::getFilesPathsFromFolders(metadataFolders, [&filename](const fs::path& path) { return path.filename().string() == filename; });

if (metadataFilePaths.size() > 1)

{

ALICEVISION_LOG_ERROR("Ambiguous case: Multiple path corresponding to this file was found for metadata replacement.");

throw std::invalid_argument("Ambiguous case: Multiple path corresponding to this file was found for metadata replacement");

}

if (metadataFilePaths.empty())

{

ALICEVISION_LOG_WARNING("Metadata folders was specified but there is no matching for this image: "

<< filename << ". The default metadata will be used instead for this image.");

metadataFilePath = inputPath;

}

else

{

ALICEVISION_LOG_TRACE("Metadata path found for the current image: " << filename);

metadataFilePath = metadataFilePaths[0];

}

metadata = image::readImageMetadata(metadataFilePath);

}

else

{

// Metadata are extracted from the original images

metadata = image::readImageMetadata(inputPath);

}

// Save image

ALICEVISION_LOG_TRACE("Export image: '" << outputPath << "'.");

if (outputFormat == EImageFormat::Grayscale)

{

image::Image<float> outputImage;

image::ConvertPixelType(image, &outputImage);

image::writeImage(outputPath, outputImage, options, metadata);

}

else if (outputFormat == EImageFormat::RGB)

{

image::Image<image::RGBfColor> outputImage;

image::ConvertPixelType(image, &outputImage);

image::writeImage(outputPath, outputImage, options, metadata);

}

else

{

// Already in RGBAf

image::writeImage(outputPath, image, options, metadata);

}

{

std::string inputExpression;

std::vector<std::string> inputFolders;

std::vector<std::string> metadataFolders;