# 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.