diff --git a/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.cc b/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.cc index b0f8cb14fb..ad7d5f8900 100644 --- a/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.cc +++ b/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.cc @@ -222,18 +222,26 @@ bool ResizeBilinear(const LiteMat &src, LiteMat &dst, int dst_w, int dst_h) { if (src.data_type_ != LDataType::UINT8) { return false; } + if (src.channel_ != 3 && src.channel_ != 1) { + return false; + } + if (dst.IsEmpty()) { + (void)dst.Init(dst_w, dst_h, src.channel_, LDataType::UINT8); + } else if (dst.height_ != dst_h || dst.width_ != dst_w || dst.channel_ != src.channel_) { + return false; + } else if (dst.data_type_ != LDataType::UINT8) { + return false; + } else { + } + if (src.channel_ == 3) { - (void)dst.Init(dst_w, dst_h, 3, LDataType::UINT8); const unsigned char *src_start_p = src; unsigned char *dst_start_p = dst; (void)ResizeBilinear3C(src_start_p, src.width_, src.height_, dst_start_p, dst_w, dst_h); - } else if (src.channel_ == 1) { - (void)dst.Init(dst_w, dst_h, 1, LDataType::UINT8); + } else { // channel == 1 const unsigned char *src_start_p = src; unsigned char *dst_start_p = dst; (void)ResizeBilinear1C(src_start_p, src.width_, src.height_, dst_start_p, dst_w, dst_h); - } else { - return false; } return true; } @@ -418,7 +426,13 @@ bool ConvertTo(const LiteMat &src, LiteMat &dst, double scale) { if (scale < 0.0 || scale > 100) { return false; } - (void)dst.Init(src.width_, src.height_, src.channel_, LDataType::FLOAT32); + if (dst.IsEmpty()) { + (void)dst.Init(src.width_, src.height_, src.channel_, LDataType::FLOAT32); + } else if (dst.height_ != src.height_ || dst.width_ != src.width_ || dst.channel_ != src.channel_) { + return false; + } else if (dst.data_type_ != LDataType::FLOAT32) { + return false; + } const unsigned char *src_start_p = src; float *dst_start_p = dst; for (int h = 0; h < src.height_; h++) { @@ -433,11 +447,17 @@ bool ConvertTo(const LiteMat &src, LiteMat &dst, double scale) { } template -static void CropInternal(const LiteMat &src, LiteMat &dst, int x, int y, int w, int h) { +static bool CropInternal(const LiteMat &src, LiteMat &dst, int x, int y, int w, int h) { int dst_h = h; int dst_w = w; int dst_c = src.channel_; - dst.Init(dst_w, dst_h, dst_c, src.data_type_); + if (dst.IsEmpty()) { + dst.Init(dst_w, dst_h, dst_c, src.data_type_); + } else if (dst.height_ != h || dst.width_ != w || dst.channel_ != src.channel_) { + return false; + } else if (dst.data_type_ != src.data_type_) { + return false; + } const T *src_start_p = src; T *dst_start_p = dst; for (int i_h = 0; i_h < dst_h; i_h++) { @@ -445,6 +465,7 @@ static void CropInternal(const LiteMat &src, LiteMat &dst, int x, int y, int w, T *dst_index_p = dst_start_p + i_h * dst_w * dst_c; (void)memcpy(dst_index_p, src_index_p, dst_w * dst_c * sizeof(T)); } + return true; } bool Crop(const LiteMat &src, LiteMat &dst, int x, int y, int w, int h) { @@ -456,9 +477,9 @@ bool Crop(const LiteMat &src, LiteMat &dst, int x, int y, int w, int h) { } if (src.data_type_ == LDataType::UINT8) { - CropInternal(src, dst, x, y, w, h); + return CropInternal(src, dst, x, y, w, h); } else if (src.data_type_ == LDataType::FLOAT32) { - CropInternal(src, dst, x, y, w, h); + return CropInternal(src, dst, x, y, w, h); } else { return false; } @@ -511,8 +532,13 @@ bool SubStractMeanNormalize(const LiteMat &src, LiteMat &dst, const std::vector< if (!CheckMeanAndStd(src.channel_, mean, std)) { return false; } - - dst.Init(src.width_, src.height_, src.channel_, LDataType::FLOAT32); + if (dst.IsEmpty()) { + dst.Init(src.width_, src.height_, src.channel_, LDataType::FLOAT32); + } else if (dst.height_ != src.height_ || dst.width_ != src.width_ || dst.channel_ != src.channel_) { + return false; + } else if (dst.data_type_ != LDataType::FLOAT32) { + return false; + } const float *src_start_p = src; float *dst_start_p = dst; @@ -880,8 +906,14 @@ bool ImplementAffine(LiteMat &src, LiteMat &out_img, const double M[6], std::vec double b2 = -IM[3] * IM[2] - IM[4] * IM[5]; IM[2] = b1; IM[5] = b2; + if (out_img.IsEmpty()) { + out_img.Init(dsize[0], dsize[1], sizeof(Pixel_Type), src.data_type_); + } else if (out_img.height_ != dsize[1] || out_img.width_ != dsize[0] || out_img.channel_ != src.channel_) { + return false; + } else if (out_img.data_type_ != src.data_type_) { + return false; + } - out_img.Init(dsize[0], dsize[1], sizeof(Pixel_Type)); for (int y = 0; y < out_img.height_; y++) { for (int x = 0; x < out_img.width_; x++) { int src_x = IM[0] * x + IM[1] * y + IM[2]; @@ -899,11 +931,35 @@ bool ImplementAffine(LiteMat &src, LiteMat &out_img, const double M[6], std::vec } bool Affine(LiteMat &src, LiteMat &out_img, const double M[6], std::vector dsize, UINT8_C1 borderValue) { - return ImplementAffine(src, out_img, M, dsize, borderValue); + if (src.channel_ == 1 && src.data_type_ == LDataType::UINT8) { + return ImplementAffine(src, out_img, M, dsize, borderValue); + } else { + return false; + } } bool Affine(LiteMat &src, LiteMat &out_img, const double M[6], std::vector dsize, UINT8_C3 borderValue) { - return ImplementAffine(src, out_img, M, dsize, borderValue); + if (src.channel_ == 3 && src.data_type_ == LDataType::UINT8) { + return ImplementAffine(src, out_img, M, dsize, borderValue); + } else { + return false; + } +} + +bool Affine(LiteMat &src, LiteMat &out_img, const double M[6], std::vector dsize, FLOAT32_C1 borderValue) { + if (src.channel_ == 1 && src.data_type_ == LDataType::FLOAT32) { + return ImplementAffine(src, out_img, M, dsize, borderValue); + } else { + return false; + } +} + +bool Affine(LiteMat &src, LiteMat &out_img, const double M[6], std::vector dsize, FLOAT32_C3 borderValue) { + if (src.channel_ == 3 && src.data_type_ == LDataType::FLOAT32) { + return ImplementAffine(src, out_img, M, dsize, borderValue); + } else { + return false; + } } } // namespace dataset diff --git a/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/lite_mat.cc b/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/lite_mat.cc index 2ec4dfd309..b44d8375d7 100644 --- a/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/lite_mat.cc +++ b/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/lite_mat.cc @@ -229,7 +229,7 @@ void LiteMat::Init(int width, int height, int channel, void *p_data, LDataType d ref_count_ = nullptr; } -bool LiteMat::IsEmpty() const { return data_ptr_ == 0 || data_ptr_ == nullptr || c_step_ * channel_ == 0; } +bool LiteMat::IsEmpty() const { return data_ptr_ == nullptr || c_step_ * channel_ == 0; } void LiteMat::Release() { if (ref_count_ && (addRef(ref_count_, -1) == 1)) { @@ -240,7 +240,7 @@ void LiteMat::Release() { delete[] ref_count_; } } - data_ptr_ = 0; + data_ptr_ = nullptr; elem_size_ = 0; width_ = 0; height_ = 0; diff --git a/mindspore/ccsrc/minddata/dataset/kernels/image/lite_image_utils.cc b/mindspore/ccsrc/minddata/dataset/kernels/image/lite_image_utils.cc index 542c69790e..9aaae55fc3 100644 --- a/mindspore/ccsrc/minddata/dataset/kernels/image/lite_image_utils.cc +++ b/mindspore/ccsrc/minddata/dataset/kernels/image/lite_image_utils.cc @@ -267,13 +267,18 @@ Status Crop(const std::shared_ptr &input, std::shared_ptr *outpu int num_channels = input->shape()[2]; shape = shape.AppendDim(num_channels); } + + std::shared_ptr output_tensor; + RETURN_IF_NOT_OK(Tensor::CreateEmpty(shape, input->type(), &output_tensor)); + + uint8_t *buffer = reinterpret_cast(&(*output_tensor->begin())); LiteMat lite_mat_cut; + + lite_mat_cut.Init(w, h, lite_mat_rgb.channel_, reinterpret_cast(buffer), GetLiteCVDataType(input->type())); + bool ret = Crop(lite_mat_rgb, lite_mat_cut, x, y, w, h); CHECK_FAIL_RETURN_UNEXPECTED(ret, "Crop failed in lite cv"); - // create output Tensor based off of lite_mat_cut - std::shared_ptr output_tensor; - RETURN_IF_NOT_OK( - Tensor::CreateFromMemory(shape, input->type(), static_cast(lite_mat_cut.data_ptr_), &output_tensor)); + *output = output_tensor; return Status::OK(); } catch (std::runtime_error &e) { @@ -340,6 +345,14 @@ Status Normalize(const std::shared_ptr &input, std::shared_ptr * const_cast(reinterpret_cast(input->GetBuffer())), GetLiteCVDataType(input->type())); + std::shared_ptr output_tensor; + RETURN_IF_NOT_OK(Tensor::CreateEmpty(input->shape(), DataType(DataType::DE_FLOAT32), &output_tensor)); + + uint8_t *buffer = reinterpret_cast(&(*output_tensor->begin())); + + lite_mat_norm.Init(lite_mat_rgb.width_, lite_mat_rgb.height_, lite_mat_rgb.channel_, + reinterpret_cast(buffer), GetLiteCVDataType(input->type())); + if (input->type() == DataType::DE_UINT8) { LiteMat lite_mat_float; // change input to float @@ -351,10 +364,6 @@ Status Normalize(const std::shared_ptr &input, std::shared_ptr * } CHECK_FAIL_RETURN_UNEXPECTED(ret, "Normalize in lite cv failed"); - // create output Tensor based off of lite_mat_cut - std::shared_ptr output_tensor; - RETURN_IF_NOT_OK(Tensor::CreateFromMemory(input->shape(), DataType(DataType::DE_FLOAT32), - static_cast(lite_mat_norm.data_ptr_), &output_tensor)); *output = output_tensor; } catch (std::runtime_error &e) { RETURN_STATUS_UNEXPECTED("Unexpected error in normalize."); @@ -394,11 +403,17 @@ Status Resize(const std::shared_ptr &input, std::shared_ptr *out } LiteMat lite_mat_resize; + std::shared_ptr output_tensor; + RETURN_IF_NOT_OK(Tensor::CreateEmpty(shape, input->type(), &output_tensor)); + + uint8_t *buffer = reinterpret_cast(&(*output_tensor->begin())); + + lite_mat_resize.Init(output_width, output_height, lite_mat_rgb.channel_, reinterpret_cast(buffer), + GetLiteCVDataType(input->type())); + bool ret = ResizeBilinear(lite_mat_rgb, lite_mat_resize, output_width, output_height); CHECK_FAIL_RETURN_UNEXPECTED(ret, "Resize failed in lite cv"); - std::shared_ptr output_tensor; - RETURN_IF_NOT_OK( - Tensor::CreateFromMemory(shape, input->type(), static_cast(lite_mat_resize.data_ptr_), &output_tensor)); + *output = output_tensor; } catch (std::runtime_error &e) { RETURN_STATUS_UNEXPECTED("Error in image resize."); @@ -426,14 +441,23 @@ Status Pad(const std::shared_ptr &input, std::shared_ptr *output const_cast(reinterpret_cast(input->GetBuffer())), GetLiteCVDataType(input->type())); LiteMat lite_mat_pad; + + std::shared_ptr output_tensor; + + int pad_width = lite_mat_rgb.width_ + pad_left + pad_right; + int pad_height = lite_mat_rgb.height_ + pad_top + pad_bottom; + TensorShape new_shape = TensorShape({pad_height, pad_width, input->shape()[2]}); + RETURN_IF_NOT_OK(Tensor::CreateEmpty(new_shape, input->type(), &output_tensor)); + + uint8_t *buffer = reinterpret_cast(&(*output_tensor->begin())); + + lite_mat_pad.Init(pad_width, pad_height, lite_mat_rgb.channel_, reinterpret_cast(buffer), + GetLiteCVDataType(input->type())); + bool ret = Pad(lite_mat_rgb, lite_mat_pad, pad_top, pad_bottom, pad_left, pad_right, PaddBorderType::PADD_BORDER_CONSTANT, fill_r, fill_g, fill_b); CHECK_FAIL_RETURN_UNEXPECTED(ret, "Pad failed in lite cv"); - // new shape for output tensor - TensorShape new_shape = TensorShape({lite_mat_pad.height_, lite_mat_pad.width_, input->shape()[2]}); - std::shared_ptr output_tensor; - RETURN_IF_NOT_OK( - Tensor::CreateFromMemory(new_shape, input->type(), static_cast(lite_mat_pad.data_ptr_), &output_tensor)); + *output = output_tensor; } catch (std::runtime_error &e) { RETURN_STATUS_UNEXPECTED("Error in image Pad."); @@ -451,7 +475,6 @@ static Status RotateAngleWithOutMirror(const std::shared_ptr &input, std LiteMat lite_mat_rgb(input->shape()[1], input->shape()[0], input->shape()[2], const_cast(reinterpret_cast(input->GetBuffer())), GetLiteCVDataType(input->type())); - LiteMat lite_mat_affine; if (orientation == 3) { height = lite_mat_rgb.height_; @@ -486,14 +509,17 @@ static Status RotateAngleWithOutMirror(const std::shared_ptr &input, std std::vector dsize; dsize.push_back(width); dsize.push_back(height); + LiteMat lite_mat_affine; + std::shared_ptr output_tensor; + TensorShape new_shape = TensorShape({height, width, input->shape()[2]}); + RETURN_IF_NOT_OK(Tensor::CreateEmpty(new_shape, input->type(), &output_tensor)); + uint8_t *buffer = reinterpret_cast(&(*output_tensor->begin())); + lite_mat_affine.Init(width, height, lite_mat_rgb.channel_, reinterpret_cast(buffer), + GetLiteCVDataType(input->type())); + bool ret = Affine(lite_mat_rgb, lite_mat_affine, M, dsize, UINT8_C3(0, 0, 0)); CHECK_FAIL_RETURN_UNEXPECTED(ret, "Rotate failed in lite cv"); - // new shape for output tensor - TensorShape new_shape = TensorShape({lite_mat_affine.height_, lite_mat_affine.width_, input->shape()[2]}); - std::shared_ptr output_tensor; - RETURN_IF_NOT_OK(Tensor::CreateFromMemory(new_shape, input->type(), static_cast(lite_mat_affine.data_ptr_), - &output_tensor)); *output = output_tensor; } catch (std::runtime_error &e) { RETURN_STATUS_UNEXPECTED("Error in image Rotate."); @@ -511,7 +537,7 @@ static Status RotateAngleWithMirror(const std::shared_ptr &input, std::s LiteMat lite_mat_rgb(input->shape()[1], input->shape()[0], input->shape()[2], const_cast(reinterpret_cast(input->GetBuffer())), GetLiteCVDataType(input->type())); - LiteMat lite_mat_affine; + if (orientation == 2) { height = lite_mat_rgb.height_; width = lite_mat_rgb.width_; @@ -553,14 +579,17 @@ static Status RotateAngleWithMirror(const std::shared_ptr &input, std::s std::vector dsize; dsize.push_back(width); dsize.push_back(height); + LiteMat lite_mat_affine; + std::shared_ptr output_tensor; + TensorShape new_shape = TensorShape({height, width, input->shape()[2]}); + RETURN_IF_NOT_OK(Tensor::CreateEmpty(new_shape, input->type(), &output_tensor)); + uint8_t *buffer = reinterpret_cast(&(*output_tensor->begin())); + lite_mat_affine.Init(width, height, lite_mat_rgb.channel_, reinterpret_cast(buffer), + GetLiteCVDataType(input->type())); + bool ret = Affine(lite_mat_rgb, lite_mat_affine, M, dsize, UINT8_C3(0, 0, 0)); CHECK_FAIL_RETURN_UNEXPECTED(ret, "Rotate failed in lite cv"); - // new shape for output tensor - TensorShape new_shape = TensorShape({lite_mat_affine.height_, lite_mat_affine.width_, input->shape()[2]}); - std::shared_ptr output_tensor; - RETURN_IF_NOT_OK(Tensor::CreateFromMemory(new_shape, input->type(), static_cast(lite_mat_affine.data_ptr_), - &output_tensor)); *output = output_tensor; } catch (std::runtime_error &e) { RETURN_STATUS_UNEXPECTED("Error in image Rotate.");