converting from polar coordinates

asimes

Re: converting from polar coordinates

7 months ago

You need to post the entire code, the code above does not have enough information to run the sketch as xo, yo, vert, mini_plage, and maxi_plage are all missing.

lcd1602

Re: converting from polar coordinates

7 months ago

oh excuse me
thank you

import processing.opengl.*;

import processing.serial.*;
Serial port;
//------ déclaration des variables de couleur utiles ----

int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int grisHom=color(128,128,128);
int grisF=color(192,192,192);
int grisC=color(210,210,210);
int grisGrille=color(128,128,128);
int orange = color (255,128,0);
int violet = color( 91,91,255);
int fuchia = color(250,0,255);

// données du scrollbar
int x_pos;
int y_pos;
int largeur;

//int hauteur=16;
float x_plage;
float y_plage;
boolean dessus_plage = false;
boolean Sel_plage = false;
float x_plageOffset = 0;
float y_plageOffset = 0;
float larg_plage;
int deb_pla_old=0;

float decalage;
float rayon;
float xo, yo; // point référence graphique
float angle_radians;
float mini_plage;
float maxi_plage;
int deb_pla=0;

// données triangle mini
float x_tri_min_1;
float y_tri_min_1;
float x_tri_min_2;
float y_tri_min_2;
float x_tri_min_3;
float y_tri_min_3;
float trim_max;
float x_tri_min_2old;

boolean dessus_trimini = false;
boolean Sel_trimini = false;
int x_triminiOffset = 0;
int y_triminiOffset = 0;

// données triangle maxi
int x_tri_max_1;
int y_tri_max_1;
int x_tri_max_2;
int y_tri_max_2;
int x_tri_max_3;
int y_tri_max_3;
int x_tri_max_2old;

boolean dessus_trimaxi = false;
boolean Sel_trimaxi = false;
int x_trimaxiOffset = 0;
int y_trimaxiOffset = 0;

//curseur
int x_curs,y_curs,larg_curs,haut_curs;
boolean dessus_curs=false;
boolean Sel_curs=false;
int x_cursOffset = 0;

// bouton 90°
boolean dessus_90;
boolean Sel_90=false;
int x_90Offset = 0;
int x_90;

int rpm=0;
int gear=0;
float angle_radians2;
void setup()
{
size(400, 420);
println("Available serial ports:");
println(Serial.list());

// Uses the first port in this list (number 0). Change this to
// select the port corresponding to your Arduino board. The last
// parameter (e.g. 9600) is the speed of the communication. It
// has to correspond to the value passed to Serial.begin() in your
// Arduino sketch.

port = new Serial(this, Serial.list()[0], 9600);
// slider
x_pos=20;
y_pos= 180;
largeur=180;
xo=(x_pos+largeur)/2;
yo=y_pos;

// plage
mini_plage= radians(200);
maxi_plage= radians(320);

// triangle min

x_tri_min_2=0;
y_tri_min_2=0;
x_tri_min_1=x_tri_min_2-5;
y_tri_min_1=y_tri_min_2-10;

x_tri_min_3=x_tri_min_2+5;
y_tri_min_3=y_tri_min_2-10;
//x_tri_min_2old=x_tri_min_2;

// triangle max
x_tri_max_2=0;
y_tri_max_2=0;
x_tri_max_1=x_tri_max_2-5;
y_tri_max_1=y_tri_max_2-10;

x_tri_max_3=x_tri_max_2+5;
y_tri_max_3=y_tri_max_2-10;
//x_tri_max_2old=x_tri_max_2;

}

void draw()
{
background(noir);
stroke(color(grisC));
smooth();
tracage();
dessin_plage();

if (keyPressed) {
    if (key==' ') {
      if(rpm<90) {
        if(gear<=1) {
          rpm=rpm+1;

        }
      }
    }
}
else {
    if(rpm>1) {
      rpm=rpm-5;
    }
}

curseur();
fill(blanc);
text( "mouseX : "+mouseX, -90,30);
text( "mouseY : "+mouseY, -90,50);
   text( "x_plage : "+x_plage, -90,70);
    text( "y_plage : "+y_plage, -90,90);
    text("deb_pla : '"+deb_pla,-90,110);
    text("() : '"+deb_pla,30,30);
}//fin de boucle draw
//////////////////////////////////////
void test(){
    // Test si la plage est selectionnée
if (mouseX > x_plage && mouseX < x_plage+larg_plage &&
      mouseY > y_plage-1 && mouseY < y_plage) {
        stroke(rouge);
    dessus_plage = true;
} else {
      noStroke();
    dessus_plage = false;
}
}

/////////////////

// curseur
void curseur(){
   pushMatrix();
    stroke(rouge);
     strokeWeight(2);
      translate(0,0);
       rotate(radians(rpm));
        line (-40,0,-60,0);
         fill(rouge);
          stroke(vert);
//routine retournement triangle Mini -90°
   pushMatrix();
     translate (-60,0);
      rotate (radians(-90));
       triangle (x_tri_min_1,y_tri_min_1,x_tri_min_2,y_tri_min_2,x_tri_min_3,y_tri_min_3);
         popMatrix();

//routine retournement triangle Maxi +90°
   pushMatrix();
     translate (60,0);
      rotate (radians(+90));
     triangle (x_tri_max_1,y_tri_max_1,x_tri_max_2,y_tri_max_2,x_tri_max_3,y_tri_max_3);
         popMatrix();

// fin retournement
println(rpm);

popMatrix();
strokeWeight(1);
}
void dessin_plage(){
translate (xo,yo);
   pushMatrix();
stroke(vert);
strokeCap(SQUARE);

strokeWeight(15); // mini = PI/ maxi =TWO_PI
arc(0,0,97,97,mini_plage,maxi_plage);
popMatrix();
strokeWeight(1);
//triangle mini
}

