Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
magicwindyyd
mindspore
提交
c1e6ece5
M
mindspore
项目概览
magicwindyyd
/
mindspore
与 Fork 源项目一致
Fork自
MindSpore / mindspore
通知
1
Star
1
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
M
mindspore
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
提交
c1e6ece5
编写于
6月 18, 2020
作者:
D
Danish Farid
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
my files added back in
another commit comm2 comm3 comm4 comm5 comm6
上级
14241786
变更
14
隐藏空白更改
内联
并排
Showing
14 changed file
with
669 addition
and
27 deletion
+669
-27
graphengine
graphengine
+1
-1
mindspore/ccsrc/dataset/api/python_bindings.cc
mindspore/ccsrc/dataset/api/python_bindings.cc
+37
-0
mindspore/ccsrc/dataset/kernels/image/CMakeLists.txt
mindspore/ccsrc/dataset/kernels/image/CMakeLists.txt
+3
-0
mindspore/ccsrc/dataset/kernels/image/image_utils.cc
mindspore/ccsrc/dataset/kernels/image/image_utils.cc
+97
-0
mindspore/ccsrc/dataset/kernels/image/image_utils.h
mindspore/ccsrc/dataset/kernels/image/image_utils.h
+33
-1
mindspore/ccsrc/dataset/kernels/image/random_crop_and_resize_with_bbox_op.cc
...aset/kernels/image/random_crop_and_resize_with_bbox_op.cc
+58
-0
mindspore/ccsrc/dataset/kernels/image/random_crop_and_resize_with_bbox_op.h
...taset/kernels/image/random_crop_and_resize_with_bbox_op.h
+46
-0
mindspore/ccsrc/dataset/kernels/image/random_crop_op.cc
mindspore/ccsrc/dataset/kernels/image/random_crop_op.cc
+61
-24
mindspore/ccsrc/dataset/kernels/image/random_crop_op.h
mindspore/ccsrc/dataset/kernels/image/random_crop_op.h
+10
-1
mindspore/ccsrc/dataset/kernels/image/random_crop_with_bbox_op.cc
...e/ccsrc/dataset/kernels/image/random_crop_with_bbox_op.cc
+67
-0
mindspore/ccsrc/dataset/kernels/image/random_crop_with_bbox_op.h
...re/ccsrc/dataset/kernels/image/random_crop_with_bbox_op.h
+48
-0
mindspore/ccsrc/dataset/kernels/image/random_vertical_flip_with_bbox_op.cc
...ataset/kernels/image/random_vertical_flip_with_bbox_op.cc
+58
-0
mindspore/ccsrc/dataset/kernels/image/random_vertical_flip_with_bbox_op.h
...dataset/kernels/image/random_vertical_flip_with_bbox_op.h
+52
-0
mindspore/dataset/transforms/vision/c_transforms.py
mindspore/dataset/transforms/vision/c_transforms.py
+98
-0
未找到文件。
graphengine
@
45ca7863
Subproject commit
1350673d51b3f8535bc217a7780e6a0b52ff9a41
Subproject commit
45ca7863ac6410c8e2f83168481ddc6b43bcea33
mindspore/ccsrc/dataset/api/python_bindings.cc
浏览文件 @
c1e6ece5
...
...
@@ -56,13 +56,16 @@
#include "dataset/kernels/image/pad_op.h"
#include "dataset/kernels/image/random_color_adjust_op.h"
#include "dataset/kernels/image/random_crop_and_resize_op.h"
#include "dataset/kernels/image/random_crop_and_resize_with_bbox_op.h"
#include "dataset/kernels/image/random_crop_decode_resize_op.h"
#include "dataset/kernels/image/random_crop_op.h"
#include "dataset/kernels/image/random_crop_with_bbox_op.h"
#include "dataset/kernels/image/random_horizontal_flip_bbox_op.h"
#include "dataset/kernels/image/random_horizontal_flip_op.h"
#include "dataset/kernels/image/random_resize_op.h"
#include "dataset/kernels/image/random_rotation_op.h"
#include "dataset/kernels/image/random_vertical_flip_op.h"
#include "dataset/kernels/image/random_vertical_flip_with_bbox_op.h"
#include "dataset/kernels/image/rescale_op.h"
#include "dataset/kernels/image/resize_bilinear_op.h"
#include "dataset/kernels/image/resize_op.h"
...
...
@@ -381,6 +384,12 @@ void bindTensorOps2(py::module *m) {
*
m
,
"RandomVerticalFlipOp"
,
"Tensor operation to randomly flip an image vertically."
)
.
def
(
py
::
init
<
float
>
(),
py
::
arg
(
"probability"
)
=
RandomVerticalFlipOp
::
kDefProbability
);
(
void
)
py
::
class_
<
RandomVerticalFlipWithBBoxOp
,
TensorOp
,
std
::
shared_ptr
<
RandomVerticalFlipWithBBoxOp
>>
(
*
m
,
"RandomVerticalFlipWithBBoxOp"
,
"Tensor operation to randomly flip an image vertically"
" and adjust bounding boxes."
)
.
def
(
py
::
init
<
float
>
(),
py
::
arg
(
"probability"
)
=
RandomVerticalFlipWithBBoxOp
::
kDefProbability
);
(
void
)
py
::
class_
<
RandomCropOp
,
TensorOp
,
std
::
shared_ptr
<
RandomCropOp
>>
(
*
m
,
"RandomCropOp"
,
"Gives random crop of specified size "
"Takes crop size"
)
...
...
@@ -392,6 +401,20 @@ void bindTensorOps2(py::module *m) {
py
::
arg
(
"fillG"
)
=
RandomCropOp
::
kDefFillG
,
py
::
arg
(
"fillB"
)
=
RandomCropOp
::
kDefFillB
);
(
void
)
py
::
class_
<
HwcToChwOp
,
TensorOp
,
std
::
shared_ptr
<
HwcToChwOp
>>
(
*
m
,
"ChannelSwapOp"
).
def
(
py
::
init
<>
());
(
void
)
py
::
class_
<
RandomCropWithBBoxOp
,
TensorOp
,
std
::
shared_ptr
<
RandomCropWithBBoxOp
>>
(
*
m
,
"RandomCropWithBBoxOp"
,
"Gives random crop of given "
"size + adjusts bboxes "
"Takes crop size"
)
.
def
(
py
::
init
<
int32_t
,
int32_t
,
int32_t
,
int32_t
,
int32_t
,
int32_t
,
BorderType
,
bool
,
uint8_t
,
uint8_t
,
uint8_t
>
(),
py
::
arg
(
"cropHeight"
),
py
::
arg
(
"cropWidth"
),
py
::
arg
(
"padTop"
)
=
RandomCropWithBBoxOp
::
kDefPadTop
,
py
::
arg
(
"padBottom"
)
=
RandomCropWithBBoxOp
::
kDefPadBottom
,
py
::
arg
(
"padLeft"
)
=
RandomCropWithBBoxOp
::
kDefPadLeft
,
py
::
arg
(
"padRight"
)
=
RandomCropWithBBoxOp
::
kDefPadRight
,
py
::
arg
(
"borderType"
)
=
RandomCropWithBBoxOp
::
kDefBorderType
,
py
::
arg
(
"padIfNeeded"
)
=
RandomCropWithBBoxOp
::
kDefPadIfNeeded
,
py
::
arg
(
"fillR"
)
=
RandomCropWithBBoxOp
::
kDefFillR
,
py
::
arg
(
"fillG"
)
=
RandomCropWithBBoxOp
::
kDefFillG
,
py
::
arg
(
"fillB"
)
=
RandomCropWithBBoxOp
::
kDefFillB
);
(
void
)
py
::
class_
<
OneHotOp
,
TensorOp
,
std
::
shared_ptr
<
OneHotOp
>>
(
*
m
,
"OneHotOp"
,
"Tensor operation to apply one hot encoding. Takes number of classes."
)
.
def
(
py
::
init
<
int32_t
>
());
...
...
@@ -488,6 +511,20 @@ void bindTensorOps3(py::module *m) {
py
::
arg
(
"interpolation"
)
=
RandomCropAndResizeOp
::
kDefInterpolation
,
py
::
arg
(
"maxIter"
)
=
RandomCropAndResizeOp
::
kDefMaxIter
);
(
void
)
py
::
class_
<
RandomCropAndResizeWithBBoxOp
,
TensorOp
,
std
::
shared_ptr
<
RandomCropAndResizeWithBBoxOp
>>
(
*
m
,
"RandomCropAndResizeWithBBoxOp"
,
"Tensor operation to randomly crop an image (with BBoxes) and resize to a given size."
"Takes output height and width and"
"optional parameters for lower and upper bound for aspect ratio (h/w) and scale,"
"interpolation mode, and max attempts to crop"
)
.
def
(
py
::
init
<
int32_t
,
int32_t
,
float
,
float
,
float
,
float
,
InterpolationMode
,
int32_t
>
(),
py
::
arg
(
"targetHeight"
),
py
::
arg
(
"targetWidth"
),
py
::
arg
(
"scaleLb"
)
=
RandomCropAndResizeWithBBoxOp
::
kDefScaleLb
,
py
::
arg
(
"scaleUb"
)
=
RandomCropAndResizeWithBBoxOp
::
kDefScaleUb
,
py
::
arg
(
"aspectLb"
)
=
RandomCropAndResizeWithBBoxOp
::
kDefAspectLb
,
py
::
arg
(
"aspectUb"
)
=
RandomCropAndResizeWithBBoxOp
::
kDefAspectUb
,
py
::
arg
(
"interpolation"
)
=
RandomCropAndResizeWithBBoxOp
::
kDefInterpolation
,
py
::
arg
(
"maxIter"
)
=
RandomCropAndResizeWithBBoxOp
::
kDefMaxIter
);
(
void
)
py
::
class_
<
RandomColorAdjustOp
,
TensorOp
,
std
::
shared_ptr
<
RandomColorAdjustOp
>>
(
*
m
,
"RandomColorAdjustOp"
,
"Tensor operation to adjust an image's color randomly."
...
...
mindspore/ccsrc/dataset/kernels/image/CMakeLists.txt
浏览文件 @
c1e6ece5
...
...
@@ -10,14 +10,17 @@ add_library(kernels-image OBJECT
pad_op.cc
random_color_adjust_op.cc
random_crop_decode_resize_op.cc
random_crop_and_resize_with_bbox_op.cc
random_crop_and_resize_op.cc
random_crop_op.cc
random_crop_with_bbox_op.cc
random_horizontal_flip_op.cc
random_horizontal_flip_bbox_op.cc
bounding_box_augment_op.cc
random_resize_op.cc
random_rotation_op.cc
random_vertical_flip_op.cc
random_vertical_flip_with_bbox_op.cc
rescale_op.cc
resize_bilinear_op.cc
resize_op.cc
...
...
mindspore/ccsrc/dataset/kernels/image/image_utils.cc
浏览文件 @
c1e6ece5
...
...
@@ -16,6 +16,7 @@
#include "dataset/kernels/image/image_utils.h"
#include <opencv2/imgproc/types_c.h>
#include <algorithm>
#include <vector>
#include <stdexcept>
#include <utility>
#include <opencv2/imgcodecs.hpp>
...
...
@@ -724,5 +725,101 @@ Status Pad(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *output
RETURN_STATUS_UNEXPECTED
(
"Unexpected error in pad"
);
}
}
// -------- BBOX OPERATIONS -------- //
void
UpdateBBoxesForCrop
(
std
::
shared_ptr
<
Tensor
>
*
bboxList
,
size_t
*
bboxCount
,
int
*
CB_Xmin
,
int
*
CB_Ymin
,
int
*
CB_Xmax
,
int
*
CB_Ymax
)
{
// PASS LIST, COUNT OF BOUNDING BOXES
// Also PAss X/Y Min/Max of image cropped region - normally obtained from 'GetCropBox' functions
uint32_t
bb_Xmin_t
,
bb_Ymin_t
,
bb_Xmax_t
,
bb_Ymax_t
;
std
::
vector
<
int
>
correctInd
;
std
::
vector
<
uint32_t
>
copyVals
;
dsize_t
bboxDim
=
(
*
bboxList
)
->
shape
()[
1
];
bool
retFlag
=
false
;
// true unless overlap found
for
(
int
i
=
0
;
i
<
*
bboxCount
;
i
++
)
{
int
bb_Xmin
,
bb_Xmax
,
bb_Ymin
,
bb_Ymax
;
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
bb_Xmin_t
,
{
i
,
0
});
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
bb_Ymin_t
,
{
i
,
1
});
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
bb_Xmax_t
,
{
i
,
2
});
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
bb_Ymax_t
,
{
i
,
3
});
bb_Xmin
=
bb_Xmin_t
;
bb_Ymin
=
bb_Ymin_t
;
bb_Xmax
=
bb_Xmax_t
;
bb_Ymax
=
bb_Ymax_t
;
bb_Xmax
=
bb_Xmin
+
bb_Xmax
;
bb_Ymax
=
bb_Ymin
+
bb_Ymax
;
// check for image / BB overlap
if
(((
bb_Xmin
>
*
CB_Xmax
)
||
(
bb_Ymin
>
*
CB_Ymax
))
||
((
bb_Xmax
<
*
CB_Xmin
)
||
(
bb_Ymax
<
*
CB_Ymin
)))
{
retFlag
=
true
;
// no overlap found
}
if
(
retFlag
)
{
// invalid bbox no longer within image region - reset to zero
continue
;
}
// Update this bbox and select it to move to the final output tensor
correctInd
.
push_back
(
i
);
// adjust BBox corners by bringing into new CropBox if beyond
// Also reseting/adjusting for boxes to lie within CropBox instead of Image - subtract CropBox Xmin/YMin
bb_Xmin
=
bb_Xmin
-
(
std
::
min
(
0
,
(
bb_Xmin
-
*
CB_Xmin
))
+
*
CB_Xmin
);
bb_Xmax
=
bb_Xmax
-
(
std
::
max
(
0
,
(
bb_Xmax
-
*
CB_Xmax
))
+
*
CB_Xmin
);
bb_Ymin
=
bb_Ymin
-
(
std
::
min
(
0
,
(
bb_Ymin
-
*
CB_Ymin
))
+
*
CB_Ymin
);
bb_Ymax
=
bb_Ymax
-
(
std
::
max
(
0
,
(
bb_Ymax
-
*
CB_Ymax
))
+
*
CB_Ymin
);
// reset min values and calculate width/height from Box corners
(
*
bboxList
)
->
SetItemAt
({
i
,
0
},
(
uint32_t
)(
bb_Xmin
));
(
*
bboxList
)
->
SetItemAt
({
i
,
1
},
(
uint32_t
)(
bb_Ymin
));
(
*
bboxList
)
->
SetItemAt
({
i
,
2
},
(
uint32_t
)(
bb_Xmax
-
bb_Xmin
));
(
*
bboxList
)
->
SetItemAt
({
i
,
3
},
(
uint32_t
)(
bb_Ymax
-
bb_Ymin
));
}
// create new tensor and copy over bboxes still valid to the image
// bboxes outside of new cropped region are ignored - empty tensor returned in case of none
*
bboxCount
=
correctInd
.
size
();
uint32_t
temp
;
for
(
auto
slice
:
correctInd
)
{
// for every index in the loop
for
(
int
ix
=
0
;
ix
<
bboxDim
;
ix
++
)
{
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
temp
,
{
slice
,
ix
});
copyVals
.
push_back
(
temp
);
}
}
std
::
shared_ptr
<
Tensor
>
retV
;
Tensor
::
CreateTensor
(
&
retV
,
copyVals
,
TensorShape
({(
dsize_t
)
bboxCount
,
bboxDim
}));
(
*
bboxList
)
=
retV
;
// reset pointer
}
void
PadBBoxes
(
std
::
shared_ptr
<
Tensor
>
*
bboxList
,
size_t
*
bboxCount
,
int32_t
*
pad_top
,
int32_t
*
pad_left
)
{
uint32_t
xMin
=
0
;
uint32_t
yMin
=
0
;
for
(
int
i
=
0
;
i
<
*
bboxCount
;
i
++
)
{
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
xMin
,
{
i
,
0
});
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
yMin
,
{
i
,
1
});
xMin
=
xMin
+
(
uint32_t
)(
*
pad_left
);
// should not be negative
yMin
=
yMin
+
(
uint32_t
)(
*
pad_top
);
(
*
bboxList
)
->
SetItemAt
({
i
,
0
},
xMin
);
(
*
bboxList
)
->
SetItemAt
({
i
,
1
},
yMin
);
}
}
void
UpdateBBoxesForResize
(
std
::
shared_ptr
<
Tensor
>
*
bboxList
,
size_t
*
bboxCount
,
int32_t
*
target_width_
,
int32_t
*
target_height_
,
int
*
orig_width
,
int
*
orig_height
)
{
uint32_t
bb_Xmin
,
bb_Ymin
,
bb_Xwidth
,
bb_Ywidth
;
// cast to float to preseve fractional
double
W_aspRatio
=
(
*
target_width_
*
1.0
)
/
(
*
orig_width
*
1.0
);
double
H_aspRatio
=
(
*
target_height_
*
1.0
)
/
(
*
orig_height
*
1.0
);
for
(
int
i
=
0
;
i
<
*
bboxCount
;
i
++
)
{
// for each bounding box
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
bb_Xmin
,
{
i
,
0
});
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
bb_Ymin
,
{
i
,
1
});
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
bb_Xwidth
,
{
i
,
2
});
(
*
bboxList
)
->
GetUnsignedIntAt
(
&
bb_Ywidth
,
{
i
,
3
});
// update positions and widths
bb_Xmin
=
bb_Xmin
*
W_aspRatio
;
bb_Ymin
=
bb_Ymin
*
H_aspRatio
;
bb_Xwidth
=
bb_Xwidth
*
W_aspRatio
;
bb_Ywidth
=
bb_Ywidth
*
H_aspRatio
;
// reset bounding box values
(
*
bboxList
)
->
SetItemAt
({
i
,
0
},
(
uint32_t
)
bb_Xmin
);
(
*
bboxList
)
->
SetItemAt
({
i
,
1
},
(
uint32_t
)
bb_Ymin
);
(
*
bboxList
)
->
SetItemAt
({
i
,
2
},
(
uint32_t
)
bb_Xwidth
);
(
*
bboxList
)
->
SetItemAt
({
i
,
3
},
(
uint32_t
)
bb_Ywidth
);
}
}
}
// namespace dataset
}
// namespace mindspore
mindspore/ccsrc/dataset/kernels/image/image_utils.h
浏览文件 @
c1e6ece5
...
...
@@ -225,7 +225,39 @@ Status Erase(const std::shared_ptr<Tensor> &input, std::shared_ptr<Tensor> *outp
Status
Pad
(
const
std
::
shared_ptr
<
Tensor
>
&
input
,
std
::
shared_ptr
<
Tensor
>
*
output
,
const
int32_t
&
pad_top
,
const
int32_t
&
pad_bottom
,
const
int32_t
&
pad_left
,
const
int32_t
&
pad_right
,
const
BorderType
&
border_types
,
uint8_t
fill_r
=
0
,
uint8_t
fill_g
=
0
,
uint8_t
fill_b
=
0
);
// -------- BBOX OPERATIONS -------- //
// Updates and checks bounding boxes for new cropped region of image
// @param bboxList: A tensor contaning bounding box tensors
// @param bboxCount: total Number of bounding boxes - required within caller function to run update loop
// @param CB_Xmin: Images's CropBox Xmin coordinate
// @param CB_Xmin: Images's CropBox Ymin coordinate
// @param CB_Xmax: Images's CropBox Xmax coordinate - (Xmin + width)
// @param CB_Xmax: Images's CropBox Ymax coordinate - (Ymin + height)
void
UpdateBBoxesForCrop
(
std
::
shared_ptr
<
Tensor
>
*
bboxList
,
size_t
*
bboxCount
,
int
*
CB_Xmin
,
int
*
CB_Ymin
,
int
*
CB_Xmax
,
int
*
CB_Ymax
);
// Updates bounding boxes with required Top and Left padding
// Top and Left padding amounts required to adjust bboxs min X,Y values according to padding 'push'
// Top/Left since images 0,0 coordinate is taken from top left
// @param bboxList: A tensor contaning bounding box tensors
// @param bboxCount: total Number of bounding boxes - required within caller function to run update loop
// @param pad_top: Total amount of padding applied to image top
// @param pad_left: Total amount of padding applied to image left side
void
PadBBoxes
(
std
::
shared_ptr
<
Tensor
>
*
bboxList
,
size_t
*
bboxCount
,
int32_t
*
pad_top
,
int32_t
*
pad_left
);
// Updates bounding boxes for an Image Resize Operation - Takes in set of valid BBoxes
// For e.g those that remain after a crop
// @param bboxList: A tensor contaning bounding box tensors
// @param bboxCount: total Number of bounding boxes - required within caller function to run update loop
// @param bboxList: A tensor contaning bounding box tensors
// @param target_width_: required width of image post resize
// @param target_width_: required height of image post resize
// @param orig_width: current width of image pre resize
// @param orig_height: current height of image pre resize
void
UpdateBBoxesForResize
(
std
::
shared_ptr
<
Tensor
>
*
bboxList
,
size_t
*
bboxCount
,
int32_t
*
target_width_
,
int32_t
*
target_height_
,
int
*
orig_width
,
int
*
orig_height
);
}
// namespace dataset
}
// namespace mindspore
#endif // DATASET_KERNELS_IMAGE_IMAGE_UTILS_H_
mindspore/ccsrc/dataset/kernels/image/random_crop_and_resize_with_bbox_op.cc
0 → 100644
浏览文件 @
c1e6ece5
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <random>
#include <utility>
#include "dataset/util/random.h"
#include "dataset/util/status.h"
#include "dataset/kernels/image/image_utils.h"
#include "dataset/kernels/image/random_crop_and_resize_with_bbox_op.h"
namespace
mindspore
{
namespace
dataset
{
Status
RandomCropAndResizeWithBBoxOp
::
Compute
(
const
TensorRow
&
input
,
TensorRow
*
output
)
{
IO_CHECK_VECTOR
(
input
,
output
);
BOUNDING_BOX_CHECK
(
input
);
CHECK_FAIL_RETURN_UNEXPECTED
(
input
[
0
]
->
shape
().
Size
()
>=
2
,
"The shape of input is abnormal"
);
(
*
output
).
push_back
(
nullptr
);
// init memory for return vector
(
*
output
).
push_back
(
nullptr
);
(
*
output
)[
1
]
=
std
::
move
(
input
[
1
]);
// move boxes over to output
size_t
bboxCount
=
input
[
1
]
->
shape
()[
0
];
// number of rows in bbox tensor
int
h_in
=
input
[
0
]
->
shape
()[
0
];
int
w_in
=
input
[
0
]
->
shape
()[
1
];
int
x
=
0
;
int
y
=
0
;
int
crop_height
=
0
;
int
crop_width
=
0
;
(
void
)
RandomCropAndResizeOp
::
GetCropBox
(
h_in
,
w_in
,
&
x
,
&
y
,
&
crop_height
,
&
crop_width
);
int
maxX
=
x
+
crop_width
;
// max dims of selected CropBox on image
int
maxY
=
y
+
crop_height
;
UpdateBBoxesForCrop
(
&
(
*
output
)[
1
],
&
bboxCount
,
&
x
,
&
y
,
&
maxX
,
&
maxY
);
// IMAGE_UTIL
RETURN_IF_NOT_OK
(
CropAndResize
(
input
[
0
],
&
(
*
output
)[
0
],
x
,
y
,
crop_height
,
crop_width
,
target_height_
,
target_width_
,
interpolation_
));
UpdateBBoxesForResize
(
&
(
*
output
)[
1
],
&
bboxCount
,
&
target_width_
,
&
target_height_
,
&
crop_width
,
&
crop_height
);
return
Status
::
OK
();
}
}
// namespace dataset
}
// namespace mindspore
mindspore/ccsrc/dataset/kernels/image/random_crop_and_resize_with_bbox_op.h
0 → 100644
浏览文件 @
c1e6ece5
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DATASET_KERNELS_IMAGE_RANDOM_CROP_AND_RESIZE_WITH_BBOX_OP_H_
#define DATASET_KERNELS_IMAGE_RANDOM_CROP_AND_RESIZE_WITH_BBOX_OP_H_
#include "dataset/kernels/image/random_crop_and_resize_op.h"
namespace
mindspore
{
namespace
dataset
{
class
RandomCropAndResizeWithBBoxOp
:
public
RandomCropAndResizeOp
{
public:
// Constructor for RandomCropAndResizeWithBBoxOp, with default value and passing to base class constructor
RandomCropAndResizeWithBBoxOp
(
int32_t
target_height
,
int32_t
target_width
,
float
scale_lb
=
kDefScaleLb
,
float
scale_ub
=
kDefScaleUb
,
float
aspect_lb
=
kDefAspectLb
,
float
aspect_ub
=
kDefAspectUb
,
InterpolationMode
interpolation
=
kDefInterpolation
,
int32_t
max_iter
=
kDefMaxIter
)
:
RandomCropAndResizeOp
(
target_height
,
target_width
,
scale_lb
,
scale_ub
,
aspect_lb
,
aspect_ub
,
interpolation
,
max_iter
)
{}
~
RandomCropAndResizeWithBBoxOp
()
override
=
default
;
void
Print
(
std
::
ostream
&
out
)
const
override
{
out
<<
"RandomCropAndResizeWithBBox: "
<<
RandomCropAndResizeOp
::
target_height_
<<
" "
<<
RandomCropAndResizeOp
::
target_width_
;
}
Status
Compute
(
const
TensorRow
&
input
,
TensorRow
*
output
)
override
;
};
}
// namespace dataset
}
// namespace mindspore
#endif // DATASET_KERNELS_IMAGE_RANDOM_CROP_AND_RESIZE_WITH_BBOX_OP_H_
mindspore/ccsrc/dataset/kernels/image/random_crop_op.cc
浏览文件 @
c1e6ece5
...
...
@@ -48,44 +48,81 @@ RandomCropOp::RandomCropOp(int32_t crop_height, int32_t crop_width, int32_t pad_
rnd_
.
seed
(
GetSeed
());
}
Status
RandomCropOp
::
Compute
(
const
std
::
shared_ptr
<
Tensor
>
&
input
,
std
::
shared_ptr
<
Tensor
>
*
output
)
{
IO_CHECK
(
input
,
output
);
// Apply padding first then crop
std
::
shared_ptr
<
Tensor
>
pad_image
;
Status
RandomCropOp
::
ImagePadding
(
const
std
::
shared_ptr
<
Tensor
>
&
input
,
std
::
shared_ptr
<
Tensor
>
*
pad_image
,
int32_t
*
t_pad_top
,
int32_t
*
t_pad_bottom
,
int32_t
*
t_pad_left
,
int32_t
*
t_pad_right
,
int32_t
*
padded_image_w
,
int32_t
*
padded_image_h
,
bool
*
crop_further
)
{
*
t_pad_top
=
pad_top_
;
*
t_pad_bottom
=
pad_bottom_
;
*
t_pad_left
=
pad_left_
;
*
t_pad_right
=
pad_right_
;
RETURN_IF_NOT_OK
(
Pad
(
input
,
&
pad_image
,
pad_top_
,
pad_bottom_
,
pad_left_
,
pad_right_
,
border_type_
,
fill_r_
,
fill_g_
,
fill_b_
));
CHECK_FAIL_RETURN_UNEXPECTED
(
pad_image
->
shape
().
Size
()
>=
2
,
"Abnormal shape"
);
int32_t
padded_image_h
=
pad_image
->
shape
()[
0
];
int32_t
padded_image_w
=
pad_image
->
shape
()[
1
];
// no need to crop if same size
if
(
padded_image_h
==
crop_height_
&&
padded_image_w
==
crop_width_
)
{
*
output
=
pad_image
;
Pad
(
input
,
pad_image
,
pad_top_
,
pad_bottom_
,
pad_left_
,
pad_right_
,
border_type_
,
fill_r_
,
fill_g_
,
fill_b_
));
CHECK_FAIL_RETURN_UNEXPECTED
((
*
pad_image
)
->
shape
().
Size
()
>=
2
,
"Abnormal shape"
);
*
padded_image_h
=
(
*
pad_image
)
->
shape
()[
0
];
*
padded_image_w
=
(
*
pad_image
)
->
shape
()[
1
];
if
(
*
padded_image_h
==
crop_height_
&&
*
padded_image_w
==
crop_width_
)
{
*
crop_further
=
false
;
// no need for further crop
return
Status
::
OK
();
}
if
(
pad_if_needed_
)
{
}
else
if
(
pad_if_needed_
)
{
// check the dimensions of the image for padding, if we do need padding, then we change the pad values
if
(
padded_image_h
<
crop_height_
)
{
RETURN_IF_NOT_OK
(
Pad
(
pad_image
,
&
pad_image
,
crop_height_
-
padded_image_h
,
crop_height_
-
padded_image_h
,
0
,
0
,
if
(
*
padded_image_h
<
crop_height_
)
{
RETURN_IF_NOT_OK
(
Pad
(
*
pad_image
,
pad_image
,
crop_height_
-
*
padded_image_h
,
crop_height_
-
*
padded_image_h
,
0
,
0
,
border_type_
,
fill_r_
,
fill_g_
,
fill_b_
));
// update pad total above/below
t_pad_top
+=
(
crop_height_
-
*
padded_image_h
);
t_pad_bottom
+=
(
crop_height_
-
*
padded_image_h
);
}
if
(
padded_image_w
<
crop_width_
)
{
RETURN_IF_NOT_OK
(
Pad
(
pad_image
,
&
pad_image
,
0
,
0
,
crop_width_
-
padded_image_w
,
crop_width_
-
padded_image_w
,
if
(
*
padded_image_w
<
crop_width_
)
{
RETURN_IF_NOT_OK
(
Pad
(
*
pad_image
,
pad_image
,
0
,
0
,
crop_width_
-
*
padded_image_w
,
crop_width_
-
*
padded_image_w
,
border_type_
,
fill_r_
,
fill_g_
,
fill_b_
));
// update pad total left/right
t_pad_left
+=
(
crop_width_
-
*
padded_image_w
);
t_pad_right
+=
(
crop_width_
-
*
padded_image_w
);
}
padded_image_h
=
pad_image
->
shape
()[
0
];
padded_image_w
=
pad_image
->
shape
()[
1
];
*
padded_image_h
=
(
*
pad_image
)
->
shape
()[
0
];
*
padded_image_w
=
(
*
pad_image
)
->
shape
()[
1
];
}
if
(
padded_image_h
<
crop_height_
||
padded_image_w
<
crop_width_
||
crop_height_
==
0
||
crop_width_
==
0
)
{
if
(
*
padded_image_h
<
crop_height_
||
*
padded_image_w
<
crop_width_
||
crop_height_
==
0
||
crop_width_
==
0
)
{
return
Status
(
StatusCode
::
kShapeMisMatch
,
__LINE__
,
__FILE__
,
"Crop size is greater than the image dimensions or is zero."
);
}
// random top corner
int
x
=
std
::
uniform_int_distribution
<
int
>
(
0
,
padded_image_w
-
crop_width_
)(
rnd_
);
int
y
=
std
::
uniform_int_distribution
<
int
>
(
0
,
padded_image_h
-
crop_height_
)(
rnd_
);
return
Status
::
OK
();
}
void
RandomCropOp
::
GenRandomXY
(
int
*
x
,
int
*
y
,
int32_t
*
padded_image_w
,
int32_t
*
padded_image_h
)
{
// GenCropPoints for cropping
*
x
=
std
::
uniform_int_distribution
<
int
>
(
0
,
*
padded_image_w
-
crop_width_
)(
rnd_
);
*
y
=
std
::
uniform_int_distribution
<
int
>
(
0
,
*
padded_image_h
-
crop_height_
)(
rnd_
);
}
Status
RandomCropOp
::
Compute
(
const
std
::
shared_ptr
<
Tensor
>
&
input
,
std
::
shared_ptr
<
Tensor
>
*
output
)
{
IO_CHECK
(
input
,
output
);
// Apply padding first then crop
std
::
shared_ptr
<
Tensor
>
pad_image
;
int32_t
t_pad_top
,
t_pad_bottom
,
t_pad_left
,
t_pad_right
;
int32_t
padded_image_w
;
int32_t
padded_image_h
;
bool
crop_further
=
true
;
// whether image needs further cropping based on new size & requirements
RETURN_IF_NOT_OK
(
// error code sent back directly
ImagePadding
(
input
,
&
pad_image
,
&
t_pad_top
,
&
t_pad_bottom
,
&
t_pad_left
,
&
t_pad_right
,
&
padded_image_w
,
&
padded_image_h
,
&
crop_further
));
if
(
!
crop_further
)
{
*
output
=
pad_image
;
return
Status
::
OK
();
}
int
x
,
y
;
GenRandomXY
(
&
x
,
&
y
,
&
padded_image_w
,
&
padded_image_h
);
return
Crop
(
pad_image
,
output
,
x
,
y
,
crop_width_
,
crop_height_
);
}
Status
RandomCropOp
::
OutputShape
(
const
std
::
vector
<
TensorShape
>
&
inputs
,
std
::
vector
<
TensorShape
>
&
outputs
)
{
RETURN_IF_NOT_OK
(
TensorOp
::
OutputShape
(
inputs
,
outputs
));
outputs
.
clear
();
...
...
mindspore/ccsrc/dataset/kernels/image/random_crop_op.h
浏览文件 @
c1e6ece5
...
...
@@ -50,11 +50,20 @@ class RandomCropOp : public TensorOp {
void
Print
(
std
::
ostream
&
out
)
const
override
{
out
<<
"RandomCropOp: "
<<
crop_height_
<<
" "
<<
crop_width_
;
}
Status
Compute
(
const
std
::
shared_ptr
<
Tensor
>
&
input
,
std
::
shared_ptr
<
Tensor
>
*
output
)
override
;
Status
ImagePadding
(
const
std
::
shared_ptr
<
Tensor
>
&
input
,
std
::
shared_ptr
<
Tensor
>
*
pad_image
,
int32_t
*
t_pad_top
,
int32_t
*
t_pad_bottom
,
int32_t
*
t_pad_left
,
int32_t
*
t_pad_right
,
int32_t
*
padded_image_w
,
int32_t
*
padded_image_h
,
bool
*
crop_further
);
void
GenRandomXY
(
int
*
x
,
int
*
y
,
int32_t
*
padded_image_w
,
int32_t
*
padded_image_h
);
Status
OutputShape
(
const
std
::
vector
<
TensorShape
>
&
inputs
,
std
::
vector
<
TensorShape
>
&
outputs
)
override
;
pr
ivate
:
pr
otected
:
int32_t
crop_height_
=
0
;
int32_t
crop_width_
=
0
;
private:
int32_t
pad_top_
=
0
;
int32_t
pad_bottom_
=
0
;
int32_t
pad_left_
=
0
;
...
...
mindspore/ccsrc/dataset/kernels/image/random_crop_with_bbox_op.cc
0 → 100644
浏览文件 @
c1e6ece5
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <random>
#include <algorithm>
#include <utility>
#include "dataset/kernels/image/random_crop_with_bbox_op.h"
#include "dataset/kernels/image/image_utils.h"
#include "dataset/util/random.h"
#include "dataset/util/status.h"
namespace
mindspore
{
namespace
dataset
{
Status
RandomCropWithBBoxOp
::
Compute
(
const
TensorRow
&
input
,
TensorRow
*
output
)
{
IO_CHECK_VECTOR
(
input
,
output
);
BOUNDING_BOX_CHECK
(
input
);
std
::
shared_ptr
<
Tensor
>
pad_image
;
int32_t
t_pad_top
,
t_pad_bottom
,
t_pad_left
,
t_pad_right
;
size_t
boxCount
=
input
[
1
]
->
shape
()[
0
];
// number of rows
int32_t
padded_image_h
;
int32_t
padded_image_w
;
(
*
output
).
push_back
(
nullptr
);
(
*
output
).
push_back
(
nullptr
);
(
*
output
)[
1
]
=
std
::
move
(
input
[
1
]);
// since some boxes may be removed
bool
crop_further
=
true
;
// Whether further cropping will be required or not, true unless required size matches
RETURN_IF_NOT_OK
(
// Error passed back to caller
RandomCropOp
::
ImagePadding
(
input
[
0
],
&
pad_image
,
&
t_pad_top
,
&
t_pad_bottom
,
&
t_pad_left
,
&
t_pad_right
,
&
padded_image_w
,
&
padded_image_h
,
&
crop_further
));
// update bounding boxes with new values based on relevant image padding
if
(
t_pad_left
||
t_pad_bottom
)
{
PadBBoxes
(
&
(
*
output
)[
1
],
&
boxCount
,
&
t_pad_left
,
&
t_pad_top
);
}
if
(
!
crop_further
)
{
// no further cropping required
(
*
output
)[
0
]
=
pad_image
;
(
*
output
)[
1
]
=
std
::
move
(
input
[
1
]);
return
Status
::
OK
();
}
int
x
,
y
;
RandomCropOp
::
GenRandomXY
(
&
x
,
&
y
,
&
padded_image_w
,
&
padded_image_h
);
int
maxX
=
x
+
RandomCropOp
::
crop_width_
;
// max dims of selected CropBox on image
int
maxY
=
y
+
RandomCropOp
::
crop_height_
;
UpdateBBoxesForCrop
(
&
(
*
output
)[
1
],
&
boxCount
,
&
x
,
&
y
,
&
maxX
,
&
maxY
);
return
Crop
(
pad_image
,
&
(
*
output
)[
0
],
x
,
y
,
RandomCropOp
::
crop_width_
,
RandomCropOp
::
crop_height_
);
}
}
// namespace dataset
}
// namespace mindspore
mindspore/ccsrc/dataset/kernels/image/random_crop_with_bbox_op.h
0 → 100644
浏览文件 @
c1e6ece5
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DATASET_KERNELS_IMAGE_RANDOM_CROP_WITH_BBOX_OP_H_
#define DATASET_KERNELS_IMAGE_RANDOM_CROP_WITH_BBOX_OP_H_
#include <memory>
#include <vector>
#include "dataset/kernels/image/random_crop_op.h"
namespace
mindspore
{
namespace
dataset
{
class
RandomCropWithBBoxOp
:
public
RandomCropOp
{
public:
// Constructor for RandomCropWithBBoxOp, with default value and passing to base class constructor
RandomCropWithBBoxOp
(
int32_t
crop_height
,
int32_t
crop_width
,
int32_t
pad_top
=
kDefPadTop
,
int32_t
pad_bottom
=
kDefPadBottom
,
int32_t
pad_left
=
kDefPadLeft
,
int32_t
pad_right
=
kDefPadRight
,
BorderType
border_types
=
kDefBorderType
,
bool
pad_if_needed
=
kDefPadIfNeeded
,
uint8_t
fill_r
=
kDefFillR
,
uint8_t
fill_g
=
kDefFillG
,
uint8_t
fill_b
=
kDefFillB
)
:
RandomCropOp
(
crop_height
,
crop_width
,
pad_top
,
pad_bottom
,
pad_left
,
pad_right
,
border_types
,
pad_if_needed
,
fill_r
,
fill_g
,
fill_b
)
{}
~
RandomCropWithBBoxOp
()
override
=
default
;
void
Print
(
std
::
ostream
&
out
)
const
override
{
out
<<
"RandomCropWithBBoxOp: "
<<
RandomCropOp
::
crop_height_
<<
" "
<<
RandomCropOp
::
crop_width_
;
}
Status
Compute
(
const
TensorRow
&
input
,
TensorRow
*
output
)
override
;
};
}
// namespace dataset
}
// namespace mindspore
#endif // DATASET_KERNELS_IMAGE_RANDOM_CROP_WITH_BBOX_OP_H_
mindspore/ccsrc/dataset/kernels/image/random_vertical_flip_with_bbox_op.cc
0 → 100644
浏览文件 @
c1e6ece5
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <utility>
#include "dataset/util/status.h"
#include "dataset/kernels/image/image_utils.h"
#include "dataset/kernels/image/random_vertical_flip_with_bbox_op.h"
namespace
mindspore
{
namespace
dataset
{
const
float
RandomVerticalFlipWithBBoxOp
::
kDefProbability
=
0.5
;
Status
RandomVerticalFlipWithBBoxOp
::
Compute
(
const
TensorRow
&
input
,
TensorRow
*
output
)
{
IO_CHECK_VECTOR
(
input
,
output
);
BOUNDING_BOX_CHECK
(
input
);
if
(
distribution_
(
rnd_
))
{
dsize_t
imHeight
=
input
[
0
]
->
shape
()[
0
];
size_t
boxCount
=
input
[
1
]
->
shape
()[
0
];
// number of rows in tensor
// one time allocation -> updated in the loop
// type defined based on VOC test dataset
for
(
int
i
=
0
;
i
<
boxCount
;
i
++
)
{
uint32_t
boxCorner_y
=
0
;
uint32_t
boxHeight
=
0
;
uint32_t
newBoxCorner_y
=
0
;
input
[
1
]
->
GetUnsignedIntAt
(
&
boxCorner_y
,
{
i
,
1
});
// get min y of bbox
input
[
1
]
->
GetUnsignedIntAt
(
&
boxHeight
,
{
i
,
3
});
// get height of bbox
// subtract (curCorner + height) from (max) for new Corner position
newBoxCorner_y
=
(
imHeight
-
1
)
-
(
boxCorner_y
+
boxHeight
);
input
[
1
]
->
SetItemAt
({
i
,
1
},
newBoxCorner_y
);
}
(
*
output
).
push_back
(
nullptr
);
(
*
output
).
push_back
(
nullptr
);
(
*
output
)[
1
]
=
std
::
move
(
input
[
1
]);
return
VerticalFlip
(
input
[
0
],
&
(
*
output
)[
0
]);
}
*
output
=
input
;
return
Status
::
OK
();
}
}
// namespace dataset
}
// namespace mindspore
mindspore/ccsrc/dataset/kernels/image/random_vertical_flip_with_bbox_op.h
0 → 100644
浏览文件 @
c1e6ece5
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DATASET_KERNELS_IMAGE_RANDOM_VERTICAL_FLIP_WITH_BBOX_OP_H_
#define DATASET_KERNELS_IMAGE_RANDOM_VERTICAL_FLIP_WITH_BBOX_OP_H_
#include <memory>
#include <random>
#include "dataset/core/tensor.h"
#include "dataset/kernels/tensor_op.h"
#include "dataset/util/status.h"
#include "dataset/util/random.h"
namespace
mindspore
{
namespace
dataset
{
class
RandomVerticalFlipWithBBoxOp
:
public
TensorOp
{
public:
// Default values, also used by python_bindings.cc
static
const
float
kDefProbability
;
// Constructor for RandomVerticalFlipWithBBoxOp
// @param probability: Probablity of Image flipping, 0.5 by default
explicit
RandomVerticalFlipWithBBoxOp
(
float
probability
=
kDefProbability
)
:
distribution_
(
probability
)
{
rnd_
.
seed
(
GetSeed
());
}
~
RandomVerticalFlipWithBBoxOp
()
override
=
default
;
void
Print
(
std
::
ostream
&
out
)
const
override
{
out
<<
"RandomVerticalFlipWithBBoxOp"
;
}
Status
Compute
(
const
TensorRow
&
input
,
TensorRow
*
output
)
override
;
private:
std
::
mt19937
rnd_
;
std
::
bernoulli_distribution
distribution_
;
};
}
// namespace dataset
}
// namespace mindspore
#endif // DATASET_KERNELS_IMAGE_RANDOM_VERTICAL_FLIP_WITH_BBOX_OP_H_
mindspore/dataset/transforms/vision/c_transforms.py
浏览文件 @
c1e6ece5
...
...
@@ -149,6 +149,54 @@ class RandomCrop(cde.RandomCropOp):
super
().
__init__
(
*
size
,
*
padding
,
border_type
,
pad_if_needed
,
*
fill_value
)
class
RandomCropWithBBox
(
cde
.
RandomCropWithBBoxOp
):
"""
Crop the input image at a random location, and adjust bounding boxes
Args:
size (int or sequence): The output size of the cropped image.
If size is an int, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
padding (int or sequence, optional): The number of pixels to pad the image (default=None).
If padding is not None, pad image firstly with padding values.
If a single number is provided, it pads all borders with this value.
If a tuple or list of 2 values are provided, it pads the (left and top)
with the first value and (right and bottom) with the second value.
If 4 values are provided as a list or tuple,it pads the left, top, right and bottom respectively.
pad_if_needed (bool, optional): Pad the image if either side is smaller than
the given output size (default=False).
fill_value (int or tuple, optional): The pixel intensity of the borders if
the padding_mode is Border.CONSTANT (default=0). If it is a 3-tuple, it is used to
fill R, G, B channels respectively.
padding_mode (Border mode, optional): The method of padding (default=Border.CONSTANT). Can be any of
[Border.CONSTANT, Border.EDGE, Border.REFLECT, Border.SYMMETRIC].
- Border.CONSTANT, means it fills the border with constant values.
- Border.EDGE, means it pads with the last value on the edge.
- Border.REFLECT, means it reflects the values on the edge omitting the last
value of edge.
- Border.SYMMETRIC, means it reflects the values on the edge repeating the last
value of edge.
"""
@
check_random_crop
def
__init__
(
self
,
size
,
padding
=
None
,
pad_if_needed
=
False
,
fill_value
=
0
,
padding_mode
=
Border
.
CONSTANT
):
self
.
size
=
size
self
.
padding
=
padding
self
.
pad_if_needed
=
pad_if_needed
self
.
fill_value
=
fill_value
self
.
padding_mode
=
padding_mode
.
value
if
padding
is
None
:
padding
=
(
0
,
0
,
0
,
0
)
if
isinstance
(
fill_value
,
int
):
# temporary fix
fill_value
=
tuple
([
fill_value
]
*
3
)
border_type
=
DE_C_BORDER_TYPE
[
padding_mode
]
super
().
__init__
(
*
size
,
*
padding
,
border_type
,
pad_if_needed
,
*
fill_value
)
class
RandomHorizontalFlip
(
cde
.
RandomHorizontalFlipOp
):
"""
Flip the input image horizontally, randomly with a given probability.
...
...
@@ -192,6 +240,20 @@ class RandomVerticalFlip(cde.RandomVerticalFlipOp):
super
().
__init__
(
prob
)
class
RandomVerticalFlipWithBBox
(
cde
.
RandomVerticalFlipWithBBoxOp
):
"""
Flip the input image vertically and adjust bounding boxes, randomly with a given probability.
Args:
prob (float): Probability of the image being flipped (default=0.5).
"""
@
check_prob
def
__init__
(
self
,
prob
=
0.5
):
self
.
prob
=
prob
super
().
__init__
(
prob
)
class
BoundingBoxAug
(
cde
.
BoundingBoxAugOp
):
"""
Flip the input image vertically, randomly with a given probability.
...
...
@@ -237,6 +299,42 @@ class Resize(cde.ResizeOp):
super
().
__init__
(
*
size
,
interpoltn
)
class
RandomResizedCropWithBBox
(
cde
.
RandomCropAndResizeWithBBoxOp
):
"""
Crop the input image to a random size and aspect ratio and adjust the Bounding Boxes accordingly
Args:
size (int or sequence): The size of the output image.
If size is an int, a square crop of size (size, size) is returned.
If size is a sequence of length 2, it should be (height, width).
scale (tuple, optional): Range (min, max) of respective size of the original
size to be cropped (default=(0.08, 1.0)).
ratio (tuple, optional): Range (min, max) of aspect ratio to be cropped
(default=(3. / 4., 4. / 3.)).
interpolation (Inter mode, optional): Image interpolation mode (default=Inter.BILINEAR).
It can be any of [Inter.BILINEAR, Inter.NEAREST, Inter.BICUBIC].
- Inter.BILINEAR, means interpolation method is bilinear interpolation.
- Inter.NEAREST, means interpolation method is nearest-neighbor interpolation.
- Inter.BICUBIC, means interpolation method is bicubic interpolation.
max_attempts (int, optional): The maximum number of attempts to propose a valid
crop_area (default=10). If exceeded, fall back to use center_crop instead.
"""
@
check_random_resize_crop
def
__init__
(
self
,
size
,
scale
=
(
0.08
,
1.0
),
ratio
=
(
3.
/
4.
,
4.
/
3.
),
interpolation
=
Inter
.
BILINEAR
,
max_attempts
=
10
):
self
.
size
=
size
self
.
scale
=
scale
self
.
ratio
=
ratio
self
.
interpolation
=
interpolation
self
.
max_attempts
=
max_attempts
interpoltn
=
DE_C_INTER_MODE
[
interpolation
]
super
().
__init__
(
*
size
,
*
scale
,
*
ratio
,
interpoltn
,
max_attempts
)
class
RandomResizedCrop
(
cde
.
RandomCropAndResizeOp
):
"""
Crop the input image to a random size and aspect ratio.
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录