mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/dataset/vision/utils.py

@@ -20,9 +20,28 @@ import numbers
 import numpy as np
 from PIL import Image
 
-from mindspore import log as logger
+import mindspore
 import mindspore._c_dataengine as cde
 
+if Image.__version__ >= "9.1.0":
+    FLIP_LEFT_RIGHT = Image.Transpose.FLIP_LEFT_RIGHT
+    FLIP_TOP_BOTTOM = Image.Transpose.FLIP_TOP_BOTTOM
+    PERSPECTIVE = Image.Transform.PERSPECTIVE
+    AFFINE = Image.Transform.AFFINE
+    NEAREST = Image.Resampling.NEAREST
+    ANTIALIAS = Image.Resampling.LANCZOS
+    LINEAR = Image.Resampling.BILINEAR
+    CUBIC = Image.Resampling.BICUBIC
+else:
+    FLIP_LEFT_RIGHT = Image.FLIP_LEFT_RIGHT
+    FLIP_TOP_BOTTOM = Image.FLIP_TOP_BOTTOM
+    PERSPECTIVE = Image.PERSPECTIVE
+    AFFINE = Image.AFFINE
+    NEAREST = Image.NEAREST
+    ANTIALIAS = Image.ANTIALIAS
+    LINEAR = Image.LINEAR
+    CUBIC = Image.CUBIC
+
 
 class AutoAugmentPolicy(str, Enum):
     """
@@ -119,7 +138,9 @@ class Border(str, Enum):
     - Border.CONSTANT: means it fills the border with constant values.
     - Border.EDGE: means it pads with the last value on the edge.
     - Border.REFLECT: means it reflects the values on the edge omitting the last value of edge.
+      For example, padding [1,2,3,4] with 2 elements on both sides will result in [3,2,1,2,3,4,3,2].
     - Border.SYMMETRIC: means it reflects the values on the edge repeating the last value of edge.
+      For example, padding [1,2,3,4] with 2 elements on both sides will result in [2,1,1,2,3,4,4,3].
 
     Note:
         This class derived from class str to support json serializable.
@@ -254,6 +275,31 @@ class ImageBatchFormat(IntEnum):
         return c_values.get(image_batch_format)
 
 
+class ImageReadMode(IntEnum):
+    """
+    The read mode used for the image file.
+
+    Possible enumeration values are: ImageReadMode.UNCHANGED, ImageReadMode.GRAYSCALE, ImageReadMode.COLOR.
+
+    - ImageReadMode.UNCHANGED: remain the output in the original format.
+    - ImageReadMode.GRAYSCALE: convert the output into one channel grayscale data.
+    - ImageReadMode.COLOR: convert the output into three channels RGB color data.
+    """
+    UNCHANGED = 0
+    GRAYSCALE = 1
+    COLOR = 2
+
+    @staticmethod
+    def to_c_type(image_read_mode):
+        """
+        Function to return C type for ImageReadMode.
+        """
+        c_values = {ImageReadMode.UNCHANGED: cde.ImageReadMode.DE_IMAGE_READ_MODE_UNCHANGED,
+                    ImageReadMode.GRAYSCALE: cde.ImageReadMode.DE_IMAGE_READ_MODE_GRAYSCALE,
+                    ImageReadMode.COLOR: cde.ImageReadMode.DE_IMAGE_READ_MODE_COLOR}
+        return c_values.get(image_read_mode)
+
+
 class Inter(IntEnum):
     """
     Interpolation Modes.
@@ -283,16 +329,11 @@ class Inter(IntEnum):
         """
         Function to return Python type for Interpolation Mode.
         """
-        if Image.__version__ >= "9.1.0":
-            python_values = {Inter.NEAREST: Image.Resampling.NEAREST,
-                             Inter.ANTIALIAS: Image.Resampling.LANCZOS,
-                             Inter.LINEAR: Image.Resampling.BILINEAR,
-                             Inter.CUBIC: Image.Resampling.BICUBIC}
-        else:
-            python_values = {Inter.NEAREST: Image.NEAREST,
-                             Inter.ANTIALIAS: Image.ANTIALIAS,
-                             Inter.LINEAR: Image.LINEAR,
-                             Inter.CUBIC: Image.CUBIC}
+        python_values = {Inter.NEAREST: NEAREST,
+                         Inter.ANTIALIAS: ANTIALIAS,
+                         Inter.LINEAR: LINEAR,
+                         Inter.CUBIC: CUBIC}
+
         return python_values.get(inter_type)
 
     @staticmethod
@@ -332,6 +373,81 @@ class SliceMode(IntEnum):
         return c_values.get(mode)
 
 
