2013-09-06 22:57:46 kezunhai 阅读数 8940

           论文转载请注明出处:http://blog.csdn.net/kezunhai

           在前面的博文中,介绍了Moravec算子,并对moravec算子的不足也进行了简单的描述,具体请参考:图像处理特征算子系列之Moravec算子(一)。Harris算子针对Moravec算子的不足,提出了以下的改进:

         1)Moravec算子各向异性响应(Anisotropic Response of Operator

           Moravec算子仅仅在8个方向(水平、垂直和四个对角方向)计算灰度变化,为了对其扩展,有必要设计一个可以在任何方向对灰度变化进行测度的函数。1988年,Harris和Stephen通过对Moravec算子进行展开,推导得到了Plessey算子,也即Harris算子。

          我们先来看看与Harris相关的背景知识。通常,Prewitt算子被用来对图像的梯度进行近似。然而,在实际应用中,一阶梯度通过下图中的公式来进行近似:


对Morevec算子(如果对Moravec算子也不清楚的地方,请参考博主前一篇对Morevec算子的讲解)进行分析可以得到:Two Morevec windows中对应像素差的和可以作为图像梯度的合理近似。我们再来看下图:


通过对上图的分析,我们有可以进一步得到:morevec算子中的灰度变化可以采用图像梯度进行近似

         通过上面的分析,灰度的变化可以表示为图像梯度的函数,公式表示如下:


其中,(u,v)表示滑动,x方向为(1,0),y方向为(0,1),微分的计算如上图所示。

          到这里,大家非常明了:上式可以对moravec算子中的灰度变化计算进行精确的逼近。但是又与Moravec算子中灰度变化不同的是通过合理的选择(u,v)可以对任何方向的灰度变化进行测度。     

         2)噪声响应  (Noise Response   

            在Moravec算子中,滑动窗采用的是方形的(square window),方形窗使得不同方向上的中心像素与边界像素的欧式距离是变化的。为了克服这个问题,Harris&Stephen提出只需将方向窗改成圆窗(circle window)。同时,窗中的每个像素是同等地位的,理论上应该是离中心越近的权重越大,而离中心越远,权重越小,因此我们加入高斯权重。因此,灰度变化的新测度方式可以通过下图来表示:


         通过公式表示如下:

其中,wi表示位置i处的高斯权重。

           3)边缘的强响应(Large Response of Edge

            因为Moravec算子在边缘处很容易出现误检,Harris&Stephen通过考虑不同方向的灰度度量形成新的角度性测度(cornerness measure)。接着,我们对上面的式子进行变换,如下式:


Harris&Stephen同时也注意到,上式可以写成:


对上面的矩阵M,其特征值与图像表面的主曲率是成正比的,并且形成了对M的旋转不变的描述(Proportional to the principle curvature of the image surface and form a rotationally invariant description of M)。然后,由于M是通过水平和垂直方向的梯度来近似的,他们不是真正的旋转不变。

          同样,与Moravec算子一样,我们再来看下面的四张张图:


图中A表示在一个物体的内部或背景上,窗口内的灰度值相对不变,因此该窗口表面上几乎没有曲率,因此M的特征值相对很小;B窗口在一个边缘处,垂直于边缘的地方将有明显很大的曲率,而平行于边缘的地方几乎没什么曲率,因此该形式下M的特征值一个会比较大,另一个较小;C和D对应于角度和离散点,在两个方向都会有很大的曲率,因此,M的特征值都将会很大。假设r1和r2是M的两个特征值,通过上面的分析,可以将一个平面表示为以下三个可区分的区域:


            Harris&Stephen提出下面的角点性测度(cornerness measure)

:

k一般取值04~0.6。

         最后,我们来总结下Harris算子的计算步骤:

        ( 1)对每一个像素计算自相关矩阵M


        (2)构造角点性映射图(Construct cornerness map)

          

        (3)阈值化,对得到的C(x,y)进行阈值

       (4)非极大值抑制

          总结:Harris算子针对Moravec算子的不足进行了改进,提高了特征点的检测率以及Repeatability。但是,Harris算子计算量大,对尺度很敏感,不具有尺度不变形;另外Harris对特征点的定位也不是很精确,而且Harris也是各向异性的,对噪声敏感。


2016-01-07 15:06:30 lanchunhui 阅读数 2123
  • time domain:时域, 如speech signal;spatial domain: 空域, 如image
  • transform domain:变换域, 如傅里叶域的傅里叶系数,小波域的小波系数
  • corpus:预料库(文本建模基本术语),一般由多篇文档构成的可称为预料库,记一篇文档 d=w⃗ =(w1,w2,,wn)(由 n个单词构成);
  • signal corruption:noise, missing data and outliers.
  • on many benchmark visual datasets for different tasks
  • performance metrics(性能度量)
  • streaming workflows with pipelines

1. 计算机视觉的挑战

  1. viewpoint variation:视角
  2. scale variation:尺度
  3. deformation:变形
  4. occlusion:遮挡
  5. illumination conditions:照明
  6. background clutter:前景背景混淆
  7. Intra-class variation:类内的差异



2. DC(direct current)

直流。

  • 一个图像块的 DC,通常意味着其均值。还记得二维傅里叶变换,

    F(u,v)=xyf(x,y)ei2π(ux/M+vy/N)

    其在(0, 0)(频率原点),

    F(0,0)=xyf(x,y)

    就对应着直流分量。

3. Population Sparsity(种群稀疏) vs Lifetime Sparsity(存在稀疏)

Fn×m=Wn×dXd×m

  • d:表示原有的特征空间
  • n:变换后的特征空间
  • m:样本的数目
  • F:特征矩阵(Feature Matrix)

每个样本都只用很少的激活(非零)特征来描述。具体来说,对于特征矩阵的每一列(一个样本)f(i),只有很少的非零元素。其他的都是0 。例如,一幅图像可以由里面包含的一些目标来描述,如果里面存在很多可能的目标,那么在某一时刻,也只可能出现一些。我们称之为population sparsity(种群稀疏)。

好的特征应该是具有区分性的,这样才可以区分样本。例如需要区分人脸和人手,那么很明显,肤色不是区分性的特征,因为人脸和人手都有肤色。但如果看有没有眼睛,那么就很容易区分是人脸还是人手了,所以眼睛就是一个区分性的特征。所以要区分样本,就要选择样本独有的,而不是大家都有的特征。稍微学术点的表达就是,每个特征只允许在少量的样本内被激活。也就是说,在特征矩阵中,每一行(一种特征)应该只有少量的非零元素。这个特征的属性被称为lifetime sparsity(存在稀疏)。

4. High Dispersal(高分散性)

对每一行(一种特征在不同样本的时候的不同取值)的特征的分布,应该和其他行的特征的分布相似,或者说每种特征都应该具有相似的统计特性。具体来说,对矩阵的每一行,我们取该行所有元素(一种特征在不同样本的时候的不同取值)的平方后的均值作为其统计特性的描述。每一行都存在一个均值,那么每行的均值都应该是一样的,这样就可以认为所有的特征都具有相似的分布。这种属性我们称之为 high dispersal(高分散性)。但对于一个好的特征描述来说,这个属性并不是必要的。但它可以防止特征的退化,也就是可以防止提取到相同的特征(如果提取到相同的特征,那么特征既冗余,又没有增加信息量,所以一般都要求提取到的特征是正交的)。对于过完备的特征表达。high dispersal 可以理解为只有很少的 inactive 不活跃的特征。例如,PCA编码一般不会满足 high dispersal,因为大的特征值对应的特征向量(也就是特征code)大部分总是活跃active的。

2019-03-19 23:12:23 weixin_43837871 阅读数 179

图像映射

    图像映射就是图像之间的变换,加上使用一些计算变换的方法。可以实现图像扭曲变形和图像配准,适用于全景拼接。普遍变换方法有单应性变换、仿射变换、阿尔法通道等等。图像的映射类型有:平移、旋转、仿射、透视映射、尺度变换,不同的类型对应不一样的方法。经过这些处理就可以达到自己想要实现的映射效果。

(一)原理解析

(1)单应性变换(homography)

    矩阵的一个重要作用是将空间中的点变换到另一个空间中。比较形像直观地理解的方法就是图像变换,图像变换的方法很多,单应性变换是其中一种方法,单应性变换会涉及到单应性矩阵。单应性变换的目标是通过给定的几个点(通常是4对点)来得到单应性矩阵。以下为单应性矩阵的推导过程。

  

单应性矩阵 H 仅依赖尺度定义,所以,单应性矩阵具有 8 个独立自由度。通常会使第三个值为一来归一化点,即 :a 点坐标(x , y , z ) 转换成  a'  (x , y , 1)这样,点就具有唯一的图像坐标 x y 。这个额外的坐标使得我们可以简单使用一个矩阵来表示表换。例如:矩阵H会将一幅图像上的一个点的坐标 =(x,y,1)映射成另一幅图像上的点的坐标 =(x1,y1,1),已知 a b ,它们是在同一平面上。 则有下面的公式:

即:

由上面的公式   1=h31x+h32y+h331 可得到:

然后取 的最后一列出来作为求解hh。因为矩阵 是行满秩,即只有一个自由度。具体实现需要输入两张图片,在两张图片之间找到4个点坐标,由此得到矩阵H。

 

(2)仿射变换 

仿射变换(Affine Transformation )是一种二维坐标(x, y)到二维坐标(u, v)的线性变换,保持二维图形的"平直性"(即变换后直线还是直线不会打弯,圆弧还是圆弧)和"平行性"(译注:par常用的仿射变换:旋转、倾斜、平移、缩放allelness,指保持二维图形间的相对位置关系不变,平行线还是平行线,而直线上点的位置顺序不变,需要注意向量间夹角可能会发生变化)。由于仿射变换具有6个自由度,因此需要三个对应点对估计矩阵H。通过最后两个元素设置为0,再通过直接线性变换(DLT)估计算出。可以通过Haffine_from_points(fp,tp)函数使用对应点对来计算仿射变换矩阵。其线性表达式形式如下:

                                                                                                                        常用的仿射变换:旋转、倾斜、平移、缩放

对应的齐次坐标矩阵表示形式为:此类变换可以用一个3×3的矩阵来表示,其最后一行为(0, 0, 1)。该变换矩阵将原坐标(x, y)变换为新坐标(x', y'),这里原坐标和新坐标皆视为最末一行为(1)的三维列向量,原列向量左乘变换矩阵得到新的列向量:

 (3)alpha通道

阿尔法通道是一个8位的灰度通道,该通道用256级灰度来记录图像中的透明度信息,定义透明、不透明和半透明区域,其中白表示不透明,黑表示透明,灰表示半透明。

(二)仿射变换将一幅图像放置到另外一幅图像中

  仿射扭曲im1到im3的例子:

 # -*- coding: utf-8 -*-
from PCV.geometry import warp, homography
from PIL import  Image
from pylab import *
from scipy import ndimage



# example of affine warp of im1 onto im2

im1 = array(Image.open('E.jpg').convert('L'))
im2 = array(Image.open('G.jpg').convert('L'))
# set to points
#tp = array([[120,260,260,120],[16,16,305,305],[1,1,1,1]])
tp = array([[600,2250,2550,600],[500,500,2400,2400],[1,1,1,1]])
im3 = warp.image_in_image(im1,im2,tp)
figure()
gray()
subplot(141)
axis('off')
imshow(im1)
subplot(142)
axis('off')
imshow(im2)
subplot(143)
axis('off')
imshow(im3)

# set from points to corners of im1
m,n = im1.shape[:2]
fp = array([[0,m,m,0],[0,0,n,n],[1,1,1,1]])
# first triangle
tp2 = tp[:,:3]
fp2 = fp[:,:3]
# compute H
H = homography.Haffine_from_points(tp2,fp2)
im1_t = ndimage.affine_transform(im1,H[:2,:2],
(H[0,2],H[1,2]),im2.shape[:2])
# alpha for triangle
alpha = warp.alpha_for_triangle(tp2,im2.shape[0],im2.shape[1])
im3 = (1-alpha)*im2 + alpha*im1_t
# second triangle
tp2 = tp[:,[0,2,3]]
fp2 = fp[:,[0,2,3]]
# compute H
H = homography.Haffine_from_points(tp2,fp2)
im1_t = ndimage.affine_transform(im1,H[:2,:2],
(H[0,2],H[1,2]),im2.shape[:2])
# alpha for triangle
alpha = warp.alpha_for_triangle(tp2,im2.shape[0],im2.shape[1])
im4 = (1-alpha)*im3 + alpha*im1_t
subplot(144)
imshow(im4)
axis('off')
show()

  warp.py.

from scipy.spatial import Delaunay 
from scipy import ndimage
from pylab import *
from numpy import *

from PCV.geometry import homography
    

def image_in_image(im1,im2,tp):
    """ Put im1 in im2 with an affine transformation
        such that corners are as close to tp as possible.
        tp are homogeneous and counter-clockwise from top left. """ 
    
    # points to warp from
    m,n = im1.shape[:2]
    fp = array([[0,m,m,0],[0,0,n,n],[1,1,1,1]])
    
    # compute affine transform and apply
    H = homography.Haffine_from_points(tp,fp)
    im1_t = ndimage.affine_transform(im1,H[:2,:2],
                    (H[0,2],H[1,2]),im2.shape[:2])
    alpha = (im1_t > 0)
    
    return (1-alpha)*im2 + alpha*im1_t


def combine_images(im1,im2,alpha):
    """ Blend two images with weights as in alpha. """
    return (1-alpha)*im1 + alpha*im2    
    

def alpha_for_triangle(points,m,n):
    """ Creates alpha map of size (m,n) 
        for a triangle with corners defined by points
        (given in normalized homogeneous coordinates). """
    
    alpha = zeros((m,n))
    for i in range(min(points[0]),max(points[0])):
        for j in range(min(points[1]),max(points[1])):
            x = linalg.solve(points,[i,j,1])
            if min(x) > 0: #all coefficients positive
                alpha[i,j] = 1
    return alpha
    

def triangulate_points(x,y):
    """ Delaunay triangulation of 2D points. """
    
    centers,edges,tri,neighbors = md.delaunay(x,y)
    return tri


def plot_mesh(x,y,tri):
    """ Plot triangles. """ 
    
    for t in tri:
        t_ext = [t[0], t[1], t[2], t[0]] # add first point to end
        plot(x[t_ext],y[t_ext],'r')


def pw_affine(fromim,toim,fp,tp,tri):
    """ Warp triangular patches from an image.
        fromim = image to warp 
        toim = destination image
        fp = from points in hom. coordinates
        tp = to points in hom.  coordinates
        tri = triangulation. """
                
    im = toim.copy()
    
    # check if image is grayscale or color
    is_color = len(fromim.shape) == 3
    
    # create image to warp to (needed if iterate colors)
    im_t = zeros(im.shape, 'uint8') 
    
    for t in tri:
        # compute affine transformation
        H = homography.Haffine_from_points(tp[:,t],fp[:,t])
        
        if is_color:
            for col in range(fromim.shape[2]):
                im_t[:,:,col] = ndimage.affine_transform(
                    fromim[:,:,col],H[:2,:2],(H[0,2],H[1,2]),im.shape[:2])
        else:
            im_t = ndimage.affine_transform(
                    fromim,H[:2,:2],(H[0,2],H[1,2]),im.shape[:2])
        
        # alpha for triangle
        alpha = alpha_for_triangle(tp[:,t],im.shape[0],im.shape[1])
        
        # add triangle to image
        im[alpha>0] = im_t[alpha>0]
        
    return im
    
    
def panorama(H,fromim,toim,padding=2400,delta=2400):
    """ Create horizontal panorama by blending two images 
        using a homography H (preferably estimated using RANSAC).
        The result is an image with the same height as toim. 'padding' 
        specifies number of fill pixels and 'delta' additional translation. """ 
    
    # check if images are grayscale or color
    is_color = len(fromim.shape) == 3
    
    # homography transformation for geometric_transform()
    def transf(p):
        p2 = dot(H,[p[0],p[1],1])
        return (p2[0]/p2[2],p2[1]/p2[2])
    
    if H[1,2]<0: # fromim is to the right
        print ('warp - right')
        # transform fromim
        if is_color:
            # pad the destination image with zeros to the right
            toim_t = hstack((toim,zeros((toim.shape[0],padding,3))))
            fromim_t = zeros((toim.shape[0],toim.shape[1]+padding,toim.shape[2]))
            for col in range(3):
                fromim_t[:,:,col] = ndimage.geometric_transform(fromim[:,:,col],
                                        transf,(toim.shape[0],toim.shape[1]+padding))
        else:
            # pad the destination image with zeros to the right
            toim_t = hstack((toim,zeros((toim.shape[0],padding))))
            fromim_t = ndimage.geometric_transform(fromim,transf,
                                    (toim.shape[0],toim.shape[1]+padding)) 
    else:
        print ('warp - left')
        # add translation to compensate for padding to the left
        H_delta = array([[1,0,0],[0,1,-delta],[0,0,1]])
        H = dot(H,H_delta)
        # transform fromim
        if is_color:
            # pad the destination image with zeros to the left
            toim_t = hstack((zeros((toim.shape[0],padding,3)),toim))
            fromim_t = zeros((toim.shape[0],toim.shape[1]+padding,toim.shape[2]))
            for col in range(3):
                fromim_t[:,:,col] = ndimage.geometric_transform(fromim[:,:,col],
                                            transf,(toim.shape[0],toim.shape[1]+padding))
        else:
            # pad the destination image with zeros to the left
            toim_t = hstack((zeros((toim.shape[0],padding)),toim))
            fromim_t = ndimage.geometric_transform(fromim,
                                    transf,(toim.shape[0],toim.shape[1]+padding))
    
    # blend and return (put fromim above toim)
    if is_color:
        # all non black pixels
        alpha = ((fromim_t[:,:,0] * fromim_t[:,:,1] * fromim_t[:,:,2] ) > 0)
        for col in range(3):
            toim_t[:,:,col] = fromim_t[:,:,col]*alpha + toim_t[:,:,col]*(1-alpha)
    else:
        alpha = (fromim_t > 0)
        toim_t = fromim_t*alpha + toim_t*(1-alpha)
    
    return toim_t

输出结果:

1.仿射扭曲就是讲图像或者图像的一部分放置在另一幅图像中,使得它们能够和指定的区域或者标记物对齐。在函数image_in_image()中,函数的输入参数是两幅图像和一个坐标。该坐标为将第一幅图像放置到第二幅图像中的角点坐标:

设置仿射映射的目的坐标:

(三)遇到的问题

首先下载一个PCV包,然后进入cmd命令行窗口,进到pcv的路径下,输入:

具体步骤看链接:http://yongyuan.name/pcvwithpython/installation.html

cd PCV
python setup.py install

出现以上问题就是,你的python版本是python3,里面的warp.py里的删掉matplotlib包里一些方法,里面的matplotlib.delaunay不再被使用了,所以把它换成一个相同功能的就可以,可以在warp.py把import matplotlib.delaunay as md 换成from scipy.spatial import Delaunay,就可以运行。

 

DCN解读
2019-08-30 17:38:03 l2181265 阅读数 355

DCN论文的贡献是提出Deformable Conv。

论文创新:
1、Deformable Conv
2、Deformable ROI pooling

背景
深度学习对图像处理往往需要大量的数据集训练,是因为我们需要让网络学习到所有可能存在的情况,所以我们采用了数据增强的方法,如旋转、左右移、上下移、裁剪等操作。
但是针对图像目标尺度、姿态、角度、局部的变形等情况,基于经典卷积固定的几何结构,我们并不能完全模拟出来。
在这里插入图片描述

方法
于是,作者提出Deformable,对于3×3卷积核,经典卷积是第一幅图那样简单,紧密排列的样子;第三幅图是针对尺度和纵横比,改变之后的卷积核,类似与空洞卷积;第四幅图是针对图像旋转的卷积核;而第二幅是作者提出的,针对任意的图像改变,网络会学习到卷积核的一个偏移量,使网络可以适应目标不同的变化。
在这里插入图片描述

Deformable Conv
在这里插入图片描述
w(pn)是网络学习的参数(权重),即卷积核;x(p0+pn)是像素p0+pn的像素值,如下图,我们使用3×3的卷积核,pn是p0附近的8个坐标。
Δpn是基于经典卷积的偏移量,是需要输入数据通过网络学习而得的。
在这里插入图片描述

Deformable ROI pooling
看这个之前需要先了解一下Fast RCNN的ROI pooling,大致就是将ROI映射后的特征图分成几个小窗口,然后对每个小窗口做max pooling。可以看下我的Fast RCNN论文解读
在这里插入图片描述
Fast RCNN取得是max pooling,而本文中是取得mean pooling。这里也是通过学习它的偏移量,使ROI映射的小窗口更接近于真实的目标。

实例
Deformable Conv
这里每个图像针对采样位置(其中一个小绿点),使用3个激活单元(b图是显示的2个激活单元),采用3×3的deformable卷积核,所以(3×3)^3=729个小红点。
下图中左侧是分布的背景,中间是小目标分布,右图是大目标分布。
在这里插入图片描述
Deformable ROI pooling
这里将ROI映射分成3×3=9个小窗口,图中可以很容易理解,这9个小窗口都更偏向于目标。
在这里插入图片描述

2017-12-13 11:27:59 lingzidong 阅读数 276

总览

图像的几何变换主要是以下几种:缩放,旋转,仿射变换和透视
变换,接下来我们一一介绍。

图像的缩放:尺度变换

在opencv中提供了缩放的函数cv2.resize,这个函数可以按照倍数进行缩放,或者是直接将图像的大小变成指定的。说到缩放,我们首先想到的是如何处理变换之后图片中缺少的像素如何填充,在介绍缩放函数之前我们先来了解什么是插值。
插值算法,顾名思义就是如何填充/去掉图像中的像素,使得图像在变换大小过后中原有的特征得以保留。opencv支持的插值算法有三种:
cv2.INTER_AREA : 最近邻插值,把一个点的像素值直接设置为这个点最近的点的像素,但是这个方法会让图像出现很多色块
cv2.INTER_LINEAR : 双线性插值,这里使用了一维下的线性插值算法在二维上的推广,一维上的插值算法就是在两点之间填上一条直线,二维中只要4个方程对上下左右四个像素解方程就行
cv2.INTER_CUBIC:立方插值是在双线性插值算法的基础上进行改进,除了考虑函数值以外还添加了变化率的估量,只不过速度很慢就是了。
下面是代码的演示

import cv2
import numpy as np



img = cv2.imread(r"C:\Users\LIMN2O4\Pictures\lena.jpg")
# 按照倍数缩放


res1 = cv2.resize(img,(0,0),fx = 1.3,fy = 1.3,interpolation=cv2.INTER_CUBIC)

# 按照大小进行变化
res2 = cv2.resize(img,(500,500),interpolation=cv2.INTER_AREA)


cv2.imshow("out1",res1)
cv2.imshow("out2",res2)

cv2.waitKey(0)

图像的旋转

图像的旋转是通过图像的“投影”实现的,相当于将一张图像的某个点投影到另外一个点。我们将一个一个点投影到另外的点事实上变换算法的过程。我们将原矩阵乘以一个变换矩阵,得到的新矩阵就是投影完成之后的矩阵就是我们想要的图像。
具体的矩阵是通过cv2.getRotationMatrix2D 实现的,这个函数需要的参数是旋转的角度,之后将这个矩阵当作cv2.warpAffine 的参数就行:

import cv2
import numpy as np



img = cv2.imread(r"C:\Users\LIMN2O4\Pictures\lena.jpg")

# 旋转90°

row,col,ch = img.shape
M = cv2.getRotationMatrix2D(((col/2),(row/2)),90,1)
# 参数分别是中心点,角度,缩放尺度
res1 = cv2.warpAffine(img,M,(row,col))

cv2.imshow("out1",res1)

cv2.waitKey(0)

仿射变换和透视变换:

仿射变换很容易理解,就是在源图像中平行的直线,在变换之后的图像中仍然是平行的,这个方法需要三个点在变换前,变换后的坐标。
透视变换是保持原有图形的一种变换方法,在源图像中的直线,在变换后的时候仍是直线,这个方法需要4个点的坐标,我们需要创建一个np.float32 矩阵来保存这两种方法所需的矩阵和坐标点。

import cv2
import numpy as np



img = cv2.imread(r"C:\Users\LIMN2O4\Pictures\lena.jpg")

# 通过三个点的相对位置来确定整个图像

row,col,ch = img.shape

pts1 = np.float32([[0,0],[0,col],[row,0]])
pts2 = np.float32([[0,0],[100,col],[row,50]])
M1 = cv2.getAffineTransform(pts1,pts2)
res1 = cv2.warpAffine(img,M1,(row,col))

pts3 = np.float32([[0,0],[0,col],[row,0],[row,col]])
pts4 = np.float32([[10,10],[10,col-10],[row-10,10],[row-10,col-10]])
M2 = cv2.getPerspectiveTransform(pts3,pts4)

res2 = cv2.warpPerspective(img,M2,(row,col))

cv2.imshow("out1",res1)
cv2.imshow("out2",res2)
cv2.waitKey(0)

U-Net论文

阅读数 152

没有更多推荐了,返回首页