Problème pour hachurage d'une zone graphique

[Zorro_X]

Rebonjour à tous (et à toutes !),

Voici mon problème dans sa globalité : j'essaie de hachurer la zone orange ci-dessous avec les traits verts.



La zone à hachurer est contrainte par 0, Xmin, Xmax, la droite dP et Ymax. Ce sont là des paramètres constants donc connus pour le calcul.
De plus, n (nombre de traits du hachurage) est constant ainsi que R (recouvrement : la même valeur entre deux traits successifs, pour tous les traits du hachurage).
Enfin, les traits du hachurage doivent être parallèles (même pente dF), le premier doit commencer à (Xmin,0) et le dernier doit se terminer à (Xmax, Ymax).
Ce que j'essaie de trouver de façon algébrique c'est la valeur de dF pour que mes hachures demarrent là où il faut et s'arrêtent là où il faut. Sachant que le hachurage n'est pas régulier car lorsque la zone se rétrécit, le recouvrement doit rester constant, donc les hachures se rapprochent.

Precisions :
RP etant une valeur réelle comprise entre 0 et 1, fixe.
Avec RP on calcule Xr qui est de longueur constante telle que Xr = (Xmax - Xmin).RP
Enfin R = Xr.dF
R est bien constante sur les n traits à dessiner.

J'ai déjà trouvé une solution "algorithmique" ou itérative, c'est à dire que je fais un "premier jet" de mes hachures et je modifie par dichotomie la valeur de dF jusqu'à ce que le dernier trait atteigne (Xmax,Ymax) comme souhaité. Cette solution ne me satisfait pas parce qu'elle est coûteuse (beaucoup de calculs itératifs donc successifs et par conséquence perte de temps) pour mon logiciel. D'où ma tentative de trouver une solution algébrique au problème, où j'aurai dF exprimé en fonction de tous les autres paramètres exposés ci-dessus.
Etant donné qu'il n'y a qu'une seule solution possible à ce problème (nombre de traits finis, recouvrement fini et constant, intervalle borné, etc...) je suis convaincu que dF doit pouvoir s'exprimer simplement en fonction des autres paramètres... mais je peux me tromper...

Alors... est-ce un défi qui vous interesse ?

[Judoboy]

Tu veux que toutes les surfaces délimitées par tes hachures aient la même aire ? Comme ça rapidement je suis pas sûr du tout que tu aies une solution, vu qu'il faut que par exemple l'aire A du triangle en bas (délimité par la figure et le premier trait) soit égale à l'aire totale sur n+1, mais également à l'aire entre 2 traits et à l'aire du triangle en haut. Or tu ne peux agir que sur dF, soit sur la hauteur d'arrivée du premier trait.

Ca fait pas mal de contraintes pour un seul degré de liberté...

[Zorro_X]

non, ce n'est pas l'aire qui doit être constante mais R (le recouvrement entre deux traits, du point de vue vertical), ce qui fait que la distance entre deux traits en haut (lorsque dP dépasse Xmin) diminue...

[Judoboy]

Attends, qu'est-ce que tu appelles R exactement ?

[Zorro_X]

Attends, qu'est-ce que tu appelles R exactement ?

Bein, c'est sur le graphe, c'est la distance, qui pour simplifier peut être un pourcentage par exemple sur laquelle deux traits successifs se "chevauchent"...

[Skullkid]

Bonjour, comme l'écart vertical entre deux hachures est , avec le recouvrement défini comme un nombre signé (recouvrement négatif = le point le plus haut de la hachure la plus basse est en dessous du point le plus bas de la hachure suivante), tu peux facilement calculer l'ordonnée du point le plus haut de la n-ième hachure, et tu veux qu'elle soit égale à ymax. Ceci à supposer que ta droite oblique a un coefficient directeur suffisamment élevé pour que la situation soit comme sur ta figure. Sinon, l'ordonnée à atteindre n'est pas ymax mais dP*xmax.

[Zorro_X]

Alors en effet, je crois que j'ai un problème avec la définition que je vous ai donné du recouvrement : l'objectif du recouvrement c'est que la distance couverte sur dF soit la même pour toutes les lignes du hachurage... Ce qui rend la distance entre deux hachures variable (et decroissante) à partir du moment ou dP dépasse Xmin.

[Zorro_X]

