Dieser Artikel wurde maschinell übersetzt.

Touch and Go

Nachthimmel mit Windows Phone entdecken

Charles Petzold

In die Titelei der klassischen Geschichte, "Die Kopernikanische Revolution" (Harvard University Press, 1957), Thomas S. Kuhn beschwört eine Welt vor vielen Jahrhunderten, in der Menschen eine intime Vertrautheit mit Nachthimmel hatten. Noch nicht unterliegen die dauerhafte Beleuchtung der künstlichen Beleuchtung, diese Beobachter aus erster Hand erlebt wie die Kuppel von Sternen während der Nacht in einem langen Bogen um den Nord-Stern zu drehen scheint, und wie die Konfiguration der Stars bei Sonnenauf- und-Untergang verläuft durch einen jährlichen Zyklus der 12 Schritte des Tierkreises.

Sie beobachtet auch, wie mehrere Stars nicht dieses gleichen Muster folgen. Diese Seltsamkeiten schien das Panorama der Fixsterne, manchmal sogar umkehren Bewegung relativ zu den himmlischen Dome durchwandern. Diese Ausnahmen von dieser Grundregel sind noch von dem altgriechischen Wort für Wanderer bekannt: Πλανήτης, oder Planeten.

Der Versuch, zu verfolgen und Vorhersagen, die Bewegung dieser Planeten war der Beginn der berühmtesten Umwälzung in der Geschichte der Wissenschaft, die letztlich zu den Sturz des primitiven Kosmologie und die Vertreibung von der Erde aus dem Zentrum des Universums. Zur gleichen Zeit, die die Menschheit ein viel besseres Verständnis der seinen Platz im Kosmos gewonnen, begann es auch, diese besondere Beziehung zu den Nachthimmel zu verlieren.

Verwendung von AstroPhone

Heutzutage haben die meisten von uns nicht die Zeit, die Geduld oder die Ruhe des Geistes zu starren auf den Nachthimmel lange genug zu bekommen ein Gefühl für seine zyklische Muster oder die Wanderung der Planeten zu erkennen. Stattdessen setzen wir auf Sternkarten oder computergestützte astronomischen Tools um zu helfen.

Diese Spalte beschreibt meine eigenen bescheidenen Beitrag zum Genre, ein kleines Programm für Windows Phone mit dem dummen Namen AstroPhone. Der herunterladbare Quellcode für die Anwendung besteht aus einem XNA-Programm namens AstroPhone und eine Bibliothek mit dem Namen Petzold.Astronomy, die Zahlenverarbeitung und den Daten enthält.

Dieses Programm hat keine Benutzeroberfläche überhaupt außer der Aufwand erforderlich, um die Rückseite des Telefons auf eine Position in den Nachthimmel zu zeigen. Das Telefon-Bildschirm zeigt dann die Sterne, Sternbilder und Planeten, die dort gelegen. Abbildung 1 zeigt einen typischen Bildschirm, am 15:45 Lokalzeit am 15. Juli 2012, in der Region von New York City, mit dem Telefon in westlicher Richtung statt.

Abbildung 1 typische AstroPhone Bildschirm

Die grüne Linie ist der Horizont mit Kompass Punkte gekennzeichnet. (Beachten Sie die W für West). Die rote Linie ist die Ekliptik, die das Flugzeug durch das alle Planeten rund ist, mit Teilstrichen jedes 15 ° umkreisen. Jupiter und Venus wegen sehen Sie setzen Sie innerhalb der nächsten 90 Minuten oder so. Auch sichtbar – auf dem Bildschirm, wenn nicht in der Mitte-­am Nachmittag Himmel — ist das Sternbild des Stiers.

Um die Sterne und Planeten korrekt auf dem Bildschirm zu positionieren, muss das Programm Informationen aus mehreren Quellen kombiniert:

• Daten und Algorithmen, die Position der Sterne und Planeten (in den folgenden Abschnitten beschrieben) abzuleiten.
• Das aktuelle Datum und die Uhrzeit in dieser Algorithmen verwenden.
• Das Telefon GPS, damit das Programm weiß, wo sich das Telefon befindet sich auf der Oberfläche der Erde.
• Das Telefon-Bewegungssensor, damit das Programm weiß, wie das Telefon im 3D-Raum ausgerichtet ist und somit Teil des celestialen Sphäre es wird in Richtung gezeigt.

