Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /v0.43.0 /pt /api /image_processor.md
mishig
2 days ago
preview code
download
raw
26.3 kB
# Processador de Imagem VAE

O [VaeImageProcessor](/docs/diffusers/v0.43.0/pt/api/image_processor#diffusers.VaeImageProcessor) fornece uma API unificada para [StableDiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline)s prepararem as entradas de imagem para a codificação por VAE e processarem os resultados após a decodificação. Isso inclui transformações como redimensionamento, normalização e conversão entre PIL Image, PyTorch e arrays NumPy.

Todos os pipelines com [VaeImageProcessor](/docs/diffusers/v0.43.0/pt/api/image_processor#diffusers.VaeImageProcessor) aceitam PIL Image, tensor do PyTorch ou arrays NumPy como entradas de imagem e retornam saídas com base no argumento `output_type` definido pelo usuário. Você pode passar latentes de imagem codificados diretamente para o pipeline e retornar latentes do pipeline como uma saída específica com o argumento `output_type` (por exemplo, `output_type="latent"`). Isso permite pegar os latentes gerados de um pipeline e passá-los para outro pipeline como entrada, sem sair do espaço latente. Também facilita muito o uso de vários pipelines juntos, passando tensores do PyTorch diretamente entre diferentes pipelines.

## VaeImageProcessor[[diffusers.VaeImageProcessor]]

#### diffusers.VaeImageProcessor[[diffusers.VaeImageProcessor]]

```python
diffusers.VaeImageProcessor(do_resize: bool = True, vae_scale_factor: int = 8, vae_latent_channels: int = 4, resample: str = 'lanczos', reducing_gap: int | None = None, do_normalize: bool = True, do_binarize: bool = False, do_convert_rgb: bool = False, do_convert_grayscale: bool = False)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L83)

**Parâmetros:**

do_resize (`bool`, *opcional*, padrão `True`) : Se as dimensões (altura, largura) da imagem devem ser reduzidas para múltiplos de `vae_scale_factor`. Pode aceitar os argumentos `height` e `width` do método [image_processor.VaeImageProcessor.preprocess()](/docs/diffusers/v0.43.0/pt/api/image_processor#diffusers.VaeImageProcessor.preprocess).
vae_scale_factor (`int`, *opcional*, padrão `8`) : Fator de escala do VAE. Se `do_resize` for `True`, a imagem será redimensionada automaticamente para múltiplos deste fator.

resample (`str`, *opcional*, padrão `lanczos`) : Filtro de reamostragem a ser usado ao redimensionar a imagem.

do_normalize (`bool`, *opcional*, padrão `True`) : Se normalizar a imagem para [-1,1].
do_binarize (`bool`, *opcional*, padrão `False`) : Se deve binarizar a imagem para 0/1.

do_convert_rgb (`bool`, *opcional*, padrão é `False`) : Se as imagens devem ser convertidas para o formato RGB.

do_convert_grayscale (`bool`, *opcional*, padrão é `False`) : Se as imagens devem ser convertidas para o formato de escala de cinza.

Processador de imagem para VAE.

#### apply_overlay[[diffusers.VaeImageProcessor.apply_overlay]]

```python
apply_overlay(mask: Image, init_image: Image, image: Image, crop_coords: tuple[int, int, int, int] | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L789)

**Parâmetros:**

mask (`PIL.Image.Image`) : A imagem de máscara que destaca as regiões a serem sobrepostas.

init_image (`PIL.Image.Image`) : A imagem original à qual a sobreposição é aplicada.
image (`PIL.Image.Image`) : A imagem a ser sobreposta à original.
crop_coords (`tuple[int, int, int, int]`, *opcional*) : Coordenadas para recortar a imagem. Se fornecidas, a imagem será recortada de acordo.

**Retorna:** `PIL.Image.Image`

A imagem final com a sobreposição aplicada.

Aplica uma sobreposição da máscara e da imagem reparada sobre a imagem original.

#### binarizar[[diffusers.VaeImageProcessor.binarize]]

```python
binarize(image: Image)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L524)

**Parâmetros:**

image (`PIL.Image.Image`) : A entrada da imagem, deve ser uma imagem PIL.

**Retorna:** `PIL.Image.Image`

A imagem binarizada. Valores menores que 0,5 são definidos como 0, valores maiores que 0,5 são definidos como 1.

Crie uma máscara.

#### blur[[diffusers.VaeImageProcessor.blur]]

```python
blur(image: Image, blur_factor: int = 4)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L271)

**Parâmetros:**

image (`PIL.Image.Image`) : A imagem PIL a ser convertida para escala de cinza.

**Retorna:** `PIL.Image.Image`

A imagem PIL convertida para escala de cinza.

Aplica um desfoque gaussiano a uma imagem.

#### convert_to_grayscale[[diffusers.VaeImageProcessor.convert_to_grayscale]]

```python
convert_to_grayscale(image: Image)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L254)

**Parâmetros:**

image (`PIL.Image.Image`) : A imagem de entrada a ser convertida.

**Retorna:** `PIL.Image.Image`

A imagem convertida para escala de cinza.

Converte uma imagem PIL fornecida para escala de cinza.

#### convert_to_rgb[[diffusers.VaeImageProcessor.convert_to_rgb]]

```python
convert_to_rgb(image: Image)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L237)

