Filter meister et Pixia

[Eric]

Génial !
Y' a plus qu' a écrire les filtres pour faire des 8bf !

1) Telecharger et installer filter meister
http://www.filtermeister.com

2) ouvrir une tiote image avec Pixia
3) filtre Ebisawa et choisir AfhFM04Beta7.8bf ( dans le repertoire d' installation de filter meister )
4) cliquez sur appliquer

5) vous pouvez maintenant concevoir vos filtres

Capture d' écran



@+ Eric

[gg]

oui, c'est cool... on va finir par être obligé de se mettre au langage informatique
il ne te reste plus qu'à faire un énorme tuto pour nous expliquer comment ça marche

[Eric]

J' ai fait ce post rapidement , comme un gamin devant un sapin de noel , émerveillé par les paquets qu' il n' a pas encore ouvert ...

j' ai simplement chargé les quelques codes fournis avec le soft , et cela fonctionne , très très rapidement . Et avec Pixia de surcroit

Un flou très large , lent avec Gonta , devient très rapide avec ce langage .

Divers algorithmes sont fournis en exemples ( auto contraste , détection des bords .... ) de quoi faire .. et passer un sacré temps avant d' envisager un quelconque tuto

Une chose semble sure : Pixia , Ebisawa , ne permettent pas aux filtre 8bf la gestion et modification de la transparence ( le canal alpha chez toshop ,gimp ...)

une autre concerne la prévisualisation : il faut y aller tres doucement lorsque l' on veut la changer autrement crash de Pixia

Dernier point , pour faire un 8bf ( compilé et transmissible ) , il faut acheter la licence ( 18 euros )
Sans la licence , c' est un fichier que tu peux sauver et que tu doit compiler avant l' exécution .

C' est quand même prometteur

Pour le reste , c' est une question perso cet investissement , pas forcement besoin de se mettre au langage informatique pour ses créations

Pis des 8bf , y' en a déjà des tonnes .

je vais quand même essayer d' en faire un rien que pour voir
@+ Eric

[gg]

je rigole...
je m'étais déjà interessé à ce truc, il y a un paquet d'années, mais j'avais vite abandonné par incapacité à programmer et par le fait qu'il était shareware.
en plus, la gestion de la couche alpha de pixia est vraiment particulière quand il s'agit de filtre, soit à cause d'ebisawa soit à cause de pixia directement...

A la limite, étant donnée la quantité de 8bf déjà existante, je pense qu'il vaut mieux pour quelqu'un comme moi de d'abord apprendre à utiliser Gonta (ce que j'ai peu de chance de faire... )

mais si tu nous sors des fichiers à compiler pour pouvoir utiliser des filtres sortis de ton esprit fertile avec pixia, je suis preneur.

[Eric]

Pour l' instant , j' essaye de modifier les codes fournis avec le soft .
Je galère pas mal , mais si j' avais commencé par lire le manuel de référence


Un premier truc modifié pour tester les modes de fusion possibles avec ce soft : tu ouvres une nouvelle image , colles un tiot truc dans la moitié droite et un autre dans la gauche .
La moitié droite ce verra modifiée.
Le code ( il n' est pas utile d' oter les commentaires )

Code: Tout sélectionner

%ffp

//Test mode de fusion : mélange les deux moitiés
// droite gauche de l' image dans la moitié droite
// en fonction du mode selectionné


ctl(0): "Mélange",range=(0,255),val=128
ctl(1): combobox(vscroll),action=preview, color=#FFFFFF,fontcolor=#0000ff,
   size=(50,200), text="Normal\nDissolve\nTreshold\nTreshold 2\nMultiply\nScreen\nOverlay\nSoft Light\nHard Light\nDodge\nBurn\nDarken\nLighten\nExclusion\nDifference\nNegDif 1\nNegDif 2\nSubtract\nAdd\nExpose",
   val=0


ForEveryTile:
{
   for (y=y_start; y<y_end; y++){
      updateProgress(y,y_end);
   for (x=x_start; x<x_end; x++){
   for (z=0; z<Z; z++){
      if( x>=X/2 )   //moitié droite de l' image ?
      pset(x, y, z, blend (src(x,y,z), src(x-(X/2),y,z) , z, ctl(1),ctl(0)) );

   }}}

   return true;
}




