立体视觉算法--SAD+DP

最新推荐文章于 2019-07-11 17:14:53 发布
最新推荐文章于 2019-07-11 17:14:53 发布
阅读量467 收藏 4
点赞数
分类专栏： 050 算法
 

立体视觉算法--SAD+DP

标签： 立体视觉
2013-01-26 10:27  1867人阅读  评论(1)  收藏  举报

版权声明：本文为博主原创文章，未经博主允许不得转载。

[cpp]  view plain  copy
  1. #include <cstdio>  
  2. #include <cstring>  
  3. #include <iostream>  
  4. #include<cv.h>  
  5. #include<highgui.h>  
  6. #include <cmath>  
  7.   
  8. using namespace std;  
  9. const int Width =  512;  
  10. const int Height = 512;  
  11. int Ddynamic[Width][Width];  
  12.   
  13. int  main()  
  14. {    
  15.     //打开文件  
  16.     FILE* pFile;  
  17.     if (pFile = fopen("data.txt","a"))  
  18.     {  
  19.         //cout <<"File Open Success"<<endl;   
  20.     }else{  
  21.         //cout <<"File Open Failed"<<end;  
  22.         return 0;  
  23.     }  
  24.     // IplImage * leftImage = cvLoadImage("l1.png",0);  
  25.     // IplImage * rightImage = cvLoadImage("r1.png",0);  
  26.   
  27.     //IplImage * leftImage = cvLoadImage("l2.jpg",0);  
  28.     //IplImage * rightImage = cvLoadImage("r2.jpg",0);  
  29.   
  30.   
  31.     IplImage * leftImage = cvLoadImage("left.bmp",0);                             
  32.     IplImage * rightImage = cvLoadImage("right.bmp",0);  
  33.   
  34.     int imageWidth = leftImage->width;  
  35.     int imageHeight =leftImage->height;  
  36.   
  37.     IplImage * leftDepth = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);  
  38.     IplImage * rightDepth = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);  
  39.   
  40.     IplImage * leftValid = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);  
  41.     IplImage * rightValid = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);  
  42.   
  43.     IplImage * leftFilter = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);  
  44.     IplImage * rightFilter = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);  
  45.   
  46.     IplImage * depth = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);  
  47.     IplImage * valid = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);  
  48.   
  49.     unsigned char * pPixel = NULL;  
  50.     unsigned char  pixel;  
  51.     unsigned char * pPixel2 = NULL;  
  52.     unsigned char  pixel2;  
  53.     cvZero(leftDepth);  
  54.     cvZero(rightDepth);  
  55.     cvZero(leftValid);  
  56.     cvZero(rightValid);  
  57.     cvZero(leftFilter);  
  58.     cvZero(rightFilter);  
  59.     cvZero(depth);  
  60.     cvZero(valid);  
  61.   
  62.   
  63.   
  64.     CvSize SADWindowSize = cvSize(5,5);  //(widh,height)  
  65.     int SW2 = SADWindowSize.width/2;  
  66.     int SH2 = SADWindowSize.height/2;  
  67.     cout<<"SH2:  "<<SH2<<endl;  
  68.     cout<<"SW2:  "<<SW2<<endl;  
  69.   
  70.     int minD = 0;  
  71.     int maxD = 15;  
  72.     //假设图像是经过矫正的，那么每次都只是需要搜搜同一行的内容  
  73.     int max12Diff = 8*SADWindowSize.width*SADWindowSize.height;  
  74.   
  75.     for (int i = 0;i < imageWidth;i++)  
  76.     {  
  77.         Ddynamic[0][i] = 0;  
  78.         Ddynamic[i][0] = 0;  
  79.     }  
  80.     unsigned char * pLeftPixel  = NULL;  
  81.     unsigned char * pRightPixel = NULL;  
  82.     unsigned char leftPixel = 0;  
  83.     unsigned char rightPixel =0;  
  84.     int m,n,l;  
  85.     int difPixel = 0;  
  86.     int t1 = clock();  
  87.     for (int i = SH2 ; i < imageHeight -SH2;i++)  
  88.     {  
  89.         for (int j = SW2; j<imageWidth - SW2;j++)  
  90.         {  
  91.             for (int k = j + minD; k <= j + maxD;k++)  
  92.             {  
  93.                 difPixel = 0;  
  94.                 for (m = -SH2;m <= SH2;m++)  
  95.                 {  
  96.                     for (n = -SW2; n <= SW2;n++)  
  97.                     {  
  98.                         pRightPixel= (unsigned char*)rightImage->imageData+  
  99.                             (i+m)*rightImage->widthStep + j+n;  
  100.                         rightPixel = *pRightPixel;  
  101.                         if (k < SW2  || k  >= imageWidth -SW2 )  
  102.                         {  
  103.                             difPixel += rightPixel;  
  104.                         }else {  
  105.                             pLeftPixel = (unsigned char*)leftImage->imageData +   
  106.                                 (i+m)*leftImage->widthStep + k+n;    
  107.                             leftPixel  = *pLeftPixel;   
  108.                             difPixel += abs(leftPixel - rightPixel);  
  109.                         }  
  110.   
  111.                     }  
  112.                 }  
  113.                 if (difPixel <= max12Diff)  
  114.                 {  
  115.                     Ddynamic[j + 1][k + 1] = Ddynamic[j][k] +1;   
  116.                 }else if (Ddynamic[j][k+1] > Ddynamic[j+1][k])  
  117.                 {  
  118.                     Ddynamic[j + 1][k + 1] = Ddynamic[j][k+1];  
  119.                 }else{  
  120.                     Ddynamic[j+1][k+1] = Ddynamic[j+1][k];  
  121.                 }  
  122.   
  123.                 //cout<<Ddynamic[j +1][k+1]<<"  ";  
  124.             }  
  125.             //cout<<"\n";  
  126.         }  
  127.         //逆向搜索，找出最佳路径  
  128.         m = imageWidth - SW2;  
  129.         n = imageWidth - SW2;  
  130.         int m2 = m, n2 = n;  
  131.   
  132.         while( m >= 1 && n >= 1)  
  133.         {  
  134.             if ((m2 == m + 1 && n2 >= n +1) || ( m2 > m +1 && n2 == n + 1))  
  135.             {  
  136.                 pPixel = (unsigned char *)rightDepth->imageData + i*rightDepth->widthStep + m;  
  137.                 *pPixel = (n-m)*10;  
  138.                 //标记有效匹配点  
  139.                 pPixel = (unsigned char *)rightValid->imageData + i*rightValid->widthStep + m;  
  140.                 *pPixel = 255;  
  141.   
  142.                 m2 = m;  
  143.                 n2 = n;  
  144.             }  
  145.             if (Ddynamic[m-1][n-1] >= Ddynamic[m][n -1] && Ddynamic[m-1][n -1] >= Ddynamic[m-1][n])  
  146.             {  
  147.   
  148.                 m--;   
  149.                 n--;  
  150.             }else if (Ddynamic[m-1][n] >= Ddynamic[m][n -1] && Ddynamic[m-1][n] >= Ddynamic[m-1][n -1])  
  151.             {   
  152.                 m--;  
  153.             }  
  154.             else  
  155.             {   
  156.                 n--;  
  157.             }  
  158.   
  159.         }  
  160.   
  161.         //cvWaitKey(0);  
  162.     }  
  163.     int t2 = clock();  
  164.     cout<<"dt: "<<t2-t1<<endl;  
  165.     //统计未能匹配点的个数  
  166.     int count = 0;  
  167.     for (int i = 0 ;i< imageHeight;i++)  
  168.     {  
  169.         for (int j= 0; j< imageWidth;j++)  
  170.         {  
  171.             pPixel = (unsigned char *)rightValid->imageData + i*rightValid->widthStep + j;  
  172.             pixel = *pPixel;  
  173.             if (pixel == 0)  
  174.             {  
  175.                 count++;  
  176.             }  
  177.         }  
  178.     }  
  179.     cout<<"rightCount:  "<<count<<"  "<<(double)count/(imageWidth*imageHeight)<<endl;  
  180.     rightFilter = cvCloneImage(rightDepth);  
  181.     //7*7中值滤波  
  182.     int halfMedianWindowSize = 3;  
  183.     int medianWindowSize = 2*halfMedianWindowSize + 1;  
  184.     int medianArray[100] = {0};  
  185.     count = 0;  
  186.     int temp = 0;  
  187.     int medianVal = 0;  
  188.   
  189.     for (int i = halfMedianWindowSize + 1 ;i< imageHeight - halfMedianWindowSize;i++)  
  190.     {  
  191.         for (int j = halfMedianWindowSize; j< imageWidth - halfMedianWindowSize;j++)  
  192.         {  
  193.             pPixel = (unsigned char *)rightValid->imageData + i*rightValid->widthStep + j;  
  194.             pixel = *pPixel;  
  195.             if (pixel == 0)  
  196.             {  
  197.                 count = 0;  
  198.                 for (int m = i - halfMedianWindowSize ; m <= i + halfMedianWindowSize ;m++)  
  199.                 {  
  200.                     for (int n = j - halfMedianWindowSize; n <= j + halfMedianWindowSize ;n++)  
  201.                     {  
  202.                         pPixel2 = (unsigned char *)rightDepth->imageData + m*rightDepth->widthStep + n;  
  203.                         pixel2 = *pPixel2;  
  204.                         if (pixel2 != 0)  
  205.                         {  
  206.                             medianArray[count] = pixel2;  
  207.                             count++;  
  208.                         }  
  209.   
  210.                     }  
  211.                     //排序  
  212.                     for (int k = 0; k< count;k++)  
  213.                     {  
  214.                         for (int l = k + 1; l< count;l++)  
  215.                         {  
  216.                             if (medianArray[l] < medianArray[l-1] )  
  217.                             {  
  218.                                 temp = medianArray[l];  
  219.                                 medianArray[l] = medianArray[l-1];  
  220.                                 medianArray[l-1] = temp;  
  221.                             }  
  222.                         }  
  223.                     }  
  224.                     medianVal = medianArray[count/2];  
  225.                     pPixel = (unsigned char *)rightFilter->imageData + i*rightFilter->widthStep + j;  
  226.                     *pPixel = medianVal;  
  227.                 }  
  228.   
  229.             }  
  230.         }  
  231.     }  
  232.   
  233.     //两次进行DP计算，分别是左对右和右对左,从右想左扫描  
  234.     for (int j = 0; j<= imageWidth;j++)  
  235.     {  
  236.         for (int k = 0;k <= imageWidth;k++)  
  237.         {  
  238.             Ddynamic[j][k] = 0;  
  239.         }  
  240.     }  
  241.     minD = -maxD;  
  242.     maxD = 0;  
  243.     
  244.     for (int i = SH2 ; i < imageHeight -SH2;i++)  
  245.     {  
  246.         for (int j = imageWidth-SW2-1; j >= SW2;j--)  
  247.         {  
  248.             for (int k = j + maxD; k >= j + minD;k--)  
  249.             {  
  250.                 difPixel = 0;  
  251.                 for (m = -SH2;m <= SH2;m++)  
  252.                 {  
  253.                     for (n = -SW2; n <= SW2;n++)  
  254.                     {  
  255.                         pLeftPixel = (unsigned char*)leftImage->imageData +   
  256.                                      (i+m)*leftImage->widthStep + j+n;  
  257.                         leftPixel  = *pLeftPixel;  
  258.                         if (k < SW2 || k  >= imageWidth -SW2)  
  259.                         {  
  260.                              difPixel += leftPixel;  
  261.                         }else {  
  262.                               
  263.                             pRightPixel= (unsigned char*)rightImage->imageData+  
  264.                                          (i+m)*rightImage->widthStep + k+n;   
  265.                             rightPixel = *pRightPixel;  
  266.                             difPixel += abs(leftPixel - rightPixel);  
  267.                             //cout<<Ddynamic[j +1][k+1]<<"  ";  
  268.                         }  
  269.                     }  
  270.                 }  
  271.   
  272.                 if (difPixel <= max12Diff)  
  273.                 {  
  274.                     Ddynamic[j][k] = Ddynamic[j+1][k+1] +1;   
  275.                 }else if (Ddynamic[j+1][k] > Ddynamic[j][k+1])  
  276.                 {  
  277.                     Ddynamic[j][k] = Ddynamic[j+1][k];  
  278.                 }else{  
  279.                     Ddynamic[j][k] = Ddynamic[j][k+1];  
  280.                 }  
  281.   
  282.             }  
  283.             //cout<<"\n";  
  284.         }  
  285.         //逆向搜索，找出最佳路径  
  286.   
  287.         m = 0;  
  288.         n = 0;  
  289.         int m2 = m, n2 = n;  
  290.         while( m < imageWidth && n < imageWidth)  
  291.         {  
  292.             if ((m == m2 + 1 && n >= n2 +1) || ( m > m2 +1 && n == n2 + 1))  
  293.             {  
  294.                 pPixel = (unsigned char *)leftDepth->imageData + i*leftDepth->widthStep + m;  
  295.                 *pPixel = (m-n)*10;  
  296.                 //标记有效匹配点  
  297.                 pPixel = (unsigned char *)leftValid->imageData + i*leftValid->widthStep + m;  
  298.                 *pPixel = 255;  
  299.   
  300.                 m2 = m;  
  301.                 n2 = n;  
  302.             }  
  303.             if (Ddynamic[m+1][n+1] >= Ddynamic[m][n+1] && Ddynamic[m+1][n+1] >= Ddynamic[m+1][n])  
  304.             {  
  305.   
  306.                 m++;   
  307.                 n++;  
  308.             }else if (Ddynamic[m+1][n] >= Ddynamic[m][n +1] && Ddynamic[m+1][n] >= Ddynamic[m+1][n+1])  
  309.             {   
  310.                 m++;  
  311.             }  
  312.             else  
  313.             {   
  314.                 n++;  
  315.             }  
  316.   
  317.         }  
  318.         //cvWaitKey(0);  
  319.     }  
  320.     int t3 = clock();  
  321.     //refine the depth image  7*7中值滤波  
  322.     //统计未能匹配点的个数  
  323.     count = 0;  
  324.     for (int i = 0 ;i< imageHeight;i++)  
  325.     {  
  326.         for (int j= 0; j< imageWidth;j++)  
  327.         {  
  328.             pPixel = (unsigned char *)leftValid->imageData + i*leftValid->widthStep + j;  
  329.             pixel = *pPixel;  
  330.             if (pixel == 0)  
  331.             {  
  332.                 count++;  
  333.             }  
  334.         }  
  335.     }  
  336.   
  337.     cout<<"Left Count:  "<<count<<"  "<<(double)count/(imageWidth*imageHeight)<<endl;  
  338.   
  339.     //将关键信息计入文件  
  340.     fprintf(pFile,"\nDP:\nClock:   %dms",t3-t1);  
  341.     fprintf(pFile,"\nInvalid Point:   %f",(double)count/(imageWidth*imageHeight));  
  342.     // cvWaitKey(0);  
  343.     leftFilter = cvCloneImage(leftDepth);  
  344.     //7*7中值滤波  
  345.     count = 0;  
  346.     for (int i = halfMedianWindowSize + 1 ;i< imageHeight - halfMedianWindowSize;i++)  
  347.     {  
  348.         for (int j = halfMedianWindowSize; j< imageWidth - halfMedianWindowSize;j++)  
  349.         {  
  350.             pPixel = (unsigned char *)leftValid->imageData + i*leftValid->widthStep + j;  
  351.             pixel = *pPixel;  
  352.             if (pixel == 0)  
  353.             {  
  354.                 count = 0;  
  355.                 for (int m = i - halfMedianWindowSize ; m <= i + halfMedianWindowSize ;m++)  
  356.                 {  
  357.                     for (int n = j - halfMedianWindowSize; n <= j + halfMedianWindowSize ;n++)  
  358.                     {  
  359.                         pPixel2 = (unsigned char *)leftDepth->imageData + m*leftDepth->widthStep + n;  
  360.                         pixel2 = *pPixel2;  
  361.                         if (pixel2 != 0)  
  362.                         {  
  363.                             medianArray[count] = pixel2;  
  364.                             count++;  
  365.                         }  
  366.   
  367.                     }  
  368.                     //排序  
  369.                     for (int k = 0; k< count;k++)  
  370.                     {  
  371.                         for (int l = k + 1; l< count;l++)  
  372.                         {  
  373.                             if (medianArray[l] < medianArray[l-1] )  
  374.                             {  
  375.                                 temp = medianArray[l];  
  376.                                 medianArray[l] = medianArray[l-1];  
  377.                                 medianArray[l-1] = temp;  
  378.                             }  
  379.                         }  
  380.                     }  
  381.                     medianVal = medianArray[count/2];  
  382.                     pPixel = (unsigned char *)leftFilter->imageData + i*leftFilter->widthStep + j;  
  383.                     *pPixel = medianVal;  
  384.                 }  
  385.   
  386.             }  
  387.         }  
  388.     }  
  389.     //假如已知左右图片的深度，进行refinement  
  390.     unsigned char dLeft = 0, dRight = 0;  
  391.     count = 0;  
  392.     for (int i = 0; i< imageHeight;i++)  
  393.     {  
  394.         for (int j = 0; j< imageWidth;j++)  
  395.         {  
  396.             pRightPixel= (unsigned char*)rightDepth->imageData + i*rightDepth->widthStep + j;  
  397.             dRight = (*pRightPixel)/10;  
  398.             if (j + dRight < imageWidth)  
  399.             {      
  400.                 pPixel= (unsigned char*)depth->imageData + i*depth->widthStep + j;  
  401.                 pLeftPixel= (unsigned char*)leftDepth->imageData + i*leftDepth->widthStep + j + dRight;  
  402.                 dLeft = (*pLeftPixel)/10;  
  403.                 if (abs(int(dRight) -(int)dLeft) <= 1)  
  404.                 {  
  405.                     //深度一致    
  406.                     *pPixel = dRight*10;  
  407.                       
  408.                 }else{  
  409.                     //深度不一致，认为是误匹配、错误匹配  
  410.                     *pPixel = 0;  
  411.                     count++;  
  412.                 }  
  413.             }  
  414.         }  
  415.     }  
  416.     cout<<"depth Count:  "<<count<<"  "<<(double)count/(imageWidth*imageHeight)<<endl;  
  417.   
  418.   
  419.     cvNamedWindow("leftImage",1);  
  420.     cvNamedWindow("rightImage",1);  
  421.     cvNamedWindow("leftDepth",1);  
  422.     cvNamedWindow("leftValid",1);  
  423.     cvNamedWindow("rightDepth",1);  
  424.     cvNamedWindow("rightValid",1);  
  425.     cvNamedWindow("leftFilter",1);  
  426.     cvNamedWindow("rightFilter",1);  
  427.     cvNamedWindow("depth",1);  
  428.   
  429.       
  430.     cvShowImage("leftImage",leftImage);  
  431.     cvShowImage("rightImage",rightImage);  
  432.   
  433.     cvShowImage("leftDepth",leftDepth);  
  434.     cvShowImage("rightDepth",rightDepth);  
  435.   
  436.     cvShowImage("leftValid",leftValid);   
  437.     cvShowImage("rightValid",rightValid);  
  438.   
  439.     cvShowImage("leftFilter",leftFilter);  
  440.     cvShowImage("rightFilter",rightFilter);  
  441.     cvShowImage("depth",depth);  
  442.   
  443.     cvSaveImage("leftDepth.jpg",leftDepth);  
  444.     cvSaveImage("rightDepth.jpg",rightDepth);  
  445.     cvSaveImage("leftValid.jpg",leftValid);  
  446.     cvSaveImage("rightValid.jpg",rightValid);  
  447.     cvSaveImage("leftFilter.jpg",leftFilter);  
  448.     cvSaveImage("rightFilter.jpg",rightFilter);  
  449.     cvSaveImage("depth.jpg",depth);  
  450.   
  451.   
  452.   
  453.     fclose(pFile);  
  454.     cvWaitKey(0);  
  455.     return 0;  
  456. }  

