Please enable JavaScript.

Coggle requires JavaScript to display documents.

Practical Python and OpenCV (Chapter 6 – Image Processing…

- - - - canvas = np.zeros((300, 300, 3), dtype = "uint8")
        green = (0, 255, 0)
        cv2.line(canvas, (0, 0), (300, 300), green)
      - cv2.rectangle(canvas, (50, 200), (200, 225), red, 5)　　 # 最后一个参数5表示画矩形的线的粗细
        cv2.rectangle(canvas, (200, 50), (225, 125), blue, -1)　　# -1表示以填充方式画矩形
      - cv2.circle(canvas, (centerX, centerY), r, white)
- - - - M = np.float32([[1, 0, 25], [0, 1, 50]]) 　　# 第一个参数表示左右移动(正值为右)，第二个参数表示上下移动(正值为下)
        shifted = cv2.warpAffine(image, M, (image.shape[1], image.shape[0])) 　# shape[1]表示图像长度，shape[0]表示图像高度
        cv2.imshow("Shifted Down and Right", shifted)
    - - (h, w) = image.shape[:2] 　　# w = shape[1] 　h=shape[0]
        center = (w // 2, h // 2)
        M = cv2.getRotationMatrix2D(center, 45, 1.0) 　　# 45表示度数，正值表示逆时针旋转，负值表示顺时针旋转
        rotated = cv2.warpAffine(image, M, (w, h))
        cv2.imshow("Rotated by 45 Degrees", rotated)
    - - r = 150.0 / image.shape[1]
        dim = (150, int(image.shape[0] * r)) 　# 缩放时要保持长宽比例
        resized = cv2.resize(image, dim, interpolation = cv2.INTER_AREA)
        cv2.imshow("Resized (Width)", resized)
    - - flipped = cv2.flip(image, 1) 　　# 水平翻转(左右方向上)
        cv2.imshow("Flipped Horizontally", flipped)　　
        flipped = cv2.flip(image, 0)　　　#垂直翻转(上下方向上)
        cv2.imshow("Flipped Vertically", flipped)
        flipped = cv2.flip(image, -1)
        cv2.imshow("Flipped Horizontally & Vertically", flipped)
    - - cropped = image[30:120 , 240:335] 　　#[y_start : y_end, x_start : x_end]
        cv2.imshow("T-Rex Face", cropped)
  - - - 一般表示RGB图像的数据类型为：uint8，所能表示的范围为[0, 255]
      - Opencv和numpy在进行数据加减的时候是有区别的
        
        Opencv：对于不在[0, 255]的结果值采取裁剪的方式，即小于0时就取值为0，大于255时就取值为255，这种方式在视觉表现上更可行。
        
        numpy:对于不在[0, 255]的结果将采取取余的方式来限制结果值的范围。
        
        print("max of 255: {}".format(cv2.add(np.uint8([200]), np.uint8([100]))))
        print("min of 0: {}".format(cv2.subtract(np.uint8([50]), np.uint8([100]))))
        print("wrap around: {}".format(np.uint8([200]) + np.uint8([100])))
        print("wrap around: {}".format(np.uint8([50]) - np.uint8([100])))
        ouput:
        max of 255: [[255]]
        min of 0: [[0]]
        wrap around: [44]
        wrap around: [206]
  - - - bitwiseAnd = cv2.bitwise_and(rectangle,circle) 　# 与
        
        bitwiseOr = cv2.bitwise_or(rectangle, circle)　# 或
        
        bitwiseXor = cv2.bitwise_xor(rectangle, circle)　#异或
        
        bitwiseNot = cv2.bitwise_not(circle)　# 非
  - - - mask = np.zeros(image.shape[:2], dtype = "uint8")
        (cX, cY) = (image.shape[1] // 2, image.shape[0] // 2)
        cv2.rectangle(mask, (cX - 75, cY - 75), (cX + 75 , cY + 75), 255,-1)
        cv2.imshow("Mask", mask)
        masked = cv2.bitwise_and(image, image, mask = mask)
        cv2.imshow("Mask Applied to Image", masked)
  - - - (B, G, R) = cv2.split(image)
        cv2.imshow("Red", R)
        cv2.imshow("Green", G)
        cv2.imshow("Blue", B)
        merged = cv2.merge([B, G, R])
        cv2.imshow("Merged", merged)
  - - - HSV通常用于确定想要跟踪的颜色范围（例如视频流中的绿球）
      - 还可以使用HSV提取颜色直方图，来量化图像的内容甚至构建图像搜索引擎。
    - - 增加感知意义属性使得L a b *颜色空间比RGB或HSV更不直观和易于理解，但由于感知意义属性，我们经常在计算机视觉中使用它。
    - - gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        cv2.imshow("Gray", gray)
        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
        cv2.imshow("HSV", hsv)
        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
        cv2.imshow("L*a*b*", lab)
- - - - 一维直方图（只考虑图像的一个特征）
        
        统计灰度图像中每个颜色强度（0~255）的像素数量
        
        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        cv2.imshow("Original", image)
        hist = cv2.calcHist([image], [0], None, [256], [0, 256])
        plt.figure()
        plt.title("Grayscale Histogram")
        plt.xlabel("Bins")
        plt.ylabel("# of Pixels")
        plt.plot(hist)
        plt.xlim([0, 256])
        plt.show()
        cv2.waitKey(0)
        
        统计彩色图像中每个颜色强度（0~255）的像素数量
        
        chans = cv2.split(image)
        colors = ("b", "g", "r")
        plt.figure()
        plt.title("’Flattened’ Color Histogram")
        plt.xlabel("Bins")
        plt.ylabel("# of Pixels")
        for (chan, color) in zip(chans, colors):
        　　hist = cv2.calcHist([chan], [0], None, [256], [0, 256])
        　　plt.plot(hist, color = color)
        　　plt.xlim([0, 256])
      - 二维直方图（考虑图像的两个特征）
        
        分别统计图像中：R和G、R和B、G和B两个颜色强度的像素数量
        
        fig = plt.figure()
        ax = fig.add_subplot(131)
        hist = cv2.calcHist([chans[1], chans[0]], [0, 1], None,[32, 32], [0, 256, 0, 256])
        p = ax.imshow(hist, interpolation = "nearest")
        ax.set_title("2D Color Histogram for G and B")
        plt.colorbar(p)
        print("2D histogram shape: {}, with {} values".format(hist.shape, hist.flatten().shape[0])
        
        图中蓝色到红的渐变过程表示：像素的数量由少到多
  - - - image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        eq = cv2.equalizeHist(image)
        cv2.imshow("Histogram Equalization", np.hstack([image, eq]))
        cv2.waitKey(0)
- - - - 应用简单的阈值方法需要人为干预，即图像阈值需要我们自己手动设置。
      - image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(image, (5, 5), 0)
        cv2.imshow("Image", image)
        (T, thresh) = cv2.threshold(blurred, 155, 255, cv2.THRESH_BINARY)
        cv2.imshow("Threshold Binary", thresh)
        (T, threshInv) = cv2.threshold(blurred, 155, 255, cv2.THRESH_BINARY_INV)
        cv2.imshow("Threshold Binary Inverse", threshInv)
        cv2.imshow("Coins", cv2.bitwise_and(image, image, mask = threshInv))
        cv2.waitKey(0)
        
        在进行二值化之前需要先进行一次高斯模糊：应用高斯模糊有助于去除图像中我们不关心的一些高频边缘。
        
        在代码中，155是我们手动设置的阈值T，当像素值小于155时，其值就设置为0，否则就设置为255
    - - 简单阈值方法的一大缺点就是需要人工设置阈值T，为了克服这个问题，我们可以使用自适应阈值处理，它考虑像素的小邻居，然后为每个邻居找到最佳阈值T.
      - image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(image, (5, 5), 0)
        cv2.imshow("Image", image)
        thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 11, 4)
        cv2.imshow("Mean Thresh", thresh)
        thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 15, 3)
        cv2.imshow("Gaussian Thresh", thresh)
        cv2.waitKey(0)
        
        我们使用cv2.THRESH_BINARY_INV来指示邻域中任何大于T的像素强度应设置为255，否则应设置为0。
    - - 我们可以自动计算T的阈值的另一种方法是使用Otsu的方法。Otsu的方法假设图像的灰度直方图中有两个峰值。然后它试图找到一个最佳值来分隔这两个峰值——T值。
      - import mahotas
        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(image, (5, 5), 0)
        cv2.imshow("Image", image)
        T = mahotas.thresholding.otsu(blurred)
        print("Otsu’s threshold: {}".format(T))
        thresh = image.copy()
        thresh[thresh > T] = 255
        thresh[thresh < 255] = 0
        thresh = cv2.bitwise_not(thresh)
        cv2.imshow("Otsu", thresh)
        T = mahotas.thresholding.rc(blurred)
        print("Riddler-Calvard: {}".format(T))
        thresh = image.copy()
        thresh[thresh > T] = 255
        thresh[thresh < 255] = 0
        thresh = cv2.bitwise_not(thresh)
        cv2.imshow("Riddler-Calvard", thresh)
        cv2.waitKey(0)
- - - - 在图像顶部定义一个k*k滑动窗口，其中k始终是奇数。此窗口将从左到右，从上到下滑动。然后将该矩阵中心的像素（我们必须使用奇数，否则不会有真正的“中心”）设置为围绕它的所有其他像素的平均值。
      - blurred = np.hstack([
        　　cv2.blur(image, (3, 3)),
        　　cv2.blur(image, (5, 5)),
        　　cv2.blur(image, (7, 7))])
        cv2.imshow("Averaged", blurred)
        cv2.waitKey(0)
    - - 与平均方法不同，中值模糊方法不是用邻域的平均值替换中心像素，而是用邻域的中值替换中心像素。
      - blurred = np.hstack([
        　　cv2.medianBlur(image, 3),
        　　cv2.medianBlur(image, 5),
        　　cv2.medianBlur(image, 7)])
        cv2.imshow("Median", blurred)
        cv2.waitKey(0)
        
        请注意，中值模糊方法不再像平均和高斯模糊那样创建“运动模糊”效果，相反，它正在消除细节和噪音。
      - 传统上，中值模糊方法在去除椒盐噪声时最有效。
        中值模糊在去除图像中的椒盐样式噪声方面更有效，因为每个中心像素总是被图像中存在的像素强度替换。
    - - 高斯模糊类似于平均模糊，但是我们现在使用加权平均值而不是使用简单均值，其中更接近中心像素的邻域像素对平均值贡献更多“权重”。
      - blurred = np.hstack([
        　　cv2.GaussianBlur(image, (3, 3), 0),
        　　cv2.GaussianBlur(image, (5, 5), 0),
        　　cv2.GaussianBlur(image, (7, 7), 0)])
        cv2.imshow("Gaussian", blurred)
        cv2.waitKey(0)
        
        与平均方法相比，高斯模糊的图像模糊度更低，但更自然模糊。
    - - 到目前为止，我们的模糊方法的目的是减少图像中的噪声和细节; 但是，我们往往会丢失图像中的边缘。
        
        为了在保持边缘的同时降低噪音，我们可以使用双边模糊。双边模糊通过引入两个高斯分布来实现这一点。
        
        第一高斯函数仅考虑空间邻居，即在图像的（x，y）坐标空间中出现在一起的像素。然后，第二高斯模型对邻域的像素强度进行建模，确保在模糊的实际计算中仅包括具有相似强度的像素。
      - blurred = np.hstack([
        　　cv2.bilateralFilter(image, 5, 21, 21),
        　　cv2.bilateralFilter(image, 7, 31, 31),
        　　cv2.bilateralFilter(image, 9, 41, 41)])
        cv2.imshow("Bilateral", blurred)
        cv2.waitKey(0)
        
        总的来说，这种方法能够保留图像的边缘，同时还能降低噪点。这种方法的最大缺点是它比平均，高斯和中值模糊慢得多。
- - - - image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        cv2.imshow("Original", image)
        lap = cv2.Laplacian(image, cv2.CV_64F)
        lap = np.uint8(np.absolute(lap)) 　　#这一步非常重要
        cv2.imshow("Laplacian", lap)
        cv2.waitKey(0)
      - sobelX = cv2.Sobel(image, cv2.CV_64F, 1, 0)
        sobelY = cv2.Sobel(image, cv2.CV_64F, 0, 1)
        # 由于uint8不支持负数，所以下面两行代码如果没有的话，边缘将会检测不出来。
        sobelX = np.uint8(np.absolute(sobelX))
        sobelY = np.uint8(np.absolute(sobelY))
        sobelCombined = cv2.bitwise_or(sobelX, sobelY)
        cv2.imshow("Sobel X", sobelX)
        cv2.imshow("Sobel Y", sobelY)
        cv2.imshow("Sobel Combined", sobelCombined)
        cv2.waitKey(0)
        
        从黑色到白色的转变被认为是正斜率，而从白色到黑色的转变是负斜率。
    - - Canny边缘检测器是一个多步骤的过程。它涉及模糊图像以去除噪声，计算x和y方向上的Sobel梯度图像，抑制边缘，以及最后确定像素是否“边缘样”的滞后阈值阶段。
      - image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        image = cv2.GaussianBlur(image, (5, 5), 0)
        cv2.imshow("Blurred", image)
        canny = cv2.Canny(image, 30, 150)
        cv2.imshow("Canny", canny)
        cv2.waitKey(0)
        
        在这种情况下，任何低于30的梯度值都被认为是非边缘，而高于150的任何值都被认为是边缘。
- - - - cv2.findContours函数中放入第二个参数是我们想要的轮廓类型。我们使用cv2.RETR_EXTERNAL来仅检索最外面的轮廓（即，跟随硬币轮廓的轮廓）。