Ca ne remplace pas un calque , car la fusion est réalisée une fois pour toute , on peut la modifier ultérieurement .
Ca peut rendre service pour des effets de textes ou textures ...

En fait , ça va pas servir à grand chose

Dis , GG , pour Gonta , si tu t' y mettais ? En cas de soucis , tu m' envois un mail

@+ Eric

[Eric]

Ainsi le mode de fusion " calque " de pixia semble etre Hard light , lumiere dure pour gimp . Toshop ? probablement le meme .

[gg]

je m'y suis mis à gonta grâce à tous les tutos ... régulièrement depuis plusieurs années... mais j'ai à chaque fois abandonné

en fait, j'ai un petit souci de démarrage, il y a quelques notions de base qui m'échappent... et surtout, il faudrait que je trouve une idée de filtre... je n'aime pas travailler sur de la pure théorie, je préfère nettement avoir un truc qui me tient à coeur et qui me pousse... (et qu'on ne me parle pas de cette histoire de ligne pointillée qui semble bien difficile pour un débutant)

mais t'inquiète, il est fort probable qu'à un moment ou l'autre ça recommence à me titiller...

[Eric]

Essais que je trouve prometteur:
Le script gonta pour les contours et le script gonta pour la réduction des couleurs a la vitesse 8bf
Aidé par les tuto pour un flou ( utilisé pour la detection des bords ) pouvant etre tres large , et le nombre de mode de superposition des 2 calques virtuels ( le trait et les couleurs )

Le code:

Code: Tout sélectionner

%ffp
//
// 12/04/99 Fixed tile buffer padding bug.
//
Category:"FM Tutorial"
Title:   "Box Blur 2"
Author:  "Ilyich the Toad; Alex Hunter"
Dialog: color=White
ctl(0):"Rayon flou",val=3,range=(3,scaleFactor*Y/2),pos= (320,40)
//ctl(1):"H Blur (pixels)",val=10,range=(0,scaleFactor*X/2)
//
//ctl(2):"Multiplicateur",val=256,range=(0,512)
ctl(3):"Pre Contraste",Range=(-100,100),val=0, pos=(320,10)
ctl(4):"Centre Contraste",Range=(0,255),val=128,pos=(320,20)
ctl(5): "Melange",range=(0,255),val=128,pos=(270,122)
//
ctl(7):"Reduction",Range=(2,12),val=8,pos=(320,65)
ctl(8):"Luminosité",Range=(-128,128),val=0,pos=(320,90)

ctl(9):"Saturation",Range=(-128,128),val=0,pos=(320,100)
//ctl(1):"Couleur",Range=(-128,128),val=0
ctl(6): combobox(vscroll),action=preview, color=#FFFFFF,fontcolor=#0000ff,
   size=(50,200), text="Normal\nDissolve\nTreshold\nTreshold 2\nMultiply\nScreen\nOverlay\nSoft Light\nHard Light\nDodge\nBurn\nDarken\nLighten\nExclusion\nDifference\nNegDif 1\nNegDif 2\nSubtract\nAdd\nExpose",
   val=0,pos=(410,120)

//ctl(20):CHECKBOX, "Inverser le mélange", pos=(350, 140)

//ctl(11):statictext,"Detection de bords",pos=(320,30),fontcolor=red,size=(150,*)
ctl(12):statictext,"Reduction des couleurs",pos=(320,55),fontcolor=red,size=(150,*)
//ctl(13):statictext,"Post traitement",pos=(320,80),fontcolor=red,size=(150,*)
ctl(14):statictext,"Melange et mode de fusion",pos=(320,110),fontcolor=red,size=(150,*)
ctl(10):groupbox(group), "Pre traitement:", pos=(250,0),size=(220, 32), fontcolor=navyblue, color=white
ctl(11):groupbox(group), "Detection des bords", pos=(250,32),size=(220, 20), fontcolor=navyblue, color=white
ctl(13):groupbox(group), "Post traitement", pos=(250,80),size=(220, 32), fontcolor=navyblue, color=white




//*************************
//Pre contraste et conversion noir blanc
//et ranger sur un seul canal t(0)
//*************************

