Transformations bijectives d'images: Photomaton et Boulanger

rem ============================================================================
rem            Transformations bijectives d’images
rem               Trans_Biject_Images.bas
rem ============================================================================
rem Wikipédia :
rem On appelle transformation bijective d’image une transformation d’une image
rem finie de n x m pixels sur elle-même :
rem Chaque pixel est donc déplacé et aucun pixel n’est perdu, ce qu’on appelle
rem en mathématiques une permutation de l’ensemble des pixels et en langage
rem courant un mélange.
rem De manière triviale, n applications de cette transformation redonnent l’image
rem initiale.
rem Cette propriété est générale : pour toute transformation bijective d’image,
rem il existe un plus petit entier k telle que appliquée k fois, la transformation
rem redonne l’image initiale.
rem ============================================================================
rem Les transformations bijectives d’images les plus connues sont
rem * La transformation du photomaton
rem * La transformation du boulanger (et sa variante le fer à cheval de Smale)
rem * La transformation de Hilbert
rem ============================================================================
rem Le nombre d’étapes avant de voir réapparaitre l’image est parfois très grand
rem et dépend d’une part de la transformation et d’autre part de la taille de
rem l’image.
rem Par exemple une image carrée dont le côté est une puissance de 2 reviendra
rem très vite, alors qu’avec deux nombres quelconques, le retour peut-être
rem extrêmement long.
rem Durant ces étapes, on passe parfois par des reconstitutions très proches de
rem l’image initiale.
rem ============================================================================
rem *** Transformation du photomaton
rem La transformation du cliché Photomaton est une description d’un type de
rem mélange analogue à un cliché Photomaton qui à partir d’une image en fabrique
rem quatre de plus petites dimensions, et ainsi de suite par itération.
rem Cette transformation est un cas particulier de transformations bijectives
rem d’images.
rem ============================================================================
rem Principe de la transformation du photomaton
rem Le principe de cette transformation est le suivant :
rem pour obtenir une nouvelle image, l’image originale est decomposée en 4 images
rem rétrécies récursivement.
rem L’image est tout d’abord découpée en carrés de 4 pixels (2 × 2) puis le pixel
rem en haut à droite de chaque carré sert à recomposer une image de taille 1/2
rem en haut à droite, idem pour la partie en haut à gauche, en bas à droite,
rem en bas à gauche.
rem Cette transformation ne fonctionne qu’avec des images dont la hauteur et la
rem largeur sont paires.
rem Si on répète un certain nombre de fois cette transformation, on retrouve
rem l’image de départ.
rem Le nombre d’itérations s’appelle période de retour.
rem Il se calcule comme suit pour une image de dimension 2n x 2m pixels :
rem On détermine le plus petit entier p tel que 2n-1 divise 2^p-1 ;
rem On détermine le plus petit entier k tel que 2m-1 divise 2^k-1 ;
rem On calcule le ppcm de p et k.
rem Le résultat obtenu est la période cherchée.
rem ============================================================================
rem Dans le cas où la taille de l’image est 2^p x 2^k, la période est ppcm(p,k).
rem Nous allons travailler avec des images carrées de dimensions une puissance
rem de deux, par exemple 256 x 256 ou 512 x 512.
rem De cette façon le calcul de la période sera simplifié et en plus le retour
rem à l’image d’origine sera rapide.
rem ============================================================================
rem Important :
rem Notez bien que les 4 images qui apparaissent après une étape de transformation
rem ne sont pas identiques comme elles le seraient avec l’appareil photographique
rem de la société Photomaton.
rem Les quatre images sont bien différentes au sens des pixels qu’elles contiennent.
rem Elles proviennent d’une redistribution des pixels de l’image initiale sans
rem aucune duplication ni perte.
rem ============================================================================
rem *** Transformation du boulanger
rem La transformation du boulanger est une transformation basée sur l’idée d’un
rem mélange analogue au pétrissage par un boulanger qui étire une pâte jusqu’à
rem ce qu’elle soit d’épaisseur moitié, puis la coupe en deux et superpose les
rem deux moitiés pour lui redonner sa dimension initiale, et ainsi de suite.
rem ============================================================================
rem La transformation du boulanger se définit sur [0,1]² de la façon suivante:
rem      ________________________________________________
rem     |                                                |
rem     |  S(x,y) = (2x  , y/2)        si 0 <= x <= 1/2  |
rem     |  S(x,y) = (2x-1, (y+1)/2)    sinon             |
rem     |________________________________________________|
rem
rem Une version alternative consiste à replier plutôt que couper et resuperposer
rem les deux demi-pâtons. C’est la transformation dite du fer à cheval de Smale.
rem ============================================================================
rem &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
rem ============================================================================