void tracage(){
decalage=(largeur*0.1);
rayon =((largeur-decalage)/2);

// tracer des rayons angulaires tous les 45°
float degres;
int ajustx=0;
int ajusty=0;
for (int angle=0; angle<=4; angle++) { // défile de 0 à 180 degres
angle_radians=radians(angle*45);
line (xo,yo,xo+(cos(angle_radians)*rayon),yo-(sin(angle_radians)*rayon));

//effacage des lignes intermediaires
fill(noir);
arc(xo,yo,rayon*2.5*0.3*1.9,rayon*2.5*0.3*1.9,PI,TWO_PI);
fill(vert);
stroke (grisC);
//calcul et affichage des degres
degres= (180-(45*angle));
if (angle>2){ajustx=5;ajusty=3;}
else
{ajustx=0;ajusty=3;}
text(int(degres),xo+(cos(angle_radians)*rayon)-6-ajustx ,yo-(sin(angle_radians)*rayon)-3-ajusty);
} // fin boucle rayon
// dessin des deux arcs
stroke(grisC);
noFill();
strokeWeight(2);
arc(xo,yo,rayon*2.5*0.3*1.3,rayon*2.5*0.3*1.3,PI,TWO_PI);
arc(xo,yo,rayon*2.5*0.3*1.9,rayon*2.5*0.3*1.9,PI,TWO_PI);
}// fin void dessin

asimes

Re: converting from polar coordinates

7 months ago

I don't speak French so I had a hard time following the original code and had to make programatic transformations. None of them actually affect the sketch, they just relocate or remove code. If you don't like the changes feel free to use your old code, the test for the green area should still work.

Here is the code:

//import processing.opengl.*;
//import processing.serial.*;
//Serial port;
// données du scrollbar
int x_pos = 20;
int y_pos = 180;
int largeur = 180;
float x_plage = 0;
float y_plage = 0;
int deb_pla = 0;
// point référence graphique
float xo = (x_pos+largeur)/2;
float yo = y_pos;
// plage
float mini_plage = radians(200);
float maxi_plage = radians(320);
// données triangle
float x_tri_1 = 0;
float y_tri_1 = 0;
float x_tri_2 = -5;
float y_tri_2 = -10;
float x_tri_3 = 5;
float y_tri_3 = -10;
int rpm = 0;
void setup() {
size(400, 420);
strokeCap(SQUARE); // Call this once
smooth(); // Call this once
//println("Available serial ports:");
//println(Serial.list());
//port = new Serial(this, Serial.list()[0], 9600);
}
void draw() {
background(0);
tracage();
dessin_plage();
curseur();
fill(255);
strokeWeight(1);
text("mouseX : "+mouseX, -90, 30);
text("mouseY : "+mouseY, -90, 50);
text("x_plage : "+x_plage, -90, 70);
text("y_plage : "+y_plage, -90, 90);
text("deb_pla : '"+deb_pla, -90, 110);
text("() : '"+deb_pla, 30, 30);
// Test if the mouse is on the green area
float radius = ((largeur-largeur*0.1)/2)*2.5*0.3;
boolean inGreenArea = true;
// False if the mouse is inside the inner circle
if (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) < (radius*1.3)/2) inGreenArea = false;
// False if the mouse is outside the outer circle
if (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) > (radius*1.9)/2) inGreenArea = false;
// Get the mouse angle
float mouseAngle = atan2(mouseY-yo, mouseX-xo);
if (mouseAngle < 0) mouseAngle = map(mouseAngle, -PI, 0.0, PI, TWO_PI);
// False if the mouse angle is outside the green area
if (mouseAngle < mini_plage || mouseAngle > maxi_plage) inGreenArea = false;
if (inGreenArea) println("In Green Area");
}
void tracage() {
float decalage = largeur*0.1;
float rayon = (largeur-decalage)/2;
int ajustx = 0;
int ajusty = 0;
float angle_radians;
stroke(210);
for (int angle = 0; angle <= 4; angle++) {
angle_radians = radians(angle*45);
line(xo, yo, xo+cos(angle_radians)*rayon, yo-sin(angle_radians)*rayon);
if (angle > 2) {
ajustx = 5;
ajusty = 3;
}
else {
ajustx = 0;
ajusty = 3;
}
fill(0, 255, 0);
float degres = (180-(45*angle));
text(int(degres), xo+(cos(angle_radians)*rayon)-6-ajustx, yo-(sin(angle_radians)*rayon)-3-ajusty);
}
// Draw this once
fill(0);
arc(xo, yo, rayon*2.5*0.3*1.9, rayon*2.5*0.3*1.9, PI, TWO_PI);
stroke(210);
noFill();
strokeWeight(2);
arc(xo, yo, rayon*2.5*0.3*1.3, rayon*2.5*0.3*1.3, PI, TWO_PI);
arc(xo, yo, rayon*2.5*0.3*1.9, rayon*2.5*0.3*1.9, PI, TWO_PI);
}
void dessin_plage() {
translate(xo, yo);
stroke(0, 255, 0);
strokeWeight(15);
arc(0, 0, 97, 97, mini_plage, maxi_plage);
}
void curseur() {
if (keyPressed) {
if (key ==' ' && rpm < 90) rpm = rpm+1;
}
else {
if (rpm > 1) rpm = rpm-5;
if (rpm < 0) rpm = 0; // Prevent the line from going negative
}
stroke(255, 0, 0);
strokeWeight(2);
pushMatrix();
rotate(radians(rpm));
line(-40, 0, -60, 0);
fill(255, 0, 0);
stroke(0, 255, 0);
pushMatrix();
translate(-60, 0);
rotate(radians(-90));
triangle(x_tri_1, y_tri_1, x_tri_2, y_tri_2, x_tri_3, y_tri_3);
popMatrix();
pushMatrix();
translate(60, 0);
rotate(radians(+90));
triangle(x_tri_1, y_tri_1, x_tri_2, y_tri_2, x_tri_3, y_tri_3);
popMatrix();
popMatrix();
//println(rpm); // fin retournement
}

