[Résolu] J'aimerais pouvoir utiliser le filtre de redimensionnement Jinc

C'est là que l'on voit à quel point les écrans CRT dupaient notre cerveau avec leur scanlines. On avait l'impression d'avoir une résolution 2 fois plus élevée

 

Et hop : WeTransfer

Fichier original redimensionné dans After Effects sans aucun plug-in ou effet

 

Merci beaucoup Alcoriza !

J'avoue, c'est vraiment pas mal (bon, niveau compression, tu n'y es pas allé de main morte ). L'image garde un bon relief

Je vais voir pour tester ce truc.

 

C'est à dire ? Tu vois des soucis de compression même en zoomant à 500% ? Si c'est le cas, ton décodeur a un souci !

 

Non, mais je veux dire que la vidéo est assez compressée, mais sinon, le rendu est très bon

Edit : En fait, ce n'est pas la compression je pense, je m'excuse, mais le passage à un espace de couleur réduit (YV12). C'est pareil chez moi C'est parce que j'ai l'habitude de travailler en RGB24 ou YV24, donc ça m'a choqué. Mais c'est normal

 

J'ai réfléchis et je pense que j'ai compris une chose. Le souvenir que j'ai de ces vieux jeux est aussi directement liée aux technologies de l'époque, donc les écrans CRT. Les fameuses scanlines par exemple trompaient pas mal le cerveau et donnaient l'illusion d'une plus grande définition et d'un meilleur relief. C'est assez évident et impressionnant quand on y pense, vu la faible résolution des jeux de l'époque.

J'ai donc tenté avec mes derniers scripts d'essayer de retrouver ce fameux relief, mais sans les scanlines.

J'ai d'ailleurs mis un aperçu de ce que ça donne avec les scanlines dans la nouvelle vidéo que je suis en train d'uploader, même si j'aurais préféré juste agrandir l'image 2X au lieu de 4X, car ça se voyait mieux, mais malheureusement, après passage de l'espace de couleur RGB24 à YV12, j'ai perdu énormément en couleur.

Je mets donc une image avec scanlines et agrandit 2X par rapport à l'original (c'est donc pratiquement équivalent à la même résolution qu'à l'origine) :



Comme vous pouvez le voir, ça donne un peu plus de relief à l'image et une sensation de plus grosse définition, même si ce n'est pas aussi évident qu'avec un écran CRT.

Dans cette vidéo on voit mieux ce que ça donne :



Bref, en partant de ce raisonnement, je me suis plus focalisé sur le relief et l'illusion de définition, mais sans les scanlines évidemment

Quelqu'un m'a aussi donné une bonne astuce pour voir ce que donne l'effet des différents filtres sur l'image.

Avec ce filtre, on peut afficher une grille aux dimensions de la vidéo et voir ce qu'il en est après applications de tout un tas de filtres :

Grid - Avisynth wiki

Suffit juste d'ajouter des lignes de ce genre dans le script :

Grid()
SZ=5
BlankClip(Width=256,height=224,color=$FFFFFF)
grid(Bold=SZ,vbold=1)

Je m'en suis d'ailleurs servi pour le dernier script de ma vidéo. Après bien sûr, il faut l'enlever du script, sinon on ne voit que cette grille moche :



Mais on sent qu'il y a de vrais passionnés sur le forum Doom9 et de sacrés perfectionnistes

 

Pour créer l'illusion des scanlines (ce qui est impossible à mon avis : suis persuadé que la rémanence des phosphores de CRT donne un aspect inimitable à l'image), c'est qu'il ne suffit pas de faire une ligne noire sur deux. Moi je ferai un truc comme ça :

 

Oui, tu as tout à fait raison C'est pour ça que j'ai mis l'autre vidéo avec les écrans CRT pour qu"on se rende un peu mieux compte, car c'est clair qu'on est loin du vrai effet d'un écran CRT. C'était juste pour illustrer en fait

Bon, j'ai fini d'uploader ma vidéo. Je vais me coucher Bonne nuit Alcoriza et tout ceux qui passeraient par là

Je remets juste ma 1ère vidéo :



Et la nouvelle :



Dites moi l'image que vous préférez si vous voulez bien Et ne trichez pas hein, ne regardez pas les scripts dans la description SVP !

 

Un gars sur Doom9, m'a pondu un truc assez intéressant, à base de scanlines et de bloom



J'ai juste corrigé la luminosité à "-12.5" (c'était trop clair) avec le filtre interne de VirtualDub "Brightness & Contrast".

Mais bon, quand tu vois la taille du script !

## requires: MaskTools2

AviSource().ConvertToRGB32()
#<source=RGB>