Aufgrund seiner starken Abhängigkeit von der Telefon Sensoren läuft dieses Programm nicht auf dem Windows Phone-Emulator.

In einigen früheren Ausgaben dieser Rubrik habe ich einige der Konzepte für die Verwendung der Bewegungsmelder und konvertieren diese Informationen in verschiedenen Koordinatensystemen diskutiert. Jene früheren Artikel sind auf der MSDN Magazin-Website alle verfügbaren (bit.ly/NoMc8R). Viel von meinem Ansatz positionelle Astronomie basiert auf dem Buch von Jean Meeus, "Astronomischen Algorithmen" (Willmann-Bell, 1998), obwohl ich manchmal etwas vereinfachte Berechnungen benutzt habe, und ich mache keine Garantien, dass ich alle Fehler beseitigt habe.

Sterne und Sternbilder

Wenn Sie einen bestimmten Stern auf Wikipedia nachschlagen, finden Sie seine Lage ist in Bezug auf zwei Zahlen gegeben — eine Rektaszension und eine Deklination. Beteigeuze hat beispielsweise eine Rektaszension von 5 Stunden, 55 Minuten und 10.3053 Sekunden, und eine Deklination von 7°, 24 Minuten, 25.426 Sekunden. Diese Position ist relativ zum äquatorialen Koordinatensystem, in dem Äquator der Erde das Universum in positive eckig Deklinationen im Norden und negative eckig Deklinationen im Süden teilt. (Polaris, auch bekannt als das North Star, hat eine Deklination von fast 90°).

Traditionell wird in Stunden, mit jeder Stunde entspricht 15 ° Rektaszension gemessen. Die gleiche Richtung wie Norden bei Mitternacht nach lokaler Zeit auf das Datum der Frühlingstagundnachtgleiche entspricht einer Rektaszension von NULL. Weil die Ebene des Äquators der Erde etwa konstant, während des ganzen Jahres (und im Laufe der Jahrhunderte bleibt), und weil die Sterne so weit entfernt sind, sie werden als die gleichen äquatorialen Koordinaten unabhängig von der Position der Erde haben. Diese äquatorialen Koordinaten für Stars für eine bestimmte Epoche (z. B. im Jahr 2000) angegeben sind, und kleine jährliche Anpassungen können angewendet werden, um die leichte Bewegung der Sterne zu berücksichtigen.

Viele Sterne Kataloge vorhanden, die meisten davon mit vielen mehr Sterne, als ich in meinem Programm anzuzeigen wollte. Ich beschloss, die aktualisierte Version eines Katalogs zu verwenden, die vor mehr als 100 Jahren entstanden: Bright-Star-Katalog, 5. überarbeitete Auflage, die ich von einer FTP-Site von Straßburg astronomisches Rechenzentrum gepflegt zu erhalten (bit.ly/T51GE5).

Auch dieser Katalog zur Verfügung, viel mehr Informationen als ich brauchte und auch etwas weniger. Zum größten Teil wollte ich mein Programm nur die großen Stars, 88 Norm Konstellationen in der modernen Astronomie verwendet zugeordnet angezeigt. Das war einfach genug, weil die Sterne Bezeichnungen (zuerst entwickelt von Johann Bayer vor mehr als 400 Jahren), die dem Sternbild anzugeben haben, der Stern mit einer Abkürzung und einen einzigartigen griechischen Buchstaben gehört.

Aber ich wollte auch verbessern jede Konstellation mit diesen vertraut Leitungsverbindungen zwischen den Sternen, so dass Leo tatsächlich wie ein Strichmännchen Löwe aussehen würde. Verbindungslinien zwischen die Sternen in den Sternbildern sind nicht standard, und ich wusste nicht, des Sterne-Katalogs, die sie enthalten.

So dass ich sie mir selbst hinzugefügt. Ich schrieb ein kleines Windows Presentation Foundation (WPF)-Programm, das dem Bright Star Katalog abgerufen und angezeigt die Sterne aller 88 Sternbilder. Das Programm reagiert auf Mausklicks auf Paare von Sternen und die Ergebnisse aufgezeichnet. In der Regel ich Diagramme der Sternbilder auf Wikipedia, die der Internationalen Astronomischen Union und Himmel gutgeschrieben werden Verbindungslinien Grundlage & Teleskop-Magazin.

