ArraysI (WOImageJ API)

java.lang.Object
- woSource.math.ArraysI

```
public class ArraysI
extends java.lang.Object
```
ArraysI contains manhy of my own functions that process 2D and 3D arrays
WO 8/13/2012 I now understand the byte &0xff thing. The byte datatype in java is -127..127, while we all use it here as 0..255, so the &0xff does that conversion.

Field Summary

Fields
Modifier and Type Field and Description

static float pi

static double PI

static int X

static int Y

static int Z

Fields
Modifier and Type	Field and Description
`static float`	`pi`
`static double`	`PI`
`static int`	`X`
`static int`	`Y`
`static int`	`Z`

Constructor Summary

Constructors
Constructor and Description

ArraysI()

Constructors
Constructor and Description
`ArraysI()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean[][][]`	`AND(boolean[][][] A, boolean[][][] B)`
`static boolean[][]`	`AND(boolean[][] A, boolean[][] B)`
`static byte[][][]`	`AND(byte[][][] A, boolean[][][] B)` WO 9/24/2013 want to combine a binary image of skeleton to original short image of chest CT
`static short[][][]`	`AND(short[][][] A, boolean[][][] B)`
`static LIDCnodule[]`	`append(LIDCnodule[] A, LIDCnodule[] B)` public static int[] sortLow2HighInsert(int[] A, int newval) { int i=0; // using '>=' to reduce amount of shifting to be done on insert while (i=A[i] && A[i]< Integer.MAX_VALUE) i++; if (i
`static LIDCnodule[]`	`append(LIDCnodule[] A, LIDCnodule[] B, LIDCnodule[] C)` merge such that result may be longer than either inputs
`static byte[][]`	`array1DToBitMask(int[][] A)` this maps a list of x,y coords of ON pixels into a 2D bit mask/image image dims passed as first entry in 1D array
`static float`	`avg(byte[] A)`
`static float`	`avg(byte[][] A)`
`static float`	`avg(byte[][][] A)`
`static float`	`avg(byte[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static float`	`avg(byte[][] A, int sx, int sy, int width, int height)`
`static double`	`avg(double[] A)`
`static double`	`avg(double[][] A)`
`static double`	`avg(double[][][] A)`
`static double`	`avg(double[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static double`	`avg(double[][] A, int sx, int sy, int width, int height)`
`static float`	`avg(float[] A)`
`static float`	`avg(float[][] A)`
`static float`	`avg(float[][][] A)`
`static float`	`avg(float[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static float`	`avg(float[][] A, int sx, int sy, int width, int height)`
`static float`	`avg(int[] A)`
`static float`	`avg(int[][] A)`
`static float`	`avg(int[][][] A)`
`static float`	`avg(int[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static float`	`avg(int[][] A, int sx, int sy, int width, int height)`
`static float`	`avg(short[] A)`
`static float`	`avg(short[][] A)`
`static float`	`avg(short[][][] A)`
`static float`	`avg(short[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static float`	`avg(short[][] A, int sx, int sy, int width, int height)`
`static int[][]`	`BitMaskToArray1D(byte[][] B)`
`static int[][][]`	`BitMaskToArray1D(byte[][][] B)`
`static boolean[][][]`	`Compliment(boolean[][][] A, boolean[][][] B)` boolean compliment operator = the part of A that is not also a part of B (almost == A - B)
`static boolean[][]`	`Compliment(boolean[][] A, boolean[][] B)` boolean compliment operator = the part of A that is not also a part of B (almost == A - B)
`static byte[][][]`	`Compliment(byte[][][] A, byte[][][] B)`
`static byte[][]`	`Compliment(byte[][] A, byte[][] B)`
`static boolean[][]`	`copy(boolean[][] A)`
`static boolean[][][]`	`copy(boolean[][][] A)`
`static boolean[][][][]`	`copy(boolean[][][][] A)`
`static void`	`copy(boolean[][][][] A, boolean[][][][] B)`
`static void`	`copy(boolean[][][] A, boolean[][][] B)`
`static void`	`copy(boolean[][] A, boolean[][] B)`
`static byte[][]`	`copy(byte[][] A)`
`static byte[][][]`	`copy(byte[][][] A)`
`static byte[][][][]`	`copy(byte[][][][] A)`
`static void`	`copy(byte[][][][] A, byte[][][][] B)`
`static void`	`copy(byte[][][] A, byte[][][] B)`
`static void`	`copy(byte[][] A, byte[][] B)`
`static double[]`	`copy(double[] A)`
`static double[][]`	`copy(double[][] A)`
`static void`	`copy(double[][] A, double[][] B)`
`static float[]`	`copy(float[] A)`
`static float[][]`	`copy(float[][] A)`
`static float[][][]`	`copy(float[][][] A)`
`static float[][][][]`	`copy(float[][][][] A)`
`static void`	`copy(float[][][] A, float[][][] B)`
`static void`	`copy(float[][] A, float[][] B)`
`static void`	`copy(float[] A, float[] B)`
`static int[]`	`copy(int[] A)`
`static int[][]`	`copy(int[][] A)`
`static int[][][]`	`copy(int[][][] A)`
`static void`	`copy(int[][][] A, int[][][] B)`
`static void`	`copy(int[][] A, int[][] B)`
`static void`	`copy(int[] A, int[] B)`
`static short[][]`	`copy(short[][] A)`
`static short[][][]`	`copy(short[][][] A)`
`static short[][][][]`	`copy(short[][][][] A)`
`static void`	`copy(short[][][][] A, short[][][][] B)`
`static void`	`copy(short[][][] A, short[][][] B)`
`static void`	`copy(short[][] A, short[][] B)`
`static boolean[][][]`	`copyOutsideRoi(boolean[][][] A, Rectangle3D roi)`
`static byte[][][]`	`copyOutsideRoi(byte[][][] A, Rectangle3D roi)`
`static int[][][][]`	`divide(int[][][][] A, int B)`
`static int[][][]`	`divide(int[][][] A, int B)`
`static int[][]`	`divide(int[][] A, int B)`
`static short[][][][]`	`divide(short[][][][] A, int B)`
`static short[][][]`	`divide(short[][][] A, int B)` matrix multiplication by 1/scalar
`static short[][]`	`divide(short[][] A, int B)` matrix multiplication by 1/scalar
`static byte[][][]`	`extend(byte[][][] A, int nextend1)`
`static byte[][][]`	`extend(byte[][][] A, int nextend1, int nextend2, int nextend3)`
`static byte[][]`	`extend(byte[][] A, int nextend1)`
`static byte[][]`	`extend(byte[][] A, int nextend1, int nextend2)`
`static byte[]`	`extend(byte[] A, int nextend)`
`static double[]`	`extend(double[] A, int nextend)`
`static float[][][][][][]`	`extend(float[][][][][][] A, int nextend1)`
`static float[][][][][][]`	`extend(float[][][][][][] A, int nextend1, int nextend2, int nextend3, int nextend4, int nextend5, int nextend6)`
`static float[][][][][]`	`extend(float[][][][][] A, int nextend1)`
`static float[][][][][]`	`extend(float[][][][][] A, int nextend1, int nextend2, int nextend3, int nextend4, int nextend5)`
`static float[][][][]`	`extend(float[][][][] A, int nextend1)`
`static float[][][][]`	`extend(float[][][][] A, int nextend1, int nextend2, int nextend3, int nextend4)`
`static float[][][]`	`extend(float[][][] A, int nextend1)`
`static float[][][]`	`extend(float[][][] A, int nextend1, int nextend2, int nextend3)`
`static float[][]`	`extend(float[][] A, int nextend1)`
`static float[][]`	`extend(float[][] A, int nextend1, int nextend2)`
`static float[]`	`extend(float[] A, int nextend)`
`static HyperSkelPair[]`	`extend(HyperSkelPair[] A, int nextend)`
`static int[][][][]`	`extend(int[][][][] A, int nextend1)`
`static int[][][][]`	`extend(int[][][][] A, int nextend1, int nextend2, int nextend3, int nextend4)`
`static int[][][]`	`extend(int[][][] A, int nextend1)`
`static int[][][]`	`extend(int[][][] A, int nextend1, int nextend2, int nextend3)`
`static int[][]`	`extend(int[][] A, int nextend1)`
`static int[][]`	`extend(int[][] A, int nextend1, int nextend2)`
`static int[]`	`extend(int[] A, int nextend)`
`static Point2D[][]`	`extend(Point2D[][] A, int nextend1)`
`static Point2D[][]`	`extend(Point2D[][] A, int nextend1, int nextend2)`
`static Point2D[]`	`extend(Point2D[] A, int nextend)`
`static Point3D[][]`	`extend(Point3D[][] A, int nextend1, int nextend2)`
`static Point3D[]`	`extend(Point3D[] A, int nextend)`
`static Point3Dint[][]`	`extend(Point3Dint[][] A, int nextend1, int nextend2)`
`static Point3Dint[]`	`extend(Point3Dint[] A, int nextend)`
`static short[][][][]`	`extend(short[][][][] A, int nextend1)`
`static short[][][][]`	`extend(short[][][][] A, int nextend1, int nextend2, int nextend3, int nextend4)`
`static short[][][]`	`extend(short[][][] A, int nextend1)`
`static short[][][]`	`extend(short[][][] A, int nextend1, int nextend2, int nextend3)`
`static short[][]`	`extend(short[][] A, int nextend1)`
`static short[][]`	`extend(short[][] A, int nextend1, int nextend2)`
`static Point2D`	`farthestMaxpt(float[][] A, Point2D prevpt)` WO 6/30/11 find max point.
`static Point2D`	`farthestMaxpt(float[][] A, Point2D prevpt, int x, int y, int width, int height)`
`static Point3Dint[]`	`findLocalExtrema(byte[][][][] image, int search_size, int Threshold, int NMax)` WO 12/23/10 for stack of images
`static Point3Dint[]`	`findLocalExtrema(byte[][][][] image, int searchI, int searchJ, int searchK, int Threshold, int NMax)` WO 12/23/10 for stack of images with same search size for each
`static Point3Dint[]`	`findLocalExtrema(byte[][][] image, int search_size, int Threshold, int NMax)` WO 1/19/11 3D version; 2/16/11 removing divotThreshold, and corrected error where if a new close point was found, it didn't check to see if the old point was worse and throw it out if so.
`static Point3Dint[]`	`findLocalExtrema(byte[][][] image, int searchI, int searchJ, int searchK, int Threshold, int NMax)`
`static Point2D[]`	`findLocalExtrema(int[][] image, int search_size)`
`static Point2D[]`	`findLocalExtrema(int[][] image, int search_size, float Threshold)`
`static Point2D[]`	`findLocalExtrema(int[][] image, int search_size, float Threshold, float DivotThresh, int NMax)`
`static Point2D[]`	`findLocalExtrema(int[][] image, int search_size, int NMax)`
`static Point3Dint[]`	`findLocalExtrema(short[][][][] image, int search_size, short Threshold, int NMax)`
`static Point3Dint[]`	`findLocalExtrema(short[][][] image, int search_size, float Threshold, int NMax)` WO 2/16/11 omitted DivotThresh as doesn't make sense with NCCC calculations
`static Point2D[]`	`findLocalExtrema(short[][] image, int search_size)` returns Point2D array of length of number of good candidates, up to NMax
`static Point2D[]`	`findLocalExtrema(short[][] image, int search_size, float Threshold)`
`static Point2D[]`	`findLocalExtrema(short[][] image, int search_size, float Threshold, float DivotThresh, int NMax)`
`static Point2D[]`	`findLocalExtrema(short[][] image, int search_size, int NMax)`
`static byte[][]`	`flipLR(byte[][] A)` meant to flip an image horizontally (Left-right)
`static float[][]`	`flipLR(float[][] A)`
`static short[][]`	`flipLR(short[][] A)`
`static int`	`getDim(java.lang.Object array)`
`static float`	`getInterpolatedValue(byte[][][] A, float ptd, float ptw, float pth)`
`static float`	`getInterpolatedValue(byte[][] A, float ptx, float pty)` bi-linear interpolation of array elements
`static float`	`getInterpolatedValue(float[][] A, float ptx, float pty)`
`static float`	`getInterpolatedValue(short[][][] A, float ptd, float ptw, float pth)`
`static float`	`getInterpolatedValue(short[][] A, float ptx, float pty)`
`static int`	`getRankingIndex(int[][] A, int[] rankIndices, int val, int from, int to)` WO 5/18/2012 find where the current 'val' belongs in the unsorted list A[list index][4=x,y,z,value] but with sorting accomplished by int[] rankIndices which ranks low to high.
`static float[][]`	`getRotMtx(float rotAngle)` float version, already in radians
`static float[][]`	`getRotMtx(float rotA, float rotB, float rotC)` this should work for any right handed coordinate system, where A is the first rotation about the first (X usually) axis, B is the rotation about the second (usu.
`static float[][]`	`getRotMtx(int rotAngle)` WO 6/29/04 int version for angles in degrees
`static float[][]`	`getRotMtx(int rotA, int rotB, int rotC)`
`static short[][]`	`getSlice(short[][][] A, int slice)`
`static int[]`	`getSortedIndices(float[] A, int n)`
`static short[][]`	`gradient(byte[][] A)`
`static short[][][]`	`gradient(byte[][][] A)`
`static short[][][]`	`gradient(byte[][][] A, Rectangle3D roi)`
`static short[][]`	`gradient(byte[][] A, java.awt.Rectangle roi)`
`static float[][]`	`gradient(float[][] A)`
`static float[][]`	`gradient(float[][] A, java.awt.Rectangle roi)`
`static short[][]`	`gradient(short[][] A)`
`static short[][][]`	`gradient(short[][][] A)`
`static short[][][]`	`gradient(short[][][] A, Rectangle3D roi)`
`static short[][]`	`gradient(short[][] A, java.awt.Rectangle roi)`
`static short[][][]`	`gradient2D(byte[][][] A)`
`static short[][][]`	`gradient2D(byte[][][] A, Rectangle3D roi)`
`static short[][][]`	`gradient2D(short[][][] A)`
`static short[][][]`	`gradient2D(short[][][] A, Rectangle3D roi)`
`static short[][]`	`gradientIn(byte[][] A, java.awt.Rectangle roi)`
`static short[][]`	`gradientIn(short[][] A, java.awt.Rectangle roi)`
`static boolean[][]`	`gradientMag(boolean[][] A)` WO 3/19/03 added roi feature 3/23/03 for 'binary' images, do not want to smear out edge over two pixels, rather put it on the high pixel.
`static boolean[][][]`	`gradientMag(boolean[][][] A)`
`static boolean[][][]`	`gradientMag(boolean[][][] A, Rectangle3D roi)`
`static boolean[][]`	`gradientMag(boolean[][] A, java.awt.Rectangle roi)` WO 6/13/05 duh, this works for binary images, not byte images.
`static byte[][]`	`gradientMag(byte[][] A)` WO 6/5/2013 created accurate grad calc for byte (used to be the boolean version above).
`static byte[][][]`	`gradientMag(byte[][][] A)`
`static byte[][][]`	`gradientMag(byte[][][] A, Rectangle3D roi)`
`static byte[][]`	`gradientMag(byte[][] A, java.awt.Rectangle roi)`
`static boolean[][][]`	`gradientMag2D(boolean[][][] A)`
`static boolean[][][]`	`gradientMag2D(boolean[][][] A, Rectangle3D roi)`
`static byte[][][]`	`gradientMag2D(byte[][][] A)`
`static byte[][][]`	`gradientMag2D(byte[][][] A, Rectangle3D roi)`
`static short[][]`	`gradientOut(byte[][] A, java.awt.Rectangle roi)`
`static short[][]`	`gradientOut(short[][] A, java.awt.Rectangle roi)`
`static float[][]`	`identity(float[][] A)` returns identity matrix of same dims as A
`static float[][][]`	`identity(float[][][] A)` returns identity matrix of same dims as A
`static float[][]`	`identity(int W, int H)` return identity matrix of dims WxH
`static float[]`	`insert(float[] A, float newval, int loc)`
`static int[][]`	`insert(int[][] A, int[] newval, int loc)`
`static int[][]`	`insert(int[][] A, int[] newval, int loc, int maxFirstIndex)`
`static int[]`	`insert(int[] A, int newval, int loc)` WO 5/23/2012 apparently by design this does not lengthen the array A, rather it just pushes the bottom value off the bottom of the array.
`static int[]`	`insert(int[] A, int newval, int loc, int maxIndex)`
`static NoduleCandidate[]`	`insert(NoduleCandidate[] A, NoduleCandidate newval, int loc)` insert without extending array
`static Point2D[]`	`insert(Point2D[] A, Point2D newval, int loc)`
`static Point3D[]`	`insert(Point3D[] A, Point3D newval, int loc)`
`static Point3Dint[]`	`insert(Point3Dint[] A, Point3Dint newval, int loc)`
`static boolean[][][]`	`insertSubArray(boolean[][][] A, int doffset, int woffset, int hoffset, int newdepth, int newwidth, int newheight)` WO 9/25/2013 insert subArray into bigger matrix space
`static byte[][][]`	`insertSubArray(byte[][][] A, int doffset, int woffset, int hoffset, int newdepth, int newwidth, int newheight)`
`static short[][][]`	`insertSubArray(short[][][] A, int doffset, int woffset, int hoffset, int newdepth, int newwidth, int newheight)`
`static boolean[][]`	`invert(boolean[][] A)` computes OFF/ON for each element != matrix inversion
`static boolean[][][]`	`invert(boolean[][][] A)`
`static float`	`linRegrSlope(float[] A)` linear regression: y = ax + b, assume x=0,1,2,...,N-1, returns values[2]
`static short[][][]`	`makeConst(short[][][] A, int newval)`
`static short[][]`	`makeConst(short[][] A, int newval)`
`static short[]`	`makeConst(short[] A, int newval)`
`static double[][]`	`matrix_inv(double[][] A)` matrix inverse using the JAMA library
`static float[][]`	`matrix_inv(float[][] A)` matrix inverse using the JAMA library
`static int`	`max(byte[] A)`
`static int`	`max(byte[][] A)`
`static int`	`max(byte[][][] A)`
`static int`	`max(byte[][][][] A)`
`static int`	`max(byte[][][][] A, int n, int m, int l, int p)`
`static byte[][][]`	`max(byte[][][] A, byte[][][] B)` resultant array is element-wise max between A's and B's elements
`static int`	`max(byte[][][] A, int n, int m, int l)`
`static byte[][]`	`max(byte[][] A, byte[][] B)` resultant array is element-wise max between A's and B's elements
`static int`	`max(byte[][] A, int n, int m)`
`static int`	`max(byte[] A, int end)`
`static int`	`max(byte[] A, int begin, int end)`
`static double`	`max(double[] A)`
`static double`	`max(double[][] A)`
`static double`	`max(double[][][] A)`
`static double`	`max(double[][][] A, int n, int m, int l)`
`static double`	`max(double[][] A, int n, int m)`
`static double`	`max(double[] A, int end)`
`static double`	`max(double[] A, int begin, int end)`
`static float`	`max(float[] A)`
`static float`	`max(float[][] A)`
`static float`	`max(float[][][] A)`
`static float[][][]`	`max(float[][][] A, float[][][] B)` resultant array is element-wise max between A's and B's elements
`static float`	`max(float[][][] A, int n, int m, int l)`
`static float[][]`	`max(float[][] A, float[][] B)` resultant array is element-wise max between A's and B's elements
`static float`	`max(float[][] A, int n, int m)`
`static float`	`max(float[] A, int end)`
`static float`	`max(float[] A, int begin, int end)`
`static int`	`max(int[] A)`
`static int`	`max(int[][] A)`
`static int`	`max(int[][][] A)`
`static int`	`max(int[][][][] A)`
`static int`	`max(int[][][][] A, int n, int m, int l, int p)`
`static int`	`max(int[][][] A, int n, int m, int l)`
`static int`	`max(int[][] A, int n, int m)`
`static int`	`max(int[] A, int end)`
`static int`	`max(int[] A, int begin, int end)`
`static float`	`max(Point2D[] A)`
`static float`	`max(Point2D[][] A)`
`static float`	`max(Point2D[][][] A)`
`static float`	`max(Point3D[] A)`
`static float`	`max(Point3D[][] A)`
`static float`	`max(Point3D[][][] A)`
`static int`	`max(short[] A)`
`static int`	`max(short[][] A)`
`static int`	`max(short[][][] A)`
`static int`	`max(short[][][][] A)`
`static int`	`max(short[][][][] A, int n, int m, int l, int p)`
`static int`	`max(short[][][] A, int n, int m, int l)`
`static short[][][]`	`max(short[][][] A, short[][][] B)` resultant array is element-wise max between A's and B's elements
`static int`	`max(short[][] A, int n, int m)`
`static int`	`max(short[][] A, int nstart, int nend, int mstart, int mend)`
`static short[][]`	`max(short[][] A, short[][] B)` resultant array is element-wise max between A's and B's elements
`static int`	`max(short[] A, int end)`
`static int`	`max(short[] A, int begin, int end)`
`static int`	`maxIndex(float[] A)`
`static int`	`maxIndex(float[] A, int end)`
`static int`	`maxIndex(float[] A, int begin, int end)`
`static int`	`maxIndex(int[] A)` return index to max value in array
`static int`	`maxIndex(int[] A, int end)`
`static int`	`maxIndex(int[] A, int begin, int end)`
`static Point3Dint`	`maxpt(byte[][][] A)`
`static Point3Dint`	`maxpt(byte[][][] A, int x, int y, int z, int width, int height, int depth)`
`static Point2D`	`maxpt(float[][] A)`
`static Point3Dint`	`maxpt(float[][][] A)`
`static Point3Dint`	`maxpt(float[][][] A, int x, int y, int z, int width, int height, int depth)`
`static Point2D`	`maxpt(float[][] A, int x, int y, int width, int height)`
`static Point2D`	`maxpt(int[][] A)`
`static Point3Dint`	`maxpt(int[][][] A)`
`static Point3Dint`	`maxpt(int[][][] A, int x, int y, int z, int width, int height, int depth)`
`static Point2D`	`maxpt(int[][] A, int x, int y, int width, int height)`
`static NoduleCandidate`	`maxpt(NoduleCandidate[] A)`
`static NoduleCandidate`	`maxpt(NoduleCandidate[] A, int x, int width)`
`static Point2D`	`maxpt(Point2D[] A)`
`static Point2D`	`maxpt(Point2D[][] A)`
`static Point2D`	`maxpt(Point2D[][] A, int x, int y, int width, int height)`
`static Point2D`	`maxpt(Point2D[] A, int x, int width)`
`static Point3D`	`maxpt(Point3D[] A)`
`static Point3D`	`maxpt(Point3D[] A, int x, int width)`
`static Point3Dint`	`maxpt(Point3Dint[] A)`
`static Point3Dint`	`maxpt(Point3Dint[] A, int x, int width)`
`static Point4D`	`maxpt(Point4D[] A)`
`static Point4D`	`maxpt(Point4D[] A, int x, int width)`
`static Point2D`	`maxpt(short[][] A)`
`static Point3Dint`	`maxpt(short[][][] A)`
`static Point3Dint`	`maxpt(short[][][] A, int x, int y, int z, int width, int height, int depth)`
`static Point2D`	`maxpt(short[][] A, int x, int y, int width, int height)`
`static int`	`min(byte[] A)`
`static int`	`min(byte[][] A)`
`static int`	`min(byte[][][] A)`
`static int`	`min(byte[][][][] A)`
`static int`	`min(byte[] A, int end)`
`static int`	`min(byte[] A, int begin, int end)`
`static double`	`min(double[] A)`
`static double`	`min(double[][] A)`
`static double`	`min(double[][][] A)`
`static double`	`min(double[] A, int end)`
`static double`	`min(double[] A, int begin, int end)`
`static float`	`min(float[] A)`
`static float`	`min(float[][] A)`
`static float`	`min(float[][][] A)`
`static float`	`min(float[] A, int end)`
`static float`	`min(float[] A, int begin, int end)`
`static int`	`min(int[] A)`
`static int`	`min(int[][] A)`
`static int`	`min(int[][][] A)`
`static int`	`min(int[][][][] A)`
`static int`	`min(int[] A, int end)`
`static int`	`min(int[] A, int begin, int end)`
`static float`	`min(Point2D[] A)`
`static float`	`min(Point2D[][] A)`
`static float`	`min(Point2D[][][] A)`
`static float`	`min(Point3D[] A)`
`static float`	`min(Point3D[][] A)`
`static float`	`min(Point3D[][][] A)`
`static int`	`min(short[] A)`
`static short`	`min(short[][] A)`
`static short`	`min(short[][][] A)`
`static short`	`min(short[][][][] A)`
`static int`	`min(short[] A, int end)`
`static int`	`min(short[] A, int begin, int end)`
`static Point2D`	`minpt(float[][] A)`
`static Point3Dint`	`minpt(float[][][] A)`
`static Point3Dint`	`minpt(float[][][] A, int x, int y, int z, int width, int height, int depth)`
`static Point2D`	`minpt(float[][] A, int x, int y, int width, int height)`
`static Point2D`	`minpt(int[][] A)`
`static Point3Dint`	`minpt(int[][][] A)`
`static Point3Dint`	`minpt(int[][][] A, int x, int y, int z, int width, int height, int depth)`
`static Point2D`	`minpt(int[][] A, int x, int y, int width, int height)`
`static Point2D`	`minpt(Point2D[] A)`
`static Point2D`	`minpt(Point2D[][] A)`
`static Point2D`	`minpt(Point2D[][] A, int x, int y, int width, int height)`
`static Point2D`	`minpt(Point2D[] A, int x, int width)`
`static byte[][][]`	`minus(byte[][][] A, byte[][][] B)`
`static byte[][]`	`minus(byte[][] A, byte[][] B)` resultant array is element-wise subtraction of B's from A's elements.
`static float[]`	`minus(Point3Dint A, Point3Dint B)` create vector separating the 2 Points
`static byte[][][]`	`mult(byte[][][] A, float B)` matrix multiplication by scalar
`static byte[][][]`	`mult(byte[][][] A, int B)` matrix multiplication by scalar
`static byte[][]`	`mult(byte[][] A, float B)` matrix multiplication by scalar
`static byte[][]`	`mult(byte[][] A, int B)` matrix multiplication by scalar.
`static double[][][]`	`mult(double[][][] A, double[][] B)`
`static double[]`	`mult(double[][] A, double[] B)`
`static double[][]`	`mult(double[][] A, double[][] B)`
`static double[]`	`mult(double[] A, double[][] B)`
`static float[][][][]`	`mult(float[][][][] A, float B)`
`static float[][][][]`	`mult(float[][][][] A, int B)`
`static float[][][]`	`mult(float[][][] A, float B)`
`static float[][][]`	`mult(float[][][] A, float[][] B)`
`static float[][][]`	`mult(float[][][] A, int B)`
`static float[][]`	`mult(float[][] A, float B)`
`static float[]`	`mult(float[][] A, float[] B)` does post-vec mult
`static float[][]`	`mult(float[][] A, float[][] B)`
`static float[][]`	`mult(float[][] A, int B)`
`static float[]`	`mult(float[] A, float B)`
`static float[]`	`mult(float[] A, float[][] B)` pre-mult as needed after creating rotation matrix getRotMtx() below
`static float[]`	`mult(float[] A, int B)`
`static short[][][][]`	`mult(short[][][][] A, int B)`
`static short[][][]`	`mult(short[][][] A, int B)` matrix multiplication by scalar
`static short[][]`	`mult(short[][] A, int B)` matrix multiplication by scalar
`static void`	`multvec(float[][] rot, float[][] B)` intended for transformation (rotation) of array of point vectors alters the inputted B array -- to save memory
`static void`	`multvec(float[][] rot, float[][][] B)` intended for transformation (rotation) of array of point vectors alters the inputted B array -- to save memory
`static void`	`multvec(float[][] rot, float[][][][] B)` intended for transformation (rotation) of array of point vectors alters the inputted B array -- to save memory
`static void`	`nameSorter(java.lang.String[] list)` a version of 'quicksort'
`static int`	`nbrOn(boolean[][] A)` WO 7/9/2013 return number of On pixels = volume of object if objects is connected ala a flood-fill
`static int`	`nbrOn(boolean[][][] A)`
`static void`	`normalize(double[][] A)`
`static void`	`normalize(double[][][] A)`
`static void`	`normalize(float[][] A)` normalizes an array's values (e.g.
`static void`	`normalize(float[][][] A)`
`static byte[]`	`ones(byte[] A)` returns entire matrix of 255 of same dims as A
`static byte[][]`	`ones(byte[][] A)` returns entire matrix of 255 of same dims as A
`static byte[][][]`	`ones(byte[][][] A)` returns entire matrix of 255 of same dims as A
`static float[]`	`ones(float[] A)` returns entire matrix of ones of same dims as A
`static float[][]`	`ones(float[][] A)`
`static float[][][]`	`ones(float[][][] A)`
`static int[]`	`ones(int[] A)` returns entire matrix of ones of same dims as A
`static boolean[][][]`	`OR(boolean[][][] A, boolean[][][] B)`
`static boolean[][]`	`OR(boolean[][] A, boolean[][] B)`
`static byte[][][]`	`OR(byte[][][] A, byte[][][] B)`
`static byte[][]`	`OR(byte[][] A, byte[][] B)` boolean OR operator
`static byte[][][]`	`plus(byte[][][] A, byte[][][] B)`
`static byte[][][]`	`plus(byte[][][] A, int B)`
`static float[][][]`	`plus(float[][][] A, float B)`
`static float[][][]`	`plus(float[][][] A, float[][][] B)` resultant array is element-wise addition of A's and B's elements
`static float[][]`	`plus(float[][] A, float[][] B)`
`static int[][]`	`plus(int[][] A, int[][] B)`
`static short[][][]`	`plus(short[][][] A, int B)`
`static short[][]`	`plus(short[][] A, short[][] B)`
`static void`	`print(boolean[] A)`
`static void`	`print(boolean[][] A)`
`static void`	`print(boolean[][] A, int m, int n)`
`static void`	`print(boolean[][] A, int m, int n, java.lang.String label)`
`static void`	`print(boolean[][] A, java.lang.String label)`
`static void`	`print(boolean[] A, int n)`
`static void`	`print(boolean[] A, int n, java.lang.String label)`
`static void`	`print(boolean[] A, java.lang.String label)`
`static void`	`print(byte[] A)`
`static void`	`print(byte[] A, int n)`
`static void`	`print(byte[] A, int n, java.lang.String label)`
`static void`	`print(byte[] A, java.lang.String label)`
`static void`	`print(double[] A)`
`static void`	`print(double[][] A)`
`static void`	`print(double[][] A, int m, int n)`
`static void`	`print(double[][] A, int m, int n, java.lang.String label)`
`static void`	`print(double[][] A, java.lang.String label)`
`static void`	`print(double[] A, int n)`
`static void`	`print(double[] A, int n, java.lang.String label)`
`static void`	`print(double[] A, java.lang.String label)`
`static void`	`print(float[] A)`
`static void`	`print(float[][] A)`
`static void`	`print(float[][][] A)` my ArraysDisplay 3D conventions [depth][width][height]
`static void`	`print(float[][][] A, int d, int w, int h, java.lang.String label)`
`static void`	`print(float[][][] A, java.lang.String label)`
`static void`	`print(float[][] A, int m, int n)`
`static void`	`print(float[][] A, int m, int n, java.lang.String label)`
`static void`	`print(float[][] A, java.lang.String label)`
`static void`	`print(float[] A, int n)`
`static void`	`print(float[] A, int n, java.lang.String label)`
`static void`	`print(float[] A, java.lang.String label)`
`static void`	`print(int[][] A)`
`static void`	`print(int[][] A, int m, int n)`
`static void`	`print(int[][] A, int m, int n, java.lang.String label)`
`static void`	`print(int[][] A, java.lang.String label)`
`static void`	`print(int[] A, int n)`
`static void`	`print(int[] A, int n, java.lang.String label)`
`static void`	`print(int[] A, java.lang.String label)`
`static void`	`print(LIDCnodule[][] A, java.lang.String label)` 2/21/11 this version permits different size of 2nd dimension for each 1st dim
`static void`	`print(LIDCnodule[] A, int n, java.lang.String label)`
`static void`	`print(LIDCnodule[] A, java.lang.String label)`
`static void`	`print(NoduleCandidate[][] A, java.lang.String label)`
`static void`	`print(NoduleCandidate[] A, int n, java.lang.String label)`
`static void`	`print(NoduleCandidate[] A, java.lang.String label)`
`static void`	`print(Point2D[] A, int n, java.lang.String label)`
`static void`	`print(Point2D[] A, java.lang.String label)`
`static void`	`print(Point3D[] A, int n, java.lang.String label)`
`static void`	`print(Point3D[] A, java.lang.String label)`
`static void`	`print(Point3Dint[] A, int n, java.lang.String label)`
`static void`	`print(Point3Dint[] A, java.lang.String label)`
`static void`	`print(Point4D[] A, int n, java.lang.String label)`
`static void`	`print(Point4D[] A, java.lang.String label)`
`static void`	`print(short[] A)`
`static void`	`print(short[] A, int n)`
`static void`	`print(short[] A, int n, java.lang.String label)`
`static void`	`print(java.lang.String[] A)`
`static void`	`print(java.lang.String[][] A, int m, int n, java.lang.String label)`
`static void`	`print(java.lang.String[][] A, java.lang.String label)`
`static void`	`print(java.lang.String[] A, int n)`
`static void`	`print(java.lang.String[] A, int n, java.lang.String label)`
`static void`	`print(java.lang.String[] A, java.lang.String label)`
`static float[][][][][]`	`read_sparse(float[][][][][] typeFlag, java.lang.String path)`
`static float[][][][]`	`read_sparse(float[][][][] typeFlag, java.lang.String path)`
`static byte[][][]`	`read(byte[][][] typeFlag, java.lang.String path)`
`static double[][]`	`read(double[][] typeFlag, java.lang.String path)`
`static double[]`	`read(double[] typeFlag, java.lang.String label)`
`static float[][][][][]`	`read(float[][][][][] typeFlag, java.lang.String path)`
`static float[][][][]`	`read(float[][][][] typeFlag, java.lang.String path)`
`static float[][][]`	`read(float[][][] typeFlag, java.lang.String path)`
`static float[][]`	`read(float[][] typeFlag, java.lang.String path)`
`static float[]`	`read(float[] typeFlag, java.lang.String label)`
`static int[][]`	`read(int[][] typeFlag, java.lang.String path)`
`static int[]`	`read(int[] typeFlag, java.lang.String label)`
`static LIDCnodule[][]`	`read(LIDCnodule[][] A, java.lang.String path)`
`static LIDCnodule[]`	`read(LIDCnodule[] A, java.lang.String path)`
`static NoduleCandidate[]`	`read(NoduleCandidate[] A, java.lang.String path)`
`static Point3D[]`	`read(Point3D[] A, java.lang.String label)`
`static Point3D[]`	`read(Point3D[] A, java.lang.String label, boolean ask)`
`static Point4D[]`	`read(Point4D[] A, java.lang.String label)`
`static Point4D[]`	`read(Point4D[] A, java.lang.String label, boolean ask)`
`static Polygon2D[]`	`read(Polygon2D[] A, java.lang.String label)`
`static Polygon2D`	`read(Polygon2D A, java.lang.String label)`
`static Polygon3D[]`	`read(Polygon3D[] A, java.lang.String label)`
`static Polygon3Dint[]`	`read(Polygon3Dint[] A, java.lang.String label)`
`static float[]`	`read(java.lang.String label)`
`static short[]`	`redimension(short[][] A)` convert from 2D array into one long 1D array using convensions in imageProcessor
`static boolean[][]`	`remove(boolean[][] A, int loc1)`
`static boolean[]`	`remove(boolean[] A, int loc)` remove point and shorten array
`static float[][][]`	`remove(float[][][] A, int loc1)`
`static float[][]`	`remove(float[][] A, int loc1)`
`static float[]`	`remove(float[] A, int loc)`
`static int[][]`	`remove(int[][] A, int loc1)`
`static NoduleCandidate[]`	`remove(NoduleCandidate[] A, int loc)`
`static Point2D[]`	`remove(Point2D[] A, int loc)`
`static Point3D[]`	`remove(Point3D[] A, int loc)`
`static Point3Dint[]`	`remove(Point3Dint[] A, int loc)`
`static Point4D[]`	`remove(Point4D[] A, int loc)`
`static java.lang.String[]`	`remove(java.lang.String[] A, int loc)`
`static short[][][]`	`resize(short[][][] A, double dScale, double wScale, double hScale)`
`static short[][]`	`resize(short[][] A, double wScale, double hScale)` stretch the image/array
`static byte[][][]`	`resizeHalf(byte[][][] A)` WO 1/10/2012, ImageJ built-in resize 3D is not doing slice dim correctly.
`static int[][][]`	`resizeHalf(int[][][] A)`
`static short[][][]`	`resizeHalf(short[][][] A)`
`static byte[][][]`	`restoreArray(byte[][][] A, Rectangle3D croppedroi, Rectangle3D origroi)`
`static byte[][]`	`restoreArray(byte[][] A, java.awt.Rectangle croppedroi, java.awt.Rectangle origroi)`
`static void`	`scale(byte[][] A)` change the element values to fit within the given range
`static void`	`scale(byte[][][] A)`
`static void`	`scale(byte[][][] A, int min, int max)`
`static void`	`scale(byte[][] A, int min, int max)`
`static void`	`scale(double[][] A)`
`static void`	`scale(double[][][] A)`
`static void`	`scale(double[][][] A, double min, double max)`
`static void`	`scale(double[][] A, double min, double max)`
`static void`	`scale(float[][] A)`
`static void`	`scale(float[][][] A)`
`static void`	`scale(float[][][] A, float min, float max)`
`static void`	`scale(float[][] A, float min, float max)`
`static void`	`scale(int[][] A)`
`static void`	`scale(int[][][] A)`
`static void`	`scale(int[][][] A, int min, int max)`
`static void`	`scale(int[][] A, int min, int max)`
`static void`	`scale(short[][] A)`
`static void`	`scale(short[][][] A)`
`static void`	`scale(short[][][] A, int minval, int maxval)`
`static void`	`scale(short[][] A, int minval, int maxval)`
`static int[][]`	`shiftup(int[][] A, int iloc)`
`static int[][]`	`shiftup(int[][] A, int iloc, int by, int maxpts)` this has unique definition that it shifts entire 2nd dim down along 1st dim
`static int[]`	`shiftup(int[] A, int loc)`
`static int[]`	`shiftup(int[] A, int loc, int by)`
`static short[][]`	`shiftup(short[][] A, int iloc)`
`static short[][]`	`shiftup(short[][] A, int iloc, int by)` this has unique definition that it shifts entire 2nd dim down along 1st dim
`static short[]`	`shiftup(short[] A, int loc)` remove point without shortening array
`static short[]`	`shiftup(short[] A, int loc, int by)`
`static void`	`sort(float[] A)`
`static void`	`sort(int[] A)` quick-sort type.
`static void`	`sort(LIDCnodule[] A)` WO 2/8/11 sort by patientID.
`static void`	`sort(NoduleCandidate[] A)`
`static void`	`sort(Point3D[] A)`
`static void`	`sort(Point4D[] A)` 1/29/11 this sort is not working correctly -- the last 10 items in 150 element list should not be there
`static float[]`	`sortInsert(float[] A, float newval)`
`static int[][]`	`sortInsert(int[][] A, int[] newval, int maxIndex, int from, int to)` maxIndex is an index not a count (use A.length-1) WO 5/23/2012 trying to improve efficiency with center check and split.
`static int[]`	`sortInsert(int[] A, int newval)` WO 5/24/2012 will someday want to make this more efficient like the 2D one below
`static NoduleCandidate[]`	`sortInsert(NoduleCandidate[] A, NoduleCandidate newval)`
`static Point2D[]`	`sortInsert(Point2D[] A, Point2D newval)`
`static Point3D[]`	`sortInsert(Point3D[] A, Point3D newval)`
`static Point3D[]`	`sortInsert(Point3D[] A, Point3D[] B)` WO 12/23/2010 merge 2 lists, but do not extend beyond the max length
`static Point3Dint[]`	`sortInsert(Point3Dint[] A, Point3Dint newval)`
`static int[][]`	`sortLow2HighInsert(int[][] A, int[] newval)` Sort low to high.
`static int[][]`	`sortLow2HighInsert(int[][] A, int[] newval, int maxIndex)`
`static int[][]`	`sortLow2HighInsert(int[][] A, int[] newval, int maxIndex, int from, int to)`
`static NoduleCandidate[]`	`sortMerge(NoduleCandidate[] A, NoduleCandidate[] B)`
`static Point3D[]`	`sortMerge(Point3D[] A, Point3D[] B)` merge such that result may be longer than either inputs
`static Point4D[]`	`sortMerge(Point4D[] A, Point4D[] B)` merge such that result may be longer than either inputs
`static float[][][]`	`sqrt(float[][][] A)` computes A[i][j]*A[i][j] for each element != matrix multiplication
`static float`	`stdev(byte[] A)`
`static float`	`stdev(byte[][] A)`
`static float`	`stdev(byte[][][] A)`
`static float`	`stdev(float[] A)`
`static float`	`stdev(float[][] A)`
`static float`	`stdev(float[][][] A)`
`static float`	`stdev(short[] A)`
`static float`	`stdev(short[][] A)`
`static float`	`stdev(short[][][] A)`
`static boolean`	`stringGreaterThan(java.lang.String s1, java.lang.String s2)`
`static boolean`	`stringLessThan(java.lang.String s1, java.lang.String s2)` WO my versions of stringarray sorting for comparing filenames whose initial name characters are integers (1.img, 10.img, 2.img, 3,img) the windows sorter messes up these.
`static boolean[][][]`	`subArray(boolean[][][] A, int doffset, int woffset, int hoffset, int newdepth, int newwidth, int newheight)`
`static boolean[][][]`	`subArray(boolean[][][] A, Rectangle3D roi)`
`static boolean[][]`	`subArray(boolean[][] A, int woffset, int hoffset, int newwidth, int newheight)`
`static boolean[][]`	`subArray(boolean[][] A, java.awt.Rectangle roi)`
`static byte[][][]`	`subArray(byte[][][] A, int doffset, int woffset, int hoffset, int newdepth, int newwidth, int newheight)`
`static byte[][][]`	`subArray(byte[][][] A, Rectangle3D roi)`
`static byte[][]`	`subArray(byte[][] A, int woffset, int hoffset, int newwidth, int newheight)`
`static byte[][]`	`subArray(byte[][] A, java.awt.Rectangle roi)`
`static float[][][]`	`subArray(float[][][] A, int doffset, int woffset, int hoffset, int newdepth, int newwidth, int newheight)`
`static float[][][]`	`subArray(float[][][] A, Rectangle3D roi)`
`static float[][]`	`subArray(float[][] A, int woffset, int hoffset, int newwidth, int newheight)`
`static float[][]`	`subArray(float[][] A, java.awt.Rectangle roi)`
`static float[]`	`subArray(float[] A, int offset, int newwidth)`
`static int[][][]`	`subArray(int[][][] A, int doffset, int woffset, int hoffset, int newdepth, int newwidth, int newheight)`
`static int[][][]`	`subArray(int[][][] A, Rectangle3D roi)`
`static int[][]`	`subArray(int[][] A, int woffset, int hoffset, int newwidth, int newheight)`
`static int[][]`	`subArray(int[][] A, java.awt.Rectangle roi)`
`static int[]`	`subArray(int[] A, int offset, int newwidth)`
`static LIDCnodule[]`	`subArray(LIDCnodule[] A, int offset, int newwidth)`
`static NoduleCandidate[]`	`subArray(NoduleCandidate[] A, int offset, int newwidth)`
`static Point3D[]`	`subArray(Point3D[] A, int offset, int newwidth)`
`static Point4D[]`	`subArray(Point4D[] A, int offset, int newwidth)`
`static java.util.Properties[]`	`subArray(java.util.Properties[] A, int offset, int newdepth)`
`static short[][][]`	`subArray(short[][][] A, int doffset, int woffset, int hoffset, int newdepth, int newwidth, int newheight)`
`static short[][][]`	`subArray(short[][][] A, Rectangle3D roi)`
`static short[][]`	`subArray(short[][] A, int woffset, int hoffset, int newwidth, int newheight)`
`static short[][]`	`subArray(short[][] A, java.awt.Rectangle roi)`
`static java.lang.String[]`	`subArray(java.lang.String[] A, int offset, int newdepth)`
`static float[][][]`	`subMiddle(float[][][] A, int newdepth, int newwidth, int newheight)`
`static float[][]`	`subMiddle(float[][] A, int newwidth, int newheight)`
`static float[]`	`subMiddle(float[] A, int newwidth)`
`static short[][][]`	`subMiddle(short[][][] A, int newdepth, int newwidth, int newheight)`
`static short[][]`	`subMiddle(short[][] A, int newwidth, int newheight)`
`static float`	`sum(byte[] A)` WO 1/4/11 return float here since sum can easily be > byte.max
`static float`	`sum(byte[][] A)`
`static float`	`sum(byte[][][] A)`
`static float`	`sum(byte[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static float`	`sum(byte[][] A, int sx, int sy, int width, int height)`
`static float`	`sum(float[] A)`
`static float`	`sum(float[][] A)`
`static float`	`sum(float[][][] A)`
`static float`	`sum(float[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static float`	`sum(float[][] A, int sx, int sy, int width, int height)`
`static int`	`sum(int[] A)`
`static int`	`sum(int[][] A)`
`static int`	`sum(int[][][] A)`
`static int`	`sum(int[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static int`	`sum(int[][] A, int sx, int sy, int width, int height)`
`static short`	`sum(short[] A)`
`static short`	`sum(short[][] A)`
`static short`	`sum(short[][][] A)`
`static short`	`sum(short[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static short`	`sum(short[][] A, int sx, int sy, int width, int height)`
`static float`	`sumSquares(float[] A)`
`static float`	`sumSquares(float[][] A)`
`static float`	`sumSquares(float[][][] A)`
`static float`	`sumSquares(float[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static float`	`sumSquares(float[][] A, int sx, int sy, int width, int height)`
`static short`	`sumSquares(short[] A)`
`static short`	`sumSquares(short[][] A)`
`static short`	`sumSquares(short[][][] A)`
`static short`	`sumSquares(short[][][] A, int sx, int sy, int sz, int width, int height, int depth)`
`static short`	`sumSquares(short[][] A, int sx, int sy, int width, int height)`
`static void`	`swap(float[] A, float[] B)`
`static void`	`swap(int[] A, int[] B)`
`static boolean[][]`	`toBoolean(byte[][] A)`
`static boolean[][][]`	`toBoolean(byte[][][] A)`
`static boolean[][][]`	`toBoolean(byte[][][] A, int threshold)`
`static boolean[][]`	`toBoolean(byte[][] A, int threshold)`
`static boolean[][]`	`toBoolean(short[][] A)`
`static boolean[][][]`	`toBoolean(short[][][] A)`
`static boolean[][][]`	`toBoolean(short[][][] A, int threshold)`
`static byte[][]`	`toByte(boolean[][] A)`
`static byte[][][]`	`toByte(boolean[][][] A)`
`static byte[][]`	`toByte(float[][] A)`
`static byte[][][]`	`toByte(float[][][] A)`
`static byte[][]`	`toByte(int[][] A)`
`static byte[][][]`	`toByte(int[][][] A)`
`static byte[][]`	`toByte(short[][] A)`
`static byte[][][]`	`toByte(short[][][] A)`
`static byte[][][]`	`toByte(short[][][] A, int minval, int maxval)`
`static byte[][]`	`toByte(short[][] A, int minval, int maxval)` 5/19/2012 added this for use with Dicom images where ther Hounsfield unit range should be -1024 to +1024, but can have metal that gives the max value over 3,000, which throws off the scaling.
`static double[]`	`toDouble(float[] A)`
`static double[][]`	`toDouble(float[][] A)`
`static double[][][]`	`toDouble(float[][][] A)`
`static double[][]`	`toDouble(int[][] A)`
`static double[][][]`	`toDouble(int[][][] A)`
`static float[][]`	`toFloat(boolean[][] A)`
`static float[][][]`	`toFloat(boolean[][][] A)`
`static float[][][]`	`toFloat(boolean[][][] A, float maxvalue)`
`static float[][][]`	`toFloat(boolean[][][] A, float minvalue, float maxvalue)`
`static float[][]`	`toFloat(boolean[][] A, float maxvalue)`
`static float[][]`	`toFloat(boolean[][] A, float minvalue, float maxvalue)`
`static float[][]`	`toFloat(byte[][] A)`
`static float[][][]`	`toFloat(byte[][][] A)`
`static float[]`	`toFloat(double[] A)`
`static float[][]`	`toFloat(double[][] A)`
`static float[][][]`	`toFloat(double[][][] A)`
`static float[]`	`toFloat(int[] A)`
`static float[][]`	`toFloat(int[][] A)`
`static float[][]`	`toFloat(short[][] A)`
`static float[][][]`	`toFloat(short[][][] A)`
`static int[][]`	`toInt(byte[][] A)`
`static int[][][]`	`toInt(byte[][][] A)`
`static int[]`	`toInt(float[] A)`
`static int[][]`	`toInt(float[][] A)`
`static int[][][]`	`toInt(float[][][] A)`
`static int[][][][]`	`toInt(float[][][][] A)`
`static short[]`	`toShort(boolean[] A)`
`static short[][]`	`toShort(boolean[][] A)`
`static short[][][]`	`toShort(boolean[][][] A)`
`static short[][][]`	`toShort(boolean[][][] A, int maxvalue)`
`static short[][][]`	`toShort(boolean[][][] A, int minvalue, int maxvalue)`
`static short[][]`	`toShort(boolean[][] A, int maxvalue)`
`static short[][]`	`toShort(boolean[][] A, int minvalue, int maxvalue)`
`static short[]`	`toShort(boolean[] A, int maxvalue)`
`static short[]`	`toShort(boolean[] A, int minvalue, int maxvalue)`
`static short[]`	`toShort(byte[] A)`
`static short[][]`	`toShort(byte[][] A)`
`static short[][][]`	`toShort(byte[][][] A)`
`static short[][]`	`toShort(float[][] A)`
`static short[][][]`	`toShort(float[][][] A)`
`static short[]`	`toShort(int[] A)`
`static short[][]`	`toShort(int[][] A)`
`static short[][][]`	`toShort(int[][][] A)`
`static short[]`	`toShort(java.lang.Object A)`
`static byte[][]`	`transpose(byte[][] A)`
`static double[][]`	`transpose(double[][] A)`
`static float[][]`	`transpose(float[][] A)`
`static short[][]`	`transpose(short[][] A)`
`static void`	`write_sparse(float[][][][][] A, int n, int m, int d, int e, int f, java.lang.String label, boolean ask)`
`static void`	`write_sparse(float[][][][][] A, java.lang.String label)`
`static void`	`write_sparse(float[][][][][] A, java.lang.String label, boolean ask)`
`static void`	`write_sparse(float[][][][] A, int n, int m, int d, int e, java.lang.String label, boolean ask)`
`static void`	`write_sparse(float[][][][] A, java.lang.String label)`
`static void`	`write_sparse(float[][][][] A, java.lang.String label, boolean ask)`
`static void`	`write(byte[][][] A, int n, int m, int d, java.lang.String label, boolean ask)`
`static void`	`write(byte[][][] A, java.lang.String label)`
`static void`	`write(byte[][][] A, java.lang.String label, boolean ask)`
`static void`	`write(double[] A, int n, java.lang.String label)`
`static void`	`write(double[] A, java.lang.String label)`
`static void`	`write(float[][][][][] A, int n, int m, int d, int e, int f, java.lang.String label, boolean ask)` works but output files can be very large (~60M for eigenvectors of DTI).
`static void`	`write(float[][][][][] A, java.lang.String label)`
`static void`	`write(float[][][][][] A, java.lang.String label, boolean ask)`
`static void`	`write(float[][][][] A, int n, int m, int d, int e, java.lang.String label, boolean ask)`
`static void`	`write(float[][][][] A, java.lang.String label)`
`static void`	`write(float[][][][] A, java.lang.String label, boolean ask)`
`static void`	`write(float[][][] A, int n, int m, int d, java.lang.String label, boolean ask)`
`static void`	`write(float[][][] A, java.lang.String label)`
`static void`	`write(float[][][] A, java.lang.String label, boolean ask)`
`static void`	`write(float[] Xvals, float[] Yvals, float[] Ystdev, int n, java.lang.String label)`
`static void`	`write(float[] Xvals, float[] Yvals, float[] Ystdev, java.lang.String label)`
`static void`	`write(float[] Xvals, float[] Yvals, int n, java.lang.String label)`
`static void`	`write(float[] Xvals, float[] Yvals, java.lang.String label)` WO 10/2/07 great, we can write out 2 arrays but cannot read in and save 2 arrays
`static void`	`write(float[] A, int n, java.lang.String label)`
`static void`	`write(float[] A, java.lang.String label)`
`static void`	`write(int[][][] A, int n, int m, int d, java.lang.String label, boolean ask)`
`static void`	`write(int[][][] A, java.lang.String label)`
`static void`	`write(int[][][] A, java.lang.String label, boolean ask)`
`static void`	`write(int[][] A, int n, int m, java.lang.String label, boolean ask)`
`static void`	`write(int[][] A, java.lang.String label)`
`static void`	`write(int[][] A, java.lang.String label, boolean ask)`
`static void`	`write(int[] A, int n, java.lang.String label)`
`static void`	`write(int[] A, int n, java.lang.String label, boolean ask)`
`static void`	`write(int[] A, java.lang.String label)`
`static void`	`write(int[] A, java.lang.String label, boolean ask)`
`static void`	`write(LIDCnodule[][] A, java.lang.String path)`
`static void`	`write(LIDCnodule[] A, int npts, java.lang.String path)`
`static void`	`write(LIDCnodule[] A, java.lang.String path)`
`static void`	`write(NoduleCandidate[][] A, java.lang.String path)`
`static void`	`write(NoduleCandidate[][] A, java.lang.String path, boolean ask)`
`static void`	`write(NoduleCandidate[] A, int npts, java.lang.String path)`
`static void`	`write(NoduleCandidate[] A, int npts, java.lang.String path, boolean ask)`
`static void`	`write(NoduleCandidate[] A, java.lang.String path)`
`static void`	`write(NoduleCandidate[] A, java.lang.String path, boolean ask)`
`static void`	`write(Point2D[][] A, java.lang.String label)`
`static void`	`write(Point2D[] A, int n, java.lang.String label)`
`static void`	`write(Point2D[] A, java.lang.String label)`
`static void`	`write(Point3D[][][] A, java.lang.String label)`
`static void`	`write(Point3D[][] A, java.lang.String label)`
`static void`	`write(Point3D[] A, int n, java.lang.String label)`
`static void`	`write(Point3D[] A, int n, java.lang.String label, boolean ask)`
`static void`	`write(Point3D[] A, java.lang.String label)`
`static void`	`write(Point4D[][][] A, java.lang.String label)`
`static void`	`write(Point4D[] A, int n, java.lang.String label)`
`static void`	`write(Point4D[] A, int n, java.lang.String label, boolean ask)`
`static void`	`write(Point4D[] A, java.lang.String label)`
`static void`	`write(Point4D[] A, java.lang.String label, boolean ask)`
`static void`	`write(Polygon2D[] A, java.lang.String label)`
`static void`	`write(Polygon2D A, java.lang.String label)`
`static void`	`write(Polygon3D[] A, java.lang.String label)`
`static void`	`write(Polygon3Dint[] A, java.lang.String label)`
`static void`	`write(short[][][] A, int n, int m, int d, java.lang.String label, boolean ask)`
`static void`	`write(short[][][] A, java.lang.String label)`
`static void`	`write(short[][][] A, java.lang.String label, boolean ask)`
`static boolean[]`	`zeros(boolean[] A)`
`static boolean[][]`	`zeros(boolean[][] A)`
`static boolean[][][]`	`zeros(boolean[][][] A)`
`static byte[]`	`zeros(byte[] A)`
`static byte[][]`	`zeros(byte[][] A)`
`static byte[][][]`	`zeros(byte[][][] A)`
`static double[]`	`zeros(double[] A)`
`static double[][]`	`zeros(double[][] A)`
`static double[][][]`	`zeros(double[][][] A)`
`static float[]`	`zeros(float[] A)`
`static float[][]`	`zeros(float[][] A)`
`static float[][][]`	`zeros(float[][][] A)`
`static float[][][][]`	`zeros(float[][][][] A)`
`static float[][][][][][]`	`zeros(float[][][][][][] A)`
`static int[]`	`zeros(int[] A)` returns array of zeros of same dims as A
`static int[][]`	`zeros(int[][] A)`
`static int[][][]`	`zeros(int[][][] A)`
`static int[][][][]`	`zeros(int[][][][] A)`
`static short[]`	`zeros(short[] A)`
`static short[][]`	`zeros(short[][] A)`
`static short[][][]`	`zeros(short[][][] A)`
`static short[][][][]`	`zeros(short[][][][] A)`

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

Field Detail
- X
```
public static final int X
```
  See Also:
  
  Constant Field Values
- Y
```
public static final int Y
```
  See Also:
  
  Constant Field Values
- Z
```
public static final int Z
```
  See Also:
  
  Constant Field Values
- PI
```
public static final double PI
```
  See Also:
  
  Constant Field Values
- pi
```
public static final float pi
```
  See Also:
  
  Constant Field Values

Constructor Detail
- ArraysI
```
public ArraysI()
```

Method Detail

getDim

public static int getDim(java.lang.Object array)

copy

public static void copy(boolean[][] A,
                        boolean[][] B)

copy

public static boolean[][] copy(boolean[][] A)

copy

public static void copy(boolean[][][] A,
                        boolean[][][] B)

copy

public static boolean[][][] copy(boolean[][][] A)

copy

public static void copy(boolean[][][][] A,
                        boolean[][][][] B)

copy

public static boolean[][][][] copy(boolean[][][][] A)

copy

public static void copy(byte[][] A,
                        byte[][] B)

copy

public static byte[][] copy(byte[][] A)

copy

public static void copy(byte[][][] A,
                        byte[][][] B)

copy

public static byte[][][] copy(byte[][][] A)

copy

public static void copy(byte[][][][] A,
                        byte[][][][] B)

copy

public static byte[][][][] copy(byte[][][][] A)

copy

public static void copy(short[][] A,
                        short[][] B)

copy

public static short[][] copy(short[][] A)

copy

public static void copy(short[][][] A,
                        short[][][] B)

copy

public static void copy(short[][][][] A,
                        short[][][][] B)

copy

public static short[][][] copy(short[][][] A)

copy

public static short[][][][] copy(short[][][][] A)

copy

public static void copy(int[] A,
                        int[] B)

copy
```
public static int[] copy(int[] A)
```

copy

public static void copy(int[][] A,
                        int[][] B)

copy

public static int[][] copy(int[][] A)

copy

public static void copy(int[][][] A,
                        int[][][] B)

copy

public static int[][][] copy(int[][][] A)

copy

public static void copy(float[] A,
                        float[] B)

copy

public static float[] copy(float[] A)

copy

public static void copy(float[][] A,
                        float[][] B)

copy

public static float[][] copy(float[][] A)

copy

public static void copy(float[][][] A,
                        float[][][] B)

copy

public static float[][][] copy(float[][][] A)

copy

public static float[][][][] copy(float[][][][] A)

copy

public static double[] copy(double[] A)

copy

public static void copy(double[][] A,
                        double[][] B)

copy

public static double[][] copy(double[][] A)

copyOutsideRoi

public static boolean[][][] copyOutsideRoi(boolean[][][] A,
                                           Rectangle3D roi)

copyOutsideRoi

public static byte[][][] copyOutsideRoi(byte[][][] A,
                                        Rectangle3D roi)

swap

public static void swap(int[] A,
                        int[] B)

swap

public static void swap(float[] A,
                        float[] B)

identity
```
public static float[][] identity(float[][] A)
```
returns identity matrix of same dims as A

identity

public static float[][] identity(int W,
                                 int H)

return identity matrix of dims WxH

identity

public static float[][][] identity(float[][][] A)

returns identity matrix of same dims as A

ones
```
public static byte[] ones(byte[] A)
```
returns entire matrix of 255 of same dims as A

ones
```
public static byte[][] ones(byte[][] A)
```
returns entire matrix of 255 of same dims as A

ones
```
public static byte[][][] ones(byte[][][] A)
```
returns entire matrix of 255 of same dims as A

ones
```
public static int[] ones(int[] A)
```
returns entire matrix of ones of same dims as A

ones
```
public static float[] ones(float[] A)
```
returns entire matrix of ones of same dims as A

ones

public static float[][] ones(float[][] A)

ones

public static float[][][] ones(float[][][] A)

zeros
```
public static int[] zeros(int[] A)
```
returns array of zeros of same dims as A

zeros

public static int[][] zeros(int[][] A)

zeros

public static int[][][] zeros(int[][][] A)

zeros

public static int[][][][] zeros(int[][][][] A)

zeros

public static boolean[] zeros(boolean[] A)

zeros

public static boolean[][] zeros(boolean[][] A)

zeros

public static boolean[][][] zeros(boolean[][][] A)

zeros

public static float[] zeros(float[] A)

zeros

public static float[][] zeros(float[][] A)

zeros

public static float[][][] zeros(float[][][] A)

zeros

public static float[][][][] zeros(float[][][][] A)

zeros

public static float[][][][][][] zeros(float[][][][][][] A)

zeros
```
public static byte[] zeros(byte[] A)
```

zeros

public static byte[][] zeros(byte[][] A)

zeros

public static byte[][][] zeros(byte[][][] A)

zeros

public static short[] zeros(short[] A)

zeros

public static short[][] zeros(short[][] A)

zeros

public static short[][][] zeros(short[][][] A)

zeros

public static short[][][][] zeros(short[][][][] A)

zeros

public static double[] zeros(double[] A)

zeros

public static double[][] zeros(double[][] A)

zeros

public static double[][][] zeros(double[][][] A)

invert
```
public static boolean[][] invert(boolean[][] A)
```
computes OFF/ON for each element != matrix inversion

invert

public static boolean[][][] invert(boolean[][][] A)

sqrt
```
public static float[][][] sqrt(float[][][] A)
```
computes A[i][j]*A[i][j] for each element != matrix multiplication

makeConst

public static short[] makeConst(short[] A,
                                int newval)

makeConst

public static short[][] makeConst(short[][] A,
                                  int newval)

makeConst

public static short[][][] makeConst(short[][][] A,
                                    int newval)

transpose

public static byte[][] transpose(byte[][] A)

transpose

public static short[][] transpose(short[][] A)

transpose

public static float[][] transpose(float[][] A)

transpose

public static double[][] transpose(double[][] A)

matrix_inv

public static float[][] matrix_inv(float[][] A)

matrix inverse using the JAMA library

matrix_inv

public static double[][] matrix_inv(double[][] A)

matrix inverse using the JAMA library

flipLR
```
public static byte[][] flipLR(byte[][] A)
```
meant to flip an image horizontally (Left-right)

flipLR

public static short[][] flipLR(short[][] A)

flipLR

public static float[][] flipLR(float[][] A)

minus

public static float[] minus(Point3Dint A,
                            Point3Dint B)

create vector separating the 2 Points

mult
```
public static byte[][] mult(byte[][] A,
                            int B)
```
matrix multiplication by scalar. If B<0 then need to invert and rescale to get back to 0..255, else all pts are zero since byte cannot go negative.

mult

public static byte[][][] mult(byte[][][] A,
                              int B)

matrix multiplication by scalar

mult

public static byte[][] mult(byte[][] A,
                            float B)

matrix multiplication by scalar

mult

public static byte[][][] mult(byte[][][] A,
                              float B)

matrix multiplication by scalar

mult

public static short[][] mult(short[][] A,
                             int B)

matrix multiplication by scalar

mult

public static short[][][] mult(short[][][] A,
                               int B)

matrix multiplication by scalar

mult

public static short[][][][] mult(short[][][][] A,
                                 int B)

mult

public static float[] mult(float[] A,
                           int B)

mult

public static float[][] mult(float[][] A,
                             int B)

mult

public static float[][][] mult(float[][][] A,
                               int B)

mult

public static float[][][][] mult(float[][][][] A,
                                 int B)

mult

public static float[] mult(float[] A,
                           float B)

mult

public static float[][] mult(float[][] A,
                             float B)

mult

public static float[][][] mult(float[][][] A,
                               float B)

mult

public static float[][][][] mult(float[][][][] A,
                                 float B)

divide

public static short[][] divide(short[][] A,
                               int B)

matrix multiplication by 1/scalar

divide

public static short[][][] divide(short[][][] A,
                                 int B)

matrix multiplication by 1/scalar

divide

public static short[][][][] divide(short[][][][] A,
                                   int B)

divide

public static int[][] divide(int[][] A,
                             int B)

divide

public static int[][][] divide(int[][][] A,
                               int B)