ForEveryTile:{
   int r,g,b,h,s,l,pla;
   float tot;
   // Compute rounded, scaled blur radius.
int vBlurRadius = (2*ctl(0)+scaleFactor)/(2*scaleFactor);  //Vertical blur radius
int hBlurRadius = (2*ctl(0)+scaleFactor)/(2*scaleFactor);  //Horizontal blur radius

int vWeight = vBlurRadius*2 + 1;
  int hWeight = hBlurRadius*2 + 1;

  int total = (x_end-x_start) + (y_end-y_start);
  int x, y, z;
  int i;
  pla=256/ctl(7);


      for (y= y_start; y < y_end; y++){
         if(updateProgress(y,y_end)) abort();
      for (x = x_start; x < x_end; x++){
            
         r = src(x,y,0);
         g = src(x,y,1);
         b = src(x,y,2);
         
         r=(r+g+b)/3;// conversion noir et blanc
         
         r=r+((r-ctl(4))*((float)ctl(3)/100));//pre contraste
         
         
         // noir et blanc : 8 bits suffisent donc un seul canal
         tset( x, y, 0, r );//ranger r cela dans le calque t(0)
         
         

      }}

   


// If unscaled radius was nonzero, force scaled radius
// to be nonzero also, to show some effect in preview.
if (vBlurRadius == 0 && ctl(0) > 0) vBlurRadius = 1;
//if (hBlurRadius == 0 && ctl(1) > 0) hBlurRadius = 1;


// *****************************
// Flouter l' image et ranger sur un seul canal t(2)
// contenant l' image en noir et blanc )
//******************************

  for (x=x_start-hBlurRadius; x < x_end+hBlurRadius; x++) {
   int sum = 0;
    if (updateProgress(x-x_start, total)) break;
    // vertical blur...
   
       
        for (i=-vBlurRadius; i <= vBlurRadius; i++) {
            sum += tget(x, y_start-1+i, 0);
        }
        for (y=y_start; y < y_end; y++) {
            sum += tget(x, y+vBlurRadius,0) - tget(x, y-vBlurRadius-1, 0);
            tset(x,y,1,sum/vWeight);
        }
    }
 

  for (y=y_start; y < y_end; y++) {
   int sum = 0;
    if (updateProgress(y-y_start + (x_end-x_start), total)) break;
    // horizontal blur...
   
       
        for (i=-hBlurRadius; i <= hBlurRadius; i++) {
            sum += tget(x_start-1+i, y, 1);
        }
        for (x=x_start; x < x_end; x++) {
            sum += tget(x+hBlurRadius, y, 1) - tget(x-hBlurRadius-1, y, 1);
            tset(x,y,2,sum/hWeight);//ranger dans le canal t(2)
        }
    }
 
//*****************************************
//DETECTION DES BORDS
// division du pixel par le pixel flouté
//****************************************
   for (y= y_start; y < y_end; y++){
         if(updateProgress(y,y_end)) abort();
      for (x = x_start; x < x_end; x++){
         
         int sum=0;
         sum= (tget(x, y, 0)*256)/tget(x,y,2)+0;
//*******************************
//Reduction des couleurs de l' image d' origine
//*******************************            
         r = src(x,y,0);
         g = src(x,y,1);
         b = src(x,y,2);

         h = rgb2hsl (r,g,b,0);
         s = rgb2hsl (r,g,b,1);
         l = rgb2hsl (r,g,b,2);
         
         
         l=(l/pla)*pla+pla;
//********************************
// ajustement lumiere et saturation
//********************************
         l = l + ctl(8);
         s = s + ctl(9);
         
//******************************************
// Melange final : calque noir et blanc calque couleur
//******************************************


         pset(x, y, 0, blend (hsl2rgb (h,s,l,0), sum , z, ctl(6),ctl(5)) );
         pset(x, y, 1, blend (hsl2rgb (h,s,l,1), sum , z, ctl(6),ctl(5)) );
         pset(x, y, 2, blend (hsl2rgb (h,s,l,2), sum , z, ctl(6),ctl(5)) );
            
         }
   }




updateProgress(0,0);

return true;  //Done!
}


Encore un peu de travail dans le code et la présentation.


Un tiot rendu ( le filtre avec 2 réglages différents sur deux calques )

[gg]

c'est joli comme résultat

[Eric]

J' y suis pour rien , c' est le modele !

je vais acheter la licence , c' est pas une ruine, pour compiler en 8bf