opencv对图片的处理

最新推荐文章于 2019-06-21 15:42:52 发布
最新推荐文章于 2019-06-21 15:42:52 发布
阅读量868 收藏 1
点赞数
分类专栏： iOS 文章标签： opencv 图片
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ios_suda/article/details/12559627
版权

//根据车牌倾斜角校正车牌位置

void correctionPlatePositionForAngle(IplImage *srcImage,IplImage *destImage){

    IplImage *grayImage = nil;

    int thinTime = 0;

    IplImage *thinImage = cvCreateImage(cvSize(srcImage->width,srcImage->height),IPL_DEPTH_8U,1);

    changeToGrayImageASColor(srcImage, &grayImage,1);

    if (grayImage==NULL) {

        return;

    }

    cvThin(grayImage, thinImage, thinTime);

    

    // 3 . hough 找直线

    CvMemStorage * stroge = cvCreateMemStorage(0);

    CvSeq * lines = NULL;

    float *fline,fTheta;

    int angle;

    lines = cvHoughLines2(thinImage,stroge,CV_HOUGH_STANDARD,2,CV_PI/180,50,0,0);


    if (lines->total == 0) {

        isContinue = NO;

        return;

    }

    fline = (float*)cvGetSeqElem(lines,0);

    fTheta = fline[1]; // 过原点与直线垂直的直线与x轴夹角

    angle = (int)(fTheta *180/ CV_PI+0.5);

    if (angle >= 90 && angle <= 135)

    {

        angle = angle -90;

    }

    else if (angle >0 && angle <= 45)

    {

        

    }

    else if(angle >135 && angle < 180)

    {

        angle = 90 - angle;

    }else if (angle >45 &&angle <90)

    {

        angle = angle -90;

    }

    

    if (angle != 0) {

        float m[6];

        CvMat M = cvMat( 2, 3, CV_32F, m );

        CvPoint2D32f pt = cvPoint2D32f(thinImage->width/2.0, thinImage->height/2.0);

        cv2DRotationMatrix(pt, angle, 1.0, &M);

        cvWarpAffine(srcImage,destImage,&M,CV_INTER_AREA |CV_WARP_FILL_OUTLIERS,cvScalarAll(255));

    }else{

        cvCopy(srcImage, destImage);

    }

    

    cvReleaseMemStorage(&stroge);

    cvReleaseImage(&thinImage);

    cvReleaseImage(&grayImage);

}

//转换灰度图像，将指定颜色像素对应值255 其他颜色变为0

void changeToGrayImageASColor (IplImage *srcImage,IplImage **destImage,int flag = 1,int color = 0){

    IplImage* grayImage=cvCreateImage(cvSize(srcImage->width,srcImage->height),IPL_DEPTH_8U,1);

    int r,g,b;

    for( int y=0; y<srcImage->height; y++ ) {

        uchar* ptr = (uchar*) (srcImage->imageData + y * srcImage->widthStep);

        uchar * grayPtr = (uchar *)grayImage->imageData + grayImage->widthStep * y;

        for( int x=0; x<srcImage->width; x++ ) {

            b = ptr[4*x] ;

            g = ptr[4*x+1];

            r =  ptr[4*x+2];

            if (flag == 1) {//blue

                

            }

            

            switch (flag) {

                case 0://white

                    if (abs(r-b) < 35 && abs(g-b) < 35 && abs(r-g) < 35 &&(r > 175 || g > 175||b > 175)) {

                        grayPtr[x] = color?255:0;

                    }else{

                        grayPtr[x] = color?0:255;

                    }

                    ;

                    break;

                case 1://blue

                    if (2*b - r -g > 100) {

                        grayPtr[x] = color?0:255;

                    }else{

                        grayPtr[x] = color?255:0;

                    }

                    ;

                    break;

                case 2://yellow

                    ;

                    break;

                case 3://black

                    ;

                    break;

                default:

                    break;

            }

        }

    }

    

    if (destImage) {

        *destImage = grayImage;

    }

}

//大津法求阈值

int otsu(const IplImage *src_image)

