检测边缘

要检测图像中的边缘，我们可以使用实现 Canny 边缘检测器的 cv2 的 Canny() 方法。
Canny 边缘检测器也称为最优检测器。

Canny() 的语法如下：

cv2.Canny(image, minVal, maxVal)

这里 minVal 和 maxVal 分别是最小和最大强度梯度值。

考虑以下代码：

import cv2
img = cv2.imread("pyimg.jpg")
edge_img = cv2.Canny(img,100,200)
cv2.imshow("Detected Edges", edge_img)
cv2.waitKey(0)

裁剪图像

首先，我们需要导入 cv2 模块并读取图像并提取图像的宽度和高度：

import cv2
img = cv2.imread("pyimg.jpg")
height, width = img.shape[0:2]

现在获取行和列的开始和结束索引。
这将定义新创建的图像的大小。
例如，从第 10 行开始到第 15 行将给出图像的高度。

同样，从第 10 列开始直到第 15 列将给出图像的宽度。

我们可以通过指定总高度和总宽度的百分比值来获取起点。
同样，要获得裁剪图像的终点，请指定百分比值，如下所示：

startRow = int(height*.15)
startCol = int(width*.15)
endRow = int(height*.85)
endCol = int(width*.85)

现在将这些值映射到原始图像。
请注意，我们必须将起始值和结束值转换为整数，因为在映射时，索引始终是整数。

croppedImage = img[startRow:endRow, startCol:endCol]

现在在输出中显示原始和裁剪的图像：

cv2.imshow('Oroirnal Image', img)
cv2.imshow('Cropped Image', croppedImage)
cv2.waitKey(0)

将图像转换为灰度（黑白）

转换灰度图像的简单方法是像这样加载它：

img = cv2.imread("pyimg.jpg", 0)

还有另一种使用 BGR2GRAY 的方法。

要将彩色图像转换为灰度图像，请使用 cv2 模块的 BGR2GRAY 属性。
下面的示例演示了这一点：

导入 cv2 模块：

import cv2

读取图片：

img = cv2.imread("pyimg.jpg")

使用 cv2 模块的 cvtColor() 方法，它将原始图像和 COLOR_BGR2GRAY 属性作为参数。
将结果图像存储在变量中：

gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

显示原始图像和灰度图像：

cv2.imshow("Oroirnal Image", img)
cv2.imshow("Gray Scale Image", gray_img)
cv2.waitKey(0)

质心（斑点中心）检测

要找到图像的中心，第一步是将原始图像转换为灰度。
我们可以像以前一样使用 cv2 的 cvtColor() 方法。

这在以下代码中进行了演示：

import cv2
img = cv2.imread("py.jpg")
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

我们读取图像并将其转换为灰度图像。
新图像存储在 gray_img 中。

现在我们必须计算图像的矩。
使用 cv2 的 moment() 方法。
在 moment() 方法中，灰度图像将按如下方式传递：

moment = cv2.moments(gray_img)

然后我们需要使用上面得到的矩来计算图像中心的 x 和 y 坐标：

X = int(moment ["m10"] / moment["m00"])
Y = int(moment ["m01"] / moment["m00"])

最后，我们有图像的中心。
为了突出这个中心位置，我们可以使用 circle 方法，它将在给定半径的给定坐标中创建一个圆。

circle() 方法获取 img、将创建圆的 x 和 y 坐标、大小、我们希望圆的颜色和厚度。

cv2.circle(img, (X, Y), 15, (205, 114, 101), 1)

圆圈是在图像上创建的。

cv2.imshow("Center of the Image", img)
cv2.waitKey(0)

从图像中提取文本 (OCR)

要从图像中提取文本，我们可以使用 Google Tesseract-OCR。
你可以从这个链接下载

然后你应该安装 pytesseract 模块，它是 Tesseract-OCR 的 Python 包装器。

pip install pytesseract

现在让我们将此图像中的文本转换为字符串，并在输出时将文本显示为字符串：

导入 pytesseract 模块：

import pytesseract

设置 Tesseract-OCR 可执行文件的路径：

pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files (x86)\Tesseract-OCR\tesseract'

现在使用 image_to_string 方法将图像转换为字符串：

print(pytesseract.image_to_string('pytext.png'))

使图像模糊

高斯模糊

要使图像模糊，可以使用 OpenCV 的 GaussianBlur() 方法。

GaussianBlur() 使用高斯内核。
内核的高度和宽度应为正数和奇数。

