A geometric transformation in computer graphics and multimedia applications refers to a change in position, size, shape or orientation of an object or image. Some common examples of geometric transformations include translation, rotation, scaling and reflection. These transformations can be performed using mathematical algorithms and matrices to manipulate the coordinates of an object in a 2D or 3D space. The result of these transformations can be visualized on a computer screen to produce the desired effect.

## 2D Transformation

2D transformations refer to the transformations applied to objects or images in a 2D plane. Some common types of 2D transformations include:

- Translation: A translation moves an object from one position to another without changing its orientation or size.
- Rotation: A rotation changes the orientation of an object around a fixed point, known as the origin.
- Scaling: A scaling transformation changes the size of an object, either uniformly (isotropic scaling) or non-uniformly (anisotropic scaling).
- Shear: A shear transformation changes the shape of an object, moving its parallel sides closer together or further apart.
- Reflection: A reflection transformation creates a mirror image of an object across a specified axis.

These transformations are typically performed using matrix operations, where the object’s coordinates are transformed according to a transformation matrix. The transformed coordinates are then used to render the object in its new position, orientation, size, or shape

## Homogeneous Coordinates and Matrix Representation of 2D

Transformations

Homogeneous coordinates are a method of representing 2D points and vectors in a three-dimensional space. In homogeneous coordinates, each 2D point (x, y) is represented as a 3D point (x, y, w) where w ≠ 0. This allows for more concise and efficient representation of certain types of transformations, such as translations and projective transformations.

The matrix representation of 2D transformations using homogeneous coordinates is represented by 3×3 matrices, where the last row is always [0, 0, 1]. The matrix multiplication between the transformation matrix and the homogeneous coordinates of a point results in the transformed coordinates of the point.

For example, the translation matrix for a translation by (dx, dy) can be represented as:

[ 1 0 dx ]

[ 0 1 dy ]

[ 0 0 1 ]

The rotation matrix for a rotation by angle θ can be represented as:

[ cos(θ) -sin(θ) 0 ]

[ sin(θ) cos(θ) 0 ]

[ 0 0 1 ]

The scaling matrix for a uniform scaling by factor s can be represented as:

[ s 0 0 ]

[ 0 s 0 ]

[ 0 0 1 ]

By using matrix representation of transformations, multiple transformations can be combined into a single matrix, allowing for efficient and concise representation of complex transformations.

### representation of 2d transformation

The matrix representation of 2D transformations is a mathematical way of representing the changes that occur to an object as a result of a transformation. The transformation matrix, which is a 2×2 or 3×3 matrix, defines how the coordinates of an object are transformed. The transformation is then performed by matrix multiplication between the transformation matrix and the original coordinates of the object.

For example, the matrix representation of a 2D translation can be given as:

[ 1 0 dx ]

[ 0 1 dy ]

Where (dx, dy) represents the translation vector. To perform the translation, the original coordinates (x, y) are multiplied with the transformation matrix:

[ x’ ] [ 1 0 dx ] [ x ]

[ y’ ] = [ 0 1 dy ] * [ y ]

[ 1 ] [ 0 0 1 ] [ 1 ]

The result (x’, y’) are the transformed coordinates of the object.

Similarly, the matrix representation of a 2D rotation can be given as:

[ cos(θ) -sin(θ) ]

[ sin(θ) cos(θ) ]

Where θ is the angle of rotation. To perform the rotation, the original coordinates (x, y) are multiplied with the transformation matrix:

[ x’ ] [ cos(θ) -sin(θ) ] [ x ]

[ y’ ] = [ sin(θ) cos(θ) ] * [ y ]

The result (x’, y’) are the transformed coordinates of the object.

The matrix representation of a 2D scaling can be given as:

[ sx 0 ]

[ 0 sy ]

Where (sx, sy) represents the scaling factors along the x and y axes, respectively. To perform the scaling, the original coordinates (x, y) are multiplied with the transformation matrix:

