Loading...
Logo
Processing Forum
Integration and Hardware
p3tr4s
p3tr4s

Processing sketch conversion to eclipse.

in Integration and Hardware  •  5 months ago  
Hello,

I would like to ask your help converting processing sketch to eclipse.

I am new to eclipse, I know how to implement class to get all the functionality from the main tab from Chose Sanchez tutorials.

For learning purposes, day to day I try to rewrite other people sketches.

But, when I try to rewrite sketches I usually get errors. Errors comes not from my writing mistakes but from difference in  know, that there is difference with syntax between these 2 applications. 

Please help me make this sketch work in eclipse; 
This would be enormous help for me for now and future. I really want to learn eclipse... 

Thank you very much.

Down here is processing sketch, and below it is eclipse sketch that does not work.

Processing:
Copy code
  2. int number_of_particles;
  3. line[] lines;
  4. collision collision;


  7. void setup() {
  8.   size(1280,720,OPENGL);
  9.   frameRate(20);
  10.   background(0);
  11.   number_of_particles = 6;
  12.   lines = new line[number_of_particles];
  13.   for( int x=0; x < number_of_particles; x++) {
  14.     lines[x] = new line();
  15.     lines[x].spawn_random();
  16.   }
  17.   collision = new collision(lines);
  18. }
  19. void draw() {

  21.   
  22.   for( int x=0; x < number_of_particles; x++) {
  23.     line temp_line = lines[x].draw();
  24.     if( temp_line != null) {
  25.       lines = (line[]) append(lines,temp_line);
  26.       collision.add_line(lines[number_of_particles]);
  27.       number_of_particles ++;
  28.     }
  29.   }

  31.   collision.of_lines();
  32.  
  33. }

  35. float[] collision_line_line(float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, float p4_x, float p4_y) {
  36.   float xD1,yD1,xD2,yD2,xD3,yD3;
  37.   float dot,deg,len1,len2;
  38.   float segmentLen1,segmentLen2;
  39.   float ua,ub,div;

  41.   // calculate differences
  42.   xD1=p2_x-p1_x;
  43.   xD2=p4_x-p3_x;
  44.   yD1=p2_y-p1_y;
  45.   yD2=p4_y-p3_y;
  46.   xD3=p1_x-p3_x;
  47.   yD3=p1_y-p3_y;  

  49.   // calculate the lengths of the two lines
  50.   len1=sqrt(xD1*xD1+yD1*yD1);
  51.   len2=sqrt(xD2*xD2+yD2*yD2);

  53.   // calculate angle between the two lines.
  54.   dot=(xD1*xD2+yD1*yD2); // dot product
  55.   deg=dot/(len1*len2);

  57.   // if abs(angle)==1 then the lines are parallell,
  58.   // so no intersection is possible
  59.   if(abs(deg)==1) return null;

  61.   // find intersection Pt between two lines
  62.   float pt_x;
  63.   float pt_y;
  64.  // Point pt=new Point(0,0);
  65.   div=yD2*xD1-xD2*yD1;
  66.   ua=(xD2*yD3-yD2*xD3)/div;
  67.   ub=(xD1*yD3-yD1*xD3)/div;
  68.   pt_x=p1_x+ua*xD1;
  69.   pt_y=p1_y+ua*yD1;

  71.   // calculate the combined length of the two segments
  72.   // between Pt-p1 and Pt-p2
  73.   xD1=pt_x-p1_x;
  74.   xD2=pt_x-p2_x;
  75.   yD1=pt_y-p1_y;
  76.   yD2=pt_y-p2_y;
  77.   segmentLen1=sqrt(xD1*xD1+yD1*yD1)+sqrt(xD2*xD2+yD2*yD2);

  79.   // calculate the combined length of the two segments
  80.   // between Pt-p3 and Pt-p4
  81.   xD1=pt_x-p3_x;
  82.   xD2=pt_x-p4_x;
  83.   yD1=pt_y-p3_y;
  84.   yD2=pt_y-p4_y;
  85.   segmentLen2=sqrt(xD1*xD1+yD1*yD1)+sqrt(xD2*xD2+yD2*yD2);

  87.   // if the lengths of both sets of segments are the same as
  88.   // the lenghts of the two lines the point is actually
  89.   // on the line segment.

  91.   // if the point isn't on the line, return null
  92.   if(abs(len1-segmentLen1)>0.1 || abs(len2-segmentLen2)>0.1)
  93.     return null;

  95.   // return the valid intersection

  97.   float[] output = new float[2];

  99.   output[0] = pt_x;
  100.   output[1] = pt_y;

  102.   return output;
  103. }
  106. class collision {


  109.   line[] lines= new line[0];

  111.   int total;

  113.   collision(line[] lines) {
  114.     this.lines = lines;
  115.     total = lines.length;
  116.   }

  118.   void add_line(line new_line) {
  119.     lines = (line[]) append(lines,new_line);
  120.     total++;
  121.   }

  123.   float[] temp = new float[2];

  125.   void of_lines() {


  128.     for( int x=0; x< total; x++) {

  130.       if(    (lines[x].end.x <0)||(lines[x].end.x>width)   ||   (lines[x].end.y <0)||(lines[x].end.y>height)         ) {
  131.         lines[x].collision = true;
  132.       }

  134.       for( int y=0; y< total; y++) {

  136.         if( ! lines[x].collision) {

  138.           if (x != y) {
  139.             temp =collision_line_line(lines[x].start.x,lines[x].start.y,lines[x].end.x,lines[x].end.y,lines[y].start.x,lines[y].start.y,lines[y].end.x,lines[y].end.y);

  141.             if( temp != null) {

  143.               if( ( abs(temp[0])-abs(lines[x].end.x)  < 5) && (abs(temp[1])-abs(lines[x].end.y) <5 )) {
  144.                 lines[x].collision();
  145.               }
  146.             }
  147.           }
  148.         }
  149.       }
  150.     }
  151.   }
  152. }
  155. class line {

  157.   PVector start = new PVector(); 
  158.   PVector end   = new PVector(); 

  160.   float velocity;
  161.   int way;

  163.   int spawn_base=4;
  164.   int spawn_rate=spawn_base;
  165.   int children_counter;
  166.   int children_max= 5;
  167.   float heading;
  168.   line child_line;

  170.   line() {
  171.     velocity = 2;
  172.   }

  174.   void spawn_random() {

  176.     start.x =  random(0, width);
  177.     start.y =  random(0, height);

  179.     end.x   =  start.x+random(-1, 1) ;
  180.     end.y   =  start.y+random(-1, 1) ;

  182.     heading = get_heading();
  183.   }


  186.   void spawn_location(float x, float y, float heading) {

  188.     way = round(random(-1, 1));

  190.     heading = heading+HALF_PI*way;


  193.     if (heading > TWO_PI) {
  194.       heading-=TWO_PI;
  195.     }

  197.     if (heading < -TWO_PI) {
  198.       heading+=TWO_PI;
  199.     }

  201.     this.heading=heading;


  204.     start.x = x + cos( heading)*velocity;
  205.     start.y = y + sin( heading)*velocity;

  207.     end.x =  start.x + cos( heading)*velocity;
  208.     end.y =  start.y + sin( heading)*velocity;
  209.   }




  214.   boolean spawn_timer() {

  216.     if (children_counter < children_max) {
  217.       if ( spawn_rate == 0 ) {
  218.         spawn_base *=spawn_base;
  219.         spawn_rate= spawn_base;
  220.         children_counter++;  
  221.         return true;
  222.       }
  223.       spawn_rate--;
  224.     }
  225.     return false;
  226.   }

  228.    line child_line() {

  230.     if ( (!collision)  && (spawn_timer()) ) {
  231.       child_line = new line();
  232.       child_line.spawn_location(end.x, end.y, heading);
  233.       return child_line;
  234.     }
  235.     else {
  236.       return null;
  237.     }
  238.   }

  240.   line draw() {
  241.     if ( ! collision) {

  243.       stroke(255);

  245.       line(start.x, start.y, end.x, end.y);
  246.       grow();
  247.       return child_line();
  248.     }
  249.     line(start.x, start.y, end.x, end.y);
  250.     return null;
  251.   }


  254.   float get_heading() {
  255.     return atan2(  start.y - end.y, start.x - end.x);
  256.   }

  258.   void grow() {

  260.     end.x +=  cos(heading)* (velocity);
  261.     end.y +=  sin(heading)* (velocity);
  262.   }

  264.   boolean  collision = false;

  266.   void collision() {
  267.     collision = true;
  268.   }
  269. }