然后我们必须分别指定 sigmaX 和 sigmaY 的 X 和 Y 方向。
如果只指定了一个，则两者都被认为是相同的。

示例：

import cv2
img = cv2.imread("pyimg.jpg")
blur_image = cv2.GaussianBlur(img, (7,7), 0)
cv2.imshow('Oroirnal Image', img)
cv2.imshow('Blur Image', blur_image)
cv2.waitKey(0)

在上面的代码片段中，实际图像与内核的高度和宽度以及 X 和 Y 方向一起传递给 GaussianBlur()。

中值模糊

在中值模糊中，图像所有像素的中值在内核区域内计算。
然后用所得中值替换中心值。
当图像中有椒盐噪声时使用中值模糊。

要应用中值模糊，我们可以使用 OpenCV 的 mediumBlur() 方法。

考虑以下示例，其中图像中有噪声：

import cv2
img = cv2.imread("pynoise.png")
blur_image = cv2.medianBlur(img,5)

这将在图像中应用 50% 的噪声以及中值模糊。
现在显示图像：

cv2.imshow('Oroirnal Image', img)
cv2.imshow('Blur Image', blur_image)
cv2.waitKey(0)

检测并纠正文本倾斜

在本节中，我们将纠正文本倾斜。

导入模块 cv2、NumPy 并读取图像：

import cv2
import numpy as np
img = cv2.imread("pytext1.png")

将图像转换为灰度图像：

gray_img=cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

使用 bitwise_not 反转灰度图像：

gray_img=cv2.bitwise_not(gray_img)

使用 NumPy 的 column_stack 方法选择大于零的像素的 x 和 y 坐标：

coordinates = np.column_stack(np.where(gray_img > 0))

现在我们必须计算倾斜角。
我们将使用 cv2 的 minAreaRect() 方法，该方法返回从 -90 到 0 度的角度范围（其中不包括 0）。

ang=cv2.minAreaRect(coordinates)[-1]

文本区域的旋转角度将存储在 ang 变量中。
现在我们为角度添加一个条件；如果文本区域的角度小于 -45，我们将添加 90 度，否则我们将乘以负角使角度为正。

if ang<-45:
	ang=-(90+ang)
else:
	ang=-ang

计算文本区域的中心：

height, width = img.shape[:2]
center_img = (width / 2, height / 2)

现在我们有了文本倾斜的角度，我们将应用 getRotationMatrix2D() 来获取旋转矩阵，然后我们将使用 wrapAffine() 方法来旋转角度（之前解释过）。

rotationMatrix = cv2.getRotationMatrix2D(center, angle, 1.0)
rotated_img = cv2.warpAffine(img, rotationMatrix, (width, height), borderMode = cv2.BORDER_REFLECT)

显示旋转后的图像：

cv2.imshow("Rotated Image", rotated_img)
cv2.waitKey(0)

获取图像轮廓

轮廓是图像中连接在一起的曲线。
曲线连接图像中的连续点。
轮廓的目的是用来检测物体。

考虑以下代码，其中我们使用 findContours() 方法来查找图像中的轮廓：

导入 cv2 模块：

import cv2

读取图像并将其转换为灰度图像：

img = cv2.imread('py1.jpg')
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

找到阈值：

retval, thresh = cv2.threshold(gray_img, 127, 255, 0)

使用 findContours() 获取图像（我们在这里通过了阈值）和一些属性。
参见 findContours() 官方。

img_contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

使用 drawContours() 方法在图像上绘制轮廓：

cv2.drawContours(img, img_contours, -1, (0, 255, 0))

显示图像：

cv2.imshow('Image Contours', img)
cv2.waitKey(0)

颜色检测

让我们从图像中检测绿色：

为图像导入模块 cv2，为图像数组导入 NumPy：

import cv2
import numpy as np

读取图像并使用 cvtColor() 将其转换为 HSV：

img = cv2.imread("pydetect.png")
hsv_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

显示图像：

cv2.imshow("HSV Image", hsv_img)

现在为较低的绿色值和较高的绿色值创建一个 NumPy 数组：

lower_green = np.array([34, 177, 76])
upper_green = np.array([255, 255, 255])

使用 cv2 的 inRange() 方法检查给定的图像数组元素是否位于上下边界的数组值之间：

masking = cv2.inRange(hsv_img, lower_green, upper_green)

最后，显示原始图像和结果图像：

cv2.imshow("Oroirnal Image", img)

cv2.imshow("Green Color detection", masking)
cv2.waitKey(0)