Das WPF-Programm konsolidierte Daten in eine Datei namens Constellations.xml, die Sie in das Datenverzeichnis von die Petzold.Astronomy-Bibliothek-Projekt finden. Jedes Sternbild-Tag enthält eine Auflistung von Star-Tags. Jeder Stern wird mit einer Zahl aus dem Bright Star Katalog identifiziert. Die Star-Tags in jeder Konstellation folgen dann eine Auflistung der Connector-Tags, die Linien zwischen Paaren von nummerierten Sternen zu definieren.

Die Planeten

Als auch primitive Stargazers realisiert ist die Position der Planeten viel komplexer als die von den Sternen. Die Planeten haben elliptische Bahnen um die Sonne, aber Unregelmäßigkeiten ergeben sich aus der gegenseitigen Gravitation Interaktion. Ein Algorithmus, um die Position eines Planeten zu einem bestimmten Zeitpunkt zu bestimmen ist oft als eine "Theorie" bekannt, und im Allgemeinen auf der Grundlage einer Fourier-Reihen.

Die planetarische Theorie habe ich heißt VSOP87, Variations Séculaires des Orbites Planétaires, 1987-Version, die vom Bureau des Longitudes in Paris verwaltet wird. Die Dateien mit den Daten eines Teils der VSOP87 sind auch im Datenverzeichnis des Projektes Petzold.Astronomy enthalten. Die VsopCruncher-Klasse führt die Berechnungen für jeden Planeten für einen bestimmten Punkt in der Zeit.

Die Positionen der Planeten werden in der Regel berechnet, in ekliptikale Koordinaten, aber mit der Sonne in der Mitte — d. h. heliozentrische anstatt geozentrischen. Für jeden Planeten umfassen diese Koordinaten:

• eine ekliptikale Länge, die von 0° bis 360° als Planeten geht macht eine komplette Umlaufbahn um die Sonne in seinem bestimmten
• eine Ekliptik-Breitengrad, die nahe bei Null ist, weil alle Planeten umkreisen die Sonne in etwa der gleichen Ebene
• einem Radius, der Abstand des Planeten von der Sonne.

Diese Koordinaten sind ideal für die Bewegung der Planeten um die Sonne zu plotten. Allerdings wollen Sie berechnen die Position des Planeten als von der Erde aus gesehen, ist es nützlich, diese Kugelkoordinaten in dreidimensionale rechtwinkligen Koordinaten zu konvertieren, wobei eines Planeten Stellung mit X angegeben wird, Werte Y und Z mit der Sonne, die Besetzung des Zentrum-Ursprungs an (0, 0, 0). Durch Subtraktion der rechteckig-Koordinate jedes Planeten von der rechteckig-Koordinate der Erde, Sie erhalten einen 3D Vektor von der Erde auf diesem Planeten, die dann in die Rektaszension und Deklination Werte einer Koordinate geozentrische ekliptikale umgewandelt werden kann — das gleiche Koordinatensystem verwendet für die Stars.

Bewegung des Mondes ist sehr viel komplexer als die der Sterne und Planeten, und hat als ein separater Fall behandelt werden. Ich habe nicht den Mond in dieser Version des Programms AstroPhone gehören. Außerdem wäre ich auf den Mond, ich fühle mich verpflichtet, die aktuelle Phase zu zeigen, und, die die Arbeit noch mehr erschweren würde.

Ketten von Berechnungen

Um die notwendigen Berechnungen auf methodische Weise definiert eine Hierarchie von Klassen:

CelestialBody
        Constellation
        Star
            SolarSystemBody
                Sun
                Planet
                    Earth

Die Sterne und Konstellation Klassen spielen auch doppelte Rollen als Deserialisierung Ziele der Constellations.xaml-Datei.