lcd1602

Re: converting from polar coordinates

7 months ago

thank you for your help I will study the code.
good day. :))))

lcd1602

Re: converting from polar coordinates

7 months ago

hello
First of all a big thank you for the job.
I advanced on the code.
I managed to move the track "gray".
I managed to move the triangles maisje can not block them between PI and 2 * PI?
you have an idea.
thank you for reading and your help.

//import processing.opengl.*;
//import processing.serial.*;
//Serial port;
//------ déclaration des variables de couleur utiles ----

int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int grisHom=color(128,128,128);
int grisF=color(192,192,192);
int grisC=color(210,210,210);
int grisGrille=color(128,128,128);
int orange = color (255,128,0);
int violet = color( 91,91,255);
int fuchia = color(250,0,255);
// données du scrollbar
int x_pos = 20;
int y_pos = 180;
int largeur = 180;

float x_deb_plage = 0;
float y_deb_plage = 0;
float x_fin_plage = 0;
float y_fin_plage = 0;
int deb_pla = 0;

// point référence graphique
float xo = (x_pos+largeur)/2;
float yo = y_pos;

// plage
float mini_plage ;
float maxi_plage ;
boolean dessus_plage = false;
boolean Sel_plage = false;
float x_mini_plageOffset = 0.0;
float x_maxi_plageOffset=0.0;
float rot_drag_mini=0;
float rot_drag_maxi=0;
float ecart_plage=0;

// données triangle mini
float x_tri_1_min = 0.0;
float y_tri_1_min =-60;
float x_tri_2_min = x_tri_1_min-5;
float y_tri_2_min = y_tri_1_min-10;
float x_tri_3_min =x_tri_1_min+5;
float y_tri_3_min =y_tri_1_min-10;
boolean dessus_tri_min= false;
boolean Sel_dessus_tri_min = false;
float x_tri_1_min_plageOffset= 0.0;
float angle_mini_dep= 22;
float angle_maxi_dep= 120;

// données triangle maxi
float x_tri_1_max = 0;
float y_tri_1_max = -60;
float x_tri_2_max = x_tri_1_max-5;
float y_tri_2_max = y_tri_1_max-10;
float x_tri_3_max = x_tri_1_max+5;
float y_tri_3_max = y_tri_1_max-10;
boolean dessus_tri_max= false;
boolean Sel_dessus_tri_max = false;
float x_tri_1_max_plageOffset= 0.0;

float radius;
float rayon;
float mouseX_xo;
float mouseY_yo;
float x_deb_plageC;
float y_deb_plageC;
float x_fin_plageC;
float y_fin_plageC;

float mouseAngle;

int rpm = 0;

void setup() {
size(400, 420);
strokeCap(SQUARE); // Call this once
smooth(); // Call this once
mini_plage= PI+radians(angle_mini_dep);
maxi_plage=PI+radians(angle_maxi_dep);
//println("Available serial ports:");
//println(Serial.list());
//port = new Serial(this, Serial.list()[0], 9600);
}

void draw() {
background(0);

tracage();
dessin_plage();
curseur();

fill(255);
strokeWeight(1);
text("mini_plage : "+mini_plage, -90, 30);
text("(mini_plage < radians(180)) : "+(mini_plage < radians(180)), -90, 50);
text("mouseAngle-x_tri_1_min_plageOffset : "+(mouseAngle-x_tri_1_min_plageOffset), -90, 70);
text("rot_drag_maxi : "+rot_drag_maxi, -90, 90);
text("mouseAngle : "+mouseAngle, -90, 110);
text("x_tri_1_min : "+(x_tri_1_min), -90, 130);
// text("maxi_plage : "+maxi_plage, 30, 50);



   ////////////////////////////////////////
// Test
///////////////////////////////////////
// calcul de l'angle de la souris
   mouseAngle = atan2(mouseY-yo, mouseX-xo);
if (mouseAngle < 0) mouseAngle = map(mouseAngle, -PI, 0.0, PI, TWO_PI);

   radius = ((largeur-largeur*0.1)/2)*2.5*0.3;

// dessus de la plage
// Vrai si la souris est au dessus du cercle intérieur
if ((sqrt(sq(xo-mouseX)+sq(yo-mouseY)) > (radius*1.3)/2) &&

// Vrai si la souris est en dessous du cercle extérieur
   (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) < (radius*1.9)/2) &&

// Vrai si l'angle de la souris est dedans la plage: mini < souris >maxi
   ( mouseAngle > mini_plage && maxi_plage > mouseAngle)) {

   dessus_plage = true;}
   else {
    dessus_plage = false;}
   // debug
// if (dessus_plage) println("In Green Area");
// else {println("out green are");}

// au dessus du triangle mini

// Vrai si la souris est en dessous du cercle extérieur invisible voir dessins des reperes 45°
if (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) < (radius*2.4)/2 && // dessus_tri_min = false;
// Vrai si la souris est au dessus du cercle interieur pointe du triangle
   (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) > (radius*1.9)/2)&& // dessus_tri_min = false;
// Vrai si la souris est au dessus du cercle interieur pointe du triangle
(mouseAngle > mini_plage-(3*0.0174) && mouseAngle < mini_plage+(3*0.0174))){

   dessus_tri_min = true;}
   else {
    dessus_tri_min = false;}
   // debug
// if (dessus_tri_min) println("dessus_tri_min");
// else {println("dehors-tri_min");}

   // au dessus du triangle maxi

// Vrai si la souris est en dessous du cercle extérieur invisible voir dessins des reperes 45°
if (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) < (radius*2.4)/2 &&
// Vrai si la souris est au dessus du cercle interieur pointe du triangle
   (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) > (radius*1.9)/2) &&
