public void LearnAlgorithm(List <byte[]> imageList)
{
byte[] array = new byte[imageList[1].Length];
byte[] avarageImage = new byte[imageList[1].Length];
//Calculate avarage face
for (int i = 0; i < imageList.Count(); i++)
{
array = imageList[i];
for (int j = 0; j < array.Length; j++)
{
avarageImage[j] = (byte)(avarageImage[j] + array[j]);
}
}
for (int j = 0; j < array.Length; j++)
{
avarageImage[j] = (byte)(avarageImage[j] / imageList.Count());
}
//Make matrix of images
Double[,] T = new Double[imageList.Count(), avarageImage.Length];
for (int i = 0; i < imageList.Count(); i++)
{
array = imageList[i];
for (int j = 0; j < avarageImage.Length; j++)
{
T[i, j] = array[j] - avarageImage[j];
}
}
//Making mathematical things
Double[,] TT = T.Transpose();
Double[,] C = Accord.Math.Matrix.Multiply(T, TT);
EigenvalueDecomposition dec2 = new Accord.Math.Decompositions.EigenvalueDecomposition(C);
Double[,] V = dec2.Eigenvectors;
Double[,] E = Accord.Math.Matrix.Multiply(TT, V);; //EE actually is eigenvectors matrix
E = E.Transpose();
pca = new PrincipalComponentAnalysis(E);
pca.Compute();
R = pca.Transform(T);
}
public void InverseTestNaN()
{
int n = 5;
var I = Matrix.Identity(n);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
double[,] value = Matrix.Magic(n);
value[i, j] = double.NaN;
var target = new EigenvalueDecomposition(value);
}
}
}
public void SetToRotations(RotationIndex[] rotationIndices)
{
if (rotationIndices.Length == 1)
{
SetToRotation(rotationIndices[0].index);
return;
}
var matrixM = Accord.Math.Matrix.Zeros(4, 4);
double weightSum = 0;
foreach (RotationIndex rotIdx in rotationIndices)
{
Quaternion currRot = GetRotation(rotIdx.index).normalized;
double[] q = { currRot.x, currRot.y, currRot.z, currRot.w };
if (currRot.x < 0)
{
q.Multiply(-1);
}
double currWeight = rotIdx.weight;
matrixM = (q.Outer(q)).Multiply(currWeight).Add(matrixM);
weightSum += currWeight;
}
matrixM.Divide(weightSum);
var eigDec = new Accord.Math.Decompositions.EigenvalueDecomposition(matrixM, false, true);
double[] outQuat = eigDec.Eigenvectors.GetColumn(0);
Quaternion newRot = new Quaternion((float)outQuat[0], (float)outQuat[1], (float)outQuat[2], (float)outQuat[3]);
this.transform.localRotation = newRot;
//this.transform.localRotation = GetRotation(index);
foreach (KNNBone child in this.children)
{
child.SetToRotations(rotationIndices);
}
}
public EllipsoidQuadraticForm(double A, double B, double C, double D, double E, double F, double G, double H, double I, double J)
{
var doubleUtils = new DoubleUtils(1e-12);
if (doubleUtils.Sign(A) < 0) {
A = -A;
B = -B;
C = -C;
D = -D;
E = -E;
F = -F;
G = -G;
H = -H;
I = -I;
J = -J;
}
Requires.Positive(doubleUtils.Sign(A), "A");
Requires.Positive(doubleUtils.Sign(B), "B");
Requires.Positive(doubleUtils.Sign(C), "C");
Requires.Positive(doubleUtils.Sign(A * B - D * D), "A * B - D * D");
Requires.Positive(doubleUtils.Sign(A * C - E * E), "A * C - E * E");
Requires.Positive(doubleUtils.Sign(B * C - F * F), "B * C - F * F");
_coefficients = new[] { A, B, C, D, E, F, G, H, I, J };
QuadraticFrom = new[,] {
{ A, D, E },
{ D, B, F },
{ E, F, C }
};
Offset = new[] { G, H, I, };
var b = QuadraticFrom.Inverse().Multiply(Offset.Multiply(-1));
var eigenDecomposition = new EigenvalueDecomposition(QuadraticFrom);
var axisNumerator = b.ElementwiseMultiply(QuadraticFrom.Multiply(b)).Sum() - J;
var xradius = System.Math.Sqrt(axisNumerator / eigenDecomposition.RealEigenvalues[0]);
var yradius = System.Math.Sqrt(axisNumerator / eigenDecomposition.RealEigenvalues[1]);
var zradius = System.Math.Sqrt(axisNumerator / eigenDecomposition.RealEigenvalues[2]);
var rotation = eigenDecomposition.Eigenvectors;
EllipsoidParametricForm = new EllipsoidParametricForm(xradius, yradius, zradius, new Point3D(b[0], b[1], b[2]), rotation);
var sqrt = rotation.Multiply(eigenDecomposition.DiagonalMatrix.Sqrt().Multiply(rotation.Inverse()));
AffineTransform = sqrt.Multiply(1.0 / System.Math.Sqrt(axisNumerator));
}
public void EigenvalueDecompositionConstructorTest()
{
// Symmetric test
double[,] A =
{
{ 4, 2 },
{ 2, 4 }
};
var target = new EigenvalueDecomposition(A);
var D = target.DiagonalMatrix;
var Q = target.Eigenvectors;
double[,] expectedD =
{
{ 2, 0 },
{ 0, 6 }
};
double[,] expectedQ =
{
{ 0.7071, 0.7071 },
{ -0.7071, 0.7071 }
};
Assert.IsTrue(Matrix.IsEqual(expectedD, D, 0.00001));
Assert.IsTrue(Matrix.IsEqual(expectedQ, Q, 0.0001));
// Decomposition identity
var actualA = Matrix.Multiply(Matrix.Multiply(Q, D), Q.Inverse());
Assert.IsTrue(Matrix.IsEqual(expectedD, D, 0.00001));
Assert.IsTrue(Matrix.IsEqual(A, actualA, 0.0001));
Assert.IsTrue(Matrix.IsEqual(A, target.Reverse(), 0.0001));
}
/// <summary>Eigenvalue decomposition.</summary>
protected static double[] eig(double[,] a, out double[,] V, out double[] im)
{
var eig = new EigenvalueDecomposition(a);
V = eig.Eigenvectors;
im = eig.ImaginaryEigenvalues;
return eig.RealEigenvalues;
}
public void EigenvalueDecompositionConstructorTest2()
{
// Asymmetric test
double[,] A =
{
{ 5, 2, 1 },
{ 1, 4, 1 },
{ -1, 2, 3 }
};
EigenvalueDecomposition target = new EigenvalueDecomposition(A);
var D = target.DiagonalMatrix;
var Q = target.Eigenvectors;
double[,] expectedD =
{
{ 6, 0, 0 },
{ 0, 4, 0 },
{ 0, 0, 2 }
};
// Decomposition identity
var actualA = Q.Multiply(D).Multiply(Q.Inverse());
Assert.IsTrue(Matrix.IsEqual(expectedD, D, 0.00001));
Assert.IsTrue(Matrix.IsEqual(A, actualA, 0.0001));
}
/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
/// <returns>
/// A new object that is a copy of this instance.
/// </returns>
public object Clone()
{
var clone = new EigenvalueDecomposition();
clone.d = (Double[])d.Clone();
clone.e = (Double[])e.Clone();
clone.H = (Double[,])H.Clone();
clone.n = n;
clone.ort = (Double[])ort;
clone.symmetric = symmetric;
clone.V = (Double[,])V.Clone();
return clone;
}
static void Main(string[] args)
{
Console.WriteLine("Please take a look at the source for examples!");
Console.ReadKey();
#region 1. Declaring matrices
// 1.1 Using standard .NET declaration
double[,] A =
{
{1, 2, 3},
{6, 2, 0},
{0, 0, 1}
};
double[,] B =
{
{2, 0, 0},
{0, 2, 0},
{0, 0, 2}
};
{
// 1.2 Using Accord extension methods
double[,] Bi = Matrix.Identity(3).Multiply(2);
double[,] Bj = Matrix.Diagonal(3, 2.0); // both are equal to B
// 1.2 Using Accord extension methods with implicit typing
var I = Matrix.Identity(3);
}
#endregion
#region 2. Matrix Operations
{
// 2.1 Addition
var C = A.Add(B);
// 2.2 Subtraction
var D = A.Subtract(B);
// 2.3 Multiplication
{
// 2.3.1 By a scalar
var halfM = A.Multiply(0.5);
// 2.3.2 By a vector
double[] m = A.Multiply(new double[] { 1, 2, 3 });
// 2.3.3 By a matrix
var M = A.Multiply(B);
// 2.4 Transposing
var At = A.Transpose();
}
}
// 2.5 Elementwise operations
// 2.5.1 Elementwise multiplication
A.ElementwiseMultiply(B); // A.*B
// 2.5.1 Elementwise division
A.ElementwiseDivide(B); // A./B
#endregion
#region 3. Matrix characteristics
{
// 3.1 Calculating the determinant
double det = A.Determinant();
// 3.2 Calculating the trace
double tr = A.Trace();
// 3.3 Computing the sum vector
{
double[] sumVector = A.Sum();
// 3.3.1 Computing the total sum of elements
double sum = sumVector.Sum();
// 3.3.2 Computing the sum along the rows
sumVector = A.Sum(0); // Equivalent to Octave's sum(A, 1)
// 3.3.2 Computing the sum along the columns
sumVector = A.Sum(1); // Equivalent to Octave's sum(A, 2)
}
}
#endregion
#region 4. Linear Algebra
{
// 4.1 Computing the inverse
var invA = A.Inverse();
// 4.2 Computing the pseudo-inverse
var pinvA = A.PseudoInverse();
// 4.3 Solving a linear system (Ax = B)
var x = A.Solve(B);
}
#endregion
#region 5. Special operators
{
// 5.1 Finding the indices of elements
double[] v = { 5, 2, 2, 7, 1, 0 };
int[] idx = v.Find(e => e > 2); // finding the index of every element in v higher than 2.
// 5.2 Selecting elements by index
double[] u = v.Submatrix(idx); // u is { 5, 7 }
// 5.3 Converting between different matrix representations
double[][] jaggedA = A.ToArray(); // from multidimensional to jagged array
// 5.4 Extracting a column or row from the matrix
double[] a = A.GetColumn(0); // retrieves the first column
double[] b = B.GetRow(1); // retrieves the second row
// 5.5 Taking the absolute of a matrix
var absA = A.Abs();
// 5.6 Applying some function to every element
var newv = v.Apply(e => e + 1);
}
#endregion
#region 7. Vector operations
{
double[] u = { 1, 2, 3 };
double[] v = { 4, 5, 6 };
var w1 = u.InnerProduct(v);
var w2 = u.OuterProduct(v);
var w3 = u.CartesianProduct(v);
double[] m = { 1, 2, 3, 4 };
double[,] M = Matrix.Reshape(m, 2, 2);
}
#endregion
#region Decompositions
{
// Singular value decomposition
{
SingularValueDecomposition svd = new SingularValueDecomposition(A);
var U = svd.LeftSingularVectors;
var S = svd.Diagonal;
var V = svd.RightSingularVectors;
}
// or (please see documentation for details)
{
SingularValueDecomposition svd = new SingularValueDecomposition(A.Transpose());
var U = svd.RightSingularVectors;
var S = svd.Diagonal;
var V = svd.LeftSingularVectors;
}
// Eigenvalue decomposition
{
EigenvalueDecomposition eig = new EigenvalueDecomposition(A);
var V = eig.Eigenvectors;
var D = eig.DiagonalMatrix;
}
// QR decomposition
{
QrDecomposition qr = new QrDecomposition(A);
var Q = qr.OrthogonalFactor;
var R = qr.UpperTriangularFactor;
}
// Cholesky decomposition
{
CholeskyDecomposition chol = new CholeskyDecomposition(A);
var R = chol.LeftTriangularFactor;
}
// LU decomposition
{
LuDecomposition lu = new LuDecomposition(A);
var L = lu.LowerTriangularFactor;
var U = lu.UpperTriangularFactor;
}
}
#endregion
}
/// <summary>
/// Computes the Kernel Principal Component Analysis algorithm.
/// </summary>
///
public void Compute(int components)
{
if (components < 0 || components > Source.GetLength(0))
{
throw new ArgumentException(
"The number of components must be between 0 and " +
"the number of rows in your source data matrix.");
}
int dimension = Source.GetLength(0);
// If needed, center the source matrix
sourceCentered = Adjust(Source, Overwrite);
// Create the Gram (Kernel) Matrix
this.kernelMatrix = new double[dimension, dimension];
for (int i = 0; i < dimension; i++)
{
double[] row = sourceCentered.GetRow(i);
for (int j = i; j < dimension; j++)
{
double k = kernel.Function(row, sourceCentered.GetRow(j));
kernelMatrix[i, j] = k; // Kernel matrix is symmetric
kernelMatrix[j, i] = k;
}
}
// Center the Gram (Kernel) Matrix if requested
double[,] Kc = centerFeatureSpace ? centerKernel(kernelMatrix) : kernelMatrix;
// Perform the Eigenvalue Decomposition (EVD) of the Kernel matrix
EigenvalueDecomposition evd = new EigenvalueDecomposition(Kc, assumeSymmetric: true);
// Gets the Eigenvalues and corresponding Eigenvectors
double[] evals = evd.RealEigenvalues;
double[,] eigs = evd.Eigenvectors;
// Sort eigenvalues and vectors in descending order
eigs = Matrix.Sort(evals, eigs, new GeneralComparer(ComparerDirection.Descending, true));
// Eliminate unwanted components
if (components != Source.GetLength(0))
{
eigs = eigs.Submatrix(null, 0, components - 1);
evals = evals.Submatrix(0, components - 1);
}
if (threshold > 0)
{
// We will be discarding less important
// eigenvectors to conserve memory.
// Calculate component proportions
double sum = 0.0; // total variance
for (int i = 0; i < evals.Length; i++)
sum += Math.Abs(evals[i]);
if (sum > 0)
{
int keep = 0;
// Now we will detect how many components we have
// have to keep in order to achieve the level of
// explained variance specified by the threshold.
while (keep < components)
{
// Get the variance explained by the component
double explainedVariance = Math.Abs(evals[keep]);
// Check its proportion
double proportion = explainedVariance / sum;
// Now, if the component explains an
// enough proportion of the variance,
if (proportion > threshold)
keep++; // We can keep it.
else
break; // Otherwise we can stop, since the
// components are ordered by variance.
}
if (keep != components)
{
if (keep > 0)
{
// Resize the vectors keeping only needed components
eigs = eigs.Submatrix(0, components - 1, 0, keep - 1);
evals = evals.Submatrix(0, keep - 1);
}
else
{
// No component will be kept.
eigs = new double[dimension, 0];
evals = new double[0];
}
}
}
}
// Normalize eigenvectors
if (centerFeatureSpace)
{
for (int j = 0; j < evals.Length; j++)
{
double val = Math.Sqrt(Math.Abs(evals[j]));
for (int i = 0; i < eigs.GetLength(0); i++)
eigs[i, j] = eigs[i, j] / val;
}
}
// Set analysis properties
this.SingularValues = new double[evals.Length];
this.Eigenvalues = evals;
this.ComponentMatrix = eigs;
// Project the original data into principal component space
this.Result = Kc.Multiply(eigs);
// Computes additional information about the analysis and creates the
// object-oriented structure to hold the principal components found.
CreateComponents();
}
private double[][] getFeature(double[][] input, int K)
{
//var activationContext = Type.GetTypeFromProgID("matlab.application.single");
//var matlab = (MLApp.MLApp)Activator.CreateInstance(activationContext);
//matlab.Visible = 0;
int i, j;
int row = input[0].Length;
int column = input.Length;
double[][] X = new double[column][];
for (i = 0; i < column; i++) {
X[i] = input[i].Subtract(this.meanMatrix);
}
// matlab.PutWorkspaceData("X", "base", X.ToMatrix());
// MessageBox.Show(matlab.Execute("XTX=X'*X;"));
// MessageBox.Show(matlab.Execute("size(XTX)"));
// var t = matlab.GetVariable("XTX", "base");
// matlab.Quit();
double[][] XT = X.Transpose();
double[,] XTX = X.Multiply(XT).ToMatrix();
var feature = new EigenvalueDecomposition(XTX);
//EigenvalueDecomposition feature = XTX.eig();
double[] d = feature.RealEigenvalues;
// assert d.length >= K : "number of eigenvalues is less than K";
int[] indexes;
d.StableSort(out indexes);
indexes= indexes.Reverse().ToArray();
indexes = indexes.Submatrix(0, K-1);
double[][] eigenVectors = XT.Multiply(feature.Eigenvectors.ToArray());
double[][] selectedEigenVectors = eigenVectors.Submatrix(0,
eigenVectors.Length - 1, indexes);
// normalize the eigenvectors
row = selectedEigenVectors.Length;
column = selectedEigenVectors[0].Length;
for (i = 0; i < column; i++) {
double temp = 0;
for (j = 0; j < row; j++)
temp += Math.Pow(selectedEigenVectors[j][ i], 2);
temp = Math.Sqrt(temp);
for (j = 0; j < row; j++) {
selectedEigenVectors[j][ i]= selectedEigenVectors[j][ i] / temp;
}
}
return selectedEigenVectors;
}
public Matrix KLTransform(Matrix matrix)
{
matrix = (Matrix)matrix.Transpose();
int columnNumber = matrix.ColumnCount;
Matrix mean = GetMean(matrix);
//Don't print it becouse is a lot of values
// PrintMatrix(mean, null, " mean matrix"); -
float[,] oneD = new float[1, columnNumber];
for (int i = 0; i < columnNumber; i++)
{
oneD[0, i] = 1;
}
//so called edinichna matrica
Matrix onesMatrix = DenseMatrix.OfArray(oneD);
// center the data
Matrix xm = (DenseMatrix)matrix.Subtract(mean.Multiply(onesMatrix));
// PrintMatrix(null, xm.ToArray(), "center the data");
// Calculate covariance matrix
DenseMatrix cov = (DenseMatrix)(xm.Multiply(xm.Transpose())).Multiply(1.0f / columnNumber);
// PrintMatrix(cov, null, "Calculate covariance matrix");
PrintText(cov.ColumnCount.ToString() + " Calculate covariance ColumnCount");
PrintText(cov.RowCount.ToString() + " Calculate covariance RowCount");
//this is from another libraly accord .net
EigenvalueDecomposition v = new EigenvalueDecomposition(FromFloatMatrixToDouble(cov.ToArray()));
double[,] eigVectors = v.Eigenvectors;
double[,] eidDiagonal = v.DiagonalMatrix;
Matrix eigVectorsTransposedMatrix = (DenseMatrix)DenseMatrix.OfArray(FromDoubleMatrixToFlaot(eigVectors)).Transpose();
Matrix eidDiagonalMatrix = DenseMatrix.OfArray(FromDoubleMatrixToFlaot(eidDiagonal));
int rowsCountDiagonals = eidDiagonal.GetLength(0);
int maxLambdaIndex = 0;
for (int i = 0; i < rowsCountDiagonals - 1; i++)
{
if (eidDiagonal[i, i] <= eidDiagonal[i + 1, i + 1])
{
maxLambdaIndex = i + 1;
}
}
double maxAlpha = eidDiagonal[maxLambdaIndex, maxLambdaIndex];
double sumAlpha = 0;
for (int i = 0; i < rowsCountDiagonals; i++)
{
sumAlpha += eidDiagonal[i, i];
}
CalculateAndPrintError(maxAlpha, sumAlpha);
PrintText("Max lambda index " + maxLambdaIndex);
// PrintMatrix(eidDiagonalMatrix, null, "Eign vals");
// //PCA
float[,] arr = new float[1, eigVectorsTransposedMatrix.ColumnCount];
for (int i = 0; i < eigVectorsTransposedMatrix.ColumnCount; i++)
{
arr[0, i] = eigVectorsTransposedMatrix[maxLambdaIndex, i];
}
Matrix mainComponentMatrix = DenseMatrix.OfArray(arr);
// PrintMatrix(mainComponentMatrix, null, "Main Component");
Matrix pca = (DenseMatrix)mainComponentMatrix.Multiply(xm);
// PrintMatrix(pca, null, "PCA");
return pca;
}
public LDA(double[][] trainingSet, List<string> labels,int numOfComponents)
{
int n = trainingSet.Length; // sample size
HashSet<String> tempSet = new HashSet<String>(labels);
int c = tempSet.Count; // class size
// process in PCA
PCA pca = new PCA(trainingSet, labels, n - c);
// classify
double[][] meanTotal = new double[n - c][];
for (int i = 0; i < n - c; i++)
{
meanTotal[i] = new double[1];
}
Dictionary<String, List<double[]>> dict = new Dictionary<String, List<double[]>>();
List<projectedTrainingMatrix> pcaTrain = pca.getProjectedTrainingSet();
for (int i = 0; i < pcaTrain.Count; i++) {
String key = pcaTrain[i].label;
meanTotal= meanTotal.Add(pcaTrain[i].matrix);
if (!dict.ContainsKey(key)) {
List<double[]> temp = new List<double[]>();
temp.Add(pcaTrain[i].matrix.Transpose()[0]);
dict.Add(key, temp);
} else {
List<double[]> temp = dict[key];
temp.Add(pcaTrain[i].matrix.Transpose()[0]);
dict[key]= temp;
}
}
meanTotal.ToMatrix().Multiply((double) 1 / n);
// calculate Sw, Sb
double[][] Sw = new double[n - c][];
double[][] Sb = new double[n - c][];
for (int i = 0; i < n - c; i++)
{
Sw[i] = new double[n-c];
Sb[i] = new double[n-c];
}
List<String> labelSet = dict.Keys.ToList();
foreach(string label in labelSet)
{
List<double[]> tempMatrix = dict[label];
double[][] matrixWithinThatClass = tempMatrix.ToArray();
double[] meanOfCurrentClass = Accord.Statistics.Tools.Mean(matrixWithinThatClass);
for (int i = 0; i < matrixWithinThatClass.Length; i++) {
double[][] temp1 = matrixWithinThatClass[i].ToArray().Subtract(meanOfCurrentClass.ToArray());
temp1 = temp1.Multiply(temp1.Transpose());
Sw =Sw.Add(temp1);
}
double[][] temp = meanOfCurrentClass.ToArray().Subtract(meanTotal);
temp = temp.Multiply(temp.Transpose()).ToMatrix().Multiply((double)matrixWithinThatClass.Length).ToArray();
Sb=Sb.Add(temp);
}
// calculate the eigenvalues and vectors of Sw^-1 * Sb
double [][] targetForEigen = Sw.Inverse().Multiply(Sb);
var feature = new EigenvalueDecomposition(targetForEigen.ToMatrix());
double[] d = feature.RealEigenvalues;
int[] indexes;
d.StableSort(out indexes);
indexes = indexes.Reverse().ToArray();
indexes = indexes.Submatrix(0, c - 1);
//int[] indexes = getIndexesOfKEigenvalues(d, c - 1);
double[][] eigenVectors = feature.Eigenvectors.ToArray();
double[][] selectedEigenVectors = eigenVectors.Submatrix(0, eigenVectors.Length - 1, indexes);
this.W = pca.getW().Multiply(selectedEigenVectors);
// Construct projectedTrainingMatrix
this.projectedTrainingSet = new List<projectedTrainingMatrix>();
for (int i = 0; i < trainingSet.Length; i++) {
projectedTrainingMatrix ptm = new projectedTrainingMatrix(this.W.Transpose().Multiply(trainingSet[i].Subtract(pca.meanMatrix).ToArray()), labels[i]);
this.projectedTrainingSet.Add(ptm);
}
this.meanMatrix= pca.meanMatrix;
GC.Collect();
}
public void CalculateLambda2CriterionIrregularGrids(List <Vector3d> pointsToRegistrate, Dictionary <string, List <float> > scalarValues, List <string> scalarNames, List <Vector4> tetraPoints)
{
List <float> scalarValuesX = new List <float>();
List <float> scalarValuesY = new List <float>();
List <float> scalarValuesZ = new List <float>();
//if (scalarNames.Count() <= 4)
//{
scalarValues.TryGetValue(scalarNames[0], out scalarValuesX);
scalarValues.TryGetValue(scalarNames[1], out scalarValuesY);
scalarValues.TryGetValue(scalarNames[2], out scalarValuesZ);
//}
//else
//{
// scalarValues.TryGetValue(scalarNames[1], out scalarValuesX);
// scalarValues.TryGetValue(scalarNames[2], out scalarValuesY);
// scalarValues.TryGetValue(scalarNames[3], out scalarValuesZ);
//}
vtkDoubleArray lambda2Values = new vtkDoubleArray();
List <double> lambda2ValuesList = new List <double>();
// create vectorfield
List <Vector3d> vectorField = new List <Vector3d>();
for (int i = 0; i < scalarValuesX.Count(); i++)
{
Vector3d vec = new Vector3d(scalarValuesX[i], scalarValuesY[i], scalarValuesZ[i]);
vectorField.Add(vec);
}
int count = 0;
double[,] lambda2ValuesArray = new double[pointsToRegistrate.Count(), 2];
for (int k = 0; k < tetraPoints.Count(); k++)
{
// first rows and than columns
double[,] A = new double[12, 12];
double[,] rightSide = new double[12, 1];
int i = 0, j = 0;
int s = 0;
if (k == 779834)
{
Console.WriteLine("Test");
}
for (int g = 0; g < 12; g += 3, i++, s++)
{
//1-3 columns of 4x3 Matrix
for (int l = 0; l < 3; l++)
{
for (int m = 0; m < 3; m++)
{
if (l == m)
{
// Warum tetraPoints[k]
A[g + l, m] = pointsToRegistrate[(int)tetraPoints[k][i]].X;
}
else
{
A[g + l, m] = 0;
}
}
}
for (int l = 0; l < 3; l++)
{
for (int m = 3; m < 6; m++)
{
if (l == (m - 3))
{
A[g + l, m] = pointsToRegistrate[(int)tetraPoints[k][i]].Y;
}
else
{
A[g + l, m] = 0;
}
}
}
for (int l = 0; l < 3; l++)
{
for (int m = 6; m < 9; m++)
{
if (l == (m - 6))
{
A[g + l, m] = pointsToRegistrate[(int)tetraPoints[k][i]].Z;
}
else
{
A[g + l, m] = 0;
}
}
}
for (int l = 0; l < 3; l++)
{
for (int m = 9; m < 12; m++)
{
if (l == (m - 9))
{
A[g + l, m] = 1;
}
else
{
A[g + l, m] = 0;
}
}
}
rightSide[g, 0] = vectorField[(int)tetraPoints[k][s]].X;
rightSide[g + 1, 0] = vectorField[(int)tetraPoints[k][s]].Y;
rightSide[g + 2, 0] = vectorField[(int)tetraPoints[k][s]].Z;
}
//for (int l = 0; l < 12; l++)
//{
// for (int m = 0; m < 12; m++)
// {
// Console.Write(A[l, m] + " ");
// }
// Console.WriteLine("");
//}
double[,] Vold = Accord.Math.Matrix.Solve(A, rightSide, leastSquares: true);
// Solve matrix with matlab
//LGS lgsObj = new LGS();
//MWNumericArray mwV = (MWNumericArray)lgsObj.solveLGS((MWNumericArray)A, (MWNumericArray)rightSide);
//double[,] V = new double[mwV.Dimensions[0], 1];
//for (i = 1; i <= mwV.Dimensions[1]; i++)
//{
// V[i, 0] = (double)mwV[1, i];
//}
double[,] jacobiMat = new double[3, 3];
int n = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
// first increas rows and than columns
jacobiMat[j, i] = Vold[n, 0];
//jacobiMat[i, j] = Vold[n, 0];
n++;
}
}
if (jacobiMat[1, 1] == 0 && jacobiMat[0, 0] == 0 && jacobiMat[2, 2] == 0)
{
//lambda2Values.InsertNextValue(0);
//lambda2ValuesList.Add(0);
count++;
}
//only if diagonal elements are not equal zero
else
{
MatrixOperations classObj = new MatrixOperations();
double[,] transposedJacobiMat = classObj.TransposeRowsAndColumns(jacobiMat);
// calculation of S und Omega
double[,] S = classObj.DivideArrayByValue(classObj.AddArrays(jacobiMat, transposedJacobiMat), 2);
double[,] squaredS = classObj.MultiplyArrays(S, S);
double[,] Omega = classObj.DivideArrayByValue(classObj.SubtractArrays(jacobiMat, transposedJacobiMat), 2);
double[,] squaredOmega = classObj.MultiplyArrays(Omega, Omega);
double[,] summation = classObj.AddArrays(squaredS, squaredOmega);
var eigenvalueDecomposition = new Accord.Math.Decompositions.EigenvalueDecomposition(summation, false, true, true);
var eigenVec = eigenvalueDecomposition.Eigenvectors;
var eigenValue = eigenvalueDecomposition.RealEigenvalues;
double lambda2 = eigenValue[1];
//int t = (int)lambda2Values.InsertNextValue(lambda2);
//lambda2ValuesList.Add(lambda2);
lambda2ValuesArray[(int)tetraPoints[k][0], 0] += lambda2;
lambda2ValuesArray[(int)tetraPoints[k][0], 1] += 1;
lambda2ValuesArray[(int)tetraPoints[k][1], 0] += lambda2;
lambda2ValuesArray[(int)tetraPoints[k][1], 1] += 1;
lambda2ValuesArray[(int)tetraPoints[k][2], 0] += lambda2;
lambda2ValuesArray[(int)tetraPoints[k][2], 1] += 1;
lambda2ValuesArray[(int)tetraPoints[k][3], 0] += lambda2;
lambda2ValuesArray[(int)tetraPoints[k][3], 1] += 1;
//if (k == 779834)
// Console.WriteLine("Test");
//if (lambda2 < 0)
//{
// lambda2ValuesArray[(int)tetraPoints[k][0], 0] = lambda2;
// lambda2ValuesArray[(int)tetraPoints[k][0], 1] += 1;
//}
////else
////{
//// lambda2ValuesArray[(int)tetraPoints[k][0], 0] += lambda2;
//// lambda2ValuesArray[(int)tetraPoints[k][0], 1] += 1;
////}
//if (lambda2 < 0)
//{
// lambda2ValuesArray[(int)tetraPoints[k][1], 0] = lambda2;
// lambda2ValuesArray[(int)tetraPoints[k][1], 1] += 1;
//}
////else
////{
//// lambda2ValuesArray[(int)tetraPoints[k][1], 0] += lambda2;
//// lambda2ValuesArray[(int)tetraPoints[k][1], 1] += 1;
////}
//if (lambda2 < 0)
//{
// lambda2ValuesArray[(int)tetraPoints[k][2], 0] = lambda2;
// lambda2ValuesArray[(int)tetraPoints[k][2], 1] += 1;
//}
////else
////{
//// lambda2ValuesArray[(int)tetraPoints[k][2], 0] += lambda2;
//// lambda2ValuesArray[(int)tetraPoints[k][2], 1] += 1;
////}
//if (lambda2 < 0)
//{
// lambda2ValuesArray[(int)tetraPoints[k][3], 0] = lambda2;
// lambda2ValuesArray[(int)tetraPoints[k][3], 1] += 1;
//}
// if (lambda2ValuesArray[(int)tetraPoints[k][0], 1] == 0)
//{
// lambda2ValuesArray[(int)tetraPoints[k][0], 0] = lambda2;
//}
// if (lambda2ValuesArray[(int)tetraPoints[k][1], 1] == 0)
//{
// lambda2ValuesArray[(int)tetraPoints[k][1], 0] = lambda2;
//}
// if (lambda2ValuesArray[(int)tetraPoints[k][2], 1] == 0)
//{
// lambda2ValuesArray[(int)tetraPoints[k][2], 0] = lambda2;
//}
// if (lambda2ValuesArray[(int)tetraPoints[k][3], 1] == 0)
//{
// lambda2ValuesArray[(int)tetraPoints[k][3], 0] = lambda2;
//}
}
}
for (int i = 0; i < pointsToRegistrate.Count(); i++)
{
if (lambda2ValuesArray[i, 1] > 1)
{
double lambda2 = lambda2ValuesArray[i, 0] / lambda2ValuesArray[i, 1];
//if (lambda2 < 0)
// Console.WriteLine("lambda2 ist " + lambda2);
lambda2ValuesList.Add(lambda2);
lambda2Values.InsertNextValue(lambda2);
count++;
}
else
{
count++;
lambda2Values.InsertNextValue(lambda2ValuesArray[i, 0]);
}
}
//WriteScalarDifferences(lambda2ValuesList, "..\\..\\..\\..\\..\\03Daten\\lambda2\\Tomo_lambda2regularGridsOwnEigen.txt");
vtkDataArray dataArray;
dataArray = lambda2Values;
dataArray.SetName("lambda2");
if (this.scalar_dataArray.ContainsKey("lambda2"))
{
this.scalar_dataArray["lambda2"] = lambda2Values;
}
else
{
this.scalar_dataArray.Add("lambda2", dataArray);
this.arrayNames.Add("lambda2");
}
}
public void CalculateLambdaCriterionRegularGrids(List <Vector3d> pointsToRegistrate, Dictionary <string, List <float> > scalarValues, List <string> scalarNames, int[] dimensions)
{
List <float> scalarValuesX = new List <float>();
scalarValues.TryGetValue(scalarNames[0], out scalarValuesX);
List <float> scalarValuesY = new List <float>();
scalarValues.TryGetValue(scalarNames[1], out scalarValuesY);
List <float> scalarValuesZ = new List <float>();
scalarValues.TryGetValue(scalarNames[2], out scalarValuesZ);
// create vectorfield
List <Vector3d> vectorField = new List <Vector3d>();
for (int i = 0; i < scalarValuesX.Count(); i++)
{
Vector3d vec = new Vector3d(scalarValuesX[i], scalarValuesY[i], scalarValuesZ[i]);
vectorField.Add(vec);
}
vtkDoubleArray lambda2Values = new vtkDoubleArray();
// lambda2Values.SetNumberOfValues(vectorField.Count());
int sizeJacobimat = 3;
// iterating over all points
for (int k = 0; k < vectorField.Count(); k++)
{
if (k == 356003)
{
Console.WriteLine("ID");
}
double[,] jacobiMat = new double[sizeJacobimat, sizeJacobimat];
for (int j = 0, i = 0; j < sizeJacobimat; j++, i++)
{
Vector3d vec = vectorField[k];
Vector3d gradVec = new Vector3d();
// first column of jacobi matrix
if (i == 0)
{
// forward difference
if (k == 0)
{
double hx = Math.Abs(pointsToRegistrate[k + 1].X - pointsToRegistrate[k].X);
gradVec = (vectorField[k + 1] - vec) / hx;
}
// backward difference
else if (k == vectorField.Count() - 1)
{
double hx = Math.Abs(pointsToRegistrate[k - 1].X - pointsToRegistrate[k].X);
gradVec = (vec - vectorField[k - 1]) / hx;
}
// central difference
else
{
double hx = Math.Abs(pointsToRegistrate[k + 1].X - pointsToRegistrate[k].X);
Vector3d f = vectorField[k + 1];
Vector3d b = vectorField[k - 1];
gradVec = (f - b) / (2 * hx);
}
}
// second column of jacobi matrix
else if (i == 1)
{
// forward difference
if (k - dimensions[0] < 0)
{
double hy = Math.Abs(pointsToRegistrate[k + dimensions[0]].Y - pointsToRegistrate[k].Y);
gradVec = (vectorField[k + dimensions[0]] - vec) / hy;
}
// backward difference
else if (k + dimensions[0] > vectorField.Count() - 1)
{
double hy = Math.Abs(pointsToRegistrate[k - dimensions[0]].Y - pointsToRegistrate[k].Y);
gradVec = (vec - vectorField[k - dimensions[0]]) / hy;
}
// central difference
else
{
double hy = Math.Abs(pointsToRegistrate[k + dimensions[0]].Y - pointsToRegistrate[k].Y);
Vector3d f = vectorField[k + dimensions[0]];
Vector3d b = vectorField[k - dimensions[0]];
gradVec = (f - b) / (2 * hy);
}
}
// third column of jacobi matrix
else if (i == 2)
{
// forward difference
if (k - (dimensions[0] * dimensions[1]) < 0)
{
double hz = Math.Abs(pointsToRegistrate[k + (dimensions[0] * dimensions[1])].Z - pointsToRegistrate[k].Z);
gradVec = (vectorField[k + (dimensions[0] * dimensions[1])] - vec) / hz;
}
// backward difference
else if (k + (dimensions[0] * dimensions[1]) > vectorField.Count() - 1)
{
double hz = Math.Abs(pointsToRegistrate[k - (dimensions[0] * dimensions[1])].Z - pointsToRegistrate[k].Z);
gradVec = (vec - vectorField[k - (dimensions[0] * dimensions[1])]) / hz;
}
// central difference
else
{
double hz = Math.Abs(pointsToRegistrate[k + (dimensions[0] * dimensions[1])].Z - pointsToRegistrate[k].Z);
Vector3d f = vectorField[k + (dimensions[0] * dimensions[1])];
Vector3d b = vectorField[k - (dimensions[0] * dimensions[1])];
gradVec = (f - b) / (2 * hz);
}
}
// fill jacobi matrix
jacobiMat[0, j] = gradVec[0];
jacobiMat[1, j] = gradVec[1];
if (sizeJacobimat == 3)
{
jacobiMat[2, j] = gradVec[2];
}
}
// only if diagonal elements are not equal zero
if (jacobiMat[1, 1] == 0 && jacobiMat[0, 0] == 0 && jacobiMat[2, 2] == 0)
{
lambda2Values.InsertNextValue(0);
}
else
{
MatrixOperations classObj = new MatrixOperations();
double[,] transposedJacobiMat = classObj.TransposeRowsAndColumns(jacobiMat);
// calculation of S und Omega
double[,] S = classObj.DivideArrayByValue(classObj.AddArrays(jacobiMat, transposedJacobiMat), 2);
double[,] squaredS = classObj.MultiplyArrays(S, S);
double[,] Omega = classObj.DivideArrayByValue(classObj.SubtractArrays(jacobiMat, transposedJacobiMat), 2);
double[,] squaredOmega = classObj.MultiplyArrays(Omega, Omega);
double[,] summation = classObj.AddArrays(squaredS, squaredOmega);
var eigenvalueDecomposition = new Accord.Math.Decompositions.EigenvalueDecomposition(summation, false, false, true);
var eigenVec = eigenvalueDecomposition.Eigenvectors;
var eigenValue = eigenvalueDecomposition.RealEigenvalues;
double lambda2 = eigenValue[1];
lambda2Values.InsertNextValue(lambda2);
}
}
vtkDataArray dataArray;
dataArray = lambda2Values;
dataArray.SetName("lambda2");
Console.WriteLine("All lambda2 were calculated!");
if (this.scalar_dataArray.ContainsKey("lambda2"))
{
this.scalar_dataArray["lambda2"] = lambda2Values;
}
else
{
this.scalar_dataArray.Add("lambda2", dataArray);
this.arrayNames.Add("lambda2");
}
}