# Pemroses Gambar VAE

[VaeImageProcessor](/docs/diffusers/main/id/api/image_processor#diffusers.VaeImageProcessor) menyediakan API terpadu bagi [StableDiffusionPipeline](/docs/diffusers/main/id/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) untuk menyiapkan input gambar untuk encoding VAE dan memproses output pasca-decoding. Ini mencakup transformasi seperti pengubahan ukuran, normalisasi, dan konversi antara PIL Image, PyTorch, dan array NumPy.

Semua pipeline dengan [VaeImageProcessor](/docs/diffusers/main/id/api/image_processor#diffusers.VaeImageProcessor) menerima PIL Image, tensor PyTorch, atau array NumPy sebagai input gambar dan mengembalikan output berdasarkan argumen `output_type` dari pengguna. Anda dapat meneruskan latens gambar yang sudah dienkod secara langsung ke pipeline dan mengembalikan latens dari pipeline sebagai output tertentu dengan argumen `output_type` (misalnya `output_type="latent"`). Hal ini memungkinkan Anda mengambil latens yang dihasilkan dari satu pipeline dan meneruskannya ke pipeline lain sebagai input tanpa keluar dari ruang latens. Ini juga membuat penggunaan beberapa pipeline bersama menjadi jauh lebih mudah dengan meneruskan tensor PyTorch secara langsung antar pipeline yang berbeda.

## 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L83)

**Parameter:**

do_resize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menurunkan skala dimensi (tinggi, lebar) gambar menjadi kelipatan dari `vae_scale_factor`. Dapat menerima argumen `height` dan `width` dari metode [image_processor.VaeImageProcessor.preprocess()](/docs/diffusers/main/id/api/image_processor#diffusers.VaeImageProcessor.preprocess).

vae_scale_factor (`int`, *opsional*, defaultnya `8`) : Faktor skala VAE. Jika `do_resize` adalah `True`, gambar akan di-resize secara otomatis menjadi kelipatan dari faktor ini.

resample (`str`, *opsional*, defaultnya `lanczos`) : Filter resampling yang digunakan saat mengubah ukuran gambar.

do_normalize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menormalisasi gambar ke [-1,1].

do_binarize (`bool`, *opsional*, defaultnya `False`) : Apakah akan mbinerisasi gambar menjadi 0/1.

do_convert_rgb (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengonversi gambar ke format RGB.

do_convert_grayscale (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengonversi gambar ke format grayscale.

Pemroses gambar untuk 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L789)

**Parameter:**

mask (`PIL.Image.Image`) : Gambar mask yang menyoroti area untuk ditumpangkan.

init_image (`PIL.Image.Image`) : Gambar asli tempat overlay diterapkan.

image (`PIL.Image.Image`) : Gambar yang akan ditumpangkan ke gambar asli.

crop_coords (`tuple[int, int, int, int]`, *opsional*) : Koordinat untuk memotong gambar. Jika diberikan, gambar akan dipotong sesuai koordinat tersebut.

**Mengembalikan:** `PIL.Image.Image`

Gambar akhir dengan overlay yang diterapkan.

Menerapkan overlay dari mask dan gambar inpainted pada gambar asli.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L524)

**Parameter:**

image (`PIL.Image.Image`) : Input gambar, harus berupa gambar PIL.

**Mengembalikan:** `PIL.Image.Image`

Gambar yang telah dibiarkan. Nilai kurang dari 0.5 diatur menjadi 0, nilai lebih dari 0.5 diatur menjadi 1.

Buat sebuah mask.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L271)

**Parameter:**

image (`PIL.Image.Image`) : Gambar PIL yang akan dikonversi menjadi grayscale.

**Mengembalikan:** `PIL.Image.Image`

Gambar PIL yang telah dikonversi menjadi skala abu-abu.

Menerapkan Gaussian blur pada gambar.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L254)

**Parameter:**

image (`PIL.Image.Image`) : Gambar input yang akan dikonversi.

**Mengembalikan:** `PIL.Image.Image`

Gambar yang dikonversi menjadi skala abu-abu.

Mengonversi gambar PIL yang diberikan menjadi grayscale.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L237)

**Parameter:**

