random sharpness cpp op support

mindspore/ccsrc/minddata/dataset/api/python/bindings/dataset/kernels/image/bindings.cc

@@ -43,6 +43,7 @@
 #include "minddata/dataset/kernels/image/random_resize_op.h"
 #include "minddata/dataset/kernels/image/random_resize_with_bbox_op.h"
 #include "minddata/dataset/kernels/image/random_rotation_op.h"
+#include "minddata/dataset/kernels/image/random_sharpness_op.h"
 #include "minddata/dataset/kernels/image/random_select_subpolicy_op.h"
 #include "minddata/dataset/kernels/image/random_solarize_op.h"
 #include "minddata/dataset/kernels/image/random_vertical_flip_op.h"
@@ -333,6 +334,15 @@ PYBIND_REGISTER(RandomRotationOp, 1, ([](const py::module *m) {
                       py::arg("fillG") = RandomRotationOp::kDefFillG, py::arg("fillB") = RandomRotationOp::kDefFillB);
                 }));
 
+PYBIND_REGISTER(RandomSharpnessOp, 1, ([](const py::module *m) {
+                  (void)py::class_<RandomSharpnessOp, TensorOp, std::shared_ptr<RandomSharpnessOp>>(
+                    *m, "RandomSharpnessOp",
+                    "Tensor operation to apply RandomSharpness."
+                    "Takes a range for degrees")
+                    .def(py::init<float, float>(), py::arg("startDegree") = RandomSharpnessOp::kDefStartDegree,
+                         py::arg("endDegree") = RandomSharpnessOp::kDefEndDegree);
+                }));
+
 PYBIND_REGISTER(RandomSelectSubpolicyOp, 1, ([](const py::module *m) {
                   (void)py::class_<RandomSelectSubpolicyOp, TensorOp, std::shared_ptr<RandomSelectSubpolicyOp>>(
                     *m, "RandomSelectSubpolicyOp")

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

@@ -31,6 +31,7 @@
 #include "minddata/dataset/kernels/image/random_crop_op.h"
 #include "minddata/dataset/kernels/image/random_horizontal_flip_op.h"
 #include "minddata/dataset/kernels/image/random_rotation_op.h"
+#include "minddata/dataset/kernels/image/random_sharpness_op.h"
 #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"
@@ -209,6 +210,16 @@ std::shared_ptr<RandomSolarizeOperation> RandomSolarize(uint8_t threshold_min, u
   return op;
 }
 
+// Function to create RandomSharpnessOperation.
+std::shared_ptr<RandomSharpnessOperation> RandomSharpness(std::vector<float> degrees) {
+  auto op = std::make_shared<RandomSharpnessOperation>(degrees);
+  // Input validation
+  if (!op->ValidateParams()) {
+    return nullptr;
+  }
+  return op;
+}
+
 // Function to create RandomVerticalFlipOperation.
 std::shared_ptr<RandomVerticalFlipOperation> RandomVerticalFlip(float prob) {
   auto op = std::make_shared<RandomVerticalFlipOperation>(prob);
@@ -665,6 +676,22 @@ std::shared_ptr<TensorOp> RandomRotationOperation::Build() {
   return tensor_op;
 }
 
+// Function to create RandomSharpness.
+RandomSharpnessOperation::RandomSharpnessOperation(std::vector<float> degrees) : degrees_(degrees) {}
+
+bool RandomSharpnessOperation::ValidateParams() {
+  if (degrees_.empty() || degrees_.size() != 2) {
+    MS_LOG(ERROR) << "RandomSharpness: degrees vector has incorrect size: degrees.size()";
+    return false;
+  }
+  return true;
+}
+
+std::shared_ptr<TensorOp> RandomSharpnessOperation::Build() {
+  std::shared_ptr<RandomSharpnessOp> tensor_op = std::make_shared<RandomSharpnessOp>(degrees_[0], degrees_[1]);
+  return tensor_op;
+}
+
 // RandomSolarizeOperation.
 RandomSolarizeOperation::RandomSolarizeOperation(uint8_t threshold_min, uint8_t threshold_max)
     : threshold_min_(threshold_min), threshold_max_(threshold_max) {}

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

@@ -61,6 +61,7 @@ class RandomColorAdjustOperation;
 class RandomCropOperation;
 class RandomHorizontalFlipOperation;
 class RandomRotationOperation;
+class RandomSharpnessOperation;
 class RandomSolarizeOperation;
 class RandomVerticalFlipOperation;
 class ResizeOperation;
@@ -209,6 +210,13 @@ std::shared_ptr<RandomRotationOperation> RandomRotation(
   std::vector<float> degrees, InterpolationMode resample = InterpolationMode::kNearestNeighbour, bool expand = false,
   std::vector<float> center = {-1, -1}, std::vector<uint8_t> fill_value = {0, 0, 0});
 
+/// \brief Function to create a RandomSharpness TensorOperation.
+/// \notes Tensor operation to perform random sharpness.
+/// \param[in] start_degree - float representing the start of the range to uniformly sample the factor from it.
+/// \param[in] end_degree - float representing the end of the range.
+/// \return Shared pointer to the current TensorOperation.
+std::shared_ptr<RandomSharpnessOperation> RandomSharpness(std::vector<float> degrees = {0.1, 1.9});
+
 /// \brief Function to create a RandomSolarize TensorOperation.
 /// \notes Invert pixels within specified range. If min=max, then it inverts all pixel above that threshold
 /// \param[in] threshold_min - lower limit
@@ -468,6 +476,20 @@ class RandomRotationOperation : public TensorOperation {
   std::vector<uint8_t> fill_value_;
 };
 
+class RandomSharpnessOperation : public TensorOperation {
+ public:
+  explicit RandomSharpnessOperation(std::vector<float> degrees = {0.1, 1.9});
+
+  ~RandomSharpnessOperation() = default;
+
+  std::shared_ptr<TensorOp> Build() override;
+
+  bool ValidateParams() override;
+
+ private:
+  std::vector<float> degrees_;
+};
+
 class RandomVerticalFlipOperation : public TensorOperation {
  public:
   explicit RandomVerticalFlipOperation(float probability = 0.5);

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

@@ -32,9 +32,11 @@ add_library(kernels-image OBJECT
     random_solarize_op.cc
     random_vertical_flip_op.cc
     random_vertical_flip_with_bbox_op.cc
+    random_sharpness_op.cc
     rescale_op.cc
     resize_bilinear_op.cc
     resize_op.cc
+    sharpness_op.cc
     solarize_op.cc
     swap_red_blue_op.cc
     uniform_aug_op.cc

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

@@ -0,0 +1,51 @@
+/**
+ * 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/random_sharpness_op.h"
+#include <random>
+#include "minddata/dataset/kernels/image/sharpness_op.h"
+#include "minddata/dataset/core/cv_tensor.h"
+#include "minddata/dataset/util/random.h"
+#include "minddata/dataset/util/status.h"
+
+namespace mindspore {
+namespace dataset {
+
+const float RandomSharpnessOp::kDefStartDegree = 0.1;
+const float RandomSharpnessOp::kDefEndDegree = 1.9;
+
+/// constructor
+RandomSharpnessOp::RandomSharpnessOp(float start_degree, float end_degree)
+    : start_degree_(start_degree), end_degree_(end_degree) {
+  rnd_.seed(GetSeed());
+}
+
+/// main function call for random sharpness : Generate the random degrees
+Status RandomSharpnessOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
+  IO_CHECK(input, output);
+  float random_double = distribution_(rnd_);
+  /// get the degree sharpness range
+  /// the way this op works (uniform distribution)
+  /// assumption here is that mDegreesEnd > mDegreeStart so we always get positive number
+  float degree_range = (end_degree_ - start_degree_) / 2;
+  float mid = (end_degree_ + start_degree_) / 2;
+  alpha_ = mid + random_double * degree_range;
+
+  SharpnessOp::Compute(input, output);
+  return Status::OK();
+}
+}  // namespace dataset
+}  // namespace mindspore

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

@@ -0,0 +1,56 @@
+/**
+ * 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_IMAGE_RANDOM_SHARPNESS_OP_H_
+#define MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_IMAGE_RANDOM_SHARPNESS_OP_H_
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#include "minddata/dataset/kernels/image/sharpness_op.h"
+#include "minddata/dataset/util/status.h"
+
+namespace mindspore {
+namespace dataset {
+
+class RandomSharpnessOp : public SharpnessOp {
+ public:
+  static const float kDefStartDegree;
+  static const float kDefEndDegree;
+
+  /// Adjust the sharpness of the input image by a random degree within the given range.
+  /// \@param[in] start_degree A float indicating the beginning of the range.
+  /// \@param[in] end_degree A float indicating the end of the range.
+
+  explicit RandomSharpnessOp(float start_degree = kDefStartDegree, const float end_degree = kDefEndDegree);
+  ~RandomSharpnessOp() override = default;
+  void Print(std::ostream &out) const override { out << Name(); }
+
+  Status Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) override;
+
+  std::string Name() const override { return kRandomSharpnessOp; }
+
+ protected:
+  float start_degree_;
+  float end_degree_;
+  std::uniform_real_distribution<float> distribution_{-1.0, 1.0};
+  std::mt19937 rnd_;
+};
+
+}  // namespace dataset
+}  // namespace mindspore
+
+#endif  // MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_IMAGE_RANDOM_SHARPNESS_OP_H_

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

@@ -0,0 +1,84 @@
+/**
+ * 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/sharpness_op.h"
+#include "minddata/dataset/kernels/image/image_utils.h"
+#include "minddata/dataset/core/cv_tensor.h"
+#include "minddata/dataset/util/status.h"
+
+namespace mindspore {
+namespace dataset {
+
+const float SharpnessOp::kDefAlpha = 1.0;
+
+Status SharpnessOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
+  IO_CHECK(input, output);
+
+  try {
+    std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
+    cv::Mat input_img = input_cv->mat();
+    if (!input_cv->mat().data) {
+      RETURN_STATUS_UNEXPECTED("Could not convert to CV Tensor");
+    }
+
+    if (input_cv->Rank() != 3 && input_cv->Rank() != 2) {
+      RETURN_STATUS_UNEXPECTED("Shape not <H,W,C> or <H,W>");
+    }
+
+    /// Get number of channels and image matrix
+    std::size_t num_of_channels = input_cv->shape()[2];
+    if (num_of_channels != 1 && num_of_channels != 3) {
+      RETURN_STATUS_UNEXPECTED("Number of channels is not 1 or 3.");
+    }
+
+    /// creating a smoothing filter. 1, 1, 1,
+    ///                              1, 5, 1,
+    ///                              1, 1, 1
+
+    float filterSum = 13.0;
+    cv::Mat filter = cv::Mat(3, 3, CV_32F, cv::Scalar::all(1.0 / filterSum));
+    filter.at<float>(1, 1) = 5.0 / filterSum;
+
+    /// applying filter on channels
+    cv::Mat result = cv::Mat();
+    cv::filter2D(input_img, result, -1, filter);
+
+    int height = input_cv->shape()[0];
+    int width = input_cv->shape()[1];
+
+    /// restoring the edges
+    input_img.row(0).copyTo(result.row(0));
+    input_img.row(height - 1).copyTo(result.row(height - 1));
+    input_img.col(0).copyTo(result.col(0));
+    input_img.col(width - 1).copyTo(result.col(width - 1));
+
+    /// blend based on alpha : (alpha_ *input_img) +  ((1.0-alpha_) * result);
+    cv::addWeighted(input_img, alpha_, result, 1.0 - alpha_, 0.0, result);
+
+    std::shared_ptr<CVTensor> output_cv;
+    RETURN_IF_NOT_OK(CVTensor::CreateFromMat(result, &output_cv));
+    RETURN_UNEXPECTED_IF_NULL(output_cv);
+
+    *output = std::static_pointer_cast<Tensor>(output_cv);
+  }
+
+  catch (const cv::Exception &e) {
+    RETURN_STATUS_UNEXPECTED("OpenCV error in random sharpness");
+  }
+  return Status::OK();
+}
+}  // namespace dataset
+}  // namespace mindspore

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

@@ -0,0 +1,53 @@
+/**
+ * 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_IMAGE_SHARPNESS_OP_H_
+#define MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_IMAGE_SHARPNESS_OP_H_
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#include "minddata/dataset/core/tensor.h"
+#include "minddata/dataset/kernels/tensor_op.h"
+#include "minddata/dataset/util/status.h"
+
+namespace mindspore {
+namespace dataset {
+class SharpnessOp : public TensorOp {
+ public:
+  /// Default values, also used by bindings.cc
+  static const float kDefAlpha;
+
+  /// This class can be used to adjust the sharpness of an image.
+  /// \@param[in] alpha A float indicating the enhancement factor.
+  /// a factor of 0.0 gives a blurred image, a factor of 1.0 gives the
+  /// original image, and a factor of 2.0 gives a sharpened image.
+
+  explicit SharpnessOp(const float alpha = kDefAlpha) : alpha_(alpha) {}
+
+  ~SharpnessOp() override = default;
+
+  Status Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) override;
+
+  std::string Name() const override { return kSharpnessOp; }
+
+ protected:
+  float alpha_;
+};
+}  // namespace dataset
+}  // namespace mindspore
+
+#endif  // MINDSPORE_CCSRC_MINDDATA_DATASET_KERNELS_IMAGE_SHARPNESS_OP_H_

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

@@ -114,6 +114,7 @@ constexpr char kRandomResizeOp[] = "RandomResizeOp";
 constexpr char kRandomResizeWithBBoxOp[] = "RandomResizeWithBBoxOp";
 constexpr char kRandomRotationOp[] = "RandomRotationOp";
 constexpr char kRandomSolarizeOp[] = "RandomSolarizeOp";
+constexpr char kRandomSharpnessOp[] = "RandomSharpnessOp";
 constexpr char kRandomVerticalFlipOp[] = "RandomVerticalFlipOp";
 constexpr char kRandomVerticalFlipWithBBoxOp[] = "RandomVerticalFlipWithBBoxOp";
 constexpr char kRescaleOp[] = "RescaleOp";
@@ -121,6 +122,7 @@ constexpr char kResizeBilinearOp[] = "ResizeBilinearOp";
 constexpr char kResizeOp[] = "ResizeOp";
 constexpr char kResizeWithBBoxOp[] = "ResizeWithBBoxOp";
 constexpr char kSolarizeOp[] = "SolarizeOp";
+constexpr char kSharpnessOp[] = "SharpnessOp";
 constexpr char kSwapRedBlueOp[] = "SwapRedBlueOp";
 constexpr char kUniformAugOp[] = "UniformAugOp";
 constexpr char kSoftDvppDecodeRandomCropResizeJpegOp[] = "SoftDvppDecodeRandomCropResizeJpegOp";

mindspore/dataset/transforms/vision/c_transforms.py

@@ -48,7 +48,7 @@ from .validators import check_prob, check_crop, check_resize_interpolation, chec
     check_mix_up_batch_c, check_normalize_c, check_random_crop, check_random_color_adjust, check_random_rotation, \
     check_range, check_resize, check_rescale, check_pad, check_cutout, check_uniform_augment_cpp, \
     check_bounding_box_augment_cpp, check_random_select_subpolicy_op, check_auto_contrast, check_random_affine, \
-    check_random_solarize, check_soft_dvpp_decode_random_crop_resize_jpeg, FLOAT_MAX_INTEGER
+    check_random_solarize, check_soft_dvpp_decode_random_crop_resize_jpeg, check_positive_degrees, FLOAT_MAX_INTEGER
 
 DE_C_INTER_MODE = {Inter.NEAREST: cde.InterpolationMode.DE_INTER_NEAREST_NEIGHBOUR,
                    Inter.LINEAR: cde.InterpolationMode.DE_INTER_LINEAR,
@@ -90,6 +90,31 @@ class AutoContrast(cde.AutoContrastOp):
         super().__init__(cutoff, ignore)
 
 
+class RandomSharpness(cde.RandomSharpnessOp):
+    """
+    Adjust the sharpness of the input image by a fixed or random degree. degree of 0.0 gives a blurred image,
+            a degree of 1.0 gives the original image, and a degree of 2.0 gives a sharpened image.
+
+    Args:
+        degrees (sequence): Range of random sharpness adjustment degrees.
+            it should be in (min, max) format. If min=max, then it is a
+            single fixed magnitude operation (default = (0.1, 1.9)).
+
+    Raises:
+        TypeError : If degrees is not a list or tuple.
+        ValueError: If degrees is not positive.
+        ValueError: If degrees is in (max, min) format instead of (min, max).
+
+    Examples:
+         >>>c_transform.RandomSharpness(degrees=(0.2,1.9))
+    """
+
+    @check_positive_degrees
+    def __init__(self, degrees=(0.1, 1.9)):
+        self.degrees = degrees
+        super().__init__(*degrees)
+
+
 class Equalize(cde.EqualizeOp):
     """
     Apply histogram equalization on input image.

mindspore/dataset/transforms/vision/validators.py

@@ -614,14 +614,16 @@ def check_positive_degrees(method):
     @wraps(method)
     def new_method(self, *args, **kwargs):
         [degrees], _ = parse_user_args(method, *args, **kwargs)
-
         if isinstance(degrees, (list, tuple)):
             if len(degrees) != 2:
                 raise ValueError("Degrees must be a sequence with length 2.")
+            for value in degrees:
+                check_value(value, (0., FLOAT_MAX_INTEGER))
             check_positive(degrees[0], "degrees[0]")
             if degrees[0] > degrees[1]:
                 raise ValueError("Degrees should be in (min,max) format. Got (max,min).")
-
+        else:
+            raise TypeError("Degrees should be a tuple or list.")
         return method(self, *args, **kwargs)
 
     return new_method

tests/ut/cpp/dataset/c_api_transforms_test.cc

@@ -34,12 +34,12 @@
 #include "minddata/dataset/include/samplers.h"
 
 using namespace mindspore::dataset::api;
-using mindspore::MsLogLevel::ERROR;
-using mindspore::ExceptionType::NoExceptionType;
 using mindspore::LogStream;
-using mindspore::dataset::Tensor;
-using mindspore::dataset::Status;
 using mindspore::dataset::BorderType;
+using mindspore::dataset::Status;
+using mindspore::dataset::Tensor;
+using mindspore::ExceptionType::NoExceptionType;
+using mindspore::MsLogLevel::ERROR;
 
 class MindDataTestPipeline : public UT::DatasetOpTesting {
  protected:
@@ -308,10 +308,10 @@ TEST_F(MindDataTestPipeline, TestPad) {
 
   uint64_t i = 0;
   while (row.size() != 0) {
-  i++;
+    i++;
-  auto image = row["image"];
+    auto image = row["image"];
-  MS_LOG(INFO) << "Tensor image shape: " << image->shape();
+    MS_LOG(INFO) << "Tensor image shape: " << image->shape();
-  iter->GetNextRow(&row);
+    iter->GetNextRow(&row);
   }
 
   EXPECT_EQ(i, 20);
@@ -358,10 +358,10 @@ TEST_F(MindDataTestPipeline, TestCutOut) {
 
   uint64_t i = 0;
   while (row.size() != 0) {
-  i++;
+    i++;
-  auto image = row["image"];
+    auto image = row["image"];
-  MS_LOG(INFO) << "Tensor image shape: " << image->shape();
+    MS_LOG(INFO) << "Tensor image shape: " << image->shape();
-  iter->GetNextRow(&row);
+    iter->GetNextRow(&row);
   }
 
   EXPECT_EQ(i, 20);
@@ -527,12 +527,12 @@ TEST_F(MindDataTestPipeline, TestRandomColorAdjust) {
   std::shared_ptr<TensorOperation> random_color_adjust1 = vision::RandomColorAdjust({1.0}, {0.0}, {0.5}, {0.5});
   EXPECT_NE(random_color_adjust1, nullptr);
 
-  std::shared_ptr<TensorOperation> random_color_adjust2 = vision::RandomColorAdjust({1.0, 1.0}, {0.0, 0.0}, {0.5, 0.5},
+  std::shared_ptr<TensorOperation> random_color_adjust2 =
-                                                                                    {0.5, 0.5});
+    vision::RandomColorAdjust({1.0, 1.0}, {0.0, 0.0}, {0.5, 0.5}, {0.5, 0.5});
   EXPECT_NE(random_color_adjust2, nullptr);
 
-  std::shared_ptr<TensorOperation> random_color_adjust3 = vision::RandomColorAdjust({0.5, 1.0}, {0.0, 0.5}, {0.25, 0.5},
+  std::shared_ptr<TensorOperation> random_color_adjust3 =
-                                                                             {0.25, 0.5});
+    vision::RandomColorAdjust({0.5, 1.0}, {0.0, 0.5}, {0.25, 0.5}, {0.25, 0.5});
   EXPECT_NE(random_color_adjust3, nullptr);
 
   std::shared_ptr<TensorOperation> random_color_adjust4 = vision::RandomColorAdjust();
@@ -558,10 +558,68 @@ TEST_F(MindDataTestPipeline, TestRandomColorAdjust) {
 
   uint64_t i = 0;
   while (row.size() != 0) {
-  i++;
+    i++;
-  auto image = row["image"];
+    auto image = row["image"];
-  MS_LOG(INFO) << "Tensor image shape: " << image->shape();
+    MS_LOG(INFO) << "Tensor image shape: " << image->shape();
+    iter->GetNextRow(&row);
+  }
+
+  EXPECT_EQ(i, 20);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestRandomSharpness) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomSharpness.";
+
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, RandomSampler(false, 10));
+  EXPECT_NE(ds, nullptr);
+
+  // Create a Repeat operation on ds
+  int32_t repeat_num = 2;
+  ds = ds->Repeat(repeat_num);
+  EXPECT_NE(ds, nullptr);
+
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorOperation> random_sharpness_op_1 = vision::RandomSharpness({0.4, 2.3});
+  EXPECT_NE(random_sharpness_op_1, nullptr);
+
+  std::shared_ptr<TensorOperation> random_sharpness_op_2 = vision::RandomSharpness({});
+  EXPECT_EQ(random_sharpness_op_2, nullptr);
+
+  std::shared_ptr<TensorOperation> random_sharpness_op_3 = vision::RandomSharpness();
+  EXPECT_NE(random_sharpness_op_3, nullptr);
+
+  std::shared_ptr<TensorOperation> random_sharpness_op_4 = vision::RandomSharpness({0.1});
+  EXPECT_EQ(random_sharpness_op_4, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({random_sharpness_op_1, random_sharpness_op_3});
+  EXPECT_NE(ds, nullptr);
+
+  // Create a Batch operation on ds
+  int32_t batch_size = 1;
+  ds = ds->Batch(batch_size);
+  EXPECT_NE(ds, nullptr);
+
+  // Create an iterator over the result of the above dataset
+  // This will trigger the creation of the Execution Tree and launch it.
+  std::shared_ptr<Iterator> iter = ds->CreateIterator();
+  EXPECT_NE(iter, nullptr);
+
+  // Iterate the dataset and get each row
+  std::unordered_map<std::string, std::shared_ptr<Tensor>> row;
   iter->GetNextRow(&row);
+
+  uint64_t i = 0;
+  while (row.size() != 0) {
+    i++;
+    auto image = row["image"];
+    MS_LOG(INFO) << "Tensor image shape: " << image->shape();
+    iter->GetNextRow(&row);
   }
 
   EXPECT_EQ(i, 20);

tests/ut/cpp/dataset/common/cvop_common.cc

@@ -146,6 +146,14 @@ void CVOpCommon::CheckImageShapeAndData(const std::shared_ptr<Tensor> &output_te
       expect_image_path = dir_path + "imagefolder/apple_expect_random_solarize.jpg";
       actual_image_path = dir_path + "imagefolder/apple_actual_random_solarize.jpg";
       break;
+    case kInvert:
+      expect_image_path = dir_path + "imagefolder/apple_expect_invert.jpg";
+      actual_image_path = dir_path + "imagefolder/apple_actual_invert.jpg";
+      break;
+    case kRandomSharpness:
+      expect_image_path = dir_path + "imagefolder/apple_expect_random_sharpness.jpg";
+      actual_image_path = dir_path + "imagefolder/apple_actual_random_sharpness.jpg";
+      break;
     default:
       MS_LOG(INFO) << "Not pass verification! Operation type does not exists.";
       EXPECT_EQ(0, 1);

tests/ut/cpp/dataset/common/cvop_common.h

@@ -39,6 +39,8 @@ class CVOpCommon : public Common {
     kRandomSolarize,
     kTemplate,
     kCrop,
+    kRandomSharpness,
+    kInvert,
     kRandomAffine,
     kAutoContrast,
     kEqualize

tests/ut/cpp/dataset/invert_op_test.cc

@@ -0,0 +1,40 @@
+/**
+ * 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/invert_op.h"
+#include "common/common.h"
+#include "common/cvop_common.h"
+#include "utils/log_adapter.h"
+
+using namespace mindspore::dataset;
+using mindspore::MsLogLevel::INFO;
+using mindspore::ExceptionType::NoExceptionType;
+using mindspore::LogStream;
+
+class MindDataTestInvert : public UT::CVOP::CVOpCommon {
+ public:
+  MindDataTestInvert() : CVOpCommon() {}
+};
+
+TEST_F(MindDataTestInvert, TestOp) {
+  MS_LOG(INFO) << "Doing test Invert.";
+  std::shared_ptr<Tensor> output_tensor;
+  std::unique_ptr<InvertOp> op(new InvertOp());
+  EXPECT_TRUE(op->OneToOne());
+  Status st = op->Compute(input_tensor_, &output_tensor);
+  EXPECT_TRUE(st.IsOk());
+  CheckImageShapeAndData(output_tensor, kInvert);
+  MS_LOG(INFO) << "testInvert end.";
+}

tests/ut/cpp/dataset/random_sharpness_op_test.cc

@@ -0,0 +1,52 @@
+/**
+ * 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/random_sharpness_op.h"
+#include "common/common.h"
+#include "common/cvop_common.h"
+#include "utils/log_adapter.h"
+#include "minddata/dataset/core/config_manager.h"
+#include "minddata/dataset/core/global_context.h"
+
+using namespace mindspore::dataset;
+using mindspore::MsLogLevel::INFO;
+using mindspore::ExceptionType::NoExceptionType;
+using mindspore::LogStream;
+
+class MindDataTestRandomSharpness : public UT::CVOP::CVOpCommon {
+ public:
+  MindDataTestRandomSharpness() : CVOpCommon() {}
+};
+
+TEST_F(MindDataTestRandomSharpness, TestOp) {
+  MS_LOG(INFO) << "Doing test RandomSharpness.";
+  // setting seed here
+  u_int32_t curr_seed = GlobalContext::config_manager()->seed();
+  GlobalContext::config_manager()->set_seed(120);
+  // Sharpness with a factor in range [0.2,1.8]
+  float start_degree = 0.2;
+  float end_degree = 1.8;
+  std::shared_ptr<Tensor> output_tensor;
+  // sharpening
+  std::unique_ptr<RandomSharpnessOp> op(new RandomSharpnessOp(start_degree, end_degree));
+  EXPECT_TRUE(op->OneToOne());
+  Status st = op->Compute(input_tensor_, &output_tensor);
+  EXPECT_TRUE(st.IsOk());
+  CheckImageShapeAndData(output_tensor, kRandomSharpness);
+  // restoring the seed
+  GlobalContext::config_manager()->set_seed(curr_seed);
+  MS_LOG(INFO) << "testRandomSharpness end.";
+}