**Parâmetros:**

image (`PIL.Image.Image`) : A imagem PIL a ser convertida para RGB.

**Retorna:** `PIL.Image.Image`

A imagem PIL convertida para RGB.

Converte uma imagem PIL para o formato RGB.

#### denormalizar[[diffusers.VaeImageProcessor.denormalize]]

```python
denormalize(images: typing.Union[numpy.ndarray, torch.Tensor])
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L222)

**Parâmetros:**

images (`np.ndarray` ou `torch.Tensor`) : O array de imagem para desnornalizar.

**Retorna:** `np.ndarray` ou `torch.Tensor`

O array de imagem denormalizado.

Desnormalize um array de imagem para [0,1].

#### get_crop_region[[diffusers.VaeImageProcessor.get_crop_region]]

```python
get_crop_region(mask_image: Image, width: int, height: int, pad = 0)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L288)

**Parâmetros:**

mask_image (PIL.Image.Image) : Imagem de máscara.
width (int) : Largura da imagem a ser processada.
height (int) : Altura da imagem a ser processada.
pad (int, opcional) : Preenchimento a ser adicionado à região de recorte. Padrão é 0.
**Retorna:** `tuple`
(x1, y1, x2, y2) representam uma região retangular que contém todas as áreas mascaradas em uma imagem e corresponde à proporção original.
Encontra uma região retangular que contém todas as áreas mascaradas em uma imagem e expande a região para corresponder à proporção de aspecto da imagem original; por exemplo, se o usuário desenhou a máscara em uma região de 128x32 e as dimensões para processamento são 512x512, a região será expandida para 128x128.
#### get_default_height_width[[diffusers.VaeImageProcessor.get_default_height_width]]
```python
get_default_height_width(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], height: int | None = None, width: int | None = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L561)
**Parâmetros:**
image (`PIL.Image.Image | np.ndarray | torch.Tensor`) : A entrada de imagem, que pode ser uma imagem PIL, um array NumPy ou um tensor PyTorch. Se for um array NumPy, ele deve ter a forma `[batch, height, width]` ou `[batch, height, width, channels]`. Se for um tensor PyTorch, ele deve ter a forma `[batch, channels, height, width]`.
height (`int | None`, *opcional*, padrão `None`) : A altura da imagem pré-processada. Se `None`, a altura da entrada `image` será utilizada.
width (`int | None`, *opcional*, padrão `None`) : A largura da imagem pré-processada. Se `None`, a largura da entrada `image` será utilizada.
**Retorna:** `tuple[int, int]`
Uma tupla contendo a altura e a largura, ambas redimensionadas para o múltiplo inteiro mais próximo de `vae_scale_factor`.
Retorna a altura e a largura da imagem, reduzidas para o próximo múltiplo inteiro de `vae_scale_factor`.
#### normalizar[[diffusers.VaeImageProcessor.normalize]]
```python
normalize(images: typing.Union[numpy.ndarray, torch.Tensor])
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L207)
**Parâmetros:**
images (`np.ndarray` ou `torch.Tensor`) : O array de imagem a ser normalizado.
**Retorna:** `np.ndarray` ou `torch.Tensor`
O array de imagem normalizado.
Normalizar um array de imagem para [-1,1].
#### numpy_to_pil[[diffusers.VaeImageProcessor.numpy_to_pil]]
```python
numpy_to_pil(images: ndarray)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L128)
**Parâmetros:**
images (`np.ndarray`) : O array de imagem a ser convertido para o formato PIL.
**Retorna:** `list[PIL.Image.Image]`
Uma lista de imagens PIL.
Converte uma imagem numpy ou um lote de imagens para uma imagem PIL.
#### numpy_to_pt[[diffusers.VaeImageProcessor.numpy_to_pt]]
```python
numpy_to_pt(images: ndarray)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L172)
**Parâmetros:**
images (`np.ndarray`) : O array de imagem do NumPy a ser convertido para o formato PyTorch.
**Retorna:** `torch.Tensor`
Uma representação de tensor do PyTorch das imagens.
Converte uma imagem do NumPy para um tensor do PyTorch.
#### pil_to_numpy[[diffusers.VaeImageProcessor.pil_to_numpy]]
```python
pil_to_numpy(images: list[PIL.Image.Image] | PIL.Image.Image)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L152)
**Parâmetros:**
images (`PIL.Image.Image` ou `list[PIL.Image.Image]`) : A imagem PIL ou lista de imagens a serem convertidas para o formato NumPy.
**Retorna:** `np.ndarray`
Uma representação de array NumPy das imagens.
Converte uma imagem PIL ou uma lista de imagens PIL para arrays NumPy.
#### postprocess[[diffusers.VaeImageProcessor.postprocess]]
```python
postprocess(image: Tensor, output_type: str = 'pil', do_denormalize: list[bool] | None = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L739)
**Parâmetros:**
image (`torch.Tensor`) : A entrada de imagem, deve ser um tensor do PyTorch com a forma `B x C x H x W`.
output_type (`str`, *opcional*, padrão `pil`) : O tipo de saída da imagem, pode ser um de `pil`, `np`, `pt`, `latent`.
do_denormalize (`list[bool]`, *opcional*, padrão `None`) : Se deve desnormalizar a imagem para [0,1]. Se `None`, usará o valor de `do_normalize` na configuração do `VaeImageProcessor`.
**Retorna:** `PIL.Image.Image`, `np.ndarray` ou `torch.Tensor`
A imagem pós-processada.
Pós-processe a imagem de saída do tensor para `output_type`.
#### preprocess[[diffusers.VaeImageProcessor.preprocess]]
```python
preprocess(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], height: int | None = None, width: int | None = None, resize_mode: str = 'default', crops_coords: tuple[int, int, int, int] | None = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L608)
**Parâmetros:**
image (`PipelineImageInput`) : A entrada de imagem, os formatos aceitos são imagens PIL, arrays NumPy, tensores PyTorch; Também aceita lista de formatos suportados.
height (`int`, *opcional*) : A altura da imagem pré-processada. Se `None`, usará o `get_default_height_width()` para obter a altura padrão.
width (`int`, *opcional*) : A largura pré-processada. Se `None`, usará get_default_height_width()` para obter a largura padrão.
resize_mode (`str`, *opcional*, padrão é `default`) : O modo de redimensionamento, pode ser `default` ou `fill`. Se `default`, a imagem será redimensionada para caber dentro da largura e altura especificadas, e pode não manter a proporção original. Se `fill`, a imagem será redimensionada para caber dentro da largura e altura especificadas, mantendo a proporção, e então a imagem será centralizada dentro das dimensões, preenchendo o espaço vazio com dados da imagem. Se `crop`, a imagem será redimensionada para caber dentro da largura e altura especificadas, mantendo a proporção, e então a imagem será centralizada dentro das dimensões, cortando o excesso. Observe que resize_mode `fill` e `crop` são suportados apenas para entrada de imagem PIL.
crops_coords (`list[tuple[int, int, int, int]]`, *opcional*, padrão `None`) : As coordenadas de recorte para cada imagem no lote. Se `None`, a imagem não será recortada.
**Retorna:** `torch.Tensor`
A imagem pré-processada.
Pré-processa a entrada de imagem.
#### pt_to_numpy[[diffusers.VaeImageProcessor.pt_to_numpy]]
```python
pt_to_numpy(images: Tensor)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L191)
**Parâmetros:**
images (`torch.Tensor`) : O tensor do PyTorch a ser convertido para o formato NumPy.
**Retorna:** `np.ndarray`
Uma representação de array NumPy das imagens.
Converte um tensor do PyTorch para uma imagem do NumPy.
#### resize[[diffusers.VaeImageProcessor.resize]]
```python
resize(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], height: int, width: int, resize_mode: str = 'default')
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L463)
**Parâmetros:**
image (`PIL.Image.Image`, `np.ndarray` ou `torch.Tensor`) : A entrada da imagem, pode ser uma imagem PIL, um array numpy ou um tensor pytorch.
height (`int`) : A altura para redimensionar.
width (`int`) : A largura para redimensionar.
resize_mode (`str`, *opcional*, padrão é `default`) : O modo de redimensionamento a ser usado, pode ser `default` ou `fill`. Se `default`, a imagem será redimensionada para caber dentro da largura e altura especificadas, e pode não manter a proporção original. Se `fill`, a imagem será redimensionada para caber dentro da largura e altura especificadas, mantendo a proporção, e então a imagem será centralizada dentro das dimensões, preenchendo o espaço vazio com dados da imagem. Se `crop`, a imagem será redimensionada para caber dentro da largura e altura especificadas, mantendo a proporção, e então a imagem será centralizada dentro das dimensões, cortando o excesso. Observe que os resize_mode `fill` e `crop` são suportados apenas para entrada de imagem PIL.
**Retorna:** `PIL.Image.Image`, `np.ndarray` ou `torch.Tensor`
A imagem redimensionada.
Redimensionar imagem.
## InpaintProcessor[[diffusers.InpaintProcessor]]
O [InpaintProcessor](/docs/diffusers/v0.43.0/pt/api/image_processor#diffusers.InpaintProcessor) aceita entradas `mask` e `image` e as processa juntas. Opcionalmente, pode aceitar padding_mask_crop e aplicar sobreposição de máscara.
#### diffusers.InpaintProcessor[[diffusers.InpaintProcessor]]
```python
diffusers.InpaintProcessor(do_resize: bool = True, vae_scale_factor: int = 8, vae_latent_channels: int = 4, resample: str = 'lanczos', reducing_gap: int | None = None, do_normalize: bool = True, do_binarize: bool = False, do_convert_grayscale: bool = False, mask_do_normalize: bool = False, mask_do_binarize: bool = True, mask_do_convert_grayscale: bool = True)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L837)
Processador de imagem para inpainting de imagem e máscara.
#### postprocess[[diffusers.InpaintProcessor.postprocess]]
```python
postprocess(image: Tensor, output_type: str = 'pil', original_image: PIL.Image.Image | None = None, original_mask: PIL.Image.Image | None = None, crops_coords: tuple[int, int, int, int] | None = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L944)
Pós-processa a imagem, aplicando opcionalmente a sobreposição da máscara
#### preprocess[[diffusers.InpaintProcessor.preprocess]]
```python
preprocess(image: Image, mask: PIL.Image.Image | None = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L882)
Pré-processa a imagem e a máscara.
## VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]
O [VaeImageProcessorLDM3D](/docs/diffusers/v0.43.0/pt/api/image_processor#diffusers.VaeImageProcessorLDM3D) aceita entradas RGB e de profundidade e retorna saídas RGB e de profundidade.
#### diffusers.VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]
```python
diffusers.VaeImageProcessorLDM3D(do_resize: bool = True, vae_scale_factor: int = 8, resample: str = 'lanczos', do_normalize: bool = True)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L974)
**Parâmetros:**
do_resize (`bool`, *opcional*, padrão `True`) : Se as dimensões (altura, largura) da imagem devem ser reduzidas para múltiplos de `vae_scale_factor`.
vae_scale_factor (`int`, *opcional*, padrão `8`) : Fator de escala do VAE. Se `do_resize` for `True`, a imagem será redimensionada automaticamente para múltiplos deste fator.
resample (`str`, *opcional*, padrão `lanczos`) : Filtro de reamostragem a ser usado ao redimensionar a imagem.
do_normalize (`bool`, *opcional*, padrão `True`) : Se normalizar a imagem para [-1,1].
Processador de imagem para VAE LDM3D.
#### depth_pil_to_numpy[[diffusers.VaeImageProcessorLDM3D.depth_pil_to_numpy]]
```python
depth_pil_to_numpy(images: list[PIL.Image.Image] | PIL.Image.Image)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1025)
**Parâmetros:**
images (`list[PIL.Image.Image, PIL.Image.Image]`) : A imagem de entrada ou lista de imagens a serem convertidas.
**Retorna:** `np.ndarray`
Um array NumPy das imagens convertidas.
Converte uma imagem PIL ou uma lista de imagens PIL para arrays NumPy.
#### numpy_to_depth[[diffusers.VaeImageProcessorLDM3D.numpy_to_depth]]
```python
numpy_to_depth(images: ndarray)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1083)
**Parâmetros:**
images (`np.ndarray`) : O array NumPy de entrada de imagens de profundidade, que pode ser uma única imagem ou um lote.
**Retorna:** `list[PIL.Image.Image]`
Uma lista de imagens PIL convertidas das imagens de profundidade NumPy de entrada.
Converte uma imagem de profundidade NumPy ou um lote de imagens em uma lista de imagens PIL.
#### numpy_to_pil[[diffusers.VaeImageProcessorLDM3D.numpy_to_pil]]
```python
numpy_to_pil(images: ndarray)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1001)
**Parâmetros:**
images (`np.ndarray`) : O array NumPy de entrada de imagens, que pode ser uma única imagem ou um lote.
**Retorna:** `list[PIL.Image.Image]`
Uma lista de imagens PIL convertidas do array NumPy de entrada.
Converte uma imagem NumPy ou um lote de imagens em uma lista de imagens PIL.
#### preprocess[[diffusers.VaeImageProcessorLDM3D.preprocess]]
```python
preprocess(rgb: typing.Union[torch.Tensor, PIL.Image.Image, numpy.ndarray], depth: typing.Union[torch.Tensor, PIL.Image.Image, numpy.ndarray], height: int | None = None, width: int | None = None, target_res: int | None = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1161)
**Parâmetros:**
rgb (`torch.Tensor | PIL.Image.Image | np.ndarray`) : A imagem de entrada RGB, que pode ser uma única imagem ou um lote.
depth (`torch.Tensor | PIL.Image.Image | np.ndarray`) : A imagem de profundidade de entrada, que pode ser uma única imagem ou um lote.
height (`int | None`, *opcional*, padrão `None`) : A altura desejada da imagem processada. Se `None`, o padrão é a altura da imagem de entrada.
width (`int | None`, *opcional*, padrão `None`) : A largura desejada da imagem processada. Se `None`, o padrão é a largura da imagem de entrada.
target_res (`int | None`, *opcional*, padrão `None`) : Resolução de destino para redimensionar as imagens. Se especificada, substitui a altura e a largura.
**Retorna:** `tuple[torch.Tensor, torch.Tensor]`
Uma tupla contendo as imagens RGB e de profundidade processadas como tensores do PyTorch.
Pré-processa a entrada de imagem. Os formatos aceitos são imagens PIL, arrays NumPy ou tensores PyTorch.
#### rgblike_to_depthmap[[diffusers.VaeImageProcessorLDM3D.rgblike_to_depthmap]]
```python
rgblike_to_depthmap(image: typing.Union[numpy.ndarray, torch.Tensor])
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1045)
Converte uma imagem de profundidade em formato RGB para um mapa de profundidade.
## PixArtImageProcessor[[diffusers.PixArtImageProcessor]]
#### diffusers.PixArtImageProcessor[[diffusers.PixArtImageProcessor]]
```python
diffusers.PixArtImageProcessor(do_resize: bool = True, vae_scale_factor: int = 8, resample: str = 'lanczos', do_normalize: bool = True, do_binarize: bool = False, do_convert_grayscale: bool = False)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1381)
**Parâmetros:**
do_resize (`bool`, *opcional*, padrão `True`) : Se as dimensões (altura, largura) da imagem devem ser reduzidas para múltiplos de `vae_scale_factor`. Pode aceitar os argumentos `height` e `width` do método [image_processor.VaeImageProcessor.preprocess()](/docs/diffusers/v0.43.0/pt/api/image_processor#diffusers.VaeImageProcessor.preprocess).

vae_scale_factor (`int`, *opcional*, padrão `8`) : Fator de escala do VAE. Se `do_resize` for `True`, a imagem será redimensionada automaticamente para múltiplos deste fator.

resample (`str`, *opcional*, padrão `lanczos`) : Filtro de reamostragem a ser usado ao redimensionar a imagem.

do_normalize (`bool`, *opcional*, padrão `True`) : Se normalizar a imagem para [-1,1].
do_binarize (`bool`, *opcional*, padrão `False`) : Se deve binarizar a imagem para 0/1.

do_convert_rgb (`bool`, *opcional*, padrão é `False`) : Se as imagens devem ser convertidas para o formato RGB.

do_convert_grayscale (`bool`, *opcional*, padrão é `False`) : Se as imagens devem ser convertidas para o formato de escala de cinza.

Processador de imagem para redimensionar e recortar imagens do PixArt.

#### classify_height_width_bin[[diffusers.PixArtImageProcessor.classify_height_width_bin]]

```python
classify_height_width_bin(height: int, width: int, ratios: dict)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1422)

**Parâmetros:**

height (`int`) : A altura da imagem.

width (`int`) : A largura da imagem.

ratios (`dict`) : Um dicionário em que as chaves são as proporções de aspecto e os valores são tuplas de (altura, largura).

**Retorna:** `tuple[int, int]`

A altura e a largura mais próximas em bins.

Retorna a altura e a largura em intervalos com base na proporção de aspecto.

#### resize_and_crop_tensor[[diffusers.PixArtImageProcessor.resize_and_crop_tensor]]

```python
resize_and_crop_tensor(samples: Tensor, new_width: int, new_height: int)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1440)

