How to import OPENGL in Processing inside java calss for Netbeans?

hornig

How to import OPENGL in Processing inside java calss for Netbeans?

in Integration and Hardware • 1 year ago

Hi,

I would like to do this kind of 3d scatter https://forum.processing.org/topic/3d-scatter-plot but inside a java class, because I do calculations in java that I don't want to do in pure processing.
But I don't know how to import the missing OPENGL right. I tested other non opengl things and it worked fine http://youtu.be/MqMHmBnos7k . I added all the jar libraries I found in the processing collection. But there is no opengl and I'm not sure which to take and how to import it rightly.

Could anyone help me with that?

Best regards, Andreas

Replies(5)

monkstone

Re: How to import OPENGL in Processing inside java calss for Netbeans?

1 year ago

If you are using processing 1.5.1 this might be what you want link, funnily enough I've just updated advice to cope with changes in processing-2.0a7. Advice is tailored for 64 bit linux but I'm sure you can adjust.

hornig

Re: Re: How to import OPENGL in Processing inside java calss for Netbeans?

1 year ago

Hi monstone,

wow, cool, it works now! :)
http://img685.imageshack.us/img685/5967/processingalpha2opengl.png
but I'm not sure if it's the alpha stadium, but I get two areas with the "stop" sign (image, bottom left as usual, but also upper left but without the stop letters on that image).
and is it right that there is just the canvas area displayed? because with 1.5.1 the complete screen is black and then there is the canvas on it.

best regards and thanks so far! :)

Andreas

monkstone

Re: How to import OPENGL in Processing inside java calss for Netbeans?

1 year ago

Glad it was useful, by the way setting up the opengl library you only need to include jars for your own OS/architecture.

To avoid stop button and present mode you only need the following, where box.newP5Main is your class,

of course you could just enter it as a String "box.newP5Main"

PApplet.main(new String[]{box.newP5Main.class.getName()});

To have stop button in present mode and specify the external background

PApplet.main(new String[]{"--present", "--bgcolor=#DFDFDF", box.newP5Main.class.getName()});

hornig

Re: How to import OPENGL in Processing inside java calss for Netbeans?

1 year ago

Hi everyone,

I played arount with it and it worked so far until I added rect()s and some text and now it's garbaging my ram and my laptop get's super slow.

Is it the new alpha, or is it normal with rect()s or is it just me. I would say it's me, but I can't really say.

do you have some advices?

Andreas

hornig

Re: How to import OPENGL in Processing inside java calss for Netbeans?

1 year ago

Hi again,

so, here is my crap code :). perhaps you can tell me why my way doesn't work.
and I know it's provisorical, but I wanted to see how it works.

Andreas

package pseudoranger;

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

/**
*
* @author admin
*/

import processing.core.*;
import processing.opengl.*;

public class MyProcessingSketch extends PApplet {
    PApplet parent; // The parent PApplet that we will render ourselves onto

    PVector[] vecs = new PVector[15];
    int dim = 500;
    int x = 0;
    int y = 0;
    PFont f;

    int edge_x = 40;
    int edge_y = 50;

    public void setup() {
      size(1366,768,OPENGL);
      f = createFont("Arial",20,true);
      frameRate(4);
    }

