Nnedi3/nnedi3 rpow2
From Avisynth wiki
(Difference between revisions)
m (→Description) |
m (category) |
||
| Line 1: | Line 1: | ||
| + | [[Category:Plugin_Filters]] | ||
| + | [[Category:Resizers]] | ||
'''Back to [[nnedi3#Filters|nnedi3]] ←''' | '''Back to [[nnedi3#Filters|nnedi3]] ←''' | ||
-------------------------------------------------- | -------------------------------------------------- | ||
Revision as of 18:17, 23 August 2014
Back to nnedi3 ←
Description
- nnedi3_rpow2 is for enlarging images by powers of 2.
Syntax and Parameters
- nnedi3_rpow2 (clip, int rfactor, int "nsize", int "nns", int "qual", int "etype", int "pscrn", string "cshift", int "fwidth", int "fheight", float "ep0", float "ep1", int "threads", int "opt", int "fapprox")
- int rfactor =
- Image enlargement factor. Must be a power of 2 in the range [2,1024].
- int rfactor =
- int nsize = 0
- Sets the size of the local neighborhood around each pixel that is used by the predictor
- neural network. Possible settings (x_diameter x y_diameter):
- int nsize = 0
- 0 - 8x6
- 1 - 16x6
- 2 - 32x6
- 3 - 48x6
- 4 - 8x4
- 5 - 16x4
- 6 - 32x4
- For image enlargement it is recommended to use 0 or 4. Larger y_diameter settings
- will result in sharper output. For deinterlacing larger x_diameter settings will
- allow connecting lines of smaller slope. However, what setting to use really
- depends on the amount of aliasing (lost information) in the source. If the source was
- heavily low-pass filtered before interlacing then aliasing will be low and a large
- x_diameter setting wont be needed, and vice versa.
- int nns = 3
- Sets the number of neurons in the predictor neural network. Possible settings are
- 0, 1, 2, 3, and 4. 0 is fastest. 4 is slowest, but should give the best quality. This
- is a quality vs speed option; however, differences are usually small. The difference
- in speed will become larger as 'qual' is increased.
- int nns = 3
- 0 - 16
- 1 - 32
- 2 - 64
- 3 - 128
- 4 - 256
- int qual = 1
- Controls the number of different neural network predictions that are blended together
- to compute the final output value. Each neural network was trained on a different set
- of training data. Blending the results of these different networks improves generalization
- to unseen data. Possible values are 1 or 2. Essentially this is a quality vs speed
- option. Larger values will result in more processing time, but should give better results.
- However, the difference is usually pretty small. I would recommend using qual>1 for
- things like single image enlargement.
- int qual = 1
- int etype = 0
- Controls which set of weights to use in the predictor nn. Possible settings:
- int etype = 0
- 0 - weights trained to minimize absolute error
- 1 - weights trained to minimize squared error
- int pscrn = 2
- Controls whether or not the prescreener neural network is used to decide which pixels
- should be processed by the predictor neural network and which can be handled by simple
- cubic interpolation. The prescreener is trained to know whether cubic interpolation
- will be sufficient for a pixel or whether it should be predicted by the predictor nn.
- The computational complexity of the prescreener nn is much less than that of the predictor
- nn. Since most pixels can be handled by cubic interpolation, using the prescreener
- generally results in much faster processing. The prescreener is pretty accurate, so the
- difference between using it and not using it is almost always unnoticeable.
- int pscrn = 2
- Version 0.9.3 adds a new, faster prescreener with three selectable 'levels', which
- trade off the number of pixels detected as only requiring cubic interpolation versus
- incurred error. Therefore, pscrn is now an integer with possible values of 0, 1, 2, 3,
- and 4.
- 0 - no prescreening (same as false in prior versions)
- 1 - original prescreener (same as true in prior versions)
- 2 - new prescreener level 0
- 3 - new prescreener level 1
- 4 - new prescreener level 2
- *Higher levels for the new prescreener result in cubic interpolation being
- used on fewer pixels (so are slower, but incur less error). However, the
- difference is pretty much unnoticable. Level 2 is closest to the original
- prescreener in terms of incurred error, but is much faster.
- string cshift =
- Sets the resizer used for correcting the image center shift that nnedi3_rpow2
- introduces. This can be any of Avisynth's internal resizers, such as "spline36resize",
- "lanczosresize", etc... If not specified the shift is not corrected. The correction
- is accomplished by using the subpixel cropping capability of Avisynth's internal
- resizers.
- string cshift =
- int fwidth =
- int fheight =
- If correcting the image center shift by using the 'cshift' parameter, fwidth/fheight
- allow you to set a new output resolution. First, the image is enlarged by 'rfactor'
- using nnedi3. Once that is completed the image center shift is corrected, and the
- image is resampled to fwidth x fheight resolution. The shifting and resampling
- happen in one call using the internal Avisynth resizer you specify via the 'cshift'
- string. If fwidth/fheight are not specified, then they are set equal to rfactor*width
- and rfactor*height respectively (in other words they do nothing).
- int fwidth =
- float ep0 =
- float ep1 =
- Some Avisynth resizers take optional arguments, such as 'taps' for lanczosresize or
- 'p' for gaussresize. ep0/ep1 allow you to pass values for these optional arguments
- when using the 'cshift' parameter. If the resizer only takes one optional argument
- then ep0 is used. If the argument that the resizer takes is not a float value,
- then ep0 gets rounded to an integer. If the resizer takes two optional arguments,
- then ep0 corresponds to the first one, and ep1 corresponds to the second. The only
- resizer that takes more than one optional argument is bicubicresize(), which takes
- 'b' and 'c'. So ep0 = b, and ep1 = c. If ep0/ep1 are not set then the default value
- for the optional argument(s) of the resizer is used.
- float ep0 =
- int threads = 0
- Controls how many threads will be used for processing. If set to 0, threads will
- be set equal to the number of detected processors.
- int threads = 0
- int opt = 0
- Sets which cpu optimizations to use. Possible settings:
- int opt = 0
- 0 = auto detect
- 1 = use c
- 2 = use sse2
- int fapprox = 15
- Bitmask which enables or disables certain speed-ups. Value range is [0,15].
- Mainly for debugging.
- int fapprox = 15
- 0 = nothing
- &1 = use int16 dot products in first layer of prescreener nn
- &2 = use int16 dot products in predictor nn
- &12 = 4 = use exp function approximation in predictor nn
- &12 = 8|12 = use faster (and more inaccurate) exp function approximation in predictor nn
Examples
- Enlarge image by 4x with default settings (identical to the 2nd example):
AviSource("Blah.avi") nnedi3_rpow2(rfactor=4, nsize=0, nns=3, qual=1, etype=0, pscrn=2, threads=0, opt=0, fapprox=15)
- Enlarge image by 4x, don't correct for center shift.
AviSource("Blah.avi") nnedi3_rpow2(rfactor=4)
- Enlarge image by 2x, correct for center shift using Spline36Resize.
AviSource("Blah.avi") nnedi3_rpow2(rfactor=2,cshift="Spline36Resize")
- Enlarge image by 8x, correct for center shift and downsample from 8x to 7x using LanczosResize with 5 taps.
AviSource("Blah.avi") nnedi3_rpow2(rfactor=8,cshift="LanczosResize",fwidth=width*7,fheight=height*7,ep0=5)
Back to nnedi3 ←
