vib

## Class FloatMatrix

• ```public class FloatMatrix
extends Object```
• ### Field Summary

Fields
Modifier and Type Field and Description
`protected float` `a00`
`protected float` `a01`
`protected float` `a02`
`protected float` `a03`
`protected float` `a10`
`protected float` `a11`
`protected float` `a12`
`protected float` `a13`
`protected float` `a20`
`protected float` `a21`
`protected float` `a22`
`protected float` `a23`
`float` `x`
`float` `y`
`float` `z`
• ### Constructor Summary

Constructors
Constructor and Description
`FloatMatrix()`
`FloatMatrix(float f)`
`FloatMatrix(float[][] m)`
`FloatMatrix(FloatMatrix f)`
• ### Method Summary

All Methods
Modifier and Type Method and Description
`static float` ```angleBetween(float[] v1, float[] v2)```
`void` `apply(float[] p)`
`void` ```apply(float x, float y, float z)```
`void` `apply(Point3d p)`
`void` ```applyWithoutTranslation(float x, float y, float z)```
`void` `applyWithoutTranslation(Point3d p)`
`static FloatMatrix` `average(FloatMatrix[] array)`
`static FloatMatrix` ```bestLinear(Point3d[] x, Point3d[] y)```
`static FloatMatrix` ```bestRigid(Point3d[] set1, Point3d[] set2)```
Find the best rigid transformation from set1 to set2.
`static FloatMatrix` ```bestRigid(Point3d[] set1, Point3d[] set2, boolean allowScaling)```
`FloatMatrix` `composeWith(FloatMatrix followedBy)`
`FloatMatrix` `copyFrom(FloatMatrix f)`
`void` `copyToFlatFloatArray(float[] result)`
`static float[]` ```crossProduct(float[] a, float[] b)```
`FloatMatrix[]` `decompose()`
`float` `det()`
`static float` ```dotProduct(float[] a, float[] b)```
`boolean` `equals(FloatMatrix other)`
`static FloatMatrix` `fromCalibration(ImagePlus image)`
`Point3d` `getResult()`
`void` `guessEulerParameters(float[] parameters)`
`void` ```guessEulerParameters(float[] parameters, Point3d center)```
`FloatMatrix` `inverse()`
`boolean` `isIdentity()`
`boolean` `isIdentity(float eps)`
`boolean` `isJustTranslation()`
`static void` `main(String[] args)`
`static float[]` `normalize(float[] a)`
`boolean` `noTranslation()`
`static FloatMatrix[]` `parseMatrices(String m)`
`static FloatMatrix` `parseMatrix(String m)`
`FloatMatrix` `plus(FloatMatrix other)`
`String` `resultToString()`
`static FloatMatrix` ```rotate(float angle, int axis)```
`static FloatMatrix` ```rotateAround(float nx, float ny, float nz, float angle)```
`static FloatMatrix` ```rotateEuler(float a1, float a2, float a3)```
`static FloatMatrix` ```rotateEulerAt(float a1, float a2, float a3, float cx, float cy, float cz)```
`static FloatMatrix` ```rotateFromTo(float aX, float aY, float aZ, float bX, float bY, float bZ)```
`static FloatMatrix` ```rotateToAlignVectors(float[] v2_template, float[] v1_template, float[] v2_domain, float[] v1_domain)```
`float[]` `rowwise16()`
`FloatMatrix` ```scale(float x, float y, float z)```
`void` `setFromFlatFloatArray(float[] result)`
`static float` `size(float[] a)`
`static float` `sizeSquared(float[] a)`
`FloatMatrix` `times(FloatMatrix o)`
`String` `toString()`
`String` `toStringForAmira()`
`String` `toStringIndented(String indent)`
`static FloatMatrix` ```translate(float x, float y, float z)```
`static FloatMatrix` `translateToCenter(ImagePlus image)`
• ### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`
• ### Field Detail

• #### x

`public float x`
• #### y

`public float y`
• #### z

`public float z`
• #### a00

`protected float a00`
• #### a01

`protected float a01`
• #### a02

`protected float a02`
• #### a03

`protected float a03`
• #### a10

`protected float a10`
• #### a11

`protected float a11`
• #### a12

`protected float a12`
• #### a13

`protected float a13`
• #### a20

`protected float a20`
• #### a21

`protected float a21`
• #### a22

`protected float a22`
• #### a23

`protected float a23`
• ### Constructor Detail

• #### FloatMatrix

`public FloatMatrix()`
• #### FloatMatrix

