阴影消除研究

最新推荐文章于 2024-06-16 09:34:17 发布
最新推荐文章于 2024-06-16 09:34:17 发布
阅读量9.4k 收藏 17
点赞数
分类专栏： Image Algorithm Machine Vision 文章标签： 阴影消除
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/forest_world/article/details/51878042
版权

用GMM提取运动目标，在光照比较强烈的条件下，会把阴影也当成运动目标提取出来。 利用阴影亮度降低而色度基本不变的特点，在HSV空间里利用以下公式进行判断

这里写图片描述

这里写图片描述

#include "stdafx.h"
#include "cv.h"
#include "highgui.h"
#include <opencv2/opencv.hpp>

#include "HaarDetect.h"


#include "io.h"
#include "direct.h" /*mkdir("E:\mydir");*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <float.h>
#include <limits.h>
#include <time.h>
#include <ctype.h>


#ifdef _EiC
#define WIN32
#endif

// shade1.cpp : Defines the entry point for the console application.
//
// shade.cpp : Defines the entry point for the console application.
//
//视频检测
//#include "stdafx.h"
#include "stdio.h"
#include <stdlib.h>
#include "cv.h"
#include "highgui.h"
#include "math.h"
//#pragma comment( lib, "cv200.lib" )
//#pragma comment( lib, "cxcore200.lib" )
//#pragma comment( lib, "highgui200.lib" )
//#pragma comment( lib, "cvaux200.lib" )
/*void labeling(IplImage *src,IplImage* dst)
{
    CvMemStorage* storage=0;
    storage = cvCreateMemStorage(0);
    CvSeq* contour = 0;
    cvCopy(src,dst,0);
    cvFindContours(dst,storage,&contour,sizeof(CvContour),
        CV_RETR_EXTERNAL,CV_CHAIN_APPROX_SIMPLE);
    int num = 0;
    for (;contour!=0;contour=contour->h_next)
    {
        CvRect rect;
        rect = cvBoundingRect(contour,0);
        num++;
        if (rect.height + rect.width>=50)
        {
            cvRectangle(src,cvPoint(rect.x,rect.y),cvPoint(rect.x+rect.width,rect.y+rect.height),
                CV_RGB(255,255,255),1,8);
        }
    }

}*/
void ShadeDetect(IplImage *currImg, IplImage *bkImg/*, IplImage *shdadeImg*//*,double th1,double th2,double th3,double th4*/)
{




    //cvZero(shdadeImg);
    //cvNot(shdadeImg,shdadeImg);
    //unsigned char* currData;
    //unsigned char* bkData;
    //unsigned char* shadeData;
    //int i=0,j=0;
    //int height=currImg->height;
    //int width=currImg->width;
    //double rb=0,gb=0,Ib=0,Rb=0,Gb=0,Bb=0,bf=0;
    //double rt=0,gt=0,It=0,Rt=0,Gt=0,Bt=0,tf=0;
    ////CvScalar cs=cvScalarAll(255);
    //for (i=0;i<height;i++)
    //{
    //  currData=(unsigned char*)currImg->imageData+i*currImg->widthStep;
    //  bkData=(unsigned char*)bkImg->imageData+i*bkImg->widthStep;
    //  shadeData=(unsigned char*)shdadeImg->imageData+i*shdadeImg->widthStep;
    //  for (j=0;j<width;j++)
    //  {
    //      // current normalized
    //      Rt=currData[j*3];
    //      Gt=currData[j*3+1];
    //      Bt=currData[j*3+2];
    //      tf=(Rt>Gt?Gt:Rt)>Bt?Bt:(Rt>Gt?Gt:Rt);

    //      rt=acos((0.5*((Rt-Gt)+(Rt-Bt)))/(sqrt((Rt-Gt)*(Rt-Gt)+(Rt-Bt)*(Rt-Gt))));
    //      gt=1-3*tf/(Rt+Gt+Bt);
    //      It=(Rt+Gt+Bt)/3;
    //      // Bk normalized
    //      Rb=bkData[j*3];
    //      Gb=bkData[j*3+1];
    //      Bb=bkData[j*3+2];
    //      bf=(Rb>Gb?Gb:Rb)>Bb?Bb:(Rb>Gb?Gb:Rb);

    //      rb=acos((0.5*((Rb-Gb)+(Rb-Bb)))/(sqrt((Rb-Gb)*(Rb-Gb)+(Rb-Bb)*(Rb-Gb))));
    //      gb=1-3*bf/(Rb+Gb+Bb);
    //      Ib=(Rb+Gb+Bb)/3;
    //      // judge whether is shadeimg
    //      if (It/Ib>=th1&& It/Ib<=th2 && fabs(rt-rb)<=th3 && fabs(gt-gb)<=th4)
    //      {
    //          shadeData[j]=0;
    //      }  
    //  }
    //}
}

