p60975123
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!11834 [MD] Fix error msg description of dataset 

From: @xiefangqi
Reviewed-by: @liucunwei,@heleiwang
Signed-off-by: @liucunwei
This commit is contained in:
mindspore-ci-bot 2021-01-30 14:49:24 +08:00 committed by Gitee
parent 2a7cce39a4 3d72282f26
commit 794af6d094
23 changed files with 160 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
mindspore/ccsrc/minddata/dataset/engine/datasetops/batch_op.cc
View File

@ -174,6 +174,7 @@ Status BatchOp::BatchRows(const std::unique_ptr<TensorQTable> *src, const std::u
if (batch_size == 1) {
TensorRow row = std::move((*src)->front());
row.setPath({});
(*src)->pop_front();
(*dest)->push_back(row);
for (const auto &tensor : (*dest)->front()) {

4
mindspore/ccsrc/minddata/dataset/engine/datasetops/source/cifar_op.cc
View File

@ -457,7 +457,7 @@ Status CifarOp::CountTotalRows(const std::string &dir, const std::string &usage,
for (auto &file : op->cifar_files_) {
Path file_path(file);
CHECK_FAIL_RETURN_UNEXPECTED(file_path.Exists() && !file_path.IsDirectory(),
"Invalid file, failed to open cifar file: " + file);
"Invalid file, failed to open cifar10 file: " + file);
std::string file_name = file_path.Basename();
if (op->usage_ == "train") {
@ -481,7 +481,7 @@ Status CifarOp::CountTotalRows(const std::string &dir, const std::string &usage,
std::string file_name = file_path.Basename();
CHECK_FAIL_RETURN_UNEXPECTED(file_path.Exists() && !file_path.IsDirectory(),
"Invalid file, failed to find cifar file: " + file);
"Invalid file, failed to find cifar100 file: " + file);
if (op->usage_ == "train" && file_path.Basename().find("train") == std::string::npos) continue;
if (op->usage_ == "test" && file_path.Basename().find("test") == std::string::npos) continue;

10
mindspore/ccsrc/minddata/dataset/engine/datasetops/source/coco_op.cc
View File

@ -425,9 +425,13 @@ Status CocoOp::SearchNodeInJson(const nlohmann::json &input_tree, std::string no
}
Status CocoOp::ParseAnnotationIds() {
std::ifstream in(annotation_path_);
nlohmann::json js;
in >> js;
try {
std::ifstream in(annotation_path_);
in >> js;
} catch (const std::exception &err) {
RETURN_STATUS_UNEXPECTED("Invalid file, failed to open json file: " + annotation_path_);
}
std::vector<std::string> image_que;
nlohmann::json image_list;
@ -615,7 +619,7 @@ Status CocoOp::CategoriesColumnLoad(const nlohmann::json &categories_tree) {
if (task_type_ == TaskType::Panoptic) {
auto itr_isthing = category.find(kJsonCategoriesIsthing);
CHECK_FAIL_RETURN_UNEXPECTED(itr_isthing != category.end(),
"Invalid data, no isthing found in categories of " + annotation_path_);
"Invalid data, nothing found in categories of " + annotation_path_);
label_info.push_back(*itr_isthing);
}
label_index_.emplace_back(std::make_pair(name, label_info));

32
mindspore/ccsrc/minddata/dataset/engine/datasetops/source/voc_op.cc
View File

@ -19,7 +19,6 @@
#include <fstream>
#include <iomanip>
#include "./tinyxml2.h"
#include "minddata/dataset/core/config_manager.h"
#include "minddata/dataset/core/tensor_shape.h"
#include "minddata/dataset/engine/datasetops/source/sampler/sequential_sampler.h"
@ -28,9 +27,6 @@
#include "minddata/dataset/engine/opt/pass.h"
#include "utils/ms_utils.h"
using tinyxml2::XMLDocument;
using tinyxml2::XMLElement;
using tinyxml2::XMLError;
namespace mindspore {
namespace dataset {
const char kColumnImage[] = "image";
@ -327,6 +323,14 @@ Status VOCOp::ParseAnnotationIds() {
return Status::OK();
}
void VOCOp::ParseNodeValue(XMLElement *bbox_node, const char *name, float *value) {
*value = 0.0;
if (bbox_node != nullptr) {
XMLElement *node = bbox_node->FirstChildElement(name);
if (node != nullptr) *value = node->FloatText();
}
}
Status VOCOp::ParseAnnotationBbox(const std::string &path) {
if (!Path(path).Exists()) {
RETURN_STATUS_UNEXPECTED("Invalid file, failed to open file: " + path);
@ -350,21 +354,15 @@ Status VOCOp::ParseAnnotationBbox(const std::string &path) {
float xmin = 0.0, ymin = 0.0, xmax = 0.0, ymax = 0.0, truncated = 0.0, difficult = 0.0;
XMLElement *name_node = object->FirstChildElement("name");
if (name_node != nullptr && name_node->GetText() != 0) label_name = name_node->GetText();
XMLElement *truncated_node = object->FirstChildElement("truncated");
if (truncated_node != nullptr) truncated = truncated_node->FloatText();
XMLElement *difficult_node = object->FirstChildElement("difficult");
if (difficult_node != nullptr) difficult = difficult_node->FloatText();
ParseNodeValue(object, "difficult", &difficult);
ParseNodeValue(object, "truncated", &truncated);
XMLElement *bbox_node = object->FirstChildElement("bndbox");
if (bbox_node != nullptr) {
XMLElement *xmin_node = bbox_node->FirstChildElement("xmin");
if (xmin_node != nullptr) xmin = xmin_node->FloatText();
XMLElement *ymin_node = bbox_node->FirstChildElement("ymin");
if (ymin_node != nullptr) ymin = ymin_node->FloatText();
XMLElement *xmax_node = bbox_node->FirstChildElement("xmax");
if (xmax_node != nullptr) xmax = xmax_node->FloatText();
XMLElement *ymax_node = bbox_node->FirstChildElement("ymax");
if (ymax_node != nullptr) ymax = ymax_node->FloatText();
ParseNodeValue(bbox_node, "xmin", &xmin);
ParseNodeValue(bbox_node, "xmax", &xmax);
ParseNodeValue(bbox_node, "ymin", &ymin);
ParseNodeValue(bbox_node, "ymax", &ymax);
} else {
RETURN_STATUS_UNEXPECTED("Invalid data, bndbox dismatch in " + path);
}
@ -406,7 +404,7 @@ Status VOCOp::ReadImageToTensor(const std::string &path, const ColDescriptor &co
if (decode_ == true) {
Status rc = Decode(*tensor, tensor);
if (rc.IsError()) {
RETURN_STATUS_UNEXPECTED("Invalid file, failed to decode file: " + path);
RETURN_STATUS_UNEXPECTED("Invalid data, failed to decode image: " + path);
}
}
return Status::OK();

10
mindspore/ccsrc/minddata/dataset/engine/datasetops/source/voc_op.h
View File

@ -22,6 +22,7 @@
#include <utility>
#include <vector>
#include "./tinyxml2.h"
#include "minddata/dataset/core/tensor.h"
#include "minddata/dataset/engine/data_buffer.h"
#include "minddata/dataset/engine/data_schema.h"
@ -33,6 +34,9 @@
#include "minddata/dataset/util/status.h"
#include "minddata/dataset/util/wait_post.h"
using tinyxml2::XMLDocument;
using tinyxml2::XMLElement;
using tinyxml2::XMLError;
namespace mindspore {
namespace dataset {
// Forward declares
@ -260,6 +264,12 @@ class VOCOp : public ParallelOp, public RandomAccessOp {
// @return Status The status code returned
Status ParseAnnotationBbox(const std::string &path);
// @param XMLElement *bbox_node - bbox node info found in json object
// @param const char *name - sub node name in object
// @param float *value - value of certain sub node
// @return Status The status code returned
void ParseNodeValue(XMLElement *bbox_node, const char *name, float *value);
// @param const std::shared_ptr<Tensor> &sample_ids - sample ids of tensor
// @param std::vector<int64_t> *keys - image id
// @return Status The status code returned

96
mindspore/ccsrc/minddata/dataset/kernels/image/affine_op.cc
View File

@ -45,55 +45,59 @@ AffineOp::AffineOp(float_t degrees, const std::vector<float_t> &translation, flo
Status AffineOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
IO_CHECK(input, output);
float_t translation_x = translation_[0];
float_t translation_y = translation_[1];
float_t degrees = 0.0;
DegreesToRadians(degrees_, &degrees);
float_t shear_x = shear_[0];
float_t shear_y = shear_[1];
DegreesToRadians(shear_x, &shear_x);
DegreesToRadians(-1 * shear_y, &shear_y);
std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
try {
float_t translation_x = translation_[0];
float_t translation_y = translation_[1];
float_t degrees = 0.0;
DegreesToRadians(degrees_, &degrees);
float_t shear_x = shear_[0];
float_t shear_y = shear_[1];
DegreesToRadians(shear_x, &shear_x);
DegreesToRadians(-1 * shear_y, &shear_y);
std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
// Apply Affine Transformation
// T is translation matrix: [1, 0, tx | 0, 1, ty | 0, 0, 1]
// C is translation matrix to keep center: [1, 0, cx | 0, 1, cy | 0, 0, 1]
// RSS is rotation with scale and shear matrix
// RSS(a, s, (sx, sy)) =
// = R(a) * S(s) * SHy(sy) * SHx(sx)
// = [ s*cos(a - sy)/cos(sy), s*(-cos(a - sy)*tan(x)/cos(y) - sin(a)), 0 ]
// [ s*sin(a - sy)/cos(sy), s*(-sin(a - sy)*tan(x)/cos(y) + cos(a)), 0 ]
// [ 0 , 0 , 1 ]
//
// where R is a rotation matrix, S is a scaling matrix, and SHx and SHy are the shears:
// SHx(s) = [1, -tan(s)] and SHy(s) = [1 , 0]
// [0, 1 ] [-tan(s), 1]
//
// Thus, the affine matrix is M = T * C * RSS * C^-1
// Apply Affine Transformation
// T is translation matrix: [1, 0, tx | 0, 1, ty | 0, 0, 1]
// C is translation matrix to keep center: [1, 0, cx | 0, 1, cy | 0, 0, 1]
// RSS is rotation with scale and shear matrix
// RSS(a, s, (sx, sy)) =
// = R(a) * S(s) * SHy(sy) * SHx(sx)
// = [ s*cos(a - sy)/cos(sy), s*(-cos(a - sy)*tan(x)/cos(y) - sin(a)), 0 ]
// [ s*sin(a - sy)/cos(sy), s*(-sin(a - sy)*tan(x)/cos(y) + cos(a)), 0 ]
// [ 0 , 0 , 1 ]
//
// where R is a rotation matrix, S is a scaling matrix, and SHx and SHy are the shears:
// SHx(s) = [1, -tan(s)] and SHy(s) = [1 , 0]
// [0, 1 ] [-tan(s), 1]
//
// Thus, the affine matrix is M = T * C * RSS * C^-1
float_t cx = ((input_cv->mat().cols - 1) / 2.0);
float_t cy = ((input_cv->mat().rows - 1) / 2.0);
// Calculate RSS
std::vector<float_t> matrix{
static_cast<float>(scale_ * cos(degrees + shear_y) / cos(shear_y)),
static_cast<float>(scale_ * (-1 * cos(degrees + shear_y) * tan(shear_x) / cos(shear_y) - sin(degrees))),
0,
static_cast<float>(scale_ * sin(degrees + shear_y) / cos(shear_y)),
static_cast<float>(scale_ * (-1 * sin(degrees + shear_y) * tan(shear_x) / cos(shear_y) + cos(degrees))),
0};
// Compute T * C * RSS * C^-1
matrix[2] = (1 - matrix[0]) * cx - matrix[1] * cy + translation_x;
matrix[5] = (1 - matrix[4]) * cy - matrix[3] * cx + translation_y;
cv::Mat affine_mat(matrix);
affine_mat = affine_mat.reshape(1, {2, 3});
float_t cx = ((input_cv->mat().cols - 1) / 2.0);
float_t cy = ((input_cv->mat().rows - 1) / 2.0);
// Calculate RSS
std::vector<float_t> matrix{
static_cast<float>(scale_ * cos(degrees + shear_y) / cos(shear_y)),
static_cast<float>(scale_ * (-1 * cos(degrees + shear_y) * tan(shear_x) / cos(shear_y) - sin(degrees))),
0,
static_cast<float>(scale_ * sin(degrees + shear_y) / cos(shear_y)),
static_cast<float>(scale_ * (-1 * sin(degrees + shear_y) * tan(shear_x) / cos(shear_y) + cos(degrees))),
0};
// Compute T * C * RSS * C^-1
matrix[2] = (1 - matrix[0]) * cx - matrix[1] * cy + translation_x;
matrix[5] = (1 - matrix[4]) * cy - matrix[3] * cx + translation_y;
cv::Mat affine_mat(matrix);
affine_mat = affine_mat.reshape(1, {2, 3});
std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &output_cv));
RETURN_UNEXPECTED_IF_NULL(output_cv);
cv::warpAffine(input_cv->mat(), output_cv->mat(), affine_mat, input_cv->mat().size(),
GetCVInterpolationMode(interpolation_), cv::BORDER_CONSTANT,
cv::Scalar(fill_value_[0], fill_value_[1], fill_value_[2]));
(*output) = std::static_pointer_cast<Tensor>(output_cv);
std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &output_cv));
RETURN_UNEXPECTED_IF_NULL(output_cv);
cv::warpAffine(input_cv->mat(), output_cv->mat(), affine_mat, input_cv->mat().size(),
GetCVInterpolationMode(interpolation_), cv::BORDER_CONSTANT,
cv::Scalar(fill_value_[0], fill_value_[1], fill_value_[2]));
(*output) = std::static_pointer_cast<Tensor>(output_cv);
} catch (const cv::Exception &e) {
RETURN_STATUS_UNEXPECTED("Affine: " + std::string(e.what()));
}
return Status::OK();
}
} // namespace dataset

2
mindspore/ccsrc/minddata/dataset/kernels/image/bounding_box.cc
View File

@ -48,7 +48,7 @@ Status BoundingBox::ValidateBoundingBoxes(const TensorRow &image_and_bbox) {
}
if (image_and_bbox[1]->shape().Size() < 2) {
return Status(StatusCode::kBoundingBoxInvalidShape, __LINE__, __FILE__,
"BoundingBox: bounding boxes shape should have at least two dimensions.");
"BoundingBox: bounding boxes should have to be two-dimensional matrix at least.");
}
uint32_t num_of_features = image_and_bbox[1]->shape()[1];
if (num_of_features < 4) {

2
mindspore/ccsrc/minddata/dataset/kernels/image/center_crop_op.cc
View File

@ -34,7 +34,7 @@ Status CenterCropOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_p
std::string err_msg;
std::string err_head = "CenterCrop: ";
dsize_t rank = input->shape().Rank();
err_msg += (rank < 2 || rank > 3) ? "rank received::" + std::to_string(rank) + " Expected: 2 or 3 \t" : "";
err_msg += (rank < 2 || rank > 3) ? "image shape is not <H,W,C> or <H,W> \t" : "";
err_msg += (crop_het_ <= 0 || crop_wid_ <= 0) ? "crop size needs to be positive integers\t" : "";
if (err_msg.length() != 0) RETURN_STATUS_UNEXPECTED(err_head + err_msg);

2
mindspore/ccsrc/minddata/dataset/kernels/image/hwc_to_chw_op.cc
View File

@ -33,7 +33,7 @@ Status HwcToChwOp::OutputShape(const std::vector<TensorShape> &inputs, std::vect
TensorShape out = TensorShape{in[2], in[0], in[1]};
if (inputs[0].Rank() == 3) outputs.emplace_back(out);
if (!outputs.empty()) return Status::OK();
return Status(StatusCode::kUnexpectedError, "HwcToChw: invalid input shape.");
return Status(StatusCode::kUnexpectedError, "HWC2CHW: invalid input shape.");
}
} // namespace dataset
} // namespace mindspore

82
mindspore/ccsrc/minddata/dataset/kernels/image/image_utils.cc
View File

@ -61,6 +61,14 @@ int GetCVBorderType(BorderType type) {
}
}
bool CheckTensorShape(const std::shared_ptr<Tensor> &tensor, const int &channel) {
bool rc = false;
if (tensor->Rank() != 3 || (tensor->shape()[channel] != 1 && tensor->shape()[channel] != 3)) {
rc = true;
}
return rc;
}
Status Flip(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output, int flip_code) {
std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(std::move(input));
@ -99,11 +107,13 @@ Status Resize(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *out
}
cv::Mat in_image = input_cv->mat();
// resize image too large or too small
if (output_height == 0 || output_height > in_image.rows * 1000 || output_width == 0 ||
output_width > in_image.cols * 1000) {
if (output_height > in_image.rows * 1000 || output_width > in_image.cols * 1000) {
std::string err_msg =
"Resize: the resizing width or height 1) is too big, it's up to "
"1000 times the original image; 2) can not be 0.";
"Resize: the resizing width or height is too big, it's 1000 times bigger than the original image.";
return Status(StatusCode::kShapeMisMatch, err_msg);
}
if (output_height == 0 || output_width == 0) {
std::string err_msg = "Resize: the resizing width or height is invalid, width or height is zero.";
return Status(StatusCode::kShapeMisMatch, err_msg);
}
try {
@ -216,7 +226,7 @@ static Status JpegReadScanlines(jpeg_decompress_struct *const cinfo, int max_sca
try {
num_lines_read = jpeg_read_scanlines(cinfo, &scanline_ptr, 1);
} catch (std::runtime_error &e) {
RETURN_STATUS_UNEXPECTED("Decode: jpeg_read_scanlines error.");
RETURN_STATUS_UNEXPECTED("Decode: image decode failed.");
}
if (cinfo->out_color_space == JCS_CMYK && num_lines_read > 0) {
for (int i = 0; i < crop_w; ++i) {
@ -243,11 +253,11 @@ static Status JpegReadScanlines(jpeg_decompress_struct *const cinfo, int max_sca
int copy_status = memcpy_s(buffer, buffer_size, scanline_ptr + offset, stride);
if (copy_status != 0) {
jpeg_destroy_decompress(cinfo);
RETURN_STATUS_UNEXPECTED("Decode: memcpy failed");
RETURN_STATUS_UNEXPECTED("Decode: memcpy failed.");
}
} else {
jpeg_destroy_decompress(cinfo);
std::string err_msg = "Decode: failed to read scanline";
std::string err_msg = "Decode: image decode failed.";
RETURN_STATUS_UNEXPECTED(err_msg);
}
buffer += stride;
@ -271,7 +281,7 @@ static Status JpegSetColorSpace(jpeg_decompress_struct *cinfo) {
return Status::OK();
default:
jpeg_destroy_decompress(cinfo);
std::string err_msg = "Decode: image decompress failed.";
std::string err_msg = "Decode: image decode failed.";
RETURN_STATUS_UNEXPECTED(err_msg);
}
}
@ -390,7 +400,7 @@ Status HwcToChw(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output)
try {
std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
if (!input_cv->mat().data) {
RETURN_STATUS_UNEXPECTED("HwcToChw: load image failed.");
RETURN_STATUS_UNEXPECTED("HWC2CHW: load image failed.");
}
if (input_cv->Rank() == 2) {
// If input tensor is 2D, we assume we have hw dimensions
@ -400,7 +410,7 @@ Status HwcToChw(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output)
int num_channels = input_cv->shape()[2];
if (input_cv->shape().Size() < 2 || input_cv->shape().Size() > 3 ||
(input_cv->shape().Size() == 3 && num_channels != 3 && num_channels != 1)) {
RETURN_STATUS_UNEXPECTED("HwcToChw: invalid image shape: number of channels does not equal 3 nor 1");
RETURN_STATUS_UNEXPECTED("HWC2CHW: image shape is not <H,W,C>.");
}
cv::Mat output_img;
@ -417,19 +427,19 @@ Status HwcToChw(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output)
*output = std::move(output_cv);
return Status::OK();
} catch (const cv::Exception &e) {
RETURN_STATUS_UNEXPECTED("HwcToChw: " + std::string(e.what()));
RETURN_STATUS_UNEXPECTED("HWC2CHW: " + std::string(e.what()));
}
}
Status MaskWithTensor(const std::shared_ptr<Tensor> &sub_mat, std::shared_ptr<Tensor> *input, int x, int y,
int crop_width, int crop_height, ImageFormat image_format) {
if (image_format == ImageFormat::HWC) {
if ((*input)->Rank() != 3 || ((*input)->shape()[2] != 1 && (*input)->shape()[2] != 3)) {
if (CheckTensorShape(*input, 2)) {
RETURN_STATUS_UNEXPECTED(
"CutMixBatch: MaskWithTensor failed: "
"input shape doesn't match <H,W,C> format.");
}
if (sub_mat->Rank() != 3 || (sub_mat->shape()[2] != 1 && sub_mat->shape()[2] != 3)) {
if (CheckTensorShape(sub_mat, 2)) {
RETURN_STATUS_UNEXPECTED(
"CutMixBatch: MaskWithTensor failed: "
"sub_mat shape doesn't match <H,W,C> format.");
@ -443,12 +453,12 @@ Status MaskWithTensor(const std::shared_ptr<Tensor> &sub_mat, std::shared_ptr<Te
}
}
} else if (image_format == ImageFormat::CHW) {
if ((*input)->Rank() != 3 || ((*input)->shape()[0] != 1 && (*input)->shape()[0] != 3)) {
if (CheckTensorShape(*input, 0)) {
RETURN_STATUS_UNEXPECTED(
"CutMixBatch: MaskWithTensor failed: "
"input shape doesn't match <C,H,W> format.");
}
if (sub_mat->Rank() != 3 || (sub_mat->shape()[0] != 1 && sub_mat->shape()[0] != 3)) {
if (CheckTensorShape(sub_mat, 0)) {
RETURN_STATUS_UNEXPECTED(
"CutMixBatch: MaskWithTensor failed: "
"sub_mat shape doesn't match <C,H,W> format.");
@ -512,9 +522,7 @@ Status SwapRedAndBlue(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *ou
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 != 3) {
RETURN_STATUS_UNEXPECTED(
"SwapRedBlue: invalid input shape, "
"number of channels does not equal 3");
RETURN_STATUS_UNEXPECTED("SwapRedBlue: image shape is not <H,W,C>.");
}
std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &output_cv));
@ -616,7 +624,7 @@ Status Normalize(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *
RETURN_STATUS_UNEXPECTED("Normalize: load image failed.");
}
if (input_cv->Rank() != 3) {
RETURN_STATUS_UNEXPECTED("Normalize: only support 3 channels image.");
RETURN_STATUS_UNEXPECTED("Normalize: image shape is not <H,W,C>.");
}
cv::Mat in_image = input_cv->mat();
std::shared_ptr<CVTensor> output_cv;
@ -713,9 +721,7 @@ Status AdjustBrightness(const std::shared_ptr<Tensor> &input, std::shared_ptr<Te
}
int num_channels = input_cv->shape()[2];
if (input_cv->Rank() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED(
"AdjustBrightness: image shape is incorrect: "
"number of channels does not equal 3");
RETURN_STATUS_UNEXPECTED("AdjustBrightness: image shape is not <H,W,C>.");
}
std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &output_cv));
@ -732,13 +738,11 @@ Status AdjustContrast(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tens
std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
cv::Mat input_img = input_cv->mat();
if (!input_cv->mat().data) {
RETURN_STATUS_UNEXPECTED("AdjustContrast: ");
RETURN_STATUS_UNEXPECTED("AdjustContrast: load image failed.");
}
int num_channels = input_cv->shape()[2];
if (input_cv->Rank() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED(
"AdjustContrast: image shape is incorrect: "
"number of channels does not equal 3");
RETURN_STATUS_UNEXPECTED("AdjustContrast: image shape is not <H,W,C>.");
}
cv::Mat gray, output_img;
cv::cvtColor(input_img, gray, CV_RGB2GRAY);
@ -773,7 +777,7 @@ Status AutoContrast(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor
// 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("AutoContrast: the number of channels is not 1 or 3.");
RETURN_STATUS_UNEXPECTED("AutoContrast: image shape is not <H,W,C>.");
}
cv::Mat image = input_cv->mat();
// Separate the image to channels
@ -843,9 +847,7 @@ Status AdjustSaturation(const std::shared_ptr<Tensor> &input, std::shared_ptr<Te
}
int num_channels = input_cv->shape()[2];
if (input_cv->Rank() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED(
"AdjustSaturation: image shape is incorrect: "
"number of channels does not equal 3");
RETURN_STATUS_UNEXPECTED("AdjustSaturation: image shape is not <H,W,C>.");
}
std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &output_cv));
@ -873,7 +875,7 @@ Status AdjustHue(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *
}
int num_channels = input_cv->shape()[2];
if (input_cv->Rank() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED("AdjustHue: number of channels does not equal 3");
RETURN_STATUS_UNEXPECTED("AdjustHue: image shape is not <H,W,C>.");
}
std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &output_cv));
@ -912,7 +914,7 @@ Status Equalize(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *o
// 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("Equalize: number of channels is not 1 or 3.");
RETURN_STATUS_UNEXPECTED("Equalize: image shape is not <H,W,C>.");
}
cv::Mat image = input_cv->mat();
// Separate the image to channels
@ -944,17 +946,17 @@ Status Erase(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *outp
std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
int num_channels = input_cv->shape()[2];
if (input_cv->mat().data == nullptr) {
RETURN_STATUS_UNEXPECTED("Erase: load image failed.");
RETURN_STATUS_UNEXPECTED("CutOut: load image failed.");
}
if (input_cv->Rank() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED("Erase: number of channels is not 1 or 3.");
RETURN_STATUS_UNEXPECTED("CutOut: image shape is not <H,W,C> or <H,W>.");
}
cv::Mat input_img = input_cv->mat();
int32_t image_h = input_cv->shape()[0];
int32_t image_w = input_cv->shape()[1];
// check if erase size is bigger than image itself
if (box_height > image_h || box_width > image_w) {
RETURN_STATUS_UNEXPECTED("Erase: box size is too large for image erase");
RETURN_STATUS_UNEXPECTED("CutOut: box size is too large for image erase");
}
// for random color
@ -997,7 +999,7 @@ Status Erase(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *outp
*output = std::static_pointer_cast<Tensor>(input);
return Status::OK();
} catch (const cv::Exception &e) {
RETURN_STATUS_UNEXPECTED("Erase: " + std::string(e.what()));
RETURN_STATUS_UNEXPECTED("CutOut: " + std::string(e.what()));
}
}
@ -1035,8 +1037,8 @@ Status RgbaToRgb(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *
int num_channels = input_cv->shape()[2];
if (input_cv->shape().Size() != 3 || num_channels != 4) {
std::string err_msg =
"RgbaToRgb: Number of channels does not equal 4, "
"got : " +
"RgbaToRgb: Number of channels of image does not equal 4, "
"but got : " +
std::to_string(num_channels);
RETURN_STATUS_UNEXPECTED(err_msg);
}
@ -1057,8 +1059,8 @@ Status RgbaToBgr(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *
int num_channels = input_cv->shape()[2];
if (input_cv->shape().Size() != 3 || num_channels != 4) {
std::string err_msg =
"RgbaToBgr: number of channels does not equal 4, "
"got : " +
"RgbaToBgr: number of channels of image should be 4, "
"but got : " +
std::to_string(num_channels);
RETURN_STATUS_UNEXPECTED(err_msg);
}

6
mindspore/ccsrc/minddata/dataset/kernels/image/image_utils.h
View File

@ -56,6 +56,12 @@ int GetCVInterpolationMode(InterpolationMode mode);
/// \return Status code
int GetCVBorderType(BorderType type);
/// \brief Returns the check result of tensor rank and tensor shape
/// \param[in] tensor: The input tensor need to check
/// \param[in] channel: The channel index of tensor shape.
/// \param[out] return true if channel of tensor shape is 1 or 3.
bool CheckTensorShape(const std::shared_ptr<Tensor> &tensor, const int &channel);
/// \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

2
mindspore/ccsrc/minddata/dataset/kernels/image/random_color_op.cc
View File

@ -26,7 +26,7 @@ RandomColorOp::RandomColorOp(float t_lb, float t_ub) : rnd_(GetSeed()), dist_(t_
Status RandomColorOp::Compute(const std::shared_ptr<Tensor> &in, std::shared_ptr<Tensor> *out) {
IO_CHECK(in, out);
if (in->Rank() != 3) {
RETURN_STATUS_UNEXPECTED("RandomColor: image must have 3 channels");
RETURN_STATUS_UNEXPECTED("RandomColor: image shape is not <H,W,C>.");
}
// 0.5 pixel precision assuming an 8 bit image
const auto eps = 0.00195;

12
mindspore/ccsrc/minddata/dataset/kernels/image/random_crop_op.cc
View File

@ -60,7 +60,7 @@ Status RandomCropOp::ImagePadding(const std::shared_ptr<Tensor> &input, std::sha
CHECK_FAIL_RETURN_UNEXPECTED(pad_top_ < input->shape()[0] * 3 && pad_bottom_ < input->shape()[0] * 3 &&
pad_left_ < input->shape()[1] * 3 && pad_right_ < input->shape()[1] * 3,
"RandomCrop: padding size is too big, it's more than 3 times the original size.");
"Pad: padding size is three times bigger than the image size.");
RETURN_IF_NOT_OK(
Pad(input, pad_image, pad_top_, pad_bottom_, pad_left_, pad_right_, border_type_, fill_r_, fill_g_, fill_b_));
@ -93,9 +93,13 @@ Status RandomCropOp::ImagePadding(const std::shared_ptr<Tensor> &input, std::sha
*padded_image_w = (*pad_image)->shape()[1];
}
if (crop_height_ == 0 || crop_width_ == 0) {
return Status(StatusCode::kShapeMisMatch, __LINE__, __FILE__,
"RandomCrop: invalid crop size, crop dimension is not allowed to be zero.");
}
if (*padded_image_h < crop_height_ || *padded_image_w < crop_width_ || crop_height_ == 0 || crop_width_ == 0) {
return Status(StatusCode::kShapeMisMatch, __LINE__, __FILE__,
"RandomCrop: crop size is greater than the image dimensions or is zero.");
"RandomCrop: invalid crop size, crop size is bigger than the image dimensions.");
}
return Status::OK();
}
@ -109,6 +113,10 @@ void RandomCropOp::GenRandomXY(int *x, int *y, const int32_t &padded_image_w, co
Status RandomCropOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
IO_CHECK(input, output);
if (input->Rank() != 3 && input->Rank() != 2) {
RETURN_STATUS_UNEXPECTED("RandomCrop: image shape is not <H,W,C> or <H,W>.");
}
// Apply padding first then crop
std::shared_ptr<Tensor> pad_image;
int32_t t_pad_top, t_pad_bottom, t_pad_left, t_pad_right;

4
mindspore/ccsrc/minddata/dataset/kernels/image/resize_op.cc
View File

@ -29,9 +29,7 @@ const InterpolationMode ResizeOp::kDefInterpolation = InterpolationMode::kLinear
Status ResizeOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
IO_CHECK(input, output);
CHECK_FAIL_RETURN_UNEXPECTED(
input->shape().Size() >= 2,
"Resize: image shape " + std::to_string(input->shape().Size()) + " is not <H,W,C> or <H,W>.");
CHECK_FAIL_RETURN_UNEXPECTED(input->shape().Size() >= 2, "Resize: image shape is not <H,W,C> or <H,W>.");
int32_t output_h, output_w = 0;
int32_t input_h = static_cast<int>(input->shape()[0]);
int32_t input_w = static_cast<int>(input->shape()[1]);

2
mindspore/ccsrc/minddata/dataset/kernels/image/sharpness_op.cc
View File

@ -41,7 +41,7 @@ Status SharpnessOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_pt
/// 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("Sharpness: number of channels is not 1 or 3.");
RETURN_STATUS_UNEXPECTED("Sharpness: image shape is not <H,W,C>.");
}
/// creating a smoothing filter. 1, 1, 1,

4
mindspore/ccsrc/minddata/dataset/kernels/image/solarize_op.cc
View File

@ -40,12 +40,12 @@ Status SolarizeOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr
}
if (input_cv->Rank() != 2 && input_cv->Rank() != 3) {
RETURN_STATUS_UNEXPECTED("Solarize: image shape is not of either <H,W,C> or <H,W>.");
RETURN_STATUS_UNEXPECTED("Solarize: image shape is not <H,W,C> or <H,W>.");
}
if (input_cv->Rank() == 3) {
int num_channels = input_cv->shape()[2];
if (num_channels != 3 && num_channels != 1) {
RETURN_STATUS_UNEXPECTED("Solarize: number of channels is not 1 or 3.");
RETURN_STATUS_UNEXPECTED("Solarize: image shape is not <H,W,C>.");
}
}

5
mindspore/ccsrc/minddata/dataset/kernels/py_func_op.cc
View File

@ -89,11 +89,12 @@ ComputeReturn:
return ret;
ShapeMisMatch:
ret = Status(StatusCode::kShapeMisMatch, "PyFunc should return a numpy array or a numpy array tuple");
ret =
Status(StatusCode::kShapeMisMatch, __LINE__, __FILE__, "PyFunc should return a numpy array or a numpy array tuple");
goto ComputeReturn;
TimeoutError:
ret = Status(StatusCode::kTimeOut, "PyFunc execute time out");
ret = Status(StatusCode::kTimeOut, __LINE__, __FILE__, "PyFunc execute time out");
goto ComputeReturn;
}

2
mindspore/ccsrc/minddata/dataset/kernels/tensor_op.h
View File

@ -60,7 +60,7 @@ constexpr char kCutOutOp[] = "CutOutOp";
constexpr char kCropOp[] = "CropOp";
constexpr char kDvppDecodeResizeCropJpegOp[] = "DvppDecodeResizeCropJpegOp";
constexpr char kEqualizeOp[] = "EqualizeOp";
constexpr char kHwcToChwOp[] = "HwcToChwOp";
constexpr char kHwcToChwOp[] = "HWC2CHWOp";
constexpr char kInvertOp[] = "InvertOp";
constexpr char kMixUpBatchOp[] = "MixUpBatchOp";
constexpr char kNormalizeOp[] = "NormalizeOp";

2
mindspore/ccsrc/minddata/dataset/util/status.cc
View File

@ -44,7 +44,7 @@ std::string CodeAsString(const StatusCode c) {
s = "Interrupted system call";
break;
case StatusCode::kShapeMisMatch:
s = "Shape is incorrect.";
s = "Shape is incorrect";
break;
case StatusCode::kNoSpace:
s = "No space left on device";

2
tests/ut/python/dataset/test_datasets_coco.py
View File

@ -274,7 +274,7 @@ def test_coco_case_exception():
pass
assert False
except RuntimeError as e:
assert "json.exception.parse_error" in str(e)
assert "failed to open json file" in str(e)
try:
sampler = ds.PKSampler(3)

2
tests/ut/python/dataset/test_random_color_adjust.py
View File

@ -58,7 +58,7 @@ def util_test_random_color_adjust_error(brightness=(1, 1), contrast=(1, 1), satu
c_image = item1["image"]
dataset_shape_1.append(c_image.shape)
error_msg = "number of channels does not equal 3"
error_msg = "image shape is not <H,W,C>"
assert error_msg in str(info.value)

2
tests/ut/python/dataset/test_random_crop.py
View File

@ -261,7 +261,7 @@ def test_random_crop_04_c():
data.create_dict_iterator(num_epochs=1).__next__()
except RuntimeError as e:
logger.info("Got an exception in DE: {}".format(str(e)))
assert "crop size is greater than the image dimensions or is zero" in str(e)
assert "crop size is bigger than the image dimensions" in str(e)
def test_random_crop_04_py():
"""

2
tests/ut/python/dataset/test_random_crop_with_bbox.py
View File

@ -273,7 +273,7 @@ def test_random_crop_with_bbox_op_bad_padding():
break
except RuntimeError as err:
logger.info("Got an exception in DE: {}".format(str(err)))
assert "padding size is too big, it\'s more than 3 times the original size." in str(err)
assert "padding size is three times bigger than the image size" in str(err)
if __name__ == "__main__":