Planetarium mit ca. 1600 Sternen darstellen!?

[Circushund]

hi,
Es geht um die Darstellung von ca. 1600 Sterne in einer stereografischen Projektion.

OK, damit man das Versteht, muss ich jetzt mal ein bisschen Ausholen und einen kleinen Exkurs in die Astronomie machen.

1) Jeder Stern hat eine fixe Koordinate auf der Himmelskugel, die nennt sich Rektaszension und Deklination(nur so nebenbei).

2) Mithilfe dieser Koordinaten ermittelt man die Position relativ zum Beobachtungsort: Salzbur,München ect. diese Koordinaten heissen dann Azimut und Höhe.

3) Um nun aber das Firnament möglichst realistisch darzustellen, muss man diese Koordinaten nochmal in stereografische Koordinaten umwandeln um die Kugel auf die Fläche zu projezieren (diese Projektion nimmt man u.a. auch bei Karten der Kontinent ect.)

Die Daten aus 1) speicher ich in einem Array, was in einer Klasse liegt.
daraus ermittel ich dann Azimut Höhe (2) um schliessendlich die stereografischen End-Koordinaten(3) zu haben (siehe Anhang)

Für die Berrechnung von 2) und 3) werden einigen Sinus und Cosinus Operationen ausgeführt, die auch ein ziemlicher Flaschenhals sind.
In einer Schleife attache/remove ich jeden MC, je nachdem ob er über oder unter dem Horizont ist!

Meine Frage ist nun:
Gibt es eine Möglichkeit, die Darstellung der Sterne etwas fixer zu machen(evtl. mit AS3), würde es evtl. schneller gehen, die Scheibchen(+dem Blur)mit AS zu erzeugen? Könnte man evtl. eine 3D Engine mit involvieren?

Das Planetarium gibt es da:
http://www.dwienand.de/FS/movie.html

Der Source Code ist da:
http://www.dwienand.de/Expo/FlashSkiesCode.zip
...möchte das nicht wirklich jemand zumuten, denn es sind einige tausend Zeilen Code, aber die (wichtigen)Klassen sind im Unterordner "at" müsste man evtl. den Pfad angeben?

[georgem]

wenn du die Himmelskugel schon mal in getrennte Bereiche einteilst, dann kannst du es dir sparen immer alle Sterne durchzuschleifen.

z.B. sind immer nur höchstens 2 Himmelsrichtungen sichtbar, Nord und Ost, oder Süd und West.


Wenn du die Sterne in AS3 programmierst, und sie als einfache bitmaps auf den Screen bringst, dann kannst du locker 2000 Sterne flüssig darstellen, und einige tausend mal ne sinus-berechnung machen.

Eventuell lohnt in deinem Fall auch die Benutzung von vorgefertigten Sinus-Tabellen.

Wenn ich mal Zeit habe, werde ich mir deinen Code etwas anschauen.

[Circushund]

hi georgem,

wenn du die Himmelskugel schon mal in getrennte Bereiche einteilst, dann kannst du es dir sparen immer alle Sterne durchzuschleifen.

hmm, ja so einfach ist das nicht ganz , wenn man die geografische Breite ändert, muss man wieder die Sterne, die dann neu erscheinen bzw. die die dann nicht mehr sichtbar sind, komplett neu berrechnen. Im grunde muss man so immer mit der ganzen Kugel arbeiten...

[georgem]

aber im Grunde ist ja zu jedem Zeitpunkt immer nur ein 6tel oder weniger der Kugel sichtbar...

das ist also definitiv der Flaschenhals.

Es müsste doch möglich sein, das Stern-array irgendwie so zu modellieren, dass du eine Art Zonen hast...
nehmen wir an, du hängst jedem Stern noch seine Zone an... und du hast 12 Zonen oder so...
Wenn jetzt nach wenigen neuen Berechnung klar wird, dass nur Sterne der Zonen 3 , 4 und 5 auf den Screen kommen, dann könntest du schnell ableiten, dass Sterne der gegenüberliegenden Zone 8,9 und 10 gar nicht erst berechnet werden müssen. Ich denke mit etwas Experimentieren kriegst du hier einen guten Performance-Gewinn...

Also: die jeweilige Zone schon zu Beginn dem jeweiligen Stern aufstempeln (als klare ID)
Diese Zonen-Aufteilung müsste dann nur einmal gemacht werden, anschliessend behalten die Sterne die Zone bei, da sich die Position untereinander ja nicht verändert.

[Janoscharlipp]

Erstmal fetten Respekt, das ist ne richtig schicke Sache, die du da gebastelt hast!