OpenCV 是一个用于实时图像处理的免费开源库。
它用于处理图像、视频甚至实时流。

减少噪音

为了减少图像中的噪声，OpenCV 提供了以下方法：

• fastNlMeansDenoising()：从灰度图像中去除噪声
• fastNlMeansDenoisingColored()：从彩色图像中去除噪声
• fastNlMeansDenoisingMulti()：从灰度图像帧（灰度视频）中去除噪声
• fastNlMeansDenoisingColoredMulti()：与 3 相同，但适用于彩色帧

让我们在示例中使用 fastNlMeansDenoisingColored()：

导入 cv2 模块并读取图像：

import cv2
img = cv2.imread("pyn1.png")

应用去噪函数，分别采用原始图像 (src)、目标（我们在存储结果时没有保留）、过滤强度、去除有色噪声的图像值（通常等于过滤强度或者 10 )，以像素为单位的模板补丁大小来计算权重，权重应该始终是奇数（推荐大小等于 7），以及以像素为单位的窗口大小，以计算给定像素的平均值。

result = cv2.fastNlMeansDenoisingColored(img,None,20,10,7,21)

显示原始和去噪图像：

cv2.imshow("Oroirnal Image", img)
cv2.imshow("Denoised Image", result)
cv2.waitKey(0)

调整图像对比度

在 Python OpenCV 模块中，没有专门的函数来调整图像对比度，但是 OpenCV 的官方文档提出了一个可以同时执行图像亮度和图像对比度的等式。

new_img = a * oroirnal_img + b

这里 a 是定义图像对比度的 alpha。
如果a大于1，对比度会更高。

如果 a 的值介于 0 和 1 之间（小于 1 但大于 0），则对比度会降低。
如果 a 为 1，则图像上将没有对比度效果。

b 代表测试版。
b 的值在 -127 到 +127 之间变化。

要在 Python OpenCV 中实现此等式，我们可以使用 addWeighted() 方法。
我们使用 addWeighted() 方法，因为它为 24 位彩色图像生成 0 到 255 范围内的输出。

addWeighted() 方法的语法如下：

cv2.addWeighted(source_img1, alpha1, source_img2, alpha2, beta)

此语法将混合两个图像，第一个源图像 (source_img1) 的权重为 alpha1，第二个源图像 (source_img2)。

如果我们只想在一张图像中应用对比度，我们可以使用 NumPy 将第二个图像源添加为零。

示例：

导入以下模块：

import cv2
import numpy as np

读取原图：

img = cv2.imread("pyimg.jpg")

现在调整对比度。
由于没有其他图像，我们将使用 np.zeros 它将创建一个与原始图像具有相同形状和数据类型的数组，但该数组将用零填充。

contrast_img = cv2.addWeighted(img, 2.5, np.zeros(img.shape, img.dtype), 0, 0)
cv2.imshow('Oroirnal Image', img)
cv2.imshow('Contrast Image', contrast_img)
cv2.waitKey(0)

为彩色图像应用蒙版

图像遮罩是指将一些其他图像作为遮罩应用于原始图像或者更改图像中的像素值。

要在图像上应用蒙版，我们将使用 OpenCV 模块的 HoughCircles() 方法。
HoughCircles() 方法检测图像中的圆圈。
检测到圆圈后，我们可以简单地在这些圆圈上应用蒙版。

HoughCircles() 方法采用原始图像、Hough Gradient（检测圆边缘的梯度信息）以及来自以下圆方程的信息：

(x - xcenter)2 + (y - ycenter)2 = r2

在这个方程中 (xcenter , ycenter) 是圆的中心，r 是圆的半径。

应用蒙版：

import cv2
import numpy as np
img1 = cv2.imread('pyimg.jpg')
img1 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

使用 OpenCV 中的 HoughCircles() 代码检测图像中的圆圈：Hough Circle Transform：

gray_img = cv2.medianBlur(cv2.cvtColor(img, cv2.COLOR_RGB2GRAY), 3)
circles = cv2.HoughCircles(gray_img, cv2.HOUGH_GRADIENT, 1, 20, param1=50, param2=50, minRadius=0, maxRadius=0)
circles = np.uint16(np.around(circles))

要创建掩码，请使用 np.full ，它将返回给定形状的 NumPy 数组：

masking=np.full((img1.shape[0], img1.shape[1]),0,dtype=np.uint8)
for j in circles[0, :]:
    cv2.circle(masking, (j[0], j[1]), j[2], (255, 255, 255), -1)

