5 EASY Ways To Integrate Image Processing In Your Apps

In this article, we’ll go over what image processing is, how digital image processing is superior, Image Processing vs Computer Vision, using python windows GUI builder for image processing, using python libraries to perform image processing tasks, and much more.

Table of Contents

What does image processing mean?

According to Gonzalez and Rafael in 2018, Image Processing or Digital Image Processing refers to processing digital images using a digital computer. Note that a digital image is composed of a finite number of elements; each element has a particular location and value. These elements are called picture elements, image elements, and pixels. Pixel is the term used most widely to denote the elements of a digital image. Since images are defined over two dimensions (perhaps more), digital image processing may be modeled in the form of multidimensional systems.

How is digital image processing better?

As a subcategory or field of digital signal processing, digital image processing has many advantages over analog image processing. It allows a much wider range of algorithms to be applied to the input data and can avoid problems such as the build-up of noise and distortion during processing.

The generation and development of digital image processing are mainly affected by three factors: First, the development of computers; second, the development of mathematics (especially the creation and improvement of discrete mathematics theory); third, the increasing demand for a wide range of applications in environment, agriculture, military, industry, medical science, etc.

Image Processing is frequently used in ‘Computer Vision’. Don’t be confused-we are going to talk about the difference between these terms and how they connect.

Image Processing vs Computer Vision

The main difference between Image Processing and Computer Vision approaches is the goals (not the methods used). For example, if the goal is to enhance an image for later use, then this may be called image processing. If the goal is to emulate human vision, like object recognition, event detection, or automatic driving, then it may be called computer vision.

Both Image Processing algorithms and Computer Vision (CV) algorithms take an image as input; however, in image processing, the output is also an image, whereas in computer vision the output can be some features/information about the image.

Read our previous article about Computer Vision here:

5 Ways To Use Computer Vision In Your Windows Apps

Why use Python for Image Processing?

Now, almost every image processing or computer vision library has a form of scripting interface in its main functions. Most of the time, this scripting language is Python (this article shows the power of Delphi to provide a nice GUI for Python scripting power).

Developers favor this particular ecosystem because of the following:

Easy to learn and easy to use, without losing the quality of programming decisions.
Python has been on the market for a long time and has been established.
Python continues to evolve dynamically.
With Python, you can use the coolest OOP solutions and you can write simple and effective code.
Python provides a huge number of libraries that solve the whole range of programming problems.

How to use Pillow, Matplotlib, scikit-learn, scikit-image, and Mahotas Python libraries to perform Image Processing tasks

All of them would be integrated with Python4Delphi to create Windows Apps with Image Processing capabilities.

Prerequisites

Before we begin to work, download and install the latest Python for your platform. Follow the Python4Delphi installation instructions mentioned here. Alternatively, you can check out the easy instructions found in the Getting Started With Python4Delphi video by Jim McKeeth.

Time to get Started!

First, open and run our Python GUI using project Demo1 from Python4Delphi with RAD Studio. Then insert the script into the lower Memo, click the Execute button, and get the result in the upper Memo. You can find the Demo1 source on GitHub. The behind the scene details of how Delphi manages to run your Python code in this amazing Python GUI can be found at this link.

python4delphi run demo01 — Open Demo01dproj

How do I perform Image Processing with Pillow Library on Windows?

Pillow or PIL is the Python Imaging Library that adds Image Processing capabilities to your Python interpreter. This library provides extensive file format support, an efficient internal representation, and fairly powerful image processing capabilities.

The core image library is designed for fast access to data stored in a few basic pixel formats. It should provide a solid foundation for a general image processing tool.

Another reason you would consider using Pillow is the fact that it is quite easy to use and very popular with Python users. Pillow is a common tool in the arsenal of most Data Scientists who work with images. Pillow provides various image processing methods that are very useful, especially in augmenting training data for computer vision problems.

This section will guide you to combine Python4Delphi with Pillow library, inside Delphi and C++Builder, from installing Pillow with pip to perform simple geometrical transformations to the image.

After installing Python4Delphi properly, you can get Pillow or PIL using pip or easy install to your command prompt:

pip install Pillow

1	pip install Pillow

Don’t forget to put the path where your Pillow installed, to the System Environment Variables:

System Environment Variable Examples

C:/Users/YOUR_USERNAME/AppData/Local/Programs/Python/Python38/Lib/site-packages
C:/Users/YOUR_USERNAME/AppData/Local/Programs/Python/Python38/Scripts
C:/Users/YOUR_USERNAME/AppData/Local/Programs/Python/Python38