**Parâmetros:**

samples (`torch.Tensor`) : Um tensor de forma (N, C, H, W), onde N é o tamanho do lote, C é o número de canais, H é a altura e W é a largura.

new_width (`int`) : A largura desejada das imagens de saída.
new_height (`int`) : A altura desejada das imagens de saída.

**Retorna:** `torch.Tensor`

Um tensor contendo as imagens redimensionadas e recortadas.

Redimensiona e recorta um tensor de imagens para as dimensões especificadas.

## IPAdapterMaskProcessor[[diffusers.IPAdapterMaskProcessor]]

#### diffusers.IPAdapterMaskProcessor[[diffusers.IPAdapterMaskProcessor]]

```python
diffusers.IPAdapterMaskProcessor(do_resize: bool = True, vae_scale_factor: int = 8, resample: str = 'lanczos', do_normalize: bool = False, do_binarize: bool = True, do_convert_grayscale: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1277)

**Parâmetros:**

do_resize (`bool`, *opcional*, padrão `True`) : Se as dimensões (altura, largura) da imagem devem ser reduzidas para múltiplos de `vae_scale_factor`.
vae_scale_factor (`int`, *opcional*, padrão `8`) : Fator de escala do VAE. Se `do_resize` for `True`, a imagem será redimensionada automaticamente para múltiplos deste fator.

resample (`str`, *opcional*, padrão `lanczos`) : Filtro de reamostragem a ser usado ao redimensionar a imagem.

do_normalize (`bool`, *opcional*, padrão `False`) : Se normalizar a imagem para [-1,1].
do_binarize (`bool`, *opcional*, padrão `True`) : Se deve binarizar a imagem para 0/1.

do_convert_grayscale (`bool`, *opcional*, padrão é `True`) : Se as imagens devem ser convertidas para o formato de escala de cinza.

Processador de imagem para máscaras de imagem do IP Adapter.

#### downsample[[diffusers.IPAdapterMaskProcessor.downsample]]

```python
downsample(mask: Tensor, batch_size: int, num_queries: int, value_embed_dim: int)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1318)

**Parâmetros:**

mask (`torch.Tensor`) : O tensor de máscara de entrada gerado com `IPAdapterMaskProcessor.preprocess()`.

batch_size (`int`) : O tamanho do lote.
num_queries (`int`) : O número de consultas.

value_embed_dim (`int`) : A dimensionalidade dos embeddings de valor.

**Retorna:** `torch.Tensor`

O tensor de máscara com amostragem reduzida.

Reduz a dimensão do tensor de máscara fornecido para corresponder às dimensões esperadas para a atenção de produto escalar. Se a proporção de aspecto da máscara não corresponder à proporção de aspecto da imagem de saída, um aviso é emitido.
Xet Storage Details

Size:: 26.3 kB
Xet hash:: 1ac210d6707865092086f4f64835c789a0ceba7998f04c8383d26e0f359ad19e
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.