Feel free to make it complicated. regards, Algwat.

2. // sweep image viewer
3. 
   
4. File[] list; // Files, not Strings
5. //
6. PImage[] imgs ; // fn matched images
7. 
   
8. int Nimg = 0;
9. int sframes = 0;
10. int eframes = 0;
11. int nframes = 0;
12. int lprate = 15 ;
13. 
    
14. //String fnmatch = "20130812_18" ; // files matched to this string
15. String fnmatch = "20121012_" ; // files matched to this string
16. String fpath = "C:\\Users\\alan\\Documents\\Processing\\StereoRotator1\\data\\HI1B" ;
17. //String fpath = "F:\\Documents\\DMKALLSKY1\\data\\20130812meteor" ; // filepath to images
18. 
    
19. 
    
20. void setup() {
21.   size(968, 720);
22.   frameRate(lprate);
23.   //
24.   File dir = new File(dataPath(fpath)); 
25.   list = dir.listFiles();
26.   //
27.   mloop() ;  // match file names
28.   //
29.   ldloop();  // load matched files
30.   //
31. }
32. 
    
33. void draw() {
34.   background(0);
35. 
    
36.   floop();  // show image loop
37. 
    
38.   text("[ "+frameCount+" / "+nframes+" ][ FPS "+lprate+" ]", 500, 10 );  
39. 
    
40.   frameRate(lprate);
41.   // g.removeCache(imgs); // do not remove this line
42. }
43. 
    
44. void floop() {
45.   image(imgs[abs(frameCount)], 0, 0, width, height);
46.   if (frameCount >= nframes-1) { 
47.     frameCount = -(nframes) ;
48.   } 
49.   if (frameCount == -1) { 
50.     frameCount = 1 ;
51.   }
52. }
53. 
    
54. void mloop() {
55.   for ( Nimg = 0; Nimg < list.length ; Nimg++) {
56.     //
57.     String fn = list[Nimg].getAbsolutePath();
58.     String[] m2 = match(fn, fnmatch );
59.     if (m2 != null) {
60.       eframes = Nimg  ;
61.       nframes++ ;
62.       // println(list.length+" "+sframes+" "+eframes+" "+nframes+ "Match found in '" + list[Nimg] + "'\n"+fn);
63.     }   
64.     else {
65.       // This will print to the console, since no match was found.
66.       sframes = (eframes - nframes)  ;
67.       // println(sframes+" "+eframes+" "+nframes+ "No match found in '" + list[Nimg] + "'\n"+fn);
68.     }
69.   }
70. }
71. 
    
72. void ldloop() {
73.   // load matched images
74.   imgs = new PImage[nframes];  
75. 
    
76.   for (int x = 1; x < nframes; x++)
77.   {
78.     imgs[x] = loadImage(list[(sframes+x)].getAbsolutePath());
79.     print( x + " images loaded\n ") ;
80.   }
81. }
82. 
    
83. void keyPressed() {
84.   //
85.   if (key =='x') { 
86.     exit();
87.   } 
88.   if (key =='c') { 
89.     background(0);
90.   }
91.   if (key =='-') {  
92.     lprate=lprate-1 ; 
93.     if (lprate <= 0) { 
94.       lprate=1 ;
95.     }
96.   }
97.   if (key =='=') {  
98.     lprate=lprate+1 ; 
99.     if (lprate >= 30) { 
100.       lprate= 30 ;
101.     }
102.   }
103.   //
104. }

A link to my code is at the blog....

Meteor camera - DIY

