c ========================================================
c
c		Recuit simulé à la sauce f.m.b.l
c		--------------------------------
c
c	ce programme utilise une librairie graphique
c	pour l'écriture des images. vous la trouverez
c	à la buvette, dans /archives.
c
c	This program is free software... bla... etc...
c
c	As usual, whithout any garanties... etc...
c
c ========================================================

	program recuit

c --------------------------------------------------------
c	déclaration des constantes

	integer largeur,hauteur
	parameter (largeur=640, hauteur=480)

	integer nbpoints,nbpasses
	parameter (nbpoints=100, nbpasses=10000)

	real diametre
	parameter (diametre=200.42)

c --------------------------------------------------------
c	déclaration des fonctions externes (libimage)

	integer img_create

c --------------------------------------------------------
c	déclaration des variables

	integer image
	integer foo, ix, iy
	integer passe
	integer reprises
	real x, y, dist, cumul, delta
	real precedent

	real px0(nbpoints), py0(nbpoints)
	real px1(nbpoints), py1(nbpoints)
	real px2(nbpoints), py2(nbpoints)

c --------------------------------------------------------

	write(6,*) '---------------------------------------'
	write(6,*) '--------    Recuit   Simulé    --------'
	write(6,*) '---------------------------------------'
	write(6,*) '--------  (g) Tonton Th 2002   --------'
	write(6,*) '---------------------------------------'
	write(6,*)

c	allocation et initialisation de l'image

	image = img_create(largeur, hauteur, 3)
	call img_clear(image, 42, 42, 42)

c	initialisation randomatique des points
	do 10 foo=1,nbpoints
	    px0(foo) = rand() * real(largeur)
	    py0(foo) = rand() * real(hauteur)
	    call croix(image, px0(foo), py0(foo), 255, 0, 0)
10	continue

c 	sauvegarde de l'image des points de depart
	call img_tga_sa(image, "depart.tga", 0)

c	------------------------------------------------
c	recopie de la table des points d'origine dans la
c	table de travail.
	do 20 foo=1,nbpoints
	    px1(foo) = px0(foo)
	    py1(foo) = py0(foo)
20	continue

c	----------------------------
c	initialisation des variables

	precedent = 1e10

c	=================
c	boucle principale

	do 1000 passe=1, nbpasses

C	    write(6, 5000) passe, nbpasses

c	    ----------------------------------------------
c	    point de reprise: c'est là que l'on revient si
c	    la bonheur n'a pas augmenté...
	    reprises = 0
99	    continue

c	    -----------------------------------
c	    déplacement randomatique des points
	    do 100 foo=1,nbpoints
		px2(foo) = px1(foo)+(rand()*2.0)-1.0
		py2(foo) = py1(foo)+(rand()*2.0)-1.0
100	    continue

c	    --------------------------------
c	    calcul du coefficient de bonheur.
	    cumul = 0.0
	    do 110 foo=1,nbpoints
		x = px2(foo)-real(largeur/2)
		y = py2(foo)-real(hauteur/2)
		dist = sqrt(x*x+y*y)
		cumul=cumul+abs(diametre-dist)
110	    continue
	    delta = cumul

c	    ----------------------------------------------
c	    tester si on a fait mieux qu'au tour précédent
	    if (delta .gt. precedent) then
		reprises = reprises+1
		goto 99
	    endif

	    precedent = delta

	    write(6, 5004) passe,delta,reprises

c	    -----------------------------
c	    recopie et plotage des points
	    do 120 foo=1,nbpoints
		px1(foo) = px2(foo)
		py1(foo) = py2(foo)
		ix = int(px1(foo))
		iy = int(py1(foo))
	        call img_plot(image,ix,iy,20,100,30)
120	    continue
	
c	    --------------------------------------
c	    eventuellement, on peut sauver l'image
	    if ( mod(passe,100) .eq. 0 ) then
	    	do 150 foo=1,nbpoints
		    ix = int(px1(foo))
		    iy = int(py1(foo))
	            call img_plot(image,ix,iy,120,120,120)
150		continue
	    	call img_tga_sa(image, "toto.tga", 0)
	    endif

c	    -----------------------------------------
c	    si notre objectif de bonheur est atteint,
c	    on peut sortir avec joie de la boucle
	    if ( delta .lt. (real(nbpoints)*1.4) ) goto 1010

c	---------------------------
c	fin de la boucle principale
1000	continue


c       °°°°°°°°°°°°°°°°°°°°°°°°°°
c	\O/ sortie victorieuse \O/
c       ~~~~~~~~~~~~~~~~~~~~~~~~~~
1010	continue

c	----------------------------------------
c	dessin des points d'origine dans l'image
	do 300 foo=1,nbpoints
	    call croix(image, px0(foo), py0(foo), 255, 0, 0)
300	continue

c	-------------------------------------
c	dessin des points finaux dans l'image
	do 400 foo=1,nbpoints
	    call croix(image, px1(foo), py1(foo), 100, 255, 255)
400	continue

c	------------------------------------
c 	encadrement et sauvegarde de l'image
	call img_cadre(image, 1)
	call img_tga_sa(image, "finale.tga", 0)


5000	format('-----  passe ', i6, '   / ', i6)
5001	format('  delta    ', f15.6)
5002	format('  reprises ', i8)

5004	format(i8, f15.6, i8)

	end

c --------------------------------------------------------
	subroutine croix(img, x, y, r, g, b)
	integer		img, r, g, b
	real		x, y

	integer		ix, iy, foo

	ix = int(x)
	iy = int(y)
	do 1 foo=-2,2
	    call img_plot(img, ix+foo, iy, r, g, b)
1	continue
	do 2 foo=-2,2
	    call img_plot(img, ix, iy+foo, r, g, b)
2	continue
	end
c --------------------------------------------------------
