m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fix error msg issue

Browse Source
pull/11834/head
xiefangqi 4 years ago
parent 941cb499d8
commit 3d72282f26
23 changed files with 160 additions and 128 deletions
Show Stats Download Patch File Download Diff File

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

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

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

@ -457,7 +457,7 @@ Status CifarOp::CountTotalRows(const std::string &dir, const std::string &usage,
for (auto &file : op->cifar_files_) { for (auto &file : op->cifar_files_) {
Path file_path(file); Path file_path(file);
CHECK_FAIL_RETURN_UNEXPECTED(file_path.Exists() && !file_path.IsDirectory(), 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(); std::string file_name = file_path.Basename();
if (op->usage_ == "train") { 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(); std::string file_name = file_path.Basename();
CHECK_FAIL_RETURN_UNEXPECTED(file_path.Exists() && !file_path.IsDirectory(), 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_ == "train" && file_path.Basename().find("train") == std::string::npos) continue;
if (op->usage_ == "test" && file_path.Basename().find("test") == std::string::npos) continue; if (op->usage_ == "test" && file_path.Basename().find("test") == std::string::npos) continue;

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

@ -425,9 +425,13 @@ Status CocoOp::SearchNodeInJson(const nlohmann::json &input_tree, std::string no
} }
Status CocoOp::ParseAnnotationIds() { Status CocoOp::ParseAnnotationIds() {
std::ifstream in(annotation_path_);
nlohmann::json js; nlohmann::json js;
try {
std::ifstream in(annotation_path_);
in >> js; 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; std::vector<std::string> image_que;
nlohmann::json image_list; nlohmann::json image_list;
@ -615,7 +619,7 @@ Status CocoOp::CategoriesColumnLoad(const nlohmann::json &categories_tree) {
if (task_type_ == TaskType::Panoptic) { if (task_type_ == TaskType::Panoptic) {
auto itr_isthing = category.find(kJsonCategoriesIsthing); auto itr_isthing = category.find(kJsonCategoriesIsthing);
CHECK_FAIL_RETURN_UNEXPECTED(itr_isthing != category.end(), 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_info.push_back(*itr_isthing);
} }
label_index_.emplace_back(std::make_pair(name, label_info)); label_index_.emplace_back(std::make_pair(name, label_info));

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

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

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

@ -22,6 +22,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "./tinyxml2.h"
#include "minddata/dataset/core/tensor.h" #include "minddata/dataset/core/tensor.h"
#include "minddata/dataset/engine/data_buffer.h" #include "minddata/dataset/engine/data_buffer.h"
#include "minddata/dataset/engine/data_schema.h" #include "minddata/dataset/engine/data_schema.h"
@ -33,6 +34,9 @@
#include "minddata/dataset/util/status.h" #include "minddata/dataset/util/status.h"
#include "minddata/dataset/util/wait_post.h" #include "minddata/dataset/util/wait_post.h"
using tinyxml2::XMLDocument;
using tinyxml2::XMLElement;
using tinyxml2::XMLError;
namespace mindspore { namespace mindspore {
namespace dataset { namespace dataset {
// Forward declares // Forward declares
@ -260,6 +264,12 @@ class VOCOp : public ParallelOp, public RandomAccessOp {
// @return Status The status code returned // @return Status The status code returned
Status ParseAnnotationBbox(const std::string &path); 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 const std::shared_ptr<Tensor> &sample_ids - sample ids of tensor
// @param std::vector<int64_t> *keys - image id // @param std::vector<int64_t> *keys - image id
// @return Status The status code returned // @return Status The status code returned

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

@ -45,6 +45,7 @@ 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) { Status AffineOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
IO_CHECK(input, output); IO_CHECK(input, output);
try {
float_t translation_x = translation_[0]; float_t translation_x = translation_[0];
float_t translation_y = translation_[1]; float_t translation_y = translation_[1];
float_t degrees = 0.0; float_t degrees = 0.0;
@ -94,6 +95,9 @@ Status AffineOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<T
GetCVInterpolationMode(interpolation_), cv::BORDER_CONSTANT, GetCVInterpolationMode(interpolation_), cv::BORDER_CONSTANT,
cv::Scalar(fill_value_[0], fill_value_[1], fill_value_[2])); cv::Scalar(fill_value_[0], fill_value_[1], fill_value_[2]));
(*output) = std::static_pointer_cast<Tensor>(output_cv); (*output) = std::static_pointer_cast<Tensor>(output_cv);
} catch (const cv::Exception &e) {
RETURN_STATUS_UNEXPECTED("Affine: " + std::string(e.what()));
}
return Status::OK(); return Status::OK();
} }
} // namespace dataset } // namespace dataset

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

@ -48,7 +48,7 @@ Status BoundingBox::ValidateBoundingBoxes(const TensorRow &image_and_bbox) {
} }
if (image_and_bbox[1]->shape().Size() < 2) { if (image_and_bbox[1]->shape().Size() < 2) {
return Status(StatusCode::kBoundingBoxInvalidShape, __LINE__, __FILE__, 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]; uint32_t num_of_features = image_and_bbox[1]->shape()[1];
if (num_of_features < 4) { if (num_of_features < 4) {

2
mindspore/ccsrc/minddata/dataset/kernels/image/center_crop_op.cc
Unescape 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_msg;
std::string err_head = "CenterCrop: "; std::string err_head = "CenterCrop: ";
dsize_t rank = input->shape().Rank(); 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" : ""; 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); if (err_msg.length() != 0) RETURN_STATUS_UNEXPECTED(err_head + err_msg);

2
mindspore/ccsrc/minddata/dataset/kernels/image/hwc_to_chw_op.cc
Unescape 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]}; TensorShape out = TensorShape{in[2], in[0], in[1]};
if (inputs[0].Rank() == 3) outputs.emplace_back(out); if (inputs[0].Rank() == 3) outputs.emplace_back(out);
if (!outputs.empty()) return Status::OK(); 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 dataset
} // namespace mindspore } // namespace mindspore

82
mindspore/ccsrc/minddata/dataset/kernels/image/image_utils.cc
Unescape 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) { 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)); 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(); cv::Mat in_image = input_cv->mat();
// resize image too large or too small // resize image too large or too small
if (output_height == 0 || output_height > in_image.rows * 1000 || output_width == 0 || if (output_height > in_image.rows * 1000 || output_width > in_image.cols * 1000) {
output_width > in_image.cols * 1000) {
std::string err_msg = std::string err_msg =
"Resize: the resizing width or height 1) is too big, it's up to " "Resize: the resizing width or height is too big, it's 1000 times bigger than the original image.";
"1000 times the original image; 2) can not be 0."; 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); return Status(StatusCode::kShapeMisMatch, err_msg);
} }
try { try {
@ -216,7 +226,7 @@ static Status JpegReadScanlines(jpeg_decompress_struct *const cinfo, int max_sca
try { try {
num_lines_read = jpeg_read_scanlines(cinfo, &scanline_ptr, 1); num_lines_read = jpeg_read_scanlines(cinfo, &scanline_ptr, 1);
} catch (std::runtime_error &e) { } 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) { if (cinfo->out_color_space == JCS_CMYK && num_lines_read > 0) {
for (int i = 0; i < crop_w; ++i) { 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); int copy_status = memcpy_s(buffer, buffer_size, scanline_ptr + offset, stride);
if (copy_status != 0) { if (copy_status != 0) {
jpeg_destroy_decompress(cinfo); jpeg_destroy_decompress(cinfo);
RETURN_STATUS_UNEXPECTED("Decode: memcpy failed"); RETURN_STATUS_UNEXPECTED("Decode: memcpy failed.");
} }
} else { } else {
jpeg_destroy_decompress(cinfo); 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); RETURN_STATUS_UNEXPECTED(err_msg);
} }
buffer += stride; buffer += stride;
@ -271,7 +281,7 @@ static Status JpegSetColorSpace(jpeg_decompress_struct *cinfo) {
return Status::OK(); return Status::OK();
default: default:
jpeg_destroy_decompress(cinfo); 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); RETURN_STATUS_UNEXPECTED(err_msg);
} }
} }
@ -390,7 +400,7 @@ Status HwcToChw(std::shared_ptr<Tensor> input, std::shared_ptr<Tensor> *output)
try { try {
std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input); std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
if (!input_cv->mat().data) { 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_cv->Rank() == 2) {
// If input tensor is 2D, we assume we have hw dimensions // 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]; int num_channels = input_cv->shape()[2];
if (input_cv->shape().Size() < 2 || input_cv->shape().Size() > 3 || if (input_cv->shape().Size() < 2 || input_cv->shape().Size() > 3 ||
(input_cv->shape().Size() == 3 && num_channels != 3 && num_channels != 1)) { (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; 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); *output = std::move(output_cv);
return Status::OK(); return Status::OK();
} catch (const cv::Exception &e) { } 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, 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) { int crop_width, int crop_height, ImageFormat image_format) {
if (image_format == ImageFormat::HWC) { if (image_format == ImageFormat::HWC) {
if ((*input)->Rank() != 3 || ((*input)->shape()[2] != 1 && (*input)->shape()[2] != 3)) { if (CheckTensorShape(*input, 2)) {
RETURN_STATUS_UNEXPECTED( RETURN_STATUS_UNEXPECTED(
"CutMixBatch: MaskWithTensor failed: " "CutMixBatch: MaskWithTensor failed: "
"input shape doesn't match <H,W,C> format."); "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( RETURN_STATUS_UNEXPECTED(
"CutMixBatch: MaskWithTensor failed: " "CutMixBatch: MaskWithTensor failed: "
"sub_mat shape doesn't match <H,W,C> format."); "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) { } 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( RETURN_STATUS_UNEXPECTED(
"CutMixBatch: MaskWithTensor failed: " "CutMixBatch: MaskWithTensor failed: "
"input shape doesn't match <C,H,W> format."); "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( RETURN_STATUS_UNEXPECTED(
"CutMixBatch: MaskWithTensor failed: " "CutMixBatch: MaskWithTensor failed: "
"sub_mat shape doesn't match <C,H,W> format."); "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)); std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(std::move(input));
int num_channels = input_cv->shape()[2]; int num_channels = input_cv->shape()[2];
if (input_cv->shape().Size() != 3 || num_channels != 3) { if (input_cv->shape().Size() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED( RETURN_STATUS_UNEXPECTED("SwapRedBlue: image shape is not <H,W,C>.");
"SwapRedBlue: invalid input shape, "
"number of channels does not equal 3");
} }
std::shared_ptr<CVTensor> output_cv; std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &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."); RETURN_STATUS_UNEXPECTED("Normalize: load image failed.");
} }
if (input_cv->Rank() != 3) { 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(); cv::Mat in_image = input_cv->mat();
std::shared_ptr<CVTensor> output_cv; 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]; int num_channels = input_cv->shape()[2];
if (input_cv->Rank() != 3 || num_channels != 3) { if (input_cv->Rank() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED( RETURN_STATUS_UNEXPECTED("AdjustBrightness: image shape is not <H,W,C>.");
"AdjustBrightness: image shape is incorrect: "
"number of channels does not equal 3");
} }
std::shared_ptr<CVTensor> output_cv; std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &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); std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
cv::Mat input_img = input_cv->mat(); cv::Mat input_img = input_cv->mat();
if (!input_cv->mat().data) { if (!input_cv->mat().data) {
RETURN_STATUS_UNEXPECTED("AdjustContrast: "); RETURN_STATUS_UNEXPECTED("AdjustContrast: load image failed.");
} }
int num_channels = input_cv->shape()[2]; int num_channels = input_cv->shape()[2];
if (input_cv->Rank() != 3 || num_channels != 3) { if (input_cv->Rank() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED( RETURN_STATUS_UNEXPECTED("AdjustContrast: image shape is not <H,W,C>.");
"AdjustContrast: image shape is incorrect: "
"number of channels does not equal 3");
} }
cv::Mat gray, output_img; cv::Mat gray, output_img;
cv::cvtColor(input_img, gray, CV_RGB2GRAY); 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 // Get number of channels and image matrix
std::size_t num_of_channels = input_cv->shape()[2]; std::size_t num_of_channels = input_cv->shape()[2];
if (num_of_channels != 1 && num_of_channels != 3) { 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(); cv::Mat image = input_cv->mat();
// Separate the image to channels // 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]; int num_channels = input_cv->shape()[2];
if (input_cv->Rank() != 3 || num_channels != 3) { if (input_cv->Rank() != 3 || num_channels != 3) {
RETURN_STATUS_UNEXPECTED( RETURN_STATUS_UNEXPECTED("AdjustSaturation: image shape is not <H,W,C>.");
"AdjustSaturation: image shape is incorrect: "
"number of channels does not equal 3");
} }
std::shared_ptr<CVTensor> output_cv; std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &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]; int num_channels = input_cv->shape()[2];
if (input_cv->Rank() != 3 || num_channels != 3) { 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; std::shared_ptr<CVTensor> output_cv;
RETURN_IF_NOT_OK(CVTensor::CreateEmpty(input_cv->shape(), input_cv->type(), &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 // Get number of channels and image matrix
std::size_t num_of_channels = input_cv->shape()[2]; std::size_t num_of_channels = input_cv->shape()[2];
if (num_of_channels != 1 && num_of_channels != 3) { 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(); cv::Mat image = input_cv->mat();
// Separate the image to channels // 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); std::shared_ptr<CVTensor> input_cv = CVTensor::AsCVTensor(input);
int num_channels = input_cv->shape()[2]; int num_channels = input_cv->shape()[2];
if (input_cv->mat().data == nullptr) { 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) { 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(); cv::Mat input_img = input_cv->mat();
int32_t image_h = input_cv->shape()[0]; int32_t image_h = input_cv->shape()[0];
int32_t image_w = input_cv->shape()[1]; int32_t image_w = input_cv->shape()[1];
// check if erase size is bigger than image itself // check if erase size is bigger than image itself
if (box_height > image_h || box_width > image_w) { 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 // 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); *output = std::static_pointer_cast<Tensor>(input);
return Status::OK(); return Status::OK();
} catch (const cv::Exception &e) { } 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]; int num_channels = input_cv->shape()[2];
if (input_cv->shape().Size() != 3 || num_channels != 4) { if (input_cv->shape().Size() != 3 || num_channels != 4) {
std::string err_msg = std::string err_msg =
"RgbaToRgb: Number of channels does not equal 4, " "RgbaToRgb: Number of channels of image does not equal 4, "
"got : " + "but got : " +
std::to_string(num_channels); std::to_string(num_channels);
RETURN_STATUS_UNEXPECTED(err_msg); 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]; int num_channels = input_cv->shape()[2];
if (input_cv->shape().Size() != 3 || num_channels != 4) { if (input_cv->shape().Size() != 3 || num_channels != 4) {
std::string err_msg = std::string err_msg =
"RgbaToBgr: number of channels does not equal 4, " "RgbaToBgr: number of channels of image should be 4, "
"got : " + "but got : " +
std::to_string(num_channels); std::to_string(num_channels);
RETURN_STATUS_UNEXPECTED(err_msg); RETURN_STATUS_UNEXPECTED(err_msg);
} }

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

@ -56,6 +56,12 @@ int GetCVInterpolationMode(InterpolationMode mode);
/// \return Status code /// \return Status code
int GetCVBorderType(BorderType type); 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 /// \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[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 /// \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
Unescape 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) { Status RandomColorOp::Compute(const std::shared_ptr<Tensor> &in, std::shared_ptr<Tensor> *out) {
IO_CHECK(in, out); IO_CHECK(in, out);
if (in->Rank() != 3) { 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 // 0.5 pixel precision assuming an 8 bit image
const auto eps = 0.00195; const auto eps = 0.00195;

12
mindspore/ccsrc/minddata/dataset/kernels/image/random_crop_op.cc
Unescape 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 && 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, 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( RETURN_IF_NOT_OK(
Pad(input, pad_image, pad_top_, pad_bottom_, pad_left_, pad_right_, border_type_, fill_r_, fill_g_, fill_b_)); 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]; *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) { if (*padded_image_h < crop_height_ || *padded_image_w < crop_width_ || crop_height_ == 0 || crop_width_ == 0) {
return Status(StatusCode::kShapeMisMatch, __LINE__, __FILE__, 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(); 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) { Status RandomCropOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
IO_CHECK(input, 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 // Apply padding first then crop
std::shared_ptr<Tensor> pad_image; std::shared_ptr<Tensor> pad_image;
int32_t t_pad_top, t_pad_bottom, t_pad_left, t_pad_right; int32_t t_pad_top, t_pad_bottom, t_pad_left, t_pad_right;

4
mindspore/ccsrc/minddata/dataset/kernels/image/resize_op.cc
Unescape 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) { Status ResizeOp::Compute(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output) {
IO_CHECK(input, output); IO_CHECK(input, output);
CHECK_FAIL_RETURN_UNEXPECTED( CHECK_FAIL_RETURN_UNEXPECTED(input->shape().Size() >= 2, "Resize: image shape is not <H,W,C> or <H,W>.");
input->shape().Size() >= 2,
"Resize: image shape " + std::to_string(input->shape().Size()) + " is not <H,W,C> or <H,W>.");
int32_t output_h, output_w = 0; int32_t output_h, output_w = 0;
int32_t input_h = static_cast<int>(input->shape()[0]); int32_t input_h = static_cast<int>(input->shape()[0]);
int32_t input_w = static_cast<int>(input->shape()[1]); int32_t input_w = static_cast<int>(input->shape()[1]);

2
mindspore/ccsrc/minddata/dataset/kernels/image/sharpness_op.cc
Unescape 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 /// Get number of channels and image matrix
std::size_t num_of_channels = input_cv->shape()[2]; std::size_t num_of_channels = input_cv->shape()[2];
if (num_of_channels != 1 && num_of_channels != 3) { 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, /// creating a smoothing filter. 1, 1, 1,

4
mindspore/ccsrc/minddata/dataset/kernels/image/solarize_op.cc
Unescape 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) { 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) { if (input_cv->Rank() == 3) {
int num_channels = input_cv->shape()[2]; int num_channels = input_cv->shape()[2];
if (num_channels != 3 && num_channels != 1) { 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
Unescape View File

@ -89,11 +89,12 @@ ComputeReturn:
return ret; return ret;
ShapeMisMatch: 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; goto ComputeReturn;
TimeoutError: TimeoutError:
ret = Status(StatusCode::kTimeOut, "PyFunc execute time out"); ret = Status(StatusCode::kTimeOut, __LINE__, __FILE__, "PyFunc execute time out");
goto ComputeReturn; goto ComputeReturn;
} }

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

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

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

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

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

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

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

@ -58,7 +58,7 @@ def util_test_random_color_adjust_error(brightness=(1, 1), contrast=(1, 1), satu
c_image = item1["image"] c_image = item1["image"]
dataset_shape_1.append(c_image.shape) 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) assert error_msg in str(info.value)

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

@ -261,7 +261,7 @@ def test_random_crop_04_c():
data.create_dict_iterator(num_epochs=1).__next__() data.create_dict_iterator(num_epochs=1).__next__()
except RuntimeError as e: except RuntimeError as e:
logger.info("Got an exception in DE: {}".format(str(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(): def test_random_crop_04_py():
""" """

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

@ -273,7 +273,7 @@ def test_random_crop_with_bbox_op_bad_padding():
break break
except RuntimeError as err: except RuntimeError as err:
logger.info("Got an exception in DE: {}".format(str(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__": if __name__ == "__main__":

Write Preview
Loading…
Cancel
Save