// Vrai si la souris est au dessus du cercle interieur pointe du triangle
(mouseAngle > maxi_plage-(3*0.0174) && mouseAngle < maxi_plage+(3*0.0174))){
     dessus_tri_max = true;}
   else {
    dessus_tri_max = false;}
   // debug
// if (dessus_tri_max) println("dessus_tri_max");
// else {println("dehors max");}
}

void mousePressed() {
if(dessus_plage) {
    Sel_plage = true;
   // fill(255, 255, 255);
} else {
    Sel_plage = false;
}
x_mini_plageOffset = mouseAngle-mini_plage;
   x_maxi_plageOffset = mouseAngle-maxi_plage;
//fin dessus plage

   if(dessus_tri_min) {
    Sel_dessus_tri_min = true;
   // fill(255, 255, 255);

} else {
    Sel_dessus_tri_min = false;
}
    x_tri_1_min_plageOffset = mouseAngle-x_tri_1_min;
// x_maxi_plageOffset = mouseAngle-maxi_plage;
//fin dessus_tri_min
if(dessus_tri_max) {
    Sel_dessus_tri_max = true;
   // fill(255, 255, 255);
} else {
    Sel_dessus_tri_max = false;
}
x_tri_1_max_plageOffset = mouseAngle-x_tri_1_max;

//fin Sel_dessus_tri_max
}

void mouseDragged() {

    mouseAngle = mouseX-xo;
mouseAngle = map(mouseAngle, -90, 90, PI, TWO_PI);

if(Sel_plage) {
// Sel_curs= true;
   // calcul de l'angle de la souris

mini_plage = mouseAngle-x_mini_plageOffset;
   maxi_plage= mouseAngle-x_maxi_plageOffset;
    // debug println("yyyyyyyyyyyyyyyyy");
     ecart_plage= maxi_plage-mini_plage;
        if ((mini_plage)<(radians(180))){
    mini_plage =(radians(180));maxi_plage=mini_plage+ecart_plage;}
   else { if (maxi_plage >(radians(360))) {maxi_plage=radians(360);mini_plage = maxi_plage-ecart_plage;}

       rot_drag_mini= mini_plage+ radians(180-22);;
      rot_drag_maxi= maxi_plage-radians (180+120);
}
}//fin Sel_plage

if(Sel_dessus_tri_min) {

x_tri_1_min= mouseAngle-x_tri_1_min_plageOffset;

    rot_drag_mini= x_tri_1_min;

    mini_plage= x_tri_1_min-radians(-180-22);





}//fin Sel_dessus_tri_min

if(Sel_dessus_tri_max) {

x_tri_1_max= mouseAngle-x_tri_1_max_plageOffset;

if (x_tri_1_max> radians(359)){

     maxi_plage=radians(360);

      }
    else {

rot_drag_maxi=x_tri_1_max- radians(180+120);

}

}//fin Sel_dessus_tri_max

}

void tracage() {
float decalage = largeur*0.1;
   rayon = (largeur-decalage)/2;
float degres=0;
int ajustx = 0;
int ajusty = 0;

float angle_radians;
stroke(210);
// dessin des reperes tout les 45°
     // dessin du cercle des triangles pour reperage : couleur noire
     stroke(0);
   noFill();
arc(xo, yo, rayon*2.5*0.3*2.4, rayon*2.5*0.3*2.4, PI, TWO_PI);
fill(0);
stroke(210);
// on remet tout en ordre
// rouitne dessin ligne tous les 45°
for (int angle = 0; angle <= 4; angle++) {
    angle_radians = radians(angle*45);
    line(xo, yo, xo+cos(angle_radians)*rayon, yo-sin(angle_radians)*rayon);

    if (angle > 2) {
      ajustx = 5;
      ajusty = 3;
    }
    else {
      ajustx = -2;
      ajusty = 3;
    }
    // affichage du text des degrees.
    fill(0, 255, 0);

      if (angle <= 2) { degres = (90-(45*angle)) ;
    text(int(degres), xo+(cos(angle_radians)*rayon)-6-ajustx, yo-(sin(angle_radians)*rayon)-3-ajusty);}
     else { degres = (-90+(45*angle)) ;
    text("-"+int(degres), xo+(cos(angle_radians)*rayon)-6-ajustx, yo-(sin(angle_radians)*rayon)-3-ajusty);
}}

// efface le début des lignes d'angle
fill(0);
arc(xo, yo, rayon*2.5*0.3*1.9, rayon*2.5*0.3*1.9, PI, TWO_PI);
// dessin des arcs inferieur et supérieur.
stroke(210);
noFill();
strokeWeight(2);
arc(xo, yo, rayon*2.5*0.3*1.3, rayon*2.5*0.3*1.3, PI, TWO_PI);
arc(xo, yo, rayon*2.5*0.3*1.9, rayon*2.5*0.3*1.9, PI, TWO_PI);

}

void dessin_plage() {

translate(xo, yo);
stroke(color( grisC));
strokeWeight(15);

arc(0, 0, 97, 97, mini_plage, maxi_plage);

   fill(255, 0, 0);
stroke(0, 255, 0);
   strokeWeight(2);
rotate (radians(angle_mini_dep)+rot_drag_mini);
pushMatrix();
translate(-0, 0);
rotate(radians(-90));
triangle(x_tri_1_min, y_tri_1_min, x_tri_2_min, y_tri_2_min, x_tri_3_min, y_tri_3_min);
popMatrix();
rotate (radians(-angle_mini_dep ));
   rotate(-rot_drag_mini);

   // triangle maxi


rotate (radians (angle_maxi_dep)+rot_drag_maxi);
pushMatrix();
translate(-0, 0);
rotate(radians(-90));
triangle(x_tri_1_max, y_tri_1_max, x_tri_2_max, y_tri_2_max, x_tri_3_max, y_tri_3_max);
popMatrix();
    rotate (radians(-angle_maxi_dep)-rot_drag_maxi);
}