C:/Users/YOUR_USERNAME/AppData/Local/Programs/Python/Python38/Lib/site-packages

C:/Users/YOUR_USERNAME/AppData/Local/Programs/Python/Python38/Scripts

C:/Users/YOUR_USERNAME/AppData/Local/Programs/Python/Python38

The following is a code example of Pillow to perform geometrical transformations with the image (run this inside the lower Memo of Python4Delphi Demo01 GUI):

from __future__ import print_function
from PIL import Image
 
im = Image.open("C:/Users/YOUR_USERNAME/cat1.jpg")
box = (0, 0, 540, 720)
region = im.crop(box)
region = region.transpose(Image.ROTATE_180)
region = region.transpose(Image.FLIP_LEFT_RIGHT)
im.paste(region, box)
im = im.rotate(45)
im.save("C:/Users/YOUR_USERNAME/cat1Rotated.jpg")

from __future__ import print_function

from PIL import Image

im = Image.open("C:/Users/YOUR_USERNAME/cat1.jpg")

box = (0, 0, 540, 720)

region = im.crop(box)

region = region.transpose(Image.ROTATE_180)

region = region.transpose(Image.FLIP_LEFT_RIGHT)

im.paste(region, box)

im = im.rotate(45)

im.save("C:/Users/YOUR_USERNAME/cat1Rotated.jpg")

Here is the result in Python GUI

Learn To Build A Python GUI For Easily Processing Images With Pillow Library In A Delphi Windows App

How do I perform Image Processing with Matplotlib Library on Windows?

Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python.

Matplotlib is one of the most popular and oldest Data Visualization libraries in Python which is commonly used in Exploratory Data Analysis and Machine Learning. In Data Science and Machine Learning, Matplotlib helps us to gain insights from a huge amount of data through different Data Visualization techniques.

In this section, you will see that Matplotlib is not only powerful for Data Visualization, but also a powerful tool for Image Processing!

First, here is how you can get Matplotlib to work with Python4Delphi to create GUI with Data Visualization and Image Processing capabilities:

pip install matplotlib

1	pip install matplotlib

The following is a code example of Matplotlib “Hello World!” for Image Processing (load image as NumPy array and show image). Run this inside the lower Memo of Python4Delphi Demo01 GUI:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.image import imread

img = imread('C:/Users/YOUR_USERNAME/stinkbug.png')

# Load image as a NumPy array
print(type(img))
print(img)

# Show image
plt.imshow(img)
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.image import imread

img = imread('C:/Users/YOUR_USERNAME/stinkbug.png')

# Load image as a NumPy array

print(type(img))

print(img)

# Show image

plt.imshow(img)

plt.show()

Here is the Matplotlib for Image Processing result in the Python GUI:

Matplotlib Demo with Python4Delphi in Windows

How do I perform Image Processing with scikit-learn Library on Windows?

scikit-learn is an open-source Python library for Machine Learning. Scikit-Learn has simple and efficient tools for predictive data analysis that are built on top of SciPy, NumPy, and Matplotlib.

As mentioned before, Image Processing allows a wide range of algorithms to be applied to the input data, and some of the algorithms belong to the Machine Learning domain. So, if you are looking for one of the ideal Image Processing libraries in Python, scikit-learn might be your choice.

This section will guide you to combine Python4Delphi with scikit-learn, inside Delphi and C++Builder, from installing scikit-learn with pip, to using it to quantize colors of a given image using Machine Learning algorithm, such as K-Means clustering!

The following code for Color Quantization using K-Means is credited to Robert Layton, Olivier Grisel, and Mathieu Blondel (visit the original source here). Run the following code inside the lower Memo of Python4Delphi Demo01 GUI:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.metrics import pairwise_distances_argmin
from sklearn.datasets import load_sample_image
from sklearn.utils import shuffle
from time import time

n_colors = 64

# Load the Summer Palace photo
china = load_sample_image("china.jpg")

# Convert to floats instead of the default 8 bits integer coding. Dividing by
# 255 is important so that plt.imshow behaves works well on float data (need to
# be in the range [0-1])
china = np.array(china, dtype=np.float64) / 255

# Load Image and transform to a 2D numpy array.
w, h, d = original_shape = tuple(china.shape)
assert d == 3
image_array = np.reshape(china, (w * h, d))