int main(int argc, char* argv[])
{
    //声明IplImage指针
    IplImage* pFrame = NULL;
    IplImage* pFrame18 = NULL;
    IplImage* Iavg = NULL; 
    IplImage* pBkImg = NULL;
    IplImage* pFrImg = NULL;

    int avg1[240][320]={0};
    int avg2[240][320]={0};
    int avg3[240][320]={0};
    /////////////////////////////////////////////////////////////////////////////////////////////
    IplImage* pRetImg = NULL;

    IplImage* pFkHsv = NULL;
    //IplImage* pFrImg = NULL;

    IplImage* pFrImgGray = NULL;

    IplImage* pFrImgR = NULL;
    IplImage* pFrImgG = NULL;
    IplImage* pFrImgB = NULL;

    IplImage* pBkHsv = NULL;
    //IplImage* pBkImg = NULL;



    IplImage* pBkImgR = NULL;
    IplImage* pBkImgG = NULL;
    IplImage* pBkImgB = NULL;

    //IplImage* pBkImg1 = NULL;
    //IplImage* shadeImg = NULL;
    //IplImage* dst=NULL;

    CvMat* pFrameMatGray = NULL;

    CvMat* pFrameMatR = NULL;
    CvMat* pFrameMatG = NULL;
    CvMat* pFrameMatB = NULL;

    CvMat* pFrMatGray = NULL;

    CvMat* pFrMatR = NULL;
    CvMat* pFrMatG = NULL;
    CvMat* pFrMatB = NULL;

    CvMat* pBkMatGray = NULL;

    CvMat* pBkMatR = NULL;
    CvMat* pBkMatG = NULL;
    CvMat* pBkMatB = NULL;

    //void labeling(IplImage *src,IplImage* dst);
    //CvMat* pBkMattmp = NULL;
    CvCapture* pCapture = NULL;
    double nFrmNum = 0.;
    //创建窗口
    cvNamedWindow("video", 1);
    cvNamedWindow("background",1);
    cvNamedWindow("foreground0",1);
    cvNamedWindow("foreground",1);
    //cvNamedWindow("shade", 1);
    //使窗口有序排列
    cvMoveWindow("video", 30, 0);
    cvMoveWindow("background", 360, 120);
    cvMoveWindow("foreground", 690, 240);
    if( !(pCapture = cvCreateFileCapture("E:\\video\\高速公路 汽车阴影.AVI")))
    {
        printf("不能打开视频文件！\n");
        return -1;
    }
    pFrame18 = cvQueryFrame( pCapture );
    pFrame = cvQueryFrame( pCapture );
    CvSize sz=cvGetSize(pFrame);
    Iavg=cvCreateImage(cvGetSize(pFrame),IPL_DEPTH_16U,3);

    //int step = pFrame->widthStep/sizeof(uchar);
 //   for (int i=0;i<pFrame->height;i++)
 //   {
 //       for (int j=0;j<pFrame->width;j++)
 //       {                                                                 
 //           Iavg->imageData[i*step+j*3+0]=0;
    //      Iavg->imageData[i*step+j*3+1]=0;
    //      Iavg->imageData[i*step+j*3+2]=0;                                                                    
 //       }
 //   }

    pBkImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,3);
    pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,3);
     pRetImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U,3);
                pBkHsv = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,3);