+def encode_jpeg(image, quality=75):
+    """
+    Encode the input image as JPEG data.
+
+    Args:
+        image (Union[numpy.ndarray, mindspore.Tensor]): The image to be encoded.
+        quality (int, optional): Quality of the resulting JPEG data, in range of [1, 100]. Default: 75.
+
+    Returns:
+        numpy.ndarray, one dimension uint8 data.
+
+    Raises:
+        TypeError: If `image` is not of type numpy.ndarray or mindspore.Tensor.
+        TypeError: If `quality` is not of type int.
+        RuntimeError: If the data type of `image` is not uint8.
+        RuntimeError: If the shape of `image` is not <H, W> or <H, W, 1> or <H, W, 3>.
+        RuntimeError: If `quality` is less than 1 or greater than 100.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> # Generate a random image with height=120, width=340, channels=3
+        >>> image = np.random.randint(256, size=(120, 340, 3), dtype=np.uint8)
+        >>> jpeg_data = vision.encode_jpeg(image)
+    """
+    if not isinstance(quality, int):
+        raise TypeError("Input quality is not of type {0}, but got: {1}.".format(int, type(quality)))
+    if isinstance(image, np.ndarray):
+        return cde.encode_jpeg(cde.Tensor(image), quality).as_array()
+    if isinstance(image, mindspore.Tensor):
+        return cde.encode_jpeg(cde.Tensor(image.asnumpy()), quality).as_array()
+    raise TypeError("Input image is not of type {0} or {1}, but got: {2}.".format(np.ndarray,
+                                                                                  mindspore.Tensor, type(image)))
+
+
+def encode_png(image, compression_level=6):
+    """
+    Encode the input image as PNG data.
+
+    Args:
+        image (Union[numpy.ndarray, mindspore.Tensor]): The image to be encoded.
+        compression_level (int, optional): The compression_level for encoding, in range of [0, 9]. Default: 6.
+
+    Returns:
+        numpy.ndarray, one dimension uint8 data.
+
+    Raises:
+        TypeError: If `image` is not of type numpy.ndarray or mindspore.Tensor.
+        TypeError: If `compression_level` is not of type int.
+        RuntimeError: If the data type of `image` is not uint8.
+        RuntimeError: If the shape of `image` is not <H, W> or <H, W, 1> or <H, W, 3>.
+        RuntimeError: If `compression_level` is less than 0 or greater than 9.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> # Generate a random image with height=120, width=340, channels=3
+        >>> image = np.random.randint(256, size=(120, 340, 3), dtype=np.uint8)
+        >>> png_data = vision.encode_png(image)
+    """
+    if not isinstance(compression_level, int):
+        raise TypeError("Input compression_level is not of type {0}, but got: {1}.".format(int,
+                                                                                           type(compression_level)))
+    if isinstance(image, np.ndarray):
+        return cde.encode_png(cde.Tensor(image), compression_level).as_array()
+    if isinstance(image, mindspore.Tensor):
+        return cde.encode_png(cde.Tensor(image.asnumpy()), compression_level).as_array()
+    raise TypeError("Input image is not of type {0} or {1}, but got: {2}.".format(np.ndarray,
+                                                                                  mindspore.Tensor, type(image)))
+
+
 def get_image_num_channels(image):
     """
     Get the number of input image channels.
@@ -342,6 +458,10 @@ def get_image_num_channels(image):
     Returns:
         int, the number of input image channels.
 
+    Raises:
+        RuntimeError: If the dimension of `image` is less than 2.
+        TypeError: If `image` is not of type <class 'numpy.ndarray'> or <class 'PIL.Image.Image'>.
+
     Examples:
         >>> num_channels = vision.get_image_num_channels(image)
     """
@@ -368,6 +488,10 @@ def get_image_size(image):
     Returns:
         list[int, int], the image size.
 
