>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> center_crop = transform.CenterCrop(16)
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> center_crop(img).size
(16, 16)
class jittor.transform.ColorJitter(brightness=0, contrast=0, saturation=0, hue=0)[源代码]
随机改变图像的亮度、对比度、饱和度和色调。该类用于对图像进行随机的颜色变换，以进行数据增强。这些变换包括亮度、对比度、饱和度和色调的调整。
brightness (float, tuple(min, max)): 要改变的亮度范围。亮度因子从 \([\max(0, 1 - brightness), 1 + brightness]\) 或给定的 \([min, max]\) 中均匀选择。应为非负数。默认值为 0，表示不改变亮度。
contrast (float,  tuple(min, max)): 要改变的对比度范围。对比度因子从 \([\max(0, 1 - contrast), 1 + contrast]\) 或给定的 \([min, max]\) 中均匀选择。应为非负数。默认值为 0，表示不改变对比度。
saturation (float,  tuple(min, max)): 要改变的饱和度范围。饱和度因子从 \([\max(0, 1 - saturation), 1 + saturation]\) 或给定的 \([min, max]\) 中均匀选择。应为非负数。默认值为 0，表示不改变饱和度。
hue (float,  tuple(min, max)): 要改变的色调范围。色调因子从 \([-hue, hue]\) 或给定的 \([min, max]\) 中均匀选择。应满足 \(0\leq hue\leq 0.5\) 或 \(-0.5 \leq min \leq max \leq 0.5\)。默认值为 0，表示不改变色调。
代码示例:
>>> from jittor.transform import ColorJitter
>>> from PIL import Image
>>> img = Image.open('''path_to_image.jpg''')
>>> transform = ColorJitter(brightness=0.2, contrast=0.3, saturation=0.4, hue=0.1)
>>> img_transformed = transform(img)
class jittor.transform.Compose(transforms)[源代码]
将多个图像变换组合在一起的类。该类将输入的变换列表依次应用到输入数据上。如果输入数据为单个对象，会依次通过每个变换；如果输入为多个对象（例如图像和对应标签），则每个变换都会接收相同的参数列表，并依次处理。
transforms (list): 需要组合的变换列表。
代码示例:
>>> from jittor import transform
>>> compose = transform.Compose([
    transform.Resize(224),
    transform.Gray(),
    transform.ImageNormalize(mean=[0.5], std=[0.5]),
>>> img_ = compose(img)
class jittor.transform.Crop(top, left, height, width)[源代码]
根据指定大小裁剪PIL图像。在初始化时需要指定裁剪区域的边界，之后可以作为一个可调用对象直接应用在图像上。
top (int): 裁剪区域顶部边界的像素索引
left (int): 裁剪区域左侧边界的像素索引
height (int): 裁剪区域高度
width (int): 裁剪区域宽度
代码示例:
>>> from jittor import transform
>>> cropper = transform.Crop(top=100, left=100, height=200, width=200)
>>> cropped_img = cropper(img)
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> five_crop = transform.FiveCrop(16)
>>> imgs = five_crop(img)
>>> imgs[0].size, imgs[1].size, imgs[2].size, imgs[3].size, imgs[4].size
((16, 16), (16, 16), (16, 16), (16, 16), (16, 16))
class jittor.transform.ImageNormalize(mean, std)[源代码]
对图像进行标准化处理的类。给定n个通道的均值(mean[1], …, mean[n])和标准差(std[1], .., std[n])，此转换将标准化输入张量的每个通道，即：
\[output[channel] = (input[channel] - mean[channel]) / std[channel]\]




    

mean(list): 标准化使用的平均值列表
std(list): 标准化使用的标准差列表
代码示例:
>>> from jittor import transform
>>> img_normalize = transform.ImageNormalize(mean=[0.5], std=[0.5])
>>> img_ = img_normalize(img)
代码示例:
>>> from jittor import transform
>>> lambda = transform.Lambda(lambda x: x + 10)
>>> result = lambda(5)
class jittor.transform.RandomAffine(degrees, translate=None, scale=None, shear=None, resample=False, fillcolor=0)[源代码]
随机仿射变换，输入保持中心不变。
degrees (序列或int) : 可供选择的度数范围。如果度数是数字而不是序列(min, max) ，则度数范围将为 (-degrees, +degrees)。
translate (元组, 可选): 例如 translate=(a, b)，那么水平平移将在 img_width * a < dx < img_width * a 的范围内随机采样，垂直平移将在 -img_height * b < dy < img_height * b 的范围内随机采样。默认情况下不进行平移。默认值: None
scale (元组, 可选): 缩放因子区间，例如 (a, b)，则缩放比例在 a <= scale <= b 的范围内随机采样。默认值: None
shear (序列, float或int, 可选): 从中选取剪切角度的范围。 如果 shear 是一个数字，则将应用范围是 (-shear, +shear) 并且平行于 x 轴的剪切;若是一个元组或列表且包含2个值，则应用范围是 (shear[0], shear[1]) 并且平行于 x 轴的剪切; 若是一个元组或列表且包含4个值，则应用 x 轴剪切范围 (shear[0], shear[1]) 以及y 轴剪切范围 (shear[2], shear[3])。默认情况下不应用剪切。默认值: None
resample ({PIL.Image.NEAREST, PIL.Image.BILINEAR, PIL.Image.BICUBIC}, 可选): 可选的重采样滤波器。请参阅 这里 以获取更多信息。默认值: False
fillcolor (元组或int, 可选): 对输出图像中变换区域外的区域填充的颜色（RGB 图像用元组表示，灰度图像用整数表示）。默认值: 0
代码示例:
>>> from jittor import transform
>>> random_affine = transform.RandomAffine(degrees=45)
>>> img_ = random_affine(img)
代码示例:
>>> from jittor import transform
>>> transform_list = [transform.RandomHorizontalFlip(), transform.RandomCrop(size=(32, 32))] 
>>> random_apply = transform.RandomApply(transform_list, p=0.5)
>>> img_= random_apply(img)
代码示例:
>>> from jittor import transform
>>> transform_list = [transform.RandomHorizontalFlip(), transform.RandomCrop(size=(32, 32))] 
>>> random_choice = transform.RandomChoice(transform_list)
>>> img_ = random_choice(img)
size (tuple, int): 欲裁剪的目标大小。如果是int，将裁剪出一个正方形；如果是tuple，则按照(tuple_height, tuple_width)的形式给出。




    

代码示例:
>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> random_crop = transform.RandomCrop(128)
>>> random_crop(img).size
(128, 128)
class jittor.transform.RandomCropAndResize(size, scale: tuple = (0.08, 1.0), ratio: tuple = (0.75, 1.3333333333333333), interpolation=2)[源代码]
对给定的PIL图像进行随机裁剪和尺寸调整。
size (int, tuple): 输出图像的[高度,宽度]
scale (tuple): 裁剪区域的面积比例范围。默认值: (0.08, 1.0)
ratio (tuple): 裁剪图像的长宽比范围。默认值: (3.0/4.0, 4.0/3.0)
interpolation (InterpolationMode): 图像大小调整时采用的插值类型。默认使用双线性插值。默认值: PIL.Image.BILINEAR
代码示例:
>>> from jittor import transform
>>> import numpy as np  
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> transform = transform.RandomCropAndResize(128)
>>> transform(img).size
(133, 128)
class jittor.transform.RandomGray(p=0.1)[源代码]
随机将图片转换为灰度图。该类用于以给定的概率p随机将输入图像转换为灰度图像，转换后的图像可能保持不变或则转换为灰度图，这取决于一个随机事件。输出灰度图与输入图的通道数保持一致。
p (float): 图像被转换为灰度图的概率。默认值: 0.1
代码示例:   
>>> from jittor import transform
>>> random_gray = transform.RandomGray()
>>> img_ = random_gray(img)
class jittor.transform.RandomHorizontalFlip(p=0.5)[源代码]
对图像进行随机水平翻转的变换类，以一定的概率水平翻转输入的图像。
p (float): 图像翻转的概率。默认值为0.5。
代码示例:
>>> from jittor import transform
>>> random_hflip = transform.RandomHorizontalFlip(0.6)
>>> img_ = random_hflip(img)
代码示例:
>>> from jittor import transform
>>> transform_list = [transform.RandomHorizontalFlip(), transform.RandomCrop(size=(32, 32))] 
>>> random_order = transform.RandomOrder(transform_list)
>>> img_ = random_order(img)
class jittor.transform.RandomPerspective(distortion_scale=0.5, p=0.5, interpolation=3)[源代码]
对图像以一定的概率进行随机透视变换。
distortion_scale(float, 可选): 控制变形程度的比例系数，值域为 [0, 1]。默认值: 0.5
p (float, 可选): 图片被透视变换的概率。默认值: 0.5
interpolation (PIL.Image.Interpolation method, 可选): 插值方法。默认值: PIL.Image.BICUBIC
代码示例:
>>> from jittor import transform
>>> random_perspective = transform.RandomPerspective(distortion_scale=0.5, p=0.5)
>>> img_ = random_perspective(img)
class jittor.transform.RandomResizedCrop(size, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=2)[源代码]
对给定的PIL图像执行随机尺寸与宽高比的裁剪并将其调整为给定大小。
同 jittor.transform.RandomSizedCrop
size (int, tuple[int]): 裁剪后每边的期望输出尺寸。若为单一整数，输出将是正方形；若为(int, int)元组，则输出为指定的宽高。
scale (tuple[float], 可选): 原始尺寸裁剪范围。默认值: (0.08, 1.0)。
ratio (tuple[float], 可选): 原始宽高比裁剪范围。默认值: (3/4, 4/3)。
interpolation (PIL.Image.Interpolation method, 可选): 图像插值方法。默认值: PIL.Image.BILINEAR
代码示例:
>>> from jittor import transform
>>> random_resized_crop = transform.RandomResizedCrop(size=(224, 224))
>>> img_ = random_resized_crop(img)
class jittor.transform.RandomRotation(degrees, resample=False, expand=False, center=None, fill=None)[源代码]
对图像进行随机旋转。
degrees (sequence, float, int): 选择的角度范围，如果degrees是一个数字而不是像(min, max)这样的序列，角度的范围将为(-degrees, +degrees)。
resample ({PIL.Image.NEAREST, PIL.Image.BILINEAR, PIL.Image.BICUBIC}, 可选):可选的重采样滤波器。请参阅 链接 以获取更多信息。如果省略或图像的模式为1或P，则设置为 PIL.Image.NEAREST 。默认值: False
expand (bool, 可选): 可选的扩展标志。若为真，则扩展输出以使其足够大以容纳整个旋转后的图像；为假或省略，则使输出图像与输入图像的尺寸相同。请注意，扩展标志假定围绕中心旋转且不进行平移。默认值: False
center (2-tuple, 可选): 可选的旋转中心，原点是左上角。默认值: 图像的中心。默认值: None
fill (n-tuple, int, float, 可选): 旋转后图像之外区域的像素填充值。如果是整数或浮点数，分别用于所有通道。默认情况下，所有通道的值都为0。此选项仅在`pillow>=5.2.0`版本中可用。默认值: None
代码示例:
>>> from jittor import transform
>>> random_rotation = transform.RandomRotation(degrees=45)
>>> rotated_image = random_rotation(input_image)
class jittor.transform.RandomVerticalFlip(p=0.5)[源代码]
随机垂直翻转图像的类。该类以一定概率沿垂直方向翻转给定的图像。这是数据增强过程中的一个常用技术，旨在提高模型对图像方向变化的鲁棒性。
p (float, 可选): 图像翻转的概率。默认值:  0.5。
代码示例：
>>> from jittor.transform import RandomVerticalFlip
>>> from PIL import Image
>>> random_vflip = RandomVerticalFlip(0.6)
>>> img = Image.open('path/to/image.jpg')
>>> img_transformed = random_vflip(img)
class jittor.transform.TenCrop(size, vertical_flip=False)[源代码]
将给定图像裁剪成四个角落和中心部分，以及这些部分的翻转版本（默认为水平翻转，可选择垂直翻转），共十张图片。
size (sequence, int): 裁剪的期望输出大小。如果size是一个整数而不是像(h, w)这样的序列，会进行一个(size, size)的正方形裁剪
vertical_flip (bool, 可选): 若为True，则使用垂直翻转。否则使用水平翻转。默认值: False
代码示例:
>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> ten_crop = transform.TenCrop(16)
>>> imgs = ten_crop(img)
>>> imgs[0].size, imgs[1].size, imgs[2].size, imgs[8].size, imgs[9].size 
((16, 16), (16, 16), (16, 16), (16, 16), (16, 16))
class jittor.transform.ToPILImage(mode=None)[源代码]
将张量或ndarray转换为PIL图像。该类将一个C x H x W 的张量或者一个H x W x C 型的numpy ndarray转换成 PIL Image ，同时根据mode调整value的范围。
初始化参数:

mode (PIL.Image mode , 可选): PIL图像模式，指定输入数据的颜色空间和像素深度。支持的模式参见PIL文档中 关于图像模式的介绍 。默认值: None
执行参数:

pic (Var, numpy.ndarray): 将被转换成PIL image 的 HWC 格式的 image。
代码示例:
>>> from jittor import transform
>>> transform = transform.ToPILImage('RGB')
>>> img_ = transform(img_var)
class jittor.transform.ToTensor[源代码]
将 PIL Image 或 numpy.ndarray 格式的图像转换为 Tensor。
ToTensor 类的实例是一个可调用对象，它可以将 PIL 库中的图像或者 numpy.ndarray 类型的数组转换为 Jittor 的 Tensor 格式。此操作通常用于数据预处理阶段。转换后的 Tensor 数据格式为 C x H x W，并且数据范围被归一化到 [0, 1]。
pic (PIL.Image, numpy.ndarray): 需要转换为 Tensor 的图像对象。如果是 PIL 图像，则应为 L, LA, RGB, RGBA, P, PA, I, I;16, I;16L, I;16B, I;16P, F 等模式之一。如果是 numpy.ndarray，则应为形状为 H x W x C，数据类型为 np.uint8 的数组。
Var: 转换后的 Tensor，形状为 C x H x W，范围 [0.0, 1.0]。
代码示例：
>>> from jittor import transform
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')
>>> to_tensor = transform.ToTensor()
>>> tensor = to_tensor(img)
>>> print(tensor.dtype, tensor.shape)
float32 (3, 200, 200)
img (PIL.Image.Image): 输入图像
brightness_factor (float): 调整亮度的程度。可以为任何非负数。0会得到一个黑色的图像，1会得到原始图像，2则会将亮度提高一倍
返回值:
PIL.Image.Image: 亮度调整后的图像
代码示例：
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> img.show() # RGB噪声图
>>> img_black = jt.transform.adjust_brightness(img, 0) 
>>> img_black.show() # 亮度调整为0，即全黑图
img (Image.Image): 需要调整的图像。
contrast_factor (float): 调整对比度的程度。可以是任意非负数。0 会将图像转换为纯灰色，1 保持原图，2 增加两倍对比度。
返回值:
返回调整对比度后的图像。
代码示例:
>>> import numpy as np
>>> from PIL import Image
>>> from jittor import transform
>>> img = np.ones((100, 100, 3)).astype(np.uint8)
>>> img = Image.fromarray(img)
>>> img_adjusted = transform.adjust_contrast(img, 0.5)
jittor.transform.adjust_gamma(img, gamma, gain=1)[源代码]
图像的伽玛校正，也被称为幂律转换。更多详细信息，请参见 WIKI。基于以下公式对RGB模式的强度进行调整：
\[I_{\text{out}} = 255 \times \text{gain} \times (\frac{I_{\text{in}}}{255})^{\gamma}\]




    

img (PIL.Image.Image): 输入图像
gamma (float): 非负实数，即上述公式中的 \(\gamma\) 。 gamma大于1使阴影变暗，gamma小于1使暗区变亮。
gain (float, optional): 常数乘数，默认值: 1
返回值:
PIL.Image.Image: 伽马校正后的图像
代码示例：
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> img.show() # RGB噪声图
>>> jt.transform.adjust_gamma(img, 0.2).show() # 暗区变亮
jittor.transform.adjust_hue(img, hue_factor)[源代码]
调整图像的色调。先将图像转换为HSV空间，并在色调通道（H）中循环移动强度来调整的；然后，再转换回原始图像模式。 hue_factor 是H通道中的移动量，必须在`[-0.5，0.5]`内。更多详细信息，请参见 Hue




    

img (PIL.Image.Image): 输入图像
hue_factor (float): 色调通道移动量。取值应在[-0.5, 0.5]之间。0.5和-0.5分别在HSV空间中以正和负方向给出色调通道的完全反转。0表示无移动。因此，-0.5和0.5都会给出具有互补色的图像，而0则给出原始图像。
返回值:
PIL.Image.Image: 色调调整后的图像
代码示例：
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> img.show() # RGB噪声图
>>> img_complementary = jt.transform.adjust_hue(img, 0.5) 
>>> img_complementary.show() # 色调反转，即互补色图
img (PIL.Image.Image): 输入图像
saturation_factor (float): 调整饱和度的程度。0将产生黑白图像，1将给出原始图像，2将增强2倍的饱和度
返回值:
PIL.Image.Image: 饱和度调整后的图像
代码示例：
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> img.show() # RGB噪声图
>>> img_blackwhite = jt.transform.adjust_saturation(img, 0) 
>>> img_blackwhite.show() # 饱和度调整为0，即黑白图
img (PIL.Image.Image): 输入图像
output_size (int, list) ：裁剪框的（高度、宽度）。如果为整数或只有单个整数的序列，则高度和宽度都使用该整数
返回值:
PIL.Image.Image: 裁剪后的图像
代码示例：
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200)
>>> img = Image.fromarray(data, 'L')       
>>> img.size
(200, 200)
>>> jt.transform.center_crop(img, 100).size 
(100, 100) 
jittor.transform.crop(img, top, left, height, width)[源代码]
对图像进行裁剪，根据给定的边界参数从原始图像中裁剪出一个矩形区域。
img (Image.Image): 输入的 PIL 图像。
top (int): 裁剪框的上边界。
left (int): 裁剪框的左边界。
height (int): 裁剪框的高度。
width (int): 裁剪框的宽度。
返回裁剪后的图像。
代码示例:
>>> img = np.ones((100, 100, 3)).astype(np.uint8)
>>> img = Image.fromarray(img)
>>> img_cropped = crop(img, 10, 10, 100, 100)
jittor.transform.crop_and_resize(img, top, left, height, width, size, interpolation=2)[源代码]
裁剪后调整图像大小。
img (PIL.Image.Image): 输入图像
top (int): 裁剪框的顶部边界
left (int): 裁剪框的左边界
height (int): 裁剪框的高度
width (int): 裁剪框的宽度
size (list)：裁剪之后图像要调整到的（高度, 宽度）
interpolation (int, optional): 调整大小所用的插值方法。默认值: PIL.Image.BILINEAR
返回值:
PIL.Image.Image: 裁剪并且调整大小之后的图像
代码示例：
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200)
>>> img = Image.fromarray(data, 'L')       
>>> img.size
(200, 200)
>>> # 截取坐标为[10,90]x[10,90]的正方形并且缩小0.5倍
>>> jt.transform.crop_and_resize(img, 10, 10, 80, 80, [40, 40]).size 
(40, 40)
jittor.transform.gray(img, num_output_channels)[源代码]
将任意模式（如 RGB、HSV、LAB 等）的 PIL 图片转换为灰度版本。该函数支持将灰度图像转换为单通道或三通道图像。
img (PIL.Image.Image): 输入的 PIL 图片。
num_output_channels (int, 可选): 输出图片的通道数。值可以为 1 或 3。默认值:  1。
返回图片的灰度版本。如果 num_output_channels 为 1，返回单通道图像；如果为 3，返回三通道图像，其中 R、G、B 值相同。
代码示例:
>>> import numpy as np
>>> from PIL import Image
>>> from jittor.transform import gray
>>> img = np.ones((100, 100, 3)).astype(np.uint8)
>>> img = Image.fromarray(img)
>>> img_gray_1_channel = gray(img, 1)
>>> print(np.array(img_gray_1_channel).shape)
(100, 100)
>>> img_gray_3_channel = gray(img, 3)
>>> print(np.array(img_gray_3_channel).shape)
(100, 100, 3)
>>> from PIL import Image
>>> data = np.random.rand(200,200)
>>> img = Image.fromarray(data, 'L')       
>>> img.size
(200, 200)
>>> img_flipped = jt.transform.hflip(img) # 水平翻转
img (PIL Image.Image, jt.Var, np.ndarray): 输入的图像。如果输入的图像类型是 np.ndarray，则它应该具有形状 (C, H, W)
mean (list): 归一化的平均值
std (list): 归一化的标准差值
返回值:
归一化后的图像
代码示例: 
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> mean = jt.ones(200,200) / 2
>>> std = jt.ones(200,200) / 2  
>>> jt.transform.image_normalize(img, mean, std)
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> arr = jt.transform.to_tensor(img) 
>>> type(arr), arr.shape
(<class 'numpy.ndarray'>, (3, 200, 200))
img (PIL.Image.Image): 输入图像。
size (list): 调整后的大小，格式为 [高, 宽]
interpolation (int，optional): 调整大小的插值方法类型。默认值: PIL.Image.BILINEAR
返回值:
PIL.Image.Image: 调整后的图像
代码示例：
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(3,4)
>>> img = Image.fromarray(data, 'L')                              
>>> img.size
(3, 4)
>>> jt.transform.resize(img, [2,3]).size  
(3, 2)
jittor.transform.to_pil_image(pic, mode=None)[源代码]
将一个jt.Var或np.ndarray转换为PIL Image对象
pic (Var, numpy.ndarray): 需要被转换为PIL Image的图像，应为HWC格式
mode (PIL.Image mode, optional): 输入数据的颜色空间和像素深度。默认值：None
返回值:
PIL Image: 转换后的PIL Image
代码示例：
>>> import jittor as jt
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200,200, 3)
>>> img = jt.transform.to_pil_image(data) 
>>> img.show()
>>> import numpy as np
>>> from PIL import Image
>>> data = np.random.rand(200, 200, 3)
>>> img = Image.fromarray(data, 'RGB')   
>>> arr = jt.transform.to_tensor(img) 
>>> type(arr), arr.shape
(<class 'numpy.ndarray'>, (3, 200, 200))
>>> from PIL import Image
>>> data = np.random.rand(200,200)
>>> img = Image.fromarray(data, 'L')       
>>> img.size
(200, 200)
>>> img_vflipped = jt.transform.vflip(img) # 垂直翻转