dim f$,fn$,ext$,n,p,t
dim largeur,hauteur : ' dimensions de l'image
dim exit
label clic
application_title "Transformations bijectives d’images"
dir_change "C:\Users\MICROTEK\Desktop\Transformations_Images" : ' Adapter le chemin
f$ = dir_current$ +"\joconde"
fn$ = f$ : ext$ = ".bmp"
Dimensions(fn$+ext$) : ' récuperer les dimensions (largeur et hauteur) de l'image
Menu()
create_hide
picture 10 : picture 20 : picture 30
alpha 11 : top 11,10 : left 11,largeur/2     : font_color 11,255,255,0
alpha 21 : top 21,10 : left 21,2*largeur     : font_color 21,255,255,0
alpha 31 : top 31,10 : left 31,3*largeur+150 : font_color 31,255,255,0  
end
rem ============================================================================
SUB Menu()
    dim_local i
    main_menu 1
        sub_menu 2 : parent 2,1 : caption 2,"Transformations"
        sub_menu 3 : parent 3,2 : caption 3,"Transformation du photomaton"
        sub_menu 4 : parent 4,2 : caption 4,"Transformation du boulanger"
        sub_menu 5 : parent 5,2 : caption 5,"-"
        sub_menu 6 : parent 6,2 : caption 6,"Quitter"
        sub_menu 7 : parent 7,1 : caption 7,"Aide"
        sub_menu 8 : parent 8,7 : caption 8,"Infos"
        sub_menu 9 : parent 9,7 : caption 9,"A-Propos"
    for i = 3 to 9 : on_click i,clic : next i        
END_SUB
rem ============================================================================
Clic:
    select number_click
        case 3 : GUI_Photomaton()
        case 4 : GUI_Boulanger()
        case 6 : Quitter()
        case 8 : Infos()
        case 9 : Propos()
    end_select
return
rem ============================================================================
SUB GUI_Photomaton()
    width 0,2*largeur+100 : height 0,hauteur +200 : color 0,100,50,20  
    width 10,largeur : height 10,hauteur : top 10,50 : left 10,50
    width 20,largeur : height 20,hauteur : top 20,50 : left 20,50+width(10)+10
    show 10 : show 20
    p = Periode(largeur,hauteur)
    Traitement_Photomaton(p)
END_SUB
rem ============================================================================
' Traitement
SUB Traitement_Photomaton(p)
    dim_local n,im$
    inactive 2 : inactive 7
    exit = 0
    im$ = f$ + "_Photomathon"
    for n = 1 to p
        caption 0,"Transformation du Photomaton. Traitement en cours ..." + str$(n) + " / " + str$(p) + " ... <ESC> pour arrêter"
        2d_target_is 10 : file_load 10,fn$ + ext$
        2d_target_is 20 : cls
        Photomaton()
        if exit = 1 then active 2 : active 7 : exit_sub
        file_save 20,im$ + "_" + str$(n) + ext$
        fn$ = im$ + "_" + str$(n)
    next n
    caption 0,"Traitement terminé. On retrouve bien l'image de départ"
    active 2 : active 7
END_SUB
rem ============================================================================
SUB Photomaton()
    dim_local x,y,nx,ny,r,g,b
    for x = 0 to largeur-1
        for y = 0 to hauteur-1
            r = color_pixel_red(10,x,y)
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)
            if (even(x) = 1) and (even(y) = 1) : ' x et y sont pairs
               nx = int(x/2) : ny = int(y/2)
            else
               if even(x) = 1                  : ' x est pair et y impair
                  nx = int(x/2) : ny = int(hauteur/2) + int(y/2)
               else
                  if even(y) = 1               : ' x est impair et y pair
                     nx = int(largeur/2) + int(x/2) : ny = int(y/2)
                  else                         : ' x et y sont impairs
                     nx = int(largeur/2) + int(x/2) : ny = int(hauteur/2) + int(y/2)
                  end_if
               end_if
            end_if
            2d_pen_color r,g,b : 2d_point nx,ny
            if scancode = 27 then exit = 1 : exit_sub
        next y
        display
    next x