+    Raises:
+        RuntimeError: If the dimension of `image` is less than 2.
+        TypeError: If `image` is not of type <class 'numpy.ndarray'> or <class 'PIL.Image.Image'>.
+
     Examples:
         >>> image_size = vision.get_image_size(image)
     """
@@ -388,13 +512,185 @@ def parse_padding(padding):
     if isinstance(padding, numbers.Number):
         padding = [padding] * 4
     if len(padding) == 2:
-        logger.warning("The behavior when `padding` is a sequence of length 2 will change from padding left/top "
-                       "with the first value and right/bottom with the second, to padding left/right with the "
-                       "first one and top/bottom with the second in the future. Or you can pass in a 4-element "
-                       "sequence to specify left, top, right and bottom respectively.")
-        left = top = padding[0]
-        right = bottom = padding[1]
+        left = right = padding[0]
+        top = bottom = padding[1]
         padding = (left, top, right, bottom,)
     if isinstance(padding, list):
         padding = tuple(padding)
     return padding
+
+
+def read_file(filename):
+    """
+    Read a file in binary mode.
+
+    Args:
+        filename(str): The path to the file to be read.
+
+    Returns:
+        numpy.ndarray, the one dimension uint8 data.
+
+    Raises:
+        TypeError: If `filename` is not of type str.
+        RuntimeError: If `filename` does not exist or is not a common file.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> output = vision.read_file("/path/to/file")
+    """
+    if isinstance(filename, str):
+        return cde.read_file(filename).as_array()
+    raise TypeError("Input filename is not of type {0}, but got: {1}.".format(str, type(filename)))
+
+
+def read_image(filename, mode=ImageReadMode.UNCHANGED):
+    """
+    Read a image file and decode it into one channel grayscale data or RGB color data.
+    Supported file types are JPEG, PNG, BMP, TIFF.
+
+    Args:
+        filename(str): The path to the image file to be read.
+        mode(ImageReadMode, optional): The mode used for decoding the image. It can be any of
+            [ImageReadMode.UNCHANGED, ImageReadMode.GRAYSCALE, IMageReadMode.COLOR]. Default: ImageReadMode.UNCHANGED.
+
+            - ImageReadMode.UNCHANGED, remain the output in the original format.
+
+            - ImageReadMode.GRAYSCALE, convert the output into one channel grayscale data.
+
+            - IMageReadMode.COLOR, convert the output into three channels RGB color data.
+
+    Returns:
+        numpy.ndarray, three dimensions uint8 data in the shape of (Height, Width, Channels).
+
+    Raises:
+        TypeError: If `filename` is not of type str.
+        TypeError: If `mode` is not of type :class:`mindspore.dataset.vision.ImageReadMode` .
+        RuntimeError: If `filename` does not exist, or not a regular file, or not a supported image file.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> from mindspore.dataset.vision import ImageReadMode
+        >>> output = vision.read_image("/path/to/image_file", ImageReadMode.UNCHANGED)
+    """
+    if not isinstance(filename, str):
+        raise TypeError("Input filename is not of type {0}, but got: {1}.".format(str, type(filename)))
+    if not isinstance(mode, ImageReadMode):
+        raise TypeError("Input mode is not of type {0}, but got: {1}.".format(ImageReadMode, type(mode)))
+    return cde.read_image(filename, ImageReadMode.to_c_type(mode)).as_array()
+
+
+def write_file(filename, data):
+    """
+    Write the one dimension uint8 data into a file using binary mode.
+
+    Args:
+        filename (str): The path to the file to be written.
+        data (Union[numpy.ndarray, mindspore.Tensor]): The one dimension uint8 data to be written.
+
+    Raises:
+        TypeError: If `filename` is not of type str.
+        TypeError: If `data` is not of type numpy.ndarray or mindspore.Tensor.
+        RuntimeError: If the `filename` is not a common file.
+        RuntimeError: If the data type of `data` is not uint8.
+        RuntimeError: If the shape of `data` is not a one-dimensional array.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> # Generate a random data with 1024 bytes
+        >>> data = np.random.randint(256, size=(1024), dtype=np.uint8)
+        >>> vision.write_file("/path/to/file", data)
+    """
+    if not isinstance(filename, str):
+        raise TypeError("Input filename is not of type {0}, but got: {1}.".format(str, type(filename)))
+    if isinstance(data, np.ndarray):
+        return cde.write_file(filename, cde.Tensor(data))
+    if isinstance(data, mindspore.Tensor):
+        return cde.write_file(filename, cde.Tensor(data.asnumpy()))
+    raise TypeError("Input data is not of type {0} or {1}, but got: {2}.".format(np.ndarray,
+                                                                                 mindspore.Tensor, type(data)))
+
+
+def write_jpeg(filename, image, quality=75):
+    """
+    Write the image data into a JPEG file.
+
+    Args:
+        filename (str): The path to the file to be written.
+        image (Union[numpy.ndarray, mindspore.Tensor]): The image data to be written.
+        quality (int, optional): Quality of the resulting JPEG file, in range of [1, 100]. Default: 75.
+
+    Raises:
+        TypeError: If `filename` is not of type str.
+        TypeError: If `image` is not of type numpy.ndarray or mindspore.Tensor.
+        TypeError: If `quality` is not of type int.
+        RuntimeError: If the `filename` does not exist or not a common file.
+        RuntimeError: If the data type of `image` is not uint8.
+        RuntimeError: If the shape of `image` is not <H, W> or <H, W, 1> or <H, W, 3>.
+        RuntimeError: If `quality` is less than 1 or greater than 100.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> # Generate a random image with height=120, width=340, channels=3
+        >>> image = np.random.randint(256, size=(120, 340, 3), dtype=np.uint8)
+        >>> vision.write_jpeg("/path/to/file", image)
+    """
+    if not isinstance(filename, str):
+        raise TypeError("Input filename is not of type {0}, but got: {1}.".format(str, type(filename)))
+    if not isinstance(quality, int):
+        raise TypeError("Input quality is not of type {0}, but got: {1}.".format(int, type(quality)))
+    if isinstance(image, np.ndarray):
+        return cde.write_jpeg(filename, cde.Tensor(image), quality)
+    if isinstance(image, mindspore.Tensor):
+        return cde.write_jpeg(filename, cde.Tensor(image.asnumpy()), quality)
+    raise TypeError("Input image is not of type {0} or {1}, but got: {2}.".format(np.ndarray,
+                                                                                  mindspore.Tensor, type(image)))
+
+
+def write_png(filename, image, compression_level=6):
+    """
+    Write the image into a PNG file.
+
+    Args:
+        filename (str): The path to the file to be written.
+        image (Union[numpy.ndarray, mindspore.Tensor]): The image data to be written.
+        compression_level (int, optional): Compression level for the resulting PNG file, in range of [0, 9]. Default: 6.
+
+    Raises:
+        TypeError: If `filename` is not of type str.
+        TypeError: If `image` is not of type numpy.ndarray or mindspore.Tensor.
+        TypeError: If `compression_level` is not of type int.
+        RuntimeError: If the `filename` does not exist or not a common file.
+        RuntimeError: If the data type of `image` is not uint8.
+        RuntimeError: If the shape of `image` is not <H, W> or <H, W, 1> or <H, W, 3>.
+        RuntimeError: If `compression_level` is less than 0 or greater than 9.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> # Generate a random image with height=120, width=340, channels=3
+        >>> image = np.random.randint(256, size=(120, 340, 3), dtype=np.uint8)
+        >>> vision.write_png("/path/to/file", image)
+    """
+    if not isinstance(filename, str):
+        raise TypeError("Input filename is not of type {0}, but got: {1}.".format(str, type(filename)))
+    if not isinstance(compression_level, int):
+        raise TypeError("Input compression_level is not of type {0}, but got: {1}.".format(int,
+                                                                                           type(compression_level)))
+    if isinstance(image, np.ndarray):
+        return cde.write_png(filename, cde.Tensor(image), compression_level)
+    if isinstance(image, mindspore.Tensor):
+        return cde.write_png(filename, cde.Tensor(image.asnumpy()), compression_level)
+    raise TypeError("The input image is not of type {0} or {1}, but got: {2}.".format(np.ndarray,
+                                                                                      mindspore.Tensor, type(image)))

mindspore/dataset/vision/validators.py

@@ -1380,22 +1380,22 @@ def check_to_tensor(method):
 
 
 def deprecated_c_vision(substitute_name=None, substitute_module=None):
-    """Decorator for version 1.8 deprecation warning for legacy mindspore.dataset.vision.c_transforms operator.
+    """Decorator for version 1.8 deprecation warning for legacy mindspore.dataset.vision.c_transforms operation.
 
     Args:
-        substitute_name (str, optional): The substitute name for deprecated operator.
-        substitute_module (str, optional): The substitute module for deprecated operator.
+        substitute_name (str, optional): The substitute name for deprecated operation.
+        substitute_module (str, optional): The substitute module for deprecated operation.
     """
     return deprecator_factory("1.8", "mindspore.dataset.vision.c_transforms", "mindspore.dataset.vision",
                               substitute_name, substitute_module)
 
 
 def deprecated_py_vision(substitute_name=None, substitute_module=None):
-    """Decorator for version 1.8 deprecation warning for legacy mindspore.dataset.vision.py_transforms operator.
+    """Decorator for version 1.8 deprecation warning for legacy mindspore.dataset.vision.py_transforms operation.
 
     Args:
-        substitute_name (str, optional): The substitute name for deprecated operator.
-        substitute_module (str, optional): The substitute module for deprecated operator.
+        substitute_name (str, optional): The substitute name for deprecated operation.
+        substitute_module (str, optional): The substitute module for deprecated operation.
     """
     return deprecator_factory("1.8", "mindspore.dataset.vision.py_transforms", "mindspore.dataset.vision",
                               substitute_name, substitute_module)

mindspore/default_config.py

@@ -1,3 +1,2 @@
 __backend__ = 'ms'
-__device_target__ = 'cpu'
 __package_name__ = 'mindspore'

mindspore/{compression → experimental}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2022 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""
-MindSpore compression module.
+"""Experimental module."""
+from __future__ import absolute_import
+from mindspore.experimental.map_parameter import MapParameter
 
-Note: This is an experimental interface that is subject to change and/or deletion.
-"""
+# Symbols from experimental module.
+__all__ = ["MapParameter"]