Computer Vision

At its core, computer vision is the ability of computers to understand and analyze visual content in
the same way humans do. This includes tasks such as recognizing objects and faces, reading text and
understanding the context of an image or video. Computer vision is closely related to artificial
intelligence (AI) and often uses AI techniques such as machine learning to analyze and understand
visual data. Machine learning algorithms are used to “train” a computer to recognize patterns and
features in visual data, such as edges, shapes and colors.

Once trained, the computer can use this knowledge to identify and classify objects in new images
and videos. The accuracy of these classifications can be improved over time through further training
and exposure to more data. In addition to machine learning, computer vision may also use
techniques such as deep learning, which involves training artificial neural networks on large amounts
of data to recognize patterns and features in a way that is similar to how the human brain works.

Below are a few key aspects that Computer Vision seeks to

recognize in the photographs:
Object Detection: The location of the object.

Object Recognition: The objects in the image, and their positions.

Object Classification: The broad category that the object lies in.

Object Segmentation: The pixels belonging to that object

How Does Computer Vision Work?

The computer vision system consists of two main components: a sensory device, such as a camera,
and an interpreting device, such as a computer. The sensory device captures visual data from the
environment and the interpreting device processes this data to extract meaning.

Computer vision algorithms are based on the hypothesis that “our brains rely on patterns to decode
individual objects.” Just as our brains process visual data by looking for patterns in the shapes, colors
and textures of objects, computer vision algorithms process images by looking for patterns in the
pixels that make up the image. These patterns can be used to identify and classify different objects in
the image.

To analyze an image, a computer vision algorithm first converts the image into a set of numerical
data that can be processed by the computer. This is typically done by dividing the image into a grid
of small units called pixels and representing each pixel with a set of numerical values that describe
its color and brightness. These values can be used to create a digital representation of the image
that can be analyzed by the computer.

Once the image has been converted into numerical data, the computer vision algorithm can begin to
analyze it. This generally involves using techniques from machine learning and artificial intelligence
to recognize patterns in the data and make decisions based on those patterns. For example, an
algorithm might analyze the pixel values in an image to identify the edges of objects or to recognize
specific patterns or textures that are characteristic of certain types of objects.

Overall, the goal of computer vision is to enable computers to analyze and understand visual data in
much the same way that human brains and eyes do, and to use this understanding to make
intelligent decisions based on that data.

Applications of computer vision

1. Optical character recognition (OCR): the ability to recognize and extract text from images or
scanned documents
2. Machine inspection: the use of computer vision to inspect and evaluate the quality or
condition of various components or products
3. Retail: the use of computer vision in automated checkout systems and other retail
applications, such as inventory management and customer tracking
4. 3D model building: the use of computer vision to analyze multiple images of an object or
environment and construct a 3D model of it
5. Medical imaging: the use of computer vision to analyze medical images, such as X-rays or CT
scans, to aid in the diagnosis and treatment of patients
6. Automotive safety: the use of computer vision in driver assistance systems and autonomous
vehicles to detect and respond to obstacles and other hazards on the road
7. Match move: the use of computer vision to align and merge CGI elements with live-action
footage in movies and other visual effects
8. Motion capture: the use of computer vision to capture and analyze the movement of actors
or other objects, typically for use in animation or virtual reality applications
9. Surveillance: the use of computer vision to analyze video footage for security and
monitoring purposes
10. Fingerprint recognition and biometrics: the use of computer vision to analyze and recognize
unique physical characteristics, such as fingerprints, for identity verification and other
applications

The Challenges of Computer Vision

Computer vision is a complex field that involves many challenges and difficulties. Some of these
challenges include:

Data limitations : Computer vision requires large amounts of data to train and test algorithms. This
can be problematic in situations where data is limited or sensitive, and may not be suitable for
processing in the cloud. Additionally, scaling up data processing can be expensive and may be
constrained by hardware and other resources.

Learning rate : Another challenge in computer vision is the time and resources required to train
algorithms. While error rates have decreased over time, they still occur, and it takes time for the
computer to be trained to recognize and classify objects and patterns in images. This process
typically involves providing sets of labeled images and comparing them to the predicted output label
or recognition measurements and then modifying the algorithm to correct any errors.