## upscale "point-wise" to half scale
## (Gauss p=100 is sharp like PointResize, but works at non-integer ratios)
GaussResize(1408/2, 1080/2, p=100)

## Rec601/Rec709 as required for correct colors
ConvertToYV12(matrix="Rec709")

## scanlines effect, set very weak, no flickering
scanlines2(2, 0.3, false)

## final upscale (p= 0 to 100 to set sharpness)
GaussResize(1408, 1080, p=100)

## subtle bloom effect
SoftBloom_B(radius=198, minlevels=219, min=174, max=185,
\ threshold=251, sat=0.64, cont=173, mul=0.76)
return Last

##################################
### scanlines effect
## CRT emulation with scanline and phosphor effects - Page 3 - Doom9's Forum
##
function scanlines2(clip C, int "size", float "strength", bool "flicker")
{
size = Min(Max(1, Default(size, 2)), 4)
strength = Min(Max(0.0, Default(strength, 0.25)), 1.0)
flicker = Default(flicker, false)

C
A=mt_lutspa(
\ mode="absolute",
\ expr=mt_polish("(((y/(2*"+String(0.25*size)+"))%2)>0)?128+64:128-64"),
\ u=-128, v=-128
\ )

B = (flicker)
\ ? ScriptClip(A, """(current_frame % 2) > 0 ? Last : Last.FlipVertical""")
\ : A

return Overlay(B, opacity=0.25*strength, mode="luma")
}

##################################
## SoftBloom with constrained inputs and resizing
## original by MJLives12
## @ Bloom filter for film look - Page 3 - Doom9's Forum
## modded raffriff42
## @ Bloom filter for film look - Page 3 - Doom9's Forum
##
function SoftBloom_B(clip Last, int "radius", int "minlevels",
\ int "min", int "max", int "threshold", int "blur",
\ float "sat", int "cont", float "mul") {

## (limits are set based on guesswork; please adjust if needed)
radius = Min(Max(2, Default (radius, 2)), Width / 2)
edges = (width / radius) + ((width / radius) % 2) #bigger radius smaller effect
threshold = Min(Max(16, Round (Default (threshold, 250) * 219 / 255.0) + 16), 255)
minlevels = Min(Max(-255, Default (minlevels, 0)), threshold-1)
min = Min(Max(threshold+1, Default (min, 254)), 254)
max = Min(Max(min+1, Default (max, min+1)), 255)
blur = Min(Max(0, Default (blur, 1)), 100)
sat = Min(Max(0.0, Default (sat, 0.5)), 4.0)
cont = Min(Max(16, Default (cont, 127)), 255)
mul = Min(Max(0.0, Float(Default (mul, 0.25))), 4.0)

old_wid = Width
old_hgt = height
new_wid = width / edges
new_hgt = height / edges
new_wid = Min(Max(64, new_wid), old_wid / 2)
new_hgt = Min(Max(64, new_hgt), old_hgt / 2)
new_wid = new_wid + new_wid % 2
new_hgt = new_hgt + new_hgt % 2

Mask = ConvertToRGB32().RGBLevelsG(min, 1.0, max, 0, 255)
\ .Levels(minlevels, 0.1, threshold, 0, 255, false)
\ .ConvertToYV12()
\ .GaussResize(new_wid, new_hgt, p = blur)
\ .BilinearResize(old_wid, old_hgt)
\ .Tweak(sat = sat)
\ .Levels(0, 1.0, cont, 0, 255, false)
White = BlankClip(Mask).Invert("Y")

MT_Merge(MT_lutxy(Mask
\ ,uexpr = " y 128 < x y * 128 /"
\ ,vexpr = " y 128 < x y * 128 /", U = 3, V = 3), White, luma = true
\ ,Merge(Tweak(cont = 0, sat = 0), Mask, mul))
}

##################################
### Levels in RGB mode
## Bloom filter for film look - Page 3 - Doom9's Forum
## @ StainlessS
##
function RGBlevelsG(clip clp,
\ int "input_low", float "gamma", int "input_high",
\ int "output_low", int "output_high", bool "show_function")
{
input_low = Default(input_low, 0)
gamma = Default(gamma, 1.0)
input_high = Default(input_high, 255)
output_low = Default(output_low, 0)
output_high = Default(output_high, 255)
show_function = Default(show_function, false)

wicked = (gamma > 1.0)
\ ? "x " +string(input_low)+ " - " +string(input_high)+
\ " " +string(input_low)+ " - / 1 " +string(gamma)+
\ " / ^ " +string(output_high)+ " " +string(output_low)+
\ " - * " +string(output_low)+ " + x * x 255 x - * + 255 /"
\ : "x " +string(input_low)+ " - " +string(input_high)+
\ " " +string(input_low)+ " - / 1 " +string(gamma)+
\ " / ^ " +string(output_high)+ " " +string(output_low)+
\ " - * " +string(output_low)+ " + 255 x - * x x * + 255 /"

return (show_function) ? clp.subtitle(wicked)
\ : clp.UUmt_rgblut(wicked, wicked, wicked)
}

