# Geometry in affiner

### Table of Contents

- Angle objects
- Trigonometry
- 2D Coordinates
- 3D Coordinates
- Orthographic/Axonometric and Oblique Projections

## Angle objects

In `{affiner}` angles are represented by the `angle()` class:

- Supports the following angular units (note we ignore any punctuation and space characters as well as any trailing s’s e.g. “half turns” will be treated as equivalent to “halfturn”):

  - “deg” or “degree”
  - “half-revolution”, “half-turn”, or “pi-radian”
  - “gon”, “grad”, “grade”, or “gradian”
  - “rad” or “radian”
  - “rev”, “revolution”, “tr”, or “turn”

- `degrees()`, `gradians()`, `pi_radians()`, `radians()`, `turns()` are convenience wrappers around `as_angle.()` that specifies the angular unit.

- One can use the `affiner_angular_unit` global option to set the default angular unit used by this package from “degrees” to “gradians”, (multiples of) “pi-radians”, “radians”, or “turns”.

- Use `is_congruent()` to check if two angles are congruent modulo full turns.

    library("affiner")
    as_angle(90, "degrees") + turns(1)

    ## <angle<degrees>[1]>
    ## [1] 450°

    is_congruent(degrees(180), radians(pi))

    ## [1] TRUE

    as.numeric(turns(1/3), "radians")

    ## [1] 2.094395

## Trigonometry

`{affiner}` provides several `angle()` class aware trigonometric functions:

- `sine()`, `cosine()`, `tangent()`, `secant()`, `cosecant()`, `cotangent()`,
- `arcsine()`, `arccosine()`, `arctangent()`, `arcsecant()`, `arccosecant()`, and `arccotangent()`. `arcsine()` and `arccosine()` also feature a `tolerance` value so that values that exceed the `1` / `-1` cutoffs by a small tolerance are rounded to those values.
- One can also use the base S3 methods `sin()`, `cos()`, and `tan()` on `angle()` objects.

    library("affiner")
    sin(2 * pi)

    ## [1] -2.449294e-16

    sine(degrees(360))

    ## [1] 0

    arctangent(x = 0, y = 1)

    ## <angle<degrees>[1]>
    ## [1] 90°

## 2D Coordinates

In `{affiner}` 2D Coordinates are represented by a `Coord2D` R6 class:

- Create `Coord2D` objects with `as_coord2d()`

- `Coord2D` R6 objects supports several affine transformation methods that can be chained:

  - `permute()`
  - `project()`
  - `reflect()`
  - `rotate()`
  - `scale()`
  - `shear()`
  - `translate()`
  - `transform()`
  - R6 method chained affine transformation matrices are auto-multiplied so you don’t need to manually multiply them for efficiency reasons.
  - `{affiner}` affine transformations are post-multiplied so affine transformations can be applied in an intuitive order.
  - `abs()` computes Euclidean norm and `distance2d()` computes Euclidean distances
  - `convex_hull2d()` computes the convex hull.
  - `range()` computes the axis-aligned bounding box ranges.

    # Cartesian coordinates
    library("affiner")
    p <- as_coord2d(x = 1:10, y = 1:10)
    print(p)

    ## <Coord2D[10]>
    ##        x  y w
    ##  [1,]  1  1 1
    ##  [2,]  2  2 1
    ##  [3,]  3  3 1
    ##  [4,]  4  4 1
    ##  [5,]  5  5 1
    ##  [6,]  6  6 1
    ##  [7,]  7  7 1
    ##  [8,]  8  8 1
    ##  [9,]  9  9 1
    ## [10,] 10 10 1

    p2 <- p$
        clone()$
        scale(x = 0.5)$
        rotate(degrees(90))$
        reflect(as_line2d("y-axis"))$
        translate(as_coord2d(x = 0.5, y = 0.5))$
        print()

    ## <Coord2D[10]>
    ##         x   y w
    ##  [1,] 1.0 1.0 1
    ##  [2,] 1.5 1.5 1
    ##  [3,] 2.0 2.0 1
    ##  [4,] 2.5 2.5 1
    ##  [5,] 3.0 3.0 1
    ##  [6,] 3.5 3.5 1
    ##  [7,] 4.0 4.0 1
    ##  [8,] 4.5 4.5 1
    ##  [9,] 5.0 5.0 1
    ## [10,] 5.5 5.5 1

    # Polar coordinates
    theta <- degrees(seq(0, 300, by = 60))
    radius <- 1
    p <- as_coord2d(theta, radius = radius)
    is_congruent(as_angle(p), theta) |> all()

    ## [1] TRUE

    is_congruent(abs(p), radius) |> all()

    ## [1] TRUE