Wie im Abbildung 2, die CelestialBody-Klasse ist verantwortlich für Datenverarbeitung eine HorizontalCoordinate aus einer EquatorialCoordinate auf die geographische Lage der das Telefon und das aktuelle Datum und die Zeit. Die Nachfolgerklassen zu berechnen, dass die EquatorialCoordinate-Eigenschaft in der OnTimeChanged-Methode überschreibt.

Abbildung 2 Die Elternklasse CelestialBody

public abstract class CelestialBody
{
  // Only used internally
  private GeographicCoordinate Location { set; get; }
  // Set here, used by descendant classes
  protected Time Time { private set; get; }
  // Set by descendant classes, used here
  protected EquatorialCoordinate EquatorialCoordinate { set; private get; }
  // Set here, used external to library
  public HorizontalCoordinate HorizontalCoordinate { private set; get; }
  // Used externally to retain screen location
  public float ScreenX;
  public float ScreenY;
  // Called external to update HorizontalCoordinate
  public void Update(Time time, GeographicCoordinate location)
  {
    bool needsUpdate = false;
    if (!this.Time.Equals(time))
    {
      this.Time = time;
      needsUpdate = true;
      OnTimeChanged();
    }
    if (!this.Location.Equals(location))
    {
      this.Location = location;
      needsUpdate = true;
    }
    if (needsUpdate)
    {
      this.HorizontalCoordinate =
        HorizontalCoordinate.From(this.EquatorialCoordinate,
                                  this.Location, this.Time);
    }
  }
  // Overridden by descendant classes to update EquatorialCoordinate
  protected virtual void OnTimeChanged()
  {
  }
}

Die SolarSystemBody-Klasse Abbildung 3 berechnet die EquatorialCoordinate-Eigenschaft von einem seiner untergeordneten Klassen und die Planet-Klasse, in HeliocentricLocation-Vektor Abbildung 4, rechnet damit, dass HeliocentricLocation bei einem Aufruf der VsopCruncher basiert.

Abbildung 3 die SolarSystemBody-Klasse

public class SolarSystemBody : CelestialBody
{
  protected SolarSystemBody()
  {
  }
  protected SolarSystemBody(string name, Color color)
  {
    this.Name = name;
    this.Color = color;
  }
  public string Name { protected set; get; }
  public Color Color { protected set; get; }
  // Set by descendant classes, used here
  protected Vector3 HeliocentricLocation { set; private get; }
  protected override void OnTimeChanged()
  {
    // Calculate geocentric coordinates
    Vector3 bodyLocation = this.HeliocentricLocation -
                           Earth.Instance.HeliocentricLocation;
    EclipticCoordinate geocentricCoordinate =
      new EclipticCoordinate(bodyLocation);
    this.EquatorialCoordinate =
      EquatorialCoordinate.From(geocentricCoordinate, this.Time);
    base.OnTimeChanged();
  }
}

Abbildung 4 die Planet-Klasse

