Diskussion zu Dideé AviSynth Filter Collection

Ich hab einfach meine Anhänge gelöscht. (auch damit Kati endlich Ruhe gibt )
Nun muss man deine nehmen.
Ich würde den Changelog nicht in einen Code setzen, sieht nicht schön aus.

Ich bin gerade dabei die Readme zu LSF zu übersetzen und dabei ist mir aufgefallen das die Momentane version teilweise veraltet ist. Ich hab mir deshalb noch mal den LS-Thread durchgelesen und folgende Didée zitate zu den Neuen optionen zusammengetragen:

Zitat von Didée am 28th November 2005 09:12

"Undershoot" is not meant do force any line darkening. It just allows to do the cutting-off of the sharpening effect "later", in those places where it actually makes pixels darker. To force more darkening, you have to increase the sharpening strength. Try

LimitedSharpen(Smode=1, radius=3, strength=2048, undershoot=255)

and look again whether lines get darker or not
(But heaven help, never use it like this!)

Zitat von Didée am 29th November 2005 17:37

"special" I would not consider important. It often produces artefacts, like halos and whatnotelse. It will be ditched, and replaced with something ... pssst ... much more special.

Zitat von Didée am 1st December 2005 11:15

The "soft" option now works as follows:

- first compute the sharpening
- build the difference map between "input" and "sharpened"
- apply a modified blurring to the difference map
- apply the blurred difference map to the input

The modified blurring works by only allowing pixel values getting closer to 128, not farther away from 128. This is important: a plain blur to the difference map in the end would result in the "fat" look of unsharp masking (ugh!). This sort of "reduction blur" retains the sharp look, because it is more similar to a linear scaling. But then again, it is smarter then just doing linear scaling: where plain scaling would just reduce the effect everywhere by the same amount, this sort of blurring is respecting spatial coherency of the current pixel. (Kind of that ... it's a poor man's method. True spatial "tracing" is not possible to do through an avisynth script.)
So, for a pixel that received sharpening values very different from those of its neighbors, the sharpening will be reduced more (i.e. a pixel that got darker, where all of its neighbors got brighter). For a pixel that received sharpening values rather similar to those of its neighbors, the sharpening will be reduced less.

The idea behind the new "soft" mode were:

- reduce aliasing when using only little supersampling (or none at all)

- try to be detail- and noise-aware. The more neighbor pixels are having similar properties than the current pixel, the more likely it is we're on a detail's edge, and we want to allow sharpening. If current pixel's properties are very different to those of its neighbors, the pixel probably is noisy, and we don't want to sharpen it.

That's basically it. Good values for "soft" depend on the supersampling factors (small ss factors --> small values for "soft", and TOWR), and on the sharpening strength. Or vice versa for strength - if you use e.g. soft=33, increase also the strength ... perhaps by 33% as a start, and make your way from there.

Alles anzeigen

Zitat von Didée am 14th February 2006 10:33

Soft=-1 in LS ~tries~ to find a suited value for "soft" automatically, depending on the used supersampling factors. However I would not trust too much in it, but rather set it manually: suited strengths for "soft" depend pretty much on the combination of values for Smode, strength, supersampling & overshoot ... and so far, no formula containing all these variables & spitting out a good value for "soft" appeared to me.

Zitat von Didée am 18th September 2007 11:54

http://www.myimg.de

The graph above shows how the *sharpening* of Smode=4 works. Blue is "linear" sharpening, i.e. if the sharpener calculated a change of x for a pixel, then the pixel is changed by x.

Smode=4 (pink) uses a gamma function to modify the calculated change. It's the very same principle as used in SeeSaw, only that there are no parameters for Spower/SdampLo (LimitedSharpen /w Smode=4 uses fixed values), and SdampHi is not used at all.

For Smode=4: if the blurring kernel yielded a change of 'x' for the current pixel, then the change that will be applied is:

Code:
16 * sqrt(|x/16|) * (x^2 /4+x^2) * (-sign(x)) | (for strength=100)

Jatzt müßen wir nur noch sehen wie wir das mit der readme kombineren um sie auf den aktuellen Stand zu bringen...

Warscheinlich werden ich beider nächsten Version html satet txt benutzen um Grafiken verwenen zu .können.

Zitat

Code:
16 * sqrt(|x/16|) * (x^2 /4+x^2) * (-sign(x)) | (for strength=100)

