2018-03-12 17:46


  • opencv

I started playing with gocv. I'm trying to figure out a simple thing: how to cut out an object from an image which has a background of certain colour. In this case the object is pizza and background colour is blue.

enter image description here

I'm using InRange function (inRange in OpenCV) to define the upper and lower threshold for blue colour to create a mask and then CopyToWithMask function (copyTo in OpenCV) to apply the mask on the original image. I expect the result to be the blue background with the pizza cut out of it.

The code is very simple:

package main

import (


func main() {
    imgPath := "pizza.png"
    // read in an image from filesystem
    img := gocv.IMRead(imgPath, gocv.IMReadColor)
    if img.Empty() {
        fmt.Printf("Could not read image %s
", imgPath)
    // Create a copy of an image
    hsvImg := img.Clone()

    // Convert BGR to HSV image
    gocv.CvtColor(img, hsvImg, gocv.ColorBGRToHSV)
    lowerBound := gocv.NewMatFromScalar(gocv.NewScalar(110.0, 100.0, 100.0, 0.0), gocv.MatTypeCV8U)
    upperBound := gocv.NewMatFromScalar(gocv.NewScalar(130.0, 255.0, 255.0, 0.0), gocv.MatTypeCV8U)

    // Blue mask
    mask := gocv.NewMat()
    gocv.InRange(hsvImg, lowerBound, upperBound, mask)

    // maskedImg: output array that has the same size and type as the input arrays.
    maskedImg := gocv.NewMatWithSize(hsvImg.Rows(), hsvImg.Cols(), gocv.MatTypeCV8U)
    hsvImg.CopyToWithMask(maskedImg, mask)

    // save the masked image
    newImg := gocv.NewMat()
    // Convert back to BGR before saving
    gocv.CvtColor(maskedImg, newImg, gocv.ColorHSVToBGR)
    gocv.IMWrite("no_pizza.jpeg", newImg)

However the resulting image is basically almost completely black except for a slight hint of a pizza edge:

enter image description here

As for the chosen upper and lower bound of blue colours, I followed the guide mentioned in the official documentation:

blue = np.uint8([[[255, 0, 0]]])
hsv_blue = cv2.cvtColor(blue, cv2.COLOR_BGR2HSV)

[[[120 255 255]]]

Now you take [H-10, 100,100] and [H+10, 255, 255] as lower bound and upper bound respectively.

I'm sure I'm missing something fundamental, but can't figure out what it is.

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享
  • 邀请回答


  • dongpu4141 dongpu4141 3年前

    So I spent quite some time on this to figure out what I'm missing and finally found the answer to my question in case anyone is interested. It's now clearer to me now why this question hasn't been answered as the solution to it is rather crazy due to gocv API.

    Here is the code that I had to write to get the result I'm after:

    package main
    import (
    func main() {
        // read image
        pizzaPath := filepath.Join("pizza.png")
        pizza := gocv.IMRead(pizzaPath, gocv.IMReadColor)
        if pizza.Empty() {
            fmt.Printf("Failed to read image: %s
    ", pizzaPath)
        // Convert BGR to HSV image (dont modify the original)
        hsvPizza := gocv.NewMat()
        gocv.CvtColor(pizza, &hsvPizza, gocv.ColorBGRToHSV)
        pizzaChannels, pizzaRows, pizzaCols := hsvPizza.Channels(), hsvPizza.Rows(), hsvPizza.Cols()
        // define HSV color upper and lower bound ranges
        lower := gocv.NewMatFromScalar(gocv.NewScalar(110.0, 50.0, 50.0, 0.0), gocv.MatTypeCV8UC3)
        upper := gocv.NewMatFromScalar(gocv.NewScalar(130.0, 255.0, 255.0, 0.0), gocv.MatTypeCV8UC3)
        // split HSV lower bounds into H, S, V channels
        lowerChans := gocv.Split(lower)
        lowerMask := gocv.NewMatWithSize(pizzaRows, pizzaCols, gocv.MatTypeCV8UC3)
        lowerMaskChans := gocv.Split(lowerMask)
        // split HSV lower bounds into H, S, V channels
        upperChans := gocv.Split(upper)
        upperMask := gocv.NewMatWithSize(pizzaRows, pizzaCols, gocv.MatTypeCV8UC3)
        upperMaskChans := gocv.Split(upperMask)
        // copy HSV values to upper and lower masks
        for c := 0; c < pizzaChannels; c++ {
            for i := 0; i < pizzaRows; i++ {
                for j := 0; j < pizzaCols; j++ {
                    lowerMaskChans[c].SetUCharAt(i, j, lowerChans[c].GetUCharAt(0, 0))
                    upperMaskChans[c].SetUCharAt(i, j, upperChans[c].GetUCharAt(0, 0))
        gocv.Merge(lowerMaskChans, &lowerMask)
        gocv.Merge(upperMaskChans, &upperMask)
        // global mask
        mask := gocv.NewMat()
        gocv.InRange(hsvPizza, lowerMask, upperMask, &mask)
        // cut out pizza mask
        pizzaMask := gocv.NewMat()
        gocv.Merge([]gocv.Mat{mask, mask, mask}, &pizzaMask)
        // cut out the pizza and convert back to BGR
        gocv.BitwiseAnd(hsvPizza, pizzaMask, &hsvPizza)
        gocv.CvtColor(hsvPizza, &hsvPizza, gocv.ColorHSVToBGR)
        // write image to filesystem
        outPizza := "no_pizza.jpeg"
        if ok := gocv.IMWrite(outPizza, hsvPizza); !ok {
            fmt.Printf("Failed to write image: %s
    ", outPizza)
        // write pizza mask to filesystem
        outPizzaMask := "no_pizza_mask.jpeg"
        if ok := gocv.IMWrite(outPizzaMask, mask); !ok {
            fmt.Printf("Failed to write image: %s
    ", outPizza)

    This code produces the result I was after:

    pizza cut out

    I'm also going to add another picture that shows the im

    image mask

    Now, let's get to code. gocv API function InRange() does not accept Scalar like OpenCV does so you have to do all that crazy image channel splitting and merging dance since you need to pass in Mats as lower and upper bounds to InRange(); these Mat masks have to have the exact number of channels as the image on which you run InRange().

    This brings up another important point: when allocating the Scalars in gocv for this task, I originally used gocv.MatTypeCV8U type which represents single channel color - not enough for HSV image which has three channels -- this is fixed by using gocv.MatTypeCV8UC3 type.

    If I it were possible pass in gocv.Scalars into gocv.InRange() a lot of the boiler plate code would disappear; so would all the unnecessary gocv.NewMat() allocations for splitting and reassembling the channels which are required to create lower and upper bounds channels.

    点赞 评论 复制链接分享
  • dougan5772 dougan5772 3年前

    enter image description here

    inRange with the given range runs perfectly for me. I'm not familiar with Go, but here's my python code:

    import numpy as py
    import cv2
    img = cv2.imread("pizza.png")
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    mask = cv2.inRange(hsv, (110, 100, 100), (130, 255, 255))
    inv_mask = cv2.bitwise_not(mask)
    pizza = cv2.bitwise_and(img, img, mask=inv_mask)
    cv2.imshow("img", img)
    cv2.imshow("mask", mask)
    cv2.imshow("pizza", pizza)
    cv2.imshow("inv mask", inv_mask)

    A few of notes here:

    • inRange returns the blue background so we need to invert it to reveal the object's mask (if you need the object).
    • You don't need to apply mask on hsvImg and convert to BGR, you can apply mask directly on the original image (which is BGR already).
    • Python does not have CopyToWithMask so I use the equivalent bitwise_and. You may check this function in Go, but I suspect there would be no differences.
    点赞 评论 复制链接分享
  • dongtiao2976 dongtiao2976 3年前

    Here is what I did with Python because I don't know Go...


    Let me explain first.

    (1) Image has been turned to gray.

    (2) Applied Canny Edge

    (3 - 4) Created kernel and used it to do Dilate and Close operations

    (5) Found contours

    (6) Created and applied mask

    (7) Cropped and saved the region

    Here is the code:

    import cv2
    import numpy as np
    image = cv2.imread("image.png")
    copy = image.copy()
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imshow('Gray', gray)
    edged = cv2.Canny(gray, 10, 250)
    cv2.imshow('Edged', edged)
    kernel = np.ones((5, 5), np.uint8)
    dilation = cv2.dilate(edged, kernel, iterations=1)
    cv2.imshow('Dilation', dilation)
    closing = cv2.morphologyEx(dilation, cv2.MORPH_CLOSE, kernel)
    cv2.imshow('Closing', closing)
    # if using OpenCV 4, remove image variable from below
    image, cnts, hiers = cv2.findContours(closing, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    cont = cv2.drawContours(copy, cnts, -1, (0, 0, 0), 1, cv2.LINE_AA)
    cv2.imshow('Contours', cont)
    mask = np.zeros(cont.shape[:2], dtype="uint8") * 255
    # Draw the contours on the mask
    cv2.drawContours(mask, cnts, -1, (255, 255, 255), -1)
    # remove the contours from the image and show the resulting images
    img = cv2.bitwise_and(cont, cont, mask=mask)
    cv2.imshow("Mask", img)
    for c in cnts:
        x, y, w, h = cv2.boundingRect(c)
        if w > 50 and h > 130:
            new_img = img[y:y + h, x:x + w]
            cv2.imwrite('Cropped.png', new_img)
            cv2.imshow("Cropped", new_img)

    Hope will help more than one user.

    点赞 评论 复制链接分享