END_SUB
rem ============================================================================
SUB GUI_Boulanger()
    width 0,4*Largeur+200 : height 0,Hauteur + 200 : color 0,100,50,20  
    width 10,Largeur : height 10,Hauteur : top 10,30 : left 10,50
    width 20,2*Largeur : height 20,Hauteur : top 20,30 : left 20,50+width(10)+10
    width 30,largeur : height 30,hauteur : top 30,30 : left 30,3*largeur + 70    
    show_all
    p = 2 * Periode(Largeur,Hauteur) + 1
    Traitement_Boulanger(p)
END_SUB
rem ============================================================================
SUB Traitement_Boulanger(p)
    2d_target_is 10 : file_load 10,fn$ + ext$ : caption 11,"Etape 0"
    2d_target_is 20  
    All_Boulanger(p)
END_SUB
rem ============================================================================
' Visualiser l'ensemble des transformations du boulanger
' avant le retour à l'image initiale
SUB All_Boulanger(p)
    dim_local n,im$
    2d_target_is 10
    inactive 2 : inactive 7
    im$ = f$ + "_Boulanger"
    exit = 0
    for n = 1 to p
        caption 0,"Transformation du boulanger. Traitement en cours ..." + str$(n) + " / " + str$(p) + " ... <ESC> pour arrêter"        
        2d_target_is 10 : file_load 10,fn$ + ext$
        2d_target_is 30 : cls
        2d_target_is 20 : cls        
        Boulanger_Etirer(n)  : if exit = 1 then active 2 : active 7 :  exit_sub
        Boulanger_Replier(n) : if exit = 1 then active 2 : active 7 : exit_sub      
        file_save 30,im$ + "_" + str$(n) + ext$        
        fn$ = im$ + "_" + str$(n)
        caption 11,"Etape " + str$(n)
    next n  
    2d_target_is 10 : file_load 10,f$ + ext$
    2d_target_is 20 : cls
    caption 0,"Traitement terminé. On retrouve bien l'image de départ"
    caption 11,"Image de départ"
    caption 21,""
    caption 31,"Etape " + str$(p)
    active 2 : active 7
END_SUB
rem ============================================================================
SUB Boulanger_Etirer(n)
    dim_local x,y,x1,y1,r,g,b,nx,ny
    caption 21,"Etirement " + str$(n)    
    for x = 0 to largeur-1
        for y = 0 to hauteur-1
            r = color_pixel_red(10,x,y)
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)            
            if even(y) = 1
               nx = 2*x : ny = int(y/2)
            else
               nx = 2*x+1 : ny = int(y/2)
            end_if                                            
            2d_pen_color r,g,b : 2d_point nx,ny
            if scancode = 27 then exit = 1 : exit_sub
        next y
        display
    next x
END_SUB
rem ============================================================================
SUB Boulanger_Replier(n)
    dim_local x,y,x1,y1,r,g,b,nx,ny,h,l
    caption 31,"Repliement " + str$(n)
    2d_target_is 30 : cls
    h = hauteur/2
    l = 2*largeur
    for x = 0 to l-1
        for y = 0 to h-1
            r = color_pixel_red(20,x,y)
            g = color_pixel_green(20,x,y)
            b = color_pixel_blue(20,x,y)            
            if x < int(l/2)      
               nx = x : ny = y
            else
               nx = l-x-1 : ny = 2*h-y-1
            end_if                                                        
            2d_pen_color r,g,b : 2d_point nx,ny
            if scancode = 27 then exit = 1 : exit_sub
        next y
        display
    next x
    caption 31,""
END_SUB
rem ============================================================================
' Récuperer les dimensions (largeur et hauteur) de l'image image$
SUB Dimensions(image$)
    filebin_open_read 999,image$
    filebin_position 999,18
    largeur = filebin_read(999) + 256 * filebin_read(999)
    filebin_position 999,22
    hauteur = filebin_read(999) + 256 * filebin_read(999)
    filebin_close 999
END_SUB
rem ============================================================================
' Fonction Plus Grand Commun Diviseur de deux entiers a et b
' Cette fonction sera utilisée dans le calcul du nombre d'étapes pour réaliser
' la transformation.
FNC PGCD(a,b)
    dim_local r
    a = abs(a) : b = abs(b)
    if a > b then r = b : b = a : a = r
    repeat
        r = mod(a,b) : a = b : b = r
    until r = 0
    result a
END_FNC
rem ============================================================================
' Fonction retournant la période (nombre de transformations)
FNC Periode(p1,p2)
    dim_local q1,q2
    q1 = 0
    repeat
        q1 = q1 + 1
    until mod(power(2,q1)-1,p1-1) = 0
    q2 = 0
    repeat
        q2 = q2 + 1
    until mod(power(2,q2)-1,p2-1) = 0
    result int(q1*q2 / pgcd(q1,q2))