print("Fitting model on a small sub-sample of the data")
t0 = time()
image_array_sample = shuffle(image_array, random_state=0)[:1000]
kmeans = KMeans(n_clusters=n_colors, random_state=0).fit(image_array_sample)
print("done in %0.3fs." % (time() - t0))

# Get labels for all points
print("Predicting color indices on the full image (k-means)")
t0 = time()
labels = kmeans.predict(image_array)
print("done in %0.3fs." % (time() - t0))


codebook_random = shuffle(image_array, random_state=0)[:n_colors]
print("Predicting color indices on the full image (random)")
t0 = time()
labels_random = pairwise_distances_argmin(codebook_random,
                                          image_array,
                                          axis=0)
print("done in %0.3fs." % (time() - t0))


def recreate_image(codebook, labels, w, h):
    """Recreate the (compressed) image from the code book & labels"""
    d = codebook.shape[1]
    image = np.zeros((w, h, d))
    label_idx = 0
    for i in range(w):
        for j in range(h):
            image[i][j] = codebook[labels[label_idx]]
            label_idx += 1
    return image

# Display all results, alongside original image
plt.figure(1)
plt.clf()
plt.axis('off')
plt.title('Original image (96,615 colors)')
plt.imshow(china)

plt.figure(2)
plt.clf()
plt.axis('off')
plt.title('Quantized image (64 colors, K-Means)')
plt.imshow(recreate_image(kmeans.cluster_centers_, labels, w, h))

plt.figure(3)
plt.clf()
plt.axis('off')
plt.title('Quantized image (64 colors, Random)')
plt.imshow(recreate_image(codebook_random, labels_random, w, h))
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.cluster import KMeans

from sklearn.metrics import pairwise_distances_argmin

from sklearn.datasets import load_sample_image

from sklearn.utils import shuffle

from time import time

n_colors = 64

# Load the Summer Palace photo

china = load_sample_image("china.jpg")

# Convert to floats instead of the default 8 bits integer coding. Dividing by

# 255 is important so that plt.imshow behaves works well on float data (need to

# be in the range [0-1])

china = np.array(china, dtype=np.float64) / 255

# Load Image and transform to a 2D numpy array.

w, h, d = original_shape = tuple(china.shape)

assert d == 3

image_array = np.reshape(china, (w * h, d))

print("Fitting model on a small sub-sample of the data")

t0 = time()

image_array_sample = shuffle(image_array, random_state=0)[:1000]

kmeans = KMeans(n_clusters=n_colors, random_state=0).fit(image_array_sample)

print("done in %0.3fs." % (time() - t0))

# Get labels for all points

print("Predicting color indices on the full image (k-means)")

t0 = time()

labels = kmeans.predict(image_array)

print("done in %0.3fs." % (time() - t0))

codebook_random = shuffle(image_array, random_state=0)[:n_colors]

print("Predicting color indices on the full image (random)")

t0 = time()

labels_random = pairwise_distances_argmin(codebook_random,

image_array,

axis=0)

print("done in %0.3fs." % (time() - t0))

def recreate_image(codebook, labels, w, h):

"""Recreate the (compressed) image from the code book & labels"""

d = codebook.shape[1]

image = np.zeros((w, h, d))

label_idx = 0

for i in range(w):

for j in range(h):

image[i][j] = codebook[labels[label_idx]]

label_idx += 1

return image

# Display all results, alongside original image

plt.figure(1)

plt.clf()

plt.axis('off')

plt.title('Original image (96,615 colors)')

plt.imshow(china)

plt.figure(2)

plt.clf()

plt.axis('off')

plt.title('Quantized image (64 colors, K-Means)')

plt.imshow(recreate_image(kmeans.cluster_centers_, labels, w, h))

plt.figure(3)

plt.clf()

plt.axis('off')

plt.title('Quantized image (64 colors, Random)')

plt.imshow(recreate_image(codebook_random, labels_random, w, h))

plt.show()

scikit-learn Python4Delphi Results

scikit learn Demo with Python4Delphi in Windows

Using the above example, we reduce the number of colors required to show the image from 96,615 unique colors to 64, while preserving the overall appearance quality. Pretty cool, isn’t it?

How do I perform Image Processing with scikit-image Library on Windows?

scikit-image is an image processing library that implements algorithms and utilities for use in research, education, and industry applications. It is released under the liberal Modified BSD open source license, provides a well-documented API in the Python programming language, and is developed by an active, international team of collaborators.

