arim.geometry#

Utilities for geometric operations: translation, rotation, change of basis, etc.

Points#

A Points object contains the Cartesian coordinates of one or more points. The points can be stored as a ndarray. However ray tracing and many parts of arim expects as input an 1d array of points.

Function points_1d_wall_z() provides an easy way to create a flat line. For more complicated lines and surfaces, create the points manually.

Oriented points#

An oriented point is defined as a point and three orthonormal vectors. It is actually a full coordinate system.

For probe and surfaces (front, back wall), the two first vectors must be tangential to the surface and the third vector must be normal to it.

In the block in immersion model, the probe normals must be towards the examination object. The front and back walls’ normals must be towards the probe.

For scatterers and grid points, there is no tangent or normal vectors. Only the third vector of the basis is used. It defines the reference orientation of the scatterer. To use a rotated scatterer, one can therefore change the orientation of this third vector; however, the recommend technique is to argument scat_angle in arim.model.model_amplitudes_factory().

Basis#

A basis (i_hat, j_hat, k_hat) is stored as a matrix:

         (i1 i2 i3)
basis =  (j1 j2 j3)
         (k1 k2 k3)

where (i1, i2, i3) is the coordinate of the basis vector i_hat in the global coordinate system.

Remark: this storage is consistent with the Points layout: basis[0, :] = (i1, i2, i3). A basis can be seen as three points (i_hat, j_hat, k_hat).

Warning: basis in CoordinateSystem objects are stored in a different convention: they are transposed i.e. basis[:, 0] = (i1, i2, i3).

Spherical coordinate system#

Physics and ISO convention (r, theta, phi):

  • r is the radial distance,

  • theta is the polar angle (inclination) in the rangle in the range [0, pi],

  • phi is the azimuthal angle in the range [-pi, pi].

Cf. Wikipedia article on Spherical coordinate system

arim.geometry.GCS#

Global coordinate system (CoordinateSystem). i = (1, 0, 0), j = (0, 1, 0), k = (0, 0, 1), O = (0, 0, 0).

CoordinateSystem(origin, i_hat, j_hat)

A point and a direct 3D affine basis.

Grid(xmin, xmax, ymin, ymax, zmin, zmax, ...)

Regularly spaced 3d grid

OrientedPoints(points, orientations)

Points(coords[, name])

Set of points in a 3D space.

SphericalCoordinates(r, theta, phi)

Spherical coordinates as usually defined in physics

are_points_aligned(points[, rtol, atol])

Are the points aligned? Returns a boolean.

are_points_close(points1, points2[, atol, rtol])

Return True if and only if the two sets of points have the same shape and coordinates close to the given precision.

aspoints(array_like)

Returns a Point object: the input itself if it is a point, or wrap the object as a Point otherwise.

combine_oriented_points(oriented_points[, name])

Combines multiple walls (oriented points) into one as a simple concatenation.

default_orientations(points)

Returns the default orientations for unoriented points.

default_oriented_points(points)

Returns OrientedPoints from Points assuming the default orientations.

direct_isometry_2d(A, B, Ap, Bp)

Returns a direct isometry that transform A to A' and B to B'.

direct_isometry_3d(A, i_hat, j_hat, B, ...)

Returns the isometry that send the direct orthogonal base (A, i_hat, j_hat, i_hat^j_hat) to (B, u_hat, v_hat, u_hat^v_hat)

distance_pairwise(points1, points2[, out, ...])

Compute the Euclidean distances of flight between two sets of points.

from_gcs(points_gcs, bases, origins)

Convert the coordinates of points expressed in the global coordinate system to coordinates expressed in the basis/bases given as parameter.

is_orthonormal(basis)

is_orthonormal_direct(basis)

Returns True if the basis is orthonormal and direct: :param basis:

make_contiguous_geometry(coords, numpoints)

Returns a list of OrientedPoints with length m which are uniquely named.

norm2(x, y, z[, out])

Euclidean norm of a ndarray

norm2_2d(x, y[, out])

Euclidean norm of a ndarray

points_1d_wall(start, end, numpoints[, ...])

Returns a set of regularly spaced points between start and end.

points_1d_wall_z(xmin, xmax, z, numpoints[, ...])

Returns a set of regularly spaced points between (xmin, y, z) and (xmax, y, z).

points_from_probe(probe[, name])

Probe object to OrientedPoints (points and orientations).

points_in_rectbox(x, y, z[, xmin, xmax, ...])

Returns points in the rectangular box.

rotate(coords, rotation_matrix[, centre])

Rotate these points given a rotation matrix and the centre.

rotation_matrix_x(theta)

rotation_matrix_y(theta)

rotation_matrix_ypr(yaw, pitch, roll)

Returns the rotation matrix (as a ndarray) from the yaw, pitch and roll in radians.

rotation_matrix_z(theta)

spherical_coordinates(x, y, z[, r])

Compute the spherical coordinates (r, θ, φ) of points.

spherical_coordinates_phi(x, y[, out])

azimuthal angle

spherical_coordinates_r(x, y, z[, out])

radial distance

spherical_coordinates_theta(z, r[, out])

polar angle

to_gcs(coords_cs, bases, origins)

Convert the coordinates of points expressed in the basis/bases given as parameter to coordinates expressed in the global coordinate system.