Eclipse code:


Copy code
  2. package lines;

  4. import processing.core.PApplet;


  7. public class Lines extends PApplet {
  9. int number_of_particles = 6;
  10. Line[] lines;
  11. collision collission;
  13. public void setup() {
  15. size(1280,720,P3D);
  16. background(0);
  17. smooth();
  19. lines = new Line[number_of_particles];
  21. for (int x = 0; x < number_of_particles; x++) {
  22. lines[x] = new Line();
  23. lines[x].spawn_random();
  24. }
  26. collission = new collision(lines);
  28. }

  30. public void draw() {
  32. for(int x = 0; x < number_of_particles; x++){
  33. Line temp_line = lines[x].draw();
  34. if ( temp_line != null) {
  35. lines = (Line[]) append(lines,temp_line);
  36. collision.add_line(lines[number_of_particles]);
  37. number_of_particles ++; /////////////////////////////  del to stringa?
  38. }
  39. }
  41. collsion.of_lines();
  43. }
  45. float[] collision_line_line(float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, float p4_x, float p4_y){
  47. float xD1,yD1,xD2,yD2,xD3,yD3;
  48. float dot,deg,len1,len2;
  49. float segmentLen1,segmentLen2;
  50. float ua,ub,div;
  52.  // calculate differences
  53.  xD1=p2_x-p1_x;
  54.  xD2=p4_x-p3_x;
  55.  yD1=p2_y-p1_y;
  56.  yD2=p4_y-p3_y;
  57.  xD3=p1_x-p3_x;
  58.  yD3=p1_y-p3_y; 
  59.  
  60.  //calculate the lengths of the two lines
  61.  len1 = sqrt(xD1*xD1+yD1*yD1);
  62.  len2 = sqrt(xD2*xD2+yD2*yD2);
  63.  
  64.  //calculate angle between the two lines
  65.  dot=(xD1*xD2+yD1*yD2); // dot product
  66.  deg=dot/(len1*len2);
  67.  
  68.  // if abs(angle) == 1 then the lines are parallell,
  69.  // if no -> intersection is possible
  70.  
  71.  if(abs(deg)==1) return null;
  72.  
  73.  //find intersection Pt between two lines;
  74.  float pt_x;
  75.  float pt_y;
  76.  
  77.  div=yD2*xD1-xD2*yD1;
  78.  ua=(xD2*yD3-yD2*xD3)/div;
  79.  ub=(xD1*yD3-yD1*xD3)/div;
  80.  pt_x=p1_x+ua*xD1;
  81.  pt_y=p1_y+ua*yD1;
  82.  
  83.  //calculate the combined length of the two segments: Pt-p1 and Pt-p2
  84.  xD1=pt_x-p1_x;
  85.  xD2=pt_x-p2_x;
  86.  yD1=pt_y-p1_y;
  87.  yD2=pt_y-p2_y;
  88.  segmentLen1=sqrt(xD1*xD1+yD1*yD1)+sqrt(xD2*xD2+yD2*yD2);
  89. //calculate the combined length of the two segments: Pt-p1 and Pt-p2
  90.  xD1=pt_x-p3_x;
  91.  xD2=pt_x-p4_x;
  92.  yD1=pt_y-p3_y;
  93.  yD2=pt_y-p4_y;
  94.  segmentLen2=sqrt(xD1*xD1+yD1*yD1)+sqrt(xD2*xD2+yD2*yD2);
  95.  
  96.  // if the lengths of both sets of segments are the same as
  97.  // the lengths of the two lines the point is actually
  98.  // on the line segment
  99.  
  100.  //if the points is not on the line, return null
  101.  
  102.  if(abs(len1-segmentLen1)>0.01 || abs(len2-segmentLen2)>0.01)
  103.    return null;
  104.  
  105.  //return the valid intersection
  106.  
  107.  float[] output = new float[2];
  108.  
  109.  output[0] = pt_x;
  110.  output[1] = pt_y;
  111.  
  112.  return output;  
  117. }
  118. }
