<
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;

namespace Tango.SharedUI.Converters
{
    public class OneToPercentConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return System.Convert.ToDouble(value) * 100d;
        }

        public object ConvertBack(object value
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream> 
#include "CalibrationPoint.pb-c.h"
#include "CalibrationData.pb-c.h"
#include "ColorSpace.pb-c.h"
#include "ConversionInput.pb-c.h"
#include "ConversionOutput.pb-c.h"
#include "InputCoordinates.pb-c.h"
#include "OutputCoordinates.pb-c.h"
#include "OutputLiquid.pb-c.h"
#include "InputLiquid.pb-c.h"
#include "Exports.h"

size_t ReadCalData(char *name, double **&CalData, long &nCalData);
size_t ReadCLUTFile(char *name, uint8_t *&buffer, long &lsize);

size_t InitData(uint8_t *&input_buffer, long &buffersize, char *ForwardName, char *InverseName,
	char * CalCyanName, char *CalMagentaName, char *CalYellowName)
{
	ConversionInput *conversionInput = (ConversionInput*)malloc(sizeof(ConversionInput));
	conversion_input__init(conversionInput);//CONVERSION_INPUT__INIT;
											//fill conversionInput
	conversionInput->colorspace = COLOR_SPACE__RGB;
	conversionInput->has_colorspace = true;
	conversionInput->has_forwarddata = true;
	conversionInput->has_inversedata = true;
	conversionInput->has_threadl = true;
	conversionInput->has_threada = true;
	conversionInput->has_threadb = true;
	conversionInput->threadl = 90.5055;
	conversionInput->threada = 2.8998;;
	conversionInput->threadb = -11.4028;
	conversionInput->segmentlength = 10;
	uint8_t *buffer = NULL;
	long lsize;
	size_t retVal = ReadCLUTFile(ForwardName, buffer, lsize);
	conversionInput->forwarddata.data = buffer;
	conversionInput->forwarddata.len = lsize;
	retVal = ReadCLUTFile(InverseName, buffer, lsize);
	conversionInput->inversedata.data = buffer;
	conversionInput->inversedata.len = lsize;

	//Input Coordinates

	InputCoordinates *inputcoordinates = (InputCoordinates *)malloc(sizeof(InputCoordinates));
	input_coordinates__init(inputcoordinates);
	inputcoordinates->has_red = true;
	inputcoordinates->has_green = true;
	inputcoordinates->has_blue = true;
	inputcoordinates->red = 128;
	inputcoordinates->green = 128;
	inputcoordinates->blue = 128;
	/*	inputcoordinates->has_l = true;
	inputcoordinates->has_a = true;
	inputcoordinates->has_b = true;
	inputcoordinates->l = 50.00;
	inputcoordinates->a = 0.00;
	inputcoordinates->b = 0.00;*/
	//Ink Data

	inputcoordinates->n_inputliquids = 3;
	InputLiquid **inputliquids = (InputLiquid **)malloc(sizeof(InputLiquid *)*(inputcoordinates->n_inputliquids));
	//	input_liquid__init(*inputliquids);
	for (size_t i = 0; i < inputcoordinates->n_inputliquids; ++i)
	{
		inputliquids[i] = (InputLiquid *)malloc(sizeof(InputLiquid));
		input_liquid__init(inputliquids[i]);
	}
	//Cyan
	double **CalData = NULL;
	long nCalData;
	InputLiquid *inputliquidCyan = (InputLiquid *)malloc(sizeof(InputLiquid));
	input_liquid__init(inputliquidCyan);
	inputliquidCyan->volume = 25.0;
	inputliquidCyan->has_volume = true;
	CalibrationData *CalibDataCyan = (CalibrationData*)malloc(sizeof(CalibrationData));
	calibration_data__init(CalibDataCyan);
	retVal = ReadCalData(CalCyanName, CalData, nCalData);
	CalibDataCyan->has_liquidtype = true;
	CalibDataCyan->liquidtype = LIQUID_TYPE__Cyan;
	CalibDataCyan->n_calibrationpoints = nCalData;
	CalibrationPoint **CalPointsCyan = (CalibrationPoint **)malloc(sizeof(CalibrationPoint *)* nCalData);
	//CalibrationPoint* CP = (CalibrationPoint *)malloc(sizeof(CalibrationPoint ));
	//calibration_point__init(CP);
	for (int i = 0; i<nCalData; ++i)
	{
		CalPointsCyan[i] = (CalibrationPoint *)malloc(sizeof(CalibrationPoint));
		calibration_point__init(CalPointsCyan[i]);
		CalPointsCyan[i]->has_x = true;
		CalPointsCyan[i]->has_y = true;
		CalPointsCyan[i]->x = CalData[i][0];
		CalPointsCyan[i]->y = CalData[i][1];
	}
	CalibDataCyan->calibrationpoints = CalPointsCyan;
	inputliquidCyan->calibrationdata = CalibDataCyan;
	inputliquidCyan->has_maxnanoliterpercentimeter = true;
	inputliquidCyan->maxnanoliterpercentimeter = 200;
	inputliquidCyan->liquidtype = LIQUID_TYPE__Cyan;
	//Magenta
	InputLiquid *inputliquidMagenta = (InputLiquid *)malloc(sizeof(InputLiquid));
	input_liquid__init(inputliquidMagenta);
	inputliquidMagenta->volume = 30.0;
	inputliquidMagenta->has_volume = true;
	CalibrationData *CalibDataMagenta = (CalibrationData*)malloc(sizeof(CalibrationData));
	calibration_data__init(CalibDataMagenta);
	retVal = ReadCalData(CalMagentaName, CalData, nCalData);
	CalibDataMagenta->has_liquidtype = true;
	CalibDataMagenta->liquidtype = LIQUID_TYPE__Magenta;
	CalibDataMagenta->n_calibrationpoints = nCalData;
	CalibrationPoint **CalPointsMagenta = (CalibrationPoint **)malloc(sizeof(CalibrationPoint *)* nCalData);
	//	calibration_point__init(*CalPointsMagenta);
	for (int i = 0; i<nCalData; ++i)
	{
		CalPointsMagenta[i] = (CalibrationPoint *)malloc(sizeof(CalibrationPoint));
		calibration_point__init(CalPointsMagenta[i]);
		CalPointsMagenta[i]->has_x = true;
		CalPointsMagenta[i]->has_y = true;
		CalPointsMagenta[i]->x = CalData[i][0];
		CalPointsMagenta[i]->y = CalData[i][1];
	}
	CalibDataMagenta->calibrationpoints = CalPointsMagenta;
	inputliquidMagenta->calibrationdata = CalibDataMagenta;
	inputliquidMagenta->has_maxnanoliterpercentimeter = true;
	inputliquidMagenta->maxnanoliterpercentimeter = 200;
	inputliquidMagenta->liquidtype = LIQUID_TYPE__Magenta;
	//Yellow
	InputLiquid *inputliquidYellow = (InputLiquid *)malloc(sizeof(InputLiquid));
	input_liquid__init(inputliquidYellow);
	inputliquidYellow->volume = 30.0;
	inputliquidYellow->has_volume = true;
	CalibrationData *CalibDataYellow = (CalibrationData*)malloc(sizeof(CalibrationData));
	calibration_data__init(CalibDataYellow);

	retVal = ReadCalData(CalYellowName, CalData, nCalData);
	CalibDataYellow->has_liquidtype = true;
	CalibDataYellow->liquidtype = LIQUID_TYPE__Yellow;
	CalibDataYellow->n_calibrationpoints = nCalData;
	CalibrationPoint **CalPointsYellow = (CalibrationPoint **)malloc(sizeof(CalibrationPoint *)* nCalData);
	//	calibration_point__init(*CalPointsYellow);
	for (int i = 0; i<nCalData; ++i)
	{
		CalPointsYellow[i] = (CalibrationPoint *)malloc(sizeof(CalibrationPoint));
		calibration_point__init(CalPointsYellow[i]);
		CalPointsYellow[i]->has_x = true;
		CalPointsYellow[i]->has_y = true;
		CalPointsYellow[i]->x = CalData[i][0];
		CalPointsYellow[i]->y = CalData[i][1];
	}
	CalibDataYellow->calibrationpoints = CalPointsYellow;
	inputliquidYellow->calibrationdata = CalibDataYellow;
	inputliquidYellow->has_maxnanoliterpercentimeter = true;
	inputliquidYellow->maxnanoliterpercentimeter = 200;
	inputliquidYellow->liquidtype = LIQUID_TYPE__Yellow;
	inputliquids[0] = inputliquidCyan;
	inputliquids[1] = inputliquidMagenta;
	inputliquids[2] = inputliquidYellow;
	inputcoordinates->inputliquids = inputliquids;
	conversionInput->inputcoordinates = inputcoordinates;

	buffersize = conversion_input__get_packed_size(conversionInput);

	input_buffer = (uint8_t*)malloc(buffersize);
	conversion_input__pack(conversionInput, input_buffer);
	return retVal;
}

size_t ReadCLUTFile(char *name, uint8_t *&buffer, long &lSize)
{
	FILE * pFile;
	size_t result;

	errno_t err = fopen_s(&pFile, name, "rb");
	if (err)
		return false;
	if (pFile == NULL) { fputs("File error", stderr); exit(1); }
	// obtain file size:
	fseek(pFile, 0, SEEK_END);
	lSize = ftell(pFile);
	rewind(pFile);

	// allocate memory to contain the whole file:
	uint8_t *tmp_buffer = (uint8_t*)malloc(sizeof(uint8_t)*lSize);
	if (tmp_buffer == NULL) { fputs("Memory error", stderr); exit(2); }

	// copy the file into the buffer:
	result = fread(tmp_buffer, 1, lSize, pFile);
	if (result != lSize) { fputs("Reading error", stderr); exit(3); }

	/* the whole file is now loaded in the memory buffer. */
	// terminate
	buffer = tmp_buffer;
	fclose(pFile);
	return(0);
}

size_t ReadCalData(char *name, double **&CalData, long &nCalData)
{
	size_t retVal = 0;
	double scaleData = (pow(2, 32) - 1) / 100;
	FILE * pFile;
	//pFile = fopen(name, "rb");
	errno_t err = fopen_s(&pFile, name, "rb");

	if (pFile == NULL) { fputs("Calibration File error", stderr); exit(1); }
	// obtain file size:
	fseek(pFile, 0, SEEK_END);
	long lSize = ftell(pFile);
	rewind(pFile);
	// allocate memory to contain the whole file:
	int lSize4 = lSize / 4;
	unsigned int *buffer = new unsigned int[lSize4];
	if (buffer == NULL) { fputs("Calibration Memory error", stderr); exit(2); }

	// copy the file into the buffer:
	size_t result = fread(buffer, 4, lSize4, pFile);
	if (result != lSize4)
	{
		fputs("Calibration Reading error", stderr);
		fclose(pFile);
		pFile = NULL;
		exit(3);
	}
	// dynamically allocate pair array
	int lSize4H = lSize4 / 2;
	double **tmpData = new double*[lSize4H];
	nCalData = lSize4H;
	if (tmpData == NULL)
	{
		fputs("Calibration Allocation error", stderr);
		fclose(pFile);
		pFile = NULL;
		exit(4);
	}
	for (int count = 0; count < lSize4H; count++)
	{
		tmpData[count] = new double[2];
		if (tmpData[count] == NULL)
		{
			fputs(" Calibration Allocation error", stderr); exit(4);
		}
	}
	for (int count = 0; count < lSize4H; count++)
	{
		tmpData[count][0] = (double)buffer[2 * count] / scaleData;
		tmpData[count][1] = (double)buffer[2 * count + 1] / scaleData;
	}
	CalData = tmpData;
	fclose(pFile);
	return(retVal);
}

int main()
{
	char *ForwardName = new char[256];
	strcpy_s(ForwardName, 256, "..\\..\\..\\ColorData\\CCT\\test.cct");
	
	char *InverseName = new char[256];
	strcpy_s(InverseName, 256, "..\\..\\..\\ColorData\\CCT\\B2A_Lin.cct");

	char *CalCyanName = new char[256];
	strcpy_s(CalCyanName, 256, "..\\..\\..\\ColorData\\CAT\\CyanToLinear.cat");
	char *CalMagentaName = new char[256];
	strcpy_s(CalMagentaName, 256, "..\\..\\..\\ColorData\\CAT\\MagentaToLinear.cat");
	char *CalYellowName = new char[256];
	strcpy_s(CalYellowName, 256, "..\\..\\..\\ColorData\\CAT\\YellowToLinear.cat");

	uint8_t *input_buffer = NULL;
	long bufferSize = 0;
	size_t retVal = InitData(input_buffer, bufferSize, ForwardName, InverseName, CalCyanName, CalMagentaName, CalYellowName);
	if (retVal > 0) exit(1);

	
	uint8_t *output_buffer;
	size_t size = Convert(input_buffer, bufferSize, output_buffer);
	ConversionOutput* conversionOutput = (ConversionOutput*)malloc(sizeof(ConversionOutput));
	conversionOutput = conversion_output__unpack(NULL, size, output_buffer);
}