mirror of
https://github.com/open-mmlab/mmdeploy.git
synced 2025-01-14 08:09:43 +08:00
823ca38646
* first * fix0 * fix1 * dirty work * wip * add allocator * finally done! * lint * fix lint * better gather * better onnx2ncnn * fix expand * [Fix] NCNN TensorSlice op bugs (#42) * fix custom ops support, fix multiple mark bug, add name mapping * check if the value_info need to be added * remove unnecessary print * add nms implement * two stage split wip * add two stage split * add split retinanet visualize * add two stage split (wip) * finish two stage split * fix lint * move parse string to mmdeploy.utils * add calib data generator * create calib dataset * finish end2end int8 * add split two stage tensorrt visualize * fix tensorslice bugs * fix lint * fix clang-format * remove comments * int param * fix lint Co-authored-by: grimoire <yaoqian@sensetime.com> * add two stage ncnn support * remove unused ops * git unused config * remove no_grad, should add in refactor * add ncnn wrapper * fix lint * size return tuple * Resolve grammar error * Fix lint * Trim Trailing Whitespace * fix trim * update wrapper * remove logs * remove * csrc optimize Co-authored-by: hanrui1sensetime <83800577+hanrui1sensetime@users.noreply.github.com>
497 lines
19 KiB
C++
Executable File
497 lines
19 KiB
C++
Executable File
// right alignment broadcast (c, h, w).
|
|
// the same as onnx
|
|
#include "expand.h"
|
|
|
|
#include "../ncnn_ops_definer.h"
|
|
namespace mmlab {
|
|
using namespace ncnn;
|
|
DEFINE_LAYER_CREATOR(Expand)
|
|
DEFINE_NCNN_OPS(Expand, Expand)
|
|
Expand::Expand() {
|
|
one_blob_only = false;
|
|
support_inplace = false;
|
|
}
|
|
|
|
int Expand::forward(const std::vector<Mat>& bottom_blobs,
|
|
std::vector<Mat>& top_blobs, const Option& opt) const {
|
|
const Mat& bottom_blob = bottom_blobs[0];
|
|
size_t elemsize = bottom_blob.elemsize;
|
|
const Mat& old_shape_blob = bottom_blobs[1];
|
|
const int shape_width = old_shape_blob.w - 1;
|
|
Mat shape_blob(shape_width, elemsize, opt.workspace_allocator);
|
|
memcpy(shape_blob.row(0), old_shape_blob.row(0) + 1, shape_width * elemsize);
|
|
Mat& top_blob = top_blobs[0];
|
|
|
|
if (bottom_blob.dims == 1 && shape_blob.w == 1) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
if (bottom_blob.w != shape_0 && bottom_blob.w != 1 && shape_0 != 1) {
|
|
fprintf(stderr, "The broadcast rule is wrong, (%d) vs (%d)\n",
|
|
bottom_blob.w, shape_0);
|
|
} else if (bottom_blob.w == shape_0 || shape_0 == 1) {
|
|
top_blob.create(bottom_blob.w, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob[i] = bottom_blob[i];
|
|
}
|
|
} else if (bottom_blob.w == 1) {
|
|
top_blob.create(shape_0, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
|
|
for (int i = 0; i < shape_0; i++) {
|
|
top_blob[i] = bottom_blob[0];
|
|
}
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
if (bottom_blob.dims == 1 && shape_blob.w == 2) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
int shape_1 = (int)(shape_blob[1] + 0.5);
|
|
if (bottom_blob.w != shape_1 && bottom_blob.w != 1 && shape_1 != 1) {
|
|
fprintf(stderr, "The broadcast rule is wrong, (1, %d) vs (%d, %d)\n",
|
|
bottom_blob.w, shape_0, shape_1);
|
|
} else if (bottom_blob.w == shape_1 || shape_1 == 1) {
|
|
top_blob.create(bottom_blob.w, shape_0, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
|
|
for (int j = 0; j < shape_0; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.row(j)[i] = bottom_blob[i];
|
|
}
|
|
}
|
|
|
|
} else if (bottom_blob.w == 1) {
|
|
top_blob.create(shape_1, shape_0, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
|
|
for (int j = 0; j < shape_0; j++) {
|
|
for (int i = 0; i < shape_1; i++) {
|
|
top_blob.row(j)[i] = bottom_blob[0];
|
|
}
|
|
}
|
|
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
if (bottom_blob.dims == 1 && shape_blob.w == 3) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
int shape_1 = (int)(shape_blob[1] + 0.5);
|
|
int shape_2 = (int)(shape_blob[2] + 0.5);
|
|
|
|
if (bottom_blob.w != shape_2 && bottom_blob.w != 1 && shape_2 != 1) {
|
|
fprintf(stderr,
|
|
"The broadcast rule is wrong, (1, 1, %d) vs (%d, %d, %d)\n",
|
|
bottom_blob.w, shape_0, shape_1, shape_2);
|
|
} else if (bottom_blob.w == shape_2 || shape_2 == 1) {
|
|
top_blob.create(bottom_blob.w, shape_1, shape_0, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < shape_1; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob[i];
|
|
}
|
|
}
|
|
}
|
|
} else if (bottom_blob.w == 1) {
|
|
top_blob.create(shape_2, shape_1, shape_0, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < shape_1; j++) {
|
|
for (int i = 0; i < shape_2; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob[0];
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
if (bottom_blob.dims == 2 && shape_blob.w == 1) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
if (bottom_blob.w != shape_0 && bottom_blob.w != 1 && shape_0 != 1) {
|
|
fprintf(stderr, "The broadcast rule is wrong, (%d, %d) vs (1, %d)\n",
|
|
bottom_blob.h, bottom_blob.w, shape_0);
|
|
} else if (bottom_blob.w == shape_0 || shape_0 == 1) {
|
|
top_blob.create(bottom_blob.w, bottom_blob.h, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.row(j)[i] = bottom_blob.row(j)[i];
|
|
}
|
|
}
|
|
} else if (bottom_blob.w == 1) {
|
|
top_blob.create(shape_0, bottom_blob.h, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < shape_0; i++) {
|
|
top_blob.row(j)[i] = bottom_blob.row(j)[0];
|
|
}
|
|
}
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
if (bottom_blob.dims == 2 && shape_blob.w == 2) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
int shape_1 = (int)(shape_blob[1] + 0.5);
|
|
if (bottom_blob.w != shape_1 && bottom_blob.w != 1 && shape_1 != 1) {
|
|
fprintf(stderr, "The broadcast rule is wrong, (%d, %d) vs (%d, %d)\n",
|
|
bottom_blob.h, bottom_blob.w, shape_0, shape_1);
|
|
} else if (bottom_blob.h != shape_0 && bottom_blob.h != 1 && shape_0 != 1) {
|
|
fprintf(stderr, "The broadcast rule is wrong, (%d, %d) vs (%d, %d)\n",
|
|
bottom_blob.h, bottom_blob.w, shape_0, shape_1);
|
|
} else if ((bottom_blob.w == shape_1 || shape_1 == 1) &&
|
|
(bottom_blob.h == shape_0 || shape_0 == 1)) {
|
|
top_blob.create(bottom_blob.w, bottom_blob.h, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.row(j)[i] = bottom_blob.row(j)[i];
|
|
}
|
|
}
|
|
} else if ((bottom_blob.w == shape_1 || shape_1 == 1) &&
|
|
(bottom_blob.h == 1)) {
|
|
top_blob.create(bottom_blob.w, shape_0, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int j = 0; j < shape_0; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.row(j)[i] = bottom_blob.row(0)[i];
|
|
}
|
|
}
|
|
} else if ((bottom_blob.w == 1) &&
|
|
(bottom_blob.h == shape_0 || shape_0 == 1)) {
|
|
top_blob.create(shape_1, bottom_blob.h, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < shape_1; i++) {
|
|
top_blob.row(j)[i] = bottom_blob.row(j)[0];
|
|
}
|
|
}
|
|
} else if (bottom_blob.h == 1 && bottom_blob.w == 1) {
|
|
top_blob.create(shape_1, shape_0, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int j = 0; j < shape_0; j++) {
|
|
for (int i = 0; i < shape_1; i++) {
|
|
top_blob.row(j)[i] = bottom_blob.row(0)[0];
|
|
}
|
|
}
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
if (bottom_blob.dims == 2 && shape_blob.w == 3) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
int shape_1 = (int)(shape_blob[1] + 0.5);
|
|
int shape_2 = (int)(shape_blob[2] + 0.5);
|
|
if (bottom_blob.w != shape_2 && bottom_blob.w != 1 && shape_2 != 1) {
|
|
fprintf(stderr, "The broadcast rule is wrong, (%d, %d) vs (%d, %d, %d)\n",
|
|
bottom_blob.h, bottom_blob.w, shape_0, shape_1, shape_2);
|
|
} else if (bottom_blob.h != shape_1 && bottom_blob.h != 1 && shape_1 != 1) {
|
|
fprintf(stderr, "The broadcast rule is wrong, (%d, %d) vs (%d, %d, %d)\n",
|
|
bottom_blob.h, bottom_blob.w, shape_0, shape_1, shape_2);
|
|
} else if ((bottom_blob.w == shape_2 || shape_2 == 1) &&
|
|
(bottom_blob.h == shape_1 || shape_1 == 1)) {
|
|
top_blob.create(bottom_blob.w, bottom_blob.h, shape_0, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.row(j)[i];
|
|
}
|
|
}
|
|
}
|
|
} else if ((bottom_blob.w == shape_2 || shape_2 == 1) &&
|
|
(bottom_blob.h == 1)) {
|
|
top_blob.create(bottom_blob.w, shape_1, shape_0, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < shape_1; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.row(0)[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if ((bottom_blob.w == 1) &&
|
|
(bottom_blob.h == shape_1 || shape_1 == 1)) {
|
|
top_blob.create(shape_2, bottom_blob.h, shape_0, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < shape_2; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.row(j)[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bottom_blob.h == 1 && bottom_blob.w == 1) {
|
|
top_blob.create(shape_2, shape_1, shape_0, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < shape_1; j++) {
|
|
for (int i = 0; i < shape_2; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.row(0)[0];
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
if (bottom_blob.dims == 3 && shape_blob.w == 1) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
if (bottom_blob.w != shape_0 && bottom_blob.w != 1 && shape_0 != 1) {
|
|
fprintf(stderr,
|
|
"The broadcast rule is wrong, (%d, %d, %d) vs (1, 1, %d)\n",
|
|
bottom_blob.c, bottom_blob.h, bottom_blob.w, shape_0);
|
|
} else if (bottom_blob.w == shape_0 || shape_0 == 1) {
|
|
top_blob.create(bottom_blob.w, bottom_blob.h, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(j)[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bottom_blob.w == 1) {
|
|
top_blob.create(shape_0, bottom_blob.h, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < shape_0; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(j)[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
if (bottom_blob.dims == 3 && shape_blob.w == 2) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
int shape_1 = (int)(shape_blob[1] + 0.5);
|
|
if (bottom_blob.w != shape_1 && bottom_blob.w != 1 && shape_1 != 1) {
|
|
fprintf(stderr,
|
|
"The broadcast rule is wrong, (%d, %d, %d) vs (1, %d, %d)\n",
|
|
bottom_blob.c, bottom_blob.h, bottom_blob.w, shape_0, shape_1);
|
|
} else if (bottom_blob.h != shape_0 && bottom_blob.h != 1 && shape_0 != 1) {
|
|
fprintf(stderr,
|
|
"The broadcast rule is wrong, (%d, %d, %d) vs (1, %d, %d)\n",
|
|
bottom_blob.c, bottom_blob.h, bottom_blob.w, shape_0, shape_1);
|
|
} else if ((bottom_blob.w == shape_1 || shape_1 == 1) &&
|
|
(bottom_blob.h == shape_0 || shape_0 == 1)) {
|
|
top_blob.create(bottom_blob.w, bottom_blob.h, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(j)[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if ((bottom_blob.w == shape_1 || shape_1 == 1) &&
|
|
(bottom_blob.h == 1)) {
|
|
top_blob.create(bottom_blob.w, shape_0, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < shape_0; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(0)[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if ((bottom_blob.w == 1) &&
|
|
(bottom_blob.h == shape_0 || shape_0 == 1)) {
|
|
top_blob.create(shape_1, bottom_blob.h, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < shape_1; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(j)[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bottom_blob.h == 1 && bottom_blob.w == 1) {
|
|
top_blob.create(shape_1, shape_0, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < shape_0; j++) {
|
|
for (int i = 0; i < shape_1; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(0)[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
if (bottom_blob.dims == 3 && shape_blob.w == 3) {
|
|
int shape_0 = (int)(shape_blob[0] + 0.5);
|
|
int shape_1 = (int)(shape_blob[1] + 0.5);
|
|
int shape_2 = (int)(shape_blob[2] + 0.5);
|
|
if (bottom_blob.w != shape_2 && bottom_blob.w != 1 && shape_2 != 1) {
|
|
fprintf(stderr,
|
|
"The broadcast rule is wrong, (%d, %d, %d) vs (%d, %d, %d)\n",
|
|
bottom_blob.c, bottom_blob.h, bottom_blob.w, shape_0, shape_1,
|
|
shape_2);
|
|
} else if (bottom_blob.h != shape_1 && bottom_blob.h != 1 && shape_1 != 1) {
|
|
fprintf(stderr,
|
|
"The broadcast rule is wrong, (%d, %d, %d) vs (%d, %d, %d)\n",
|
|
bottom_blob.c, bottom_blob.h, bottom_blob.w, shape_0, shape_1,
|
|
shape_2);
|
|
} else if (bottom_blob.c != shape_0 && bottom_blob.c != 1 && shape_0 != 1) {
|
|
fprintf(stderr,
|
|
"The broadcast rule is wrong, (%d, %d, %d) vs (%d, %d, %d)\n",
|
|
bottom_blob.c, bottom_blob.h, bottom_blob.w, shape_0, shape_1,
|
|
shape_2);
|
|
} else if ((bottom_blob.w == shape_2 || shape_2 == 1) &&
|
|
(bottom_blob.h == shape_1 || shape_1 == 1) &&
|
|
(bottom_blob.c == shape_0 || shape_0 == 1)) {
|
|
top_blob.create(bottom_blob.w, bottom_blob.h, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(j)[i];
|
|
}
|
|
}
|
|
}
|
|
} else if ((bottom_blob.w == shape_2 || shape_2 == 1) &&
|
|
(bottom_blob.h == shape_1 || shape_1 == 1) &&
|
|
(bottom_blob.c == 1)) {
|
|
top_blob.create(bottom_blob.w, bottom_blob.h, shape_0, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(0).row(j)[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if ((bottom_blob.w == shape_2 || shape_2 == 1) &&
|
|
(bottom_blob.h == 1) &&
|
|
(bottom_blob.c == shape_0 || shape_0 == 1)) {
|
|
top_blob.create(bottom_blob.w, shape_1, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < shape_1; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(0)[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if ((bottom_blob.w == shape_2 || shape_2 == 1) &&
|
|
(bottom_blob.h == 1) && (bottom_blob.c == 1)) {
|
|
top_blob.create(bottom_blob.w, shape_1, shape_0, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < shape_1; j++) {
|
|
for (int i = 0; i < bottom_blob.w; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(0).row(0)[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if (bottom_blob.w == 1 &&
|
|
(bottom_blob.h == shape_1 || shape_1 == 1) &&
|
|
(bottom_blob.c == shape_0 || shape_0 == 1)) {
|
|
top_blob.create(shape_2, bottom_blob.h, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < shape_2; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(j)[0];
|
|
}
|
|
}
|
|
}
|
|
} else if (bottom_blob.w == 1 &&
|
|
(bottom_blob.h == shape_1 || shape_1 == 1) &&
|
|
(bottom_blob.c == 1)) {
|
|
top_blob.create(shape_2, bottom_blob.h, shape_0, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < bottom_blob.h; j++) {
|
|
for (int i = 0; i < shape_2; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(0).row(j)[0];
|
|
}
|
|
}
|
|
}
|
|
} else if (bottom_blob.w == 1 && bottom_blob.h == 1 &&
|
|
(bottom_blob.c == shape_0 || shape_0 == 1)) {
|
|
top_blob.create(shape_2, shape_1, bottom_blob.c, elemsize,
|
|
opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < bottom_blob.c; k++) {
|
|
for (int j = 0; j < shape_1; j++) {
|
|
for (int i = 0; i < shape_2; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(k).row(0)[0];
|
|
}
|
|
}
|
|
}
|
|
} else if (bottom_blob.w == 1 && bottom_blob.h == 1 && bottom_blob.c == 1) {
|
|
top_blob.create(shape_2, shape_1, shape_0, elemsize, opt.blob_allocator);
|
|
if (top_blob.empty()) return -100;
|
|
for (int k = 0; k < shape_0; k++) {
|
|
for (int j = 0; j < shape_1; j++) {
|
|
for (int i = 0; i < shape_2; i++) {
|
|
top_blob.channel(k).row(j)[i] = bottom_blob.channel(0).row(0)[0];
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
fprintf(stderr, "error case\n");
|
|
return -100;
|
|
}
|
|
return 0;
|
|
}
|
|
fprintf(stderr, "top_blob.shape: (%d %d %d)\n", top_blob.c, top_blob.h,
|
|
top_blob.w);
|
|
}
|
|
|
|
} // namespace mmlab
|