Astronomy programming

General Discussion Other

miquael

in General Discussion • Other • 1 years ago

I'm setting out to create an astronomy / astrology application with Processing, and wondering if anyone has any tips, examples of work already created (open-source would be great), and/or other related Processing / Java libraries and resources. Let me know if you do ... Thanks!

( PS - I developed a pretty capable astronomy / astrology application from scratch with ActionScript years ago, so my aim is to port that code into Java. Tho, as I am starting out fresh, I can imagine that there may already be Java resources out there for this type of thing ... )

Replies(7)

jbum

Re: Astronomy programming

1 years ago

I usually don't thnk of astronomy and astrology as equivalent or in the same category. Which is it? Is there a link to your flash software so we can see the scope of what you have in mind?

miquael

Re: Astronomy programming

1 years ago

Yes, astronomy and astrology software are typically distinct. I've created an application in ActionScript that represents both (astronomical planetary data and astrological planetary data are actually the same data, just represented in different ways). The Flash application itself is currently not available for download, tho you can read more about it and see a screen shot here: http://www.michaelgaio.com/aion/

I intent to release this Flash version soon, tho also want to create a different version in Processing. And with that said, the Flash version can almost be ignored--as I have a much different vision of how the Processing version will be represented. And so, since I'm starting from scratch, just wondering what Processing / Java resources may be available to get a good start.

miquael

Re: Astronomy programming

1 years ago

Yesterday, I actually mashed and tweaked a bunch of stuff to make this:

