// this is simple offline processing example application
// it captures images from camera (using xiAPI) and process them using xiProcAPI		

#ifdef WIN32
#include "xiApi.h"
#else
#include <m3api/xiApi.h>
#endif

#include <stdio.h>

#include <string>
#include <iostream>
using namespace std;

#define throw_line(message) {char err[500]="";sprintf(err,"Fatal error: %s in:" __FILE__ "line:%d\n",message,__LINE__);throw err;}
#define XI_CARE(func) {XI_RETURN ret=func;char msg[200]="";if (XI_OK!=ret) {sprintf(msg,"Error on " #func " - expected XI_OK. Result:%d\n",ret);throw_line(msg);};}
#define THROW_IF_ZERO(val) {if (!val) throw_line("Value "#val"is zero");}

void TestOfflineProcessing_UsingAPI_WithCamera()
{
	cout << "TestOfflineProcessing_UsingAPI_WithCamera V3\n";

	// images buffer
#define MAX_IMAGES 10
	unsigned char* src_data[MAX_IMAGES];

	XI_IMG image;
	memset(&image, 0, sizeof(image));
	image.size = sizeof(XI_IMG);
	char defect_list[10000] = "";

	// get images from camera to RAM buffers
	cout << "Capturing images from camera\n";
	HANDLE camh = NULL;
	DWORD dwNumberOfDevices = 0;
	XI_CARE(xiGetNumberDevices(&dwNumberOfDevices));
	THROW_IF_ZERO(dwNumberOfDevices);
	XI_CARE(xiOpenDevice(0, &camh))
		XI_CARE(xiSetParamInt(camh, XI_PRM_IMAGE_DATA_FORMAT, XI_FRM_TRANSPORT_DATA));
	XI_CARE(xiSetParamInt(camh, XI_PRM_BUFFER_POLICY, XI_BP_SAFE));
	// set the same parameters like when camera processing is running online
	// these parameters will be part of API context list
	XI_CARE(xiSetParamInt(camh, XI_PRM_EXPOSURE, 1000));
	// save factory defect list for further use in offline processing
	XI_CARE(xiSetParamInt(camh, XI_PRM_SENS_DEFECTS_CORR_LIST_SELECTOR, XI_SENS_DEFFECTS_CORR_LIST_SEL_FACTORY));
	XI_CARE(xiGetParamString(camh, XI_PRM_SENS_DEFECTS_CORR_LIST_CONTENT, defect_list, sizeof(defect_list)));

	// allocate buffers for input images
	int img_size_bytes = 0;
	XI_CARE(xiGetParamInt(camh, XI_PRM_IMAGE_PAYLOAD_SIZE, &img_size_bytes));
	for (int i = 0; i<MAX_IMAGES; i++)
	{
		src_data[i] = (unsigned char*)malloc(img_size_bytes);
		THROW_IF_ZERO(src_data[i]);
	}

	XI_CARE(xiStartAcquisition(camh))
		for (int i = 0; i < MAX_IMAGES; i++)
		{
		// getting image from camera
		image.bp = src_data[i];
		image.bp_size = img_size_bytes;
#define IMAGE_TIMEOUT_MS 3000
		XI_CARE(xiGetImage(camh, IMAGE_TIMEOUT_MS, &image)); // this will copy data into src_data[i] - because of XI_BP_SAFE policy set
		cout << "Image " << i << ": " << image.width << "x" << image.height << " received from camera. First pixel: " << (int)src_data[i][0] << endl;
		}
	char* cam_context = NULL;
#define SIZE_OF_CONTEXT_BUFFER (10*1024*1024) // 10MiB
	cam_context = (char*)malloc(SIZE_OF_CONTEXT_BUFFER);
	XI_CARE(xiGetParamString(camh, XI_PRM_API_CONTEXT_LIST, cam_context, SIZE_OF_CONTEXT_BUFFER));
	XI_CARE(xiStopAcquisition(camh));
	XI_CARE(xiCloseDevice(camh));

	// offline processing
	cout << "Offline processing started\n";
	xiProcessingHandle_t proc;
	XI_CARE(xiProcOpen(&proc));
	int cam_context_len = (DWORD)strlen(cam_context);

	XI_CARE(xiProcSetParam(proc, XI_PRM_API_CONTEXT_LIST, cam_context, cam_context_len, xiTypeString));
	XI_IMG_FORMAT output_format = XI_RAW8;
	XI_CARE(xiProcSetParam(proc, XI_PRM_IMAGE_DATA_FORMAT, &output_format, sizeof(output_format), xiTypeInteger));
	// load and set previously saved defect list as user list, enable defect correction
	XI_SENS_DEFFECTS_CORR_LIST_SELECTOR list_sel = XI_SENS_DEFFECTS_CORR_LIST_SEL_USER0;
	XI_SWITCH correction_on = XI_ON;
	XI_CARE(xiProcSetParam(proc, XI_PRM_SENS_DEFECTS_CORR_LIST_SELECTOR, &list_sel, sizeof(XI_SENS_DEFFECTS_CORR_LIST_SEL_USER0), xiTypeInteger));
	XI_CARE(xiProcSetParam(proc, XI_PRM_SENS_DEFECTS_CORR_LIST_CONTENT, defect_list, sizeof(defect_list), xiTypeString));
	XI_CARE(xiProcSetParam(proc, XI_PRM_SENS_DEFECTS_CORR, &correction_on, sizeof(correction_on), xiTypeInteger));

	int w = 0;
	int h = 0;
	FILE * pFile;
	char filename[12];

	for (int i = 0; i < MAX_IMAGES; i++)
	{
		// image structure
		XI_IMG out_image;
		out_image.size = sizeof(XI_IMG);
		out_image.bp = NULL;
		out_image.bp_size = 0;
		// process
		XI_CARE(xiProcPushImage(proc, src_data[i]));
		XI_CARE(xiProcPullImage(proc, 0, &out_image));
		w = (int)out_image.width;
		h = (int)out_image.height;
		cout << "Image " << i << ": " << w << "x" << h << " processed by offline processing in format: " << out_image.frm << ", First pixel: " << (unsigned short)((unsigned char*)out_image.bp)[0] << endl;
		// save image
		sprintf(filename, "img_%d.raw", i);
		pFile = fopen(filename, "wb");
		fwrite(out_image.bp, sizeof(unsigned char), w*h, pFile);
	}
	XI_CARE(xiProcClose(proc));
	fclose(pFile);
}

int main(int argc, char* argv[])
{
	try
	{
		TestOfflineProcessing_UsingAPI_WithCamera();
	}
	catch (char* err)
	{
		cout << "Error" << err << "\n";
	}
	cout << "Done\n";
	cout << "Press enter\n";
	cin.get();
}