Planetary Motion Source Code

This code is from my demo Android app offering a tutorial in coding Keppler's first two laws in Java for Android. The snippet here is intended to be read with the truly excellent work of Jean Meeus in his book, which I strongly recommend to anyone with an interest in astronomy and computing.

Feel free to use this code for any purpose. I don't guarantee it works. The code isn't written for speed or efficiency, just so it works and you can see what is going on. Feel free to improve it.

Keppler

Mr Keppler. What a guy. Also, Jean Meeus. I thank you both. In Meeus's book, chapter 30, he describes the process of "calculating the position of a body (planet, minor planet or periodic comet) on its elliptical orbit around the Sun at a given instant ... from the orbital elements of the body".

My notes here do not teach you all about this topic - you go and do the work yourself, following Mr Meeus. My code here is just one way of calculating the position of the body, according to Meeus's description.

I'm assuming you know how to create an Android app, know Java and have a copy of his book.

This is my method for drawing the planet at the 'next' position in the orbit. Think of the steps like stepping round a circle, one degree at a time, on a circle which has the same period as the planet you are trying to track. Outside of this method I use a global double as the step counter - called dTime, which contains a number of degrees of rotation.

The key parameters passed to the method are, dEccentricty, dScalar (a scaling factor so the orbit all fits on the display), dYear (the duration of the orbit in Earth years) and to orient the orbit so that perihelion is at the right place on the dial, so to speak, dLongPeri - the Longitude of Perihelion.

Read the comments.

public void drawPlanet (double dEccentricity, double dScalar, double dYear, Canvas canvas, Paint paint, 
    		String sName, Bitmap bmp, double dLongPeri)
        {
        double dE, dr, dv, dSatX, dSatY, dSatXCorrected, dSatYCorrected;
        float fX, fY;
        int iSunXOffset = getWidth() / 2;
        int iSunYOffset = getHeight() / 2;
        
        // get the value of E from the angle travelled in this 'tick'
	    
	    dE = getE (dTime * (1 / dYear), dEccentricity);
	    
	    // get r: the length of 'radius' vector
	    
	    dr = getRfromE (dE, dEccentricity, dScalar);
	    
	    // calculate v - the true anomaly
	    
	    dv = 2 * Math.atan (
	    		Math.sqrt((1 + dEccentricity) / (1 - dEccentricity))
	    		*
	    		Math.tan(dE / 2)
	    		); 
	    
	    // get X and Y coords based on the origin
	    
	    dSatX = dr / Math.sin(Math.PI / 2) * Math.sin(dv);
	    dSatY = Math.sin((Math.PI / 2) - dv) * (dSatX / Math.sin(dv));
	    
	    // now correct for Longitude of Perihelion for this planet
	    
	    dSatXCorrected = dSatX * (float)Math.cos (Math.toRadians(dLongPeri)) - 
            dSatY * (float)Math.sin(Math.toRadians(dLongPeri));
	    dSatYCorrected = dSatX * (float)Math.sin (Math.toRadians(dLongPeri)) + 
            dSatY * (float)Math.cos(Math.toRadians(dLongPeri));
	    
	    // offset the origin to nearer the centre of the display
	    
	    fX = (float)dSatXCorrected + (float)iSunXOffset;
	    fY = (float)dSatYCorrected + (float)iSunYOffset;
	    
	    if (bDrawOrbits)
            {
            // draw the path of the orbit travelled
            paint.setColor(Color.WHITE);
            paint.setStyle(Paint.Style.STROKE);
            paint.setAntiAlias(true);
        
            // get the size of the rect which encloses the elliptical orbit
        
            dE = getE (0.0, dEccentricity);
            dr = getRfromE (dE, dEccentricity, dScalar);
            rectOval.bottom = (float)dr;
            dE = getE (180.0, dEccentricity);
            dr = getRfromE (dE, dEccentricity, dScalar);
            rectOval.top = (float)(0 - dr);
        
            // calculate minor axis from major axis and eccentricity
            // http://www.1728.org/ellipse.htm

            double dMajor = rectOval.bottom - rectOval.top;
            double dMinor = Math.sqrt(1 - (dEccentricity * dEccentricity)) * dMajor;
        
            rectOval.left = 0 - (float)(dMinor / 2);
            rectOval.right = (float)(dMinor / 2);

            rectOval.left += (float)iSunXOffset;
            rectOval.right += (float)iSunXOffset;
            rectOval.top += (float)iSunYOffset;
            rectOval.bottom += (float)iSunYOffset;
       
            // now correct for Longitude of Perihelion for this orbit's path

            canvas.save();
            	canvas.rotate((float)dLongPeri, (float)iSunXOffset, (float)iSunYOffset);
            	canvas.drawOval(rectOval, paint);
            canvas.restore();
            }
	    
	    int iBitmapHeight = bmp.getHeight();
		
	    canvas.drawBitmap(bmp, fX - (iBitmapHeight / 2), fY - (iBitmapHeight / 2), null);

	    // draw planet label
	    
		myPaint.setColor(Color.WHITE);
		paint.setTextSize(30);
		canvas.drawText(sName, fX+20, fY-20, paint);
        }

The method above calls two further methods which provide values of E (the mean anomaly) and r, the length of the vector at the end of which the planet is found. Check out the equation numbers and line numbers in Meeus's Basic program on page 206:

    public double getE (double dTime, double dEccentricity)
        {
    	// we are passed the degree count in degrees (duh) 
        // and the eccentricity value
	    // the method returns E

    	double dM1, dD, dE0, dE = 0; // return value E = the mean anomaly
    	double dM; // local value of M in radians
    	      
    	dM = Math.toRadians (dTime);
    	
    	int iSign = 1;
    	
    	if (dM > 0) iSign = 1; else iSign = -1;
    	
    	dM = Math.abs(dM) / (2 * Math.PI); // Meeus, p 206, line 110
    	dM = (dM - (long)dM) * (2 * Math.PI) * iSign; // line 120
    	if (dM < 0)
    		dM = dM + (2 * Math.PI); // line 130
    	iSign = 1;
    	if (dM > Math.PI) iSign = -1; // line 150
    	if (dM > Math.PI) dM = 2 * Math.PI - dM; // line 160
    	
    	dE0 = Math.PI / 2; // line 170
    	dD = Math.PI / 4; // line 170
    	
        for (int i = 0; i < 33; i++) // line 180 
            {
        	dM1 = dE0 - dEccentricity * Math.sin(dE0); // line 190
        	dE0 = dE0 + dD * Math.signum((float)(dM - dM1));
        	dD = dD / 2; 
            }
        
        dE = dE0 * iSign;
        
        return dE;
        }

And once you have E, you need the length of the vector r:

public double getRfromE (double dE, double dEccentricty, double dScalar)
        {
    	return Math.min(getWidth(), getHeight()) / 2 * dScalar * (1 - (dEccentricty * Math.cos(dE)));
        }

If you would like the entire source code of my app, go here.