image (`PIL.Image.Image`) : Gambar PIL yang akan dikonversi ke RGB.

**Mengembalikan:** `PIL.Image.Image`

Gambar PIL yang telah dikonversi ke RGB.

Mengonversi gambar PIL ke format RGB.

#### denormalisasi[[diffusers.VaeImageProcessor.denormalize]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L222)

**Parameter:**

images (`np.ndarray` atau `torch.Tensor`) : Array gambar untuk dinormalisasi ulang.

**Mengembalikan:** `np.ndarray` atau `torch.Tensor`

Array gambar yang dinormalisasi.

Denormalisasi array gambar ke [0,1].

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L288)

**Parameter:**

mask_image (PIL.Image.Image) : Gambar mask.

width (int) : Lebar gambar yang akan diproses.

height (int) : Tinggi gambar yang akan diproses.

pad (int, opsional) : Padding yang akan ditambahkan ke area crop. Defaultnya 0.

**Mengembalikan:** `tuple`

(x1, y1, x2, y2) merepresentasikan area persegi panjang yang berisi semua area ter-mask pada sebuah gambar dan sesuai dengan rasio aspek asli.

Menemukan area persegi panjang yang berisi semua area yang dimasker dalam sebuah gambar, lalu memperluas area tersebut agar sesuai dengan rasio aspek gambar asli; misalnya, jika pengguna menggambar mask pada area 128x32, dan dimensi untuk pemrosesan adalah 512x512, area tersebut akan diperluas menjadi 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L561)

**Parameter:**

image (`PIL.Image.Image | np.ndarray | torch.Tensor`) : Input gambar, yang dapat berupa gambar PIL, array NumPy, atau tensor PyTorch. Jika berupa array NumPy, bentuknya harus `[batch, height, width]` atau `[batch, height, width, channels]`. Jika berupa tensor PyTorch, bentuknya harus `[batch, channels, height, width]`.

height (`int | None`, *opsional*, defaultnya `None`) : Tinggi gambar yang dipreprocess. Jika `None`, tinggi dari input `image` akan digunakan.

width (`int | None`, *opsional*, defaultnya `None`) : Lebar dari gambar yang telah dipreprocess. Jika `None`, lebar dari input `image` akan digunakan.

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

Tuple yang berisi tinggi dan lebar, keduanya di-resize ke kelipatan bilangan bulat terdekat dari `vae_scale_factor`.

Mengembalikan tinggi dan lebar gambar, yang diskalakan ke bawah menjadi kelipatan bilangan bulat terdekat dari `vae_scale_factor`.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L207)

**Parameter:**

images (`np.ndarray` atau `torch.Tensor`) : Array gambar yang akan dinormalisasi.

**Mengembalikan:** `np.ndarray` atau `torch.Tensor`

Array gambar ternormalisasi.

Normalisasi array gambar ke [-1,1].

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

```python
numpy_to_pil(images: ndarray)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L128)

**Parameter:**

images (`np.ndarray`) : Array gambar untuk dikonversi ke format PIL.

**Mengembalikan:** `list[PIL.Image.Image]`

Daftar gambar PIL.

Mengonversi gambar numpy atau batch gambar menjadi gambar PIL.

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

```python
numpy_to_pt(images: ndarray)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L172)

**Parameter:**

images (`np.ndarray`) : Array gambar NumPy yang akan dikonversi ke format PyTorch.

**Mengembalikan:** `torch.Tensor`

Representasi tensor PyTorch dari gambar-gambar tersebut.

Mengonversi gambar NumPy menjadi tensor PyTorch.

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

```python
pil_to_numpy(images: list[PIL.Image.Image] | PIL.Image.Image)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L152)

**Parameter:**

images (`PIL.Image.Image` atau `list[PIL.Image.Image]`) : Gambar PIL atau daftar gambar yang akan dikonversi ke format NumPy.

**Mengembalikan:** `np.ndarray`

Representasi array NumPy dari gambar-gambar tersebut.

Mengonversi gambar PIL atau daftar gambar PIL menjadi array NumPy.

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

```python
postprocess(image: Tensor, output_type: str = 'pil', do_denormalize: list[bool] | None = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L739)

