## BicubicResize / BilinearResize / LanczosResize / Lanczos4Resize / PointResize

`BicubicResize` (clip, int target_width, int target_height, float "b", float "c")
`BilinearResize` (clip, int target_width, int target_height)
`LanczosResize` (clip, int target_width, int target_height, int "taps")
`Lanczos4Resize` (clip, int target_width, int target_height)
`Spline16Resize` (clip, int target_width, int target_height)
`Spline36Resize` (clip, int target_width, int target_height)
`GaussResize` (clip, int target_width, int target_height, float "p")
`PointResize` (clip, int target_width, int target_height)

`BicubicResize` (clip, int target_width, int target_height, float "b", float "c", float "src_left", float "src_top", float "src_width", float "src_height")
`BilinearResize` (clip, int target_width, int target_height, float "src_left", float "src_top", float "src_width", float "src_height", int "taps")
`LanczosResize` (clip, int target_width, int target_height, float "src_left", float "src_top", float "src_width", float "src_height")
`Lanczos4Resize` (clip, int target_width, int target_height, float "src_left", float "src_top", float "src_width", float "src_height")
`Spline16Resize` (clip, int target_width, int target_height, float "src_left", float "src_top", float "src_width", float "src_height")
`Spline36Resize` (clip, int target_width, int target_height, float "src_left", float "src_top", float "src_width", float "src_height")
`GaussResize` (clip, int target_width, int target_height, float "src_left", float "src_top", float "src_width", float "src_height")
`PointResize` (clip, int target_width, int target_height, float "src_left", float "src_top", float "src_width", float "src_height", float "p")

Para todos os resizes você pode usar uma sintaxe expandida que apara antes. As mesmas operações são executadas como se você pôs um Crop antes do Resize, pode haver uma leve diferença de velocidade.

    Crop(10,10,200,300).BilinearResize(100,150)
      é igual a
    BilinearResize(100,150,10,10,200,300)

Importante: AviSynth tem resizers vertical e horizontal completamente separados. Se a entrada é igual à saída em um eixo, esse resizer será ignorado.
Qual é chamado primeiro, é determinado pelo que tiver a menor relação diminuída. Isto é feito para preservar máxima qualidade, assim o 2º resizer tem o melhor quadro possível para trabalhar.

### BilinearResize

O filtro BilinearResize re-escala a entrada de quadros de vídeo para uma nova resolução arbitrária. Se você der os argumentos de fonte opcionais, o resultado é igual se você aplicar `Crop` com esses argumentos ao clipe antes de BilinearResize (exceto mais rápido).

`BilinearResize usa filtragem bilinear normal e é quase idêntico à opção resizing "precise bilinear" de VirtualDub.``` Só é "quase" porque o filtro de VirtualDub parece obter o fator de escala ligeiramente incorreto, com o resultado de que os píxeis são cortados no topo e à direita da imagem ou são duplicados. (Este erro é saliente se ampliar o tamanho da imagem a um fator de dois ou mais, senão é insignificante, assim eu não me preocuparia muito com isso).

    Exemplos:
    # Carregue um vídeo e redimensione-o para 240x180 (não  importa o que era antes)
    AVISource("video.avi").BilinearResize(240,180)

    # Carregue um vídeo 720x480 (CCIR601) e redimensione-o para  352x240 (VCD),
    # preservando a relação de aspecto correta
    AVISource("dv.avi").BilinearResize(352,240,8,0,704,480)

    #Extraia o quadrante superior direito de um vídeo 320x240 e faça zoom nele
    # para encher todo o quadro
    BilinearResize(320,240,160,0,160,120)

### BicubicResize

``BicubicResize`` é igual a ``BilinearResize``, exceto que em vez de uma função de filtragem linear usa o cúbico de duas partes de Mitchell-Netravali. Os parâmetros b e c podem ser usados para ajustar as propriedades do cúbico, às vezes eles são chamados de 'Blurring' e 'Ringing ' respectivamente.

Com b = 0 e c = 0.75 o filtro é exatamente igual ao "precise bicubic," bicúbico preciso de VirtualDub e os resultados são idênticos com exceção de problemas escalares do VirtualDub acima mencionado. O padrão é b = 1/3 e c = 1/3, cujos valores foram recomendados por Mitchell e Netravali rendendo resultados visualmente agradáveis em testes subjetivos dos seres humanos. Valores maiores de b e c podem produzir efeitos "op-art" interessantes por exemplo, tente b = 0 e c = -5.

