Math2

Overview

Package

Class

Tree

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

de.grogra.vecmath
Class Math2

java.lang.Object
  de.grogra.vecmath.Math2

public final class Math2
extends java.lang.Object
extends java.lang.Object

This class contains a set of mathematical functions and constants, including random and noise generators, linear algebra, and table-based trigonometric functions.

Author:: Ole Kniemeyer

Field Summary
`static float`	`EPS` The very small number epsilon. 1E-05
`static float`	`EPSILON` The very small number epsilon. 1E-09
`static float`	`M_1_2PI` The constant 1 / (2 π) as `float`.
`static float`	`M_1_PI` The constant 1 / π as `float`.
`static float`	`M_2PI` The constant 2 π as `float`.
`static float`	`M_PI` The constant π as `float`.
`static float`	`M_PI_2` The constant π / 2 as `float`.
`static int`	`nbSkySegments` Numbers of skysegments for the turtlesky
`static Vector3d[]`	`turtsky` Define the turtlesky

Method Summary
`static float`	`absthgs(Vector3d ss, Vector3d rr, Vector3d sa, Vector3d se)`
`static float`	`abstphg(Vector3d pp, Vector3d ss, Vector3d rr)`
`static float`	`abstpp(Vector3d av, Vector3d ev)` Computated the distance between two vectors
`static float`	`abstps(Vector3d pp, Vector3d sa, Vector3d se)` Calculates the distance between the point pp and the piece of straight line delimited by sa and se.
`static int`	`binomial(int n, int k)`
`static float`	`ccos(char c)` Returns the cosine of the argument.
`static double`	`clamp(double value, double min, double max)`
`static float`	`clamp(float value, float min, float max)`
`static int`	`clamp(int value, int min, int max)`
`static long`	`clamp(long value, long min, long max)`
`static double`	`closestConnection(Tuple3d p, Vector3d v, Tuple3d q)`
`static float`	`csin(char c)` Returns the sine of the argument.
`static void`	`cutCone(Vector3d ss, float alpha, Vector3d pp, Vector3d qq, CutConeParameter ccp)`
`static void`	`cutRay2(float a1, float a2, float r1, float r2, float u1, float u2, float v1, float v2, CutRay2Parameter crp)`
`static void`	`decomposeQR(Matrix3d r, Matrix3d q)` Computes a QR decomposition of `r`.
`static float`	`determinate3(Vector3d a1, Vector3d a2, Vector3d a3)`
`static double`	`distance(Tuple3d p, Vector3d v, Tuple3d q)`
`static void`	`dNoise(Tuple3f out, float x, float y, float z)` This method represents the derivative of a Perlin-style 3D noise function.
`static double`	`dot(Tuple3d a, Tuple3d b)`
`static double`	`dot(Tuple3d p, Tuple3d q, Tuple3d v)` Computes the scalar product `(p - q) v`
`static float`	`dot(Tuple3f a, Tuple3d b)`
`static float`	`dot(Tuple3f a, Tuple3f b)`
`static void`	`dTurbulence(Tuple3f out, float x, float y, float z, int octaves, float lambda, float omega)`
`static double`	`estimateScaleSquared(Matrix4d transformation)`
`static int`	`factorial(int n)`
`static int`	`floor(double x)`
`static float`	`fresnel(Vector3f normal, Vector3f in, float iorRatio, Vector3f reflectedOut, Vector3f transmittedOut)` Computes reflected and transmitted directions according to Fresnel's formulas.
`static float`	`gamma(float x)`
`static void`	`getBeginAndEndOfShoot(Matrix4d m, double length, Vector3d beginOfShoot, Vector3d endOfShoot)`
`static void`	`getBeginOfShoot(Matrix4d m, Vector3d beginOfShoot)`
`static void`	`getEndOfShoot(Matrix4d m, double length, Vector3d endOfShoot)`
`static void`	`getOrthogonal(Tuple3d in, Tuple3d out)` Computes an orthogonal vector to `in`.
`static void`	`getOrthogonal(Tuple3f in, Tuple3f out)` Computes an orthogonal vector to `in`.
`static void`	`getOrthogonalBasis(Tuple3d in, Matrix3d out, boolean orthonormal)` Computes an orthogonal basis.
`static void`	`getOrthogonalBasis(Tuple3f in, Matrix3f out, boolean orthonormal)` Computes an orthogonal basis.
`static double`	`intersectLineWithFrustum(double px, double py, double pz, double dx, double dy, double dz, double ax, double ay, double az, double top, double base, double tan)` Determines the fraction of a line (p,d) which intersects a frustum.
`static double`	`intersectLineWithFrustum(Point3d point, Vector3d direction, Point3d origin, Vector3d axis, double top, double base, double tan)`
`static void`	`invertAffine(Matrix34d in, Matrix4d out)`
`static void`	`invertAffine(Matrix3d in, Matrix3d out)`
`static void`	`invertAffine(Matrix3f in, Matrix3f out)`
`static void`	`invertAffine(Matrix4d in, Matrix4d out)`
`static void`	`invertAffine(Matrix4f in, Matrix4f out)`
`static void`	`invMul(Matrix3d t, Tuple3d v)`
`static void`	`invTransformPoint(Matrix34d t, Tuple3d p)`
`static void`	`invTransformPoint(Matrix3d t, Tuple2d p)`
`static void`	`invTransformPoint(Matrix3f t, Tuple2f p)`
`static void`	`invTransformPoint(Matrix4d t, Tuple3d p)`
`static void`	`invTransformPointAndVector(Matrix4d t, Tuple3d p, Tuple3d v)`
`static void`	`invTransformVector(Matrix34d t, Tuple3d v)`
`static void`	`invTransformVector(Matrix3d t, Tuple2d v)`
`static void`	`invTransformVector(Matrix3f t, Tuple2f v)`
`static void`	`invTransformVector(Matrix4d t, Tuple3d v)`
`static boolean`	`isInsideConeT(double px, double py, double pz, double ax, double ay, double az, double tipDistance, double capDistance, double tan)` Determines if a point p lies inside a (part of a) cone.
`static boolean`	`isInsideConeT(double px, double py, double pz, double ox, double oy, double oz, double ax, double ay, double az, double tipDistance, double capDistance, double tan)`
`static boolean`	`isNullVector(Vector3d a)` Test of all parts of the vector are null
`static boolean`	`lessThan(Tuple3d a, Tuple3d b)`
`static boolean`	`lessThanOrEqual(Tuple3d a, Tuple3d b)`
`static void`	`lmul(Matrix3d rot, Matrix34d m)`
`static void`	`makeAffine(Matrix3d m)`
`static void`	`makeAffine(Matrix3f m)`
`static void`	`makeAffine(Matrix4d m)`
`static void`	`makeAffine(Matrix4f m)`
`static void`	`max(Tuple2d max, Tuple2d t)`
`static void`	`max(Tuple2f max, Tuple2f t)`
`static void`	`max(Tuple3d max, Tuple3d t)`
`static void`	`max(Tuple3f max, Tuple3f t)`
`static void`	`min(Tuple2d min, Tuple2d t)`
`static void`	`min(Tuple2f min, Tuple2f t)`
`static void`	`min(Tuple3d min, Tuple3d t)`
`static void`	`min(Tuple3f min, Tuple3f t)`
`static void`	`mul(Tuple3d out, Tuple3d a, Tuple3d b)`
`static void`	`mul(Tuple3f out, Tuple3f a, Tuple3f b)`
`static void`	`mulAffine(Matrix3d out, Matrix3d l, Matrix3d r)`
`static void`	`mulAffine(Matrix4d out, Matrix4d l, Matrix4d r)`
`static long`	`nextRandom(long seed)` Returns the next 48-bit pseudo-random number based on the previous pseudo-random number `seed`.
`static float`	`noise(float x, float y, float z)` This method represents a Perlin-style 3D noise function.
`static void`	`normalize(Vector3d aVector)` Normalizes this vector in place.
`static void`	`normalize(Vector3f aVector)` Normalizes this vector in place.
`static void`	`onbco(Vector3d result, Vector3d a, Vector3d ba1, Vector3d ba2, Vector3d ba3)`
`static boolean`	`parallelVector(Vector3d a1, Vector3d a2)`
`static long`	`pow(int a, int b)`
`static boolean`	`quadricIntersection(double a00, double a01, double a02, double a11, double a12, double a22, double b0, double b1, double b2, double c, Point3d p, Vector3d d, double[] lambda)`
`static char`	`random(char index)` This method represents a random permutation of `char` values.
`static int`	`roundUpNextPowerOfTwo(int v)` Calculate the next power of two greater or equal than v.
`static void`	`setAffine(Matrix4d out, Matrix4d in)`
`static void`	`setAffineTransform(java.awt.geom.AffineTransform out, Matrix3d in)`
`static void`	`setMatrix3d(Matrix3d out, java.awt.geom.AffineTransform in)`
`static double`	`shortestConnection(Tuple3d p1, Vector3d v1, Tuple3d p2, Vector3d v2, double[] lambda)` Computes the shortest straight connection between two lines.
`static double`	`shortestConnection(Tuple3d p1, Vector3d v1, Tuple3f p2, Vector3f v2, double[] lambda)` Computes the shortest straight connection between two lines.
`static float`	`shortestConnection(Tuple3f p1, Vector3f v1, Tuple3f p2, Vector3f v2, float[] lambda)` Computes the shortest straight connection between two lines.
`static float`	`sin(float x)` Returns the sine of the argument.
`static float`	`sin01(float x)` Returns the sine of the argument.
`static int`	`skySegment(Vector3d rv)`
`static float[]`	`toFloatArray(Tuple3d p)`
`static float[]`	`toFloatArray(Tuple4d p)`
`static float[]`	`toFloatArray(Tuple4f p)`
`static void`	`transformPoint(Matrix3d t, Tuple2d p)`
`static void`	`transformPoint(Matrix4d t, Tuple3d p)`
`static void`	`transformPoint(Matrix4d t, Tuple3d p, Tuple3d out)`
`static void`	`transformPoint(Matrix4f t, Tuple3f p)`
`static void`	`transformTranspose(Matrix3d t, Tuple3d v)`
`static void`	`transformVector(Matrix3d t, Tuple2d v)`
`static void`	`transformVector(Matrix4d t, Tuple3d v)`
`static void`	`transformVector(Matrix4f t, Tuple3f v)`
`static float`	`turbulence(float x, float y, float z, int octaves, float lambda, float omega)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

EPS

public static final float EPS

The very small number epsilon. 1E-05

See Also:: Constant Field Values

EPSILON

public static final float EPSILON

The very small number epsilon. 1E-09

See Also:: Constant Field Values

M_1_2PI

public static float M_1_2PI

The constant 1 / (2 π) as float.

M_1_PI

public static float M_1_PI

The constant 1 / π as float.

M_2PI

public static float M_2PI

The constant 2 π as float.

M_PI

public static float M_PI

The constant π as float.

M_PI_2

public static float M_PI_2

The constant π / 2 as float.

nbSkySegments

public static int nbSkySegments

Numbers of skysegments for the turtlesky

turtsky

public static final Vector3d[] turtsky

Define the turtlesky

Method Detail

absthgs

public static float absthgs(Vector3d ss,
                            Vector3d rr,
                            Vector3d sa,
                            Vector3d se)

abstphg

public static float abstphg(Vector3d pp,
                            Vector3d ss,
                            Vector3d rr)

abstpp

public static float abstpp(Vector3d av,
                           Vector3d ev)

Computated the distance between two vectors

Parameters:: av - first vector; ev - second vector
Returns:: distance between the two vectors

abstps

public static float abstps(Vector3d pp,
                           Vector3d sa,
                           Vector3d se)

Calculates the distance between the point pp and the piece of straight line delimited by sa and se. If sa == se, the distance to this point is calculated.

Parameters:: pp - Point; sa - Begin of the straight line; se - End of the straight line
Returns:: Distance between the point pp and the piece of straight line

binomial

public static int binomial(int n,
                           int k)

ccos

public static float ccos(char c)

Returns the cosine of the argument. The range of char values is mapped to [0, 2 π), i.e., the angle in radians is 2 π c / 0x10000. This method uses a pre-computed table.

Parameters:: c - an angle
Returns:: the cosine of the angle

clamp

public static double clamp(double value,
                           double min,
                           double max)

clamp

public static float clamp(float value,
                          float min,
                          float max)

clamp

public static int clamp(int value,
                        int min,
                        int max)

clamp

public static long clamp(long value,
                         long min,
                         long max)

closestConnection

public static double closestConnection(Tuple3d p,
                                       Vector3d v,
                                       Tuple3d q)

csin

public static float csin(char c)

Returns the sine of the argument. The range of char values is mapped to [0, 2 π), i.e., the angle in radians is 2 π c / 0x10000. This method uses a pre-computed table.

Parameters:: c - an angle
Returns:: the sine of the angle

cutCone

public static void cutCone(Vector3d ss,
                           float alpha,
                           Vector3d pp,
                           Vector3d qq,
                           CutConeParameter ccp)

cutRay2

public static void cutRay2(float a1,
                           float a2,
                           float r1,
                           float r2,
                           float u1,
                           float u2,
                           float v1,
                           float v2,
                           CutRay2Parameter crp)

decomposeQR

public static void decomposeQR(Matrix3d r,
                               Matrix3d q)

Computes a QR decomposition of r. The non-singular matrix a to be composed is the parameter r. This method computes r and q such that a = q * r, q is an orthogonal matrix, and r an upper triangular matrix. The signs of r.m00 and r.m11 are positive. The sign of r.m22 is the sign of det(a). As a consequence, det(q) == 1, so q is a pure rotation.

Parameters:: r - the input for the matrix to compose and the output for r; q - the output for q

determinate3

public static float determinate3(Vector3d a1,
                                 Vector3d a2,
                                 Vector3d a3)

distance

public static double distance(Tuple3d p,
                              Vector3d v,
                              Tuple3d q)

dNoise

public static void dNoise(Tuple3f out,
                          float x,
                          float y,
                          float z)

This method represents the derivative of a Perlin-style 3D noise function. It is implemented based on POV-Ray's DNoise function.

Parameters:: out - the computed derivate at (x, y, z) is placed in here; x - x-coordinate; y - x-coordinate; z - x-coordinate

dot

public static double dot(Tuple3d a,
                         Tuple3d b)

dot

public static double dot(Tuple3d p,
                         Tuple3d q,
                         Tuple3d v)

Computes the scalar product (p - q) v

Parameters:: p - a point; q - point which is subtracted from p; v - a vector
Returns:: scalar product (p - q) v

dot

public static float dot(Tuple3f a,
                        Tuple3d b)

dot

public static float dot(Tuple3f a,
                        Tuple3f b)

dTurbulence

public static void dTurbulence(Tuple3f out,
                               float x,
                               float y,
                               float z,
                               int octaves,
                               float lambda,
                               float omega)

estimateScaleSquared

public static double estimateScaleSquared(Matrix4d transformation)

factorial

public static int factorial(int n)

floor

public static int floor(double x)

fresnel

public static float fresnel(Vector3f normal,
                            Vector3f in,
                            float iorRatio,
                            Vector3f reflectedOut,
                            Vector3f transmittedOut)

Computes reflected and transmitted directions according to Fresnel's formulas.

Parameters:: normal - the normal unit vector of the surface; in - the negated direction unit vector of the incoming ray; iorRatio - the index of refraction of the surface side where the normal vector points into, divided by the index of refraction of the opposite side; reflectedOut - the computed unit vector of the reflection direction; transmittedOut - the computed unit vector of the transmission direction
Returns:: the reflection coefficient

gamma

public static float gamma(float x)

getBeginAndEndOfShoot

public static void getBeginAndEndOfShoot(Matrix4d m,
                                         double length,
                                         Vector3d beginOfShoot,
                                         Vector3d endOfShoot)

getBeginOfShoot

public static void getBeginOfShoot(Matrix4d m,
                                   Vector3d beginOfShoot)

getEndOfShoot

public static void getEndOfShoot(Matrix4d m,
                                 double length,
                                 Vector3d endOfShoot)

getOrthogonal

public static void getOrthogonal(Tuple3d in,
                                 Tuple3d out)

Computes an orthogonal vector to in. The computed vector is written to out, which may be the same reference as in.

Parameters:: in - an input vector; out - the computed orthogonal vector is placed in here

getOrthogonal

public static void getOrthogonal(Tuple3f in,
                                 Tuple3f out)

Computes an orthogonal vector to in. The computed vector is written to out, which may be the same reference as in.

Parameters:: in - an input vector; out - the computed orthogonal vector is placed in here

getOrthogonalBasis

public static void getOrthogonalBasis(Tuple3d in,
                                      Matrix3d out,
                                      boolean orthonormal)

Computes an orthogonal basis. The first two columns of the computed basis out are unit vectors, the third column equals in if orthonormal is false, otherwise it equals the unit vector in the direction of in. Thus, out represents a coordinate transformation which transforms the local z-axis into the direction of in.

Parameters:: in - the direction of the local z-axis; out - the computed matrix; orthonormal - compute an orthonormal matrix?

getOrthogonalBasis

public static void getOrthogonalBasis(Tuple3f in,
                                      Matrix3f out,
                                      boolean orthonormal)

Parameters:: in - the direction of the local z-axis; out - the computed matrix; orthonormal - compute an orthonormal matrix?

intersectLineWithFrustum

public static double intersectLineWithFrustum(double px,
                                              double py,
                                              double pz,
                                              double dx,
                                              double dy,
                                              double dz,
                                              double ax,
                                              double ay,
                                              double az,
                                              double top,
                                              double base,
                                              double tan)

Determines the fraction of a line (p,d) which intersects a frustum.

The frustum is specified by the cone from which it is obtained by cutting away the top: The cone's tip is located at the origin, its axis is given by a and points to the center of the cone's cap which is located at base * a. The half-angle of the cone is specified by its tangent. The cutting plane for obtaining the frustum is located at the position top * a.

The line is specified by its origin p and its vector d from the origin to the end.

Parameters:: px - x coordinate of line origin p; py - y coordinate of line origin p; pz - z coordinate of line origin p; dx - x coordinate of line vector d; dy - y coordinate of line vector d; dz - z coordinate of line vector d; ax - x coordinate of cone axis a; ay - y coordinate of cone axis a; az - z coordinate of cone axis a; top - relative position of frustum's top cap along axis; base - relative position of frustum's base cap along axis; tan - tangent of cone's half angle
Returns:: fraction of line which intersects the frustum

intersectLineWithFrustum

public static double intersectLineWithFrustum(Point3d point,
                                              Vector3d direction,
                                              Point3d origin,
                                              Vector3d axis,
                                              double top,
                                              double base,
                                              double tan)

invertAffine

public static void invertAffine(Matrix34d in,
                                Matrix4d out)

invertAffine

public static void invertAffine(Matrix3d in,
                                Matrix3d out)

invertAffine

public static void invertAffine(Matrix3f in,
                                Matrix3f out)

invertAffine

public static void invertAffine(Matrix4d in,
                                Matrix4d out)

invertAffine

public static void invertAffine(Matrix4f in,
                                Matrix4f out)

invMul

public static void invMul(Matrix3d t,
                          Tuple3d v)

invTransformPoint

public static void invTransformPoint(Matrix34d t,
                                     Tuple3d p)

invTransformPoint

public static void invTransformPoint(Matrix3d t,
                                     Tuple2d p)

invTransformPoint

public static void invTransformPoint(Matrix3f t,
                                     Tuple2f p)

invTransformPoint

public static void invTransformPoint(Matrix4d t,
                                     Tuple3d p)

invTransformPointAndVector

public static void invTransformPointAndVector(Matrix4d t,
                                              Tuple3d p,
                                              Tuple3d v)

invTransformVector

public static void invTransformVector(Matrix34d t,
                                      Tuple3d v)

invTransformVector

public static void invTransformVector(Matrix3d t,
                                      Tuple2d v)

invTransformVector

public static void invTransformVector(Matrix3f t,
                                      Tuple2f v)

invTransformVector

public static void invTransformVector(Matrix4d t,
                                      Tuple3d v)

isInsideConeT

public static boolean isInsideConeT(double px,
                                    double py,
                                    double pz,
                                    double ax,
                                    double ay,
                                    double az,
                                    double tipDistance,
                                    double capDistance,
                                    double tan)

Determines if a point p lies inside a (part of a) cone. The cone's tip is located at the origin, its axis is given by a and points to the center of the cone's cap which is located at axis * capDistance. The small cone from the tip to axis * tipDistance is removed, i.e., this tests actually checks againts a frustum. The half-angle of the cone is specified by its tangent.

Parameters:: px - x coordinate of point p; py - y coordinate of point p; pz - z coordinate of point p; ax - x coordinate of cone axis a; ay - y coordinate of cone axis a; az - z coordinate of cone axis a; tipDistance - distance to the tip (in units of axis); capDistance - distance of the cap (in units of axis); tan - tangent of cone's half angle
Returns:: true iff p lies within or on the cone

isInsideConeT

public static boolean isInsideConeT(double px,
                                    double py,
                                    double pz,
                                    double ox,
                                    double oy,
                                    double oz,
                                    double ax,
                                    double ay,
                                    double az,
                                    double tipDistance,
                                    double capDistance,
                                    double tan)

isNullVector

public static boolean isNullVector(Vector3d a)

Test of all parts of the vector are null

Parameters:: a - the vector to test
Returns:: true, if all parts of the vector are null

lessThan

public static boolean lessThan(Tuple3d a,
                               Tuple3d b)

lessThanOrEqual

public static boolean lessThanOrEqual(Tuple3d a,
                                      Tuple3d b)

lmul

public static void lmul(Matrix3d rot,
                        Matrix34d m)

makeAffine

public static void makeAffine(Matrix3d m)

makeAffine

public static void makeAffine(Matrix3f m)

makeAffine

public static void makeAffine(Matrix4d m)

makeAffine

public static void makeAffine(Matrix4f m)

max

public static void max(Tuple2d max,
                       Tuple2d t)

max

public static void max(Tuple2f max,
                       Tuple2f t)

max

public static void max(Tuple3d max,
                       Tuple3d t)

max

public static void max(Tuple3f max,
                       Tuple3f t)

min

public static void min(Tuple2d min,
                       Tuple2d t)

min

public static void min(Tuple2f min,
                       Tuple2f t)

min

public static void min(Tuple3d min,
                       Tuple3d t)

min

public static void min(Tuple3f min,
                       Tuple3f t)

mul

public static void mul(Tuple3d out,
                       Tuple3d a,
                       Tuple3d b)

mul

public static void mul(Tuple3f out,
                       Tuple3f a,
                       Tuple3f b)

mulAffine

public static void mulAffine(Matrix3d out,
                             Matrix3d l,
                             Matrix3d r)

mulAffine

public static void mulAffine(Matrix4d out,
                             Matrix4d l,
                             Matrix4d r)

nextRandom

public static long nextRandom(long seed)

Returns the next 48-bit pseudo-random number based on the previous pseudo-random number seed. The sequence of numbers is the same as the sequence computed by java.util.Random:

 nextRandom = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);

However, this method should be slightly faster because it does not have to deal with multi-threading issues.

Pseudo-random ints of n bits should be obtained from the returned value by the formula (int) (nextRandom >>> (48 - n)).

Parameters:: seed - previous number of sequence
Returns:: next number of sequence

noise

public static float noise(float x,
                          float y,
                          float z)

This method represents a Perlin-style 3D noise function. It is implemented based on POV-Ray's Noise function.

Parameters:: x - x-coordinate; y - x-coordinate; z - x-coordinate
Returns:: noise value at (x, y, z)

normalize

public static void normalize(Vector3d aVector)

Normalizes this vector in place. If the length is 0, then the complett vector will be (0, 0, 0).

Parameters:: aVector - The normalized vector

normalize

public static void normalize(Vector3f aVector)

Normalizes this vector in place. If the length is 0, then the complett vector will be (0, 0, 0).

Parameters:: aVector - The normalized vector

onbco

public static void onbco(Vector3d result,
                         Vector3d a,
                         Vector3d ba1,
                         Vector3d ba2,
                         Vector3d ba3)

parallelVector

public static boolean parallelVector(Vector3d a1,
                                     Vector3d a2)

pow

public static long pow(int a,
                       int b)

quadricIntersection

public static boolean quadricIntersection(double a00,
                                          double a01,
                                          double a02,
                                          double a11,
                                          double a12,
                                          double a22,
                                          double b0,
                                          double b1,
                                          double b2,
                                          double c,
                                          Point3d p,
                                          Vector3d d,
                                          double[] lambda)

random

public static char random(char index)

This method represents a random permutation of char values. I.e., it is a bijective map on chars, the mapping being defined by a pseudo-random number generator. The mapping remains the same between different invocations of the Java Virtual Machine.

Parameters:: index - an index into a permutation table
Returns:: the permuted value

roundUpNextPowerOfTwo

public static int roundUpNextPowerOfTwo(int v)

Calculate the next power of two greater or equal than v. (see "Bit Twiddling Hacks")

Parameters:: v -
Returns:

setAffine

public static void setAffine(Matrix4d out,
                             Matrix4d in)

setAffineTransform

public static void setAffineTransform(java.awt.geom.AffineTransform out,
                                      Matrix3d in)

setMatrix3d

public static void setMatrix3d(Matrix3d out,
                               java.awt.geom.AffineTransform in)

shortestConnection

public static double shortestConnection(Tuple3d p1,
                                        Vector3d v1,
                                        Tuple3d p2,
                                        Vector3d v2,
                                        double[] lambda)

Computes the shortest straight connection between two lines. This method computes two scalars lambda[0] and lambda[1] such that the line from p1 + lambda[0] v1 to p2 + lambda[1] v2 is the shortest connection line between these lines.

Parameters:: p1 - a point on the first line; v1 - the direction of the first line; p2 - a point on the second line; v2 - the direction of the second line; lambda - the computed scalars are written into this array
Returns:: the length of the shortest connection

shortestConnection

public static double shortestConnection(Tuple3d p1,
                                        Vector3d v1,
                                        Tuple3f p2,
                                        Vector3f v2,
                                        double[] lambda)

Parameters:: p1 - a point on the first line; v1 - the direction of the first line; p2 - a point on the second line; v2 - the direction of the second line; lambda - the computed scalars are written into this array
Returns:: the length of the shortest connection

shortestConnection

public static float shortestConnection(Tuple3f p1,
                                       Vector3f v1,
                                       Tuple3f p2,
                                       Vector3f v2,
                                       float[] lambda)

Parameters:: p1 - a point on the first line; v1 - the direction of the first line; p2 - a point on the second line; v2 - the direction of the second line; lambda - the computed scalars are written into this array
Returns:: the length of the shortest connection

sin

public static float sin(float x)

Returns the sine of the argument. This method uses a pre-computed table.

Parameters:: x - an angle, in radians
Returns:: the sine of the angle

sin01

public static float sin01(float x)

Returns the sine of the argument. The range of [0, 1] for x is mapped to [0, 2 π], i.e., the angle in radians is 2 π x. This method uses a pre-computed table.

Parameters:: x - an angle
Returns:: the sine of the angle

skySegment

public static int skySegment(Vector3d rv)

toFloatArray

public static float[] toFloatArray(Tuple3d p)

toFloatArray

public static float[] toFloatArray(Tuple4d p)

toFloatArray

public static float[] toFloatArray(Tuple4f p)

transformPoint

public static void transformPoint(Matrix3d t,
                                  Tuple2d p)

transformPoint

public static void transformPoint(Matrix4d t,
                                  Tuple3d p)

transformPoint

public static void transformPoint(Matrix4d t,
                                  Tuple3d p,
                                  Tuple3d out)

transformPoint

public static void transformPoint(Matrix4f t,
                                  Tuple3f p)

transformTranspose

public static void transformTranspose(Matrix3d t,
                                      Tuple3d v)

transformVector

public static void transformVector(Matrix3d t,
                                   Tuple2d v)

transformVector

public static void transformVector(Matrix4d t,
                                   Tuple3d v)

transformVector

public static void transformVector(Matrix4f t,
                                   Tuple3f v)

turbulence

public static float turbulence(float x,
                               float y,
                               float z,
                               int octaves,
                               float lambda,
                               float omega)

Overview

Package

Class

Tree

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

de.grogra.vecmath Class Math2

EPS

EPSILON

M_1_2PI

M_1_PI

M_2PI

M_PI

M_PI_2

nbSkySegments

turtsky

absthgs

abstphg

abstpp

abstps

binomial

ccos

clamp

clamp

clamp

clamp

closestConnection

csin

cutCone

cutRay2

decomposeQR

determinate3

distance

dNoise

dot

dot

dot

dot

dTurbulence

estimateScaleSquared

factorial

floor

fresnel

gamma

getBeginAndEndOfShoot

getBeginOfShoot

getEndOfShoot

getOrthogonal

getOrthogonal

getOrthogonalBasis

getOrthogonalBasis

intersectLineWithFrustum

intersectLineWithFrustum

invertAffine

invertAffine

invertAffine

invertAffine

invertAffine

invMul

invTransformPoint

invTransformPoint

invTransformPoint

invTransformPoint

invTransformPointAndVector

invTransformVector

invTransformVector

invTransformVector

invTransformVector

isInsideConeT

isInsideConeT

isNullVector

lessThan

lessThanOrEqual

lmul

makeAffine

makeAffine

makeAffine

makeAffine

max

max

max

max

min

min

min

min

de.grogra.vecmath
Class Math2