**Parameter:**

image (`torch.Tensor`) : Input gambar, harus berupa tensor pytorch dengan bentuk `B x C x H x W`.

output_type (`str`, *opsional*, defaultnya `pil`) : Jenis output gambar, dapat berupa salah satu dari `pil`, `np`, `pt`, `latent`.

do_denormalize (`list[bool]`, *opsional*, defaultnya `None`) : Apakah akan mendenormalisasi gambar ke [0,1]. Jika `None`, akan menggunakan nilai `do_normalize` dalam konfigurasi `VaeImageProcessor`.

**Mengembalikan:** `PIL.Image.Image`, `np.ndarray` atau `torch.Tensor`

Gambar yang telah diproses pascaproses.

Proses pascaproses output gambar dari tensor ke `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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L608)

**Parameter:**

image (`PipelineImageInput`) : Input gambar, format yang diterima adalah gambar PIL, array NumPy, tensor PyTorch; juga menerima daftar format yang didukung.

height (`int`, *opsional*) : Tinggi pada gambar yang telah dipreprocess. Jika `None`, akan menggunakan `get_default_height_width()` untuk mendapatkan tinggi default.

width (`int`, *opsional*) : Lebar dalam praproses. Jika `None`, akan menggunakan get_default_height_width()` untuk mendapatkan lebar default.

resize_mode (`str`, *opsional*, defaultnya `default`) : Mode resize, dapat berupa `default` atau `fill`. Jika `default`, gambar akan di-resize agar muat di dalam lebar dan tinggi yang ditentukan, dan rasio aspek asli mungkin tidak dipertahankan. Jika `fill`, gambar akan di-resize agar muat di dalam lebar dan tinggi yang ditentukan dengan mempertahankan rasio aspek, kemudian gambar diposisikan di tengah dimensi tersebut, mengisi area kosong dengan data dari gambar. Jika `crop`, gambar akan di-resize agar muat di dalam lebar dan tinggi yang ditentukan dengan mempertahankan rasio aspek, kemudian gambar diposisikan di tengah dimensi tersebut, memotong bagian yang berlebih. Perhatikan bahwa resize_mode `fill` dan `crop` hanya didukung untuk input gambar PIL.

crops_coords (`list[tuple[int, int, int, int]]`, *opsional*, defaultnya `None`) : Koordinat pemotongan untuk setiap gambar dalam batch. Jika `None`, gambar tidak akan dipotong.

**Mengembalikan:** `torch.Tensor`

Gambar yang telah dipreprocess.

Praproses input gambar.

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