//       
            pFkHsv = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,3);
    //double* avg=(double*)malloc((pFrame->width*pFrame->height)*sizeof(double));
uchar* data=(uchar *)pFrame->imageData;  
int step = pFrame->widthStep/sizeof(uchar);  
int channels = pFrame->nChannels;  

    //逐帧读取视频
    while(nFrmNum<=100)//获取视频帧，到结尾退出循环
    {
        pFrame = cvQueryFrame( pCapture );
        nFrmNum++;

        //char* s11=(char *)malloc(sizeof(char)*255);//
        //strcpy(s11,"E:\\");
        //strcat(s11,"\\");
        //char s3[100];
        //itoa(nFrmNum,s3,10); /*把a转到s中,10是十进制*/
        //strcat(s11,s3);
        //strcat(s11,".jpg");
        //cvSaveImage(s11,pFrame);//保存图片
        //free(s11);//


        /*cvShowImage("pFrame", pFrame);
        cvWaitKey(10);*/

        //如果是第一帧，需要申请内存，并初始化
//        if(nFrmNum == 1)
//        {
///////////////////////////////////////////////////////////////////////////////////////
//          pBkImgGray = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//          pFrImgGray = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//
//          pBkMatGray = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          pFrMatGray = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          pFrameMatGray = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          //转化成单通道图像再处理
//          cvCvtColor(pFrame, pBkImgGray, CV_BGR2GRAY);
//          cvCvtColor(pFrame, pFrImgGray, CV_BGR2GRAY);
//
//          cvConvertScale(pFrImgGray, pFrameMatGray);
//          cvConvertScale(pFrImgGray, pFrMatGray);
//          cvConvertScale(pFrImgGray, pBkMatGray);
///////////////////////////////////////////////////////////////////////////////////////
//                  
//          pRetImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,3);
//

//          
//          pBkImgR = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//          pBkImgG = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//          pBkImgB = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//
//          pFkHsv = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,3);
//
//          pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,3);
//
//            pFrImgR = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//          pFrImgG = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//          pFrImgB = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//
//          //pBkImg1 = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,3);
//          //shadeImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);
//                  
//          pBkMatR = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          pBkMatG = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          pBkMatB = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//            //pBkMattmp = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//           
//          pFrMatR = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          pFrMatG = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          pFrMatB = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//
//            pFrameMatR = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          pFrameMatG = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//          pFrameMatB = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//
//            //转化成单通道图像再处理
//          cvSplit(pFrame, pBkImgB, pBkImgG, pBkImgR, 0);//分离RGB通道，分别得到BGR的单通道图像
//            //cvCvtColor(pFrame, pBkImg, CV_BGR2GRAY);
//          cvSplit(pFrame, pFrImgB, pFrImgG, pFrImgR, 0);//分离RGB通道，分别得到BGR的单通道图像
//            //cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
//
//            cvConvertScale(pFrImgR, pFrameMatR);
//            cvConvertScale(pFrImgG, pFrameMatG);
//          cvConvertScale(pFrImgB, pFrameMatB);
//
//            cvConvertScale(pFrImgR, pBkMatR);
//            cvConvertScale(pFrImgG, pBkMatG);
//          cvConvertScale(pFrImgB, pBkMatB);
//
//          cvConvertScale(pFrImgR, pFrMatR);
//            cvConvertScale(pFrImgG, pFrMatG);
//          cvConvertScale(pFrImgB, pFrMatB);
//
//          //cvCopy(pFrame,pBkImg1,NULL);
//            //cvConvertScale(pFrImg, pBkMattmp);
//
//
//        }
//        else
//        {
//          cvCvtColor(pFrame, pFrImgGray, CV_BGR2GRAY);
//          cvConvertScale(pFrImgGray, pFrameMatGray);
//          //高斯滤波先，以平滑图像
//          cvSmooth(pFrameMatGray, pFrameMatGray, CV_GAUSSIAN, 3, 0, 0);
//
//          //当前帧跟背景图相减
//          cvAbsDiff(pFrameMatGray, pBkMatGray, pFrMatGray);
//
//          //二值化前景图
//            cvThreshold(pFrMatGray, pFrImgGray, 60, 255.0, CV_THRESH_BINARY);
//
//          //进行形态学滤波，去掉噪音  
//          /*cvErode(pFrImgGray, pFrImgGray, 0, 1);
//          cvDilate(pFrImgGray, pFrImgGray, 0, 1);*/
//
//          //更新背景
//          cvRunningAvg(pFrameMatGray, pBkMatGray, 0.003, 0);
//          //将背景转化为图像格式，用以显示
//          cvConvertScale(pBkMatGray, pBkImgGray);
//
//          //显示图像
//          //cvShowImage("pFrame", pFrame);
//          cvShowImage("pBkImgGray", pBkImgGray);
//          cvShowImage("pFrImgGray", pFrImgGray);
//          
//          //更新背景
//          cvRunningAvg(pFrameMatGray, pBkMatGray, 0.003, 0);
//          //将背景转化为图像格式，用以显示
//          cvConvertScale(pBkMatGray, pBkImgGray);
//          
//////////////////////////////////////////////////////////////////////////////////////////////
//          cvSplit(pFrame, pFrImgB, pFrImgG, pFrImgR, 0);//分离RGB通道，分别得到BGR的单通道图像
//            //cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
//          
//          //cvCvtColor(pFrame, pFrImg, CV_BGR2HSV);
//            cvConvertScale(pFrImgR, pFrameMatR);
//          cvConvertScale(pFrImgG, pFrameMatG);
//          cvConvertScale(pFrImgB, pFrameMatB);
//
//            //当前帧跟背景图相减
//            cvAbsDiff(pFrameMatR, pBkMatR, pFrMatR);
//          cvAbsDiff(pFrameMatG, pBkMatG, pFrMatG);
//          cvAbsDiff(pFrameMatB, pBkMatB, pFrMatB);
//
//            //cvAbsDiff(pBkMat, pFrMat, pBkMattmp);//背景相消，需要足够多帧
//            //cvOr(pBkMat, pBkMattmp, pBkMat);
//            //高斯滤波先，以平滑图像
//          //cvFlip(pFrMat,NULL,0);
//            cvSmooth(pFrMatR, pFrMatR, CV_GAUSSIAN, 3,0,0);
//          cvSmooth(pFrMatG, pFrMatG, CV_GAUSSIAN, 3,0,0);
//          cvSmooth(pFrMatB, pFrMatB, CV_GAUSSIAN, 3,0,0);
//
//          cvConvertScale(pFrMatR, pFrImgR);
//          cvConvertScale(pFrMatG, pFrImgG);
//          cvConvertScale(pFrMatB, pFrImgB);
//            //二值化前景图
//            //cvSmooth(pFrImg, pFrImg, CV_MEDIAN, 3,0,0);
//            /*cvThreshold(pFrMatR, pFrImgR, 30, 255, CV_THRESH_BINARY);
//          cvThreshold(pFrMatG, pFrImgG, 30, 255, CV_THRESH_BINARY);
//          cvThreshold(pFrMatB, pFrImgB, 30, 255, CV_THRESH_BINARY);*/
//
//            //进行形态学滤波，去掉噪音
//   //         cvErode(pFrImgR, pFrImgR, 0, 1);//腐蚀
//          //cvErode(pFrImgG, pFrImgG, 0, 1);//腐蚀
//          //cvErode(pFrImgB, pFrImgB, 0, 1);//腐蚀
//
//   //         cvDilate(pFrImgR, pFrImgR, 0, 1);//膨胀
//          //cvDilate(pFrImgG, pFrImgG, 0, 1);//膨胀
//          //cvDilate(pFrImgB, pFrImgB, 0, 1);//膨胀
//
//            //更新背景
//     
//            //运动平滑（alpha参数：以多快的速度忘掉前面的帧）
//            cvRunningAvg(pFrameMatR, pBkMatR, 0.003, 0);//0.005
//          cvRunningAvg(pFrameMatG, pBkMatG, 0.003, 0);
//          cvRunningAvg(pFrameMatB, pBkMatB, 0.003, 0);
//            //将背景转化为图像格式，用以显示
//      
//          cvConvertScale(pBkMatR, pBkImgR);
//          cvConvertScale(pBkMatG, pBkImgG);
//          cvConvertScale(pBkMatB, pBkImgB);
//            //cvConvertScale(pBkMat, pBkImg);
//          //cvCvtColor(pBkImg, pBkImg1, CV_GRAY2BGR);
//          //ShadeDetect(pFrame,pBkImg1,shadeImg,0.3,0.8,0.9,1);
//            //显示图像
//          //cvFlip(shadeImg,NULL,0);
//            
//          //cvFlip(pBkImg,NULL,0);
//            //cvCopy(dst,pFrImg,0);
//         
//          cvMerge(pFrImgB, pFrImgG, pFrImgR, 0, pFrImg);//逆运算，将三通道图像融合得到彩色图像
//      cvSaveImage("E:\\pFrImg.jpg",pFrImg);//保存图片
//          cvCvtColor(pFrImg,pFkHsv,CV_BGR2HSV);//得到HSV图
//          cvShowImage("foreground0", pFrImg);
//
//          //cvAnd(pFrImg,shadeImg,pFrImg,NULL);
//          //labeling(pFrImg,pFrImg);
//          //cvErode(pFrImg, pFrImg, 0, 1);//腐蚀
//          //cvDilate(pFrImg, pFrImg, 0, 1);//膨胀
//          
//            //cvShowImage("shade", shadeImg);
//            //cvShowImage("video", pFrame);
//
//          cvMerge(pBkImgB, pBkImgG, pBkImgR, 0, pBkImg);//逆运算，将三通道图像融合得到彩色图像
//      cvSaveImage("E:\\pBkImg.jpg",pBkImg);//保存图片
//          cvCvtColor(pBkImg,pBkHsv,CV_BGR2HSV);//得到HSV图
//            cvShowImage("background", pBkImg);
//            //cvShowImage("foreground", pFrImg);
//            //如果有按键事件，则跳出循环
//            //此等待也为cvShowImage函数提供时间完成显示
//            //等待时间可以根据CPU速度调整
//            if( cvWaitKey(50)>= 0)
//                break;

            ///////////////<<<<<<<pFkHsv  pBkHsv<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

       /* if(nFrmNum==10)
            cvCopy(pFrame,pFrame18);*/




        double a,b,c,d;
        for (int i=0;i<pFrame->height;i++)
        {
            for (int j=0;j<pFrame->width;j++)
            {  

                avg1[i][j]+=data[i*step+j*channels+0];
                avg2[i][j]+=data[i*step+j*channels+1];
                avg3[i][j]+=data[i*step+j*channels+2];
                /*Iavg->imageData[i*step+j*3+0]+=pFrame->imageData[i*step+j*3+0];
                Iavg->imageData[i*step+j*3+1]+=pFrame->imageData[i*step+j*3+1];
                Iavg->imageData[i*step+j*3+2]+=pFrame->imageData[i*step+j*3+2];     */                                                          
            }
        }
        //cvShowImage("pRetImg", pRetImg);

        ///////////////>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

        //ShadeDetect(pFkHsv,pBkHsv);
    }
    nFrmNum--;
    int step2 = pFrame->widthStep/sizeof(uchar);
    for (int i=0;i<pFrame->height;i++)
    {
        for (int j=0;j<pFrame->width;j++)
        {                                                                   
         pBkImg->imageData[i*step2+j*3+0]=(uchar)(avg1[i][j]/nFrmNum);
         pBkImg->imageData[i*step2+j*3+1]=(uchar)(avg2[i][j]/nFrmNum);
         pBkImg->imageData[i*step2+j*3+2]=(uchar)(avg3[i][j]/nFrmNum);      

        }
    }
    cvShowImage("pBkImg", pBkImg);
    //cvConvertScale(Iavg, pFrameMatGray);

    //cvShowImage("pFrameMatGray", pFrameMatGray);
    //等待时间可以根据CPU速度调整
    cvWaitKey(50);


    pFrame18 = cvLoadImage( "E:\\16.jpg", 1);
    cvShowImage("pFrame18", pFrame18);
    cvWaitKey(50);

    data=(uchar *)pFrame18->imageData;  
    step = pFrame18->widthStep/sizeof(uchar);  
    channels = pFrame18->nChannels;  
    uchar* data2=(uchar *)pBkImg->imageData; 

    uchar* data3=(uchar *)pFrImg->imageData;  

    for (int i=0;i<pFrame18->height;i++)
    {
        for (int j=0;j<pFrame18->width;j++)
        {                                                                   
                /*data3[i*step+j*channels+0]=
                    ((abs(data[i*step+j*channels+0]-data2[i*step+j*channels+0])>=20) ? data[i*step+j*channels+0]:0);
                data3[i*step+j*channels+1]=
                    ((abs(data[i*step+j*channels+1]-data2[i*step+j*channels+1])>=20) ? data[i*step+j*channels+1]:0);
                data3[i*step+j*channels+2]=
                    ((abs(data[i*step+j*channels+2]-data2[i*step+j*channels+2])>=20) ? data[i*step+j*channels+2]:0);*/


                    if((abs(data[i*step+j*channels+0]-data2[i*step+j*channels+0])>=40)||
                    (abs(data[i*step+j*channels+1]-data2[i*step+j*channels+1])>=40)|| 
                    (abs(data[i*step+j*channels+2]-data2[i*step+j*channels+2])>=40))
                    {
                        data3[i*step+j*channels+0]=data[i*step+j*channels+0];
                        data3[i*step+j*channels+1]=data[i*step+j*channels+1];
                        data3[i*step+j*channels+2]=data[i*step+j*channels+2];

                    }
                    else

                    {
                        data3[i*step+j*channels+0]=0;
                        data3[i*step+j*channels+1]=0;
                        data3[i*step+j*channels+2]=0;

                    }

        }
    }
    cvShowImage("pFrImg", pFrImg);
    cvWaitKey(50);

    ///////////////////////////////////////////////////////////////////////////////////////////////////////
    cvCvtColor(pBkImg, pBkHsv, CV_BGR2HSV);
    cvCvtColor(pFrImg, pFkHsv, CV_BGR2HSV);

    cvShowImage("pFkHsv", pFkHsv);
    cvWaitKey(50);

    step = pRetImg->widthStep/sizeof(uchar);
   double a,b,c,d;
