!12553 dataset: Split c_api_vision_test.cc

From: @cathwong
Reviewed-by: @robingrosman,@nsyca
Signed-off-by: @robingrosman

tests/ut/cpp/dataset/CMakeLists.txt

@@ -34,7 +34,13 @@ SET(DE_UT_SRCS
         c_api_text_sentence_piece_vocab_test.cc
         c_api_text_vocab_test.cc
         c_api_transforms_test.cc
-        c_api_vision_test.cc
+        c_api_vision_a_to_q_test.cc
+        c_api_vision_bounding_box_augment_test.cc
+        c_api_vision_random_subselect_policy_test.cc
+        c_api_vision_random_test.cc
+        c_api_vision_r_to_z_test.cc
+        c_api_vision_soft_dvpp_test.cc
+        c_api_vision_uniform_aug_test.cc
         celeba_op_test.cc
         center_crop_op_test.cc
         channel_swap_test.cc

tests/ut/cpp/dataset/c_api_vision_bounding_box_augment_test.cc

@@ -0,0 +1,83 @@
+/**
+ * Copyright 2020-2021 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 "common/common.h"
+#include "minddata/dataset/include/datasets.h"
+#include "minddata/dataset/include/transforms.h"
+#include "minddata/dataset/include/vision.h"
+
+using namespace mindspore::dataset;
+
+class MindDataTestPipeline : public UT::DatasetOpTesting {
+ protected:
+};
+
+// Tests for vision C++ API BoundingBoxAugment TensorTransform Operation
+
+TEST_F(MindDataTestPipeline, TestBoundingBoxAugmentSuccess) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBoundingBoxAugmentSuccess.";
+  // Create an VOC Dataset
+  std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
+  std::shared_ptr<Dataset> ds = VOC(folder_path, "Detection", "train", {}, true, SequentialSampler(0, 3));
+  EXPECT_NE(ds, nullptr);
+
+  /* FIXME - Resolve BoundingBoxAugment to properly handle TensorTransform input
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorTransform> bound_box_augment = std::make_shared<vision::BoundingBoxAugment>(vision::RandomRotation({90.0}), 1.0);
+  EXPECT_NE(bound_box_augment, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({bound_box_augment}, {"image", "bbox"}, {"image", "bbox"}, {"image", "bbox"});
+  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, mindspore::MSTensor> 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, 3);
+  // Manually terminate the pipeline
+  iter->Stop();
+  */
+}
+
+TEST_F(MindDataTestPipeline, TestBoundingBoxAugmentFail) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestBoundingBoxAugmentFail with invalid params.";
+
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  /*
+  // Testing invalid ratio < 0.0
+  std::shared_ptr<TensorTransform> bound_box_augment = std::make_shared<vision::BoundingBoxAugment>(vision::RandomRotation({90.0}), -1.0);
+  EXPECT_EQ(bound_box_augment, nullptr);
+  // Testing invalid ratio > 1.0
+  std::shared_ptr<TensorTransform> bound_box_augment1 = std::make_shared<vision::BoundingBoxAugment>(vision::RandomRotation({90.0}), 2.0);
+  EXPECT_EQ(bound_box_augment1, nullptr);
+  // Testing invalid transform
+  std::shared_ptr<TensorTransform> bound_box_augment2 = std::make_shared<vision::BoundingBoxAugment>(nullptr, 0.5);
+  EXPECT_EQ(bound_box_augment2, nullptr);
+  */
+}

tests/ut/cpp/dataset/c_api_vision_r_to_z_test.cc

