如何提取图像

Question

的特定区域我想只计算该图像的小插曲区域，像我有图像here

我怎么可以算或迭代/只在应用暗角区域通过，离开其他地区？我只想在应用晕影的区域应用该算法，我尝试了这种方法，就像给红色的标量并提取发现红色的区域，但它不工作就像没有给出结果，因为当朝向中心时颜色变得更亮的形象。

的vignette由图像强度随以下掩码相乘变暗角落和边缘：

这是原始图像here

欲blending overlay的**only vignette part of** vignette image与original image

这里是我的代码混合覆盖

void blending_overlay(Mat& img1 , Mat& img2 , Mat& out) 
{ 
Mat result(img1.size(), CV_32FC3); 
for(int i = 0; i < img1.size().height; ++i){ 
    for(int j = 0; j < img1.size().width; ++j){ 

     for (int c=0 ; c<img1.channels();c++){ 
      float target = (float)img1.at<uchar>(i, 3*j+c)/255. ; 
      float blend = (float)img2.at<uchar>(i, 3*j+c)/255. ; 

      if(target > 0.5){ 
       result.at<float>(i, 3*j+c) = ((1 - (1-2*(target-0.5)) * (1-blend))); 

       } 
      else{ 
       result.at<float>(i, 3*j+c) = ((2*target) * blend); 
       } 
     } 
    } 
} 
result.convertTo(out,CV_8UC3,255); 
} 

int main(int argc, char** argv) 
{ 
    Mat Img1=imread("D:\\Vig.png",-1); // the vignete in the question 
    Mat Img2=imread("D:\\i.png"); // the iamge in the question 
    cv::resize(Img1,Img1,Img2.size()); 
    Img1.convertTo(Img1,CV_32FC4,1.0/255.0); 
    Img2.convertTo(Img2,CV_32FC3,1.0/255.0); 

    vector<Mat> ch; 
    split(Img1,ch); 

    Mat mask = ch[3].clone();    // here's the vignette 

    ch.resize(3); 

    Mat I1,I2,result; 

    cv::multiply(mask,ch[0],ch[0]); 
    cv::multiply(mask,ch[1],ch[1]); 
    cv::multiply(mask,ch[2],ch[2]); 
    merge(ch,I1); 
    vector<Mat> ch2(3); 
    split(Img2, ch2); 
    cv::multiply(1.0-mask,ch2[0],ch2[0]); 
    cv::multiply(1.0-mask,ch2[1],ch2[1]); 
    cv::multiply(1.0-mask,ch2[2],ch2[2]); 
    merge(ch2,I2); 
    I1.convertTo(I1,CV_8UC3,255); 
    I2.convertTo(I2,CV_8UC3,255); 
    result=I1+I2; // The image with the vignette in the question 
    result.convertTo(result,CV_8UC4,255); 
    Mat result2; 
    Mat mask2; 
    Mat image = imread ("D:\\i.png"); // image in the question 
    blending_overlay(image,result,result2,mask2); 
    imshow("Image",result2); 
    waitKey(0); 
} 

它适用于与原始图像混合小品形象，但我只想与原来的图像混合的暗角部分来自小插曲图像

Required Result

我得到的结果是this

Answer 1

你有一些错误。 首先你似乎在使用颜色混合来选择屏幕和混合混合，但你应该使用强度。我认为photoshop可能会在hsv色彩空间中进行混合，但在这种情况下，rgb似乎可以像使用L =（r + g + b）/ 3作为强度那样工作。

此外，你的代码是混合图像和小插曲和图像的alpha混合（没有你问题中的代码匹配在你的问题中生成的图像？）。相反，您需要一个与您想要应用小插图的区域中的小插图等同的“遮罩”，并且在您不希望应用它的区域中等于0.5。

所以我把你提供的图案（最左边）有一个alpha通道（左边第二个）， 做一个alpha混合灰色（右边第二个）以获得一个图像用作顶部图像混合叠加（最右边）。在顶部图像是灰色的情况下，当与其他图像混合时，底部将显示但不变。这是因为在这两行代码中：

_result[j][c] = ((1 - (1 - 2 * (target - 0.5)) * (1 - blend))); 
_result[j][c] = 2 * target * blend; 

如果blend = 0.5，则结果为设置为目标。

 Vignette    Alpha     Gray    Blend Image (top) 

我已经包含所生成的图像，以及将码做以下。所需的图像显示在左侧，生成的图像显示在右侧。据我所知，他们是一样的。 通过在中间不转换为CV_UC3，但在blend_overlay()中传递FC3参数，可以获得准确度的提高。

   Required         Generated 