```python
pt_to_numpy(images: Tensor)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L191)

**Parameter:**

images (`torch.Tensor`) : Tensor PyTorch yang akan dikonversi ke format NumPy.

**Mengembalikan:** `np.ndarray`

Representasi array NumPy dari gambar-gambar tersebut.

Mengonversi tensor PyTorch menjadi gambar 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')
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L463)

**Parameter:**

image (`PIL.Image.Image`, `np.ndarray` atau `torch.Tensor`) : Input gambar, dapat berupa gambar PIL, array numpy atau tensor pytorch.

height (`int`) : Tinggi untuk mengubah ukuran.

width (`int`) : Lebar untuk mengubah ukuran.

resize_mode (`str`, *opsional*, defaultnya `default`) : Mode resize yang akan digunakan, dapat berupa `default` atau `fill`. Jika `default`, gambar akan di-resize agar muat di dalam lebar dan tinggi yang ditentukan, dan rasio aspek asli mungkin tidak dipertahankan. Jika `fill`, gambar akan di-resize agar muat di dalam lebar dan tinggi yang ditentukan dengan mempertahankan rasio aspek, kemudian gambar diposisikan di tengah dimensi tersebut, mengisi area kosong dengan data dari gambar. Jika `crop`, gambar akan di-resize agar muat di dalam lebar dan tinggi yang ditentukan dengan mempertahankan rasio aspek, kemudian gambar diposisikan di tengah dimensi tersebut, memotong bagian yang berlebih. Perhatikan bahwa resize_mode `fill` dan `crop` hanya didukung untuk input gambar PIL.

**Mengembalikan:** `PIL.Image.Image`, `np.ndarray` atau `torch.Tensor`

Gambar yang telah diubah ukurannya.

Ukurkan ulang gambar.

## InpaintProcessor[[diffusers.InpaintProcessor]]

[InpaintProcessor](/docs/diffusers/main/id/api/image_processor#diffusers.InpaintProcessor) menerima input `mask` dan `image` lalu memproses keduanya secara bersama. Secara opsional, ia dapat menerima padding_mask_crop dan menerapkan overlay mask.

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L837)

Pemroses gambar untuk inpainting gambar dan mask.

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L944)

Proses pascaproses gambar, terapkan overlay mask secara opsional

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L882)

Praproses gambar dan mask.

## VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

[VaeImageProcessorLDM3D](/docs/diffusers/main/id/api/image_processor#diffusers.VaeImageProcessorLDM3D) menerima input RGB dan kedalaman serta mengembalikan output RGB dan kedalaman.

#### diffusers.VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L974)

**Parameter:**

do_resize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menurunkan skala dimensi (tinggi, lebar) gambar menjadi kelipatan dari `vae_scale_factor`.

vae_scale_factor (`int`, *opsional*, defaultnya `8`) : Faktor skala VAE. Jika `do_resize` adalah `True`, gambar akan di-resize secara otomatis menjadi kelipatan dari faktor ini.

resample (`str`, *opsional*, defaultnya `lanczos`) : Filter resampling yang digunakan saat mengubah ukuran gambar.

do_normalize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menormalisasi gambar ke [-1,1].

Pemroses gambar untuk 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1025)

**Parameter:**

images (`list[PIL.Image.Image, PIL.Image.Image]`) : Gambar input atau daftar gambar yang akan dikonversi.

**Mengembalikan:** `np.ndarray`

Array NumPy dari gambar yang telah dikonversi.

Mengonversi gambar PIL atau daftar gambar PIL menjadi array NumPy.

#### numpy_to_depth[[diffusers.VaeImageProcessorLDM3D.numpy_to_depth]]

```python
numpy_to_depth(images: ndarray)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1083)

**Parameter:**

images (`np.ndarray`) : Array NumPy input dari gambar kedalaman, yang dapat berupa satu gambar atau batch.

**Mengembalikan:** `list[PIL.Image.Image]`

Daftar gambar PIL yang dikonversi dari gambar kedalaman NumPy input.

Mengonversi gambar kedalaman NumPy atau kumpulan gambar menjadi daftar gambar PIL.

#### numpy_to_pil[[diffusers.VaeImageProcessorLDM3D.numpy_to_pil]]

```python
numpy_to_pil(images: ndarray)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1001)

**Parameter:**

images (`np.ndarray`) : Array NumPy input berisi gambar, yang bisa berupa satu gambar atau batch.

**Mengembalikan:** `list[PIL.Image.Image]`

Daftar gambar PIL yang dikonversi dari array NumPy input.

Mengonversi gambar NumPy atau batch gambar menjadi daftar gambar 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1161)

**Parameter:**

rgb (`torch.Tensor | PIL.Image.Image | np.ndarray`) : Gambar input RGB, yang dapat berupa satu gambar atau batch.

depth (`torch.Tensor | PIL.Image.Image | np.ndarray`) : Gambar input kedalaman, yang dapat berupa satu gambar atau batch.

height (`int | None`, *opsional*, defaultnya `None`) : Tinggi yang diinginkan untuk gambar yang diproses. Jika `None`, defaultnya adalah tinggi gambar input.

width (`int | None`, *opsional*, defaultnya `None`) : Lebar yang diinginkan untuk gambar yang diproses. Jika `None`, defaultnya adalah lebar gambar input.

target_res (`int | None`, *opsional*, defaultnya `None`) : Resolusi target untuk mengubah ukuran gambar. Jika ditentukan, menimpa tinggi dan lebar.

**Mengembalikan:** `tuple[torch.Tensor, torch.Tensor]`

Tuple yang berisi gambar RGB dan kedalaman yang telah diproses sebagai tensor PyTorch.

Praproses input gambar. Format yang diterima adalah gambar PIL, array NumPy, atau tensor PyTorch.

#### rgblike_to_depthmap[[diffusers.VaeImageProcessorLDM3D.rgblike_to_depthmap]]

```python
rgblike_to_depthmap(image: typing.Union[numpy.ndarray, torch.Tensor])
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1045)