## 3D Coordinates

In `{affiner}` 3D Coordinates are represented by a `Coord3D` R6 class:

- Create `Coord3D` objects with `as_coord3d()`

- `Coord3D` R6 objects supports several affine transformation methods that can be chained:

  - `permute()`
  - `project()`
  - `reflect()`
  - `rotate()`
  - `scale()`
  - `shear()`
  - `translate()`
  - `transform()`
  - R6 method chained affine transformation matrices are auto-multiplied so you don’t need to manually pre-multiply them for efficiency reasons.
  - `{affiner}` affine transformations are post-multiplied so affine transformations can be applied in an intuitive order.
  - `abs()` computes Euclidean norm and `distance3d()` computes Euclidean distances
  - `range()` computes the axis-aligned bounding box ranges.
  - `cross_product3d()` computes cross products (`*` computes inner products).

    # Cartesian coordinates
    library("affiner")
    p <- as_coord3d(x = 1:10, y = 1:10, z = 1:10)
    print(p)

    ## <Coord3D[10]>
    ##        x  y  z w
    ##  [1,]  1  1  1 1
    ##  [2,]  2  2  2 1
    ##  [3,]  3  3  3 1
    ##  [4,]  4  4  4 1
    ##  [5,]  5  5  5 1
    ##  [6,]  6  6  6 1
    ##  [7,]  7  7  7 1
    ##  [8,]  8  8  8 1
    ##  [9,]  9  9  9 1
    ## [10,] 10 10 10 1

    p2 <- p$
        clone()$
        scale(z = 0.5)$
        rotate(axis = as_coord3d("z-axis"), theta = degrees(90))$
        reflect(as_plane3d("yz-plane"))$
        shear(xy_shear = 0.5)$
        translate(as_coord3d(x = 0.5, y = 0.5, z = 0.5))$
        print()

    ## <Coord3D[10]>
    ##          x    y   z w
    ##  [1,]  2.0  1.5 1.0 1
    ##  [2,]  3.5  2.5 1.5 1
    ##  [3,]  5.0  3.5 2.0 1
    ##  [4,]  6.5  4.5 2.5 1
    ##  [5,]  8.0  5.5 3.0 1
    ##  [6,]  9.5  6.5 3.5 1
    ##  [7,] 11.0  7.5 4.0 1
    ##  [8,] 12.5  8.5 4.5 1
    ##  [9,] 14.0  9.5 5.0 1
    ## [10,] 15.5 10.5 5.5 1

    # Spherical coordinates
    inclination <- as_angle(p, type = "inclination")
    azimuth <- as_angle(p, type = "azimuth")
    radius <- abs(p)
    ps <- as_coord3d(azimuth, radius = radius, inclination = inclination)
    all.equal(p, ps)

    ## [1] TRUE

    # Cylindrical coordinates
    radius <- as_coord2d(p, plane = "xy-plane") |> abs()
    pc <- as_coord3d(azimuth, radius = radius, z = p$z)
    all.equal(p, pc)

    ## [1] TRUE

## Orthographic/Axonometric and Oblique Projections

`{affiner}` can project `Coord3D` objects to `Coord2D` objects using orthographic/axonometric and oblique projections:

- For a multiview/primary orthographic projection onto the xy-plane use `as_coord2d(x)`

- For a multiview/primary orthographic projection onto the xz-plane use `as_coord2d(x, permutation = "xzy")`

- For a “cabinet” oblique projection onto the xy-plane use `as_coord2d(x, scale = 0.5)`

- For a “cabinet” oblique projection onto the xz-plane use `as_coord2d(x, permutation = "xzy", scale = 0.5)`

- For other oblique projections manipulate the `scale` parameter (usually from 0.5 to 1.0) and the `alpha` angle parameter (usually from 30° to 45°).

- For one “isometric” axonometric projection one can use

      x$
        clone()$
        translate(-mean(x)$
        rotate("z-axis", degrees(45))$
        rotate("x-axis", degrees(-90 + 35.264)) |>
        as_coord2d()

- Other axonometric projections can be achieved with the right 3D rotations

- See `vignette("affiner", package = "affiner")` for some visual examples

- Recall one can use “scale” affine transformation to flip signs of x/y/z axes and “permute” affine transformation to switch order of x/y/z coordinates