samplesCommon::OnnxSampleParams mParams;
mParams.dataDirs.push_back("./");
mParams.inputTensorNames.push_back("input_layer:0");
mParams.onnxFileName = "model.onnx";
mParams.outputTensorNames.push_back("Identity:0");
mParams.int8 = false;
mParams.fp16 = false;


auto builder = std::unique_ptr<nvinfer1::IBuilder, samplesCommon::InferDeleter>(nvinfer1::createInferBuilder(sample::gLogger.getTRTLogger()));
if (!builder)
	return 0;

const auto explicitBatch = 1U << static_cast<uint32_t>(NetworkDefinitionCreationFlag::kEXPLICIT_BATCH);
auto network = std::unique_ptr<nvinfer1::INetworkDefinition, samplesCommon::InferDeleter>(builder->createNetworkV2(explicitBatch));
if (!network)
	return 0;
auto config = std::unique_ptr<nvinfer1::IBuilderConfig, samplesCommon::InferDeleter>(builder->createBuilderConfig());
if (!config)
	return 0;

auto parser = std::unique_ptr<nvonnxparser::IParser, samplesCommon::InferDeleter>(nvonnxparser::createParser(*network, sample::gLogger.getTRTLogger()));
if (!parser)
	return 0;

// construct network
auto parsed = parser->parseFromFile(locateFile(mParams.onnxFileName, mParams.dataDirs).c_str(), static_cast<int>(sample::gLogger.getReportableSeverity()));
if (!parsed)
	return 0;
config->setMaxWorkspaceSize(16_MiB);

std::shared_ptr<nvinfer1::ICudaEngine> mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(builder->buildEngineWithConfig(*network, *config), samplesCommon::InferDeleter());
if (!mEngine)
	return 0;

nvinfer1::Dims mInputDims = network->getInput(0)->getDimensions();
nvinfer1::Dims mOutputDims = network->getOutput(0)->getDimensions();

// Create RAII buffer manager object
samplesCommon::BufferManager buffers(mEngine);

auto context = std::unique_ptr<nvinfer1::IExecutionContext, samplesCommon::InferDeleter>(mEngine->createExecutionContext());
if (!context)
	return 0;

// Read the input data into the managed buffers
assert(mParams.inputTensorNames.size() == 1);

// processInput(buffers)
string fileName = "cat.jpg";
//string fileName = "dog.jpg";

float* hostDataBuffer = static_cast<float*>(buffers.getHostBuffer(mParams.inputTensorNames[0]));
cv::Mat frame = cv::imread(fileName);
auto input_batch_size = mInputDims.d[0];
auto input_height = mInputDims.d[1];
auto input_width = mInputDims.d[2];
auto input_channels = mInputDims.d[3]; 

Size size = Size(input_height, input_width);
cv::resize(frame, frame, size, 0, 0, INTER_NEAREST);
Scalar mean = Scalar(103.939, 116.779, 123.68); // BGR format
Mat inputBlob;
float scale = 1.0;
inputBlob = cv::dnn::blobFromImages(frame, scale, size, mean); // format NCHW order

int volChl = input_height * input_width;
int volImg = input_channels * input_height * input_width;
for (int i = 0; i < input_batch_size; ++i)
{
	for (int j = 0; j < input_height; ++j)
	{
		for(int k = 0; k < input_width; ++k) {
			Vec<int, 4> idxB = Vec<int, 4>(i, 0, j, k);
			Vec<int, 4> idxG = Vec<int, 4>(i, 1, j, k);
			Vec<int, 4> idxR = Vec<int, 4>(i, 2, j, k);
			hostDataBuffer[i * volImg + 0 * volChl + j * input_width + k] = inputBlob.at<float>(idxB);
			hostDataBuffer[i * volImg + 1 * volChl + j * input_width + k] = inputBlob.at<float>(idxG);
			hostDataBuffer[i * volImg + 2 * volChl + j * input_width + k] = inputBlob.at<float>(idxR);
		 }
	}
}

// Memcpy from host input buffers to device input buffers
buffers.copyInputToDevice();

bool status = context->executeV2(buffers.getDeviceBindings().data());
if (!status)
	return 0;

// Memcpy from device output buffers to host output buffers
buffers.copyOutputToHost();

// Verify results; verifyOutput(buffers)
const int outputSize = mOutputDims.d[1];
float* output = static_cast<float*>(buffers.getHostBuffer(mParams.outputTensorNames[0]));

for (int i = 0; i < outputSize; i++) {
	qDebug() << output[i];
}