Some finger exercises with image levels

[Didée]

Sorry for not replying ... with an all-time-bursting PM box, some PMs might slip through.

Worse is that YlevelsG/S/C indeed is wrongly implemented, and has been like that since day one.
Consequently, ffdshow "correctly" incorporates the faulty Ylevels variants ... so my complaints always were unjustified.

I am standing there with egg on my face.

[Jeremy Duncan]

Didée,

The FFdshow developer h_yamagata updated the YlevelsG/S/C using Alain2's patch.

Check it out. Rev 567
Link

FFDShow

[bananacreamandpeca]

Ok. this is interesting. I was looking for a quick way just to
control the gamma for my video.
But how do I use this? I only need the masktools.dll for avisynth,
that's all?

[digitalone]

thx for this great function Didée...but is it possible to update it using MVTools v2 semantics? thx again.

[Manao]

Just replace yv12lut by mt_lut

[digitalone]

thx a lot manao..it's working now...

I need some help understanding this.

I have a DVD that's too "bright" and looks a bit washed out. I can get more of a "film-ish" look if I use:

Levels(0, 0.85, 255, 0, 255)

But this pulls the brightest bits down a bit too much and gives the illusion of reduced contrast. It sounds like the adjusted curves in this script are what I need to make the dark bits darker and not touch the bright bits too much, but reading the first post it looks as if this filter was not desinged for gamma values less than 1.0? (Where it says "YlevelsG (not YlevelsS) does "inverse" scaling for gamma values < 1.0, but that's not that great. It's just for completeness.") Of course I could just try it and see what it looks like, but if someone could clarify whether I should be using this or if something else would do a better job?

[LigH]

You should use a limited luminance (and chrominance) range when encoding to MPEG2 for DVD. MPEG2 encoders may expect "TV range" material (due to the fact that TV sets expect a limited signal voltage range from the receiver), and if you give them "PC range" instead, you will get overbright results especially on CRT TV sets.

You should apply the filter ColorYUV(levels="PC->TV") on full range material before encoding it.

http://avisynth.org/mediawiki/ColorYUV

I don't think that's going to help, because the MPEG2 source should already be in TV range, I'm not doing any colourpsace conversions.

My quick test:

a=ImageReader("greyscale.png").converttoyv12().histogram()
b=ImageReader("greyscale.png").converttoyv12().levels(0, 0.6, 255, 0 , 255).histogram()
c=ImageReader("greyscale.png").converttoyv12().ylevels(0, 0.6, 255, 0 , 255).histogram()
d=ImageReader("greyscale.png").converttoyv12().ylevelsg(0, 0.6, 255, 0 , 255).histogram()
e=ImageReader("greyscale.png").converttoyv12().ylevelss(0, 0.6, 255, 0 , 255).histogram()
stackvertical(a, b, c, d, e)

YLevels and YLevelsG seems to clip the black too much. YLevelsS reduces the peak white.

Using gamma values >1.0, I see similar clipping in the white.

[IanB]

You might also test the coring=false option to Levels(). This option changes the range scaling from 16..235 to 0..255

...ImageReader("greyscale.png").converttoyv12().levels(0, 0.6, 255, 0 , 255, coring=false)

This should be the same as the default coring=true

...ImageReader("greyscale.png").converttoyv12().levels(16, 0.6, 235, 16 , 235, coring=false)

I should have used the 16-235 levels in my YLevels script above!
e.g.
ImageReader("greyscale.png").converttoyv12().ylevelsg(16, 0.6, 235, 16 , 235).histogram()
is correct with no clipping.

But, is there any reason why I shouldn't do this:

ImageReader("greyscale.png").ConvertToYV12().FlimsYLevels(15).Histogram()

function FlimsYlevels(clip clp, float amp)
       { wicked="x x 16 - 34,85493 / sin "+string(amp)+" * -"
         return( clp.mt_lut(Yexpr = wicked) )  
         }

[zee944]

Didée, this filter is a great idea. I hope you'll continue refining it. Very useful.

My problem with it that I can't call forth the effect I want. I'd like to define which range I want to boost up a little. I've played around a lot with the values, but I just can't do it.

What I want is to only affect pixels that have luma value between (say) 50 and 200. I don't want to touch pixels under and above a certain brightness. So probably the gamma curve should be shrinked to fit between 50 and 200. Is it possible?

[Didée]

Answered zee944's question here.

Summary: Possible, but not feasable to do that with MaskTools' lookup tables.

[Kumo]

i'm trying to use this filter on a jap dvd r2 anime.i'm calling ylevels in my script like : "ylevelsS(16, 1.0, 235, 0 , 255).
i can adjust input_low and output_low settings to reach a 0-255 full range (checking it with histogram)only with gamma=1.
if i try with i.e. gamma =1.6(or any other value), i get dark levels too bright with i.e. input_low=34 and too dark with next value(i.e. input_low=35, there are no mid-ways).where am i wrong?

I tried to test ylevels, but the problem I got is, when I try to work on source with AvsP everythink looks ok,but when rip finish I don't see any effect of ylevels in my rip...any Idea why.
I am using this script and Virtualdub for rip.

Script:

LoadPlugin("C:\Program Files\AviSynth 2.5\plugins\DGDecode.dll")
MPEG2Source("C:\Documents and Settings\Vesi\My Documents\Test\Test.d2v")
Deblock_QED()
tfm(order=1).tdecimate()
Crop(0, 44, -0, -48)