import processing.opengl.*;
import remixlab.proscene.*;
import controlP5.*;
Scene scene;
ControlP5 controlP5;
PMatrix3D currCameraMatrix;
PGraphics3D g3;
Planet[] planets = new Planet[3]; // new Planet[10];
OrbitElipse[] orbitelipses = new OrbitElipse[2];
PImage sun_map;
PImage earth_map;
PImage moon_map;
boolean texturedSpheres = true;
// --
int sDetail = 12; // 48 : sphere detail setting
float rotationX = 0;
float rotationY = 0;
float velocityX = 0;
float velocityY = 0;
float globeRadius = 600;
float pushBack = 100;
float[] cx,cz,sphereX,sphereY,sphereZ;
float sinLUT[];
float cosLUT[];
float SINCOS_PRECISION = 0.5f;
int SINCOS_LENGTH = int(360.0 / SINCOS_PRECISION);
// SETUP ///////////////////////////////////////////////////////////////////////////
void setup() {
//size(1000, 1000, OPENGL); // P3D for web
size(screen.width, screen.height, OPENGL);
scene = new Scene(this); // create a Scene instance
scene.setAxisIsDrawn(false); // hide axis
scene.setGridIsDrawn(false); // hide grid
scene.camera().setPosition(new PVector(300, 300, 300)); // move the camera
scene.camera().lookAt(new PVector(0, 0, 0)); // make the camera look at the center of the board
sun_map = loadImage("sunmap.jpg");
earth_map = loadImage("earthmap1k.jpg");
moon_map = loadImage("moonmap1k.jpg");
// distance, diameter,
// orbit direction, orbit speed,
// rotate direction, rotate speed,
// color, image, texture
// SUN
planets[0] = new Planet(0, 70,
1, 0,
1, .003,
color(255, 160, 0), sun_map, true);
// EARTH
planets[1] = new Planet(130, 8,
1, .005,
1, .6,
color(0, 0, 255), earth_map, true);
// MOON
planets[2] = new Planet(24, 2,
1, -.55,
1, 0,
color(160, 160, 160), moon_map, true);
orbitelipses[0] = new OrbitElipse(0, 0, 0, 0);
orbitelipses[1] = new OrbitElipse(0, 0, 260, 260);
//orbitelipse[2] = new OrbitElipse(0, 0, 0, 0);
g3 = (PGraphics3D)g;
controlP5 = new ControlP5(this);
controlP5.addButton("button",10,100,60,80,20).setId(1);
controlP5.addButton("buttonValue",4,100,90,80,20).setId(2);
controlP5.setAutoDraw(false);
}
// DRAW ///////////////////////////////////////////////////////////////////////////
void draw(){
background(0);
//lights();
// create some lights
//directionalLight(300, 300, 300, scene.camera().orientation().x - scene.camera().position().x, scene.camera().orientation().y - scene.camera().position().y, scene.camera().orientation().z - scene.camera().position().z);
//spotLight(150, 150, 150, scene.camera().position().x, scene.camera().position().y, scene.camera().position().z, 0, 0, -1, 1, 20);
//spotLight(100, 100, 100, scene.camera().position().x, scene.camera().position().y, scene.camera().position().z, 0, 0, 1, 1, 20);
//scale(1); // 50
// SUN /////////////////////////////////////////////////////
pushMatrix(); // this saves the current "state" of the translations and rotations
planets[0].display();
popMatrix(); // we now return to "universe" orientation
// EARTH /////////////////////////////////////////////////////
pushMatrix(); // Save this position again
planets[1].display();
//popMatrix(); // WAIT! Before we do that to get back to the UNIVERSE level, let's add a moon!
// MOON /////////////////////////////////////////////////////
planets[2].display();
popMatrix(); // must match calls to push and pop
pushMatrix();
orbitelipses[1].display();
popMatrix();
gui();
}
// GUI ///////////////////////////////////////////////////////////////////////////
void gui() {
// Disable depth test to draw 2d on top
hint(DISABLE_DEPTH_TEST);
currCameraMatrix = new PMatrix3D(g3.modelview);
// Since proscene handles the projection in a slightly different manner
// we set the camera to Processing default values before calling camera():
float cameraZ = ((height/2.0) / tan(PI*60.0/360.0));
perspective(PI/3.0, scene.camera().aspectRatio(), cameraZ/10.0, cameraZ*10.0);
camera();
controlP5.draw();
g3.camera = currCameraMatrix;
// Re-enble depth test
hint(ENABLE_DEPTH_TEST);
}
// PLANET ///////////////////////////////////////////////////////////////////////////
class Planet {
float distFromCenter;
float diameter;
float orbitDirection;
float orbitSpeed;
float rotateDirection;
float rotateSpeed;
color c;
PImage imageMap;
boolean renderTexture;
float orbit_theta;
float rotate_theta;
//float moonTheta;
Planet(float distFromCenter_, float diameter_,
float orbitDirection_, float orbitSpeed_,
float rotateDirection_, float rotateSpeed_,
color c_, PImage imageMap_, boolean renderTexture_) {
distFromCenter = distFromCenter_;
diameter = diameter_;
orbitDirection = orbitDirection_;
orbitSpeed = orbitSpeed_;
rotateDirection = rotateDirection_;
rotateSpeed = rotateSpeed_;
c = c_;
imageMap = imageMap_;
renderTexture = renderTexture_;
if (texturedSpheres && renderTexture) {
initializeSphere(sDetail);
}
}
void display() {
orbit_theta += orbitSpeed * orbitDirection;
rotateY(orbit_theta / 5);
//rotateZ((millis() * TWO_PI / orbitSpeed) % TWO_PI ); // This makes the planet move faster than the universe rotates.
translate(distFromCenter, 0, 0);
rotate_theta += rotateSpeed * rotateDirection;
rotateY(rotate_theta / 5);
//rotateY((millis() * TWO_PI / rotateSpeed) % TWO_PI); // This makes the planet rotate.
noStroke();
if (texturedSpheres && renderTexture) {
noFill();
textureMode(IMAGE);
texturedSphere(diameter, imageMap);
}
else {
fill(c);
box(diameter);
//sphere(diameter);
}
}
}
// ORBIT ELLIPSE ///////////////////////////////////////////////////////////////////////////
class OrbitElipse {
float x;
float y;
float width;
float height;
OrbitElipse(float x_, float y_,
float width_, float height_) {
x = x_;
y = y_;
width = width_;
height = height_;
}
void display() {
stroke(200, 200, 200, 50);
strokeWeight(2);
noFill();
rotateX(PI/2);
ellipse(x, y, width, height);
}
}
// CUSTOM SPHERE ///////////////////////////////////////////////////////////////////////////
void initializeSphere(int res) {
sinLUT = new float[SINCOS_LENGTH];
cosLUT = new float[SINCOS_LENGTH];
for (int i = 0; i < SINCOS_LENGTH; i++) {
sinLUT[i] = (float) Math.sin(i * DEG_TO_RAD * SINCOS_PRECISION);
cosLUT[i] = (float) Math.cos(i * DEG_TO_RAD * SINCOS_PRECISION);
}
float delta = (float)SINCOS_LENGTH/res;
float[] cx = new float[res];
float[] cz = new float[res];
// Calc unit circle in XZ plane
for (int i = 0; i < res; i++) {
cx[i] = -cosLUT[(int) (i*delta) % SINCOS_LENGTH];
cz[i] = sinLUT[(int) (i*delta) % SINCOS_LENGTH];
}
// Computing vertexlist vertexlist starts at south pole
int vertCount = res * (res-1) + 2;
int currVert = 0;
// Re-init arrays to store vertices
sphereX = new float[vertCount];
sphereY = new float[vertCount];
sphereZ = new float[vertCount];
float angle_step = (SINCOS_LENGTH*0.5f)/res;
float angle = angle_step;
// Step along Y axis
for (int i = 1; i < res; i++) {
float curradius = sinLUT[(int) angle % SINCOS_LENGTH];
float currY = -cosLUT[(int) angle % SINCOS_LENGTH];
for (int j = 0; j < res; j++) {
sphereX[currVert] = cx[j] * curradius;
sphereY[currVert] = currY;
sphereZ[currVert++] = cz[j] * curradius;
}
angle += angle_step;
}
sDetail = res;
}
// Generic routine to draw textured sphere
void texturedSphere(float r, PImage t) {
int v1,v11,v2;
// r = (r + 240 ) * 0.33; // r = (r + 240 ) * 0.33; *****
beginShape(TRIANGLE_STRIP);
texture(t);
float iu=(float)(t.width-1)/(sDetail);
float iv=(float)(t.height-1)/(sDetail);
float u=0,v=iv;
for (int i = 0; i < sDetail; i++) {
vertex(0, -r, 0,u,0);
vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);
u+=iu;
}
vertex(0, -r, 0,u,0);
vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);
endShape();
// Middle rings
int voff = 0;
for(int i = 2; i < sDetail; i++) {
v1=v11=voff;
voff += sDetail;
v2=voff;
u=0;
beginShape(TRIANGLE_STRIP);
texture(t);
for (int j = 0; j < sDetail; j++) {
vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);
u+=iu;
}
// Close each ring
v1=v11;
v2=voff;
vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);
endShape();
v+=iv;
}
u=0;
// Add the northern cap
beginShape(TRIANGLE_STRIP);
texture(t);
for (int i = 0; i < sDetail; i++) {
v2 = voff + i;
vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);
vertex(0, r, 0,u,v+iv);
u+=iu;
}
vertex(0, r, 0,u, v+iv);
vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);
endShape();
}
// EVENT HANDLERS ///////////////////////////////////////////////////////////////////////////
void controlEvent(ControlEvent theEvent) {
println(theEvent.controller().id());
}
void button(float theValue) {
println("a button event. "+theValue);
}

