jv.vecmath

## Class PuProj

- java.lang.Object
- - jv.vecmath.PuProj

-     public class PuProj
      extends java.lang.Object

  Projection between different models of Euclidean, spherical and hyperbolic space. All vertex projection methods implicitly use the dimension of the argument point which is being projected. The dimension of the resulting projected point depends on the dimension of the target model space.

  Coordinate system in Lorentz Rn+1 has signature (1,..,1,-1).

  Author:
    Konrad Polthier
  Version:
    29.07.03, 1.10 revised (kp) Doc upgraded, all point projection methods are now documented as working in all dimensions.
    27.12.99, 1.00 created (kp)

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `PuProj()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `static void` | `diffKlein2Lorentz(PdMatrix diffMat, PdVector p)` Compute differential of projection map of H3 from Klein ball into Lorentz model at given point in Klein ball.
    `static void` | `diffPoincare2Lorentz(PdMatrix diffMat, PdVector p)` Compute differential of projection map of H3 from Poincare ball into Lorentz model at given point in Poincare ball.
    `static void` | `diffStereoInvR3_to_S3(PdMatrix diffMat, PdVector p)` Compute differential of inverse stereographic projection R3 to S3.
    `static void` | `diffStereoS3_to_R3(PdMatrix diffMat, PdVector p)` Compute differential of stereographic projection S3 to R3 with projection center (1,0,0,0).
    `static void` | `klein2Lorentz(PdVector pl, PdVector p)` Projection from Klein ball in Rn into Lorentz model in Rn+1 of n-dim hyperbolic space.
    `static void` | `klein2Poincare(PdVector p, PdVector pk)` Projection from Klein ball to Poincare ball of n-dim hyperbolic space.
    `static void` | `klein2Uhm(PdVector pu, PdVector p)` Projection of H3 from Klein ball to UHM of n-dim hyperbolic space.
    `static void` | `lorentz2Klein(PdVector p, PdVector pl)` Projection from Lorentz model in Rn+1 into Klein ball in Rn of n-dim hyperbolic space.
    `static void` | `lorentz2Poincare(PdVector p, PdVector pl)` Projection from Lorentz model in Rn+1 into Poincare ball in Rn of n-dim hyperbolic space.
    `static void` | `lorentz2Uhm(PdVector p, PdVector pl)` Projection from Lorentz model in Rn+1 into UHM in Rn of n-dim hyperbolic space.
    `static void` | `poincare2Klein(PdVector pk, PdVector p)` Projection from Poincare ball to Klein ball of n-dim hyperbolic space.
    `static void` | `poincare2Lorentz(PdVector pl, PdVector p)` Projection from Poincare ball in Rn into Lorentz model in Rn+1 of n-dim hyperbolic space.
    `static void` | `poincare2Uhm(PdVector pu, PdVector p)` Projection of H3 from Poincare ball to UHM of n-dim hyperbolic space.
    `static void` | `stereographic(PdVector p, PdVector pl)` Stereographic projection of a sphere Sn into Rn with projection center (0,..,0,1).
    `static void` | `stereoInvR3_to_S3(PdVector pl, PdVector p)` Projection from Rn p=(a,b,c) to Sn pl=(x,y,z,t).
    `static void` | `stereoS3_to_R3(PdVector p, PdVector pl)` Deprecated. use stereographic(PdVector, PdVector)
    `static void` | `uhm2Klein(PdVector p, PdVector pu)` Projection from UHM to Klein ball of n-dim hyperbolic space.
    `static void` | `uhm2Lorentz(PdVector pl, PdVector p)` Projection from UHM in Rn into Lorentz model in Rn+1 of n-dim hyperbolic space.
    `static void` | `uhm2Poincare(PdVector p, PdVector pu)` Projection from UHM to Poincare ball of n-dim hyperbolic space.

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### PuProj

          public PuProj()

  - ### Method Detail

    - #### lorentz2Klein

          public static void lorentz2Klein(PdVector p,
                                           PdVector pl)

      Projection from Lorentz model in Rn+1 into Klein ball in Rn of n-dim hyperbolic space. For Lorentz R4, a point (x,y,z,t) is mapped to `(a, b, c) = (x, y, z)/t`. Coordinate system in Lorentz R4 has signature (1,1,1,-1). The parameters may be identical vectors.
      Parameters:
        `p` - resulting vector in Klein ball
        `pl` - argument vector in Lorentz model

    - #### klein2Lorentz

          public static void klein2Lorentz(PdVector pl,
                                           PdVector p)

      Projection from Klein ball in Rn into Lorentz model in Rn+1 of n-dim hyperbolic space. For H3, `(t, x, y, z) = (t, t * a, t * b, t * c) with t = 1/sqrt(1 - |p|^2)` Coordinate system in Lorentz R4 has signature (1,1,1,-1). The parameters may be identical vectors.
      Parameters:
        `p` - argument vector in Klein ball
        `pl` - resulting vector in Lorentz model

    - #### diffKlein2Lorentz

          public static void diffKlein2Lorentz(PdMatrix diffMat,
                                               PdVector p)

      Compute differential of projection map of H3 from Klein ball into Lorentz model at given point in Klein ball. Coordinate system in Lorentz R4 has signature (1,1,1,-1).
      Parameters:
        `diffMat` - resulting differential matrix of size 4*3
        `p` - argument vector of size 3 in Klein ball

    - #### lorentz2Poincare

          public static void lorentz2Poincare(PdVector p,
                                              PdVector pl)

      Projection from Lorentz model in Rn+1 into Poincare ball in Rn of n-dim hyperbolic space. For H3, `(a, b, c) = (x, y, z)/(1 + t)` Coordinate system in Lorentz R4 has signature (1,1,1,-1). The parameters may be identical vectors.
      Parameters:
        `p` - resulting vector in Poincare ball
        `pl` - argument vector in Lorentz model

    - #### poincare2Lorentz

          public static void poincare2Lorentz(PdVector pl,
                                              PdVector p)

      Projection from Poincare ball in Rn into Lorentz model in Rn+1 of n-dim hyperbolic space. For H3, `(t, x, y, z) = (t, (1 + t) * a, (1 + t) * b, (1 + t) * c)` with `t = (1 + |p|^2)/(1 - |p|^2), 1 + t = 2/(1 - |p|^2)`. Coordinate system in Lorentz R4 has signature (1,1,1,-1). The parameters may be identical vectors.
      Parameters:
        `pl` - resulting vector in Lorentz model
        `p` - argument vector in Poincare ball

    - #### diffPoincare2Lorentz

          public static void diffPoincare2Lorentz(PdMatrix diffMat,
                                                  PdVector p)

      Compute differential of projection map of H3 from Poincare ball into Lorentz model at given point in Poincare ball. Coordinate system in Lorentz R4 has signature (1,1,1,-1).
      Parameters:
        `diffMat` - resulting differential matrix of size 4*3
        `p` - argument vector of size 3 in Klein ball

    - #### lorentz2Uhm

          public static void lorentz2Uhm(PdVector p,
                                         PdVector pl)

      Projection from Lorentz model in Rn+1 into UHM in Rn of n-dim hyperbolic space. For H3, `(a, b, c) = (x, y, 1)/(t - z)` Coordinate system in Lorentz Rn+1 has signature (1,..,1,-1). The parameters may be identical vectors.
      Parameters:
        `p` - resulting vector in Upper Halfspace model
        `pl` - argument vector in Lorentz model

    - #### uhm2Lorentz

          public static void uhm2Lorentz(PdVector pl,
                                         PdVector p)

      Projection from UHM in Rn into Lorentz model in Rn+1 of n-dim hyperbolic space. For H3, `(x, y, z, t) = (2 x, 2 y, t - 1, 1 + t)/(2 * z)` with `t = |p|^2`. Coordinate system in Lorentz Rn+1 has signature (1,..,1,-1). The parameters may be identical vectors.
      Parameters:
        `pl` - resulting vector in Lorentz model
        `p` - argument vector in Upper Halfspace model

    - #### poincare2Klein

          public static void poincare2Klein(PdVector pk,
                                            PdVector p)

      Projection from Poincare ball to Klein ball of n-dim hyperbolic space. For H3, `(a, b, c) = 2/(1-|p|^2) * (x, y, z)` The parameters may be identical vectors.
      Parameters:
        `pk` - resulting vector in Klein ball
        `p` - argument vector in Poincare ball

    - #### klein2Poincare

          public static void klein2Poincare(PdVector p,
                                            PdVector pk)

      Projection from Klein ball to Poincare ball of n-dim hyperbolic space. For H3, `(a, b, c) = (x, y, z) / (1+sqrt(1-|p|^2))` The parameters may be identical vectors.
      Parameters:
        `p` - resulting vector in Poincare ball
        `pk` - argument vector in Klein ball

    - #### poincare2Uhm

          public static void poincare2Uhm(PdVector pu,
                                          PdVector p)

      Projection of H3 from Poincare ball to UHM of n-dim hyperbolic space. For H3, `(a, b, c) = (2 x, 2 y, 1 - |p|^2)/(x^2 + y^2 + (z - 1)^2)`. The parameters may be identical vectors.
      Parameters:
        `pu` - resulting vector in Upper Halfspace model
        `p` - argument vector in Poincare ball

    - #### uhm2Poincare

          public static void uhm2Poincare(PdVector p,
                                          PdVector pu)

      Projection from UHM to Poincare ball of n-dim hyperbolic space. For H3, `(a, b, c) = (2 x, 2 y, |p|^2 - 1)/(x^2 + y^2 + (z + 1)^2)`. The parameters may be identical vectors.
      Parameters:
        `p` - resulting vector of size 3 in Poincare ball
        `pu` - argument vector of size 3 in Upper Halfspace model

    - #### klein2Uhm

          public static void klein2Uhm(PdVector pu,
                                       PdVector p)

      Projection of H3 from Klein ball to UHM of n-dim hyperbolic space. For H3, `(a, b, c) = (x, y, 1 - |p|^2/(1 + sqrt(1 - |p|^2)))/(1 - z)`. The parameters may be identical vectors.
      Parameters:
        `pu` - resulting vector in Upper Halfspace model
        `p` - argument vector in Klein ball

    - #### uhm2Klein

          public static void uhm2Klein(PdVector p,
                                       PdVector pu)

      Projection from UHM to Klein ball of n-dim hyperbolic space. For H3, `(a, b, c) = (2 x, 2 y, |p|^2 - 1)/(1 + |p|^2)`. The parameters may be identical vectors.
      Parameters:
        `p` - resulting vector in Klein ball
        `pu` - argument vector in Upper Halfspace model

    - #### stereoS3_to_R3

          public static void stereoS3_to_R3(PdVector p,
                                            PdVector pl)

      Deprecated. use stereographic(PdVector, PdVector)
      Stereographic projection of S3 into R3 with projection center (0,0,0,1).

    - #### stereographic

          public static void stereographic(PdVector p,
                                           PdVector pl)

      Stereographic projection of a sphere Sn into Rn with projection center (0,..,0,1). `(a_1, .., a_n) = (x_1, ..., x_n)/(1 - x_n+1)`. The parameters may be identical vectors of any dimension.
      Parameters:
        `p` - resulting vector of size n in Euclidean space
        `pl` - argument vector of size n+1 in Sn
      Version:
        29.04.01, 1.10 revised (kp) Renamed to stereographic from stereoS3_to_R3.
        29.04.01, 1.10 revised (kp) Projection center moved to (0,0,0,1).

    - #### diffStereoS3_to_R3

          public static void diffStereoS3_to_R3(PdMatrix diffMat,
                                                PdVector p)

      Compute differential of stereographic projection S3 to R3 with projection center (1,0,0,0).
      Parameters:
        `diffMat` - resulting 3*4 differential matrix of size 4*3
        `p` - argument vector of size 3 in Klein ball

    - #### stereoInvR3_to_S3

          public static void stereoInvR3_to_S3(PdVector pl,
                                               PdVector p)

      Projection from Rn p=(a,b,c) to Sn pl=(x,y,z,t). `(x, y, z, t) = ((1 + t) * a, (1 + t) * b, (1 + t) * c, t)` with `t = (1 - |p|^2)/(1 + |p|^2), 1 + t = 2/(1 + |p|^2)`. The parameters may be identical vectors.
      Parameters:
        `pl` - resulting vector in Sn
        `p` - argument vector in Euclidean space Rn
      Version:
        29.04.01, 1.10 revised (kp) Projection center moved to (0,0,0,1).

    - #### diffStereoInvR3_to_S3

          public static void diffStereoInvR3_to_S3(PdMatrix diffMat,
                                                   PdVector p)

      Compute differential of inverse stereographic projection R3 to S3.
      Parameters:
        `diffMat` - resulting 4*3 differential matrix of size 4*3
        `p` - argument vector of size 3 in Euclidean R3

"

The software JavaView? is copyright protected. All Rights Reserved.
"