Type:	Package
Title:	An Image Processing Toolkit
Version:	1.3.0
Date:	2023-07-08
Maintainer:	Lampros Mouselimis <mouselimislampros@gmail.com>
BugReports:	https://github.com/mlampros/OpenImageR/issues
URL:	https://github.com/mlampros/OpenImageR
Description:	Incorporates functions for image preprocessing, filtering and image recognition. The package takes advantage of 'RcppArmadillo' to speed up computationally intensive functions. The histogram of oriented gradients descriptor is a modification of the 'findHOGFeatures' function of the 'SimpleCV' computer vision platform, the average_hash(), dhash() and phash() functions are based on the 'ImageHash' python library. The Gabor Feature Extraction functions are based on 'Matlab' code of the paper, "CloudID: Trustworthy cloud-based and cross-enterprise biometric identification" by M. Haghighat, S. Zonouz, M. Abdel-Mottaleb, Expert Systems with Applications, vol. 42, no. 21, pp. 7905-7916, 2015, <doi:10.1016/j.eswa.2015.06.025>. The 'SLIC' and 'SLICO' superpixel algorithms were explained in detail in (i) "SLIC Superpixels Compared to State-of-the-art Superpixel Methods", Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua, and Sabine Suesstrunk, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 34, num. 11, p. 2274-2282, May 2012, <doi:10.1109/TPAMI.2012.120> and (ii) "SLIC Superpixels", Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua, and Sabine Suesstrunk, EPFL Technical Report no. 149300, June 2010.
License:	GPL-3
Encoding:	UTF-8
Copyright:	inst/COPYRIGHTS
SystemRequirements:	libarmadillo: apt-get install -y libarmadillo-dev (deb), libblas: apt-get install -y libblas-dev (deb), liblapack: apt-get install -y liblapack-dev (deb), libarpack++2: apt-get install -y libarpack++2-dev (deb), gfortran: apt-get install -y gfortran (deb), libjpeg-dev: apt-get install -y libjpeg-dev (deb), libpng-dev: apt-get install -y libpng-dev (deb), libfftw3-dev: apt-get install -y libfftw3-dev (deb), libtiff5-dev: apt-get install -y libtiff5-dev (deb)
Depends:	R(≥ 3.2.3)
Imports:	Rcpp (≥ 0.12.17), graphics, grDevices, grid, shiny, jpeg, png, tiff, R6, lifecycle, tools
LinkingTo:	Rcpp, RcppArmadillo (≥ 0.8.0)
Suggests:	testthat, knitr, rmarkdown, covr
RoxygenNote:	7.2.3
VignetteBuilder:	knitr
NeedsCompilation:	yes
Packaged:	2023-07-08 07:59:50 UTC; lampros
Author:	Lampros Mouselimis [aut, cre], Sight Machine [cph] (findHOGFeatures function of the SimpleCV computer vision platform), Johannes Buchner [cph] (average_hash, dhash and phash functions of the ImageHash python library), Mohammad Haghighat [cph] (Gabor Feature Extraction), Radhakrishna Achanta [cph] (Author of the C++ code of the SLIC and SLICO algorithms (for commercial use please contact the author)), Oleh Onyshchak [cph] (Author of the Python code of the WarpAffine function)
Repository:	CRAN
Date/Publication:	2023-07-08 11:00:05 UTC

image augmentations of a matrix, data frame, array or a list of 3-dimensional arrays (where the third dimension is equal to 3)

Description

image augmentations of a matrix, data frame, array or a list of 3-dimensional arrays (where the third dimension is equal to 3)

Usage

Augmentation(
  image,
  flip_mode = NULL,
  crop_width = NULL,
  crop_height = NULL,
  resiz_width = 0,
  resiz_height = 0,
  resiz_method = "nearest",
  shift_rows = 0,
  shift_cols = 0,
  rotate_angle = 0,
  rotate_method = "nearest",
  zca_comps = 0,
  zca_epsilon = 0,
  image_thresh = 0,
  padded_value = 0,
  verbose = FALSE
)

Arguments

Details

This function takes advantage of various methods to accomplish image augmentations. The order of the preprocessing steps, in case that all transformations are applied to an image, is : 1st flip image, 2nd crop image, 3rd resize image, 4th shift rows or columns, 5th rotate image, 6th zca-whitening and 7th image-thresholding.

Value

the output is of the same type with the input (in case of a data frame it returns a matrix)

Author(s)

Lampros Mouselimis

Examples

## Not run: 

# a matrix
object = matrix(1, 10, 10)

res = Augmentation(object, resiz_width = 8, resiz_height = 8, rotate_angle = 40)


# an array
object = array(0, dim = c(10, 10, 3))

res = Augmentation(object, resiz_width = 8, resiz_height = 8, rotate_angle = 30)


# an array (multiple matrices)
object = array(0, dim = c(10, 10, 10))

res = Augmentation(object, resiz_width = 8, resiz_height = 8, rotate_angle = 20)


# a list of 3-dimensional arrays (where the third dimension is equal to 3)
object = list(array(0, dim = c(10, 10, 3)), array(0, dim = c(10, 10, 3)))

res = Augmentation(object, resiz_width = 8, resiz_height = 8, rotate_angle = 40)

## End(Not run)

Gabor Feature Extraction

Description

Gabor Feature Extraction

Gabor Feature Extraction

Usage

# init <- GaborFeatureExtract$new()

