!4322 Adding RGBA color conversion

Merge pull request !4322 from EricZ/bitmap_support

mindspore/ccsrc/minddata/dataset/api/transforms.cc

@@ -35,6 +35,8 @@
 #include "minddata/dataset/kernels/image/random_solarize_op.h"
 #include "minddata/dataset/kernels/image/random_vertical_flip_op.h"
 #include "minddata/dataset/kernels/image/resize_op.h"
+#include "minddata/dataset/kernels/image/rgba_to_bgr_op.h"
+#include "minddata/dataset/kernels/image/rgba_to_rgb_op.h"
 #include "minddata/dataset/kernels/image/swap_red_blue_op.h"
 #include "minddata/dataset/kernels/image/uniform_aug_op.h"
 
@@ -240,6 +242,26 @@ std::shared_ptr<ResizeOperation> Resize(std::vector<int32_t> size, Interpolation
   return op;
 }
 
+// Function to create RgbaToBgrOperation.
+std::shared_ptr<RgbaToBgrOperation> RGBA2BGR() {
+  auto op = std::make_shared<RgbaToBgrOperation>();
+  // Input validation
+  if (!op->ValidateParams()) {
+    return nullptr;
+  }
+  return op;
+}
+
+// Function to create RgbaToRgbOperation.
+std::shared_ptr<RgbaToRgbOperation> RGBA2RGB() {
+  auto op = std::make_shared<RgbaToRgbOperation>();
+  // Input validation
+  if (!op->ValidateParams()) {
+    return nullptr;
+  }
+  return op;
+}
+
 // Function to create SwapRedBlueOperation.
 std::shared_ptr<SwapRedBlueOperation> SwapRedBlue() {
   auto op = std::make_shared<SwapRedBlueOperation>();
@@ -743,6 +765,26 @@ std::shared_ptr<TensorOp> ResizeOperation::Build() {
   return std::make_shared<ResizeOp>(height, width, interpolation_);
 }
 
+// RgbaToBgrOperation.
+RgbaToBgrOperation::RgbaToBgrOperation() {}
+
+bool RgbaToBgrOperation::ValidateParams() { return true; }
+
+std::shared_ptr<TensorOp> RgbaToBgrOperation::Build() {
+  std::shared_ptr<RgbaToBgrOp> tensor_op = std::make_shared<RgbaToBgrOp>();
+  return tensor_op;
+}
+
+// RgbaToRgbOperation.
+RgbaToRgbOperation::RgbaToRgbOperation() {}
+
+bool RgbaToRgbOperation::ValidateParams() { return true; }
+
+std::shared_ptr<TensorOp> RgbaToRgbOperation::Build() {
+  std::shared_ptr<RgbaToRgbOp> tensor_op = std::make_shared<RgbaToRgbOp>();
+  return tensor_op;
+}
+
 // SwapRedBlueOperation.
 SwapRedBlueOperation::SwapRedBlueOperation() {}
 

mindspore/ccsrc/minddata/dataset/include/transforms.h

@@ -65,14 +65,16 @@ class RandomSharpnessOperation;
 class RandomSolarizeOperation;
 class RandomVerticalFlipOperation;
 class ResizeOperation;
+class RgbaToBgrOperation;
+class RgbaToRgbOperation;
 class SwapRedBlueOperation;
 class UniformAugOperation;
 
 /// \brief Function to create a CenterCrop TensorOperation.
 /// \notes Crops the input image at the center to the given size.
 /// \param[in] size - a vector representing the output size of the cropped image.
-///               If size is a single value, a square crop of size (size, size) is returned.
-///               If size has 2 values, it should be (height, width).
+///      If size is a single value, a square crop of size (size, size) is returned.
+///      If size has 2 values, it should be (height, width).
 /// \return Shared pointer to the current TensorOperation.
 std::shared_ptr<CenterCropOperation> CenterCrop(std::vector<int32_t> size);
 
@@ -103,15 +105,15 @@ std::shared_ptr<HwcToChwOperation> HWC2CHW();
 
 /// \brief Function to create a MixUpBatch TensorOperation.
 /// \notes Apply MixUp transformation on an input batch of images and labels. The labels must be in one-hot format and
-///    Batch must be called before calling this function.
+///     Batch must be called before calling this function.
 /// \param[in] alpha hyperparameter of beta distribution (default = 1.0)
 /// \return Shared pointer to the current TensorOperation.
 std::shared_ptr<MixUpBatchOperation> MixUpBatch(float alpha = 1);
 
 /// \brief Function to create a Normalize TensorOperation.
 /// \notes Normalize the input image with respect to mean and standard deviation.
-/// \param[in] mean - a vector of mean values for each channel, w.r.t channel order.
-/// \param[in] std - a vector of standard deviations for each channel, w.r.t. channel order.
+/// \param[in] mean A vector of mean values for each channel, w.r.t channel order.
+/// \param[in] std A vector of standard deviations for each channel, w.r.t. channel order.
 /// \return Shared pointer to the current TensorOperation.
 std::shared_ptr<NormalizeOperation> Normalize(std::vector<float> mean, std::vector<float> std);
 
@@ -230,8 +232,18 @@ std::shared_ptr<RandomSolarizeOperation> RandomSolarize(uint8_t threshold_min =
 /// \return Shared pointer to the current TensorOperation.
 std::shared_ptr<RandomVerticalFlipOperation> RandomVerticalFlip(float prob = 0.5);
 
+/// \brief Function to create a RgbaToBgr TensorOperation.
+/// \notes Changes the input 4 channel RGBA tensor to 3 channel BGR.
+/// \return Shared pointer to the current TensorOperation.
+std::shared_ptr<RgbaToBgrOperation> RGBA2BGR();
+
+/// \brief Function to create a RgbaToRgb TensorOperation.
+/// \notes Changes the input 4 channel RGBA tensor to 3 channel RGB.
+/// \return Shared pointer to the current TensorOperation.
+std::shared_ptr<RgbaToRgbOperation> RGBA2RGB();
+
 /// \brief Function to create a Resize TensorOperation.
-/// \notes Resize the input image to the given size..
+/// \notes Resize the input image to the given size.
 /// \param[in] size - a vector representing the output size of the resized image.
 ///               If size is a single value, the image will be resized to this value with
 ///               the same image aspect ratio. If size has 2 values, it should be (height, width).
@@ -520,6 +532,28 @@ class ResizeOperation : public TensorOperation {
   InterpolationMode interpolation_;
 };
 
+class RgbaToBgrOperation : public TensorOperation {
+ public:
+  RgbaToBgrOperation();
+
+  ~RgbaToBgrOperation() = default;
+
+  std::shared_ptr<TensorOp> Build() override;
+
+  bool ValidateParams() override;
+};
+
+class RgbaToRgbOperation : public TensorOperation {
+ public:
+  RgbaToRgbOperation();
+
+  ~RgbaToRgbOperation() = default;
+
+  std::shared_ptr<TensorOp> Build() override;
+
+  bool ValidateParams() override;
+};
+
 class UniformAugOperation : public TensorOperation {
  public:
   explicit UniformAugOperation(std::vector<std::shared_ptr<TensorOperation>> transforms, int32_t num_ops = 2);

mindspore/ccsrc/minddata/dataset/kernels/image/CMakeLists.txt

@@ -36,6 +36,8 @@ add_library(kernels-image OBJECT
     rescale_op.cc
     resize_bilinear_op.cc
     resize_op.cc
+    rgba_to_bgr_op.cc
+    rgba_to_rgb_op.cc
     sharpness_op.cc
     solarize_op.cc
     swap_red_blue_op.cc

mindspore/ccsrc/minddata/dataset/kernels/image/image_utils.cc

@@ -856,6 +856,44 @@ Status Pad(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output
     RETURN_STATUS_UNEXPECTED("Unexpected error in pad");
   }
 }
+
+Status RgbaToRgb(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
+  try {
+    std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(std::move(input));
+    int num_channels = input_cv->shape()[2];
+    if (input_cv->shape().Size() != 3 || num_channels != 4) {
+      std::string err_msg = "Number of channels does not equal 4, got : " + std::to_string(num_channels);
+      RETURN_STATUS_UNEXPECTED(err_msg);
+    }
+    TensorShape out_shape = TensorShape({input_cv->shape()[0], input_cv->shape()[1], 3});
+    std::shared_ptr<CVTensor> output_cv;
+    RETURN_IF_NOT_OK(CVTensor::CreateEmpty(out_shape, input_cv->type(), &output_cv));
+    cv::cvtColor(input_cv->mat(), output_cv->mat(), static_cast<int>(cv::COLOR_RGBA2RGB));
+    *output = std::static_pointer_cast<Tensor>(output_cv);
+    return Status::OK();
+  } catch (const cv::Exception &e) {
+    RETURN_STATUS_UNEXPECTED("Unexpected error in RgbaToRgb.");
+  }
+}
+
+Status RgbaToBgr(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
+  try {
+    std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(std::move(input));
+    int num_channels = input_cv->shape()[2];
+    if (input_cv->shape().Size() != 3 || num_channels != 4) {
+      std::string err_msg = "Number of channels does not equal 4, got : " + std::to_string(num_channels);
+      RETURN_STATUS_UNEXPECTED(err_msg);
+    }
+    TensorShape out_shape = TensorShape({input_cv->shape()[0], input_cv->shape()[1], 3});
+    std::shared_ptr<CVTensor> output_cv;
+    RETURN_IF_NOT_OK(CVTensor::CreateEmpty(out_shape, input_cv->type(), &output_cv));
+    cv::cvtColor(input_cv->mat(), output_cv->mat(), static_cast<int>(cv::COLOR_RGBA2BGR));
+    *output = std::static_pointer_cast<Tensor>(output_cv);
+    return Status::OK();
+  } catch (const cv::Exception &e) {
+    RETURN_STATUS_UNEXPECTED("Unexpected error in RgbaToBgr.");
+  }
+}
 // -------- BBOX OPERATIONS -------- //
 Status UpdateBBoxesForCrop(std::shared_ptr<Tensor> *bboxList, size_t *bboxCount, int CB_Xmin, int CB_Ymin, int CB_Xmax,
                            int CB_Ymax) {

mindspore/ccsrc/minddata/dataset/kernels/image/image_utils.h

@@ -44,50 +44,50 @@ struct JpegErrorManagerCustom {
   jmp_buf setjmp_buffer;
 };
 
-// Returns the interpolation mode in openCV format
-// @param mode: interpolation mode in DE format
+/// \brief Returns the interpolation mode in openCV format
+/// \param[in] mode Interpolation mode in DE format
 int GetCVInterpolationMode(InterpolationMode mode);
 
-// Returns the openCV equivalent of the border type used for padding.
-// @param type
-// @return
+/// \brief Returns the openCV equivalent of the border type used for padding.
+/// \param type
+/// \return Status code
 int GetCVBorderType(BorderType type);
 
-// Returns flipped image
-// @param input/output: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// @param flip_code: 1 for Horizontal (around y-axis), 0 for Vertical (around x-axis), -1 for both
-// The flipping happens in place.
+/// \brief Returns flipped image
+/// \param[in] input/output: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// \param flip_code: 1 for Horizontal (around y-axis), 0 for Vertical (around x-axis), -1 for both
+///     The flipping happens in place.
 Status Flip(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output, int flip_code);
 
-// Returns Horizontally flipped image
-// @param input/output: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// The flipping happens in place.
+/// \brief Returns Horizontally flipped image
+/// \param input/output: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// The flipping happens in place.
 Status HorizontalFlip(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output);
 
-// Returns Vertically flipped image
-// @param input/output: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// The flipping happens in place.
+/// \brief Returns Vertically flipped image
+/// \param input/output: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// \note The flipping happens in place.
 Status VerticalFlip(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output);
 
-// Returns Resized image.
-// @param input/output: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// @param output_height: height of output
-// @param output_width: width of output
-// @param fx: horizontal scale
-// @param fy: vertical scale
-// @param InterpolationMode: the interpolation mode
-// @param output: Resized image of shape <outputHeight,outputWidth,C> or <outputHeight,outputWidth>
-//                and same type as input
+/// \brief  Returns Resized image.
+/// \param input/output: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// \param output_height: height of output
+/// \param output_width: width of output
+/// \param fx: horizontal scale
+/// \param fy: vertical scale
+/// \param InterpolationMode: the interpolation mode
+/// \param output: Resized image of shape <outputHeight,outputWidth,C> or <outputHeight,outputWidth>
+///                and same type as input
 Status Resize(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, int32_t output_height,
               int32_t output_width, double fx = 0.0, double fy = 0.0,
               InterpolationMode mode = InterpolationMode::kLinear);
 
-// Returns Decoded image
-// Supported images:
-//  BMP JPEG JPG PNG TIFF
-// supported by opencv, if user need more image analysis capabilities, please compile opencv particularlly.
-// @param input: CVTensor containing the not decoded image 1D bytes
-// @param output: Decoded image Tensor of shape <H,W,C> and type DE_UINT8. Pixel order is RGB
+/// \brief Returns Decoded image
+/// Supported images:
+///  BMP JPEG JPG PNG TIFF
+/// supported by opencv, if user need more image analysis capabilities, please compile opencv particularlly.
+/// \param input: CVTensor containing the not decoded image 1D bytes
+/// \param output: Decoded image Tensor of shape <H,W,C> and type DE_UINT8. Pixel order is RGB
 Status Decode(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output);
 
 Status DecodeCv(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output);
@@ -98,106 +98,107 @@ void JpegSetSource(j_decompress_ptr c_info, const void *data, int64_t data_size)
 
 Status JpegCropAndDecode(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, int x = 0, int y = 0,
                          int w = 0, int h = 0);
-// Returns Rescaled image
-// @param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// @param rescale: rescale parameter
-// @param shift: shift parameter
-// @param output: Rescaled image Tensor of same input shape and type DE_FLOAT32
+
+/// \brief Returns Rescaled image
+/// \param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// \param rescale: rescale parameter
+/// \param shift: shift parameter
+/// \param output: Rescaled image Tensor of same input shape and type DE_FLOAT32
 Status Rescale(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, float rescale, float shift);
 
-// Returns cropped ROI of an image
-// @param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// @param x: starting horizontal position of ROI
-// @param y: starting vertical position of ROI
-// @param w: width of the ROI
-// @param h: height of the ROI
-// @param output: Cropped image Tensor of shape <h,w,C> or <h,w> and same input type.
+/// \brief Returns cropped ROI of an image
+/// \param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// \param x: starting horizontal position of ROI
+/// \param y: starting vertical position of ROI
+/// \param w: width of the ROI
+/// \param h: height of the ROI
+/// \param output: Cropped image Tensor of shape <h,w,C> or <h,w> and same input type.
 Status Crop(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, int x, int y, int w, int h);
 
-// Swaps the channels in the image, i.e. converts HWC to CHW
-// @param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// @param output: Tensor of shape <C,H,W> or <H,W> and same input type.
+/// \brief Swaps the channels in the image, i.e. converts HWC to CHW
+/// \param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// \param output: Tensor of shape <C,H,W> or <H,W> and same input type.
 Status HwcToChw(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output);
 
-// Swap the red and blue pixels (RGB <-> BGR)
-// @param input: Tensor of shape <H,W,3> and any OpenCv compatible type, see CVTensor.
-// @param output: Swapped image of same shape and type
+/// \brief Swap the red and blue pixels (RGB <-> BGR)
+/// \param input: Tensor of shape <H,W,3> and any OpenCv compatible type, see CVTensor.
+/// \param output: Swapped image of same shape and type
 Status SwapRedAndBlue(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output);
 
-// Crops and resizes the image
-// @param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// @param x: horizontal start point
-// @param y: vertical start point
-// @param crop_height: height of the cropped ROI
-// @param crop_width: width of the cropped ROI
-// @param target_width: width of the final resized image
-// @param target_height: height of the final resized image
-// @param InterpolationMode: the interpolation used in resize operation
-// @param output: Tensor of shape <targetHeight,targetWidth,C> or <targetHeight,targetWidth>
-//                and same type as input
+/// \brief Crops and resizes the image
+/// \param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// \param x: horizontal start point
+/// \param y: vertical start point
+/// \param crop_height: height of the cropped ROI
+/// \param crop_width: width of the cropped ROI
+/// \param target_width: width of the final resized image
+/// \param target_height: height of the final resized image
+/// \param InterpolationMode: the interpolation used in resize operation
+/// \param output: Tensor of shape <targetHeight,targetWidth,C> or <targetHeight,targetWidth>
+///     and same type as input
 Status CropAndResize(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, int x, int y,
                      int crop_height, int crop_width, int target_height, int target_width, InterpolationMode mode);
 
-// Returns rotated image
-// @param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
-// @param fx: rotation center x coordinate
-// @param fy: rotation center y coordinate
-// @param degree: degree to rotate
-// @param expand: if reshape is necessary
-// @param output: rotated image of same input type.
+/// \brief Returns rotated image
+/// \param input: Tensor of shape <H,W,C> or <H,W> and any OpenCv compatible type, see CVTensor.
+/// \param fx: rotation center x coordinate
+/// \param fy: rotation center y coordinate
+/// \param degree: degree to rotate
+/// \param expand: if reshape is necessary
+/// \param output: rotated image of same input type.
 Status Rotate(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, float fx, float fy, float degree,
               InterpolationMode interpolation = InterpolationMode::kNearestNeighbour, bool expand = false,
               uint8_t fill_r = 0, uint8_t fill_g = 0, uint8_t fill_b = 0);
 
-// Returns Normalized image
-// @param input: Tensor of shape <H,W,C> in RGB order and any OpenCv compatible type, see CVTensor.
-// @param mean: Tensor of shape <3> and type DE_FLOAT32 which are mean of each channel in RGB order
-// @param std:  Tensor of shape <3> and type DE_FLOAT32 which are std of each channel in RGB order
-// @param output: Normalized image Tensor of same input shape and type DE_FLOAT32
+/// \brief Returns Normalized image
+/// \param input: Tensor of shape <H,W,C> in RGB order and any OpenCv compatible type, see CVTensor.
+/// \param mean: Tensor of shape <3> and type DE_FLOAT32 which are mean of each channel in RGB order
+/// \param std:  Tensor of shape <3> and type DE_FLOAT32 which are std of each channel in RGB order
+/// \param output: Normalized image Tensor of same input shape and type DE_FLOAT32
 Status Normalize(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output,
                  const std::shared_ptr<Tensor> &mean, const std::shared_ptr<Tensor> &std);
 
-// Returns image with adjusted brightness.
-// @param input: Tensor of shape <H,W,3> in RGB order and any OpenCv compatible type, see CVTensor.
-// @param alpha: Alpha value to adjust brightness by. Should be a positive number.
-//               If user input one value in python, the range is [1 - value, 1 + value].
-//               This will output original image multiplied by alpha. 0 gives a black image, 1 gives the
-//               original image while 2 increases the brightness by a factor of 2.
-// @param output: Adjusted image of same shape and type.
+/// \brief Returns image with adjusted brightness.
+/// \param input: Tensor of shape <H,W,3> in RGB order and any OpenCv compatible type, see CVTensor.
+/// \param alpha: Alpha value to adjust brightness by. Should be a positive number.
+///               If user input one value in python, the range is [1 - value, 1 + value].
+///               This will output original image multiplied by alpha. 0 gives a black image, 1 gives the
+///               original image while 2 increases the brightness by a factor of 2.
+/// \param output: Adjusted image of same shape and type.
 Status AdjustBrightness(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, const float &alpha);
 
-// Returns image with adjusted contrast.
-// @param input: Tensor of shape <H,W,3> in RGB order and any OpenCv compatible type, see CVTensor.
-// @param alpha: Alpha value to adjust contrast by. Should be a positive number.
-//               If user input one value in python, the range is [1 - value, 1 + value].
-//               0 gives a solid gray image, 1 gives the original image while 2 increases
-//               the contrast by a factor of 2.
-// @param output: Adjusted image of same shape and type.
+/// \brief Returns image with adjusted contrast.
+/// \param input: Tensor of shape <H,W,3> in RGB order and any OpenCv compatible type, see CVTensor.
+/// \param alpha: Alpha value to adjust contrast by. Should be a positive number.
+///               If user input one value in python, the range is [1 - value, 1 + value].
+///               0 gives a solid gray image, 1 gives the original image while 2 increases
+///               the contrast by a factor of 2.
+/// \param output: Adjusted image of same shape and type.
 Status AdjustContrast(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, const float &alpha);
 
-// Returns image with contrast maximized.
-// @param input: Tensor of shape <H,W,3>/<H,W,1>/<H,W> in RGB/Grayscale and any OpenCv compatible type, see CVTensor.
-// @param cutoff: Cutoff percentage of how many pixels are to be removed (high pixels change to 255 and low change to 0)
-//                from the high and low ends of the histogram.
-// @param ignore: Pixel values to be ignored in the algorithm.
+/// \brief Returns image with contrast maximized.
+/// \param input: Tensor of shape <H,W,3>/<H,W,1>/<H,W> in RGB/Grayscale and any OpenCv compatible type, see CVTensor.
+/// \param cutoff: Cutoff percentage of how many pixels are to be removed (high pixels change to 255 and low change
+///     to 0) from the high and low ends of the histogram.
+/// \param ignore: Pixel values to be ignored in the algorithm.
 Status AutoContrast(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, const float &cutoff,
                     const std::vector<uint32_t> &ignore);
 
-// Returns image with adjusted saturation.
-// @param input: Tensor of shape <H,W,3> in RGB order and any OpenCv compatible type, see CVTensor.
-// @param alpha: Alpha value to adjust saturation by. Should be a positive number.
-//               If user input one value in python, the range is [1 - value, 1 + value].
-//               0 will give a black and white image, 1 will give the original image while
-//               2 will enhance the saturation by a factor of 2.
-// @param output: Adjusted image of same shape and type.
+/// \brief Returns image with adjusted saturation.
+/// \param input: Tensor of shape <H,W,3> in RGB order and any OpenCv compatible type, see CVTensor.
+/// \param alpha: Alpha value to adjust saturation by. Should be a positive number.
+///               If user input one value in python, the range is [1 - value, 1 + value].
+///               0 will give a black and white image, 1 will give the original image while
+///               2 will enhance the saturation by a factor of 2.
+/// \param output: Adjusted image of same shape and type.
 Status AdjustSaturation(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, const float &alpha);
 
-// Returns image with adjusted hue.
-// @param input: Tensor of shape <H,W,3> in RGB order and any OpenCv compatible type, see CVTensor.
-// @param hue: Hue value to adjust by, should be within range [-0.5, 0.5]. 0.5 and - 0.5 will reverse the hue channel
-//             completely.
-//             If user input one value in python, the range is [-value, value].
-// @param output: Adjusted image of same shape and type.
+/// \brief Returns image with adjusted hue.
+/// \param input: Tensor of shape <H,W,3> in RGB order and any OpenCv compatible type, see CVTensor.
+/// \param hue: Hue value to adjust by, should be within range [-0.5, 0.5]. 0.5 and - 0.5 will reverse the hue channel
+///             completely.
+///             If user input one value in python, the range is [-value, value].
+/// \param output: Adjusted image of same shape and type.
 Status AdjustHue(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, const float &hue);
 
 /// \brief Returns image with equalized histogram.
@@ -206,72 +207,84 @@ Status AdjustHue(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *
 /// \param[out] output: Equalized image of same shape and type.
 Status Equalize(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output);
 
-// Masks out a random section from the image with set dimension
-// @param input: input Tensor
-// @param output: cutOut Tensor
-// @param box_height: height of the cropped box
-// @param box_width: width of the cropped box
-// @param num_patches: number of boxes to cut out from the image
-// @param bounded: boolean flag to toggle between random erasing and cutout
-// @param random_color: whether or not random fill value should be used
-// @param fill_r: red fill value for erase
-// @param fill_g: green fill value for erase
-// @param fill_b: blue fill value for erase.
+/// \brief Masks out a random section from the image with set dimension
+/// \param input: input Tensor
+/// \param output: cutOut Tensor
+/// \param box_height: height of the cropped box
+/// \param box_width: width of the cropped box
+/// \param num_patches: number of boxes to cut out from the image
+/// \param bounded: boolean flag to toggle between random erasing and cutout
+/// \param random_color: whether or not random fill value should be used
+/// \param fill_r: red fill value for erase
+/// \param fill_g: green fill value for erase
+/// \param fill_b: blue fill value for erase.
 Status Erase(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, int32_t box_height,
              int32_t box_width, int32_t num_patches, bool bounded, bool random_color, std::mt19937 *rnd,
              uint8_t fill_r = 0, uint8_t fill_g = 0, uint8_t fill_b = 0);
 
-// Pads the input image and puts the padded image in the output
-// @param input: input Tensor
-// @param output: padded Tensor
-// @param pad_top: amount of padding done in top
-// @param pad_bottom: amount of padding done in bottom
-// @param pad_left: amount of padding done in left
-// @param pad_right: amount of padding done in right
-// @param border_types: the interpolation to be done in the border
-// @param fill_r: red fill value for pad
-// @param fill_g: green fill value for pad
-// @param fill_b: blue fill value for pad.
+/// \brief Pads the input image and puts the padded image in the output
+/// \param input: input Tensor
+/// \param output: padded Tensor
+/// \param pad_top: amount of padding done in top
+/// \param pad_bottom: amount of padding done in bottom
+/// \param pad_left: amount of padding done in left
+/// \param pad_right: amount of padding done in right
+/// \param border_types: the interpolation to be done in the border
+/// \param fill_r: red fill value for pad
+/// \param fill_g: green fill value for pad
+/// \param fill_b: blue fill value for pad.
 Status Pad(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output, const int32_t &pad_top,
            const int32_t &pad_bottom, const int32_t &pad_left, const int32_t &pad_right, const BorderType &border_types,
            uint8_t fill_r = 0, uint8_t fill_g = 0, uint8_t fill_b = 0);
 
-// -------- BBOX OPERATIONS -------- //
-// Updates and checks bounding boxes for new cropped region of image
-// @param bboxList: A tensor contaning bounding box tensors
-// @param bboxCount: total Number of bounding boxes - required within caller function to run update loop
-// @param CB_Xmin: Image's CropBox Xmin coordinate
-// @param CB_Xmin: Image's CropBox Ymin coordinate
-// @param CB_Xmax: Image's CropBox Xmax coordinate - (Xmin + width)
-// @param CB_Xmax: Image's CropBox Ymax coordinate - (Ymin + height)
+/// \brief Take in a 4 channel image in RBGA to RGB
+/// \param[in] input The input image
+/// \param[out] output The output image
+/// \return Status code
+Status RgbaToRgb(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output);
+
+/// \brief Take in a 4 channel image in RBGA to BGR
+/// \param[in] input The input image
+/// \param[out] output The output image
+/// \return Status code
+Status RgbaToBgr(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output);
+
+/// -------- BBOX OPERATIONS -------- ///
+/// \brief Updates and checks bounding boxes for new cropped region of image
+/// \param bboxList: A tensor contaning bounding box tensors
+/// \param bboxCount: total Number of bounding boxes - required within caller function to run update loop
+/// \param CB_Xmin: Image's CropBox Xmin coordinate
+/// \param CB_Xmin: Image's CropBox Ymin coordinate
+/// \param CB_Xmax: Image's CropBox Xmax coordinate - (Xmin + width)
+/// \param CB_Xmax: Image's CropBox Ymax coordinate - (Ymin + height)
 Status UpdateBBoxesForCrop(std::shared_ptr<Tensor> *bboxList, size_t *bboxCount, int CB_Xmin, int CB_Ymin, int CB_Xmax,
                            int CB_Ymax);
 
-// Updates bounding boxes with required Top and Left padding
-// Top and Left padding amounts required to adjust bboxs min X,Y values according to padding 'push'
-// Top/Left since images 0,0 coordinate is taken from top left
-// @param bboxList: A tensor contaning bounding box tensors
-// @param bboxCount: total Number of bounding boxes - required within caller function to run update loop
-// @param pad_top: Total amount of padding applied to image top
-// @param pad_left: Total amount of padding applied to image left side
+/// \brief Updates bounding boxes with required Top and Left padding
+/// \note Top and Left padding amounts required to adjust bboxs min X,Y values according to padding 'push'
+///     Top/Left since images 0,0 coordinate is taken from top left
+/// \param bboxList: A tensor contaning bounding box tensors
+/// \param bboxCount: total Number of bounding boxes - required within caller function to run update loop
+/// \param pad_top: Total amount of padding applied to image top
+/// \param pad_left: Total amount of padding applied to image left side
 Status PadBBoxes(const std::shared_ptr<Tensor> *bboxList, const size_t &bboxCount, int32_t pad_top, int32_t pad_left);
 
-// Updates bounding boxes for an Image Resize Operation - Takes in set of valid BBoxes
-// For e.g those that remain after a crop
-// @param bboxList: A tensor contaning bounding box tensors
-// @param bboxCount: total Number of bounding boxes - required within caller function to run update loop
-// @param bboxList: A tensor contaning bounding box tensors
-// @param target_width_: required width of image post resize
-// @param target_width_: required height of image post resize
-// @param orig_width: current width of image pre resize
-// @param orig_height: current height of image pre resize
+/// \brief Updates bounding boxes for an Image Resize Operation - Takes in set of valid BBoxes
+/// For e.g those that remain after a crop
+/// \param bboxList: A tensor contaning bounding box tensors
+/// \param bboxCount: total Number of bounding boxes - required within caller function to run update loop
+/// \param bboxList: A tensor contaning bounding box tensors
+/// \param target_width_: required width of image post resize
+/// \param target_width_: required height of image post resize
+/// \param orig_width: current width of image pre resize
+/// \param orig_height: current height of image pre resize
 Status UpdateBBoxesForResize(const std::shared_ptr<Tensor> &bboxList, const size_t &bboxCount, int32_t target_width_,
                              int32_t target_height_, int orig_width, int orig_height);
 
-// Get jpeg image width and height
-// @param input: CVTensor containing the not decoded image 1D bytes
-// @param img_width: the jpeg image width
-// @param img_height: the jpeg image height
+/// \brief Get jpeg image width and height
+/// \param input: CVTensor containing the not decoded image 1D bytes
+/// \param img_width: the jpeg image width
+/// \param img_height: the jpeg image height
 Status GetJpegImageInfo(const std::shared_ptr<Tensor> &input, int *img_width, int *img_height);
 
 }  // namespace dataset

mindspore/ccsrc/minddata/dataset/kernels/image/rgba_to_bgr_op.cc

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2020 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "minddata/dataset/kernels/image/rgba_to_bgr_op.h"
+
+#include "minddata/dataset/kernels/image/image_utils.h"
+#include "minddata/dataset/util/status.h"
+
+namespace mindspore {
+namespace dataset {
+
+Status RgbaToBgrOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
+  IO_CHECK(input, output);
+  return RgbaToBgr(input, output);
+}
+}  // namespace dataset
+}  // namespace mindspore

mindspore/ccsrc/minddata/dataset/kernels/image/rgba_to_bgr_op.h

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2020 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_RGBA_TO_BGR_OP_H_
+#define MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_RGBA_TO_BGR_OP_H_
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#include "minddata/dataset/core/tensor.h"
+#include "minddata/dataset/kernels/image/image_utils.h"
+#include "minddata/dataset/kernels/tensor_op.h"
+#include "minddata/dataset/util/status.h"
+
+namespace mindspore {
+namespace dataset {
+class RgbaToBgrOp : public TensorOp {
+ public:
+  RgbaToBgrOp() {}
+
+  ~RgbaToBgrOp() override = default;
+
+  Status Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) override;
+
+  std::string Name() const override { return kRgbaToBgrOp; }
+};
+}  // namespace dataset
+}  // namespace mindspore
+
+#endif  // MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_RGBA_TO_BGR_OP_H_

mindspore/ccsrc/minddata/dataset/kernels/image/rgba_to_rgb_op.cc

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2020 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "minddata/dataset/kernels/image/rgba_to_rgb_op.h"
+
+#include "minddata/dataset/kernels/image/image_utils.h"
+#include "minddata/dataset/util/status.h"
+
+namespace mindspore {
+namespace dataset {
+
+Status RgbaToRgbOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
+  IO_CHECK(input, output);
+  return RgbaToRgb(input, output);
+}
+}  // namespace dataset
+}  // namespace mindspore

mindspore/ccsrc/minddata/dataset/kernels/image/rgba_to_rgb_op.h

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2020 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_RGBA_TO_RGB_OP_H_
+#define MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_RGBA_TO_RGB_OP_H_
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#include "minddata/dataset/core/tensor.h"
+#include "minddata/dataset/kernels/image/image_utils.h"
+#include "minddata/dataset/kernels/tensor_op.h"
+#include "minddata/dataset/util/status.h"
+
+namespace mindspore {
+namespace dataset {
+class RgbaToRgbOp : public TensorOp {
+ public:
+  RgbaToRgbOp() {}
+
+  ~RgbaToRgbOp() override = default;
+
+  Status Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) override;
+
+  std::string Name() const override { return kRgbaToRgbOp; }
+};
+}  // namespace dataset
+}  // namespace mindspore
+
+#endif  // MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_RGBA_TO_RGB_OP_H_