Ich denke das die XStereo und YStereo Funktionen das Problem sind, da werden ja jeweils sieben trigonometrische Funktionen aufgerufen, das muss einfach dauern
Was mir als erstes auffällt, dass XStereo und YStereo auf gleiche Weise das kk berechnen, und damit machst du schonmal fünf trigonometrische Funktionen mit gleichen Werten doppelt. Das kannst du dir sparen, indem du die Berechnungen zusammenlegst, und einfach ein Objekt mir x und y Eigenschaft zurückgibst.

Ansonsten könntest du ganz prinzipiell die Berechnung mit Matrizen machen, dann musst du nur einmal am Anfang eine Transformationsmatrix berechnen, und kannst dann mit dieser alle Koordinaten mit simplen Multiplikationen und Additionen transformieren .
Erfordert bei dir allerdings einen ziemlichen Umbau, da du dann, soweit ich weiß erstmal alles auf kartesische Koordinaten umstellen müsstest.

[Circushund]

@georgem

ja, du hast recht, mitunter geht das mit Zonen (siehe Skizze)
Als erstes berechnet man ja Azimut und Höhe eines jeden Sterns, Sterne mit eben Höhe kleiner Null werden nicht dargestellt. Azimut und Höhe sind abhänig von der Neigung der Polachse(geografisch Breite) dem Stundenwinkel und der Deklination des Sterns.
1) Kürzung:
Sterne mit kleinerer Deklination als: 90-geogr.Breite*-1 ...sind am Ort nie sichtbar!(sieht man von der Refraktion ab)

Das zweite ist, und da hast du recht, das für eine bestimmte Blickrichtung Ost,West Südwest ect. man nur solche Sterne sieht, die sich in einem bestimmten Streifen sichtbar sind (wenn man die Kugel dreht! (siehe Skizze)

@ Janoscharlipp

du hast recht , das hatte ich garnicht gesehen, das kk ist wiklich bei beiden Formeln gleich. Ich überleg grad, könnt man als Argument der Funktion einschleusen?

Ansonsten könntest du ganz prinzipiell die Berechnung mit Matrizen machen, dann musst du nur einmal am Anfang eine Transformationsmatrix berechnen, und kannst dann mit dieser alle Koordinaten mit simplen Multiplikationen und Additionen transformieren .
Erfordert bei dir allerdings einen ziemlichen Umbau, da du dann, soweit ich weiß erstmal alles auf kartesische Koordinaten umstellen müsstest.

ja, und da fängs bei mir an, das ich auschecke *grins. Ne klar, solchen Überlegungen hatte ich auch schon. Hab aber keine Ahnung wie man das anstellen könnte? Man könnte jeden Stern eine x,y und z Koordinate geben und ihn dann um die Achse des Himmelspols im kartesischen System rotieren, aber wie macht man das?? Hast du eine Idee?
Für die Performance müsste ich sowieso einiges ändern und auch komplett umbauen, ist mir schon klar

Insgesammt müsste man das Ganze aber schon recht flexibel halten, das der User schnell irgendeine Zeit wählen kann und der Himmel dann neu berrechnet wird. Leider hab ich die ganzenen Astro-Funktionen(auch Planetenpositionen) in AS3 Klassen, die sich glaub ich auch nicht ohne einiges gemecker(vom Compiler) in AS3 umwandeln lassen oder?

[Circushund]

hmm, hat denn keiner eine Idee?

Formeln:
A)

PHP-Code:

//*********************
//*     Höhe          *
//*********************
function Hoehe( RA:Number, DE:Number ){
       
           var  H = this.range360((this.SZ()-RA));
               H *= this.rads;
          var gB  = this.geoB *this.rads;
              DE *= this.rads;
        
         var sinh = ( Math.sin( gB )* Math.sin( DE ))
                  + ( Math.cos( gB )* Math.cos( DE )* Math.cos( H )); 
        
         return( Math.asin( sinh )* this.degs );
        }
        
//*********************
//*     Azimut        *
//*********************
function Azimut( RA:Number, DE:Number ){
        
        var  H = this.range360( ( this.SZ()-RA ) );
            H *= rads;
       var gB  = this.geoB *this.rads;
           DE *= rads;
        
        var arctan2=0;   
        var c=0;
            var a = Math.sin ( H );
            var b =((Math.cos( H )*Math.sin( gB ) )- (Math.tan( DE )*Math.cos( gB ) ));

        if (( b )==0 ){
             var arctan2 = Math.atan(a) * this.degs;
        
             if (b < 0) {
             var arctan2 = arctan2 + 180; 
             b =  arctan2 / 360;
             a = 360 * (b - int(b));
             }
            
             if (a < 0) { a = a + 360;}
        
             arctan2 = a;
             }
            else 
            {
             arctan2 = Math.atan( a / b ) * this.degs;
              
              if (b < 0){
              arctan2 = arctan2 + 180;
              b = arctan2 / 360;
              a = 360 * (b - int(b));
                if (a < 0){  a = a + 360;}
                arctan2 = a;
              } //ende IF-Block
           }// else geschlossen
        
        c = arctan2;
        
        if (c < 0) {c = c + 360;}
        
        return(c);
        
        }
} 


