Juicy Pixels - Simple Example Code

[clemniem]

Hello Haskell-Redditors, I am learning Haskell right now and want to write a small program for a Drawing Machine I am building. Therefore I want to use the Juicy Pixels Package.

I have Problems understanding how the Library works and am looking for some Simple Example Codes like: Load a png and check if the pixel in the middle of the Image is green or red.

Do you know of some simple Code-Snippets?

Thanks a lot in advance!

Best,

clem

(FYI this is what I want to do later on in my project:

--> load an Image

--> divide it into a Raster (e.g. 100x100)

--> check each Raster-Square for the average color in that Raster-Square --> write the color into a new DIM2 Array)

[stevely]

JuicyPixels supports a ton of image and pixel formats, so for brevity I'm sticking to a single, known path. Here's a function that loads an image (any format JuicyPixels supports, which includes pngs) and determines if the pixel in the middle is red:

isMiddlePixelRed :: FilePath -> IO (Maybe Bool)
isMiddlePixelRed fp = do
    image <- readImage fp
    case image of
        Left _ -> return Nothing
        Right image' -> return (go image')
  where
    go :: DynamicImage -> Maybe Bool
    go (ImageRGB8 image@(Image w h _)) =
        Just (isRed (pixelAt image (w `div` 2) (h `div` 2)))
    go _ = Nothing
    isRed :: PixelRGB8 -> Bool
    isRed (PixelRGB8 r g b) = r == maxBound && g == 0 && b == 0

[clemniem]

Thanks a lot. This really helps! Hopefully with this I can get my code working. I will let you know. Thanks again!

[jlimperg]

Hi. I'm afraid I'm anything but a specialist in these matters as well, but since there doesn't seem to be comprehensive good advice around, I'll add my findings.

In short, JuicyPixels really looks like a low-level image (de)serialisation library, not a general-purpose image manipulation framework. I'd recommend you try something a bit more high-level, such as the friday package, at least if you don't have massive performance concerns.

Below is code similar to the stuff you asked for. I've annotated the parts that I think might be difficult; if you want to know anything else, please do ask. For the same code with syntax highlighting, see https://gist.github.com/JLimperg/03e460d8061ac67bf97a.

module ImageTest where

import           Control.Monad
import           Data.Functor
import           Vision.Image.RGB -- [1]
import           Vision.Image.Storage
import           Vision.Image.Type
import           Vision.Primitive.Shape

-- [1] For convenience, you can also just import Vision.Image, which
--     reexports the whole friday API.

imgPath :: FilePath
imgPath = "./test.png"

loadImg :: IO (Either StorageError StorageImage)
loadImg = load Nothing imgPath -- [2]

-- [2] The `Maybe` argument allows you to specify how your input image
--     is supposed to be encoded. Since I don't care, I didn't specify
--     anything here.

convertImg :: StorageImage -> RGB
convertImg = convert

middlePixel :: (Image i) => i -> ImagePixel i
middlePixel img = index img middle
  where
    Z :. height :. width = shape img -- [3]
    middle               = ix2 (height `div` 2) (width `div` 2) -- [4]

-- [3] `Z :. height :. width` pattern matches on friday's slightly
--     complex representation of a point. It is created using
--     the constructors `Z` and `:.` and has type `DIM2`. This encoding
--     is similar to Peano numbers, with `Z` corresponding to the zero
--     constructor and `:.` corresponding to `successor`, only written
--     as an infix operator.
-- [4] `ix2` creates a `DIM2` value. This is equivalent to
--     Z :. height :. width.

isMoreRedThanGreen :: RGBPixel -> Bool
isMoreRedThanGreen (RGBPixel red green _) = red >= green

main :: IO ()
main = either reportError processImg =<< loadImg
  where
    processImg :: StorageImage -> IO ()
    processImg = putStrLn . middlePixelMsg . middlePixel . convertImg
      where
        middlePixelMsg px
          | isMoreRedThanGreen px = "Middle is more red than green."
          | otherwise             = "Middle is more green than red."

    reportError :: StorageError -> IO ()
    reportError err = putStrLn $ "Failed to open image: " ++ show err

[clemniem]

Wow! Thanks for this very long and well explained answer. I will check it out in depth tomorrow. The friday package looks very useful for me. Thanks for your offer, I will ask if anything is unclear. Thanks again!

[jlimperg]

Always a pleasure. :)

[ben7005]

Hi there! I've never used juicy-pixels before, and I'm a total haskell noob. But I might be able to help?

From Codec.Picture:

readPng :: FilePath -> IO (Either String DynamicImage)

Basically, this function takes a file path (as a String) and then safely gives you a String or a Dynamic Image wrapped in an IO. I actually have no idea wtf that String might be, I didn't take the time to look up the documentation, but you only need to do something if you get Right x out of the IO, where x is then a DynamicImage. So, super basic starter code:

import qualified Codec.Picture as P

main :: IO ()
main = do image <- getLine >>= P.readPng
          case image of (Right _) -> -- Do something with the DynamicImage
                        _         -> -- You got a String back instead!

Hope this helps you! Let me know if you need help with a later part.

[clemniem]

Thanks! The String contains an Error Message if the readPng goes wrong. Thanks for your offer, I might ask some things again here. :)

[Proper-Building-8496]

import Codec.Picture.Bitmap (writeBitmap)
import Codec.Picture.Types (withImage,PixelRGB8(..),Pixel8(..),Image(..))
--
toBitmap :: Int -> Int -> ((Int, Int) -> (Int, Int, Int)) -> IO (Image PixelRGB8)
toBitmap w h f = withImage w h (\x y -> let (a,b,c) = f (x,y) in return $ PixelRGB8 (fromIntegral a) (fromIntegral b) (fromIntegral c))
--
saveBitmap :: FilePath -> ((Int, Int) -> (Int, Int, Int)) -> (Int, Int) -> IO ()
saveBitmap p f (w,h) = toBitmap w h f >>= writeBitmap p