Hardware requirements : Computer vision algorithms are computationally demanding, requiring

fast processing and optimized memory architecture for quicker memory access. Properly configured
hardware systems and software algorithms are also necessary to ensure that image-processing
applications can run smoothly and efficiently.

Inherent complexity in the visual world : In the real world, subjects may be seen from various
orientations and in myriad lighting conditions, and there are an infinite number of possible scenes in
a true vision system. This inherent complexity makes it difficult to build a general-purpose “seeing
machine” that can handle all possible visual scenarios.

Image manipulation
Image manipulation in R refers to the process of editing, altering, or transforming digital images
using the R programming language. This can be done using image processing libraries like the
"imager" package or the "raster" package. Some common operations that can be performed using
these libraries include resizing, cropping, rotating, and converting between different image formats.
In addition, you can use the R graphics system to create plots, charts, and other visualizations of your
images.

Packages that can be used for image manipulation

- The "magick"

- The "mosaic" package

- The "OpenCV" package

- The "raster" package

The “EBImage” package

EBImage
EBImage is a software package for the R programming language that is designed for analyzing and
manipulating images. The package provides a wide range of image analysis and manipulation tools,
including functions for reading and writing images, performing image processing operations like
filtering and edge detection, measuring features like size and shape, and performing statistical
analyses.

The basic syntax for using these functions is as follows:

ebimage_function(input_image, options)

where "input_image" is the name of the image you want to manipulate, and "options" is a list of
options to control how the function operates. For example, to resize an image to half its original size,
you would use the following syntax:

ebimage_resize(input_image, width=.5*width(input_image), height=.5*height(input_image))

How to use EBImage package for image manipulation

# to install: source("http://bioconductor.org/biocLite.R"); biocLite("EBImage")

library("EBImage")

pic <- readImage("sicily.jpeg")

display(pic)

Image Properties
dim(pic) # there are 3 matrices for RGB colors

## [1] 500 380 3

print(pic) # the RGB values are from [0,1]

## Image

## colorMode : Color

## storage.mode : double

## dim : 500 380 3

## frames.total : 3

## frames.render: 1

##

## imageData(object)[1:5,1:6,1]

## [,1] [,2] [,3] [,4] [,5] [,6]

## [1,] 0.9960784 0.9803922 0.9843137 0.2156863 0.2117647 0.1960784

## [2,] 0.9960784 0.9882353 0.9882353 0.2156863 0.2156863 0.1960784

## [3,] 0.9882353 0.9882353 0.9882353 0.2235294 0.2274510 0.2117647

## [4,] 0.9882353 0.9882353 0.9882353 0.2313725 0.2431373 0.2313725

## [5,] 0.9882353 0.9843137 0.9882353 0.2313725 0.2352941 0.2313725

Change to Greyscale

pic_bw <- pic

colorMode(pic_bw) <- Grayscale

display(pic_bw)

## The image contains more than one frame: only the first one is displayed. To display all frames use
'all = TRUE'.

Adjust Brighthness
pic1 <- pic + 0.1 # more light

pic2 <- pic - 0.1 # less light

par(mfrow=c(1,2))

display(pic1)

display(pic2)
Adjust Contrast
pic1 <- pic * 0.5 # reduce contrast

pic2 <- pic * 2 # increase contrast

par(mfrow=c(1,2))

display(pic1)

display(pic2)

Gamma Correction
pic1 <- pic ^ 2

pic2 <- pic ^0.7

par(mfrow=c(1,2))
display(pic1)

display(pic2)

Adding text lables

We can add text to images using the drawtext function for example

library(EBImage)

# Load the image

image_path <- "path_to_your_image.jpg"

image <- readImage(image_path)

# Define the text label

label <- "Hello, World!"

# Specify the font properties

font_size <- 24

font_color <- "white"

# Determine the position to place the label

label_position <- c(10, 10) # X and Y coordinates

# Add the label to the image

image_with_label <- drawText(image, label_position[1], label_position[2], label, cex = font_size/10,

col = font_color)

# Save the modified image

output_path <- "path_to_save_output_image.jpg"

writeImage(image_with_label, output_path)

# Display the image

display(image_with_label)