aihao_diy
关注
专栏目录
双目立体视觉（一）：SAD算法
On my way
10-29 1万+
立体匹配是双目立体视觉中很重要的一步。图像在经过校正行对准后，需要确定每一点像素的视差用于计算深度信息。匹配算法就是用于确认左右视图图像的匹配关系，这一篇文章主要叙述SAD算法和代码实现。
立体匹配sad算法
05-04
只是一个很简单的立体匹配，可以运行。如果是做计算机视觉方面的东西，还是有一定的参考价值。
立体匹配SAD算法matlab实现
laoliaixuexi的博客
02-18 1万+
1.算法原理 SAD(Sum of absolute differences)是一种图像匹配算法。基本思想：差的绝对值之和。此算法常用于图像块匹配，将每个像素对应数值之差的绝对值求和，据此评估两个图像块的相似度。该算法快速、但并不精确，通常用于多级处理的初步筛选。 2.基本流程 输入：两幅图像，一幅Left，一幅Right 对左图，依次扫描，选定一个锚点： （1）构造一个小窗口,类似于卷积核； （...
立体匹配算法-sad
05-04
总的来说，"立体匹配算法-SAD"是一个基础的计算机视觉学习资源，适合初学者用来了解立体匹配的基本概念和MATLAB编程实践。通过学习和实践这个代码，不仅可以掌握SAD算法，还能为后续更复杂的视觉算法打下坚实的基础...
SSD+SAD+NCC算法.rar_SAD_SSD+SAD+NCC算法_seldomerq_立体匹配_立体匹配算法
07-14
立体匹配 计算机视觉 SSD+SAD+NCC算法
SSD+SAD+NCC立体匹配算法matlab代码
05-04
压缩包中的"SSD+SAD+NCC算法"文件很可能包含了这些算法的MATLAB源代码，可以直接运行。对于初学者来说，这些代码可以帮助理解算法原理，同时提供了一个快速实践的平台。通过学习和调试这些代码，可以深入掌握立体...
SAD-立体匹配算法.zip
11-12
SAD（Sum of Absolute Differences）即绝对差值之和，是一种简单而有效的立体匹配算法。本篇文章将深入探讨SAD算法及其在实际应用中的原理和实现。 **SAD算法的基本原理** SAD算法主要基于像素级别的灰度差值来...
SADPDP.rar_DP_SAD_双目立体视觉_立体匹配 DP_立体匹配DP
07-15
SAD+DP算法，是在双目立体视觉中，求左右图对匹配深度图
立体视觉算法-SGBM（一）
weixin_30482181的博客
01-21 1029
最近一直在学习SGBM算法，作为一种全局匹配算法，立体匹配的效果明显好于局部匹配算法，但是同时复杂度上也要远远大于局部匹配算法。算法主要是参考StereoProcessingbySemiglobalMatchingandMutualInformation，里面有讲完整的算法实现。 OpenCV中实际上是提供了SGBM类进行SGBM算法的实现。 #include<highg...
深度学习与计算机视觉 看这一篇就够了
热门推荐
u012507022的博客
05-18 15万+
来源：http://www.leiphone.com/news/201605/zZqsZiVpcBBPqcGG.html#rd 人工智能是人类一个非常美好的梦想，跟星际漫游和长生不老一样。我们想制造出一种机器，使得它跟人一样具有一定的对外界事物感知能力，比如看见世界。 在上世纪50年代，数学家图灵提出判断机器是否具有人工智能的标准：图灵测试。即把机器放在一个房间，人类测试员在另一个房间
SAD算法原理及其实现
opencv_fjc的博客
07-11 1万+
一。算法原理。 SAD（Sum of absolute differences）是图像立体匹配中常用的初级块匹配算法，其基本运算思想是求取相对应的左右两个像素块内像素值之差的绝对值之和。 二。计算流程。 前期准备：某物体在同一时刻左右相机拍摄得到的左右图像。left_image,right_image. ！！！强调一点：在进行立体匹配之前，两幅图像处于经过立体校正之后的行对准状态。 ...
双目立体视觉SAD匹配算法
u012507022的博客
05-22 3万+
SAD(Sum of absolute differences)是一种图像匹配算法。基本思想：差的绝对值之和。此算法常用于图像块匹配，将每个像素对应数值之差的绝对值求和，据此评估两个图像块的相似度。该算法快速、但并不精确，通常用于多级处理的初步筛选。
【双目视觉探索路2】获取视差图（未完待续）
JDeng的编程应用入门
12-13 1万+
本篇文章的目的是获取视差图，基本原理涉及立体矫正与立体匹配。
20170216. 绝对值之和算法(SAD)(Sum_of_absolute_differences)
u014488388的专栏
02-16 2695
https://en.wikipedia.org/wiki/Sum_of_absolute_differences 用于比较区域的相似性。 比如在一个图中，寻找和目标block最接近的区域。
基于java的共享汽车管理系统的开题报告2.docx
09-25
基于java的共享汽车管理系统的开题报告2.docx
基于SpringBoot的ChongyouLostandfound失物招领网站设计源码
09-25
该源码是一款基于SpringBoot框架构建的重邮失物招领网站，包含了250个文件，涵盖101个XML配置文件、44个Java源代码文件、26个HTML页面文件、20个JavaScript脚本文件、12个CSS样式文件、12个图片文件（JPG格式）、10个属性文件、5个ICO图标文件、5个PNG图片文件、4个SVG矢量图形文件。项目采用Java、HTML、JavaScript和CSS等多种语言实现，功能完善，界面友好。
小白学JavaScript的第六天
最新发布
09-25
小白学JavaScript的第六天
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值