scikit-image aims to:

To provide high quality, well-documented and easy-to-use implementations of common image processing algorithms.
To facilitate education in image processing.
To address industry challenges.

First, here is how you can get scikit-image:

pip install scikit-image

1	pip install scikit-image

Next, we will show the demo of the scikit-image library to perform skeletonization to the sample image. Skeletonization reduces binary objects to 1 pixel wide representations. This can be useful for feature extraction, and/or representing an object’s topology.

Run the following code inside the lower Memo of Python4Delphi Demo01 GUI:

from skimage.morphology import skeletonize, thin
from skimage import data
import matplotlib.pyplot as plt
from skimage.util import invert

# Invert the horse image
image = invert(data.horse())

skeleton = skeletonize(image)
thinned = thin(image)
thinned_partial = thin(image, max_iter=25)

fig, axes = plt.subplots(2, 2, figsize=(8, 8), sharex=True, sharey=True)
ax = axes.ravel()

ax[0].imshow(image, cmap=plt.cm.gray)
ax[0].set_title('original')
ax[0].axis('off')

ax[1].imshow(skeleton, cmap=plt.cm.gray)
ax[1].set_title('skeleton')
ax[1].axis('off')

ax[2].imshow(thinned, cmap=plt.cm.gray)
ax[2].set_title('thinned')
ax[2].axis('off')

ax[3].imshow(thinned_partial, cmap=plt.cm.gray)
ax[3].set_title('partially thinned')
ax[3].axis('off')

fig.tight_layout()
plt.show()

from skimage.morphology import skeletonize, thin

from skimage import data

import matplotlib.pyplot as plt

from skimage.util import invert

# Invert the horse image

image = invert(data.horse())

skeleton = skeletonize(image)

thinned = thin(image)

thinned_partial = thin(image, max_iter=25)

fig, axes = plt.subplots(2, 2, figsize=(8, 8), sharex=True, sharey=True)

ax = axes.ravel()

ax[0].imshow(image, cmap=plt.cm.gray)

ax[0].set_title('original')

ax[0].axis('off')

ax[1].imshow(skeleton, cmap=plt.cm.gray)

ax[1].set_title('skeleton')

ax[1].axis('off')

ax[2].imshow(thinned, cmap=plt.cm.gray)

ax[2].set_title('thinned')

ax[2].axis('off')

ax[3].imshow(thinned_partial, cmap=plt.cm.gray)

ax[3].set_title('partially thinned')

ax[3].axis('off')

fig.tight_layout()

plt.show()

scikit-image Skeletonize Result

scikit image Demo with Python4Delphi in Windows

Skeletonize effect works by making successive passes of the image. On each pass, border pixels are identified and removed on the condition that they do not break the connectivity of the corresponding object.

How do I perform Image Processing with Mahotas Library on Windows?

Mahotas is a fast computer vision algorithms library (all implemented in C++ for speed) that operates over NumPy arrays. Mahotas supports Python 2.7 and 3.4+.

Currently, Mahotas has over 100 functions for image processing and computer vision and it keeps growing.

Here are some notable algorithms provided by Mahotas:

Watershed
Convex points calculations.
Hit & miss, thinning.
Zernike & Haralick, LBP, and TAS features.
Speeded-Up Robust Features (SURF), a form of local features.
Thresholding.
Convolution.
Sobel edge detection.
Spline interpolation
SLIC superpixels.

Are you looking for a powerful Image Processing library and build a nice GUI for them? This section will show you how to get started!

First, here is how you can get Mahotas:

pip install mahotas

1	pip install mahotas

The following is a code example of Mahotas to use the thresholding to transform an image to black and white nicely (run this inside the lower Memo of Python4Delphi Demo01 GUI):

import mahotas as mh
import numpy as np
from pylab import imshow, gray, show, subplot
from os import path

# Load photo of mahotas' author in greyscale
originalPhoto = mh.demos.load('luispedro')
photo = mh.demos.load('luispedro', as_grey=True)

# Convert to integer values (using numpy operations)
photo = photo.astype(np.uint8)

# Compute Riddler-Calvard threshold
T_rc = mh.rc(photo)
thresholded_rc = (photo > T_rc)

# Now call pylab functions to display the image
subplot(2,1,1)
imshow(originalPhoto)
subplot(2,1,2)
imshow(thresholded_rc)
show()

import mahotas as mh

import numpy as np

