/// <summary>erzeugt einen Neuen Punkt, der die Differenzen a-b enthält.
/// Unterschiede in Strings werden als Text 'abc != CDE' angezeigt</summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static ClassCADdyPunkt operator -(ClassCADdyPunkt a, ClassCADdyPunkt b)
{
ClassCADdyPunkt ergebnis = new ClassCADdyPunkt();
if (a == b)
{
ergebnis.Punktnummer = a.Punktnummer;
}
else
{
if (a.Punktnummer != b.Punktnummer)
{
ergebnis.Punktnummer = a.Punktnummer + " <> " + b.Punktnummer;
}
else
{
ergebnis.Punktnummer = a.Punktnummer;
}
ergebnis._rechtswert = a._rechtswert - b._rechtswert;
ergebnis._hochwert = a._hochwert - b._hochwert;
ergebnis._hoehe = a._hoehe - b._hoehe;
if (a.Code != b.Code)
{
ergebnis.Code = a.Code + " <> " + b.Code;
}
if (a.Bemerkung != b.Bemerkung)
{
ergebnis.Bemerkung = a.Bemerkung + " <> " + b.Bemerkung;
}
}
return(ergebnis);
}
public ClassCADdyPunkt getAsCopy()
{
ClassCADdyPunkt result = new ClassCADdyPunkt(_punktnummer, _rechtswert, _hochwert, _hoehe, _code);
result._bemerkung = _bemerkung;
result.lineNumber = lineNumber;
return(result);
}
/// <summary>Trennt die Punkte aus dem angegebenen Text</summary>
/// <param name="settings"></param>
/// <param name="editor"></param>
public void getPointsFromEditor(Settings settings, IScintillaGateway editor)
{
punkte.Clear();
if (editor != null)
{
Int32 countLines = editor.GetLineCount();
for (Int32 lc = 0; lc < countLines; lc++)
{
String cuLine = editor.GetLine(lc);
// Auch Excel Splitbar machen ;-)
cuLine = cuLine.Replace('\t', ' '); // Tab durch Leerzeichen ersetzten
cuLine = cuLine.Replace(',', settings.Decimalseperator[0]); // , durch . ersetzten
String[] split = ClassStringTools.GetFieldsManyDelimiters(cuLine, ' ', true);
if (split != null)
{
if (split.Length >= 4) // mind PNR R H E
{
ClassCADdyPunkt newPoint = new ClassCADdyPunkt();
{
newPoint.Punktnummer = ClassStringTools.trimToEmpty(split[settings.PointName_Column - 1]);
if (settings.PointName_ToUpper)
{
newPoint.Punktnummer = newPoint.Punktnummer.ToUpper();
}
if (!ClassStringTools.IsNullOrWhiteSpace(newPoint.Punktnummer))
{
Double temp = Double.NaN;
if (ClassConverters.StringToDouble(split[settings.Koord_RW_E_Column - 1], out temp))
{
newPoint.Rechtswert = temp;
if (ClassConverters.StringToDouble(split[settings.Koord_HW_N_Column - 1], out temp))
{
newPoint.Hochwert = temp;
if (ClassConverters.StringToDouble(split[settings.Koord_Elev_Column - 1], out temp))
{
newPoint.Hoehe = temp;
newPoint.LineNumber = lc;
if (split.Length >= 5)
{ // code
newPoint.Code = ClassStringTools.trimToEmpty(split[settings.Koord_Code_Column - 1]);
if (split.Length >= 6)
{ // code
newPoint.Bemerkung = ClassStringTools.trimToEmpty(split[settings.Koord_Descript_Column - 1]);
}
}
punkte.Add(newPoint);
}
}
}
}
}
}
}
}
}
hasPunkte = punkte.Count > 0;
}
public void prepare()
{
dstPoints.sortBy(enPointColumn.colPointnumber);
matchPoints.Clear();
foreach (ClassCADdyPunkt dstPoint in dstPoints.Punkte)
{
ClassCADdyPunkt srcPoint = srcPoints.getPointByName(dstPoint.Punktnummer);
if (srcPoint != null)
{
ClassTransformPointPair matchPoint = new ClassTransformPointPair(srcPoint, dstPoint);
matchPoints.Add(matchPoint);
}
}
}
/// <summary>Gibt den Punkt mit dem namen zurück</summary>
/// <param name="name"></param>
/// <returns></returns>
public ClassCADdyPunkt getPointByName(String name)
{
ClassCADdyPunkt result = null;
foreach (ClassCADdyPunkt item in Punkte)
{
if (name.Equals(item.Punktnummer))
{
result = item;
break;
}
}
return(result);
}
/// <summary>Vergleicht a mit b delta = b-a</summary>
/// <param name="srcPoint"></param>
/// <param name="desPoint"></param>
/// <param name="decimalesCoord"></param>
/// <param name="decimalesRiwi"></param>
public ClassTransformPointPair(ClassCADdyPunkt srcPoint, ClassCADdyPunkt desPoint)
{
if (srcPoint.Punktnummer.Equals(desPoint.Punktnummer))
{
this.srcPoint = srcPoint;
this.destPoint = desPoint;
punktnummer = srcPoint.Punktnummer;
bUsePoint = true;
bUseZ = true;
}
else
{
throw new Exception("Punkt a ist nicht Punkt b (Punktnummer nicht identisch!)");
}
}
public void calcTransformation()
{
transfPoints.clear();
foreach (ClassCADdyPunkt srcPoint in srcPoints.Punkte)
{
if (!usedMatchPoints.Contains(srcPoint.Punktnummer.ToLower()))
{
ClassCADdyPunkt transform = srcPoint.getAsCopy();
transform.Rechtswert = X0 - (o * srcPoint.Hochwert) + (a * srcPoint.Rechtswert);
transform.Hochwert = Y0 + (a * srcPoint.Hochwert) + (o * srcPoint.Rechtswert);
transform.Hoehe = srcPoint.Hoehe + translZ;
transfPoints.Punkte.Add(transform);
}
}
}
/// <summary>Berechnet eine Koordinatentranslation und Koordinatenrotation </summary>
/// <param name="rPName">Wird im Rotierten System (0,0,0)</param>
/// <param name="dPName">Wird im rotierten System polar(direction,Distanz rPoint zu dPoint)</param>
/// <param name="direction"></param>
/// <param name="setRPointZTo0">Soll auch Z auf Null gesetzt werden?</param>
public Boolean rotateCoords(String rPName, String dPName, Double direction, Boolean setRPointZTo0)
{
Boolean result = false;
ClassCADdyPunkt rPoint = getPointByName(rPName);
ClassCADdyPunkt dPoint = getPointByName(dPName);
if ((rPoint != null) && (dPoint != null))
{
Double translRW = -rPoint.Rechtswert;
Double translHW = -rPoint.Hochwert;
Double translZW = -rPoint.Hoehe;
if (!setRPointZTo0)
{
translZW = 0.0;
}
// 1. Translation
foreach (ClassCADdyPunkt item in Punkte)
{
item.Rechtswert += translRW;
item.Hochwert += translHW;
item.Hoehe += translZW;
}
rPoint = getPointByName(rPName);
dPoint = getPointByName(dPName);
if ((rPoint != null) && (dPoint != null))
{
Double dirOld = rPoint.gonRiwiTo(dPoint);
Double dirDelta = direction - dirOld;
// Richtung +- drehen, mathematisch ist linksrum
Double dirRad = -1.0 * dirDelta / 200 * Math.PI;
//2. Rotation
foreach (ClassCADdyPunkt item in Punkte)
{
Double x = item.Rechtswert;
Double y = item.Hochwert;
item.Rechtswert = x * Math.Cos(dirRad) - y * Math.Sin(dirRad);
item.Hochwert = x * Math.Sin(dirRad) + y * Math.Cos(dirRad);
}
result = true;
}
}
return(result);
}
/// <summary>Vergleicht diesen Punkt mit Punkt b
/// 'unscharf' d.h. alle texte werden mit ToUpper() verglichen,
/// alle Zahlen nur auf 0,000 verglichen</summary>
/// <param name="b">der zu vergleichende Punkt</param>
/// <returns>True = beide gleich | False = nicht gleich</returns>
public bool FuzzyEqual(ClassCADdyPunkt b)
{
// beide null oder beide die gleiche Instance
if (System.Object.ReferenceEquals(this, b))
{
return(true);
}
//Punktnummer
if (!ClassFuzzyLogic.FuzzyEqual(this._punktnummer, b._punktnummer))
{
return(false);
}
// Hochwert
if (!ClassFuzzyLogic.FuzzyEqual(this._hochwert, b._hochwert, 3))
{
return(false);
}
// Rechtswert
if (!ClassFuzzyLogic.FuzzyEqual(this._rechtswert, b._rechtswert, 3))
{
return(false);
}
// Höhe
if (!ClassFuzzyLogic.FuzzyEqual(this._hoehe, b._hoehe, 3))
{
return(false);
}
// Code
if (!ClassFuzzyLogic.FuzzyEqual(this._code, b._code))
{
return(false);
}
// Bemerkung
if (!ClassFuzzyLogic.FuzzyEqual(this._bemerkung, b._bemerkung))
{
return(false);
}
// Beide gleich
return(true);
}
/// <summary>Vergleicht a mit b delta = b-a</summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="decimalesCoord"></param>
/// <param name="decimalesRiwi"></param>
public ClassCADdyPointCompare(ClassCADdyPunkt a, ClassCADdyPunkt b, Int32 decimalesCoord, Int32 decimalesRiwi)
{
if (a.Punktnummer.Equals(b.Punktnummer))
{
this.decimalesCoord = decimalesCoord;
this.decimalesRiwi = decimalesRiwi;
point1 = a;
point2 = b;
punktnummer = a.Punktnummer;
ClassCADdyPunkt delta = b - a;
deltaRW = delta.Rechtswert;
deltaHW = delta.Hochwert;
deltaZ = delta.Hoehe;
delta2D = delta.length();
delta3D = delta.distance();
deltaRiwi = delta.gonRiwi();
delta = null;
}
else
{
throw new Exception("Punkt a ist nicht Punkt b (Punktnummer nicht identisch!)");
}
}
/// <summary>Berechnet den RIWI in Gon aus dem Delta</summary>
/// <param name="target"></param>
/// <returns></returns>
public Double gonRiwiTo(ClassCADdyPunkt target)
{
ClassCADdyPunkt delta = target - this;
if (delta.Hochwert == 0.0)
{
if (delta.Rechtswert > 0.0)
{
return(100.0);
}
else if (delta.Rechtswert < 0.0)
{
return(300.0);
}
return(Double.NaN);
}
if (delta.Rechtswert == 0.0)
{
if (delta.Hochwert > 0.0)
{
return(0.0);
}
return(200.0);
}
Double ergebnis = Math.Atan(delta.Rechtswert / delta.Hochwert) * (200.0 / Math.PI);
// Quadrantenkorrektur
if (delta.Hochwert < 0.0)
{
ergebnis += 200.0;
}
else if ((delta.Rechtswert < 0.0) && (delta.Hochwert >= 0.0))
{
ergebnis += 400.0;
}
return(ergebnis);
}