@@ -0,0 +1,255 @@
+/**
+ * Copyright 2020-2021 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 "common/common.h"
+#include "minddata/dataset/include/datasets.h"
+#include "minddata/dataset/include/transforms.h"
+#include "minddata/dataset/include/vision.h"
+
+using namespace mindspore::dataset;
+
+class MindDataTestPipeline : public UT::DatasetOpTesting {
+ protected:
+};
+
+// Tests for vision C++ API R to Z TensorTransform Operations (in alphabetical order)
+
+TEST_F(MindDataTestPipeline, TestRescaleSucess1) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRescaleSucess1.";
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, SequentialSampler(0, 1));
+  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, mindspore::MSTensor> row;
+  iter->GetNextRow(&row);
+
+  auto image = row["image"];
+
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorTransform> rescale(new mindspore::dataset::vision::Rescale(1.0, 0.0));
+  EXPECT_NE(rescale, nullptr);
+
+  // Convert to the same type
+  std::shared_ptr<TensorTransform> type_cast(new transforms::TypeCast("uint8"));
+  EXPECT_NE(type_cast, nullptr);
+
+  ds = ds->Map({rescale, type_cast}, {"image"});
+  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> iter1 = ds->CreateIterator();
+  EXPECT_NE(iter1, nullptr);
+
+  // Iterate the dataset and get each row1
+  std::unordered_map<std::string, mindspore::MSTensor> row1;
+  iter1->GetNextRow(&row1);
+
+  auto image1 = row1["image"];
+
+  // EXPECT_EQ(*image, *image1);
+
+  // Manually terminate the pipeline
+  iter1->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestRescaleSucess2) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRescaleSucess2 with different params.";
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, RandomSampler(false, 1));
+  EXPECT_NE(ds, nullptr);
+
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorTransform> rescale(new mindspore::dataset::vision::Rescale(1.0 / 255, 1.0));
+  EXPECT_NE(rescale, nullptr);
+
+  ds = ds->Map({rescale}, {"image"});
+  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, mindspore::MSTensor> 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, 1);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestRescaleFail) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRescaleFail with invalid params.";
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  // incorrect negative rescale parameter
+  std::shared_ptr<TensorTransform> rescale(new mindspore::dataset::vision::Rescale(-1.0, 0.0));
+  EXPECT_NE(rescale, nullptr);
+}
+
+TEST_F(MindDataTestPipeline, TestResize1) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestResize1 with single integer input.";
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, RandomSampler(false, 6));
+  EXPECT_NE(ds, nullptr);
+
+  // Create a Repeat operation on ds
+  int32_t repeat_num = 4;
+  ds = ds->Repeat(repeat_num);
+  EXPECT_NE(ds, nullptr);
+
+  // Create resize object with single integer input
+  std::shared_ptr<TensorTransform> resize_op(new vision::Resize({30}));
+  EXPECT_NE(resize_op, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({resize_op});
+  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, mindspore::MSTensor> 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, 24);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestResizeFail) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestResize with invalid parameters.";
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  // negative resize value
+  std::shared_ptr<TensorTransform> resize_op1(new mindspore::dataset::vision::Resize({30, -30}));
+  EXPECT_NE(resize_op1, nullptr);
+  // zero resize value
+  std::shared_ptr<TensorTransform> resize_op2(new mindspore::dataset::vision::Resize({0, 30}));
+  EXPECT_NE(resize_op2, nullptr);
+  // resize with 3 values
+  std::shared_ptr<TensorTransform> resize_op3(new mindspore::dataset::vision::Resize({30, 20, 10}));
+  EXPECT_NE(resize_op3, nullptr);
+}
+
+TEST_F(MindDataTestPipeline, TestResizeWithBBoxSuccess) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestResizeWithBBoxSuccess.";
+  // Create an VOC Dataset
+  std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
+  std::shared_ptr<Dataset> ds = VOC(folder_path, "Detection", "train", {}, true, SequentialSampler(0, 3));
+  EXPECT_NE(ds, nullptr);
+
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorTransform> resize_with_bbox_op(new vision::ResizeWithBBox({30}));
+  EXPECT_NE(resize_with_bbox_op, nullptr);
+
+  std::shared_ptr<TensorTransform> resize_with_bbox_op1(new vision::ResizeWithBBox({30, 30}));
+  EXPECT_NE(resize_with_bbox_op1, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({resize_with_bbox_op, resize_with_bbox_op1}, {"image", "bbox"}, {"image", "bbox"}, {"image", "bbox"});
+  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, mindspore::MSTensor> 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, 3);
+  // Manually terminate the pipeline
+  iter->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestResizeWithBBoxFail) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestResizeWithBBoxFail with invalid parameters.";
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  // Testing negative resize value
+  std::shared_ptr<TensorTransform> resize_with_bbox_op(new vision::ResizeWithBBox({10, -10}));
+  EXPECT_NE(resize_with_bbox_op, nullptr);
+  // Testing negative resize value
+  std::shared_ptr<TensorTransform> resize_with_bbox_op1(new vision::ResizeWithBBox({-10}));
+  EXPECT_NE(resize_with_bbox_op1, nullptr);
+  // Testinig zero resize value
+  std::shared_ptr<TensorTransform> resize_with_bbox_op2(new vision::ResizeWithBBox({0, 10}));
+  EXPECT_NE(resize_with_bbox_op2, nullptr);
+  // Testing resize with 3 values
+  std::shared_ptr<TensorTransform> resize_with_bbox_op3(new vision::ResizeWithBBox({10, 10, 10}));
+  EXPECT_NE(resize_with_bbox_op3, nullptr);
+}
+
+TEST_F(MindDataTestPipeline, TestVisionOperationName) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestVisionOperationName.";
+
+  std::string correct_name;
+
+  // Create object for the tensor op, and check the name
+  /* FIXME - Update and move test to IR level
+  std::shared_ptr<TensorOperation> random_vertical_flip_op = vision::RandomVerticalFlip(0.5);
+  correct_name = "RandomVerticalFlip";
+  EXPECT_EQ(correct_name, random_vertical_flip_op->Name());
+
+  // Create object for the tensor op, and check the name
+  std::shared_ptr<TensorOperation> softDvpp_decode_resize_jpeg_op = vision::SoftDvppDecodeResizeJpeg({1, 1});
+  correct_name = "SoftDvppDecodeResizeJpeg";
+  EXPECT_EQ(correct_name, softDvpp_decode_resize_jpeg_op->Name());
+  */
+}

