# Bộ xử lý hình ảnh VAE

[VaeImageProcessor](/docs/diffusers/v0.43.0/vi/api/image_processor#diffusers.VaeImageProcessor) cung cấp API thống nhất cho các [StableDiffusionPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) để chuẩn bị đầu vào hình ảnh cho quá trình mã hóa VAE và xử lý hậu kỳ đầu ra sau khi chúng được giải mã. Điều này bao gồm các phép biến đổi như thay đổi kích thước, chuẩn hóa và chuyển đổi giữa mảng PIL Image, PyTorch và NumPy.

Tất cả các pipeline có [VaeImageProcessor](/docs/diffusers/v0.43.0/vi/api/image_processor#diffusers.VaeImageProcessor) đều chấp nhận PIL Image, tensor PyTorch hoặc mảng NumPy làm đầu vào hình ảnh và trả về kết quả dựa trên đối số `output_type` do người dùng cung cấp. Bạn có thể truyền trực tiếp các latent của hình ảnh đã mã hóa vào pipeline và nhận lại latent từ pipeline dưới dạng một đầu ra cụ thể bằng đối số `output_type` (ví dụ `output_type="latent"`). Điều này cho phép bạn lấy các latent được tạo ra từ một pipeline và truyền chúng vào một pipeline khác làm đầu vào mà không cần rời khỏi không gian latent. Nó cũng giúp việc sử dụng nhiều pipeline cùng nhau trở nên dễ dàng hơn rất nhiều bằng cách truyền trực tiếp các tensor PyTorch giữa các pipeline khác nhau.

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

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

**Tham số:**

do_resize (`bool`, *tùy chọn*, mặc định là `True`) : Có nên giảm kích thước (chiều cao, chiều rộng) của ảnh xuống các bội số của `vae_scale_factor` hay không. Có thể nhận các đối số `height` và `width` từ phương thức [image_processor.VaeImageProcessor.preprocess()](/docs/diffusers/v0.43.0/vi/api/image_processor#diffusers.VaeImageProcessor.preprocess).

vae_scale_factor (`int`, *optional*, mặc định là `8`) : Hệ số tỷ lệ của VAE. Nếu `do_resize` là `True`, hình ảnh sẽ được tự động thay đổi kích thước thành bội số của hệ số này.

resample (`str`, *tùy chọn*, mặc định là `lanczos`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh.

do_normalize (`bool`, *tùy chọn*, mặc định là `True`) : Có nên chuẩn hóa hình ảnh về [-1,1] hay không.

do_binarize (`bool`, *tùy chọn*, mặc định là `False`) : Có nhị phân hóa ảnh thành 0/1 hay không.

do_convert_rgb (`bool`, *tùy chọn*, mặc định là `False`) : Có chuyển đổi hình ảnh sang định dạng RGB hay không.

do_convert_grayscale (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có chuyển đổi hình ảnh sang định dạng đen trắng hay không.

Bộ xử lý ảnh cho 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)
```

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

**Tham số:**

mask (`PIL.Image.Image`) : Ảnh mask làm nổi bật các vùng cần phủ chồng lên.

init_image (`PIL.Image.Image`) : Ảnh gốc mà lớp phủ được áp dụng lên.

image (`PIL.Image.Image`) : Ảnh cần phủ lên ảnh gốc.

crop_coords (`tuple[int, int, int, int]`, *optional*) : Tọa độ để cắt ảnh. Nếu được cung cấp, ảnh sẽ được cắt theo đó.

**Trả về:** `PIL.Image.Image`

Hình ảnh cuối cùng sau khi áp dụng lớp phủ.

Áp dụng lớp phủ của mặt nạ và hình ảnh đã được inpaint lên hình ảnh gốc.

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

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

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

**Tham số:**

image (`PIL.Image.Image`) : Đầu vào hình ảnh, phải là một hình ảnh PIL.

**Trả về:** `PIL.Image.Image`

Hình ảnh nhị phân. Các giá trị nhỏ hơn 0.5 được đặt thành 0, các giá trị lớn hơn 0.5 được đặt thành 1.

Tạo một mặt nạ.

#### mờ[[diffusers.VaeImageProcessor.blur]]

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

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

**Tham số:**

image (`PIL.Image.Image`) : Ảnh PIL cần chuyển sang thang xám.

**Trả về:** `PIL.Image.Image`

Hình ảnh PIL đã chuyển sang thang xám.

Áp dụng làm mờ Gaussian lên một hình ảnh.

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

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

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

**Tham số:**

image (`PIL.Image.Image`) : Ảnh đầu vào cần chuyển đổi.

**Trả về:** `PIL.Image.Image`

Hình ảnh đã được chuyển đổi sang thang xám.

Chuyển đổi một hình ảnh PIL cho trước sang thang xám.

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

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

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

**Tham số:**

image (`PIL.Image.Image`) : Ảnh PIL cần chuyển đổi sang RGB.

**Trả về:** `PIL.Image.Image`

Hình ảnh PIL đã chuyển đổi sang RGB.

Chuyển đổi ảnh PIL sang định dạng RGB.

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

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

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

**Tham số:**

images (`np.ndarray` hoặc `torch.Tensor`) : Mảng ảnh cần khử chuẩn hóa.

**Trả về:** `np.ndarray` hoặc `torch.Tensor`

Mảng ảnh đã khử chuẩn hóa.

Chuẩn hóa lại một mảng ảnh về [0,1].

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

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

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

**Tham số:**

mask_image (PIL.Image.Image) : Ảnh mặt nạ.

width (int) : Độ rộng của hình ảnh cần xử lý.

height (int) : Chiều cao của hình ảnh cần xử lý.

pad (int, tùy chọn) : Phần đệm được thêm vào vùng cắt. Mặc định là 0.

**Trả về:** `tuple`

(x1, y1, x2, y2) đại diện cho một vùng hình chữ nhật chứa tất cả các vùng bị che (masked areas) trong một hình ảnh và khớp với tỷ lệ khung hình gốc.

Tìm một vùng hình chữ nhật chứa tất cả các vùng bị che (masked areas) trong ảnh, sau đó mở rộng vùng đó để khớp với tỷ lệ khung hình của ảnh gốc; ví dụ, nếu người dùng vẽ mask trong một vùng 128x32 và kích thước xử lý là 512x512, vùng đó sẽ được mở rộng thành 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L561)

**Tham số:**

image (`PIL.Image.Image | np.ndarray | torch.Tensor`) : Đầu vào hình ảnh, có thể là hình ảnh PIL, mảng NumPy hoặc tensor PyTorch. Nếu là mảng NumPy, nó phải có hình dạng `[batch, height, width]` hoặc `[batch, height, width, channels]`. Nếu là tensor PyTorch, nó phải có hình dạng `[batch, channels, height, width]`.

height (`int | None`, *tùy chọn*, mặc định là `None`) : Chiều cao của hình ảnh đã được tiền xử lý. Nếu là `None`, chiều cao của đầu vào `image` sẽ được sử dụng.

width (`int | None`, *tùy chọn*, mặc định là `None`) : Độ rộng của hình ảnh đã được tiền xử lý. Nếu là `None`, độ rộng của đầu vào `image` sẽ được sử dụng.

**Trả về:** `tuple[int, int]`

Một tuple chứa chiều cao và chiều rộng, cả hai đều được điều chỉnh kích thước đến bội số nguyên gần nhất của `vae_scale_factor`.

Trả về chiều cao và chiều rộng của hình ảnh, được thu nhỏ xuống bội số nguyên gần nhất của `vae_scale_factor`.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L207)

**Tham số:**

images (`np.ndarray` hoặc `torch.Tensor`) : Mảng ảnh cần chuẩn hóa.

**Trả về:** `np.ndarray` hoặc `torch.Tensor`

Mảng ảnh đã được chuẩn hóa.

Chuẩn hóa một mảng ảnh về khoảng [-1,1].

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L128)

**Tham số:**

images (`np.ndarray`) : Mảng ảnh cần chuyển đổi sang định dạng PIL.

**Trả về:** `list[PIL.Image.Image]`

Danh sách các hình ảnh PIL.

Chuyển đổi một ảnh numpy hoặc một lô ảnh thành ảnh PIL.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L172)

**Tham số:**

images (`np.ndarray`) : Mảng ảnh NumPy cần chuyển sang định dạng PyTorch.

**Trả về:** `torch.Tensor`

Đại diện tensor PyTorch của các hình ảnh.

Chuyển đổi một hình ảnh NumPy thành tensor PyTorch.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L152)

**Tham số:**

images (`PIL.Image.Image` hoặc `list[PIL.Image.Image]`) : Ảnh PIL hoặc danh sách ảnh cần chuyển đổi sang định dạng NumPy.

**Trả về:** `np.ndarray`

Đại diện mảng NumPy của các hình ảnh.

Chuyển đổi một hình ảnh PIL hoặc danh sách các hình ảnh PIL thành các mảng NumPy.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L739)

**Tham số:**

image (`torch.Tensor`) : Đầu vào hình ảnh, phải là một tensor pytorch có hình dạng `B x C x H x W`.

output_type (`str`, *tùy chọn*, mặc định là `pil`) : Kiểu đầu ra của hình ảnh, có thể là một trong `pil`, `np`, `pt`, `latent`.

do_denormalize (`list[bool]`, *tùy chọn*, mặc định là `None`) : Có nên khử chuẩn hóa ảnh về [0,1] hay không. Nếu là `None`, sẽ sử dụng giá trị của `do_normalize` trong cấu hình `VaeImageProcessor`.

**Trả về:** `PIL.Image.Image`, `np.ndarray` hoặc `torch.Tensor`

Hình ảnh sau khi xử lý hậu kỳ.

Xử lý hậu xử lý ảnh đầu ra từ tensor sang `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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L608)

**Tham số:**

image (`PipelineImageInput`) : Đầu vào hình ảnh, các định dạng được chấp nhận là hình ảnh PIL, mảng NumPy, tensor PyTorch; Cũng chấp nhận danh sách các định dạng được hỗ trợ.

height (`int`, *optional*) : Chiều cao của ảnh đã tiền xử lý. Nếu là `None`, sẽ sử dụng `get_default_height_width()` để lấy chiều cao mặc định.

width (`int`, *optional*) : Độ rộng trong dữ liệu đã tiền xử lý. Nếu là `None`, sẽ sử dụng get_default_height_width()` để lấy độ rộng mặc định.

resize_mode (`str`, *tùy chọn*, mặc định là `default`) : Chế độ thay đổi kích thước, có thể là `default` hoặc `fill`. Nếu là `default`, sẽ thay đổi kích thước ảnh để vừa với chiều rộng và chiều cao được chỉ định, và có thể không giữ nguyên tỷ lệ khung hình gốc. Nếu là `fill`, sẽ thay đổi kích thước ảnh để vừa với chiều rộng và chiều cao được chỉ định, giữ nguyên tỷ lệ khung hình, sau đó căn giữa ảnh trong các kích thước đó, lấp đầy phần trống bằng dữ liệu từ ảnh. Nếu là `crop`, sẽ thay đổi kích thước ảnh để vừa với chiều rộng và chiều cao được chỉ định, giữ nguyên tỷ lệ khung hình, sau đó căn giữa ảnh trong các kích thước đó, cắt bỏ phần thừa. Lưu ý rằng resize_mode `fill` và `crop` chỉ được hỗ trợ cho đầu vào ảnh PIL.

crops_coords (`list[tuple[int, int, int, int]]`, *tùy chọn*, mặc định là `None`) : Tọa độ cắt cho từng hình ảnh trong lô. Nếu là `None`, sẽ không cắt hình ảnh.

**Trả về:** `torch.Tensor`

Hình ảnh đã được tiền xử lý.

Tiền xử lý đầu vào hình ảnh.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L191)

**Tham số:**

images (`torch.Tensor`) : Tensor PyTorch cần chuyển đổi sang định dạng NumPy.

**Trả về:** `np.ndarray`

Đại diện mảng NumPy của các hình ảnh.

Chuyển đổi một tensor PyTorch thành một ảnh 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')
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L463)

**Tham số:**

image (`PIL.Image.Image`, `np.ndarray` hoặc `torch.Tensor`) : Đầu vào hình ảnh, có thể là hình ảnh PIL, mảng numpy hoặc tensor pytorch.

height (`int`) : Chiều cao cần điều chỉnh kích thước.

width (`int`) : Độ rộng để thay đổi kích thước.

resize_mode (`str`, *tùy chọn*, mặc định là `default`) : Chế độ resize cần sử dụng, có thể là `default` hoặc `fill`. Nếu là `default`, hình ảnh sẽ được resize để vừa với chiều rộng và chiều cao đã chỉ định, và có thể không giữ nguyên tỷ lệ khung hình gốc. Nếu là `fill`, hình ảnh sẽ được resize để vừa với chiều rộng và chiều cao đã chỉ định, giữ nguyên tỷ lệ khung hình, sau đó căn giữa hình ảnh trong các kích thước đó, lấp đầy phần trống bằng dữ liệu từ hình ảnh. Nếu là `crop`, hình ảnh sẽ được resize để vừa với chiều rộng và chiều cao đã chỉ định, giữ nguyên tỷ lệ khung hình, sau đó căn giữa hình ảnh trong các kích thước đó, cắt bỏ phần thừa. Lưu ý rằng resize_mode `fill` và `crop` chỉ được hỗ trợ cho đầu vào hình ảnh PIL.

**Trả về:** `PIL.Image.Image`, `np.ndarray` hoặc `torch.Tensor`

Hình ảnh đã được thay đổi kích thước.

Đổi kích thước ảnh.

## InpaintProcessor[[diffusers.InpaintProcessor]]

[InpaintProcessor](/docs/diffusers/v0.43.0/vi/api/image_processor#diffusers.InpaintProcessor) nhận các đầu vào `mask` và `image` và xử lý chúng cùng nhau. Tùy chọn, nó có thể nhận padding_mask_crop và áp dụng lớp phủ 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L837)

Bộ xử lý ảnh cho việc inpainting ảnh và 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L944)

Xử lý hậu kỳ hình ảnh, tùy chọn áp dụng lớp phủ mặt nạ

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L882)

Tiền xử lý ảnh và mặt nạ.

## VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

[VaeImageProcessorLDM3D](/docs/diffusers/v0.43.0/vi/api/image_processor#diffusers.VaeImageProcessorLDM3D) nhận đầu vào RGB và độ sâu, sau đó trả về đầu ra RGB và độ sâu.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L974)

**Tham số:**

do_resize (`bool`, *tùy chọn*, mặc định là `True`) : Có nên giảm kích thước (chiều cao, chiều rộng) của ảnh xuống các bội số của `vae_scale_factor` hay không.

vae_scale_factor (`int`, *optional*, mặc định là `8`) : Hệ số tỷ lệ của VAE. Nếu `do_resize` là `True`, hình ảnh sẽ được tự động thay đổi kích thước thành bội số của hệ số này.

resample (`str`, *tùy chọn*, mặc định là `lanczos`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh.

do_normalize (`bool`, *tùy chọn*, mặc định là `True`) : Có nên chuẩn hóa hình ảnh về [-1,1] hay không.

Bộ xử lý ảnh cho 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1025)

**Tham số:**

images (`list[PIL.Image.Image, PIL.Image.Image]`) : Ảnh đầu vào hoặc danh sách các ảnh cần được chuyển đổi.

**Trả về:** `np.ndarray`

Một mảng NumPy của các hình ảnh đã được chuyển đổi.

Chuyển đổi một hình ảnh PIL hoặc danh sách các hình ảnh PIL thành các mảng NumPy.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1083)

**Tham số:**

images (`np.ndarray`) : Mảng NumPy đầu vào chứa các ảnh độ sâu, có thể là một ảnh đơn lẻ hoặc một lô (batch).

**Trả về:** `list[PIL.Image.Image]`

Một danh sách các hình ảnh PIL được chuyển đổi từ các hình ảnh độ sâu NumPy đầu vào.

Chuyển đổi một ảnh độ sâu NumPy hoặc một lô ảnh thành một danh sách ảnh PIL.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1001)

**Tham số:**

images (`np.ndarray`) : Mảng NumPy đầu vào chứa các hình ảnh, có thể là một hình ảnh đơn lẻ hoặc một lô (batch).

**Trả về:** `list[PIL.Image.Image]`

Danh sách các hình ảnh PIL được chuyển đổi từ mảng NumPy đầu vào.

Chuyển đổi một ảnh NumPy hoặc một lô ảnh thành một danh sách ảnh 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1161)

**Tham số:**

rgb (`torch.Tensor | PIL.Image.Image | np.ndarray`) : Ảnh đầu vào RGB, có thể là một ảnh đơn lẻ hoặc một lô (batch).

depth (`torch.Tensor | PIL.Image.Image | np.ndarray`) : Ảnh đầu vào độ sâu, có thể là một ảnh đơn hoặc một lô (batch).

height (`int | None`, *tùy chọn*, mặc định là `None`) : Chiều cao mong muốn của hình ảnh đã xử lý. Nếu là `None`, mặc định sẽ là chiều cao của hình ảnh đầu vào.

width (`int | None`, *tùy chọn*, mặc định là `None`) : Độ rộng mong muốn của hình ảnh đã xử lý. Nếu là `None`, mặc định sẽ là độ rộng của hình ảnh đầu vào.

target_res (`int | None`, *tùy chọn*, mặc định là `None`) : Độ phân giải đích để thay đổi kích thước ảnh. Nếu được chỉ định, sẽ ghi đè lên chiều cao và chiều rộng.

**Trả về:** `tuple[torch.Tensor, torch.Tensor]`

Một tuple chứa các hình ảnh RGB và độ sâu đã được xử lý dưới dạng tensor PyTorch.

Tiền xử lý đầu vào hình ảnh. Các định dạng được chấp nhận là hình ảnh PIL, mảng NumPy hoặc tensor PyTorch.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1045)

Chuyển đổi ảnh độ sâu dạng RGB thành bản đồ độ sâu.

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/image_processor.py#L1381)

**Tham số:**

do_resize (`bool`, *tùy chọn*, mặc định là `True`) : Có nên giảm kích thước (chiều cao, chiều rộng) của ảnh xuống các bội số của `vae_scale_factor` hay không. Có thể nhận các đối số `height` và `width` từ phương thức [image_processor.VaeImageProcessor.preprocess()](/docs/diffusers/v0.43.0/vi/api/image_processor#diffusers.VaeImageProcessor.preprocess).

vae_scale_factor (`int`, *optional*, mặc định là `8`) : Hệ số tỷ lệ của VAE. Nếu `do_resize` là `True`, hình ảnh sẽ được tự động thay đổi kích thước thành bội số của hệ số này.

resample (`str`, *tùy chọn*, mặc định là `lanczos`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh.

do_normalize (`bool`, *tùy chọn*, mặc định là `True`) : Có nên chuẩn hóa hình ảnh về [-1,1] hay không.

do_binarize (`bool`, *tùy chọn*, mặc định là `False`) : Có nhị phân hóa ảnh thành 0/1 hay không.

do_convert_rgb (`bool`, *tùy chọn*, mặc định là `False`) : Có chuyển đổi hình ảnh sang định dạng RGB hay không.

do_convert_grayscale (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có chuyển đổi hình ảnh sang định dạng đen trắng hay không.

Bộ xử lý ảnh để thay đổi kích thước và cắt ảnh PixArt.

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

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

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

**Tham số:**

height (`int`) : Chiều cao của hình ảnh.

width (`int`) : Độ rộng của hình ảnh.

ratios (`dict`) : Một từ điển trong đó các khóa là tỷ lệ khung hình và các giá trị là các bộ ba (chiều cao, chiều rộng).

**Trả về:** `tuple[int, int]`

Chiều cao và chiều rộng được phân loại gần nhất.

Trả về chiều cao và chiều rộng đã được phân loại dựa trên tỷ lệ khung hình.

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

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

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

**Tham số:**

samples (`torch.Tensor`) : Một tensor có hình dạng (N, C, H, W) trong đó N là kích thước lô (batch size), C là số kênh, H là chiều cao và W là chiều rộng.

new_width (`int`) : Độ rộng mong muốn của các hình ảnh đầu ra.

new_height (`int`) : Chiều cao mong muốn của các hình ảnh đầu ra.

**Trả về:** `torch.Tensor`

Một tensor chứa các hình ảnh đã được thay đổi kích thước và cắt.

Đổi kích thước và cắt một tensor ảnh thành các kích thước được chỉ định.

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

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

**Tham số:**

do_resize (`bool`, *tùy chọn*, mặc định là `True`) : Có nên giảm kích thước (chiều cao, chiều rộng) của ảnh xuống các bội số của `vae_scale_factor` hay không.

vae_scale_factor (`int`, *optional*, mặc định là `8`) : Hệ số tỷ lệ của VAE. Nếu `do_resize` là `True`, hình ảnh sẽ được tự động thay đổi kích thước thành bội số của hệ số này.

resample (`str`, *tùy chọn*, mặc định là `lanczos`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh.

do_normalize (`bool`, *tùy chọn*, mặc định là `False`) : Có nên chuẩn hóa hình ảnh về [-1,1] hay không.

do_binarize (`bool`, *tùy chọn*, mặc định là `True`) : Xác định có nhị phân hóa ảnh thành 0/1 hay không.

do_convert_grayscale (`bool`, *tùy chọn*, mặc định là `True`) : Xác định có chuyển đổi hình ảnh sang định dạng đen trắng hay không.

Bộ xử lý ảnh cho mặt nạ ảnh IP Adapter.

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

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

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

**Tham số:**

mask (`torch.Tensor`) : Tensor mặt nạ đầu vào được tạo bằng `IPAdapterMaskProcessor.preprocess()`.

batch_size (`int`) : Kích thước lô (batch size).

num_queries (`int`) : Số lượng truy vấn.

value_embed_dim (`int`) : Độ cao của các vector nhúng giá trị.

**Trả về:** `torch.Tensor`

Tensor mặt nạ đã được giảm mẫu.

Thực hiện giảm mẫu (downsample) tensor mask được cung cấp để khớp với các kích thước mong đợi cho scaled dot-product attention. Nếu tỷ lệ khung hình (aspect ratio) của mask không khớp với tỷ lệ khung hình của ảnh đầu ra, một cảnh báo sẽ được phát ra.