From 0f0548f21bb8c7ca7e9d38cdbd383174b1a6645d Mon Sep 17 00:00:00 2001 From: eric Date: Wed, 6 May 2020 21:05:12 -0400 Subject: [PATCH] Added test case for grayscale support --- .../dataset/kernels/image/image_utils.cc | 11 ++- tests/ut/python/dataset/test_center_crop.py | 35 ++++++++- tests/ut/python/dataset/test_pad.py | 78 ++++++++++++------- .../dataset/test_random_color_adjust.py | 75 ++++++++++++------ 4 files changed, 144 insertions(+), 55 deletions(-) diff --git a/mindspore/ccsrc/dataset/kernels/image/image_utils.cc b/mindspore/ccsrc/dataset/kernels/image/image_utils.cc index e4570b876d2..19cf0aecd9c 100644 --- a/mindspore/ccsrc/dataset/kernels/image/image_utils.cc +++ b/mindspore/ccsrc/dataset/kernels/image/image_utils.cc @@ -370,6 +370,11 @@ Status HwcToChw(std::shared_ptr input, std::shared_ptr *output) if (!input_cv->mat().data) { RETURN_STATUS_UNEXPECTED("Could not convert to CV Tensor"); } + if (input_cv->Rank() == 2) { + // If input tensor is 2D, we assume we have hw dimensions + *output = input; + return Status::OK(); + } if (input_cv->shape().Size() != 3 && input_cv->shape()[2] != 3) { RETURN_STATUS_UNEXPECTED("The shape is incorrect: number of channels is not equal 3"); } @@ -395,9 +400,6 @@ Status HwcToChw(std::shared_ptr input, std::shared_ptr *output) Status SwapRedAndBlue(std::shared_ptr input, std::shared_ptr *output) { try { std::shared_ptr input_cv = CVTensor::AsCVTensor(std::move(input)); - if (!input_cv->mat().data) { - RETURN_STATUS_UNEXPECTED("Could not convert to CV Tensor"); - } if (input_cv->shape().Size() != 3 && input_cv->shape()[2] != 3) { RETURN_STATUS_UNEXPECTED("The shape is incorrect: number of channels is not equal 3"); } @@ -714,7 +716,10 @@ Status Pad(const std::shared_ptr &input, std::shared_ptr *output } std::shared_ptr output_cv = std::make_shared(out_image); RETURN_UNEXPECTED_IF_NULL(output_cv); + // pad the dimension if shape information is only 2 dimensional, this is grayscale + if (input_cv->Rank() == 3 && input_cv->shape()[2] == 1 && output_cv->Rank() == 2) output_cv->ExpandDim(2); *output = std::static_pointer_cast(output_cv); + return Status::OK(); } catch (const cv::Exception &e) { RETURN_STATUS_UNEXPECTED("Unexpected error in pad"); diff --git a/tests/ut/python/dataset/test_center_crop.py b/tests/ut/python/dataset/test_center_crop.py index e178e8c2bf5..5a418878e63 100644 --- a/tests/ut/python/dataset/test_center_crop.py +++ b/tests/ut/python/dataset/test_center_crop.py @@ -108,9 +108,42 @@ def test_center_crop_comp(height=375, width=375, plot=False): visualize(image, image_cropped) +def test_crop_grayscale(height=375, width=375): + """ + Test that centercrop works with pad and grayscale images + """ + def channel_swap(image): + """ + Py func hack for our pytransforms to work with c transforms + """ + return (image.transpose(1, 2, 0) * 255).astype(np.uint8) + + transforms = [ + py_vision.Decode(), + py_vision.Grayscale(1), + py_vision.ToTensor(), + (lambda image: channel_swap(image)) + ] + + transform = py_vision.ComposeOp(transforms) + data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) + data1 = data1.map(input_columns=["image"], operations=transform()) + + # if input is grayscale, the output dimensions should be single channel + crop_gray = vision.CenterCrop([height, width]) + data1 = data1.map(input_columns=["image"], operations=crop_gray) + + for item1 in data1.create_dict_iterator(): + c_image = item1["image"] + + # check that the image is grayscale + assert (len(c_image.shape) == 3 and c_image.shape[2] == 1) + + if __name__ == "__main__": test_center_crop_op(600, 600) test_center_crop_op(300, 600) test_center_crop_op(600, 300) - test_center_crop_md5(600, 600) + test_center_crop_md5() test_center_crop_comp() + test_crop_grayscale() diff --git a/tests/ut/python/dataset/test_pad.py b/tests/ut/python/dataset/test_pad.py index 4f92242bd6e..449a83ae147 100644 --- a/tests/ut/python/dataset/test_pad.py +++ b/tests/ut/python/dataset/test_pad.py @@ -22,34 +22,11 @@ import numpy as np import mindspore.dataset as ds import mindspore.dataset.transforms.vision.py_transforms as py_vision from mindspore import log as logger +from util import diff_mse DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"] SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json" - -def visualize(first, mse, second): - """ - visualizes the image using DE op and enCV - """ - plt.subplot(141) - plt.imshow(first) - plt.title("c transformed image") - - plt.subplot(142) - plt.imshow(second) - plt.title("py random_color_jitter image") - - plt.subplot(143) - plt.imshow(first - second) - plt.title("Difference image, mse : {}".format(mse)) - plt.show() - - -def diff_mse(in1, in2): - mse = (np.square(in1.astype(float) / 255 - in2.astype(float) / 255)).mean() - return mse * 100 - - def test_pad_op(): """ Test Pad op @@ -77,9 +54,7 @@ def test_pad_op(): data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) data2 = data2.map(input_columns=["image"], operations=transform()) - num_iter = 0 for item1, item2 in zip(data1.create_dict_iterator(), data2.create_dict_iterator()): - num_iter += 1 c_image = item1["image"] py_image = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8) @@ -89,11 +64,60 @@ def test_pad_op(): logger.info("dtype of c_image: {}".format(c_image.dtype)) logger.info("dtype of py_image: {}".format(py_image.dtype)) - diff = c_image - py_image mse = diff_mse(c_image, py_image) logger.info("mse is {}".format(mse)) assert mse < 0.01 +def test_pad_grayscale(): + """ + Tests that the pad works for grayscale images + """ + def channel_swap(image): + """ + Py func hack for our pytransforms to work with c transforms + """ + return (image.transpose(1, 2, 0) * 255).astype(np.uint8) + + transforms = [ + py_vision.Decode(), + py_vision.Grayscale(1), + py_vision.ToTensor(), + (lambda image: channel_swap(image)) + ] + + transform = py_vision.ComposeOp(transforms) + data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) + data1 = data1.map(input_columns=["image"], operations=transform()) + + # if input is grayscale, the output dimensions should be single channel + pad_gray = c_vision.Pad(100, fill_value=(20, 20, 20)) + data1 = data1.map(input_columns=["image"], operations=pad_gray) + dataset_shape_1 = [] + for item1 in data1.create_dict_iterator(): + c_image = item1["image"] + dataset_shape_1.append(c_image.shape) + + # Dataset for comparison + data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) + decode_op = c_vision.Decode() + + # we use the same padding logic + ctrans = [decode_op, pad_gray] + dataset_shape_2 = [] + + data2 = data2.map(input_columns=["image"], operations=ctrans) + + for item2 in data2.create_dict_iterator(): + c_image = item2["image"] + dataset_shape_2.append(c_image.shape) + + for shape1, shape2 in zip(dataset_shape_1, dataset_shape_2): + # validate that the first two dimensions are the same + # we have a little inconsistency here because the third dimension is 1 after py_vision.Grayscale + assert (shape1[0:1] == shape2[0:1]) + + if __name__ == "__main__": test_pad_op() + test_pad_grayscale() diff --git a/tests/ut/python/dataset/test_random_color_adjust.py b/tests/ut/python/dataset/test_random_color_adjust.py index d2ad4f831c1..e03f8dcc409 100644 --- a/tests/ut/python/dataset/test_random_color_adjust.py +++ b/tests/ut/python/dataset/test_random_color_adjust.py @@ -22,6 +22,7 @@ import numpy as np import mindspore.dataset as ds import mindspore.dataset.transforms.vision.py_transforms as py_vision from mindspore import log as logger +from util import diff_mse DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"] SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json" @@ -29,7 +30,7 @@ SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json" def visualize(first, mse, second): """ - visualizes the image using DE op and enCV + visualizes the image using DE op and OpenCV """ plt.subplot(141) plt.imshow(first) @@ -45,12 +46,7 @@ def visualize(first, mse, second): plt.show() -def diff_mse(in1, in2): - mse = (np.square(in1.astype(float) / 255 - in2.astype(float) / 255)).mean() - return mse * 100 - - -def test_random_color_adjust_op_brightness(): +def test_random_color_adjust_op_brightness(plot=False): """ Test RandomColorAdjust op """ @@ -92,15 +88,16 @@ def test_random_color_adjust_op_brightness(): mse = diff_mse(c_image, py_image) logger.info("mse is {}".format(mse)) + + logger.info("random_rotation_op_{}, mse: {}".format(num_iter + 1, mse)) assert mse < 0.01 - # logger.info("random_rotation_op_{}, mse: {}".format(num_iter + 1, mse)) # if mse != 0: # logger.info("mse is: {}".format(mse)) - # Uncomment below line if you want to visualize images - # visualize(c_image, mse, py_image) + if plot: + visualize(c_image, mse, py_image) -def test_random_color_adjust_op_contrast(): +def test_random_color_adjust_op_contrast(plot=False): """ Test RandomColorAdjust op """ @@ -139,11 +136,10 @@ def test_random_color_adjust_op_contrast(): logger.info("dtype of c_image: {}".format(c_image.dtype)) logger.info("dtype of py_image: {}".format(py_image.dtype)) - diff = c_image - py_image logger.info("contrast difference c is : {}".format(c_image[0][0])) logger.info("contrast difference py is : {}".format(py_image[0][0])) - + diff = c_image - py_image logger.info("contrast difference is : {}".format(diff[0][0])) # mse = (np.sum(np.power(diff, 2))) / (c_image.shape[0] * c_image.shape[1]) mse = diff_mse(c_image, py_image) @@ -152,11 +148,11 @@ def test_random_color_adjust_op_contrast(): # logger.info("random_rotation_op_{}, mse: {}".format(num_iter + 1, mse)) # if mse != 0: # logger.info("mse is: {}".format(mse)) - # Uncomment below line if you want to visualize images - # visualize(c_image, mse, py_image) + if plot: + visualize(c_image, mse, py_image) -def test_random_color_adjust_op_saturation(): +def test_random_color_adjust_op_saturation(plot=False): """ Test RandomColorAdjust op """ @@ -197,19 +193,17 @@ def test_random_color_adjust_op_saturation(): logger.info("dtype of c_image: {}".format(c_image.dtype)) logger.info("dtype of py_image: {}".format(py_image.dtype)) - diff = c_image - py_image - mse = diff_mse(c_image, py_image) logger.info("mse is {}".format(mse)) assert mse < 0.01 # logger.info("random_rotation_op_{}, mse: {}".format(num_iter + 1, mse)) # if mse != 0: # logger.info("mse is: {}".format(mse)) - # Uncomment below line if you want to visualize images - # visualize(c_image, mse, py_image) + if plot: + visualize(c_image, mse, py_image) -def test_random_color_adjust_op_hue(): +def test_random_color_adjust_op_hue(plot=False): """ Test RandomColorAdjust op """ @@ -251,13 +245,45 @@ def test_random_color_adjust_op_hue(): logger.info("dtype of py_image: {}".format(py_image.dtype)) # logger.info("dtype of img: {}".format(img.dtype)) - diff = c_image - py_image # mse = (np.sum(np.power(diff, 2))) / (c_image.shape[0] * c_image.shape[1]) mse = diff_mse(c_image, py_image) logger.info("mse is {}".format(mse)) assert mse < 0.01 - # Uncomment below line if you want to visualize images - # visualize(c_image, mse, py_image) + if plot: + visualize(c_image, mse, py_image) + + +def test_random_color_adjust_grayscale(): + """ + Tests that the random color adjust works for grayscale images + """ + def channel_swap(image): + """ + Py func hack for our pytransforms to work with c transforms + """ + return (image.transpose(1, 2, 0) * 255).astype(np.uint8) + + transforms = [ + py_vision.Decode(), + py_vision.Grayscale(1), + py_vision.ToTensor(), + (lambda image: channel_swap(image)) + ] + + transform = py_vision.ComposeOp(transforms) + data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) + data1 = data1.map(input_columns=["image"], operations=transform()) + + # if input is grayscale, the output dimensions should be single channel, the following should fail + random_adjust_op = c_vision.RandomColorAdjust((1, 1), (1, 1), (1, 1), (0.2, 0.2)) + try: + data1 = data1.map(input_columns=["image"], operations=random_adjust_op) + dataset_shape_1 = [] + for item1 in data1.create_dict_iterator(): + c_image = item1["image"] + dataset_shape_1.append(c_image.shape) + except BaseException as e: + logger.info("Got an exception in DE: {}".format(str(e))) if __name__ == "__main__": @@ -265,3 +291,4 @@ if __name__ == "__main__": test_random_color_adjust_op_contrast() test_random_color_adjust_op_saturation() test_random_color_adjust_op_hue() + test_random_color_adjust_grayscale()