Bonsoir,

Une courbe qui passe par trois points est une parabole, donc elle est de la forme
y = ax2 + bx + c
tu te retrouve avec un système de trois équation une pour chaque point a trois inconnus a, b, c.
Donc tu peux facilement trouver l'équation qui passe par les trois points.

J'ai fait cela dans le train, ce n'est pas exactement ce que tu souhaites, mais peut te donner des pistes.

PVector positionSouris;
PVector debut = new PVector(100, 100);
PVector fin = new PVector(700, 500);
float definition;

void setup() {
  size(800, 600);
  noFill();
  positionSouris = new PVector(0, 0);
  definition = 100;
}

void draw() {
  background(255);
  if (mousePressed) {
    PVector pointPrecedent = debut.copy();
    for (float t = 1 / definition; t < 1; t = t + 1 / definition) {
      PVector point = new PVector((1 - t * t) * debut.x + 2 * t * (1 - t) * mouseX + t * t * fin.x, (1 - t * t) * debut.y + 2 * t * (1 - t) * mouseY + t * t * fin.y);
      line(pointPrecedent.x , pointPrecedent.y, point.x, point.y);
      pointPrecedent.set(point);
    }
  } else {
    line(debut.x, debut.y, fin.x, fin.y);
  }
}

Re:

Pour l'équation du second trouvé, c'est bon j'ai trouvé... Par contre le résultat obtenu ne ressemble pas à ton programme et la courbe ner éagit pas comme je le souhaiterais...

Voici le résultat obtenu avec la solution y = ax2 + bx


int diamPoignee = 10;
int w = 300;

float cadre;
PVector ptA, ptB, ptC;
float a, b, y;
boolean poigneeSelected = false;

void setup(){
 
  size(600, 600);
  stroke(255);
  noFill();
  rectMode(CENTER);

  cadre = (height - w) / 2;
 
  ptA = new PVector(0, 0);
  ptB = new PVector(w, w);
  ptC = new PVector(w/2, w/2);
}

void draw(){
 
  background(0);
  translate(cadre, cadre);
 
  a = (ptC.x - ptC.y) / ( ptC.x * (ptB.x - ptC.x) );
  b = 1 - a * ptB.x;
  for(int x = 0; x < w; x++){
    y = a * x * x + b * x;
    point(x, y);
  }
 
  rect(ptC.x, ptC.y, 10, 10); // poignee
}

void mousePressed(){
 
  if(mouseX > ptC.x - diamPoignee/2 + cadre && mouseX < ptC.x + diamPoignee/2 + cadre &&
     mouseY > ptC.y - diamPoignee/2 + cadre && mouseY < ptC.y + diamPoignee/2 + cadre){
       poigneeSelected = true;
  }
  else{
    poigneeSelected = false;
  }
}

void mouseDragged(){
 
  if (poigneeSelected){
    ptC.x = mouseX - cadre;
    ptC.y = mouseY - cadre;
  }
}

Bon, cela aura été un peu fastidieux, mais je suis parvenu à faire ce que je voulais  

En gros, j'ai créé un petit objet que l'on peut placer où l'on souhaite sur notre canvas. Cet objet est un peu semblable à l'objet "map()" de processing, excepté que celui affiche un graphique que l'on peu manipuler et dont la courbe peut "étirer" la manière dont le nombre sera mappé...

Voici un petit exemple si quelqu'un souhaiterait voir le résultat



Curseur curseur;

void setup(){
 
  println("move the cursor to see what happens");
  println("or press the keys UP and DOWN");
  size(400, 225);
  colorMode(HSB);
 
  curseur = new Curseur(150, 25, 100);
}

void draw(){
 
  background(0);
 
  curseur.show();
 
  for(int i = 0; i < 255; i++){
    float j = curseur.mapCurve(i, 0, 255);
    fill(j, 255, 255);
    noStroke();
    rect(i+72, 150, 1, 50);
  }
}