Spline36Resize(624,304) # Spline36 (Neutral)
YlevelsS(0,1.6,255,0,255)
FFT3DFILTER(sigma=1.0,bw=32,bh=32,ow=16,oh=16,bt=3)
dull = last
sharp = dull.LimitedSharpenfaster( ss_x=1.25, ss_y=1.25,smode=4, strength=150, overshoot=1 )
Soothe( sharp, dull, 40 )
Tweak(hue=0.0, sat=1.2)

Before

With AvsP

Output

[WorBry]

FlimsyFeet,

I know this is quite an old thread, but I'm experimenting with routines for simulating 'film-looks', ideally keeping the process in YV12.
Since there seems to be no easy way to import Photoshop/Gimp curves without color space conversion (and I'm not sure if the Levels > Curves control in FFDSHow avoids that), I've been using a Masktools (mt_lutxy) function (128-centred multiply) that achieves the same result as the Overlay blend mode, found in After Effects etc.

http://forum.doom9.org/showthread.ph...67#post1387067

This effectively creates an S-shaped luma curve, the 'strength' of which can be somewhat adjusted by opacity.

I also came across your FlimsYLevels function, which produces a sinusoidal S-curve.

Originally Posted by FlimsyFeet

function FlimsYlevels(clip clp, float amp)
{ wicked="x x 16 - 34,85493 / sin "+string(amp)+" * -"
return( clp.mt_lut(Yexpr = wicked) )
}[/CODE]

I'm interested to know how you derived the calc for the the 'wicked' mt_lut expression; I want to stay in full 0 - 255 range, not 16 -235.

Cheers.

[Mounir]

I'm beginning to experiment and appreciate the benefits of this filter; sadly enough, like most of the filters it is YV12 only so i have to make an official request for YUY2 support , if that's not asking the moon.

[LaTo]

Originally Posted by Mounir

I'm beginning to experiment and appreciate the benefits of this filter; sadly enough, like most of the filters it is YV12 only so i have to make an official request for YUY2 support , if that's not asking the moon.

You can do the same with SmoothAdjust which support YV16 (and so YUY2) in avisynth 2.6.x


Or you can add YUY2 indirectly in these functions:

clip = last
ConvertToYV12()

xxxlevels(...)

ConvertToYUY2()
MergeChroma(clip)

[hello_hello]

Would anyone with a wiki account care to fix the version of Ylevels on the wiki?

For the version on the wiki, the "show_function" argument is integer, when it should be bool.

function Ylevels(clip clp,
\                int "input_low", float "gamma", int "input_high",
\                int "output_low", int "output_high", int "show_function")

And the return line has been changed to display the subtitle over the source video when show_function=true. I'm not sure if that was deliberate, but I'm also not sure why it would've been changed.

Wiki version:

return( show_function ? clp.subtitle(wicked) : clp.mt_lut(Yexpr = wicked, U=2,V=2) )

The version I've been using:

########
# Levels transforms by Didée
# Requires MaskTools v2.0 or greater
# last revision 2004-12-07; update to MaskTools v2.0 semantics 2008-03-09
#
# PARAMETERS:
#   "input_low"     : (Default: 0)
#   "gamma"         : (Default: 1.0)
#   "input_high"    : (Default: 255)
#   "output_low"    : (Default: 0)
#   "output_high"   : (Default: 255)
#   "show_function" : (Default: false) - the function to be made into a lookup-table
#                                        transform, shown in postfix notation
#
# USAGE:
#   YLevels(0, 1.2, 255, 0, 255, false)
#   YLevels(0, 1.2, 255)
#   YLevels(gamma=1.2)

# Constant
function Ylevels(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 = "x " +string(input_low)+ " - " +string(input_high)+ " " +string(input_low)+ " - / 1 " +string(gamma)+
    \        " / ^ " +string(output_high)+ " " +string(output_low)+ " - * " +string(output_low)+ " +"
        
    return show_function ? \
    clp.mt_lut(Yexpr = wicked, U=2,V=2).subtitle(wicked) : \
    clp.mt_lut(Yexpr = wicked, U=2,V=2)
}
         
# Gradient
function YlevelsG(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.mt_lut(Yexpr = wicked, U=2,V=2).subtitle(wicked) : \
    clp.mt_lut(Yexpr = wicked, U=2,V=2)
}

# Sine
function YlevelsS(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="x " +string(input_low)+ " - " +string(input_high)+ " " +string(input_low)+ " - / 1 " +string(gamma)+
    \      " / ^ " +string(output_high)+ " " +string(output_low)+ " - * " +string(output_low)+ " + x 162,97466 /" +
    \      " sin 255 * * x 255 x 162,97466 / sin 255 * - * + 255 /"
    
    return show_function ? \
    clp.mt_lut(Yexpr = wicked, U=2,V=2).subtitle(wicked) : \
    clp.mt_lut(Yexpr = wicked, U=2,V=2)
}

# Cosine
function YlevelsC(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="x " +string(input_low)+ " - "+ string(input_high)+ " " +string(input_low)+ " - / 1 "+string(gamma)+
    \      " / ^ " +string(output_high)+ " " +string(output_low)+ " - * " +string(output_low)+ " + 255 x 162,97466" +
    \      " / cos 255 * - * x x 162,97466 / cos 255 * * + 255 /"
    
    return show_function ? \
    clp.mt_lut(Yexpr = wicked, U=2,V=2).subtitle(wicked) : \
    clp.mt_lut(Yexpr = wicked, U=2,V=2)
}