END_FNC
rem ============================================================================
SUB Quitter()
    if message_confirmation_yes_no("Vous voulez vraiment quitter ?") = 1
       terminate
    end_if
END_SUB
rem ============================================================================
SUB Infos()
    dim_local t$
    t$ = "Une transformation bijective d'une image déplace les points d'une image d'un endroit à un autre sans en ajouter ni en enlever aucun." + chr$(13)
    t$ = t$ + "Une propriété remarquable de ces transformations bijectives est qu'elles reviennent toujours au point de départ après un nombre d'applications plus ou moins important." + chr$(13) + chr$(13)
    t$ = t$ + "Ce programme traite les deux plus importantes transformations les plus connues à savoir la transformation du photomaton et la tranformation du boulanger."+chr$(13)
    t$ = t$ + "La transformation du photomaton consiste à réaliser l’opération suivante sur les numéros des lignes : " + chr$(13)
    t$ = t$ + "On prend les lignes de rang pair qu’on fait suivre de celles de numéro impair." + chr$(13)
    t$ = t$ + "De même, pour les numéros des colonnes — cela explique l’apparition de quatre versions en plus petit de l’image initiale." + chr$(13) + chr$(13)
    t$ = t$ + "La transformation du boulanger s’appelle ainsi car elle s’apparente au travail du boulanger qui réalise une pâte feuilletée."+chr$(13)
    t$ = t$ + "L’image est tout d’abord étirée puis coupée en deux dans le sens vertical pour placer la partie de droite sous la partie gauche en la faisant tourner de 180°"+chr$(13)
    t$ = t$ + "La transformation du boulanger est donc la succession d’un étirement et d’un repliement." + chr$(13)
    t$ = t$ + "Partant d’un tableau n x n on obtinet encore un tableau n x n."+chr$(13)
    t$ = t$ + "On part d’un tableau n × n, avec n pair dont chaque élément représente un pixel."+chr$(13)
    t$ = t$ + "On va appliquer deux transformations élémentaires à chaque fois :"+chr$(13)
    t$ = t$ + " 1 / Étirer." +chr$(13)
    t$ = t$ + "Le principe est le suivant :"+chr$(13)
    t$ = t$ + "les deux premières lignes (chacune de longueur n) produisent une seule ligne de longueur 2n en mixant les valeurs de chaque ligne en alternant un élément du haut, un élément du bas."+chr$(13)
    t$ = t$ + " 2 / Replier."+chr$(13)
    t$ = t$ + "Le principe est le suivant : "+chr$(13)
    t$ = t$ + "la partie droite d’un tableau étiré est retournée (en la faisant tourner de 180°), puis ajoutée sous la partie gauche."+chr$(13)
    t$ = t$ + "Pour que cette tranformation soit bien définie, il est nécessaire que les dimensions de l’image soient paires."+chr$(13)
    t$ = t$ + "Partant d’un tableau n/2 × 2n on obtient un tableau n × n."
    message t$
END_SUB
rem ============================================================================
SUB Propos()
    dim_local t$
    t$ = "Transformations bijectives d'images : transformations du photomaton et du boulanger" + chr$(13)
    t$ = t$ + "Auteur : Papydall" + chr$(13)
    t$ = t$ + "Date   : 30 / 09 / 2022" + chr$(13)
    t$ = t$ + "Dernière modif : 01 / 10 / 2022"
    message t$
END_SUB
rem ============================================================================
rem &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
rem ============================================================================

rem ============================================================================
rem                 Traitement d’images
rem                  Couleur ===> Gris
rem ============================================================================
dim Largeur, Hauteur
dim image$

image$ = "D:\Langages\Panoramic\Versions\V09.29i11\Image\1.bmp" : ' à adapter
Dimensions(image$)
width 0, 2*Largeur + 100
height 0, Hauteur + 100

picture 10 : width 10,Largeur : height 10,Hauteur
top 10,40 : left 10,50 : 2d_target_is 10 : file_load 10,image$
picture 20 : width 20,Largeur : height 20,Hauteur
top 20,40 : left 20,50+Largeur + 10

Gris()

end
rem ============================================================================
' Obtention d'une image en gris à partir d'une image initiale en couleur
SUB Gris()
    dim_local x,y,nx,ny,r,g,b,c
    2d_target_is 20
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)
            c = (r+g+b)/3
            2d_pen_color c,c,c
            2d_point x,y
        next x
        display
    next y
    