Mengonversi gambar kedalaman mirip RGB menjadi peta kedalaman.

## 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1381)

**Parameter:**

do_resize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menurunkan skala dimensi (tinggi, lebar) gambar menjadi kelipatan dari `vae_scale_factor`. Dapat menerima argumen `height` dan `width` dari metode [image_processor.VaeImageProcessor.preprocess()](/docs/diffusers/main/id/api/image_processor#diffusers.VaeImageProcessor.preprocess).

vae_scale_factor (`int`, *opsional*, defaultnya `8`) : Faktor skala VAE. Jika `do_resize` adalah `True`, gambar akan di-resize secara otomatis menjadi kelipatan dari faktor ini.

resample (`str`, *opsional*, defaultnya `lanczos`) : Filter resampling yang digunakan saat mengubah ukuran gambar.

do_normalize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menormalisasi gambar ke [-1,1].

do_binarize (`bool`, *opsional*, defaultnya `False`) : Apakah akan mbinerisasi gambar menjadi 0/1.

do_convert_rgb (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengonversi gambar ke format RGB.

do_convert_grayscale (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengonversi gambar ke format grayscale.

Pemroses gambar untuk pengubahan ukuran dan pemotongan gambar PixArt.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1422)

**Parameter:**

height (`int`) : Tinggi gambar.

width (`int`) : Lebar gambar.

ratios (`dict`) : Kamus di mana kuncinya adalah rasio aspek dan nilainya adalah tuple (tinggi, lebar).

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

Tinggi dan lebar terbin terdekat.

Mengembalikan tinggi dan lebar yang telah dibin berdasarkan rasio aspek.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1440)

**Parameter:**

samples (`torch.Tensor`) : Tensor dengan bentuk (N, C, H, W) di mana N adalah ukuran batch, C adalah jumlah channel, H adalah tinggi, dan W adalah lebar.

new_width (`int`) : Lebar yang diinginkan untuk gambar keluaran.

new_height (`int`) : Tinggi yang diinginkan untuk gambar output.

**Mengembalikan:** `torch.Tensor`

Tensor yang berisi gambar yang telah diubah ukurannya dan dipotong.

Mengubah ukuran dan memotong tensor gambar ke dimensi yang ditentukan.

## 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1277)

**Parameter:**

do_resize (`bool`, *opsional*, defaultnya `True`) : Apakah akan menurunkan skala dimensi (tinggi, lebar) gambar menjadi kelipatan dari `vae_scale_factor`.

vae_scale_factor (`int`, *opsional*, defaultnya `8`) : Faktor skala VAE. Jika `do_resize` adalah `True`, gambar akan di-resize secara otomatis menjadi kelipatan dari faktor ini.

resample (`str`, *opsional*, defaultnya `lanczos`) : Filter resampling yang digunakan saat mengubah ukuran gambar.

do_normalize (`bool`, *opsional*, defaultnya `False`) : Apakah akan menormalisasi gambar ke [-1,1].

do_binarize (`bool`, *opsional*, defaultnya `True`) : Apakah akan mbinerisasi gambar menjadi 0/1.

do_convert_grayscale (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengonversi gambar ke format grayscale.

Pemroses gambar untuk masker gambar IP Adapter.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1318)

**Parameter:**

mask (`torch.Tensor`) : Tensor mask input yang dihasilkan dengan `IPAdapterMaskProcessor.preprocess()`.

batch_size (`int`) : Ukuran batch.

num_queries (`int`) : Jumlah query.

value_embed_dim (`int`) : Dimensi dari value embeddings.

**Mengembalikan:** `torch.Tensor`

Tensor mask yang telah di-downsample.

Menurunkan sampel tensor mask yang diberikan agar sesuai dengan dimensi yang diharapkan untuk scaled dot-product attention. Jika rasio aspek mask tidak cocok dengan rasio aspek gambar keluaran, peringatan akan diterbitkan.