Introduction to Imaging

Introduction to Imaging

• Imaging produces pictures of objects using radiation such as visible light, X-rays, and ultrasound.
• Mathematics is crucial for creating image processing software and designing lenses.

Digital Image

• A digital image represents a scene as a 2D array of pixels.
• A pixel has a discrete value representing a physical quantity.
• These images are stored and processed by computers.
• In a grayscale image, each pixel has a brightness value between 0 (black) and 255 (white).
• A color image has three channels: red, green, and blue (RGB).

Continuous Image

• A continuous image maps a 2D point to a value, represented by the function (I: \mathbb{R}^2 \rightarrow \mathbb{R}).
• The value represents a physical quantity and are mathematical abstractions.

Grayscale Image as a Function

• A grayscale image can be represented as a function (I(x,y)), where ((x, y)) are spatial coordinates.
• (I(x, y)) denotes the intensity at point ((x, y)), with the intensity value being a real number between 0 and 1.

Color Image as a Function

• A color image is represented as a vector-valued function $I(x,y) = \begin{bmatrix} R(x,y) \ G(x,y) \ B(x,y) \end{bmatrix}$.
• (R(x, y)), (G(x, y)), and (B(x, y)) are the red, green, and blue components, respectively.
• The intensity values for the color components are real numbers between 0 and 1.

Image Processing Operations

• Image processing operations are mathematical functions that transform one image into another.
• Image processing operations can enhance images, extract information from images and compress image data.

Image Filtering

• Image filtering modifies pixel values based on neighboring pixel values.
• Image segmentation partitions an image into multiple regions.
• Image registration aligns multiple images of the same scene.

Linear Filtering

• Linear filtering replaces each pixel with a weighted sum of its neighbors.
• The weights are determined by a filter kernel.
• Linear filtering can blur, sharpen, and detect edges in images.

Convolution

• Convolution is a math operation expressing one functions overlap as it is shifted over another.
• In image processing, it implements linear filtering.
• The convolution is defined as ((I * K)(x,y) = \sum_{u=-\infty}^{\infty} \sum_{v=-\infty}^{\infty} I(u,v)K(x-u, y-v)).

Blurring Filter Example

• A blurring filter replaces pixel values with the average of its neighbors.
• The Gaussian filter is a common blurring filter and looks like this (G(x,y) = \frac{1}{2\pi\sigma^2}e^{-\frac{x^2+y^2}{2\sigma^2}}).
• (\sigma) represents the standard deviation of the Gaussian distribution.
• The larger the (\sigma), the more blurred the image.

Image Segmentation Definition

• Image segmentation partitions an image into multiple regions to simplify its representation.

Segmentation Methods

• Thresholding assigns pixels to regions based on intensity values.
• Edge-based segmentation defines regions based on edges.
• Region-based segmentation grows regions from seed points based on similarity criteria.
• Clustering groups pixels into regions based on their features.

Thresholding Example

• Thresholding partitions an image into two regions based on a threshold value.
• Pixels above the threshold are assigned to one region, and those below the threshold are assigned to another.
• Thresholding separates objects from the background and creates binary masks.

Image Registration Definition

• Image registration aligns two or more images of the same scene.
• The goal is to overlay images from different modalities, track changes over time, and create panoramic images.

Registration Methods

• Feature-based registration identifies corresponding features to estimate the transformation between images.
• Intensity-based registration uses intensity values to estimate the transformation.

Feature-Based Registration Example

• Involves feature detection, feature matching, transformation estimation, and image resampling.

Conclusion on Imaging

• Mathematics is essential for image formation and processing, including designing lenses, developing algorithms for medical scanners, and creating image processing software.

Information Channels

• A channel is the physical medium through which symbols are transmitted, but is not perfect due to noise.
• Channels can be modeled probabilistically, with discrete input and output alphabets.
• A channel is memoryless if (p(y_n|x_1, x_2,..., x_n, y_1,..., y_{n-1}) = p(y_n|x_n)).

