Artikel
Beobachtungsberichte
Equipment
Literatur
Objektliste
Links
Das bin ich
Impressum
|
Home Artikel Beobachtungsberichte Equipment Literatur |
|
Projekte Objektliste Links Das bin ich Impressum |
Stern- und Objektkataloge gibt es eine Menge. Angefangen von einigen Basisdaten bis hin zu ausführlichen Objektdaten sind in solchen Katalogen eine Menge Informationen enthalten. Die wichtigsten Informationen sind der Name und die Koordinatenangabe sowie die Helligkeitsangabe. Häufig findet man noch die Größenangaben, den Objekttyp, weitere Helligkeitsangaben, das Entfernungsmodul, die galaktischen Koordinaten, ...
Was mir aufgefallen ist (und ich für das beobachtende Volk etwas störend empfand): Da fehlt irgendwie die Angabe des Sternbildes, in dem der Stern oder das Objekt drin ist, hat man doch mit dieser Angabe direkt eine Vorstellung, wo das Objekt zu suchen ist. Also hab ich mir gedacht, das ich eine kleines Stück'chen Software schreibe, mit dem ich aus der Koordinatenangabe das Sternbild bestimme.
Die International Astronomical Union (IAU) hat die Grenzen der Sternbilder im letzten Jahrtausend verbindlich festgelegt. Insgesamt sind es 88 an der Zahl. Die festgelegten Sternbilder können über die IAU eingesehen werden oder als Datenpaket heruntergeladen werden (siehe Links unten).
Zur Bestimmung des Sternbildes gibt es mehrere Möglichkeiten. Eine dieser Methoden möchte ich
hier vorstellen und als implementierter Algorithmus zum Download anbieten.
Im Bild rechts sei mal eine Grenze eines x-beliebigen Sternbildes (rot) eingezeichnet, das Objekt, zu dem das Sternbild ermittelt werden soll, ist mit dem Kreuz (blau) dargestellt. Nun kann man sich eine gedachte Linie, ausgehend von dem Objekt (blaues Kreuz), vorstellen, die weit ins Nirwana führt. Wenn jetzt das Objekt innerhalb des Sternbildes liegt, so müsste diese gedachte Linie die Grenze des Sternbildes einmal schneiden. Ist das Objekt außerhalb des Sternbildes, so wird die Linie die Grenzen entweder gar nicht schneiden oder die gedachte Linie geht durch das Sternbild durch, dann wird es zwei Schnittpunkte (einmal Eintritt, einam Austritt) geben. Allgemeiner gesagt, wenn die Anzahl der Schnittpunkte ungerade ist, dann liegt das Objekt im Sternbild, ist die Anzahl der Schnittpunkte gerade, dann liegt das Objekt außerhalb des Sternbildes.
Zwei Dinge sind bei der gedachten Linie wichtig: Zum einen muss der Startpunkt der gedachten Linie in dem Objekt (also der Koordinate des Objektes) beginnen. Der Startpunkt der gedachten Linie ist ja dann klar. Zum anderen muss der Endpunkt der gedachten Linie außerhalb des Gültigkeitsbereichs liegen, also nicht innerhalb irgend eines anderen Sternbildes. Die Koordinaten der Sternbilder sind i.d.R. im äquatorialen Koordinatensystem gegeben, womit die Werte von [RA]=(0°..360°) bzw. [RA]=(0h..24h) und [DEC]=(-90°..+90°) gehen. Einen Punkt außerhalb ist also auch leicht zu finden.
Die Sternbildgrenzen sind i.d.R. als umrandende Punkte gegeben (Anzahl = n). Verbindet man diese Punkte, so erhält man die ganze Umrandung des Sternbildes. Die einzelnen Verbindungen zwischen jeweils zwei Punkten kann man als Gerade ansehen. Es ergeben sich also n Geraden, die die Grenzen des Sternbildes beschreiben (P1->P2, P2->P3, ...Pn-1->Pn, Pn->P1). Die gedachte Linie kann man auch als eine Gerade ansehen.
Eine Gerade ist hier zwar nicht korrekt, da eine Gerade eigentlich eine unendliche Länge hat. Betrachtet werden aber nur die Abschnitte zwischen den beiden beschreibenden Punkten, also die Strecke Pn->Pn+1.
Die Geraden kann allgemein folgendermaßen beschrieben werden:
y = m*x + b
y: Funktionswert
x: Argument
m: Steigung der Geraden
b: Schnittpunkt mit der Y-Achse
Da wir immer zwei Punkte haben, mit denen die Gerade bestimmt wird, ist es sinnvoll, die Zwei-Punkte-Gleichung zu benutzen:
y - y1 = (y2-y1)/(x2-x1) * (x - x1)
y: Funktionswert
x: Argument
x1: X-Wert von Punkt 1
x2: X-Wert von Punkt 2
y1: Y-Wert von Punkt 1
y2: Y-Wert von Punkt 2
Durch Vergleich mit der ersten Geradengleichung erhält man:
m = (y2-y1)/(x2-x1)
b = y1 - m * x1
Um den Schnittpunkt von zwei Geraden zu bestimmen, kann man die beiden Geradengelichungen gleichsetzen (y = m1*x+b1 = m2*x+b2), etwas herumrechnen, und man erhält den Schnittpunkt:
xS = (b2 - b1) / (m1 - m2)
yS = ((m1 * b2) - (m2 * b1)) / (m1 - m2)
xS: X-Koordinate der Schnittpunkts
yS: Y-Koordinate der Schnittpunkts
Das herumrechnen erspare ich mit hier und verweise auf die Links unten.
Bei der Bestimmung, ob ein Objekt in einem Sternbild liegt, ging es ja darum, die Anzahl
Schnittpunkte der gedachten Linie mit den Sternbildgrenzen zu ermitteln. Da sowohl die gedachte
Linie als auch die Sternbildgrenzen als Gerade angesehen wird, muss man jeweils den
Schnittpunkt zwischen den Geraden bestimmen, also einfach iterativ die
Schnittpunkte der gedachten Linie mit allen n Geraden der Sternbildumrandung bestimmen.
Alle Angaben sind als Punkte verfügbar, aus denen wir die benötigten Geraden bestimmen können. Im Bild rechts ist die gedachte Gerade (grün) eingezeichnet, die einzelnen Abschnitte der Sternbildgrenzen (rot, 1..9) dargestellt. Weiterhin sind die Schnittpunkte der gedachten Gerade mit einigen Sternbildgrenzen (blau umrandet, 1..4) zu sehen. Die entsprechenden Berechnungen der Geraden (Zwei-Punkte-Form, Schnittpunkt der Geraden) sind nun klar, es kann ans Berechnen gehen.
Die Daten der Sternbildgrenzen liegen als Textdatei vor, in jeder Zeile eine Koordinate mit Angabe, zu welchem Sternbild dieser Grenzpunkt gehört. Hier ein kleiner Auszug:
113.308239 +35.2360916 LYN I
112.560719 +35.2445297 LYN O
112.577898 +36.2444344 LYN I
112.595529 +37.2443314 LYN I
Die erste Spalte enthält die Rektaszension (10 Zeichen), die zweite Spalte die Deklination (11 Zeichen) und die dritte Spalte das Kürzel des Sternbides (4 Zeichen, jawohl 4 Zeichen). Die Datei lese ich zeilenweise ein und splitte die drei Spalten auf. Das Kürzel ist der Key einer assoziativen Liste (Hashtable), die Koordinatenangabe verpacke ich in einen Datencontainer namens Coordinate. Der Value der assoziativen Liste ein eine Collection vom Typ Coordinate, in den ich die Koordinaten einfach beim Lesen anhänge. Diese Datenstruktur wird nur einmal eingelesen und für jede Suchanfrage immer wieder benutzt.
Jetzt kommt der Holzhammer. Beim Suchen prüfe ich zu der zu suchenden Koordinate jedes Sternbild einzeln. Das heißt, ich mache für die 88 Sternbilder jeweils einen Test, ob die gegebene Koordinate (ra, dec) in diesem Sternbild liegt. Wenn alles funktioniert, wird die Suche bei genau einem Sternbild fündig.
Hier ein kleiner Codeauszug für die Suche:
///
/// Sucht das Sternbild, in dem die gegebenen Koordinaten liegen.
///
/// RA-Koordinate (0°..360°).
/// DEC-Koordinate (-90°..+90°).
/// Name des Sternbild, in dem die Koordinate liegt (in/out).
/// true, wenn das Sternbild gefunden wurde.
private bool FindeKonstellation(double ra, double dec, ref string name)
{
bool gefunden = false;
Coordinate koordinate = new Coordinate(ra,dec);
int anzahlSchnittpunkte = 0;
if (LadeSternbildGrenzen())
{
foreach (string kuerzel in _grenzen.Keys)
{
anzahlSchnittpunkte = TestKoordinate(koordinate,
(Collection)_grenzen[kuerzel]);
if ((anzahlSchnittpunkte % 2) == 1)
{
name = abbreviation;
gefunden = true;
}
}
}
return gefunden;
}
Das ganze ist in C# geschrieben.
Im obigen Bild sind die gedachte Linie vom Objekt ins Nirwana sowie die Sternbildgrenzen (1..9, rot) zu sehen. Weiterhin sind die Schnittpunkte eingezeichnet (1..4, blau). Hierzu gibt es einiges zu beachten (bedenke, wir rechnen mit Geraden, die unendlich lang sind, nicht mit Vektoren o.ä.). Der Schnittpunkt 2 (blau) ist ein echter Schnittpunkt, da dieser auf der Begrenzungslinie 4 (rot) liegt. Die Schnittpunkte 1, 3, 4 (blau) sind unechte Schnittpunkte, da diese zwar die (verlängerte) Gerade der Begrenzungslinien 2, 3, 6 (rot) schneiden, der Schnittpunkt aber nicht innerhalb der gegebenen Begrenzungslinie, sondern außerhalb dieser Begrenzungslinie auf der Verlängerung liegt.
Aber zuerst mal zur Berechnung der Geraden und des Schnittpunktes. Hierzu iteriere ich über alle Punkte der Sternbildbegrenzung und extrahiere jeweils zwei nebeneinanderliegende Punkte (coord1, coord2):
for (int i = 0; i < points - 1; ++i)
{
Coordinate coord1 = sternbildgrenze[i];
Coordinate coord2 = sternbildgrenze[i + 1];
:
:
}
Aus diesen beiden Punkten berechne ich die Parameter m1 und b1 der ersten Gerade:
// erste Gerade m1*x+b1 aus c1 und c2
m1 = 10000000000.0;
if (coord1.Rektaszension != coord2.Rektaszension)
{
m1 = (coord2.Deklination - coord1.Deklination)
/ (coord2.Rektaszension - coord1.Rektaszension);
}
b1 = coord1.Deklination - coord1.Rektaszension * m1;
Für die zu suchende Koordinate und die Referenzkoordinate bestimme ich genau so die Parameter m2 und b2 der gedachten Gerade/Linie. Diese Parameterbestimmung muss ja nur einmal erfolgen, da diese Gerade für alle durchzuführenden Test dieselbe ist, also auch die Parameter immer gleich sind.
// zweite Gerade m2*x+b2 aus Such- und Referenzpunkt
m2 = 9999999999.0;
if (suche.Rektaszension != _referenzpunkt.Rektaszension)
{
m2 = (_referenzpunkt.Deklination - suche.Deklination)
/ (_referenzpunkt.Rektaszension - suche.Rektaszension);
}
b2 = suche.Deklination - suche.Rektaszension * m2;
Warum ist eigentlich das komische
if (a.Rektaszention != b.Rektaszension)da drin? Nun, bei der Bestimmung der Steigung der Geraden wird ja Δdec / Δra gerechnet. Damit keine Division durch Null dem Programm ein jähes Ende bereitet, wird einfach die Division durch Null ausgeschlossen. Da ein Δra von Null eine Unendliche Steigung bedeutet, wird einfach ein sehr hoher Wert für die Steigung (9999999999.0) vorbelegt, der anstelle der Division durch Null benutzt wird (das ist Numerisch schon korrekt so).
Hat man die Parameter m1, b1 und m2, b2 der beiden Geraden erst mal ermittelt, ist die Schnittpunktsbestimmung mit o.a. Formeln ja kein Problem mehr.
// Schnittpunkt
sx = (b2 - b1) / (m1 - m2);
sy = ((m1 * b2) - (m2 * b1)) / (m1 - m2);
Huch, hier ist ja auch eine Division durch 0 möglich.
Bleibt als nächstes noch der Test auf einen gültigen oder ungültigen Schnittpunkt. Da die Geraden in den seltensten Fällen exakt Parallel zueinander sind, wird erwartungsgemäß immer ein Schnittpunkt berechnet. Der Schnittpunkt muss ja auf den definierten Abschnitten der Geraden sein, damit er als gültig angesehen wird (ein Schnittpunkt auf der Verlängerung wird ja als ungültig angesehen). Anders ausgedrückt, der Schnittpunkt sx/sy muss in den Grenzen der gegebenen Punkte Pn, Pn+1, PObjekt und PNirwana sein. Das ganze erfolgt durch einen einfachen Vergleich:
// ist der Schnittpunkt im Gültigkeitsbereich?
if ((sx >= raMin1) && (sx <= raMax1) && (sy >= decMin1) && (sy <= decMax1)
&& (sx >= raMin2) && (sx <= raMax2) && (sy >= decMin2) && (sy <= decMax2))
{
++anzahlSchnittpunkte;
}
So hat man also die Anzahl der Schnittpunkte bestimmt und kann nun sagen, ob die gesuchte Koordinate des Objektes in dem Sternbild liegt (die Anzahl musste ja ungerade sein).
Ja, die gibt es auch noch. Aber dazu lieber mehr beim nächsten mal...
Das nicht ganz fertige Programm (siehe Schwächen) mit den Sternbildgrenzen als Textdatei gibt es hier als aufführbares Executable für Windows im Zip zum Download. Den Quellcode findet man dann hier. Aber nicht zu hart urteilen, es ist ein Demo.
Stand: 28. Dezember 2009