tests/ut/cpp/dataset/c_api_vision_random_subselect_policy_test.cc

@@ -0,0 +1,97 @@
+/**
+ * Copyright 2020-2021 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 "common/common.h"
+#include "minddata/dataset/include/datasets.h"
+#include "minddata/dataset/include/transforms.h"
+#include "minddata/dataset/include/vision.h"
+
+using namespace mindspore::dataset;
+
+class MindDataTestPipeline : public UT::DatasetOpTesting {
+ protected:
+};
+
+// Tests for vision C++ API RandomSelectSubpolicy TensorTransform Operations
+
+TEST_F(MindDataTestPipeline, TestRandomSelectSubpolicySuccess) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomSelectSubpolicySuccess.";
+
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, RandomSampler(false, 7));
+  EXPECT_NE(ds, nullptr);
+
+  /* FIXME - Resolve RandomSelectSubpolicy to properly handle TensorTransform input
+  // Create objects for the tensor ops
+  // Valid case: TensorTransform is not null and probability is between (0,1)
+  std::shared_ptr<TensorTransform> random_select_subpolicy(new vision::RandomSelectSubpolicy(
+    {{{vision::Invert(), 0.5}, {vision::Equalize(), 0.5}}, {{vision::Resize({15, 15}), 1}}}));
+  EXPECT_NE(random_select_subpolicy, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({random_select_subpolicy});
+  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, mindspore::MSTensor> 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, 7);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+  */
+}
+
+TEST_F(MindDataTestPipeline, TestRandomSelectSubpolicyFail) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomSelectSubpolicyFail.";
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  /* FIXME - Resolve RandomSelectSubpolicy to properly handle TensorTransform input
+  // RandomSelectSubpolicy : probability of transform must be between 0.0 and 1.0
+  std::shared_ptr<TensorTransform> random_select_subpolicy1(new vision::RandomSelectSubpolicy(
+    {{{vision::Invert(), 1.5}, {vision::Equalize(), 0.5}}, {{vision::Resize({15, 15}), 1}}}));
+  EXPECT_NE(random_select_subpolicy1, nullptr);
+
+  // RandomSelectSubpolicy: policy must not be empty
+  std::shared_ptr<TensorTransform> random_select_subpolicy2(new vision::RandomSelectSubpolicy({{{vision::Invert(), 0.5}, {vision::Equalize(), 0.5}}, {{nullptr, 1}}}));
+  EXPECT_NE(random_select_subpolicy2, nullptr);
+
+  // RandomSelectSubpolicy: policy must not be empty
+  std::shared_ptr<TensorTransform> random_select_subpolicy3(new vision::RandomSelectSubpolicy({}));
+  EXPECT_NE(random_select_subpolicy3, nullptr);
+
+  // RandomSelectSubpolicy: policy must not be empty
+  std::shared_ptr<TensorTransform> random_select_subpolicy4(new vision::RandomSelectSubpolicy({{{vision::Invert(), 0.5}, {vision::Equalize(), 0.5}}, {}}));
+  EXPECT_NE(random_select_subpolicy4, nullptr);
+
+  // RandomSelectSubpolicy: policy must not be empty
+  std::shared_ptr<TensorTransform> random_select_subpolicy5(new vision::RandomSelectSubpolicy({{{}, {vision::Equalize(), 0.5}}, {{vision::Resize({15, 15}), 1}}}));
+  EXPECT_NE(random_select_subpolicy5, nullptr);
+  */
+}