mindspore/ccsrc/minddata/dataset/kernels/image/swap_red_blue_op.h

@@ -29,14 +29,7 @@ namespace mindspore {
 namespace dataset {
 class SwapRedBlueOp : public TensorOp {
  public:
-  // SwapRedBlues the image to the output specified size. If only one value is provided,
-  // the it will crop the smaller size and maintains the aspect ratio.
-  // @param size1: the first size of output. If only this parameter is provided
-  // the smaller dimension will be cropd to this and then the other dimension changes
-  // such that the aspect ratio is maintained.
-  // @param size2: the second size of output. If this is also provided, the output size
-  // will be (size1, size2)
-  // @param InterpolationMode: the interpolation mode being used.
+  /// \brief Constructor
   SwapRedBlueOp() {}
 
   SwapRedBlueOp(const SwapRedBlueOp &rhs) = default;
@@ -45,7 +38,7 @@ class SwapRedBlueOp : public TensorOp {
 
   ~SwapRedBlueOp() override = default;
 
-  void Print(std::ostream &out) const override { out << "SwapRedBlueOp x"; }
+  void Print(std::ostream &out) const override { out << "SwapRedBlueOp"; }
 
   Status Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) override;
 

mindspore/ccsrc/minddata/dataset/kernels/tensor_op.h

@@ -121,8 +121,10 @@ constexpr char kRescaleOp[] = "RescaleOp";
 constexpr char kResizeBilinearOp[] = "ResizeBilinearOp";
 constexpr char kResizeOp[] = "ResizeOp";
 constexpr char kResizeWithBBoxOp[] = "ResizeWithBBoxOp";
-constexpr char kSolarizeOp[] = "SolarizeOp";
+constexpr char kRgbaToBgrOp[] = "RgbaToBgrOp";
+constexpr char kRgbaToRgbOp[] = "RgbaToRgbOp";
 constexpr char kSharpnessOp[] = "SharpnessOp";
+constexpr char kSolarizeOp[] = "SolarizeOp";
 constexpr char kSwapRedBlueOp[] = "SwapRedBlueOp";
 constexpr char kUniformAugOp[] = "UniformAugOp";
 constexpr char kSoftDvppDecodeRandomCropResizeJpegOp[] = "SoftDvppDecodeRandomCropResizeJpegOp";

tests/ut/cpp/dataset/CMakeLists.txt

@@ -55,12 +55,14 @@ SET(DE_UT_SRCS
         random_vertical_flip_with_bbox_op_test.cc
         rename_op_test.cc
         repeat_op_test.cc
-        skip_op_test.cc
         rescale_op_test.cc
         resize_bilinear_op_test.cc
         resize_op_test.cc
         resize_with_bbox_op_test.cc
+	rgba_to_bgr_op_test.cc
+	rgba_to_rgb_op_test.cc
         schema_test.cc
+        skip_op_test.cc
         shuffle_op_test.cc
         stand_alone_samplers_test.cc
         status_test.cc

tests/ut/cpp/dataset/rgba_to_bgr_op_test.cc

@@ -0,0 +1,62 @@
+/**
+ * Copyright 2020 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <opencv2/imgcodecs.hpp>
+#include "common/common.h"
+#include "common/cvop_common.h"
+#include "minddata/dataset/kernels/image/rgba_to_bgr_op.h"
+#include "minddata/dataset/core/cv_tensor.h"
+#include "utils/log_adapter.h"
+
+using namespace mindspore::dataset;
+using mindspore::MsLogLevel::INFO;
+using mindspore::ExceptionType::NoExceptionType;
+using mindspore::LogStream;
+
+class MindDataTestRgbaToBgrOp : public UT::CVOP::CVOpCommon {
+ protected:
+  MindDataTestRgbaToBgrOp() : CVOpCommon() {}
+
+  std::shared_ptr<Tensor> output_tensor_;
+};
+
+TEST_F(MindDataTestRgbaToBgrOp, TestOp1) {
+  MS_LOG(INFO) << "Doing testRGBA2BGR.";
+  std::unique_ptr<RgbaToBgrOp> op(new RgbaToBgrOp());
+  EXPECT_TRUE(op->OneToOne());
+  // prepare 4 channel image
+  cv::Mat rgba_image;
+  // First create the image with alpha channel
+  cv::cvtColor(raw_cv_image_, rgba_image, cv::COLOR_BGR2RGBA);
+  std::vector<cv::Mat>channels(4);
+  cv::split(rgba_image, channels);
+  channels[3] = cv::Mat::zeros(rgba_image.rows, rgba_image.cols, CV_8UC1);
+  cv::merge(channels, rgba_image);
+  // create new tensor to test conversion
+  std::shared_ptr<Tensor> rgba_input;
+  std::shared_ptr<CVTensor> input_cv_tensor;
+  CVTensor::CreateFromMat(rgba_image, &input_cv_tensor);
+  rgba_input = std::dynamic_pointer_cast<Tensor>(input_cv_tensor);
+
+  Status s = op->Compute(rgba_input, &output_tensor_);
+  size_t actual = 0;
+  if (s == Status::OK()) {
+    actual = output_tensor_->shape()[0] * output_tensor_->shape()[1] * output_tensor_->shape()[2];
+  }
+  EXPECT_EQ(actual, input_tensor_->shape()[0] * input_tensor_->shape()[1] * 3);
+  EXPECT_EQ(s, Status::OK());
+}
+

tests/ut/cpp/dataset/rgba_to_rgb_op_test.cc

@@ -0,0 +1,62 @@
+/**
+ * Copyright 2020 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <opencv2/imgcodecs.hpp>
+#include "common/common.h"
+#include "common/cvop_common.h"
+#include "minddata/dataset/kernels/image/rgba_to_rgb_op.h"
+#include "minddata/dataset/core/cv_tensor.h"
+#include "utils/log_adapter.h"
+
+using namespace mindspore::dataset;
+using mindspore::MsLogLevel::INFO;
+using mindspore::ExceptionType::NoExceptionType;
+using mindspore::LogStream;
+
+class MindDataTestRgbaToRgbOp : public UT::CVOP::CVOpCommon {
+ protected:
+  MindDataTestRgbaToRgbOp() : CVOpCommon() {}
+
+  std::shared_ptr<Tensor> output_tensor_;
+};
+
+TEST_F(MindDataTestRgbaToRgbOp, TestOp1) {
+  MS_LOG(INFO) << "Doing testRGBA2RGB.";
+  std::unique_ptr<RgbaToRgbOp> op(new RgbaToRgbOp());
+  EXPECT_TRUE(op->OneToOne());
+  // prepare 4 channel image
+  cv::Mat rgba_image;
+  // First create the image with alpha channel
+  cv::cvtColor(raw_cv_image_, rgba_image, cv::COLOR_BGR2RGBA);
+  std::vector<cv::Mat>channels(4);
+  cv::split(rgba_image, channels);
+  channels[3] = cv::Mat::zeros(rgba_image.rows, rgba_image.cols, CV_8UC1);
+  cv::merge(channels, rgba_image);
+  // create new tensor to test conversion
+  std::shared_ptr<Tensor> rgba_input;
+  std::shared_ptr<CVTensor> input_cv_tensor;
+  CVTensor::CreateFromMat(rgba_image, &input_cv_tensor);
+  rgba_input = std::dynamic_pointer_cast<Tensor>(input_cv_tensor);
+
+  Status s = op->Compute(rgba_input, &output_tensor_);
+  size_t actual = 0;
+  if (s == Status::OK()) {
+    actual = output_tensor_->shape()[0] * output_tensor_->shape()[1] * output_tensor_->shape()[2];
+  }
+  EXPECT_EQ(actual, input_tensor_->shape()[0] * input_tensor_->shape()[1] * 3);
+  EXPECT_EQ(s, Status::OK());
+}
+