END_SUB
rem ============================================================================
' Récuperer les dimensions (Largeur_Image et Hauteur_Image) de l'image image$
SUB Dimensions(image$)
    filebin_open_read 999,image$
    filebin_position 999,18
    Largeur = filebin_read(999) + 256 * filebin_read(999)
    filebin_position 999,22
    Hauteur = filebin_read(999) + 256 * filebin_read(999)
    filebin_close 999

END_SUB
rem ============================================================================

rem ============================================================================
rem                 Traitement d’images
rem                    Par Papydall
rem ============================================================================
dim Largeur, Hauteur
dim image$
dim i
label clic
image$ = "c:\users\microtek\desktop\Traitement_Images\lena.bmp" : ' à adapter
Dimensions(image$)
width 0, 2*Largeur + 400
if Hauteur < 500
   height 0, 600
else
   height 0,Hauteur + 100
end_if

picture 10 : width 10,Largeur : height 10,Hauteur
top 10,40 : left 10,365 : 2d_target_is 10 : file_load 10,image$
picture 20 : width 20,Largeur : height 20,Hauteur
top 20,40 : left 20,350+Largeur + 20
alpha 23 : top 23,10 : left 23,300+largeur/2 : caption 23,"Image originale"
font_bold 23 : font_color 23,0,0,255 : font_size 23,12
alpha 24 : top 24,10 : left 24,280+3*largeur/2 : caption 24,"Image traitée"
font_bold 24 : font_color 24,0,0,255 : font_size 24,12 : hide 24
container_option 25 : top 25,20 : left 25,10 : font_bold 25 : font_color 25,255,0,0
width 25,350 : height 25,400 : font_size 25,14 : caption 25,"Faites votre choix"
for i = 30 to 41
    option i : parent i,25
    top i,50+(i-30)*30 : left i,20 : width i,320 : font_bold i
    font_color i,0,0,255 :  font_size i,10
     on_click i,clic
next i
caption 30," Eclaircir l'image "
caption 31," Eliminer les couleurs,excepté le rouge"
caption 32," Eliminer les couleurs,excepté le vert "
caption 33," Eliminer les couleurs,excepté le bleu "
caption 34," Créer le négatif de l'image "
caption 35," Convertir l'image couleur en noir et blanc "
caption 36," Convertir l'image couleur en nuances de sépia "
caption 37," Modifier le contrast "
caption 38," Symétrie axiale d'axe horizontal "
caption 39," Symétrie axiale d'axe vertical "
caption 40," Afficher l'image dans une ellipse ou un cercle "
caption 41," QUITTER LE PROGRAMME "

font_bold 0 : font_color 0,255,0,0 : font_size 0,10
print_locate 20,top(25)+height(25)+20
print "Dimensions de l'image originale : " + str$(largeur) + " x " + str$(hauteur) + " pixels"

end
rem ============================================================================
Clic:
    for i = 30 to 40 : inactive i : next i
    show 24
    select number_click
        case 30 : Lumineuse()
        case 31 : Rouge()
        case 32 : Vert()
        case 33 : Bleu()
        case 34 : Negatif()
        case 35 : Gris()
        case 36 : Sepia()
        case 37 : Modifier_Contrast()
        case 38 : Symetrie_Horizontale()
        case 39 : Symetrie_Verticale()
        case 40 : Ellipse()
        case 41 : terminate
    end_select
    for i = 30 to 40 : active i : next i
return
rem ============================================================================
' Rendre l'image plus lumineuse
SUB Lumineuse()
    dim_local x,y,r,g,b
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Rendre l'image plus lumineuse"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)   : r = min(r+30,255)
            g = color_pixel_green(10,x,y) : g = min(g+30,255)
            b = color_pixel_blue(10,x,y)  : b = min(b+30,255)
            2d_pen_color r,g,b : 2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Eliminer toutes les couleurs, excepté le rouge
SUB Rouge()
    dim_local x,y,r,g,b
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Eliminer toutes les couleurs, excepté le rouge"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y) : g = 0 : b = 0  
            2d_pen_color r,g,b : 2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Eliminer toutes les couleurs, excepté le vert
SUB Vert()
    dim_local x,y,r,g,b
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Eliminer toutes les couleurs, excepté le vert"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            g = color_pixel_red(10,x,y) : r = 0 : b = 0  
            2d_pen_color r,g,b : 2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Eliminer toutes les couleurs, excepté le bleu