for (int i=0;i<pFkHsv->height;i++)
{
                for (int j=0;j<pFkHsv->width;j++)
                {

                    a=(double)(pFkHsv->imageData[i*step+j*3+2])/(pBkHsv->imageData[i*step+j*3+2]);
                    b=(double)(pFkHsv->imageData[i*step+j*3+2])/(pBkHsv->imageData[i*step+j*3+2]);
                    c=abs(pFkHsv->imageData[i*step+j*3+1]-pBkHsv->imageData[i*step+j*3+1]);
                    d=abs(pFkHsv->imageData[i*step+j*3+0]-pBkHsv->imageData[i*step+j*3+0]);
                    if (
                        (a<=0.35)&&(b>=0.05)&&
                        (c<=4*255)&&(d<=1*255)
                        )
                    {
                    pRetImg->imageData[i*step+j*3+0]=255;
                    pRetImg->imageData[i*step+j*3+1]=255;
                    pRetImg->imageData[i*step+j*3+2]=255;
                    }
                    else
                    {
                    pRetImg->imageData[i*step+j*3+0]=0;
                    pRetImg->imageData[i*step+j*3+1]=0;
                    pRetImg->imageData[i*step+j*3+2]=0;
                    }

                }
}
   cvShowImage("pRetImg", pRetImg);
            //等待时间可以根据CPU速度调整
           cvWaitKey(50);



    //销毁窗口
    cvDestroyWindow("video");
    cvDestroyWindow("background");
    cvDestroyWindow("foreground0");
    cvDestroyWindow("foreground");
    //cvReleaseImage(&shadeImg);
    cvDestroyWindow("shade");
    //释放图像和矩阵
    cvReleaseImage(&pFrImg);
    cvReleaseImage(&pBkImg);
    //cvReleaseImage(&pBkImg1);
    /*cvReleaseMat(&pFrameMat);
    cvReleaseMat(&pFrMat);
    cvReleaseMat(&pBkMat);*/
    cvReleaseCapture(&pCapture);
    return 0;

}
cv.exp
关注
专栏目录
【MATLAB教程案例30】基于MATLAB的图像阴影检测和消除算法的实现
FPGA/MATLAB学习教程/源码/项目合作开发
10-25 2491
本课程，我们简单的介绍了下图像的阴影检测和去除算法。采用了基于颜色比例的方式来检测图像的阴影区域和亮度较高的区域。对于未来的学习过程中，如果有兴趣的通信，可以进一步学习基于深度学习的图像阴影检测和去除算法，基于小波变换的图像阴影检测和去除算法等。
使用VIBE算法进行车流量检测并消除鬼影、阴影
12-31
使用VIBE算法进行车流量检测并利用帧差法消除鬼影、利用梯度算子消除阴影
**深度解析与应用推荐：Mask-ShadowGAN——阴影去除的新突破**
最新发布
gitblog_00037的博客
06-16 730
深度解析与应用推荐：Mask-ShadowGAN——阴影去除的新突破 项目地址:https://gitcode.com/xw-hu/Mask-ShadowGAN 在计算机视觉领域，阴影问题一直是影响图像处理和分析准确性的关键因素之一。从简单的图像增强到复杂的场景理解任务，如何有效地去除阴影成为了研究人员关注的焦点。今天，我们将详细介绍一款名为Mask-ShadowGAN的开源项目，它利用生成对抗网...
数字图像处理（去除阴影）
12-05
一篇非常不错的英文原版的数字图像处理（去除阴影）论文~
GMM混合高斯背景建模 含去阴影
11-10
GMM混合高斯背景建模 含去阴影，源码包含算法实现部分
图像阴影去除
weixin_44576543的博客
12-14 4551
OpenCV的图像阴影去除
lw_11.rar_车辆 阴影_道路_道路 matlab_阴影 消除_阴影消除
07-14
这个源代码可以作为学习和研究阴影消除技术的一个实例，对于从事计算机视觉、图像处理或自动驾驶技术的研究者和开发者来说，具有很高的参考价值。它可以帮助理解如何在实际场景中解决阴影问题，提高图像分析的准确性...
论文研究-基于照度补偿的人脸图像遮挡阴影消除处理.pdf
07-22
为了消除人脸图像中的遮挡阴影对识别精度的影响，采用数学形态学处理对阴影进行检测分离，根据其照度损失不同划分为阴影边缘区和阴影主体区，分别实施照度补偿，并将非阴影区、阴影边缘区和阴影主体区光强光顺过渡，...
阴影去除matlab程序
04-23
阴影去除,This code is tested with MATLAB 2009b on Linux x86_64, 包含Meanshift代码
matlab精度检验代码-deshadow:交互式阴影去除
05-21
matlab精度检验代码交互式阴影去除 该存储库包含论文“”的代码，《美国光学学会杂志》（JOSA）A 2016。 版权所有:copyright:2016汉功（） 巴斯大学和东英吉利大学 该代码是根据GNU通用公共较小许可证（LGPL）3发布的。 要求 该代码已在MATLAB 2015b x64 Ubuntu上进行了测试。 其他版本的MATLAB可能也可以，但是结果可能并不相同。 注意 此代码是纯MATLAB脚本实现（非MEX）。 因此，它并未针对速度进行优化。 在此仅不共享参数训练代码。 但是，通常情况下，如果以良好的精度检测到二进制阴影掩码，则提供的默认参数集应该可以很好地完成工作。 如果要合并自己的自动阴影检测算法，只需用自己的二进制阴影蒙版图像替换deshadow.m中的变量“ smsk”。 用法 main.m是批处理阴影删除的驱动程序。 请参阅main.m或在MATLAB终端中执行doc main getinput.m是用于获取图像I用户输入的驱动程序。 参数是用于一般阴影去除的预训练参数集。 可变场景类别的阴影去除数据集和在线基准 为了鼓励在社区中对单个图像阴影去除进行公开比较，我们提供了和数
阴影去除资源matlab
03-22
一种阴影去除的MATLAB代码资源，效果没有测试，应该还行
matlab图像去除阴影代码-PyFmask:在PythonFmask算法中实现以对遥感中的云进行分类（卫星图像）
05-27
matlab图像去除阴影代码PyFmask 该存储库中的代码非常有待开发，非常试验。 但是，这并不意味着您不应该使用它！ 我们鼓励您尝试一下。 如果您对FMask有用，我们希望收到您的来信。 任何问题，绊脚石或问题都可以提出来，这可以很好地集中我们的努力并导致图书馆的改进。 快速开始 您将需要安装以下内容： 我们还没有合适的Python软件包。 您将需要下载存储库并将其本地化到当前工作目录。 IE： git clone https://github.com/akalenda/PyFmask.git cd PyFmask python3 它的用法很灵活，但是要快速入门，请使用Landsat8Scene.py的便捷方法： from Landsat8Scene import Landsat8Scene from Landsat8Scene import EXAMPLE_SCENE_IDS for scene in EXAMPLE_SCENE_IDS: (LandsatScene(scene) .download_scene_from_aws(will_overwrite=False) .da
matlab图像去除阴影代码-Frame-Based-Object-Detection-for-Traffic-Monitoring-Appl
05-27
matlab图像去除阴影代码基于帧的交通监控应用Matlab检测 目的是从视频流中检测车辆并对其进行监视。 该代码可以与每个具有稳定功能的摄像机一起使用。 根据您的视频分辨率，您可以采用该代码。 HSV彩色平面用于去除阴影。 通过使用基本的图像处理技术，可以正确检测物体。
matlab图像去除阴影代码-Vineyard_FastRCNN:使用快速R-CNN（具有卷积神经网络的区域）对象检测器在葡萄园中进行深度学习
05-27
matlab图像去除阴影代码Vineyard_FastRCNN 介绍 该项目提出了一种在农业环境中使用Matlab的基于快速区域的卷积神经网络方法（Fast R-CNN）的物体/障碍物检测器。 卷积神经网络近年来显着提高了图像分类和检测精度[1]。 可以以更高的置信度来检测具有多种光学特征和表面的特别复杂的场景和物体。 农业是异构几何形状和表面的杰出典范，给传统的计算机视觉方法带来了无数困难。 纵观现代葡萄园，控制杂草的一种逐渐普遍的方法是机械/物理去除植物下方的杂草。 因此，去除杂草的机具必须检测植物和其他障碍物以避免碰撞。 如下面所示，如果工具前有障碍物，则可以“感觉”到现有技术： 这种物理相互作用会损坏植物的树皮，从而使真菌生长。 非接触式系统，无论是基于传感器还是基于摄像头的实施方案，都可以对该主题产生积极影响，并且进一步允许农民收集有价值的信息，例如： 智能农场的数据挖掘， 自治系统 健康监测。 现代网络日益复杂 最近的CNN（例如VGG16，VGG19，GoogleNet或Inception网络）的复杂性和大小不断增加，导致对分类/检测的处理能力需求很高。 尽管在Amazo
MATLAB阴影提取
04-02
利用matlab工具，运用微分数学形态学算法提取阴影，提取结果可以较好的与原6影像进行匹配。
高斯混合模型在图像序列运动目标检测中的应用与阴影消除研究
此外，还在阴影消除实验中，对室外单个运动物体的检测结果进行阴影检测与消除，实现了无阴影的目标分割。 关键词：运动目标检测，高斯混合模型，阴影检测和消除。 这篇论文的工作为解决实时监控、视频分析等领域的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值