#!/bin/csh
#######################################################################################################################################
# #
# G E N E R A T I O N D ' U N F R A C T A L " C A R R E " ( V E R S I O N 1 ) : #
# #
# #
# Utilisation : #
# #
# $xrf/FractalCarre.11$Z <SequenceR> #
# <Niterations> #
# <DimensionX> <DimensionY> #
# <Complementer> #
# <ListeNiveaux> #
# <Mode> <Convoluer> <Remplir> <Bande> #
# <FormatR> #
# <ArgumentsRemplir> #
# <Palette> #
# <ArgContours> #
# #
# #
# Author of '$xrf/FractalCarre.11$Z' : #
# #
# Jean-Francois COLONNA (LACTAMME, 20231118094000). #
# #
#######################################################################################################################################
set SequenceR=($1)
set Niterations=$2
set DimensionX=$3
set DimensionY=$4
set Complementer=$5
set ListeNiveaux=($6)
set Mode=$7
set Convoluer=$8
set Remplir=$9
# Argument introduit le 20231122110435... #
set Bande=$10
set FormatR="$11"
set ArgumentsRemplir="$12"
set Palette="$13"
# Argument introduit le 20231123114147... #
set ArgContours="$14"
# Argument introduit le 20231129101031... #
setArgum ArgContours "$K_VIDE"
set SequenceR1=$SequenceR[1]
if ($#SequenceR > 1) then
set SequenceR2=$SequenceR[2]
# Possibilite introduite le 20231127171401... #
else
endif
set index0=1
set indexP=1
set NpOiNtS=9
set GrAiNe=1947
set PGrAiNe=1
set ExPoSaNt=0.5
set SeUiL_NB=0.85
set NiVeAu_CaDrE=$GRIS_4
set EpAiSsEuR_CaDrE=4
set AtTeNuAtIoN=0.5
set NiVeAu_InItIaL=$GRIS_2
# Quelques parametres... #
@ NoIr = $NOIR
@ BlAnC = $BLANC
# Et ce a cause de la definition des niveaux '$GRIS_?' avec un ou plusieurs "0" en tete... #
set AlEaToIrE=0
set index2=$index0
while ($index2 <= $#ListeNiveaux)
if ($ListeNiveaux[$index2] == $NoIr) then
@ AlEaToIrE = $AlEaToIrE + 1
# Si '$ListeNiveaux' ne contient que du '$NOIR', elle sera aleatoire... #
else
endif
@ index2 = $index2 + $indexP
end
if ($AlEaToIrE == $#ListeNiveaux) then
set GAlEaToIrE=$EXIST
# Si '$ListeNiveaux' ne contient que du '$NOIR', elle sera aleatoire... #
else
set GAlEaToIrE=$NEXIST
endif
if ($GAlEaToIrE == $EXIST) then
alias GRaNdOm '$xci/valeurs_alea$X p=$index0 d=$#ListeNiveaux graine=$GrAiNe entiers=FAUX | \\
$xrv/PUIX.01$X ne=0 fichier== E=$ExPoSaNt | \\
$xrv/IFGT.11$X ne=0 fichier1== fichier2=$SeUiL_NB | \\
$xrv/MUL2.11$X ne=0 fichier2== fichier1=$BLANC formater=VRAI signe="$K_VIDE" entier=VRAI ; \\
'
set ListeNiveaux=`GRaNdOm`
# Generation d'une liste aleatoire... #
@ GrAiNe = $GrAiNe + $PGrAiNe
# La progression de la graine ne peut avoir lieu dans l'alias 'GRaNdOm' car, en effet, #
# cette progression serait alors locale a 'GRaNdOm' et ne propagerait donc pas... #
else
endif
if ($Complementer) then
#20231119075531____: set ListeNiveaux=`echo "$ListeNiveaux" | $SE -e "s/$NOIR/NOIR/g" -e "s/$BLANC/BLANC/g"` #
#20231119075531____: set ListeNiveaux=`echo "$ListeNiveaux" | $SE -e "s/NOIR/$BLANC/g" -e "s/BLANC/$NOIR/g"` #
alias CoMpLeM 'FilSTmpB FCoMpLeMeNtEr $Y ; \\
$CA $xcs/csh$Y \\
>> $FCoMpLeMeNtEr ; \\
echo "$ListeNiveaux" | \\
$R "$K_BLANC" "$K_NL" | \\
$GRE -v '"'"'^ *$'"'"' | \\
$SE -e '"'"'s/^\(.*\)$'"'"'"/@ CoMpLeMeNt = $BLANC - \1\necho "'"'"'$CoMpLeMeNt/'"'"' \\
>> $FCoMpLeMeNtEr ; \\
set ListeNiveaux=`source $FCoMpLeMeNtEr` ; \\
FilSTmpE FCoMpLeMeNtEr'
CoMpLeM
# On notera le 20231118172950 que les conventions de Jean-Paul Delahaye sont inversees par #
# rapport a moi : pour lui, le fractal est '$NOIR', alors que pour moi il est '$BLANC'... #
# D'ou cette inversion initiale... #
else
endif
@ VaLiDaTiOn = $DimensionX * $DimensionY
if ($VaLiDaTiOn == $#ListeNiveaux) then
set List_dimX="$K_VIDE"
set List_Xmin="$K_VIDE"
set List_Xmax="$K_VIDE"
set DiMeNsIoN_X=1
set List_dimY="$K_VIDE"
set List_Ymin="$K_VIDE"
set List_Ymax="$K_VIDE"
set DiMeNsIoN_Y=1
set index2=$index0
while ($index2 <= $Niterations)
@ DiMeNsIoN_X = $DimensionX * $DiMeNsIoN_X
@ DiMeNsIoN_Y = $DimensionY * $DiMeNsIoN_Y
set List_Xmin=($List_Xmin $Xmin)
set List_Xmax=($List_Xmax `calculINS $Xmin+$DiMeNsIoN_X-1`)
set List_dimX=($List_dimX $DiMeNsIoN_X)
set List_Ymin=($List_Ymin $Ymin)
set List_Ymax=($List_Ymax `calculINS $Ymin+$DiMeNsIoN_Y-1`)
set List_dimY=($List_dimY $DiMeNsIoN_Y)
@ index2 = $index2 + $indexP
end
FilSTmpB FraCtAl
FilSTmpB MoTiFsDeBaSe
set Final_Xmax=`echo "$FormatR" | $SE -e "s/^.*Xmax//" | $AW ' { print $1 }' | $SE -e "s/^.*R=//"`
set Final_Ymax=`echo "$FormatR" | $SE -e "s/^.*Ymax//" | $AW ' { print $1 }' | $SE -e "s/^.*R=//"`
if (($List_Xmax[$Niterations] > $Final_Xmax) || ($List_Ymax[$Niterations] > $Final_Ymax)) then
EROR "Le format '$FormatR' n'est pas suffisant, il faut l'augmenter."
else
endif
#20231120102055____: set MoDeReDiM=7 #
#20231120103019____: set MoDeReDiM=0 #
#20231120105508____: set MoDeReDiM=2 #
set MoDeReDiM=$Mode
set LiStE_NuMeRoS=`$xci/nombres$X A="$K_VIDE" premiere=$index0 derniere=$#ListeNiveaux pas=$indexP`
XYmaxNe 0 0
# Au debut du processus, les images etant uniformes (de niveau donne par '$ListeNiveaux') #
# elles sont de taille 1x1... #
set index1=$index0
foreach NiVeAu ($ListeNiveaux)
$xci/init$X n=$NiVeAu \
R=$MoTiFsDeBaSe.$LiStE_NuMeRoS[$index1] \
$formatI
# Generation des images de base de taille 1x1... #
@ index1 = $index1 + $indexP
end
set index2=$index0
set ListeNumeros=`$xci/nombres$X p=$index2 d=$Niterations pas=$indexP`
set FoRmAtR="$K_VIDE"
set FoRmAtR="$FoRmAtR"" XminR=$List_Xmin[$index2]"
set FoRmAtR="$FoRmAtR"" XmaxR=$List_Xmax[$index2]"
set FoRmAtR="$FoRmAtR"" YminR=$List_Ymin[$index2]"
set FoRmAtR="$FoRmAtR"" YmaxR=$List_Ymax[$index2]"
$xci/regroupe.01$Z $MoTiFsDeBaSe. \
$FraCtAl.$ListeNumeros[$index2] \
$index0 $indexP \
$DimensionX $DimensionY \
"$K_VIDE" \
"$FoRmAtR"
# Regroupement des images de base de taille 1x1 pour en faire le motif de base du fractal... #
# #
# ATTENTION : l'image '$FraCtAl.$ListeNumeros[$index2]' donne l'iteration '$index2=1' au #
# format (D^N)x(D^N) ou 'D' represente '$DimensionX' et '$DimensionY' et 'N=$index2=1'... #
FilSTmpE MoTiFsDeBaSe
if ($?SequenceR2 == $EXIST) then
$xci/neutre$X A=$FraCtAl.$ListeNumeros[$index2] \
R=$SequenceR2.$LiStE_NuMeRoS[$index2] \
Xmin=$List_Xmin[$index2] \
Xmax=$List_Xmax[$index2] \
Ymin=$List_Ymin[$index2] \
Ymax=$List_Ymax[$index2]
else
endif
$xci/format.01$X A=$FraCtAl.$ListeNumeros[$index2] \
Xmin=$List_Xmin[$index2] \
Xmax=$List_Xmax[$index2] \
Ymin=$List_Ymin[$index2] \
Ymax=$List_Ymax[$index2] \
mode=0 \
R=$SequenceR1.$LiStE_NuMeRoS[$index2] \
XminR=$List_Xmin[$Niterations] \
XmaxR=$List_Xmax[$Niterations] \
YminR=$List_Ymin[$Niterations] \
YmaxR=$List_Ymax[$Niterations]
$xci/format.01$X A=$SequenceR1.$LiStE_NuMeRoS[$index2] \
Xmin=$List_Xmin[$Niterations] \
Xmax=$List_Xmax[$Niterations] \
Ymin=$List_Ymin[$Niterations] \
Ymax=$List_Ymax[$Niterations] \
mode=$MoDeReDiM \
R=$SequenceR1.$LiStE_NuMeRoS[$index2] \
$FormatR
while ($index2 < $Niterations)
if ($GAlEaToIrE == $EXIST) then
set ListeNiveaux=`GRaNdOm`
# Generation d'une nouvelle liste aleatoire... #
@ GrAiNe = $GrAiNe + $PGrAiNe
# La progression de la graine ne peut avoir lieu dans l'alias 'GRaNdOm' car, en effet, #
# cette progression serait alors locale a 'GRaNdOm' et ne propagerait donc pas... #
if ($Complementer) then
CoMpLeM
else
endif
else
endif
XYmaxNe $List_Xmax[$index2] $List_Ymax[$index2]
set index1=$index0
FilSTmpB MoTiFsDeBaSe
foreach NiVeAu ($ListeNiveaux)
@ NiVeAu = $NiVeAu
# Et ce a cause de la definition des niveaux '$GRIS_?'... #
#20231118172950____: if ($NiVeAu == $NoIr) then #
#20231118190159____: if ($NiVeAu == $BlAnC) then #
if ($NiVeAu == $NoIr) then
$xci/init$X n=$NiVeAu \
R=$MoTiFsDeBaSe.$LiStE_NuMeRoS[$index1] \
$formatI
else
$xci/seuil$X A=$FraCtAl.$ListeNumeros[$index2] \
superieur=$NiVeAu \
R=$MoTiFsDeBaSe.$LiStE_NuMeRoS[$index1] \
$formatI
endif
# Construction du motif de base suivant du fractal... #
@ index1 = $index1 + $indexP
end
@ index2 = $index2 + $indexP
set FoRmAtR="$K_VIDE"
set FoRmAtR="$FoRmAtR"" XminR=$List_Xmin[$index2]"
set FoRmAtR="$FoRmAtR"" XmaxR=$List_Xmax[$index2]"
set FoRmAtR="$FoRmAtR"" YminR=$List_Ymin[$index2]"
set FoRmAtR="$FoRmAtR"" YmaxR=$List_Ymax[$index2]"
$xci/regroupe.01$Z $MoTiFsDeBaSe. \
$FraCtAl.$ListeNumeros[$index2] \
$index0 $indexP \
$DimensionX $DimensionY \
"$K_VIDE" \
"$FoRmAtR"
# Regroupement donnant l'iteration courante du fractal... #
# #
# ATTENTION : l'image '$FraCtAl.$ListeNumeros[$index2]' donne l'iteration '$index2' au #
# format (D^N)x(D^N) ou 'D' represente '$DimensionX' et '$DimensionY' et 'N=$index2'... #
if ($?SequenceR2 == $EXIST) then
$xci/neutre$X A=$FraCtAl.$ListeNumeros[$index2] \
R=$SequenceR2.$LiStE_NuMeRoS[$index2] \
Xmin=$List_Xmin[$index2] \
Xmax=$List_Xmax[$index2] \
Ymin=$List_Ymin[$index2] \
Ymax=$List_Ymax[$index2]
else
endif
FilSTmpE MoTiFsDeBaSe
$xci/format.01$X A=$FraCtAl.$ListeNumeros[$index2] \
Xmin=$List_Xmin[$index2] \
Xmax=$List_Xmax[$index2] \
Ymin=$List_Ymin[$index2] \
Ymax=$List_Ymax[$index2] \
mode=0 \
R=$SequenceR1.$ListeNumeros[$index2] \
XminR=$List_Xmin[$Niterations] \
XmaxR=$List_Xmax[$Niterations] \
YminR=$List_Ymin[$Niterations] \
YmaxR=$List_Ymax[$Niterations]
$xci/format.01$X A=$SequenceR1.$ListeNumeros[$index2] \
Xmin=$List_Xmin[$Niterations] \
Xmax=$List_Xmax[$Niterations] \
Ymin=$List_Ymin[$Niterations] \
Ymax=$List_Ymax[$Niterations] \
mode=$MoDeReDiM \
R=$SequenceR1.$ListeNumeros[$index2] \
$FormatR
# Le "mode=7" garantit l'integrite du motif et la meme echelle "pour tout le monde"... #
end
set FoRmAt=`echo "$FormatR" | $SE "s/R\(=\)/\1/g"`
FilSTmpE FraCtAl
if ($Complementer) then
set index2=$index0
while ($index2 <= $Niterations)
$xci/complement$X A=$SequenceR1.$ListeNumeros[$index2] \
R=$SequenceR1.$ListeNumeros[$index2] \
$FoRmAt
@ index2 = $index2 + $indexP
end
else
endif
if ($Convoluer == $EXIST) then
set index2=$index0
while ($index2 <= $Niterations)
$xci/convol.01$X A=$SequenceR1.$ListeNumeros[$index2] \
points=$NpOiNtS \
R=$SequenceR1.$ListeNumeros[$index2] \
$FoRmAt
# Pourquoi cette convolution ? Il y a en fait deux cas : #
# #
# 1-Si '$DimensionX*$DimensionY' n'est pas une puissance de 2 et/ou si '$FormatR' ne definit #
# pas une "image puissance de 2" (tel 'Sdu' par exemple), alors les '$xci/format.01$X's #
# precedents introduisent du "flou" sur les contours (via "mode=2"). #
# #
# 1-Si '$DimensionX*$DimensionY' est pas une puissance de 2 et si '$FormatR' definit une #
# "image puissance de 2" (tel 'Sdu' par exemple), alors les '$xci/format.01$X's precedents #
# n'introduisent pas de "flou" sur les contours (via "mode=2") et les images sont nettes. #
# #
# Le '$xci/convol.01$X' precedent est donc destine a introduire du "flou" dans les images #
# trop nettes (c'est un comble !) et ce afin que toutes les images aient la meme apparence #
# quel que soit la taille de leur 'Noyau' (defini pas {$DimensionX,$DimensionY}) et quel #
# soit la taille finale (definie par '$FormatR')... #
@ index2 = $index2 + $indexP
end
else
if ($Remplir == $EXIST) then
# Possibilite introduite le 20231122110435... #
set index2=$index0
while ($index2 <= $Niterations)
$xci/contours.22$X A=$SequenceR1.$ListeNumeros[$index2] \
$ArgumentsRemplir \
$FoRmAt | \
$xci/maximum$X A2=$SequenceR1.$ListeNumeros[$index2] \
R=$SequenceR1.$ListeNumeros[$index2] \
$FoRmAt
# Remplissage des composantes connexes... #
@ index2 = $index2 + $indexP
end
else
endif
endif
XYmaxNe $Final_Xmax $Final_Ymax
if (($Xmax > $XmaxSdu) || ($Ymax > $YmaxSdu)) then
set index2=$index0
while ($index2 <= $Niterations)
$xci/format.01$X A=$SequenceR1.$ListeNumeros[$index2] \
mode=2 \
$formatI \
R=$SequenceR1.$ListeNumeros[$index2] \
$formatR_Sdu
# Reduction des images trop grandes... #
@ index2 = $index2 + $indexP
end
Sdu
set Final_Xmax=$Xmax
set Final_Ymax=$Ymax
else
endif
if ($Bande == $EXIST) then
# Possibilite introduite le 20231121105020... #
FilSTmpB ImAgE_EnCaDrReE
set Elargi_Xmax=`calculINS $EpAiSsEuR_CaDrE+$Final_Xmax+$EpAiSsEuR_CaDrE`
set Elargi_Ymax=`calculINS $EpAiSsEuR_CaDrE+$Final_Ymax+$EpAiSsEuR_CaDrE`
set index2=$index0
while ($index2 <= $Niterations)
$xci/format.01$X A=$SequenceR1.$ListeNumeros[$index2] \
mode=7 \
$formatI \
R=$ImAgE_EnCaDrReE.$ListeNumeros[$index2] \
XminR=$List_Xmin[$index2] \
XmaxR=$Elargi_Xmax \
YminR=$List_Ymin[$index2] \
YmaxR=$Elargi_Ymax
# Agrandissement de l'image afin de pouvoir ensuite encadrer sans rien ecraser... #
@ index2 = $index2 + $indexP
end
XYmaxNe $Elargi_Xmax $Elargi_Ymax
set BaNdE_Xmax=`calculINS ($Niterations*$dimX)-1`
set BaNdE_Ymax=$Ymax
if ("$Palette" == "$K_VIDE") then
set index2=$index0
while ($index2 <= $Niterations)
$xci/cadre$X A=$ImAgE_EnCaDrReE.$ListeNumeros[$index2] \
epaisseur=$EpAiSsEuR_CaDrE \
niveau=$NiVeAu_CaDrE \
R=$ImAgE_EnCaDrReE.$ListeNumeros[$index2] \
$formatI
# Encadrement de l'image... #
@ index2 = $index2 + $indexP
end
$xci/regroupe.01$Z $ImAgE_EnCaDrReE. \
$SequenceR1 \
$index0 $indexP \
$Niterations 1 \
"$K_VIDE" \
"XminR=0 Xmax=$BaNdE_Xmax YminR=0 Ymax=$BaNdE_Ymax"
# Creation d'une bande horizontale de '$Niterations' images... #
else
@ SeUiL = $BLANC - 1
set index2=$index0
while ($index2 <= $Niterations)
$xci/vraies_C$X A=$ImAgE_EnCaDrReE.$ListeNumeros[$index2] \
p=$Palette \
R=$ImAgE_EnCaDrReE.$ListeNumeros[$index2] \
$formatI
# Coloriage de l'eventuel remplissage. #
execRVB $xci/scale$X A=$ImAgE_EnCaDrReE.$ListeNumeros[$index2]%s \
a=$AtTeNuAtIoN \
R=$ImAgE_EnCaDrReE.$ListeNumeros[$index2]%s \
$formatI
# Attenuation de l'eventuel remplissage. #
$xci/seuil$X A=$ImAgE_EnCaDrReE.$ListeNumeros[$index2] \
seuil=$SeUiL \
R=$ImAgE_EnCaDrReE.$ListeNumeros[$index2] \
$formatI
# Recuperation du fond '$BLANC'... #
execRVB $xci/cache$X A=$ImAgE_EnCaDrReE.$ListeNumeros[$index2]%s \
M=$ImAgE_EnCaDrReE.$ListeNumeros[$index2] \
R=$ImAgE_EnCaDrReE.$ListeNumeros[$index2]%s \
$formatI
# Et reinsertion du fond '$BLANC'... #
execRVB $xci/cadre$X A=$ImAgE_EnCaDrReE.$ListeNumeros[$index2]%s \
epaisseur=$EpAiSsEuR_CaDrE \
niveau=$NiVeAu_CaDrE \
R=$ImAgE_EnCaDrReE.$ListeNumeros[$index2]%s \
$formatI
# Encadrement de l'image... #
@ index2 = $index2 + $indexP
end
execRVB $xci/regroupe.01$Z $ImAgE_EnCaDrReE. \
$SequenceR1%s \
$index0 $indexP \
$Niterations 1 \
"%s" \
'$K_QD XminR=0 Xmax=$BaNdE_Xmax YminR=0 Ymax=$BaNdE_Ymax $K_QD'
endif
FilSTmpE ImAgE_EnCaDrReE
else
endif
if ($?SequenceR2 == $EXIST) then
# Possibilite introduite le 20231127171401... #
if ($Complementer) then
set CoMplEmEnTeR=VRAI
else
set CoMplEmEnTeR=FAUX
endif
set index2=$index0
while ($index2 <= $Niterations)
$xci/contours.22$X A=$SequenceR2.$LiStE_NuMeRoS[$index2] \
complementer=$CoMplEmEnTeR \
optimiser_increment=FAUX \
niveau_initial=$NiVeAu_InItIaL \
$ArgContours \
R=$SequenceR2.$LiStE_NuMeRoS[$index2] \
Xmin=$List_Xmin[$index2] \
Xmax=$List_Xmax[$index2] \
Ymin=$List_Ymin[$index2] \
Ymax=$List_Ymax[$index2]
# Il ne faut surtout pas utiliser l'option : #
# #
# optimiser_increment=VRAI #
# #
# car, en effet, elle fait que nombreux sont les points voisins de meme niveau (voir par #
# exemple 'v $xiirf/FRC1.31.45.CC.0005'... #
@ index2 = $index2 + $indexP
end
else
endif
else
EROR "La liste des niveaux est incompatible avec les deux dimensions."
endif