from pylab import imshow, gray, show, subplot

from os import path

# Load photo of mahotas' author in greyscale

originalPhoto = mh.demos.load('luispedro')

photo = mh.demos.load('luispedro', as_grey=True)

# Convert to integer values (using numpy operations)

photo = photo.astype(np.uint8)

# Compute Riddler-Calvard threshold

T_rc = mh.rc(photo)

thresholded_rc = (photo > T_rc)

# Now call pylab functions to display the image

subplot(2,1,1)

imshow(originalPhoto)

subplot(2,1,2)

imshow(thresholded_rc)

show()

Here is the Mahotas Thresholding Result in the Python GUI:

Mahotas Demo with Python4Delphi in Windows

Conclusion

In conclusion, it is very easy to work with digital image processing tasks now, compared to, let’s say, 5-10 years ago. This is achieved through the development of various libraries and processing methods (we have tried five of them), as well as through the development of computing hardware and specialized processors.

Reduce development time and get to market faster with RAD Studio, Delphi, or C++Builder.
Design. Code. Compile. Deploy.
Start Free Trial Upgrade Today

Free Delphi Community Edition Free C++Builder Community Edition

2 Comments


Nata [25%] (@NataPolish)

June 13, 2021 at 1:47 pm

It would be great if you showed here an FMX example of text recognition in a photo using free python libraries (preferably not a tesseract).
- Reply
  
  Ian Barker
  
  June 13, 2021 at 5:59 pm
  
  That’s a great suggestion. have you looked at the following post? It describes how to use the EasyOCR package to do text recognition. It might help point you in the right direction. See here: https://blogs.embarcadero.com/5-ways-to-use-computer-vision-in-your-windows-apps/

5 EASY Ways To Integrate Image Processing In Your Apps

What does image processing mean?

How is digital image processing better?

Image Processing vs Computer Vision

Why use Python for Image Processing?

How to use Pillow, Matplotlib, scikit-learn, scikit-image, and Mahotas Python libraries to perform Image Processing tasks

Prerequisites

Time to get Started!

How do I perform Image Processing with Pillow Library on Windows?

System Environment Variable Examples

Here is the result in Python GUI

How do I perform Image Processing with Matplotlib Library on Windows?

Here is the Matplotlib for Image Processing result in the Python GUI:

How do I perform Image Processing with scikit-learn Library on Windows?

scikit-learn Python4Delphi Results

How do I perform Image Processing with scikit-image Library on Windows?

scikit-image Skeletonize Result

How do I perform Image Processing with Mahotas Library on Windows?

Here is the Mahotas Thresholding Result in the Python GUI:

Conclusion

2 Comments

Leave a ReplyCancel reply

Search

Something Fresh

How Does Reliable Delphi Keep This Wonderland Running 365 Days A Year?

How To Use WebStencils To EASILY Create Modern, Professional, Superfast Websites

Meet The Developer: FontCreator - Erwin Denissen

Popular Posts

RAD Studio 12.2 Athens Inline Patch 1 Available

Announcing the Availability of RAD Studio 12.2 Athens

Delphi 12 And C++Builder 12 Community Editions Released!

InterBase ODBC Driver on GitHub

Embarcadero Partners with Raize Software for KSVC Maintenance

Categories

Unknown Feed

Unknown Feed

Categories

Useful Links

Follow us

5 EASY Ways To Integrate Image Processing In Your Apps

What does image processing mean?

How is digital image processing better?

Image Processing vs Computer Vision

Why use Python for Image Processing?

How to use Pillow, Matplotlib, scikit-learn, scikit-image, and Mahotas Python libraries to perform Image Processing tasks

Prerequisites

Time to get Started!

How do I perform Image Processing with Pillow Library on Windows?

System Environment Variable Examples

Here is the result in Python GUI

How do I perform Image Processing with Matplotlib Library on Windows?

Here is the Matplotlib for Image Processing result in the Python GUI:

How do I perform Image Processing with scikit-learn Library on Windows?

scikit-learn Python4Delphi Results

How do I perform Image Processing with scikit-image Library on Windows?

scikit-image Skeletonize Result

How do I perform Image Processing with Mahotas Library on Windows?

Here is the Mahotas Thresholding Result in the Python GUI:

Conclusion

2 Comments

Leave a ReplyCancel reply

Join Our Global Developer Community

Search

Something Fresh

Popular Posts

Categories

Categories

Useful Links

Follow us