void curseur() {
if (keyPressed) {
    if (key ==' ' && rpm < 180) rpm = rpm+1;
}
else {
    if (rpm > 1) rpm = rpm-5;
    if (rpm < 0) rpm = 0; // Prevent the line from going negative
}

// stroke(0,255, 0);
// strokeWeight(2);
// translate(xo, yo);
pushMatrix();
noFill();
rotate(radians(rpm));
// fill(0,255, 0);
strokeCap(SQUARE); // Call this once
strokeWeight(15);
arc(0, 0, 97, 97, PI,PI+(radians(10)));
stroke(255, 0, 0);
strokeWeight(2);
line(0, 0, cos(PI+(radians(9)/2))*56, sin(PI+(radians(9)/2))*56);

   strokeWeight(3);
stroke(0);
   line(0, 0, cos(PI+(radians(9)/2))*41, sin(PI+(radians(9)/2))*41);

// fill(255, 0, 0);
// stroke(0, 255, 0);
//rotate(radians(+mini_plage));

popMatrix();
strokeWeight(1);
    stroke(255);
    translate(0,0);
   line (-80,0,80,0);
      stroke(210);
   strokeWeight(2);
    arc(0, 0, rayon*2.5*0.3*1.3, rayon*2.5*0.3*1.3, PI, TWO_PI);
}
//println(rpm); // fin retournement

lcd1602

Re: converting from polar coordinates

7 months ago

hello
I did, I post the code if it can be used for another.
I return.

if(Sel_dessus_tri_min) {

x_tri_1_min= mouseAngle-x_tri_1_min_plageOffset;
   if (x_tri_1_min+ radians(22) <0) {x_tri_1_min=(radians(-22));mini_plage=radians(180);}
   else
   {
    rot_drag_mini= x_tri_1_min;

    mini_plage= x_tri_1_min-radians(-180-22);
   }




}//fin Sel_dessus_tri_min

if(Sel_dessus_tri_max) {

x_tri_1_max= mouseAngle-x_tri_1_max_plageOffset;

if (x_tri_1_max> 1){x_tri_1_max=radians(360-180-122);maxi_plage= radians(360);

     maxi_plage=radians(360);

      }
    else
    {

rot_drag_maxi=x_tri_1_max;
maxi_plage= x_tri_1_max+radians(180+122);

}

}//fin Sel_dessus_tri_max

}

lcd1602

Re: converting from polar coordinates

6 months ago

hi

I advance in my project,
I have to change the zero reperes up on the right and on the left -90 +90.
between arc detection works well, but I can not seem to detect when the mouse is within the range.
I confess to being lost in the maze of sin and cos ..
if someone has an idea, it will be welcome
thank you for reading.

import controlP5.*;
ControlP5 controlP5; // create the handler to allow for controlP5 objects

//import processing.opengl.*;
//import processing.serial.*;
//Serial port;
//------ déclaration des variables de couleur utiles ----

int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int grisHom=color(128,128,128);
int grisF=color(192,192,192);
int grisC=color(210,210,210);
int grisGrille=color(128,128,128);
int orange = color (255,128,0);
int violet = color( 91,91,255);
int fuchia = color(250,0,255);
// données du scrollbar
int x_pos = 20;
int y_pos = 180;
int largeur = 180;

float x_deb_plage = 0;
float y_deb_plage = 0;
float x_fin_plage = 0;
float y_fin_plage = 0;
int deb_pla = 0;

// point référence graphique
float xo = (x_pos+largeur)/2;
float yo = y_pos;

// plage
float mini_plage ;
float maxi_plage ;
boolean dessus_plage = false;
boolean Sel_plage = false;
float x_mini_plageOffset = 0.0;
float x_maxi_plageOffset=0.0;
float rot_drag_mini=0;
float rot_drag_maxi=0;
float ecart_plage=0;
float angle_mini_dep=-45;
float angle_maxi_dep= 45;

// données triangle mini
float x_tri_1_min =map(((angle_mini_dep)),270,90,3*(PI/2), PI/2);
float y_tri_1_min =-60;
float x_tri_2_min = x_tri_1_min-5;
float y_tri_2_min = y_tri_1_min-10;
float x_tri_3_min =x_tri_1_min+5;
float y_tri_3_min =y_tri_1_min-10;
boolean dessus_tri_min= false;
boolean Sel_dessus_tri_min = false;
float x_tri_1_min_plageOffset= 0.0;

// données triangle maxi
float x_tri_1_max = (map((angle_maxi_dep),PI,TWO_PI,-90,90));
float y_tri_1_max = -60;
float x_tri_2_max = x_tri_1_max-5;
float y_tri_2_max = y_tri_1_max-10;
float x_tri_3_max = x_tri_1_max+5;
float y_tri_3_max = y_tri_1_max-10;
boolean dessus_tri_max= false;
boolean Sel_dessus_tri_max = false;
float x_tri_1_max_plageOffset= 0.0;

float radius;
float rayon;
float mouseX_xo;
float mouseY_yo;
float x_deb_plageC;
float y_deb_plageC;
float x_fin_plageC;
float y_fin_plageC;

float mouseAngle;

//curseur
float curs=map(((ecart_plage/2)),270,90,3*(PI/2), PI/2);
float mini_curs= curs-radians(4);
float maxi_curs=curs+radians(4);
boolean dessus_curs=false;
boolean Sel_curs=false;
float x_mini_cursOffset=0.0;
float x_maxi_cursOffset=0.0;
float ecart_curs=0.0;
float rot_curs_mini=0.0;
float rot_curs_maxi=0.0;

float x_90=xo-6;
float y_90= yo-99;
boolean Sel_90=false;
boolean dessus_90=false;

// affichage
int Aff_mini=0;
int Aff_maxi=0;
int Aff_curs=0;
String Buff_text_mini = "";
Textfield Text_mini;
Textlabel label_mini;
float Buff_mini_plage=0;

