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

fix pclint

This commit is contained in:
zetongzhao 2021-07-20 17:17:28 -04:00
parent 11694db238
commit ca517e4573
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) {
(void)py::class_<vision::AutoContrastOperation, TensorOperation, std::shared_ptr<vision::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);
THROW_IF_ERROR(auto_contrast->ValidateParams());
return auto_contrast;
@ -82,7 +82,7 @@ PYBIND_REGISTER(BoundingBoxAugmentOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::BoundingBoxAugmentOperation, TensorOperation,
std::shared_ptr<vision::BoundingBoxAugmentOperation>>(*m,
"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>(
std::move(toTensorOperation(transform)), ratio);
THROW_IF_ERROR(bounding_box_augment->ValidateParams());
@ -94,7 +94,7 @@ PYBIND_REGISTER(
CenterCropOperation, 1, ([](const py::module *m) {
(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)")
.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);
THROW_IF_ERROR(center_crop->ValidateParams());
return center_crop;
@ -104,7 +104,7 @@ PYBIND_REGISTER(
PYBIND_REGISTER(CropOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::CropOperation, TensorOperation, std::shared_ptr<vision::CropOperation>>(
*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
// those in CropOperation. So we need to swap the coordinates.
std::swap(coordinates[0], coordinates[1]);
@ -219,7 +219,7 @@ PYBIND_REGISTER(
NormalizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::NormalizeOperation, TensorOperation, std::shared_ptr<vision::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);
THROW_IF_ERROR(normalize->ValidateParams());
return normalize;
@ -240,8 +240,8 @@ PYBIND_REGISTER(
PYBIND_REGISTER(PadOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::PadOperation, TensorOperation, std::shared_ptr<vision::PadOperation>>(
*m, "PadOperation")
.def(py::init(
[](std::vector<int32_t> padding, std::vector<uint8_t> fill_value, BorderType padding_mode) {
.def(py::init([](const std::vector<int32_t> &padding, const std::vector<uint8_t> &fill_value,
BorderType padding_mode) {
auto pad = std::make_shared<vision::PadOperation>(padding, fill_value, padding_mode);
THROW_IF_ERROR(pad->ValidateParams());
return pad;
@ -266,8 +266,8 @@ PYBIND_REGISTER(RandomColorAdjustOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomColorAdjustOperation, TensorOperation,
std::shared_ptr<vision::RandomColorAdjustOperation>>(*m,
"RandomColorAdjustOperation")
.def(py::init([](std::vector<float> brightness, std::vector<float> contrast,
std::vector<float> saturation, std::vector<float> hue) {
.def(py::init([](const std::vector<float> &brightness, const std::vector<float> &contrast,
const std::vector<float> &saturation, const std::vector<float> &hue) {
auto random_color_adjust =
std::make_shared<vision::RandomColorAdjustOperation>(brightness, contrast, saturation, hue);
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,
std::shared_ptr<vision::RandomCropDecodeResizeOperation>>(
*m, "RandomCropDecodeResizeOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio,
InterpolationMode interpolation, int32_t max_attempts) {
auto random_crop_decode_resize = std::make_shared<vision::RandomCropDecodeResizeOperation>(
size, scale, ratio, interpolation, max_attempts);
std::shared_ptr<vision::RandomCropDecodeResizeOperation>>(*m, "RandomCropDecodeResizeOperation")
.def(py::init([](const std::vector<int32_t> &size, const std::vector<float> &scale,
const std::vector<float> &ratio, InterpolationMode interpolation, int32_t max_attempts) {
auto random_crop_decode_resize =
std::make_shared<vision::RandomCropDecodeResizeOperation>(size, scale, ratio, interpolation, max_attempts);
THROW_IF_ERROR(random_crop_decode_resize->ValidateParams());
return random_crop_decode_resize;
}));
@ -303,8 +303,8 @@ PYBIND_REGISTER(
RandomCropOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomCropOperation, TensorOperation, std::shared_ptr<vision::RandomCropOperation>>(
*m, "RandomCropOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed,
std::vector<uint8_t> fill_value, BorderType padding_mode) {
.def(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 =
std::make_shared<vision::RandomCropOperation>(size, padding, pad_if_needed, fill_value, padding_mode);
THROW_IF_ERROR(random_crop->ValidateParams());
@ -316,8 +316,9 @@ PYBIND_REGISTER(RandomCropWithBBoxOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomCropWithBBoxOperation, TensorOperation,
std::shared_ptr<vision::RandomCropWithBBoxOperation>>(*m,
"RandomCropWithBBoxOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed,
std::vector<uint8_t> fill_value, BorderType padding_mode) {
.def(
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>(
size, padding, pad_if_needed, fill_value, padding_mode);
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,
std::shared_ptr<vision::RandomResizedCropOperation>>(*m,
"RandomResizedCropOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio,
InterpolationMode interpolation, int32_t max_attempts) {
auto random_resized_crop = std::make_shared<vision::RandomResizedCropOperation>(
size, scale, ratio, interpolation, max_attempts);
std::shared_ptr<vision::RandomResizedCropOperation>>(*m, "RandomResizedCropOperation")
.def(py::init([](const std::vector<int32_t> &size, const std::vector<float> &scale,
const std::vector<float> &ratio, InterpolationMode interpolation, int32_t max_attempts) {
auto random_resized_crop =
std::make_shared<vision::RandomResizedCropOperation>(size, scale, ratio, interpolation, max_attempts);
THROW_IF_ERROR(random_resized_crop->ValidateParams());
return random_resized_crop;
}));
@ -375,8 +376,9 @@ PYBIND_REGISTER(RandomResizedCropWithBBoxOperation, 1, ([](const py::module *m)
(void)py::class_<vision::RandomResizedCropWithBBoxOperation, TensorOperation,
std::shared_ptr<vision::RandomResizedCropWithBBoxOperation>>(
*m, "RandomResizedCropWithBBoxOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio,
InterpolationMode interpolation, int32_t max_attempts) {
.def(py::init([](const std::vector<int32_t> &size, const std::vector<float> &scale,
const std::vector<float> &ratio, InterpolationMode interpolation,
int32_t max_attempts) {
auto random_resized_crop_with_bbox = std::make_shared<vision::RandomResizedCropWithBBoxOperation>(
size, scale, ratio, interpolation, max_attempts);
THROW_IF_ERROR(random_resized_crop_with_bbox->ValidateParams());
@ -388,7 +390,7 @@ PYBIND_REGISTER(
RandomResizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomResizeOperation, TensorOperation, std::shared_ptr<vision::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);
THROW_IF_ERROR(random_resize->ValidateParams());
return random_resize;
@ -399,7 +401,7 @@ PYBIND_REGISTER(RandomResizeWithBBoxOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomResizeWithBBoxOperation, TensorOperation,
std::shared_ptr<vision::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);
THROW_IF_ERROR(random_resize_with_bbox->ValidateParams());
return random_resize_with_bbox;
@ -422,7 +424,7 @@ PYBIND_REGISTER(
RandomSelectSubpolicyOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomSelectSubpolicyOperation, TensorOperation,
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;
for (auto &py_sub : py_policy) {
cpp_policy.push_back({});
@ -459,7 +461,7 @@ PYBIND_REGISTER(
PYBIND_REGISTER(RandomSharpnessOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomSharpnessOperation, TensorOperation,
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);
THROW_IF_ERROR(random_sharpness->ValidateParams());
return random_sharpness;
@ -469,7 +471,7 @@ PYBIND_REGISTER(RandomSharpnessOperation, 1, ([](const py::module *m) {
PYBIND_REGISTER(RandomSolarizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::RandomSolarizeOperation, TensorOperation,
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);
THROW_IF_ERROR(random_solarize->ValidateParams());
return random_solarize;
@ -513,7 +515,7 @@ PYBIND_REGISTER(RescaleOperation, 1, ([](const py::module *m) {
PYBIND_REGISTER(ResizeOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::ResizeOperation, TensorOperation, std::shared_ptr<vision::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);
THROW_IF_ERROR(resize->ValidateParams());
return resize;
@ -523,7 +525,7 @@ PYBIND_REGISTER(ResizeOperation, 1, ([](const py::module *m) {
PYBIND_REGISTER(ResizeWithBBoxOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::ResizeWithBBoxOperation, TensorOperation,
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 =
std::make_shared<vision::ResizeWithBBoxOperation>(size, interpolation_mode);
THROW_IF_ERROR(resize_with_bbox->ValidateParams());
@ -570,8 +572,8 @@ PYBIND_REGISTER(SoftDvppDecodeRandomCropResizeJpegOperation, 1, ([](const py::mo
(void)py::class_<vision::SoftDvppDecodeRandomCropResizeJpegOperation, TensorOperation,
std::shared_ptr<vision::SoftDvppDecodeRandomCropResizeJpegOperation>>(
*m, "SoftDvppDecodeRandomCropResizeJpegOperation")
.def(py::init([](std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio,
int32_t max_attempts) {
.def(py::init([](const std::vector<int32_t> &size, const std::vector<float> &scale,
const std::vector<float> &ratio, int32_t max_attempts) {
auto soft_dvpp_decode_random_crop_resize_jpeg =
std::make_shared<vision::SoftDvppDecodeRandomCropResizeJpegOperation>(size, scale, ratio,
max_attempts);
@ -584,7 +586,7 @@ PYBIND_REGISTER(SoftDvppDecodeResizeJpegOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::SoftDvppDecodeResizeJpegOperation, TensorOperation,
std::shared_ptr<vision::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 =
std::make_shared<vision::SoftDvppDecodeResizeJpegOperation>(size);
THROW_IF_ERROR(soft_dvpp_decode_resize_jpeg->ValidateParams());
@ -596,7 +598,7 @@ PYBIND_REGISTER(
UniformAugOperation, 1, ([](const py::module *m) {
(void)py::class_<vision::UniformAugOperation, TensorOperation, std::shared_ptr<vision::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 =
std::make_shared<vision::UniformAugOperation>(std::move(toTensorOperations(transforms)), num_ops);
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 {
#ifndef ENABLE_ANDROID
// AutoContrastOperation
AutoContrastOperation::AutoContrastOperation(float cutoff, std::vector<uint32_t> ignore)
AutoContrastOperation::AutoContrastOperation(float cutoff, const std::vector<uint32_t> &ignore)
: cutoff_(cutoff), ignore_(ignore) {}
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 {
public:
explicit AutoContrastOperation(float cutoff, std::vector<uint32_t> ignore);
explicit AutoContrastOperation(float cutoff, const std::vector<uint32_t> &ignore);
~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 vision {
#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) {}
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 {
public:
explicit BoundingBoxAugmentOperation(std::shared_ptr<TensorOperation> transform, float ratio);
explicit BoundingBoxAugmentOperation(const std::shared_ptr<TensorOperation> &transform, float ratio);
~BoundingBoxAugmentOperation();

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

@ -24,7 +24,7 @@
namespace mindspore {
namespace dataset {
namespace vision {
CenterCropOperation::CenterCropOperation(std::vector<int32_t> size) : size_(size) {}
CenterCropOperation::CenterCropOperation(const std::vector<int32_t> &size) : size_(size) {}
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 {
public:
explicit CenterCropOperation(std::vector<int32_t> size);
explicit CenterCropOperation(const std::vector<int32_t> &size);
~CenterCropOperation();

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

@ -24,7 +24,7 @@
namespace mindspore {
namespace dataset {
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) {}
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 {
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();

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

@ -25,7 +25,8 @@ namespace mindspore {
namespace dataset {
namespace vision {
// 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;

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 {
public:
NormalizeOperation(std::vector<float> mean, std::vector<float> std);
NormalizeOperation(const std::vector<float> &mean, const std::vector<float> &std);
~NormalizeOperation();

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

@ -28,7 +28,8 @@ namespace dataset {
namespace vision {
#ifndef ENABLE_ANDROID
// 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) {}
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 {
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();

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
// RandomColorAdjustOperation.
RandomColorAdjustOperation::RandomColorAdjustOperation(std::vector<float> brightness, std::vector<float> contrast,
std::vector<float> saturation, std::vector<float> hue)
RandomColorAdjustOperation::RandomColorAdjustOperation(const std::vector<float> &brightness,
const std::vector<float> &contrast,
const std::vector<float> &saturation,
const std::vector<float> &hue)
: brightness_(brightness), contrast_(contrast), saturation_(saturation), hue_(hue) {
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 {
public:
RandomColorAdjustOperation(std::vector<float> brightness, std::vector<float> contrast, std::vector<float> saturation,
std::vector<float> hue);
RandomColorAdjustOperation(const std::vector<float> &brightness, const std::vector<float> &contrast,
const std::vector<float> &saturation, const std::vector<float> &hue);
~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 {
#ifndef ENABLE_ANDROID
// RandomCropDecodeResizeOperation
RandomCropDecodeResizeOperation::RandomCropDecodeResizeOperation(std::vector<int32_t> size, std::vector<float> scale,
std::vector<float> ratio,
RandomCropDecodeResizeOperation::RandomCropDecodeResizeOperation(const std::vector<int32_t> &size,
const std::vector<float> &scale,
const std::vector<float> &ratio,
InterpolationMode interpolation, int32_t 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 {
public:
RandomCropDecodeResizeOperation(std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio,
InterpolationMode interpolation, int32_t max_attempts);
RandomCropDecodeResizeOperation(const std::vector<int32_t> &size, const std::vector<float> &scale,
const std::vector<float> &ratio, InterpolationMode interpolation,
int32_t max_attempts);
explicit RandomCropDecodeResizeOperation(const RandomResizedCropOperation &base);

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

@ -22,14 +22,14 @@
#endif
#include "minddata/dataset/kernels/ir/validators.h"
namespace mindspore {
namespace dataset {
namespace vision {
#ifndef ENABLE_ANDROID
// RandomCropOperation
RandomCropOperation::RandomCropOperation(std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed,
std::vector<uint8_t> fill_value, BorderType padding_mode)
RandomCropOperation::RandomCropOperation(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)
: TensorOperation(true),
size_(size),
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 {
public:
RandomCropOperation(std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed,
std::vector<uint8_t> fill_value, BorderType padding_mode);
RandomCropOperation(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);
~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 {
#ifndef ENABLE_ANDROID
// RandomCropWithBBoxOperation
RandomCropWithBBoxOperation::RandomCropWithBBoxOperation(std::vector<int32_t> size, std::vector<int32_t> padding,
bool pad_if_needed, std::vector<uint8_t> fill_value,
RandomCropWithBBoxOperation::RandomCropWithBBoxOperation(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)
: TensorOperation(true),
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 {
public:
RandomCropWithBBoxOperation(std::vector<int32_t> size, std::vector<int32_t> padding, bool pad_if_needed,
std::vector<uint8_t> fill_value, BorderType padding_mode);
RandomCropWithBBoxOperation(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);
~RandomCropWithBBoxOperation();

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

@ -28,7 +28,7 @@ namespace dataset {
namespace vision {
#ifndef ENABLE_ANDROID
// 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;

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 {
public:
explicit RandomResizeOperation(std::vector<int32_t> size);
explicit RandomResizeOperation(const std::vector<int32_t> &size);
~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 {
#ifndef ENABLE_ANDROID
// RandomResizeWithBBoxOperation
RandomResizeWithBBoxOperation::RandomResizeWithBBoxOperation(std::vector<int32_t> size)
RandomResizeWithBBoxOperation::RandomResizeWithBBoxOperation(const std::vector<int32_t> &size)
: TensorOperation(true), size_(size) {}
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 {
public:
explicit RandomResizeWithBBoxOperation(std::vector<int32_t> size);
explicit RandomResizeWithBBoxOperation(const std::vector<int32_t> &size);
~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::RandomResizedCropOperation(std::vector<int32_t> size, std::vector<float> scale,
std::vector<float> ratio, InterpolationMode interpolation,
int32_t max_attempts)
RandomResizedCropOperation::RandomResizedCropOperation(const std::vector<int32_t> &size,
const std::vector<float> &scale, const std::vector<float> &ratio,
InterpolationMode interpolation, int32_t max_attempts)
: TensorOperation(true),
size_(size),
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 {
public:
RandomResizedCropOperation(std::vector<int32_t> size, std::vector<float> scale, std::vector<float> ratio,
InterpolationMode interpolation, int32_t max_attempts);
RandomResizedCropOperation(const std::vector<int32_t> &size, const std::vector<float> &scale,
const std::vector<float> &ratio, InterpolationMode interpolation, int32_t max_attempts);
/// \brief default copy constructor
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 {
#ifndef ENABLE_ANDROID
// RandomResizedCropWithBBoxOperation
RandomResizedCropWithBBoxOperation::RandomResizedCropWithBBoxOperation(std::vector<int32_t> size,
std::vector<float> scale,
std::vector<float> ratio,
RandomResizedCropWithBBoxOperation::RandomResizedCropWithBBoxOperation(const std::vector<int32_t> &size,
const std::vector<float> &scale,
const std::vector<float> &ratio,
InterpolationMode interpolation,
int32_t 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 {
public:
explicit RandomResizedCropWithBBoxOperation(std::vector<int32_t> size, std::vector<float> scale,
std::vector<float> ratio, InterpolationMode interpolation,
explicit RandomResizedCropWithBBoxOperation(const std::vector<int32_t> &size, const std::vector<float> &scale,
const std::vector<float> &ratio, InterpolationMode interpolation,
int32_t max_attempts);
~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
// 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) {}
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 {
public:
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();

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;
// Function to create RandomSharpness.
RandomSharpnessOperation::RandomSharpnessOperation(std::vector<float> degrees)
RandomSharpnessOperation::RandomSharpnessOperation(const std::vector<float> &degrees)
: TensorOperation(true), degrees_(degrees) {}
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 {
public:
explicit RandomSharpnessOperation(std::vector<float> degrees);
explicit RandomSharpnessOperation(const std::vector<float> &degrees);
~RandomSharpnessOperation();

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

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

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

@ -25,7 +25,7 @@ namespace mindspore {
namespace dataset {
namespace vision {
// ResizeOperation
ResizeOperation::ResizeOperation(std::vector<int32_t> size, InterpolationMode interpolation)
ResizeOperation::ResizeOperation(const std::vector<int32_t> &size, InterpolationMode interpolation)
: size_(size), interpolation_(interpolation) {}
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 {
public:
explicit ResizeOperation(std::vector<int32_t> size, InterpolationMode interpolation);
explicit ResizeOperation(const std::vector<int32_t> &size, InterpolationMode interpolation);
~ResizeOperation();

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

@ -28,7 +28,7 @@ namespace dataset {
namespace vision {
#ifndef ENABLE_ANDROID
// ResizeWithBBoxOperation
ResizeWithBBoxOperation::ResizeWithBBoxOperation(std::vector<int32_t> size, InterpolationMode interpolation)
ResizeWithBBoxOperation::ResizeWithBBoxOperation(const std::vector<int32_t> &size, InterpolationMode interpolation)
: size_(size), interpolation_(interpolation) {}
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 {
public:
explicit ResizeWithBBoxOperation(std::vector<int32_t> size, InterpolationMode interpolation_mode);
explicit ResizeWithBBoxOperation(const std::vector<int32_t> &size, InterpolationMode interpolation_mode);
~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 {
#ifndef ENABLE_ANDROID
// SoftDvppDecodeRandomCropResizeJpegOperation
SoftDvppDecodeRandomCropResizeJpegOperation::SoftDvppDecodeRandomCropResizeJpegOperation(std::vector<int32_t> size,
std::vector<float> scale,
std::vector<float> ratio,
SoftDvppDecodeRandomCropResizeJpegOperation::SoftDvppDecodeRandomCropResizeJpegOperation(
const std::vector<int32_t> &size, const std::vector<float> &scale, const std::vector<float> &ratio,
int32_t 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 {
public:
explicit SoftDvppDecodeRandomCropResizeJpegOperation(std::vector<int32_t> size, std::vector<float> scale,
std::vector<float> ratio, int32_t max_attempts);
explicit SoftDvppDecodeRandomCropResizeJpegOperation(const std::vector<int32_t> &size,
const std::vector<float> &scale, const std::vector<float> &ratio,
int32_t max_attempts);
~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 {
#ifndef ENABLE_ANDROID
// SoftDvppDecodeResizeJpegOperation
SoftDvppDecodeResizeJpegOperation::SoftDvppDecodeResizeJpegOperation(std::vector<int32_t> size) : size_(size) {}
SoftDvppDecodeResizeJpegOperation::SoftDvppDecodeResizeJpegOperation(const std::vector<int32_t> &size) : size_(size) {}
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 {
public:
explicit SoftDvppDecodeResizeJpegOperation(std::vector<int32_t> size);
explicit SoftDvppDecodeResizeJpegOperation(const std::vector<int32_t> &size);
~SoftDvppDecodeResizeJpegOperation();

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

@ -28,7 +28,8 @@ namespace dataset {
namespace vision {
#ifndef ENABLE_ANDROID
// 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) {}
UniformAugOperation::~UniformAugOperation() = default;
@ -51,8 +52,9 @@ Status UniformAugOperation::ValidateParams() {
std::shared_ptr<TensorOp> UniformAugOperation::Build() {
std::vector<std::shared_ptr<TensorOp>> tensor_ops;
(void)std::transform(transforms_.begin(), transforms_.end(), std::back_inserter(tensor_ops),
[](std::shared_ptr<TensorOperation> op) -> std::shared_ptr<TensorOp> { return op->Build(); });
(void)std::transform(
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_);
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 {
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();

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

@ -20,18 +20,6 @@
namespace mindspore {
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) {
CHECK_FAIL_RETURN_UNEXPECTED(out_row != nullptr && out_row->empty(), "null/empty out_row received!");
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()) {
dsize_t buffer_size = in_row[ind]->SizeInBytes();
tensor.buffer_.resize(buffer_size);
int ret_code = memcpy_s_loop(tensor.buffer_.data(), buffer_size, in_row[ind]->GetBuffer(), buffer_size);
CHECK_FAIL_RETURN_UNEXPECTED(ret_code == 0, "Failed to copy data into tensor.");
if (buffer_size < SECUREC_MEM_MAX_LEN) {
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!
CHECK_FAIL_RETURN_UNEXPECTED(in_row[ind]->shape().NumOfElements() == 1,
"String tensor with more than 1 element is not yet supported.");