convolution_filter.cpp

#include "convolution_filter.hpp"
#include "block.hpp"
namespace fool{

template<typename Dtype>
void ConvolutionFilterCore(const Dtype* data, Dtype* outputData, const int inputChannel, const int startIdx,
							 const int outputIdx, const int kernelRow, const int kernelCol, const int channelStep,
						   const int inputColStep, const Dtype* weights, const int weightChannelStep){
	for(int c = 0; c < inputChannel; ++c){
		for(int i = 0; i < kernelRow; ++i){
			for(int j = 0; j < kernelCol; ++j){
				float inputValue = *(data + startIdx + c*channelStep + i*inputColStep + j);
				float weightValue = *(weights + weightChannelStep + c*kernelCol*kernelRow + i*kernelCol + j);
				*(outputData + outputIdx) = inputValue * weightValue;
			}
		}
	}
}

template<typename Dtype>
void ConvolutionForward(const Block<Dtype>& inputs, Block<Dtype>& outputs, const Block<Dtype>& weightParam,
						const int outputChannel, const int kernelSizeRow, const int kernelSizeCol,
						const int stride=1, const int padSize=0){
	int batchSize = inputs.batch;
	// check batch size small than 1
	assert(batchSize >= 1);

	int inputRow = inputs.height;
	int inputCol = inputs.width;
	int inputChannel = inputs.channel;
	int outputRow = (inputRow + 2*padSize - kernelSizeRow) / stride + 1;
	int outputCol = (inputCol + 2*padSize - kernelSizeCol) / stride + 1;

	Dtype* outputData = outputs.data;
	const Dtype* weight = weightParam.data;
	int inputStepLen = inputRow * inputCol;
	int outputStepLen = outputRow * outputCol;
	int inputBlockLen = inputStepLen * inputChannel;
	int outputBlockLen = outputStepLen * outputChannel;
	for(int b=0; b < batchSize; ++b){
		for(int c = 0; c < outputChannel; ++c){
			for(int i = 0; i < outputRow; i += stride){
				for(int j = 0; j < outputCol; j += stride){
					int startIdx = i * outputCol + j;
					int outputIdx = c * outputStepLen + i * outputCol + j;
					ConvolutionFilterCore(inputs.data, outputData, inputChannel, startIdx, outputIdx, kernelSizeRow, kernelSizeCol,
										  inputStepLen, inputCol, weight, c*kernelSizeCol*kernelSizeRow );
				}
			}
		}

	}



	return;

}
template<typename Dtype>
void ConvolutionFilter<Dtype>::FilterInitize(){

}


} // namespace FOOL