class Line:
Copy code
  2. package lines;

  4. import processing.core.PVector;

  6. public class Line {

  8. Lines e;
  9. PVector start = new PVector();
  10. PVector end = new PVector();
  11. float velocity;
  12. int way;
  13.     int spawn_base=4;
  14.     int spawn_rate=spawn_base;
  15.     int children_counter;
  16.     int children_max= 5;
  17.     float heading;
  18.     Line child_line;
  19.     
  20. Line(Lines _e){
  22. e = _e;
  23. velocity = 2;
  25. }
  27. void spawn_random(){
  29. start.x = e.random(0,e.width);
  30. start.y = e.random(0,e.height);
  32. end.x = start.x+e.random(-1,1);
  33. end.y = start.y+e.random(-1,1);
  35. heading = get_heading();  
  37. }
  39. void spawn_location(float x, float y, float heading){
  41. way = e.round(e.random(-1,1));
  42. heading = e.heading+e.HALF_PI*way;
  44. if (heading>e.TWO_PI){
  45. heading-=e.TWO_PI;
  46. }
  48. if (heading<-e.TWO_PI){
  49. heading+=e.TWO_PI;
  50. }
  52. this.heading = heading;
  54. start.x = x + e.cos( heading)*velocity;
  55. start.y = y + e.sin( heading)*velocity;

  57. end.x =  start.x + e.cos( heading)*velocity;
  58. end.y =  start.y + e.sin( heading)*velocity;
  60. }
  62. boolean spawn_timer() {
  64. if(children_counter < children_max){
  65. if(spawn_rate == 0){
  66. spawn_base *= spawn_base;
  67. spawn_rate = spawn_base;
  68. children_counter++;
  69. return true;
  70. }
  71. spawn_rate--;
  72. }
  73. return false;
  74. }
  76. Line child_line() {

  78.    if ( (!collision)  && (spawn_timer()) ) {
  79.      child_line = new Line();
  80.      child_line.spawn_location(end.x, end.y, heading);
  81.      return child_line;
  82.    }
  83.    else {
  84.      return null;
  85.    }
  86.  }
  87.  
  88. Line draw() {
  89.    if ( ! collision) {

  91.      e.stroke(255);

  93.      Line(start.x, start.y, end.x, end.y);
  94.      grow();
  95.      return child_line();
  96.    }
  97.    Line(start.x, start.y, end.x, end.y);
  98.    return null;
  99.  }


  102.  float get_heading() {
  103.    return e.atan2(  start.y - end.y, start.x - end.x);
  104.  }

  106.  void grow() {

  108.    end.x +=  e.cos(heading)* (velocity);
  109.    end.y +=  e.sin(heading)* (velocity);
  110.  }

  112.  boolean  collision = false;

  114.  void collision() {
  115.    collision = true;
  116.  }
  117. }