boolean dessus_text_mini=false;
int balise_clear=0;
void setup() {
size(400, 420);
strokeCap(SQUARE); // Call this once
smooth(); // Call this once
if ( angle_mini_dep> -45 ) {angle_mini_dep=angle_mini_dep+ (-1);} //de 0 à -45
if (angle_mini_dep<-45) {angle_mini_dep=angle_mini_dep+ (-0.5);}// de -45 à -90
if (angle_mini_dep==-45) {angle_mini_dep=angle_mini_dep+(-0.5);}

mini_plage=map((angle_mini_dep),270,90,3*(PI/2), PI/2);// PI+radians(angle_mini_dep);
maxi_plage=map((angle_maxi_dep),270,90,3*(PI/2), PI/2);//PI+radians(angle_maxi_dep);

//port = new Serial(this, Serial.list()[0], 9600);
controlP5 = new ControlP5(this); // initialize the GUI controls
Text_mini=controlP5.addTextfield("text_mini")
     .setPosition(-60,-98)
     .setSize(25,15)
   // .setColor(CColor)
     .setColorActive(color(vert))
     .setColorBackground(color(grisHom))
     .setColorCaptionLabel(color(blanc))
     .setColorForeground(color(blanc))
    .setAutoClear(false)
   // .setValue(str(Aff_mini))
    //.keepFocus(true)
    //.setFocus(true)
     .setColor(color(blanc));// couleur de font
   controlP5.getController("text_mini").getCaptionLabel().setVisible(false);
// label_mini = controlP5.addTextlabel("label_mini01")

//                  .setPosition(-60,-58);

// label_mini.toUpperCase(false);
}

void draw() {
background(0);

tracage();
dessin_plage();
curseur();

fill(255);
strokeWeight(1);

   // affichage
   Aff_mini=int(degrees(mini_plage));
   Aff_maxi=int(degrees(maxi_plage));
   Aff_curs=int (degrees(curs));
   text("Mini : ",-95,-90);
   text("Maxi : "+Aff_maxi,45,-90);
   text("Curseur : ",-22,-20);
   text(""+Aff_curs,-5,-5);
// label_mini.setText(str(Aff_mini));
text("Buff_text_mini;"+(float (Buff_text_mini)),-90,30);
text("mini_plage;"+degrees(mini_plage),-90,50);
text(" ( mouseAngle > mini_plage && maxi_plage > mouseAngle));"+ ( mouseAngle > mini_plage && maxi_plage > mouseAngle),-90,70);
text("(x_tri_1_min);"+((x_tri_1_min)),-90,90);
if (dessus_text_mini== false){ Aff_mini=int(degrees(mini_plage));
;Text_mini.setText(str(Aff_mini));}
else
{   }

   ////////////////////////////////////////
// Test
///////////////////////////////////////
// calcul de l'angle de la souris
   mouseAngle = atan2(mouseY-yo, mouseX-xo);
if (mouseAngle < 0) mouseAngle = map(mouseAngle, 270,90,3*(PI/2),( PI/2));// -PI, 0.0, PI, TWO_PI);
println("mouseAngle : "+mouseAngle);
// println("mini_plage"+mini_plage);
//   println("maxi_plage"+maxi_plage);
   radius = ((largeur-largeur*0.1)/2)*2.5*0.3;

   // dessus de la plage
// Vrai si la souris est au dessus du cercle intérieur
if ((sqrt(sq(xo-mouseX)+sq(yo-mouseY)) > (radius*1.3)/2) &&

// Vrai si la souris est en dessous du cercle extérieur
(sqrt(sq(xo-mouseX)+sq(yo-mouseY)) < (radius*1.9)/2))// &&

// Vrai si l'angle de la souris est dedans la plage: mini < souris >maxi
//(abs( mouseAngle )< mini_plage && maxi_plage > mouseAngle))

{

   dessus_plage = true;
balise_clear=0;}
   else {
    dessus_plage = false;}
//     println("mouseAngle > mini_plage :"+(atan2(mini_plage, maxi_plage)));
//   println("maxi_plage > mouseAngle :"+(maxi_plage > mouseAngle));
   // debug
   println("atan2(sin(mini_plage)-yo,cos(mini_plage)-xo)"+atan2(yo-sin(mini_plage),xo-cos(mini_plage)));
if (dessus_plage) println("In Green Area");
else {println("out green are");}

// au dessus du triangle mini

// Vrai si la souris est en dessous du cercle extérieur invisible voir dessins des reperes 45°
if (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) < (radius*2.4)/2 && // dessus_tri_min = false;
// Vrai si la souris est au dessus du cercle interieur pointe du triangle
   (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) > (radius*1.9)/2))// && // dessus_tri_min = false;
// Vrai si la souris est au dessus du cercle interieur pointe du triangle
   // (abs(mouseAngle) > mini_plage))// && mouseAngle < mini_plage+(10*0.0174)))
{

   dessus_tri_min = true;
balise_clear=0;}
   else {
    dessus_tri_min = false;}
   // debug
// if (dessus_tri_min) println("dessus_tri_min");
// else {println("dehors-tri_min");}

   // au dessus du triangle maxi

// Vrai si la souris est en dessous du cercle extérieur invisible voir dessins des reperes 45°
if (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) < (radius*2.4)/2 &&
// Vrai si la souris est au dessus du cercle interieur pointe du triangle
   (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) > (radius*1.9)/2) &&
// Vrai si la souris est au dessus du cercle interieur pointe du triangle
(mouseAngle > maxi_plage-(3*0.0174) && mouseAngle < maxi_plage+(3*0.0174))){
     dessus_tri_max = true;
    balise_clear=0;}
   else {
    dessus_tri_max = false;}
   // debug
// if (dessus_tri_max) println("dessus_tri_max");
// else {println("dehors max");}

      // Test si le curseur est selectionné
