Les entre-deux ou In-beetween

Les entre-deux sont dessinés avec deux éléments distincts mais similaires par le nombre de point de contrôle de chemin pour obtenir une correspondance deux à deux de ces points. Le «genre» des points est conservé, mais doit aussi correspondre deux à deux. Exemple : deux points de type Bézier.

Si vous savez comment diviser une ligne en segments égaux, alors vous devez comprendre comment générer autant de chemin de dessins successifs pour les relier.

function IN_Between(a,b,index,max:real):integer;
	begin
	if max=0.0 then
		IN_Between:=round(a)
	else
		IN_Between:=round(a+index*(b-a)/max);
	end;

function IN_Between(a,b,index,max:real):integer;
	begin
	if max=0.0 then
		IN_Between:=round(a)
	else
		IN_Between:=round(a+index*(b-a)/max);
	end;

function IN_Between_int(a,b,index,max:integer):integer;
	begin
	if max=0 then
		IN_Between_int:=a
	else
		IN_Between_int:=a+(index*(b-a)) div max;
	end;

function Real_IN_Between(a,b,index,max:real):Real;
	begin
	if max=0.0 then
		Real_IN_Between:=a
	else
		Real_IN_Between:=a+index*(b-a)/max;
	end;

function IN_Between_longint_RGB(a,b:longint; index,max:real):longint;
	begin
	IN_Between_longint_RGB:=RGB(
		IN_Between(getrvalue(a),getrvalue(b),index,max),
		IN_Between(getgvalue(a),getgvalue(b),index,max),
		IN_Between(getbvalue(a),getbvalue(b),index,max));
	end;

(* code C a partir d'une méthode découverte à la bibliothèque de la vilette by db*)
procedure HLS_to_RGB(h,l,s:real; var r,g,b:real);
	var v,m,sv,fract,vsf,mid1,mid2:real;
	    sextant:integer;
	begin
	if h=360 then
  	    h:=0
  	  else
  	    h:=h/360;
	if l<=0.5 then
		v:=l*(1.0+s)
	else
		v:=l+s-l*s;
	if v<=0.0 then
		begin
		r:=0.0; g:=0.0; b:=0.0;
		end
	else
		begin
		m:=l+l-v; sv:=(v-m)/v;
		h:=h*6.0;
		sextant:=trunc(h);
		fract:=h-sextant;
		vsf:=v*sv*fract;
		mid1:=m+vsf;
		mid2:=v-vsf;
		case sextant of
			0:begin r:=v;	 g:=mid1; b:=m	  end;
			1:begin r:=mid2; g:=v;	  b:=m	  end;
			2:begin r:=m;	 g:=v;	  b:=mid1 end;
			3:begin r:=m;	 g:=mid2; b:=v    end;
			4:begin r:=mid1; g:=m;    b:=v	  end;
			5:begin r:=v;	 g:=m;	  b:=mid2 end;
			end; {case sextant}
      		end;
	end; {HLS_to_RGB}

{tcolorref  ->  h:0..360, l:0..1, s:0..1}
procedure tcolorref_to_hls(acolor:tcolorref; var h,l,s:real);
	begin
	RGB_to_HLS(
		1.0*getrvalue(acolor)/255,
		1.0*getgvalue(acolor)/255,
		1.0*getbvalue(acolor)/255, h,l,s);
   end;

{r:0..1, g:0..1, b:0..1   ->  h:0..360, l:0..1, s:0..1}
procedure RGB_to_HLS(r,g,b:real; var h,l,s:real);
	var v,m,vm,r2,g2,b2:real;
	begin
	v:=rmax(rmax(r,g),b);
	m:=rmin(rmin(r,g),b);

	l:=(m+v) / 2.0; h:=0; s:=0;
	if l<=0 then
		begin
		l:=0;
   		 exit;
		end;

   	vm:=v-m;
   	s:=vm;
	if s>0.0 then
		begin
		if l<0.5 then
			s:=s/(v+m)
		else
			s:=s/(2.0-v-m);
		end
	else
		exit;
	r2:=(v-r)/vm;
	g2:=(v-g)/vm;
	b2:=(v-b)/vm;
	if r=v then
		begin
		if g=m then
			h:=5.0+b2
		else
      	h:=1.0-g2
		end
	else if g=v then
		begin
		if b=m then
			h:=1.0+r2
		else
      	h:=3.0-b2
		end
	else
		begin
		if r=m then
			h:=3.0+g2
		else
      	h:=5.0-r2
		end;

	h:=round(h*60) mod 360;
	{h:=h/6;
	h:=h*360;}
	end; {RGB_to_HLS}

function IN_Between_longint_HLS(a,b:longint; index,max:real):longint;
	var ah,al,asat:real;
	    bh,bl,bs:real;
	    acolorref:tcolorref;
	begin
	hls_rvb.tcolorref_to_hls(a,ah,al,asat);
	hls_rvb.tcolorref_to_hls(b,bh,bl,bs);
	if a=b then	bh:=bh+360;
	hls_to_tcolorref(
		Real_IN_Between(ah,bh,index,max),
		Real_IN_Between(al,bl,index,max),
		Real_IN_Between(asat,bs,index,max),acolorref);
	IN_Between_longint_HLS:=acolorref;
	end;

function IN_Between_longint_Exp(a,b:longint; index,max:real):longint;
  var max_exp:real;
      ind_exp:real;
  begin
  ind_exp:=(index/max);
  ind_exp:=ind_exp*ind_exp;
  max_exp:=1.0;
  IN_Between_longint_Exp:=RGB(
		IN_Between(getrvalue(a),getrvalue(b),ind_exp,max_exp),
		IN_Between(getgvalue(a),getgvalue(b),ind_exp,max_exp),
		IN_Between(getbvalue(a),getbvalue(b),ind_exp,max_exp) );
  end; {IN_Between_longint_Exp}

Dans le dialogue Entre-deux vous pouvez déterminer le nombre d'étapes intermédiaires.

Et dans le dialogue Interpolation une réglette permet de positionner des couleurs intermédiaires et de visualiser en temps-réel l'affichage du dégradé de couleur.

Faire varier un ensemble de points vers un autre, voilà ce que réalise la fonction entre-deux. Mais pour celà une spécificité du dessin vectoriel, propre à Denis-Draw demande à ce que le nombre et le type des points de controle de chemin soient d'une forme à l'autre similaires. Comme expliquer plus haut, la génération de la premiére courbe vers la seconde courbe génére alors autant de courbe de passage de l'une vers l'autre selon le nombre d'intervalles définies.
Et autant de points de contrôle de chemin, se déplacant des uns vers les autres.

La fonction Interpolation n'agis pas différemment, mais permet aussi d'ajouter des couleurs intermédiares qui seront appliquées à chaque étape du dessin des courbes intermédiaires.

Cette fonction m'a été suggerée par Brian Smith professeur à l'Ecole Nationale de Bourges d'Art.