Channel Capacity Definition

• Capacity (C) is the amount of information reliably sent through a channel.
• (C) is mathematically defined as (C = \max_{p(x)} I(X;Y)) measured in bits per channel use.

Noiseless Channel Example

• In a noiseless channel, the output is exactly the same as the input.
• If (X = Y = {0, 1}) and (p(y|x) = 1) if (y=x), else (0), then (H(Y|X) = 0).
• Capacity is achieved when the input distribution is uniform.

Noisy Channel with Non-Overlapping Outputs Example

• Even with a probability of erasure, if the non-erased outputs are distinct, we can recover the input.

Noisy Typewriter Example

• Each letter maps to the next with probability 1, resulting in channel capacity (C = \log(26)).

Binary Symmetric Channel

• With error probability p, the channel capacity (C = 1 - H(p)).

Binary Erasure Channel (BEC)

• With erasure probability (\alpha), the channel capacity (C = 1 - \alpha).

Properties of Channel Capacity

• (0 \leq C \leq \min(\log |X|, \log |Y|))
• (C \geq 0) because (I(X;Y) \geq 0)
• (C \leq \min(\log |X|, \log |Y|)) because (I(X;Y) \leq \min(H(X), H(Y)) \leq \min(\log |X|, \log |Y|))

Lists

• Lists are ordered sequences of elements of the same type.

Types of Lists

• Contiguous lists store elements in contiguous memory (arrays).
• Linked lists store elements in non-contiguous memory, linked by pointers.

List Operations

• Common operations include insertion, deletion, search, access, and sort.
• Insertion and deletion are costly in contiguous lists because they require shifting elements.

Stacks

• Stacks are linear data structures based on the LIFO principle.

Stack Operations

• Push adds an element to the top.
• Pop removes the top element.
• Top accesses the top element.
• isEmpty checks if the stack is empty.

Stack Implementation

• Stacks can be implemented with an array or linked list.

Stack Applications

• Stacks are used for evaluating expressions, managing function calls, tree traversals, and undo/redo features.

Queues

• Queues are linear data structures based on the FIFO principle.

Queue Operations

• Enqueue adds an element to the end.
• Dequeue removes the element from the front.
• Front accesses the front element.
• isEmpty checks if the queue is empty.

Queue Implementation

• Queues can be implemented with an array or linked list.
• Circular arrays are used to avoid shifting elements.

Types of Queues

• Simple queues follow FIFO.
• Priority queues remove elements based on priority.

Queue Applications

• Queues are used for task and process management, simulations, tree traversals, and inter-process communication.

Lorentz Force

• The force (\overrightarrow{F}) on a charge (q) moving with velocity (\overrightarrow{v}) in a magnetic field (\overrightarrow{B}) is (\overrightarrow{F} = q\overrightarrow{v} \times \overrightarrow{B}).
• The force is perpendicular to both (\overrightarrow{v}) and (\overrightarrow{B}).
• The magnitude of the Lorenz force is (F = qvB\sin\theta), where (\theta) is the angle between (\overrightarrow{v}) and (\overrightarrow{B}).
• Use the right-hand rule to determine the direction of the force: point fingers in direction of (\overrightarrow{v}), curl towards (\overrightarrow{B}), thumb points in direction of (\overrightarrow{F})

Units of the Lorenz force

• (F) is in Newtons (N)
• (q) is in Coulombs (C)
• (v) is in meters per second (m/s)
• (B) is in Tesla (T)

Force on a current-carrying wire

• The force on a straight wire of length $l$ carrying a current $I$ in a magnetic field $\overrightarrow{B}$ is: (\overrightarrow{F} = I\overrightarrow{l} \times \overrightarrow{B})
• The magnitude is (F = I l B \sin\theta), where (\theta) is the angle between (\overrightarrow{l}) and (\overrightarrow{B}).