// dessus de la plage
// Vrai si la souris est au dessus du cercle intérieur
if ((sqrt(sq(xo-mouseX)+sq(yo-mouseY)) > (radius*1.3)/2) &&

// Vrai si la souris est en dessous du cercle extérieur
   (sqrt(sq(xo-mouseX)+sq(yo-mouseY)) < (radius*1.9)/2) &&

// Vrai si l'angle de la souris est dans le curseur : mini < souris >maxi
   (abs( mouseAngle) > mini_curs && maxi_curs > mouseAngle)) {

   dessus_curs = true;
balise_clear=0;}
   else {
    dessus_curs = false;}

// test si le bouton RAZ= 0 est selectioinné

   if (mouseX > x_90 && mouseX < x_90+11 &&
      mouseY > y_90 && mouseY < y_90+13)
{
          stroke(vert);
    dessus_90 = true;
      Bout90();
       balise_clear=0;
} else {
    dessus_90 = false;
}
// desssu text mini

if (mouseX > xo-60 && mouseX < xo-60+25 &&
      mouseY > yo-101 && mouseY < yo-101+15)
{
          stroke(vert);
       //   println("yyyyyyyyyyyyyyyyyyy");
    dessus_text_mini = true;

} else {
    dessus_text_mini = false;

}

}

void mousePressed() {
if(dessus_plage) {
    Sel_plage = true;
    Sel_curs= true;
   // fill(255, 255, 255);
} else {
    Sel_plage = false;
}
x_mini_plageOffset = mouseAngle-mini_plage;
   x_maxi_plageOffset = mouseAngle-maxi_plage;
//fin dessus plage

   if(dessus_tri_min) {
    Sel_dessus_tri_min = true;
   // fill(255, 255, 255);

} else {
    Sel_dessus_tri_min = false;
}
    x_tri_1_min_plageOffset = mouseAngle-x_tri_1_min;
// x_maxi_plageOffset = mouseAngle-maxi_plage;
//fin dessus_tri_min
if(dessus_tri_max) {
    Sel_dessus_tri_max = true;
   // fill(255, 255, 255);
} else {
    Sel_dessus_tri_max = false;
}
x_tri_1_max_plageOffset = mouseAngle-x_tri_1_max;
// x_maxi_plageOffset = mouseAngle-maxi_plage;
//fin Sel_dessus_tri_max

if(dessus_curs) {

    Sel_curs = true;

     Sel_plage= false;
   // fill(255, 255, 255);
} else {
    Sel_curs = false;
}
x_mini_cursOffset = mouseAngle-mini_curs;
   x_maxi_cursOffset = mouseAngle-maxi_curs;
//fin dessus curs

if(dessus_90) {
    Sel_90 = true;


} else {
    Sel_90 = false;
}
//x_90Offset = mouseX-x_90;
///////////////////////////////////
////////////////////////////////
if(dessus_text_mini) {

    //Sel_curs = true;
    Text_mini.keepFocus(true);
if (balise_clear==0){Text_mini.clear();balise_clear=1;

Buff_text_mini=Text_mini.getStringValue() ;}

// println(Buff_text_mini);


} else {
   // Sel_curs = false;
}

//fin dessus curs
}
public void text_mini(String Buff_text_mini) {
// automatically receives results from controller input
// println("a textfield event for controller 'Buff_text_mini' : "+Buff_text_mini);
//Sel_dessus_tri_min=true;

x_tri_1_min=x_tri_1_min+((x_tri_1_min)+radians( float(Buff_text_mini)));
//mouseDragged();
rot_drag_mini= x_tri_1_min;
    mini_plage= x_tri_1_min-radians(-180-22);
}
void mouseDragged() {

   mouseAngle = mouseX-xo;
//mouseAngle = map(mouseAngle, -90, 90, PI, TWO_PI);
mouseAngle=map((mouseAngle),270,90,3*(PI/2), PI/2);

if(Sel_plage) {
Sel_curs=true;
mini_plage = mouseAngle-x_mini_plageOffset;
   maxi_plage= mouseAngle-x_maxi_plageOffset;

     ecart_plage= maxi_plage-mini_plage;

        if ((mini_plage)<(radians(-90))){
    mini_plage =(radians(-90));maxi_plage=mini_plage+ecart_plage; Sel_curs=false;}
   else { if (maxi_plage >(radians(90))) {maxi_plage=radians(90);mini_plage = maxi_plage-ecart_plage; Sel_curs=false;}
     // rot_drag_mini= mini_plage+ radians(180-45);
     // rot_drag_maxi= maxi_plage-radians (180+120);
x_tri_1_min= mouseAngle-x_tri_1_min_plageOffset;
   x_tri_1_max= mouseAngle-x_tri_1_max_plageOffset;
    }
}//fin Sel_plage

if(Sel_dessus_tri_min) {
//rot_drag_mini= x_tri_1_min;
    mini_plage= x_tri_1_min-radians(-90-angle_mini_dep);
x_tri_1_min= mouseAngle-x_tri_1_min_plageOffset;

//   if (x_tri_1_min+ radians(angle_mini_dep) <0) {x_tri_1_min=(radians(-angle_mini_dep));mini_plage=radians(-90);}
// if ((x_tri_1_min+radians(22)+PI) > mini_curs) {curs = mini_plage+radians(4);mini_curs=curs-radians(4);maxi_curs=curs+radians(4);}
// if ((x_tri_1_min+radians(22)+radians(14)+PI) > maxi_plage) {x_tri_1_min=mini_plage=maxi_plage-radians(14)-radians(22)-PI;}

}//fin Sel_dessus_tri_min

if(Sel_dessus_tri_max) {
x_tri_1_max= mouseAngle-x_tri_1_max_plageOffset;

if (x_tri_1_max> 1){x_tri_1_max=radians(360-180-122);maxi_plage= radians(360); maxi_plage=radians(360);}
if ((x_tri_1_max+radians(180+122)) < maxi_curs) {curs = maxi_plage-radians(4);mini_curs=curs-radians(4);maxi_curs=curs+radians(4);}
if (x_tri_1_max-radians(14)+radians(180+122) < mini_plage) {x_tri_1_max=maxi_plage=mini_plage+radians(14)-radians(180+122);}

rot_drag_maxi=x_tri_1_max;
maxi_plage= x_tri_1_max+radians(180+122);

}//fin Sel_dessus_tri_max

if(Sel_curs) {

     ecart_curs= maxi_curs-mini_curs;

    curs = mouseAngle-x_mini_cursOffset;
    mini_curs=curs-(radians(4));
    maxi_curs=curs+(radians(4));
   //maxi_curs= mouseAngle-x_maxi_cursOffset;

       if ((curs)<mini_plage+radians(1)){

    curs = mini_plage; mini_curs=curs;
    maxi_curs=curs+(radians(4));}
   else { if (curs >(maxi_plage)) {curs=maxi_plage;
     maxi_curs=curs;
    mini_curs=curs-(radians(4));}
   }

} //fin Sel_curs

}