miquael

Re: Astronomy programming

1 years ago

Get the planet textures here: http://planetpixelemporium.com/earth.html

miquael

Re: Astronomy programming

1 years ago

^ So, that's just a basic start, trying to get a handle on things. There's no real data happening here yet. I'm justing playing around with how Processing handles visual representations. That's my primary concern: is having a really good visual representation while also maintaining effecient processing. I may soon begin to translate code in from what I did in ActionScript, tho just want to get a good handle on what is even happening here now. My questions so far are:

1) What Processing / Java libraries are there that may support astronomical data and/or representations?

2) In the fundamental code above, what general improvements can be made to increase processing power and better graphic representation? What other improvements? (I'm open to any feedback whatsoever).

3) I'm wondering about the way that I utilized this initializeSphere() and texturedSphere() methods (I found these elsewhere, and adapted them into my code). Is this a more efficient or less efficient method of representing texturized spheres? Seems like this might be outdated custom code, and maybe Processing has something better in its core libraries?

4) In an early attempt to get a handle on 2D UI over 3D representation, I used a very basic controlP5 sample. Is this the best way to go? And I notice that if the 3D representation is animating, and I click a 2D UI button, it also affects the 3D interaction. How to prevent this?

5) With my years of ActionScript programming, I'm used to OOP programming and OOP design (embedded symbols and such). I hope that Processing operates in a similar way with Classes. Regarding #4: would it work to place the 3D representation in it's own modular class, have the 2D UI in it's own module class, and then create instances of them in a primary application class? Would this help with keeping them distinct in the way that Processing registers interaction?

6) What other ways can I improve the visual representation (such as having the sun glow etc), while also maintaining efficient processing power?

7) If I was to add several more planets and graphics etc, I might expect the processing power to suffer. How can maximum processing power be achieved overall?

I might have more questions. I'm just getting started, and putting these questions out here to begin getting an overall better understanding of how to move forward. Thanks to anyone who is inspired to help!

miquael

Re: Astronomy programming

1 year ago

Anyone?

PhiLho

Re: Astronomy programming

1 year ago

1) If no one answers, it means that no one has an idea on the answer. I can google it for you, but it would have little interest... Search toward Java libraries more than toward Processing-specific ones.
2) Too generic question, idem for 6 and 7. And most other questions...
5) OOP: yes, Processing is well suited to proper OOP techniques.

Top Reply