class collide:


Copy code
  2. class collision {


  5.   line[] lines= new line[0];

  7.   int total;

  9.   collision(line[] lines) {
  10.     this.lines = lines;
  11.     total = lines.length;
  12.   }

  14.   void add_line(line new_line) {
  15.     lines = (line[]) append(lines,new_line);
  16.     total++;
  17.   }

  19.   float[] temp = new float[2];

  21.   void of_lines() {


  24.     for( int x=0; x< total; x++) {

  26.       if(    (lines[x].end.x <0)||(lines[x].end.x>width)   ||   (lines[x].end.y <0)||(lines[x].end.y>height)         ) {
  27.         lines[x].collision = true;
  28.       }

  30.       for( int y=0; y< total; y++) {

  32.         if( ! lines[x].collision) {

  34.           if (x != y) {
  35.             temp =collision_line_line(lines[x].start.x,lines[x].start.y,lines[x].end.x,lines[x].end.y,lines[y].start.x,lines[y].start.y,lines[y].end.x,lines[y].end.y);

  37.             if( temp != null) {

  39.               if( ( abs(temp[0])-abs(lines[x].end.x)  < 5) && (abs(temp[1])-abs(lines[x].end.y) <5 )) {
  40.                 lines[x].collision();
  41.               }
  42.             }
  43.           }
  44.         }
  45.       }
  46.     }
  47.   }
  48. }

Thank you.

Replies(3)

monkstone
monkstone

Re: Processing sketch conversion to eclipse.

5 months ago
The easiest way is to export the sketch (then use the generated java file). Or what I usually do on linux is just run the sketch (from the processing ide) then pick up the generated java file from the /tmp folder (it will be somewhere else on  Mac/Windows). This generates a file with all inner classes, there is tool in Netbeans (I expect Eclipse, has such a tool) to refactor inner classes to self contained classes. Do this sort of thing a few times and you will soon get to know the different syntax.
p3tr4s
p3tr4s

Re: Processing sketch conversion to eclipse.

5 months ago
Dear monkstone,

By this line:
.... Or what I usually do on linux is just run the sketch (from the processing ide) then pick up the generated java file from the /tmp folder (it will be somewhere else on  Mac/Windows).  ...

Do you mean:
1) Open processing and run the sketch;
2) after running the script there is temporary processing file created

Or you mean:

1) Open eclipse somehow run the script (How to run processing in eclipse?)

I tried to search through processing files, there were no temporary files.
But in eclipse I found files named:
.tmp449117427675497990.instance

Is it .tmp file you wrote?

Sorry for silly questions

monkstone
monkstone

Re: Re: Processing sketch conversion to eclipse.

5 months ago
When you run the sketch in the processing ide a temporary java file is created, on linux that ends up in a sub folder in the /tmp directory (actually two folders are created, one contains the java file one contains the class file). If you run the processing_java command line script, then you decide where that temporary file gets created http://wiki.processing.org/w/Command_Line.
Top Reply

Statistics

  • 3 Replies
  • 343  Views
  • 0 Followers

Tags

No tags available for this topic.

Actions

Related Posts