void mouseReleased() {
// Sel_plage = false;
}
void Bout90(){
// gestion du bouton 90°
    if(Sel_90) {

       curs=map(((ecart_plage/2)),270,90,3*(PI/2), PI/2);
       mini_curs= curs-radians(4);
       maxi_curs=curs+radians(4);
mini_plage=map((angle_mini_dep),270,90,3*(PI/2), PI/2);// PI+radians(angle_mini_dep);

maxi_plage=map((angle_maxi_dep),270,90,3*(PI/2), PI/2);//PI+radians(angle_maxi_dep);

    }
}



void tracage() {
float decalage = largeur*0.1;
   rayon = (largeur-decalage)/2;
float degres=0;
int ajustx = 0;
int ajusty = 0;

float angle_radians;
      fill(grisHom);
rect (0,75,200,105);
stroke(210);
// dessin des reperes tout les 45°
     // dessin du cercle des triangles pour reperage : couleur noire
     stroke(color(grisHom));
   noFill();
arc(xo, yo, rayon*2.5*0.3*2.4, rayon*2.5*0.3*2.4, PI, TWO_PI);
fill(0);
stroke(0);
// on remet tout en ordre
// routine dessin ligne tous les 45°
for (int angle = 0; angle <= 4; angle++) {
    angle_radians = radians(angle*45);
    line(xo, yo, xo+cos(angle_radians)*rayon, yo-sin(angle_radians)*rayon);

    if (angle > 2) {
      ajustx = 5;
      ajusty = 3;
    }
    else {
      ajustx = -2;
      ajusty = 3;
    }

    // dessin bouton 0°
strokeWeight(1);
     stroke(color(vert));
     //fill(color(rouge));
       noFill();
     rect (x_90,y_90, 11, 13);

     //noFill();
     fill(color(vert));
     strokeWeight(1);
     text("0",xo-4,yo-87);
    // affichage du text des degrees.
    fill(0, 255, 0);

      if (angle <= 2) { degres = (90-(45*angle)) ;
    text(int(degres), xo+(cos(angle_radians)*rayon)-6-ajustx, yo-(sin(angle_radians)*rayon)-3-ajusty);}
     else { degres = (-90+(45*angle)) ;
    text("-"+int(degres), xo+(cos(angle_radians)*rayon)-6-ajustx, yo-(sin(angle_radians)*rayon)-3-ajusty);
}}

// efface le début des lignes d'
strokeWeight(1);
fill(color(grisHom));
arc(xo, yo, rayon*2.5*0.3*1.9, rayon*2.5*0.3*1.9, PI, TWO_PI);
// dessin des arcs inferieur et supérieur.
stroke(0);
noFill();
strokeWeight(1);
arc(xo, yo, rayon*2.5*0.3*1.3, rayon*2.5*0.3*1.3, PI, TWO_PI);
arc(xo, yo, rayon*2.5*0.3*1.9, rayon*2.5*0.3*1.9, PI, TWO_PI);
// dessin du cadre
   // stroke(grisF);

}

void dessin_plage() {

translate(xo, yo);
stroke(color( grisC));
strokeWeight(15);
pushMatrix();
rotate (-PI/2);
arc(0, 0, 97, 97, mini_plage,maxi_plage);
//println( mini_plage);
//println(maxi_plage);
// println(degrees (mini_plage));
   fill(255, 0, 0);
stroke(0, 255, 0);
   strokeWeight(2);
// triangle maxi
// pushMatrix();
rotate (mini_plage+rot_drag_mini);
// translate(-0, 0);
rotate(radians(90));
triangle(x_tri_1_min, y_tri_1_min, x_tri_2_min, y_tri_2_min, x_tri_3_min, y_tri_3_min);
// popMatrix();

   // triangle maxi
// pushMatrix();
rotate( maxi_plage+rot_drag_maxi);
// translate(-0, 0);
//rotate(radians(-90));
// triangle(x_tri_1_max, y_tri_1_max, x_tri_2_max, y_tri_2_max, x_tri_3_max, y_tri_3_max);
popMatrix();
   // rotate (radians(-angle_maxi_dep)-rot_drag_maxi);
}

void curseur() {

pushMatrix();
noFill();

// rotate(radians(rot_curs_mini));
// Dessin du curseur
rotate (-PI/2);
strokeCap(SQUARE); // Call this once
strokeWeight(15);
   //dessin du curseur
arc(0, 0, 97, 97, mini_curs,maxi_curs);
//dessin de la ligne rouge au milieu du curseur
stroke(255, 0, 0);
strokeWeight(1);
line(0, 0, cos(curs)*56, sin(curs)*56);
//effacer la ligne rouge du centre au curseur
   strokeWeight(3);
stroke(color(grisHom));
   line(0, 0, cos(curs)*41, sin(curs)*41);

popMatrix();
// redessiner la ligne de base
strokeWeight(1);
stroke(210);
   line(-90, 0,90,0);

}
   // fin retournement