Se você estiver ampliando seu vídeo, terá visuais muito bons com BicubicResize do que com BilinearResize. Porém, se você estiver diminuindo, provavelmente terá da mesma maneira, ou até melhor ainda, com BilinearResize. Embora o filtro bicubic do VirtualDub produz imagens de melhor visual que seu filtro bilinear, é principalmente porque o filtro bicubic aguça a imagem, não por amostrar melhor. As imagens aguçadas são agradáveis de olhar, até você tentar comprimi-las ao ponto em que possam lhe parecer grosseiras. O padrão em BicubicResize é não aguçar como o bicubic de VirtualDub, mas aguça mais que o bilinear. Se você planejar codificar seu vídeo a um bitrate baixo, eu não ficaria surpreendido se BilinearResize render melhor qualidade.

Você tem que fixar
b + 2 * c = 1
para o filtro numericamente mais preciso.
Isto dá para b = 0 o máximo valor para c = 0.5 que são a ranhura de Catmull-Rom e uma boa sugestão para agudez.

De c>0.6 o filtro começa a "soar". Você não adquirirá real agudez, o que você terá é o franzido como num televisor.
Valor negativo na é permitido para b. Então fique em b=0.

### LanczosResize / Lanczos4Resize

``LanczosResize`` é uma alternativa para ``BicubicResize`` com valores altos de c, entre 0.6... 0.75 e que produz aguçar bem forte.
Normalmente oferece qualidade melhor (menos objetos) e uma imagem aguçada.

`Lanczos4Resize` (incluído na v2.55) é bem relacionado a `LanczosResize` (nome correto: Lanczos3Resize). Os usos de lóbulos posteriores 2*3=6 e os anteriores 2*4=8 para fazer o resizing. O resultado é que `Lanczos4Resize` Especialmente proveitoso ao aumentar um clipe.

#### Tamanho de "Interpolation Tap" (parâmetro de tampas)

Para upsampling (torna a imagem maior), o filtro é de tamanho tal que toda a equação cai para 4 amostras da entrada, fazendo-o um filtro de 4 tampas. Não importa quanto grande a imagem de saída vai ser - terá só 4 tampas. Para downsampling (faz a imagem menor), a equação é de tamanho tal que cairá para 4 amostras de *destino* e obviamente são espaçadas a intervalos maiores que as amostras da fonte. Assim para downsampling com um fator de 2 (fazendo metade da imagem), o filtro cobre amostras 2*4=8 de entrada e assim 8 tampas. Para downsampling 3x, precisa de 3*4=12 tampas e assim sucessivamente.
Assim o número total de tampas que você precisa para downsampling é a relação de downsampling, vezes o número de lóbulos (assim downsampling Tx LanczoskResize resulta em tampas de T*2*k). E praticamente, arredonda-se até o próximo inteiro. Para upsampling, é sempre 4 tampas. Fonte: [avsforum post].

Lanczos4Resize é abreviação para LanczosResize(taps=4).

### Spline16Resize/Spline36Resize

Dois spline (ranhuras?) baseados em resizers. Spline16Resize é ligeiramente mais rápido que

Spline16Resize. (incluídos na v2.56)

GaussResize

`Usa um resizer de gaussian com parâmetro 'p' de agudez ajustável. P tem uma gama entre 1 e 100, com 1 muito borrado e 100 ser muito aguçado. GaussResize tem velocidade semelhante como Lanczos4Resize. (`incluído na`` v2.56`)`

### PointResize

``PointResize`` `é o resizer mais simples possível. Usa algoritmo Point Sampler ou Nearest Neighbor que normalmente resultam em uma imagem muito maciça. Este filtro só deve ser usado, se você pretende ter qualidade inferior, ou se precisa desenhar píxeis claros. Útil para aumentar áreas pequenas para examinar.`

Log de mudanças:

v2.56 | incluídos Spline16Resize, Spline36Resize, GaussResize e `parâmetros` tampas em LanczosResize
v2.55 | incluído Lanczos4Resize

`$Date: 2006/03/26 18:11:19 $ Portuguese translation by RoLon`