ddg.math.projective module

Utility functions for the projective module.

ddg.math.projective.homogenize(vector)[source]

Homogenize a coordinate vector by inserting a 1.

Parameters:

vectornumpy.ndarray of shape (n,): The vector to be homogenized.

Returns:

numpy.ndarray of shape (n+1,)

ddg.math.projective.dehomogenize(vector, atol=None, rtol=None)[source]

Pick an affine representative for a homogeneous coordinate vector.

Parameters:

vectornumpy.ndarray of shape (n+1,): The vector to be dehomogenized.
atol, rtolfloat (default=None): This function uses the global tolerance defaults if atol or rtol are set to None. See ddg.nonexact for details.

Returns:

numpy.ndarray of shape (n,)

ddg.math.projective.in_general_position(points)[source]

Checks whether a list of k+1 points in n-dimensional projective are in general position.

Parameters:

pointslist: List of numpy.ndarray of shape (n+1,)

Returns:

bool: True if the points are in general position, False otherwise.

Raises:

ValueError: If no points are given.

Notes

If k <= n, we test whether their lifts in (n+1)-dimensional space are linearly independent. If k > n, we test whether any (n+1)-subset of them is contained in a hyperplane of n-dimensional projective space.

ddg.math.projective.is_projective_frame(points)[source]

Checks whether a list of n+2 points in n-dimensional projective space form a projective frame.

Parameters:

pointslist: List of numpy.ndarray of shape (n+1,)

Returns:

bool: True if the points are a projective frame, False otherwise.

Raises:

ValueError: If no points are given.

Notes

A list of n+1 fundamental points and one unit point in projective space are called a projective frame if they are in general position.

ddg.math.projective.point_of_intersection(planes, homogeneous_coords=True)[source]

Computes the point of intersection of given hyperplanes (in dual coordinates). If more hyperplanes are given than the dimension of the space, a least square solution is computed.

E.g. in RP^3 it computes the intersection of (at least) three given planes.

Parameters:

planeslist: List of planes given in dual coordinates, i.e. by a vector of the form (a,-b) for a.T * x - b = 0

Returns:

intersectionarray: Intersection of the given planes

ddg.math.projective.affine_transformation(A, b)[source]

Assemble affine transformation.

Given a matrix A and a vector b, assemble the projective transformation

     A | b
F =  --|---
     0 | 1

It corresponds in affine coordinates to the affine transformation x -> Ax + b.

Parameters:

Anumpy.ndarray of shape (n, m)
bnumpy.ndarray of shape (n,)

Returns:

Fnumpy.ndarray of shape (n+1, m+1)

ddg.math.projective.decompose_affine_transformation(F, atol=None, rtol=None)[source]

Decompose affine transformation.

Given a projective transformation

     A | b
F =  --|---
     0 | s

disassemble it into a matrix A/s and a vector b/s.

Parameters:

Fnumpy.ndarray of shape (n+1, m+1)
atol, rtolfloat (default=None): This function uses the global tolerance defaults if atol or rtol are set to None. See ddg.nonexact for details.

Returns:

Anumpy.ndarray of shape (n, m)
bnumpy.ndarray of shape (n,)

ddg.math.projective.decompose_similarity(F, atol=None, rtol=None)[source]

Decompose a similarity transformation into scaling, orthogonal matrix and translation.

Parameters:

Fnumpy.ndarray of shape (n+1, m+1)
atol, rtolfloat (default=None)

Returns:

sfloat: Scaling factor
Onumpy.ndarray of shape (n, m): Orthogonal matrix
bnumpy.ndarray of shape (n,): Translation vector
atol, rtolfloat (default=None)

Raises:

ValueError: If F does not represent a similarity embedding.

ddg.math.projective.affine_component_transformation(n, before, after=-1)[source]

Transformation transforming between affine pictures.

If an object dehomogenized wth affine component before produces a certain affine picture, the object transformed with F will produce the same picture when dehomogenized with affine component after.

Parameters:

nint: Size of returned matrix
beforeint
afterint (default=-1)

Returns:

Fnumpy.ndarray of shape (n, n)

ddg.math.projective.translation(normal, direction, atol=None, rtol=None)[source]

Projective translation.

Returns the matrix

I + direction @ normal.T

This transformation fixes all vectors v in the hyperplane orthogonal to normal. It can also be thought of as mapping

v -> v + dot(normal, v) * direction

Parameters:

normal, directionnumpy.ndarray of shape (n,): direction must lie in the hyperplane orthogonal to normal.
atol, rtolfloat (default=None): This function uses the global tolerance defaults if atol or rtol are set to None. See ddg.nonexact for details.

Returns:

numpy.ndarray of shape (n, n)

Raises:

ValueError

If the dimensions of normal and direction do not match.
If direction is not orthogonal to normal.

ddg.math.projective.translations_from_quad_3d(x00, x10, x11, x01, atol=None, rtol=None)[source]

Translations that map along a quadrilateral in RP2.

Returns two projective translations T1, T2 of RP2 such that

       T1
  x01 ---> x11
   ^        ^
T2 |        | T2
   |        |
  x00 ---> x10
       T1

Parameters:

x00, x10, x11, x01numpy.ndarray of shape (3,)
atol, rtolfloat (default=None): This function uses the global tolerance defaults if atol or rtol are set to None. See ddg.nonexact for details.

Returns:

T1, T2numpy.ndarray of shape (4, 4)

ddg.math.projective.translations_from_quad_4d(x00, x10, x11, x01, n, atol=None, rtol=None)[source]

Translations that map along a quadrilateral in a plane in RP3.

Returns two projective translations T1, T2 of RP3 such that

       T1
  x01 ---> x11
   ^        ^
T2 |        | T2
   |        |
  x00 ---> x10
       T1

Parameters:

x00, x10, x11, x01, nnumpy.ndarray of shape (4,): The corners of the quadrilateral must lie in the plane orthogonal to n.
atol, rtolfloat (default=None): This function uses the global tolerance defaults if atol or rtol are set to None. See ddg.nonexact for details.

Returns:

T1, T2numpy.ndarray of shape (4, 4)