opencv caffe模型加载 c++ 一个用来降维叫做DimensionalityReduction的层

读入参数

参数order1，order2，order3，order4

将需要保留的维度的参数赋值为1，将需要删除的维度的参数赋值为1

DimensionalityReductionLayer(const cv::dnn::LayerParams &params) : Layer(params)
	{
		order1 = params.get<int>("order1", -1);
		order2 = params.get<int>("order2", -1);
		order3 = params.get<int>("order3", -1);
		order4 = params.get<int>("order4", -1);
	}

确定输出参数格式

virtual bool getMemoryShapes(const std::vector<std::vector<int> > &inputs,
		const int requiredOutputs,
		std::vector<std::vector<int> > &outputs,
		std::vector<std::vector<int> > &internals) const CV_OVERRIDE
	{
		CV_UNUSED(requiredOutputs); CV_UNUSED(internals);
		cout << "start DimensionalityReductionLayer getMemoryShapes" << endl;
		std::vector<int> order(4);
		order[0] = order1;
		order[1] = order2;
		order[2] = order3;
		order[3] = order4;

		int dim = 0;
		for (int i = 0; i < 4; i++) {
			if (order[i] <0) {
				break;
			}
			else {
				dim++;
			}
		}

		std::vector<int> newShape;
		for (int i = 0; i < dim; i++) {
			newShape.push_back(inputs[0][i]);
		}

		std::vector<int> outShape; //创建一个不定长数组
		int count = 0;
		for (int i = 0; i < dim; i++) {
			if (order[i] == 1) {
				continue;
			}
			outShape.push_back(newShape[i]);			
		}
		outputs.assign(1, outShape);
		for (int i = 0; i < outShape.size(); i++) {
			cout << outShape[i] << "   ";
		}
		return false;
	}

计算过程

virtual void forward(std::vector<cv::Mat*> &inputs, std::vector<cv::Mat> &outputs, std::vector<cv::Mat> &internals) CV_OVERRIDE
	{
		CV_UNUSED(internals);
		cout << "start DimensionalityReductionLayer forward1" << endl;
		cv::Mat& inp = *inputs[0];
		cv::Mat& out = outputs[0];
		std::vector<int> order(4);
		order[0] = order1;
		order[1] = order2;
		order[2] = order3;
		order[3] = order4;
		//断言 至少剩下两个维度，去掉的维度都是1
		int dim = 0;
		std::vector<int> dimind(4);
		for (int i = 0; i < 4; i++) {
			if (order[i] <0) {
				break;
			}
			else {
				dim++;
			}
			if (order[i] == 0) {
				dimind.push_back(i);
			}
		}
		if (dim == 4) {
			int B = inp.size[0];
			int C = inp.size[1];
			int H = inp.size[2];
			int W = inp.size[3];
			std::vector<int> sq;
			for (int b = 0; b < B; b++) {
				sq.push_back(b);
				for (int c = 0; c < C; c++) {
					sq.push_back(c);
					for (int h = 0; h < H; h++) {
						sq.push_back(h);
						for (int w = 0; w < W; w++) {
							sq.push_back(w);

							if (dimind.size() == 3) {
								out.ptr<float>(sq[dimind[0]], sq[dimind[1]])[sq[dimind[2]]] = inp.ptr<float>(sq[0], sq[1],sq[2])[sq[3]];
							}
							if (dimind.size() == 2) {
								out.ptr<float>(sq[dimind[0]])[sq[dimind[1]]] = inp.ptr<float>(sq[0], sq[1], sq[2])[sq[3]];
							}

							sq.pop_back();
						}
						sq.pop_back();
					}
					sq.pop_back();
				}
				sq.pop_back();
			}
			sq.pop_back();
		}

		if (dim == 4) {
			int B = inp.size[0];
			int H = inp.size[1];
			int W = inp.size[2];
			std::vector<int> sq;
			for (int b = 0; b < B; b++) {
				sq.push_back(b);
				for (int h = 0; h < H; h++) {
					sq.push_back(h);
					for (int w = 0; w < W; w++) {
						sq.push_back(w);

						if (dimind.size() == 2) {
							out.ptr<float>(sq[dimind[0]])[sq[dimind[1]]] = inp.ptr<float>(sq[0], sq[1])[sq[2]];
						}

						sq.pop_back();
					}
					sq.pop_back();
				}
				sq.pop_back();
			}
			sq.pop_back();
		}
		
	}