ORB、SIFT、SURF、手动配准VS程序以及配准后图像融合方法

忘是亡心i 2022-01-17 03:57 349阅读 0赞 
  1. #include<opencv2\highgui\highgui.hpp>
  2. #include "opencv2/nonfree/nonfree.hpp"    
  3. #include "opencv2/legacy/legacy.hpp"   
  4. #include <iostream>  
  6. using namespace cv;
  7. using namespace std;
  9. #if SURF
  10. //SURF
  11. int main()
  12. {
  14.     Mat image01 = imread("0007.jpg", 1);
  15.     Mat image02 = imread("A07.jpg", 1);
  16.     imshow("p2", image01);
  17.     imshow("p1", image02);
  19.     //灰度图转换  
  20.     Mat image1, image2;
  21.     cvtColor(image01, image1, CV_RGB2GRAY);
  22.     cvtColor(image02, image2, CV_RGB2GRAY);
  25.     //提取特征点    
  26.     SurfFeatureDetector surfDetector(2000);  // 海塞矩阵阈值，在这里调整精度，值越大点越少，越精准 
  27.     vector<KeyPoint> keyPoint1, keyPoint2;
  28.     surfDetector.detect(image1, keyPoint1);
  29.     surfDetector.detect(image2, keyPoint2);
  31.     //特征点描述，为下边的特征点匹配做准备    
  32.     SurfDescriptorExtractor SurfDescriptor;
  33.     Mat imageDesc1, imageDesc2;
  34.     SurfDescriptor.compute(image1, keyPoint1, imageDesc1);
  35.     SurfDescriptor.compute(image2, keyPoint2, imageDesc2);
  37.     FlannBasedMatcher matcher;
  38.     vector<vector<DMatch> > matchePoints;
  39.     vector<DMatch> GoodMatchePoints;
  41.     vector<Mat> train_desc(1, imageDesc1);
  42.     matcher.add(train_desc);
  43.     matcher.train();
  45.     matcher.knnMatch(imageDesc2, matchePoints, 2);
  46.     cout << "total match points: " << matchePoints.size() << endl;
  48.     // Lowe's algorithm,获取优秀匹配点
  49.     for (int i = 0; i < matchePoints.size(); i++)
  50.     {
  51.         if (matchePoints[i][0].distance < 0.9 * matchePoints[i][1].distance)
  52.         {
  53.             GoodMatchePoints.push_back(matchePoints[i][0]);
  54.         }
  55.     }
  57.     Mat first_match;
  58.     drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
  59.     imshow("first_match ", first_match);
  60.     waitKey();
  61.     return 0;
  62. }
  63. #elif 0
  64. //sift
  65. int main()
  66. {
  68.     Mat image01 = imread("0366.jpg", 1);
  69.     Mat image02 = imread("img441.png", 1);
  70.     imshow("p2", image01);
  71.     imshow("p1", image02);
  73.     //灰度图转换  
  74.     Mat image1, image2;
  75.     cvtColor(image01, image1, CV_RGB2GRAY);
  76.     cvtColor(image02, image2, CV_RGB2GRAY);
  79.     //提取特征点    
  80.     SiftFeatureDetector siftDetector(800);  // 海塞矩阵阈值，在这里调整精度，值越大点越少，越精准 
  81.     vector<KeyPoint> keyPoint1, keyPoint2;
  82.     siftDetector.detect(image1, keyPoint1);
  83.     siftDetector.detect(image2, keyPoint2);
  85.     //特征点描述，为下边的特征点匹配做准备    
  86.     SiftDescriptorExtractor SiftDescriptor;
  87.     Mat imageDesc1, imageDesc2;
  88.     SiftDescriptor.compute(image1, keyPoint1, imageDesc1);
  89.     SiftDescriptor.compute(image2, keyPoint2, imageDesc2);
  91.     FlannBasedMatcher matcher;
  92.     vector<vector<DMatch> > matchePoints;
  93.     vector<DMatch> GoodMatchePoints;
  95.     vector<Mat> train_desc(1, imageDesc1);
  96.     matcher.add(train_desc);
  97.     matcher.train();
  99.     matcher.knnMatch(imageDesc2, matchePoints, 2);
  100.     cout << "total match points: " << matchePoints.size() << endl;
  102.     // Lowe's algorithm,获取优秀匹配点
  103.     for (int i = 0; i < matchePoints.size(); i++)
  104.     {
  105.         if (matchePoints[i][0].distance < 0.6 * matchePoints[i][1].distance)
  106.         {
  107.             GoodMatchePoints.push_back(matchePoints[i][0]);
  108.         }
  109.     }
  111.     Mat first_match;
  112.     drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
  113.     imshow("first_match ", first_match);
  114.     imwrite("first_match.jpg", first_match);
  115.     waitKey();
  116.     return 0;
  117. }
  118. #elif 0
  119. //ORB
  120. int main()
  121. {
  123.     Mat image01 = imread("0366.jpg", 1);
  124.     Mat image02 = imread("img441.png", 1);
  125.     imshow("p2", image01);
  126.     imshow("p1", image02);
  128.     //灰度图转换  
  129.     Mat image1, image2;
  130.     cvtColor(image01, image1, CV_RGB2GRAY);
  131.     cvtColor(image02, image2, CV_RGB2GRAY);
  134.     //提取特征点    
  135.     OrbFeatureDetector OrbDetector(1000);  // 在这里调整精度，值越小点越少，越精准 
  136.     vector<KeyPoint> keyPoint1, keyPoint2;
  137.     OrbDetector.detect(image1, keyPoint1);
  138.     OrbDetector.detect(image2, keyPoint2);
  140.     //特征点描述，为下边的特征点匹配做准备    
  141.     OrbDescriptorExtractor OrbDescriptor;
  142.     Mat imageDesc1, imageDesc2;
  143.     OrbDescriptor.compute(image1, keyPoint1, imageDesc1);
  144.     OrbDescriptor.compute(image2, keyPoint2, imageDesc2);
  146.     flann::Index flannIndex(imageDesc1, flann::LshIndexParams(12, 20, 2), cvflann::FLANN_DIST_HAMMING);
  148.     vector<DMatch> GoodMatchePoints;
  150.     Mat macthIndex(imageDesc2.rows, 2, CV_32SC1), matchDistance(imageDesc2.rows, 2, CV_32FC1);
  151.     flannIndex.knnSearch(imageDesc2, macthIndex, matchDistance, 2, flann::SearchParams());
  153.     // Lowe's algorithm,获取优秀匹配点
  154.     for (int i = 0; i < matchDistance.rows; i++)
  155.     {
  156.         if (matchDistance.at<float>(i,0) < 0.6 * matchDistance.at<float>(i, 1))
  157.         {
  158.             DMatch dmatches(i, macthIndex.at<int>(i, 0), matchDistance.at<float>(i, 0));
  159.             GoodMatchePoints.push_back(dmatches);
  160.         }
  161.     }
  163.     Mat first_match;
  164.     drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
  165.     imshow("first_match ", first_match);
  166.     imwrite("first_match.jpg", first_match);
  167.     waitKey();
  168.     return 0;
  169. }
  170. #elif 1
  171. //手工标注配准
  172. vector<Point2f> imagePoints1, imagePoints2;
  173. Mat ref_win, src_win;
  174. int pcount = 0;
  176. //Mat二进制文件写
  177. bool matWrite(string filename, Mat &M){
  178.     Mat M_copy;
  179.     M.copyTo(M_copy);
  180.     FILE* file = fopen(filename.c_str(), "wb");
  181.     if (file == NULL || M.empty())
  182.         return false;
  183.     fwrite("CmMat", sizeof(char), 5, file);
  184.     int headData[3] = { M_copy.cols, M_copy.rows, M_copy.type() };
  185.     fwrite(headData, sizeof(int), 3, file);
  186.     fwrite(M.data, sizeof(char), M.step * M.rows, file);
  187.     fclose(file);
  188.     return true;
  189. }
  190. //Mat二进制文件读
  192. bool matRead(const string& filename, Mat& M){
  193.     //Mat M_copy;
  194.     FILE* f = fopen(filename.c_str(), "rb");
  195.     if (f == NULL)
  196.         return false;
  197.     char buf[8];
  198.     int pre = fread(buf, sizeof(char), 5, f);
  199.     if (strncmp(buf, "CmMat", 5) != 0)    {
  200.         printf("Invalidate CvMat data file %s\n", filename.c_str());
  201.         return false;
  202.     }
  203.     int headData[3]; // Width, height, type
  204.     fread(headData, sizeof(int), 3, f);
  205.     Mat M_copy(headData[1], headData[0], headData[2]);
  206.     fread(M.data, sizeof(char), M.step * M.rows, f);
  207.     fclose(f);
  208.     M_copy.copyTo(M);
  209.     return true;
  210. }
  213. void on_mouse1(int event, int x, int y, int flags, void *ustc) 
  214. {
  215.     if (event == CV_EVENT_LBUTTONDOWN)
  216.     {
  217.         Point  p = Point(x, y);
  218.         circle(ref_win, p, 1, Scalar(0, 0, 255), -1);
  219.         imshow("底图", ref_win);
  220.         imagePoints1.push_back(p);   
  221.         cout << "底图: " << p << endl;
  222.         pcount++;
  223.         cout << "ponit num:" << pcount << endl;
  224.     }
  225. }
  227. void on_mouse2(int event, int x, int y, int flags, void *ustc) 
  228. {
  229.     if (event == CV_EVENT_LBUTTONDOWN)
  230.     {
  231.         Point  p = Point(x, y);
  232.         circle(src_win, p, 1, Scalar(0, 0, 255), -1);
  233.         imshow("待配准图", src_win);
  234.         imagePoints2.push_back(p);   
  235.         cout << "待配准图: " << p << endl;
  236.     }
  237. }
  239. int main()
  240. {
  241.     Mat ref = imread("A0001.jpg");  
  242.     Mat src = imread("Bimg1.png"); 
  244.     ref_win = ref.clone();
  245.     src_win = src.clone();
  247.     namedWindow("待配准图");
  248.     namedWindow("底图");
  249.     imshow("待配准图", src_win);
  250.     imshow("底图", ref_win);
  251.     setMouseCallback("待配准图", on_mouse2);
  252.     setMouseCallback("底图", on_mouse1);
  254.     waitKey();
  255.     string str;
  256.     printf("next？\n");
  257.     cin >> str;
  260.     //compute the mertix
  261.     Mat homo = findHomography(imagePoints2, imagePoints1, CV_RANSAC);
  262.     //matWrite("1JuZhen", homo);
  263.     //Mat homo1;
  264.     //matRead("1JuZhen", homo1);
  266.     Mat imageTransform1;
  267.     warpPerspective(src, imageTransform1, homo, Size(ref.cols, ref.rows));   //变换
  268.     imshow("transform", imageTransform1);
  269.     //imshow("基准图打点", ref_win);
  270.     //imshow("待配准图打点", src_win);
  271.     imshow("transform result", imageTransform1);
  273.     imwrite("result.jpg", imageTransform1);
  274.     //imwrite("src_p.jpg", src_win);
  275.     //imwrite("ref_p.jpg", ref_win);
  277.     waitKey();
  278.     return 0;
  279. }
  280. #else
  281. void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);
  283. typedef struct
  284. {
  285.     Point2f left_top;
  286.     Point2f left_bottom;
  287.     Point2f right_top;
  288.     Point2f right_bottom;
  289. }four_corners_t;
  291. four_corners_t corners;
  293. void CalcCorners(const Mat& H, const Mat& src)
  294. {
  295.     double v2[] = { 0, 0, 1 };//左上角
  296.     double v1[3];//变换后的坐标值
  297.     Mat V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  298.     Mat V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  300.     V1 = H * V2;
  301.     //左上角(0,0,1)
  302.     cout << "V2: " << V2 << endl;
  303.     cout << "V1: " << V1 << endl;
  304.     corners.left_top.x = v1[0] / v1[2];
  305.     corners.left_top.y = v1[1] / v1[2];
  307.     //左下角(0,src.rows,1)
  308.     v2[0] = 0;
  309.     v2[1] = src.rows;
  310.     v2[2] = 1;
  311.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  312.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  313.     V1 = H * V2;
  314.     corners.left_bottom.x = v1[0] / v1[2];
  315.     corners.left_bottom.y = v1[1] / v1[2];
  317.     //右上角(src.cols,0,1)
  318.     v2[0] = src.cols;
  319.     v2[1] = 0;
  320.     v2[2] = 1;
  321.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  322.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  323.     V1 = H * V2;
  324.     corners.right_top.x = v1[0] / v1[2];
  325.     corners.right_top.y = v1[1] / v1[2];
  327.     //右下角(src.cols,src.rows,1)
  328.     v2[0] = src.cols;
  329.     v2[1] = src.rows;
  330.     v2[2] = 1;
  331.     V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
  332.     V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
  333.     V1 = H * V2;
  334.     corners.right_bottom.x = v1[0] / v1[2];
  335.     corners.right_bottom.y = v1[1] / v1[2];
  337. }
  339. int main(int argc, char *argv[])
  340. {
  341.     Mat image01 = imread("img1.png", 1);    //右图
  342.     Mat image02 = imread("img2.png", 1);    //左图
  343.     imshow("p2", image01);
  344.     imshow("p1", image02);
  346.     //灰度图转换  
  347.     Mat image1, image2;
  348.     cvtColor(image01, image1, CV_RGB2GRAY);
  349.     cvtColor(image02, image2, CV_RGB2GRAY);
  352.     //提取特征点    
  353.     OrbFeatureDetector  surfDetector(3000);
  354.     vector<KeyPoint> keyPoint1, keyPoint2;
  355.     surfDetector.detect(image1, keyPoint1);
  356.     surfDetector.detect(image2, keyPoint2);
  358.     //特征点描述，为下边的特征点匹配做准备    
  359.     OrbDescriptorExtractor  SurfDescriptor;
  360.     Mat imageDesc1, imageDesc2;
  361.     SurfDescriptor.compute(image1, keyPoint1, imageDesc1);
  362.     SurfDescriptor.compute(image2, keyPoint2, imageDesc2);
  364.     flann::Index flannIndex(imageDesc1, flann::LshIndexParams(12, 20, 2), cvflann::FLANN_DIST_HAMMING);
  366.     vector<DMatch> GoodMatchePoints;
  368.     Mat macthIndex(imageDesc2.rows, 2, CV_32SC1), matchDistance(imageDesc2.rows, 2, CV_32FC1);
  369.     flannIndex.knnSearch(imageDesc2, macthIndex, matchDistance, 2, flann::SearchParams());
  371.     // Lowe's algorithm,获取优秀匹配点
  372.     for (int i = 0; i < matchDistance.rows; i++)
  373.     {
  374.         if (matchDistance.at<float>(i, 0) < 0.4 * matchDistance.at<float>(i, 1))
  375.         {
  376.             DMatch dmatches(i, macthIndex.at<int>(i, 0), matchDistance.at<float>(i, 0));
  377.             GoodMatchePoints.push_back(dmatches);
  378.         }
  379.     }
  381.     Mat first_match;
  382.     drawMatches(image02, keyPoint2, image01, keyPoint1, GoodMatchePoints, first_match);
  383.     imshow("first_match ", first_match);
  385.     vector<Point2f> imagePoints1, imagePoints2;
  387.     for (int i = 0; i<GoodMatchePoints.size(); i++)
  388.     {
  389.         imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].queryIdx].pt);
  390.         imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].trainIdx].pt);
  391.     }
  395.     //获取图像1到图像2的投影映射矩阵 尺寸为3*3  
  396.     Mat homo = findHomography(imagePoints1, imagePoints2, CV_RANSAC);
  397.     也可以使用getPerspectiveTransform方法获得透视变换矩阵，不过要求只能有4个点，效果稍差  
  398.     //Mat   homo=getPerspectiveTransform(imagePoints1,imagePoints2);  
  399.     cout << "变换矩阵为：\n" << homo << endl << endl; //输出映射矩阵      
  401.     //计算配准图的四个顶点坐标
  402.     CalcCorners(homo, image01);
  403.     cout << "left_top:" << corners.left_top << endl;
  404.     cout << "left_bottom:" << corners.left_bottom << endl;
  405.     cout << "right_top:" << corners.right_top << endl;
  406.     cout << "right_bottom:" << corners.right_bottom << endl;
  408.     //图像配准  
  409.     Mat imageTransform1, imageTransform2;
  410.     warpPerspective(image01, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image02.rows));
  411.     //warpPerspective(image01, imageTransform2, adjustMat*homo, Size(image02.cols*1.3, image02.rows*1.8));
  412.     imshow("直接经过透视矩阵变换", imageTransform1);
  413.     imwrite("trans1.jpg", imageTransform1);
  415.     waitKey();
  417.     return 0;
  418. }
  419. #endif