`public FloatMatrix(float f)`
• #### FloatMatrix

`public FloatMatrix(float[][] m)`
• #### FloatMatrix

`public FloatMatrix(FloatMatrix f)`
• ### Method Detail

• #### copyFrom

`public FloatMatrix copyFrom(FloatMatrix f)`
• #### isJustTranslation

`public boolean isJustTranslation()`
• #### noTranslation

`public boolean noTranslation()`
• #### composeWith

`public FloatMatrix composeWith(FloatMatrix followedBy)`
• #### decompose

`public FloatMatrix[] decompose()`
• #### plus

`public FloatMatrix plus(FloatMatrix other)`
• #### apply

```public void apply(float x,
float y,
float z)```
• #### apply

`public void apply(Point3d p)`
• #### apply

`public void apply(float[] p)`
• #### applyWithoutTranslation

```public void applyWithoutTranslation(float x,
float y,
float z)```
• #### applyWithoutTranslation

`public void applyWithoutTranslation(Point3d p)`
• #### getResult

`public Point3d getResult()`
• #### scale

```public FloatMatrix scale(float x,
float y,
float z)```
• #### times

`public FloatMatrix times(FloatMatrix o)`
• #### det

`public float det()`
• #### inverse

`public FloatMatrix inverse()`
• #### rotate

```public static FloatMatrix rotate(float angle,
int axis)```
• #### rotateFromTo

```public static FloatMatrix rotateFromTo(float aX,
float aY,
float aZ,
float bX,
float bY,
float bZ)```
• #### dotProduct

```public static float dotProduct(float[] a,
float[] b)```
• #### sizeSquared

`public static float sizeSquared(float[] a)`
• #### size

`public static float size(float[] a)`
• #### angleBetween

```public static float angleBetween(float[] v1,
float[] v2)```
• #### crossProduct

```public static float[] crossProduct(float[] a,
float[] b)```
• #### normalize

`public static float[] normalize(float[] a)`
• #### rotateToAlignVectors

```public static FloatMatrix rotateToAlignVectors(float[] v2_template,
float[] v1_template,
float[] v2_domain,
float[] v1_domain)```
• #### rotateAround

```public static FloatMatrix rotateAround(float nx,
float ny,
float nz,
float angle)```
• #### rotateEuler

```public static FloatMatrix rotateEuler(float a1,
float a2,
float a3)```
• #### rotateEulerAt

```public static FloatMatrix rotateEulerAt(float a1,
float a2,
float a3,
float cx,
float cy,
float cz)```
• #### guessEulerParameters

`public void guessEulerParameters(float[] parameters)`
• #### guessEulerParameters

```public void guessEulerParameters(float[] parameters,
Point3d center)```
• #### translate

```public static FloatMatrix translate(float x,
float y,
float z)```
• #### bestLinear

```public static FloatMatrix bestLinear(Point3d[] x,
Point3d[] y)```
• #### bestRigid

```public static FloatMatrix bestRigid(Point3d[] set1,
Point3d[] set2)```
Find the best rigid transformation from set1 to set2. This function uses the method by Horn, using quaternions: Closed-form solution of absolute orientation using unit quaternions, Horn, B. K. P., Journal of the Optical Society of America A, Vol. 4, page 629, April 1987
• #### bestRigid

```public static FloatMatrix bestRigid(Point3d[] set1,
Point3d[] set2,
boolean allowScaling)```
• #### average

`public static FloatMatrix average(FloatMatrix[] array)`
• #### rowwise16

`public float[] rowwise16()`
• #### parseMatrix

`public static FloatMatrix parseMatrix(String m)`
• #### parseMatrices

`public static FloatMatrix[] parseMatrices(String m)`
• #### fromCalibration

`public static FloatMatrix fromCalibration(ImagePlus image)`
• #### translateToCenter

`public static FloatMatrix translateToCenter(ImagePlus image)`
• #### isIdentity

`public final boolean isIdentity()`
• #### equals

`public final boolean equals(FloatMatrix other)`
• #### isIdentity

`public final boolean isIdentity(float eps)`
• #### copyToFlatFloatArray

`public void copyToFlatFloatArray(float[] result)`
• #### setFromFlatFloatArray

`public void setFromFlatFloatArray(float[] result)`
• #### resultToString

`public String resultToString()`
• #### toStringIndented

`public String toStringIndented(String indent)`
• #### toString

`public String toString()`
Overrides:
`toString` in class `Object`
• #### toStringForAmira

`public String toStringForAmira()`
• #### main

`public static void main(String[] args)`