var canevas, glissFigure, info, vitesse, infoVitesse, avecCercles, arreter, x, no, _re, _im, _freq, _amp, _phase, a, b, XX, N, somme, k, nn, i, phi, c, deltaX, deltaY, trace, fourier, temps, chemin, y, rotation, j, xPrec, yPrec, freq, rayon, phase, v, m, dt, manuel, point, o, avecVecteurs, p, modeTri, glissTri, infoTri, pas, facteur, nbCotes, temp, avecFigure, parametre, niveau, contenant, fourierPartie, borne, proportion, infoProportion, texte;

/**
 * Fonction exécutée une fois, au départ
 */
function actions_initiales() {
  document.body.style.paddingLeft="40px";
  createElement("h1",'Figures via Fourier');
  glissFigure=createSlider(0,7,2,1);
  siChangementPrudent("glissFigure",glissFigure,"pr_C3_A9parer_figure",pr_C3_A9parer_figure);
  info = nouveau_texte('');
  parametre=createSlider(0,1,0,0.01);
  siChangementPrudent("parametre",parametre,"pr_C3_A9parer_figure",pr_C3_A9parer_figure);
  createSpan("<br>");
  proportion=createSlider(0.1,1,1,0.01);
  siChangementPrudent("proportion",proportion,"pr_C3_A9parer_figure",pr_C3_A9parer_figure);
  infoProportion = nouveau_texte('Précision souhaitée 100%');
  createSpan("<br>");
  glissTri=createSlider(0,3,1,1);
  siChangementPrudent("glissTri",glissTri,"pr_C3_A9parer_figure",pr_C3_A9parer_figure);
  infoTri = nouveau_texte('');
  createSpan("<br>");
  vitesse=createSlider(0.6,60,60,0.1);
  infoVitesse = nouveau_texte('Vitesse du tracé');
  createSpan("<br>");
  avecCercles=createCheckbox('Montrer les cercles ',true);
  createSpan("").style("display","inline-block").style("width","10px");
  avecVecteurs=createCheckbox('Montrer les vecteurs ',true);
  createSpan("").style("display","inline-block").style("width","10px");
  avecFigure=createCheckbox('Montrer la figure ',true);
  createSpan("").style("display","inline-block").style("width","10px");
  arreter=createCheckbox('Arrêter le tracé à la fin',true);
  createSpan("<br>");
  createSpan("<br>");
  canevas=creerCanvas(1000,1100); canvas=canevas;
  eval('canevas.mousePressed(depart)');
  eval('canevas.mouseReleased(arrivee)');
  frameRate(round((valeurPrudent("vitesse",vitesse))));
  nommer_composantes();
  aligner();
  pr_C3_A9parer_figure();
  positionnerObjetPrudent("(select('#'+'refFourier'))",(select('#'+'refFourier')),1100,0);
}

/**
 * Décrire cette fonction…
 */
function nommer_figure(no) {
  cacherObjetPrudent("parametre",parametre);
  if (no == 0) {
    fixeContenuPrudent("info",info,'Tracer votre propre figure avec la souris');
  }
  if (no == 1) {
    fixeContenuPrudent("info",info,'Portrait de Fourier');
  }
  if (no == 2) {
    fixeContenuPrudent("info",info,'Coding Train');
  }
  if (no == 3) {
    fixeContenuPrudent("info",info,'Carrés emboités');
  }
  if (no == 4) {
    fixeContenuPrudent("info",info,'Carrés emboités spiralés');
  }
  if (no == 5) {
    montrerObjetPrudent("parametre",parametre);
    stylerObjetPrudent("parametre",parametre,'display','inline-block');
    nbCotes = Math.floor(3 + 13 * valeurPrudent("parametre",parametre));
    fixeContenuPrudent("info",info,(['Polygone régulier ',nbCotes,' côtés'].join('')));
  }
  if (no == 6) {
    montrerObjetPrudent("parametre",parametre);
    stylerObjetPrudent("parametre",parametre,'display','inline-block');
    niveau = Math.floor(2 + 3 * valeurPrudent("parametre",parametre));
    fixeContenuPrudent("info",info,(String('Sierpinski niveau ') + String(niveau)));
  }
  if (no == 7) {
    fixeContenuPrudent("info",info,'Spirales');
  }
}

/**
 * Décrire cette fonction…
 */
