public TransData(VolumetricData vData, int[] t, double fi, double[] ax)
{
rnd = new Random();
this.vData = vData;
this.Measures = new int[3];
this.Measures[0] = 100; //vData.Measures[0] - t[0] - 400;
this.Measures[1] = 80; //vData.Measures[1] - t[1] - 400;
this.Measures[2] = 120; //vData.Measures[2] - t[2] - 400;
fi = Math.PI * fi / 180; //degrees to radians
this.xSpacing = vData.XSpacing;
this.ySpacing = vData.YSpacing;
this.zSpacing = vData.ZSpacing;
this.RotationM = Matrix <double> .Build.Dense(3, 3);
this.Translation = Vector <double> .Build.Dense(3);
this.Translation[0] = t[0] * XSpacing;
this.Translation[1] = t[1] * YSpacing;
this.Translation[2] = t[2] * ZSpacing;
this.RotationM[0, 0] = Math.Cos(fi) + ax[0] * ax[0] * (1 - Math.Cos(fi));
this.RotationM[0, 1] = ax[0] * ax[1] * (1 - Math.Cos(fi)) - ax[2] * Math.Sin(fi);
this.RotationM[0, 2] = ax[0] * ax[2] * (1 - Math.Cos(fi)) + ax[1] * Math.Sin(fi);
this.RotationM[1, 0] = ax[0] * ax[1] * (1 - Math.Cos(fi)) + ax[2] * Math.Sin(fi);
this.RotationM[1, 1] = Math.Cos(fi) + ax[1] * ax[1] * (1 - Math.Cos(fi));
this.RotationM[1, 2] = ax[1] * ax[2] * (1 - Math.Cos(fi)) - ax[0] * Math.Sin(fi);
this.RotationM[2, 0] = ax[0] * ax[2] * (1 - Math.Cos(fi)) - ax[1] * Math.Sin(fi);
this.RotationM[2, 1] = ax[1] * ax[2] * (1 - Math.Cos(fi)) + ax[0] * Math.Sin(fi);
this.RotationM[2, 2] = Math.Cos(fi) + ax[2] * ax[2] * (1 - Math.Cos(fi));
}
public VolumetricData CutVol(int[] translation)
{
int xRes = Measures[0] - translation[0];
int yRes = Measures[1] - translation[1];
int zRes = Measures[2] - translation[2];
int[][,] cut = new int[zRes][, ];
for (int k = 0; k < zRes; k++)
{
cut[k] = new int[xRes, yRes];
for (int i = 0; i < xRes; i++)
{
for (int j = 0; j < yRes; j++)
{
cut[k][i, j] = VData[translation[2] + k][translation[0] + i, translation[1] + j];
}
}
}
Data copy = new Data(this.Data);
VolumetricData vDnew = new VolumetricData(copy);
vDnew.VData = cut;
vDnew.Measures = new int[] { xRes, yRes, zRes };
return(vDnew);
}
public static TransData SettingFakeData(string macro, int[] translation, double phi, double[] axis)
{
VolumetricData vDataMacro = new VolumetricData(macro);
TransData td = new TransData(vDataMacro, translation, phi, axis);
iDataMicro = td;
iDataMacro = vDataMacro;
return(td);
}
/// <summary>
///
/// </summary>
/// <param name="point"></param>
/// <param name="v1"></param>
/// <param name="v2"></param>
/// <param name="v3"></param>
/// <param name="xRes"></param>
/// <param name="yRes"></param>
/// <param name="zRes"></param>
/// <param name="spacing"></param>
/// <returns></returns>
public VolumetricData Cut3D(double[] point, double[] v1, double[] v2, double[] v3, int xRes, int yRes, int zRes, double spacing)
{
ISpacing = spacing;
double[] vertical2 = Orthogonalize2D(v1, v2);
double[] vertical3 = Orthogonalize3D(v1, vertical2, v3);
double lengthV1 = Math.Sqrt(ScalarProduct(v1, v1));
double lengthV2 = Math.Sqrt(ScalarProduct(vertical2, vertical2));
double lengthV3 = Math.Sqrt(ScalarProduct(vertical3, vertical3));
double[] unitVector1 = new double[3];
double[] unitVector2 = new double[3];
double[] unitVector3 = new double[3];
for (int i = 0; i < v1.Length; i++)
{
unitVector1[i] = v1[i] * ISpacing / lengthV1;
unitVector2[i] = vertical2[i] * ISpacing / lengthV2;
unitVector3[i] = vertical3[i] * ISpacing / lengthV3;
}
int[][,] cut = new int[zRes][, ];
double x, y, z;
for (int k = 0; k < zRes; k++)
{
cut[k] = new int[xRes, yRes];
for (int i = 0; i < xRes; i++)
{
x = point[0] + i * unitVector2[0] + k * unitVector3[0];
y = point[1] + i * unitVector2[1] + k * unitVector3[1];
z = point[2] + i * unitVector2[2] + k * unitVector3[2];
for (int j = 0; j < yRes; j++)
{
cut[k][i, j] = (int)GetValueMatrixCoordinates(x, y, z);
x += unitVector1[0];
y += unitVector1[1];
z += unitVector1[2];
}
}
}
VolumetricData vDnew = new VolumetricData(Data);
vDnew.VData = cut;
return(vDnew);
}
public static void TestFeatureVector(string macro, int countPoints, int countSimilarities, int a)
{
Random rnd = new Random();
IFeatureComputer fc = new FeatureComputerNormedRings();
VolumetricData vDataMacro = new VolumetricData(macro);
iDataMacro = vDataMacro;
ISampler s = new Sampler(configuration);
Point3D[] pointsM = s.Sample(iDataMacro, countPoints);
double[] distanceFC = new double[countSimilarities];
double[] distanceReal = new double[countSimilarities];
Console.WriteLine("Computing similarities");
int index1 = rnd.Next(0, countPoints);
int index2 = index1;
//Point3D p1 = pointsM[index1];
//List<Point3D> pMacro = GetSphere(p1, 15, countSimilarities);
//Point3D[] pointsMacro = pMacro.ToArray();
//double[] point = new double[] { p1.X, p1.Y, p1.Z };
//FeatureVector f1 = fc.ComputeFeatureVector(iDataMacro, p1);
for (int i = 0; i < countSimilarities; i++)
{
if (i % 10000 == 0)
{
Console.WriteLine("i= " + i);
}
Point3D p1 = pointsM[index1];
Point3D p2 = pointsM[index2];
FeatureVector f2 = fc.ComputeFeatureVector(iDataMacro, p2);
FeatureVector f1 = fc.ComputeFeatureVector(iDataMacro, p1);
// counting similarity
distanceFC[i] = f1.DistTo2(f2);
distanceReal[i] = Math.Sqrt((p1.X - p2.X) * (p1.X - p2.X) + (p1.Y - p2.Y) * (p1.Y - p2.Y) + (p1.Z - p2.Z) * (p1.Z - p2.Z));
index2 = rnd.Next(0, countPoints);
index1 = rnd.Next(0, countPoints);
}
//WriteCSVdouble(point, "d:\\FC_test/point" + a + ".csv");
WriteCSVdouble(distanceFC, "d:\\FC_test/distanceFC" + a + ".csv");
WriteCSVdouble(distanceReal, "d:\\FC_test/distanceReal" + a + ".csv");
}
public Point3D[] Sample(VolumetricData d, int count, int radius)
{
this.pointsMax = new Point3D[count];
this.pointsMin = new Point3D[count];
int[] measures = d.Measures;
Random r = new Random(); // change rnd
for (int i = 0; i < count; i++)
{
double x = r.Next(translationX + radius, measures[0] - radius);
double y = r.Next(translationY + radius, measures[1] - radius);
double z = r.Next(translationZ + radius, measures[2] - radius);
pointsMax[i] = new Point3D(x, y, z);
}
GetSamples2();
return(pointsMax);
}
public static void MainFunction(string micro, string macro, Point3D[] pointsMicro, Point3D[] pointsMacro) // the truly main function
{
//----------------------------------------PARAMETERS----------------------------------------------
int numberOfPointsMicro = 1_000;
int numberOfPointsMacro = 1_000;
double threshold = 10; //percentage
ISampler s = new Sampler(configuration);
IFeatureComputer fc = new FeatureComputer();
IMatcher matcher = new Matcher();
ITransformer transformer = new Transformer3D();
//----------------------------------------MICRO CT------------------------------------------------
Console.WriteLine("Reading micro data.");
VolumetricData vDataMicro = new VolumetricData(micro);
iDataMicro = vDataMicro;
Console.WriteLine("Data read succesfully.");
Console.WriteLine("Sampling.");
//Point3D[] pointsMicro = s.Sample(iDataMicro, numberOfPointsMicro);
FeatureVector[] featureVectorsMicro = new FeatureVector[pointsMicro.Length];
Console.WriteLine("Computing feature vectors.");
for (int i = 0; i < pointsMicro.Length; i++)
{
featureVectorsMicro[i] = fc.ComputeFeatureVector(iDataMicro, pointsMicro[i]);
}
//----------------------------------------MACRO CT------------------------------------------------
Console.WriteLine("\nReading macro data.");
VolumetricData vDataMacro = new VolumetricData(macro);
iDataMacro = vDataMacro;
Console.WriteLine("Data read succesfully.");
Console.WriteLine("Sampling.");
//Point3D[] pointsMacro = s.Sample(iDataMacro, numberOfPointsMacro);
FeatureVector[] featureVectorsMacro = new FeatureVector[pointsMacro.Length];
Console.WriteLine("Computing feature vectors.");
for (int i = 0; i < pointsMacro.Length; i++)
{
featureVectorsMacro[i] = fc.ComputeFeatureVector(iDataMacro, pointsMacro[i]);
}
//----------------------------------------MATCHES-------------------------------------------------
Console.WriteLine("\nMatching.");
Match[] matches = matcher.Match(featureVectorsMicro, featureVectorsMacro, threshold);
Console.WriteLine("Count of matches: " + matches.Length);
//------------------------------------GET TRANSFORMATION -----------------------------------------
Console.WriteLine("Computing transformations.\n");
List <Transform3D> transformations = new List <Transform3D>();
for (int i = 0; i < matches.Length; i++)
{
transformations.Add(transformer.GetTransformation(matches[i], iDataMicro, iDataMacro));
//transformations.Add(transformer.GetTransformation(matches[i], vData, vData2, configuration));
}
Candidate.initSums(iDataMicro.Measures[0] / iDataMicro.XSpacing, iDataMicro.Measures[1] / iDataMicro.YSpacing, iDataMicro.Measures[2] / iDataMicro.ZSpacing);
Density d = new Density(); // finder, we need an instance for certain complicated reason
Transform3D solution = d.Find(transformations.ToArray());
Console.WriteLine("Solution found.");
Console.WriteLine(solution);
Cut(solution.RotationMatrix, solution.TranslationVector);
}
//Uses configuration file
public Point3D[] Sample(VolumetricData d)
{
return(Sample(d, Convert.ToInt32(configuration["Sampling:count"])));
}
