mindspore-Ecosystem
/
mindspore
21
0
Fork 27
Code Issues Pull Requests 6 Projects Releases Wiki Activity

!21015 master pclint warning fix 

Merge pull request !21015 from zetongzhao/warn_fix
This commit is contained in:
i-robot 2021-07-30 21:05:45 +00:00 committed by Gitee
parent 5a58327a2e ca517e4573
commit 36066a8c23
46 changed files with 142 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
mindspore/ccsrc/minddata/dataset/api/python/bindings/dataset/kernels/ir/image/bindings.cc
View File

@ -71,7 +71,7 @@ PYBIND_REGISTER(
AutoContrastOperation, 1, ([](const py::module *m) { AutoContrastOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::AutoContrastOperation, TensorOperation, std::shared_ptr<vision::AutoContrastOperation>>( (void)py::class_<vision::AutoContrastOperation, TensorOperation, std::shared_ptr<vision::AutoContrastOperation>>(
*m, "AutoContrastOperation") *m, "AutoContrastOperation")
.def(py::init([](float cutoff, std::vector<uint32_t> ignore) { .def(py::init([](float cutoff, const std::vector<uint32_t> &ignore) {
auto auto_contrast = std::make_shared<vision::AutoContrastOperation>(cutoff, ignore); auto auto_contrast = std::make_shared<vision::AutoContrastOperation>(cutoff, ignore);
THROW_IF_ERROR(auto_contrast->ValidateParams()); THROW_IF_ERROR(auto_contrast->ValidateParams());
return auto_contrast; return auto_contrast;
@ -82,7 +82,7 @@ PYBIND_REGISTER(BoundingBoxAugmentOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::BoundingBoxAugmentOperation, TensorOperation, (void)py::class_<vision::BoundingBoxAugmentOperation, TensorOperation,
std::shared_ptr<vision::BoundingBoxAugmentOperation>>(*m, std::shared_ptr<vision::BoundingBoxAugmentOperation>>(*m,
"BoundingBoxAugmentOperation") "BoundingBoxAugmentOperation")
.def(py::init([](py::object transform, float ratio) { .def(py::init([](const py::object transform, float ratio) {
auto bounding_box_augment = std::make_shared<vision::BoundingBoxAugmentOperation>( auto bounding_box_augment = std::make_shared<vision::BoundingBoxAugmentOperation>(
std::move(toTensorOperation(transform)), ratio); std::move(toTensorOperation(transform)), ratio);
THROW_IF_ERROR(bounding_box_augment->ValidateParams()); THROW_IF_ERROR(bounding_box_augment->ValidateParams());
@ -94,7 +94,7 @@ PYBIND_REGISTER(
CenterCropOperation, 1, ([](const py::module *m) { CenterCropOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::CenterCropOperation, TensorOperation, std::shared_ptr<vision::CenterCropOperation>>( (void)py::class_<vision::CenterCropOperation, TensorOperation, std::shared_ptr<vision::CenterCropOperation>>(
*m, "CenterCropOperation", "Tensor operation to crop and image in the middle. Takes height and width (optional)") *m, "CenterCropOperation", "Tensor operation to crop and image in the middle. Takes height and width (optional)")
.def(py::init([](std::vector<int32_t> size) { .def(py::init([](const std::vector<int32_t> &size) {
auto center_crop = std::make_shared<vision::CenterCropOperation>(size); auto center_crop = std::make_shared<vision::CenterCropOperation>(size);
THROW_IF_ERROR(center_crop->ValidateParams()); THROW_IF_ERROR(center_crop->ValidateParams());
return center_crop; return center_crop;
@ -104,7 +104,7 @@ PYBIND_REGISTER(
PYBIND_REGISTER(CropOperation, 1, ([](const py::module *m) { PYBIND_REGISTER(CropOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::CropOperation, TensorOperation, std::shared_ptr<vision::CropOperation>>( (void)py::class_<vision::CropOperation, TensorOperation, std::shared_ptr<vision::CropOperation>>(
*m, "CropOperation", "Tensor operation to crop images") *m, "CropOperation", "Tensor operation to crop images")
.def(py::init([](std::vector<int32_t> coordinates, std::vector<int32_t> size) { .def(py::init([](std::vector<int32_t> coordinates, const std::vector<int32_t> &size) {
// In Python API, the order of coordinates is first top then left, which is different from // In Python API, the order of coordinates is first top then left, which is different from
// those in CropOperation. So we need to swap the coordinates. // those in CropOperation. So we need to swap the coordinates.
std::swap(coordinates[0], coordinates[1]); std::swap(coordinates[0], coordinates[1]);
@ -219,7 +219,7 @@ PYBIND_REGISTER(
NormalizeOperation, 1, ([](const py::module *m) { NormalizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::NormalizeOperation, TensorOperation, std::shared_ptr<vision::NormalizeOperation>>( (void)py::class_<vision::NormalizeOperation, TensorOperation, std::shared_ptr<vision::NormalizeOperation>>(
*m, "NormalizeOperation") *m, "NormalizeOperation")
.def(py::init([](std::vector<float> mean, std::vector<float> std) { .def(py::init([](const std::vector<float> &mean, const std::vector<float> &std) {
auto normalize = std::make_shared<vision::NormalizeOperation>(mean, std); auto normalize = std::make_shared<vision::NormalizeOperation>(mean, std);
THROW_IF_ERROR(normalize->ValidateParams()); THROW_IF_ERROR(normalize->ValidateParams());
return normalize; return normalize;
@ -240,8 +240,8 @@ PYBIND_REGISTER(
PYBIND_REGISTER(PadOperation, 1, ([](const py::module *m) { PYBIND_REGISTER(PadOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::PadOperation, TensorOperation, std::shared_ptr<vision::PadOperation>>( (void)py::class_<vision::PadOperation, TensorOperation, std::shared_ptr<vision::PadOperation>>(
*m, "PadOperation") *m, "PadOperation")
.def(py::init( .def(py::init([](const std::vector<int32_t> &padding, const std::vector<uint8_t> &fill_value,
[](std::vector<int32_t> padding, std::vector<uint8_t> fill_value, BorderType padding_mode) { BorderType padding_mode) {
auto pad = std::make_shared<vision::PadOperation>(padding, fill_value, padding_mode); auto pad = std::make_shared<vision::PadOperation>(padding, fill_value, padding_mode);
THROW_IF_ERROR(pad->ValidateParams()); THROW_IF_ERROR(pad->ValidateParams());
return pad; return pad;
@ -266,8 +266,8 @@ PYBIND_REGISTER(RandomColorAdjustOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomColorAdjustOperation, TensorOperation, (void)py::class_<vision::RandomColorAdjustOperation, TensorOperation,
std::shared_ptr<vision::RandomColorAdjustOperation>>(*m, std::shared_ptr<vision::RandomColorAdjustOperation>>(*m,
"RandomColorAdjustOperation") "RandomColorAdjustOperation")
.def(py::init([](std::vector<float> brightness, std::vector<float> contrast, .def(py::init([](const std::vector<float> &brightness, const std::vector<float> &contrast,
std::vector<float> saturation, std::vector<float> hue) { const std::vector<float> &saturation, const std::vector<float> &hue) {
auto random_color_adjust = auto random_color_adjust =
std::make_shared<vision::RandomColorAdjustOperation>(brightness, contrast, saturation, hue); std::make_shared<vision::RandomColorAdjustOperation>(brightness, contrast, saturation, hue);
THROW_IF_ERROR(random_color_adjust->ValidateParams()); THROW_IF_ERROR(random_color_adjust->ValidateParams());
@ -286,14 +286,14 @@ PYBIND_REGISTER(
})); }));
})); }));
PYBIND_REGISTER(RandomCropDecodeResizeOperation, 1, ([](const py::module *m) { PYBIND_REGISTER(
RandomCropDecodeResizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomCropDecodeResizeOperation, TensorOperation, (void)py::class_<vision::RandomCropDecodeResizeOperation, TensorOperation,
std::shared_ptr<vision::RandomCropDecodeResizeOperation>>( std::shared_ptr<vision::RandomCropDecodeResizeOperation>>(*m, "RandomCropDecodeResizeOperation")
*m, "RandomCropDecodeResizeOperation") .def(py::init([](const std::vector<int32_t> &size, const std::vector<float> &scale,
.def(py::init([](std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio, const std::vector<float> &ratio, InterpolationMode interpolation, int32_t max_attempts) {
InterpolationMode interpolation, int32_t max_attempts) { auto random_crop_decode_resize =
auto random_crop_decode_resize = std::make_shared<vision::RandomCropDecodeResizeOperation>( std::make_shared<vision::RandomCropDecodeResizeOperation>(size, scale, ratio, interpolation, max_attempts);
size, scale, ratio, interpolation, max_attempts);
THROW_IF_ERROR(random_crop_decode_resize->ValidateParams()); THROW_IF_ERROR(random_crop_decode_resize->ValidateParams());
return random_crop_decode_resize; return random_crop_decode_resize;
})); }));
@ -303,8 +303,8 @@ PYBIND_REGISTER(
RandomCropOperation, 1, ([](const py::module *m) { RandomCropOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomCropOperation, TensorOperation, std::shared_ptr<vision::RandomCropOperation>>( (void)py::class_<vision::RandomCropOperation, TensorOperation, std::shared_ptr<vision::RandomCropOperation>>(
*m, "RandomCropOperation") *m, "RandomCropOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed, .def(py::init([](const std::vector<int32_t> &size, const std::vector<int32_t> &padding, bool pad_if_needed,
std::vector<uint8_t> fill_value, BorderType padding_mode) { const std::vector<uint8_t> &fill_value, BorderType padding_mode) {
auto random_crop = auto random_crop =
std::make_shared<vision::RandomCropOperation>(size, padding, pad_if_needed, fill_value, padding_mode); std::make_shared<vision::RandomCropOperation>(size, padding, pad_if_needed, fill_value, padding_mode);
THROW_IF_ERROR(random_crop->ValidateParams()); THROW_IF_ERROR(random_crop->ValidateParams());
@ -316,8 +316,9 @@ PYBIND_REGISTER(RandomCropWithBBoxOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomCropWithBBoxOperation, TensorOperation, (void)py::class_<vision::RandomCropWithBBoxOperation, TensorOperation,
std::shared_ptr<vision::RandomCropWithBBoxOperation>>(*m, std::shared_ptr<vision::RandomCropWithBBoxOperation>>(*m,
"RandomCropWithBBoxOperation") "RandomCropWithBBoxOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed, .def(
std::vector<uint8_t> fill_value, BorderType padding_mode) { py::init([](const std::vector<int32_t> &size, const std::vector<int32_t> &padding,
bool pad_if_needed, const std::vector<uint8_t> &fill_value, BorderType padding_mode) {
auto random_crop_with_bbox = std::make_shared<vision::RandomCropWithBBoxOperation>( auto random_crop_with_bbox = std::make_shared<vision::RandomCropWithBBoxOperation>(
size, padding, pad_if_needed, fill_value, padding_mode); size, padding, pad_if_needed, fill_value, padding_mode);
THROW_IF_ERROR(random_crop_with_bbox->ValidateParams()); THROW_IF_ERROR(random_crop_with_bbox->ValidateParams());
@ -358,14 +359,14 @@ PYBIND_REGISTER(RandomPosterizeOperation, 1, ([](const py::module *m) {
})); }));
})); }));
PYBIND_REGISTER(RandomResizedCropOperation, 1, ([](const py::module *m) { PYBIND_REGISTER(
RandomResizedCropOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomResizedCropOperation, TensorOperation, (void)py::class_<vision::RandomResizedCropOperation, TensorOperation,
std::shared_ptr<vision::RandomResizedCropOperation>>(*m, std::shared_ptr<vision::RandomResizedCropOperation>>(*m, "RandomResizedCropOperation")
"RandomResizedCropOperation") .def(py::init([](const std::vector<int32_t> &size, const std::vector<float> &scale,
.def(py::init([](std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio, const std::vector<float> &ratio, InterpolationMode interpolation, int32_t max_attempts) {
InterpolationMode interpolation, int32_t max_attempts) { auto random_resized_crop =
auto random_resized_crop = std::make_shared<vision::RandomResizedCropOperation>( std::make_shared<vision::RandomResizedCropOperation>(size, scale, ratio, interpolation, max_attempts);
size, scale, ratio, interpolation, max_attempts);
THROW_IF_ERROR(random_resized_crop->ValidateParams()); THROW_IF_ERROR(random_resized_crop->ValidateParams());
return random_resized_crop; return random_resized_crop;
})); }));
@ -375,8 +376,9 @@ PYBIND_REGISTER(RandomResizedCropWithBBoxOperation, 1, ([](const py::module *m)
(void)py::class_<vision::RandomResizedCropWithBBoxOperation, TensorOperation, (void)py::class_<vision::RandomResizedCropWithBBoxOperation, TensorOperation,
std::shared_ptr<vision::RandomResizedCropWithBBoxOperation>>( std::shared_ptr<vision::RandomResizedCropWithBBoxOperation>>(
*m, "RandomResizedCropWithBBoxOperation") *m, "RandomResizedCropWithBBoxOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio, .def(py::init([](const std::vector<int32_t> &size, const std::vector<float> &scale,
InterpolationMode interpolation, int32_t max_attempts) { const std::vector<float> &ratio, InterpolationMode interpolation,
int32_t max_attempts) {
auto random_resized_crop_with_bbox = std::make_shared<vision::RandomResizedCropWithBBoxOperation>( auto random_resized_crop_with_bbox = std::make_shared<vision::RandomResizedCropWithBBoxOperation>(
size, scale, ratio, interpolation, max_attempts); size, scale, ratio, interpolation, max_attempts);
THROW_IF_ERROR(random_resized_crop_with_bbox->ValidateParams()); THROW_IF_ERROR(random_resized_crop_with_bbox->ValidateParams());
@ -388,7 +390,7 @@ PYBIND_REGISTER(
RandomResizeOperation, 1, ([](const py::module *m) { RandomResizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomResizeOperation, TensorOperation, std::shared_ptr<vision::RandomResizeOperation>>( (void)py::class_<vision::RandomResizeOperation, TensorOperation, std::shared_ptr<vision::RandomResizeOperation>>(
*m, "RandomResizeOperation") *m, "RandomResizeOperation")
.def(py::init([](std::vector<int32_t> size) { .def(py::init([](const std::vector<int32_t> &size) {
auto random_resize = std::make_shared<vision::RandomResizeOperation>(size); auto random_resize = std::make_shared<vision::RandomResizeOperation>(size);
THROW_IF_ERROR(random_resize->ValidateParams()); THROW_IF_ERROR(random_resize->ValidateParams());
return random_resize; return random_resize;
@ -399,7 +401,7 @@ PYBIND_REGISTER(RandomResizeWithBBoxOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomResizeWithBBoxOperation, TensorOperation, (void)py::class_<vision::RandomResizeWithBBoxOperation, TensorOperation,
std::shared_ptr<vision::RandomResizeWithBBoxOperation>>( std::shared_ptr<vision::RandomResizeWithBBoxOperation>>(
*m, "RandomResizeWithBBoxOperation") *m, "RandomResizeWithBBoxOperation")
.def(py::init([](std::vector<int32_t> size) { .def(py::init([](const std::vector<int32_t> &size) {
auto random_resize_with_bbox = std::make_shared<vision::RandomResizeWithBBoxOperation>(size); auto random_resize_with_bbox = std::make_shared<vision::RandomResizeWithBBoxOperation>(size);
THROW_IF_ERROR(random_resize_with_bbox->ValidateParams()); THROW_IF_ERROR(random_resize_with_bbox->ValidateParams());
return random_resize_with_bbox; return random_resize_with_bbox;
@ -422,7 +424,7 @@ PYBIND_REGISTER(
RandomSelectSubpolicyOperation, 1, ([](const py::module *m) { RandomSelectSubpolicyOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomSelectSubpolicyOperation, TensorOperation, (void)py::class_<vision::RandomSelectSubpolicyOperation, TensorOperation,
std::shared_ptr<vision::RandomSelectSubpolicyOperation>>(*m, "RandomSelectSubpolicyOperation") std::shared_ptr<vision::RandomSelectSubpolicyOperation>>(*m, "RandomSelectSubpolicyOperation")
.def(py::init([](const py::list &py_policy) { .def(py::init([](const py::list py_policy) {
std::vector<std::vector<std::pair<std::shared_ptr<TensorOperation>, double>>> cpp_policy; std::vector<std::vector<std::pair<std::shared_ptr<TensorOperation>, double>>> cpp_policy;
for (auto &py_sub : py_policy) { for (auto &py_sub : py_policy) {
cpp_policy.push_back({}); cpp_policy.push_back({});
@ -459,7 +461,7 @@ PYBIND_REGISTER(
PYBIND_REGISTER(RandomSharpnessOperation, 1, ([](const py::module *m) { PYBIND_REGISTER(RandomSharpnessOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomSharpnessOperation, TensorOperation, (void)py::class_<vision::RandomSharpnessOperation, TensorOperation,
std::shared_ptr<vision::RandomSharpnessOperation>>(*m, "RandomSharpnessOperation") std::shared_ptr<vision::RandomSharpnessOperation>>(*m, "RandomSharpnessOperation")
.def(py::init([](std::vector<float> degrees) { .def(py::init([](const std::vector<float> &degrees) {
auto random_sharpness = std::make_shared<vision::RandomSharpnessOperation>(degrees); auto random_sharpness = std::make_shared<vision::RandomSharpnessOperation>(degrees);
THROW_IF_ERROR(random_sharpness->ValidateParams()); THROW_IF_ERROR(random_sharpness->ValidateParams());
return random_sharpness; return random_sharpness;
@ -469,7 +471,7 @@ PYBIND_REGISTER(RandomSharpnessOperation, 1, ([](const py::module *m) {
PYBIND_REGISTER(RandomSolarizeOperation, 1, ([](const py::module *m) { PYBIND_REGISTER(RandomSolarizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomSolarizeOperation, TensorOperation, (void)py::class_<vision::RandomSolarizeOperation, TensorOperation,
std::shared_ptr<vision::RandomSolarizeOperation>>(*m, "RandomSolarizeOperation") std::shared_ptr<vision::RandomSolarizeOperation>>(*m, "RandomSolarizeOperation")
.def(py::init([](std::vector<uint8_t> threshold) { .def(py::init([](const std::vector<uint8_t> &threshold) {
auto random_solarize = std::make_shared<vision::RandomSolarizeOperation>(threshold); auto random_solarize = std::make_shared<vision::RandomSolarizeOperation>(threshold);
THROW_IF_ERROR(random_solarize->ValidateParams()); THROW_IF_ERROR(random_solarize->ValidateParams());
return random_solarize; return random_solarize;
@ -513,7 +515,7 @@ PYBIND_REGISTER(RescaleOperation, 1, ([](const py::module *m) {
PYBIND_REGISTER(ResizeOperation, 1, ([](const py::module *m) { PYBIND_REGISTER(ResizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::ResizeOperation, TensorOperation, std::shared_ptr<vision::ResizeOperation>>( (void)py::class_<vision::ResizeOperation, TensorOperation, std::shared_ptr<vision::ResizeOperation>>(
*m, "ResizeOperation") *m, "ResizeOperation")
.def(py::init([](std::vector<int32_t> size, InterpolationMode interpolation_mode) { .def(py::init([](const std::vector<int32_t> &size, InterpolationMode interpolation_mode) {
auto resize = std::make_shared<vision::ResizeOperation>(size, interpolation_mode); auto resize = std::make_shared<vision::ResizeOperation>(size, interpolation_mode);
THROW_IF_ERROR(resize->ValidateParams()); THROW_IF_ERROR(resize->ValidateParams());
return resize; return resize;
@ -523,7 +525,7 @@ PYBIND_REGISTER(ResizeOperation, 1, ([](const py::module *m) {
PYBIND_REGISTER(ResizeWithBBoxOperation, 1, ([](const py::module *m) { PYBIND_REGISTER(ResizeWithBBoxOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::ResizeWithBBoxOperation, TensorOperation, (void)py::class_<vision::ResizeWithBBoxOperation, TensorOperation,
std::shared_ptr<vision::ResizeWithBBoxOperation>>(*m, "ResizeWithBBoxOperation") std::shared_ptr<vision::ResizeWithBBoxOperation>>(*m, "ResizeWithBBoxOperation")
.def(py::init([](std::vector<int32_t> size, InterpolationMode interpolation_mode) { .def(py::init([](const std::vector<int32_t> &size, InterpolationMode interpolation_mode) {
auto resize_with_bbox = auto resize_with_bbox =
std::make_shared<vision::ResizeWithBBoxOperation>(size, interpolation_mode); std::make_shared<vision::ResizeWithBBoxOperation>(size, interpolation_mode);
THROW_IF_ERROR(resize_with_bbox->ValidateParams()); THROW_IF_ERROR(resize_with_bbox->ValidateParams());
@ -570,8 +572,8 @@ PYBIND_REGISTER(SoftDvppDecodeRandomCropResizeJpegOperation, 1, ([](const py::mo
(void)py::class_<vision::SoftDvppDecodeRandomCropResizeJpegOperation, TensorOperation, (void)py::class_<vision::SoftDvppDecodeRandomCropResizeJpegOperation, TensorOperation,
std::shared_ptr<vision::SoftDvppDecodeRandomCropResizeJpegOperation>>( std::shared_ptr<vision::SoftDvppDecodeRandomCropResizeJpegOperation>>(
*m, "SoftDvppDecodeRandomCropResizeJpegOperation") *m, "SoftDvppDecodeRandomCropResizeJpegOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio, .def(py::init([](const std::vector<int32_t> &size, const std::vector<float> &scale,
int32_t max_attempts) { const std::vector<float> &ratio, int32_t max_attempts) {
auto soft_dvpp_decode_random_crop_resize_jpeg = auto soft_dvpp_decode_random_crop_resize_jpeg =
std::make_shared<vision::SoftDvppDecodeRandomCropResizeJpegOperation>(size, scale, ratio, std::make_shared<vision::SoftDvppDecodeRandomCropResizeJpegOperation>(size, scale, ratio,
max_attempts); max_attempts);
@ -584,7 +586,7 @@ PYBIND_REGISTER(SoftDvppDecodeResizeJpegOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::SoftDvppDecodeResizeJpegOperation, TensorOperation, (void)py::class_<vision::SoftDvppDecodeResizeJpegOperation, TensorOperation,
std::shared_ptr<vision::SoftDvppDecodeResizeJpegOperation>>( std::shared_ptr<vision::SoftDvppDecodeResizeJpegOperation>>(
*m, "SoftDvppDecodeResizeJpegOperation") *m, "SoftDvppDecodeResizeJpegOperation")
.def(py::init([](std::vector<int32_t> size) { .def(py::init([](const std::vector<int32_t> &size) {
auto soft_dvpp_decode_resize_jpeg = auto soft_dvpp_decode_resize_jpeg =
std::make_shared<vision::SoftDvppDecodeResizeJpegOperation>(size); std::make_shared<vision::SoftDvppDecodeResizeJpegOperation>(size);
THROW_IF_ERROR(soft_dvpp_decode_resize_jpeg->ValidateParams()); THROW_IF_ERROR(soft_dvpp_decode_resize_jpeg->ValidateParams());
@ -596,7 +598,7 @@ PYBIND_REGISTER(
UniformAugOperation, 1, ([](const py::module *m) { UniformAugOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::UniformAugOperation, TensorOperation, std::shared_ptr<vision::UniformAugOperation>>( (void)py::class_<vision::UniformAugOperation, TensorOperation, std::shared_ptr<vision::UniformAugOperation>>(
*m, "UniformAugOperation") *m, "UniformAugOperation")
.def(py::init([](py::list transforms, int32_t num_ops) { .def(py::init([](const py::list transforms, int32_t num_ops) {
auto uniform_aug = auto uniform_aug =
std::make_shared<vision::UniformAugOperation>(std::move(toTensorOperations(transforms)), num_ops); std::make_shared<vision::UniformAugOperation>(std::move(toTensorOperations(transforms)), num_ops);
THROW_IF_ERROR(uniform_aug->ValidateParams()); THROW_IF_ERROR(uniform_aug->ValidateParams());

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/auto_contrast_ir.cc
View File

@ -28,7 +28,7 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// AutoContrastOperation // AutoContrastOperation
AutoContrastOperation::AutoContrastOperation(float cutoff, std::vector<uint32_t> ignore) AutoContrastOperation::AutoContrastOperation(float cutoff, const std::vector<uint32_t> &ignore)
: cutoff_(cutoff), ignore_(ignore) {} : cutoff_(cutoff), ignore_(ignore) {}
AutoContrastOperation::~AutoContrastOperation() = default; AutoContrastOperation::~AutoContrastOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/auto_contrast_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kAutoContrastOperation[] = "AutoContrast";
class AutoContrastOperation : public TensorOperation { class AutoContrastOperation : public TensorOperation {
public: public:
explicit AutoContrastOperation(float cutoff, std::vector<uint32_t> ignore); explicit AutoContrastOperation(float cutoff, const std::vector<uint32_t> &ignore);
~AutoContrastOperation(); ~AutoContrastOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/bounding_box_augment_ir.cc
View File

@ -27,7 +27,7 @@ namespace mindspore {
namespace dataset { namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
BoundingBoxAugmentOperation::BoundingBoxAugmentOperation(std::shared_ptr<TensorOperation> transform, float ratio) BoundingBoxAugmentOperation::BoundingBoxAugmentOperation(const std::shared_ptr<TensorOperation> &transform, float ratio)
: transform_(transform), ratio_(ratio) {} : transform_(transform), ratio_(ratio) {}
BoundingBoxAugmentOperation::~BoundingBoxAugmentOperation() = default; BoundingBoxAugmentOperation::~BoundingBoxAugmentOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/bounding_box_augment_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kBoundingBoxAugmentOperation[] = "BoundingBoxAugment";
class BoundingBoxAugmentOperation : public TensorOperation { class BoundingBoxAugmentOperation : public TensorOperation {
public: public:
explicit BoundingBoxAugmentOperation(std::shared_ptr<TensorOperation> transform, float ratio); explicit BoundingBoxAugmentOperation(const std::shared_ptr<TensorOperation> &transform, float ratio);
~BoundingBoxAugmentOperation(); ~BoundingBoxAugmentOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/center_crop_ir.cc
View File

@ -24,7 +24,7 @@
namespace mindspore { namespace mindspore {
namespace dataset { namespace dataset {
namespace vision { namespace vision {
CenterCropOperation::CenterCropOperation(std::vector<int32_t> size) : size_(size) {} CenterCropOperation::CenterCropOperation(const std::vector<int32_t> &size) : size_(size) {}
CenterCropOperation::~CenterCropOperation() = default; CenterCropOperation::~CenterCropOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/center_crop_ir.h
View File

@ -39,7 +39,7 @@ constexpr char kCenterCropOperation[] = "CenterCrop";
class CenterCropOperation : public TensorOperation { class CenterCropOperation : public TensorOperation {
public: public:
explicit CenterCropOperation(std::vector<int32_t> size); explicit CenterCropOperation(const std::vector<int32_t> &size);
~CenterCropOperation(); ~CenterCropOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/crop_ir.cc
View File

@ -24,7 +24,7 @@
namespace mindspore { namespace mindspore {
namespace dataset { namespace dataset {
namespace vision { namespace vision {
CropOperation::CropOperation(std::vector<int32_t> coordinates, std::vector<int32_t> size) CropOperation::CropOperation(const std::vector<int32_t> &coordinates, const std::vector<int32_t> &size)
: coordinates_(coordinates), size_(size) {} : coordinates_(coordinates), size_(size) {}
CropOperation::~CropOperation() = default; CropOperation::~CropOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/crop_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kCropOperation[] = "Crop";
class CropOperation : public TensorOperation { class CropOperation : public TensorOperation {
public: public:
CropOperation(std::vector<int32_t> coordinates, std::vector<int32_t> size); CropOperation(const std::vector<int32_t> &coordinates, const std::vector<int32_t> &size);
~CropOperation(); ~CropOperation();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/normalize_ir.cc
View File

@ -25,7 +25,8 @@ namespace mindspore {
namespace dataset { namespace dataset {
namespace vision { namespace vision {
// NormalizeOperation // NormalizeOperation
NormalizeOperation::NormalizeOperation(std::vector<float> mean, std::vector<float> std) : mean_(mean), std_(std) {} NormalizeOperation::NormalizeOperation(const std::vector<float> &mean, const std::vector<float> &std)
: mean_(mean), std_(std) {}
NormalizeOperation::~NormalizeOperation() = default; NormalizeOperation::~NormalizeOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/normalize_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kNormalizeOperation[] = "Normalize";
class NormalizeOperation : public TensorOperation { class NormalizeOperation : public TensorOperation {
public: public:
NormalizeOperation(std::vector<float> mean, std::vector<float> std); NormalizeOperation(const std::vector<float> &mean, const std::vector<float> &std);
~NormalizeOperation(); ~NormalizeOperation();

3
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/pad_ir.cc
View File

@ -28,7 +28,8 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// PadOperation // PadOperation
PadOperation::PadOperation(std::vector<int32_t> padding, std::vector<uint8_t> fill_value, BorderType padding_mode) PadOperation::PadOperation(const std::vector<int32_t> &padding, const std::vector<uint8_t> &fill_value,
BorderType padding_mode)
: padding_(padding), fill_value_(fill_value), padding_mode_(padding_mode) {} : padding_(padding), fill_value_(fill_value), padding_mode_(padding_mode) {}
PadOperation::~PadOperation() = default; PadOperation::~PadOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/pad_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kPadOperation[] = "Pad";
class PadOperation : public TensorOperation { class PadOperation : public TensorOperation {
public: public:
PadOperation(std::vector<int32_t> padding, std::vector<uint8_t> fill_value, BorderType padding_mode); PadOperation(const std::vector<int32_t> &padding, const std::vector<uint8_t> &fill_value, BorderType padding_mode);
~PadOperation(); ~PadOperation();

6
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_color_adjust_ir.cc
View File

@ -33,8 +33,10 @@ constexpr size_t size_two = 2;
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomColorAdjustOperation. // RandomColorAdjustOperation.
RandomColorAdjustOperation::RandomColorAdjustOperation(std::vector<float> brightness, std::vector<float> contrast, RandomColorAdjustOperation::RandomColorAdjustOperation(const std::vector<float> &brightness,
std::vector<float> saturation, std::vector<float> hue) const std::vector<float> &contrast,
const std::vector<float> &saturation,
const std::vector<float> &hue)
: brightness_(brightness), contrast_(contrast), saturation_(saturation), hue_(hue) { : brightness_(brightness), contrast_(contrast), saturation_(saturation), hue_(hue) {
random_op_ = true; random_op_ = true;
} }

4
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_color_adjust_ir.h
View File

@ -37,8 +37,8 @@ constexpr char kRandomColorAdjustOperation[] = "RandomColorAdjust";
class RandomColorAdjustOperation : public TensorOperation { class RandomColorAdjustOperation : public TensorOperation {
public: public:
RandomColorAdjustOperation(std::vector<float> brightness, std::vector<float> contrast, std::vector<float> saturation, RandomColorAdjustOperation(const std::vector<float> &brightness, const std::vector<float> &contrast,
std::vector<float> hue); const std::vector<float> &saturation, const std::vector<float> &hue);
~RandomColorAdjustOperation(); ~RandomColorAdjustOperation();

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_decode_resize_ir.cc
View File

@ -28,8 +28,9 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomCropDecodeResizeOperation // RandomCropDecodeResizeOperation
RandomCropDecodeResizeOperation::RandomCropDecodeResizeOperation(std::vector<int32_t> size, std::vector<float> scale, RandomCropDecodeResizeOperation::RandomCropDecodeResizeOperation(const std::vector<int32_t> &size,
std::vector<float> ratio, const std::vector<float> &scale,
const std::vector<float> &ratio,
InterpolationMode interpolation, int32_t max_attempts) InterpolationMode interpolation, int32_t max_attempts)
: RandomResizedCropOperation(size, scale, ratio, interpolation, max_attempts) {} : RandomResizedCropOperation(size, scale, ratio, interpolation, max_attempts) {}

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_decode_resize_ir.h
View File

@ -38,8 +38,9 @@ constexpr char kRandomCropDecodeResizeOperation[] = "RandomCropDecodeResize";
class RandomCropDecodeResizeOperation : public RandomResizedCropOperation { class RandomCropDecodeResizeOperation : public RandomResizedCropOperation {
public: public:
RandomCropDecodeResizeOperation(std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio, RandomCropDecodeResizeOperation(const std::vector<int32_t> &size, const std::vector<float> &scale,
InterpolationMode interpolation, int32_t max_attempts); const std::vector<float> &ratio, InterpolationMode interpolation,
int32_t max_attempts);
explicit RandomCropDecodeResizeOperation(const RandomResizedCropOperation &base); explicit RandomCropDecodeResizeOperation(const RandomResizedCropOperation &base);

6
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_ir.cc
View File

@ -22,14 +22,14 @@
#endif #endif
#include "minddata/dataset/kernels/ir/validators.h" #include "minddata/dataset/kernels/ir/validators.h"
namespace mindspore { namespace mindspore {
namespace dataset { namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomCropOperation // RandomCropOperation
RandomCropOperation::RandomCropOperation(std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed, RandomCropOperation::RandomCropOperation(const std::vector<int32_t> &size, const std::vector<int32_t> &padding,
std::vector<uint8_t> fill_value, BorderType padding_mode) bool pad_if_needed, const std::vector<uint8_t> &fill_value,
BorderType padding_mode)
: TensorOperation(true), : TensorOperation(true),
size_(size), size_(size),
padding_(padding), padding_(padding),

4
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_ir.h
View File

@ -37,8 +37,8 @@ constexpr char kRandomCropOperation[] = "RandomCrop";
class RandomCropOperation : public TensorOperation { class RandomCropOperation : public TensorOperation {
public: public:
RandomCropOperation(std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed, RandomCropOperation(const std::vector<int32_t> &size, const std::vector<int32_t> &padding, bool pad_if_needed,
std::vector<uint8_t> fill_value, BorderType padding_mode); const std::vector<uint8_t> &fill_value, BorderType padding_mode);
~RandomCropOperation(); ~RandomCropOperation();

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_with_bbox_ir.cc
View File

@ -28,8 +28,9 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomCropWithBBoxOperation // RandomCropWithBBoxOperation
RandomCropWithBBoxOperation::RandomCropWithBBoxOperation(std::vector<int32_t> size, std::vector<int32_t> padding, RandomCropWithBBoxOperation::RandomCropWithBBoxOperation(const std::vector<int32_t> &size,
bool pad_if_needed, std::vector<uint8_t> fill_value, const std::vector<int32_t> &padding, bool pad_if_needed,
const std::vector<uint8_t> &fill_value,
BorderType padding_mode) BorderType padding_mode)
: TensorOperation(true), : TensorOperation(true),
size_(size), size_(size),

4
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_crop_with_bbox_ir.h
View File

@ -37,8 +37,8 @@ constexpr char kRandomCropWithBBoxOperation[] = "RandomCropWithBBox";
class RandomCropWithBBoxOperation : public TensorOperation { class RandomCropWithBBoxOperation : public TensorOperation {
public: public:
RandomCropWithBBoxOperation(std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed, RandomCropWithBBoxOperation(const std::vector<int32_t> &size, const std::vector<int32_t> &padding, bool pad_if_needed,
std::vector<uint8_t> fill_value, BorderType padding_mode); const std::vector<uint8_t> &fill_value, BorderType padding_mode);
~RandomCropWithBBoxOperation(); ~RandomCropWithBBoxOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resize_ir.cc
View File

@ -28,7 +28,7 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomResizeOperation // RandomResizeOperation
RandomResizeOperation::RandomResizeOperation(std::vector<int32_t> size) : TensorOperation(true), size_(size) {} RandomResizeOperation::RandomResizeOperation(const std::vector<int32_t> &size) : TensorOperation(true), size_(size) {}
RandomResizeOperation::~RandomResizeOperation() = default; RandomResizeOperation::~RandomResizeOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resize_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kRandomResizeOperation[] = "RandomResize";
class RandomResizeOperation : public TensorOperation { class RandomResizeOperation : public TensorOperation {
public: public:
explicit RandomResizeOperation(std::vector<int32_t> size); explicit RandomResizeOperation(const std::vector<int32_t> &size);
~RandomResizeOperation(); ~RandomResizeOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resize_with_bbox_ir.cc
View File

@ -28,7 +28,7 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomResizeWithBBoxOperation // RandomResizeWithBBoxOperation
RandomResizeWithBBoxOperation::RandomResizeWithBBoxOperation(std::vector<int32_t> size) RandomResizeWithBBoxOperation::RandomResizeWithBBoxOperation(const std::vector<int32_t> &size)
: TensorOperation(true), size_(size) {} : TensorOperation(true), size_(size) {}
RandomResizeWithBBoxOperation::~RandomResizeWithBBoxOperation() = default; RandomResizeWithBBoxOperation::~RandomResizeWithBBoxOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resize_with_bbox_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kRandomResizeWithBBoxOperation[] = "RandomResizeWithBBox";
class RandomResizeWithBBoxOperation : public TensorOperation { class RandomResizeWithBBoxOperation : public TensorOperation {
public: public:
explicit RandomResizeWithBBoxOperation(std::vector<int32_t> size); explicit RandomResizeWithBBoxOperation(const std::vector<int32_t> &size);
~RandomResizeWithBBoxOperation(); ~RandomResizeWithBBoxOperation();

6
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resized_crop_ir.cc
View File

@ -30,9 +30,9 @@ namespace vision {
RandomResizedCropOperation::RandomResizedCropOperation(const RandomResizedCropOperation &) = default; RandomResizedCropOperation::RandomResizedCropOperation(const RandomResizedCropOperation &) = default;
// RandomResizedCropOperation // RandomResizedCropOperation
RandomResizedCropOperation::RandomResizedCropOperation(std::vector<int32_t> size, std::vector<float> scale, RandomResizedCropOperation::RandomResizedCropOperation(const std::vector<int32_t> &size,
std::vector<float> ratio, InterpolationMode interpolation, const std::vector<float> &scale, const std::vector<float> &ratio,
int32_t max_attempts) InterpolationMode interpolation, int32_t max_attempts)
: TensorOperation(true), : TensorOperation(true),
size_(size), size_(size),
scale_(scale), scale_(scale),

4
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resized_crop_ir.h
View File

@ -37,8 +37,8 @@ constexpr char kRandomResizedCropOperation[] = "RandomResizedCrop";
class RandomResizedCropOperation : public TensorOperation { class RandomResizedCropOperation : public TensorOperation {
public: public:
RandomResizedCropOperation(std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio, RandomResizedCropOperation(const std::vector<int32_t> &size, const std::vector<float> &scale,
InterpolationMode interpolation, int32_t max_attempts); const std::vector<float> &ratio, InterpolationMode interpolation, int32_t max_attempts);
/// \brief default copy constructor /// \brief default copy constructor
explicit RandomResizedCropOperation(const RandomResizedCropOperation &); explicit RandomResizedCropOperation(const RandomResizedCropOperation &);

6
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resized_crop_with_bbox_ir.cc
View File

@ -28,9 +28,9 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomResizedCropWithBBoxOperation // RandomResizedCropWithBBoxOperation
RandomResizedCropWithBBoxOperation::RandomResizedCropWithBBoxOperation(std::vector<int32_t> size, RandomResizedCropWithBBoxOperation::RandomResizedCropWithBBoxOperation(const std::vector<int32_t> &size,
std::vector<float> scale, const std::vector<float> &scale,
std::vector<float> ratio, const std::vector<float> &ratio,
InterpolationMode interpolation, InterpolationMode interpolation,
int32_t max_attempts) int32_t max_attempts)
: size_(size), scale_(scale), ratio_(ratio), interpolation_(interpolation), max_attempts_(max_attempts) {} : size_(size), scale_(scale), ratio_(ratio), interpolation_(interpolation), max_attempts_(max_attempts) {}

4
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_resized_crop_with_bbox_ir.h
View File

@ -38,8 +38,8 @@ constexpr char kRandomResizedCropWithBBoxOperation[] = "RandomResizedCropWithBBo
class RandomResizedCropWithBBoxOperation : public TensorOperation { class RandomResizedCropWithBBoxOperation : public TensorOperation {
public: public:
explicit RandomResizedCropWithBBoxOperation(std::vector<int32_t> size, std::vector<float> scale, explicit RandomResizedCropWithBBoxOperation(const std::vector<int32_t> &size, const std::vector<float> &scale,
std::vector<float> ratio, InterpolationMode interpolation, const std::vector<float> &ratio, InterpolationMode interpolation,
int32_t max_attempts); int32_t max_attempts);
~RandomResizedCropWithBBoxOperation(); ~RandomResizedCropWithBBoxOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_select_subpolicy_ir.cc
View File

@ -29,7 +29,7 @@ namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomSelectSubpolicyOperation. // RandomSelectSubpolicyOperation.
RandomSelectSubpolicyOperation::RandomSelectSubpolicyOperation( RandomSelectSubpolicyOperation::RandomSelectSubpolicyOperation(
std::vector<std::vector<std::pair<std::shared_ptr<TensorOperation>, double>>> policy) const std::vector<std::vector<std::pair<std::shared_ptr<TensorOperation>, double>>> &policy)
: TensorOperation(true), policy_(policy) {} : TensorOperation(true), policy_(policy) {}
RandomSelectSubpolicyOperation::~RandomSelectSubpolicyOperation() = default; RandomSelectSubpolicyOperation::~RandomSelectSubpolicyOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_select_subpolicy_ir.h
View File

@ -38,7 +38,7 @@ constexpr char kRandomSelectSubpolicyOperation[] = "RandomSelectSubpolicy";
class RandomSelectSubpolicyOperation : public TensorOperation { class RandomSelectSubpolicyOperation : public TensorOperation {
public: public:
explicit RandomSelectSubpolicyOperation( explicit RandomSelectSubpolicyOperation(
std::vector<std::vector<std::pair<std::shared_ptr<TensorOperation>, double>>> policy); const std::vector<std::vector<std::pair<std::shared_ptr<TensorOperation>, double>>> &policy);
~RandomSelectSubpolicyOperation(); ~RandomSelectSubpolicyOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_sharpness_ir.cc
View File

@ -32,7 +32,7 @@ constexpr size_t dimension_one = 1;
constexpr size_t size_two = 2; constexpr size_t size_two = 2;
// Function to create RandomSharpness. // Function to create RandomSharpness.
RandomSharpnessOperation::RandomSharpnessOperation(std::vector<float> degrees) RandomSharpnessOperation::RandomSharpnessOperation(const std::vector<float> &degrees)
: TensorOperation(true), degrees_(degrees) {} : TensorOperation(true), degrees_(degrees) {}
RandomSharpnessOperation::~RandomSharpnessOperation() = default; RandomSharpnessOperation::~RandomSharpnessOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_sharpness_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kRandomSharpnessOperation[] = "RandomSharpness";
class RandomSharpnessOperation : public TensorOperation { class RandomSharpnessOperation : public TensorOperation {
public: public:
explicit RandomSharpnessOperation(std::vector<float> degrees); explicit RandomSharpnessOperation(const std::vector<float> &degrees);
~RandomSharpnessOperation(); ~RandomSharpnessOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_solarize_ir.cc
View File

@ -28,7 +28,7 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// RandomSolarizeOperation. // RandomSolarizeOperation.
RandomSolarizeOperation::RandomSolarizeOperation(std::vector<uint8_t> threshold) RandomSolarizeOperation::RandomSolarizeOperation(const std::vector<uint8_t> &threshold)
: TensorOperation(true), threshold_(threshold) {} : TensorOperation(true), threshold_(threshold) {}
RandomSolarizeOperation::~RandomSolarizeOperation() = default; RandomSolarizeOperation::~RandomSolarizeOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/random_solarize_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kRandomSolarizeOperation[] = "RandomSolarize";
class RandomSolarizeOperation : public TensorOperation { class RandomSolarizeOperation : public TensorOperation {
public: public:
explicit RandomSolarizeOperation(std::vector<uint8_t> threshold); explicit RandomSolarizeOperation(const std::vector<uint8_t> &threshold);
~RandomSolarizeOperation(); ~RandomSolarizeOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/resize_ir.cc
View File

@ -25,7 +25,7 @@ namespace mindspore {
namespace dataset { namespace dataset {
namespace vision { namespace vision {
// ResizeOperation // ResizeOperation
ResizeOperation::ResizeOperation(std::vector<int32_t> size, InterpolationMode interpolation) ResizeOperation::ResizeOperation(const std::vector<int32_t> &size, InterpolationMode interpolation)
: size_(size), interpolation_(interpolation) {} : size_(size), interpolation_(interpolation) {}
ResizeOperation::~ResizeOperation() = default; ResizeOperation::~ResizeOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/resize_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kResizeOperation[] = "Resize";
class ResizeOperation : public TensorOperation { class ResizeOperation : public TensorOperation {
public: public:
explicit ResizeOperation(std::vector<int32_t> size, InterpolationMode interpolation); explicit ResizeOperation(const std::vector<int32_t> &size, InterpolationMode interpolation);
~ResizeOperation(); ~ResizeOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/resize_with_bbox_ir.cc
View File

@ -28,7 +28,7 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// ResizeWithBBoxOperation // ResizeWithBBoxOperation
ResizeWithBBoxOperation::ResizeWithBBoxOperation(std::vector<int32_t> size, InterpolationMode interpolation) ResizeWithBBoxOperation::ResizeWithBBoxOperation(const std::vector<int32_t> &size, InterpolationMode interpolation)
: size_(size), interpolation_(interpolation) {} : size_(size), interpolation_(interpolation) {}
ResizeWithBBoxOperation::~ResizeWithBBoxOperation() = default; ResizeWithBBoxOperation::~ResizeWithBBoxOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/resize_with_bbox_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kResizeWithBBoxOperation[] = "ResizeWithBBox";
class ResizeWithBBoxOperation : public TensorOperation { class ResizeWithBBoxOperation : public TensorOperation {
public: public:
explicit ResizeWithBBoxOperation(std::vector<int32_t> size, InterpolationMode interpolation_mode); explicit ResizeWithBBoxOperation(const std::vector<int32_t> &size, InterpolationMode interpolation_mode);
~ResizeWithBBoxOperation(); ~ResizeWithBBoxOperation();

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/softdvpp_decode_random_crop_resize_jpeg_ir.cc
View File

@ -28,9 +28,8 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// SoftDvppDecodeRandomCropResizeJpegOperation // SoftDvppDecodeRandomCropResizeJpegOperation
SoftDvppDecodeRandomCropResizeJpegOperation::SoftDvppDecodeRandomCropResizeJpegOperation(std::vector<int32_t> size, SoftDvppDecodeRandomCropResizeJpegOperation::SoftDvppDecodeRandomCropResizeJpegOperation(
std::vector<float> scale, const std::vector<int32_t> &size, const std::vector<float> &scale, const std::vector<float> &ratio,
std::vector<float> ratio,
int32_t max_attempts) int32_t max_attempts)
: size_(size), scale_(scale), ratio_(ratio), max_attempts_(max_attempts) {} : size_(size), scale_(scale), ratio_(ratio), max_attempts_(max_attempts) {}

5
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/softdvpp_decode_random_crop_resize_jpeg_ir.h
View File

@ -37,8 +37,9 @@ constexpr char kSoftDvppDecodeRandomCropResizeJpegOperation[] = "SoftDvppDecodeR
class SoftDvppDecodeRandomCropResizeJpegOperation : public TensorOperation { class SoftDvppDecodeRandomCropResizeJpegOperation : public TensorOperation {
public: public:
explicit SoftDvppDecodeRandomCropResizeJpegOperation(std::vector<int32_t> size, std::vector<float> scale, explicit SoftDvppDecodeRandomCropResizeJpegOperation(const std::vector<int32_t> &size,
std::vector<float> ratio, int32_t max_attempts); const std::vector<float> &scale, const std::vector<float> &ratio,
int32_t max_attempts);
~SoftDvppDecodeRandomCropResizeJpegOperation(); ~SoftDvppDecodeRandomCropResizeJpegOperation();

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/softdvpp_decode_resize_jpeg_ir.cc
View File

@ -28,7 +28,7 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// SoftDvppDecodeResizeJpegOperation // SoftDvppDecodeResizeJpegOperation
SoftDvppDecodeResizeJpegOperation::SoftDvppDecodeResizeJpegOperation(std::vector<int32_t> size) : size_(size) {} SoftDvppDecodeResizeJpegOperation::SoftDvppDecodeResizeJpegOperation(const std::vector<int32_t> &size) : size_(size) {}
SoftDvppDecodeResizeJpegOperation::~SoftDvppDecodeResizeJpegOperation() = default; SoftDvppDecodeResizeJpegOperation::~SoftDvppDecodeResizeJpegOperation() = default;

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/softdvpp_decode_resize_jpeg_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kSoftDvppDecodeResizeJpegOperation[] = "SoftDvppDecodeResizeJpeg"
class SoftDvppDecodeResizeJpegOperation : public TensorOperation { class SoftDvppDecodeResizeJpegOperation : public TensorOperation {
public: public:
explicit SoftDvppDecodeResizeJpegOperation(std::vector<int32_t> size); explicit SoftDvppDecodeResizeJpegOperation(const std::vector<int32_t> &size);
~SoftDvppDecodeResizeJpegOperation(); ~SoftDvppDecodeResizeJpegOperation();

8
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/uniform_aug_ir.cc
View File

@ -28,7 +28,8 @@ namespace dataset {
namespace vision { namespace vision {
#ifndef ENABLE_ANDROID #ifndef ENABLE_ANDROID
// UniformAugOperation // UniformAugOperation
UniformAugOperation::UniformAugOperation(std::vector<std::shared_ptr<TensorOperation>> transforms, int32_t num_ops) UniformAugOperation::UniformAugOperation(const std::vector<std::shared_ptr<TensorOperation>> &transforms,
int32_t num_ops)
: transforms_(transforms), num_ops_(num_ops) {} : transforms_(transforms), num_ops_(num_ops) {}
UniformAugOperation::~UniformAugOperation() = default; UniformAugOperation::~UniformAugOperation() = default;
@ -51,8 +52,9 @@ Status UniformAugOperation::ValidateParams() {
std::shared_ptr<TensorOp> UniformAugOperation::Build() { std::shared_ptr<TensorOp> UniformAugOperation::Build() {
std::vector<std::shared_ptr<TensorOp>> tensor_ops; std::vector<std::shared_ptr<TensorOp>> tensor_ops;
(void)std::transform(transforms_.begin(), transforms_.end(), std::back_inserter(tensor_ops), (void)std::transform(
[](std::shared_ptr<TensorOperation> op) -> std::shared_ptr<TensorOp> { return op->Build(); }); transforms_.begin(), transforms_.end(), std::back_inserter(tensor_ops),
[](const std::shared_ptr<TensorOperation> &op) -> std::shared_ptr<TensorOp> { return op->Build(); });
std::shared_ptr<UniformAugOp> tensor_op = std::make_shared<UniformAugOp>(tensor_ops, num_ops_); std::shared_ptr<UniformAugOp> tensor_op = std::make_shared<UniformAugOp>(tensor_ops, num_ops_);
return tensor_op; return tensor_op;
} }

2
mindspore/ccsrc/minddata/dataset/kernels/ir/vision/uniform_aug_ir.h
View File

@ -37,7 +37,7 @@ constexpr char kUniformAugOperation[] = "UniformAug";
class UniformAugOperation : public TensorOperation { class UniformAugOperation : public TensorOperation {
public: public:
explicit UniformAugOperation(std::vector<std::shared_ptr<TensorOperation>> transforms, int32_t num_ops); explicit UniformAugOperation(const std::vector<std::shared_ptr<TensorOperation>> &transforms, int32_t num_ops);
~UniformAugOperation(); ~UniformAugOperation();

21
mindspore/ccsrc/minddata/dataset/kernels/plugin_op.cc
View File

@ -20,18 +20,6 @@
namespace mindspore { namespace mindspore {
namespace dataset { namespace dataset {
errno_t memcpy_s_loop(uchar *dest, size_t destMax, const uchar *src, size_t count) {
int64_t step = 0;
while (count >= SECUREC_MEM_MAX_LEN) {
int ret_code = memcpy_s(dest + step * SECUREC_MEM_MAX_LEN, SECUREC_MEM_MAX_LEN, src + step * SECUREC_MEM_MAX_LEN,
SECUREC_MEM_MAX_LEN);
if (ret_code != 0) return ret_code;
count -= SECUREC_MEM_MAX_LEN;
step++;
}
return memcpy_s(dest + step * SECUREC_MEM_MAX_LEN, count, src + step * SECUREC_MEM_MAX_LEN, count);
}
Status PluginOp::PluginToTensorRow(const std::vector<plugin::Tensor> &in_row, TensorRow *out_row) { Status PluginOp::PluginToTensorRow(const std::vector<plugin::Tensor> &in_row, TensorRow *out_row) {
CHECK_FAIL_RETURN_UNEXPECTED(out_row != nullptr && out_row->empty(), "null/empty out_row received!"); CHECK_FAIL_RETURN_UNEXPECTED(out_row != nullptr && out_row->empty(), "null/empty out_row received!");
out_row->reserve(in_row.size()); out_row->reserve(in_row.size());
@ -53,8 +41,13 @@ Status PluginOp::TensorRowToPlugin(const TensorRow &in_row, std::vector<plugin::
if (in_row[ind]->type().IsNumeric()) { if (in_row[ind]->type().IsNumeric()) {
dsize_t buffer_size = in_row[ind]->SizeInBytes(); dsize_t buffer_size = in_row[ind]->SizeInBytes();
tensor.buffer_.resize(buffer_size); tensor.buffer_.resize(buffer_size);
int ret_code = memcpy_s_loop(tensor.buffer_.data(), buffer_size, in_row[ind]->GetBuffer(), buffer_size); if (buffer_size < SECUREC_MEM_MAX_LEN) {
CHECK_FAIL_RETURN_UNEXPECTED(ret_code == 0, "Failed to copy data into tensor."); int ret_code = memcpy_s(tensor.buffer_.data(), tensor.buffer_.size(), in_row[ind]->GetBuffer(), buffer_size);
CHECK_FAIL_RETURN_UNEXPECTED(ret_code == 0, "Failed to copy data into plugin tensor.");
} else {
auto ret_code = std::memcpy(tensor.buffer_.data(), in_row[ind]->GetBuffer(), buffer_size);
CHECK_FAIL_RETURN_UNEXPECTED(ret_code == tensor.buffer_.data(), "Failed to copy data into plugin tensor.");
}
} else { // string tensor, for now, only tensor with 1 string is supported! } else { // string tensor, for now, only tensor with 1 string is supported!
CHECK_FAIL_RETURN_UNEXPECTED(in_row[ind]->shape().NumOfElements() == 1, CHECK_FAIL_RETURN_UNEXPECTED(in_row[ind]->shape().NumOfElements() == 1,
"String tensor with more than 1 element is not yet supported."); "String tensor with more than 1 element is not yet supported.");