SUB Bleu()
    dim_local x,y,r,g,b
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Eliminer totes les couleurs, excepté le bleu"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            b = color_pixel_red(10,x,y) : r = 0 : g = 0  
            2d_pen_color r,g,b : 2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Créer le négatif de l'image
SUB Negatif()
    dim_local x,y,r,g,b
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Créer le négatif de l'image"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)   : r = 255-r
            g = color_pixel_green(10,x,y) : g = 255-g
            b = color_pixel_blue(10,x,y)  : b = 255-b
            2d_pen_color r,g,b : 2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Convertir l'image couleur en noir et blanc
SUB Gris()
    dim_local x,y,r,g,b,c
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Convertir l'image couleur en noir et blanc"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)  
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)
            ' formule standard donnant le niveau de gris en fonction
            ' des 3 composantes RGB  
            c = 0.299*r + 0.587*g + 0.114*b
            2d_pen_color c,c,c : 2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Convertir l'image couleur en nuances de sépia
SUB Sepia()
    dim_local x,y,r,g,b,r1,g1,b1
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Convertir l'image couleur en nuances de sépia"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)  
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)
          
            r1 = 0.393*r + 0.769*g + 0.189*b : if r1 > 255 then r1 = 255
            g1 = 0.349*r + 0.686*g + 0.168*b : if g1 > 255 then g1 = 255
            b1 = 0.272*r + 0.534*g + 0.131*b : if b1 > 255 then b1 = 255
            2d_pen_color r1,g1,b1 : 2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Modifier le contrast de l'image
SUB Modifier_Contrast()
    dim_local x,y,r,g,b
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Modifier le contrast de l'image"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)  
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)
            if r < 30 then r = 0
            if g < 30 then g = 0
            if b < 30 then b = 0
            if (r >= 30) and (r < 225) then r = int(255/195*(r-30)+0.5)
            if (g >= 30) and (g < 225) then g = int(255/195*(g-30)+0.5)
            if (b >= 30) and (b < 225) then b = int(255/195*(b-30)+0.5)            
            2d_pen_color r,g,b : 2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Produire une symétrie axiale d'axe horizontal
SUB Symetrie_Horizontale()
    dim_local x,y,r,g,b
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Créer une symétrie horizontale"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)  
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)  
            2d_pen_color r,g,b : 2d_point x,hauteur-y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Produire une symétrie axiale d'axe vertical
SUB Symetrie_Verticale()
    dim_local x,y,r,g,b
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Créer une symétrie verticale"
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)  
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)  
            2d_pen_color r,g,b : 2d_point largeur-x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Afficher l'image dans un cercle si l'image est carrée, dans une ellipse si
' l'image est rectangulaire
SUB Ellipse()
    dim_local x,y,r,g,b,r1,r2,xc,yc ,p
    2d_target_is 20 :cls
    caption 0,"Traitement en cours ... Affichage dans une ellipse"
    r1 = largeur/2 : r2 = hauteur/2
    xc = r1 : yc = r2
    r1 = r1-1 : r2 = r2-1
    for y = 0 to hauteur-1
        for x = 0 to largeur-1
            r = color_pixel_red(10,x,y)  
            g = color_pixel_green(10,x,y)
            b = color_pixel_blue(10,x,y)
            ' Determiner si le point (x,y) est à l'interieur de l'ellipse
            p = (power((x-xc),2) / power(r1,2)) + (power((y-yc),2) / power(r2,2))
            if p < 1                    : ' Le point (x,y) est à l'intérieur
               2d_pen_color r,g,b       : ' on le trace en couleur RGB
            else                        : ' Le point (x,y) est à l'extérieur
               2d_pen_color 255,255,255 : ' on le trace en blanc
            end_if
            2d_point x,y
        next x
        display
    next y
    caption 0,"Traitement terminé"
END_SUB
rem ============================================================================
' Recupérer les dimensions (Largeur_Image et Hauteur_Image) de l'image image$
SUB Dimensions(image$)
    filebin_open_read 999,image$
    filebin_position 999,18
    Largeur = filebin_read(999) + 256 * filebin_read(999)
    filebin_position 999,22
    Hauteur = filebin_read(999) + 256 * filebin_read(999)
    filebin_close 999

END_SUB
rem ============================================================================

' ****************************************
' *                                      *
' *        Coloriser les images          *
' *                                      *
' *  Plusieurs filtres sont disponibles  *
' *                                      *
' *                                      *
' ****************************************
'
'
execute "https://palette.fm/"
end