void keyPressed(){
 
  if (key == CODED){
    if (keyCode == UP){
      curseur.xp -= 10;
    }
    else if (keyCode == DOWN){
      curseur.xp += 10;
    }
  }
}

void mouseDragged(){
 
  /*if(mouseX > curseur.xPos && mouseX < curseur.xPos + curseur.taille &&
     mouseY > curseur.yPos && mouseY < curseur.yPos + curseur.taille){
       curseur.xp = mouseY - curseur.yPos;
  }*/
  curseur.xp = mouseY - curseur.yPos;
}

class Curseur{
 
  int xPos, yPos, taille;
 
  float xp, yp, xAngle, angleDif, a, b;
  PVector poignee = new PVector();
  PVector f2, xVec;
  boolean inverse;
 
  Curseur(int _xPos, int _yPos, int _taille){
   
    xPos = _xPos;
    yPos = _yPos;
    taille = _taille;
    xp = taille/2;
  }
 
  void show(){
   
    pushMatrix();
    translate(xPos, yPos);
   
    // bg
    fill(7);
    stroke(7);
    rect(0, 0, taille, taille);
   
    // limites curseur
    if(xp < 0){ xp = 0; }
    if(xp > taille){ xp = taille; }
   
    // ligne curseur
    stroke(63);
    line(0, 0, taille, taille);
   
    // curseur
    yp = -xp + taille;
    poignee.set(xp, yp);
    stroke(255);
    ellipse(poignee.x, taille - poignee.y, 3, 3);
   
    float tgAngle = PI/4;   // angle tangente
    f2 = new PVector(taille, taille);
    f2.sub(poignee);
    float f2Angle = PI/2 - f2.heading();      // angle vecteur MB
    angleDif = - tgAngle + f2Angle;     // différence totale
   
    inverse = true;
    for(int x = 0; x < taille; x++){
      float y = mapCurve(x, 0, taille);
      point(x, y);
    }
    inverse = false;
    popMatrix();
  }
 
  float mapCurve(int _abscisse, float min, float max){
   
    float abscisse = float(_abscisse);
    float ordonnee = 0;
   
    float minPrim = map(min, min, max, 0, taille);
    float maxPrim = map(max, min, max, 0, taille);
    int abscissePrim = int(map(abscisse, min, max, 0, taille));
   
    xAngle = angleDif / xp;
    float x = xp;
    int compt = 0;

    while(x >= 0){
      xVec = PVector.fromAngle((compt+1) * xAngle);    // difference d'angle au pas x
      xVec.rotate(PI/4);                               // angle au pas x
      a = xVec.y / xVec.x;           // calcul de a
      b = xVec.y - a * xVec.x;       // calcul de b
      float y = a * compt + b;       // fonction de la tengante au pas x
      if(y > taille - xp){ y = taille - xp; }     // constrain
      if(x == abscissePrim){ ordonnee = y; }
      x--;
      compt++;
    }
   
    xAngle = angleDif / (taille - xp);    // différence pas à pas
    x = xp;
    compt = 0;

    while(x < taille){
      xVec = PVector.fromAngle((compt+1) * xAngle);     // difference d'angle au pas x
      xVec.rotate(-PI/4);                               // angle au pas x
      a = xVec.y / xVec.x;           // calcul de a
      b = xVec.y - a * xVec.x;       // calcul de b
      float y = a * compt + b;             // fonction de la tengante au pas x
      if(y < -xp){ y = -xp; }    // constrain
      if(x == abscissePrim){ ordonnee = y; }
      x++;
      compt++;
    }
   
    ordonnee += xp;
    if(inverse){ordonnee = map(ordonnee, 0, taille, min, max);}
    else{ordonnee = map(ordonnee, 0, taille, max, min);}
    return ordonnee;
  }
}


Maintenant que je l'ai fait, je me demande s'il n'y avait pas une librairie contenant un objet similaire lol
Si quelqu'un a une idée ou des commentaires sur ce code, il est le bienvenue!

A+ et merci encore à ceux qui ont passé du temps sur ce post!