精华内容
下载资源
问答
  • 图像的基础操作学习目标掌握图像的读取和保存方法能够使用OpenCV在图像上绘制几何图形能够访问图像的像素能够获取图像的属性,并进行通道的分离和合并能够实现颜色空间的变换1 图像的IO操作这里我们会给大家介绍如何...

    图像的基础操作

    学习目标

    掌握图像的读取和保存方法

    能够使用OpenCV在图像上绘制几何图形

    能够访问图像的像素

    能够获取图像的属性,并进行通道的分离和合并

    能够实现颜色空间的变换

    1 图像的IO操作

    这里我们会给大家介绍如何读取图像,如何显示图像和如何保存图像。

    1.1 读取图像

    APIcv.imread()

    参数:

    要读取的图像

    读取方式的标志

    cv.IMREAD*COLOR:以彩色模式加载图像,任何图像的透明度都将被忽略。这是默认参数。

    cv.IMREAD*GRAYSCALE:以灰度模式加载图像

    cv.IMREAD_UNCHANGED:包括alpha通道的加载图像模式。

    可以使用1、0或者-1来替代上面三个标志

    参考代码

    import numpy as np

    import cv2 as cv

    # 以灰度图的形式读取图像

    img = cv.imread('messi5.jpg',0)

    注意:如果加载的路径有错误,不会报错,会返回一个None值

    1.2显示图像

    1 . API

    cv.imshow()

    参数:

    显示图像的窗口名称,以字符串类型表示

    要加载的图像

    注意:在调用显示图像的API后,要调用cv.waitKey()给图像绘制留下时间,否则窗口会出现无响应情况,并且图像无法显示出来。

    另外我们也可使用matplotlib对图像进行展示。

    参考代码

    # opencv中显示

    cv.imshow('image',img)

    cv.waitKey(0)

    # matplotlib中展示

    plt.imshow(img[:,:,::-1])

    1.3 保存图像

    API

    cv.imwrite()

    参数:

    文件名,要保存在哪里

    要保存的图像

    参考代码

    cv.imwrite('messigray.png',img)

    1.4 总结

    我们通过加载灰度图像,显示图像,如果按's'并退出则保存图像,或者按ESC键直接退出而不保存。

    import numpy as np

    import cv2 as cv

    import matplotlib.pyplot as plt

    # 1 读取图像

    img = cv.imread('messi5.jpg',0)

    # 2 显示图像

    # 2.1 利用opencv展示图像

    cv.imshow('image',img)

    # 2.2 在matplotplotlib中展示图像

    plt.imshow(img[:,:,::-1])

    plt.title('匹配结果'), plt.xticks([]), plt.yticks([])

    plt.show()

    k = cv.waitKey(0)

    # 3 保存图像

    cv.imwrite('messigray.png',img)

    2 绘制几何图形

    2.1 绘制直线

    cv.line(img,start,end,color,thickness)

    参数:

    img:要绘制直线的图像

    Start,end: 直线的起点和终点

    color: 线条的颜色

    Thickness: 线条宽度

    2.2 绘制圆形

    cv.circle(img,centerpoint, r, color, thickness)

    参数:

    img:要绘制圆形的图像

    Centerpoint, r: 圆心和半径

    color: 线条的颜色

    Thickness: 线条宽度,为-1时生成闭合图案并填充颜色

    2.3 绘制矩形

    cv.rectangle(img,leftupper,rightdown,color,thickness)

    参数:

    img:要绘制矩形的图像

    Leftupper, rightdown: 矩形的左上角和右下角坐标

    color: 线条的颜色

    Thickness: 线条宽度

    2.4 向图像中添加文字

    cv.putText(img,text,station, font, fontsize,color,thickness,cv.LINE_AA)

    参数:

    img: 图像

    text:要写入的文本数据

    station:文本的放置位置

    font:字体

    Fontsize :字体大小

    2.5 效果展示

    我们生成一个全黑的图像,然后在里面绘制图像并添加文字

    import numpy as np

    import cv2 as cv

    import matplotlib.pyplot as plt

    # 1 创建一个空白的图像

    img = np.zeros((512,512,3), np.uint8)

    # 2 绘制图形

    cv.line(img,(0,0),(511,511),(255,0,0),5)

    cv.rectangle(img,(384,0),(510,128),(0,255,0),3)

    cv.circle(img,(447,63), 63, (0,0,255), -1)

    font = cv.FONT_HERSHEY_SIMPLEX

    cv.putText(img,'OpenCV',(10,500), font, 4,(255,255,255),2,cv.LINE_AA)

    # 3 图像展示

    plt.imshow(img[:,:,::-1])

    plt.title('匹配结果'), plt.xticks([]), plt.yticks([])

    plt.show()

    结果:

    3 获取并修改图像中的像素点

    我们可以通过行和列的坐标值获取该像素点的像素值。对于BGR图像,它返回一个蓝,绿,红值的数组。对于灰度图像,仅返回相应的强度值。使用相同的方法对像素值进行修改。

    import numpy as np

    import cv2 as cv

    img = cv.imread('messi5.jpg')

    # 获取某个像素点的值

    px = img[100,100]

    # 仅获取蓝色通道的强度值

    blue = img[100,100,0]

    # 修改某个位置的像素值

    img[100,100] = [255,255,255]

    4 获取图像的属性

    图像属性包括行数,列数和通道数,图像数据类型,像素数等。

    5 图像通道的拆分与合并

    有时需要在B,G,R通道图像上单独工作。在这种情况下,需要将BGR图像分割为单个通道。或者在其他情况下,可能需要将这些单独的通道合并到BGR图像。你可以通过以下方式完成。

    # 通道拆分

    b,g,r = cv.split(img)

    # 通道合并

    img = cv.merge((b,g,r))

    6 色彩空间的改变

    OpenCV中有150多种颜色空间转换方法。最广泛使用的转换方法有两种,BGR↔Gray和BGR↔HSV。

    API:

    cv.cvtColor(input_image,flag)

    参数:

    input_image: 进行颜色空间转换的图像

    flag: 转换类型

    cv.COLOR_BGR2GRAY : BGR↔Gray

    cv.COLOR_BGR2HSV: BGR→HSV

    总结:

    图像IO操作的API:

    cv.imread(): 读取图像

    cv.imshow():显示图像

    cv.imwrite(): 保存图像

    在图像上绘制几何图像

    cv.line(): 绘制直线

    cv.circle(): 绘制圆形

    cv.rectangle(): 绘制矩形

    cv.putText(): 在图像上添加文字

    直接使用行列索引获取图像中的像素并进行修改

    图像的属性

    拆分通道:cv.split()

    通道合并:cv.merge()

    色彩空间的改变

    cv.cvtColor(input_image,flag)

    01.图像的IO操作.py

    import numpy as np

    import cv2 as cv

    import matplotlib.pyplot as plt

    # 1 读取图像

    img = cv.imread("image/dili.jpg",0)

    # 2 显示图像

    # 2.1 OPencv

    # cv.imshow("dili",img)

    # cv.waitKey(0)

    # cv.destroyAllWindows()

    # 2.2 matplotlib

    plt.imshow(img,cmap=plt.cm.gray)

    plt.show()

    # 3 图像保存

    cv.imwrite("image/dilireba.png",img)

    px = img[100,100]

    02.图像绘制图形.py

    import numpy as np

    import cv2 as cv

    import matplotlib.pyplot as plt

    # 1 创建图像

    img = np.zeros((512,512,3),np.uint8)

    # 2 绘制图形

    cv.line(img,(0,0),(511,511),(255,0,0),5)

    cv.circle(img,(256,256),60,(0,0,255),-1)

    cv.rectangle(img,(100,100),(400,400),(0,255,0),5)

    cv.putText(img,"hello",(100,150),cv.FONT_HERSHEY_COMPLEX,5,(255,255,255),3)

    # 3 显示结果

    plt.imshow(img[:,:,::-1])

    plt.show()

    In [1]:

    import numpy as np

    import cv2 as cv

    import matplotlib.pyplot as plt

    In [3]:

    img = np.zeros((256,256,3),np.uint8)

    In [4]:

    plt.imshow(img[:,:,::-1])

    Out[4]:

    In [5]:

    img[100,100]

    Out[5]:

    array([0, 0, 0], dtype=uint8)

    In [6]:

    img[100,100,0]

    Out[6]:

    0

    In [7]:

    img[100,100] = (0,0,255)

    In [8]:

    plt.imshow(img[:,:,::-1])

    Out[8]:

    In [9]:

    img[100,100]

    Out[9]:

    array([ 0, 0, 255], dtype=uint8)

    In [11]:

    img.shape

    Out[11]:

    (256, 256, 3)

    In [12]:

    img.dtype

    Out[12]:

    dtype('uint8')

    In [13]:

    img.size

    Out[13]:

    196608

    In [15]:

    dili = cv.imread("./image/dili.jpg")

    In [17]:

    plt.imshow(dili[:,:,::-1])

    Out[17]:

    In [18]:

    b,g,r = cv.split(dili)

    In [22]:

    plt.imshow(b,cmap=plt.cm.gray)

    Out[22]:

    In [23]:

    img2 = cv.merge((b,g,r))

    In [24]:

    plt.imshow(img2[:,:,::-1])

    Out[24]:

    In [25]:

    gray = cv.cvtColor(dili,cv.COLOR_BGR2GRAY)

    In [26]:

    plt.imshow(gray,cmap=plt.cm.gray)

    Out[26]:

    In [27]:

    hsv = cv.cvtColor(dili,cv.COLOR_BGR2HSV)

    In [28]:

    plt.imshow(hsv)

    Out[28]:

    原文链接:https://blog.csdn.net/zimiao552147572/article/details/105330897

    展开全文
  • 5.12 输出合并阶段

    2015-12-02 20:38:20
    像素着色器生成像素片段之后,它们移动到渲染管道的输出合并(OM)阶段。在这个阶段中,一些像素片段可拒绝(例如,从深度或模板缓冲区测试)。写入到后台缓冲区的像素片段将不拒绝。混合也在这个阶段完成,...

    在像素着色器生成像素片段之后,它们被移动到渲染管道的输出合并(OM)阶段。在这个阶段中,一些像素片段可被拒绝(例如,从深度或模板缓冲区测试)。被写入到后台缓冲区的像素片段将不拒绝。混合也在这个阶段完成,其中像素可以被当前在后台缓冲区的像素混合,而不是完全覆盖它。一些特殊效果像透明是通过混合实现;第9章致力于混合的讨论。

    本文固定链接:http://www.oxox.work/web/directx11/output-merger-stage-2/ | 虚幻大学

    展开全文
  • 在大气湍流条件较好而探测信标光信号极弱的工作条件下,自适应光学系统在实际的应用中需要采用子孔径合并的部分校正方式。本文针对云南天文台1.2m高分辨率自适应光学系统中的哈特曼-夏克(Hartmann-Shack)波前传感器...
  • 前一篇画出了最小外接矩形,但是有时候画出来的矩形由于中间像素干扰或者是其他原因矩形框并不是真正想要的 如图1是一个信号的雨图,矩形框分割成了多个小框: 需要合并矩形框达到的效果: 主要思想: ...

    前一篇画出了最小外接矩形,但是有时候画出来的矩形由于中间像素干扰或者是其他原因矩形框并不是真正想要的

    如图1是一个信号的雨图,被矩形框分割成了多个小框:

    需要合并矩形框达到的效果:

    主要思想:

    扫描两次最小外接矩形,第一次扫描出的矩形是图一的小矩形,遍历vector指定一个合并最大距离(假设是80),达到指定距离使用画矩形函数将这两个矩形占据的组合区域染成实心矩形。

    第二次扫描直接扫描之前画的实心矩形图确定最终边框

    过程图 膨胀处理和像素翻转:

    代码:

    #include "core/core.hpp"
    #include "highgui/highgui.hpp"
    #include "imgproc/imgproc.hpp"
    #include "iostream"
    #include "cmath"
    using namespace std;
    using namespace cv;int Distance(Rect rect1,Rect rect2)
    {
        // 用于判断rect1在rect2的第三象限里 用于反转X轴用
        bool isInversion;
        // 保存两个比较的点
        Point point1;
        Point point2;
        // 判断 rect1 在rect2的上面还是下面 也就是说是在第一、二象限还是在三四象限
        if(rect1.y<rect2.y)
        {
        // 判断rect1 在rect2的左边还是右边 也就是说是在 一象限还是二象限
            isInversion= rect1.x<rect2.x;
            if(isInversion )
            {
                // 取rect1的右上点
                point1 = Point(rect1.x+rect1.width,rect1.y+rect1.height);
                // 取rect2的左下点
                point2 = Point(rect2.x,rect2.y);
            }else
            {
                // 取rect1的左上点
                point1 = Point(rect1.x,rect1.y+rect1.height);
                // 取rect2的右下点
                point2 = Point(rect2.x+rect2.width,rect2.y);
            }
        }else
        {
        // 判断rect1 在rect2的左边还是右边 也就是说是在 三象限还是四象限
            isInversion = rect1.x>rect2.x;
            if(isInversion)
            {
                // 取rect2的右上点
                point1 = Point(rect2.x+rect2.width,rect2.y+rect2.height);
                // 取rect1的左下点
                point2 = Point(rect1.x,rect1.y);
            }else
            {
                // 取rect2的左上点
                point1 = Point(rect2.x,rect2.y+rect2.height);
                // 取rect1的右下点
                point2 = Point(rect1.x+rect1.width,rect1.y);
            }
        }
        // 做向量减法
        Point dPoint = point2 -point1;
        // 如果反转x轴
        dPoint.x = isInversion? dPoint.x:-dPoint.x;
        // 如果这个向量在第三象限里 那么这两个矩形相交 返回-1
        if(dPoint.x<0&& dPoint.y<0)
            return -1;
        // 如果x<0 返回y
        if(dPoint.x<0)
            return dPoint.y;
        // 如果y小于0 返回x
        if(dPoint.y<0)
            return dPoint.x;
        // 返回这个向量的长度
        return 2333;
    }
    
    Mat change(Mat src)
    {
        int cPointR,cPointG,cPointB,cPoint;
        for(int i=0; i<src.rows; i++)
        {
            for(int j=0; j<src.cols; j++)
            {
                cPointB=src.at<Vec3b>(i,j)[0]=src.at<Vec3b>(i,j)[0];
                cPointG=src.at<Vec3b>(i,j)[1]=src.at<Vec3b>(i,j)[1];
                cPointR=src.at<Vec3b>(i,j)[2]=src.at<Vec3b>(i,j)[2];
                if(cPointR>250||cPointG>250||cPointB>250)
                {
                    src.at<Vec3b>(i,j)[0]=0;
                    src.at<Vec3b>(i,j)[1]=0;
                    src.at<Vec3b>(i,j)[2]=0;
                }
                else
                {
                    src.at<Vec3b>(i,j)[0]=255;
                    src.at<Vec3b>(i,j)[1]=255;
                    src.at<Vec3b>(i,j)[2]=255;
                }
                cPointB=src.at<Vec3b>(i,j)[0]=src.at<Vec3b>(i,j)[0];
                cPointG=src.at<Vec3b>(i,j)[1]=src.at<Vec3b>(i,j)[1];
                cPointR=src.at<Vec3b>(i,j)[2]=src.at<Vec3b>(i,j)[2];
                //cout<<"("<<cPointB<<","<<cPointG<<","<<cPointR<<")"<<" ";
            }
            //cout<<endl;
        }
        return src;
    }
    //imageOut 原图   ;  dilation_dst膨胀图     ;imageSource单通道灰度图     ; imageTemp白图
    int main(int argc,char *argv[])
    {
    
        //freopen("stdout.txt","w",stdout);
        ///读图 读入一个3通道彩图
        Mat imageOut=imread(argv[1],1); //读入一个3通道彩图
        Mat grayImage;cvtColor(imageOut,grayImage,CV_BGR2GRAY); //存一个灰度图
        //imshow("3通道彩图",imageOut);
        Mat imageTemp=imread("C:\\Users\\Administrator\\Desktop\\Rec\\temp.png",1);  //读一个大小一样的白图
        ///腐蚀去噪处理
        Mat erosion_dst,temp;
        int erosion_size=20;
        Mat element = getStructuringElement( MORPH_RECT,Size( 2*erosion_size + 1, 2*erosion_size+1 ),
                                           Point( erosion_size, erosion_size ) ); //腐蚀去噪处理参数
        erode( imageOut,erosion_dst , element );//腐蚀去噪处理
        //imshow( "腐蚀去噪处理", erosion_dst );
        imwrite("C:\\Users\\Administrator\\Desktop\\Rec\\erosion_dst.png", erosion_dst);
        ///像素变换
        Mat change_dst=change(erosion_dst);
        //imshow( "像素变换", change_dst );
        imwrite("C:\\Users\\Administrator\\Desktop\\Rec\\change_dst.png", change_dst);
        ///单通道灰度图
        Mat imageSource;
        cvtColor(change_dst,imageSource,CV_BGR2GRAY); //转换为单通道灰度图
        //imshow("单通道灰度图",imageSource);
    
        ///接下来对imageSource单通道灰度图做处理
        Mat image;
        blur(imageSource,image,Size(3,3));
        threshold(image,image,0,255,CV_THRESH_OTSU);
        //imshow("image",image);
        //imwrite("C:\\Users\\Administrator\\Desktop\\Rec\\myimage.png", image);
    
        ///寻找最外层轮廓
        vector<vector<Point> > contours0;
        vector<Vec4i> hierarchy0;
        findContours(image,contours0,hierarchy0,RETR_EXTERNAL,CHAIN_APPROX_NONE,Point());
        //imshow("最外层轮廓",image);
    
        ///连接矩形区域///
        //Mat RECtest=imread("C:\\Users\\Administrator\\Desktop\\Rec\\temp.png",0);
        cout<<contours0.size()<<endl;
        for(int i=0; i<contours0.size()-1; i++)
        {
            RotatedRect rect_i=minAreaRect(contours0[i]);
            Point2f P_i[4];
            rect_i.points(P_i);
            rectangle(image,Point(P_i[2].x,P_i[2].y),Point(P_i[0].x,P_i[0].y),Scalar(255,255,255),-1,1);
            for(int j=i+1; j<contours0.size(); j++)
            {
                RotatedRect rect_j=minAreaRect(contours0[j]);
                Point2f P_j[4];
                rect_j.points(P_j);
                double recArea_i=contourArea(contours0[i]);
                double recArea_j=contourArea(contours0[j]);
                //cout<<(P_i[3].x-P_i[2].x)*(P_i[1].y-P_i[2].y)<<" -> "<<(P_j[3].x-P_j[2].x)*(P_j[1].y-P_j[2].y)<<"   ";
                Rect r_j = rect_j.boundingRect();
                Rect r_i = rect_i.boundingRect();
                //cout<<recArea_i<<" -> "<<recArea_j<<"     "<<Distance(r_i,r_j)<<"     ";
                if(Distance(r_i,r_j)<=100)
                {
                    int minx=min(P_i[2].x,P_j[2].x);
                    int maxx=max(P_i[3].x,P_j[3].x);
                    int miny=min(P_i[2].y,P_j[2].y);
                    int maxy=max(P_i[0].y,P_j[0].y);
                    rectangle(image,Point(minx,miny),Point(maxx,maxy),Scalar(255,255,255),-1,1);//画实心矩形
                    //rectangle(RECtest,Point(minx,miny),Point(maxx,maxy),Scalar(0,0,0),-1,1);
                    //cout<<minx<<","<<miny<<" "<<maxx<<","<<maxy<<endl;
                    //line(image,P_i[2],P_j[0],Scalar(0,0,0),1);   //画线
                    //line(RECtest,P_i[2],P_j[0],Scalar(0,0,0),1);
                    //cout<<"yes";
                }
                //cout<<endl;
                /*rect_i=rect_j;
                for(int k=0;k<=3;k++)
                {
                    P_i[k].x=P_j[k].x;
                    P_i[k].y=P_j[k].y;
                }*/
            }
            //cout<<"---------------------------------------------------"<<endl;
        }
        //imwrite("C:\\Users\\Administrator\\Desktop\\Rec\\RECtest.png", RECtest);
        ///
        /*
        */
        ///
        //imshow("实心矩形",image);
        //imwrite("C:\\Users\\Administrator\\Desktop\\Rec\\images.png", image);
        vector<vector<Point> > contours;
        vector<Vec4i> hierarchy;
        findContours(image,contours,hierarchy,RETR_EXTERNAL,CHAIN_APPROX_NONE,Point());
        Mat imageContours=Mat::zeros(image.size(),CV_8UC1);    //最小外接矩形画布
    
    
        for(int i=0; i<contours.size(); i++)
        {
            ///绘制轮廓
            drawContours(imageContours,contours,i,Scalar(0,0,0),1,8,hierarchy);
    
    
            ///绘制轮廓的最小外结矩形
            RotatedRect rect=minAreaRect(contours[i]);
            Point2f P[4];
            rect.points(P);
    
            int minx=min(P[1].x,P[2].x);
            int maxx=max(P[3].x,P[0].x);
            int miny=min(P[2].y,P[3].y);
            int maxy=max(P[1].y,P[0].y);
            rectangle(grayImage,Point(minx,miny),Point(maxx,maxy),Scalar(0,0,0),1,1);//二值图绘线
            rectangle(imageOut,Point(minx,miny),Point(maxx,maxy),Scalar(0,0,0),1,1);//原图绘线
            rectangle(imageTemp,Point(minx,miny),Point(maxx,maxy),Scalar(0,0,0),1,1);//白图
    
        }
        imwrite("C:\\Users\\Administrator\\Desktop\\Rec\\new1.png", grayImage);
        imwrite("C:\\Users\\Administrator\\Desktop\\Rec\\new2.png", imageOut);
        imwrite("C:\\Users\\Administrator\\Desktop\\Rec\\new3.png", imageTemp);
        waitKey(0);
        return 0;
    }

     

    转载于:https://www.cnblogs.com/dzzy/p/9267995.html

    展开全文
  • (2)然后将种子像素周围邻域中与种子像素有相同或相似性质的像素(根据某种事先确定的生长或相似准则来判定)合并到种子像素所在的区域中。 (3)将这些新像素当做新的种子像素继续进行上面的过程,知道没有满足...

    ★区域生长

    ●区域生长的基本思想是将具有相似性质的像素集合起来构成区域。

    (1)首先对每个需要分割的区域找一个种子像素为生长的起点;

    (2)然后将种子像素周围邻域中与种子像素有相同或相似性质的像素(根据某种事先确定的生长或相似准则来判定)合并到种子像素所在的区域中。

    (3)将这些新像素当做新的种子像素继续进行上面的过程,知道没有满足条件的像素可被包括进来。

    ●这样一个区域就长成了。

    ●如借助逻辑谓词的概念,就是在生长过程中要始终保持:P(Ri) =  TRUE   (Ri代表区域,P代表某种属性)

    ●采用的判断准则是:如果所考虑的像素与种子像素灰度值差的绝对值小于某个门限T,则将该像素包括种子像素所在区域。(种子的选择和门限的选择)


    在实际应用区域生长法时需要解决的三个问题:

    (1)选择或确定一组能正确代表所需区域的种子像素;

    (2)确定在生长过程中能将相邻像素包括进来的准则;

    (3)制定让生长停止的条件或规则。


    常用的解决办法:

    ●种子像素的选取可借助具体问题的特点。如军用红外图像中检测目标时,由于一般情况下目标辐射较大,选用图中最亮的像素作为种子像素。若果对具体问题没有先验知识,则可借助生长所用准则对每个像素进行相应计算。如果计算结果呈现聚类的情况,则接近聚类重心的像素可取为种子像素。因为你生长准则为基于灰度值的差,所以各选一个具有聚类中心灰度值的像素作为种子。

    ●生长准则的选取不仅依赖具体问题,也和所用图像数据的种类有关。例如当图像是彩色的,仅用单色的准则,效果就会受到影响。另外还需要考虑像素间的连通性和邻近性,否则有时会出现无意思的分割结果。

    ●一般生长过程在进行到没有满足生长准则需要的像素时停止。但常用的基于灰度、纹理、彩色的准则大都基于图像中的局部性质、并没有充分考虑生长的“历史”。为增加区域生长的能力常需考虑一些与尺寸、形状等图像全局性质有关的准则。在这种情况下常需对分割结果建立一定的模型。


    ★分裂合并

    ●区域生长法是从单个种子像素开始通过不断接纳新像素得到整个区域——从小到大。

    ●从整幅图像开始通过不断分裂得到各个区域——从大到小

    ●实际中常先把图像分成任意大小且不重叠的区域,然后再合并或分裂这些区域以满足分割的要求。

    ●利用图像四叉树表达方法的迭代分裂合并算法。


    分裂合并算法的基本步骤(不确定的继续分、确定下来的不再分):

    (1)对任一区域Ri,如果P(Ri)= FALSE(表示既有目标又有背景、P(Ri)= TRUE代表代表在R中的所有像素都具有相同的灰度值),就将其分裂成不重叠的四等分;

    (2)对相邻的两个区域Ri和Rj,如果P(Ri∪Rj)= TRUE(要么同为背景、要么同为前景),就将它们合并起来;

    (3)如果进一步的分裂或合并都不可能了,则结束。

    改进:可将原图先分裂成一组正方块,进一步分裂仍按上述方法进行,但先仅合并并在四叉树表达式中属于用一个父节点且满足逻辑谓词P的四个区域(分完再合,用得同一个四叉树,算法更节约)。如果这种类型的合并不再可能了,在整个分割过程结束前再最后按满足上述第二步的条件进行一次合并,注意此时合并的各个区域有可能彼此尺寸不同。

    改进方法的主要优点:在最后一步合并前,分裂和合并用的都是同一四叉树。


    ★★★★★★★★★★★★★★★感谢上海交大——赵宇明老师★★★★★★★★★★★★★★★★


    展开全文
  • import cv2 as cv import numpy as np 泛洪填充算法(Flood Fill Algorithm) 泛洪填充算法又称洪水填充算法是在很多图形绘制...的颜色,直到封闭区域内的所有像素点都填充新颜色为止。泛红填充实现最常见有四邻域...
  • 在手机像素不断提升的当下,使用手机拍照是很常见的。每个人的手机相册里都会保存一部分重要的照片,当这些照片删掉该怎么恢复?由于苹果手机相册自带有最近删除相簿,我们删除的照片可以通过这个相簿恢复,不过...
  • 5.12 输出合并阶段在像素片段被像素着色器生成之后,接下来就是渲染管线中的输出合并阶段了。在这个阶段,一些像素点也许会踢出(比如深度模板测试)。没有踢出的像素片段就写入后台缓存。融合也是在这个阶段...
  • OpenCV - 区域生长算法

    万次阅读 多人点赞 2015-11-27 16:13:21
    对每一个区域要先指定一个种子点作为生长的起点,然后将种子点周围领域的像素点和种子点进行对比,将具有相似性质的点合并起来继续向外生长,直到没有满足条件的像素被包括进来为止。这样一个区域的生长就完成了。这...
  • 区域生长的基本方法是从分割对象里作为种子区域 ( 通常是一个或多个像素 ) 的一个区域开始,在种子区域的相邻像素寻找与种子像素有相同或相似性质的像素,并将这些像素合并到种子像素所在的区域中。将这些新像素...
  • 单点区域生长算法

    千次阅读 2018-10-01 13:05:52
    对每一个区域要先指定一个种子点作为生长的起点,然后将种子点周围领域的像素点和种子点进行对比,将具有相似性质的点合并起来继续向外生长,直到没有满足条件的像素被包括进来为止。这样一个区域的生长就完成了。这...
  • opencv笔记(六)——区域生长算法

    千次阅读 2018-07-26 20:33:08
    对每一个区域要先指定一个种子点作为生长的起点,然后将种子点周围领域的像素点和种子点进行对比,将具有相似性质的点合并起来继续向外生长,直到没有满足条件的像素被包括进来为止。这样一个区域的生长就完成了。这...
  • 对每一个区域要先指定一个种子点作为生长的起点,然后将种子点周围领域的像素点和种子点进行对比,将具有相似性质的点合并起来继续向外生长,直到没有满足条件的像素被包括进来为止。这样一个区域的生长就完成了。这...
  • CV | 区域生长算法

    2020-08-21 17:10:55
    对每一个区域要先指定一个种子点作为生长的起点,然后将种子点周围领域的像素点和种子点进行对比,将具有相似性质的点合并起来继续向外生长,直到没有满足条件的像素被包括进来为止。这样一个区域的生长就完成了。 ...
  • 对每一个区域要先指定一个种子点作为生长的起点,然后将种子点周围领域的像素点和种子点进行对比,将具有相似性质的点合并起来继续向外生长,直到没有满足条件的像素被包括进来为止。这样一个区域的生长就完成了。这...
  • 区域生长算法

    千次阅读 2018-12-15 20:54:21
    具体先对每个需要分割的区域找一个种子像素作为生长的起点,然后将种子像素周围邻域中与种子像素具有相同或相似性质的像素(根据某种事先确定的生长或相似准则来判定)合并到种子像素所在的区域中。将这些新像素当做...
  • 区域生长法

    千次阅读 2018-06-16 21:07:56
    具体先对每个需要分割的区域找一个种子像素作为生长的起点,然后将种子像素周围邻域中与种子像素具有相同或相似性质的像素(根据某种事先确定的生长或相似准则来判定)合并到种子像素所在的区域中。将这些新像素当做...
  • 运动目标分割--区域生长

    千次阅读 2016-06-23 16:38:35
    具体先对每个需要分割的区域找一个种子像素作为生长的起点,然后将种子像素周围邻域中与种子像素有相同或相似性质的像素(根据某种事先确定的生长或相似准则来判定)合并到种子像素所在的区域中。将这些新像素当作新的...
  • 图像分割-区域生长

    2012-07-25 15:49:00
    然后将种子像素周围领域中与种子像素有相同或相似性质的像素(根据某种实现确定的生长或相似准则来判断)合并到种子像素所在的区域中,将这些新像素当作新的种子像素继续进行上面的过程,知道再没有满足条件的像素...
  • Photoshop 练习题二 一单项选择题 将...如果一个图层锁定那么下列说法哪个是不正确的 此图层可以移动 此图层可以进行任何的编辑 此图层不可能编辑 此图层像素可以改变 下列哪种合并将一个图像中所有图层合并到一
  • 被合并的文件支持gif, tif, png, jpg, bmp等格式,最后合并成gif或者tif格式。支持用户设置被合并的文件的顺序,支持不同的文件。比如被合并的文件中,有文件本省就是一个多帧图片文件,这时候也也可以一起合并。...
  • 被合并的文件支持gif, tif, png, jpg, bmp等格式,最后合并成gif或者tif格式。支持用户设置被合并的文件的顺序,支持不同的文件。比如被合并的文件中,有文件本省就是一个多帧图片文件,这时候也也可以一起合并。...
  • 对常规的直方图均衡算法进行了改进,避免了不同灰度的像素均衡后被合并、图像细节丢失等现象。实验结果表明,改进的直方图均衡新算法既能充分增强图像的对比度,又能保持图像的局部细节,使图像具有更加自然的视觉...
  • 分水岭算法记录

    2020-12-14 10:47:31
    传统的形态学分水岭算法见 数字图像处理 主要思想是对于无标记...主要思想是对于标记图片,根据r,g,b像素距离确定查找优先级,更小的更早查找划分,当某像素的四邻域只有一个标记为已知区域,则将该像素划分至..
  • 原理:把原始图像的灰度直方图从比较集中的某个灰度区间变成在全部灰度值范围内的均匀分布,是对原图像的灰度值...灰度级“归并”现象:一幅图像经过直方图均衡化处理后,出现概率较小像素的灰度级将会被合并,灰度...
  • Shader - Pass (五)

    2015-11-28 10:34:07
    当图像渲染时,所有着色器执行以后,所有贴图应用后,像素写到屏幕。他们是如何通过Blend命令的控制和已有的图像合并呢?Syntax 语法 Blend Off: 关闭混合 Blend SrcFactor DstFactor:配置并启动混合。...
  • 当图像渲染时,所有着色器执行以后,所有贴图应用后,像素写到屏幕。他们是如何通过Blend命令的控制和已有的图像合并呢? Syntax 语法 Blend OffTurn off blending关闭混合BlendSrcFactor DstFactor配置...
  • 混合和过度绘制 在第12章有提到,GPU每一帧可以绘制的...GPU会放弃绘制那些完全其他图层遮挡的像素,但是要计算出一个图层是否遮挡也是相当复杂并且会消耗处理器资源。同样,合并不同图层的透明重叠像素(即混...
  • 总结canvas刮刮乐游戏

    2020-03-23 19:18:40
    2.利用新旧像素合并的时候擦掉 ctx.globalCompositeOperation = 'destination-out' 3.快速移动会出现断点,那就直接让两边落下的地方连成线 4.利用getImageData这个方法获得里面的data,data里包含了每一个像素点...
  • 光栅化具体描述

    2018-08-19 21:04:12
    和几何形状阶段类似,本阶段也细分为几个功能阶段:建立三角形、遍历三角形、像素着色和合并,如图2.8。 2.4.1 建立三角形 本阶段计算三角形表面的差值和其他数据。该数据用于扫描转换,以及几何形状阶段生成的...

空空如也

空空如也

1 2 3 4 5 6
收藏数 108
精华内容 43
关键字:

像素被合并