    public void draw() {
      background(0);
      // signs
      /*
      strokeWeight(5);
      stroke(255);
      fill(255);
      rect(edge_x,edge_y,230,60,2);

      textFont(createFont("Arial",50,true));
      fill(0);
      text("hgg.aero",edge_x+15,edge_y+48);

      stroke(255,255,0);
      fill(255,255,0);
      rect(edge_x,edge_y+60+15,200,60,2);
      textFont(f);
      fill(0);
      text("distributed ground",edge_x+12+8,edge_y+60+39);
      text("station network",edge_x+22+8,edge_y+60+67);

      textFont(createFont("Arial",50,true));
      stroke(255,255,0);
      fill(255,255,0);
      rect(edge_x,edge_y+425+(60+15),210,60,2);
      fill(0);
      text("mode: "+Main.rangemode,edge_x+12+8,edge_y+425+60+65);

      int y_bb = 100;
      stroke(255,255,0);
      fill(255,255,0);
      rect(edge_x,edge_y+y_bb+400+(60+15),240,60,2);
      textFont(f);
      textFont(f);
      fill(0);
      text("ground stations: "+Main.x.length,edge_x+12+8,edge_y+y_bb+400+60+39);
      text("in groups of "+stationcombinations.Main.stationtaken.length,edge_x+12+8,edge_y+y_bb+400+60+67);

      stroke(255,255,0);
      fill(255,255,0);
      rect(edge_x,edge_y+y_bb+400+2*(60+15),330,30,2);
      textFont(f);
      fill(0);
      text("combinations = "+stationcombinations.Main.combinationCount+" / done = "+stationcombinations.Main.counter,edge_x+12+8,edge_y+y_bb+400+2*(60+15)+21);

      // right
      stroke(0,255,0);
      fill(0,255,0);
      rect(1130,edge_y+60+15,200,60,2);
      textFont(f);
      fill(0);
      text("real beacon:",1130+12+8,edge_y+60+39);
      text("[0.0,0.0,7173] km",1130+12+8,edge_y+60+67);

      if(Auxiliary.b_count>=2){
      stroke(0,0,255);
      fill(0,0,255);
      rect(1000,edge_y+y_bb+400+2*(60+15),330,30,2);
      textFont(f);
      fill(0);
      text("mode 0: ["+Auxiliary.b[0][0]+","+Auxiliary.b[0][1]+","+Auxiliary.b[0][1]+"]",1000+12+8,edge_y+y_bb+400+2*(60+15)+21);

      stroke(0,0,255);
      fill(0,0,255);
      rect(1000,edge_y+y_bb+400+1*(60+15)+30,330,30,2);
      textFont(f);
      fill(0);
      text("mode 0: ["+Auxiliary.b[1][0]+","+Auxiliary.b[1][1]+","+Auxiliary.b[1][1]+"]",1000+12+8,edge_y+y_bb+400+1*(60+15)+30+21);
      }

      if(Auxiliary.b_count>=4){
      stroke(0,0,255);
      fill(0,0,255);
      rect(1000,edge_y+y_bb+400+2*(60+15)-100,330,30,2);
      textFont(f);
      fill(0);
      text("mode 1: ["+Auxiliary.b[2][0]+","+Auxiliary.b[2][1]+","+Auxiliary.b[2][1]+"]",1000+12+8,edge_y+y_bb+400+2*(60+15)+21-100);

      stroke(0,0,255);
      fill(0,0,255);
      rect(1000,edge_y+y_bb+400+1*(60+15)+30-100,330,30,2);
      textFont(f);
      fill(0);
      text("mode 1: ["+Auxiliary.b[3][0]+","+Auxiliary.b[3][1]+","+Auxiliary.b[3][1]+"]",1000+12+8,edge_y+y_bb+400+1*(60+15)+30+21-100);
      }

      if(Auxiliary.b_count>=6){
      stroke(0,0,255);
      fill(0,0,255);
      rect(1000,edge_y+y_bb+400+2*(60+15)-200,330,30,2);
      textFont(f);
      fill(0);
      text("mode 1: ["+Auxiliary.b[4][0]+","+Auxiliary.b[4][1]+","+Auxiliary.b[4][1]+"]",1000+12+8,edge_y+y_bb+400+2*(60+15)+21-200);

      stroke(0,0,255);
      fill(0,0,255);
      rect(1000,edge_y+y_bb+400+1*(60+15)+30-200,330,30,2);
      textFont(f);
      fill(0);
      text("mode 1: ["+Auxiliary.b[5][0]+","+Auxiliary.b[5][1]+","+Auxiliary.b[5][1]+"]",1000+12+8,edge_y+y_bb+400+1*(60+15)+30+21-200);
      }
      */
/*
textFont(f);
fill(0);
text("This text is right aligned.",20,140);

textFont(createFont("Arial",32,true));
fill(255);
text("hgg.aero",1100,140);
*
*/


      translate(width/2,height/2);
      scale(1,-1,1); // so Y is up, which makes more sense in plotting

      rotateX(radians(-47));//mouseY));
      rotateZ(radians(frameCount));//mouseY));
     stroke(255);
      noFill();
      strokeWeight(2);
      box(dim);

      int scale = 15;

      int[][] grids = new int[34][2];
      int k = 0;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
      k = k+1;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
       k = k+1;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
       k = k+1;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
       k = k+1;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
       k = k+1;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
       k = k+1;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
       k = k+1;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
       k = k+1;
      grids[0+k][0] = 5+k;
      grids[0+k][1] = 6+k;
      k = k+1;
      grids[0+k][0] = 14;
      grids[0+k][1] = 5;
      k = k+1;
      grids[0+k][0] = 0;
      grids[0+k][1] = 1;
      k = k+1;
      grids[0+k][0] = 1;
      grids[0+k][1] = 2;
      k = k+1;
      grids[0+k][0] = 2;
      grids[0+k][1] = 3;
      k = k+1;
      grids[0+k][0] = 3;
      grids[0+k][1] = 4;
      k = k+1;
      grids[0+k][0] = 0;
      grids[0+k][1] = 3;
      k = k+1;
      grids[0+k][0] = 1;
      grids[0+k][1] = 3;
      k = k+1;
      grids[0+k][0] = 0;
      grids[0+k][1] = 4;
      k = k+1;
      grids[0+k][0] = 0;
      grids[0+k][1] = 5;
      k = k+1;
      grids[0+k][0] = 0;
      grids[0+k][1] = 6;
      k = k+1;
      grids[0+k][0] = 1;
      grids[0+k][1] = 6;
      k = k+1;
      grids[0+k][0] = 1;
      grids[0+k][1] = 7;
      k = k+1;
      grids[0+k][0] = 1;
      grids[0+k][1] = 8;
      k = k+1;
      grids[0+k][0] = 2;
      grids[0+k][1] = 8;
      k = k+1;
      grids[0+k][0] = 2;
      grids[0+k][1] = 9;
      k = k+1;
      grids[0+k][0] = 2;
      grids[0+k][1] = 10;
      k = k+1;
      grids[0+k][0] = 3;
      grids[0+k][1] = 10;
      k = k+1;
      grids[0+k][0] = 4;
      grids[0+k][1] = 10;
      k = k+1;
      grids[0+k][0] = 4;
      grids[0+k][1] = 11;
      k = k+1;
      grids[0+k][0] = 4;
      grids[0+k][1] = 12;
      k = k+1;
      grids[0+k][0] = 4;
      grids[0+k][1] = 13;
      k = k+1;
      grids[0+k][0] = 0;
      grids[0+k][1] = 13;
      k = k+1;
      grids[0+k][0] = 0;
      grids[0+k][1] = 14;

      stroke(255,75);
      strokeWeight(2);
      int x1;
      int y1;
      int z1;
      int x2;
      int y2;
      int z2;
      for(int i=0; i<grids.length; i++){
          x1 = Test.points_pointgrd[grids[i][0]][0];
          y1 = Test.points_pointgrd[grids[i][0]][1];
          z1 = Test.points_pointgrd[grids[i][0]][2];
          x2 = Test.points_pointgrd[grids[i][1]][0];
          y2 = Test.points_pointgrd[grids[i][1]][1];
          z2 = Test.points_pointgrd[grids[i][1]][2];
          line(x1,y1,z1,x2,y2,z2);
      }

      for (int i=0; i<Test.points_pointgrd.length; i++) {
          int flash = 0;
          for(int j=0; j<stationcombinations.Main.stationtaken.length;j++){
              if(i==stationcombinations.Main.takestations[j]){
                  flash = 1;
              }
          }
          if(flash==0){
            stroke(255);
            strokeWeight(12);
          } else{
            stroke(255,0,0);
            strokeWeight(20);
          }
        point(Test.points_pointgrd[i][0],Test.points_pointgrd[i][1],Test.points_pointgrd[i][2]);
      }

      //target
       stroke(0,255,0);
        strokeWeight(12);
        point(Test.target_vec[0],Test.target_vec[1],Test.target_vec[2]);

       //beacon
       stroke(0,0,255);
        strokeWeight(12);

        for(int l=0; l<stationcombinations.Main.factor; l++){
        int x_b = (int)((pseudoranger.Main.m_x[stationcombinations.Main.counter+l])/(4*100000)*200);
        int y_b = (int)((pseudoranger.Main.m_y[stationcombinations.Main.counter+l])/(4*100000)*200);//-3400;
        int z_b = (int)((pseudoranger.Main.m_z[stationcombinations.Main.counter+l])/(4*(100000))*200)-3400;
        point(x_b,y_b,z_b);


        int x2_b;
        int y2_b;
        int z2_b;
        for(int i=0; i<stationcombinations.Main.stationtaken.length;i++){
                //stationcombinations.Main.takestations[i]=stationcombinations.Main.stationtaken[i];
                //System.out.print(takestations[i]+";");
                x2_b = Test.points_pointgrd[stationcombinations.Main.takestations[i]][0];
                y2_b = Test.points_pointgrd[stationcombinations.Main.takestations[i]][1];
                z2_b = Test.points_pointgrd[stationcombinations.Main.takestations[i]][2];
                stroke(255);
                strokeWeight(2);
                line(x2_b,y2_b,z2_b,x_b,y_b,z_b);
            }
        }
    }


    public void mouseDragged(){
      x=mouseX;
      y=mouseY;
    }
}

Top Reply