tests/ut/cpp/dataset/c_api_vision_soft_dvpp_test.cc

@@ -0,0 +1,256 @@
+/**
+ * Copyright 2020-2021 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 "common/common.h"
+#include "minddata/dataset/include/datasets.h"
+#include "minddata/dataset/include/transforms.h"
+#include "minddata/dataset/include/vision.h"
+
+using namespace mindspore::dataset;
+
+class MindDataTestPipeline : public UT::DatasetOpTesting {
+ protected:
+};
+
+// Tests for vision C++ API SoftDvpp* TensorTransform Operations (in alphabetical order)
+
+TEST_F(MindDataTestPipeline, TestSoftDvppDecodeRandomCropResizeJpegSuccess1) {
+  MS_LOG(INFO)
+    << "Doing MindDataTestPipeline-TestSoftDvppDecodeRandomCropResizeJpegSuccess1 with single integer input.";
+
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, false, RandomSampler(false, 4));
+  EXPECT_NE(ds, nullptr);
+
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorTransform> soft_dvpp_decode_random_crop_resize_jpeg(new
+    vision::SoftDvppDecodeRandomCropResizeJpeg({500}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({soft_dvpp_decode_random_crop_resize_jpeg}, {"image"});
+  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, mindspore::MSTensor> 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();
+    // EXPECT_EQ(image->shape()[0] == 500 && image->shape()[1] == 500, true);
+    iter->GetNextRow(&row);
+  }
+
+  EXPECT_EQ(i, 4);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestSoftDvppDecodeRandomCropResizeJpegSuccess2) {
+  MS_LOG(INFO)
+    << "Doing MindDataTestPipeline-TestSoftDvppDecodeRandomCropResizeJpegSuccess2 with (height, width) input.";
+
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, false, RandomSampler(false, 6));
+  EXPECT_NE(ds, nullptr);
+
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorTransform> soft_dvpp_decode_random_crop_resize_jpeg(new 
+    vision::SoftDvppDecodeRandomCropResizeJpeg({500, 600}, {0.25, 0.75}, {0.5, 1.25}, 20));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({soft_dvpp_decode_random_crop_resize_jpeg}, {"image"});
+  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, mindspore::MSTensor> 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();
+    // EXPECT_EQ(image->shape()[0] == 500 && image->shape()[1] == 600, true);
+    iter->GetNextRow(&row);
+  }
+
+  EXPECT_EQ(i, 6);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestSoftDvppDecodeRandomCropResizeJpegFail) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestSoftDvppDecodeRandomCropResizeJpegFail with incorrect parameters.";
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  // SoftDvppDecodeRandomCropResizeJpeg: size must only contain positive integers
+  auto soft_dvpp_decode_random_crop_resize_jpeg1(new vision::SoftDvppDecodeRandomCropResizeJpeg({-500, 600}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg1, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: size must only contain positive integers
+  auto soft_dvpp_decode_random_crop_resize_jpeg2(new vision::SoftDvppDecodeRandomCropResizeJpeg({-500}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg2, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: size must be a vector of one or two values
+  auto soft_dvpp_decode_random_crop_resize_jpeg3(new vision::SoftDvppDecodeRandomCropResizeJpeg({500, 600, 700}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg3, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: scale must be greater than or equal to 0
+  auto soft_dvpp_decode_random_crop_resize_jpeg4(new vision::SoftDvppDecodeRandomCropResizeJpeg({500}, {-0.1, 0.9}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg4, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: scale must be in the format of (min, max)
+  auto soft_dvpp_decode_random_crop_resize_jpeg5(new vision::SoftDvppDecodeRandomCropResizeJpeg({500}, {0.6, 0.2}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg5, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: scale must be a vector of two values
+  auto soft_dvpp_decode_random_crop_resize_jpeg6(new vision::SoftDvppDecodeRandomCropResizeJpeg({500}, {0.5, 0.6, 0.7}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg6, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: ratio must be greater than or equal to 0
+  auto soft_dvpp_decode_random_crop_resize_jpeg7(new vision::SoftDvppDecodeRandomCropResizeJpeg({500}, {0.5, 0.9}, {-0.2, 0.4}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg7, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: ratio must be in the format of (min, max)
+  auto soft_dvpp_decode_random_crop_resize_jpeg8(new vision::SoftDvppDecodeRandomCropResizeJpeg({500}, {0.5, 0.9}, {0.4, 0.2}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg8, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: ratio must be a vector of two values
+  auto soft_dvpp_decode_random_crop_resize_jpeg9(new vision::SoftDvppDecodeRandomCropResizeJpeg({500}, {0.5, 0.9}, {0.1, 0.2, 0.3}));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg9, nullptr);
+
+  // SoftDvppDecodeRandomCropResizeJpeg: max_attempts must be greater than or equal to 1
+  auto soft_dvpp_decode_random_crop_resize_jpeg10(new vision::SoftDvppDecodeRandomCropResizeJpeg({500}, {0.5, 0.9}, {0.1, 0.2}, 0));
+  EXPECT_NE(soft_dvpp_decode_random_crop_resize_jpeg10, nullptr);
+}
+
+TEST_F(MindDataTestPipeline, TestSoftDvppDecodeResizeJpegSuccess1) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestSoftDvppDecodeResizeJpegSuccess1 with single integer input.";
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, false, RandomSampler(false, 4));
+  EXPECT_NE(ds, nullptr);
+
+  // Create a Repeat operation on ds
+  int32_t repeat_num = 3;
+  ds = ds->Repeat(repeat_num);
+  EXPECT_NE(ds, nullptr);
+
+  // Create SoftDvppDecodeResizeJpeg object with single integer input
+  std::shared_ptr<TensorTransform> soft_dvpp_decode_resize_jpeg_op(new vision::SoftDvppDecodeResizeJpeg({1134}));
+  EXPECT_NE(soft_dvpp_decode_resize_jpeg_op, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({soft_dvpp_decode_resize_jpeg_op});
+  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, mindspore::MSTensor> 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, 12);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestSoftDvppDecodeResizeJpegSuccess2) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestSoftDvppDecodeResizeJpegSuccess2 with (height, width) input.";
+  // Create an ImageFolder Dataset
+  std::string folder_path = datasets_root_path_ + "/testPK/data/";
+  std::shared_ptr<Dataset> ds = ImageFolder(folder_path, false, RandomSampler(false, 2));
+  EXPECT_NE(ds, nullptr);
+
+  // Create SoftDvppDecodeResizeJpeg object with single integer input
+  std::shared_ptr<TensorTransform> soft_dvpp_decode_resize_jpeg_op(new vision::SoftDvppDecodeResizeJpeg({100, 200}));
+  EXPECT_NE(soft_dvpp_decode_resize_jpeg_op, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({soft_dvpp_decode_resize_jpeg_op});
+  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, mindspore::MSTensor> 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, 2);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+}
+
+TEST_F(MindDataTestPipeline, TestSoftDvppDecodeResizeJpegFail) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestSoftDvppDecodeResizeJpegFail with incorrect size.";
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  // CSoftDvppDecodeResizeJpeg: size must be a vector of one or two values
+  std::shared_ptr<TensorTransform> soft_dvpp_decode_resize_jpeg_op1(new vision::SoftDvppDecodeResizeJpeg({}));
+  EXPECT_NE(soft_dvpp_decode_resize_jpeg_op1, nullptr);
+
+  // SoftDvppDecodeResizeJpeg: size must be a vector of one or two values
+  std::shared_ptr<TensorTransform> soft_dvpp_decode_resize_jpeg_op2(new vision::SoftDvppDecodeResizeJpeg({1, 2, 3}));
+  EXPECT_NE(soft_dvpp_decode_resize_jpeg_op2, nullptr);
+
+  // SoftDvppDecodeResizeJpeg: size must only contain positive integers
+  std::shared_ptr<TensorTransform> soft_dvpp_decode_resize_jpeg_op3(new vision::SoftDvppDecodeResizeJpeg({20, -20}));
+  EXPECT_NE(soft_dvpp_decode_resize_jpeg_op3, nullptr);
+
+  // SoftDvppDecodeResizeJpeg: size must only contain positive integers
+  std::shared_ptr<TensorTransform> soft_dvpp_decode_resize_jpeg_op4(new vision::SoftDvppDecodeResizeJpeg({0}));
+  EXPECT_NE(soft_dvpp_decode_resize_jpeg_op4, nullptr);
+}

tests/ut/cpp/dataset/c_api_vision_uniform_aug_test.cc

@@ -0,0 +1,127 @@
+/**
+ * Copyright 2020-2021 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 "common/common.h"
+#include "minddata/dataset/include/datasets.h"
+#include "minddata/dataset/include/transforms.h"
+#include "minddata/dataset/include/vision.h"
+
+using namespace mindspore::dataset;
+
+class MindDataTestPipeline : public UT::DatasetOpTesting {
+ protected:
+};
+
+// Tests for vision UniformAugment
+// Tests for vision C++ API UniformAugment TensorTransform Operations
+
+TEST_F(MindDataTestPipeline, TestUniformAugmentFail1) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestUniformAugmentFail1 with invalid num_ops parameter.";
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  /*
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorTransform> random_crop_op(new vision::RandomCrop({28, 28}));
+  EXPECT_NE(random_crop_op, nullptr);
+
+  std::shared_ptr<TensorTransform> center_crop_op(new vision::CenterCrop({16, 16}));
+  EXPECT_NE(center_crop_op, nullptr);
+
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  // UniformAug: num_ops must be greater than 0
+  std::shared_ptr<TensorTransform> uniform_aug_op1(new vision::UniformAugment({random_crop_op, center_crop_op}, 0));
+  EXPECT_EQ(uniform_aug_op1, nullptr);
+
+  // UniformAug: num_ops must be greater than 0
+  std::shared_ptr<TensorTransform> uniform_aug_op2(new vision::UniformAugment({random_crop_op, center_crop_op}, -1));
+  EXPECT_EQ(uniform_aug_op2, nullptr);
+
+  // UniformAug: num_ops is greater than transforms size
+  std::shared_ptr<TensorTransform> uniform_aug_op3(new vision::UniformAugment({random_crop_op, center_crop_op}, 3));
+  EXPECT_EQ(uniform_aug_op3, nullptr);
+  */
+
+}
+
+TEST_F(MindDataTestPipeline, TestUniformAugmentFail2) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestUniformAugmentFail2 with invalid transform.";
+
+  // FIXME: For error tests, need to check for failure from CreateIterator execution
+  /*
+  // UniformAug: transform ops must not be null
+  std::shared_ptr<TensorTransform> uniform_aug_op1(new vision::UniformAugment({vision::RandomCrop({-28})}, 1));
+  EXPECT_NE(uniform_aug_op1, nullptr);
+
+  // UniformAug: transform ops must not be null
+  std::shared_ptr<TensorTransform> uniform_aug_op2(new vision::UniformAugment({vision::RandomCrop({28}), nullptr}, 2));
+  EXPECT_NE(uniform_aug_op2, nullptr);
+
+  // UniformAug: transform list must not be empty
+  std::shared_ptr<TensorTransform> uniform_aug_op3(new vision::UniformAugment({}, 1));
+  EXPECT_NE(uniform_aug_op3, nullptr);
+  */
+}
+
+TEST_F(MindDataTestPipeline, TestUniformAugWithOps) {
+  MS_LOG(INFO) << "Doing MindDataTestPipeline-TestUniformAugWithOps.";
+
+  // Create a Mnist Dataset
+  std::string folder_path = datasets_root_path_ + "/testMnistData/";
+  std::shared_ptr<Dataset> ds = Mnist(folder_path, "all", RandomSampler(false, 20));
+  EXPECT_NE(ds, nullptr);
+
+  // Create a Repeat operation on ds
+  int32_t repeat_num = 1;
+  ds = ds->Repeat(repeat_num);
+  EXPECT_NE(ds, nullptr);
+
+  // Create objects for the tensor ops
+  std::shared_ptr<TensorTransform> resize_op(new vision::Resize({30, 30}));
+  EXPECT_NE(resize_op, nullptr);
+
+  std::shared_ptr<TensorTransform> random_crop_op(new vision::RandomCrop({28, 28}));
+  EXPECT_NE(random_crop_op, nullptr);
+
+  std::shared_ptr<TensorTransform> center_crop_op(new vision::CenterCrop({16, 16}));
+  EXPECT_NE(center_crop_op, nullptr);
+
+  std::shared_ptr<TensorTransform> uniform_aug_op(new vision::UniformAugment({random_crop_op, center_crop_op}, 2));
+  EXPECT_NE(uniform_aug_op, nullptr);
+
+  // Create a Map operation on ds
+  ds = ds->Map({resize_op, uniform_aug_op});
+  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, mindspore::MSTensor> 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);
+
+  // Manually terminate the pipeline
+  iter->Stop();
+}