#######################################
### RGBLUT for MaskTools v.2
## MaskTools blending modes - dodge, burn, etc, etc - Doom9's Forum
##
function UUmt_rgblut(clip C,
\ string Rexpr, string Gexpr, string Bexpr,
\ bool "showargs")
{
Assert(C.IsRGB, "UUmt_rgblut: source must be RGB")

showargs = Default(showargs, false)

## v = R, y = G, u = B
Cy = YToUV(C.ShowBlue("YV12"), C.ShowRed("YV12"), C.ShowGreen("YV12"))

Zy = Cy.mt_lut(yexpr=Gexpr, uexpr=Bexpr, vexpr=Rexpr, U=3, V=3)

## R = v, G = y, B = u
Z = MergeRGB(Zy.VToY, Zy.ConvertToY8, Zy.UToY,
\ pixel_type=(C.IsRGB32)?"RGB32":"RGB24")

return (showargs==false) ? Z
\ : Z.Subtitle("Rexpr = "+SplitLines(Rexpr, 80), lsp=0, align=7)
\ .Subtitle("Gexpr = "+SplitLines(Gexpr, 80), lsp=0, align=4)
\ .Subtitle("Bexpr = "+SplitLines(Bexpr, 80), lsp=0, align=1)
}

#### end main script - the following required only for UUmt_rgblut above if showargs=true

##################################
##
function StrReplace(string base, string findstr, string repstr)
{
pos = FindStr(base, findstr)
return (StrLen(findstr)==0) || (pos==0)
\ ? base
\ : StrReplace(
\ LeftStr(base, pos-1) + repstr +
\ MidStr(base, pos+StrLen(findstr)),
\ findstr, repstr)
}

##################################
## Split long lines for Subtitle line wrap;
## tries to split on word boundaries
## with a /very/ basic algorithm.
##
## Example: Subtitle(SplitLines(longstring, 80), lsp=0)
## (remember to add the /lsp/ argument)
##
## @ lastcol - maximum line length before breaking (default 80)
## @ cc - line count, for internal use; leave it alone
##
## On return, global variable /splitlines_count/
## is set to the number of lines in the string
## this will be needed if you want to bottom-align.
## (splitlines_count==1 means one line & no breaks)
##
## Suggest caller remove line breaks from source argument with:
## StrReplace(Chr(10), "")
## StrReplace(Chr(13), " ")
##
function SplitLines(string s, int "lastcol", int "cc")
{
lastcol = Default(lastcol, 80)
cc = Default(cc, 1)
global splitlines_count = cc

## dumb split: no word breaks
#return (StrLen(s)<lastcol) ? s :
#\ TrimLeft(LeftStr(s, lastcol)) + "\n"
#\ + SplitLines(MidStr(s, lastcol+1), lastcol, counter+1)

## a little smarter
p = FindStr(RevStr(LeftStr(s, lastcol)), " ")
return (StrLen(s)<lastcol)
\ ? TrimLeft(s)
\ : (p < 12)
\ ? TrimLeft(LeftStr(s, lastcol-p)) + "\n" +
\ SplitLines(MidStr(s, lastcol-p+1), lastcol, cc+1)
\ : TrimLeft(LeftStr(s, lastcol)) + "\n" +
\ SplitLines(MidStr(s, lastcol+1), lastcol, cc+1)
}

##################################
## SplitLines helper: trim spaces from left side of string
##
function TrimLeft(string s) {
# return (LeftStr(s, 1)==" ") ? TrimLeft(MidStr(s, 2)) : s
return Ord(s)==9 ? TrimLeft(MidStr(s, 2))
\ : Ord(s)==10 ? TrimLeft(MidStr(s, 2))
\ : Ord(s)==12 ? TrimLeft(MidStr(s, 2))
\ : Ord(s)==32 ? TrimLeft(MidStr(s, 2))
\ : Ord(s)==160 ? TrimLeft(MidStr(s, 2))
\ : s
}

Une machine le mec ! Non sérieux, il y en a qui sont vraiment fortiches !

Bon, après je ne pense pas que je vais l'utiliser. Mais l'effet est tout de même très sympa ! Assez pour que je le poste ici !

 

Y'a des grands malades quand-même
Et pour un résultat pas franchement top je trouve, ça rajoute des défauts, je préfère tes scripts (que j'ai du mal à différencier d'ailleurs).

 