J'avoue que j'osais espérer une réponse un peu plus construite, ça fait 2 jours que je planche sur ce problème et on s'est déjà même mis à deux, mais nos capacités mathématiques nous limitent pas mal dans la recherche d'une solution... :(

[Judoboy]

Bah honnêtement ça a pas l'air super dur, le problème c'est que je comprends pas la question...

Tu veux que la différence entre la hauteur max d'un trait et la hauteur min du trait suivant soit constante ?

[Zorro_X]

Bon ok, simplifions, enlevons le recouvrement : il faut faire en sorte que le y le plus haut d'un trait coïncide avec le y le plus bas du trait suivant (R=0). J'ai toujours besoin de trouver dF,en fonction des autres paramètres...
Si le problème est trop simple, je suis prêt à assumer mon incompétence à ce propos, mais franchement je ne vois pas la solution... :(

[fatal_error]

qqch comme ca?

Code: Tout sélectionner




#canvas{
  background-color:#eeeeee;
}


function toY(y){
  return -y+400;//400=canvas.height
}
function clearPlot(ctx, param){
  ctx.clearRect ( 0 , 0 , 400 , 450 );
  ctx.beginPath();
  var ymax=param.ymax;
  var ymin=param.ymin;
  var xmin=param.xmin;
  var xmax=param.xmax;
  var P=param.P;//ax=b, [a,b]
  //plot ymax
  ctx.moveTo(0,toY(ymax));
  ctx.lineTo(400, toY(ymax));
 
  //plot xmin
  ctx.moveTo(xmin,toY(ymin));
  ctx.lineTo(xmin,toY(400));
 
  //plot xmax
  ctx.moveTo(xmax,toY(ymin));
  ctx.lineTo(xmax,toY(400));
 
  //plot P
  ctx.moveTo(0,toY(ymin));
  ctx.lineTo((450-P[1]-ymin)/P[0], toY(450));
  ctx.stroke();
  ctx.closePath();
}
function plotHachures(ctx,param){
   var n=param.n,
         R=param.R,
         w=param.xmax-param.xmin,
         xmax=param.xmax,
         xmin=param.xmin,
         ymin=param.ymin,
         ymax=param.ymax,
         P=param.P;
  ctx.beginPath();
  var h=ymin;
  var d=(ymax-ymin-R)/n;//distance between two lines
   var a=(d+R)/w;//slope
   for(var i=0;i P[0]*xmin+P[1]){
         zemin =(h-a*xmin-P[1]-ymin)/(P[0]-a);
      }
      ctx.moveTo(zemin, toY(h));
      ctx.lineTo(xmax, toY(a*(xmax-xmin)+h));
      h+=d;
   }
  ctx.stroke();
  ctx.closePath();

}
window.onload=function(){
   var canvas = document.getElementById('canvas');
  var ctx = canvas.getContext('2d');
  var param={n:10,R:5,xmax:390,ymax:390,xmin:20,ymin:50,P:[5,0]};
  clearPlot(ctx, param);
  plotHachures(ctx, param);
};











[Zorro_X]

Désolé fatal_error, mais comme les autres, ta solution fait un hachurage constant ( distance constante entre deux lignes), je cherche un hachurage qui se rapproche lorsque la zone se rétrécit. R est un recouvrement constant entre tous les traits, pas seulement pour le trait indique en exemple...

[fatal_error]

salut,

je viens de piger pour le recouvrement.
T'aurais pu le préciser sur le dessin!

[Zorro_X]

merci ! J'ai tellement la tête dedans que j'ai l'impression que mon dessin est flagrant, ce qui visiblement n'est pas le cas... :( :mur:
alors ? des solutions ? ;)

[fatal_error]

en fait c'est un prob plus interessant quil n'en a l'air.
Je pense qu'on peut proceder ainsi ( mais je suis pas alle jusqu'au bout).
on pose n_1+n_2=n
avec n_1 le nombre de droites avant le point dintersection entre xmin et P
et n_2 le nombre de droite qui prennent leur support sur P (et non xmin)

on exprime ymax-ymin = n_1*d + somme(i=0, n_2-1) d(i)
ou d=(xmax-xmin)*a-R
avec a le coeff directeur de la droite, ce qu'on cherche
et h(i) = n_1*d + i*d(i)
et d(i) = (xmax-x(h))*a -R
avec x(i) qui depend de d(i)

dans les grosses lignes, jai pas fait gaffe aux indices et au raccord en passant de n_1 a n_2.
puis apres..., on a un truc qui depend de a,n_1,n_2 avec n_1 et n_2 des entiers, qu'il faut trouver.

[Zorro_X]

J'essaie justement d'éviter la solution itérative, car je tombe sur des itérations qui dependent de la pente à calculer (dF), ce que je ne sais du coup pas extraire et je me retrouve coincé.

[Dlzlogic]

Bonjour,
Ca me fait penser à un problème sur lequel je m'étais penché il y a un bout de temps.
Le but était de dessiner un certain graphisme à l'aide de hachures et seulement de hachures, pour des raisons de rapidité. S'il s'agit effectivement de cela, je peux rechercher mes notes.
En fait, de mémoire, la difficulté consistait à créer le modèle.
Est-ce que le mot-clé "Bird" vous dit quelque-chose ?

[Dlzlogic]

Ce que vous cherchez à faire serait-il quelque-chose comme ça ?
http://www.dlzlogic.com/EditePat.png

[Zorro_X]

Ce que vous cherchez à faire serait-il quelque-chose comme ça ?
http://www.dlzlogic.com/EditePat.png

Euh, au vu de l'image je ne sais pas dire si c'est le même problème, Bird ne me disant rien du tout, je ne peux pas confirmer s'il s'agit ou pas du même problème. Ma contrainte c'est réellement celle de remplir cette sorte de "semi-rectangle" avec des traits à recouvrement regulier sur leur hauteur (donc à distance non-régulière).

[Dlzlogic]

Je vais préciser les hypothèses.
Le rectangle Xmin,Xmax, Ymax est connu.
Le nombre n de traits de hachures est connu, 6 dans le cas de la figure.
Le longueur R de "recouvrement" est connue.
Le départ de la première hachure est en [Xmin;0]
L'arrivée de le dernière hachure est en [Xmax;Ymax]
La droite DP est sans importance pour le problème.

J'appelle A le point à Xmin, pour la 5è hachure. Sa projection sur Xmax est C, L'arrivée de cette 5è hachure est B
AC = Xmax-Xmin
BC = (Xmax-Xmin) * DF = e + R ; e est la distance de 2 arrivées de hachures.
Ymax = n * e + BC = n * e + e +R
e = (Ymax + R) / (n+1)
DF = (e + R) / (Xmax - Xmin)

Mais, ça parait trop simple.