#include <opencv2/core/core.hpp> 
#include <opencv2/highgui/highgui.hpp> 
#include <opencv2/imgproc/imgproc.hpp> 
#include <iostream>  // std::cout 
#include <vector>  // std::vector 
using namespace std; 
using namespace cv; 

void blending_overlay2(Mat& bot, Mat& top, Mat& out) 
{ 
    Mat result(bot.size(), CV_32FC3); 

    // Extract the calculate I = (r + g + b)/3 
    Mat botf; 
    bot.convertTo(botf, CV_32FC3, 1.0/255.0); 
    std::vector<cv::Mat> planes(3); 
    cv::split(botf, planes); 

    cv::Mat intensity_f((planes[0] + planes[1] + planes[2])/3.0f); 
    cv::Mat L; 
    intensity_f.convertTo(L, CV_8UC1, 255.0); 
    //cv::imshow("L", L); 


    for(int i = 0; i < bot.size().height; ++i) 
    { 
     // get pointers to each row 
     cv::Vec3b* _bot = bot.ptr<cv::Vec3b>(i); 
     cv::Vec3b* _top = top.ptr<cv::Vec3b>(i); 
     cv::Vec3f* _result = result.ptr<cv::Vec3f>(i); 
     uchar* _L = L.ptr<uchar>(i); 

     // now scan the row 
     for(int j = 0; j < bot.size().width; ++j) 
     { 
      for (int c=0; c < bot.channels(); c++) 
      { 
       float target = float(_bot[j][c])/255.0f; 
       float blend = float(_top[j][c])/255.0f; 

       if(_L [j] > 128) 
       { 
        _result[j][c] = 2 * (blend + target - target * blend) - 1; 
        // Why isn't the below line simplified like above? 
        //_result[j][c] = ((1 - (1 - 2 * (target - 0.5)) * (1 - blend))); 
       } 
       else 
       { 
        _result[j][c] = 2 * target * blend; 
       } 
      } 
     } 
    } 
    result.convertTo(out, CV_8UC3, 255); 
} 

int main(int argc, char** argv) 
{ 
    Mat Img1=cv::imread("kqw0D.png",-1); // the vignete in the question 

    Mat Img2=cv::imread("i.png"); // the iamge in the question 
    Mat image = Img2.clone(); 
    cv::resize(Img1,Img1,Img2.size()); 
    Img1.convertTo(Img1,CV_32FC4,1.0/255.0); 
    Img2.convertTo(Img2,CV_32FC3,1.0/255.0); 

    // split off the alpha channel from the vignette 
    vector<Mat> ch; 
    split(Img1,ch); 
    Mat alpha = ch[3].clone();    // here's the vignette 
    Mat alpha_u; 
    alpha.convertTo(alpha_u,CV_8UC1,255); 
    imshow("alpha",alpha); 

    // drop the alpha channel from vignette 
    ch.resize(3); 

    // pre-mutiply each color channel by the alpha 
    // and merge premultiplied color channels into 3 channel vignette I1 
    Mat I1; 
    cv::multiply(alpha, ch[0], ch[0]); 
    cv::multiply(alpha, ch[1], ch[1]); 
    cv::multiply(alpha, ch[2], ch[2]); 
    merge(ch, I1); 

    // Now make the vignette = 0.5 in areas where it should not be "applied" 
    Mat I2; 
    vector<Mat> ch2; 
    cv::Mat half = cv::Mat::ones(Img2.rows, Img2.cols, CV_32FC1) * 0.5; 
    cv::multiply(1.0f - alpha, half, half); 
    ch2.push_back(half); 
    ch2.push_back(half); 
    ch2.push_back(half); 
    //split(Img2, ch2); 
    //cv::multiply(1.0f - alpha, ch2[0], ch2[0]); 
    //cv::multiply(1.0f - alpha, ch2[1], ch2[1]); 
    //cv::multiply(1.0f - alpha, ch2[2], ch2[2]); 
    merge(ch2, I2); 

    // result = alpha * vignette + (1 - alpha) * gray; 
    Mat top; 
    top=I1+I2; 


    // make I1 8 bit images again 
    I1.convertTo(I1,CV_8UC3,255); 
    I2.convertTo(I2,CV_8UC3,255); 
    top.convertTo(top,CV_8UC3,255); 
    //imshow("I1",I1); 
    //imshow("I2",I2); 
    //imshow("top",top); 

    Mat result2; 
    blending_overlay2(image,top, result2); 
    imshow("Voila!", result2); 
    imwrite("voila.png", result2); 
    waitKey(0); 
}