Image processing in R

Simple image processing steps using R

Have you ever found yourself doing a million of clicks when preparing your stimuli? 

In some cases you can solve this issue with few lines of code. In this post I want to do a little introduction on how to do basic image processing in R. There are 2 pretty well known C libraries that have been ported entirely in R. The package Imager (Barthelme', 2018) which is a porting of the C library CImg (written in C++ by David Tschumperlé). The package Magick also ported from C++ by Jeroen Ooms.

Both packages have a great range of functions for image processing and image statistics. Thanks to the imager functions cimg2magick() and magick2cimg() included in the imager package they are also highly compatible between each other and can easily benefit from the excellent functions of both packages with the same pool of images!

Here I cannot do a full complete intro of these packages but I will introduce a few of these functions plus some basic way to import all the images in a folder and perform operations in loop to all of them. Note that many of the functions are well introduced in the packages documentation, here Imager and Magick . So the focus here would be to provide a basic guide to those that might need to learn few tips on how to loop operations in R over lists.

#if you have never installed these packages before

install.packages("imager")

install.packages("magick")

#load the packages in R

library(imager)

library(magick)

Now Packages are loaded. Say we want to load all the images from the folder /Documents/Images

imgpath <- "/Documents/Images" #define a variable with the image path

imgfiles <- list.files(imgpath, full.names = TRUE, pattern = "jpg") #list all the img files in img path

imgnames <- list.files(imgpath, pattern = "jpg") #without full names gets only the img title.   

#read the images in the folder with imager and store it into a variable

imgList <- imager::load.dir(imgpath)

#read the images in the folder with magick

imglist <- list() # define empty list

for(img in seq_along(imgfiles)) {

imglist[[img]] <- magick::image_read(imgfiles[[img]])

}      

Ok let's take a little break to comment this. The imager package has already a function that would load all the directory  (load.dir), pretty handy! 

The Magick package, to my knowledge, does not. So for the first time we are asked to loop and read one image at a time to store it into a list.

In both cases a folder with images in R will be loaded as a list. If you are not familiar with R objects this is more complex than a vector, of course, and more complex than a dataframe. A list can contain as many objects that we want. Within a list there can be other dataframes or even list of dataframes. Lists are indexed in R as you can see above with the double squared bracket! I normally work with gray scaled images which are two dimensional but potentially an image list could contain a full folder with coloured images where the structure is more complex!

Now that you have a list of images in you are in power! you can do whatever you like with those images as if you were working on a single one. Let's grayscale them all in one go.

imggraylist <- list()

for (img in seq_along(imglist)) {

imggraylist[[img]] <- imager::grayscale(imglist[[img]],method = "XYZ")

#or the same thing with magick

imggraylist[[img]] <- magick::image_convert(imglist[[img]], colorspace = "gray")

}

Nice, you now have a list of grayscaled images!!!  Note that this is for demonstration purposes with both packages. If you run the code the way it is you will end up having only the imggraylist created with magick because it will be overwritten! So pick one of them!

Now you might want to export all these nice grayscaled images:

for (img in seq_along(imggraylist)) {

# Do it with Imager

imager::save.image(as.cimg(imggraylist[[img]]), paste0(imgpath, "gray_",imgnames[[img]]), quality = 0.75)

# or Magick

magick::image_write(imggraylist[[img]], paste0(imgpath, "gray_",imgnames[[img]]), quality = 75)

}

You can see here that both functions get as a first argument the image you need to write and as a second argument the path. I use paste 0 to concatenate the file path in imgpath with the prefix "gray_" and the imgname for each image. As a third argument there is the quality. In imager is from 0 to 1 while in magick is from 0 to 100! 

You could export the images in another format, just be careful to the names! because at the moment the imgnames contains the extension.

The two packages overlap for basics of image processing. However, they differ greatly for other aspects not covered here. Nicely, the package imager has 2 functions that enable quick and easy conversion between the two image classes within R:

cimg2magick : To convert an imager class to magick

magick2cimg: To convert a magick class image to cimg

So in the case you need to use the function of one after having worked with the other you can easily use these to change the image class in most cases!

Make Everything faster using lapply rather than for loops

To me for loops are the clearer way to show what you are doing but the code can get quite verbose and hard to read. Further, if you have a very large amount of images, they can be very slow, particularly using Imager. There are several solutions for speeding up looped operations. One that is very easy is to use the functions from the apply family from base R to loop through your lists. This will make everything noticeably faster. Honestly I didn't bother doing it for a long time thinking that the difference would have been barely noticeable... However that is not the case. So if you have a large image list this is definitely the way to go. An example below using Imager  with lapply :

imglist <- imager::load.dir("path/myimages/")

doimproc <- function(x){

  grayscale(x, method = "XYZ")

  imager::resize_halfXY(x)

}

sttime <- Sys.time() #start the clock

proclist <- lapply(imglist, doimproc) #apply function to the imglist and store it in proclist

entime <- Sys.time() #stop the clock

print(entime - sttime)

Lapply takes as arguments: the list you want to loop the operations on, and the function you want to apply to the elements of such list. Here this function has been user-defined. It does not do anything special, it simply combines to other functions from imager. That is grayscale and resize half. In one go I grayscaled and resized all the images in one folder. You can have some "fun" benchmarking how quick are the operations with lapply vs the for loops. I added a clock above as an example..

Flip horizontally all the images in a folder and export them in another folder

Here is a small example of how you could make your image processing efficient by building functions yourself.

In this case I built a little function to flip all the images in a folder and export them into another. This help if you want to do this operation in several folders to avoid a billion loops and to make sure to not overload with too many images the RAM of your computer.

flip_images <- function(importpath, exportpath, imgformat = "jpg"){

  ## this function will flip all the images in an importpath (string), and export them in a 

  ## exportpath (string). You also include the imgformat. It defaults to JPEG but could also insert png.

  ## for example: flip_images("stimuli/imgs_to_flip", "stimuli/imgs_flipped", format = "png").

  ## allstrings

  if (!require('magick')) install.packages('magick'); library('magick')

  if (!require('purrr')) install.packages('purrr'); library('purrr')

  ### get the filepaths

  filelist <- list.files(importpath, pattern = ".jpg|.png", full.names = TRUE)

print(filelist);

  ## get the basenames of these paths

  thenames <- basename(filelist)

  ## read the images

  imlist <- map(filelist, image_read)

  print("IMAGE LIST IS LOADED")

  ## flip the images

  fl_imlist <- map(imlist, image_flop)

  print("IMAGE LIST IS FLIPPED, prepare to write imgs")

  ## remove the list of the nonflipped imgs

  rm(imlist)

  ## export all the images to the destinationpath

  for(img in seq_along(fl_imlist)){

    image_write(fl_imlist[[img]], paste0(exportpath, "/", thenames[img]), quality = 100, format = imgformat)

  }

  rm(fl_imlist)

}

You can download this function here: https://github.com/marco2gandolfo/rcourse/blob/main/flip_images.R or copy paste it in your R environment and save it as a function. To use it remember to either run it or use the function source("yourpath/flip_images.R")  to have it available in your R space.

Shift an object position within a plain background image without flipping :)