关于图像融合：可以使用MATLAB中的waveanalyzer工具箱进行小波分解融合，也可以使用使用如下程序进行融合，不过程序里面我采用的是高频和低频取平均融合的方法-.-

  1. %合成两幅图像:将图像girl.bmp融合到图像scene.png上
  2. clear
  3. %读入第一个图像Girl.bmp
  4. filename1='girl.bmp';
  5. info=imfinfo(filename1);                %取一张图片的具体信息
  6. width1=info.Width;
  7. height1=info.Height;
  8. if strcmp(info.ColorType,'grayscale')==1
  9.     [A,MAP]=gray2ind(imread(filename1));%将灰度图变为索引图
  10.     RGB1=ind2rgb(A,MAP);                %将索引图变为真彩色图
  11. end
  12. if strcmp(info.ColorType,'indexed')==1
  13.     [A,MAP]=imread(filename1);
  14.     RGB1=ind2rgb(A,MAP);                %将索引图变为真彩色图
  15. end    
  16. if strcmp(info.ColorType,'truecolor')==1
  17.     RGB1=imread(filename1);
  18. end
  19. figure,imshow(RGB1);
  21. %读入第二个图像Scene.png
  22. filename2='scene.png';      
  23. info=imfinfo(filename2);                %取一张图片的具体信息
  24. width2=info.Width;
  25. height2=info.Height;
  26. if strcmp(info.ColorType,'grayscale')==1
  27.     [A,MAP]=gray2ind(imread(filename2));%将灰度图变为索引图
  28.     RGB2=ind2rgb(A,MAP);                %将索引图变为真彩色图
  29. end
  30. if strcmp(info.ColorType,'indexed')==1
  31.     [A,MAP]=imread(filename2);
  32.     RGB2=ind2rgb(A,MAP);                %将索引图变为真彩色图
  33. end    
  34. if strcmp(info.ColorType,'truecolor')==1
  35.     RGB2=imread(filename2);
  36. end
  37. figure,imshow(RGB2);
  38. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  39. %种子填充，得到参考图像
  40. BW=~im2bw(RGB1);                        %图像二值化后取反
  41. figure;imshow(BW);
  42. %选择二值化图像左上角、右上角为种子起始点，连通模板选择4邻域的,将人物外轮廓以外
  43. %的像素设置为1得B，然后用BW减去B,即可。
  44. B=imfill(imfill(BW,[1,1],4),[1,width1],4);
  45. figure;imshow(B);
  46. B=~xor(BW,B);                        %经过异或取反（）得到了人物轮廓参考图像B
  47. figure;imshow(B);
  48. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  49. %尝试边缘检测，然后再imfill填充hole的尝试，不过，效果不好没
  50. %有成功，后来知道是外轮廓底端不封闭的缘故
  51. BW2=im2bw(RGB1); 
  52. figure,imshow(BW2);
  53. [m n]=size(BW2);
  54. imgn=zeros(m,n);        %边界标记图像
  55. ed=[-1 -1;0 -1;1 -1;1 0;1 1;0 1;-1 1;-1 0]; %从左上角像素，逆时针搜索
  56. for i=2:m-1
  57.     for j=2:n-1
  58.         if BW2(i,j)==1 && imgn(i,j)==0      %当前是没标记的白色像素
  59.             if sum(sum(BW2(i-1:i+1,j-1:j+1)))~=9    %块内部的白像素不标记
  60.                 ii=i;         %像素块内部搜寻使用的坐标
  61.                 jj=j;
  62.                 imgn(i,j)=1;    %本像素块第一个标记的边界，第一个边界像素为2
  64.                 while imgn(ii,jj)~=1    %是否沿着像素块搜寻一圈了。
  65.                     for k=1:8           %逆时针八邻域搜索
  66.                         tmpi=ii+ed(k,1);        %八邻域临时坐标
  67.                         tmpj=jj+ed(k,2);
  68.                         %搜索到新边界，并且没有搜索一圈
  69.                         if BW2(tmpi,tmpj)==1 && imgn(tmpi,tmpj)~=1  
  70.                            ii=tmpi;        %更新内部搜寻坐标，继续搜索
  71.                            jj=tmpj;
  72.                            imgn(ii,jj)=1;%边界标记图像该像素标记，普通边界为1
  73.                             break;
  74.                         end
  75.                     end
  76.                 end
  78.             end
  79.         end
  80.     end
  81. end
  83. figure;imshow(imgn)
  84. %imgn=imgn>=1;
  85. imfill(imgn,'hole')
  86. figure,imshow(imgn);
  87. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  89. %对第一个图像进行预处理
  90. A=im2double(RGB1);                    %人物原图像变为双精度型
  91. D=zeros(height1,width1);              %前景和背景交界点的标志矩阵D
  92. K=3;                                  %领域宽度
  93. for i=1:1:height1
  94.     for j=1:1:width1
  95.         if B(i,j)==0          %参考图像数据为0时,将第一幅图像的背景替换为蓝色
  96.             A(i,j,1)=0;
  97.             A(i,j,2)=0;
  98.             A(i,j,3)=1.0;
  99.         else                        %对第一个图像中的前景和背景交界处进行处理
  100.             for k=1:1:K
  101.                 N(k)=B(i,j+k-round(K/2));
  102.             end
  103.             if ~all(N)                %假如该点左右两个像素点存在背景点  
  104.                 if ~isempty(find(N==1))   
  105.                     k1=1;k2=-1;
  106.                     while 1           %用内点（人廓内部）替换该点颜色
  107.                         r=A(i,j+k1,1);g=A(i,j+k1,2);b=A(i,j+k1,3);
  108.                         if B(i,j+k1)==1
  109.                             break;
  110.                         end
  111.                         r=A(i,j+k2,1);g=A(i,j+k2,2);b=A(i,j+k2,3);
  112.                         if B(i,j+k2)==1
  113.                             break;
  114.                         end
  115.                         k1=k1+1;k2=k2-1;
  116.                     end
  117.                     A(i,j,1)=r;
  118.                     A(i,j,2)=g;
  119.                     A(i,j,3)=b;
  120.                     D(i,j)=1;         %对前景背景交界点做标志
  121.                 end       
  122.             end
  123.         end        
  124.     end
  125. end
  126. figure;imshow(A);
  127. x=0;y=0;                        %第一幅图像融合到第二幅图像的起点位置指定
  128. RGB=im2double(RGB2);
  130. %融合图像
  131. for i=1:1:height1
  132.     for j=1:1:width1
  133.         if B(i,j)==1   
  134.             if D(i,j)==1             %交界点的处理，用渐进法。  
  135.                 RGB(y+i,x+j,1)=0.5*A(i,j,1)+0.5*RGB(y+i,x+j,1);
  136.                 RGB(y+i,x+j,2)=0.5*A(i,j,2)+0.5*RGB(y+i,x+j,2);
  137.                 RGB(y+i,x+j,3)=0.5*A(i,j,3)+0.5*RGB(y+i,x+j,3);
  138.             else                     %前景的处理，直接用人物图像替代
  139.                 RGB(y+i,x+j,1)=A(i,j,1);
  140.                 RGB(y+i,x+j,2)=A(i,j,2);
  141.                 RGB(y+i,x+j,3)=A(i,j,3);    
  142.             end
  143.         end
  144.     end
  145. end
  146. figure,imshow(RGB);
  147. clc;

发表评论

表情：
评论列表 （有 0 条评论，349人围观）

还没有评论，来说两句吧...

相关阅读

    相关 ArcMap地理配准

    1.打开菜单栏中的Customize中的 ->ToolBars ->Georeference 2.将两幅图像进行地理配准，现在需要配准的图像上选取GCP然后在相对正确的图像上

    你的名字你的名字/ 0 赞/ 287 阅读