Oh-lala, da hatte ich mich aber verschrieben: der Reduktionsterm macht ^so^ relativ wenig Sinn. Richtig ist:

16 * sqrt(|x/16|) * (x^2 / (x^2+4)) * (-sign(x)) | (for strength=100)

Oder, um ganz genau zu sein:

16 * sqrt(|x/16|) * (x^2 / (x^2+(strength/25))) * (-sign(x))

Der Meister "mischt mit"

• YAMCGC_EV "Yet another motion compensated grain cruncher (easy version)"
• Scripted_MVDegrain3

Bitte beachten das das "Scripte für bestimmte Fälle" und keine vollwertigen Funktionen sind!

Übrigens ist der gesamte Thread sehr lesenswert.

*gig* die 300 BlurRay Version hab ich bei nem Kumpel schon 'bewundern' dürfen,. Grumpf, das Teil ist so mir grain voll, dass ich Teilweise an Ameisen auf der BluRay getippt hätte. -> Respekt an Didée was er da noch rausgeholt hat.

Cu Selur

Ich habe mir mal erlaubt für die "Didée AviSynth Filter Collection" zwei Sachen aus dem Need Suggestions for VERY GRAINY source-Thread auf Doom9 in Funktionen umzuwandeln.

LFDeFlicker()

# Idee von Didée# aus dem VERY-GRAINY-Doom9-Thread (http://forum.doom9.org/showpost.php?p=1073349&postcount=33)# Stand: 2008-04-22# benötigte Plugins: MedianBlur 0.84 #                    RemoveGrain 1.0pre #                    MaskTools v2#                    FluxSmooth 1.1b# The following script will remove the low-frequency flicker, leaving the high-frequencies intact.# In result, there will be almost no smoothing, and the grain basically is fully preserved.# It's just the flicker, or "dancing" effect, that will be removed.# As a side-effect, there might occur some slight toning-down of shadings when there is motion.# One can definetly see it in single-frame comparisons by flipping between original and processed.# But one will hardly note that during watching the moviefunction LFDeFlicker(clip clp){f = clp.MinBlur(1,2).MinBlur(2,2).RemoveGrain(11,-1)f.FluxSmoothT(7).mt_AddDiff(mt_MakeDiff(clp,f,U=2,V=2),U=4,V=4) # eventually, limit the maximum pixel change to +/- 2 :# mt_LutXY(clp,last,"x 2 + y < x 2 + x 2 - y > x 2 - y ? ?",U=2,V=2)return(last)}# Taken from MCBob.avs:function MinBlur(clip clp, int r, int "uv"){uv   = default(uv,3)uv2  = (uv==2) ? 1 : uvrg4  = (uv==3) ? 4 : -1rg11 = (uv==3) ? 11 : -1rg20 = (uv==3) ? 20 : -1medf = (uv==3) ? 1 : -200RG11D = (r==1) ? mt_makediff(clp,clp.removegrain(11,rg11),U=uv2,V=uv2) \    : (r==2) ? mt_makediff(clp,clp.removegrain(11,rg11).removegrain(20,rg20),U=uv2,V=uv2) \    :          mt_makediff(clp,clp.removegrain(11,rg11).removegrain(20,rg20).removegrain(20,rg20),U=uv2,V=uv2)RG4D  = (r==1) ? mt_makediff(clp,clp.removegrain(4,rg4),U=uv2,V=uv2) \    : (r==2) ? mt_makediff(clp,clp.medianblur(2,2*medf,2*medf),U=uv2,V=uv2) \    :          mt_makediff(clp,clp.medianblur(3,3*medf,3*medf),U=uv2,V=uv2)DD    = mt_lutxy(RG11D,RG4D,"x 128 - y 128 - * 0 < 128 x 128 - abs y 128 - abs < x y ? ?",U=uv2,V=uv2)clp.mt_makediff(DD,U=uv,V=uv)return(last)}

Zitat von Didee

One step further, something in this direction often is very useful for subsequent motioncompensated denoising. If the flicker is left in, it eventually will also disturb the ME engine (making the vectors follow the flicker, causing spatial shifts where in fact there should be none), which will lower the benefit one can get from MC-NR. When the flicker is taken out before the motion search, chances are better to get more clean vectors.

ContraSharpening()