function tfd(x) {
  var XX;
  var N;
  var somme;
  XX = [];
  N = x.length;
  for (k = 0; k <= N - 1; k += abs(1)) {
    somme = complexe(0, 0);
    for (nn = 0; nn <= N - 1; nn += abs(1)) {
      phi = (360 * k * nn) / N;
      c = complexe(Math.cos(phi / 180 * Math.PI), -Math.sin(phi / 180 * Math.PI));
      somme = add(somme, mult(x[nn], c));
    }
    somme[_re] = (somme[_re] / N);
    somme[_im] = (somme[_im] / N);
    XX[k] = [somme[_re], somme[_im], k, (normeVecteur2D((somme[_re]),(somme[_im]))), (orientationVecteur2D((somme[_re]),(somme[_im])))];
  }
  return XX;
}

/**
 * Décrire cette fonction…
 */
function nommer_composantes() {
  _re = 0;
  _im = 1;
  _freq = 2;
  _amp = 3;
  _phase = 4;
}

/**
 * Décrire cette fonction…
 */
function tri(a, b) {
  if (modeTri == 0) {
    return 0;
  }
  if (modeTri == 1) {
    return b[_amp] - a[_amp];
  }
  if (modeTri == 2) {
    return a[_freq] - b[_freq];
  }
  if (modeTri == 3) {
    return a[_phase] - b[_phase];
  }
}

/**
 * Décrire cette fonction…
 */
function nommer_tri() {
  modeTri = valeurPrudent("glissTri",glissTri);
  if (modeTri == 0) {
    fixeContenuPrudent("infoTri",infoTri,'Pas de tri');
  }
  if (modeTri == 1) {
    fixeContenuPrudent("infoTri",infoTri,'Tri par amplitude décroissante');
  }
  if (modeTri == 2) {
    fixeContenuPrudent("infoTri",infoTri,'Tri par fréquence croissante');
  }
  if (modeTri == 3) {
    fixeContenuPrudent("infoTri",infoTri,'Tri par phase croissante');
  }
}

/**
 * Décrire cette fonction…
 */
function complexe(a, b) {
  return [a, b];
}

/**
 * Décrire cette fonction…
 */
function add(a, b) {
  return [a[_re] + b[_re], a[_im] + b[_im]];
}

/**
 * Décrire cette fonction…
 */
function mult(a, b) {
  return [a[_re] * b[_re] - a[_im] * b[_im], a[_re] * b[_im] + a[_im] * b[_re]];
}

/**
 * Décrire cette fonction…
 */
function aligner() {
  stylerObjetPrudent("avecCercles",avecCercles,'display','inline-block');
  stylerObjetPrudent("avecVecteurs",avecVecteurs,'display','inline-block');
  stylerObjetPrudent("avecFigure",avecFigure,'display','inline-block');
  stylerObjetPrudent("arreter",arreter,'display','inline-block');
}

/**
 * Décrire cette fonction…
 */
function nouveau_texte(texte) {
  var x;
  createSpan("").style("display","inline-block").style("width","20px");
  x=createSpan(texte);
  stylerObjetPrudent("x",x,'font-size','14pt');
  createSpan("").style("display","inline-block").style("width","20px");
  return x;
}

/**
 * Décrire cette fonction…
 */
function polyReg() {
  nbCotes = Math.floor(3 + 13 * valeurPrudent("parametre",parametre));
  deltaX = 0;
  deltaY = 0;
  trace = [];
  for (p = 0; p <= nbCotes; p += abs(1)) {
    trace[p] = [400 * Math.cos((p * (360 / nbCotes)) / 180 * Math.PI), 400 * Math.sin((p * (360 / nbCotes)) / 180 * Math.PI)];
  }
}

/**
 * Décrire cette fonction…
 */
function pr_C3_A9parer_figure() {
  no = valeurPrudent("glissFigure",glissFigure);
  if (no == 0) {
    return null;
  }
  x = [];
  pas = 1;
  facteur = 1;
  deltaX = 300;
  deltaY = 300;
  if (no == 1) {
    deltaX = 1000;
    deltaY = 580;
    trace = eval('retournerFigure()[7]');
  }
  if (no == 2) {
    pas = 5;
    facteur = 2;
    deltaX = 0;
    deltaY = 0;
    trace = eval('retournerFigure()[9]');
  }
  if (no == 3) {
    deltaX = 400;
    deltaY = 400;
    trace = eval('retournerFigure()[5]');
  }
  if (no == 4) {
    deltaX = 400;
    deltaY = 400;
    trace = eval('retournerFigure()[6]');
  }
  if (no == 5) {
    polyReg();
  }
  if (no == 6) {
    sierpinski();
  }
  if (no == 7) {
    deltaX = 250;
    deltaY = 250;
    trace = eval('retournerFigure()[8]');
  }
  for (i = 0; i <= trace.length - 1; i += abs(pas)) {
    c = complexe(facteur * (trace[i])[_re] - deltaX, facteur * (trace[i])[_im] - deltaY);
    x.push(c);
  }
  fourier = tfd(x);
  eval('fourier.sort(tri)');
  temps = 0;
  chemin = [];
  couleurFondC('rgb(225 ,255 ,225)');
}