tests/ut/cpp/dataset/execute_test.cc

@@ -181,3 +181,34 @@ TEST_F(MindDataTestExecute, TestTransformInputSequential) {
   ASSERT_EQ(image.Shape()[1], 224);
   ASSERT_EQ(image.Shape()[2], 224);
 }
+
+TEST_F(MindDataTestExecute, TestTransformDecodeResizeCenterCrop1) {
+  MS_LOG(INFO) << "Doing MindDataTestExecute-TestTransformDecodeResizeCenterCrop1.";
+  // Test Execute with Decode, Resize and CenterCrop transform ops input using API constructors, with auto pointers
+
+  // Read image
+  std::shared_ptr<mindspore::dataset::Tensor> de_tensor;
+  mindspore::dataset::Tensor::CreateFromFile("data/dataset/apple.jpg", &de_tensor);
+  auto image = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(de_tensor));
+
+  // Define transform operations
+  std::vector<int32_t> resize_paras = {256, 256};
+  std::vector<int32_t> crop_paras = {224, 224};
+  auto decode(new vision::Decode());
+  auto resize(new vision::Resize(resize_paras));
+  auto centercrop(new vision::CenterCrop(crop_paras));
+  auto hwc2chw(new vision::HWC2CHW());
+
+  std::vector<TensorTransform *> op_list = {decode, resize, centercrop, hwc2chw};
+  mindspore::dataset::Execute Transform(op_list, "CPU");
+
+  // Apply transform on image
+  Status rc = Transform(image, &image);
+
+  // Check image info
+  ASSERT_TRUE(rc.IsOk());
+  ASSERT_EQ(image.Shape().size(), 3);
+  ASSERT_EQ(image.Shape()[0], 3);
+  ASSERT_EQ(image.Shape()[1], 224);
+  ASSERT_EQ(image.Shape()[2], 224);
+}