B)

PHP-Code:

//**********************
//*     XStereo        *
//**********************
        function XStereo (lat:Number, lng:Number, lat0:Number, lng0:Number, RZoom:Number,kk:Number)
        {
        var pi=3.141592654;
        var rads=0.01745329251;
        lat  *=rads;
        lat0 *=rads;
        lng  *=rads;
        lng0 *=rads;
        
        // Umrechnugskonstanten
            var k;
            var kk = ( 1 + Math.sin( lat0 ) 
                * Math.sin( lat  ) 
                 + Math.cos( lat0  ) * Math.cos( lat )
                  * Math.cos( ( lng - lng0 )  ) );
            
            if ((kk)==0)
            {
                k = 2 * RZoom;
            }
            else
            {
                k = 2 * (RZoom / kk);
            }          
              var Xstereo_Double = k * ( Math.cos ( lat ) * Math.sin( ( lng - lng0 )  ) );      
         return(Xstereo_Double);
        }
//**********************
//*     YStereo        *
//**********************
function YStereo (lat:Number, lng:Number, lat0:Number, lng0:Number, RZoom:Number, kk:Number)
        {
        var pi=3.141592654;
        var rads=0.01745329251;
        lat  *=rads;
        lat0 *=rads;
        lng  *=rads;
        lng0 *=rads;

            var k;
            var kk = ( 1 + Math.sin( lat0  ) 
                * Math.sin( lat  ) 
                 + Math.cos( lat0  ) * Math.cos( lat  )
                  * Math.cos( ( lng - lng0 ) ) );
            if ((kk)==0)
            {
                k = 2 * RZoom;
            }
            else{
                k = 2 * (RZoom / kk);
            }          
             var Ystereo_double = k * (Math.cos( lat0  ) * Math.sin( lat  ) - Math.sin( lat0  ) * Math.cos( lat  ) * Math.cos( ( lng - lng0 ) ) );
          return(Ystereo_double);
        } 


Also, in A) erstmal alles in Azimut und Höhe umrechen, in B) auf die Stereografisch Projektion abbilden.


..die Sternchen haben auch Spikes und ist Vektorgrafik, evtl. das raus.
Aber wo ist wirklich der Flaschenhals bei diesen Satz Trigonometrischen Formeln, die "nur" 1600 Sterne berrechnen müssen?
..hab auch wirklich keine Idee wie ich das bzgl. einer Matrizendrehung umstellen muss?

OK Überlegungen:
1) alles in AS3 umbauen
2) Bitmap statt Vektor-Grafix (machts wirklich so einen grossen Unterschied?)
3) Oder noch simpler, mittels "drawCircle()" odersowat zeichnen??
4) for- in -Schleife, lookup Tabellen für sin/cos ect. dh. allerlei (kleine) Optimierungen?

..naja, weit weit weg von Echtzeit Animation ..

[Janoscharlipp]

Die Umstellung auf AS3 bring sicher am meisten, ist aber auch am aufwendigsten.

Die Berechnungen kannst du noch extrem optimieren, am besten, in dem du die jeweiligen zwei Funktionen zusammenlegst, denn du machst in beiden Fällen vieles (immernoch) doppelt.

Es gibt schon eine atan2 Funktion, kannst du nicht die verwenden?

Leider verstehe ich diese Projektionen nicht, habs mir bei Wikipedia angesehen, kann ich mir aber anhand dessen nicht vorstellen, was da vor sich geht.

Kannst du vielleicht mal in eigenen Worten beschreiben, wie ich mir diese Himmelskoordinaten vorzustellen habe? Sind das alles nur Winkel?

Ist halt nicht so leicht, in deine Berechnung einzusteigen

[georgem]

Wenn du noch keine AS3 Erfahrung hast, ist der Umbau wohl schon recht umfangreich. Ansonsten ist in AS3 auch vieles genau gleich wie in AS2...

In deinem Fall müsstest du vorerst das AS3 DisplayContainer-Prinzip verstehen, dann dürfte der Rest beinahe CopyPaste sein....