[ x’ ] [ sx 0 ] [ x ]

[ y’ ] = [ 0 sy ] * [ y ]

The result (x’, y’) are the transformed coordinates of the object.

## composition of 2D transformations

The composition of 2D transformations refers to the application of multiple transformations to an object, one after the other, to achieve a desired result. The order in which the transformations are applied can have a significant impact on the final result.

In matrix representation, the composition of transformations can be represented as matrix multiplication, where the matrices representing each transformation are multiplied together in the desired order.

For example, if we have a translation matrix T, a rotation matrix R, and a scaling matrix S, the composition of these transformations can be represented as:

A = S * R * T

This means that first, a translation is applied (T), then a rotation (R), and finally a scaling (S).

To apply the transformations to a given point (x, y), we simply multiply the point with the composition matrix A:

[ x’ ] [ S * R * T ] [ x ]

[ y’ ] = [ ] * [ y ]

[ 1 ] [ ] [ 1 ]

The result (x’, y’) are the transformed coordinates of the point, reflecting the combined effect of all three transformations.

It’s important to note that the order of transformations affects the final result, so it’s important to choose the right order depending on the desired outcome. In some cases, it may be necessary to use the inverse of a transformation matrix to undo its effect, or to switch the order of transformations.

## the Window-to-Viewport Transformations

Window-to-Viewport transformations are used in computer graphics to map a 2D world-coordinate system (the “window”) to a 2D screen-coordinate system (the “viewport”). This mapping is necessary to display the graphical objects in a way that fits the screen.

The window-to-viewport transformation can be represented as a matrix multiplication of the form:

[ x’ ] [ sx 0 tx ] [ x ]

[ y’ ] = [ 0 sy ty ] * [ y ]

[ 1 ] [ 0 0 1 ] [ 1 ]

Where:

- (x, y) are the original window coordinates of a point
- (x’, y’) are the transformed viewport coordinates of the point
- (sx, sy) are the scaling factors along the x and y axes, respectively
- (tx, ty) are the translation factors along the x and y axes, respectively

The scaling factors (sx, sy) are used to stretch or shrink the window coordinates so that they fit the viewport. The translation factors (tx, ty) are used to shift the origin of the window coordinates to a different location within the viewport.

It’s important to note that the window-to-viewport transformation does not change the aspect ratio of the objects. This means that the relative proportions of the objects are preserved, even though their size may change. This is important to ensure that the objects are displayed correctly on the screen, without being distorted.

## Introduction to 3D Transformations Matrix.

3D transformations are used in computer graphics to manipulate 3D objects in a virtual world. A 3D transformation matrix is used to represent a 3D transformation, just like a 2D transformation matrix represents a 2D transformation.

A 3D transformation matrix can represent a combination of translation, rotation, and scaling operations in 3D space. The matrix representation of a 3D transformation allows for efficient computation and application of the transformations to 3D objects.

For example, a 3D translation matrix can be represented as:

[ 1 0 0 tx ]

[ 0 1 0 ty ]

[ 0 0 1 tz ]

[ 0 0 0 1 ]

Where (tx, ty, tz) are the translation factors along the x, y, and z axes, respectively.

A 3D rotation matrix can be represented as:

[ cos(θ) -sin(θ) 0 0 ]

[ sin(θ) cos(θ) 0 0 ]

[ 0 0 1 0 ]

[ 0 0 0 1 ]

Where θ is the angle of rotation.

A 3D scaling matrix can be represented as:

[ sx 0 0 0 ]

[ 0 sy 0 0 ]

[ 0 0 sz 0 ]

[ 0 0 0 1 ]

Where (sx, sy, sz) are the scaling factors along the x, y, and z axes, respectively.

The composition of 3D transformations is similar to the composition of 2D transformations, where multiple transformations can be combined into a single matrix to achieve the desired result. To apply a 3D transformation to a given point (x, y, z), the point is multiplied by the transformation matrix to obtain the transformed point.