将一副图像映射到另一幅图像内的操作。
dst = cv2.resize( src, dsize[, fx[, fy[, interpolation]]] )
cv2.resize() 的dsize 参数与图像shape 属性在行,列的顺序上是不一样的。shape中,(行,列),dsize中(列,行)
dst=cv2.flip(src, flipCode)
filpCode旋转类型
img=cv2.imread("5.jpg")
x=cv2.flip(img,0)
y=cv2.flip(img,1)
xy=cv2.flip(img,-1)
cv2.imshow("img",img)
cv2.imshow("x",x) # 沿x轴翻转
cv2.imshow("y",y)
cv2.imshow("xy",xy) # 都翻一下。。。。
cv2.waitKey()
cv2.destroyAllWindows()
仿射变换是指图像可以通过一系列的几何变换实现平移,旋转等多种操作。改变换能够保持图像的平直性和平行性。平直性是经过仿射变换后直线还是直线,平行性是指,经过仿射变换后,平行线仍是平行线。
dst = cv2.warpAffine( src, M, dsize[, flags[, borderMode[, borderValue]]] )
通过转换矩阵M 将原始图像src转换成目标图像dst。dst(, ) = src(11 + 12 + 13, 21 + 22 + 23)。所以,进行何种形式的仿射变换完全取决于转换矩阵M。下面介绍不同M实现的仿射变换。
将原图右移100像素,向下200像素 dst (x, y) = src (1·x + 0·y + 100, 0·x + 1·y + 200)。得到转换矩阵 M=[[1,0,100],[0,1,200]]
img=cv2.imread("5.jpg")
height,width=img.shape[:2]
x=100
y=200
M = np.float32([[1, 0, x], [0, 1, y]])
move=cv2.warpAffine(img,M,(width,height))
cv2.imshow("original",img)
cv2.imshow("move",move)
cv2.waitKey()
cv2.destroyAllWindows()
retval=cv2.getRotationMatrix2D(center, angle, scale)
通过这个函数获得转换矩阵,参数是中心点,旋转角度(正数逆时针),缩放大小。
height,width=img.shape[:2]
M=cv2.getRotationMatrix2D((width/2,height/2),45,0.6)# 以图形中心为圆点,逆时针45度,将图像缩小为原图的0.6倍。
rotate=cv2.warpAffine(img,M,(width,height))
cv2.imshow("original",img)
cv2.imshow("rotation",rotate)
cv2.waitKey()
cv2.destroyAllWindows()
对于更复杂的仿射变换,Opencv提供了cv2.getAffineTransform() 来生成仿射函数 cv2.warpAffine() 所使用的转换矩阵M。
retval=cv2.getAffineTransform(src, dst)
src 输入图像的三个点,dst 表示输出图像的三个点坐标。这两个参数是包含三个二维数组(x,y) 点的数组。函数定义了两个平行四边形,三个点分别对应四边形的左上角,右上角,左下角。函数 cv2.warpAffine()以函数 cv2.getAffineTransform()获取的
转换矩阵 M 为参数,将 src 中的点仿射到 dst 中。函数 cv2.getAffineTransform()对所指定的点
完成映射后,将所有其他点的映射关系按照指定点的关系计算确定。
img=cv2.imread('5.jpg')
rows,cols,ch=img.shape
p1=np.float32([[0,0],[cols-1,0],[0,rows-1]]) # 原图三个角,左上,右上,左下
p2=np.float32([[0,rows*0.33],[cols*0.85,rows*0.25],[cols*0.15,rows*0.7]])
M=cv2.getAffineTransform(p1,p2)
dst=cv2.warpAffine(img,M,(cols,rows))
cv2.imshow("origianl",img)
cv2.imshow("result",dst)
cv2.waitKey()
cv2.destroyAllWindows()
仿射变换可以将矩形映射为任意平行四边形,透视变换则可以将矩形映射为任意四边形。
dst = cv2.warpPerspective( src, M, dsize[, flags[, borderMode[, borderValue]]] )
同样可以使用一个函数生成 cv2.warpPerspective() 所使用的转换矩阵,是cv2.getPerspecitveTransform(src, dst) 参数是图像四个顶点的坐标
这里pts2 的坐标是(y,x) ,也不知道为啥。。。
把一副图像内的像素点放置到另外一副图像内的指定位置,这个过程为重映射。
dst = cv2.remap( src, map1, map2, interpolation[, borderMode[, borderValue]] )
重映射通过修改像素点的位置得到一副新的图像。构建时需要确定新图像中每个像素在原图中的位置,映射函数的作用就是查找新图像在原图像的位置。也成为反向映射。参数map1,2 用来说明反向映射,分别对应x,y 坐标
这两个参数都是浮点数。所以目标图像可以反向映射到原始图像的两个像素点之间的位置(当然是不存在像素值的)。这是就可以使用 interpolation 的插值方式。也是因为map1,2 是浮点数,可以实现更加随意的映射。
map1 指代像素点所在位置的列号,map2指行号。例如,将结果图像某个点像素点映射为原图的 0行 3列 的像素点,map1=3,map2=0
img=np.random.randint(0,256,size=[4,5],dtype=np.uint8)
rows,cols=img.shape
mapx = np.ones(img.shape,np.float32)*3 # 将目标数组的所有像素点都映射为
mapy = np.ones(img.shape,np.float32)*0 # 原始图像内第零行第三列上的像素点
rst=cv2.remap(img,mapx,mapy,cv2.INTER_LINEAR) # 必须三个参数。。。
print("img=\n",img)
print("mapx=\n",mapx)
print("mapy=\n",mapy)
print("rst=\n",rst)
img=
[[217 62 124 22 219]
[245 228 169 240 164]
[ 7 244 49 0 135]
[232 245 161 28 49]]
mapx=
[[3. 3. 3. 3. 3.]
[3. 3. 3. 3. 3.]
[3. 3. 3. 3. 3.]
[3. 3. 3. 3. 3.]]
mapy=
[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
rst=
[[22 22 22 22 22]
[22 22 22 22 22]
[22 22 22 22 22]
[22 22 22 22 22]]
通过该函数实现图像的复制
img=cv2.imread("lena.bmp")
rows,cols=img.shape[:2]
mapx = np.zeros(img.shape[:2],np.float32)
mapy = np.zeros(img.shape[:2],np.float32)
for i in range(rows):
for j in range(cols):
mapx.itemset((i,j),j) # 就是将结果图每个点的坐标对应原图相应的坐标
mapy.itemset((i,j),i)
rst=cv2.remap(img,mapx,mapy,cv2.INTER_LINEAR)
cv2.imshow("original",img) # 就不贴图了。。
cv2.imshow("result",rst)
cv2.waitKey()
cv2.destroyAllWindows()
# 就是类似这样的,两个矩阵组合对应每个点的坐标
mapx=
[[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]]
mapy=
[[0. 0. 0. 0. 0.]
[1. 1. 1. 1. 1.]
[2. 2. 2. 2. 2.]
[3. 3. 3. 3. 3.]]
绕 x 轴翻转
img=np.random.randint(0,256,size=[4,5],dtype=np.uint8)
rows,cols=img.shape
mapx = np.zeros(img.shape,np.float32)
mapy = np.zeros(img.shape,np.float32)
for i in range(rows):
for j in range(cols):
mapx.itemset((i,j),j)
mapy.itemset((i,j),rows-1-i)
rst=cv2.remap(img,mapx,mapy,cv2.INTER_LINEAR)
print("img=\n",img)
print("mapx=\n",mapx)
print("mapy=\n",mapy)
print("rst=\n",rst)
img=
[[187 203 30 126 192]
[113 122 142 108 81]
[190 232 114 72 243]
[106 41 192 178 211]]
mapx=
[[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]]
mapy=
[[3. 3. 3. 3. 3.]
[2. 2. 2. 2. 2.]
[1. 1. 1. 1. 1.]
[0. 0. 0. 0. 0.]]
rst= # 对图像就是倒过来
[[106 41 192 178 211]
[190 232 114 72 243]
[113 122 142 108 81]
[187 203 30 126 192]]
mapx.itemset((i,j),cols-1-j) # 这是绕Y 轴翻转
mapy.itemset((i,j),i)
mapx.itemset((i,j),cols-1-j)
mapy.itemset((i,j),rows-1-i) # 绕 xy 翻转
mapx.itemset((i,j),i)
mapy.itemset((i,j),j) # x,y轴互换