用随机颜色填充封闭区域 - Haskell - 星期五

Question

我正在尝试执行不太复杂的图像分析，以尝试找到不同的形状并计算它们的一些参数，例如面积和周长（以像素为单位），我正在尝试在 Haskell 中执行此操作（我想这样做是为了尝试并使用函数式编程语言）。

第一个任务是计算图像上勺子的数量： 我正在使用 Friday Haskell 包来处理图像。

我的想法是使用周五的边缘检测，然后用它的填充功能填充所有封闭区域。第一个需要我迭代图像的像素，直到我偶然发现一个黑色像素。比我填充该区域并继续在图像中搜索（现在填充了其中一个对象）。我可以用随机颜色为不同的对象着色，并将这些颜色与其对象相关联，以找到它们的面积和周长。

以下是我对其应用边缘检测后该图像的外观：

我无法找到迭代所有像素的方法。 我在以下包中找到了那些 read 和 readLinear 函数：https://hackage.haskell.org/package/friday-0.2.2.0/docs/Vision-Image-Mutable.html#v:linearRead，但我不确定如何使用它们，我无法从它们的类型签名，因为我对 Haskell 非常陌生。

这是完成所有图像读取、灰度和边缘检测的代码：

{-# LANGUAGE ScopedTypeVariables #-}
import Prelude hiding (filter)
import System.Environment (getArgs)

import Vision.Detector.Edge (canny)
import Vision.Image
import Vision.Image.Storage.DevIL (Autodetect (..), load, save)

detectEdges :: RGBA -> Grey
detectEdges img =
  let grey = convert img :: Grey
      -- Img blurring --
      blurRadius = 2
      blurred = gaussianBlur blurRadius (Nothing :: Maybe Double) grey :: Grey

      -- Sobel applying --
      sobelRadius = 2
      lowThreshold = 256
      highThreshold = 1024
  in (canny sobelRadius lowThreshold highThreshold blurred) :: Grey

processImg :: RGBA -> RGBA
processImg img =
  let edges = detectEdges img
  -- Here goes all of the important stuff
  in convert edges :: RGBA

main :: IO ()
main = do
  [input, output] <- getArgs

  io <- load Autodetect input
  case io of
    Left err             -> do
      putStrLn "Unable to load the image:"
      print err

    Right (img :: RGBA)  -> do
      mErr <- save Autodetect output (processImg img)
      case mErr of
        Nothing  ->
          putStrLn "Success."
        Just err -> do
          putStrLn "Unable to save the image:"
          print err

提前谢谢你。

Answer 1

如何找到连接组件的面积和周长？

您可以使用来自Vision.Image.Contour 的轮廓跟踪来获取所有轮廓周长。首先让我们从获得您所拥有的优势开始：

{-# LANGUAGE ScopedTypeVariables #-}
import Prelude as P
import System.Environment (getArgs)

import Vision.Detector.Edge (canny)
import Vision.Image
import Vision.Primitive.Shape
import Vision.Image.Storage.DevIL (Autodetect (..), load, save)
import Vision.Image.Transform(floodFill)
import Control.Monad.ST (runST, ST)
import Vision.Image.Contour

-- Detects the edge of the image with the Canny's edge detector.
--
-- usage: ./canny input.png output.png
main :: IO ()
main = do
    [input, output] <- getArgs

    -- Loads the image. Automatically infers the format.
    io <- load Autodetect input

    case io of
        Left err             -> do
            putStrLn "Unable to load the image:"
            print err
        Right (grey :: Grey) -> do
            let blurred, edges :: Grey
                edges = canny 2 256 1024 blurred :: Grey

这里是我们获取轮廓的地方。由于我稍后使用的绘图功能中的错误，我将首先模糊以获得具有不同内点和外点的轮廓。这最终会得到修补......

                cs           = contours (blur 2 edges :: Grey)
                goodContours = P.filter goodSize (allContourIds cs)

现在我们有一个 Contours 类型的值，其中包含每个连接组件的有效 ContourId。对于每个ContourId，您可以使用contourSize 获取其面积，使用contourPerimeter 获取周长。周长的大小就是周长点列表的长度。

我刚刚做了一个非常定制的过滤器，称为 goodSize 来获得勺子，但你可以随意调整面积和周长：

                goodSize x   = let ((xmin,xmax),(ymin,ymax)) = contourBox cs x
                               in xmax-xmin > 60 && xmax-xmin < 500 &&
                                  ymax-ymin > 100 && ymax-ymin < 500

                final, filledContours :: RGBA
                filledContours =
                   convert $ drawContours cs (shape edges) Fill goodContours

（可选）对于每个轮廓，使用 floodFill 来获取颜色。在这里，我只使用三种颜色并填充列表中的第一个轮廓。轮廓列表从上到下从左到右排序，所以这看起来很奇怪。您可以sortBy xmin goodContours 获得左右排序。

                floodStart = concatMap (take 1 . contourPerimeter cs) goodContours
                colors = cycle [RGBAPixel 255 0 0 255, RGBAPixel 0 255 0 255, RGBAPixel 0 0 255 255]
                final = runST doFill

填充操作使用ST monad，您可以在 StackOverflow 上找到很多关于这里的问题。

                doFill :: forall s. ST s RGBA
                doFill = do
                          m <- thaw filledContours :: ST s (MutableManifest RGBAPixel s)
                          mapM_ (\(p,c) -> floodFill p c m) (zip floodStart colors)
                          return =<< unsafeFreeze m

            -- Saves the edges image. Automatically infers the output format.
            mErr <- save Autodetect output final
            case mErr of
                Nothing  ->
                    putStrLn "Success."
                Just err -> do
                    putStrLn "Unable to save the image:"
                    print err

contourBox cs x =
  let ps = contourPerimeter cs x
      (xs,ys) = unzip $ P.map (\(Z :. x :. y) -> (x,y)) ps
  in ((minimum xs, maximum xs), (minimum ys, maximum ys))

最终结果是：

Answer 2

我在您的帖子中没有看到问题，最接近的似乎是：

但我无法找到遍历所有像素的方法。

您可以使用map 遍历所有像素，但是...这只是一张地图，您不会得到任何状态（毕竟它不是折叠）。因此，您可能想要创建自己的原始递归函数，并使用与! 相同的index 索引每个像素。

你也说过：

我的想法是使用星期五的边缘检测，然后用它的填充功能填充所有封闭区域。

好吧，如果您填充“所有封闭区域”，那么您的整个图片将被 white 填充，而外部轮廓取决于填充策略 - 请注意包含整个图像的较大矩形。我建议你做一个轮廓跟踪并过滤一些简单的东西，比如周长、高度、宽度或比率。我的轮廓模块还没有升级到hackage，但是你可以从github上得到它。请注意，drawContour 功能在其正常运行后应该可以为您工作（这也是我暂时不将其推送到 Hackage 的部分原因）。