public void IsIndentityTest_shouldReturnTrue()
{
var identityMatrix =
DenseMatrix.CreateIdentity(10);
Assert.IsTrue(MatrixFunctions.isIndentity(identityMatrix));
}
public ShapeMatching(GameObject points)
{
//Instantiation method for shapematching object
//Stores duplicates of points passed in to object as an array of original positions to be used in calculation
particles = points;
Transform [] original_transforms = particles.GetComponentsInChildren <Transform>();
original_positions = new Vector3[original_transforms.Length - 1];
for (int i = 1; i < original_transforms.Length; i++) //i starts at one in order to avoid origin being added to positions
{
original_positions[i - 1] = particles.transform.InverseTransformPoint(original_transforms[i].position);
cm0 += original_positions[i - 1];
}
cm0 /= original_positions.Length;
//Precalculates Aqq from original positions
aqq = new double [, ] {
{ 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }
};
for (int i = 0; i < original_positions.Length; i++)
{
original_positions[i] -= cm0;
MatrixFunctions.matrix_add_3x3(ref aqq, MatrixFunctions.vector3_covariance(original_positions[i], original_positions[i]));
}
//performs inverse operation on Aqq matrix as stated in Muller paper
MatrixFunctions.matrixInverse3x3(ref aqq);
}
// Update is called once per frame
void FixedUpdate()
{
if (deformation_frames > 0)
{
for (int i = 0; i < particles.Length; i++)
{
particles[i].displace(displacements[i]);
displacements[i] /= 4;
}
cluster.recalculate();
for (int i = 0; i < particles.Length; i++)
{
particles[i].movePoints(cluster.origin_cm);
}
for (int i = 0; i < vertices.Length; i++)
{
Vector3 x = particle_container.transform.TransformPoint(original_vertices[i] - cluster.origin_cm);
vertices[i] = MatrixFunctions.matrix_multiply_1x3_by_3x3(x, cluster.getTransformation());
}
gameObject.transform.position = cluster.cm;
rigidbody.centerOfMass = cluster.cm;
mesh.vertices = vertices;
deformation_frames--;
}
prev_velocity = rigidbody.velocity;
}
public override Matrix GetHandleMatrix(SETItem item)
{
Matrix matrix = Matrix.Identity;
MatrixFunctions.Translate(ref matrix, item.Position);
return(matrix);
}
public void IsIndentityTest_shouldReturnFalse()
{
var notIdentityMatrix =
DenseMatrix.OfArray(new[, ] {
{ 1.1, 2, 3 }, { 1, 2, 3 }
});
Assert.IsFalse(MatrixFunctions.isIndentity(notIdentityMatrix));
}
public override Matrix GetHandleMatrix(SETItem item)
{
Matrix matrix = Matrix.Identity;
MatrixFunctions.Translate(ref matrix, item.Position.X, item.Position.Y + 0.5f, item.Position.Z);
MatrixFunctions.RotateY(ref matrix, item.Rotation.Y);
return(matrix);
}
public override Matrix GetHandleMatrix(SETItem item)
{
Matrix matrix = Matrix.Identity;
MatrixFunctions.Translate(ref matrix, item.Position);
MatrixFunctions.RotateObject(ref matrix, item.Rotation.X & 0xC000, item.Rotation.Y, 0);
return(matrix);
}
public void updatePositions()
{
double [,] t = cluster.getTransformation();
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = MatrixFunctions.matrix_multiply_1x3_by_3x3(vertices[i], t);
}
mesh.vertices = vertices;
}
public override Matrix GetHandleMatrix(SETItem item)
{
Matrix matrix = Matrix.Identity;
float Scale = item.Scale.X + 1.0f;
MatrixFunctions.Translate(ref matrix, item.Position);
MatrixFunctions.RotateY(ref matrix, item.Rotation.Y);
MatrixFunctions.Scale(ref matrix, Scale, Scale, Scale);
return(matrix);
}
public override Matrix GetHandleMatrix(SETItem item)
{
Matrix matrix = Matrix.Identity;
MatrixFunctions.Translate(ref matrix, item.Position);
MatrixFunctions.RotateY(ref matrix, (ushort)(item.Rotation.Y + 0x8000));
MatrixFunctions.RotateZ(ref matrix, item.Rotation.Z);
MatrixFunctions.RotateX(ref matrix, item.Rotation.X);
return(matrix);
}
public override Matrix GetHandleMatrix(SETItem item)
{
Matrix matrix = Matrix.Identity;
MatrixFunctions.Translate(ref matrix, item.Position);
MatrixFunctions.RotateObject(ref matrix, item.Rotation);
float size = item.Scale.X + 1.0f;
MatrixFunctions.Scale(ref matrix, size, size, size);
return(matrix);
}
void run_test()
{
//randomize rotation of control spheres
Quaternion rot = Random.rotation;
print(rot.eulerAngles);
duplicate.transform.rotation = rot;
//Stores positions of particles post rotation
Vector3 [] new_positions;
Transform [] temp = duplicate.GetComponentsInChildren <Transform>(); //Get components in children creates unwanted first element in array, needs compensation
new_positions = new Vector3[temp.Length - 1];
//Instantiates spheres at particle locations
destroy_markers();
markers = new GameObject[temp.Length - 1];
for (int i = 1; i < temp.Length; i++) //i starts at one to compensate for problem descibed earlier
{
new_positions[i - 1] = duplicate.transform.TransformPoint(temp[i].position) + new Vector3(Random.Range(-randomness, randomness), Random.Range(-randomness, randomness), Random.Range(-randomness, randomness));;
GameObject t = Instantiate(marker, new_positions[i - 1], Quaternion.identity);
t.transform.parent = duplicate.transform; //Parents new objects under Duplicate_Points
}
//ENTERY INTO SHAPE MATCH
double [,] rotation_matrix;
if (linear)
{
rotation_matrix = shape_match.generate_linear_matrix(new_positions, beta);
}
else
{
rotation_matrix = shape_match.generate_rotation_matrix(new_positions);
}
//print_matrix(rotation_matrix);
//Multiplies rotation matrix recieved by shape matching to mesh's vertices
Vector3 [] new_vertices = new Vector3 [vertices.Length];
for (int i = 0; i < vertices.Length; i++)
{
new_vertices[i] = MatrixFunctions.matrix_multiply_1x3_by_3x3(vertices[i], rotation_matrix);
}
//Assigns altered vertice positions to object
Mesh mesh = gameObject.GetComponent <MeshFilter>().mesh;
mesh.vertices = new_vertices;
// flipNormals();
mesh.RecalculateNormals();
}
public override Matrix GetHandleMatrix(SETItem item)
{
Matrix matrix = Matrix.Identity;
MatrixFunctions.Translate(ref matrix, item.Position);
int RotY = item.Rotation.Y + 34;
if ((RotY + 24) != 0x4000)
{
MatrixFunctions.RotateY(ref matrix, (RotY + 24) - 0x4000);
}
return matrix;
}
public double [,] generate_linear_matrix(Vector3 [] new_positions, double beta)
{
double [,] r = generate_rotation_matrix(new_positions);
double [,] a = MatrixFunctions.matrixMultiply3x3(apq, aqq);
//Rotation_test.print_matrix(aqq);
double determinant = alglib.rmatrixdet(a);
determinant = Mathf.Pow((float)determinant, 1.0f / 3.0f);
MatrixFunctions.scalar_multiply(ref a, beta / determinant);
MatrixFunctions.scalar_multiply(ref r, 1 - beta);
MatrixFunctions.matrix_add_3x3(ref a, r);
return(a);
}
void OnCollisionEnter(Collision collision)
{
if (cooldown_remaining > 0)
{
foreach (ContactPoint contact in collision.contacts)
{
for (int i = 0; i < particles.Length; i++)
{
float d = ((particles[i].transform.position - contact.point).magnitude);
Vector3 force = MatrixFunctions.vector_scalar(collision.impulse, Time.fixedDeltaTime * (1 + (d * d * d)));
particles[i].set_force(force);
}
}
cooldown_remaining = cooldown_frames;
}
else
{
cooldown_remaining--;
}
}
public override Matrix GetHandleMatrix(SETItem item)
{
Matrix matrix = Matrix.Identity;
MatrixFunctions.Translate(ref matrix, item.Position);
int x = item.Rotation.X;
int y = item.Rotation.Y;
if (!item.Scale.IsEmpty)
{
(item.Position - item.Scale).GetRotation(out x, out y);
}
MatrixFunctions.RotateY(ref matrix, x);
MatrixFunctions.RotateY(ref matrix, y);
MatrixFunctions.RotateY(ref matrix, item.Rotation.Z);
return(matrix);
}
public double [,] generate_rotation_matrix(Vector3 [] new_positions)
{
//3x3 matrix of zeros used for summation
apq = new double [, ] {
{ 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }
};
for (int i = 0; i < original_positions.Length; i++)
{
MatrixFunctions.matrix_add_3x3(ref apq, MatrixFunctions.vector3_covariance(new_positions[i], original_positions[i]));
//CHECKED: new positions are different from old ones, seem consitent
}
//CHECKED THROUGH THIS POINT
s = MatrixFunctions.matrixMultiply3x3(MatrixFunctions.transpose3x3(apq), apq);
MatrixFunctions.matrixInverseSquareRoot(ref s);
double [,] r = MatrixFunctions.matrixMultiply3x3(apq, s);
return(r);
}
public Matrix GetLocalAxes(out Vector3 Up, out Vector3 Right, out Vector3 Look)
{
Matrix transform = Matrix.Identity;
try
{
MatrixFunctions.RotateXYZ(ref transform, Rotation.X, Rotation.Y, Rotation.Z);
}
catch (NotSupportedException)
{
Console.WriteLine("Certain Item types don't support rotations. This can be ignored.");
}
Up = new Vector3(0, 1, 0);
Look = new Vector3(0, 0, 1);
Right = new Vector3(1, 0, 0);
Up = Vector3.TransformCoordinate(Up, transform);
Look = Vector3.TransformCoordinate(Look, transform);
Right = Vector3.TransformCoordinate(Right, transform);
return(transform);
}
public void movePoints(Vector3 cm0)
{
Vector3 x = gameObject.transform.parent.transform.TransformPoint(original_position - cm0);
gameObject.transform.position = MatrixFunctions.matrix_multiply_1x3_by_3x3(x, transformation_matrix);
}
public void IsIndentityTest_shouldReturnTrue()
{
Assert.IsTrue(MatrixFunctions.isIndentity(_identityMatrix));
}
public void IsIndentityTest_shouldReturnFalse()
{
Assert.IsFalse(MatrixFunctions.isIndentity(_notIdentityMatrix));
}
// protected override Band_Data Get_ChemPot_From_External(Band_Data density)
// {
// Save_Data(density, dens_filename);
//
// return Get_Data_From_External(flexpde_script, initcalc_result_filename);
// }
/// <summary>
/// Calculates the Laplacian for the given band structure of the input potential
/// ie. returns d(eps * d(input))
/// NOTE: the input should be a potential so make sure you divide all band energies by q_e
/// </summary>
public Band_Data Calculate_Phi_Laplacian(Band_Data input)
{
DoubleTriDiagMatrix lap_mat = Generate_Laplacian(exp.Layers);
return(new Band_Data(MatrixFunctions.Product(lap_mat, input.vec)));
}
private void BuildNextRandom()
{
NowRandomComponent = (Component)random.Next(0, 2);
switch (NowRandomComponent.ToString())
{
case "Матрицы":
{
NowRandomMatrixFunction = (MatrixFunctions)random.Next(0, 2);
switch (NowRandomMatrixFunction.ToString())
{
case "Sub":
{
dataGridViews = new DataGridView[3];
dataGridViews = MatrixBuilder.BuildDefaultThreeMatrix(random.Next(1, 6), random.Next(1, 6), dataGridViews);
QuestionLabel = CreateQuestionLabel("Вычитение");
Controls.Add(QuestionLabel);
PrevRandomComponent = 0;
InitialyzeComponents(dataGridViews);
break;
}
case "Mul":
{
dataGridViews = new DataGridView[3];
int Count = random.Next(1, 6);
dataGridViews = MatrixBuilder.BuildDefaultThreeMatrix(Count, Count, dataGridViews);
QuestionLabel = CreateQuestionLabel("Умножение");
Controls.Add(QuestionLabel);
PrevRandomComponent = 0;
InitialyzeComponents(dataGridViews);
break;
}
}
break;
}
case "Уравнения":
{
NowEquFunction = random.Next(0, 0);
FirstB = random.Next(-10, 0);
SecondB = random.Next(0, 11);
switch (NowEquFunction)
{
case 0:
{
koef1 = random.Next(-1, 10);
AnswerText = CreateTextBox();
Controls.Add(AnswerText);
QuestionLabel = CreateQuestionLabel("Cos(x-" + koef1 + "). Границы: " + FirstB + ", " + SecondB);
Controls.Add(QuestionLabel);
PrevRandomComponent = (Component)1;
break;
}
//case 2:
// {
// }
//case 3:
// {
// }
//case 4:
// {
// }
}
break;
}
}
QuestionCounter++;
}
DoubleComplexMatrix Product(DoubleHermitianMatrix A, DoubleComplexMatrix B)
{
return(new DoubleComplexMatrix(NMathFunctions.Product(MatrixFunctions.ToGeneralMatrix(A), B)));
}