J'en ai aussi profité pour tester l'upscaling simplement avec Sony Vegas, puis ensuite avec le filtre "Netteté Sony" à une valeur de 0,541 et le filtre "Flou rapide Sony" à 0,264.



Mais je ne suis pas convaincu. Je pense que le filtre utilisé par Vegas est du bicubique, mais comme quoi, avec un redimensionnement basique, je n'obtiens pas ce que je veux.

Bon, je vais être honnête, je ne vais plus rien faire d'autre. Je vais juste choisir un des scripts que j'ai fait, car je suis fatigué, et vous sans doute aussi

Bonne nuit !

 

Ah ah ! Merci

Et encore, avant ma correction ça donnait ça :



En tout cas, son script est ouf ! Vous ne pensiez pas pouvoir trouver plus dingue que moi hein ! En plus, je suis lucide, je me rends compte que c'était un peu ouf tout ce que j'ai pondu, mais bon, j'étais dans le trip

Après, le but du script qu'il m'a filé n'était pas vraiment de rendre la vidéo plus nette, mais plutôt de simuler l'effet "vieil écran".

Au niveau du feeling, ça se rapproche effectivement de ce que c'était à l'époque. Mais objectivement, c'est clair que ça détruit plus qu'autre chose. Mais au moins j'ai compris que ce truc particulier que je recherchais était beaucoup lié à la technologie de l'époque. En gros, le relief et la sensation de définition étaient basés sur un gros effet d'optique (les scanlines notamment). Mais ça marchait diablement bien faut le dire. Ces vieux jeux étaient clairement pensés pour les écrans CRT.

Bon voilà, ayant capté tout ça et fait le deuil des écrans CRT, je peux avancer ! D'autant plus que je veux améliorer la définition de ma vidéo, pas la dégrader

 

J'ai eu une idée

Comme vous pouvez le voir sur cette capture de la vidéo YouTube que j'ai postée plus haut, les scanlines font littéralement parti de l'image :



C'est carrément un espace entre chaque ligne de pixel, et c'est cet espace, ce manque d'information, qui paradoxalement créé une information en plus dans l'image. Ou du moins c'est notre cerveau qui comble cette absence d'information. Mais ce qui est sûr, c'est que les développeurs de jeux vidéo à l'époque, on pensé à ça, car sans scanlines, ce n'est carrément pas la même chose.

Je n'essaye pas de dire que je vais en mettre. D'ailleurs comme l'a dit Alcoriza, il ne suffit pas simplement de mettre une ligne noire sur 2

De plus, si on compare l'épaisseur d'une ligne de pixels, elle est pratiquement 5 fois plus grande par rapport à une scanline.

Berf, j'ai pensé à une chose Au lieu de mettre des scanlines ou de carrément nier cet apport, je vais en quelque sorte rajouter de l'information verticalement

En se basant sur l'idée qu'on a environ 5 lignes de pixels (en numérique cette fois-ci) pour 1 ligne de pixel noir, mais que je veux plutôt créé de l'information plutôt que d'en enlever, ça équivaut à ça à peu près :

5 lignes horizontales de pixels + 1 lignes d'information en plus

<=> 10 lignes horizontales de pixels + 2 lignes d'informations en plus (normalement on en enlève une à la fin, mais là on ne peut pas, car il nous faut un chiffre paire, donc on s'en fout)

Donc si je ne me trompe pas dans mes calculs, il faut :

10x = 2160 (je vise tout d'abord une résolution de 2160p)
x = 216

Les lignes que je veux ajouter, ça équivaut à 2 lignes horizontales en plus, pour 10 lignes de pixels, donc 10/5.

Donc on fait :

(10x/5) = (2160/5) = 432 lignes de pixels

Je dois ajouter 432 lignes de pixels horizontales en plus par rapport à 2160, ce qui fait une résolution verticale de 2592 pxls.

Voici donc comment je recréé cette information. Au lieu d'upscaler en 2160p pour commence, je passe en 2592p. Ensuite je downscale dans la résolution voulue

Mon script donne ça :

AviSource()
Spline16Resize(2816, 2592)
BicubicResize(b=0, c=0.5, 1408, 1080)

Et le résultat n'est pas trop mal Cet apport d'information n'est pas aussi négligeable qu'on peut le penser.



En fait, après recul, le script n°2 que j'ai fait me plait aussi pas mal. Donc je vais juste décider entre celui-ci et celui que je viens de faire, et j'en aurai enfin terminé avec tout ça

 

Jusqu'au prochain post

Olivier

 

Oui, enfin j'aimerais quand même finir un jour Mais après, ce n'est pas impossible...

Voilà la vidéo avec le script 2 et mon dernier script :