[Circushund]

@ georgem
jup das DisplayContain ist mit AS3 dazugekommen oder? Vom Umbau her ist es ja zweierlei, die Funktionen können ja so bleiben(bzw. optimiert).
Was natürlich komplett neu werden soll wäre dann das Plotten der Sterne, also kein attacheMovie und removeMovieClip mehr.

@ Janoscharlipp

..du kannst mal bei FlashSkies das Netz einblenden(kleiner Button unten rechts).

die Formeln die ich verwende sind hier:
http://mathworld.wolfram.com/Stereog...rojection.html

Versuch es dir vll. so vorzustellen, als hättest du eine Glaskugel, wo die Längen und Breitenkreise aufgezeichnet sind. Die Kugel liegt auf einer Platte und in der Mitte der Kugel ist eine Leuchtquelle. Die Schatten die auf die Platte geworfen werden entsprechen dann der stereografischen Projektion. Ist also eine Abbildung der Kugelfläche auf eine Grade bzw. Ebene.

ja stimmt, die XStereo und YStereo kann man zusammenlegen und in einem Array oderso beide Werte zurückgeben, dann müsste man das kk nur einmal rechnen. Hatte ich erst falsch verstanden denn ich hab versucht, das als Argument in der Funktion einzuschleusen, was aber nichts brachte, da ich es trotzdem 2mal rechnen musste, da sich die "lat" und "lat0" ect mit jeden einzelenen Stern natürlich immer wieder ändern...

ich werd mich gleich mal ranmachen und poste dann hier ein Zwischenresultat..

[Circushund]

Ok, hier ein Zwischenresultat:

PHP-Code:

//********************** 
//*     Stereo        
//********************** 
function Stereo (lat:Number, lng:Number, lat0:Number, lng0:Number, RZoom:Number):Array { 
    var pi=3.141592654; 
    var rads=0.01745329251; 
    lat  *=rads; 
    lat0 *=rads; 
    lng  *=rads; 
    lng0 *=rads; 
      // Umrechnugskonstanten 
    var k; 
    var kk = ( 1 + Math.sin( lat0 ) * Math.sin(lat ) + Math.cos( lat0  )
                 * Math.cos( lat )  * Math.cos((lng - lng0))); 
      if ((kk)==0){ 
           k = 2 * RZoom; 
        }else{ 
           k = 2 * (RZoom / kk); 
        }           
   var XStero = k * ( Math.cos ( lat ) * Math.sin( ( lng - lng0 )  ) );       
   var YStero = k * (Math.cos( lat0  ) * Math.sin( lat ) - Math.sin( lat0 ) * Math.cos( lat ) * Math.cos( ( lng - lng0 ) ) ); 
          
  return ([XStero, YStero]); 

} 

for (var ii:Number = 0; ii< 5; ii++){
    var T:Number =getTimer() 
    
    for (var i:Number = 0; i< 1600; i++){
        
        Stereo(10,10,0,90,1);
    }
  trace("Zeit :" + (getTimer()-T))
} 


ich hab da im Durchschnitt 170ms
allerdings rechne ich erstmal nur mit Pseudowerten.

könnte man da noch was verbessern?

[hgseib]

ja, aber dadurch wirds nicht schöner. und kein vergleich zu AS3 (diesen script kann man als AS2 oder als AS3 laufen lassen).

function Stereo(lat:Number, lng:Number, lat0:Number, lng0:Number, RZoom:Number):Array {
  lat *= rads;
  lat0 *= rads;
  lng *= rads;
  lng0 *= rads;
  var h:Number = c(lat)*c(lng-lng0);
  var k:Number = 2*(1+s(lat0)*s(lat)+c(lat0)*h);
  k = k ? RZoom/k : RZoom;
  return ([k*(c(lat)*s(lng-lng0)), k*(c(lat0)*s(lat)-s(lat0)*h)]);
}
//
var rads:Number = Math.PI/180;
var s:Function = Math.sin;
var c:Function = Math.cos;
for (var ii:Number = 0; ii<5; ii++) {
  var T:Number = getTimer();
  for (var i:Number = 0; i<1600; i++) {
    Stereo(10, 10, 0, 90, 1);
  }
  trace("Zeit :"+(getTimer()-T));
}

wobei trick's für AS2 nicht unbedingt auch für AS3 geeigent sind:

