1
2
3
4
5
6
7
8
|
#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);
}
|