Details

In case of an RGB image (3-dimensional where the third dimension is equal to 3) one can use the rgb_2gray() to convert the image to a 2-dimensional one

I added the option downsample_gabor to the original matlab code based on the following question on stackoverflow : https://stackoverflow.com/questions/49119991/feature-extraction-with-gabor-filters

Methods

GaborFeatureExtract$new()

--------------

gabor_filter_bank(scales, orientations, gabor_rows, gabor_columns, plot_data = FALSE)

--------------

gabor_feature_extraction(image, scales, orientations, gabor_rows, gabor_columns, downsample_gabor = FALSE, plot_data = FALSE, downsample_rows = NULL, downsample_cols = NULL, normalize_features = FALSE, threads = 1, vectorize_magnitude = TRUE)

--------------

gabor_feature_engine(img_data, img_nrow, img_ncol, scales, orientations, gabor_rows, gabor_columns, downsample_gabor = FALSE, downsample_rows = NULL, downsample_cols = NULL, normalize_features = FALSE, threads = 1, verbose = FALSE)

--------------

plot_gabor(real_matrices, margin_btw_plots = 0.15, thresholding = FALSE)

--------------

plot_multi_images(list_images, par_ROWS, par_COLS)

--------------

Methods

Public methods

• GaborFeatureExtract$new()

• GaborFeatureExtract$gabor_filter_bank()

• GaborFeatureExtract$gabor_feature_extraction()

• GaborFeatureExtract$gabor_feature_engine()

• GaborFeatureExtract$plot_gabor()

• GaborFeatureExtract$plot_multi_images()

• GaborFeatureExtract$clone()

Method new()

Usage

GaborFeatureExtract$new()

Method gabor_filter_bank()

Usage

GaborFeatureExtract$gabor_filter_bank(
  scales,
  orientations,
  gabor_rows,
  gabor_columns,
  plot_data = FALSE
)

Arguments

Method gabor_feature_extraction()

Usage

GaborFeatureExtract$gabor_feature_extraction(
  image,
  scales,
  orientations,
  gabor_rows,
  gabor_columns,
  downsample_gabor = FALSE,
  plot_data = FALSE,
  downsample_rows = NULL,
  downsample_cols = NULL,
  normalize_features = FALSE,
  threads = 1,
  verbose = FALSE,
  vectorize_magnitude = TRUE
)

Arguments

Method gabor_feature_engine()

Usage

GaborFeatureExtract$gabor_feature_engine(
  img_data,
  img_nrow,
  img_ncol,
  scales,
  orientations,
  gabor_rows,
  gabor_columns,
  downsample_gabor = FALSE,
  downsample_rows = NULL,
  downsample_cols = NULL,
  normalize_features = FALSE,
  threads = 1,
  verbose = FALSE
)

Arguments

Method plot_gabor()

Usage

GaborFeatureExtract$plot_gabor(
  real_matrices,
  margin_btw_plots = 0.65,
  thresholding = FALSE
)

Arguments

Method plot_multi_images()

Usage