public class Planet : SolarSystemBody
{
  VsopCruncher vsop;
  public Planet(string strPlanetAbbreviation, 
    string name, Color color) :
    this(strPlanetAbbreviation)
  {
    this.Name = name;
    this.Color = color;
  }
  protected Planet(string strPlanetAbbreviation)
  {
    vsop = new VsopCruncher(strPlanetAbbreviation);
  }
  protected override void OnTimeChanged()
  {
    Angle latitude = Angle.FromRadians(vsop.GetLatitude(this.Time.Tau));
    Angle longitude = Angle.FromRadians(vsop.GetLongitude(this.Time.Tau));
    double radius = vsop.GetRadius(this.Time.Tau);
    this.HeliocentricLocation =
      new EclipticCoordinate(longitude, 
          latitude, radius).RectangularCoordinates;
    base.OnTimeChanged();
  }

Starboot ist noch einfacher, da es eine Äquatoriale berechnen kann­mit nur eine geringfügige Anpassung an die Jahr 2000-Position zu koordinieren.

Die XNA-Front-End

Ich begann das AstroPhone-Programm mithilfe von Silverlight, die groß mit dem ersten mehrere Konstellationen arbeiteten zu schreiben. Aber die weitere Sternbilder habe ich hinzugefügt, desto langsamer wurde.

Denken Sie daran, dass bei der Verwendung von Silverlight für ein solches Programm alle Text, Linien und Punkte TextBlock, Linie und Pfad Elemente in einem Bereich von einer Art sind. Um flüssige Bewegungen zu erhalten, wie Sie das Telefon in einem Bogen zu fegen, das nur ein Panel sein muss, und es hat alles drin haben. Wenn Sie beginnen, Entfernen von Elementen oder sie unsichtbar machen, wenn sie nicht angezeigt wird, beeinträchtigt noch mehr Leistung.

Ich verbrachte viel Zeit damit, die Leistung dieses Silverlight-Programm zu verbessern. Ich entdeckte, dass mit eine Leinwand besser als eine einzelne Zelle Raster arbeitete. Ich fand, dass wenn viele Line-Elemente angezeigt werden, Sie Leistung verbessern könnte, indem eine Koordinate der Linie auf den Punkt (0, 0), die andere Koordinate durch die gleiche Menge anzupassen und mithilfe einer TranslateTransform in Position verschieben.

Aber mit alle 88 Sternbilder an Ort, die Videobildrate fiel bis auf einen einzelnen Frame pro Sekunde und es gab einfach keine Alternative außer Silverlight aufzugeben. Das ist, warum AstroPhone ist ein XNA-Programm.

Interessanterweise ist der langsamste Teil von AstroPhone Grafiken überhaupt nicht. Es ist die Deserialisierung die Constellations.xml-Datei, die in der OnActivated-Überschreibung der Game-Klasse auftritt. Das Programm erstellt dann mehrere Kollektionen für die Aktualisierung und Rendern der Himmelsobjekte. Die primäre Auflistung, die für die Aktualisierung von Koordinaten verwendet wird CelestialBodies genannt. Wie der Name schon sagt, dies ist eine Auflistung von Instanzen der Klassen, die von CelestialBody abgeleitet und 832 Objekte enthält — 735 Objekte vom Typ Star, 88 von geben, Sternbild, eine Sonne und alle acht Planeten Objekte. (Pluto ist nicht im VSOP87 inbegriffen.)

In ein XNA-Programm für Windows Phone werden die Update und Draw Überschreibungen in der Game-Klasse mit einer Rate von 30 Mal pro Sekunde aufgerufen. Update ist verantwortlich für die Beschaffung von Eingabe der Sensoren (GPS und Bewegung, in diesem Fall) und Vorbereiten von Daten für die Draw-Methode.

Um die glatte Antwort auf Bewegungen des Telefons zu erzielen, das Update überschreiben Schleifen durch die gesamte CelestialBodies-Sammlung, ruft die HorizontalCoordinate-Eigenschaft der einzelnen Objekte und verwendet die aktuelle Bewegung-Matrix umwandeln, die zum einen zweidimensionalen Punkt auf dem Bildschirm, der es dann in den Eigenschaften ScreenX und ScreenY des CelestialBody-Objekts gespeichert. Die Draw-Methode greift dann auf diese ScreenX und ScreenY Eigenschaften, um das Objekt auf dem Bildschirm zu zeichnen.

Aber diese Berechnung ausschließlich ist für die Bewegung des Bildschirms Konto. Es ist auch notwendig für jedes Objekt CelestialBody, seine HorizontalCoordinate-Eigenschaft wie die Zeit vergeht in regelmäßigen Abständen zu aktualisieren und die Erde und andere Planeten bewegen ein wenig. Dennoch ist dieses Update nicht entscheidend für das reibungslose Funktionieren des Programms. Die HorizontalCoordinate-Eigenschaft basiert auf dem aktuellen Datum und Zeit und den geographischen Standort des Benutzers, aber keines dieser Elemente ändert schnell genug zu Auswirkungen auf die Position der Sterne und Planeten auf kurze Sicht.

Aus diesem Grund beschäftigt sich die Update-Überschreibung der Game-Klasse mit die Update-Methoden der CelestialBody-Objekte in einer gemütlichen Weise. Nur ein Element in der CelestialBodies-Auflistung wird für jeden Aufruf der Klasse Game Update überschreiben, erfordern einen Zyklus von etwa 28 Sekunden durchlaufen die gesamte Sammlung von 832 Objekte aktualisiert.

Zwecken Rendern werden andere Sammlungen verwaltet, da verschiedene Arten von Himmelsobjekten auf unterschiedliche Weise gerendert werden. Die VisibleStars-Auflistung enthält die 735 Star-Objekte, die auf dem Bildschirm gerendert werden, die Sternbilder-Kollektion hat die 88 Sternbilder und die SystemBodies-Kollektion hat die Sonne und die sieben Planeten außer der Erde.

Wie jede andere Klasse, die von CelestialBody abgeleitet ist, die Constellation-Klasse legt eine EquatorialCoordinate-Eigenschaft, dies jedoch ausschließlich zu Zwecken der Positionierung der Name des Sternbildes. Diese Position wird berechnet, indem jede Konstellation-Instanz vom Durchschnitt der angeschlossenen Sterne, die die Konstellation bilden.

Die Verbindungslinien selbst waren ziemlich schwierig. Jedes Sternbild-Objekt verfügt über eine Sammlung von Connectorobjekten, von die jedes ein paar von Sternen im Sternbild verweist. Aber dieser Connector-Objekte stammen aus der Originaldatei Constellations.xml und verweisen auf das Paar von verbundenen Sternen mit ID-Nummern. Um die Zeichnung zu beschleunigen, verbringt das Programm der Initialisierungsprozess Ergänzung jedes Paar von ID-Nummern mit einem StarConnector-Objekt, das ein paar von den eigentlichen Star-Objekte ist. Somit kann das Programm Verbindungslinien durch Verweisen auf die ScreenX und ScreenY Eigenschaften der eigentlichen Star Objekte zeichnen.

Abbildung 5 zeigt den Teil der Draw-Methode, die die Konstellation-Namen, die Verbindungslinien und die Sterne selbst rendert.

Abbildung 5 der Draw-Methode zum Rendern der Sternbilder und Sterne

protected override void Draw(GameTime gameTime)
{
  // Dark blue sky
  GraphicsDevice.Clear(new Color(0, 0, 0x20));
  spriteBatch.Begin(SpriteSortMode.Immediate, 
    null, null, null, null, null,
    displayMatrix);
  ...
  // Loop through constellations
  foreach (Constellation constellation in 
    constellations.ConstellationList)
  {
    if (!float.IsNaN(constellation.ScreenX))
    {
      // Display constellation name
      Vector2 textSize = 
        labelFont.MeasureString(constellation.LongName);
      spriteBatch.DrawString(labelFont, constellation.LongName,
        new Vector2(constellation.ScreenX - textSize.X / 2,
        constellation.ScreenY - textSize.Y / 2), Color.Gray);
    }
    // Display constellation connectors
    if (constellation.StarConnectors != null)
    {
      foreach (StarConnector starConnector in 
        constellation.StarConnectors)
      {
        Vector2 point1 = new Vector2((float)starConnector.From.ScreenX,
          (float)starConnector.From.ScreenY);
        Vector2 point2 = new Vector2((float)starConnector.To.ScreenX,
          (float)starConnector.To.ScreenY);
        if (!float.IsNaN(point1.X) && !float.IsNaN(point2.X))
          lineRenderer.Draw(spriteBatch, point1, point2, 
           1, Color.White);
      }
    }
  }
  // Now display the stars themselves
  foreach (Star star in visibleStars)
    if (!float.IsNaN(star.ScreenX))
      starDotRenderer.Draw(spriteBatch,
        new Vector2(star.ScreenX, star.ScreenY), Color.White);
  ...
  spriteBatch.End();
  base.Draw(gameTime);
}

Obwohl Programme wie AstroPhone eine hilfreiche Einführung in die Sterne und Planeten bieten, kommt nichts in der Nähe der Erfahrung tatsächlich im wirklichen Leben betrachten. Vielleicht als Menschen mehr wissen mit Hilfe von Programmen wie dies gewinnen, entwickeln sie wieder einmal eine intime Vertrautheit mit den Nachthimmel.

Charles Petzold ist eine langjährige Mitarbeit beim MSDN Magazin und ist derzeit aktualisiert sein klassisches Buch "Programming Windows" (Microsoft Press, 1998), für Windows 8. Seiner Website lautet charlespetzold.com.

Unser Dank gilt dem folgenden technischen Experten für die Durchsicht dieses Artikels: Donn Morse