python实现泊松图像融合

本文实例为大家分享了python实现泊松图像融合的具体代码,供大家参考,具体内容如下

```
from __future__ import division
import numpy as np
import scipy.fftpack
import scipy.ndimage
import cv2
import matplotlib.pyplot as plt
#sns.set(style="darkgrid")

def DST(x):
  """
  Converts Scipy's DST output to Matlab's DST (scaling).
  """
  X = scipy.fftpack.dst(x,type=1,axis=0)
  return X/2.0

def IDST(X):
  """
  Inverse DST. Python -> Matlab
  """
  n = X.shape[0]
  x = np.real(scipy.fftpack.idst(X,type=1,axis=0))
  return x/(n+1.0)

def get_grads(im):
  """
  return the x and y gradients.
  """
  [H,W] = im.shape
  Dx,Dy = np.zeros((H,W),'float32'), np.zeros((H,W),'float32')
  j,k = np.atleast_2d(np.arange(0,H-1)).T, np.arange(0,W-1)
  Dx[j,k] = im[j,k+1] - im[j,k]
  Dy[j,k] = im[j+1,k] - im[j,k]
  return Dx,Dy

def get_laplacian(Dx,Dy):
  """
  return the laplacian
  """
  [H,W] = Dx.shape
  Dxx, Dyy = np.zeros((H,W)), np.zeros((H,W))
  j,k = np.atleast_2d(np.arange(0,H-1)).T, np.arange(0,W-1)
  Dxx[j,k+1] = Dx[j,k+1] - Dx[j,k]
  Dyy[j+1,k] = Dy[j+1,k] - Dy[j,k]
  return Dxx+Dyy

def poisson_solve(gx,gy,bnd):
  # convert to double:
  gx = gx.astype('float32')
  gy = gy.astype('float32')
  bnd = bnd.astype('float32')

  H,W = bnd.shape
  L = get_laplacian(gx,gy)

  # set the interior of the boundary-image to 0:
  bnd[1:-1,1:-1] = 0
  # get the boundary laplacian:
  L_bp = np.zeros_like(L)
  L_bp[1:-1,1:-1] = -4*bnd[1:-1,1:-1] \
           + bnd[1:-1,2:] + bnd[1:-1,0:-2] \
           + bnd[2:,1:-1] + bnd[0:-2,1:-1] # delta-x
  L = L - L_bp
  L = L[1:-1,1:-1]

  # compute the 2D DST:
  L_dst = DST(DST(L).T).T #first along columns, then along rows

  # normalize:
  [xx,yy] = np.meshgrid(np.arange(1,W-1),np.arange(1,H-1))
  D = (2*np.cos(np.pi*xx/(W-1))-2) + (2*np.cos(np.pi*yy/(H-1))-2)
  L_dst = L_dst/D

  img_interior = IDST(IDST(L_dst).T).T # inverse DST for rows and columns

  img = bnd.copy()

  img[1:-1,1:-1] = img_interior

  return img

def blit_images(im_top,im_back,scale_grad=1.0,mode='max'):
  """
  combine images using poission editing.
  IM_TOP and IM_BACK should be of the same size.
  """
  assert np.all(im_top.shape==im_back.shape)

  im_top = im_top.copy().astype('float32')
  im_back = im_back.copy().astype('float32')
  im_res = np.zeros_like(im_top)

  # frac of gradients which come from source:
  for ch in xrange(im_top.shape[2]):
    ims = im_top[:,:,ch]
    imd = im_back[:,:,ch]

    [gxs,gys] = get_grads(ims)
    [gxd,gyd] = get_grads(imd)

    gxs *= scale_grad
    gys *= scale_grad

    gxs_idx = gxs!=0
    gys_idx = gys!=0
    # mix the source and target gradients:
    if mode=='max':
      gx = gxs.copy()
      gxm = (np.abs(gxd))>np.abs(gxs)
      gx[gxm] = gxd[gxm]

      gy = gys.copy()
      gym = np.abs(gyd)>np.abs(gys)
      gy[gym] = gyd[gym]

      # get gradient mixture statistics:
      f_gx = np.sum((gx[gxs_idx]==gxs[gxs_idx]).flat) / (np.sum(gxs_idx.flat)+1e-6)
      f_gy = np.sum((gy[gys_idx]==gys[gys_idx]).flat) / (np.sum(gys_idx.flat)+1e-6)
      if min(f_gx, f_gy) <= 0.35:
        m = 'max'
        if scale_grad > 1:
          m = 'blend'
        return blit_images(im_top, im_back, scale_grad=1.5, mode=m)

    elif mode=='src':
      gx,gy = gxd.copy(), gyd.copy()
      gx[gxs_idx] = gxs[gxs_idx]
      gy[gys_idx] = gys[gys_idx]

    elif mode=='blend': # from recursive call:
      # just do an alpha blend
      gx = gxs+gxd
      gy = gys+gyd

    im_res[:,:,ch] = np.clip(poisson_solve(gx,gy,imd),0,255)

  return im_res.astype('uint8')

def contiguous_regions(mask):
  """
  return a list of (ind0, ind1) such that mask[ind0:ind1].all() is
  True and we cover all such regions
  """
  in_region = None
  boundaries = []
  for i, val in enumerate(mask):
    if in_region is None and val:
      in_region = i
    elif in_region is not None and not val:
      boundaries.append((in_region, i))
      in_region = None

  if in_region is not None:
    boundaries.append((in_region, i+1))
  return boundaries

if __name__=='__main__':
  """
  example usage:
  """
  import seaborn as sns

  im_src = cv2.imread('../f01006.jpg').astype('float32')

  im_dst = cv2.imread('../f01006-5.jpg').astype('float32')

  mu = np.mean(np.reshape(im_src,[im_src.shape[0]*im_src.shape[1],3]),axis=0)
  # print mu
  sz = (1920,1080)
  im_src = cv2.resize(im_src,sz)
  im_dst = cv2.resize(im_dst,sz)

  im0 = im_dst[:,:,0] > 100
  im_dst[im0,:] = im_src[im0,:]
  im_dst[~im0,:] = 50
  im_dst = cv2.GaussianBlur(im_dst,(5,5),5)

  im_alpha = 0.8*im_dst + 0.2*im_src

  # plt.imshow(im_dst)
  # plt.show()

  im_res = blit_images(im_src,im_dst)

  import scipy
  scipy.misc.imsave('orig.png',im_src[:,:,::-1].astype('uint8'))
  scipy.misc.imsave('alpha.png',im_alpha[:,:,::-1].astype('uint8'))
  scipy.misc.imsave('poisson.png',im_res[:,:,::-1].astype('uint8'))

  im_actual_L = cv2.cvtColor(im_src.astype('uint8'),cv2.cv.CV_BGR2Lab)[:,:,0]
  im_alpha_L = cv2.cvtColor(im_alpha.astype('uint8'),cv2.cv.CV_BGR2Lab)[:,:,0]
  im_poisson_L = cv2.cvtColor(im_res.astype('uint8'),cv2.cv.CV_BGR2Lab)[:,:,0]

  # plt.imshow(im_alpha_L)
  # plt.show()
  for i in xrange(500,im_alpha_L.shape[1],5):
    l_actual = im_actual_L[i,:]#-im_actual_L[i,:-1]
    l_alpha = im_alpha_L[i,:]#-im_alpha_L[i,:-1]
    l_poisson = im_poisson_L[i,:]#-im_poisson_L[i,:-1]

    with sns.axes_style("darkgrid"):
      plt.subplot(2,1,2)
      #plt.plot(l_alpha,label='alpha')

      plt.plot(l_poisson,label='poisson')
      plt.hold(True)
      plt.plot(l_actual,label='actual')
      plt.legend()

      # find "text regions":
      is_txt = ~im0[i,:]
      t_loc = contiguous_regions(is_txt)
      ax = plt.gca()
      for b0,b1 in t_loc:
        ax.axvspan(b0, b1, facecolor='red', alpha=0.1)

    with sns.axes_style("white"):
      plt.subplot(2,1,1)
      plt.imshow(im_alpha[:,:,::-1].astype('uint8'))
      plt.hold(True)
      plt.plot([0,im_alpha_L.shape[0]-1],[i,i],'r')
      plt.axis('image')
      plt.show()

  plt.subplot(1,3,1)
  plt.imshow(im_src[:,:,::-1].astype('uint8'))
  plt.subplot(1,3,2)
  plt.imshow(im_alpha[:,:,::-1].astype('uint8'))
  plt.subplot(1,3,3)
  plt.imshow(im_res[:,:,::-1]) #cv2 reads in BGR
  plt.show()

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • python opencv检测目标颜色的实例讲解

    实例如下所示: # -*- coding:utf-8 -*- __author__ = 'kingking' __version__ = '1.0' __date__ = '14/07/2017' import cv2 import numpy as np import time if __name__ == '__main__': Img = cv2.imread('example.png')#读入一幅图像 kernel_2 = np.ones((2,2),np.uint8)#2x2的卷积核

  • python opencv 图像尺寸变换方法

    利用Python OpenCV中的 cv.Resize(源,目标,变换方法)就可以实现变换为想要的尺寸了 源文件:就不用说了 目标:你可以对图像进行倍数的放大和缩小 也可以直接的输入尺寸大小 变换的方法: CV_INTER_NN - 最近邻插值, CV_INTER_LINEAR - 双线性插值 (缺省使用) CV_INTER_AREA - 使用象素关系重采样.当图像缩小时候,该方法可以避免波纹出现.当图像放大时,类似于 CV_INTER_NN 方法.. CV_INTER_CUBIC - 立方插值

  • python opencv设置摄像头分辨率以及各个参数的方法

    1,为了获取视频,你应该创建一个 VideoCapture 对象.他的参数可以是设备的索引号,或者是一个视频文件.设备索引号就是在指定要使用的摄像头.一般的笔记本电脑都有内置摄像头.所以参数就是 0.你可以通过设置成 1 或者其他的来选择别的摄像头.之后,你就可以一帧一帧的捕获视频了.但是最后,别忘了停止捕获视频.使用 ls /dev/video*命令可以查看摄像头设备 2,cap.read() 返回一个布尔值(True/False).如果帧读取的是正确的,就是 True.所以最后你可以通过检查

  • Python+OpenCV实现车牌字符分割和识别

    最近做一个车牌识别项目,入门级别的,十分简单. 车牌识别总体分成两个大的步骤: 一.车牌定位:从照片中圈出车牌 二.车牌字符识别 这里只说第二个步骤,字符识别包括两个步骤: 1.图像处理 原本的图像每个像素点都是RGB定义的,或者称为有R/G/B三个通道.在这种情况下,很难区分谁是背景,谁是字符,所以需要对图像进行一些处理,把每个RGB定义的像素点都转化成一个bit位(即0-1代码),具体方法如下: ①将图片灰度化 名字拗口,但是意思很好理解,就是把每个像素的RGB都变成灰色的RGB值,而灰色的

  • Python 3.x 安装opencv+opencv_contrib的操作方法

    Note:这篇文章不会包含任何的技术解答,仅是安装教程.同样不保证对所有可能的安装中遇到的问题都能适用.不过如果不幸又幸运地遇到了跟我一样的问题,我希望你能从我这里找到解决方案. 前言 最近做作业需要Python+opencv,但发现opencv.org官网中提供的包只支持2.7版本.因为Python已在Anaconda下已经安装了3.5且写了一些代码,所以并不想卸载了3.5重新安装2.7,所以查了资料想要能让opencv能在3.5上跑. 正文 环境:Win7, 64bit python ver

  • python使用opencv按一定间隔截取视频帧

    关于opencv OpenCV 是 Intel 开源计算机视觉库 (Computer Version) .它由一系列 C 函数和少量 C++ 类构成,实现了图像处理和计算机视觉方面的很多通用算法. OpenCV 拥有包括 300 多个 C 函数的跨平台的中.高层 API .它不依赖于其它的外部库 -- 尽管也可以使用某些外部库. OpenCV 对非商业应用和商业应用都是免费 的.同时 OpenCV 提供了对硬件的访问,可以直接访问摄像头,并且 opencv 还提供了一个简单的 GUI(graph

  • Python+OpenCV实现图像融合的原理及代码

    根据导师作业安排,在学习数字图像处理(刚萨雷斯版)第六章 彩色图像处理 中的彩色模型后,导师安排了一个比较有趣的作业: 融合原理为: 1 注意:遥感原RGB图image和灰度图Grayimage为测试用的输入图像: 2 步骤:(1)将RGB转换为HSV空间(H:色调,S:饱和度,V:明度): (2)用Gray图像诶换掉HSV中的V: (3)替换后的HSV转换回RGB空间即可得到结果. 书上只介绍了HSI彩色模型,并没有说到HSV,所以需要网上查找资料. Python代码如下: import cv

  • python+opencv识别图片中的圆形

    本文实例为大家分享了python+opencv识别图片中足球的方法,供大家参考,具体内容如下 先补充下霍夫圆变换的几个参数知识: dp,用来检测圆心的累加器图像的分辨率于输入图像之比的倒数,且此参数允许创建一个比输入图像分辨率低的累加器.上述文字不好理解的话,来看例子吧.例如,如果dp= 1时,累加器和输入图像具有相同的分辨率.如果dp=2,累加器便有输入图像一半那么大的宽度和高度. minDist,为霍夫变换检测到的圆的圆心之间的最小距离,即让我们的算法能明显区分的两个不同圆之间的最小距离.这

  • python实现泊松图像融合

    本文实例为大家分享了python实现泊松图像融合的具体代码,供大家参考,具体内容如下 ``` from __future__ import division import numpy as np import scipy.fftpack import scipy.ndimage import cv2 import matplotlib.pyplot as plt #sns.set(style="darkgrid") def DST(x): """ Conv

  • Python图像处理之图像融合与ROI区域绘制详解

    目录 一.图像融合 二.图像ROI区域定位 三.图像属性 (1)shape (2)size (3)dtype 四.图像通道分离及合并 (1)split()函数 (2)merge()函数 五.图像类型转换 六.总结 一.图像融合 图像融合通常是指多张图像的信息进行融合,从而获得信息更丰富的结果,能够帮助人们观察或计算机处理.图5-1是将两张不清晰的图像融合得到更清晰的效果图. 图像融合是在图像加法的基础上增加了系数和亮度调节量,它与图像的主要区别如下[1-3]: 图像加法:目标图像 = 图像1 +

  • python中opencv图像叠加、图像融合、按位操作的具体实现

    目录 1图像叠加 2图像融合 3按位操作 1图像叠加 可以通过OpenCV函数cv.add()或简单地通过numpy操作添加两个图像,res = img1 + img2.两个图像应该具有相同的深度和类型,或者第二个图像可以是标量值. NOTE: OpenCV添加是饱和操作,也就是有上限值,而Numpy添加是模运算. 添加两个图像时, OpenCV功能将提供更好的结果.所以总是更好地坚持OpenCV功能. 代码: import cv2 import numpy as np x = np.uint8

  • 使用Python实现图像融合及加法运算

    目录 一.图像加法运算 1.Numpy库加法 2.OpenCV加法运算 二.图像融合 三.图像类型转换 一.图像加法运算 1.Numpy库加法 其运算方法是:目标图像 = 图像1 + 图像2,运算结果进行取模运算. 当像素值<=255时,结果为“图像1+图像2”,例如:120+48=168 当像素值>255时,结果为对255取模的结果,例如:(255+64)%255=64 2.OpenCV加法运算 另一种方法是直接调用OpenCV库实现图像加法运算,方法如下: 目标图像 = cv2.add(图

  • Python中八大图像特效算法的示例详解

    目录 0写在前面 1毛玻璃特效 2浮雕特效 3油画特效 4马赛克特效 5素描特效 6怀旧特效 7流年特效 8卡通特效 0 写在前面 图像特效处理是基于图像像素数据特征,将原图像进行一定步骤的计算——例如像素作差.灰度变换.颜色通道融合等,从而达到期望的效果.图像特效处理是日常生活中应用非常广泛的一种计算机视觉应用,出现在各种美图软件中,这些精美滤镜背后的数学原理都是相通的,本文主要介绍八大基本图像特效算法,在这些算法基础上可以进行二次开发,生成更高级的滤镜. 本文采用面向对象设计,定义了一个图像

  • Python 将RGB图像转换为Pytho灰度图像的实例

    问题: 我正尝试使用matplotlib读取RGB图像并将其转换为灰度. 在matlab中,我使用这个: img = rgb2gray(imread('image.png')); 在matplotlib tutorial中他们没有覆盖它.他们只是在图像中阅读 import matplotlib.image as mpimg img = mpimg.imread('image.png') 然后他们切片数组,但是这不是从我所了解的将RGB转换为灰度. lum_img = img[:,:,0] 编辑:

  • Python实现PS图像明亮度调整效果示例

    本文实例讲述了Python实现PS图像明亮度调整效果.分享给大家供大家参考,具体如下: 这里用 Python 实现 PS 图像调整中的明度调整: 我们知道,一般的非线性RGB亮度调整只是在原有R.G.B值基础上增加和减少一定量来实现的,而PS的明度调整原理还得从前面那个公式上去找.我们将正向明度调整公式: RGB = RGB + (255 - RGB) * value / 255 转换为 RGB = (RGB * (255 - value) + 255 * value) / 255, 如果val

  • Python实现PS图像抽象画风效果的方法

    本文实例讲述了Python实现PS图像抽象画风效果的方法.分享给大家供大家参考,具体如下: 今天介绍一种基于图像分割和color map 随机采样生成一种抽象画风的图像特效,简单来说,就是先生成一张 color map 图,颜色是渐变的,然后针对要处理的图像,进行分割,这里用的是 SLIC 分割算法,然后从 color map 中随机采样,将采样得到的像素值赋予分割后的图像区域. # -*- coding: utf-8 -*- """ Created on Sun Aug 2

  • Python实现PS图像调整颜色梯度效果示例

    本文实例讲述了Python实现PS图像调整颜色梯度效果.分享给大家供大家参考,具体如下: 这里用 Python 实现 PS 中的色彩图,可以看到颜色的各种渐变,具体的效果可以参考附录说明 和之前的程序相比,这里利用矩阵的运算替代了 for 循环,提升了运行的效率. import numpy as np import matplotlib.pyplot as plt from skimage import io import numpy.matlib from skimage import img

随机推荐