GaborFeatureExtract$plot_multi_images(
  list_images,
  par_ROWS,
  par_COLS,
  axes = FALSE,
  titles = NULL
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

GaborFeatureExtract$clone(deep = FALSE)

Arguments

References

https://github.com/mhaghighat/gabor

https://stackoverflow.com/questions/20608458/gabor-feature-extraction

https://stackoverflow.com/questions/49119991/feature-extraction-with-gabor-filters

Examples

library(OpenImageR)

init_gb = GaborFeatureExtract$new()

# gabor-filter-bank
#------------------

gb_f = init_gb$gabor_filter_bank(scales = 5, orientations = 8, gabor_rows = 39,

                                 gabor_columns = 39, plot_data = TRUE)


# plot gabor-filter-bank
#-----------------------

plt_f = init_gb$plot_gabor(real_matrices = gb_f$gabor_real, margin_btw_plots = 0.65,

                           thresholding = FALSE)


# read image
#-----------

pth_im = system.file("tmp_images", "car.png", package = "OpenImageR")

im = readImage(pth_im) * 255


# gabor-feature-extract
#----------------------

# gb_im = init_gb$gabor_feature_extraction(image = im, scales = 5, orientations = 8,

#                                          downsample_gabor = TRUE, downsample_rows = 3,

#                                          downsample_cols = 3, gabor_rows = 39, gabor_columns = 39,

#                                          plot_data = TRUE, normalize_features = FALSE,

#                                          threads = 6)


# plot real data of gabor-feature-extract
#----------------------------------------

# plt_im = init_gb$plot_gabor(real_matrices = gb_im$gabor_features_real, margin_btw_plots = 0.65,

#                             thresholding = FALSE)


# feature generation for a matrix of images (such as the mnist data set)
#-----------------------------------------------------------------------

ROWS = 13; COLS = 13; SCAL = 3; ORIEN = 5; nrow_mt = 500; im_width = 12; im_height = 15

set.seed(1)
im_mt = matrix(sample(1:255, nrow_mt * im_width * im_height, replace = TRUE), nrow = nrow_mt,

                      ncol = im_width * im_height)

# gb_ex = init_gb$gabor_feature_engine(img_data = im_mt, img_nrow = im_width, img_ncol = im_height,

#                                      scales = SCAL, orientations = ORIEN, gabor_rows = ROWS,

#                                      gabor_columns = COLS, downsample_gabor = FALSE,

#                                      downsample_rows = NULL, downsample_cols = NULL,

#                                      normalize_features = TRUE, threads = 1, verbose = FALSE)


# plot of multiple image in same figure
#---------------------------------------

list_images = list(im, im, im)

plt_multi = init_gb$plot_multi_images(list_images, par_ROWS = 2, par_COLS = 2)

calculate the HOG (Histogram of oriented gradients) for an image

Description

The function is a modification of the 'findHOGFeatures' function of the SimpleCV package [ please consult the COPYRIGHT file ] The function takes either an RGB (it will be converted to gray) or a gray image and returns a vector of the HOG descriptors. The main purpose of the function is to create a vector of features, which can be used in classification tasks.

Usage

HOG(image, cells = 3, orientations = 6)

Arguments

Details

This function takes either a matrix, a data frame or a 3-dimensional array (where the third dimension is equal to 3) and returns a vector with the HOG-descriptors (histogram of oriented gradients).

Value

a numeric vector

Examples

## Not run: 

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

res = HOG(image, cells = 3, orientations = 6)

## End(Not run)

calculate the HOG (Histogram of oriented gradients) for a matrix, array or a folder of images

Description

calculate the HOG (Histogram of oriented gradients) for a matrix, array or a folder of images

Usage

HOG_apply(
  object,
  cells = 3,
  orientations = 6,
  rows = NULL,
  columns = NULL,
  threads = 1
)

Arguments

Details

This function takes as input either a matrix, a data frame, a 3-dimensional array (where the third dimension is equal to 3) or a character path to a folder of files (images). It returns the HOG-descriptors (histogram of oriented gradients) for each row (if matrix or data frame), for each array-slice (if array) or for each file (if path to a folder of images).

Value

If the input is a matrix, data frame or array it returns a matrix of the hog descriptors. If the input is a path to a folder it returns a list of length 2, the 1st sublist is a vector with the names of the image files (the order of the files in the vector corresponds to the order of the rows of the output matrix), the 2nd sublist is the matrix of the hog descriptors.

Examples

## Not run: 

MATR = matrix(runif(75), ncol = 25, nrow = 5)

res = HOG_apply(MATR, cells = 3, orientations = 5, rows = 5, columns = 5, threads = 1)


ARRAY = array(5, dim = c(10, 10, 3))

res = HOG_apply(ARRAY, cells = 3, orientations = 6, threads = 1)


FOLDER_path = paste0(system.file("tmp_images", "same_type", package = "OpenImageR"), '/')

res = HOG_apply(FOLDER_path, cells = 3, orientations = 6, threads = 1)

## End(Not run)

convert a list of matrices to an array of matrices

Description

convert a list of matrices to an array of matrices

Usage

List_2_Array(data, verbose = FALSE)

Arguments

Details

This is a helper function mainly for the HOG and hash functions. In case that matrices are stored in a list, this function converts the list to an array of 2-dimensional data.

Value

an array

Author(s)

Lampros Mouselimis

Examples

lst = list(matrix(0, 100, 100), matrix(1, 100, 100))

arr = List_2_Array(lst, verbose = FALSE)

minimum and maximum values of vector, matrix, data frame or array

Description

minimum and maximum values of vector, matrix, data frame or array

Usage

MinMaxObject(x)

Arguments

Details

This helper function returns the minimum and maximum values of a vector, 2-dimensional or 3-dimensional objects (where the third dimension is equal to 3). In case of a vector, matrix or data frame it returns a single value for the minimum and maximum of the object. In case of an array it returns the minimum and maximum values for each slice of the array.

Value

a list

Author(s)

Lampros Mouselimis

Examples

# vector
x = 1:10

res = MinMaxObject(x)


# matrix
x = matrix(runif(100), 10, 10)

res = MinMaxObject(x)


# data frame
x = data.frame(matrix(runif(100), 10, 10))

res = MinMaxObject(x)


# array
x = array(runif(300), dim = c(10, 10, 3))

res = MinMaxObject(x)

normalize a vector, matrix or array (in the range between 0 and 1)

Description

normalize a vector, matrix or array (in the range between 0 and 1)

Usage

NormalizeObject(x)

Arguments

Details

This is a helper function which normalizes all pixel values of the object to the range between 0 and 1. The function takes either a vector, matrix, data frame or array as input and returns a normalized object of the same type (in case of data frame it returns a matrix).

Value

either a normalized vector, matrix, or array

Author(s)

Lampros Mouselimis

Examples

# vector
x = 1:10

res = NormalizeObject(x)


# matrix
x = matrix(runif(100), 10, 10)

res = NormalizeObject(x)


# data frame
x = data.frame(matrix(runif(100), 10, 10))

res = NormalizeObject(x)


# array
x = array(runif(300), dim = c(10, 10, 3))

res = NormalizeObject(x)

Conversion of RGB to HSV colour type

Description

Conversion of RGB to HSV colour type

Usage

RGB_to_HSV(input_data)

Arguments

Details

Meaning: RGB (Red-Green-Blue) to HSV (Hue, Saturation, Value) colour conversion

Examples

library(OpenImageR)

set.seed(1)
array_3d = array(sample(1:255, 675, replace = TRUE), c(15, 15, 3))

res = RGB_to_HSV(array_3d)

Conversion of RGB to Lab colour type

Description

Conversion of RGB to Lab colour type

Usage

RGB_to_Lab(input_data)

Arguments

Details

Meaning: RGB (Red-Green-Blue) to LAB (Lightness, A-colour-dimension, B-colour-dimension) colour conversion

References

https://www.epfl.ch/labs/ivrl/research/snic-superpixels/

Examples

library(OpenImageR)

set.seed(1)
array_3d = array(sample(1:255, 675, replace = TRUE), c(15, 15, 3))

res = RGB_to_Lab(array_3d)

zca whiten of an image

Description

this function performs zca-whitening to a 2- or 3- dimensional image

Usage

ZCAwhiten(image, k, epsilon)

Arguments

Details

Whitening (or sphering) is the preprocessing needed for some algorithms. If we are training on images, the raw input is redundant, since adjacent pixel values are highly correlated. When using whitening the features become less correlated and all features have the same variance.

Value

a matrix or 3-dimensional array where the third dimension is equal to 3

References

http://ufldl.stanford.edu/wiki/index.php/Whitening

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

res = ZCAwhiten(image, k = 20, epsilon = 0.1)

calculation of the 'average hash' of an image

Description

This function calculates the average hash of an image

Usage

average_hash(gray_image, hash_size = 8, MODE = "hash", resize = "nearest")

Arguments

Details

The function is a modification of the 'average_hash' function of the imagehash package [ please consult the COPYRIGHT file ]. The average hash works in the following way : 1st convert to grayscale, 2nd, reduce the size of an image (for instance to an 8x8 image, to further simplify the number of computations), 3rd average the resulting colors (for an 8x8 image we average 64 colors), 4th compute the bits by comparing if each color value is above or below the mean, 5th construct the hash.

Value

either a hash-string or a binary vector

Examples

image = readImage(system.file("tmp_images", "1.png", package = "OpenImageR"))

image = rgb_2gray(image)

res_hash = average_hash(image, hash_size = 8, MODE = 'hash')

res_binary = average_hash(image, hash_size = 8, MODE = 'binary')

convolution

Description

convolution

Usage

convolution(image, kernel, mode = "same")

Arguments

Details

This function performs convolution using a kernel matrix. When mode 'same' the output object has the same dimensions with the input, whereas when mode 'full' the rows and columns of the output object equals : ROWS = nrow(image) + nrow(kernel) - 1 and COLUMNS = ncol(image) + ncol(kernel) - 1

Value

either a matrix or an array, depending on the input data

Author(s)

Lampros Mouselimis

Examples

# kernel
x = matrix(1, nrow = 4, ncol = 4) / 16   # uniform


# matrix
image_matrix = matrix(runif(100), 10, 10)

res = convolution(image_matrix, x, "same")


# array
image_array = array(runif(300), dim = c(10, 10, 3))

res = convolution(image_array, x, "same")

crop an image

Description

crop an image

Usage

cropImage(image, new_width, new_height, type = "equal_spaced")

Arguments

Details

This function crops an image in two different ways.

Value

depending on the input, either a matrix or an array

Author(s)

Lampros Mouselimis

Examples

path = system.file("tmp_images", "2.jpg", package = "OpenImageR")

image = readImage(path)

# IF 'equal_spaced':
crop1 = cropImage(image, new_width = 20, new_height = 20, type = 'equal_spaced')

# IF 'user_defined':
crop2 = cropImage(image, new_width = 5:20, new_height = 5:20, type = 'user_defined')

crop an image in R [ for RGB or grey images ]

Description

crop an image in R [ for RGB or grey images ]

Usage

crop_image_secondary(image, new_width, new_height)

Delation or Erosion of an image

Description

'r lifecycle::badge("deprecated")'

This function was deprecated because I realized that the name of the function does not correspond to the name of the algorithm (delation -> dilation)

this function performs delation or erosion to a 2- or 3- dimensional image

Usage

delationErosion(image, Filter, method = "delation", threads = 1)

Arguments

Details

This function utilizes a kernel to perform delation or erosion. The first value of the vector indicates the number of rows of the kernel, whereas the second value indicates the number of columns.

Value

a matrix or 3-dimensional array where the third dimension is equal to 3

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

res_delate = delationErosion(image, Filter = c(3,3), method = 'delation')

res_erode = delationErosion(image, Filter = c(5,5), method = 'erosion')

# ->

res_dilate = dilationErosion(image, Filter = c(3,3), method = 'dilation')

res_erode = dilationErosion(image, Filter = c(5,5), method = 'erosion')

calculation of the 'dhash' of an image

Description

This function calculates the dhash of an image

Usage

dhash(gray_image, hash_size = 8, MODE = "hash", resize = "nearest")

Arguments

Details

The function is a modification of the 'dhash' function of the imagehash package [ please consult the COPYRIGHT file ]. In comparison to average_hash and phash, the dhash algorithm takes into consideration the difference between adjacent pixels.

Value

either a hash-string or a binary vector

Examples

image = readImage(system.file("tmp_images", "3.jpeg", package = "OpenImageR"))

image = rgb_2gray(image)

res_hash = dhash(image, hash_size = 8, MODE = 'hash')

res_binary = dhash(image, hash_size = 8, MODE = 'binary')

Dilation or Erosion of an image

Description

this function performs dilation or erosion to a 2- or 3- dimensional image

Usage

dilationErosion(image, Filter, method = "dilation", threads = 1)

Arguments

Details

This function utilizes a kernel to perform dilation or erosion. The first value of the vector indicates the number of rows of the kernel, whereas the second value indicates the number of columns.

Value

a matrix or 3-dimensional array where the third dimension is equal to 3

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

res_dilate = dilationErosion(image, Filter = c(3,3), method = 'dilation')

res_erode = dilationErosion(image, Filter = c(5,5), method = 'erosion')

downsampling an image ( by a factor ) using gaussian blur

Description

downsampling an image ( by a factor ) using gaussian blur

Usage

down_sample_image(
  image,
  factor,
  gaussian_blur = FALSE,
  gauss_sigma = 1,
  range_gauss = 2
)

Arguments

Details

This function downsamples an image with the option to use gaussian blur for optimal output.

Value

depending on the input, either a matrix or an array

Author(s)

Lampros Mouselimis

Examples

path = system.file("tmp_images", "2.jpg", package = "OpenImageR")

image = readImage(path)

dsamp = down_sample_image(image, factor = 2.0, gaussian_blur = TRUE)

edge detection (Frei_chen, LoG, Prewitt, Roberts_cross, Scharr, Sobel)

Description

edge detection (Frei_chen, LoG, Prewitt, Roberts_cross, Scharr, Sobel)

Usage

edge_detection(
  image,
  method = NULL,
  conv_mode = "same",
  approx = F,
  gaussian_dims = 5,
  sigma = 1,
  range_gauss = 2,
  laplacian_type = 1
)

Arguments

Details

This function takes either a matrix or a 3-dimensional array (where the third dimension is equal to 3) and it performs edge detection using one of the following filters : 'Frei_chen', 'LoG' (Laplacian of Gaussian), 'Prewitt', 'Roberts_cross', 'Scharr', 'Sobel'

Value

depending on the input, either a matrix or an array

Author(s)

Lampros Mouselimis

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

res = edge_detection(image, method = 'Frei_chen', conv_mode = 'same')

flip image horizontally or vertically

Description

flip an image row-wise (horizontally) or column-wise (vertically)

Usage

flipImage(image, mode = "horizontal")

Arguments

Details

This function flips an image row-wise or column-wise

Value

a matrix or 3-dimensional array where the third dimension is equal to 3

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

im = readImage(path)

flp = flipImage(im, mode = 'vertical')

function to check the range of values of an image or normalize an image

Description

function to check the range of values of an image or normalize an image

Usage

func_chech_range(image)

secondary function for HOG_apply

Description

secondary function for HOG_apply

Usage

func_transform(image, folder_path, flag_type, RGB_2gray = F)

Gamma correction

Description

Gamma correction

Usage

gamma_correction(image, gamma)

Arguments

Details

This function applies gamma correction to a matrix or to a 3-dimensional array where the third dimension is equal to 3. The gamma correction controls the overall brightness of an image.

Value

depending on the input, either a matrix or an array

Author(s)

Lampros Mouselimis

Examples

path = system.file("tmp_images", "2.jpg", package = "OpenImageR")

image = readImage(path)

filt = gamma_correction(image, gamma = 0.5)

gaussian-kernel

Description

gaussian-kernel

Usage

gaussian_kernel(xy_length = 2, sigma = 1, range_gauss = 2)

Get Affine Transform

Description

Get Affine Transform

Usage

getAffineTransform(original_points, transformed_points)

Arguments

Value

a matrix

References

https://github.com/OlehOnyshchak/ImageTransformations/blob/master/AffineTransformation.ipynb

Examples

require(OpenImageR)

r = 600
c = 600
offset = 50

original_points = matrix(data = c(0, 0, r, 0, 0, c),
                         nrow = 3,
                         ncol = 2,
                         byrow = TRUE)

transformed_points = matrix(data = c(offset, 0, r, offset, 0, c-offset),
                            nrow = 3,
                            ncol = 2,
                            byrow = TRUE)

M_aff = getAffineTransform(original_points = original_points,
                           transformed_points = transformed_points)
M_aff

calculate the binary or the hexadecimal hash for a matrix, array or a folder of images for the average_hash, phash or dhash functions

Description

This function takes either a matrix, array or a folder and returns either the binary hash features or the hashes (as a character vector)

Usage

hash_apply(
  object,
  rows = 28,
  columns = 28,
  hash_size = 8,
  highfreq_factor = 3,
  method = "phash",
  mode = "binary",
  threads = 1,
  resize = "nearest"
)

Arguments

Details

This function calculates the binary hash or the hexadecimal hash for various types of objects.

Value

If the input is a matrix, data frame or array this function returns a matrix (if mode = 'binary') or a character vector (if mode = 'hex_hash'). If the input is a path to a folder the function returns a list of length 2, the 1st sublist is a vector with the names of the image files (the order of the files in the vector corresponds to the order of the rows of the output matrix), the 2nd sublist is a matrix (if mode = 'binary') or a character vector (if mode = 'hex_hash').

Examples

path = paste0(system.file("tmp_images", "same_type", package = "OpenImageR"), '/')

res_phash = hash_apply(path, method = 'phash', mode = 'binary')

display an image

Description

This function displays an image

Usage

imageShow(file_path, clear_viewer = FALSE)

Arguments

Details

This function displays an image using either a character path, a 2- or a 3-dimensional object where the third dimension is equal to 3

Value

displays an image

Examples

# path = system.file("tmp_images", "1.png", package = "OpenImageR")

# imageShow(path)

image thresholding

Description

image thresholding

Usage

image_thresholding(image, thresh)

Arguments

Details

This function applies thresholding to a matrix or to a 3-dimensional array where the third dimension is equal to 3.

Value

a matrix

Author(s)

Lampros Mouselimis

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

filt = image_thresholding(image, thresh = 0.5)

invariant hashing (caclulation of the hamming or the levenshtein distance when the image is flipped, rotated or cropped)

Description

flip-rotate-crop an image and caclulate the hamming or the levenshtein distance for phash, average_hash, dhash

Usage

invariant_hash(
  image,
  new_image,
  method = "phash",
  mode = "binary",
  hash_size = 8,
  highfreq_factor = 4,
  resize = "nearest",
  flip = T,
  rotate = T,
  angle_bidirectional = 10,
  crop = T
)

Arguments

Details

This function performs the following transformations : flips an image (no-flip, horizonal-flip, vertical-flip), rotates an image (no-angle, angle_bidirectional, 360-angle_bidirectional) and crops an image (no-crop, 10-percent-crop, 20-percent-crop). Depending on the type of mode ('binary', 'hash'), after each transformation the hamming or the levenshtein distance between the two images is calculated.

Value

If flip, rotate and crop are all FALSE then the function returns either the hamming distance (if mode = 'binary') or the levenshtein distance (if mode = 'hash') for the two images. If any of the flip, rotate, crop is TRUE then it returns the MIN, MAX of the hamming distance (if mode = 'binary') or the MIN,MAX of the levenshtein distance (if mode = 'hash').

Examples

## Not run: 

path1 = system.file("tmp_images", "1.png", package = "OpenImageR")

path2 = system.file("tmp_images", "2.jpg", package = "OpenImageR")

image1 = rgb_2gray(readImage(path1))

image2 = rgb_2gray(readImage(path2))

res1 = invariant_hash(image1, image2, hash_size = 3, flip = TRUE, crop = FALSE)

res2 = invariant_hash(image1, image2, mode = 'hash', hash_size = 3, angle_bidirectional = 10)

## End(Not run)

laplacian kernels

Description

laplacian kernels

Usage

laplacian_kernels(type = 1)

loads either 2- or 3-dimensional data (where the third dimension is equal to 3) from a binary file

Description

loads either 2- or 3-dimensional data (where the third dimension is equal to 3) from a binary file

Usage

load_binary(path, type)

Arguments

Details

This function can be used to load either 2- or 3-dimensional data (where the third dimension is equal to 3) from a binary file. It is used in combination with the superpixels function in case that the write_slic parameter is not an empty string ("").

Examples

## Not run: 

library(OpenImageR)

#------------------------------------------
# assuming the saved data are 2-dimensional
#------------------------------------------

path = "/my_dir/data.bin"

res = load_binary(path, type = '2d')


## End(Not run)

Normalize a matrix to specific range of values

Description

Normalize a matrix to specific range of values

Usage

norm_matrix_range(data, min_value = -1, max_value = 1)

Arguments

Value

a matrix

Examples

set.seed(1)
mt = matrix(1:48, 8, 6)

res = norm_matrix_range(mt, min_value = -1, max_value = 1)

Padding of matrices or n-dimensional arrays with a user specified value

Description

Padding of matrices or n-dimensional arrays with a user specified value

Usage

padding(input_data, new_rows, new_cols, fill_value = 0)

Arguments

Details

The padding function returns a list, where data is the padded / extended matrix or array and padded_start, padded_end, padded_left and padded_right are integer values specifying how many rows or columsn in up-, down-, left- or right-direction the input matrix or array was padded / extended with the specified fill-value.

Value

a list

Examples

library(OpenImageR)


#-------
# matrix
#-------

set.seed(1)
mt = matrix(runif(100), 10, 10)

res_mt = padding(mt, 15, 20, fill_value = -1)


#------
# array
#------

lst = list(matrix(1, 10, 10), matrix(2, 10, 10))

arr = List_2_Array(lst, verbose = FALSE)

res_arr = padding(arr, 15, 20, fill_value = mean(as.vector(mt)))

calculation of the 'phash' of an image

Description

This function calculates the phash of an image

Usage

phash(
  gray_image,
  hash_size = 8,
  highfreq_factor = 4,
  MODE = "hash",
  resize = "nearest"
)

Arguments

Details

The function is a modification of the 'phash' function of the imagehash package [ please consult the COPYRIGHT file ]. The phash algorithm extends the average_hash by using the discrete cosine transform.

Value

either a hash-string or a binary vector

Examples

image = readImage(system.file("tmp_images", "2.jpg", package = "OpenImageR"))

image = rgb_2gray(image)

res_hash = phash(image, hash_size = 6, highfreq_factor = 3, MODE = 'hash')

res_binary = phash(image, hash_size = 6, highfreq_factor = 3, MODE = 'binary')

this function reads various types of images

Description

Reads images of type .png, .jpeg, .jpg, .tiff

Usage

readImage(path, ...)

Arguments

Details

This function takes as input a string-path and returns the image in a matrix or array form. Supported types of images are .png, .jpeg, .jpg, .tiff. Extension types similar to .tiff such as .tif, .TIFF, .TIF are also supported

Value

the image in a matrix or array form

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

resize an image using the 'nearest neighbors' or the 'bilinear' method

Description

resize an image using the 'nearest neighbors' or the 'bilinear' method

Usage

resizeImage(image, width, height, method = "nearest", normalize_pixels = FALSE)

Arguments

Details

This function down- or upsamples an image using the 'nearest neighbors' or the 'bilinear' method

Value

depending on the input, either a matrix or an array

Author(s)

Lampros Mouselimis

Examples

path = system.file("tmp_images", "2.jpg", package = "OpenImageR")

image = readImage(path)

resiz = resizeImage(image, width = 32, height = 32, method = 'nearest')

convert an RGB image to Gray

Description

convert an RGB image to Gray

Usage

rgb_2gray(RGB_image)

Arguments

Details

This function converts an RGB image to gray

Value

a matrix

Author(s)

Lampros Mouselimis

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

gray = rgb_2gray(image)

Rotate an image by 90, 180, 270 degrees

Description

Rotate an image by 90, 180, 270 degrees

Usage

rotateFixed(image, angle)

Arguments

Details

This function is faster than the rotateImage function as it rotates an image for specific angles (90, 180 or 270 degrees).

Value

depending on the input, either a matrix or an array

Examples

path = system.file("tmp_images", "3.jpeg", package = "OpenImageR")

image = readImage(path)

r = rotateFixed(image, 90)

Rotate an image using the 'nearest' or 'bilinear' method

Description

Rotate an image by angle using the 'nearest' or 'bilinear' method

Usage

rotateImage(image, angle, method = "nearest", mode = "same", threads = 1)

Arguments

Details

This function rotates an image by a user-specified angle

Value

depending on the input, either a matrix or an array

Examples

path = system.file("tmp_images", "2.jpg", package = "OpenImageR")

image = readImage(path)

r = rotateImage(image, 75, threads = 1)

launcher for the shiny application

Description

launcher for the shiny application

Usage

runUI()

secondary function for downsampling

Description

secondary function for downsampling

Usage

sec_gaus_bl(image, factor, sigma, range_gauss)

secondary function for 'resizeImage' [ array ]

Description

secondary function for 'resizeImage' [ array ]

Usage

sec_resiz_array(image, flag = T)

Bounding box for the superpixel labels

Description

Bounding box for the superpixel labels

Usage

superpixel_bbox(superpixel_labels, non_overlapping_superpixels = FALSE)

Arguments

Details

If the non_overlapping_superpixels parameter is set to FALSE then : the superpixel_bbox function returns the bounding box for the labels of the superpixels function. The output is a matrix which contains the min and max indices of the x-y-coordinates and the corresponding unique superpixel labels.

If the non_overlapping_superpixels parameter is set to TRUE then : the superpixel_bbox function returns besides the previously explained matrix also the overlapping indices for each superpixel. These indices can be used to overwrite pixels with a specific value (say 0.0), which might appear in two superpixels simultaneously. This feature might be useful in case a user intends to use an algorithm and the separability of superpixel-segments is of importance.

Therefore in both cases overlapping superpixels will be computed, however if the non_overlapping_superpixels parameter is set to TRUE then also a list of overlapping indices will be returned.

Examples

library(OpenImageR)


#-----------
# read image
#-----------

path = system.file("tmp_images", "slic_im.png", package = "OpenImageR")

im = readImage(path)

im = im[,, 1:3]


#--------------------
# compute superpixels
#--------------------

res = superpixels(input_image = im, method = "slic", superpixel = 200,

                  compactness = 20, return_labels = TRUE)


#-------------------------
# compute the bounding box
#-------------------------

bbox = superpixel_bbox(res$labels, non_overlapping_superpixels = FALSE)


#-------------------------------------------
# plot the bounding boxes of the superpixels ( for illustration purposes )
#-------------------------------------------


graphics::plot(1:ncol(im), type='n', xlim = c(ncol(im), 1), ylim = c(1, nrow(im)))

graphics::rasterImage( flipImage(im), 1, 1, ncol(im), nrow(im))


for (i in 1:nrow(bbox)) {

  # the order of the bounding box is c('xmin', 'ymin', 'xmax', 'ymax')
  graphics::rect(bbox[i,3], bbox[i,1], bbox[i,4], bbox[i,2], border = "red", lwd = 2)
}

Bounding box for a subset of superpixel labels

Description

Bounding box for a subset of superpixel labels

Usage

superpixel_bbox_subset(superpixel_labels, superpixel_subset)

Arguments

Details

This function should be utilized to return the bounding box for a subset of superpixel segments. To compute the bounding box for all superpixels use the superpixel_bbox function.

Examples

library(OpenImageR)


#-----------
# read image
#-----------

path = system.file("tmp_images", "slic_im.png", package = "OpenImageR")

im = readImage(path)

im = im[,, 1:3]


#--------------------
# compute superpixels
#--------------------

res = superpixels(input_image = im, method = "slic", superpixel = 200,

                  compactness = 20, return_labels = TRUE)


#-------------------------
# compute the bounding box   ( for subset of superpixels )
#-------------------------

bbox = superpixel_bbox_subset(res$labels, superpixel_subset = c(0, 10, 30))

SLIC and SLICO superpixel implementations

Description

SLIC and SLICO superpixel implementations

Usage

superpixels(
  input_image,
  method = "slic",
  superpixel = 200,
  compactness = 20,
  return_slic_data = FALSE,
  return_lab_data = FALSE,
  return_labels = FALSE,
  write_slic = "",
  verbose = FALSE
)

Arguments

References

https://www.epfl.ch/labs/ivrl/research/slic-superpixels/

Examples

library(OpenImageR)

#-------------------
# 3-dimensional data
#-------------------

path = system.file("tmp_images", "slic_im.png", package = "OpenImageR")

im = readImage(path)

res = superpixels(input_image = im, method = "slic", superpixel = 200,

                  compactness = 20, return_slic_data = TRUE)


#-------------------
# 2-dimensional data
#-------------------

im_2d = im[,,1]

res_mt = superpixels(input_image = im_2d, method = "slic", superpixel = 200,

                     compactness = 20, return_slic_data = TRUE)

secondary function for edge_detection function

Description

secondary function for edge_detection function

Usage

switch_filter(
  kernel,
  conv_mod,
  gaussian_dims = 5,
  sigma = 1,
  laplacian_type = 1,
  range_gauss = 2
)

if-else function for hashing

Description

if-else function for hashing

Usage

switch_hashing(
  object,
  width,
  height,
  hash_size,
  highfreq_factor,
  method,
  mode,
  threads,
  resize
)

secondary function for invariant_hash

Description

secondary function for invariant_hash

Usage

switch_invariant(method, gray_image, MODE, hash_size, highfreq_factor, resize)

image translation

Description

shift the position of an image by adding/subtracting a value to/from the X or Y coordinates

Usage

translation(image, shift_rows = 0, shift_cols = 0, padded_value = 0)

Arguments

Details

If shift_rows is not zero then the image will be sifted row-wise (upsides or downsides depending on the sign). If shift_cols is not zero then the image will be sifted column-wise (right or left depending on the sign).

Value

a matrix or 3-dimensional array where the third dimension is equal to 3

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

res_tr = translation(image, shift_rows = 10, shift_cols = -10)

uniform filter (convolution with uniform kernel)

Description

uniform filter (convolution with uniform kernel)

Usage

uniform_filter(image, size, conv_mode = "same")

Arguments

Details

This function applies a uniform filter to a matrix or to a 3-dimensional array where the third dimension is equal to 3

Value

depending on the input, either a matrix or an array

Author(s)

Lampros Mouselimis

Examples

path = system.file("tmp_images", "1.png", package = "OpenImageR")

image = readImage(path)

filt = uniform_filter(image, c(4,4), conv_mode = "same")

Verify that the input image extension is valid

Description

Verify that the input image extension is valid

Usage

verify_image_extension(image_path, regex_img = "jpe?g|png|tif$|tiff$")

Arguments

Details

The OpenImageR package uses the 'readPNG', 'readJPEG' and 'readTIFF' R packages in the background. Thus, only image file path extensions that can be processed from these R packages should be used as input to the 'readImage' function

Value

either the image path extension or an error

References

https://github.com/mlampros/OpenImageR/issues/25

Examples

vec_img_ext = c('png', 'PNG', 'jpg', 'JPG', 'jpeg', 'JPEG', 'tif', 'TIF', 'tiff', 'TIFF')

vec_valid = sapply(vec_img_ext, function(x) {
  ext_iter = paste(c('example_image', x), collapse = '.')
  verify_image_extension(image_path = ext_iter)
})

all(vec_img_ext == vec_valid)

Warp Affine

Description

Warp Affine

Usage

warpAffine(img, M, R, C, threads = 1, verbose = FALSE)

Arguments

Value

either a matrix or a 3-dimensional array (where the third dimension is equal to 3)

References

https://github.com/OlehOnyshchak/ImageTransformations/blob/master/AffineTransformation.ipynb

Examples

require(OpenImageR)

path = system.file("tmp_images", "landscape.jpg", package = "OpenImageR")
img = readImage(path)
img = img * 255

#.............................
# compute the affine transform
#.............................

r = ncol(img)
c = nrow(img)
offset = 50

original_points = matrix(data = c(0, 0, r, 0, 0, c),
                         nrow = 3,
                         ncol = 2,
                         byrow = TRUE)

transformed_points = matrix(data = c(offset, 0, r, offset, 0, c-offset),
                            nrow = 3,
                            ncol = 2,
                            byrow = TRUE)

M_aff = getAffineTransform(original_points = original_points,
                           transformed_points = transformed_points)

#..............
# 2-dimensional
#..............

img_2d = rgb_2gray(img)

res_2d = warpAffine(img = img_2d,
                    M = M_aff,
                    R = r,
                    C = c,
                    threads = 1,
                    verbose = TRUE)

# imageShow(res_2d)

#..............
# 3-dimensional
#..............

res_3d = warpAffine(img = img,
                    M = M_aff,
                    R = r,
                    C = c,
                    verbose = TRUE)

# imageShow(res_3d)

This function writes 2- or 3-dimensional image (where the third dimension is equal to 3) data to a file

Description

This function writes 2- or 3-dimensional image (where the third dimension is equal to 3) data to a file. Supported types are .png, .jpeg, .jpg, .tiff (or .tif, .TIFF, .TIF)

Usage

writeImage(data, file_name, ...)

Arguments

Details

This function takes as input a matrix, data frame or array and saves the data in one of the supported image types ( .png, .jpeg, .jpg, .tiff ). Extension types similar to .tiff such as .tif, .TIFF, .TIF are also supported

Value

a saved image file

Examples

# path = system.file("tmp_images", "1.png", package = "OpenImageR")

# im = readImage(path)

# writeImage(im, 'new_image.jpeg')