📘 B.

Tech 6th Semester — Exam Preparation

Author: Rishav Raj | Semester: 6th Sem | Subject: Image Processing — Introduction | Marks per
Answer: 5–10 Marks

📌 How to Use This Document

• Each answer is structured for 5–10 marks university exam questions.
• Every answer covers 1-2 pages of content with proper depth.
• Format includes: Definition → Explanation → Key Points → Diagram/Example →
Conclusion

❓ Question 1: Develop a procedure for computing the median

of an n × n neighbourhood. Propose a technique for updating
the median as the centre of the neighbourhood is moved from
pixel to pixel.
✅ Answer:
📖 Definition / Introduction
The median filter is a non-linear spatial filtering technique used in image processing to reduce
noise (especially salt-and-pepper noise) while preserving edges. Unlike the mean filter, the median
filter replaces each pixel's value with the median of its n × n neighbourhood. Computing and
efficiently updating this median as the filter window slides across the image is a key algorithmic
challenge.

📝 Detailed Explanation
Key Point 1: Procedure for Computing the Median of an n × n Neighbourhood
Step 1: Define the neighbourhood window of size n × n centred at pixel (x, y).

Step 2: Extract all n² pixel intensity values from the neighbourhood.

Step 3: Sort these n² values in ascending (or descending) order.

Step 4: Select the middle value from the sorted list. For n² values (which is always odd
when n is odd), the median is the value at position (n² + 1)/2.

Step 5: Replace the centre pixel (x, y) with this median value.

1 IP_1
 Example: For a 3 × 3 neighbourhood with values {15, 20, 22, 18, 200, 19, 21, 17, 23},
sorted = {15, 17, 18, 19, 20, 21, 22, 23, 200}, median = 20 (5th value).

Key Point 2: Technique for Updating the Median (Sliding Window / Huang's Algorithm)
When the centre of the neighbourhood moves from pixel (x, y) to (x, y+1) (one column
to the right), the n × n window shifts by one column. This means:

• One column of n pixels is removed (the leftmost column of the old window).

• One column of n pixels is added (the rightmost column of the new window).

Instead of re-sorting all n² pixels, we use a histogram-based approach:

Step 1: Maintain a running histogram H of pixel intensities in the current n × n window,

along with a count of pixels less than or equal to the current median (called ltmdn).

Step 2: When the window moves right by one pixel:

• Subtract the n pixels of the outgoing (leftmost) column from H. For each
removed pixel value v, if v ≤ current median, decrement ltmdn.

• Add the n pixels of the incoming (rightmost) column to H. For each added pixel
value v, if v ≤ current median, increment ltmdn.

Step 3: The median position is at th = (n² + 1)/2.

• If ltmdn ≥ th, the new median may have shifted lower — scan H downward
from the current median until ltmdn < th.

• If ltmdn < th, the new median may have shifted higher — scan H upward until
ltmdn ≥ th.

This reduces the complexity from O(n² log n²) per pixel (full sort) to approximately
O(n) per pixel (only updating 2n values and scanning the histogram).

Key Point 3: Advantages of the Update Technique

• Efficiency: Only 2n pixels change per move, not all n².

• Speed: The histogram update is O(n), and the median search is O(number of
grey levels), making it much faster than re-sorting.

• Scalability: Particularly beneficial for larger window sizes.

📊 Diagram / Table (if applicable)

Moving Window (3×3 example, moving right):

Old Window (at x,y) New Window (at x, y+1)

┌─────┬─────┬─────┐ ┌─────┬─────┬─────┐
2 IP_2
 │ a1 │ a2 │ a3 │ │ a2 │ a3 │ b1 │
├─────┼─────┼─────┤ → ├─────┼─────┼─────┤
│ a4 │ a5 │ a6 │ │ a5 │ a6 │ b2 │
├─────┼─────┼─────┤ ├─────┼─────┼─────┤
│ a7 │ a8 │ a9 │ │ a8 │ a9 │ b3 │
└─────┴─────┴─────┘ └─────┴─────┴─────┘

Removed: a1, a4, a7 (left column)

Added: b1, b2, b3 (right column)

Histogram Update:
H[a1]--, H[a4]--, H[a7]-- (decrement removed)
H[b1]++, H[b2]++, H[b3]++ (increment added)
Then adjust median pointer in histogram.

💡 Example
Consider a 3 × 3 window scanning a row of a 256-grey-level image. At position (5, 5),
the sorted neighbourhood is {10, 12, 14, 15, 18, 20, 22, 25, 30}, median = 18. Moving
to (5, 6), pixels {10, 15, 25} are removed and {11, 19, 28} are added. Histogram is
updated by decrementing bins 10, 15, 25 and incrementing bins 11, 19, 28. The count
ltmdn is adjusted, and the histogram is scanned to find the new median = 19.

🔚 Conclusion
The median filter is a powerful tool for noise removal in images, especially salt-and-
pepper noise. The naive approach of sorting all n² pixels for every pixel position is
computationally expensive. By using a histogram-based sliding window technique
(Huang's algorithm), we can efficiently update the median with only O(n) operations per
pixel move, making real-time median filtering practical even for large neighbourhood
sizes.

❓ Question 2: What is a pixel? Explain 4-neighbour and 8-

neighbour of a pixel. Explain m-adjacency.
✅ Answer:
📖 Definition / Introduction
A pixel (short for "picture element") is the smallest addressable element in a digital image. It
represents a single point in a raster image and holds a numerical value corresponding to the
intensity or colour at that spatial location. Pixels are arranged in a 2D grid (rows and columns), and
their spatial relationships — defined through neighbourhoods and adjacency — are fundamental to
image processing operations like segmentation, edge detection, and region analysis.

3 IP_3
📝 Detailed Explanation
Key Point 1: Pixel
A pixel at coordinates (x, y) in a digital image f has an intensity value f(x, y). For a
greyscale image, this value typically ranges from 0 (black) to 255 (white) for an 8-bit
image. For a colour image, each pixel stores multiple values (e.g., R, G, B channels).
The pixel is the fundamental building block of any digital image and determines its
spatial resolution.

Key Point 2: 4-Neighbour (N₄) of a Pixel

The 4-neighbours of a pixel p at (x, y) are the four pixels that share a horizontal or
vertical edge with p. They are located at:

• (x+1, y), (x−1, y), (x, y+1), (x, y−1)

These are also called the direct neighbours or Von Neumann neighbourhood. The set
of these four pixels is denoted as N₄(p). Note: Some of these neighbours may lie outside
the image boundary for edge/corner pixels.

Key Point 3: 8-Neighbour (N₈) of a Pixel

The 8-neighbours of a pixel p at (x, y) include all pixels surrounding p — the 4 direct
neighbours plus the 4 diagonal neighbours. They are:

• (x+1, y), (x−1, y), (x, y+1), (x, y−1) — direct neighbours

• (x+1, y+1), (x+1, y−1), (x−1, y+1), (x−1, y−1) — diagonal neighbours (Nᴅ)

This is also called the Moore neighbourhood. N₈(p) = N₄(p) ∪ Nᴅ(p).

Key Point 4: m-Adjacency (Mixed Adjacency)

m-adjacency (mixed adjacency) is introduced to eliminate the ambiguity that arises
with 8-adjacency. Two pixels p and q with values from a set V are m-adjacent if:

(i) q is in N₄(p) (they are 4-adjacent), OR

(ii) q is in Nᴅ(p) (they are diagonally adjacent) AND the set N₄(p) ∩ N₄(q) has no
pixels with values from V.

This means: diagonal adjacency is allowed only when there is no 4-connected path
between the two pixels through V-valued pixels. This prevents the formation of
ambiguous multiple paths between pixels.

📊 Diagram / Table (if applicable)

4-Neighbours of p(x,y): 8-Neighbours of p(x,y):

(x-1,y) (x-1,y-1) (x-1,y) (x-1,y+1)

| \ | /
(x,y-1)—p(x,y)—(x,y+1) (x,y-1) — p(x,y) — (x,y+1)
4 IP_4
 | / | \
(x+1,y) (x+1,y-1) (x+1,y) (x+1,y+1)

m-Adjacency Example:
┌───┬───┬───┐ V = {1}
│ 0 │ 1 │ 0 │
├───┼───┼───┤ p = (1,0), q = (0,1), r = (1,1)
│ 1 │ 1 │ 0 │
├───┼───┼───┤ 8-adjacency: p-q, p-r, q-r (ambiguous path)
│ 0 │ 0 │ 0 │ m-adjacency: p-r, q-r only (no p-q diagonal
└───┴───┴───┘ since N₄(p)∩N₄(q) contains r which ∈ V)

💡 Example
Consider a binary image region where pixels with value 1 are of interest (V = {1}). If
three pixels p(1,0)=1, q(0,1)=1, r(1,1)=1 are present, using 8-adjacency all three are
mutually adjacent, creating an ambiguous triangular path. Using m-adjacency, p and q
are NOT m-adjacent because their common 4-neighbour r has a value in V. This
eliminates the ambiguity and produces a clean single-pixel-wide path: p→r→q.

🔚 Conclusion
A pixel is the fundamental unit of a digital image. The 4-neighbourhood and 8-
neighbourhood define the spatial relationship between pixels, which is essential for
operations like connectivity analysis and region growing. m-adjacency resolves the
ambiguity problem of 8-adjacency by restricting diagonal connections, ensuring unique
paths between pixels and making algorithms more deterministic and reliable.

❓ Question 3: Explain image sensing and acquisition using

Single Sensor, Sensor Strip, Sensor Array. What are image
sensors and how are they used? Discuss one technique of
image acquisition.
✅ Answer:
📖 Definition / Introduction
Image sensing and acquisition is the process of converting a physical scene (continuous visual
information) into a digital image that can be processed by a computer. This involves two main
elements: a physical device (sensor) that is sensitive to electromagnetic energy (such as light), and
a digitizer that converts the sensor output into a digital form. The type and arrangement of sensors
determine the method and quality of image acquisition.

5 IP_5
📝 Detailed Explanation
Key Point 1: What are Image Sensors?
An image sensor is a device that detects and converts incoming electromagnetic energy
(visible light, X-rays, infrared, etc.) into an electrical signal. The most common image
sensors are:

• CCD (Charge-Coupled Device): Converts photons to electric charge, which is

then read out sequentially.

• CMOS (Complementary Metal-Oxide-Semiconductor): Each pixel has its

own charge-to-voltage conversion circuit, allowing faster readout.

• Photodiodes: Simple semiconductor devices that produce a voltage proportional

to light intensity.

Key Point 2: Single Sensor Acquisition

A single sensor (e.g., a single photodiode) captures one pixel's worth of information at
a time. To generate a 2D image, the sensor or the object must be mechanically moved in
both X and Y directions. This is the slowest method but is used in applications where
very high precision is needed.

Example: A flatbed scanner uses a single sensor (or a small sensor array acting as one)
that is moved across the document line by line.

Key Point 3: Sensor Strip Acquisition

A sensor strip is a linear array of sensors arranged in a row. It captures an entire line of
the image at once. To form a 2D image, the strip moves perpendicular to its length (or
the object moves past the strip), capturing the image one row at a time. This is faster
than a single sensor.

Example: A flat-bed scanner typically uses a 1D CCD sensor strip that sweeps across
the page. Satellite imaging systems like pushbroom scanners use linear sensor arrays —
the satellite's orbital motion provides the second dimension.

Key Point 4: Sensor Array Acquisition

A sensor array is a 2D grid of sensors (rows × columns) that captures the entire image
in a single exposure. This is the fastest method and is used in most modern cameras and
imaging devices.

Example: A digital camera uses a 2D CCD or CMOS sensor array (e.g., 4000 × 3000
pixels) to capture the full image at once. Each sensor element in the array corresponds
to one pixel of the output image.

Key Point 5: Image Acquisition Technique — Using a Sensor Array (Digital Camera)
The most common technique involves a 2D sensor array coupled with an illumination
source and optics:

1. Illumination: The scene is illuminated by a light source (natural or artificial).

6 IP_6
 2. Optics/Lens: A lens focuses the reflected light onto the sensor array.

3. Sensing: Each sensor element converts the photon energy into an electrical
voltage proportional to light intensity.

4. Sampling: The continuous image is sampled at discrete spatial locations

(determined by the sensor grid).

5. Quantization: The continuous voltage at each sensor is converted to a discrete

integer value (e.g., 0–255 for 8-bit).

6. Output: The result is a digital image f(x, y) stored as a 2D matrix of pixel

values.

📊 Diagram / Table (if applicable)

(a) Single Sensor: (b) Sensor Strip:
┌─────┐ ┌─┬─┬─┬─┬─┬─┬─┬─┐
│ S │ ← moves in X & Y │S│S│S│S│S│S│S│S│ ← moves in Y only
└─────┘ └─┴─┴─┴─┴─┴─┴─┴─┘
↕ ↔ (mechanical motion) ↕ (motion in one direction)

(c) Sensor Array:

┌─┬─┬─┬─┬─┬─┬─┬─┐
│S│S│S│S│S│S│S│S│
├─┼─┼─┼─┼─┼─┼─┼─┤
│S│S│S│S│S│S│S│S│ ← No motion required
├─┼─┼─┼─┼─┼─┼─┼─┤ (captures full 2D image at once)
│S│S│S│S│S│S│S│S│
├─┼─┼─┼─┼─┼─┼─┼─┤
│S│S│S│S│S│S│S│S│
└─┴─┴─┴─┴─┴─┴─┴─┘

Image Acquisition Pipeline:

Scene → [Illumination] → [Lens/Optics] → [Sensor Array] → [Digitizer] →
Digital Image
(Sampling) (Quantization)

💡 Example
A digital camera is a practical example of sensor array-based acquisition. The CMOS
sensor array (e.g., 12 megapixels = 4000 × 3000) captures the entire scene in one shot.
Light passes through the lens, hits the Bayer filter (colour filter array with R, G, B
patterns), and each sensor converts photons to voltage. The ADC (Analog-to-Digital
Converter) quantizes these voltages into 8-bit or higher values, producing the final
digital image.

🔚 Conclusion
Image sensing and acquisition is the first and most critical step in digital image
processing. Single sensors offer precision but are slow; sensor strips provide line-by-
7 IP_7
 line capture at moderate speeds; and sensor arrays capture the entire image instantly,
making them the standard in modern cameras. The choice of sensor arrangement
depends on the application's requirements for speed, resolution, and cost. Modern image
acquisition relies primarily on CCD and CMOS sensor arrays with integrated
digitization.

❓ Question 4: Explain Bilinear Interpolation Method.

✅ Answer:
📖 Definition / Introduction
Bilinear interpolation is a technique used in digital image processing to estimate the intensity
value at a non-integer (sub-pixel) coordinate by using the weighted average of the four nearest pixel
values. It is commonly used in image resizing (scaling), rotation, geometric transformation, and
image registration. It produces smoother results than nearest-neighbour interpolation and is
computationally less expensive than bicubic interpolation.

📝 Detailed Explanation
Key Point 1: Why Interpolation is Needed
When an image undergoes geometric transformations (scaling, rotation, translation), the
transformed pixel coordinates often fall at non-integer positions in the original image.
Since pixel values exist only at integer coordinates, we need to estimate (interpolate) the
value at the fractional location. Bilinear interpolation uses the four closest known pixels
to compute this estimate.

Key Point 2: Mathematical Formulation

Given a point (x, y) where x and y are non-integer, the four nearest neighbours are:

• f(x₁, y₁), f(x₁, y₂), f(x₂, y₁), f(x₂, y₂)

where x₁ = floor(x), x₂ = x₁ + 1, y₁ = floor(y), y₂ = y₁ + 1.

Let a = x − x₁ and b = y − y₁ (fractional parts, 0 ≤ a, b < 1).

Step 1 — Interpolate in X-direction (two linear interpolations):

• R₁ = (1−a) × f(x₁, y₁) + a × f(x₂, y₁)

• R₂ = (1−a) × f(x₁, y₂) + a × f(x₂, y₂)

Step 2 — Interpolate in Y-direction (one linear interpolation):

• f(x, y) = (1−b) × R₁ + b × R₂
8 IP_8
 Combined Formula:

• f(x, y) = (1−a)(1−b) f(x₁,y₁) + a(1−b) f(x₂,y₁) + (1−a)b f(x₁,y₂) + ab f(x₂,y₂)

Key Point 3: Properties of Bilinear Interpolation

• It performs linear interpolation in two directions (hence "bilinear").

• It is smoother than nearest-neighbour interpolation (avoids blocky artefacts).

• It may cause slight blurring of edges compared to bicubic interpolation.

• It uses exactly 4 neighbouring pixels for each computation.

• Computational complexity is moderate — more than nearest-neighbour, less

than bicubic.

📊 Diagram / Table (if applicable)

Four nearest pixels around point P(x, y):

y₁ y₂
x₁ ●───────────●
│ f(x₁,y₁) │ f(x₁,y₂)
│ │
│ P(x,y) │ b = y - y₁
│ × │ a = x - x₁
│ │
x₂ ●───────────●
f(x₂,y₁) f(x₂,y₂)

Step 1: Linear interpolation along x (rows):

R₁ = lerp(f(x₁,y₁), f(x₂,y₁), a) ← at y = y₁
R₂ = lerp(f(x₁,y₂), f(x₂,y₂), a) ← at y = y₂

Step 2: Linear interpolation along y (columns):

P = lerp(R₁, R₂, b)

Comparison Table:
┌─────────────────────┬──────────┬──────────┬──────────┐
│ Method │ Pixels │ Quality │ Speed │
│ │ Used │ │ │
├─────────────────────┼──────────┼──────────┼──────────┤
│ Nearest-Neighbour │ 1 │ Low │ Fastest │
│ Bilinear │ 4 │ Medium │ Moderate │
│ Bicubic │ 16 │ High │ Slowest │
└─────────────────────┴──────────┴──────────┴──────────┘

💡 Example
Suppose we want to find the intensity at point P(2.3, 4.7). The four nearest pixels are:

• f(2, 4) = 100, f(3, 4) = 120, f(2, 5) = 140, f(3, 5) = 160

9 IP_9
 • a = 0.3, b = 0.7

• R₁ = (0.7)(100) + (0.3)(120) = 70 + 36 = 106

• R₂ = (0.7)(140) + (0.3)(160) = 98 + 48 = 146

• f(2.3, 4.7) = (0.3)(106) + (0.7)(146) = 31.8 + 102.2 = 134

🔚 Conclusion
Bilinear interpolation is a widely used technique in image processing for estimating
pixel values at non-integer coordinates. By performing two successive linear
interpolations (first along one axis, then along the other), it produces smooth and
visually pleasing results. It strikes a good balance between the blockiness of nearest-
neighbour and the computational cost of bicubic interpolation, making it the default
choice for many real-time image transformation applications.

❓ Question 5: What is the resolution of an image? Compute the

size of a 640 × 480 image at 240 pixels per inch. What do you
mean by digitization? Explain its two important steps.
✅ Answer:
📖 Definition / Introduction
Resolution of a digital image refers to the level of spatial detail that the image can represent. It is
typically described in terms of the number of pixels (spatial resolution) and the number of intensity
levels (grey-level/intensity resolution). Resolution determines how much detail an image can
convey and is a critical factor in image quality. Digitization is the process of converting a
continuous (analog) image into a digital form.

📝 Detailed Explanation
Key Point 1: Image Resolution
Resolution can be described in multiple ways:

• Spatial Resolution: The number of pixels per unit length (e.g., pixels per inch
— PPI or dots per inch — DPI). Higher spatial resolution means more detail.

• Pixel Resolution: Total pixel count, expressed as Width × Height (e.g., 640 ×
480 = 307,200 pixels).

• Intensity/Grey-level Resolution: The number of distinct intensity levels (e.g.,

8-bit = 256 levels, 16-bit = 65,536 levels).
10 IP_10
 A higher resolution image captures finer details but requires more storage.

Key Point 2: Size Computation — 640 × 480 image at 240 PPI

Given:

• Image dimensions: 640 × 480 pixels

• Resolution: 240 pixels per inch (PPI)

Physical Size:

• Width = 640 / 240 = 2.67 inches

• Height = 480 / 240 = 2.0 inches

Physical size of the image = 2.67 inches × 2.0 inches

Storage Size (assuming 8-bit greyscale):

• Total pixels = 640 × 480 = 307,200 pixels

• Storage = 307,200 × 8 bits = 2,457,600 bits = 300 KB (approximately)

For a 24-bit colour image: 307,200 × 24 = 7,372,800 bits = 900 KB (approximately)

Key Point 3: Digitization and Its Two Important Steps

Digitization is the process of converting a continuous analog image into a discrete
digital image. It involves two fundamental steps:

Step 1: Sampling (Spatial Digitization)

• Sampling is the discretization of the spatial coordinates (x, y).

• The continuous image is divided into a finite grid of M × N sample points

(pixels).

• Each sample corresponds to a specific location in the image.

• The sampling rate determines the spatial resolution — higher sampling rate
gives more pixels and finer detail.

• According to the Nyquist theorem, the sampling rate must be at least twice the
highest spatial frequency in the image to avoid aliasing.

Step 2: Quantization (Intensity Digitization)

• Quantization is the discretization of the intensity values (amplitude).

• The continuous range of intensity values at each pixel is mapped to a finite set of
L discrete levels (e.g., 256 levels for 8-bit quantization).
11 IP_11
 • The number of quantization levels L = 2^k, where k is the number of bits per
pixel.

• Finer quantization (more levels) reduces quantization error and produces

smoother intensity gradations.

• Coarser quantization can produce visible false contouring artefacts.

📊 Diagram / Table (if applicable)

Digitization Process:

Continuous Image f(x,y) ──→ [SAMPLING] ──→ [QUANTIZATION] ──→ Digital Image

Sampling (Spatial): Quantization (Intensity):

┌──────────────────┐ Continuous Quantized
│ Continuous │ intensity (L levels)
│ image │ ▲ ▲
│ ╱╲╱╲╱╲╱╲╱╲ │ │ ╱╲ │ ┌─┐
│ │ │╱ ╲ │ │ │┌─┐
│ ↓ Sample at │ ╱ ╲ │ │ ││ │
│ M × N points │ ╱ ╲─ │─┘ │└─│
│ │ └────────→
│ ● ● ● ● ● ● │
│ ● ● ● ● ● ● │ k = 8 bits → L = 256 levels
│ ● ● ● ● ● ● │ k = 1 bit → L = 2 levels (binary)
└──────────────────┘

Size Calculation:
┌───────────────────────────────────────┐
│ Width = 640 pixels ÷ 240 PPI = 2.67"│
│ Height = 480 pixels ÷ 240 PPI = 2.00"│
│ Storage = 640 × 480 × 8 bits ≈ 300 KB│
└───────────────────────────────────────┘

💡 Example
A photograph taken by a digital camera with a 12-megapixel sensor produces an image
of 4000 × 3000 pixels (sampling) with each pixel stored as a 24-bit colour value (8 bits
× 3 channels — quantization). The resulting uncompressed image size is 4000 × 3000 ×
3 bytes ≈ 36 MB. When printed at 300 DPI, it produces a 13.3" × 10" print.

🔚 Conclusion
Image resolution defines the detail and quality of a digital image and is characterized by
spatial and intensity resolution. Digitization converts continuous images to digital form
through two essential steps: sampling (discretizing spatial coordinates) and
quantization (discretizing intensity values). The balance between sampling rate,
quantization levels, and storage requirements is a fundamental trade-off in digital
imaging systems.

12 IP_12
❓ Question 6: Write down the key stages in Digital Image
Processing (DIP) and explain them. Explain different types of
DIP processes.
✅ Answer:
📖 Definition / Introduction
Digital Image Processing (DIP) refers to the use of computer algorithms to perform operations on
digital images. The goal is to improve image quality, extract useful information, or transform
images for specific applications. DIP involves a systematic pipeline of stages, each performing a
specific function. Additionally, DIP processes can be categorized based on the level of abstraction
— from low-level pixel operations to high-level semantic understanding.

📝 Detailed Explanation
Key Point 1: Key Stages in Digital Image Processing
Stage 1 — Image Acquisition: The first stage involves capturing the image using
sensors (camera, scanner, satellite) and converting it to digital form. This includes
sensing and digitization (sampling + quantization).

Stage 2 — Image Enhancement: Improves the visual appearance of an image or

converts it to a form better suited for analysis. Techniques include contrast stretching,
histogram equalization, sharpening, and noise filtering.

Stage 3 — Image Restoration: Aims to recover an image that has been degraded by a
known or estimated degradation function. Unlike enhancement (subjective), restoration
is objective and model-based. Examples: Wiener filter, inverse filtering.

Stage 4 — Colour Image Processing: Deals with processing of colour images using
colour models (RGB, HSI, CMYK). Includes colour transformations, colour-based
segmentation, and pseudo-colouring.

Stage 5 — Wavelets and Multi-Resolution Processing: Uses multi-resolution

techniques like wavelet transforms to represent images at different scales. Foundation
for image compression (JPEG 2000) and feature extraction.

Stage 6 — Compression: Reduces the amount of data required to represent an image.

Includes lossless (Huffman, LZW, Run-Length Encoding) and lossy (JPEG, JPEG
2000) techniques.

Stage 7 — Morphological Processing: Uses shape-based operations (erosion, dilation,

opening, closing) on binary/greyscale images for boundary extraction, hole filling, and
connected component analysis.

Stage 8 — Image Segmentation: Partitions an image into meaningful regions or

objects. Techniques include thresholding, edge detection, region growing, and
13 IP_13
 watershed algorithm. This is one of the most challenging stages.

Stage 9 — Representation and Description: After segmentation, regions are

represented (boundary, skeleton) and described using features (shape descriptors,
texture, colour histograms) for recognition.

Stage 10 — Object Recognition: Assigns a label or meaning to an object based on its

description. Uses pattern matching, machine learning, and deep learning. This is the
highest level of DIP.

Key Point 2: Types of DIP Processes

(a) Low-Level Processing:

• Input: Image → Output: Image

• Involves primitive operations like noise reduction, contrast enhancement,

sharpening.

• Examples: Filtering, histogram equalization, edge detection.

(b) Mid-Level Processing:

• Input: Image → Output: Attributes/Features

• Involves segmentation, classification, and feature extraction.

• Examples: Object detection, region labelling, feature descriptors.

(c) High-Level Processing:

• Input: Attributes → Output: Understanding/Interpretation

• Involves making sense of recognized objects, scene understanding.

• Examples: Autonomous navigation, medical diagnosis, facial recognition.

📊 Diagram / Table (if applicable)

Key Stages in DIP (Pipeline):

┌──────────────┐ ┌──────────────┐ ┌──────────────┐

│ Image │───→│ Image │───→│ Image │
│ Acquisition │ │ Enhancement │ │ Restoration │
└──────────────┘ └──────────────┘ └──────────────┘
│ │
↓ ↓
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Colour │───→│ Wavelets & │───→│ Compression │
│ Processing │ │ Multi-Res. │ │ │
└──────────────┘ └──────────────┘ └──────────────┘
│
┌───────────────────────────────────────┘
14 IP_14
 ↓
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Morphological│───→│ Image │───→│Representation│
│ Processing │ │ Segmentation │ │& Description │
└──────────────┘ └──────────────┘ └──────────────┘
│
↓
┌──────────────┐
│ Object │
│ Recognition │
└──────────────┘

Types of DIP Processes:

┌─────────────────┬───────────────┬────────────────────────┐
│ Level │ Input→Output │ Example │
├─────────────────┼───────────────┼────────────────────────┤
│ Low-Level │ Image→Image │ Filtering, Enhancement │
│ Mid-Level │ Image→Attrib. │ Segmentation, Features │
│ High-Level │ Attrib.→Under.│ Recognition, Analysis │
└─────────────────┴───────────────┴────────────────────────┘

💡 Example
In a medical X-ray analysis system: Image acquisition captures the X-ray (Stage 1).
Enhancement improves contrast (Stage 2). Restoration removes blur from patient
motion (Stage 3). Segmentation identifies regions of interest like tumours (Stage 8).
Feature extraction measures tumour size and shape (Stage 9). Finally, recognition
classifies the tumour as benign or malignant (Stage 10).

🔚 Conclusion
Digital Image Processing follows a well-defined pipeline of stages, from acquisition to
recognition. Each stage builds on the output of the previous one, progressively moving
from raw pixel data to high-level understanding. DIP processes can be classified into
low-level (image-to-image), mid-level (image-to-features), and high-level (features-to-
understanding) processing, each serving a distinct purpose in the image analysis
pipeline.

❓ Question 7: What is an 8-bit colour image? Explain. What is

meant by classification of image?
✅ Answer:
📖 Definition / Introduction
An 8-bit colour image is a digital image where each pixel's colour is represented using 8 bits (1
byte) of data, allowing for a maximum of 2⁸ = 256 distinct colours. This is in contrast to full-colour
images (24-bit or higher) that can represent millions of colours. Classification of images refers to
15 IP_15
the categorization of digital images based on their data representation, colour depth, and
dimensionality.

📝 Detailed Explanation
Key Point 1: 8-Bit Colour Image
In an 8-bit colour image, each pixel stores a single 8-bit value (0–255) that serves as an
index into a colour lookup table (CLUT) or palette. The palette contains up to 256
entries, where each entry specifies the actual colour (usually as 24-bit RGB values — 8
bits each for Red, Green, Blue).

• The pixel value does NOT directly represent colour; it is a pointer to the palette.

• The palette is chosen to best represent the colours in the image (using algorithms
like median-cut or octree quantization).

• This format is also known as an indexed colour image or palette-based image.

Note: An 8-bit greyscale image also uses 8 bits per pixel, but each value directly
represents intensity (0 = black, 255 = white) with no palette.

Key Point 2: Advantages and Limitations

Advantages:

• Requires significantly less memory (8 bits vs. 24 bits per pixel — 3× less).

• Faster processing and transmission.

• Suitable for images with limited colour range (logos, icons, simple graphics).

Limitations:

• Only 256 colours can be displayed simultaneously.

• Not suitable for photographs or complex natural scenes.

• Colour banding artefacts may appear in smooth gradients.

Key Point 3: Classification of Images

Digital images can be classified based on various criteria:

(a) Based on Colour Depth / Type:

• Binary Image (1-bit): Each pixel is either 0 (black) or 1 (white). Used for
documents, text recognition.

• Greyscale Image (8-bit): Each pixel has 256 intensity levels (0–255). Used for
medical imaging, document analysis.
16 IP_16
 • Colour Image (24-bit / True Colour): Each pixel has 3 channels (R, G, B), 8
bits each = 16.7 million colours. Used for photography, display.

• 8-bit Colour (Indexed): 256 colours from a palette (as described above).

• High Dynamic Range (HDR): Uses 16-bit or 32-bit per channel for extended
dynamic range.

(b) Based on Dimensionality:

• 2D Images: Standard photographs, X-rays (single 2D plane).

• 3D Images: Volumetric data like CT/MRI scans (stack of 2D slices).

• Video/Sequence: Temporal sequence of 2D images.

(c) Based on Source/Application:

• Visible light images, infrared images, X-ray images, ultrasound images, satellite
images, etc.

📊 Diagram / Table (if applicable)

8-bit Colour Image Structure:

Image (M × N pixels) Colour Palette (CLUT)

┌────┬────┬────┬────┐ ┌───────┬─────────────────┐
│ 05 │ 12 │ 200│ 45 │ │ Index │ R G B │
├────┼────┼────┼────┤ ├───────┼─────────────────┤
│ 78 │ 03 │ 156│ 99 │ → │ 00 │ 0 0 0 │
├────┼────┼────┼────┤ lookup │ 01 │ 128 0 0 │
│ 45 │ 200│ 12 │ 03 │ │ ... │ ... ... ... │
├────┼────┼────┼────┤ │ 05 │ 255 128 64 │
│ 12 │ 99 │ 78 │ 05 │ │ ... │ ... ... ... │
└────┴────┴────┴────┘ │ 255 │ 255 255 255 │
(Each value = palette index) └───────┴─────────────────┘

Image Classification:
┌──────────────────┬────────────┬───────────────────┐
│ Type │ Bits/Pixel │ Distinct Values │
├──────────────────┼────────────┼───────────────────┤
│ Binary │ 1 │ 2 │
│ Greyscale │ 8 │ 256 │
│ 8-bit Colour │ 8 (indexed)│ 256 (from palette)│
│ True Colour │ 24 │ 16,777,216 │
│ HDR │ 32–96 │ Billions+ │
└──────────────────┴────────────┴───────────────────┘

💡 Example
The GIF image format uses 8-bit indexed colour. When a 24-bit photograph is
converted to GIF, the software selects the 256 most representative colours and creates a
palette. Each pixel is then mapped to the closest palette colour. This explains why GIF
17 IP_17
 images often look "banded" or less smooth compared to JPEG images that use full 24-
bit colour.

🔚 Conclusion
An 8-bit colour image uses indexed colour representation where each pixel's 8-bit value
indexes into a palette of 256 colours. While memory-efficient, it is limited in colour
range compared to true-colour images. Image classification helps us categorize images
based on colour depth (binary, greyscale, indexed, true colour), dimensionality (2D,
3D), and application domain, enabling appropriate processing techniques to be applied.

❓ Question 8: What is aliasing in the context of image

sampling? What do you mean by image file format? Mention
some commonly used image file formats.
✅ Answer:
📖 Definition / Introduction
Aliasing is a distortion or artefact that occurs when a continuous image is sampled at a rate
insufficient to capture its detail (i.e., below the Nyquist rate). It manifests as false patterns, jagged
edges ("jaggies"), or moiré effects in the digital image. An image file format defines the structure
and encoding method used to store a digital image on disk, including how pixel data, metadata, and
compression are organized.

📝 Detailed Explanation
Key Point 1: Aliasing in Image Sampling
When a continuous image is digitized through sampling, the sampling rate must be high
enough to capture all spatial frequencies present in the image. According to the
Nyquist-Shannon Sampling Theorem, the sampling frequency must be at least twice
the highest frequency component in the image.

If sampling rate < 2 × f_max (highest frequency):

• High-frequency components (fine details, sharp edges) are incorrectly

represented as lower frequencies.

• This phenomenon is called aliasing — the high frequencies "masquerade" as

low frequencies.

Common aliasing artefacts include:

• Jagged edges (Jaggies): Staircase-like appearance of diagonal/curved lines.

18 IP_18
 • Moiré patterns: False repetitive patterns appear when sampling fine regular
patterns (e.g., a brick wall, fabric weave).

• Loss of fine detail: Small features disappear or merge.

Key Point 2: Anti-Aliasing Techniques

• Increase sampling rate: Use more pixels (higher resolution sensor).

• Pre-filtering (Low-pass filtering): Blur the image slightly before sampling to

remove frequencies above the Nyquist limit. This is done optically using an anti-
aliasing filter placed before the sensor.

• Super-sampling: Sample at a higher rate, then downsample with filtering.

Key Point 3: Image File Format

An image file format specifies:

• How pixel data is organized and stored (row-major, planar, etc.).

• The compression method used (if any).

• Metadata (resolution, colour space, creation date, etc.).

• Colour depth and colour model (RGB, CMYK, indexed).

Commonly Used Image File Formats:

Format Full Name Compression Key Features

JPEG Joint Photographic Lossy (DCT-based) Best for photographs,
Experts Group adjustable quality
PNG Portable Network Lossless (Deflate) Supports transparency
Graphics (alpha), web graphics
GIF Graphics Interchange Lossless (LZW) 256 colours, supports
Format animation
BMP Bitmap Usually uncompressed Simple format, large
file size
TIFF Tagged Image File Lossless/Lossy Professional
Format photography,
publishing
RAW Camera Raw None/Lossless Unprocessed sensor
data, maximum quality
SVG Scalable Vector N/A (vector) Resolution-
Graphics independent, web
graphics
WEBP Web Picture Lossy/Lossless Modern web format by
Google, smaller than
JPEG/PNG
19 IP_19
📊 Diagram / Table (if applicable)
Aliasing due to Under-sampling:

Original Signal (High Frequency):

╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲ (Fine detail)

Sampled at Sufficient Rate (≥ 2× f_max):

● ● ● ● ● ● ● ● → Correct reconstruction

Under-sampled (< 2× f_max):

● ● ● → Alias! Appears as low frequency
╲ ╱ ╲ ╱
╲ ╱ ╲ ╱ (False low-frequency pattern)

Moiré Pattern Example:

Original: ||||||||||||||| (fine vertical lines)
Sampled: | | | | | (coarser pattern appears — moiré)

Nyquist Theorem:
f_sampling ≥ 2 × f_max → No aliasing
f_sampling < 2 × f_max → Aliasing occurs

💡 Example
When photographing a person wearing a finely striped shirt with a digital camera, the
stripes may appear as wavy, shifting colour patterns (moiré) in the captured image. This
is aliasing — the spatial frequency of the stripe pattern exceeds the Nyquist limit of the
camera sensor. Many cameras include an optical low-pass (anti-aliasing) filter in front
of the sensor to mitigate this effect.

🔚 Conclusion
Aliasing is a fundamental sampling artefact that occurs when the sampling rate is
insufficient to represent the image's spatial frequencies accurately. It can be mitigated
through higher sampling rates or pre-filtering techniques. Image file formats define how
digital images are stored and vary in compression methods, colour support, and
intended applications. Choosing the right format depends on the trade-off between
quality, file size, and application requirements.

20 IP_20
❓ Question 9: Differentiate between an image and a scene.
Define a digital image and explain image pixels. What is
digitization of an image?
✅ Answer:
📖 Definition / Introduction
In image processing, the terms image and scene are related but distinct concepts. A scene is the
actual physical 3D environment, while an image is a 2D representation of that scene captured by a
sensor. A digital image is a numerical (discrete) representation of a 2D image, and its fundamental
building blocks are pixels. Digitization is the process of converting a continuous image into this
discrete digital form.

📝 Detailed Explanation
Key Point 1: Difference Between Image and Scene

Aspect Scene Image

Definition The actual 3D physical world or A 2D representation of the
environment being observed scene captured by an imaging
device
Dimensionality Three-dimensional (3D) Two-dimensional (2D)
Nature Physical, real-world, Projected, captured, can be
continuous continuous or digital
Information Contains complete depth, Contains partial information
texture, and spatial information (projection of 3D onto 2D)
Existence Exists independently of any Created by an imaging system
observer or device (camera, scanner, etc.)
Example A landscape with mountains, A photograph of that landscape
rivers, and trees

Key Point 2: Digital Image

A digital image is a 2D function f(x, y) where:

• x and y are discrete spatial coordinates (integer values).

• f(x, y) is the intensity or colour value at coordinates (x, y), also a discrete
quantity.

Mathematically, a digital image is a matrix (or 2D array) of size M × N, where M is the

number of rows and N is the number of columns. Each element of this matrix is a pixel.

A digital image can be represented as: f(x, y) where x = 0, 1, 2, ..., M−1 and y = 0, 1,
2, ..., N−1 and f ∈ {0, 1, 2, ..., L−1} where L is the number of grey levels.
21 IP_21
Key Point 3: Image Pixels
A pixel (picture element) is the smallest individual element of a digital image. Key
properties:

• Each pixel has a specific spatial location (x, y) in the image grid.

• Each pixel holds a value representing intensity (greyscale) or colour

(RGB/multi-channel).

• Pixels are arranged in a rectangular grid of rows and columns.

• The total number of pixels = M × N (spatial resolution).

• Pixel values are discrete integers resulting from quantization.

Key Point 4: Digitization of an Image

Digitization converts a continuous analog image into a discrete digital image through
two steps:

Sampling: Discretization of spatial coordinates. The continuous (x, y) plane is divided

into a finite grid of M × N discrete points. Each point becomes a pixel location. The
sampling rate determines the spatial resolution.

Quantization: Discretization of intensity values. The continuous range of

brightness/colour at each sampled point is mapped to one of L discrete levels. For k-bit
quantization, L = 2^k levels.

After digitization: f(x, y) → a matrix of M × N pixels, each with an integer value from 0
to L−1.

📊 Diagram / Table (if applicable)

Scene vs. Image:

3D Scene (Real World) 2D Image (Captured)

┌─────────────────┐ ┌─────────────────┐
│ /\ Mountain │ │ /\ │
│ / \ Sun ☀ │ Camera │ / \ ☀ │
│ / \ ~~~ │ ───────→ │ / \ ~~~ │
│/______\ River │ (Sensing │/______\ │
│ Trees 🌳🌳 │ + Digitiz.)│ 🌳🌳 │
└─────────────────┘ └─────────────────┘
(3D, continuous, real) (2D, discrete, digital)

Digital Image as a Matrix:

f(x,y) = ┌─────┬─────┬─────┬─────┐
│f(0,0)│f(0,1)│f(0,2)│... │ ← Row 0
├─────┼─────┼─────┼─────┤
│f(1,0)│f(1,1)│f(1,2)│... │ ← Row 1
├─────┼─────┼─────┼─────┤
│ ... │ ... │ ... │... │
├─────┼─────┼─────┼─────┤
│f(M-1,0)│...│... │... │ ← Row M-1
22 IP_22
 └─────┴─────┴─────┴─────┘
Col 0 Col 1 Col 2

Each f(x,y) is a PIXEL with value ∈ {0, 1, ..., L-1}

💡 Example
When you stand in front of a garden (scene), your eyes perceive a continuous 3D world
with infinite colour variations. When you take a photograph with a 12MP digital
camera, the sensor samples this scene into 4000 × 3000 discrete pixels (sampling) and
converts each point's light intensity into one of 256 levels per colour channel
(quantization), producing a digital image — a 2D discrete representation of the original
3D scene.

🔚 Conclusion
A scene is the physical 3D world, while an image is its 2D projection captured by an
imaging device. A digital image is a discrete matrix of pixels, where each pixel
represents a sampled and quantized intensity value at a specific spatial location.
Digitization — the process of converting continuous images to digital form through
sampling and quantization — is the foundational step that makes computer-based image
processing possible.

❓ Question 10: Brightness discrimination is poor at low levels

of illumination. Explain. What is Weber ratio? Show the
variation of Weber ratio for humans. What is colour image
processing? What is brightness adaptation?
✅ Answer:
📖 Definition / Introduction
The human visual system's ability to discriminate between different brightness levels is not uniform
— it is significantly poorer at low illumination levels compared to well-lit conditions. This
behaviour is described by the Weber ratio, a fundamental concept in visual perception.
Understanding these properties of human vision is essential for designing effective image
processing systems. Colour image processing and brightness adaptation are closely related
concepts in the study of visual perception and digital image processing.

📝 Detailed Explanation
Key Point 1: Poor Brightness Discrimination at Low Illumination
The human eye can perceive a vast range of23
illumination levels (from dim starlight to IP_23
 bright sunlight — about 10^10 range). However, at any given adaptation level, the eye
can only discriminate a limited range of brightness (called the simultaneous dynamic
range, roughly 1:100 or ~1000 levels).

At low illumination levels (scotopic vision — rod-dominated):

• The eye uses rod cells, which are more sensitive to light but cannot distinguish
colours and have low spatial resolution.

• The ability to detect small differences in brightness (ΔI) between adjacent

regions is poor.

• A larger absolute change in intensity is needed to perceive a difference.

At high illumination levels (photopic vision — cone-dominated):

• The eye uses cone cells, which provide colour vision and higher resolution.

• Brightness discrimination is better — smaller differences can be detected.

Key Point 2: Weber Ratio

The Weber ratio quantifies the minimum detectable change in intensity relative to the
background intensity:

Weber Ratio = ΔI_c / I

Where:

• I = background intensity (current illumination level)

• ΔI_c = increment of illumination (Just Noticeable Difference — JND), the

smallest change in intensity that is perceptible by the eye at intensity level I.

A small Weber ratio means the eye can discriminate fine differences in brightness
(good discrimination). A large Weber ratio means coarse discrimination (poor
sensitivity to differences).

Weber's Law states that ΔI_c / I ≈ constant over a wide range of illumination levels
(approximately 0.02 for well-adapted human vision in moderate-to-bright light).
However, this breaks down at very low illumination levels.

Key Point 3: Variation of Weber Ratio for Humans

The Weber ratio is NOT constant across all illumination levels:

• At very low intensity (scotopic/dim): Weber ratio is high (~0.1 or more) —

poor discrimination.

• As intensity increases, the ratio decreases rapidly.

• At moderate to high intensity (photopic): Weber ratio plateaus at

approximately 0.02 — good discrimination.
24 IP_24
 • At very high intensity (glare): The ratio may increase again slightly.

This means humans are best at discriminating brightness differences in well-lit

conditions, not in darkness or extreme brightness.

Key Point 4: Brightness Adaptation

Brightness adaptation (or luminance adaptation) is the ability of the human visual
system to adjust its sensitivity based on the overall illumination level. The eye adapts to
the average brightness of the scene by adjusting:

• Pupil size (mechanical adjustment — faster but limited range).

• Photochemical changes in rod and cone cells (slower but covers a wider range).

The total range of adaptation spans about 10 orders of magnitude (10^−6 to 10^4
candelas/m²), but at any single adaptation level, the eye can only discriminate about 100
–200 distinct intensity levels simultaneously.

Key Point 5: Colour Image Processing

Colour image processing is the area of DIP that deals with processing images where
colour information is present. It is divided into two major areas:

(a) Pseudo-colour (False colour) processing: Assigning colours to greyscale images

based on intensity to enhance visualization (e.g., thermal imaging, satellite imagery).

(b) Full-colour processing: Processing images that are naturally acquired in colour
(e.g., RGB photographs). Operations include colour transformations, colour-based
segmentation, colour histogram analysis, and colour space conversions (RGB ↔ HSI ↔
CMYK).

Colour adds three independent channels of information, enabling operations that are
impossible with greyscale alone (e.g., separating objects by hue).

📊 Diagram / Table (if applicable)

Weber Ratio Variation for Humans:

Weber Ratio
(ΔIc/I)
|
0.10 ┤ ● (Poor discrimination
| \ at low light)
0.08 ┤ \
| \
0.06 ┤ \
| \
0.04 ┤ \
| \
0.02 ┤--------●────────────────● (Good discrimination
| (Weber's Law region) in bright light)
0.00 ┤
└──┬──────┬──────┬──────┬──→ log(Intensity I)
25 IP_25
 Low Medium High Very High
(Scotopic) (Photopic)

Brightness Adaptation Range:

←── Full adaptation range: ~10^10 ──→
←── Simultaneous range at one level: ~10^2 ──→

Colour Image Processing:

┌─────────────────────────────────────────┐
│ Pseudo-colour │ Full-colour │
│ (Grey → Colour) │ (Natural colour) │
│ Thermal maps │ RGB photographs │
│ Medical scans │ Colour segment. │
└─────────────────────────────────────────┘

💡 Example
When driving at night (low illumination), it is difficult to distinguish between dark grey
and black objects on the road (high Weber ratio = poor discrimination). In daylight
(high illumination), the same objects are easily distinguishable (low Weber ratio). When
you walk from a dark movie theatre into bright sunlight, your eyes take several seconds
to adapt (brightness adaptation) — during this transition, your discrimination ability is
temporarily impaired.

🔚 Conclusion
The human eye's brightness discrimination ability varies with illumination level, being
poorest in dim conditions and best in moderate-to-bright light. The Weber ratio (ΔIc/I)
quantifies this behaviour and is approximately constant (~0.02) in the photopic range
but increases significantly in scotopic conditions. Brightness adaptation allows the eye
to operate across an enormous range of illumination levels, though only a limited range
is discriminable at any one adaptation level. Colour image processing leverages colour
information beyond greyscale to enable richer analysis and visualization.

❓ Question 11: What are the storage requirements for: (a) A 500
× 500 binary image? (b) A 1024 × 1024 binary image?
✅ Answer:
📖 Definition / Introduction
The storage requirement of a digital image depends on its spatial dimensions (number of pixels)
and its bit depth (number of bits used to represent each pixel). A binary image uses only 1 bit per
pixel, where each pixel is either 0 (black) or 1 (white). Calculating storage requirements is
fundamental to understanding image processing system design, memory allocation, and
transmission bandwidth.

26 IP_26
📝 Detailed Explanation
Key Point 1: Storage Formula
The storage required for an uncompressed digital image is given by:

Storage = M × N × k bits

Where:

• M = number of rows (height in pixels)

• N = number of columns (width in pixels)

• k = number of bits per pixel (bit depth)

For a binary image, k = 1 bit per pixel.

Key Point 2: (a) 500 × 500 Binary Image

• M = 500, N = 500, k = 1 bit

• Storage = 500 × 500 × 1 = 250,000 bits

• In bytes: 250,000 / 8 = 31,250 bytes

• In kilobytes: 31,250 / 1024 ≈ 30.52 KB

Key Point 3: (b) 1024 × 1024 Binary Image

• M = 1024, N = 1024, k = 1 bit

• Storage = 1024 × 1024 × 1 = 1,048,576 bits

• In bytes: 1,048,576 / 8 = 131,072 bytes

• In kilobytes: 131,072 / 1024 = 128 KB

• In megabits: 1,048,576 / 1,000,000 ≈ 1.05 Mbits

📊 Diagram / Table (if applicable)

Storage Comparison Table:

┌──────────────────┬────────┬──────────────┬──────────────┬──────────┐
│ Image Size │ Bits/ │ Total Bits │ Total Bytes │ Approx. │
│ │ Pixel │ │ │ Size │
├──────────────────┼────────┼──────────────┼──────────────┼──────────┤
│ 500 × 500 │ 1 │ 250,000 │ 31,250 │ 30.52 KB │
│ (binary) │ │ │ │ │
├──────────────────┼────────┼──────────────┼──────────────┼──────────┤
│ 1024 × 1024 │ 1 │ 1,048,576 │ 131,072 │ 128 KB │
│ (binary) │ │ │ │ │
├──────────────────┼────────┼──────────────┼──────────────┼──────────┤
27 IP_27
 │ For comparison: │ │ │ │ │
│ 1024 × 1024 │ 8 │ 8,388,608 │ 1,048,576 │ 1 MB │
│ (8-bit grey) │ │ │ │ │
├──────────────────┼────────┼──────────────┼──────────────┼──────────┤
│ 1024 × 1024 │ 24 │ 25,165,824 │ 3,145,728 │ 3 MB │
│ (24-bit colour) │ │ │ │ │
└──────────────────┴────────┴──────────────┴──────────────┴──────────┘

Note: These are UNCOMPRESSED storage requirements.

Actual file sizes may be smaller with compression (e.g., RLE for binary
images).

💡 Example
A fax machine transmits binary images of documents. A standard A4 page scanned at
200 DPI produces an image of approximately 1700 × 2340 pixels. Storage = 1700 ×
2340 × 1 = 3,978,000 bits ≈ 485 KB (uncompressed). Using Group 3 fax compression
(a form of run-length encoding), this can typically be compressed to 30–50 KB, making
transmission over phone lines feasible.

🔚 Conclusion
Storage requirements for digital images are directly determined by the image
dimensions and bit depth. A 500 × 500 binary image requires approximately 30.52 KB,
while a 1024 × 1024 binary image requires 128 KB of uncompressed storage. Binary
images are the most storage-efficient format but can only represent two intensity levels.
Understanding storage requirements is crucial for system design, particularly in
applications involving large volumes of images or real-time transmission.

💡 More questions will be added as provided by Rishav.

🎓 Documen

28 IP_28
📘 [Link] 6th Semester — Exam Preparation
Author: Rishav Raj | Semester: 6th Sem | Subject: Image Processing — Digital Image Formation |
Marks per Answer: 5–10 Marks

📌 How to Use This Document

• Each answer is structured for 5–10 marks university exam questions.
• Every answer covers 1-2 pages of content with proper depth.
• Format includes: Definition → Explanation → Key Points → Diagram/Example →
Conclusion

❓ Question 1: What is image sampling? Define saturation in a

digital image.
✅ Answer:
📖 Definition / Introduction
Image sampling is the process of converting a continuous image signal into a discrete set of spatial
coordinates by selecting values at regularly spaced intervals. It is one of the two fundamental steps
in digitizing an image (the other being quantization). Saturation in the context of a digital image
refers to the purity or vividness of a colour — it describes how "pure" a colour is, free from dilution
by white light.

📝 Detailed Explanation
Key Point 1: Image Sampling
A continuous image f(x, y) has values defined at every point in a continuous (x, y)
plane. Since a computer can only handle finite, discrete data, we must sample the image
— that is, measure f at discrete, uniformly spaced locations.

• The continuous spatial domain is divided into a grid of M rows × N columns.

• At each grid point (xᵢ, yⱼ), the image value f(xᵢ, yⱼ) is recorded.

• The distance between adjacent sample points is called the sampling interval
(Δx, Δy).

• The sampling rate (or sampling frequency) = 1/Δx samples per unit length.

Nyquist Sampling Theorem: To perfectly reconstruct a continuous image from its

1 IP_29
 samples, the sampling rate must be at least twice the highest spatial frequency
(f_max) present in the image:

f_sampling ≥ 2 × f_max

If this condition is violated, aliasing occurs — high-frequency details appear as false

low-frequency patterns.

Key Point 2: Types of Sampling

• Uniform Sampling: Samples are taken at equally spaced intervals (most
common).

• Non-uniform Sampling: Samples are taken at varying intervals (used in

adaptive methods).

• Random Sampling: Sample locations are chosen randomly (used in compressed

sensing).

Key Point 3: Saturation in a Digital Image

Saturation (also called chroma or colourfulness) is a colour property that describes
the degree to which a colour differs from a neutral grey of the same brightness. It is one
of the three components in the HSI (Hue-Saturation-Intensity) colour model:

• High saturation: The colour is vivid, pure, and intense (e.g., a bright red).

• Low saturation: The colour is washed out, dull, and closer to grey (e.g., a pastel
pink).

• Zero saturation: The "colour" is a shade of grey (achromatic — no hue).

Mathematically, for a colour with RGB components (R, G, B):

S = 1 − [3 × min(R, G, B)] / (R + G + B)

Saturation ranges from 0 (grey) to 1 (fully saturated/pure colour).

In image processing, saturation is important for:

• Colour-based segmentation (separating objects by colour purity).

• White balance correction.

• Image enhancement (increasing saturation makes images look more vibrant).

📊 Diagram / Table (if applicable)

Sampling Process:

Continuous Image f(x,y) Sampled Image (Discrete)

┌──────────────────┐ ┌──●──●──●──●──●──┐
2 IP_30
 │ │ │ ● ● ● ● ● │
│ Smooth gradient │ Sampling │ ● ● ● ● ● │
│ (infinite pts) │ ───────→ │ ● ● ● ● ● │
│ │ (M × N) │ ● ● ● ● ● │
└──────────────────┘ └──●──●──●──●──●──┘
Each ● = one sample point

Saturation Scale:
┌──────────────────────────────────────────────┐
│ S = 0 S = 0.5 S = 1.0 │
│ (Grey) (Pastel) (Pure colour) │
│ ██████████ ██████████ ██████████ │
│ (no hue) (washed out) (vivid, rich) │
└──────────────────────────────────────────────┘

💡 Example
When scanning a photograph at 300 DPI (dots per inch), the scanner samples the
continuous image at 300 points per inch in both directions. If the photograph has fine
details with spatial frequency up to 100 cycles/inch, the 300 DPI sampling rate satisfies
Nyquist (300 > 2 × 100). A flower image with high saturation appears vivid and
colourful, while reducing saturation to zero converts it to a greyscale image where only
brightness variations remain.

🔚 Conclusion
Image sampling is the essential process of discretizing the spatial domain of a
continuous image into a finite set of pixel locations. The sampling rate must satisfy the
Nyquist criterion to avoid aliasing artefacts. Saturation, on the other hand, is a colour
attribute that measures the purity or vividness of a colour in a digital image. Together,
these concepts are fundamental to understanding how digital images are formed and
how colour information is represented and manipulated.

❓ Question 2: Write down the various 2D transforms.

✅ Answer:
📖 Definition / Introduction
2D transforms in image processing are mathematical operations that convert a spatial domain
image f(x, y) into a transformed domain representation T(u, v). These transforms are used for image
analysis, compression, filtering, feature extraction, and reconstruction. Each transform has unique
properties that make it suitable for specific applications.

3 IP_31
📝 Detailed Explanation
Key Point 1: General Form of 2D Transforms
A general 2D transform can be expressed as:

T(u, v) = Σ_x Σ_y f(x, y) · g(x, y, u, v)

where g(x, y, u, v) is the forward transform kernel (basis function), and the
summation is over all pixel coordinates (x, y). The inverse transform recovers the
original image:

f(x, y) = Σ_u Σ_v T(u, v) · h(x, y, u, v)

where h is the inverse transform kernel.

Key Point 2: Major 2D Transforms

(a) Discrete Fourier Transform (DFT):

• Converts spatial information into frequency components.

• F(u, v) = (1/MN) Σ_x Σ_y f(x, y) · e^(−j2π(ux/M + vy/N))

• Application: Frequency filtering, noise removal, image analysis.

(b) Discrete Cosine Transform (DCT):

• Similar to DFT but uses only cosine functions (real-valued output).

• Concentrates energy in fewer coefficients.

• Application: JPEG compression, video encoding.

(c) Walsh-Hadamard Transform (WHT):

• Uses rectangular/square wave basis functions (+1 and −1 values only).

• Computationally simple (no multiplications, only additions/subtractions).

• Application: Fast image processing, pattern recognition.

(d) Haar Transform:

• Simplest wavelet transform using step functions as basis.

• Provides localized frequency information.

• Application: Edge detection, image compression.

(e) Karhunen-Loève Transform (KLT) / Principal Component Analysis (PCA):

• Data-dependent, optimal transform for energy compaction.

4 IP_32
 • Basis functions are eigenvectors of the image covariance matrix.

• Application: Optimal compression, dimensionality reduction, face recognition.

(f) Discrete Wavelet Transform (DWT):

• Provides both frequency and spatial localization (multi-resolution analysis).

• Uses wavelet functions (e.g., Daubechies, Haar) as basis.

• Application: JPEG 2000 compression, denoising, edge detection.

(g) Slant Transform:

• Uses slant basis functions (sawtooth-like waveforms).

• Good energy compaction for images with constant brightness gradients.

• Application: Image coding.

(h) Hotelling Transform:

• Also known as eigenvector transform.

• Based on statistical properties of the image data.

• Application: Multi-spectral image processing, decorrelation.

📊 Diagram / Table (if applicable)

Comparison of 2D Transforms:

┌────────────────┬──────────────────┬───────────────┬──────────────────┐
│ Transform │ Basis Functions │ Energy │ Primary │
│ │ │ Compaction │ Application │
├────────────────┼──────────────────┼───────────────┼──────────────────┤
│ DFT │ Complex exponent.│ Moderate │ Freq. filtering │
│ DCT │ Cosine functions │ High │ JPEG compression │
│ WHT │ Square waves │ Moderate │ Fast processing │
│ Haar │ Step functions │ Moderate │ Edge detection │
│ KLT (PCA) │ Eigenvectors │ Optimal │ Compression │
│ DWT │ Wavelets │ High │ JPEG 2000 │
│ Slant │ Sawtooth waves │ Good │ Image coding │
│ Hotelling │ Eigenvectors │ Optimal │ Decorrelation │
└────────────────┴──────────────────┴───────────────┴──────────────────┘

Transform Domain Pipeline:

f(x,y) ──→ [Forward Transform] ──→ T(u,v) ──→ [Processing] ──→ T'(u,v) ──→
[Inverse Transform] ──→ f'(x,y)
(Spatial) (Transform)
(Spatial)

5 IP_33
💡 Example
In JPEG image compression, the image is divided into 8×8 blocks, and the 2D DCT is
applied to each block. Most of the energy is concentrated in the top-left corner (low-
frequency coefficients). The high-frequency coefficients (bottom-right) are quantized
more aggressively (set to zero), achieving compression with minimal visual quality loss.

🔚 Conclusion
2D transforms are indispensable tools in digital image processing. Each transform offers
unique properties — DFT provides frequency analysis, DCT excels in compression,
WHT offers computational simplicity, KLT achieves optimal energy compaction, and
DWT provides multi-resolution analysis. The choice of transform depends on the
application requirements, including computational cost, energy compaction, and the
nature of the image data being processed.

❓ Question 3: What are the basic steps involved in image

geometrical transformation? Develop the homogeneous form
of these transformations. State the applications of image
transforms. What is energy compaction of image transform?
How is an image represented in digital formats?
✅ Answer:
📖 Definition / Introduction
Image geometrical transformations are operations that modify the spatial positions of pixels in an
image without changing their intensity values. These include translation, rotation, scaling, and
shearing. Using homogeneous coordinates, these transformations can be expressed as matrix
multiplications, allowing them to be combined efficiently. Image transforms have wide applications
in compression, analysis, and recognition, and a key property — energy compaction — makes
them particularly useful for compression.

📝 Detailed Explanation
Key Point 1: Basic Steps in Image Geometrical Transformation
The process of geometrical transformation involves three main steps:

Step 1: Spatial Transformation (Coordinate Mapping)

• Define the mathematical mapping that relates the coordinates of each pixel in the
output image to the corresponding coordinates in the input image.

• Forward mapping: (x', y') = T(x, y) — maps input to output.

6 IP_34
 • Inverse mapping: (x, y) = T⁻¹(x', y') — maps output back to input (preferred to
avoid holes).

Step 2: Intensity Interpolation

• Since the mapped coordinates often fall at non-integer positions, interpolation is

needed to determine the pixel value.

• Common methods: Nearest-neighbour, Bilinear, Bicubic interpolation.

Step 3: Grey-Level Assignment

• Assign the interpolated intensity value to the output pixel at position (x', y').

Key Point 2: Homogeneous Form of Geometric Transformations

Homogeneous coordinates add a third coordinate (w = 1) to represent 2D points as 3D
vectors: [x, y, 1]ᵀ. This allows all transformations (including translation) to be
expressed as 3×3 matrix multiplications.

(a) Translation (shift by tx, ty):

[x'] [1 0 tx] [x]

[y'] = [0 1 ty] [y]
[1 ] [0 0 1 ] [1]

(b) Scaling (scale by sx, sy):

[x'] [sx 0 0] [x]
[y'] = [0 sy 0] [y]
[1 ] [0 0 1] [1]

(c) Rotation (rotate by angle θ about origin):

[x'] [cosθ -sinθ 0] [x]
[y'] = [sinθ cosθ 0] [y]
[1 ] [ 0 0 1] [1]

(d) Shearing (shear by factors shx, shy):

[x'] [1 shx 0] [x]
[y'] = [shy 1 0] [y]
[1 ] [0 0 1] [1]

Composite Transformation: Multiple transformations can be combined by multiplying their

matrices: T_combined = T₃ × T₂ × T₁ (applied right to left).
Key Point 3: Applications of Image Transforms
• Image compression: DCT (JPEG), DWT (JPEG 2000), KLT.

• Frequency analysis and filtering: DFT for low-pass, high-pass, band-pass

filtering.

• Feature extraction: Wavelet features, Fourier descriptors.

7 IP_35
 • Image registration and alignment: Geometric transforms to align multi-modal
images.

• Image reconstruction: CT scan reconstruction using Fourier/Radon transforms.

• Noise removal: Filtering in the transform domain.

• Pattern recognition: KLT/PCA for face recognition, fingerprint analysis.

• Watermarking: Embedding information in transform domain coefficients.

Key Point 4: Energy Compaction

Energy compaction is the ability of a transform to concentrate most of the image's
energy (information) into a small number of transform coefficients, with the
remaining coefficients being close to zero.

• In the spatial domain, energy is spread across all M × N pixels.

• After applying a good transform (e.g., DCT, KLT), most energy is packed into a
few low-frequency coefficients.

• The remaining (high-frequency) coefficients can be discarded or coarsely

quantized with minimal visual quality loss.

• KLT has optimal energy compaction (mathematically proven), but is data-

dependent and computationally expensive.

• DCT has near-optimal energy compaction for natural images and is data-
independent, making it the preferred choice for standards like JPEG.

Key Point 5: Image Representation in Digital Formats

A digital image is represented as:

• A 2D matrix/array of size M × N, where each element f(x, y) is a pixel value.

• Greyscale: Single matrix with values 0–255 (8-bit).

• Colour (RGB): Three matrices (one each for Red, Green, Blue channels), each
M × N.

• Binary: Single matrix with values 0 or 1.

• Storage formats: Raster formats (BMP, JPEG, PNG, TIFF, GIF) store pixel
data; vector formats (SVG) store mathematical descriptions of shapes.

• Header + Data: Most file formats have a header (metadata: dimensions, bit
depth, colour model) followed by pixel data (compressed or uncompressed).

8 IP_36
📊 Diagram / Table (if applicable)
Geometric Transformations in Homogeneous Coordinates:

Original Translated Scaled Rotated

Sheared
┌────┐ ┌────┐ ┌────────┐ ╱────╲
┌────────┐
│ │ │ │ (tx,ty) │ │ ╱ ╲ │ ╱
│
│ │ ───→ │ │ → │ │ ╱ ╲ │╱
│
└────┘ └────┘ └────────┘ ╲────────╱
└────────┘

Energy Compaction (DCT example):

Spatial Domain DCT Domain
┌──────────────┐ ┌──────────────┐
│ Energy spread│ DCT → │██ │ ██ = High energy
│ across all │ │█ │ (few coefficients)
│ pixels │ │ │
│ uniformly │ │ │ Rest ≈ 0 (discardable)
└──────────────┘ └──────────────┘

💡 Example
To rotate an image by 30° and then translate it by (50, 100), we compute: T =
T_translate × T_rotate. For each output pixel (x', y'), we find the corresponding input
location via T⁻¹, use bilinear interpolation to find the intensity, and assign it to (x', y').
In JPEG compression, the 2D DCT achieves energy compaction — for a typical 8×8
image block, over 90% of the energy is concentrated in just 10–15 coefficients out of
64.

🔚 Conclusion
Geometrical transformations (translation, rotation, scaling, shearing) are essential
operations in image processing. Using homogeneous coordinates, all these
transformations can be represented as 3×3 matrix multiplications, enabling efficient
composition of multiple transforms. Image transforms like DCT, DFT, and KLT are
widely applied in compression, filtering, and recognition. Energy compaction — the
ability to concentrate image energy in few coefficients — is the key property that
enables effective image compression. Digital images are represented as 2D matrices
stored in various file formats with headers and pixel data.

9 IP_37
❓ Question 4: If an image is rotated by an angle of π/4, will
there be any change in the histogram of that image? Justify.
✅ Answer:
📖 Definition / Introduction
A histogram of a digital image is a graphical representation showing the frequency distribution of
pixel intensity values. It plots the number of pixels at each intensity level (0 to L−1). Image
rotation is a geometric transformation that changes the spatial positions of pixels. The question
examines whether rotating an image by π/4 (45°) affects its histogram — a fundamental relationship
between spatial and intensity transformations.

📝 Detailed Explanation
Key Point 1: Histogram is Intensity-Based, Not Position-Based
The histogram of an image depends only on the intensity values and their frequency of
occurrence — it does NOT depend on the spatial arrangement or positions of the
pixels. Whether a pixel with value 128 is at location (0, 0) or (100, 200) makes no
difference to the histogram. Therefore, any purely geometric transformation that only
rearranges pixel positions without altering intensity values should, in theory, leave the
histogram unchanged.

Key Point 2: Ideal Rotation (No Change)

In an ideal (theoretical) rotation:

• Each pixel is moved to a new location based on the rotation formula.

• The intensity values are preserved exactly.

• The number of pixels at each intensity level remains the same.

• Therefore, the histogram does NOT change.

This is because rotation is a rigid body transformation — it preserves distances and

does not modify pixel values.

Key Point 3: Practical Rotation (Minor Changes)

In practice, when a digital image is rotated by π/4 (45°):

(a) Interpolation causes intensity changes:

• The rotated pixel positions generally fall at non-integer coordinates in the

original image.

• Interpolation (nearest-neighbour, bilinear, bicubic) is required to estimate

intensity values at these non-integer positions.

10 IP_38
 • Bilinear and bicubic interpolation compute weighted averages of neighbouring
pixels, producing new intensity values that may not have existed in the original
image.

• This introduces subtle changes in the histogram (new intensity levels may
appear, some may disappear, distribution smooths out slightly).

(b) Image boundary effects:

• Rotation by 45° changes the image's bounding rectangle (the rotated square
becomes a larger diamond shape).

• New background pixels (usually black = 0 or white = 255) are added to fill the
corners of the new rectangular bounding box.

• These extra pixels add to the histogram count at the background intensity level.

(c) Image size change:

• The rotated image may have different dimensions, introducing or removing

pixels.

📊 Diagram / Table (if applicable)

Rotation by π/4 (45°):

Original Image Rotated Image (in larger bounding box)

┌──────────┐ ┌──────────────────┐
│ │ │ BG ╱╲ BG │
│ Image │ Rotate │ ╱ ╲ │
│ Content │ π/4 → │ ╱ Image ╲ │
│ │ │ ╱ Content ╲ │
└──────────┘ │╱ ╲ │
│╲ ╱ │
│ ╲ ╱ │
│ BG ╲ ╱ BG │
│ ╲╱ │
└──────────────────┘
BG = Background pixels (added)

Histogram Impact:
┌────────────────────────────────────────────────┐
│ Factor │ Effect on Histogram │
├───────────────────────┼─────────────────────────┤
│ Pure rotation (ideal) │ No change │
│ Interpolation │ Slight smoothing │
│ Background addition │ Spike at BG intensity │
│ Nearest-neighbour │ Minimal change │
│ Bilinear/Bicubic │ New intermediate values │
└───────────────────────┴─────────────────────────┘

💡 Example
Consider a small 4×4 image with only two intensity values: 100 and 200 (each
11 IP_39
 appearing 8 times). After rotating by π/4 using bilinear interpolation, some pixel values
become weighted averages like 125, 150, 175 — values that did NOT exist in the
original image. The histogram now has additional bars at these intermediate levels, and
the counts at 100 and 200 decrease. Additionally, background (black = 0) pixels are
added at the corners, creating a new spike at intensity 0.

🔚 Conclusion
Theoretically, rotating an image by π/4 should NOT change its histogram, because
rotation is a spatial transformation that rearranges pixel positions without altering their
intensity values. However, in practice, the histogram DOES change slightly due to
three factors: (1) interpolation introduces new intermediate intensity values, (2)
background pixels are added to fill the rotated image's bounding box, and (3) the total
number of pixels may change. The extent of histogram change depends on the
interpolation method used — nearest-neighbour causes the least change, while bilinear
and bicubic cause more.

❓ Question 5: Explain CMY and CMYK colour models. Explain

RGB model and HSI model. How can a colour image be
converted to a gray-scale image?
✅ Answer:
📖 Definition / Introduction
Colour models are mathematical representations used to describe colours as combinations of
numerical values. Different models are designed for different applications: RGB for display
devices, CMY/CMYK for printing, and HSI for human-intuitive colour description. Understanding
these models and the conversion between them — including converting colour to greyscale — is
fundamental to colour image processing.

📝 Detailed Explanation
Key Point 1: RGB (Red, Green, Blue) Colour Model
The RGB model is an additive colour model based on combining red, green, and blue
light:

• Each colour is represented by three components: R, G, B (each ranging from 0 to

255 for 8-bit).

• (0, 0, 0) = Black (no light), (255, 255, 255) = White (full light).

• Primary colours: Red (255,0,0), Green (0,255,0), Blue (0,0,255).

12 IP_40
 • Secondary colours: Yellow = R+G, Cyan = G+B, Magenta = R+B.

• The model is visualized as a colour cube with R, G, B on the three axes.

• The main diagonal (R=G=B) represents grey shades from black to white.

• Application: Computer monitors, TVs, cameras, displays.

• Total colours in 24-bit RGB = 256³ = 16,777,216 (16.7 million).

Key Point 2: CMY (Cyan, Magenta, Yellow) Colour Model

The CMY model is a subtractive colour model used in colour printing:

• Works by subtracting colours from white light (white paper reflects all light).

• Cyan absorbs Red, Magenta absorbs Green, Yellow absorbs Blue.

• Conversion from RGB: C = 1 − R, M = 1 − G, Y = 1 − B (values normalized to

[0, 1]).

• Combining C + M + Y = Black (in theory).

• (0, 0, 0) in CMY = White, (1, 1, 1) = Black.

• Application: Colour printers (basic).

Key Point 3: CMYK Colour Model

CMYK extends CMY by adding a K (Key/Black) component:

• In practice, mixing C + M + Y produces a muddy brown/grey, not true black.

• Adding a separate black ink (K) provides:

• True deep black.

• Sharper text and detail.

• Reduced ink usage and cost.

• Conversion from CMY:

• K = min(C, M, Y)

• C' = C − K, M' = M − K, Y' = Y − K

• Application: Professional colour printing (magazines, newspapers, packaging).

Key Point 4: HSI (Hue, Saturation, Intensity) Colour Model

The HSI model describes colour in terms more intuitive to human perception:

• Hue (H): The dominant wavelength / type of colour (0°–360°). Red = 0°, Green
= 120°, Blue = 240°.
13 IP_41
 • Saturation (S): Purity of the colour (0 = grey, 1 = fully saturated pure colour).

• Intensity (I): Brightness or luminance (0 = black, 1 = white).

The HSI model decouples colour information (H, S) from intensity (I), which is
extremely useful for:

• Processing the intensity channel independently of colour.

• Colour-based segmentation (using H and S).

• Handling illumination variations (by modifying I alone).

The model is visualized as a double cone or cylinder with H as the angular dimension,
S as the radial dimension, and I as the vertical axis.

Key Point 5: Colour to Greyscale Conversion

A colour image (RGB) can be converted to a greyscale image by computing a weighted
sum of the R, G, B channels:

Method 1: Luminosity Method (Perceptual — Recommended)

• Grey = 0.299 × R + 0.587 × G + 0.114 × B

• This accounts for human eye sensitivity (most sensitive to green, least to blue).

Method 2: Average Method

• Grey = (R + G + B) / 3

• Simple but less perceptually accurate.

Method 3: Lightness Method

• Grey = (max(R,G,B) + min(R,G,B)) / 2

Method 4: Using HSI Model

• Convert to HSI and discard H and S; use only the I (Intensity) channel.

📊 Diagram / Table (if applicable)

RGB Colour Cube: HSI Double Cone:
White
Green (0,1,0) /|\
/| / | \
/ | / | \ ← I (Intensity)
/ | Yellow (1,1,0) / | \
Cyan──/───|───/ H(hue)/ S(sat)\
(0,1,1) | / \ | /
| Black (0,0,0) \ | /
14 IP_42
 | / / \ | /
| / / \|/
Blue ──── Red (1,0,0) Black
(0,0,1) Magenta (1,0,1)

CMY/CMYK Subtractive Model:

White Paper − Cyan = No Red (reflects G + B)
White Paper − Magenta = No Green (reflects R + B)
White Paper − Yellow = No Blue (reflects R + G)
White Paper − C − M − Y = Black (absorbs all — ideally)

Colour Model Comparison:

┌─────────┬────────────┬───────────────┬─────────────────┐
│ Model │ Type │ Components │ Application │
├─────────┼────────────┼───────────────┼─────────────────┤
│ RGB │ Additive │ Red,Green,Blue│ Displays │
│ CMY │ Subtractive│ Cyan,Mag,Yel │ Basic printing │
│ CMYK │ Subtractive│ C,M,Y + Black │ Prof. printing │
│ HSI │ Perceptual │ Hue,Sat,Int │ Image analysis │
└─────────┴────────────┴───────────────┴─────────────────┘

💡 Example
A digital photograph displayed on a monitor uses the RGB model. The sky appears as
approximately (135, 206, 235) in RGB — a light blue. To print this photo, the printer
converts it to CMYK: C = 0.43, M = 0.12, Y = 0, K = 0.08. For colour-based weather
analysis, the HSI model would be used: H ≈ 197° (blue hue), S ≈ 0.43 (moderately
saturated), I ≈ 0.75 (bright). To convert to greyscale: Grey = 0.299(135) + 0.587(206) +
0.114(235) ≈ 188.

🔚 Conclusion
The four major colour models serve different purposes: RGB is standard for electronic
displays (additive), CMY/CMYK for printing (subtractive), and HSI for perceptual
colour analysis. Each model has strengths — RGB is hardware-aligned, CMYK is print-
optimized, and HSI separates colour from intensity for more intuitive processing.
Colour-to-greyscale conversion is best done using the luminosity method (weighted
sum) that reflects human visual sensitivity to different colour channels.

❓ Question 6: Write the conversion rules for converting RGB to

HSI model and vice versa. Explain histogram processing of
colour images.
✅ Answer:
📖 Definition / Introduction
Converting between RGB and HSI colour models is essential in image processing because RGB is
15 IP_43
hardware-oriented (used by cameras and displays) while HSI is perception-oriented (separating
colour from brightness). The conversion involves mathematical formulas that map between the two
representations. Histogram processing of colour images extends greyscale histogram techniques
to handle multi-channel colour data, primarily using the HSI model.

📝 Detailed Explanation
Key Point 1: RGB to HSI Conversion
Given R, G, B values normalized to [0, 1]:

Intensity (I):

• I = (R + G + B) / 3

Saturation (S):

• S = 1 − [3 × min(R, G, B)] / (R + G + B)

• If R + G + B = 0, then S = 0

Hue (H):

• θ = cos⁻¹ { [(R−G) + (R−B)] / [2 × √((R−G)² + (R−B)(G−B))] }

• If B ≤ G: H = θ

• If B > G: H = 360° − θ

• If S = 0: H is undefined (achromatic / grey)

Alternatively:

• θ = cos⁻¹ { 0.5 × [(R−G) + (R−B)] / √[(R−G)² + (R−B)(G−B)] }

Key Point 2: HSI to RGB Conversion

Given H (0°–360°), S (0–1), I (0–1), the conversion depends on which 120° sector H
falls in:

Case 1: RG Sector (0° ≤ H < 120°):

• B = I × (1 − S)

• R = I × [1 + (S × cos H) / cos(60° − H)]

• G = 3I − (R + B)

Case 2: GB Sector (120° ≤ H < 240°):

• H = H − 120°
16 IP_44
 • R = I × (1 − S)

• G = I × [1 + (S × cos H) / cos(60° − H)]

• B = 3I − (R + G)

Case 3: BR Sector (240° ≤ H < 360°):

• H = H − 240°

• G = I × (1 − S)

• B = I × [1 + (S × cos H) / cos(60° − H)]

• R = 3I − (G + B)

Key Point 3: Histogram Processing of Colour Images

Histogram equalization and other histogram techniques for colour images require
special handling because naively processing each R, G, B channel independently can
produce colour artefacts (hue shifts and unnatural colours).

Approach 1: HSI-based Processing (Recommended)

1. Convert RGB image to HSI colour space.

2. Apply histogram equalization only to the Intensity (I) channel.

3. Leave H and S channels unchanged (preserving colour information).

4. Convert back from HSI to RGB.

• Advantage: Colour (hue and saturation) is preserved; only brightness is

modified.

Approach 2: Independent Channel Processing

1. Apply histogram equalization to each R, G, B channel separately.

• Disadvantage: Can cause colour shifts and unnatural results because the
channels are processed independently.

Approach 3: Histogram Specification (Matching)

• Match the histogram of each channel (or intensity) to a desired target histogram.

• Useful for colour transfer between images.

📊 Diagram / Table (if applicable)

RGB to HSI Conversion Flow:
17 IP_45
 ┌─────────┐
│ R,G,B │
│ (0–255) │
└────┬────┘
│ Normalize to [0,1]
↓
┌─────────────────────────────────────────────┐
│ I = (R + G + B) / 3 │
│ S = 1 − 3×min(R,G,B) / (R+G+B) │
│ θ = cos⁻¹[0.5(R−G+R−B)/√((R−G)²+(R−B)(G−B))]│
│ H = θ (if B ≤ G) or 360°−θ (if B > G) │
└─────────────────────────────────────────────┘
│
↓
┌─────────┐
│ H,S,I │
└─────────┘

Histogram Processing of Colour Images:

┌─────┐ ┌─────┐ ┌─────┐
│ RGB │ ──→ │ HSI │ ──→ │ HSI │ ──→ ┌─────┐
│image│ Convert │image│ Equalize│image│ Convert│ RGB │
└─────┘ to HSI └─────┘ I only └─────┘ to RGB └─────┘
(Enhanced)
✓ H unchanged (colour type preserved)
✓ S unchanged (colour purity preserved)
✓ I equalized (contrast improved)

💡 Example
For a pixel with RGB = (200, 100, 50) normalized to (0.784, 0.392, 0.196):

• I = (0.784 + 0.392 + 0.196) / 3 = 0.457

• S = 1 − 3(0.196) / (0.784 + 0.392 + 0.196) = 1 − 0.588/1.372 = 0.571

• θ = cos⁻¹[0.5(0.392 + 0.588) / √(0.154 + 0.346 × 0.196)] = cos⁻¹(0.490/0.468) ≈

20.9°

• Since B(0.196) < G(0.392): H = 20.9° (orange-ish hue)

For histogram processing, converting this image to HSI, equalizing only the I channel,
and converting back preserves the orange hue while improving contrast.

🔚 Conclusion
RGB to HSI conversion separates the colour (H, S) from the brightness (I), enabling
independent processing. The forward conversion uses trigonometric formulas to
compute hue, a ratio for saturation, and a simple average for intensity. The inverse
conversion uses sector-based formulas to recover RGB from HSI. For histogram
processing of colour images, the preferred approach is to convert to HSI, apply
histogram equalization only to the Intensity channel, and convert back — this enhances
contrast while preserving the original colours.

18 IP_46
❓ Question 7: What is a CCD array? How is it related to image
quality?
✅ Answer:
📖 Definition / Introduction
A CCD (Charge-Coupled Device) array is a semiconductor-based image sensor consisting of a
2D grid of photosensitive elements (photosites or pixels) that convert incoming light into electrical
charge. CCD arrays are one of the most important technologies for image acquisition in digital
cameras, scanners, telescopes, and medical imaging devices. The characteristics of the CCD array
directly determine several aspects of the captured image's quality.

📝 Detailed Explanation
Key Point 1: Structure and Working of a CCD Array
• A CCD array consists of an M × N grid of photosites (metal-oxide-
semiconductor capacitors).

• Each photosite accumulates electrical charge proportional to the intensity of

light falling on it during the exposure period.

• After exposure, the accumulated charges are shifted row by row through the
array to an output amplifier using a precisely timed sequence of clock pulses
(charge coupling).

• The output amplifier converts the charge to a voltage, which is then digitized by
an ADC (Analog-to-Digital Converter) to produce pixel values.

• The entire process is highly orderly — charges are transferred without mixing,
preserving spatial accuracy.

Key Point 2: How CCD Array Relates to Image Quality

(a) Spatial Resolution:

• The number of photosites (M × N) directly determines the spatial resolution.

• More photosites = more pixels = finer detail.

• A 4000 × 3000 CCD array produces a 12-megapixel image.

(b) Sensitivity (Signal-to-Noise Ratio):

• Larger photosites collect more photons, producing a stronger signal relative to

noise.
19 IP_47
 • Higher sensitivity → better image quality in low-light conditions.

• Trade-off: larger photosites mean fewer pixels for a given sensor size, reducing
resolution.

(c) Dynamic Range:

• The full-well capacity (maximum charge a photosite can hold) determines

dynamic range.

• Higher dynamic range = ability to capture both very dark and very bright details
simultaneously.

• CCD sensors typically have excellent dynamic range.

(d) Noise Characteristics:

• Read noise: Introduced during charge transfer and readout.

• Dark current noise: Charge generated by thermal effects (even without light).

• Photon shot noise: Inherent statistical variation in photon arrival.

• Lower noise → cleaner, higher quality images.

• Cooling the CCD reduces dark current (used in astronomical CCDs).

(e) Colour Accuracy:

• Colour CCDs use a Bayer filter (mosaic of R, G, B colour filters over

photosites).

• The quality of the colour filter array and demosaicing algorithm affect colour
accuracy.

• Alternatively, some high-end cameras use 3-CCD systems (one CCD per colour
channel) for superior colour.

(f) Fill Factor:

• The percentage of photosite area that is actually light-sensitive.

• Higher fill factor → more light collected → better sensitivity and less aliasing.

📊 Diagram / Table (if applicable)

CCD Array Structure:
┌──────┬──────┬──────┬──────┬──────┐
│ P1,1 │ P1,2 │ P1,3 │ P1,4 │ ... │ ← Row 1
├──────┼──────┼──────┼──────┼──────┤
│ P2,1 │ P2,2 │ P2,3 │ P2,4 │ ... │ ← Row 2 P = Photosite
20 IP_48
 ├──────┼──────┼──────┼──────┼──────┤
│ P3,1 │ P3,2 │ P3,3 │ P3,4 │ ... │ ← Row 3
├──────┼──────┼──────┼──────┼──────┤
│ ... │ ... │ ... │ ... │ ... │
└──┬───┴──┬───┴──┬───┴──┬───┴──────┘
│ │ │ │
↓ ↓ ↓ ↓ (Charge transfer)
┌──────────────────────────────────┐
│ Output Register │ → Amplifier → ADC → Digital Value
└──────────────────────────────────┘

CCD Quality Factors:

┌─────────────────────┬──────────────────────────────────┐
│ CCD Parameter │ Impact on Image Quality │
├─────────────────────┼──────────────────────────────────┤
│ Number of photosites│ Spatial resolution │
│ Photosite size │ Sensitivity, SNR, dynamic range │
│ Full-well capacity │ Dynamic range │
│ Read noise │ Low-light image quality │
│ Dark current │ Long-exposure noise │
│ Fill factor │ Light collection efficiency │
│ Bayer filter quality│ Colour accuracy │
└─────────────────────┴──────────────────────────────────┘

💡 Example
A professional astronomical CCD camera like the KAF-16803 has a 4096 × 4096 array
with 9 μm photosites. The large photosites provide excellent sensitivity for capturing
faint stars. The sensor is cooled to −40°C to minimize dark current noise, enabling long
exposures (minutes to hours). The result is high-resolution, low-noise images of deep-
sky objects that would be impossible with smaller, noisier sensors.

🔚 Conclusion
The CCD array is a fundamental image sensing technology where photosites convert
light into electrical charge that is systematically read out and digitized. Image quality is
directly affected by CCD parameters: the number of photosites determines resolution,
photosite size affects sensitivity and noise, full-well capacity defines dynamic range,
and the colour filter arrangement impacts colour accuracy. Understanding these
relationships is essential for selecting appropriate imaging systems and optimizing
image quality for specific applications.

21 IP_49
❓ Question 8: What is image resampling? What is the purpose
of image denoising? When do we need image warping? What
is digital watermarking?
✅ Answer:
📖 Definition / Introduction
Digital image processing encompasses several important operations for transforming, cleaning, and
securing images. Image resampling changes the pixel grid of an image, denoising removes
unwanted noise, warping applies non-linear geometric distortions, and digital watermarking
embeds hidden information for copyright protection. Each of these operations serves a distinct
purpose in the image processing pipeline.

📝 Detailed Explanation
Key Point 1: Image Resampling
Image resampling is the process of transforming a digitized image from one coordinate
grid to another. It involves changing the number of pixels (resolution) or the spatial
arrangement of an image. Resampling is required whenever:

• An image is resized (scaled up or down).

• An image undergoes geometric transformation (rotation, affine transform).

• Multi-resolution processing is performed.

Methods:

• Upsampling (Interpolation): Increasing resolution by inserting new pixels and

computing their values using interpolation (nearest-neighbour, bilinear, bicubic).

• Downsampling (Decimation): Reducing resolution by discarding pixels (after

anti-aliasing filtering to prevent aliasing).

The quality of resampled images depends on the interpolation method used and the
resampling ratio.

Key Point 2: Image Denoising — Purpose

Image denoising is the process of removing noise from a digital image to recover the
clean underlying signal. Noise is unwanted random variations in pixel values introduced
during acquisition, transmission, or storage.

Purpose:

• Improve visual quality of images for human viewing.

• Improve accuracy of subsequent processing (segmentation, recognition,

22 IP_50
 measurement).

• Remove artefacts from sensor limitations, low-light conditions, or

communication errors.

Common types of noise:

• Gaussian noise: Random, bell-curve distributed variations (from sensor

electronics).

• Salt-and-pepper noise: Random black and white pixels (from transmission

errors).

• Poisson noise: Signal-dependent noise (from photon counting).

• Speckle noise: Multiplicative noise (in radar/ultrasound images).

Common denoising methods: Mean filter, median filter, Gaussian filter, Wiener filter,
wavelet denoising, Non-Local Means (NLM), BM3D.

Key Point 3: Image Warping — When Is It Needed?

Image warping is a non-linear geometric transformation that distorts an image by
mapping pixels from source to destination coordinates using a non-affine
(curved/irregular) mapping function.

We need image warping when:

• Image registration: Aligning images taken from different viewpoints, at

different times, or by different sensors (e.g., medical image fusion, satellite
mosaic).

• Lens distortion correction: Correcting barrel or pincushion distortion from

camera lenses.

• Morphing: Creating smooth transitions between two images (special effects in

movies).

• Texture mapping: Mapping 2D textures onto 3D surfaces in computer graphics.

• Panorama stitching: Aligning and blending multiple photographs into a wide

panorama.

• Cartographic projections: Converting satellite/aerial images to map

projections.

Key Point 4: Digital Watermarking

Digital watermarking is the process of embedding a unique, typically invisible, piece
of information (the watermark) into a digital image. The watermark is designed to be:

• Imperceptible: Not visible to the human eye (invisible watermark).

23 IP_51
 • Robust: Survives common image operations (compression, cropping, scaling,
filtering).

• Secure: Difficult to remove or forge without degrading the image.

Applications:

• Copyright protection: Proving ownership of digital content.

• Authentication: Verifying the image has not been tampered with.

• Content tracking: Tracing the distribution of digital media.

• Broadcast monitoring: Detecting unauthorized use of broadcast content.

Methods:

• Spatial domain: Modify LSB (Least Significant Bit) of pixel values.

• Transform domain: Modify DCT, DFT, or DWT coefficients (more robust).

📊 Diagram / Table (if applicable)

Image Processing Operations Summary:

┌─────────────────┬──────────────────────┬──────────────────────────┐
│ Operation │ Purpose │ Key Application │
├─────────────────┼──────────────────────┼──────────────────────────┤
│ Resampling │ Change pixel grid │ Resizing, rotation │
│ Denoising │ Remove noise │ Medical imaging, photos │
│ Warping │ Non-linear distortion│ Registration, panoramas │
│ Watermarking │ Embed hidden info │ Copyright protection │
└─────────────────┴──────────────────────┴──────────────────────────┘

Digital Watermarking Pipeline:

Original Image + Watermark Data → [Embedding Algorithm] → Watermarked Image
(visually
identical)
Watermarked Image → [Extraction Algorithm] → Recovered Watermark
(for verification)

Image Warping:
Source Image Warped Image
┌──────────┐ ┌──╱──╲───┐
│ │ warp │╱ ╲│
│ Grid │ ───→ │ │
│ │ │╲ ╱ │
└──────────┘ └──╲──╱───┘
(regular grid) (distorted grid)

💡 Example
Resampling: Zooming into a 1024×1024 image to display it as 2048×2048 on a high-
resolution monitor requires upsampling with bilinear interpolation. Denoising: A photo
24 IP_52
 taken in dim light has visible grain (Gaussian noise); applying a Wiener filter removes
the noise while preserving edges. Warping: Stitching two overlapping drone
photographs into a seamless panorama requires warping one image to align with the
other. Watermarking: A stock photo company embeds an invisible watermark in each
image; if a customer uses the image without a license, the watermark can be extracted to
prove ownership.

🔚 Conclusion
Image resampling, denoising, warping, and digital watermarking are four distinct but
important operations in digital image processing. Resampling enables resolution
changes and geometric transformations; denoising improves image quality by removing
unwanted noise; warping handles complex non-linear geometric corrections for
registration and alignment; and watermarking provides a means of embedding hidden
information for copyright protection and authentication. Together, these operations
address the practical challenges of image acquisition, processing, and distribution.

❓ Question 9: What is image thinning in character recognition?

✅ Answer:
📖 Definition / Introduction
Image thinning (also called skeletonization) is a morphological operation that reduces the width
of foreground objects (characters/shapes) in a binary image to a single-pixel-wide representation
(skeleton) while preserving the topological and geometric properties of the original shape. In
character recognition (OCR), thinning is a critical preprocessing step that simplifies character
shapes for more efficient and accurate recognition.

📝 Detailed Explanation
Key Point 1: What Thinning Does
Thinning iteratively peels away (erodes) pixels from the boundaries of foreground
objects, but unlike simple erosion, it ensures that:

• The connectivity of the object is preserved (no breaks or disconnections).

• The topology is maintained (no holes created or eliminated).

• The result is a skeleton — a one-pixel-wide line representation that captures the

essential structure of the shape.

The skeleton lies along the medial axis of the object — the set of centres of maximal
circles that fit within the object.
25 IP_53
Key Point 2: Role in Character Recognition
In OCR (Optical Character Recognition), thinning serves several important purposes:

• Normalization: Characters of different font sizes, styles, and stroke widths are
reduced to a uniform, single-pixel-wide representation. This removes variations
due to font weight (bold vs. thin).

• Feature Extraction: The skeleton provides a compact representation from

which structural features can be extracted: endpoints, branch points, loops,
curves, and strokes.

• Reduced Data: Processing a skeleton is computationally cheaper than

processing the full character image.

• Stroke Analysis: The skeleton directly represents the pen strokes that form the
character, making it easier to match against character templates or models.

• Invariance: The skeleton is relatively invariant to changes in stroke width,

making recognition more robust.

Key Point 3: Thinning Algorithm (Zhang-Suen Algorithm — Overview)

The Zhang-Suen thinning algorithm is a widely used iterative method:

1. The algorithm operates on a binary image (foreground = 1, background = 0).

2. In each iteration, it performs two sub-iterations:

• Sub-iteration 1: Marks boundary pixels for deletion based on specific
conditions (involving the pixel's 8-neighbours).

• Sub-iteration 2: Marks another set of boundary pixels for deletion

(complementary conditions).

3. Conditions ensure that a pixel is deleted only if:

• It is a boundary pixel (has at least one background neighbour).

• Deleting it does not break connectivity.

• It has 2–6 foreground neighbours.

• The transitions from 0→1 in the circular sequence of its 8 neighbours

equal 1.

4. The algorithm iterates until no more pixels can be deleted (convergence).

📊 Diagram / Table (if applicable)

Image Thinning Process:

Original Character "A" After Thinning (Skeleton)

┌──────────────┐ ┌──────────────┐
26 IP_54
 │ ████ │ │ █ │
│ ██ ██ │ │ █ █ │
│ ██ ██ │ │ █ █ │
│ ██ ██ │ ───→ │ █ █ │
│ ██████████ │ Thinning │ ███████ │
│ ██ ██ │ │ █ █ │
│ ██ ██ │ │ █ █ │
└──────────────┘ └──────────────┘
(Multi-pixel wide strokes) (Single-pixel skeleton)

Feature Extraction from Skeleton:

┌──────────────────────────────────────────────┐
│ ● = Endpoint (stroke termination) │
│ ★ = Branch point (junction of 3+ strokes) │
│ ○ = Loop (enclosed region) │
│ │
│ Character "A": 2 endpoints, 1 branch, │
│ 1 loop, 3 strokes │
│ Character "I": 2 endpoints, 0 branches, │
│ 0 loops, 1 stroke │
└──────────────────────────────────────────────┘

Thinning Properties:
┌──────────────────┬──────────────────────────┐
│ Property │ Preserved by Thinning? │
├──────────────────┼──────────────────────────┤
│ Connectivity │ ✓ Yes │
│ Topology │ ✓ Yes │
│ Shape structure │ ✓ Yes (approximately) │
│ Stroke width │ ✗ Normalized to 1 pixel │
│ Area │ ✗ Reduced significantly │
│ Endpoints/Junct. │ ✓ Yes │
└──────────────────┴──────────────────────────┘

💡 Example
In a handwriting recognition system, the word "Hello" is written with varying pen
pressure, resulting in strokes of different widths. Thinning reduces all strokes to single-
pixel width, normalizing the representation. From the skeleton of each character,
features are extracted: "H" has 4 endpoints, 2 branch points, 0 loops; "e" has 1 endpoint,
1 branch point, 1 loop; "l" has 2 endpoints, 0 branch points, 0 loops. These features are
then used by a classifier to identify each character.

🔚 Conclusion
Image thinning is an essential preprocessing step in character recognition that reduces
multi-pixel-wide character strokes to single-pixel-wide skeletons while preserving the
topological structure (connectivity, endpoints, branches, loops). This normalization
makes character recognition more robust to variations in font weight and writing style,
provides a compact representation for efficient feature extraction, and enables structural
analysis of character shapes. Algorithms like Zhang-Suen perform this iteratively by
carefully removing boundary pixels without breaking connectivity.

27 IP_55
❓ Question 10: Explain three different transformations used in
images. Give an example for each of them.
✅ Answer:
📖 Definition / Introduction
Image transformations are operations that modify an image's spatial coordinates, intensity values,
or domain representation for purposes like enhancement, analysis, compression, or geometric
correction. The three major categories are: Intensity (Point) Transformations, Spatial
(Geometric) Transformations, and Frequency (Domain) Transformations. Each operates on a
different aspect of the image.

📝 Detailed Explanation
Key Point 1: Intensity Transformation (Point Transformation)
An intensity transformation modifies the pixel values (grey levels) of an image
without changing their spatial positions. It operates on each pixel independently based
on a transfer function: s = T(r), where r is the input intensity and s is the output
intensity.

Types:

• Negative transformation: s = (L−1) − r (inverts intensities).

• Log transformation: s = c × log(1 + r) (compresses dynamic range).

• Power-law (Gamma) transformation: s = c × r^γ (contrast adjustment).

• Contrast stretching: Maps a narrow range of intensities to a wider range.

• Thresholding: Converts to binary — s = 0 if r < threshold, s = L−1 otherwise.

Example: In medical X-ray imaging, a log transformation is applied to enhance the

visibility of faint structures. A dark X-ray with most pixel values in the range [0, 50] is
transformed so that these low values are spread across [0, 200], making subtle details
visible to the radiologist.

Key Point 2: Spatial (Geometric) Transformation

A spatial transformation changes the position/location of pixels in the image. It maps
each pixel from its original coordinates (x, y) to new coordinates (x', y') using a
mapping function.

Types:

• Translation: Shifts the image by (tx, ty): x' = x + tx, y' = y + ty.

• Rotation: Rotates by angle θ: x' = x cosθ − y sinθ, y' = x sinθ + y cosθ.

28 IP_56
 • Scaling: Resizes: x' = sx × x, y' = sy × y.

• Affine transformation: Combines translation, rotation, scaling, and shearing.

• Perspective transformation: Simulates 3D perspective effects.

Example: In satellite image registration, a satellite image taken at time T₂ must be

aligned with a reference image from time T₁. An affine transformation (combination of
rotation by 2.3° and translation by (15, −8) pixels) is computed using control point
matching, and the T₂ image is warped to align precisely with T₁ for change detection
analysis.

Key Point 3: Frequency Domain Transformation

A frequency domain transformation converts the image from the spatial domain f(x,
y) to a frequency domain representation F(u, v) using a mathematical transform.
Processing is performed in the frequency domain, and the result is converted back.

Common transforms:

• Discrete Fourier Transform (DFT): Decomposes image into sinusoidal

frequency components.

• Discrete Cosine Transform (DCT): Uses cosine basis functions (real-valued).

• Wavelet Transform: Provides multi-resolution time-frequency analysis.

Steps: f(x,y) → Forward Transform → F(u,v) → Processing → F'(u,v) → Inverse

Transform → f'(x,y)

Example: In removing periodic noise from an image (e.g., interference patterns from
an electrical source), the image is converted to the frequency domain using DFT. The
periodic noise appears as distinct bright spots (spikes) in the frequency spectrum. A
notch-reject filter is applied to suppress these specific frequency components, and the
inverse DFT produces a clean, noise-free image.

📊 Diagram / Table (if applicable)

Three Image Transformations:

1. INTENSITY TRANSFORMATION:
Input pixel r → T(r) → Output pixel s (Position unchanged)

Example - Log Transform:

Dark X-ray Enhanced X-ray
[Dark, low contrast] → [Brighter, visible detail]
r = 20 → s = c×log(21) ≈ 150

2. SPATIAL (GEOMETRIC) TRANSFORMATION:

Input position (x,y) → T(x,y) → Output position (x',y') (Value unchanged)

Example - Rotation:
┌────┐ ╱╲
│ │ 30° → ╱ ╲
29 IP_57
 │ │ ╱ ╲
└────┘ ╲ ╱

3. FREQUENCY DOMAIN TRANSFORMATION:

f(x,y) → [DFT] → F(u,v) → [Filter] → F'(u,v) → [IDFT] → f'(x,y)

Example - Noise Removal:

[Image + periodic noise] → DFT → [Remove noise spikes] → IDFT → [Clean
image]

Comparison:
┌────────────────┬──────────────┬──────────────┬──────────────────┐
│ Transform Type │ What Changes │ What Stays │ Example │
├────────────────┼──────────────┼──────────────┼──────────────────┤
│ Intensity │ Pixel values │ Positions │ Log transform │
│ Spatial │ Positions │ Pixel values │ Rotation │
│ Frequency │ Domain repr. │ Information │ DFT filtering │
└────────────────┴──────────────┴──────────────┴──────────────────┘

💡 Example
(1) Intensity: A photograph taken in fog has very low contrast. Applying histogram
equalization (an intensity transformation) spreads the narrow range of grey levels
across the full 0–255 range, revealing hidden details in the fog.

(2) Spatial: A scanned document is slightly tilted at 5°. A rotation transformation of

−5° straightens the text, making it suitable for OCR processing.

(3) Frequency: An old scanned photo has regular horizontal line interference. After
applying DFT, the interference appears as vertical spikes in the frequency spectrum. A
band-reject filter removes these spikes, and the inverse DFT produces a clean image.

🔚 Conclusion
The three fundamental types of image transformations — intensity, spatial, and
frequency domain — each serve distinct purposes. Intensity transformations modify
pixel values for enhancement and contrast improvement. Spatial transformations modify
pixel positions for alignment, correction, and geometric operations. Frequency domain
transformations convert images into an alternate representation where certain operations
(like filtering periodic noise or compression) become more natural and efficient.
Together, they form the backbone of digital image processing.

30 IP_58
❓ Question 11: What do you mean by sampling and
quantization? Explain their functions in Digital Image
Processing (DIP).
✅ Answer:
📖 Definition / Introduction
Sampling and Quantization are the two fundamental steps in converting a continuous (analog)
image into a discrete (digital) image — a process called digitization. Sampling discretizes the
spatial coordinates, determining where we measure the image, while quantization discretizes the
amplitude (intensity) values, determining how precisely we record each measurement. Together,
they define the resolution and quality of a digital image.

📝 Detailed Explanation
Key Point 1: Sampling
Sampling is the process of selecting discrete spatial locations at which to measure the
image intensity. A continuous image f(x, y) — defined at every point in the x-y plane
— is converted into a discrete grid of M × N sample points.

Process:

• The continuous x-y plane is overlaid with a regular grid.

• At each grid intersection (xᵢ, yⱼ), the image intensity f(xᵢ, yⱼ) is recorded.

• The distance between adjacent sample points is the sampling interval (Δx, Δy).

• The sampling rate (samples per unit length) = 1/Δx.

Function in DIP:

• Determines the spatial resolution of the digital image — more samples = more
pixels = finer detail.

• Must satisfy the Nyquist criterion: sampling rate ≥ 2 × f_max (highest spatial
frequency) to avoid aliasing.

• Under-sampling causes aliasing — high-frequency details appear as false low-

frequency artefacts.

• Over-sampling wastes storage and bandwidth without adding useful information

beyond a certain point.

Effect on image quality:

• Higher sampling rate → more detail captured, larger file size.

31 IP_59
 • Lower sampling rate → loss of fine detail, potential aliasing, smaller file size.

Key Point 2: Quantization

Quantization is the process of mapping the continuous range of intensity values at each
sampled point to a finite set of discrete levels.

Process:

• The continuous intensity range [f_min, f_max] is divided into L discrete levels
(typically L = 2^k, where k is the number of bits per pixel).

• Each measured intensity value is rounded/mapped to the nearest discrete level.

• For 8-bit quantization: L = 256 levels (0 to 255).

• For 1-bit quantization: L = 2 levels (binary — 0 or 1).

Function in DIP:

• Determines the intensity resolution (grey-level resolution) — how many

distinct brightness levels the image can represent.

• More quantization levels → smoother tonal gradations, more natural appearance.

• Fewer levels → visible false contouring (banding) — smooth gradients appear

as discrete steps.

• The quantization error (difference between actual and quantized value)

introduces quantization noise.

Effect on image quality:

• More bits → better tonal quality, larger file size.

• Fewer bits → visible artefacts, smaller file size.

• The minimum acceptable quantization depends on image content — some

images look acceptable at 4–5 bits, while others need 8+ bits.

Key Point 3: Relationship Between Sampling and Quantization

Both sampling and quantization involve trade-offs between quality and storage:

Storage = M × N × k bits (M×N = spatial samples, k = bits per sample)

• For a fixed storage budget, increasing spatial resolution (more samples) requires
reducing intensity resolution (fewer bits), and vice versa.

• The optimal balance depends on the image content:

• Images with fine spatial detail benefit from higher sampling.

32 IP_60
 • Images with smooth gradients benefit from more quantization levels.

• ISO preference studies show that for natural images, increasing spatial
resolution (sampling) generally has more visible impact than increasing
quantization levels beyond 6–8 bits.

📊 Diagram / Table (if applicable)

Digitization Process:

Continuous Image f(x,y)

│
↓
┌─────────────┐ ┌──────────────┐ ┌─────────────────┐
│ SAMPLING │ ──→ │ QUANTIZATION │ ──→ │ Digital Image │
│ (Spatial │ │ (Intensity │ │ f[m,n] = matrix │
│ discretiz.) │ │ discretiz.) │ │ of integers │
└─────────────┘ └──────────────┘ └─────────────────┘

Sampling Effect:
High Sampling Rate Low Sampling Rate
● ● ● ● ● ● ● ● ● ● ● ●
● ● ● ● ● ● ● ●
● ● ● ● ● ● ● ● ● ● ● ●
● ● ● ● ● ● ● ●
(Fine detail preserved) (Detail lost, aliasing possible)

Quantization Effect:
8-bit (256 levels) 3-bit (8 levels) 1-bit (2 levels)
┌────────────────┐ ┌────────────────┐ ┌────────────────┐
│ Smooth gradient│ │ Visible steps │ │ Black or White │
│ ░░▒▒▓▓██████ │ │ ░░ ▒▒ ▓▓ ██ │ │ ░░░░ ████████ │
└────────────────┘ └────────────────┘ └────────────────┘
(No visible banding) (False contouring) (Binary image)

Storage vs. Quality Trade-off:

┌──────────┬──────────┬────────┬──────────────────┐
│ Sampling │ Quant. │Storage │ Quality │
│ (M × N) │ (k bits) │(bytes) │ │
├──────────┼──────────┼────────┼──────────────────┤
│ 256×256 │ 8 │ 64 KB │ Low res, smooth │
│ 512×512 │ 8 │ 256 KB │ Medium │
│ 1024×1024│ 8 │ 1 MB │ High res, smooth │
│ 1024×1024│ 1 │ 128 KB │ High res, binary │
│ 512×512 │ 4 │ 128 KB │ Medium, banding │
└──────────┴──────────┴────────┴──────────────────┘

💡 Example
Consider scanning a photograph at two settings:

• Setting A: 600 DPI (high sampling), 4-bit quantization (16 grey levels) —
captures fine spatial detail but shows visible banding in smooth sky regions.

• Setting B: 150 DPI (low sampling), 8-bit quantization (256 grey levels) —
smooth tonal gradations but blurry details like individual leaves on a tree.
33 IP_61
 Both produce similar file sizes but with different quality trade-offs. For most
photographs, Setting C: 300 DPI, 8-bit provides the best balance — adequate spatial
detail and smooth tonal transitions.

🔚 Conclusion
Sampling and quantization are the two pillars of image digitization. Sampling converts
the continuous spatial domain into a discrete grid of pixel locations, determining spatial
resolution and the ability to capture fine detail. Quantization converts continuous
intensity values into discrete levels, determining tonal quality and smoothness. Both
steps introduce potential artefacts — aliasing (from under-sampling) and false
contouring (from coarse quantization). The choice of sampling rate and quantization
levels involves a trade-off between image quality and storage/bandwidth requirements,
and must be tailored to the application's needs.

💡 More questions will be added as provided by Rishav.

🎓 Documente

34 IP_62
📘 [Link] 6th Semester — Exam Preparation
Author: Rishav Raj | Semester: 6th Sem | Subject: Image Processing — Mathematical
Preliminaries | Marks per Answer: 5–10 Marks

📌 How to Use This Document

• Each answer is structured for 5–10 marks university exam questions.
• Every answer covers 1-2 pages of content with proper depth.
• Format includes: Definition → Explanation → Key Points → Diagram/Example →
Conclusion

❓ Question 1: Compare one-dimensional and two-dimensional

DFT. What is DFT?
✅ Answer:
📖 Definition / Introduction
The Discrete Fourier Transform (DFT) is a mathematical tool that converts a discrete signal (or
image) from the spatial/time domain into its frequency domain representation. It decomposes a
signal into a sum of sinusoidal components at different frequencies. The 1D DFT is used for one-
dimensional signals (audio, time series), while the 2D DFT extends this to two-dimensional data
(images) by applying the transform along both rows and columns.

📝 Detailed Explanation
Key Point 1: What is DFT?
The DFT transforms a finite sequence of equally-spaced samples of a function into a
same-length sequence of equally-spaced samples of the discrete-time Fourier transform
(DTFT), which is a complex-valued function of frequency. The DFT is the most
important discrete transform because:

• It provides the frequency content of the signal/image.

• It is the basis for frequency-domain filtering, compression, and analysis.

• Efficient computation is possible via the Fast Fourier Transform (FFT)

algorithm (O(N log N) instead of O(N²)).

Key Point 2: 1D DFT

1 IP_63
 For a discrete sequence f(x) of length N, the 1D DFT is:

Forward Transform: F(u) = (1/N) Σ[x=0 to N−1] f(x) · e^(−j2πux/N), for u = 0, 1, ...,
N−1

Inverse Transform: f(x) = Σ[u=0 to N−1] F(u) · e^(j2πux/N), for x = 0, 1, ..., N−1

Where:

• f(x) = input signal in the spatial/time domain

• F(u) = output in the frequency domain (complex-valued)

• u = frequency variable

• N = total number of samples

• j = √(−1)

Key Point 3: 2D DFT

For a digital image f(x, y) of size M × N, the 2D DFT is:

Forward Transform: F(u, v) = (1/MN) Σ[x=0 to M−1] Σ[y=0 to N−1] f(x, y) ·

e^(−j2π(ux/M + vy/N))

Inverse Transform: f(x, y) = Σ[u=0 to M−1] Σ[v=0 to N−1] F(u, v) · e^(j2π(ux/M +

vy/N))

Where:

• f(x, y) = image in the spatial domain

• F(u, v) = image in the frequency domain

• (u, v) = frequency variables corresponding to spatial directions x and y

Key Point 4: Comparison — 1D DFT vs. 2D DFT

Feature 1D DFT 2D DFT

Input 1D sequence f(x) of length N 2D array f(x,y) of size M×N
Output 1D sequence F(u) of length N 2D array F(u,v) of size M×N
Variables One frequency variable u Two frequency variables u, v
Kernel e^(−j2πux/N) e^(−j2π(ux/M + vy/N))
Computation O(N²) or O(N log N) with FFT O(M²N²) or O(MN log(MN))
with FFT
Separability N/A Can be computed as row-wise
1D DFTs followed by column-
wise 1D DFTs

2 IP_64
Feature 1D DFT 2D DFT
Application Audio, 1D signal analysis Image processing, filtering
Spectrum 1D plot of magnitude vs. 2D magnitude spectrum (bright
frequency spots)
Symmetry F(u) = F*(N−u) (conjugate F(u,v) = F*(M−u, N−v)
symmetry)

📊 Diagram / Table (if applicable)

1D DFT:
f(x) = [f(0), f(1), f(2), ..., f(N-1)]
│
↓ DFT
F(u) = [F(0), F(1), F(2), ..., F(N-1)] (complex-valued)

Magnitude spectrum: |F(u)| plotted vs. u (1D plot)

2D DFT:
f(x,y) = ┌──────────────┐ F(u,v) = ┌──────────────┐
│ Image │ DFT │ Frequency │
│ (M × N) │ ────→ │ Spectrum │
│ │ │ (M × N) │
└──────────────┘ └──────────────┘

2D DFT as separable 1D DFTs:

f(x,y) → [1D DFT along rows] → intermediate → [1D DFT along columns] → F(u,v)

Magnitude Spectrum (2D):

┌──────────────────┐
│ │
│ ░░░░ │ Bright centre = low frequencies
│ ░░████░░ │ (DC component)
│ ░░████░░ │ Outer region = high frequencies
│ ░░░░ │ (edges, details)
│ │
└──────────────────┘

💡 Example
1D DFT: A 1D signal f(x) = {2, 3, 4, 4} (N=4). F(0) = (1/4)(2+3+4+4) = 3.25 (DC
component = average). F(1), F(2), F(3) capture the frequency content at harmonics 1, 2,
3.

2D DFT: A 256×256 greyscale image is transformed. The resulting 2D spectrum shows

a bright centre (DC component — average brightness) and diminishing values outward.
Sharp edges in the image correspond to high-frequency components (bright spots far
from centre).

3 IP_65
🔚 Conclusion
The DFT is a cornerstone of signal and image processing that reveals the frequency
content of discrete data. The 1D DFT handles one-dimensional signals with a single
frequency variable, while the 2D DFT extends to images with two frequency variables.
The 2D DFT is separable — it can be computed efficiently using successive 1D DFTs
along rows and columns. Both are made computationally practical by the FFT algorithm
and are fundamental to frequency-domain filtering, compression, and image analysis.

❓ Question 2: What is Fourier Transform? What are Fourier

Descriptors?
✅ Answer:
📖 Definition / Introduction
The Fourier Transform (FT) is a mathematical operation that decomposes a function (signal or
image) into its constituent frequencies, transforming data from the spatial/time domain to the
frequency domain. Fourier Descriptors are a specific application of the Fourier Transform used to
describe the shape of a closed boundary (contour) in a compact, frequency-based representation.
They are widely used in shape recognition and pattern matching.

📝 Detailed Explanation
Key Point 1: Fourier Transform
The continuous Fourier Transform of a function f(x) is defined as:

F(ω) = ∫[−∞ to +∞] f(x) · e^(−j2πωx) dx

The Inverse Fourier Transform recovers the original function:

f(x) = ∫[−∞ to +∞] F(ω) · e^(j2πωx) dω

For a 2D function f(x, y) (image):

F(u, v) = ∫∫ f(x, y) · e^(−j2π(ux + vy)) dx dy

Properties of Fourier Transform:

• Linearity: FT{af + bg} = aFT{f} + bFT{g}

• Translation: Shift in spatial domain = phase change in frequency domain

• Scaling: Compression in one domain = expansion in the other

• Rotation: Rotation in spatial domain = same rotation in frequency domain

4 IP_66
 • Convolution theorem: Convolution in spatial domain = multiplication in
frequency domain

• Parseval's theorem: Energy is preserved across domains

Key Point 2: Fourier Descriptors

Fourier Descriptors represent the shape of a 2D closed boundary using the coefficients
of its Fourier series expansion.

Process:

1. Extract the boundary of a shape as an ordered sequence of N coordinate pairs:

(x₀, y₀), (x₁, y₁), ..., (x_{N−1}, y_{N−1}).

2. Form a complex sequence: s(k) = x(k) + j·y(k), for k = 0, 1, ..., N−1.

3. Compute the DFT of s(k): a(u) = (1/N) Σ[k=0 to N−1] s(k) · e^(−j2πuk/N), for
u = 0, 1, ..., N−1

4. The coefficients a(u) are the Fourier Descriptors.

Properties of Fourier Descriptors:

• a(0) = centroid of the shape (position information).

• Low-frequency descriptors (a(1), a(2), ...) capture the overall shape (coarse
boundary).

• High-frequency descriptors capture fine details (small boundary variations,

noise).

• Using only the first P descriptors (P << N) gives a smoothed approximation of

the shape.

Key Point 3: Invariance Properties

Fourier Descriptors can be made invariant to geometric transformations:

• Translation invariance: Ignore a(0) (the DC component).

• Scale invariance: Divide all descriptors by |a(1)|.

• Rotation invariance: Use magnitudes |a(u)| instead of complex values.

• Starting point invariance: Use magnitudes |a(u)|.

These properties make Fourier Descriptors powerful for shape recognition regardless
of position, size, orientation, or starting point.

5 IP_67
📊 Diagram / Table (if applicable)
Fourier Transform Domains:

Spatial/Time Domain Frequency Domain

f(x) or f(x,y) F(ω) or F(u,v)
┌──────────────┐ FT ┌──────────────┐
│ Signal/ │ ────→ │ Amplitude │
│ Image │ │ & Phase at │
│ (position) │ ←──── │ each freq. │
└──────────────┘ IFT └──────────────┘

Fourier Descriptors:

Boundary Complex DFT Fourier

Extraction Sequence ───→ Descriptors
┌─────┐ s(k) = x(k) a(0), a(1), ...
│ ╱╲ │ + j·y(k) a(N-1)
│╱ ╲ │
│ ╲│ [N points] [N complex [Shape
│ ╱│ coefficients] description]
│╲ ╱ │
│ ╲╱ │
└─────┘

Shape Reconstruction with P descriptors:

All N descriptors P=10 P=5 P=2
┌────────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Exact │ │ Close │ │ Smooth │ │ Rough │
│ shape │ │ approx. │ │ approx. │ │ ellipse │
└────────────┘ └──────────┘ └──────────┘ └──────────┘

💡 Example
Consider recognizing the shape of a leaf. The leaf boundary is traced as 256 coordinate
pairs and converted to a complex sequence s(k). The DFT produces 256 Fourier
Descriptors. Using only the first 15 descriptors, the leaf shape can be reconstructed with
sufficient accuracy for species identification. The magnitudes |a(u)| / |a(1)| provide a
scale-invariant, rotation-invariant, translation-invariant shape signature that can be
compared against a database of known leaf shapes using Euclidean distance.

🔚 Conclusion
The Fourier Transform is a fundamental mathematical tool that converts signals and
images from the spatial/time domain to the frequency domain, enabling frequency-
based analysis, filtering, and compression. Fourier Descriptors extend this concept to
shape representation — encoding a boundary's geometry as frequency-domain
coefficients. By using only a few low-frequency descriptors, shapes can be compactly
represented and compared with invariance to translation, rotation, and scaling, making
Fourier Descriptors ideal for pattern recognition and shape matching applications.

6 IP_68
❓ Question 3: Show that the Fourier Transform of the
autocorrelation function of f(x) is the power spectrum |F(ω)|².
✅ Answer:
📖 Definition / Introduction
The relationship between the autocorrelation function and the power spectrum is one of the most
important results in signal processing, known as the Wiener-Khinchin theorem. It states that the
Fourier Transform of the autocorrelation of a function f(x) equals the power spectral density
(power spectrum) |F(ω)|², where F(ω) is the Fourier Transform of f(x). This theorem bridges
time/spatial domain correlation analysis with frequency domain energy distribution.

📝 Detailed Explanation
Key Point 1: Definitions
Fourier Transform of f(x): F(ω) = ∫[−∞ to +∞] f(x) · e^(−j2πωx) dx

Autocorrelation function of f(x): R(τ) = ∫[−∞ to +∞] f(x) · f*(x − τ) dx

(where f* denotes the complex conjugate of f)

Power Spectrum: P(ω) = |F(ω)|² = F(ω) · F*(ω)

Key Point 2: Proof

Step 1: Write the autocorrelation function:

R(τ) = ∫[−∞ to +∞] f(x) · f*(x − τ) dx

Step 2: Take the Fourier Transform of R(τ):

FT{R(τ)} = ∫[−∞ to +∞] R(τ) · e^(−j2πωτ) dτ

Step 3: Substitute the definition of R(τ):

FT{R(τ)} = ∫[−∞ to +∞] [∫[−∞ to +∞] f(x) · f*(x − τ) dx] · e^(−j2πωτ) dτ

Step 4: Change the order of integration:

FT{R(τ)} = ∫[−∞ to +∞] f(x) [∫[−∞ to +∞] f*(x − τ) · e^(−j2πωτ) dτ] dx

Step 5: In the inner integral, substitute u = x − τ, so τ = x − u, dτ = −du:

∫ f*(u) · e^(−j2πω(x−u)) (−du) = e^(−j2πωx) · ∫ f*(u) · e^(j2πωu) du

Step 6: Recognize the inner integral:

∫[−∞ to +∞] f*(u) · e^(j2πωu) du = [∫ f(u) · e^(−j2πωu) du]* = F*(ω)

7 IP_69
 (This is the complex conjugate of the Fourier Transform)

Step 7: Substitute back:

FT{R(τ)} = ∫[−∞ to +∞] f(x) · e^(−j2πωx) · F*(ω) dx

= F*(ω) · ∫[−∞ to +∞] f(x) · e^(−j2πωx) dx

= F*(ω) · F(ω)

Step 8: Therefore:

FT{R(τ)} = F(ω) · F(ω) = |F(ω)|²*

✅ Hence proved: The Fourier Transform of the autocorrelation function equals

the power spectrum.

Key Point 3: Significance

• The power spectrum |F(ω)|² tells us how much energy is present at each
frequency ω.

• The autocorrelation function R(τ) measures the self-similarity of a signal at

different lags τ.

• This theorem allows us to compute the power spectrum either directly from F(ω)
or indirectly through the autocorrelation — whichever is more convenient.

• It is the basis of spectral estimation and power spectral density analysis in

image and signal processing.

📊 Diagram / Table (if applicable)

Wiener-Khinchin Theorem:

f(x) ──────── FT ────────→ F(ω)

│ │
│ Autocorrelation │ |·|²
↓ ↓
R(τ) ──────── FT ────────→ |F(ω)|² = Power Spectrum
(Self-similarity (Energy distribution
at lag τ) across frequencies)

Proof Flow:
R(τ) = ∫ f(x)·f*(x-τ) dx

FT{R(τ)} = ∫∫ f(x)·f*(x-τ)·e^(-j2πωτ) dx dτ

= ∫ f(x)·e^(-j2πωx) dx · ∫ f*(u)·e^(j2πωu) du
╰──────────────────╯ ╰──────────────────╯
= F(ω) = F*(ω)

= F(ω) · F*(ω) = |F(ω)|² ■ (Q.E.D.)

8 IP_70
💡 Example
Consider a simple signal f(x) = cos(2πf₀x). Its Fourier Transform has impulses at ±f₀:
F(ω) = ½[δ(ω−f₀) + δ(ω+f₀)]. The power spectrum |F(ω)|² = ¼[δ(ω−f₀) + δ(ω+f₀)],
showing energy concentrated at frequency f₀. The autocorrelation R(τ) = ½cos(2πf₀τ),
and its Fourier Transform indeed gives the same power spectrum, confirming the
theorem.

🔚 Conclusion
The Wiener-Khinchin theorem establishes that the Fourier Transform of the
autocorrelation function of f(x) equals the power spectrum |F(ω)|². This fundamental
result connects the temporal/spatial self-similarity of a signal (autocorrelation) with its
frequency-domain energy distribution (power spectrum). The proof uses the
convolution-correlation properties of the Fourier Transform and the substitution
technique. This theorem is widely used in spectral analysis, noise characterization, and
image texture analysis.

❓ Question 4: Discuss briefly the usefulness of the Discrete

Cosine Transform (DCT). Explain the role of DCT in image
processing. What is Discrete Cosine Transform? What are its
applications?
✅ Answer:
📖 Definition / Introduction
The Discrete Cosine Transform (DCT) is a frequency-domain transform that expresses a sequence
of data points as a sum of cosine functions oscillating at different frequencies. Unlike the DFT, the
DCT produces only real-valued coefficients and has superior energy compaction properties for
natural images, making it the backbone of the JPEG image compression standard. It is one of the
most widely used transforms in image and video processing.

📝 Detailed Explanation
Key Point 1: What is DCT?
The 1D DCT of a sequence f(x) of length N is defined as:

F(u) = α(u) Σ[x=0 to N−1] f(x) · cos[(2x+1)uπ / 2N], for u = 0, 1, ..., N−1

where α(u) = √(1/N) for u = 0, and α(u) = √(2/N) for u ≠ 0.

9 IP_71
 The 2D DCT for an M × N image:

F(u,v) = α(u)α(v) Σ[x=0 to M−1] Σ[y=0 to N−1] f(x,y) · cos[(2x+1)uπ/2M] ·

cos[(2y+1)vπ/2N]

Key Properties:

• Uses only cosine basis functions (no sine component).

• Output is entirely real (no complex numbers, unlike DFT).

• The basis functions are orthogonal.

• F(0,0) is the DC coefficient (average intensity of the block).

• The transform is separable — can be computed as row-wise 1D DCTs followed

by column-wise 1D DCTs.

Key Point 2: Usefulness and Role in Image Processing

(a) Superior Energy Compaction:

• For typical natural images, the DCT concentrates most of the signal energy into
a few low-frequency coefficients (top-left corner of the coefficient matrix).

• The high-frequency coefficients are typically very small and can be quantized to
zero with minimal visual impact.

• DCT approaches the energy compaction efficiency of the optimal KLT

(Karhunen-Loève Transform) for Markov-1 sources, which closely model
natural images.

(b) Basis of JPEG Compression:

• JPEG divides the image into 8×8 blocks.

• Each block is transformed using the 2D DCT.

• The resulting 64 DCT coefficients are quantized (high-frequency coefficients

more aggressively).

• Quantized coefficients are entropy coded (Huffman/arithmetic coding).

• This achieves compression ratios of 10:1 to 50:1 with acceptable quality.

(c) Real-Valued Output:

• Unlike DFT which produces complex numbers, DCT output is purely real,
simplifying storage and computation.

(d) Reduced Boundary Effects:

10 IP_72
 • DCT implicitly assumes the signal is even-symmetric at boundaries, reducing
discontinuity artefacts (Gibbs phenomenon) that occur with DFT's periodic
extension.

Key Point 3: Applications of DCT

• Image compression: JPEG, MPEG (video compression).

• Video compression: H.264/AVC, H.265/HEVC (use integer approximations of

DCT).

• Audio compression: MP3, AAC (use Modified DCT — MDCT).

• Image watermarking: Embedding watermarks in DCT coefficients for

robustness.

• Feature extraction: DCT coefficients as features for face recognition, texture

classification.

• Image denoising: Thresholding high-frequency DCT coefficients.

• Image quality assessment: Comparing DCT coefficients of original and

processed images.

📊 Diagram / Table (if applicable)

DCT in JPEG Compression:

Input Image (M×N)

│
↓ Divide into 8×8 blocks
┌────────┐
│ 8 × 8 │ ──→ [2D DCT] ──→ DCT Coefficients
│ block │ ┌──────────────┐
└────────┘ │ DC │ ░ ░ ░ │ DC = average
│ ░ │ │ ░ = significant
│ ░ │ ≈ 0 │ Rest ≈ 0
│ ░ │ │ (discardable)
└──────────────┘
│
↓ Quantize + Encode
Compressed Output

DCT vs. DFT Comparison:

┌──────────────────┬───────────────┬───────────────┐
│ Property │ DCT │ DFT │
├──────────────────┼───────────────┼───────────────┤
│ Output type │ Real │ Complex │
│ Basis functions │ Cosines only │ Complex exp. │
│ Energy compaction│ Superior │ Good │
│ Boundary effects │ Minimal │ Gibbs effect │
│ Computation │ O(N log N) │ O(N log N) │
│ Standard usage │ JPEG, MPEG │ Filtering │
└──────────────────┴───────────────┴───────────────┘

11 IP_73
 DCT Basis Functions (8×8):
u=0: [constant — DC]
u=1: [one half-cycle cosine — lowest frequency]
u=2: [one full-cycle cosine]
...
u=7: [3.5 cycles cosine — highest frequency]

💡 Example
In JPEG compression of a photograph: An 8×8 pixel block with pixel values averaging
around 128 is DCT-transformed. The DC coefficient F(0,0) ≈ 128 (average). Most
energy is in F(0,0), F(0,1), F(1,0), and a few others. The remaining ~55 coefficients are
very small. After quantization (dividing by a quantization matrix and rounding), these
small coefficients become zero. Storing only the non-zero coefficients (about 10–15 out
of 64) achieves roughly 75–85% compression with imperceptible quality loss.

🔚 Conclusion
The Discrete Cosine Transform is one of the most practically important transforms in
image processing. Its superior energy compaction for natural images, real-valued
output, and minimal boundary effects make it ideal for lossy image compression
(JPEG). The DCT is also fundamental to video compression (MPEG, H.264), audio
compression (MP3), and various image analysis tasks. Its role as the core of the JPEG
standard alone makes it arguably the most widely deployed transform in digital media.

❓ Question 5: Explain Hough Transform and describe its

applications in image processing.
✅ Answer:
📖 Definition / Introduction
The Hough Transform is a feature extraction technique used in image processing to detect shapes
that can be described by a mathematical equation — particularly lines, circles, and ellipses. It
converts the problem of finding shapes in an image into a problem of finding peaks in a parameter
space (accumulator array). Originally proposed by Paul Hough in 1962 and later generalized, it is a
robust method that can detect shapes even when they are partially occluded or broken.

📝 Detailed Explanation
Key Point 1: Basic Concept — Hough Transform for Lines
A straight line in the image space (x-y plane) can be represented in normal (polar)
form:

12 IP_74
 ρ = x cos θ + y sin θ

where ρ is the perpendicular distance from the origin to the line, and θ is the angle of
the perpendicular with the x-axis.

Key Idea: Each point (xᵢ, yᵢ) in the image space maps to a sinusoidal curve in the
parameter space (ρ-θ plane). All points on the same straight line in the image will
produce sinusoidal curves that intersect at a single point (ρ₀, θ₀) in the parameter
space. This point identifies the line.

Key Point 2: Algorithm Steps

1. Edge Detection: Apply an edge detector (e.g., Canny) to the image to get edge
pixels.

2. Create Accumulator Array: Initialize a 2D array A(ρ, θ) with zeros, where ρ

ranges from −D to D (D = image diagonal) and θ from 0° to 180°.

3. Voting: For each edge pixel (xᵢ, yᵢ):

• For each θ value (0° to 180° in steps):
• Compute ρ = xᵢ cos θ + yᵢ sin θ

• Increment A(ρ, θ) by 1

4. Peak Detection: Find the cells in A(ρ, θ) with the highest values. Each peak
corresponds to a detected line.

5. Line Extraction: Map the peak (ρ₀, θ₀) back to the image space to draw the
detected line.

Key Point 3: Hough Transform for Circles

A circle is defined by: (x − a)² + (y − b)² = r²

Parameters: centre (a, b) and radius r → 3D parameter space.

If the radius r is known, the parameter space is 2D (a, b), and each edge point votes for a
circle of potential centres.

If r is unknown, all three parameters must be accumulated in a 3D space, which is

computationally expensive.

Key Point 4: Applications in Image Processing

• Line detection: Detecting lane markings in autonomous driving, detecting
horizon lines.

• Circle detection: Detecting coins, pupils (iris recognition), circular objects.

• Shape recognition: Detecting known geometric shapes in industrial inspection.

• Document analysis: Detecting table lines, page borders, ruled lines.

13 IP_75
 • Medical imaging: Detecting circular structures (cells, blood vessels).

• Computer vision: Vanishing point detection, calibration pattern detection.

• Barcode reading: Detecting straight lines in barcode patterns.

📊 Diagram / Table (if applicable)

Hough Transform for Lines:

Image Space (x, y) Parameter Space (ρ, θ)

┌──────────────────┐ ┌──────────────────┐
│ • │ │ │
│ • │ → │ ╲╱╲╱╲╱ │
│ • │ Voting │ ╲╱╲★╱╲╱ │ ★ = Peak
│ • │ │ ╲╱╲╱╲╱ │ (detected line)
│ • │ │ │
└──────────────────┘ └──────────────────┘
(Collinear edge points) (Sinusoids intersect at peak)

Each edge point (xᵢ, yᵢ) generates a sinusoid:

ρ = xᵢ cosθ + yᵢ sinθ (a curve in ρ-θ space)

Points on the same line → sinusoids pass through the same (ρ₀, θ₀)

Hough Transform Algorithm:

┌─────────┐ ┌──────────┐ ┌───────────┐ ┌──────────┐
│ Input │ → │ Edge │ → │Accumulator│ → │ Detected │
│ Image │ │Detection │ │ Voting │ │ Lines │
└─────────┘ └──────────┘ └───────────┘ └──────────┘

Hough for Circles (known radius r):

For each edge point (x,y):
centre (a,b) lies on a circle of radius r around (x,y)
→ vote for all (a,b) on this circle in parameter space

💡 Example
In an autonomous vehicle system, a camera captures a road scene. After edge
detection, the Hough Transform is applied to detect straight lines. The accumulator
shows strong peaks at approximately θ = 30° and θ = 150° (corresponding to the left
and right lane markings converging toward the vanishing point). Despite occlusions by
other vehicles and imperfect edges, the Hough Transform reliably detects the lanes
because it uses a global voting mechanism that tolerates gaps in the edge data.

🔚 Conclusion
The Hough Transform is a powerful and robust technique for detecting parameterized
shapes (lines, circles, ellipses) in images. Its voting-based approach makes it resilient to
noise, gaps, and partial occlusions. For line detection, it uses the polar representation (ρ,
θ) and finds peaks in the 2D accumulator array. For circles and more complex shapes,
the parameter space dimensionality increases. The Hough Transform is widely applied
14 IP_76
 in autonomous driving, document analysis, medical imaging, and industrial inspection,
making it one of the most practically important algorithms in computer vision.

❓ Question 6: Discuss global processing via Hough Transform.

Explain the concept of region growing and region splitting.
✅ Answer:
📖 Definition / Introduction
Global processing via Hough Transform refers to the use of the Hough Transform as a global
method for detecting geometric structures (like lines and curves) across the entire image, as
opposed to local neighbourhood-based methods. Region growing and region splitting are two
complementary image segmentation techniques — region growing builds regions by aggregating
similar pixels from seed points, while region splitting divides the image into smaller sub-regions
based on a homogeneity criterion.

📝 Detailed Explanation
Key Point 1: Global Processing via Hough Transform
The Hough Transform performs global processing because it considers all edge pixels
in the image simultaneously through a voting mechanism in the parameter space:

• Each edge pixel independently votes for all possible shapes (lines) passing
through it.

• A global accumulator array collects all votes from all pixels.

• The final result depends on the collective votes of all edge pixels, not just local
neighbourhood information.

Advantages of global approach:

• Can detect lines/shapes even when they are broken, noisy, or partially
occluded.

• Robust to local perturbations — a few missing or extra edge points have

minimal effect.

• Can detect multiple shapes simultaneously (multiple peaks in the accumulator).

Disadvantage:

• Computationally expensive for high-dimensional parameter spaces (circles,

ellipses).

15 IP_77
 • Peak detection can be challenging in noisy accumulator arrays.

The Hough Transform is thus a global-to-local method — it globally accumulates

evidence and then locally identifies peaks to extract specific shapes.

Key Point 2: Region Growing

Region growing is a segmentation technique that groups pixels into regions based on
similarity criteria, starting from one or more seed pixels.

Algorithm:

1. Select seed pixels (manually or automatically) that represent different regions.

2. For each seed, examine its neighbouring pixels (4-connected or 8-connected).

3. If a neighbour satisfies the similarity criterion (e.g., |intensity_neighbour −

mean_region| < threshold), add it to the region.

4. Update the region statistics (mean, variance) with the newly added pixel.

5. Repeat steps 2–4 until no more pixels can be added to any region.

6. Assign labels to unvisited pixels or merge small regions.

Similarity criteria include:

• Intensity difference: |f(x,y) − mean_region| < T

• Colour similarity, texture similarity.

• Statistical measures (variance within region < threshold).

Advantages: Simple, intuitive; produces connected regions; flexible

criteria. Disadvantages: Sensitive to seed selection and threshold; order-dependent.

Key Point 3: Region Splitting

Region splitting is a top-down segmentation approach that starts with the entire image
as a single region and recursively subdivides it into smaller sub-regions until each sub-
region satisfies a homogeneity criterion.

Algorithm (Quadtree-based splitting):

1. Start with the entire image as one region R.

2. Check if R satisfies the homogeneity predicate P(R) (e.g., variance <

threshold).

3. If P(R) = TRUE: R is homogeneous → do not split.

4. If P(R) = FALSE: R is not homogeneous → split R into four quadrants (Q₁,

16 IP_78
 Q₂, Q₃, Q₄).

5. Recursively apply steps 2–4 to each quadrant.

6. Stop when all sub-regions are homogeneous or reach minimum size.

Split and Merge (combined approach): After splitting, adjacent sub-regions that
satisfy the homogeneity predicate when combined are merged to produce larger,
meaningful regions. This is the split-and-merge algorithm.

Advantages: Systematic, no seed required; produces a quadtree data

structure. Disadvantages: Tends to produce blocky regions aligned to the quadtree grid;
merging step is needed.

📊 Diagram / Table (if applicable)

Global Processing via Hough Transform:
┌──────────────────────────────────────┐
│ All edge pixels vote globally │
│ │
│ Edge pixel 1 ──→ votes in (ρ,θ) │
│ Edge pixel 2 ──→ votes in (ρ,θ) │ Accumulator
│ Edge pixel 3 ──→ votes in (ρ,θ) │ ──→ Peaks = Lines
│ ... ──→ ... │
│ Edge pixel N ──→ votes in (ρ,θ) │
└──────────────────────────────────────┘

Region Growing:
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ S │ │ ░░░S░░ │ │ ░░░░░░░ │
│ │ → │ ░░░░░░ │ → │ ░░░░░░░ │
│ │ │ │ │ ░░░░░░░ │
└──────────────┘ └──────────────┘ └──────────────┘
S = seed pixel Grow from seed Region complete
(add similar (no more similar
neighbours) neighbours)

Region Splitting (Quadtree):

┌──────────────┐ ┌──────┬───────┐ ┌──────┬───────┐
│ │ │ R1 │ R2 │ │ R1 │R2a│R2b│
│ R (not │ → ├──────┼───────┤ → ├──────┼───┼───┤
│ homogeneous│ │ R3 │ R4 │ │ R3 │R2c│R2d│
└──────────────┘ └──────┴───────┘ └──────┴───┴───┘
Split into 4 R2 still not R2 split further
quadrants homogeneous

Comparison:
┌──────────────────┬────────────────┬────────────────┐
│ Feature │ Region Growing │ Region Splitting│
├──────────────────┼────────────────┼────────────────┤
│ Approach │ Bottom-up │ Top-down │
│ Starting point │ Seed pixels │ Entire image │
│ Direction │ Aggregation │ Subdivision │
│ Seed required? │ Yes │ No │
│ Region shape │ Irregular │ Rectangular │
│ Data structure │ Label map │ Quadtree │
└──────────────────┴────────────────┴────────────────┘

17 IP_79
💡 Example
Hough: In a satellite image, roads appear as broken straight lines due to tree cover. The
Hough Transform's global voting detects the roads despite gaps by finding peaks in the
accumulator.

Region Growing: In a medical ultrasound image, a seed is placed inside the liver. The
algorithm grows outward, adding pixels with similar grey levels, until the entire liver
region is segmented.

Region Splitting: In a landscape image, the entire image is split into quadrants. The sky
quadrant is homogeneous (uniform blue) and is not split further. The ground quadrant
has mixed textures and is split recursively until sub-regions contain homogeneous
patches (grass, road, buildings).

🔚 Conclusion
The Hough Transform provides global shape detection by accumulating evidence from
all edge pixels into a parameter space, making it robust to noise and gaps. Region
growing and region splitting offer complementary approaches to image segmentation —
region growing is a bottom-up approach that aggregates similar pixels from seeds, while
region splitting is a top-down approach that recursively subdivides the image. The
combined split-and-merge algorithm leverages the strengths of both, producing accurate
segmentations with clean boundaries.

❓ Question 7: Define 4-adjacency, 8-adjacency, and m-

adjacency. Explain m-connectivity among pixels. Define
connectivity. What is the difference between 8-connectivity and
m-connectivity?
✅ Answer:
📖 Definition / Introduction
In digital image processing, adjacency defines the spatial relationship between pixels that
determines when two pixels are considered "touching." Connectivity builds on adjacency to define
when pixels belong to the same connected component (region). The three main types of adjacency
— 4-adjacency, 8-adjacency, and m-adjacency (mixed adjacency) — each create different
connectivity relationships, with m-adjacency specifically designed to resolve ambiguities that arise
with 8-adjacency.

18 IP_80
📝 Detailed Explanation
Key Point 1: Connectivity
Connectivity between pixels is fundamental to defining regions, boundaries, and
components in a digital image. Two pixels are connected if:

1. They are adjacent (as defined by a specific adjacency type).

2. Their intensity values satisfy some similarity criterion (both belong to a set of
values V).

A connected component is a maximal set of pixels such that any two pixels in the set
can be connected by a path of adjacent, similar-valued pixels.

Key Point 2: 4-Adjacency

Two pixels p and q with values from a set V are 4-adjacent if q is in the 4-
neighbourhood N₄(p) of p:

• q is at position (x±1, y) or (x, y±1) relative to p.

• That is, q is directly above, below, left, or right of p.

4-adjacency defines the strictest connectivity — only horizontal and vertical neighbours
count.

Key Point 3: 8-Adjacency

Two pixels p and q with values from set V are 8-adjacent if q is in the 8-
neighbourhood N₈(p) of p:

• q is at any of the 8 surrounding positions (horizontal, vertical, or diagonal).

8-adjacency is more permissive — diagonal neighbours also count. However, it can

create ambiguous connections and multiple paths between pixels.

Key Point 4: m-Adjacency (Mixed Adjacency)

Two pixels p and q with values from set V are m-adjacent if:

(i) q is in N₄(p) — they are 4-adjacent, OR

(ii) q is in Nᴅ(p) (diagonal neighbour) AND the set N₄(p) ∩ N₄(q) contains no pixels
with values from V.

In simple terms: diagonal adjacency is allowed ONLY when there is no 4-adjacent

path through V-valued pixels between p and q. This eliminates the ambiguous multiple
paths that 8-adjacency creates.

Key Point 5: Difference Between 8-Connectivity and m-Connectivity

19 IP_81
Feature 8-Connectivity m-Connectivity
Definition Uses 8-adjacency (all 8 Uses m-adjacency (4-adj +
neighbours) restricted diagonal)
Ambiguity Can create ambiguous multiple Eliminates ambiguity — unique
paths paths
Diagonal links Always allowed Allowed only when no V-
valued 4-neighbours exist in
common
Path thickness Can produce thick (multi-pixel Produces thin (single-pixel
wide) paths wide) paths
Components May merge separate Correctly separates components
components
Example A 2×2 block of 1s: all 4 pixels Same block: only 4 m-
are mutually 8-connected connections (eliminating
(4×3/2=6 links) redundant diagonals)

📊 Diagram / Table (if applicable)

Adjacency Types for pixel p at (x,y):

4-Adjacency: 8-Adjacency: m-Adjacency:

N₄(p) N₈(p) (Conditional diagonal)

(x-1,y) (x-1,y-1)(x-1,y)(x-1,y+1)
│ \ | /
(x,y-1)─p─(x,y+1) (x,y-1)── p ──(x,y+1) Same as 8-adj BUT
│ / | \ diagonals only if
(x+1,y) (x+1,y-1)(x+1,y)(x+1,y+1) no V-valued common
4-neighbour exists

Ambiguity Example with V = {1}:

Image: 8-adjacency paths m-adjacency paths

┌───┬───┐ from a to d: from a to d:
│ a │ b │ = 1 a─b (4-adj) a─b (4-adj)
├───┼───┤ a─d (diagonal) │
│ c │ d │ = 1 a─c (4-adj) a─c (4-adj)
└───┴───┘ b─c (diagonal) │
All values=1 b─d (4-adj) b─d (4-adj)
c─d (4-adj) c─d (4-adj)

6 connections! 4 connections (no diagonals

(ambiguous paths) — cleaner, unambiguous)
a→d: via a-d, a-b-d, a→d: only a-b-d or a-c-d
a-c-d, a-b-c-d... (no direct a-d diagonal)

💡 Example
In a binary image with V = {1}, consider pixels p(1,0)=1, q(0,1)=1, r(1,1)=1:

20 IP_82
 • 8-adjacency: p and q are 8-adjacent (diagonally). p and r are 4-adjacent. q and r
are 4-adjacent. All three are mutually connected, forming a triangle with
multiple paths: p→q, p→r→q.

• m-adjacency: Check p and q: they are diagonal neighbours. But N₄(p) ∩ N₄(q)
= {r}, and r has value 1 ∈ V. So p and q are NOT m-adjacent. The only path
from p to q is p→r→q (through r). This eliminates the ambiguous diagonal
connection and produces a clean, single path.

🔚 Conclusion
Adjacency and connectivity are foundational concepts in digital image processing. 4-
adjacency is the most restrictive (only horizontal/vertical neighbours), 8-adjacency is
the most permissive (includes diagonals), and m-adjacency (mixed) provides a middle
ground by allowing diagonal connections only when they don't create ambiguity. m-
connectivity eliminates the multiple-path problem of 8-connectivity, producing unique,
unambiguous paths between pixels, which is essential for consistent region labelling,
boundary tracing, and component analysis.

❓ Question 8: What are the different methods for calculating

the distance between pixels? Explain with suitable examples.
What are the different distance measures used in digital
images?
✅ Answer:
📖 Definition / Introduction
Distance measures in digital image processing are used to quantify the "closeness" or "separation"
between two pixels in the image plane. Different distance metrics produce different results and are
used in various applications like morphological processing, region growing, nearest-neighbour
classification, and path planning. The three primary distance measures are Euclidean distance,
City-block (Manhattan) distance, and Chessboard (Chebyshev) distance.

📝 Detailed Explanation
Key Point 1: Properties of a Distance Function (Metric)
A function D(p, q) is a valid distance measure (metric) if for any pixels p, q, r:

1. Non-negativity: D(p, q) ≥ 0, and D(p, q) = 0 iff p = q.

2. Symmetry: D(p, q) = D(q, p).

3. Triangle inequality: D(p, r) ≤ D(p, q) + D(q, r).

21 IP_83
Key Point 2: Euclidean Distance (Dₑ)
The straight-line distance between two pixels p(x₁, y₁) and q(x₂, y₂):

Dₑ(p, q) = √[(x₁−x₂)² + (y₁−y₂)²]

• Produces circular equidistant contours (circles of equal distance from a point).

• Most accurate geometric distance.

• Computationally expensive due to square root.

• Can produce non-integer values.

Example: D_E between p(1, 2) and q(4, 6): D_E = √[(1−4)² + (2−6)²] = √[9 + 16] =
√25 = 5

Key Point 3: City-Block Distance / Manhattan Distance (D₄)

The sum of absolute differences of coordinates:

D₄(p, q) = |x₁−x₂| + |y₁−y₂|

• Produces diamond-shaped equidistant contours.

• Corresponds to 4-adjacency — the shortest path using only horizontal and

vertical moves.

• Computationally simple (no multiplication or square root).

• Always produces integer values for integer coordinates.

Example: D₄ between p(1, 2) and q(4, 6): D₄ = |1−4| + |2−6| = 3 + 4 = 7

Key Point 4: Chessboard Distance / Chebyshev Distance (D₈)

The maximum of absolute differences of coordinates:

D₈(p, q) = max(|x₁−x₂|, |y₁−y₂|)

• Produces square-shaped equidistant contours.

• Corresponds to 8-adjacency — the shortest path allowing diagonal moves.

• Named "chessboard" because it equals the number of king moves in chess.

• Computationally simple.

Example: D₈ between p(1, 2) and q(4, 6): D₈ = max(|1−4|, |2−6|) = max(3, 4) = 4

Key Point 5: Other Distance Measures

• Weighted Distance: Assigns different weights to horizontal/vertical vs.

22 IP_84
 diagonal moves (e.g., 1 for 4-adj, √2 for diagonal).

• Mahalanobis Distance: Accounts for correlations in data — used in

classification.

• Hausdorff Distance: Measures distance between two sets of points — used in

shape matching.

📊 Diagram / Table (if applicable)

Equidistant Contours (distance = 2 from centre pixel ●):

Euclidean (Dₑ=2): City-Block (D₄=2): Chessboard (D₈=2):

2
2 2 2 2 1 2 2 2 2 2 2
2 2 2 1 0 1 2 2 1 1 1 2
2 ● 2 2 1 2 2 1 ● 1 2
2 2 2 2 1 1 1 2
2 2 2 2 2 2 2 2
(Circle) (Diamond) (Square)

Example Computation (p=(1,2), q=(4,6)):

┌──────────────────┬───────────────────────────┬────────┐
│ Distance Metric │ Formula │ Result │
├──────────────────┼───────────────────────────┼────────┤
│ Euclidean (Dₑ) │ √[(1-4)²+(2-6)²] = √25 │ 5 │
│ City-Block (D₄) │ |1-4| + |2-6| = 3+4 │ 7 │
│ Chessboard (D₈) │ max(|1-4|,|2-6|) = max(3,4)│ 4 │
└──────────────────┴───────────────────────────┴────────┘

Relationship: D₈ ≤ Dₑ ≤ D₄ (always)

Distance contour map (D₄ distances from centre):

┌───┬───┬───┬───┬───┐
│ 4 │ 3 │ 2 │ 3 │ 4 │
├───┼───┼───┼───┼───┤
│ 3 │ 2 │ 1 │ 2 │ 3 │
├───┼───┼───┼───┼───┤
│ 2 │ 1 │ 0 │ 1 │ 2 │ ← Centre pixel = 0
├───┼───┼───┼───┼───┤
│ 3 │ 2 │ 1 │ 2 │ 3 │
├───┼───┼───┼───┼───┤
│ 4 │ 3 │ 2 │ 3 │ 4 │
└───┴───┴───┴───┴───┘

💡 Example
In a morphological dilation operation with a structuring element of radius 3:

• Using D₄ (city-block): The dilated region has a diamond shape.

• Using D₈ (chessboard): The dilated region has a square shape.

• Using Dₑ (Euclidean): The dilated region approximates a circle — most

23 IP_85
 geometrically accurate.

For p(3, 5) and q(6, 9):

• Dₑ = √(9+16) = 5.0

• D₄ = 3 + 4 = 7

• D₈ = max(3, 4) = 4

• Note: D₈ ≤ Dₑ ≤ D₄ always holds.

🔚 Conclusion
The three fundamental distance measures in digital images — Euclidean, City-block,
and Chessboard — each produce different distance values and equidistant contour
shapes (circles, diamonds, and squares respectively). The choice of distance measure
affects the results of many image processing operations including morphological
processing, region growing, and distance transforms. The relationship D₈ ≤ Dₑ ≤ D₄
always holds. Euclidean distance is most geometrically accurate, while City-block and
Chessboard distances are computationally simpler and produce integer results.

❓ Question 9: What is a unitary transform? Define and derive

the equations for Unitary Transform, Fourier Transform, and
Inverse Fourier Transform for both 1-D and 2-D images.
✅ Answer:
📖 Definition / Introduction
A unitary transform is a linear transform whose transformation matrix is unitary — meaning its
inverse equals its conjugate transpose. Unitary transforms preserve the inner product (and hence
the energy/norm) of the signal, making them fundamental in signal and image processing. The
Fourier Transform is a specific example of a unitary transform. Understanding these transforms in
both 1D and 2D forms is essential for frequency-domain image processing.

📝 Detailed Explanation
Key Point 1: Unitary Transform
A transform matrix A of size N × N is unitary if:

A · Aᴴ = Aᴴ · A = Iₙ

where Aᴴ is the conjugate transpose (Hermitian transpose) of A, and Iₙ is the N×N

24 IP_86
 identity matrix.

This means: A⁻¹ = Aᴴ — the inverse is simply the conjugate transpose.

Properties of Unitary Transforms:

• Energy preservation: ||Ax||² = ||x||² (Parseval's theorem).

• Orthonormal rows/columns: The rows (and columns) of A are orthonormal

vectors.

• If A is real: A unitary matrix becomes an orthogonal matrix (A⁻¹ = Aᵀ).

1D Unitary Transform: Given a vector f = [f(0), f(1), ..., f(N−1)]ᵀ, the forward
transform is:

F=A·f

and the inverse transform is:

f = Aᴴ · F = A⁻¹ · F

In element form: F(u) = Σ[x=0 to N−1] a(u, x) · f(x), where a(u, x) are elements of A.

2D Unitary Transform: For an image matrix f of size M × N:

F = A · f · Bᵀ

where A (M×M) and B (N×N) are unitary matrices. The inverse is:

f = Aᴴ · F · (Bᵀ)ᴴ = Aᴴ · F · B*

Key Point 2: 1D Fourier Transform (Derivation)

The DFT is a unitary transform with specific kernel functions.

Forward 1D DFT: Define the transform kernel: a(u, x) = (1/√N) · e^(−j2πux/N)

Then: F(u) = (1/√N) Σ[x=0 to N−1] f(x) · e^(−j2πux/N), for u = 0, 1, ..., N−1

Inverse 1D DFT: Since A is unitary (A⁻¹ = Aᴴ), the inverse kernel is:

a*(u, x) = (1/√N) · e^(+j2πux/N)

f(x) = (1/√N) Σ[u=0 to N−1] F(u) · e^(j2πux/N), for x = 0, 1, ..., N−1

Proof of Unitarity: Let W = e^(−j2π/N). Then A(u,x) = (1/√N) W^(ux).

[Aᴴ · A](x₁, x₂) = (1/N) Σ[u=0 to N−1] W^(−ux₁) · W^(ux₂) = (1/N) Σ[u] W^(u(x₂−x₁))

= δ(x₁ − x₂) (equals 1 if x₁=x₂, 0 otherwise) → Aᴴ · A = I ✓

25 IP_87
Key Point 3: 2D Fourier Transform (Derivation)
For an image f(x, y) of size M × N, the 2D DFT is derived as a separable extension of
the 1D DFT.

Forward 2D DFT:

F(u, v) = (1/√MN) Σ[x=0 to M−1] Σ[y=0 to N−1] f(x,y) · e^(−j2π(ux/M + vy/N))

This is separable: F(u, v) = (1/√M) Σ[x] {(1/√N) Σ[y] f(x,y) · e^(−j2πvy/N)} ·

e^(−j2πux/M)

= 1D DFT along columns (inner sum), then 1D DFT along rows (outer sum).

Inverse 2D DFT:

f(x, y) = (1/√MN) Σ[u=0 to M−1] Σ[v=0 to N−1] F(u,v) · e^(j2π(ux/M + vy/N))

In matrix form: F = A_M · f · A_Nᵀ (forward), f = A_Mᴴ · F · A_N* (inverse)

where A_M and A_N are the M×M and N×N DFT matrices respectively.

📊 Diagram / Table (if applicable)

Unitary Transform Framework:

1D: f ──[A]──→ F F ──[Aᴴ]──→ f (A·Aᴴ = I)

2D: f ──[A·f·Bᵀ]──→ F F ──[Aᴴ·F·B*]──→ f

DFT as Unitary Transform:

Forward (1D): Inverse (1D):

F(u) = (1/√N) Σ f(x)·W^(ux) f(x) = (1/√N) Σ F(u)·W^(-ux)
where W = e^(-j2π/N) (just replace W with W*)

Forward (2D): Inverse (2D):

F(u,v) = (1/√MN) Σ_x Σ_y f(x,y) = (1/√MN) Σ_u Σ_v
f(x,y)·e^(-j2π(ux/M+vy/N)) F(u,v)·e^(j2π(ux/M+vy/N))

Separability of 2D DFT:
┌──────────┐ ┌──────────┐ ┌──────────┐
│ f(x,y) │ → │ 1D DFT │ → │ 1D DFT │ → F(u,v)
│ (Image) │ │ along │ │ along │
└──────────┘ │ columns │ │ rows │
└──────────┘ └──────────┘

Summary Table:
┌──────────────────┬────────────────────────────┬────────────────────────────┐
│ Transform │ Forward │ Inverse │
├──────────────────┼────────────────────────────┼────────────────────────────┤
│ 1D Unitary │ F = A·f │ f = Aᴴ·F │
│ 2D Unitary │ F = A·f·Bᵀ │ f = Aᴴ·F·B* │
│ 1D DFT │ F(u)=(1/√N)Σf(x)W^(ux) │ f(x)=(1/√N)ΣF(u)W^(-ux) │
│ 2D DFT │ Separable: rows then cols │ Separable: rows then cols │
└──────────────────┴────────────────────────────┴────────────────────────────┘

26 IP_88
💡 Example
For N = 4, the DFT matrix is:

A = (1/2) × [1, 1, 1, 1; 1, −j, −1, j; 1, −1, 1, −1; 1, j, −1, −j]

Verify unitarity: A · Aᴴ = I₄ ✓

For f = [1, 2, 3, 4]ᵀ: F = A · f = [5, −1+j, −1, −1−j]ᵀ (after scaling).

Energy check (Parseval): ||f||² = 1+4+9+16 = 30, ||F||² = 25+2+1+2 = 30 ✓

🔚 Conclusion
A unitary transform is characterized by its transformation matrix satisfying A⁻¹ = Aᴴ,
which ensures energy preservation (Parseval's theorem). The Fourier Transform is the
most important unitary transform in image processing, with its kernel being complex
exponentials. The 1D DFT transforms N-point signals with O(N²) operations (or O(N
log N) with FFT), and the 2D DFT extends this to images through separability —
applying 1D DFTs sequentially along rows and columns. The inverse transforms use
conjugated kernels to recover the original signal/image.

❓ Question 10: What is Hadamard Transform? What is Walsh

Transform? What is Piecewise Linear Transformation? What is
Hotelling Transformation?
✅ Answer:
📖 Definition / Introduction
The Hadamard Transform, Walsh Transform, Piecewise Linear Transformation, and
Hotelling Transformation are four distinct techniques used in image processing for different
purposes. The first two are frequency-domain transforms using rectangular basis functions;
piecewise linear transformation is an intensity mapping technique; and the Hotelling Transform is a
statistical decorrelation tool. Each plays a specific role in image analysis, enhancement, and
compression.

📝 Detailed Explanation
Key Point 1: Hadamard Transform
The Hadamard Transform is a non-sinusoidal, orthogonal transform that uses a square
wave basis functions with values of +1 and −1 only.

The N × N Hadamard matrix Hₙ is defined recursively:

27 IP_89
 H₁ = [1]

Hₙ = (1/√N) × [H_{N/2} H_{N/2} ; H_{N/2} −H_{N/2}]

Example: H₂ = (1/√2) × [1, 1; 1, −1]

H₄ = (1/2) × [1,1,1,1; 1,−1,1,−1; 1,1,−1,−1; 1,−1,−1,1]

Properties:

• Basis functions are rectangular waves (only +1, −1 values).

• Computationally very fast — no multiplications, only additions and

subtractions.

• The transform matrix is symmetric and orthogonal: H = Hᵀ = H⁻¹.

• Rows are ordered by "sequency" (number of sign changes) in the Walsh-ordered

version.

Applications: Fast image processing, pattern recognition, error correction codes,

spread-spectrum communications.

Key Point 2: Walsh Transform

The Walsh Transform is closely related to the Hadamard Transform — it uses the
same basis functions but the rows are ordered by sequency (number of zero-crossings
per row, analogous to frequency).

• In the Hadamard matrix, rows are in natural (Hadamard) order.

• In the Walsh matrix, rows are reordered by increasing sequency (number of

sign changes).

Walsh function W(u, x) for N-point sequences:

W(u, x) = (1/√N) × Π[i=0 to n−1] (−1)^(bᵢ(u) · bₙ₋₁₋ᵢ(x))

where bᵢ are the bit values of the binary representation.

Key difference from Hadamard:

• Same basis functions, different ordering.

• Walsh ordering places rows in increasing "frequency" order, making the

transform more analogous to the DFT.

• Provides a natural low-frequency to high-frequency ordering.

Applications: Image compression, spectral analysis with rectangular basis functions,

communication systems.

28 IP_90
Key Point 3: Piecewise Linear Transformation
Piecewise linear transformation is an intensity transformation technique where the
transfer function T(r) is composed of multiple straight-line segments rather than a
single mathematical function.

The input intensity range [0, L−1] is divided into segments, and each segment has its
own linear mapping:

s = aᵢ · r + bᵢ, for rᵢ ≤ r < rᵢ₊₁

Common types:

• Contrast stretching: Expand a narrow intensity range to the full range.

• Intensities below r₁ → compressed toward 0 (dark).

• Intensities between r₁ and r₂ → stretched (high slope).

• Intensities above r₂ → compressed toward L−1 (bright).

• Intensity-level slicing (highlighting): Highlight a specific range of intensities.

• Values in the range of interest → mapped to a high value.

• Other values → kept same or mapped to a low value.

• Bit-plane slicing: Extract specific bit planes of the image.

Advantage: Highly flexible — can implement any desired input-output

mapping. Disadvantage: Requires user-specified breakpoints, which may be image-
dependent.

Key Point 4: Hotelling Transformation (KLT / PCA)

The Hotelling Transformation (also known as Karhunen-Loève Transform (KLT)
or Principal Component Analysis (PCA)) is a data-dependent transform that
decorrelates the data by projecting it onto the eigenvectors of its covariance matrix.

Steps:

1. Compute the mean vector m of the data: m = (1/N) Σ xᵢ

2. Compute the covariance matrix C: C = (1/N) Σ (xᵢ − m)(xᵢ − m)ᵀ

3. Compute the eigenvalues λ₁ ≥ λ₂ ≥ ... ≥ λₙ and eigenvectors e₁, e₂, ..., eₙ of C.

4. Form the transformation matrix A = [e₁, e₂, ..., eₙ]ᵀ (eigenvectors as rows).

5. Transform: y = A · (x − m)

Properties:

29 IP_91
 • The transformed components are uncorrelated (covariance matrix becomes
diagonal).

• Optimal energy compaction — eigenvalues represent the variance (energy) in

each component.

• Components are ordered by decreasing energy/importance.

• Keeping only the first P components (P << n) gives the best P-dimensional
approximation.

Applications: Dimensionality reduction, face recognition (Eigenfaces), image

compression, multi-spectral image analysis, feature extraction.

📊 Diagram / Table (if applicable)

Hadamard Matrix H₄: Walsh Matrix (sequency order):
┌────┬────┬────┬────┐ ┌────┬────┬────┬────┐
│ +1 │ +1 │ +1 │ +1 │ seq=0 │ +1 │ +1 │ +1 │ +1 │ seq=0
├────┼────┼────┼────┤ ├────┼────┼────┼────┤
│ +1 │ -1 │ +1 │ -1 │ seq=3 │ +1 │ +1 │ -1 │ -1 │ seq=1
├────┼────┼────┼────┤ ├────┼────┼────┼────┤
│ +1 │ +1 │ -1 │ -1 │ seq=1 │ +1 │ -1 │ -1 │ +1 │ seq=2
├────┼────┼────┼────┤ ├────┼────┼────┼────┤
│ +1 │ -1 │ -1 │ +1 │ seq=2 │ +1 │ -1 │ +1 │ -1 │ seq=3
└────┴────┴────┴────┘ └────┴────┴────┴────┘
(Natural order) (Ordered by sequency ↑)

Piecewise Linear Transformation:

Output (s)
L-1 ┤ ╱─────────
│ ╱
│ ╱ ← High slope (stretching)
│ ╱
│ ─────╱ ← Low slope (compression)
0 ┤─────╱
└──┬──────┬──────┬──→ Input (r)
r₁ r₂ L-1

Hotelling Transform:
Original Data Transformed Data
(correlated) (decorrelated)
y₂ ↑ ●●● y₂' ↑
│ ●●●● │ ●
│●●●●●● PCA │ ● ● ●
│●●●●● ────→ │ ● ● ● ● ●
│●●●● │ ● ● ●
│●●● │ ●
└──────→ y₁ └──────────→ y₁'
(Tilted cloud) (Aligned to axes)

Comparison:
┌──────────────────┬──────────────┬──────────────────┐
│ Transform │ Basis │ Key Feature │
├──────────────────┼──────────────┼──────────────────┤
│ Hadamard │ +1, -1 waves │ Fast, no multiply│
│ Walsh │ +1, -1 waves │ Sequency ordered │
│ Piecewise Linear │ Line segments│ Flexible mapping │

30 IP_92
 │ Hotelling (PCA) │ Eigenvectors │ Optimal compaction│
└──────────────────┴──────────────┴──────────────────┘

💡 Example
Hadamard/Walsh: Transform a 4-pixel row [150, 100, 80, 120] using H₄ — the result
separates average (DC) from detail components using only additions/subtractions.

Piecewise Linear: An under-exposed photograph has most pixels in range [30, 80]. A
piecewise linear function maps [0, 30]→[0, 10], [30, 80]→[10, 245], [80, 255]→[245,
255], stretching the useful range dramatically.

Hotelling: In face recognition (Eigenfaces), a dataset of 100 face images (each 100×100
= 10,000 pixels) is treated as 10,000-dimensional vectors. PCA finds the top 50
eigenvectors (eigenfaces) that capture 95% of the variance, reducing each face to just 50
numbers while preserving recognition accuracy.

🔚 Conclusion
The Hadamard and Walsh Transforms provide computationally efficient frequency
analysis using rectangular basis functions (+1, −1), differing only in row ordering.
Piecewise linear transformation offers flexible, user-defined intensity mapping for
image enhancement through multiple linear segments. The Hotelling Transform
(PCA/KLT) provides statistically optimal decorrelation and dimensionality reduction by
projecting data onto eigenvectors of the covariance matrix. Each serves a distinct
purpose: Hadamard/Walsh for fast transform-based processing, piecewise linear for
targeted enhancement, and Hotelling for optimal compression and feature extraction.

❓ Question 11: What is Contrast Stretching? Differentiate

between low-contrast images and enhanced images.
✅ Answer:
📖 Definition / Introduction
Contrast stretching (also called normalization or min-max stretching) is an intensity
transformation technique that expands the narrow range of intensity values in a low-contrast image
to span the full available range (typically 0 to 255 for 8-bit images). It improves the visual quality
and information content of images where pixel values are clustered in a small portion of the
intensity range. Understanding the difference between low-contrast and enhanced images is
essential for effective image processing.

31 IP_93
📝 Detailed Explanation
Key Point 1: What is Contrast Stretching?
Contrast stretching works by applying a linear or piecewise linear transformation that
maps the existing intensity range [r_min, r_max] to the full range [0, L−1]:

Simple Linear Stretching: s = [(r − r_min) / (r_max − r_min)] × (L − 1)

where r is the input intensity, s is the output intensity, and L = 256 for 8-bit.

Piecewise Linear Contrast Stretching: Uses breakpoints (r₁, s₁) and (r₂, s₂) to define
three segments:

• [0, r₁] → [0, s₁]: Compression of dark values (low slope).

• [r₁, r₂] → [s₁, s₂]: Stretching of mid-range values (high slope).

• [r₂, L−1] → [s₂, L−1]: Compression of bright values (low slope).

Thresholding (extreme case): When r₁ = r₂ = m and s₁ = 0, s₂ = L−1, the function

becomes a step function — binary thresholding.

Key Point 2: Why Images Have Low Contrast

Low contrast occurs when:

• Poor illumination during image acquisition (too dark or too bright).

• Limited dynamic range of the sensor.

• Atmospheric effects (fog, haze, underwater photography).

• Incorrect exposure settings in the camera.

• Low bit-depth imaging.

The result: pixel values are clustered in a narrow band, and the image appears washed
out, flat, or dull.

Key Point 3: Differences Between Low-Contrast and Enhanced Images

Feature Low-Contrast Image Enhanced (Contrast-

Stretched) Image
Intensity range Narrow (e.g., 50–150 out of 0– Full range (0–255)
255)
Histogram Concentrated in a small region Spread across the entire range
Visual appearance Dull, flat, washed out, grey Vivid, sharp, clear
Detail visibility Fine details are hard to Details are clearly visible
distinguish
Dynamic range Under-utilized Fully utilized
32 IP_94
Feature Low-Contrast Image Enhanced (Contrast-
Stretched) Image
Information content Same information, poorly Same information, well
displayed displayed
Brightness May appear too dark or too Balanced brightness
bright
Entropy Lower (less perceived Higher (more perceived
information) information)
Dark regions Almost indistinguishable Well separated, distinct shades
(clustered near 0 or some value)
Bright regions Similarly clustered Well separated, distinct shades

📊 Diagram / Table (if applicable)

Contrast Stretching Transfer Function:

Output (s)
255 ┤ ╱─────────
│ ╱
│ ╱ ← slope > 1 (stretching)
│ ╱
│ ╱
s₂ ┤ - - - - - - - -╱
│ ╱
│ ╱
s₁ ┤ - - - - - -╱
│ ╱╱ ← slope < 1 (compression)
0 ┤────────╱╱
└──┬────┬─────┬──────→ Input (r)
0 r₁ r₂ 255

Histogram Comparison:

Low-Contrast Image: Enhanced Image:

Frequency Frequency
│ │
│ █████ │ █ █ █ █
│ ███████ │ ██ ██ ██ ██
│ █████████ │ ██ ██ ██ ██
│ █████████ │ ███ ███ ███ ███
└──────────────── Intensity └──────────────── Intensity
0 50 100 150 255 0 50 100 150 255
(Narrow cluster) (Spread across full range)

Simple Linear Stretching Formula:

┌──────────────────────────────────────────────────┐
│ s = [(r - r_min) / (r_max - r_min)] × 255 │
│ │
│ Example: r_min=60, r_max=180 │
│ r=60 → s = 0 │
│ r=120 → s = (60/120)×255 = 127.5 ≈ 128 │
│ r=180 → s = 255 │
└──────────────────────────────────────────────────┘

33 IP_95
💡 Example
A photograph taken in heavy fog has all pixel values in the range [80, 160] — the image
looks uniformly grey with no discernible details. Applying contrast stretching:

• s = [(r − 80) / (160 − 80)] × 255 = [(r − 80) / 80] × 255

• Pixel with r = 80 → s = 0 (black)

• Pixel with r = 120 → s = 127.5 (mid-grey)

• Pixel with r = 160 → s = 255 (white)

The stretched image now uses the full 0–255 range, revealing details previously hidden
in the narrow grey band. Trees, buildings, and roads that were barely visible in the
foggy image become clearly distinguishable.

🔚 Conclusion
Contrast stretching is a simple but effective intensity transformation that maps a narrow
range of pixel values to the full dynamic range, dramatically improving the visual
quality of low-contrast images. Low-contrast images have narrow histograms and
appear flat and dull, while enhanced images have spread-out histograms and display
vivid, clearly distinguishable details. The technique preserves the image's information
content while improving its presentation, making it one of the most commonly used
enhancement operations in digital image processing.

💡 More questions will be added as provided by Rishav.

🎓 Documen

34 IP_96
📘 [Link] 6th Semester — Exam Preparation
Author: Rishav Raj | Semester: 6th Sem | Subject: Image Processing — Image Enhancement |
Marks per Answer: 5–10 Marks

📌 How to Use This Document

• Each answer is structured for 5–10 marks university exam questions.
• Every answer covers 1-2 pages of content with proper depth.
• Format includes: Definition → Explanation → Key Points → Diagram/Example →
Conclusion

❓ Question 1: What are median filters? What is image

enhancement? What is image restoration? Differentiate
between image enhancement and image restoration. What are
image negatives? What is the equation for obtaining a negative
image? Explain the operation of a median filter. (Numerical on
median filter). Explain gray-level slicing.
✅ Answer:
📖 Definition / Introduction
Image enhancement improves the visual appearance of an image subjectively, while image
restoration recovers a degraded image objectively using a mathematical model. Median filters are
non-linear spatial filters that replace each pixel with the median of its neighbourhood, excelling at
removing salt-and-pepper noise. Image negatives reverse the intensity scale, and grey-level slicing
highlights a specific intensity range while suppressing others.

📝 Detailed Explanation
Key Point 1: Image Enhancement vs. Image Restoration
Image Enhancement: The process of manipulating an image so that the result is more
suitable for a specific application than the original. It is subjective — there is no unique
"correct" output. Techniques include contrast stretching, histogram equalization,
sharpening, and smoothing.

Image Restoration: The process of recovering an image that has been degraded by a
known or estimated degradation function. It is objective — based on
mathematical/statistical models of the degradation process. Techniques include inverse
filtering, Wiener filtering, and constrained least-squares filtering.
1 IP_97
Feature Image Enhancement Image Restoration
Goal Improve visual quality Recover original image
Approach Subjective, heuristic Objective, model-based
Knowledge needed None about degradation Degradation model required
Evaluation Visual (human judgement) Mathematical (MSE, PSNR)
Techniques Histogram eq., sharpening Wiener filter, inverse filter
Result May not look like original Approximates the original

Key Point 2: Image Negatives

An image negative (also called complement) reverses the grey levels of an image —
dark becomes light and vice versa.

Equation: For an image with intensity range [0, L−1]:

s = (L − 1) − r

where r is the input intensity and s is the output intensity.

For an 8-bit image (L = 256): s = 255 − r

• r = 0 (black) → s = 255 (white)

• r = 255 (white) → s = 0 (black)

Application: Enhancing white/light details embedded in dark regions (e.g.,

mammogram analysis where tumours appear lighter in the negative).

Key Point 3: Median Filter — Operation

The median filter is a non-linear spatial filter that replaces each pixel value with the
median of the intensity values in its neighbourhood.

Algorithm:

1. Define a window (typically 3×3, 5×5, or 7×7) centred on pixel (x, y).

2. Extract all pixel values within the window.

3. Sort the values in ascending order.

4. Replace the centre pixel with the middle value (median) of the sorted list.

5. Move the window to the next pixel and repeat.

Properties:

• Excellent at removing salt-and-pepper (impulse) noise while preserving edges.

2 IP_98
 • Does NOT blur edges (unlike mean/averaging filters).

• The output value is always an existing pixel value (no new values created).

• For an n×n window, the median is at position (n²+1)/2 in the sorted list.

Key Point 4: Numerical on Median Filter

Given a 3×3 neighbourhood:

┌─────┬─────┬─────┐
│ 10 │ 15 │ 20 │
├─────┼─────┼─────┤
│ 25 │ 200 │ 30 │ ← centre pixel = 200 (noise spike)
├─────┼─────┼─────┤
│ 22 │ 18 │ 28 │
└─────┴─────┴─────┘

Sorted values: {10, 15, 18, 20, 22, 25, 28, 30, 200}
Median = 5th value = 22
The noisy pixel 200 is replaced by 22 — noise effectively removed!
Key Point 5: Grey-Level Slicing
Grey-level slicing (intensity-level slicing) highlights a specific range of grey levels in
an image. Two approaches:

(a) Without background preservation:

• Pixels in the range [A, B] → set to a high value (e.g., 255).

• All other pixels → set to a low value (e.g., 0).

• Result: Binary-like image highlighting the range.

(b) With background preservation:

• Pixels in the range [A, B] → set to a high value (e.g., 255).

• All other pixels → remain at their original values.

• Result: Highlighted range with background intact.

Application: Highlighting specific features like water bodies (specific grey range) in
satellite imagery, or specific tissue types in medical images.

📊 Diagram / Table (if applicable)

Image Negative:
Input: 0 ──────────────── 255 Output: 255 ──────────────── 0
Black Grey White White Grey Black
s = 255 - r (linear reversal)

3 IP_99
 Median Filter vs. Mean Filter:
┌──────────────┬───────────────────┬───────────────────┐
│ Feature │ Median Filter │ Mean Filter │
├──────────────┼───────────────────┼───────────────────┤
│ Type │ Non-linear │ Linear │
│ Noise type │ Salt & pepper │ Gaussian noise │
│ Edge preserv.│ Good │ Poor (blurs edges)│
│ New values? │ No │ Yes (averages) │
│ Speed │ Slower (sorting) │ Faster │
└──────────────┴───────────────────┴───────────────────┘

Grey-Level Slicing:
(a) Without background: (b) With background:
s ↑ s ↑
L ┤ ████ L ┤ ████
│ ████ │ ╱████╲
│ ████ │ ╱ ████ ╲
0 ┤────── ────── 0 ┤───╱ ╲───
└──┬───A──B─┬───→ r └──┬───A──B──┬──→ r

💡 Example
A chest X-ray image has low contrast in the lung region. Applying the image negative
makes subtle white lesions in the dark lung fields more visible. A median filter (5×5)
removes salt-and-pepper noise from a scanned document without blurring the text
edges. Grey-level slicing with range [100, 150] on a satellite image highlights water
bodies that have grey levels in this range.

🔚 Conclusion
Image enhancement and restoration are two complementary approaches —
enhancement improves visual quality subjectively, while restoration recovers degraded
images objectively. The median filter is the preferred tool for salt-and-pepper noise
removal due to its edge-preserving property. Image negatives reverse intensities using s
= (L−1) − r, useful for revealing details in dark regions. Grey-level slicing highlights
specific intensity ranges for targeted analysis, available with or without background
preservation.

4 IP_100
❓ Question 2: Discuss the limiting effect of repeatedly applying
a 3×3 spatial filter to a digital image. What is the equation of
the Wiener filter used to reconstruct an image blurred by this
type of degradation? What is Wiener filtering?
✅ Answer:
📖 Definition / Introduction
When a 3×3 spatial averaging (smoothing) filter is applied repeatedly to a digital image, it
produces progressively greater blurring that eventually converges to a uniform (constant) image.
The Wiener filter (also called the minimum mean square error filter) is the optimal linear filter for
restoring images degraded by such blurring in the presence of noise. It balances noise reduction
against deblurring.

📝 Detailed Explanation
Key Point 1: Limiting Effect of Repeated 3×3 Filtering
When a 3×3 averaging filter (each weight = 1/9) is applied once, each pixel becomes
the average of its 9 neighbours — moderate smoothing/blurring occurs.

Repeated application:

• 1st application: Slight blur, reduces high-frequency noise. Effective

neighbourhood = 3×3.

• 2nd application: More blur. Effective neighbourhood = 5×5 (each output pixel
is influenced by a 5×5 region of the original).

• k-th application: Effective neighbourhood grows to approximately (2k+1) ×

(2k+1). The image becomes progressively more blurred.

• As k → ∞: The image converges to a constant value equal to the mean grey

level of the original image. All spatial detail is lost.

Mathematically: Repeated application of a 3×3 averaging filter is equivalent to

convolution of the original image with a progressively wider Gaussian-like kernel. In
the frequency domain, this corresponds to repeated multiplication by the filter's transfer
function H(u,v), which attenuates high frequencies. As k → ∞, |H(u,v)|^k → 0 for all
(u,v) except (0,0), leaving only the DC component.

Key insight: Each application of the 3×3 filter is equivalent to a convolution in the
spatial domain (multiplication in the frequency domain). The k-th application gives an
effective filter H_eff(u,v) = [H(u,v)]^k, which approaches zero for all non-DC
frequencies.

Key Point 2: Wiener Filter

Wiener filtering (minimum mean square error filtering) is a restoration technique that

5 IP_101
 finds the estimate f̂ of the original image that minimizes the mean square error E{|f −
f̂|²}.

The degradation model: g(x,y) = h(x,y) ∗ f(x,y) + η(x,y)

In frequency domain: G(u,v) = H(u,v) · F(u,v) + N(u,v)

where g = degraded image, f = original image, h = degradation function (PSF), η =

additive noise.

Wiener Filter Equation:

F̂ (u,v) = [H(u,v) / (|H(u,v)|² + S_η(u,v)/S_f(u,v))] · G(u,v)*

Or equivalently:

F̂ (u,v) = [1/H(u,v)] · [|H(u,v)|² / (|H(u,v)|² + S_η/S_f)] · G(u,v)

Where:

• H*(u,v) = complex conjugate of H(u,v)

• |H(u,v)|² = H(u,v) · H*(u,v)

• S_η(u,v) = power spectrum of the noise

• S_f(u,v) = power spectrum of the original (undegraded) image

• S_η/S_f = noise-to-signal power ratio (NSR)

Simplified form (when NSR is a constant K):

F̂ (u,v) = [H(u,v) / (|H(u,v)|² + K)] · G(u,v)*

Key Point 3: Properties of Wiener Filter

• When noise = 0 (S_η = 0): Wiener filter reduces to the inverse filter F̂ = G/H.

• When noise dominates (S_η >> S_f · |H|²): Wiener filter acts as a smoothing
filter, suppressing noise.

• The Wiener filter automatically balances noise suppression and deblurring.

• It never amplifies noise as the inverse filter does at frequencies where |H| is
small.

• It requires knowledge of S_η and S_f, which are often estimated or

approximated.

6 IP_102
📊 Diagram / Table (if applicable)
Repeated Application of 3×3 Averaging Filter:

Original k=1 k=3 k=10 k→∞

┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
│Sharp │ │Slightly│ │Moderate│ │Heavily │ │Uniform │
│details │→ │blurred │→ │blurred │→ │blurred │→ │grey │
│visible │ │ │ │ │ │ │ │(mean) │
└────────┘ └────────┘ └────────┘ └────────┘ └────────┘
Effective: 3×3 7×7 21×21 All pixels
neighbourhood

In frequency domain:
|H_eff(u,v)| = |H(u,v)|^k → 0 for (u,v) ≠ (0,0) as k → ∞

Wiener Filter Block Diagram:

Original f → [Degradation H] → + → Degraded g → [Wiener Filter] → Restored f̂
↑
Noise η

Wiener Filter:
F̂ (u,v) = H*(u,v) · G(u,v) ← combines inverse filtering
───────────────── and noise suppression
|H|² + S_η/S_f

Wiener vs. Inverse Filter:

┌──────────────┬─────────────────┬──────────────────┐
│ Feature │ Inverse Filter │ Wiener Filter │
├──────────────┼─────────────────┼──────────────────┤
│ Formula │ F̂ = G/H │ F̂ = H*G/(|H|²+K)│
│ Noise handling│ Amplifies noise │ Suppresses noise │
│ Stability │ Unstable (H≈0) │ Stable │
│ Optimality │ Not optimal │ MSE optimal │
└──────────────┴─────────────────┴──────────────────┘

💡 Example
An image blurred by 5 repeated applications of a 3×3 averaging filter has an effective
PSF approximately equal to an 11×11 Gaussian. To restore it, the Wiener filter is
applied in the frequency domain: G(u,v) is computed via FFT, the known H(u,v) =
[H₃ₓ₃(u,v)]⁵ is used, and the NSR K is estimated (e.g., K = 0.01). The result F̂ = H*G/(|
H|²+0.01) recovers most of the lost detail while keeping noise amplification under
control.

🔚 Conclusion
Repeated application of a 3×3 spatial averaging filter progressively blurs the image,
with the effective neighbourhood growing as (2k+1)×(2k+1), until the image converges
to a uniform constant (the mean grey level). The Wiener filter is the optimal linear
restoration filter that minimizes mean square error by balancing deblurring against noise
amplification. Its equation F̂ (u,v) = H*G/(|H|²+S_η/S_f) elegantly reduces to inverse
filtering when noise is absent and to smoothing when noise dominates.

7 IP_103
❓ Question 3: Explain unsharp masking and high-boost
filtering. What is the expression of the Laplacian operator for
an image of two variables?
✅ Answer:
📖 Definition / Introduction
Unsharp masking and high-boost filtering are image sharpening techniques that enhance edges
and fine details by emphasizing high-frequency components. The Laplacian operator is a second-
order derivative operator used for edge detection and image sharpening, defined as the sum of
second partial derivatives.

📝 Detailed Explanation
Key Point 1: Unsharp Masking
Unsharp masking sharpens an image by subtracting a blurred (smoothed) version from
the original:

Step 1: Blur the original image f(x,y) to get f̄ (x,y) (using a Gaussian or averaging filter).

Step 2: Subtract the blurred image from the original to get the mask (detail/high-
frequency component): g_mask(x,y) = f(x,y) − f̄ (x,y)

Step 3: Add the mask back to the original: g(x,y) = f(x,y) + k · g_mask(x,y)

where k is a scaling constant (typically k = 1 for standard unsharp masking).

Combined formula: g(x,y) = f(x,y) + k · [f(x,y) − f̄ (x,y)]

The "unsharp" in the name refers to the blurred image used in the process — it is the
"unsharp" version.

Key Point 2: High-Boost Filtering

High-boost filtering is a generalization of unsharp masking where the original image is
amplified by a factor A before subtracting the blurred version:

g(x,y) = A · f(x,y) − f̄ (x,y)

Which can be rewritten as:

g(x,y) = (A−1) · f(x,y) + [f(x,y) − f̄ (x,y)] g(x,y) = (A−1) · f(x,y) + g_mask(x,y)

Special cases:

• A = 1: Standard unsharp masking: g = f − f̄ = mask (only high-freq components).

• A > 1: Original image is partially preserved along with enhanced details.

8 IP_104
 • A >> 1: Result approaches the original image (little enhancement).

High-boost filtering provides more control over the sharpening level than simple
unsharp masking.

Key Point 3: Laplacian Operator

The Laplacian is a second-order derivative operator defined as the sum of second
partial derivatives:

∇²f = ∂²f/∂x² + ∂²f/∂y²

Discrete approximation (for digital images):

∂²f/∂x² ≈ f(x+1, y) + f(x−1, y) − 2f(x, y)

∂²f/∂y² ≈ f(x, y+1) + f(x, y−1) − 2f(x, y)

∇²f(x,y) = f(x+1,y) + f(x−1,y) + f(x,y+1) + f(x,y−1) − 4f(x,y)

3×3 Laplacian kernel (4-neighbour):

[ 0 1 0] or including diagonals: [ 1 1 1]
[ 1 -4 1] (8-neighbour Laplacian) [ 1 -8 1]
[ 0 1 0] [ 1 1 1]

Image sharpening using Laplacian: g(x,y) = f(x,y) − ∇²f(x,y) (if centre coefficient is
negative) g(x,y) = f(x,y) + ∇²f(x,y) (if centre coefficient is positive)

📊 Diagram / Table (if applicable)

Unsharp Masking Pipeline:
f(x,y) ─────────────────────────────────(+)───→ g(x,y)
│ ↑
└──→ [Blur/Smooth] ──→ f̄ (x,y) ──→ (−) ──→ g_mask ──→ ×k ──┘
(f − f̄ = mask)

High-Boost Filtering:
f(x,y) ──→ × A ──→ (−) ──→ g(x,y) = A·f − f̄
↑
f(x,y) ──→ [Blur] ──→ f̄ (x,y)

Laplacian Kernels:
4-neighbour: 8-neighbour: Negative centre:
[ 0 1 0] [ 1 1 1] [ 0 -1 0]
[ 1 -4 1] [ 1 -8 1] [-1 4 -1]
[ 0 1 0] [ 1 1 1] [ 0 -1 0]

Sharpening: g = f - ∇²f or g = f + ∇²f

(depends on sign convention of Laplacian kernel)

Comparison:
┌─────────────────┬─────────────────┬──────────────────┐
│ Technique │ Formula │ Control Parameter│
├─────────────────┼─────────────────┼──────────────────┤
│ Unsharp masking │ g = f + k(f−f̄ ) │ k (mask weight) │

9 IP_105
 │ High-boost │ g = Af − f̄ │ A (amplification)│
│ Laplacian │ g = f − ∇²f │ None (fixed) │
└─────────────────┴─────────────────┴──────────────────┘

💡 Example
A blurry photograph is sharpened using unsharp masking: a 5×5 Gaussian blur creates f̄ ,
the mask g_mask = f − f̄ contains edges and details, and adding k=1.5 times the mask
back produces a noticeably sharper image. The Laplacian ∇²f of the same image reveals
all edges (positive and negative intensity transitions), and adding f + ∇²f enhances edge
contrast.

🔚 Conclusion
Unsharp masking enhances details by subtracting a blurred version and adding the high-
frequency mask back. High-boost filtering generalizes this by introducing an
amplification factor A for more control. The Laplacian operator ∇²f = ∂²f/∂x² + ∂²f/∂y²
provides isotropic (direction-independent) second-order edge detection and can be
implemented as a 3×3 kernel with centre coefficient −4 or −8. All three techniques serve
the common purpose of image sharpening by emphasizing high-frequency content.

❓ Question 4: Briefly describe smoothing linear spatial

filtering. What is the bit-plane slicing method? What is spatial
filtering?
✅ Answer:
📖 Definition / Introduction
Spatial filtering is the process of modifying pixel values by applying a filter mask (kernel) to the
image in the spatial domain. Smoothing linear spatial filtering uses averaging-type kernels to
reduce noise and blur images. Bit-plane slicing decomposes an image into its constituent bit planes,
revealing the contribution of each bit to the overall image appearance.

📝 Detailed Explanation
Key Point 1: Spatial Filtering
Spatial filtering operates directly on the pixel values of an image by moving a filter
mask (kernel) across the image and computing a new pixel value at each position based
on the mask coefficients and the neighbourhood pixel values.

Process:

10 IP_106
 1. A mask (kernel) of size m × n is placed over each pixel (x, y).

2. The mask coefficients are multiplied with the corresponding pixel values.

3. The products are summed (for linear filters) to produce the output at (x, y).

g(x,y) = Σᵢ Σⱼ w(i,j) · f(x+i, y+j)

Types:

• Linear filters: Output = weighted sum (averaging, Gaussian, Laplacian).

• Non-linear filters: Output = non-linear function (median, max, min).

• Smoothing filters: Reduce noise, blur (averaging, Gaussian).

• Sharpening filters: Enhance edges (Laplacian, gradient).

Key Point 2: Smoothing Linear Spatial Filtering

Smoothing (low-pass) filters blur the image and reduce noise by replacing each pixel
with a weighted average of its neighbourhood.

(a) Box/Averaging Filter: All coefficients are equal: w(i,j) = 1/(m×n)

3×3 averaging kernel: (1/9) × [1 1 1; 1 1 1; 1 1 1]

(b) Weighted Averaging Filter: Centre pixel gets more weight than neighbours:

(1/16) × [1 2 1; 2 4 2; 1 2 1]

(c) Gaussian Filter: Coefficients follow a 2D Gaussian distribution: w(x,y) = (1/2πσ²) ·

e^(−(x²+y²)/2σ²)

Provides smoother results than box filters (no ringing artefacts).

Properties:

• Larger kernels → more smoothing/blurring.

• Reduces Gaussian noise effectively.

• Blurs edges (disadvantage).

• Computationally simple (O(m×n) per pixel, or O(1) with integral images for box
filters).

Key Point 3: Bit-Plane Slicing

An 8-bit image has pixel values from 0 to 255. Each pixel can be represented as an 8-bit
binary number. Bit-plane slicing separates the image into 8 binary images (bit planes),
one for each bit position.

11 IP_107
 • Bit 7 (MSB — Most Significant Bit): Carries the most visual information.
Contains the coarse structure of the image.

• Bit 6: Second most significant — significant visual contribution.

• Bit 5, 4: Moderate contribution to visual appearance.

• Bit 3, 2, 1: Decreasing visual contribution.

• Bit 0 (LSB — Least Significant Bit): Contains the least visual information.
Appears as random noise.

Extraction: Bit plane i of pixel value v = (v >> i) & 1 (bitwise shift and AND).

Applications:

• Image compression: Discard lower bit planes (e.g., keeping only top 4–5
planes).

• Steganography/Watermarking: Hide data in the LSB plane (imperceptible

change).

• Image analysis: Understanding the contribution of each bit level.

• Texture analysis: Certain bit planes reveal texture patterns.

📊 Diagram / Table (if applicable)

Spatial Filtering Process:
┌──────────────┐ ┌────────┐
│ Image f(x,y) │ ──→ │ Kernel │ ──→ g(x,y) = Σ w(i,j)·f(x+i,y+j)
└──────────────┘ │ w(i,j) │
└────────┘

Smoothing Kernels:
Box Filter: Weighted Average: Gaussian (approx):
┌───┬───┬───┐ ┌───┬───┬───┐ ┌───┬───┬───┐
│1/9│1/9│1/9│ │1 │ 2 │ 1 │ ×1/16 │ 1 │ 2 │ 1 │ ×1/16
├───┼───┼───┤ ├───┼───┼───┤ ├───┼───┼───┤
│1/9│1/9│1/9│ │2 │ 4 │ 2 │ │ 2 │ 4 │ 2 │
├───┼───┼───┤ ├───┼───┼───┤ ├───┼───┼───┤
│1/9│1/9│1/9│ │1 │ 2 │ 1 │ │ 1 │ 2 │ 1 │
└───┴───┴───┘ └───┴───┴───┘ └───┴───┴───┘

Bit-Plane Slicing (8-bit image):

Pixel value 167 = 10100111 in binary

Bit 7 (MSB): 1 ← Most visual info

Bit 6: 0
Bit 5: 1
Bit 4: 0
Bit 3: 0
Bit 2: 1
Bit 1: 1
Bit 0 (LSB): 1 ← Least visual info (noise-like)

12 IP_108
 Visual Contribution:
Plane 7 > Plane 6 > ... > Plane 1 > Plane 0
(Coarse) (Fine/Noise)

💡 Example
A noisy medical image is filtered using a 5×5 Gaussian smoothing filter (σ=1.0). The
noise is significantly reduced, though edges become slightly blurred. Bit-plane slicing
of a portrait image shows: Plane 7 captures the face outline and major features, Planes 5
–6 add medium details, and Planes 0–2 appear as random noise. A watermark is
embedded in Plane 0 (LSB) — changing the least significant bit by 1 produces an
imperceptible change (intensity changes by at most 1 out of 255).

🔚 Conclusion
Spatial filtering applies kernels directly to pixel neighbourhoods — smoothing filters
reduce noise through averaging while blurring edges. The Gaussian filter provides the
smoothest results among linear smoothing filters. Bit-plane slicing decomposes an
image into its binary components, revealing that the MSB planes carry most visual
information while LSB planes appear noise-like. These concepts are fundamental to
understanding noise reduction, image compression, and data hiding in digital images.

❓ Question 5: What is understood by spatial domain

representation? Compute the inverse Fourier transform using
the forward transform algorithm.
✅ Answer:
📖 Definition / Introduction
Spatial domain representation refers to describing and manipulating an image directly in terms of
its pixel values at specific spatial coordinates (x, y), as opposed to its frequency-domain
representation. Computing the inverse DFT using the forward DFT algorithm is an elegant
mathematical trick that avoids implementing a separate IDFT routine — the same FFT code can be
reused.

📝 Detailed Explanation
Key Point 1: Spatial Domain Representation
In the spatial domain, a digital image is represented as a 2D function f(x, y), where:

• (x, y) are discrete spatial coordinates (pixel locations).

13 IP_109
 • f(x, y) is the intensity/grey level at that location.

The image is a matrix of M rows × N columns, with each element being a pixel value.

Spatial domain operations work directly on pixel values:

• Point operations: Transform each pixel independently: s = T(r).

• Examples: Negative, log transform, power-law transform, contrast
stretching.

• Neighbourhood operations: Transform each pixel based on its local

neighbourhood.
• Examples: Smoothing, sharpening, median filtering.

General form: g(x,y) = T[f(x,y)]

where T is an operator defined over a neighbourhood of (x, y).

Key Point 2: Computing IDFT Using Forward DFT

The forward and inverse DFT for 1D are:

Forward DFT: F(u) = (1/N) Σ[x=0 to N−1] f(x) · e^(−j2πux/N)

Inverse DFT: f(x) = Σ[u=0 to N−1] F(u) · e^(+j2πux/N)

Key Observation: The IDFT can be computed using the forward DFT as follows:

Step 1: Take the complex conjugate of F(u): F*(u)

Step 2: Apply the forward DFT to F*(u): DFT{F*(u)} = G(u)

Step 3: Take the complex conjugate of the result: G*(u)

Step 4: Divide by N: f(x) = G*(x) / N ... wait, let's be more precise.

Derivation:

f(x) = Σ[u] F(u) · e^(j2πux/N)

Taking conjugate of both sides:

f*(x) = Σ[u] F*(u) · e^(−j2πux/N) = N × DFT{F*(u)}

Therefore: f(x) = [N × DFT{F*(u)}]* → if f is real, f* = f.

Algorithm:

1. Conjugate the input: F*(u)

2. Apply forward DFT (FFT): compute DFT{F*(u)}

14 IP_110
 3. Conjugate the result

4. Divide by N

f(x) = (1/N) · [DFT{F(u)}]**

This means we can use the same FFT routine for both forward and inverse transforms!

📊 Diagram / Table (if applicable)

Spatial Domain Representation:
┌──────────────────────────────────────┐
│ f(x,y) = M × N matrix of pixels │
│ │
│ f(0,0) f(0,1) ... f(0,N-1) │
│ f(1,0) f(1,1) ... f(1,N-1) │
│ ... ... ... │
│ f(M-1,0) f(M-1,1) ... f(M-1,N-1) │
└──────────────────────────────────────┘

IDFT using Forward DFT:

F(u) ──→ [Conjugate] ──→ F*(u) ──→ [Forward DFT/FFT] ──→ G(x)
│
[Conjugate + ÷N]
│
↓
f(x)

Proof Summary:
IDFT{F(u)} = f(x) = Σ F(u)·e^(j2πux/N)

Conjugate:
f*(x) = Σ F*(u)·e^(-j2πux/N) = N · DFT{F*(u)}

Therefore:
f(x) = (1/N) · [DFT{F*(u)}]*

💡 Example
Given F(u) = {4, 1−j, 0, 1+j} for N=4:

1. Conjugate: F*(u) = {4, 1+j, 0, 1−j}

2. Apply forward DFT to F*: DFT{F*} = {(1/4)(4+1+j+0+1−j), ...} = compute

using FFT

3. Conjugate the result

4. Divide by N = 4

This gives f(x) = {1, 2, 1, 0} — the original sequence, computed entirely using the
forward FFT algorithm.

15 IP_111
🔚 Conclusion
The spatial domain represents images as matrices of pixel values at discrete coordinates,
and spatial domain operations work directly on these values. The elegant relationship
between forward and inverse DFT allows the IDFT to be computed using the same FFT
algorithm: f(x) = (1/N)[DFT{F*(u)}]*. This saves implementation effort and memory,
as only one FFT routine is needed for both directions of transformation.

❓ Question 6: What are spatial-domain and frequency-domain

techniques? Explain masks (kernels). What is filtering in the
frequency domain? Compare spatial-domain filtering and
frequency-domain filtering.
✅ Answer:
📖 Definition / Introduction
Image processing techniques are broadly classified into spatial-domain techniques (operating
directly on pixels) and frequency-domain techniques (operating on the image's frequency
representation). Masks (kernels) are small matrices used in spatial filtering. Frequency-domain
filtering involves transforming the image to the frequency domain, modifying frequency
components, and transforming back. Each approach has distinct advantages.

📝 Detailed Explanation
Key Point 1: Spatial-Domain Techniques
Operations performed directly on the pixel values f(x, y) of the image.

General form: g(x, y) = T[f(x, y)]

where T is an operator applied to the pixel and/or its neighbourhood.

Types:

• Point processing: s = T(r) — each pixel transformed independently.

• Mask/kernel processing: Output depends on neighbourhood values.

Examples: Contrast stretching, histogram equalization, spatial filtering (smoothing,

sharpening, median filtering).

Key Point 2: Masks (Kernels)

A mask (also called kernel, template, or window) is a small matrix of coefficients
16 IP_112
 (weights) that is applied to each pixel's neighbourhood to produce the filtered output.

Structure: An m × n array of coefficients w(i, j).

Application: The mask is centred on each pixel (x, y). Each mask coefficient is
multiplied by the corresponding image pixel, and all products are summed to produce
the output at (x, y):

g(x,y) = Σᵢ Σⱼ w(i,j) · f(x+i, y+j)

Common kernels:

• Averaging: all 1s (scaled) — smoothing

• Laplacian: [0 1 0; 1 −4 1; 0 1 0] — edge detection

• Sobel: gradient estimation — edge detection

• Gaussian: bell-curve weights — smoothing

Key Point 3: Frequency-Domain Filtering

In frequency-domain filtering:

1. Transform the image to frequency domain: F(u,v) = DFT{f(x,y)}

2. Multiply by a filter function: G(u,v) = F(u,v) · H(u,v)

3. Inverse transform back: g(x,y) = IDFT{G(u,v)}

Common frequency-domain filters:

• Low-pass filters: Preserve low frequencies, remove high (smoothing). Types:

Ideal, Butterworth, Gaussian.

• High-pass filters: Preserve high frequencies, remove low (sharpening). H_hp =

1 − H_lp.

• Band-pass/Band-reject filters: Pass or reject a specific frequency band.

• Notch filters: Remove specific frequency components (periodic noise).

Key Point 4: Comparison

Feature Spatial Domain Frequency Domain

Domain Pixel values f(x,y) Frequency coefficients F(u,v)
Operation Convolution with kernel Multiplication by filter function
Equivalence Convolution in spatial =
multiplication in frequency
(Convolution Theorem)

17 IP_113
Feature Spatial Domain Frequency Domain
Filter design Specify kernel coefficients Specify frequency response
curve
Intuition Direct — see effect on pixels Indirect — think in frequencies
Computation (small kernel) Fast (O(m×n per pixel)) Slower (FFT overhead)
Computation (large kernel) Slow (O(m×n grows) Fast (always O(N log N))
Flexibility Non-linear filters possible Primarily linear filters
Visualization Kernel coefficients Magnitude spectrum
Best for Small kernels, non-linear ops Large kernels, freq. analysis

📊 Diagram / Table (if applicable)

Spatial-Domain Filtering:
f(x,y) ──→ [Convolve with kernel w] ──→ g(x,y)

Frequency-Domain Filtering:
f(x,y) ──→ [DFT] ──→ F(u,v) ──→ [× H(u,v)] ──→ G(u,v) ──→ [IDFT] ──→ g(x,y)

Convolution Theorem (equivalence):

g = f ∗ w ↔ G = F · W
(spatial convolution = frequency multiplication)

Common Frequency-Domain Filters:

|H(u,v)|
1 ┤───────╲ Low-pass (Butterworth)
│ ╲
│ ╲─────
0 ┤ → D(u,v) (distance from centre)

|H(u,v)|
1 ┤ ╱───── High-pass
│ ╱
│───────╱
0 ┤ → D(u,v)

💡 Example
Spatial domain: A 3×3 averaging kernel is convolved with a noisy image — simple,
fast, direct. Frequency domain: The same smoothing can be achieved by computing
the FFT of the image, multiplying by a Gaussian low-pass filter H(u,v) = e^(−D²/2D₀²),
and computing the IFFT. For large kernels (e.g., 51×51), the frequency-domain
approach is much faster because FFT complexity O(N²logN) doesn't depend on kernel
size.

🔚 Conclusion
Spatial-domain techniques operate directly on pixels using kernels (masks), offering

18 IP_114
 simplicity and supporting non-linear operations. Frequency-domain techniques
transform the image, multiply by a filter function, and transform back, offering
computational advantages for large kernels and intuitive frequency-based filter design.
The Convolution Theorem guarantees equivalence: spatial convolution equals frequency
multiplication. The choice between them depends on kernel size, filter type (linear/non-
linear), and computational requirements.

❓ Question 7: What is a Quad-tree? What is salt-and-pepper

noise? What is Gaussian noise? What is the frequency of an
image? Discuss spatial resolution and grey-level resolution.
✅ Answer:
📖 Definition / Introduction
A Quad-tree is a hierarchical data structure that recursively subdivides a 2D image into four
quadrants. Salt-and-pepper noise and Gaussian noise are two common types of image noise. The
frequency of an image relates to the rate of intensity change across the spatial domain. Spatial
resolution and grey-level resolution define the detail and tonal range of a digital image
respectively.

📝 Detailed Explanation
Key Point 1: Quad-tree
A Quad-tree is a tree data structure in which each internal node has exactly four
children, representing the four quadrants (NW, NE, SW, SE) of a 2D region.

Construction:

1. Start with the entire image as the root node.

2. If a region is homogeneous (satisfies a predicate P), it becomes a leaf node.

3. If not homogeneous, subdivide into 4 equal quadrants — each becomes a child

node.

4. Recursively apply steps 2–3 to each child.

Applications: Image segmentation (split-and-merge), image compression, spatial

indexing, collision detection.

Depth of the tree depends on image size: for a 2^n × 2^n image, maximum depth = n.

Key Point 2: Salt-and-Pepper Noise

Also called impulse noise, it appears as random occurrences of pure black (0) and
19 IP_115
 white (255) pixels scattered across the image.

Characteristics:

• Only extreme values (0 or 255) are affected.

• Caused by transmission errors, dead pixels, or analog-to-digital converter errors.

• PDF: p(z) = P_a for z = 0 (pepper), P_b for z = 255 (salt), 0 otherwise.

• Best filter: Median filter (not mean filter — mean would blur the entire image).

Key Point 3: Gaussian Noise

Gaussian noise has a probability density function (PDF) following the
normal/Gaussian distribution:

p(z) = (1/√(2πσ²)) · e^(−(z−μ)²/2σ²)

where μ = mean (average), σ = standard deviation.

Characteristics:

• Affects ALL pixels — each pixel value is perturbed by a random amount.

• Most common noise model in image processing.

• Caused by sensor thermal noise, electronic circuit noise.

• Best filters: Averaging filter, Gaussian filter, Wiener filter.

Key Point 4: Frequency of an Image

Image frequency refers to the rate of change of pixel intensity across the spatial
domain:

• Low frequency: Regions where intensity changes slowly (smooth areas,

uniform backgrounds). Found near the centre of the frequency spectrum.

• High frequency: Regions where intensity changes rapidly (edges, fine details,
textures, noise). Found far from the centre of the frequency spectrum.

• DC component (zero frequency): The average intensity of the entire image —

the value at F(0,0).

The Fourier Transform reveals these frequency components as a 2D spectrum.

Key Point 5: Spatial Resolution and Grey-Level Resolution

Spatial Resolution:

• The smallest discernible detail in an image.

20 IP_116
 • Measured in pixels per unit length (PPI, DPI) or line pairs per unit distance.

• Determined by the number of pixels (M × N).

• Higher spatial resolution → more pixels → finer detail → larger file.

Grey-Level Resolution:

• The smallest discernible change in grey level.

• Determined by the number of bits per pixel (k): L = 2^k grey levels.

• 8-bit = 256 levels, 4-bit = 16 levels, 1-bit = 2 levels (binary).

• Higher grey-level resolution → smoother tonal gradations.

• Too few levels → false contouring artefacts.

Trade-off: For a fixed storage budget (M × N × k bits), increasing one resolution

requires decreasing the other.

📊 Diagram / Table (if applicable)

Quad-tree:
┌──────┬──────┐ Root
│ R1 │ R2 │ ╱ ╲
├──────┼──┬───┤ R1 R2...
│ R3 │R4│R5 │ ╱╲
│ ├──┼───┤ R4 R5...
│ │R6│R7 │
└──────┴──┴───┘

Noise Types:
Salt-and-Pepper: Gaussian:
┌──────────────┐ ┌──────────────┐
│ · ● · · ○ │ │ ~ ~ ~ ~ ~│
│ · · · ● · │ ● = salt │ ~ ~ ~ ~ ~│ ~ = slight random
│ ○ · · · · │ ○ = pepper │ ~ ~ ~ ~ ~│ perturbation on
│ · · ○ · ● │ │ ~ ~ ~ ~ ~│ ALL pixels
└──────────────┘ └──────────────┘

Image Frequency:
Low freq. (smooth) High freq. (edges/detail)
░░░░░░░░░░░░░░░ ░█░█░█░█░█░█
░░░░░░░░░░░░░░░ █░█░█░█░█░█░
░░░░░░░░░░░░░░░ ░█░█░█░█░█░█
(Slowly changing) (Rapidly changing)

💡 Example
A scanned document with transmission errors has salt-and-pepper noise — random
black and white dots. A 3×3 median filter removes them effectively. A low-light
photograph has Gaussian noise — a grainy appearance over the entire image. A

21 IP_117
 Gaussian smoothing filter (σ=1.5) reduces this noise. In the frequency spectrum of a
landscape photo, the sky region contributes low frequencies (smooth) while tree
branches contribute high frequencies (edges).

🔚 Conclusion
Quad-trees provide an efficient hierarchical representation for subdividing images. Salt-
and-pepper noise consists of isolated extreme-value pixels best removed by median
filtering, while Gaussian noise affects all pixels and is best reduced by averaging or
Gaussian filtering. Image frequency describes how quickly intensity values change
spatially. Spatial resolution (pixels per inch) and grey-level resolution (bits per pixel)
together define the quality of a digital image, with a fundamental trade-off between the
two for a fixed storage budget.

❓ Question 8: What is homomorphic filtering? Derive the

equation for a homomorphic filter. Describe its applications.
✅ Answer:
📖 Definition / Introduction
Homomorphic filtering is a frequency-domain technique used to simultaneously improve the
dynamic range compression (reduce illumination variations) and contrast enhancement (enhance
reflectance details) of an image. It is based on the illumination-reflectance model, where an image
is modelled as the product of illumination and reflectance components. By operating in the log-
frequency domain, these multiplicative components become separable and can be filtered
independently.

📝 Detailed Explanation
Key Point 1: Illumination-Reflectance Model
An image f(x, y) can be modelled as:

f(x, y) = i(x, y) × r(x, y)

where:

• i(x, y) = illumination component (light falling on the scene). Varies slowly →

low frequency.

• r(x, y) = reflectance component (light reflected by objects). Varies rapidly →

high frequency.

The challenge: i and r are multiplied, not added, so they cannot be separated by linear

22 IP_118
 filtering directly.

Key Point 2: Derivation of Homomorphic Filter

Step 1: Take the natural logarithm to convert multiplication to addition:

z(x,y) = ln[f(x,y)] = ln[i(x,y)] + ln[r(x,y)]

Step 2: Apply the DFT (Fourier Transform):

Z(u,v) = FT{z(x,y)} = Fᵢ(u,v) + Fᵣ(u,v)

where Fᵢ = FT{ln(i)} and Fᵣ = FT{ln(r)}.

Step 3: Apply the homomorphic filter H(u,v):

S(u,v) = H(u,v) · Z(u,v) = H(u,v) · Fᵢ(u,v) + H(u,v) · Fᵣ(u,v)

Step 4: Apply the Inverse DFT:

s(x,y) = IDFT{S(u,v)}

Step 5: Take the exponential to reverse the logarithm:

g(x,y) = e^(s(x,y))

The homomorphic filter H(u,v) is designed such that:

• γ_L < 1 (at low frequencies): Attenuates illumination variations → compresses

dynamic range.

• γ_H > 1 (at high frequencies): Amplifies reflectance variations → enhances

contrast/details.

Filter function:

H(u,v) = (γ_H − γ_L) × [1 − e^(−c·D²(u,v)/D₀²)] + γ_L

where D(u,v) = distance from origin, D₀ = cutoff frequency, c = sharpness constant.

At D = 0: H = γ_L (attenuate low freq.) At D → ∞: H = γ_H (amplify high freq.)

📊 Diagram / Table (if applicable)

Homomorphic Filtering Pipeline:

f(x,y) → [ln] → z(x,y) → [DFT] → Z(u,v) → [×H(u,v)] → S(u,v)

│
g(x,y) ← [exp] ← s(x,y) ← [IDFT] ←────────────────────────┘

f = i × r → ln(f) = ln(i) + ln(r) → Filter separately

23 IP_119
 Homomorphic Filter Transfer Function:
H(u,v)
γ_H ┤ ─────────────── (enhance reflectance)
│ ╱
│ ╱
│ ╱
γ_L ┤──────╱ (compress illumination)
│
└──────┬──────────────→ D(u,v) (frequency distance)
D₀

γ_L < 1: Reduces low-freq (illumination) variations

γ_H > 1: Boosts high-freq (reflectance/detail)

Before vs. After Homomorphic Filtering:

┌──────────────┐ ┌──────────────┐
│ Bright │Dark │ │ Moderate│Mod.│
│ area │area │ → │ even │even│
│(over- │(under-│ │illumin. │illu│
│exposed)│exposed│ │+ sharp │+sh.│
└──────────────┘ └──────────────┘
(Uneven illumination) (Uniform illumination + enhanced details)

💡 Example
A photograph taken in a room with a bright window: the area near the window is over-
exposed while the room interior is dark. Applying homomorphic filtering with γ_L =
0.3 and γ_H = 1.5: the logarithm separates illumination (slowly varying bright/dark)
from reflectance (object details). The filter attenuates the low-frequency illumination
variations (making brightness more uniform) and enhances high-frequency reflectance
(making interior objects clearer). The result shows both the window view and interior
details clearly.

Applications:
• Correcting uneven illumination in photographs and microscopy images.

• Medical imaging: Enhancing X-rays, MRI scans with varying brightness.

• Satellite imagery: Compensating for sun angle variations.

• Face recognition: Normalizing lighting conditions across face images.

• Document image processing: Handling pages photographed with shadows.

• Underwater imaging: Correcting non-uniform lighting.

🔚 Conclusion
Homomorphic filtering elegantly handles the multiplicative nature of the illumination-
reflectance model by applying a logarithm (converting multiplication to addition),
filtering in the frequency domain to separately control low frequencies (illumination)
and high frequencies (reflectance), and exponentiating the result. The filter

24 IP_120
 simultaneously compresses dynamic range (γ_L < 1) and enhances local contrast (γ_H >
1), making it invaluable for images with uneven lighting conditions.

❓ Question 9: What are the steps involved in histogram

equalization? Why is histogram equalization needed? Explain
the histogram of a digital image. What is an image histogram?
What do you mean by histogram specification? (Numerical on
DC component of an image histogram).
✅ Answer:
📖 Definition / Introduction
An image histogram is a graphical representation showing the distribution of pixel intensities in an
image. Histogram equalization transforms pixel values to produce an approximately uniform
histogram, maximizing contrast. Histogram specification (matching) transforms the image to
have a user-specified histogram distribution. The DC component (F(0,0)) of an image represents
the average intensity and is directly related to the histogram.

📝 Detailed Explanation
Key Point 1: Image Histogram
An image histogram h(rₖ) plots the number of pixels nₖ at each intensity level rₖ (k = 0,
1, ..., L−1).

Normalized histogram (PDF approximation): p(rₖ) = nₖ / (M × N), where M × N =

total pixels.

Σ p(rₖ) = 1 (sum of all probabilities = 1).

Histogram characteristics:

• Dark image: Histogram concentrated on the left (low intensities).

• Bright image: Histogram concentrated on the right (high intensities).

• Low-contrast image: Histogram concentrated in a narrow range (middle).

• High-contrast image: Histogram spread across the full range.

Key Point 2: Why Histogram Equalization is Needed

• To improve contrast of images with narrow intensity distributions.

• To maximize information content by utilizing the full dynamic range.

25 IP_121
 • To produce images that are perceptually better for human viewers.

• To normalize images for consistent appearance across different capture

conditions.

• As a preprocessing step before segmentation, recognition, or other operations.

Key Point 3: Steps in Histogram Equalization

1. Compute the histogram h(rₖ) = nₖ for k = 0, 1, ..., L−1.

2. Compute the normalized histogram (PDF): p(rₖ) = nₖ / (M × N).

3. Compute the cumulative distribution function (CDF): s(k) = Σ[j=0 to k] p(rⱼ)

4. Map old intensities to new values: sₖ = round[(L − 1) × s(k)]

5. Apply the mapping: Replace each pixel with intensity rₖ by the new value sₖ.

The transformation function: s = T(r) = (L−1) × CDF(r)

The result: the histogram of the output image is approximately uniform (flat), meaning
all intensity levels are approximately equally represented.

Key Point 4: Histogram Specification (Matching)

Histogram specification transforms an image so that its histogram matches a user-
defined target histogram (not necessarily uniform).

Steps:

1. Compute the CDF of the input image: s = T(r).

2. Compute the CDF of the desired (target) histogram: v = G(z).

3. Find the inverse mapping: z = G⁻¹(v).

4. Apply the composite mapping: z = G⁻¹(T(r)).

This allows specific histogram shapes (e.g., bimodal, Gaussian) to be imposed on the
image.

Key Point 5: DC Component and Histogram

The DC component F(0,0) of the DFT is the sum of all pixel values (scaled by 1/MN):

F(0,0) = (1/MN) Σ[x] Σ[y] f(x,y) = mean intensity × MN (with appropriate scaling)

Numerical Example: An image of size 4×4 with pixel values:

1 2 3 4
5 6 7 8
1 3 5 7
2 4 6 8
26 IP_122
Sum = 1+2+3+4+5+6+7+8+1+3+5+7+2+4+6+8 = 72
F(0,0) = (1/16) × 72 = 4.5 (mean intensity)
or with different DFT convention: F(0,0) = 72 (the raw sum).

📊 Diagram / Table (if applicable)

Histogram Equalization Process:

Original Histogram CDF (Transformation) Equalized Histogram

│ █ │ ╱─── │ █ █ █ █ █ █ █ █
│ █ █ │ ╱ │ █ █ █ █ █ █ █ █
│ █ █ █ │ ╱ │
│ █ █ █ █ │ ╱ │
│ █ █ █ █ █ │ ╱ │
└──────────→ r └──────────→ r └──────────────→ s
(Concentrated) T(r) = (L-1)·CDF(r) (Approximately uniform)

Histogram Equalization Steps:

┌──────────────────────────────────────────────────────────────┐
│ Step 1: h(rₖ) = count pixels at each intensity │
│ Step 2: p(rₖ) = h(rₖ) / (M×N) │
│ Step 3: CDF(k) = Σ[j=0 to k] p(rⱼ) │
│ Step 4: sₖ = round[(L-1) × CDF(k)] │
│ Step 5: Replace rₖ → sₖ in image │
└──────────────────────────────────────────────────────────────┘

Histogram Specification:
Input Image → T(r) → CDF_input → G⁻¹() → Matched Output
Target Histogram → G(z) → CDF_target ──────┘

DC Component:
F(0,0) = (1/MN) Σ Σ f(x,y) = Mean intensity of the image

💡 Example
Numerical — Histogram Equalization (3-bit, L=8):

rₖ nₖ p(rₖ) CDF sₖ =
round(7×CDF)
0 790 0.19 0.19 1
1 1023 0.25 0.44 3
2 850 0.21 0.65 5
3 656 0.16 0.81 6
4 329 0.08 0.89 6
5 245 0.06 0.95 7
6 122 0.03 0.98 7
7 81 0.02 1.00 7

27 IP_123
 Mapping: 0→1, 1→3, 2→5, 3→6, 4→6, 5→7, 6→7, 7→7. The equalized histogram is
more spread out across levels 1, 3, 5, 6, 7.

🔚 Conclusion
Image histograms are fundamental tools for understanding intensity distributions.
Histogram equalization uses the CDF as a transformation function to redistribute
intensities uniformly, maximizing contrast. Histogram specification extends this by
allowing any desired output distribution. The DC component F(0,0) directly represents
the average image intensity. These techniques are essential for image enhancement,
normalization, and as preprocessing steps for further analysis.

❓ Question 10: Show how Prewitt and Sobel operators can be

used to smooth/reduce the effect of noise.
✅ Answer:
📖 Definition / Introduction
The Prewitt and Sobel operators are first-order derivative-based edge detection operators. While
primarily used for detecting edges, they inherently incorporate a smoothing component
perpendicular to the gradient direction, which helps reduce the effect of noise during edge detection.
This built-in smoothing distinguishes them from simple difference operators.

📝 Detailed Explanation
Key Point 1: Prewitt Operator
The Prewitt operator uses two 3×3 kernels to compute the gradient in the x and y
directions:

Gx (horizontal edges):

[-1 0 1]
[-1 0 1]
[-1 0 1]

Gy (vertical edges):
[-1 -1 -1]
[ 0 0 0]
[ 1 1 1]

Gradient magnitude: |G| = |Gx| + |Gy| or √(Gx² + Gy²)

Smoothing in Prewitt:
• Each kernel can be decomposed as: derivative × averaging
28 IP_124
 • Gx = [-1 0 1]ᵀ × [1 1 1] (derivative along x, averaging along y)
• Gy = [1 1 1]ᵀ × [-1 0 1] (derivative along y, averaging along x)
• The averaging component (3-point average: [1 1 1]) smooths noise in the direction
perpendicular to the gradient, reducing the noise sensitivity of the edge detection.
Key Point 2: Sobel Operator
The Sobel operator uses weighted averaging for stronger smoothing:

Gx:

[-1 0 1]
[-2 0 2]
[-1 0 1]

Gy:
[-1 -2 -1]
[ 0 0 0]
[ 1 2 1]

Smoothing in Sobel:
• Gx = [-1 0 1]ᵀ × [1 2 1] (derivative along x, weighted averaging along y)
• Gy = [1 2 1]ᵀ × [-1 0 1] (derivative along y, weighted averaging along x)
• The weighted average [1 2 1] is a Gaussian-like smoothing filter (more weight to the centre
pixel), providing better noise reduction than the uniform [1 1 1] in Prewitt.
• This gives the Sobel operator a slight advantage over Prewitt in noisy conditions.
Key Point 3: How Smoothing Reduces Noise Effect
• Noise creates random, isolated intensity variations.

• Simple finite differences (e.g., [−1 0 1]) amplify noise because derivatives
enhance high-frequency content.

• By averaging perpendicular to the gradient direction, Prewitt and Sobel

operators average out random noise fluctuations before computing the gradient.

• Result: More robust edge detection with fewer false edge detections due to
noise.

📊 Diagram / Table (if applicable)

Decomposition (Separability):

Prewitt Gx = Derivative × Smoothing:

[-1 0 1] [-1] [-1 0 1]
[-1 0 1] = [-1] × [1 1 1] = [-1 0 1] (uniform avg.)
[-1 0 1] [-1] [-1 0 1]

Sobel Gx = Derivative × Weighted Smoothing:

29 IP_125
 [-1 0 1] [-1] [-1 0 1]
[-2 0 2] = [-2] × [1 2 1] = [-2 0 2] (Gaussian-like)
[-1 0 1] [-1] [-1 0 1]

Noise Reduction Comparison:

┌──────────────────┬────────────────────┬──────────────────┐
│ Operator │ Smoothing Filter │ Noise Robustness │
├──────────────────┼────────────────────┼──────────────────┤
│ Simple diff. │ None │ Poor │
│ Prewitt │ [1 1 1] uniform │ Good │
│ Sobel │ [1 2 1] weighted │ Better │
└──────────────────┴────────────────────┴──────────────────┘

Effect on noisy edge:

Noisy Edge: ... 50 52 48 │ 200 198 202 ...
↑ (edge)
Simple diff: high response at edge BUT also at noise spikes
Sobel: averages 3 rows → noise is smoothed, edge is preserved

💡 Example
Consider a noisy horizontal edge. Without smoothing, the derivative [−1 0 1] applied to
a single row detects the edge but also responds strongly to noise. The Sobel Gx kernel
averages 3 rows with weights [1 2 1] before differencing, so if one row has a noise
spike (e.g., value 250 instead of 100), the averaged value across 3 rows dilutes this
spike to approximately (100+250+100)/4 = 137.5, significantly reducing its impact on
the gradient computation.

🔚 Conclusion
Both Prewitt and Sobel operators achieve noise reduction through their inherent design:
each kernel is separable into a derivative component (for edge detection) and a
smoothing component (for noise reduction). The smoothing is applied perpendicular to
the gradient direction. Sobel's weighted average [1 2 1] provides better noise
suppression than Prewitt's uniform average [1 1 1] because it approximates a Gaussian
weighting. This built-in smoothing makes these operators significantly more robust than
simple finite difference operators for edge detection in noisy images.

❓ Question 11: Explain intensity-level slicing. Why is

logarithmic (log) transformation used in dynamic range
compression?
✅ Answer:
📖 Definition / Introduction
Intensity-level slicing (grey-level slicing) is an enhancement technique that highlights a specific
range of intensity values in an image while either suppressing or preserving the remaining values.

30 IP_126
The logarithmic (log) transformation is used to compress the wide dynamic range of certain types
of data into a displayable range, particularly useful for images with large variations in intensity like
Fourier spectra and astronomical images.

📝 Detailed Explanation
Key Point 1: Intensity-Level Slicing
Purpose: To highlight specific features that appear in a particular intensity range while
deemphasizing others.

Two approaches:

(a) Without background preservation (binary slicing):

• Pixels in the range [A, B] → set to a high value (e.g., 255).

• All other pixels → set to 0.

• Result: Binary image showing only the region of interest.

• Formula: s = L−1 if A ≤ r ≤ B, s = 0 otherwise.

(b) With background preservation:

• Pixels in the range [A, B] → set to a high value (e.g., 255).

• All other pixels → remain at their original intensity.

• Result: Highlighted region with background context intact.

• Formula: s = L−1 if A ≤ r ≤ B, s = r otherwise.

Applications:

• Highlighting water bodies in satellite images.

• Isolating specific tissue types in medical images.

• Detecting defects in industrial inspection.

Key Point 2: Logarithmic Transformation for Dynamic Range Compression

The log transformation is defined as:

s = c × log(1 + r)

where c is a scaling constant and r is the input intensity.

Why it is used for dynamic range compression:

31 IP_127
 1. Large dynamic range problem: Some image data (e.g., Fourier spectrum
magnitudes) have values ranging from 0 to millions. Directly displaying this
would result in all values appearing as either black (low values are
comparatively tiny) or white (high values saturate).

2. Logarithmic behaviour: The log function:

• Expands low-intensity values (dark regions → brighter, more

distinguishable).

• Compresses high-intensity values (bright values → closer together).

• Maps the range [0, 10⁶] to approximately [0, 6c] — a manageable range.

3. Human perception: The human eye perceives brightness approximately

logarithmically (Weber's law). The log transform aligns the image display with
human perception.

4. Fourier spectrum display: |F(u,v)| can range from 0 to millions. Without log:
only the DC component (F(0,0)) is visible as a bright dot, everything else
appears black. With log: s = c × log(1 + |F|), the spectrum reveals meaningful
patterns (edges → directional lines, periodic patterns → dots).

📊 Diagram / Table (if applicable)

Intensity-Level Slicing:

(a) Without background: (b) With background:

s ↑ s ↑
L ┤ ████ L ┤ ████
│ ████ │ ╱████
│ ████ │ ╱ ████
│ ████ │ ╱ ████╲
0 ┤─────── ────── 0 ┤───╱ ╲──
└───┬──A──B──┬──→ r └───┬──A──B──┬──→ r

Log Transformation:
s ↑
│ ─────────── (compressed high values)
│ ╱╱
│ ╱╱
│ ╱╱
│ ╱╱ (expanded low values)
0 ┤╱
└──────────────────→ r
0 10^6
s = c × log(1 + r)

Fourier Spectrum Display:

Without log: With log:
┌──────────────┐ ┌──────────────┐
│ │ │ ░░░░░░░ │
│ ● │ │ ░░████░░░ │
│ │ │ ░░██████░░░ │
│ │ │ ░░████░░░ │
└──────────────┘ └──────────────┘

32 IP_128
 (Only DC visible) (Full spectrum visible)

💡 Example
In a satellite image, water bodies have grey levels in the range [50, 80]. Applying
intensity-level slicing with [A, B] = [50, 80] highlights all water bodies in white (255)
while keeping the rest (land, vegetation, buildings) as background.

For Fourier spectrum display: An image's |F(u,v)| has DC component = 10⁶ and other
values ranging 0 to 1000. Without log: only DC is visible. With s = 30 × log(1 + |F|):
DC → 30 × log(10⁶+1) ≈ 415, while a value of 100 → 30 × log(101) ≈ 139. Both are
now in a displayable range, revealing the full spectrum structure.

🔚 Conclusion
Intensity-level slicing is a targeted enhancement technique that highlights specific
intensity ranges, available with or without background preservation. The logarithmic
transformation compresses wide dynamic ranges into displayable ranges by expanding
low values and compressing high values. The log transform is essential for visualizing
Fourier spectra and other data with extreme dynamic ranges, and its behaviour aligns
with human brightness perception, making transformed images more intuitive to
interpret.

❓ Question 12: What is image averaging? Discuss histogram

characteristics for dark images, bright images, and low-
contrast images. (Numerical on histogram equalization)
✅ Answer:
📖 Definition / Introduction
Image averaging is a noise reduction technique that averages multiple noisy copies of the same
scene to obtain a cleaner image. The histogram of a digital image reveals key visual characteristics
— dark, bright, and low-contrast images each have distinctive histogram shapes. Histogram
equalization is the standard technique for improving contrast by redistributing intensities.

📝 Detailed Explanation
Key Point 1: Image Averaging
If multiple images g₁, g₂, ..., gₖ are captured of the same static scene, each corrupted by
independent additive noise:

gᵢ(x,y) = f(x,y) + ηᵢ(x,y)

33 IP_129
 The averaged image is:

ḡ(x,y) = (1/K) Σ[i=1 to K] gᵢ(x,y)

Properties:

• E[ḡ(x,y)] = f(x,y) — the expected value equals the original (noise has zero
mean).

• Var[ḡ] = σ²_η / K — variance of noise is reduced by a factor of K.

• SNR improvement: SNR increases by √K.

• As K → ∞, ḡ → f (noise is completely eliminated).

Limitation: Requires multiple images of the same static scene — not applicable for
moving scenes.

Key Point 2: Histogram Characteristics

(a) Dark Image:

• Histogram is shifted to the left (concentrated at low intensity values).

• Most pixels have values near 0 (dark).

• Few or no pixels at high intensity levels.

(b) Bright Image:

• Histogram is shifted to the right (concentrated at high intensity values).

• Most pixels have values near 255 (bright).

• Few or no pixels at low intensity levels.

(c) Low-Contrast Image:

• Histogram is concentrated in a narrow range (neither fully left nor right, but
compressed in the middle or any portion).

• Small difference between darkest and brightest pixels.

• Image appears flat, dull, and lacks visual punch.

(d) High-Contrast Image (ideal):

• Histogram spans the entire range from 0 to 255.

• Wide, relatively uniform distribution.

• Image appears vivid with clear detail differentiation.

34 IP_130
Key Point 3: Numerical — Histogram Equalization
Given: A 3-bit image (L = 8, levels 0–7), size 64 × 64 = 4096 pixels.

rₖ nₖ p(rₖ) = nₖ/4096 CDF = Σp sₖ = round(7 ×

CDF)
0 790 0.1929 0.1929 1
1 1023 0.2498 0.4427 3
2 850 0.2075 0.6502 5
3 656 0.1602 0.8104 6
4 329 0.0803 0.8907 6
5 245 0.0598 0.9505 7
6 122 0.0298 0.9803 7
7 81 0.0198 1.0001 7

Mapping: 0→1, 1→3, 2→5, 3→6, 4→6, 5→7, 6→7, 7→7

Equalized histogram: | sₖ | Pixels | |----|--------| | 1 | 790 | | 3 | 1023 | | 5 | 850 | | 6 |

656+329 = 985 | | 7 | 245+122+81 = 448 |

The equalized histogram is more spread out (levels 1, 3, 5, 6, 7) compared to the

original (concentrated at 0–3).

📊 Diagram / Table (if applicable)

Image Averaging:
g₁ = f + η₁ ──┐
g₂ = f + η₂ ──┼──→ ḡ = (1/K)Σgᵢ ≈ f (noise ↓ by √K)
... │
gₖ = f + ηₖ ──┘

Histogram Characteristics:
Dark Image: Bright Image: Low-Contrast:
│█ │ █ │ ██
│██ │ ██ │ ████
│████ │ ████ │ ██████
│██████ │ ██████ │ ████████
└──────────→ └──────────────→ └───────────→
0 128 255 0 128 255 0 128 255
(Left-shifted) (Right-shifted) (Narrow, middle)

After Histogram Equalization:

Original: Equalized:
│████ │ █ █ █ █ █
│██████ │ █ █ █ █ █
│████████ │ ██ █ ██ █ █
└──────────→ └──────────────→
(Concentrated) (Spread/uniform)

35 IP_131
💡 Example
A security camera captures 100 frames of a static lobby. Each frame has Gaussian noise
(σ = 20). Averaging all 100 frames reduces noise standard deviation to σ/√100 = 2,
producing a nearly noise-free image. The averaged image's histogram is initially
concentrated (low contrast). After histogram equalization using the CDF mapping, the
histogram spreads across 0–255, producing a vivid, high-contrast result.

🔚 Conclusion
Image averaging reduces noise by a factor of √K when K images of the same scene are
averaged, making it effective for static scene noise reduction. Histogram characteristics
reveal image quality: dark images have left-shifted histograms, bright images have
right-shifted histograms, and low-contrast images have narrow histograms. Histogram
equalization transforms the histogram toward a uniform distribution using the CDF as a
mapping function, maximizing contrast and improving visual quality.

❓ Question 13: Describe edge detection operators. What is

point processing? What are image sharpening filters? What is
local enhancement? (Numerical on Arithmetic Mean, Harmonic
Mean, Max and Min filters)
✅ Answer:
📖 Definition / Introduction
Edge detection operators identify boundaries where significant intensity changes occur. Point
processing transforms each pixel independently. Sharpening filters enhance edges and fine details
by amplifying high-frequency components. Local enhancement applies enhancement operations to
local neighbourhoods rather than globally. Several order-statistic and mean filters — including
arithmetic mean, harmonic mean, max, and min filters — are commonly used for noise reduction.

📝 Detailed Explanation
Key Point 1: Edge Detection Operators
Edges are regions of sharp intensity change. Edge detection uses derivative-based
operators:

(a) First-order derivative operators (gradient):

• Roberts Cross: 2×2 kernels, fast but noise-sensitive.

• Gx = [1 0; 0 −1], Gy = [0 1; −1 0]

• Prewitt: 3×3, uniform smoothing + differentiation.

36 IP_132
 • Gx = [−1 0 1; −1 0 1; −1 0 1]

• Sobel: 3×3, weighted smoothing + differentiation.

• Gx = [−1 0 1; −2 0 2; −1 0 1]

• Canny: Multi-step optimal edge detector (Gaussian smoothing → gradient →

non-maximum suppression → hysteresis thresholding).

(b) Second-order derivative operators:

• Laplacian: ∇²f = [0 1 0; 1 −4 1; 0 1 0]. Detects edges as zero-crossings.

• Laplacian of Gaussian (LoG): Smooths first, then applies Laplacian.

Key Point 2: Point Processing

Point processing transforms each pixel independently without considering its
neighbours:

s = T(r)

where T depends only on the input pixel value r, not on its location or neighbours.

Examples: Negative (s = L−1−r), log transform (s = c·log(1+r)), power-law (s = c·r^γ),

thresholding, contrast stretching.

Key Point 3: Image Sharpening Filters

Sharpening filters enhance edges and fine details:

• Laplacian: Second derivative, highlights all edges isotropically.

• Unsharp masking: g = f + k(f − f̄ ).

• High-boost filtering: g = Af − f̄ .

• High-pass filtering (frequency domain): Pass high frequencies, block low

frequencies.

• Gradient operators: Sobel, Prewitt for directional sharpening.

Key Point 4: Local Enhancement

Local enhancement applies processing based on statistics (mean, variance) computed
from a local neighbourhood around each pixel, rather than using the global histogram.

At each pixel (x, y), compute local mean mₛ and local variance σₛ² from an n×n
neighbourhood. Apply enhancement based on conditions:

If σₛ < k₁·σ_global AND mₛ < k₂·m_global: enhance (multiply by a constant

E). Otherwise: keep original value.

This allows enhancement of regions with specific local properties (e.g., dark, low-
37 IP_133
 contrast areas) while leaving other regions unchanged.

Key Point 5: Numerical on Filters

Given a 3×3 neighbourhood:

┌─────┬─────┬─────┐
│ 10 │ 20 │ 30 │
├─────┼─────┼─────┤
│ 25 │ 200 │ 15 │ ← centre pixel = 200 (possible noise)
├─────┼─────┼─────┤
│ 35 │ 40 │ 45 │
└─────┴─────┴─────┘

Values: {10, 20, 30, 25, 200, 15, 35, 40, 45}
(a) Arithmetic Mean Filter: f̂ = (1/9)(10+20+30+25+200+15+35+40+45) = 420/9 = 46.67 ≈ 47
(b) Harmonic Mean Filter: f̂ = 9 / (1/10 + 1/20 + 1/30 + 1/25 + 1/200 + 1/15 + 1/35 + 1/40 +
1/45) = 9 / (0.1 + 0.05 + 0.0333 + 0.04 + 0.005 + 0.0667 + 0.0286 + 0.025 + 0.0222) = 9 / 0.3708 =
24.27 ≈ 24
(c) Max Filter: f̂ = max{10, 20, 30, 25, 200, 15, 35, 40, 45} = 200
(d) Min Filter: f̂ = min{10, 20, 30, 25, 200, 15, 35, 40, 45} = 10
Observation: Arithmetic mean (47) includes noise effect. Harmonic mean (24) is less affected by
the outlier 200. Max (200) preserves the noise. Min (10) removes the noise spike entirely.

📊 Diagram / Table (if applicable)

Edge Detection Operators:
┌──────────┬────────────────────────┬──────────────┐
│ Operator │ Kernel │ Smoothing │
├──────────┼────────────────────────┼──────────────┤
│ Roberts │ [1 0; 0 -1] │ None │
│ Prewitt │ [-1 0 1; -1 0 1; ...] │ Uniform [111]│
│ Sobel │ [-1 0 1; -2 0 2; ...] │ Weighted[121]│
│ Laplacian│ [0 1 0; 1 -4 1; ...] │ None │
│ Canny │ Multi-step │ Gaussian │
└──────────┴────────────────────────┴──────────────┘

Filter Comparison for the numerical:

┌──────────────────┬────────┬─────────────────────────┐
│ Filter │ Output │ Best for │
├──────────────────┼────────┼─────────────────────────┤
│ Arithmetic Mean │ 47 │ Gaussian noise │
│ Harmonic Mean │ 24 │ Salt noise (not pepper) │
│ Max Filter │ 200 │ Removing pepper noise │
│ Min Filter │ 10 │ Removing salt noise │
│ Median Filter │ 30 │ Salt-and-pepper noise │
└──────────────────┴────────┴─────────────────────────┘

💡 Example
In a surveillance image with Gaussian noise, an arithmetic mean filter (3×3) is applied

38 IP_134
 to reduce the overall noise level. For an image with salt noise (random white pixels), the
harmonic mean filter is effective because it gives less weight to very large values. The
min filter removes salt noise by selecting the smallest value (ignoring the white spikes),
while the max filter removes pepper noise by selecting the largest value (ignoring the
black dots).

🔚 Conclusion
Edge detection operators use first-order (Sobel, Prewitt) or second-order (Laplacian)
derivatives to identify intensity transitions. Point processing transforms pixels
independently using transfer functions. Sharpening filters emphasize high-frequency
content through derivative-based operations or unsharp masking. Local enhancement
adapts processing to neighbourhood statistics for targeted improvement. Different mean
and order-statistic filters serve different noise types: arithmetic mean for Gaussian
noise, harmonic mean for salt noise, max for pepper noise, min for salt noise, and
median for impulse noise.

❓ Question 14: Explain the process of image enhancement

using arithmetic operators. What is the need for interpolation
techniques? (Numerical on mean and entropy of an image)
✅ Answer:
📖 Definition / Introduction
Arithmetic operators (addition, subtraction, multiplication, division) are fundamental operations
used for image enhancement, noise reduction, change detection, and masking. Interpolation
techniques are needed when geometric transformations produce pixel locations at non-integer
coordinates. Mean and entropy are statistical measures that characterize the intensity distribution
and information content of an image.

📝 Detailed Explanation
Key Point 1: Image Enhancement Using Arithmetic Operators
(a) Addition (Image Averaging): g(x,y) = (1/K) Σ fᵢ(x,y) — averages K noisy images
of the same scene.

• Reduces noise by factor √K.

• Requires static scene and multiple captures.

(b) Subtraction (Image Differencing): g(x,y) = f₁(x,y) − f₂(x,y) — highlights

differences between two images.

39 IP_135
 • Applications: Change detection, motion detection, background subtraction, mask
subtraction (digital subtraction angiography).

(c) Multiplication (Masking/ROI extraction): g(x,y) = f(x,y) × m(x,y) — multiplies

image by a mask.

• If m(x,y) = 1 in ROI and 0 elsewhere: extracts region of interest.

• If m = constant > 1: brightens the image (scaling).

• Shading correction: multiply by inverse of illumination pattern.

(d) Division (Ratio imaging): g(x,y) = f₁(x,y) / f₂(x,y) — ratio of two images.

• Used in multi-spectral imaging for change detection and normalization.

• Illumination correction: divide by illumination pattern.

Key Point 2: Need for Interpolation Techniques

Interpolation is needed when:

• Image resizing (scaling up/down) — new pixel locations don't align with
original grid.

• Rotation — rotated pixel coordinates fall at non-integer positions.

• Geometric correction — correcting lens distortion or perspective.

• Image registration — aligning images from different sources.

• Any geometric transformation maps output pixels to non-integer input

locations.

Without interpolation, pixel values at non-integer locations cannot be determined.

Common methods: nearest-neighbour, bilinear, bicubic.

Key Point 3: Numerical — Mean and Entropy

Given image (4×4):

0 1 2 3
4 5 6 7
0 2 4 6
1 3 5 7

Mean: μ = (1/16) × (0+1+2+3+4+5+6+7+0+2+4+6+1+3+5+7) μ = (1/16) × 56 = 3.5

Entropy (information content): First, compute the histogram (frequency of each value): | Value |
Count | p(rₖ) = count/16 | |-------|-------|----------| | 0 | 2 | 0.125 | | 1 | 2 | 0.125 | | 2 | 2 | 0.125 | | 3 | 2 |
0.125 | | 4 | 2 | 0.125 | | 5 | 2 | 0.125 | | 6 | 2 | 0.125 | | 7 | 2 | 0.125 |
H = −Σ p(rₖ) × log₂(p(rₖ)) H = −8 × [0.125 × log₂(0.125)] H = −8 × [0.125 × (−3)] H = −8 ×
(−0.375) H = 3.0 bits/pixel
40 IP_136
Maximum possible entropy for L=8 levels = log₂(8) = 3.0 bits/pixel. Since all values are equally
probable, entropy is maximum — the image has maximum information content.

📊 Diagram / Table (if applicable)

Arithmetic Operations for Enhancement:

Addition (Averaging): Subtraction (Change Detection):

f₁ + f₂ + ... + fₖ f₁(x,y) − f₂(x,y)
────────────────── = ḡ = Difference image
K (highlights changes)

Multiplication (Masking): Division (Normalization):

f(x,y) × m(x,y) f₁(x,y) / f₂(x,y)
= ROI extraction = Ratio image

Interpolation Need:
Original grid: After rotation:
● ● ● ● ● ○ ○ ○ ○ ○ ○ = new pixel positions
● ● ● ● ● ↗ (non-integer in original)
● ● ● ● ● ○ ○ ○ ○ ○ Must interpolate from
● ● ● ● ● nearest ● values
● ● ● ● ●

Entropy Formula:
H = −Σ p(rₖ) × log₂(p(rₖ)) bits/pixel
Max entropy = log₂(L) when all levels equally probable

💡 Example
Digital Subtraction Angiography (DSA): A pre-contrast X-ray (f₁) is subtracted from
a post-contrast X-ray (f₂): g = f₂ − f₁. The difference image shows only the blood
vessels filled with contrast agent, removing all background bone and tissue structures.

The computed entropy of 3.0 bits/pixel means the image requires at least 3 bits per pixel
for lossless compression (equivalent to 16 × 3 = 48 bits total for this 4×4 image).

🔚 Conclusion
Arithmetic operators (addition, subtraction, multiplication, division) provide
fundamental image enhancement capabilities: addition for noise reduction, subtraction
for change detection, multiplication for masking, and division for normalization.
Interpolation techniques are essential whenever geometric transformations produce non-
integer pixel coordinates. Image mean and entropy are key statistical measures — mean
indicates average brightness, while entropy (measured in bits/pixel) quantifies the
information content and determines the theoretical minimum for lossless compression.

41 IP_137
❓ Question 15: Describe the algorithm for image sharpening
using DFT and IDFT. Explain the model of the image
restoration process in the presence of noise.
✅ Answer:
📖 Definition / Introduction
Image sharpening using DFT/IDFT is a frequency-domain approach that enhances edges and fine
details by applying a high-pass filter to the image's frequency representation. The image
restoration model describes how an original image is degraded by a combination of a degradation
function and additive noise, and how restoration attempts to recover the original.

📝 Detailed Explanation
Key Point 1: Image Sharpening Algorithm Using DFT and IDFT
Algorithm:

Step 1: Pre-processing

• Multiply the input image f(x,y) by (−1)^(x+y) to centre the DFT spectrum.

Step 2: Forward DFT

• Compute the 2D DFT: F(u,v) = DFT{f(x,y) × (−1)^(x+y)}

Step 3: Design a high-pass filter H(u,v)

• Options: Ideal HPF, Butterworth HPF, or Gaussian HPF.

• Gaussian HPF: H(u,v) = 1 − e^(−D²(u,v)/2D₀²)

• Where D(u,v) = √(u² + v²) is the distance from the centre.

Step 4: Apply the filter

• G(u,v) = F(u,v) × H(u,v)

Step 5: Inverse DFT

• g'(x,y) = IDFT{G(u,v)}

Step 6: Post-processing

• Multiply by (−1)^(x+y) to undo the centring.

• Take the real part: g(x,y) = Re{g'(x,y) × (−1)^(x+y)}

The result g(x,y) is a sharpened image with enhanced edges.

42 IP_138
Key Point 2: Image Restoration Model
The degradation model in the presence of noise:

Spatial domain: g(x,y) = h(x,y) ∗ f(x,y) + η(x,y)

Frequency domain: G(u,v) = H(u,v) · F(u,v) + N(u,v)

Where:

• f(x,y) = original (undegraded) image

• h(x,y) = degradation function (PSF — Point Spread Function)

• η(x,y) = additive noise

• g(x,y) = observed (degraded) image

• H(u,v) = Optical Transfer Function (OTF) = FT{h}

• N(u,v) = noise spectrum

Restoration goal: Estimate f̂ (x,y) from g(x,y), given knowledge (or estimates) of h and
noise statistics.

Restoration methods:

• Inverse filter: F̂ = G/H — simple but amplifies noise where H ≈ 0.

• Wiener filter: F̂ = H*G/(|H|²+K) — balances deblurring and noise.

• Constrained Least Squares: Minimizes ||∇²f̂||² subject to ||g − Hf̂ ||² = ||η||².

• Lucy-Richardson: Iterative algorithm for Poisson noise.

📊 Diagram / Table (if applicable)

Sharpening Algorithm (DFT/IDFT):

f(x,y) → [×(-1)^(x+y)] → [DFT] → F(u,v) → [×H_hp(u,v)] → G(u,v)

│
g(x,y) ← [×(-1)^(x+y)] ← [Real part] ← [IDFT] ←──────────────┘

High-Pass Filter H(u,v):

|H|
1 ┤ ╱──────── (pass high freq.)
│ ╱
│ ╱
0 ┤─────────╱ (block low freq.)
└────────┬──────→ D(u,v)
D₀

Degradation/Restoration Model:

43 IP_139
 Original f ──→ [Degradation h] ──→ (+) ──→ Degraded g ──→ [Restoration] ──→ f̂
↑
Noise η

In Frequency Domain:
G(u,v) = H(u,v)·F(u,v) + N(u,v)

Restoration Attempts:
┌──────────────┬──────────────────────────────────┐
│ Method │ Formula │
├──────────────┼──────────────────────────────────┤
│ Inverse │ F̂ = G / H │
│ Wiener │ F̂ = H*G / (|H|² + K) │
│ Constrained │ F̂ = H*G / (|H|² + γ|P|²) │
└──────────────┴──────────────────────────────────┘

💡 Example
A blurry photograph (degraded by motion blur h and Gaussian noise η) is restored using
the Wiener filter. The FFT of the degraded image G(u,v) is computed. The known
motion blur PSF H(u,v) and estimated NSR K=0.01 are used. The restored image F̂ =
H*G/(|H|²+0.01) recovers significant detail from the blur while keeping noise
amplification under control.

🔚 Conclusion
Image sharpening using DFT/IDFT involves transforming to the frequency domain,
applying a high-pass filter to enhance edges and details, and transforming back. The
image restoration model g = h∗f + η describes how images are degraded by blurring (h)
and noise (η). Restoration methods — from simple inverse filtering to the optimal
Wiener filter — aim to recover the original image by estimating and reversing the
degradation process while controlling noise amplification.

❓ Question 16: Explain the process of image convolution with a

suitable example. (Numerical on isotropic filters)
✅ Answer:
📖 Definition / Introduction
Convolution is a fundamental mathematical operation in image processing that combines an input
image with a filter kernel (mask) to produce an output image. It is the basis of all linear spatial
filtering operations including smoothing, sharpening, and edge detection. Isotropic filters produce
the same response regardless of the direction of the features in the image.

44 IP_140
📝 Detailed Explanation
Key Point 1: Image Convolution — Process
Convolution of an image f(x,y) with a kernel w(s,t) of size m×n is:

g(x,y) = Σ[s=−a to a] Σ[t=−b to b] w(s,t) · f(x−s, y−t)

where a = (m−1)/2, b = (n−1)/2.

Steps:

1. Flip the kernel 180° (both horizontally and vertically). For symmetric kernels
(most smoothing/Laplacian filters), flipping has no effect.

2. Slide the flipped kernel across the image, one pixel at a time.

3. At each position, multiply each kernel element with the corresponding pixel
underneath.

4. Sum all products to get the output pixel value at that position.

5. Handle boundaries: Pad the image (zero padding, replicate padding, mirror
padding).

Note: Convolution (flip kernel + slide) vs. Correlation (slide without flip). For
symmetric kernels, both give the same result.

Key Point 2: Convolution Example

Image (5×5):

0 0 0 0 0
0 100 100 100 0
0 100 100 100 0
0 100 100 100 0
0 0 0 0 0

Kernel (3×3 averaging):

1/9 1/9 1/9
1/9 1/9 1/9
1/9 1/9 1/9

Computing g(2,2) (centre pixel): g(2,2) = (1/9)(100+100+100+100+100+100+100+100+100) =

900/9 = 100
Computing g(1,1) (corner of bright region): g(1,1) = (1/9)(0+0+0+0+100+100+0+100+100) =
400/9 = 44.4 ≈ 44
Computing g(0,0) (top-left corner, with zero padding): g(0,0) = (1/9)(0+0+0+0+0+0+0+0+100) =
100/9 = 11.1 ≈ 11
The bright square's edges become gradually blurred (intensity transitions are smoothed).
Key Point 3: Isotropic Filters (Numerical)
45 IP_141
 An isotropic filter has the same response in all directions (rotationally symmetric). The
Laplacian is the simplest isotropic derivative operator.

Isotropic Laplacian Kernel (4-neighbour):

[ 0 1 0]
[ 1 -4 1]
[ 0 1 0]

Isotropic Laplacian Kernel (8-neighbour):

[ 1 1 1]
[ 1 -8 1]
[ 1 1 1]

Numerical Example — applying 4-neighbour Laplacian:

Image region:
50 50 50
50 100 50
50 50 50

∇²f(1,1) = 0×50 + 1×50 + 0×50 + 1×50 + (−4)×100 + 1×50 + 0×50 + 1×50 + 0×50 = 50 + 50 +
(−400) + 50 + 50 = −200
The large negative value indicates the centre pixel is a bright spot (local maximum) surrounded by
lower values.
Isotropic Gaussian smoothing kernel (5×5, σ=1):
1 4 7 4 1
4 16 26 16 4
1/ 7 26 41 26 7 ×(1/273)
4 16 26 16 4
1 4 7 4 1

This is isotropic because it is circularly symmetric — the response is the same in all directions.

📊 Diagram / Table (if applicable)

Convolution Process:

Step 1: Flip kernel 180° Step 2: Slide over image

┌───────┐ Flip ┌───────┐ ┌───────────────┐
│ a b c │ ────→ │ i h g │ │ ● ● ● ● ● ● │
│ d e f │ │ f e d │ │ ● ●[×]● ● ● │ ← kernel position
│ g h i │ │ c b a │ │ ● ● ● ● ● ● │
└───────┘ └───────┘ │ ● ● ● ● ● ● │
└───────────────┘
Step 3: Multiply & Sum

Isotropic Property:
Isotropic filter produces Non-isotropic filter:
circular response: directional response:
╱ ○ ╲ ──────
○ ○ ──────
╲ ○ ╱ ──────

46 IP_142
 (Same in all directions) (Stronger in one direction)

Isotropic Kernels:
┌──────────────────┬───────────────────────────────┐
│ Filter │ Kernel │
├──────────────────┼───────────────────────────────┤
│ Box (averaging) │ All 1/9 (3×3) │
│ Gaussian │ Bell-curve weights (symmetric) │
│ Laplacian (4-N) │ [0 1 0; 1 -4 1; 0 1 0] │
│ Laplacian (8-N) │ [1 1 1; 1 -8 1; 1 1 1] │
└──────────────────┴───────────────────────────────┘

💡 Example
A 3×3 Gaussian kernel (isotropic) applied to a photograph smooths it equally in all
directions — horizontal, vertical, and diagonal edges are blurred equally. Applying the
isotropic 4-neighbour Laplacian to a text image: at the edge of a letter, ∇²f produces a
large positive or negative response (highlighting the edge), while in flat regions ∇²f ≈ 0
(no response). The isotropy ensures edges in all orientations are detected equally.

🔚 Conclusion
Image convolution is the core operation of spatial filtering — it slides a flipped kernel
across the image, computing weighted sums at each position. The process handles
boundary pixels through padding. Isotropic filters like the Laplacian and Gaussian
produce direction-independent responses, making them fundamental to smoothing
(Gaussian) and edge detection (Laplacian). Understanding convolution — both its
mathematical definition and practical computation — is essential for all spatial-domain
image processing operations.

💡 More questions will be added as provided by Rishav.

🎓 Documen

47 IP_143
📘 [Link] 6th Semester — Exam Preparation
Author: Rishav Raj | Semester: 6th Sem | Subject: Image Processing — Image Restoration |
Marks per Answer: 5–10 Marks

📌 How to Use This Document

• Each answer is structured for 5–10 marks university exam questions.
• Every answer covers 1-2 pages of content with proper depth.
• Format includes: Definition → Explanation → Key Points → Diagram/Example →
Conclusion

❓ Question 1: List the various geometric transformations.

Differentiate between unconstrained restoration and
constrained restoration. Briefly explain the region growing
technique and state its problems. What are linear and non-
linear geometric image transformations? Differentiate between
them.
✅ Answer:
📖 Definition / Introduction
Geometric transformations modify the spatial relationships between pixels in an image (e.g.,
scaling, rotation). They are divided into linear (preserving straight lines) and non-linear (warping)
transformations. Image restoration can be unconstrained (minimizing error without prior
knowledge) or constrained (incorporating prior knowledge like smoothness). Region growing is a
segmentation technique that groups pixels into larger regions based on predefined similarity criteria.

📝 Detailed Explanation
Key Point 1: Various Geometric Transformations & Linear vs Non-Linear
Geometric transformations change the spatial layout of an image (coordinate
transformations).

Linear Transformations (Affine Transformations): Preserve collinearity (points on a

line remain on a line) and ratios of distances.

• Translation: Shifting the image along x and/or y axes.

• Scaling: Resizing the image (enlarging or shrinking).

1 IP_144
 • Rotation: Turning the image around a pivot point.

• Shearing: Slanting the image along an axis.

Non-Linear Transformations: Do not preserve straight lines; they cause local warping
or distortion.

• Perspective Projection: Simulates viewing a 3D plane from an angle.

• Polynomial Warping: Used for correcting lens distortions (barrel/pincushion).

• Rubber-sheet mapping: Correcting complex spatial distortions by tying

specific points to new coordinates.

Feature Linear Transformations Non-Linear Transformations

Line Preservation Straight lines remain straight Straight lines may become
curved
Matrix Representation Can be represented by a single Requires polynomial or
3x3 matrix (affine) complex equations
Complexity Computationally simple Computationally intensive
Applications Standard resizing, rotation, Lens distortion correction,
translation morphing, perspective
correction

Key Point 2: Unconstrained vs. Constrained Restoration

Image restoration aims to recover the original image from a degraded version.

Unconstrained Restoration: Minimizes a criterion function (usually least squares

error) without adding any constraints about the image's characteristics.

• Method: Minimizes the error between the observed image and the degraded
estimate.

• Result: Leads to the Inverse Filter.

• Drawback: Highly sensitive to noise. If the degradation function has values

close to zero, noise is amplified drastically, which can ruin the restored image.

Constrained Restoration: Incorporates prior knowledge about the image (e.g., images
are generally smooth) by adding mathematical constraints to the minimization problem.

• Method: Minimizes a function (like the Laplacian, measuring roughness)

subject to the constraint that the residual error equals the noise variance.

• Result: Leads to the Constrained Least Squares Filter or Wiener Filter.

• Advantage: Much more stable in the presence of noise, producing visually

superior results compared to unconstrained methods.

2 IP_145
Key Point 3: Region Growing Technique and Its Problems
Region Growing is a bottom-up image segmentation method.

Algorithm:

1. Select a set of seed points (pixels) based on some criteria (e.g., highest
intensity).

2. Check neighboring pixels (4-connected or 8-connected).

3. If a neighbor meets a similarity criterion (e.g., intensity difference < threshold),

append it to the seed's region.

4. The new pixel acts as a new seed. Repeat until no more pixels can be added.

Problems / Limitations:

• Seed Selection: The final segmentation heavily depends on the initial choice of
seed points. Poor seed selection leads to incorrect segmentation.

• Stopping Criteria: Difficult to formulate robust rules for when to stop growing.

• Noise Sensitivity: Random noise can prematurely stop region growing or

erroneously connect two regions that should be separate (leakage).

• Computationally Intensive: Requires checking many local neighborhoods

iteratively, which can be slow for large images.

📊 Diagram / Table (if applicable)

Restoration Approaches:

Unconstrained: Minimize ||g - Hf||² → Sensitive to noise (Inverse Filter)

Constrained: Minimize ||Qf||² subject to ||g - Hf||² = ||n||² → Robust
(Wiener/CLS)

Region Growing Process:

[S] = Seed pixel
[ ] = Unassigned pixel
[R] = Region pixel

Step 1: Step 2: Step 3:

[ ][ ][ ] [ ][R][ ] [R][R][R]
[ ][S][ ] → [R][S][R] → [R][S][R]
[ ][ ][ ] [ ][R][ ] [R][R][R]
(Checks neighbors based on similarity to grow region)

💡 Example
If a document image is photographed at an angle, a perspective (non-linear)
transformation corrects the keystoning effect so the page looks flat. If an image is

3 IP_146
 blurry, an unconstrained inverse filter might amplify sensor noise to the point where
the text is illegible, whereas a constrained least squares filter will restore the text
edges while keeping noise suppressed. To extract the text from the background, region
growing could start at dark seed points (ink) and grow to cover whole characters.

🔚 Conclusion
Geometric transformations adjust spatial coordinates, with linear methods preserving
lines and non-linear methods enabling complex warping. In restoration, constrained
methods significantly outperform unconstrained methods by incorporating prior
knowledge to prevent noise amplification that plagues inverse filtering. Region growing
is a classic segmentation approach that builds regions from seed points but struggles
with noise and seed selection sensitivity.

❓ Question 2: Explain the image restoration model. Explain the

restoration model for a continuous function in detail. Describe
the image degradation model.
✅ Answer:
📖 Definition / Introduction
The image degradation/restoration model mathematically describes how an original image is
corrupted by a physical degradation process and additive noise, and how a restoration process
attempts to estimate the original image. Understanding both the discrete and continuous function
forms of this model is fundamental to developing effective restoration filters that reverse the blur
and suppress noise.

📝 Detailed Explanation
Key Point 1: Image Degradation Model
The degradation process models how physical phenomena (like motion blur, out-of-
focus lenses, or atmospheric turbulence) and sensor noise corrupt an ideal image.

Let:

• f(x, y) = Original, ideal image

• h(x, y) = Degradation function (also known as the Point Spread Function, PSF)

• η(x, y) = Additive noise (from sensors, transmission, etc.)

• g(x, y) = Observed, degraded image

4 IP_147
 The Model Equation (Spatial Domain): g(x, y) = h(x, y) ∗ f(x, y) + η(x, y) (where ∗
denotes spatial convolution)

The Model Equation (Frequency Domain): Using the convolution theorem, we

transform the model into the frequency domain: G(u, v) = H(u, v) · F(u, v) + N(u, v)

The goal of restoration is to obtain an estimate, f̂ (x, y), of the original image f(x, y),
such that f̂(x, y) is as close as possible to f(x, y).

Key Point 2: Restoration Model for a Continuous Function

While digital images are discrete, the underlying physical degradation process is
continuous.

Let f(α, β) be a continuous, 2D object space (the real world). Let g(x, y) be the
continuous image plane.

The degradation function h(x, y, α, β) represents the response of the imaging system at
image coordinates (x, y) to a point source located at (α, β) in the object plane.

General Continuous Degradation Model: g(x, y) = ∫∫ f(α, β) · h(x, y, α, β) dα dβ +

η(x, y) (Limits of integration are over the entire object space)

Position Invariant (Shift Invariant) Assumption: In most practical applications, we

assume the degradation is position invariant. This means the system's response to a
point source only depends on the distance between the source and the observation point,
not on their absolute positions.

Mathematically, h(x, y, α, β) becomes h(x - α, y - β).

Substituting this back into the integral yields the continuous convolution integral: g(x,
y) = ∫∫ f(α, β) · h(x - α, y - β) dα dβ + η(x, y)

This continuous convolution is what we sample to obtain the discrete convolution

model g(x,y) = h(x,y) ∗ f(x,y) + η(x,y).

Key Point 3: The Image Restoration Process

The restoration process involves reversing the degradation. Since we only have G(u,v),
and we usually know or can estimate H(u,v) and N(u,v), we apply a restoration filter.

1. Estimation of Degradation (H): By observation, experimentation (using a point

light source to find the PSF), or mathematical modeling (e.g., modeling motion blur). 2.
Estimation of Noise (N): By analyzing uniform/flat regions of the degraded image to
find noise variance. 3. Application of Filter: Applying a mathematical filter (Inverse,
Wiener, Constrained Least Squares) to compute F̂ (u,v). 4. Inverse Transform:
Converting F̂ (u,v) back to the spatial domain to get f̂ (x,y).

📊 Diagram / Table (if applicable)

Block Diagram of the Degradation / Restoration Process:

5 IP_148
 Degradation Function h(x,y)
[System H]
│
Original Image ───────→ │ ───────→ + ───────→ Degraded Image
f(x,y) │ g(x,y)
↑
Noise η(x,y)
│
▼
[Restoration]
[Filter]
│
▼
Estimated Image
f̂ (x,y)

💡 Example
Consider taking a photograph of a fast-moving car. The original scene is f(x,y). During
the exposure time, the car moves, acting as a continuous degradation function h(x,y)
(motion blur). The camera sensor also adds random continuous noise η(x,y). The
resulting continuous signal is sampled by the camera's pixels to form the discrete
degraded image g(x,y). To restore the image, an algorithm estimates the blur direction
and length to model H(u,v), and applies a Wiener filter to recover the car's license plate
f̂(x,y).

🔚 Conclusion
The image degradation model elegantly represents physical corruption as a combination
of convolution with a Point Spread Function and additive noise. The continuous model
uses integral calculus to describe the precise optical physics, which simplifies to the
convolution integral under the assumption of position invariance. The restoration
process uses this model to mathematically estimate the original, undegraded image from
the corrupted observation using frequency-domain filtering techniques.

❓ Question 3: What is threshold coding implementation? What

is least-square restoration and constrained least-square
restoration? Differentiate between them.
✅ Answer:
📖 Definition / Introduction
Threshold coding is an image compression technique that discards transform coefficients below a
certain magnitude to save space. Least-square restoration (unconstrained) and constrained least-
square restoration are mathematical approaches to recovering a degraded image by minimizing an
error function. The constrained version incorporates prior knowledge to handle noise much more

6 IP_149
effectively.

📝 Detailed Explanation
Key Point 1: Threshold Coding Implementation
Threshold coding is a technique commonly used in transform-based image
compression (like DCT in JPEG).

Process:

1. Transform the image into the frequency domain (e.g., via Discrete Cosine
Transform).

2. Energy Compaction ensures that most visual information is packed into a few
coefficients, while many high-frequency coefficients are near zero.

3. Thresholding: A threshold value 'T' is chosen. Any coefficient with an absolute

magnitude less than 'T' is set to zero.

4. The remaining non-zero coefficients are quantized and encoded.

Result: Significant compression is achieved because long runs of zeros can be highly
compressed (using Run-Length Encoding). It is a lossy compression method, as the
discarded small coefficients cannot be recovered perfectly.

Key Point 2: Least-Square Restoration (Unconstrained)

This is a restoration method that aims to find an estimate f̂ that minimizes the sum of
squared errors between the observed degraded image 'g' and the estimated degraded
image 'Hf̂'.

Objective: Minimize the error criterion: J(f̂ ) = ||g - Hf̂ ||²

Taking the derivative and setting it to zero yields the unconstrained least-squares
estimate, which mathematically evaluates to the Inverse Filter: F̂ (u,v) = G(u,v) /
H(u,v)

Problem: It completely ignores the presence of noise. Since G = HF + N, the estimate

becomes: F̂ = F + N/H If the degradation function H(u,v) has very small values (which
is typical for high frequencies), the term N/H becomes massive, drastically amplifying
noise and ruining the restored image.

Key Point 3: Constrained Least-Square Restoration

To solve the noise amplification problem, this method adds a constraint based on prior
knowledge — specifically, that natural images are generally smooth.

Objective: Minimize a measure of roughness (usually the Laplacian, denoted by

operator Q or P). Minimize: ||Qf̂ ||² Subject to the constraint: ||g - Hf̂ ||² = ||η||² (The
residual error should equal the known noise variance).

7 IP_150
 Using Lagrange multipliers, this minimization leads to the Constrained Least Squares
Filter:

F̂ (u,v) = [ H(u,v) / (|H(u,v)|² + γ|P(u,v)|²) ] · G(u,v)*

Where:

• P(u,v) is the Fourier transform of the Laplacian operator.

• γ (gamma) is a parameter adjusted iteratively to satisfy the noise constraint.

Key Point 4: Differentiation

Feature Least-Square (Unconstrained) Constrained Least-Square

Objective Function Minimizes only the data error g - Hf̂
Prior Knowledge None Assumes image is generally
smooth
Resulting Filter Inverse Filter Constrained Least Squares
Filter
Noise Handling Extremely poor (amplifies noise Excellent (balances smoothing
massively) and restoration)
Requirements Only needs degradation H Needs degradation H, noise
variance, and an iterative
process to find γ

📊 Diagram / Table (if applicable)

Threshold Coding in DCT:
Before Thresholding: [150, 45, -12, 5, 2, -1, 0, ...]
Threshold T = 10
After Thresholding: [150, 45, -12, 0, 0, 0, 0, ...]
(Zeros are easily compressed)

Restoration Filter Shapes:

Inverse Filter (Unconstrained):
Multiplier = 1/H(u,v). Approaches infinity when H approaches zero.

Constrained Least Squares:

Multiplier = H* / (|H|² + γ|P|²).
When H approaches zero, the denominator is bounded by γ|P|², preventing
infinity and noise explosion.

💡 Example
When compressing a satellite image to send over a slow connection, threshold coding
discards minor high-frequency details (setting small DCT coefficients to zero), allowing
a 10MB image to be transmitted as 1MB with little visible loss. If this image was taken
out of focus, using unconstrained least-squares would result in a screen full of static

8 IP_151
 (noise amplification). Using constrained least-squares, the algorithm minimizes the
Laplacian (keeping the image looking natural and smooth) while enforcing the blur
model, successfully revealing the ground details without noise explosion.

🔚 Conclusion
Threshold coding provides efficient lossy image compression by aggressively
discarding low-magnitude transform coefficients. In image restoration, the
unconstrained least-squares approach fails practically due to massive noise
amplification at frequencies where the degradation function is close to zero. The
constrained least-squares restoration solves this by incorporating the mathematical
constraint of image smoothness (minimizing the Laplacian), resulting in a stable,
optimal restoration that gracefully handles both blur and noise.

❓ Question 4: Describe the restoration technique using

homomorphic filtering.
✅ Answer:
📖 Definition / Introduction
Homomorphic filtering is a technique primarily used to handle image degradations that are
multiplicative rather than additive. By applying a logarithmic transformation, the multiplicative
components are converted into additive components, allowing standard linear filtering techniques
(in the frequency domain) to be used for restoration or enhancement, after which an exponential
transformation restores the image space.

📝 Detailed Explanation
Key Point 1: The Multiplicative Degradation Model
Standard image restoration techniques (like Inverse or Wiener filtering) assume the
degradation and noise are additive: g = h ∗ f + η.

However, some degradations are multiplicative. The most classic example is the
Illumination-Reflectance model of image formation, but it also applies to
multiplicative noise (like speckle noise in ultrasound or radar images).

Let the observed degraded image be modeled as: f(x, y) = i(x, y) × r(x, y)

Where:

• i(x, y) is the illumination component (or multiplicative degradation). It generally

varies slowly across the image, meaning it is characterized by low frequencies.

9 IP_152
 • r(x, y) is the reflectance component (the actual object details we want to see). It
varies rapidly across the image, characterized by high frequencies.

Because they are multiplied together, we cannot simply use a linear high-pass or low-
pass filter to separate them directly.

Key Point 2: The Homomorphic Filtering Process

Homomorphic filtering solves the multiplication problem by using the properties of
logarithms to convert multiplication into addition.

Step 1: Logarithmic Transformation Take the natural logarithm of the image to

convert multiplication into addition. z(x, y) = ln[f(x, y)] = ln[i(x, y) × r(x, y)] z(x, y) =
ln[i(x, y)] + ln[r(x, y)] Now, the low-frequency illumination and high-frequency
reflectance are additive.

Step 2: Fourier Transform Convert the log-image into the frequency domain. Z(u, v)
= F_i(u, v) + F_r(u, v)

Step 3: Linear Filtering in Frequency Domain Apply a carefully designed filter H(u,
v). We want to suppress the low-frequency illumination (to correct uneven lighting) and
boost the high-frequency reflectance (to enhance details). S(u, v) = H(u, v) · Z(u,
v) S(u, v) = H(u, v) · F_i(u, v) + H(u, v) · F_r(u, v)

Filter Design: H(u,v) is designed to have a value < 1 for low frequencies (attenuation)
and > 1 for high frequencies (amplification).

Step 4: Inverse Fourier Transform Convert back to the spatial domain. s(x, y) =
IDFT{S(u, v)}

Step 5: Exponential Transformation Take the exponential to reverse the logarithm

applied in Step 1 and obtain the final restored image. g(x, y) = exp[s(x, y)]

Key Point 3: Applications as a Restoration Technique

While often classed under enhancement (dynamic range compression and contrast
enhancement), homomorphic filtering acts as a true restoration technique when the goal
is to remove a specific multiplicative corruption:

• Correcting Uneven Illumination: Restoring images taken under terrible

lighting conditions (e.g., a face half in deep shadow, half in bright sunlight).

• Speckle Noise Reduction: In Synthetic Aperture Radar (SAR) or medical

ultrasound, speckle noise is multiplicative. Homomorphic filtering can convert it
to additive noise, filter it out, and convert it back to restore the image details.

📊 Diagram / Table (if applicable)

Block Diagram of Homomorphic Filtering:

Multiplicative Additive Additive

Input [ Natural ] Input [ Fourier ] Frequency [ Filter ]

10 IP_153
 f(x,y)=i×r → [Logarithm] → z = In(i)+In(r) → [Transform] → Z(u,v) →
[ H(u,v) ]

│
Restored Additive Filtered Additive
▼
Image [Exponential] Output [ Inverse ] Frequency
S(u,v)
g(x,y) ← [ exp() ] ← s(x,y) ← [ Fourier ]
←──────────────────────────┘

💡 Example
A radiologist is examining an X-ray where the lighting source was faulty, resulting in
the left side of the film being brightly blown out and the right side being completely
dark (a multiplicative low-frequency degradation). By applying homomorphic filtering,
the algorithm takes the log of the image, applies a filter that heavily attenuates the low
frequencies (removing the bright-to-dark gradient), and takes the exponential. The
restored image now has perfectly uniform lighting across the whole X-ray, revealing
previously hidden bone fractures.

🔚 Conclusion
Homomorphic filtering is a powerful restoration and enhancement technique
specifically designed for multiplicative image models, such as illumination-reflectance
or speckle noise. By mapping the image into the log domain, it elegantly converts
multiplicative components into additive ones, allowing standard frequency-domain
filters to suppress illumination variations and amplify structural details simultaneously,
before returning the image to the spatial domain via an exponential function.

💡 More questions will be added as provided by Rishav.

🎓 Documented

11 IP_154
📘 [Link] 6th Semester — Exam Preparation
Author: Rishav Raj | Semester: 6th Sem | Subject: Image Processing — Image Segmentation &
Compression | Marks per Answer: 5–10 Marks

📌 How to Use This Document

• Each answer is structured for 5–10 marks university exam questions.
• Every answer covers 1-2 pages of content with proper depth.
• Format includes: Definition → Explanation → Key Points → Diagram/Example →
Conclusion

❓ Question 1: Define edge detection. Write down the

usefulness of segmentation. What is image segmentation?
What is local thresholding? What is global thresholding?
Differentiate between them. What is the basic difference
between region growing and split-and-merge techniques?
What is an edge detection algorithm? What is optimum
thresholding?
✅ Answer:
📖 Definition / Introduction
Image segmentation partitions an image into meaningful regions or objects. Edge detection is an
algorithm that identifies boundaries where intensity changes abruptly. Thresholding is a
segmentation technique classifying pixels as object or background; it can be global (one threshold
for the whole image), local (adaptive threshold per pixel), or optimum (minimizing classification
error). Region growing and split-and-merge are fundamental region-based segmentation
techniques.

📝 Detailed Explanation
Key Point 1: Image Segmentation & Its Usefulness
Image Segmentation is the process of subdividing an image into its constituent regions
or objects. The level of subdivision depends on the problem being solved (segmentation
stops when the objects of interest have been isolated).

Usefulness:

1 IP_155
 • Object recognition: Identifying faces, vehicles, or medical anomalies.

• Feature extraction: Analyzing the shape, size, and texture of isolated objects.

• Background removal: Separating foreground subjects from backgrounds.

• Medical imaging: Locating tumors, measuring tissue volumes.

Key Point 2: Edge Detection & Algorithms

Edge detection finds the boundaries between regions by identifying points where the
image brightness changes sharply or has discontinuities.

Edge Detection Algorithm: A computational method that approximates the image

gradient (1st derivative) or Laplacian (2nd derivative). Common algorithms include
Sobel, Prewitt, and the optimal Canny Edge Detector. They highlight regions of high
spatial frequency.

Key Point 3: Thresholding Techniques

Global Thresholding: A single, constant threshold value (T) is used for the entire
image.

• If f(x,y) > T, pixel becomes foreground (1).

• If f(x,y) ≤ T, pixel becomes background (0).

Local (Adaptive) Thresholding: The threshold value T(x,y) varies across the image
depending on the local neighbourhood properties (like local mean or variance).

Optimum Thresholding: Uses statistical decision theory to select a threshold that

minimizes the probability of misclassifying pixels. The most famous example is Otsu's
Method, which finds the threshold that maximizes the between-class variance (or
minimizes within-class variance).

Global vs. Local Thresholding: | Feature | Global Thresholding | Local Thresholding

| |---------|---------------------|--------------------| | Threshold Value | Single value T for
entire image | Dynamic T(x,y) for each pixel | | Computation | Very fast | Slower
(requires neighbourhood calculation) | | Illumination | Fails under uneven lighting |
Works well under uneven lighting | | Histogram | Requires clear bimodal histogram |
Does not require global bimodality |

Key Point 4: Region Growing vs. Split-and-Merge

Both are region-based segmentation techniques.

Region Growing (Bottom-Up): Starts with a set of "seed" pixels and grows regions by
appending adjacent pixels that share similar properties (like intensity).

Split-and-Merge (Top-Down + Bottom-Up): Starts with the entire image. If the image
is non-homogeneous, it splits it into four quadrants. This repeats recursively (quadtree).
After splitting, adjacent regions that are homogeneous when combined are merged.

2 IP_156
 Basic Difference: Region growing builds up from tiny seeds, making it highly
dependent on seed selection. Split-and-merge breaks down the whole image
systematically before combining, requiring no initial seeds but resulting in blockier
boundaries before merging.

📊 Diagram / Table (if applicable)

Thresholding Types:

Global: Local:
Same T everywhere. T varies based on local area.
s(x,y) = 1 if f(x,y)>T s(x,y) = 1 if f(x,y)>T(x,y)

Uneven Lighting Problem:

Global thresholding on a page with a shadow will classify the dark paper as
ink.
Local thresholding computes T based on a small window, adapting to the shadow.

💡 Example
To extract text from a scanned document with a shadow across it, global thresholding
fails (half the page turns black). Local thresholding computes a moving average and
successfully segments all text. The text boundaries are found using a Canny edge
detection algorithm. Otsu's optimum thresholding automatically calculates the best
threshold for uniformly lit regions without manual guessing.

🔚 Conclusion
Segmentation isolates objects of interest. Edge detection finds boundaries via
derivatives, while thresholding separates objects by intensity. Global thresholding is fast
but fails with poor lighting, where local thresholding succeeds. Optimum thresholding
automates threshold selection statistically. Region-based methods like growing (seed-
based) and split-and-merge (quadtree-based) offer alternative ways to define uniform
objects.

❓ Question 2: What is a boundary descriptor? What is a Fourier

descriptor? Explain the process of region extraction based on
segmentation.
✅ Answer:
📖 Definition / Introduction
Once an image is segmented, the resulting regions must be represented and described for further
processing. A boundary descriptor defines the shape of a region using features of its external

3 IP_157
contour. A Fourier descriptor is a robust boundary descriptor that uses the frequency domain to
represent shapes. Region extraction is the process of isolating and labeling these segmented
components so they can be analyzed individually.

📝 Detailed Explanation
Key Point 1: Boundary Descriptor
A boundary descriptor evaluates the outline (contour) of a segmented object to extract
quantitative features that describe its shape.

Common Boundary Descriptors:

• Length / Perimeter: Number of pixels along the boundary.

• Diameter / Major Axis: Maximum distance between any two points on the
boundary.

• Eccentricity: Ratio of the major axis to the minor axis (measures elongation).

• Chain Codes: Represents a boundary as a sequence of directional codes (e.g., 0

for right, 1 for up-right, 2 for up).

• Shape Numbers: The first difference of a chain code, making it rotation

invariant.

Key Point 2: Fourier Descriptor

Fourier Descriptors represent the shape of a 2D closed boundary in the frequency
domain.

Concept:

1. The boundary is treated as a sequence of complex numbers: s(k) = x(k) + j·y(k).

2. The 1D Discrete Fourier Transform (DFT) is applied to this sequence to produce

a set of complex coefficients a(u).

3. These coefficients are the Fourier Descriptors.

Advantages:

• Compactness: A complex shape can be approximated well by just a few low-

frequency descriptors.

• Invariance: By manipulating the descriptors (e.g., ignoring the DC component,

dividing by the first magnitude), the representation becomes invariant to
translation, rotation, and scaling.

Key Point 3: Process of Region Extraction Based on Segmentation

4 IP_158
 After a segmentation algorithm (like thresholding) produces a binary image, we must
extract the individual regions. This is done using Connected Component Analysis
(CCA).

Process:

1. Scan the Image: Move row by row, left to right.

2. Check Connectivity: When a foreground pixel is found, examine its neighbors

(4- or 8-connectivity).

3. Label Assignment:
• If all neighbors are background, assign a new label to the current pixel.

• If one neighbor has a label, assign that same label to the current pixel.

• If multiple neighbors have different labels, assign one of them and record
an equivalence (they are part of the same object).

4. Resolve Equivalences: Perform a second pass to unify all equivalent labels into
a single unique ID per connected region.

5. Extraction: Once labeled, each region can be extracted separately as an

individual object for feature calculation.

📊 Diagram / Table (if applicable)

Chain Code (Boundary Descriptor):
3 2 1 Code: 0, 0, 7, 6, ...
\ | /
4 -- P -- 0 (Directions 0-7)
/ | \
5 6 7

Connected Component Labeling (Region Extraction):

Binary Image: Pass 1: Pass 2 (Resolved):
1 1 0 0 1 A A 0 0 B 1 1 0 0 2
1 0 0 1 1 → A 0 0 C C → 1 0 0 2 2
0 0 0 1 1 0 0 0 C C 0 0 0 2 2
(2 objects) (Equivalence C=B) (Labels 1 and 2)

💡 Example
To recognize different types of leaves on a white background: First, Otsu's thresholding
segments the image. Region extraction (connected component labeling) isolates each
leaf and assigns it an ID (Leaf 1, Leaf 2). The boundary of Leaf 1 is traced. A simple
boundary descriptor like eccentricity might fail if two different leaves are both long
and thin. However, computing the Fourier Descriptors of the boundary provides a
highly unique shape signature that remains the same even if the leaf is rotated or scaled.

5 IP_159
🔚 Conclusion
Region extraction transforms a raw segmented image into distinctly labeled individual
objects using connected component analysis. Boundary descriptors quantify the shape
of these extracted objects. While simple descriptors like perimeter or chain codes are
useful, Fourier descriptors provide a mathematically elegant, compact, and
transformation-invariant representation of shape, making them highly effective for
pattern recognition.

❓ Question 3: What is the pattern fitting approach? What is the

region splitting technique? How can isolated points be
identified? How are points and edges detected using
derivatives? Give suitable examples.
✅ Answer:
📖 Definition / Introduction
The pattern fitting approach involves searching for predefined shapes or templates in an image.
Region splitting is a top-down segmentation method. Point and edge detection rely on
derivatives to find local discontinuities in image intensity, where the first derivative finds edges
and the second derivative is highly sensitive to isolated points.

📝 Detailed Explanation
Key Point 1: Pattern Fitting Approach
Pattern Fitting (or Template Matching) is a technique used to find specific structures
or shapes within an image.

Mechanism: A template (a small sub-image representing the object of interest) is

moved pixel-by-pixel across the target image. At each position, a similarity metric (like
cross-correlation or sum of absolute differences) is calculated. High values indicate a
match.

Advanced fitting: Includes techniques like the Hough Transform (fitting lines and
circles) or Active Contours/Snakes (fitting a parametric curve to object boundaries).

Key Point 2: Region Splitting Technique

Region Splitting is a top-down segmentation method based on a quadtree structure.

1. Start with the entire image as one region.

2. Evaluate a homogeneity predicate (e.g., standard deviation < threshold).

3. If the region is not homogeneous, split it into four equal quadrants.

6 IP_160
 4. Repeat recursively for each quadrant until all resulting sub-regions are
homogeneous. (Usually followed by a "merge" step to combine adjacent
homogeneous regions).

Key Point 3: Point and Edge Detection Using Derivatives

Discontinuities in an image (points, lines, edges) correspond to sharp changes in pixel
intensity. These changes are detected using mathematical derivatives.

First Derivative (Gradient):

• Responds when intensity changes (ramp/step edges).

• Produces thick edges along a ramp.

• Magnitude is proportional to the edge contrast.

• Used for Edge Detection.

Second Derivative (Laplacian):

• Responds to changes in the rate of intensity change.

• Produces a zero-crossing at the exact centre of an edge (used for precise edge
localization).

• Highly sensitive to isolated points and fine details.

• Used for Point Detection.

Key Point 4: Identifying Isolated Points (Example)

An isolated point is a pixel whose intensity is significantly different from all its
neighbors. It is detected using the Laplacian (second derivative) mask:

[-1 -1 -1]
[-1 8 -1]
[-1 -1 -1]

Process: Apply this mask to the image. If the absolute response |R| at a pixel exceeds a high
threshold T, the pixel is classified as an isolated point. The centre weight '8' ensures that if the pixel
is surrounded by identical values, the sum is zero (no point detected).

📊 Diagram / Table (if applicable)

Derivatives for Edge/Point Detection:

Intensity Profile: ___ _______

\ / ↑
\___/ isolated point
Edge

1st Derivative: 0 -ve 0 +ve 0 (Non-zero during edge ramp)

7 IP_161
 2nd Derivative: 0 - + 0 + - 0 (Zero-crossing at edge centre;
huge spike at isolated point)

Edge Detection Masks (1st Derivative):

Sobel Gx: [-1 0 1; -2 0 2; -1 0 1]

💡 Example
Pattern Fitting: Finding a specific company logo in a document by cross-correlating a
template of the logo across the page. Region Splitting: Dividing a landscape photo
until uniform patches of sky and grass are isolated in quadtree blocks. Derivative
Detection: Applying the Sobel operator (1st derivative) to an image of a cube highlights
all the outer thick edges. Applying the Laplacian operator (2nd derivative) to a night sky
image causes the isolated points (stars) to produce massive intensity spikes, allowing
them to be instantly identified via thresholding.

🔚 Conclusion
Pattern fitting searches for known structures using templates or mathematical models.
Region splitting segments images systematically from the top down. Fundamentally,
feature detection relies on calculus: first derivatives (like Sobel) measure the gradient to
find thick edges, while second derivatives (like the Laplacian) find exact zero-crossings
for edges and are extremely sensitive to isolated points, making them perfect for point
detection.

❓ Question 4: Explain the object recognition process. What is

the split-and-merge algorithm?
✅ Answer:
📖 Definition / Introduction
Object recognition is the ultimate goal of computer vision, where an algorithm assigns a label or
category to an object found in an image based on its features. The split-and-merge algorithm is a
classical region-based segmentation technique that creates the homogeneous regions necessary to
isolate objects before they can be recognized.

📝 Detailed Explanation
Key Point 1: The Object Recognition Process
Object recognition transforms raw pixel data into semantic understanding. It generally
follows a structured pipeline:

1. Image Acquisition: Capturing the digital image.

8 IP_162
 2. Preprocessing: Noise removal, contrast enhancement, or resizing to prepare the
image.

3. Segmentation: Partitioning the image to isolate the objects of interest from the
background (e.g., using thresholding, split-and-merge, or edge detection).

4. Feature Extraction: Quantifying the isolated object. Computing numerical

descriptors such as area, perimeter, Fourier descriptors, color histograms, or
texture features.

5. Classification / Recognition: Using pattern recognition techniques to assign the

object to a known class.
• Methods: Minimum distance classifiers (Euclidean distance to class
means), Neural Networks, Support Vector Machines (SVM), or Deep
Learning (CNNs) which merge feature extraction and classification.

Key Point 2: The Split-and-Merge Algorithm

While region splitting alone produces fragmented blocky regions, and region growing is
highly dependent on seeds, split-and-merge combines both for robust segmentation.

The Algorithm: Let R represent the entire image, and P be a homogeneity predicate
(e.g., "variance < T").

Step 1: Splitting (Top-Down)

• Start with region R.

• If P(R) is FALSE (region is not homogeneous), split R into 4 equal quadrants

(Q1, Q2, Q3, Q4).

• Recursively apply this step to each new quadrant until every block satisfies P, or
a minimum block size is reached. (This forms a quadtree).

Step 2: Merging (Bottom-Up)

• Examine all pairs of adjacent regions (say R_i and R_j).

• If they are homogeneous when combined — meaning P(R_i ∪ R_j) is TRUE —

merge them into a single larger region.

• Repeat the merging process until no further merges are possible.

Result: A segmentation that respects the natural boundaries of objects rather than being
constrained to the artificial square grid of the quadtree.

📊 Diagram / Table (if applicable)

Object Recognition Pipeline:
[Image] → [Preprocess] → [Segment] → [Extract Features] → [Classify] → Label

9 IP_163
 Split-and-Merge Visualization:
Initial: Split: Split More: Merge:
+-------+ +---+---+ +---+---+ +---+---+
| | | | | | +-|-+ | | | |
| Obj | → |---+---| → |-+-|-+-| → |---+---|
| | | | | | +-|-+ | | |
+-------+ +---+---+ +---+---+ +-------+
(Not homog) (Blocks) (Quadtree) (Final Object)

💡 Example
Split-and-Merge: Segmenting a brain MRI. The image is split into squares until
squares contain either only white matter, grey matter, or background. Then, adjacent
white matter squares are merged together to form the complete white matter
structure. Object Recognition: To recognize a handwritten digit '7', the image is
preprocessed and segmented to extract the digit. Features like the number of straight
lines, intersections, and loops are extracted. A classifier compares these features to a
database and recognizes the object as class '7'.

🔚 Conclusion
The object recognition process is a multi-step pipeline moving from raw data to
semantic labels, relying heavily on segmentation and feature extraction. The split-and-
merge algorithm is a powerful tool in the segmentation step, elegantly combining the
systematic top-down approach of quadtree splitting with the bottom-up aggregation of
merging to accurately isolate objects regardless of shape or size.

❓ Question 5: What are the common metrics used to assess

the performance of segmentation algorithms?
✅ Answer:
📖 Definition / Introduction
Evaluating a segmentation algorithm requires comparing the algorithm's output (predicted
segmentation mask) against a known, human-annotated ground truth mask. Common evaluation
metrics rely on measuring true positives, false positives, and false negatives to quantify spatial
overlap and pixel accuracy.

📝 Detailed Explanation
Key Point 1: The Confusion Matrix in Segmentation
For binary segmentation (Foreground vs. Background), every pixel is classified into one
of four categories:

10 IP_164
 • True Positive (TP): Pixel correctly predicted as foreground.

• True Negative (TN): Pixel correctly predicted as background.

• False Positive (FP): Background pixel incorrectly predicted as foreground

(Over-segmentation).

• False Negative (FN): Foreground pixel incorrectly predicted as background

(Under-segmentation).

Key Point 2: Common Segmentation Metrics

1. Intersection over Union (IoU) / Jaccard Index The most standard metric for
segmentation. It measures the overlap between the predicted mask (A) and the ground
truth mask (B).

• Formula: IoU = Area of Overlap / Area of Union

• Formula (Pixels): IoU = TP / (TP + FP + FN)

• Range: 0 to 1 (1.0 is a perfect match). Highly penalizes small errors in object

boundaries.

2. Dice Coefficient (F1-Score) Very similar to IoU but gives twice the weight to the
intersection. Widely used in medical image segmentation.

• Formula: Dice = 2 × Area of Overlap / (Area A + Area B)

• Formula (Pixels): Dice = 2·TP / (2·TP + FP + FN)

• Relation to IoU: Dice = 2·IoU / (1 + IoU).

3. Pixel Accuracy The percentage of pixels correctly classified in the entire image.

• Formula: Accuracy = (TP + TN) / (TP + TN + FP + FN)

• Drawback: Highly misleading if the object is very small compared to the

background (Class Imbalance). A 99% black image with a 1% white object will
get 99% accuracy if the model simply guesses "black" for everything.

4. Precision and Recall

• Precision: Of the pixels predicted as foreground, how many actually are? (TP /
(TP + FP)).

• Recall (Sensitivity): Of the actual foreground pixels, how many were found?
(TP / (TP + FN)).

📊 Diagram / Table (if applicable)

IoU vs Dice Visualization:

11 IP_165
 [ A (Prediction) ]
[ Overlap ]
[ B (Ground Truth) ]

Intersection (TP) = Overlap region

Union = A + B - Intersection

Metric Comparison:
| Metric | Best Used For | Flaw |
|----------|-------------------------------|-------------------------------|
| Accuracy | Balanced classes | Fails badly with class imbalance|
| IoU | Object detection/segmentation | Strictly penalizes minor errors|
| Dice | Medical imaging | Less intuitive geometric meaning|

💡 Example
A tumor (100 pixels) in an MRI (10,000 pixels) is segmented. The algorithm finds 80
pixels of the tumor (TP), misses 20 (FN), and falsely highlights 10 background pixels
(FP).

• Pixel Accuracy: (80 + 9870) / 10000 = 99.5% (Looks amazing, but misleading).

• IoU: 80 / (80 + 10 + 20) = 80 / 110 = 72.7% (A much more realistic score of

how well the tumor shape was captured).

• Dice: (2 × 80) / ((80+10) + (80+20)) = 160 / 190 = 84.2%.

🔚 Conclusion
Assessing segmentation performance requires metrics that evaluate spatial overlap.
While Pixel Accuracy is easily calculated, it is fundamentally flawed for images with
severe class imbalance (large backgrounds). The Intersection over Union (IoU) and the
Dice Coefficient are the industry standards because they directly measure the overlap
between the prediction and the ground truth, ignoring the vast True Negative
background entirely.

❓ Question 6: Differentiate between image deblurring and

image inpainting.
✅ Answer:
📖 Definition / Introduction
Image deblurring and image inpainting are both advanced restoration techniques, but they solve
fundamentally different problems. Deblurring mathematically reverses a global degradation (like
focus or motion blur) to sharpen the image. Inpainting intelligently hallucinates or reconstructs

12 IP_166
entirely missing or corrupted local regions based on surrounding context.

📝 Detailed Explanation
Key Point 1: Image Deblur
Deblurring (or Deconvolution) deals with images where information is present but
spread out/smeared.

• Cause: Motion of the camera/subject, out-of-focus lenses, or atmospheric

turbulence.

• Model: The image is modeled as a convolution: g = h ∗ f + η.

• Solution: Requires estimating the Point Spread Function (PSF) 'h', and then
applying an inverse process (like Wiener filtering or Richardson-Lucy
deconvolution) to mathematically reverse the spread and sharpen the edges.

• Scope: Usually applied globally to the entire image.

Key Point 2: Image Inpainting

Inpainting deals with images where information is completely missing or destroyed
in specific areas.

• Cause: Physical scratches on old photos, overlaid text/watermarks, or unwanted

objects (e.g., removing a photobomber).

• Model: There is a known "hole" mask in the image. The pixel data inside the
hole is considered irretrievable.

• Solution: Algorithms propagate information from the known boundaries inward.

Techniques include solving partial differential equations (PDEs) to extend
isophotes (lines of equal intensity), patch-based texture synthesis, or modern
Deep Learning (GANs) that understand high-level semantics.

• Scope: Applied locally only to the masked/damaged regions.

Key Point 3: Key Differences

Feature Image Deblurring Image Inpainting

Problem Image is out of focus or Specific parts of the image are
smeared missing/damaged
Information Status Information exists, but is Information in the target area is
scrambled/spread completely gone
Mathematical Process Deconvolution (Inverse Interpolation, Texture
filtering) Synthesis, Generative AI
Knowledge Required Needs Point Spread Function Needs a mask showing where
(PSF) the holes are

13 IP_167
Feature Image Deblurring Image Inpainting
Goal Restore sharpness and edges Seamlessly fill holes to fool the
human eye

📊 Diagram / Table (if applicable)

Deblurring:
[ Smeared Object ] → (Deconvolution) → [ Sharp Object ]
(Information is gathered back to its source)

Inpainting:
[ Good ][ Hole ][ Good ] → (Texture Synthesis) → [ Good ][ Good ][ Good ]
(Information is generated/cloned from neighbors to fill the void)

💡 Example
If you take a photo of a moving race car, the car appears streaked. You apply image
deblurring to reverse the motion blur and read the sponsor logo. If you have an old
family photo that was physically scratched, leaving a white line across someone's face,
you apply image inpainting. The algorithm looks at the skin texture surrounding the
scratch and seamlessly clones it inward to fill the gap.

🔚 Conclusion
While both techniques restore image quality, their methodologies differ drastically.
Image deblurring is an inverse mathematical problem aiming to unscramble smeared
pixels using deconvolution. Image inpainting is a generative problem aiming to
hallucinate missing pixels by smoothly propagating surrounding textures and structures
into a void.

❓ Question 7: Describe the process of feature extraction in an

image.
✅ Answer:
📖 Definition / Introduction
Feature extraction is a crucial dimensionality reduction process in computer vision. It transforms a
large, raw pixel matrix into a compact, numerical vector (feature vector) that captures the most
important, distinctive characteristics of an object. This vector is then used for classification, pattern
recognition, or machine learning.

14 IP_168
📝 Detailed Explanation
Key Point 1: What is a Feature?
A raw 100x100 image contains 10,000 pixels. Feeding all 10,000 pixels into a classifier
is computationally expensive and sensitive to noise, translation, and scale. A feature is
a measurable property or characteristic of the image. Good features are highly
discriminatory (different objects have different features) and robust (they don't change if
the object is rotated or scaled).

Key Point 2: The Feature Extraction Process

1. Preprocessing & Segmentation: Before extraction, the object of interest must be
isolated from the background.

2. Selection of Feature Types: Depending on the application, specific types of features

are chosen:

• Shape Features: Describe the geometry. (e.g., Area, Perimeter, Eccentricity,

Circularity, Fourier Descriptors).

• Texture Features: Describe the spatial arrangement of intensities. (e.g.,

Haralick features using the Gray-Level Co-occurrence Matrix (GLCM), entropy,
contrast).

• Color Features: Describe the chromatic content. (e.g., Color histograms,

dominant colors, color moments).

• Local/Structural Features: Keypoints that are highly distinctive. (e.g., SIFT,

SURF, HOG gradients).

3. Computation: Algorithms parse the segmented object or the whole image to

calculate the numerical values for the selected features.

4. Feature Vector Formulation: The extracted values are concatenated into a 1D array
called the Feature Vector. Example: V = [Area, Eccentricity, Contrast, Entropy] =
[4500, 0.85, 12.4, 3.2]

5. Dimensionality Reduction (Optional but Common): If too many features are

extracted, techniques like Principal Component Analysis (PCA) are used to project
the feature vector into a smaller space, keeping only the most important uncorrelated
data to prevent the "curse of dimensionality".

📊 Diagram / Table (if applicable)

Feature Extraction Pipeline:

[ Segmented Image ]
│
├─→ Shape Extractor ──→ [ Area: 50, Circ: 0.9 ]
│
├─→ Color Extractor ──→ [ Mean Red: 120, Mean Blue: 45 ]
│

15 IP_169
 └─→ Texture Extractor ─→ [ Entropy: 2.1 ]
│
(Concatenation)
│
▼
Feature Vector: [50, 0.9, 120, 45, 2.1]
│
[ Classifier ]

💡 Example
To build a system that sorts apples from bananas on a conveyor belt. The raw images
are segmented to isolate the fruit. Feature extraction computes two values: the major-
to-minor axis ratio (shape) and the average hue value (color). The apple produces a
feature vector of [1.05, Red_Hue] (round and red), while the banana produces [4.20,
Yellow_Hue] (elongated and yellow). A simple classifier can now easily separate them
based on these two numbers rather than processing thousands of pixels.

🔚 Conclusion
Feature extraction acts as an information bottleneck, stripping away redundant pixel
data and retaining only the semantic essence of an object. By calculating shape, texture,
and color metrics and packing them into a feature vector, it transforms complex visual
data into structured numerical data that is highly optimized for machine learning and
pattern recognition algorithms.

❓ Question 8: What is edge linking using local processing?

✅ Answer:
📖 Definition / Introduction
Edge detection algorithms often produce broken, fragmented edges due to noise and uneven
illumination. Edge linking is the process of connecting these disconnected edge segments to form
continuous boundaries. Local processing is a technique for edge linking that analyzes the
characteristics of pixels within a small neighborhood to decide if they should be connected.

📝 Detailed Explanation
Key Point 1: The Need for Edge Linking
Ideally, applying an edge detector (like Sobel) to an object should yield a perfect, closed
contour. In reality, noise and lighting variations cause the resulting edge map to have
gaps. To extract a meaningful boundary, these gaps must be bridged through edge
linking.

16 IP_170
Key Point 2: Edge Linking via Local Processing
Local processing connects edge pixels based on the similarity of their properties within
a small local neighborhood (typically a 3x3 or 5x5 window).

The two primary properties used to determine similarity are:

1. Gradient Magnitude (Strength of the edge): Let M(x,y) be the magnitude.

2. Gradient Direction (Angle of the edge): Let α(x,y) be the direction.

The Linking Algorithm: Let (x,y) be a known edge pixel, and (x', y') be a neighboring
pixel in its local window. They are linked (connected) if both of the following criteria
are met:

1. Magnitude Similarity: The difference in their gradient magnitudes is below a

threshold E. |M(x,y) − M(x',y')| ≤ E

2. Direction Similarity: The difference in their gradient directions is below a

threshold A (angle). |α(x,y) − α(x',y')| ≤ A

If the neighbour qualifies, it is marked as a valid edge pixel and added to the contour.
The window then moves to the newly added pixel, and the process repeats, tracing out
the boundary.

Key Point 3: Advantages and Limitations

• Advantages: Computationally simple, fast, and highly effective for small gaps
and relatively noise-free images.

• Limitations: It only looks at immediate neighbors. It cannot bridge large gaps

effectively and is highly susceptible to severe noise, which can cause the linking
process to stray off the true boundary. For global structures with large gaps, the
Hough Transform is preferred over local linking.

📊 Diagram / Table (if applicable)

Edge Linking Process:

Edge Map with Gap: Gradient Direction Check:

P1 P2 P3 P3(45°)
G1 P4 \
P2(45°) -- G1(45°?)
P1, P2, P3 are edges.
Is G1 an edge pixel?
Check local window around P3. If G1 has similar gradient magnitude
and similar direction (~45°), link P3 to G1.

💡 Example
A Sobel operator is applied to detect the outline of a stop sign. The output shows mostly

17 IP_171
 straight lines, but there is a 2-pixel gap due to a glare on the sign. Using local
processing, the algorithm looks at the pixel at the end of the broken line. It searches a
3x3 window, finds a pixel in the gap that has a weak magnitude (missed by the initial
threshold) but the exact same gradient angle (pointing outward). The algorithm links
them, successfully closing the boundary of the octagon.

🔚 Conclusion
Edge linking using local processing bridges small gaps in edge maps by leveraging the
local continuity of object boundaries. By enforcing constraints on gradient magnitude
and gradient direction within a small neighborhood, it successfully traces and connects
fragmented edge pixels into continuous, meaningful contours, essential for subsequent
shape analysis.

❓ Question 9: Describe image morphing between two images.

✅ Answer:
📖 Definition / Introduction
Image morphing is a digital image processing technique used to create a smooth, fluid transition
from a source image into a target image. It is not a simple cross-fade; it involves simultaneously
warping the shape of the source image to match the target and blending their colors, creating a
highly realistic continuous transformation.

📝 Detailed Explanation
Key Point 1: The Two Components of Morphing
True morphing consists of two simultaneous processes:

1. Geometric Warping (Shape Transformation): Distorting the spatial

coordinates of the images so that the key features of the source image align
perfectly with the key features of the target image.

2. Cross-Dissolving (Color Blending): Gradually fading the pixel intensities

(colors) of the warped source image into the warped target image.

Key Point 2: The Morphing Process

1. Feature Specification: A user or algorithm selects key corresponding feature points
or lines on both the Source Image (I_S) and the Target Image (I_T). Example: If
morphing a man to a tiger, points are placed on the man's eyes, nose, and mouth, and
corresponding points on the tiger's eyes, nose, and mouth.

2. Time Parameter (t): Morphing generates an animation over a normalized time

18 IP_172
 parameter 't' from 0.0 to 1.0.

• At t = 0.0, the image is 100% I_S.

• At t = 1.0, the image is 100% I_T.

• At t = 0.5, the image is exactly halfway between both.

3. Interpolation of Feature Points: For any frame 't', the intermediate position of the
features is calculated using linear interpolation: P_intermediate(t) = (1 - t) × P_source +
t × P_target

4. Geometric Warping:

• The Source image is warped so its features move to P_intermediate.

• The Target image is reverse-warped so its features also align with

P_intermediate.

5. Cross-Dissolving: The final pixel values for frame 't' are a weighted average of the
two warped images: Result(t) = (1 - t) × Warped_Source + t × Warped_Target

Key Point 3: Importance of Warping

If you skip the warping step and only cross-dissolve, you get "ghosting" — an image
with four eyes and two noses simultaneously fading in and out. Warping ensures the
eyes physically slide into the correct position before changing color, creating the
illusion of shape-shifting.

📊 Diagram / Table (if applicable)

Morphing vs Cross-Dissolving (at t=0.5):

Source: Man Target: Cheetah

Cross-Dissolve Only: Produces a blurry image showing a transparent man

superimposed over a transparent cheetah.

Morphing: Produces a crisp image of a "Man-Cheetah" hybrid.

The jaw has widened, the nose has shifted up, and
the skin texture is 50% skin, 50% fur.

💡 Example
Morphing is famously used in cinema (e.g., the liquid metal T-1000 in Terminator 2, or
the music video for Michael Jackson's "Black or White"). To morph a car into an SUV,
points are mapped on the wheels, roof, and headlights. At t=0.5, the roof geometrically
stretches upward (warping) while the paint color gradually shifts from red to blue
(cross-dissolving), producing seamless intermediate frames of a crossover vehicle.

19 IP_173
🔚 Conclusion
Image morphing is a powerful visual effect that combines geometric spatial warping
with photometric cross-dissolving. By defining corresponding feature points and
interpolating their positions and colors over a time parameter, morphing produces a
fluid, realistic shape-shifting transition between two completely different images,
preventing the ghosting artifacts inherent in simple fading.

❓ Question 10: What is the difference between lossless and

lossy image compression?
✅ Answer:
📖 Definition / Introduction
Image compression reduces the amount of data required to represent a digital image, saving storage
space and transmission bandwidth. It is categorized into two fundamental types: Lossless
compression, which guarantees exact reconstruction of the original image, and Lossy
compression, which permanently discards some visual data to achieve much higher compression
ratios.

📝 Detailed Explanation
Key Point 1: Lossless Compression
Concept: Reduces file size by eliminating statistical redundancy in the data without
discarding any actual information.

• Reconstruction: The decompressed image is bit-for-bit identical to the original

image. There is zero degradation in quality.

• Compression Ratio: Generally low (typically 2:1 to 3:1).

• Algorithms: Run-Length Encoding (RLE), Huffman Coding, LZW (Lempel-

Ziv-Welch), Arithmetic Coding.

• File Formats: PNG, GIF, TIFF, BMP, RAW.

• Best Use Cases: Medical imaging (where modifying a pixel could hide a tumor),
text documents, line drawings, and archiving original source files.

Key Point 2: Lossy Compression

Concept: Reduces file size by eliminating psychovisual redundancy — information
that the human eye cannot easily perceive (like high-frequency micro-textures or slight
color variations).

• Reconstruction: The decompressed image is an approximation of the original.

20 IP_174
 Data is permanently lost and cannot be recovered.

• Compression Ratio: Highly adjustable and generally very high (10:1 up to 50:1
or more).

• Algorithms: Discrete Cosine Transform (DCT) combined with Quantization,

Wavelet Transforms, Fractal Compression.

• File Formats: JPEG, WebP, HEIC.

• Best Use Cases: Digital photography, web images, video streaming, and
situations where storage space/bandwidth is critical and minor quality loss is
acceptable.

Key Point 3: Comparison

Feature Lossless Compression Lossy Compression

Data Loss None. Exact recovery. Permanent loss of imperceptible
data.
Compression Ratio Low (~2x smaller) High (10x to 50x smaller)
Image Quality Perfect (100% original) Degrades as compression
increases (artifacts)
Redundancy Targeted Statistical (coding redundancy) Psychovisual (human eye
limitations)
Re-saving Effect Can be re-saved infinitely with Generation loss (degrades every
no issue time it is saved)
Formats PNG, GIF JPEG

📊 Diagram / Table (if applicable)

Original Image (10 MB)
│
├────→ Lossless Compression (e.g., PNG) ──→ File Size: 5 MB
│ Decompressed ──→ 100% Identical to Original
│
└────→ Lossy Compression (e.g., JPEG) ───→ File Size: 1 MB
Decompressed ──→ Visually similar, mathematically different

💡 Example
You take a high-resolution photograph of a landscape. If you save it as a PNG
(lossless), the algorithm finds repeating patterns in the blue sky and compresses them,
yielding a 10MB file that retains every exact pixel value. If you save it as a JPEG
(lossy), the algorithm completely deletes very fine, high-frequency details in the grass
that your eye barely notices anyway, yielding a 1MB file. However, if you zoom in
closely on the JPEG, you will see "blocky" artifacts that don't exist in the PNG.

21 IP_175
🔚 Conclusion
The choice between lossy and lossless compression is a trade-off between file size and
data integrity. Lossless compression uses statistical algorithms to reduce size without
altering a single pixel, essential for medical and technical imaging. Lossy compression
utilizes human visual limitations to discard imperceptible data, achieving massive file
size reductions that make modern digital photography and internet media possible.

❓ Question 11: What is the full form of JPEG? Define the JPEG
compression algorithm.
✅ Answer:
📖 Definition / Introduction
JPEG stands for Joint Photographic Experts Group, the committee that created the standard. The
JPEG compression algorithm is a standardized, lossy image compression method specifically
designed for continuous-tone photographic images. It achieves high compression ratios by
transforming the image into the frequency domain and quantizing high-frequency data.

📝 Detailed Explanation
The JPEG Compression Algorithm Pipeline
JPEG compression is not a single equation, but a sequence of distinct steps:

Step 1: Color Space Conversion

• The image is converted from the RGB color space to the YCbCr color space.

• Y represents luminance (brightness).

• Cb and Cr represent chrominance (color).

• Why? The human eye is much more sensitive to brightness than to color.

Step 2: Chroma Subsampling

• The resolution of the Cb and Cr channels is reduced (e.g., 4:2:0 subsampling

cuts color resolution in half horizontally and vertically).

• This discards 50% of the data almost immediately with negligible visual impact.

Step 3: Block Splitting

22 IP_176
 • The image is divided into non-overlapping 8 × 8 pixel blocks. Each block is
processed independently from here on.

Step 4: Forward Discrete Cosine Transform (FDCT)

• The 2D DCT is applied to each 8×8 block, converting spatial pixel values into
64 frequency coefficients.

• The top-left coefficient is the DC (average brightness), and the others are AC
(high frequencies). Energy is compacted into the top-left corner.

Step 5: Quantization (The Lossy Step)

• This is where compression and data loss occur. Each of the 64 coefficients is
divided by a corresponding number in a Quantization Table and rounded to the
nearest integer.

• High-frequency coefficients are divided by large numbers, mostly turning them

into zeros.

• Lower quality settings use larger numbers in the quantization table, producing
more zeros.

Step 6: Zig-zag Scanning

• The 8×8 matrix is rearranged into a 1D array using a zig-zag pattern starting
from the top-left.

• This groups the non-zero low-frequency coefficients together, followed by long,

continuous runs of zeros.

Step 7: Entropy Coding

• The 1D array undergoes Run-Length Encoding (RLE) (compressing the long

runs of zeros into simple "skip N zeros" commands).

• Finally, Huffman Coding (a lossless technique) compresses the resulting data

by assigning shorter binary codes to frequently occurring numbers.

📊 Diagram / Table (if applicable)

JPEG Pipeline:

[RGB Image]
↓ (Color Conversion)
[YCbCr Image]
↓ (Subsampling)
[Divide into 8x8 Blocks]
↓
[2D DCT] → Generates Frequency Coefficients
↓
[Quantization] → Divides by Q-Table & Rounds (Creates Zeros) *LOSSY STEP*
↓

23 IP_177
 [Zig-Zag Scan] → Groups zeros together
↓
[RLE & Huffman Coding] → Lossless binary compression
↓
[ .JPG File ]

💡 Example
In an 8x8 block of blue sky, pixel values change very slowly. The DCT transforms this
block into a large DC coefficient and extremely small high-frequency coefficients.
During Quantization, these small coefficients are divided and rounded exactly to 0. The
Zig-zag scan organizes the data as [DC, small_number, 0, 0, 0...0]. Run-length encoding
records this as "DC, small_number, End of Block". 64 numbers are reduced to 3,
achieving massive compression.

🔚 Conclusion
The JPEG algorithm is a masterclass in exploiting human visual perception. By
converting to YCbCr to discard color data, using the DCT to isolate high frequencies,
aggressively quantizing those frequencies into zeros, and finally packing the remaining
data with Huffman coding, JPEG transforms massive bitmaps into tiny files while
retaining photographic realism, establishing it as the standard for internet imagery.

❓ Question 12: What is compression ratio? What are the

different image compression techniques?
✅ Answer:
📖 Definition / Introduction
The Compression Ratio (CR) is the primary metric used to quantify the efficiency of an image
compression algorithm. Image compression techniques are broad mathematical strategies used to
reduce the size of image data, categorized primarily into spatial-domain coding, transform coding,
and dictionary-based coding.

📝 Detailed Explanation
Key Point 1: Compression Ratio
Compression Ratio (CR) measures how much smaller the compressed file is compared
to the original, uncompressed data.

Formula: CR = Size of Original Image / Size of Compressed Image

• A CR of 10 means the compressed file is 1/10th the size of the original (a 10:1

24 IP_178
 ratio).

• Data Redundancy (R): Relative data redundancy is calculated as R = 1 -

(1/CR). If CR = 10, then R = 0.9 (90% of the original data was redundant).

Note: While higher CR saves space, in lossy compression, it comes at the direct cost of
image quality.

Key Point 2: Different Image Compression Techniques

Image compression techniques target three types of redundancy: Coding (pixel bit
allocation), Spatial (interpixel correlation), and Psychovisual (human eye limits).

1. Entropy Coding (Lossless): Reduces coding redundancy by assigning shorter codes

to more frequent pixel values.

• Huffman Coding: Assigns variable-length binary codes based on probability.

• Arithmetic Coding: Encodes the entire image as a single fractional number

between 0 and 1. Highly efficient.

2. Dictionary / String-based Coding (Lossless): Replaces repeating sequences of

pixels with references to a dictionary.

• LZW (Lempel-Ziv-Welch): Used in GIF and TIFF formats. It builds a

dictionary on the fly as it reads the image.

3. Run-Length Encoding (RLE) (Lossless): Reduces spatial redundancy. Instead of

writing [White, White, White, White, White], it writes [5, White]. Excellent for binary
images and text.

4. Predictive Coding (Lossless or Lossy): Reduces spatial redundancy by guessing the

value of a pixel based on its neighbors. Only the error (difference between guess and
actual) is encoded.

• DPCM (Differential Pulse Code Modulation): Since error values are usually
small, they require fewer bits to store.

5. Transform Coding (Lossy): Reduces spatial and psychovisual redundancy by

transforming the image into the frequency domain.

• DCT (Discrete Cosine Transform): Core of JPEG.

• Wavelet Transform: Core of JPEG 2000. Provides multi-resolution analysis

and better compression without blocky artifacts.

6. Vector Quantization (Lossy): Groups pixels into blocks (vectors) and replaces each
block with an index pointing to the closest matching block in a predefined "codebook".

25 IP_179
📊 Diagram / Table (if applicable)
Summary of Compression Techniques:

| Category | Technique | Loss Type | Reduces

Redundancy | Application |

|-------------------|---------------------------|------------|------------------
--|-------------|
| Entropy Coding | Huffman, Arithmetic | Lossless | Coding
| ZIP, PNG |
| Mapping | Run-Length Encoding (RLE) | Lossless | Spatial
| BMP, Fax |
| Dictionary | LZW | Lossless | Spatial
| GIF, TIFF |
| Predictive | DPCM | Both | Spatial
| Audio/Video |
| Frequency Domain | DCT, Wavelets | Lossy | Psychovisual
| JPEG, WebP |

Compression Ratio Example:

Original = 1,000 KB. Compressed = 100 KB.
CR = 1000 / 100 = 10 (or 10:1)

💡 Example
A simple fax machine uses Run-Length Encoding (RLE) to compress documents. A
blank white line of 800 pixels is compressed into just two numbers (800, White),
achieving a massive compression ratio losslessly. A modern smartphone uses
Transform Coding (DCT) to compress a 12-megapixel photo. The raw sensor data is
36 MB, but the resulting JPEG is only 3.6 MB, yielding a compression ratio of 10:1 by
utilizing lossy psychovisual reduction.

🔚 Conclusion
Compression ratio is the definitive metric for evaluating compression efficiency. The
landscape of compression techniques offers a spectrum of solutions depending on the
requirement: Entropy, RLE, and LZW coding provide exact lossless preservation by
targeting statistical data redundancies, whereas Transform and Predictive coding utilize
mathematical transformations and human visual limitations to achieve the massive lossy
compression ratios required by modern digital media.

💡 More questions will be added as provided by Rishav.

🎓 Documented by

26 IP_180