( http://cometal-comets.blogspot.com.au/2013/04/meteor-camera-diy.html )

Question, has anyone  thought of combining processing with ImageJ ( used mainly for medical imaging) but good for pixelmath.?

Hope you like it, feel free to make it better,

 kind regards, Alan

Gidday , First time here.

I just wanted to share this example of a solar system with planets and comets.

While it uses some real world data, its not accurate....may be later.  Regards Alan.

 

// new orbit example
//  nplanets and ncomets
import processing.opengl.*;
//

float timestep = 200.0 ;
float theta = 0.0;
int scl = 1;

// array of orbital info
String[] pname = {"SUN", "MER", "VEN", "STA", "EAR", "STB", "MAR", "P/2012 A3\nSOHO", "C/2012 S1\nISON", "C/2011 W3\nLovejoy"};
float[] pnum = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
float[] ecc =  {0, 0.206, 0.007, 0.009562656, 0.017, 0.004440, 0.093, 0.776, 0.995, 0.995}; // eccenticity
float[] au =  {0, 0.39, 0.72, 0.95539896, 1.0, 1.051887, 1.52, 2.568, 10.0, 78.68 }; // mean distance 1au
float[] rot = {0, 0.24, 0.62, 0.93326171, 1, 1.078152, 1.88, 4.12, 10.0, 10.0}; // period of rotation 1yr
float[] eqtr = {3.0, 0.382, 0.949, 0.1, 1, 0.1, 0.532, 0.1, 0.1, 0.1};   // 1 earth diam
float[] angl = {0.0, 29.124, 55.186, 259.41452171, 114.20783, 18.37796930629710, 286.537, 217.6673, 295.7576, 332.02321}; // perri

//
PFont fontA = createFont("SanSerif", 12);
PFont fontB = createFont("SanSerif", 16);
//

//  
void setup() {
  size(1024, 1024, OPENGL);
}

void draw()
{
 background(0);
 
 // Translate the origin point to the center of the screen
  translate(width/2, height/2)  ;
 
  ellipseMode(RADIUS);

  nplanets();  // draw planets
  ncomets() ;  // draw comets

    theta +=(0.00004109*(1+timestep));
  
}

void keyReleased() {
  //
  if (key =='x') { exit(); }
  if (key =='c') { background(0); }
  if (key =='[') { scl-=1 ; if (scl <= 0) {scl = 1;}}
  if (key ==']') { scl+=1 ; if (scl >= 100) { scl = 100;}}
  if (key =='-') { timestep-=100 ; if (timestep <= -1000) {timestep = -1000;}}
  if (key =='=') { timestep+=100 ; if (timestep >= 1000) { timestep = 1000;}}
}

void nplanets() {
  // draw planets
  for ( int np = 6 ; np > -1 ; np-=1 ) {  
    float e1 = ecc[np];
    float a1 = (au[np]*300  );
    float b1 = a1*sqrt(1-(e1*e1))  ;
    float c1 = a1*e1  ;
    float  l1 = (b1*b1)/a1  ;

    float r1 = l1/(1.0+(e1*cos(angl[np]+theta/rot[np])));
    float x1 = r1*cos(angl[np]+theta/rot[np]);
    float y1 = -r1*sin(angl[np]+theta/rot[np]);

    //draw orbit
    stroke(32); fill(255/(np+1),255/(np+1),16/(np+1),16);strokeWeight(2);  // transparent orbit plane
    ellipse(0, 0, r1/scl, r1/scl);

    // draw planet at orbit angle
    stroke(200, 200, 200);  fill(36*(np+1),36*(np+1),16*(np+1),255);
    ellipse(int(x1)/scl, int(y1)/scl, (3*eqtr[np])/scl, (3*eqtr[np])/scl);
    //sphere((3*eqtr[np])/scl );
    stroke(255);  fill(255);
    textFont(fontA, 12); textAlign(LEFT);
    text( np+" "+pname[np], (1+int(x1)/scl), (-1+int(y1)/scl));
  }
}

void ncomets() {
  // draw comets
  for ( int nc = 9 ; nc > 6 ; nc-=1 ) {
    float ec = ecc[nc];
    float ac = (au[nc]*300 );
    float bc = (ac*sqrt(1-(ec*ec)))  ;
    float cc = ac*ec  ;
    float  lc = (bc*bc)/ac  ;

    float rc = lc/(1.0+(ec*cos(angl[nc]+theta/rot[nc])));
    float xc = (rc*cos(angl[nc]+theta/rot[nc]))+(2*cc);
    float yc = (-rc*sin(angl[nc]+theta/rot[nc]));
    // draw at orbit angles
    stroke(200, 200, 200); fill(200, 200, 200);
    ellipse(int(xc)/scl, int(yc)/scl, (3*eqtr[nc]), (3*eqtr[nc]));
    stroke(255); fill(255);
    textFont(fontA, 12); textAlign(LEFT);
    text( pname[nc], (1+int(xc)/scl), (-1+int(yc)/scl));
  }
}