# Idee von Didée# aus dem VERY-GRAINY-Doom9-Thread (http://forum.doom9.org/showpost.php?p=1076491&postcount=70)# entnommen aus dem YAMCGC_EV-Skript# benötigte Plugins: Masktools v2#                    RemoveGrain 1.0pre#                    Repair# contra-sharpening: sharpen the denoised clip, but don't add more to any pixel than what was removed previously.FUNCTION ContraSharpening(clip denoised, clip original){s    = denoised.minblur(1,1)                                # Damp down remaining spots of the denoised clip.allD = mt_makediff(original,denoised)                       # The difference achieved by the denoisingssD  = mt_makediff(s,s.removegrain(11,-1))                  # The difference of a simple kernel blurssDD = ssD.repair(allD,1)                                   # Limit the difference to the max of what the denoising removed locally.ssDD = SSDD.mt_lutxy(ssD,"x 128 - abs y 128 - abs < x y ?") # abs(diff) after limiting may not be bigger than before.denoised.mt_adddiff(ssDD,U=2,V=2)                           # Apply the limited difference. (Sharpening is just inverse blurring.)RETURN (last)}# Taken from MCBob.avs:function MinBlur(clip clp, int r, int "uv"){uv   = default(uv,3)uv2  = (uv==2) ? 1 : uvrg4  = (uv==3) ? 4 : -1rg11 = (uv==3) ? 11 : -1rg20 = (uv==3) ? 20 : -1medf = (uv==3) ? 1 : -200RG11D = (r==1) ? mt_makediff(clp,clp.removegrain(11,rg11),U=uv2,V=uv2) \    : (r==2) ? mt_makediff(clp,clp.removegrain(11,rg11).removegrain(20,rg20),U=uv2,V=uv2) \    :          mt_makediff(clp,clp.removegrain(11,rg11).removegrain(20,rg20).removegrain(20,rg20),U=uv2,V=uv2)RG4D  = (r==1) ? mt_makediff(clp,clp.removegrain(4,rg4),U=uv2,V=uv2) \    : (r==2) ? mt_makediff(clp,clp.medianblur(2,2*medf,2*medf),U=uv2,V=uv2) \    :          mt_makediff(clp,clp.medianblur(3,3*medf,3*medf),U=uv2,V=uv2)DD    = mt_lutxy(RG11D,RG4D,"x 128 - y 128 - * 0 < 128 x 128 - abs y 128 - abs < x y ? ?",U=uv2,V=uv2)clp.mt_makediff(DD,U=uv,V=uv)return(last)}

_____

Ich habe mal SPresso für MaskTools v2 modifiziert (Wieso hat das eingentlich schon nicht schon eher mal jmd. gemacht, oder habe ich was übersehen?)

# Modifizierte Version für MaskTools v2


function SPresso_MT(clip clp, int "limit", int "bias", int "RGmode")
{
limit  = default( limit,  2 )
bias   = default( bias,  25 )
RGmode = default( RGmode, 4 )


LIM1  = (limit>0) ? string( round(limit*100.0/bias-1.0) ) : string( round(100.0/bias) )
LIM2  = (limit<0) ? "1" : string(limit)
BIA   = string(bias)


expr  = (limit<0) ?   "x y - abs "+LIM1+" < x x 1 x y - x y - abs / * - ?"
 \                :   "x y == x x "+LIM1+" + y < x "+LIM2+" + x "+LIM1+" - y > x "+LIM2+" - " \ 
                    + "x 100 "+BIA+" - * y "+BIA+" * + 100 / ? ? ?"


mt_lutxy( clp, clp.removegrain(RGmode,-1), expr, U=2,V=2)
}

_____

Ich bin mir nicht sicher, ob alles, was ich hier gepostet habe auch stimmt. Ich empfehle dringendst, dass sich ein erfahrener Skripte-Schreiber sich das nochmal anguckt, bevor es in Didée AviSynth Filter Collection übernommen wird!
_____

Alle Ideen dieser Funktionen sind von Didée, und ihn obliegt natürlich auch die Namensgebung. Falls er also anderen Namen für die Funktionen wählt, bitte diese nehmen. (Ich werde dann meinen Post auch entsprechend abändern.)
_____

Persönlich nutzt ich eine Kombination aus SPresso_MT(RGmode=1).LFDeFlicker() gern als Pre-Filtering für die MVAnalyse bei guten Quellen.

Danke, Naito-kun. :daumen:

Bin im Moment im Umzugsstress, danach schau ich mir das mal genauer an.