affin transzformáció

Kiejtés

  • IPA: [ ˈɒfːintrɒnsformaːt͡sijoː]

Főnév

affin transzformáció

  1. (matematika) Az affin transzformáció az affin geometriában használt, illetve a lineáris algebra részeként is tárgyalható fogalom. Egy affin transzformáció során a transzformált koordináták az eredeti koordináták lineáris függvényeként állnak elő. Ide tartoznak a lineáris transzformációk.

Affin transzformáció

Az affin transzformáció egy geometriai transzformáció, amely megőrzi a pontok közötti egyeneseket és párhuzamosokat, de általánosságban torzíthatja a méreteket és szögeket. Az affin transzformációk széles körben alkalmazhatók számítógépes grafikában, képfeldolgozásban és térgeometriában.

Általános definíció

Egy affin transzformáció \( T: \mathbb{R}^n \to \mathbb{R}^n \) függvény, amely az alábbi formában írható fel:  

  • **\( \mathbf{x} \)**: Az eredeti pont \((x, y)\).
  • **\( A \)**: Egy \( n \times n \)-es mátrix, amely a lineáris transzformációt reprezentálja (pl. forgatás, nyújtás, nyírás).
  • **\( \mathbf{b} \)**: Egy eltolási vektor, amely az eredeti pontot eltolja.

2D affin transzformáció

Kétdimenziós térben az affin transzformáció így néz ki:  

Ahol:

  • \( a, b, c, d \): a lineáris transzformáció elemei (forgatás, nyírás, skálázás).
  • \( e, f \): az eltolás komponensei.

Alapvető transzformációk mátrix formában

1. Eltolás (Translation):  

2. Skálázás (Scaling):  

3. Forgatás (Rotation):  

4. Nyírás (Shearing):  

Python implementáció

import numpy as np

def affine_transform(point, matrix, translation):
    """
    Affin transzformáció alkalmazása egy pontra.
    :param point: Az eredeti pont (x, y)
    :param matrix: Az affin mátrix (2x2)
    :param translation: Az eltolási vektor (e, f)
    :return: A transzformált pont (x', y')
    """
    point = np.array(point)
    matrix = np.array(matrix)
    translation = np.array(translation)
    
    transformed_point = np.dot(matrix, point) + translation
    return transformed_point

# Példa adatok
point = (2, 3)
matrix = [[1, 0], [0, 1]]  # Egységmátrix (nincs forgatás vagy nyírás)
translation = [5, -2]  # Eltolás (5, -2)

result = affine_transform(point, matrix, translation)
print("Transzformált pont:", result)

C++ implementáció

#include <iostream>
#include <Eigen/Dense>

using namespace std;
using namespace Eigen;

Vector2f affineTransform(const Vector2f& point, const Matrix2f& matrix, const Vector2f& translation) {
    return matrix * point + translation;
}

int main() {
    Vector2f point(2, 3);  // Eredeti pont
    Matrix2f matrix;       // Affin mátrix
    matrix << 1, 0,        // Egységmátrix (nincs forgatás vagy nyírás)
              0, 1;
    Vector2f translation(5, -2);  // Eltolás vektor

    Vector2f transformedPoint = affineTransform(point, matrix, translation);
    cout << "Transzformált pont: (" << transformedPoint[0] << ", " << transformedPoint[1] << ")" << endl;

    return 0;
}

Affin transzformáció homogén koordinátákkal

A homogén koordinátarendszer lehetővé teszi, hogy az eltolást is mátrixműveletekkel kezeljük. Ehhez a \( (x, y) \) pontot \( (x, y, 1) \)-re bővítjük.

Mátrix homogén formában:  

Összegzés

Az affin transzformáció rugalmas eszköz geometriai manipulációkhoz:

  • Különböző transzformációkat (forgatás, skálázás, nyírás, eltolás) képes kombinálni.
  • Számítógépes grafikában és képfeldolgozásban alapvető fontosságú.

A fenti Python és C++ implementációk az alapvető működést mutatják be, homogén koordinátákkal és összetett transzformációk esetén pedig tovább bővíthetők.

Fordítások