{

    double sum = 0.0;

    double w0 = 0.0;

    double w1 = 0.0;

    double u0_temp = 0.0;

    double u1_temp = 0.0;

    double u0 = 0.0;

    double u1 = 0.0;

    double delta_temp = 0.0;

    double delta_max = 0.0;

    

    //src_image灰度级

    int pixel_count[256]={0};

    float pixel_pro[256]={0};

    int threshold = 0;

    uchar* data = (uchar*)src_image->imageData;

    //统计每个灰度级中像素的个数

    for(int i = 0; i < src_image->height; i++)

    {

        for(int j = 0;j < src_image->width;j++)

        {

            pixel_count[(int)data[i * src_image->width + j]]++;

            sum += (int)data[i * src_image->width + j];

        }

    }

    //计算每个灰度级的像素数目占整幅图像的比例

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

    {

        pixel_pro[i] = (float)pixel_count[i] / ( src_image->height * src_image->width );

    }

    //遍历灰度级[0,255],寻找合适的threshold

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

    {

        w0 = w1 = u0_temp = u1_temp = u0 = u1 = delta_temp = 0;

        for(int j = 0; j < 256; j++)

        {

            if(j <= i)   //背景部分

            {

                w0 += pixel_pro[j];

                u0_temp += j * pixel_pro[j];

            }

            else   //前景部分

            {

                w1 += pixel_pro[j];

                u1_temp += j * pixel_pro[j];

            }

        }

        u0 = u0_temp / w0;

        u1 = u1_temp / w1;

        delta_temp = (float)(w0 *w1* pow((u0 - u1), 2)) ;

        if(delta_temp > delta_max)

        {

            delta_max = delta_temp;

            threshold = i;

        }

    }

    return threshold;

}

//图片细化处理

void cvThin( IplImage* src, IplImage* dst, int iterations)

{

    //此时的src是一个二值化的图片

    CvSize size = cvGetSize(src);

    cvCopy(src, dst);

    

    int n = 0,i = 0,j = 0;

    for(n=0; n<iterations; n++)//开始进行迭代

    {

        IplImage* t_image = cvCloneImage(dst);

        for(i=0; i<size.height;  i++)

        {

            for(j=0; j<size.width; j++)

            {

                if(CV_IMAGE_ELEM(t_image,uchar,i,j)==255)

                {

                    int ap=0;

                    int p2 = (i==0)?0:CV_IMAGE_ELEM(t_image,uchar, i-1, j);

                    int p3 = (i==0 || j==size.width-1)?0:CV_IMAGE_ELEM(t_image,uchar, i-1, j+1);

                    if (p2==0 && p3==255)

                    {

                        ap++;

                    }

                    

                    int p4 = (j==size.width-1)?0:CV_IMAGE_ELEM(t_image,uchar,i,j+1);

                    if(p3==0 && p4==255)

                    {

                        ap++;

                    }

                    

                    int p5 = (i==size.height-1 || j==size.width-1)?0:CV_IMAGE_ELEM(t_image,uchar,i+1,j+1);

                    if(p4==0 && p5==255)

                    {

                        ap++;

                    }

                    

                    int p6 = (i==size.height-1)?0:CV_IMAGE_ELEM(t_image,uchar,i+1,j);

                    if(p5==0 && p6==1)

                    {

                        ap++;

                    }

                    

                    int p7 = (i==size.height-1 || j==0)?0:CV_IMAGE_ELEM(t_image,uchar,i+1,j-1);

                    if(p6==0 && p7==255)

                    {

                        ap++;

                    }

                    

                    int p8 = (j==0)?0:CV_IMAGE_ELEM(t_image,uchar,i,j-1);

                    if(p7==0 && p8==255)

                    {

                        ap++;

                    }

                    

                    int p9 = (i==0 || j==0)?0:CV_IMAGE_ELEM(t_image,uchar,i-1,j-1);

                    if(p8==0 && p9==255)

                    {

                        ap++;

                    }

                    if(p9==0 && p2==255)

                    {

                        ap++;

                    }

                    

                    if((p2+p3+p4+p5+p6+p7+p8+p9)>255 && (p2+p3+p4+p5+p6+p7+p8+p9)<7*255)

                    {

                        if(ap==1)

                        {

                            if(!(p2 && p4 && p6))

                            {

                                if(!(p4 && p6 && p8))

                                {

                                    CV_IMAGE_ELEM(dst,uchar,i,j)=0;//设置目标图像中像素值为0的点

                                }

                            }

                        }

                    }

                    

                }

            }

        }

        

        cvReleaseImage(&t_image);

        

        t_image = cvCloneImage(dst);

        for(i=0; i<size.height;  i++)

        {

            for(int j=0; j<size.width; j++)

            {

                if(CV_IMAGE_ELEM(t_image,uchar,i,j)==255)

                {

                    int ap=0;

                    int p2 = (i==0)?0:CV_IMAGE_ELEM(t_image,uchar, i-1, j);

                    int p3 = (i==0 || j==size.width-1)?0:CV_IMAGE_ELEM(t_image,uchar, i-1, j+1);

                    if (p2==0 && p3==255)

                    {

                        ap++;

                    }

                    int p4 = (j==size.width-1)?0:CV_IMAGE_ELEM(t_image,uchar,i,j+1);

                    if(p3==0 && p4==255)

                    {

                        ap++;

                    }

                    int p5 = (i==size.height-1 || j==size.width-1)?0:CV_IMAGE_ELEM(t_image,uchar,i+1,j+1);

                    if(p4==0 && p5==255)

                    {

                        ap++;

                    }

                    int p6 = (i==size.height-1)?0:CV_IMAGE_ELEM(t_image,uchar,i+1,j);

                    if(p5==0 && p6==255)

                    {

                        ap++;

                    }

                    int p7 = (i==size.height-1 || j==0)?0:CV_IMAGE_ELEM(t_image,uchar,i+1,j-1);

                    if(p6==0 && p7==255)

                    {

                        ap++;

                    }

                    int p8 = (j==0)?0:CV_IMAGE_ELEM(t_image,uchar,i,j-1);

                    if(p7==0 && p8==255)

                    {

                        ap++;

                    }

                    int p9 = (i==0 || j==0)?0:CV_IMAGE_ELEM(t_image,uchar,i-1,j-1);

                    if(p8==0 && p9==255)

                    {

                        ap++;

                    }

                    if(p9==0 && p2==255)

                    {

                        ap++;

                    }

                    if((p2+p3+p4+p5+p6+p7+p8+p9)>255 && (p2+p3+p4+p5+p6+p7+p8+p9)<7*255)

                    {

                        if(ap==1)

                        {

                            if(p2*p4*p8==0)

                            {

                                if(p2*p6*p8==0)

                                {

                                    CV_IMAGE_ELEM(dst, uchar,i,j)=0;

                                }

                            }

                        }

                    }

                }

                

            }

            

        }

        cvReleaseImage(&t_image);

    }

}