下一步是将我们使用 bitwise_or 运算符创建的图像和掩码数组组合起来，如下所示：

final_img = cv2.bitwise_or(img1, img1, masking=masking)

旋转图像

首先，导入 cv2 模块。

import cv2

现在要读取图像，使用 cv2 模块的 imread() 方法，在参数中指定图像的路径并将图像存储在一个变量中，如下所示：

img = cv2.imread("pyimg.jpg")

图像现在被视为一个矩阵，其中的行和列值存储在 img 中。

实际上，如果我们检查 img 的类型，它将为我们提供以下结果：

>>>print(type(img))
<class 'numpy.ndarray'>

这是一个 NumPy 数组！这就是为什么使用 OpenCV 进行图像处理如此简单的原因。

要显示图像，可以使用 cv2 的 imshow() 方法。

cv2.imshow('Oroirnal Image', img) 
cv2.waitKey(0)

waitkey 函数将时间作为参数（以毫秒为单位）作为窗口关闭的延迟。
在这里，我们将时间设置为0，将永远显示窗口，直到我们手动关闭它。

要旋转此图像，我们需要图像的宽度和高度，因为稍后将在旋转过程中使用它们。

height, width = img.shape[0:2]

shape 属性返回图像矩阵的高度和宽度。

好的，现在我们有了图像矩阵，我们想要得到旋转矩阵。
为了得到旋转矩阵，我们使用 cv2 的 getRotationMatrix2D() 方法。
getRotationMatrix2D() 的语法是：

cv2.getRotationMatrix2D(center, angle, scale)

这里的center是旋转的中心点，angle是以度为单位的角度，scale比例是使图像适合屏幕的比例属性。

要获得我们图像的旋转矩阵，代码将是：

rotationMatrix = cv2.getRotationMatrix2D((width/2, height/2), 90, .5)

为了旋转图像，我们有一个名为 wrapAffine 的 cv2 方法，它将原始图像、图像的旋转矩阵以及图像的宽度和高度作为参数。

rotatedImage = cv2.warpAffine(img, rotationMatrix, (width, height))

旋转后的图像存储在rotatedImage 矩阵中。

最后，使用 imshow() 显示旋转后的图像：

cv2.imshow('Rotated Image', rotatedImage)
cv2.waitKey(0)

调整图像大小

要调整图像大小，可以使用 openCV 的 resize() 方法。
在 resize 方法中，我们可以指定 x 和 y 轴的值或者指示图像大小的行数和列数。

导入并读取图像：

import cv2
img = cv2.imread("pyimg.jpg")

现在使用带有轴值的调整大小方法：

newImg = cv2.resize(img, (0,0), fx=0.75, fy=0.75)
cv2.imshow('Resized Image', newImg)
cv2.waitKey(0)

现在使用行和列值来调整图像大小：

newImg = cv2.resize(img, (550, 350))
cv2.imshow('Resized Image', newImg)
cv2.waitKey(0)

我们说我们想要 550 列（宽度）和 350 行（高度）。

安装 OpenCV

要在系统上安装 OpenCV，请运行以下 pip 命令：

pip install opencv-python

从图像中删除背景

为了从图像中去除背景，我们将找到检测主要对象边缘的轮廓，并为背景创建一个带有 np.zeros 的掩码，然后使用 bitwise_and 运算符组合掩码和图像。

考虑下面的例子：

导入模块（NumPy 和 cv2）：

import cv2
import numpy as np

读取图像并将图像转换为灰度图像：

img = cv2.imread("py.jpg")
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

找到阈值：

_, thresh = cv2.threshold(gray_img, 127, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

在 threshold() 方法中，最后一个参数定义了阈值的样式。
请参阅 OpenCV 阈值的官方文档。

找到图像轮廓：

img_contours = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[-2]

对轮廓进行排序：

img_contours = sorted(img_contours, key=cv2.contourArea)
for i in img_contours:
    if cv2.contourArea(i) > 100:
        break

使用 np.zeros 生成掩码：

mask = np.zeros(img.shape[:2], np.uint8)

绘制轮廓：

cv2.drawContours(mask, [i],-1, 255, -1)

应用 bitwise_and 运算符：

new_img = cv2.bitwise_and(img, img, mask=mask)

显示原始图像：

cv2.imshow("Oroirnal Image", img)

显示结果图像：

cv2.imshow("Image with background removed", new_img)
cv2.waitKey(0)