function Stereo(lat:Number, lng:Number, lat0:Number, lng0:Number, RZoom:Number):Array {
  lat *= rads;
  lat0 *= rads;
  lng *= rads;
  lng0 *= rads;
  var h:Number = Math.cos(lat)*Math.cos(lng-lng0);
  var k = 2*(1+Math.sin(lat0)*Math.sin(lat)+Math.cos(lat0)*h);
  k = k ? RZoom/k : RZoom;
  return ([k*(Math.cos(lat)*Math.sin(lng-lng0)), k*(Math.cos(lat0)*Math.sin(lat)-Math.sin(lat0)*h)]);
}
//
var rads:Number = Math.PI/180;
for (var ii:uint = 0; ii<5; ii++) {
  var T:Number = getTimer();
  for (var i:uint = 0; i<1600; i++) {
    Stereo(10, 10, 0, 90, 1);
  }
  trace("Zeit :"+(getTimer()-T));
}

und ist es nicht so, das lng0, lat0 und RZoom für eine komplette berechnung unverändert bleiben?
das wären dann nochmal ein paar tausendstel ;-)

function Stereo(lat:Number, lng:Number):Array {
  lat *= rads;
  lng *= rads;
  var h:Number =Math.cos(lat)*Math.cos(lng-lng0);
  var k:Number = 2*(1+lats*Math.sin(lat)+latc*h);
  k = k ? RZoom/k : RZoom;
  return [k*Math.cos(lat)*Math.sin(lng-lng0),k*latc*Math.sin(lat)-lats*h];
}
//
var rads:Number = Math.PI/180;
var lat0:Number=0*rads;
var lng0:Number=90*rads;
var RZoom:Number=12;
var lats:Number=Math.sin(lat0);
var latc:Number=Math.cos(lat0);
for (var ii:uint = 0; ii<5; ii++) {
  var T:Number = getTimer();
  for (var i:uint = 0; i<1600; i++) {
    Stereo(10, 10);
  }
  trace("Zeit :"+(getTimer()-T));
}

[Circushund]

@hgseib,

uuuhaaah! holladilotte, das ist ja der wahnsinn gegenüber AS2.
beim letzten Beispiel bin ich bei unter 10ms(AS3) .

...ok, das kann sich erstmal sehen lassen.
Anscheinend brings da dann auch nicht mehr viel, lookup-Tabellen für die Sin/Cos Funktionen zu machen oder??

..da das Ganze ja ein Planetarium wird, werden die Sterne ja immer nur für eine Himmelsrichtung und da auch nur für einen Bestimmten Bereich geplottet.
Das "latc" steht für die Himmelsrichtung, in die man schaut, 0=süd, 90 West,180=Nord usw..
Evtl. lege ich mir ein Array an, wo diese Werte dann schon mal vorgerechnet werden (beim starten der .swf), so wie georgem in etwa vorgeschlagen hat. Die Sache ist nur die, das wenn man den Himmel animieren möchte, muss man wieder komplett das Azimut und die Höhe neu berechnen und anschliessend erst Stereo(stereografische Projektion).

[hgseib]

Zitat von Circushund

Anscheinend brings da dann auch nicht mehr viel, lookup-Tabellen für die Sin/Cos Funktionen zu machen oder??

seit erfindung der matheprozessoren vor 20 jahren - nein. die berechnung einer trigonometrischen funktion dauert einen taktzyklus. ist also nur noch die frage, wie schnell AS die passende funktion findet um den proz. zu bedienen. und das geht bei einem compiler - AS3 - in akzeptabler geschwindigkeit ;-)

Zitat von Circushund

Das "latc" steht für die Himmelsrichtung, in die man schaut ... Evtl. lege ich mir ein Array an, wo diese Werte dann schon mal vorgerechnet werden

auch nein. die richtung wird einmal gedreht, dazu berechnet man einmal den versatz und dann kommen die 1600 sternlein dazu.
also z.b. latc=Math.cos(lat0); nur einmal berechnen je bildschirmneuberechnung und nicht 1600 mal.

(tabellen rentieren sich bei komplexen berechnungen; z.b. die beiwerte für spines n.ter-ordnung. das kommt hier aber nicht vor.)

generell zu beschleunigungen:
- nichts doppelt berechen
- so früh wie möglich berechnen:
--- unnötige berechnungen aus den schleifen rausnehmen
--- an funktionen nur tatsächliche variablen übergeben und globale global halten.

[abecker]

Respekt, sehr feine Sache die du da machst.
Einen kleinen Fehler hab ich aber gefunden....wenn man einen Stern anklickt, der relativ weit oben oder am rechten rand ist, verschwindet die Information nach oben hinaus/rechts, bzw. wird abgeschnitten.
Du solltest prüfen, ob genug Platz zur darstellung der Info ist und falls nicht vom Stern aus nach links oder unten hin öffnen.