private static void PrepareGroupPointsData(LasFile file, int divisionCountX, int divisionCountY, out bool enoughPoints, out float percentOfClassTypeThreshold, out int PointsCount, out double minX, out double minY, out double ratioX, out double ratioY, out double[,] matrix, out double[,] vector, out List <LasPoint>[,] pieces)
{
enoughPoints = true;
percentOfClassTypeThreshold = 0.07f;
PointsCount = file.LasPointDataRecords.Count;
Vector3[] Points;
Points = new Vector3[4 * divisionCountX * divisionCountY];
var scaleX = file.LasHeader.ScaleFactorX;
var scaleY = file.LasHeader.ScaleFactorY;
var scaleZ = file.LasHeader.ScaleFactorZ;
minX = (float)(file.LasHeader.MinX / scaleX);
minY = (float)(file.LasHeader.MinY / scaleY);
double maxX = (float)(file.LasHeader.MaxX / scaleX);
double maxY = (float)(file.LasHeader.MaxY / scaleY);
double minZ = (float)(file.LasHeader.MinZ / scaleZ);
double diffX = maxX - minX;
double diffY = maxY - minY;
ratioX = diffX / divisionCountX;
ratioY = diffY / divisionCountY;
matrix = new double[3, 3];
vector = new double[1, 3];
pieces = new List <LasPoint> [divisionCountX, divisionCountY];
for (int i = 0; i < divisionCountX; i++)
{
for (int j = 0; j < divisionCountY; j++)
{
pieces[i, j] = new List <LasPoint>();
}
}
}
public LasPoint.ClassificationType[] Classify(LasFile file)
{
Stopwatch sw = Stopwatch.StartNew();
LasPointDataRecords points = file.LasPointDataRecords;
LasPoint.ClassificationType[] output = new LasPoint.ClassificationType[points.Count];
Statistics stats = new Statistics();
stats.Count = points.Count;
for (int i = 0; i < points.Count; i++)
{
LasPoint3Short point = (LasPoint3Short)points[i];
double green = point.Green - (point.Red + point.Blue) / 2;
IMLData classed = Network.Compute(
new BasicMLData(new double[] { file.LasHeader.ScaleZ(point.Z), point.Intensity, green }));
output[i] = Utills.QuickClassess[classed.IndexOfMax()];
if (output[i] != points[i].Classification)
{
stats.ClassErrors[(int)points[i].Classification]++;
}
stats.PredictionMatrix[(int)points[i].Classification, (int)output[i]]++;
stats.ClassCount[(int)output[i]]++;
stats.ClassRealCount[(int)points[i].Classification]++;
if (i % 1000 == 0)
{
Console.WriteLine(i);
}
}
Console.Write(stats.ToString());
sw.Stop();
Console.WriteLine("Czas trwania [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
stats.SaveMatrixAsCSV();
return(output);
}
public LasPoint.ClassificationType[] Classify(LasFile file, int count = 0)
{
var sw = Stopwatch.StartNew();
LasPointDataRecords points = file.LasPointDataRecords;
if (count == 0 || count > points.Count)
{
count = points.Count;
}
LasPoint.ClassificationType[] output = new LasPoint.ClassificationType[count];
Statistics stats = new Statistics();
stats.Count = count;
OpenTK.Vector3[] abc = new OpenTK.Vector3[count];
Parallel.For(0, count, (i) =>
{
abc[i] = LinearRegression.ComputeRegressionPoint(file, points[i], regressionCount, regressionRange);
if (i % 1000 == 0)
{
Console.WriteLine(i);
}
});
for (int i = 0; i < count; i++)
{
//double[] regression = LinearRegression.ComputeRegressionNumerics(file, points[i], regressionCount, regressionRange);
LasPoint3Short point = (LasPoint3Short)points[i];
//OpenTK.Vector3 abc = LinearRegression.ComputeRegressionPoint(file, points[i], regressionCount, regressionRange);
double distanceFromPlane = Utills.DistanceFromPlane(point, abc[i]);
double green = point.Green - (point.Red + point.Blue) / 2;
IMLData classed = Network.Compute(new BasicMLData(new double[] { green, file.LasHeader.ScaleZ(point.Z), point.Intensity,
abc[i].X, abc[i].Y, abc[i].Z, distanceFromPlane }));
output[i] = Utills.QuickClassess[classed.IndexOfMax()];
if (output[i] != points[i].Classification)
{
stats.ClassErrors[(int)points[i].Classification]++;
}
stats.ClassCount[(int)output[i]]++;
stats.ClassRealCount[(int)points[i].Classification]++;
stats.PredictionMatrix[(int)points[i].Classification, (int)output[i]]++;
if (i % 1000 == 0)
{
Console.WriteLine(i);
}
}
Console.Write(stats.ToString());
sw.Stop();
Console.WriteLine("Czas trwania [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
stats.SaveMatrixAsCSV();
return(output);
}
public LasPoint.ClassificationType[] Classify(LasFile file)
{
var sw = Stopwatch.StartNew();
LasPointDataRecords points = file.LasPointDataRecords;
int pointsCount = points.Count();
LasPoint.ClassificationType[] output = new LasPoint.ClassificationType[pointsCount];
Statistics stats = new Statistics();
stats.Count = pointsCount;
OpenTK.Vector3[] slopeVector = new OpenTK.Vector3[pointsCount];
Parallel.For(0, pointsCount, (i) =>
{
slopeVector[i] = LinearRegression.ComputeRegressionPoint(file, points[i], regressionCount, regressionRange);
if (i % 1000 == 0)
{
Console.WriteLine("ComputeRegression " + i);
}
});
for (int i = 0; i < pointsCount; i++)
{
LasPoint3Short point = (LasPoint3Short)points[i];
double distanceFromPlane = Utills.DistanceFromPlane(point, slopeVector[i]);
double green = point.Green - (point.Red + point.Blue) / 2;
output[i] = Utills.ClassificationClasses[knn.Compute(new double[] { green,
file.LasHeader.ScaleZ(point.Z), point.Intensity, slopeVector[i].X,
slopeVector[i].Y, slopeVector[i].Z, distanceFromPlane })];
if (output[i] != points[i].Classification)
{
stats.ClassErrors[(int)points[i].Classification]++;
}
stats.ClassCount[(int)output[i]]++;
stats.ClassRealCount[(int)points[i].Classification]++;
stats.PredictionMatrix[(int)points[i].Classification, (int)output[i]]++;
if (i % 1000 == 0)
{
Console.WriteLine(i);
}
}
Console.Write(stats.ToString());
sw.Stop();
Console.WriteLine("Czas trwania [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
stats.SaveMatrixAsCSV();
return(output);
}
public static double[] ComputeRegressionNumerics(LasFile file, LasPoint point, int count, int radiusSector)
{
var neighbours = file.LasPointDataRecords.GetNeighbours(point, count, radiusSector);
double[][] xy = new double[neighbours.Count][];
double[] z = new double[neighbours.Count];
for (int i = 0; i < neighbours.Count; i++)
{
xy[i] = new double[] { neighbours[i].X, neighbours[i].Y };
z[i] = neighbours[i].Z;
}
double[] p = MultipleRegression.QR(xy, z);
return(p);
}
public ClassificationType[,] Classify(LasFile file)
{
var sw = Stopwatch.StartNew();
ClassificationType[,] output = new ClassificationType[_divisionCountX, _divisionCountY];
SubgroupOfPoints[,] values = Utills.GroupPoints(file, _divisionCountX, _divisionCountY);
Statistics stats = new Statistics();
stats.Count = _divisionCountX * _divisionCountY;
for (int i = 0; i < _divisionCountX; i++)
{
for (int j = 0; j < _divisionCountY; j++)
{
double avgHeight = values[i, j].avgHeight;
double avgIntensity = values[i, j].avgIntensity;
double avgDistance = values[i, j].avgDistance;
OpenTK.Vector3 slopeVector = values[i, j].slopeVector;
IMLData classed = Network.Compute(new BasicMLData(
new double[] { avgDistance, avgHeight, avgIntensity, slopeVector[0], slopeVector[1], slopeVector[2] }));
output[i, j] = Utills.QuickClassess[classed.IndexOfMax()];
ClassificationType ct;
if (!Utills.QuickClassess.TryGetValue(values[i, j].classIndex, out ct))
{
continue;
}
if (output[i, j] != ct)
{
stats.ClassErrors[(int)ct]++;
}
stats.PredictionMatrix[(int)output[i, j], (int)ct]++;
stats.PredictionMatrix[(int)ct, (int)output[i, j]]++;
stats.ClassCount[(int)output[i, j]]++;
stats.ClassRealCount[(int)ct]++;
}
Console.WriteLine(i);
}
Console.Write(stats.ToString());
sw.Stop();
Console.WriteLine("Czas trwania [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
stats.SaveMatrixAsCSV();
return(output);
}
public static Vector3 ComputeRegressionPoint(LasFile file, LasPoint point, int count, int radiusSector)
{
var neighbours = file.LasPointDataRecords.GetNeighbours(point, count, radiusSector);
double[,] matrix = new double[3, 3];
double[,] vector = new double[1, 3];
foreach (var item in neighbours)
{
matrix[0, 0] += item.X * item.X;
matrix[0, 1] += item.X * item.Y;
matrix[0, 2] += item.X;
matrix[1, 0] += item.X * item.Y;
matrix[1, 1] += item.Y * item.Y;
matrix[1, 2] += item.Y;
matrix[2, 0] += item.X;
matrix[2, 1] += item.Y;
vector[0, 0] += item.X * item.Z;
vector[0, 1] += item.Y * item.Z;
vector[0, 2] += item.Z;
}
matrix[2, 2] = neighbours.Count;
Matrix <double> a = DenseMatrix.OfArray(matrix);
Matrix <double> b = DenseMatrix.OfArray(vector);
a = a.Inverse();
Matrix <double> x = b.Multiply(a);
var tempArray = x.ToArray();
Vector3 abc = new Vector3(Convert.ToSingle(tempArray[0, 0]), Convert.ToSingle(tempArray[0, 1]), Convert.ToSingle(tempArray[0, 2]));
return(abc);
}
public EncogNeuralNetworkQuick(LasFile file, int divisionCountX, int divisionCountY)
{
var sw = Stopwatch.StartNew();
_divisionCountX = divisionCountX;
_divisionCountY = divisionCountY;
var groupPointList = Utills.GroupPointsList(file, _divisionCountX, _divisionCountY);
int count = groupPointList.Count / 5;
double[][] input = new double[count][];
double[][] ideal = new double[count][];
int waterCount = 0;
int groundCount = 0;
int lowCount = 0;
int mediumCount = 0;
int highCount = 0;
int buildingCount = 0;
for (int i = 0; i < count; i++)
{
int rndNumber;
ClassificationType simpleClass;
while (true)
{
rndNumber = _rnd.Next(0, groupPointList.Count - 1);
if (!Utills.QuickClassess.TryGetValue(groupPointList[rndNumber].classIndex, out simpleClass))
{
continue;
}
if (simpleClass == LasPoint.ClassificationType.Water)
{
waterCount++;
if (waterCount - 25 < count / 6)
{
break;
}
}
else if (simpleClass == LasPoint.ClassificationType.Ground)
{
groundCount++;
if (groundCount - 25 < count / 6)
{
break;
}
}
else if (simpleClass == LasPoint.ClassificationType.Building)
{
buildingCount++;
if (buildingCount - 25 < count / 6)
{
break;
}
}
else if (simpleClass == LasPoint.ClassificationType.LowVegetation)
{
lowCount++;
if (lowCount - 25 < count / 6)
{
break;
}
}
else if (simpleClass == LasPoint.ClassificationType.MediumVegetation)
{
mediumCount++;
if (mediumCount - 25 < count / 6)
{
break;
}
}
else if (simpleClass == LasPoint.ClassificationType.HighVegetation)
{
highCount++;
if (highCount - 25 < count / 6)
{
break;
}
}
if (highCount > 5 * count)
{
highCount = 0;
}
if (buildingCount > 5 * count)
{
buildingCount = 0;
}
if (lowCount > 5 * count)
{
lowCount = 0;
}
if (mediumCount > 5 * count)
{
mediumCount = 0;
}
if (waterCount > 5 * count)
{
waterCount = 0;
}
if (groundCount > 5 * count)
{
groundCount = 0;
}
}
if (i % 100 == 0)
{
Console.WriteLine(i);
}
double avgHeight = groupPointList[rndNumber].avgHeight;
double avgIntensity = groupPointList[rndNumber].avgIntensity;
double avgDistance = groupPointList[rndNumber].avgDistance;
OpenTK.Vector3 slopeVector = groupPointList[rndNumber].slopeVector;
input[i] = new double[] { avgDistance, avgHeight, avgIntensity, slopeVector[0], slopeVector[1], slopeVector[2] };
ideal[i] = Utills.ClassToVector(simpleClass);
}
inputNumber = input[0].Length;
init();
IMLDataSet trainingSet = new BasicMLDataSet(input, ideal);
IMLTrain train = new ResilientPropagation(Network, trainingSet);
int epoch = 1;
do
{
train.Iteration();
Console.WriteLine(train.Error + " | " + epoch);
epoch++;
} while (epoch < 1000);
LearningError = train.Error;
train.FinishTraining();
sw.Stop();
Console.WriteLine("Czas trwania [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
}
public static Tuple <double[], int> GetInputOutputFromClassificationType(LasPoint point, LasFile file)
{
var abc = LinearRegression.ComputeRegressionPoint(file, point, regressionCount, regressionRange);
double distanceFromPlane = Utills.DistanceFromPlane(point, abc);
LasPoint3Short pointShort = (LasPoint3Short)point;
double green = pointShort.Green - (pointShort.Red + pointShort.Blue) / 2;
var input = new double[] { green, file.LasHeader.ScaleZ(point.Z), point.Intensity, abc.X, abc.Y, abc.Z, distanceFromPlane };
int output;
switch (point.Classification)
{
case LasPoint.ClassificationType.Ground:
output = 0;
break;
case LasPoint.ClassificationType.HighVegetation:
output = 1;
break;
case LasPoint.ClassificationType.Building:
output = 2;
break;
case LasPoint.ClassificationType.MediumVegetation:
output = 3;
break;
case LasPoint.ClassificationType.LowVegetation:
output = 4;
break;
case LasPoint.ClassificationType.Water:
output = 5;
break;
default:
input = new double[] { -1, -1, -1, -1, -1, -1, -1 };
output = 6;
break;
}
return(Tuple.Create(input, output));
}
public static Tuple <double[], int> GetInputOutputFromClassificationType(LasPoint point, LasFile file)
{
LasPoint3Short pointShort = (LasPoint3Short)point;
double green = pointShort.Green - (pointShort.Red + pointShort.Blue) / 2;
var input = new double[] { file.LasHeader.ScaleZ(point.Z), point.Intensity, green };
int output;
switch (point.Classification)
{
case LasPoint.ClassificationType.Ground:
output = 0;
break;
case LasPoint.ClassificationType.HighVegetation:
output = 1;
break;
case LasPoint.ClassificationType.Building:
output = 2;
break;
case LasPoint.ClassificationType.MediumVegetation:
output = 3;
break;
case LasPoint.ClassificationType.LowVegetation:
output = 4;
break;
case LasPoint.ClassificationType.Water:
output = 5;
break;
default:
input = new double[] { -1, -1, -1 };
output = 6;
break;
}
return(Tuple.Create(input, output));
}
public static Tuple <double[][], int[]> MakeInputOutputs(List <LasPoint> points, LasFile file)
{
int count = points.Count;
int[] outputs = new int[count];
double[][] inputs = new double[count][];
Parallel.For(0, count, (i) =>
{
LasPoint point = points[i];
Console.WriteLine("Preparing Teaching Dataset " + i + "/" + count);
var inout = GetInputOutputFromClassificationType(point, file);
inputs[i] = inout.Item1;
outputs[i] = inout.Item2;
});
return(new Tuple <double[][], int[]>(inputs, outputs));
}
public static List <SubgroupOfPoints> GroupPointsList(LasFile file, int divisionCountX, int divisionCountY)
{
Console.WriteLine("Preparing input dataset... ");
Stopwatch sw = Stopwatch.StartNew();
List <SubgroupOfPoints> results = new List <SubgroupOfPoints>();
bool enoughPoints;
float percentOfClassTypeThreshold;
int PointsCount;
double minX, minY, ratioX, ratioY;
double[,] matrix, vector;
List <LasPoint>[,] pieces;
PrepareGroupPointsData(file, divisionCountX, divisionCountY, out enoughPoints, out percentOfClassTypeThreshold, out PointsCount, out minX, out minY, out ratioX, out ratioY, out matrix, out vector, out pieces);
for (int i = 0; i < PointsCount; i++)
{
var xReal = (float)file.LasPointDataRecords[i].X;
var yReal = (float)file.LasPointDataRecords[i].Y;
int arrayX = (int)((xReal - minX) / ratioX);
int arrayY = (int)((yReal - minY) / ratioY);
if ((arrayX < divisionCountX) && (arrayY < divisionCountY))
{
pieces[arrayX, arrayY].Add(file.LasPointDataRecords[i]);
}
}
for (int i = 0; i < divisionCountX; i++)
{
for (int j = 0; j < divisionCountY; j++)
{
List <LasPoint> points;
int pointsCount;
double avgIntensity, avgHeight;
int[] groupClass;
CountGroupPointsParams(out enoughPoints, matrix, vector, pieces, i, j, out points, out pointsCount, out avgIntensity, out avgHeight, out groupClass);
int classIndex = 6;
if (pointsCount >= 12)
{
if (groupClass[0] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 0;
}
else if (groupClass[1] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 1;
}
else if (groupClass[2] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 2;
}
else if (groupClass[3] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 3;
}
else if (groupClass[4] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 4;
}
else if (groupClass[5] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 5;
}
}
else
{
enoughPoints = false;
}
if (enoughPoints)
{
SubgroupOfPoints group = CountSumOfDistancesFromPlane(matrix, vector, points, pointsCount, ref avgIntensity, ref avgHeight, classIndex);
results.Add(group);
}
}
}
int[] classCount = new int[8];
float[] percentOfClassInputs = { 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f };
foreach (SubgroupOfPoints group in results)
{
if (group.classIndex == 0)
{
classCount[0]++;
}
else if (group.classIndex == 1)
{
classCount[1]++;
}
else if (group.classIndex == 2)
{
classCount[2]++;
}
else if (group.classIndex == 3)
{
classCount[3]++;
}
else if (group.classIndex == 4)
{
classCount[4]++;
}
else if (group.classIndex == 5)
{
classCount[5]++;
}
else if (group.classIndex == 6)
{
classCount[6]++;
}
}
results.Sort((a, b) => a.classIndex.CompareTo(b.classIndex));
List <SubgroupOfPoints> properResults = new List <SubgroupOfPoints>();
properResults.AddRange(results.GetRange(0, (int)(classCount[0] * percentOfClassInputs[0])));
properResults.AddRange(results.GetRange(classCount[0], (int)(classCount[1] * percentOfClassInputs[1])));
properResults.AddRange(results.GetRange(classCount[0] + classCount[1], (int)(classCount[2] * percentOfClassInputs[2])));
properResults.AddRange(results.GetRange(classCount[0] + classCount[1] + classCount[2], (int)(classCount[3] * percentOfClassInputs[3])));
properResults.AddRange(results.GetRange(classCount[0] + classCount[1] + classCount[2] + classCount[3], (int)(classCount[4] * percentOfClassInputs[4])));
properResults.AddRange(results.GetRange(classCount[0] + classCount[1] + classCount[2] + classCount[3] + classCount[4], (int)(classCount[5] * percentOfClassInputs[5])));
sw.Stop();
Console.WriteLine("Preparing input dataset completed [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
return(properResults);
}
public EncogNeuralNetworkSlow(LasFile file)
{
var sw = Stopwatch.StartNew();
int count = 300000;
LasPointDataRecords points = file.LasPointDataRecords;
double[][] input = new double[count][];
double[][] ideal = new double[count][];
int waterCount = 0;
int groundCount = 0;
int lowCount = 0;
int mediumCount = 0;
int highCount = 0;
int buildingCount = 0;
for (int i = 0; i < count; i++)
{
int rndNumber;
while (true)
{
rndNumber = _rnd.Next(0, points.Count - 1);
if (points[rndNumber].Classification == LasPoint.ClassificationType.Water)
{
waterCount++;
if (waterCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.Ground)
{
groundCount++;
if (groundCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.Building)
{
buildingCount++;
if (buildingCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.LowVegetation)
{
lowCount++;
if (lowCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.MediumVegetation)
{
mediumCount++;
if (mediumCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.HighVegetation)
{
highCount++;
if (highCount - 25 < count / 6)
{
break;
}
}
if (highCount > 5 * count)
{
highCount = 0;
}
if (buildingCount > 5 * count)
{
buildingCount = 0;
}
if (lowCount > 5 * count)
{
lowCount = 0;
}
if (mediumCount > 5 * count)
{
mediumCount = 0;
}
if (waterCount > 5 * count)
{
waterCount = 0;
}
if (groundCount > 5 * count)
{
groundCount = 0;
}
}
if (i % 1000 == 0)
{
Console.WriteLine("Selected point: " + i + "/" + count);
}
//double[] regression = LinearRegression.ComputeRegressionNumerics(file, points[rndNumber], regressionCount, regressionRange);
OpenTK.Vector3 abc = LinearRegression.ComputeRegressionPoint(file, points[rndNumber], regressionCount, regressionRange);
LasPoint3Short point = (LasPoint3Short)points[rndNumber];
double distanceFromPlane = Utills.DistanceFromPlane(point, abc);
double green = point.Green - (point.Red + point.Blue) / 2;
input[i] = new double[] { green, file.LasHeader.ScaleZ(point.Z), point.Intensity, abc.X, abc.Y, abc.Z, distanceFromPlane };
ideal[i] = Utills.ClassToVector(point.Classification);
}
inputNumber = input[0].Length;
init();
IMLDataSet trainingSet = new BasicMLDataSet(input, ideal);
IMLTrain train = new ResilientPropagation(Network, trainingSet);
int epoch = 1;
do
{
train.Iteration();
Console.WriteLine("Train error: " + train.Error + ", iteration: " + epoch);
epoch++;
} while (epoch < 1000);
LearningError = train.Error;
train.FinishTraining();
sw.Stop();
Console.WriteLine("Czas trwania [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
}
public static SubgroupOfPoints[,] GroupPoints(LasFile file, int divisionCountX, int divisionCountY)
{
SubgroupOfPoints[,] results = new SubgroupOfPoints[divisionCountX, divisionCountY];
bool enoughPoints;
float percentOfClassTypeThreshold;
int PointsCount;
double minX, minY, ratioX, ratioY;
double[,] matrix, vector;
List <LasPoint>[,] pieces;
PrepareGroupPointsData(file, divisionCountX, divisionCountY, out enoughPoints, out percentOfClassTypeThreshold, out PointsCount, out minX, out minY, out ratioX, out ratioY, out matrix, out vector, out pieces);
for (int i = 0; i < PointsCount; i++)
{
var xReal = (float)file.LasPointDataRecords[i].X;
var yReal = (float)file.LasPointDataRecords[i].Y;
int arrayX = (int)((xReal - minX) / ratioX);
int arrayY = (int)((yReal - minY) / ratioY);
if ((arrayX < divisionCountX) && (arrayY < divisionCountY))
{
pieces[arrayX, arrayY].Add(file.LasPointDataRecords[i]);
}
}
for (int i = 0; i < divisionCountX; i++)
{
for (int j = 0; j < divisionCountY; j++)
{
List <LasPoint> points;
int pointsCount;
double avgIntensity, avgHeight;
int[] groupClass;
CountGroupPointsParams(out enoughPoints, matrix, vector, pieces, i, j, out points, out pointsCount, out avgIntensity, out avgHeight, out groupClass);
int classIndex = 6;
if (pointsCount < 12)
{
results[i, j] = new SubgroupOfPoints(7);
enoughPoints = false;
}
else
{
if (groupClass[0] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 0;
}
else if (groupClass[1] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 1;
}
else if (groupClass[2] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 2;
}
else if (groupClass[3] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 3;
}
else if (groupClass[4] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 4;
}
else if (groupClass[5] >= (percentOfClassTypeThreshold * pointsCount))
{
classIndex = 5;
}
}
if (enoughPoints)
{
SubgroupOfPoints group = CountSumOfDistancesFromPlane(matrix, vector, points, pointsCount, ref avgIntensity, ref avgHeight, classIndex);
results[i, j] = group;
}
}
}
return(results);
}
public EncogNeuralNetwork(LasFile file)
{
Stopwatch sw = Stopwatch.StartNew();
int count = 300000;
LasPointDataRecords points = file.LasPointDataRecords;
double[][] input = new double[count][];
double[][] ideal = new double[count][];
int waterCount = 0;
int groundCount = 0;
int lowCount = 0;
int mediumCount = 0;
int highCount = 0;
int buildingCount = 0;
for (int i = 0; i < count; i++)
{
int rndNumber;
while (true)
{
rndNumber = _rnd.Next(0, points.Count - 1);
if (points[rndNumber].Classification == LasPoint.ClassificationType.Water)
{
waterCount++;
if (waterCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.Ground)
{
groundCount++;
if (groundCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.Building)
{
buildingCount++;
if (buildingCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.LowVegetation)
{
lowCount++;
if (lowCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.MediumVegetation)
{
mediumCount++;
if (mediumCount - 25 < count / 6)
{
break;
}
}
else if (points[rndNumber].Classification == LasPoint.ClassificationType.HighVegetation)
{
highCount++;
if (highCount - 25 < count / 6)
{
break;
}
}
if (highCount > 5 * count)
{
highCount = 0;
}
if (buildingCount > 5 * count)
{
buildingCount = 0;
}
if (lowCount > 5 * count)
{
lowCount = 0;
}
if (mediumCount > 5 * count)
{
mediumCount = 0;
}
if (waterCount > 5 * count)
{
waterCount = 0;
}
if (groundCount > 5 * count)
{
groundCount = 0;
}
}
if (i % 100 == 0)
{
Console.WriteLine(i);
}
LasPoint3Short point = (LasPoint3Short)points[rndNumber];
double green = point.Green - (point.Red + point.Blue) / 2;
input[i] = new double[] { file.LasHeader.ScaleZ(point.Z), point.Intensity, green };
ideal[i] = Utills.ClassToVector(point.Classification);
}
inputNumber = input[0].Length;
init();
IMLDataSet trainingSet = new BasicMLDataSet(input, ideal);
IMLTrain train = new ResilientPropagation(Network, trainingSet);
int epoch = 1;
do
{
train.Iteration();
Console.WriteLine(train.Error + " | " + epoch);
epoch++;
} while (epoch < 1000);
LearningError = train.Error;
train.FinishTraining();
sw.Stop();
Console.WriteLine("Czas trwania [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
}
public static List <Vector3> GenerateVectorArray(List <LasPoint> classPointsRanged, LasFile file)
{
List <Vector3> vectors = new List <Vector3>();
Console.WriteLine("Generationg Vector Arrays in progress");
int pointNo = 0;
foreach (LasPoint point in classPointsRanged)
{
pointNo += 1;
vectors.Add(LinearRegression.ComputeRegressionPoint(file, point, 100, 2));
Console.WriteLine("Computing Vectors " + pointNo + "/" + classPointsRanged.Count);
}
return(vectors);
}
public ClassificationType[,] Classify(LasFile file, int divCountX, int divCountY)
{
Stopwatch swTotal = Stopwatch.StartNew();
Stopwatch sw = Stopwatch.StartNew();
Console.WriteLine("Preparing testing dataset...");
LasPointDataRecords points = file.LasPointDataRecords;
ClassificationType[,] output = new ClassificationType[divCountX, divCountY];
SubgroupOfPoints[,] values = Utills.GroupPoints(file, divCountX, divCountY);
Statistics stats = new Statistics();
stats.Count = divCountX * divCountY;
sw.Stop();
Console.WriteLine("Preparing testing dataset completed [" + sw.Elapsed.TotalSeconds.ToString() + "s]");
Stopwatch sw2 = Stopwatch.StartNew();
Console.WriteLine("Classification in progress...");
int noiseCount = 0;
for (int i = 0; i < divCountX; i++)
{
for (int j = 0; j < divCountY; j++)
{
if (values[i, j].classIndex == 7)
{
output[i, j] = ClassificationType.Noise;
noiseCount++;
}
else
{
double avgHeight = values[i, j].avgHeight;
double avgIntensity = values[i, j].avgIntensity;
double avgDistance = values[i, j].avgDistance;
OpenTK.Vector3 slopeVector = values[i, j].slopeVector;
output[i, j] = Utills.ClassificationClasses[knn.Compute(new double[] {
avgDistance, avgHeight, avgIntensity, slopeVector[0],
slopeVector[1], slopeVector[2]
})];
ClassificationType ct;
if (!Utills.QuickClassess.TryGetValue(values[i, j].classIndex, out ct))
{
continue;
}
if (output[i, j] != ct)
{
stats.ClassErrors[(int)ct]++;
}
stats.PredictionMatrix[(int)output[i, j], (int)ct]++;
stats.PredictionMatrix[(int)ct, (int)output[i, j]]++;
stats.ClassCount[(int)output[i, j]]++;
stats.ClassRealCount[(int)ct]++;
}
}
//Console.WriteLine(i);
}
Console.Write(stats.ToString());
sw2.Stop();
Console.WriteLine("Classification completed [" + sw2.Elapsed.TotalSeconds.ToString() + "s]");
swTotal.Stop();
Console.WriteLine("Total time: [" + swTotal.Elapsed.TotalSeconds.ToString() + "s]");
Console.WriteLine("Noise count: " + noiseCount.ToString());
stats.SaveMatrixAsCSV();
return(output);
}
