// transformiert Koordinaten anhand von zwei Punkten - gibt List mit transformierten Punkten zurück
public static List<Punkt> transformCoordinates2P(Punkt oP1, Punkt oP2, Punkt rP1, Punkt rP2, List<Punkt> oPoints)
{
// Vektor v (Elemente a, b, c und d)
double[] v = calcVecABCD(oP1, oP2, rP1, rP2);
// Transformationsgleichungen
List<Punkt> rPoints = new List<Punkt>();
for (int i = 0; i < oPoints.Count; i++)
{
double x = calculateXValue(v, oPoints[i]);
double y = calculateYValue(v, oPoints[i]);
rPoints.Add(new Punkt(x, y));
}
return rPoints;
}
private static double calculateYValue(double[] v, Punkt point)
{
return v[1] * point.getX() - v[0] * point.getY() + v[3];
}
// Berechnet die Distanz zwischen zwei Punkten
public static double calculateEukDistance(Punkt p1, Punkt p2)
{
return Math.Sqrt(Math.Pow(p1.getX() - p2.getX(), 2) + Math.Pow(p1.getY() - p2.getY(), 2));
}
// Matrix
public static double[] calcVecABCD(Punkt oP1, Punkt oP2, Punkt rP1, Punkt rP2)
{
// Matrixattribute
double x1 = oP1.getX(), y1 = oP1.getY(), x2 = oP2.getX(), y2 = oP2.getY();
double rx1 = rP1.getX(), ry1 = rP1.getY(), rx2 = rP2.getX(), ry2 = rP2.getY();
// Vektor u
double[] u = new double[] { rx1, ry1, rx2, ry2 };
double[] m1 = new double[] { x1, y1, 1, 0 };
double[] m2 = new double[] {-1 * y1, x1, 0, 1};
double[] m3 = new double[] { x2, y2, 1, 0 };
double[] m4 = new double[] {-1* y2, x2, 0, 1};
List<double[]> tmp = new List<double[]>();
tmp.Add(m1);
tmp.Add(m2);
tmp.Add(m3);
tmp.Add(m4);
// Matrix M
double[][] M = new double[4][];
for (int i = 0; i < tmp.Count; i++){
M[i] = new double[4];
for (int j = 0; j < tmp[i].Length; j++){
M[i][j] = tmp[i][j];
}
}
// inverse Matrix M
double[][] M1 = inverse2DMatrix(M);
// invM multipliziert mit u
double[] v = multiplyMatrix1D(M1, u);
// Zielvektor v
return v;
}
// berechnet den Flächeninhalt eines Polygons
static public double calcAreaPolygon(List<Punkt> inputPoints)
{
List<Punkt> points = new List<Punkt>();
// transferieren der Punktdaten
for (int i = 0; i < inputPoints.Count; i++)
{
points.Add(inputPoints[i]);
}
// Liste mit sortierten Punkten
List<Punkt> calcPoints = new List<Punkt>();
Punkt tmpPoint = null;
// Punkt 1
double a = 100000.00;
for (int i = 0; i < points.Count; i++)
{
// suche nach der geringsten Distanz zum Ursprung
double t = Math.Sqrt(Math.Pow(points[i].getX(), 2) + Math.Pow(points[i].getY(), 2));
if (t < a) {
a = t;
tmpPoint = points[i];
}
}
calcPoints.Add(tmpPoint);
points.Remove(tmpPoint);
tmpPoint = null;
// Punkt 2
Punkt y_min = new Punkt(100000.0, 10000.0);
tmpPoint = new Punkt(100000.0, 100000.0);
for (int i = 0; i < points.Count; i++)
{
if (y_min.getY() > points[i].getY())
{
y_min = points[i];
}
}
for (int i = 0; i < points.Count; i++)
{
if (points[i] != y_min)
{
if (tmpPoint.getX() > points[i].getX())
{
tmpPoint = points[i];
}
}
}
calcPoints.Add(tmpPoint);
points.Remove(tmpPoint);
tmpPoint = null;
y_min = null;
// Punkt 3
y_min = new Punkt(100000.0, 10000.0);
tmpPoint = new Punkt(0.0, 0.0);
for (int i = 0; i < points.Count; i++)
{
if (y_min.getY() > points[i].getY())
{
y_min = points[i];
}
}
for (int i = 0; i < points.Count; i++)
{
if (points[i] != y_min)
{
if (tmpPoint.getX() < points[i].getX())
{
tmpPoint = points[i];
}
}
}
calcPoints.Add(tmpPoint);
points.Remove(tmpPoint);
tmpPoint = null;
// Punkt 4
calcPoints.Add(points[0]);
// Berechnung der Fläche anhand eines Polygonzuges
double area = (calcPoints[0].getY() + calcPoints[1].getY()) * (calcPoints[0].getX() - calcPoints[1].getX()) +
(calcPoints[1].getY() + calcPoints[2].getY()) * (calcPoints[1].getX() - calcPoints[2].getX()) +
(calcPoints[2].getY() + calcPoints[3].getY()) * (calcPoints[2].getX() - calcPoints[3].getX()) +
(calcPoints[3].getY() + calcPoints[0].getY()) * (calcPoints[3].getX() - calcPoints[0].getX());
if (area < 0)
{
area = area * -1;
}
return area / 2;
}
// berechnet den Mittelpunkt eines Viereckes
static public Punkt calcCenterCube(List<Punkt> inputPoints)
{
List<Punkt> points = new List<Punkt>();
// transferieren der Punktdaten
for (int i = 0; i < inputPoints.Count; i++)
{
points.Add(inputPoints[i]);
}
// Liste mit sortierten Punkten
List<Punkt> calcPoints = new List<Punkt>();
Punkt tmpPoint = null;
// Punkt 1
double a = 100000.00;
for (int i = 0; i < points.Count; i++)
{
// suche nach der geringsten Distanz zum Ursprung
double t = Math.Sqrt(Math.Pow(points[i].getX(), 2) + Math.Pow(points[i].getY(), 2));
if (t < a)
{
a = t;
tmpPoint = points[i];
}
}
calcPoints.Add(tmpPoint);
points.Remove(tmpPoint);
tmpPoint = null;
// Punkt 2
Punkt y_min = new Punkt(100000.0, 10000.0);
tmpPoint = new Punkt(100000.0, 100000.0);
for (int i = 0; i < points.Count; i++)
{
if (y_min.getY() > points[i].getY())
{
y_min = points[i];
}
}
for (int i = 0; i < points.Count; i++)
{
if (points[i] != y_min)
{
if (tmpPoint.getX() > points[i].getX())
{
tmpPoint = points[i];
}
}
}
calcPoints.Add(tmpPoint);
points.Remove(tmpPoint);
tmpPoint = null;
y_min = null;
// Punkt 3
y_min = new Punkt(100000.0, 10000.0);
tmpPoint = new Punkt(0.0, 0.0);
for (int i = 0; i < points.Count; i++)
{
if (y_min.getY() > points[i].getY())
{
y_min = points[i];
}
}
for (int i = 0; i < points.Count; i++)
{
if (points[i] != y_min)
{
if (tmpPoint.getX() < points[i].getX())
{
tmpPoint = points[i];
}
}
}
calcPoints.Add(tmpPoint);
points.Remove(tmpPoint);
tmpPoint = null;
// Punkt 4
calcPoints.Add(points[0]);
// Gerade 1
double m1 = 0.0;
if ((calcPoints[0].getY() == calcPoints[2].getY()) || (calcPoints[0].getX() == calcPoints[2].getX())){
m1 = 0.0;
}
else
{
m1 = (calcPoints[0].getY() - calcPoints[2].getY()) / (calcPoints[0].getX() - calcPoints[2].getX());
}
double b1 = calcPoints[0].getY() - calcPoints[0].getX() * m1;
// Gerade 2
double m2 = 0.0;
if ((calcPoints[1].getY() == calcPoints[3].getY()) || (calcPoints[1].getX() == calcPoints[3].getX()))
{
m2 = 0.0;
}
else
{
m2 = (calcPoints[1].getY() - calcPoints[3].getY()) / (calcPoints[1].getX() - calcPoints[3].getX());
}
double b2 = calcPoints[1].getY() - calcPoints[1].getX() * m2;
// Berechnung des Schnittpunktes
double xs = m1 - m2;
double bs = b2 - b1;
double x = bs / xs;
double y = x * m1 + b1;
return new Punkt(x, y);
}
// importieren der Initialisierungsdefinitionen
private void readIniFile()
{
double ref1X = 0 , ref1Y = 0 , ref2X = 0, ref2Y = 0;
try
{
string line;
using (StreamReader sr = new StreamReader(inifile))
{
while ((line = sr.ReadLine()) != null)
{
if ((line[0] != '#') && (line[0] != ' '))
{
string[] split = line.Split('=');
if (split[0] == "OBJEKTERKENNUNGAPP")
{
detectorApp = split[1];
}
else if (split[0] == "PYTHONAPP")
{
pythonApp = split[1];
}
else if (split[0] == "INPUT_CORNERS")
{
input_corners = split[1];
}
else if (split[0] == "OUTPUT_CORNERS")
{
output_corners = split[1];
}
else if (split[0] == "PICTUREOUTPUT")
{
pictureoutput = split[1];
}
else if (split[0] == "PYTHON")
{
python = split[1];
}
else if (split[0] == "PORT")
{
port = Convert.ToInt16(split[1]);
}
else if (split[0] == "IPADRESS")
{
ipadress = split[1];
}
else if (split[0] == "Max_Area_Center")
{
maxAreaCentering = Convert.ToDouble(split[1]);
}
else if (split[0] == "Min_Area_Center")
{
minAreaCentering = Convert.ToDouble(split[1]);
}
else if (split[0] == "Max_Area_Convert")
{
maxAreaConverting = Convert.ToDouble(split[1]);
}
else if (split[0] == "Min_Area_Convert")
{
minAreaConverting = Convert.ToDouble(split[1]);
}
else if (split[0] == "Range_Center")
{
rangeCentering = Convert.ToDouble(split[1]);
}
else if (split[0] == "Range_Convert")
{
rangeConverting = Convert.ToDouble(split[1]);
}
else if (split[0] == "GROUPSIZE")
{
groupSize = Convert.ToInt16(split[1]);
}
else if (split[0] == "HEIGHT")
{
height = Convert.ToDouble(split[1]);
}
else if (split[0] == "RADIUS")
{
radius = Convert.ToDouble(split[1]);
}
else if (split[0] == "REFERENZ_1_X")
{
ref1X = Convert.ToDouble(split[1]);
}
else if (split[0] == "REFERENZ_1_Y")
{
ref1Y = Convert.ToDouble(split[1]);
}
else if (split[0] == "REFERENZ_2_X")
{
ref2X = Convert.ToDouble(split[1]);
}
else if (split[0] == "REFERENZ_2_Y")
{
ref2Y = Convert.ToDouble(split[1]);
}
else if (split[0] == "TRANS_CENTERS")
{
transOutput = split[1];
}
}
}
}
referencePoint1 = new Punkt(ref1X, ref1Y);
referencePoint2 = new Punkt(ref2X, ref2Y);
}
catch (Exception e)
{
}
}
private void btConvert_Click(object sender, EventArgs e)
{
if (convertPoints.Count == 2)
{
// Punkt 1
Punkt p1 = convertPoints[0];
// Punkt 2
Punkt p2 = convertPoints[1];
// euklidische Länge - Big Cubes Detektorkoordinaten
double d1 = Funktionen.calculateEukDistance(p1, p2);
// euklidische Länge - Referenzkoordinaten
double d2 = Funktionen.calculateEukDistance(referencePoint1, referencePoint2);
// Verhältnis zur Umrechnung der Koordinaten
double relation = d1 / d2;
// Mittelpunkte laden
List<Punkt> dataCenters = new List<Punkt>();
String line;
using (StreamReader sr = new StreamReader(output_corners))
{
while ((line = sr.ReadLine()) != null)
{
line = line.Replace('.', ',');
String[] split = line.Split(';');
Punkt point = new Punkt(Convert.ToDouble(split[0]),
Convert.ToDouble(split[1]));
dataCenters.Add(point);
}
}
// Umrechnung auf Millimeter
List<Punkt> centerMilli = new List<Punkt>();
for (int i = 0; i < dataCenters.Count; i++)
{
Punkt point = new Punkt(dataCenters[i].getX() / relation,
dataCenters[i].getY() / relation);
centerMilli.Add(point);
}
dataCenters.Clear();
dataCenters = null;
Punkt p1Milli = new Punkt(p1.getX() / relation,
p1.getY() / relation);
Punkt p2Milli = new Punkt(p2.getX() / relation,
p2.getY() / relation);
// An Roboterkoordinaten anpassen
List<Punkt> rPoints = Funktionen.transformCoordinates2P(p1Milli,
p2Milli, referencePoint1, referencePoint2, centerMilli);
// speichern der transformierten Punkten
using (StreamWriter sw = new StreamWriter(transOutput))
{
for (int i = 0; i < rPoints.Count; i++)
{
line = Convert.ToString(rPoints[i].getX()) + ";"
+ Convert.ToString(rPoints[i].getY());
sw.WriteLine(line);
line = "";
}
sw.Close();
}
// ins Klassenattribute verschieben
this.synPoints = rPoints;
Series series1 = new Series();
series1.Name = "Transformierte Mittelpunkte";
series1.ChartType = SeriesChartType.Point;
Series series2 = new Series();
series2.Name = "Referenzpunkte";
series2.ChartType = SeriesChartType.Point;
for (int i = 0; i < rPoints.Count; i++)
{
series1.Points.AddXY(rPoints[i].getX(), rPoints[i].getY());
}
series2.Points.AddXY(referencePoint1.getX(), referencePoint1.getY());
series2.Points.AddXY(referencePoint2.getX(), referencePoint2.getY());
scatterPlotTrans.Series.Clear();
scatterPlotTrans.Series.Add(series1);
scatterPlotTrans.Series.Add(series2);
MessageBox.Show("Punkte wurden transformiert.");
// Synchronisation (Datenaustausch) freischalten
btSync.Enabled = true;
}
else
{
MessageBox.Show("Zu wenig oder zu viele Referenzpunkte: Bitte führen Sie die Mittelpunkts" +
"berechnung erneut mit anderen Größe aus");
}
}
// Mittelpunktberechnung aufrufen
private void btCenter_Click(object sender, EventArgs e)
{
// Parallelisiertes Rechnen
Parallelisierung parallelisierung = new Parallelisierung(maxAreaCentering,
minAreaCentering, rangeCentering, maxAreaConverting, minAreaConverting,
rangeConverting, radius, groupSize);
List<Punkt> corners = new List<Punkt>();
string line;
try
{
using (StreamReader sr = new StreamReader(input_corners))
{
while ((line = sr.ReadLine()) != null)
{
line = line.Replace('.', ',');
String[] split = line.Split(';');
Punkt point = new Punkt(Convert.ToDouble(split[0]), Convert.ToDouble(split[1]));
corners.Add(point);
}
}
} catch (Exception ex){}
// Gruppen bilden
parallelisierung.setCorners(corners);
parallelisierung.createGroups();
// Berechnung der Mittelpunkte
parallelisierung.calculateCenters(3);
// speichern der Mittelpunkte
parallelisierung.exportCenters(output_corners);
// lese Ergebnis ein
List<double[]> dataCenters = new List<double[]>();
using (StreamReader sr = new StreamReader(output_corners))
{
while ((line = sr.ReadLine()) != null)
{
line = line.Replace('.', ',');
String[] split = line.Split(';');
double[] tmp = new double[2];
tmp[0] = Convert.ToDouble(split[0]);
tmp[1] = Convert.ToDouble(split[1]);
dataCenters.Add(tmp);
}
}
// lese Referenz ein (Eckdaten)
List<double[]> dataCorners = new List<double[]>();
using (StreamReader sr = new StreamReader(input_corners))
{
while ((line = sr.ReadLine()) != null)
{
line = line.Replace('.', ',');
String[] split = line.Split(';');
double[] tmp = new double[2];
tmp[0] = Convert.ToDouble(split[0]);
tmp[1] = Convert.ToDouble(split[1]);
dataCorners.Add(tmp);
}
}
// Erstellen des Scatter Plots
// Ecken
Series series1 = new Series();
series1.Name = "Corner Points";
series1.ChartType = SeriesChartType.Point;
// Mittelpunkte
Series series2 = new Series();
series2.Name = "Center Points";
series2.ChartType = SeriesChartType.Point;
// Mittelpunkte - Konvertierung
Series series3 = new Series();
series3.Name = "Center Big Cubes";
series3.ChartType = SeriesChartType.Point;
scatterPlot.Series.Clear(); // leert alle alten Reihen
// Series 1 & 2
for (int i = 0; i < dataCorners.Count(); i++)
{
series1.Points.AddXY(dataCorners[i][0], dataCorners[i][1]);
}
for (int i = 0; i < dataCenters.Count(); i++)
{
series2.Points.AddXY(dataCenters[i][0], dataCenters[i][1]);
}
scatterPlot.Series.Add(series1);
scatterPlot.Series.Add(series2);
// Series 3
List<Punkt> data = parallelisierung.getCentersConvert();
for (int i = 0; i < data.Count; i++)
{
series3.Points.AddXY(data[i].getX(), data[i].getY());
convertPoints.Add(data[i]);
}
scatterPlot.Series.Add(series3);
// schaltet das Synchronisieren frei
btConvert.Enabled = true;
progressBar.MarqueeAnimationSpeed = 0;
progressBar.Visible = false;
}