//计算像素点值

void countPixelsCountForEachCol(IplImage *srcImage,cv::vector<double>  & pixls){

    if (!srcImage) {

        return;

    }

    for (int col = 0; col < srcImage->width; col++) {

        pixls.push_back(0);

        for (int row = 0; row < srcImage->height; row++) {

            uchar * ptr = (uchar *)srcImage->imageData + srcImage->widthStep * row;

            int data = ptr[col];

            if (data > 0) {

                pixls[col]++;

            }

        }

    }

}

(Tensorflow之十六)采用Opencv对图像批量处理——灰度化+裁剪(python)
abiggg的博客
01-21 1万+
在Tensorflow之十五讲到采用python网络爬虫批量抓取图像，然而，由于抓取的图像尺寸不一，同时大多为RGB三通道的图像，因此需对图像进行处理。本文采用Opencv对的图像进行处理。首先将图像转为灰度图，采用物体检测的方法，抓取图像中的物体，裁剪成250x250尺寸的图像。一、Opencv图像处理过程1.1 读取原图import cv2 import numpy as np input_
opencv图像批处理过程示例
10-31
使用vs2017+Opencv3.2.0实现了图像批处理的过程，实现从txt文件中读取图像文件
图像处理库OpenCV
杀出条血路来
03-18 274
1、功能 处理图片，可以做到：人机互动、物体识别、图象分割、人脸识别、动作识别、运动跟踪和机器人。 2、OpenCV与OpenGL、Direct3D 后两者是处理3D，且为死对头。微软通过系统兼容，强制要求硬件厂商支持D3D，排斥OpenGL 3、类似图片处理库 OpenCV、FreeImage、CImg和CxImage。 四大图像库：OpenCV/FreeImage/CImg...
opencv实现二值图像细化的算法
深之JohnChen的专栏
06-02 2万+
opencv 图像细化
OpenCV学习(13) 细化算法(1)
weixin_34353714的博客
09-14 1616
程序编码参考经典的细化或者骨架算法文章： T. Y. Zhang and C. Y. Suen, “A fast parallel algorithm for thinning digital patterns,” Comm. ACM, vol. 27, no. 3, pp. 236-239, 1984. 它的原理也很简单：       我们对一副二值图像进行骨架提取，就是删除不需要的轮廓点...
图像细化算法 opencv实现 完整代码（附实验结果）
野草志
11-22 8912
一、关于图像细化的算法可以参看下面两个PDF链接： http://www.uel.br/pessoal/josealexandre/stuff/thinning/ftp/lam-lee-survey.pdf  ：总结了几乎所有92年以前的经典细化算法 http://www-prima.inrialpes.fr/perso/Tran/Draft/gateway.cfm.pdf ：本文所附代码
C#图片处理，opencv图片处理美化
07-15
在本项目中，我们关注的是使用C#语言和OpenCV库进行图片处理和美化。OpenCV是一个强大的开源计算机视觉库，它提供了丰富的功能来处理图像和视频。 首先，让我们深入了解一下C#中的图片处理。C#是一种面向对象的编程...
OpenCV-master_opencv图片处理_opencv窗体管理_opencv_emgucv_
10-01
在"OpenCV-master"这个项目中，主要涵盖了图片处理、窗体管理和与EmguCV相关的知识点。 图片处理是OpenCV的核心功能之一，包括基本操作如读取、保存图像，以及复杂的图像变换和分析。例如，可以使用OpenCV进行色彩...
c# 图片相似度处理，opencv
06-28
本文将详细介绍如何使用C#语言结合OpenCvSharp库来实现图片的相似度处理，包括SSIM（结构相似度指数）、PSNR（峰值信噪比）以及灰度和全彩直方图比较这四种方法。 1. **SSIM（Structural Similarity Index）** ...
Android OpenCV 图片灰度处理
04-28
如果你需要对这些图片进行灰度处理，你需要遍历文件，读取每一张图片，然后按照上述步骤进行处理。如果`MyFace`是一个目录，你可以使用Java的`File`类和`FileInputStream`来读取其中的文件。 总的来说，通过Android...
数字万用表(七段数码管)的图像识别(opencv实现)
xgbing
07-15 2万+
最近接触图像处理，要实现数字万用表数据的自动读取。我使用opencv+VC2005环境开发，OpenCV是Intel 开源计算机视觉库，它提供了强大的图像处理函数库。Opencv的介绍在这里太不多说，可以看看百度百科了解一下：http://baike.baidu.com/view/1343775.htm。         万用表的识别过程是先提取摄像头的一帧数据，然后对这幅图像做处理： (
C&C++图形图像处理开源库
墙角里的光线
10-30 2万+
Google三维APIO3D O3D 是一个开源的 WebAPI 用来在浏览器上创建界面丰富的交互式的 3D 应用程序。这是一种基于网页的可控3D标准。此格式期望真正的基于浏览器，独立于操作系统之外，并且支持主流的3D显卡，这样就可以在网页中实现效果逼真的3D动画。 绘图引擎RRDtoo 简单的说，RRDtool (RoundRobin Database Tool)就是一个强大的绘图的引擎，
opencv对图片处理
weixin_42074867的博客
06-21 266
一、裁剪图片 import cv2 figure=cv2.imread(r'E:\code\project\detect_all\total\0014.jpg') cv2.rectangle(figure,(700,200),(1000,400),(0,255,0),4) crop=figure[200:400,700:1000] cv2.imshow('test',figure) cv2.i...
OpenCV+C++图像处理设计-图片浏览器源码.zip
05-04
在本项目中，“OpenCV+C++图像处理设计-图片浏览器源码.zip”是一个包含使用OpenCV库和C++编程语言实现的图像浏览应用程序的压缩包。这个应用允许用户查看和处理图像，展示了OpenCV的强大功能以及C++在图形用户界面...
python用opencv批量截取图像指定区域
热门推荐
大力挥拳的专栏
01-15 3万+
代码如下 import os import cv2 for i in range(1,201): if i==169 or i==189: i = i+1 pth = "C:\\Users\\Desktop\\asd\\"+str(i)+".bmp" image = cv2.imread(pth) //从指定路径读取图像
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值