/**
 * Décrire cette fonction…
 */
function depart() {
  if (valeurPrudent("glissFigure",glissFigure) > 0) {
    return null;
  }
  manuel = true;
  trace = [];
  x = [];
  temps = 0;
  chemin = [];
}

/**
 * Décrire cette fonction…
 */
function sierpinski() {
  niveau = Math.floor(2 + 3 * valeurPrudent("parametre",parametre));
  if (niveau == 2) {
    trace = eval('retournerFigure()[1]');
  }
  if (niveau == 3) {
    trace = eval('retournerFigure()[2]');
  }
  if (niveau == 4) {
    trace = eval('retournerFigure()[3]');
  }
  if (niveau >= 5) {
    trace = eval('retournerFigure()[4]');
  }
}

/**
 * Décrire cette fonction…
 */
function arrivee() {
  if (valeurPrudent("glissFigure",glissFigure) > 0) {
    return null;
  }
  manuel = false;
  for (i = 0; i <= trace.length - 1; i += abs(1)) {
    c = complexe((trace[i])[_re], (trace[i])[_im]);
    x.push(c);
  }
  fourier = tfd(x);
  eval('fourier.sort(tri)');
}

/**
 * Fonction exécutée périodiquement, de façon répétée
 */
function actions_en_boucle() {
  nommer_figure(valeurPrudent("glissFigure",glissFigure));
  fixeContenuPrudent("infoProportion",infoProportion,(['Précision souhaitée ',Math.round(100 * valeurPrudent("proportion",proportion)),'%'].join('')));
  nommer_tri();
  if (manuel) {
    couleurFondC('rgb(225 ,255 ,225)');
    if (!mouseIsPressed) {
      return;
    }
    if (mouseIsPressed && posYsouris() < 0) {
      return;
    }
    frameRate(round(60));
    point = [posXsouris() - 500, posYsouris() - 550];
    trace.push(point);
    noFill_();
    stroke_('rgb(0 ,0 ,255)');
    debutPoly();
    for (i = 0; i <= trace.length - 1; i += abs(1)) {
      sommet(((trace[i])[0] + 500),((trace[i])[1] + 550));
    }
    finPoly();
    return ;
  }
  dt = 360 / fourier.length - 1e-12;
  if (etatCasePrudent("arreter",arreter) && temps > 360 - dt) {
    return;
  }
  couleurFondC('rgb(225 ,255 ,225)');
  borne = Math.round(valeurPrudent("proportion",proportion) * fourier.length);
  fourierPartie = eval('fourier.slice(0,borne)');
  frameRate(round((valeurPrudent("vitesse",vitesse))));
  v = epicycles(leGraphicsActif.width / 2, leGraphicsActif.height / 2, 0, fourierPartie);
  eval('chemin.unshift(v)');
  noFill_();
  stroke_('rgb(0 ,0 ,255)');
  strokeWeight_(2);
  if (etatCasePrudent("avecFigure",avecFigure)) {
    debutPoly();
    for (i = 0; i <= chemin.length - 1; i += abs(1)) {
      sommet(((chemin[i])[0]),((chemin[i])[1]));
    }
    finPoly();
  }
  strokeWeight_(1);
  temps = temps + dt;
  if (temps > 360) {
    temps = 0;
    chemin = [];
  }
}

/**
 * Décrire cette fonction…
 */
function epicycles(x, y, rotation, fourier) {
  for (i = 0; i <= fourier.length - 1; i += abs(1)) {
    xPrec = x;
    yPrec = y;
    freq = (fourier[i])[_freq];
    rayon = (fourier[i])[_amp];
    phase = (fourier[i])[_phase];
    x = x + rayon * Math.cos((freq * temps + phase + rotation) / 180 * Math.PI);
    y = y + rayon * Math.sin((freq * temps + phase + rotation) / 180 * Math.PI);
    noFill_();
    stroke_((color(0,0,0,100)));
    if (etatCasePrudent("avecCercles",avecCercles)) {
      cercle_(xPrec,yPrec,rayon);
    }
    stroke_((color(0,0,0,255)));
    if (etatCasePrudent("avecVecteurs",avecVecteurs)) {
      segment(xPrec,yPrec,x,y);
    }
  }
  return [x, y];
}