int main(int argc, char **argv) {
char serialport[256];
int n;
if (argc==1) {
exit(EXIT_SUCCESS);
}
// Parse options from the command line.
int option_index = 0, opt;
static struct option loptions[] = {
{"port", required_argument, 0, 'p'}, // Command line for setting port: -p /dev/tty.usbmodem####
{"delay", required_argument, 0, 'd'} // Command line for zero delay: -d 0
};
while(1) {
opt = getopt_long(argc, argv, "hp:b:s:rn:d:", loptions, &option_index);
if (opt==-1) break;
switch (opt) {
case '0': break;
case 'd':
n = strtol(optarg,NULL,10);
usleep(n * 1000); // Delay (sleep in milliseconds).
break;
case 'p':
strcpy(serialport,optarg);
fd = serialport_init(optarg, baudrate);
if(fd==-1) return -1;
break;
}
}
// Opens MATLAB engine, creates matrices & pointers for visual and timing samples.
ep = engOpen(NULL);
cppVisualSamples = mxCreateDoubleMatrix(numberOfSamples, 1, mxREAL);
cppTimingSamples = mxCreateDoubleMatrix(numberOfSamples, 1, mxREAL);
dataSetVisual = mxGetPr(cppVisualSamples);
dataSetTiming = mxGetPr(cppTimingSamples);
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(window_width,window_height); // Window size (in pixels).
glutInitWindowPosition(100,100); // Window position (from upper left).
glutCreateWindow("Torquometer Visual Field"); // Window title.
init();
glutKeyboardFunc(myKeyboardFunc); // Handles "normal" ascii symbols (letters).
glutSpecialFunc(mySpecialKeyFunc); // Handles "special" keyboard keys (up, down).
glutDisplayFunc(display); // Default display mode.
glutIdleFunc(idleDisplay); // Used with glutSwapBuffers();
glEnable(GL_DEPTH_TEST);
//glEnable(GL_TEXTURE_2D);
makeCheckImage(); // Generates the gradient pattern in the background.
glGenTextures(1, &texName);
glBindTexture(GL_TEXTURE_2D, texName);
//glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
glutMainLoop();
}
bool GlobFit::createMatlabArraies()
{
// matlabEngine = engOpen(NULL);
matlabEngine = engOpen("matlab -nodesktop");
if (NULL == matlabEngine) {
fprintf(stderr, "Could not initialize the engine.\n");
return false;
}
size_t numPrimitives = _vecPrimitive.size();
for (size_t i = 0; i < numPrimitives; ++i) {
const Primitive* pPrimitive = _vecPrimitive[i];
if (pPrimitive->getType() != Primitive::PT_CONE) {
continue;
}
Vector normal;
pPrimitive->getNormal(normal);
const std::vector<size_t>& vecVertexIdx = pPrimitive->getPointIdx();
for (size_t j = 0, jEnd = vecVertexIdx.size(); j < jEnd; ++j) {
size_t idx = j*numPrimitives+i;
RichPoint* pRichPoint = _vecPointSet[vecVertexIdx[j]];
if (pRichPoint->normal*normal < 0) {
pRichPoint->normal = -pRichPoint->normal;
}
}
}
numVertices = mxCreateNumericMatrix(numPrimitives, 1, mxINT32_CLASS, mxREAL);
int *pNumVertices = (int*)mxGetData(numVertices);
maxIterNum = mxCreateNumericMatrix(1, 1, mxINT32_CLASS, mxREAL);
int* pMaxIterNum = (int*)mxGetData(maxIterNum);
*pMaxIterNum = 500;
primitiveType = mxCreateNumericMatrix(numPrimitives, 1, mxINT32_CLASS, mxREAL);
int *pPrimitiveType = (int*)mxGetData(primitiveType);
int maxNumVertices = 0;
for (size_t i = 0; i < numPrimitives; ++i) {
const Primitive* pPrimitive = _vecPrimitive[i];
pNumVertices[i] = std::max(1, (int)(pPrimitive->getPointIdx().size()));
pPrimitiveType[i] = pPrimitive->getType();
if (maxNumVertices < pNumVertices[i])
maxNumVertices = pNumVertices[i];
}
coordX = mxCreateDoubleMatrix(numPrimitives, maxNumVertices, mxREAL);
double* pCoordX = mxGetPr(coordX);
coordY = mxCreateDoubleMatrix(numPrimitives, maxNumVertices, mxREAL);
double* pCoordY = mxGetPr(coordY);
coordZ = mxCreateDoubleMatrix(numPrimitives, maxNumVertices, mxREAL);
double* pCoordZ = mxGetPr(coordZ);
normalX = mxCreateDoubleMatrix(numPrimitives, maxNumVertices, mxREAL);
double* pNormalX = mxGetPr(normalX);
normalY = mxCreateDoubleMatrix(numPrimitives, maxNumVertices, mxREAL);
double* pNormalY = mxGetPr(normalY);
normalZ = mxCreateDoubleMatrix(numPrimitives, maxNumVertices, mxREAL);
double* pNormalZ = mxGetPr(normalZ);
confVertices = mxCreateDoubleMatrix(numPrimitives, maxNumVertices, mxREAL);
double* pConfVertices = mxGetPr(confVertices);
memset(pCoordX, 0, maxNumVertices*sizeof(double));
memset(pCoordY, 0, maxNumVertices*sizeof(double));
memset(pCoordZ, 0, maxNumVertices*sizeof(double));
memset(pNormalX, 0, maxNumVertices*sizeof(double));
memset(pNormalY, 0, maxNumVertices*sizeof(double));
memset(pNormalZ, 0, maxNumVertices*sizeof(double));
memset(pConfVertices, 0, maxNumVertices*sizeof(double));
for (size_t i = 0; i < numPrimitives; ++i) {
const Primitive* pPrimitive = _vecPrimitive[i];
const std::vector<size_t>& vecVertexIdx = pPrimitive->getPointIdx();
for (size_t j = 0, jEnd = vecVertexIdx.size(); j < jEnd; ++j) {
size_t idx = j*numPrimitives+i;
const RichPoint* pRichPoint = _vecPointSet[vecVertexIdx[j]];
pCoordX[idx] = pRichPoint->point.x();
pCoordY[idx] = pRichPoint->point.y();
pCoordZ[idx] = pRichPoint->point.z();
pNormalX[idx] = pRichPoint->normal.x();
pNormalY[idx] = pRichPoint->normal.y();
pNormalZ[idx] = pRichPoint->normal.z();
pConfVertices[idx] = pRichPoint->confidence;
}
}
engPutVariable(matlabEngine, "numVertices", numVertices);
engPutVariable(matlabEngine, "primitiveType", primitiveType);
engPutVariable(matlabEngine, "coordX", coordX);
engPutVariable(matlabEngine, "coordY", coordY);
engPutVariable(matlabEngine, "coordZ", coordZ);
engPutVariable(matlabEngine, "normalX", normalX);
engPutVariable(matlabEngine, "normalY", normalY);
engPutVariable(matlabEngine, "normalZ", normalZ);
engPutVariable(matlabEngine, "confVertices", confVertices);
engPutVariable(matlabEngine, "maxIterNum", maxIterNum);
return true;
}
EXPORT CLASS *init(CALLBACKS *fntable, MODULE *module, int argc, char *argv[])
{
if (set_callback(fntable)==NULL)
{
errno = EINVAL;
return NULL;
}
// open a connection to the Matlab engine
int status=0;
static char server[1024];
if (gl_global_getvar("matlab_server",server,sizeof(server)))
matlab_server = server;
if (strcmp(matlab_server,"standalone")==0)
engine = engOpenSingleUse(NULL,NULL,&status);
else
engine = engOpen(matlab_server);
if (engine==NULL)
{
gl_error("unable to start Matlab engine (code %d)",status);
return NULL;
}
// prepare session
char debug[8];
if (gl_global_getvar("debug",debug,sizeof(debug)))
debugmode = (atoi(debug)==1);
engSetVisible(engine,debugmode?1:0);
engEvalString(engine,"clear all;");
char env[1024];
_snprintf(env,sizeof(env),"NEVER=%g;INVALID=%g;",TOSERIAL(TS_NEVER),TOSERIAL(TS_INVALID));
engEvalString(engine,env);
// collect output from Matlab
engOutputBuffer(engine,output,sizeof(output));
// setup the Matlab module and run the class constructor
engEvalString(engine,"global passconfig;");
if (engEvalString(engine,argv[0])!=0)
gl_error("unable to evaluate function '%s' in Matlab", argv[0]);
else
gl_matlab_output();
// read the pass configuration
mxArray *pcfg= engGetVariable(engine,"passconfig");
if (pcfg && mxIsChar(pcfg))
{
char passinfo[1024];
KEYWORD keys[] = {
{"NOSYNC",PC_NOSYNC,keys+1},
{"PRETOPDOWN",PC_PRETOPDOWN,keys+2},
{"BOTTOMUP",PC_BOTTOMUP,keys+3},
{"POSTTOPDOWN",PC_POSTTOPDOWN,NULL},
};
PROPERTY pctype = {0,"passconfig",PT_set,1,PA_PUBLIC,NULL,&passconfig,NULL,keys,NULL};
set passdata;
if (mxGetString(pcfg,passinfo,sizeof(passinfo))==0 && callback->convert.string_to_property(&pctype,&passdata,passinfo)>0)
{
passconfig = (PASSCONFIG)passdata;
oclass=gl_register_class(module,argv[0],passconfig);
if (oclass==NULL)
gl_error("unable to register '%s' as a class",argv[0]);
DELEGATEDTYPE *pDelegate = new DELEGATEDTYPE;
pDelegate->oclass = oclass;
strncpy(pDelegate->type,"matlab",sizeof(pDelegate->type));
pDelegate->from_string = object_from_string;
pDelegate->to_string = object_to_string;
if (gl_publish_variable(oclass,PT_delegated,pDelegate,"data",0,NULL)<1) GL_THROW("unable to publish properties in %s",__FILE__);
}
else
gl_error("passconfig is invalid (expected set of NOSYNC, PRETOPDOWN, BOTTOMUP, and POSTTOPDOWN)", passinfo);
}
else
gl_error("passconfig not specified");
// read the pass configuration
mxArray *ans= engGetVariable(engine,"ans");
if (ans && mxIsStruct(ans))
{
defaults = mxDuplicateArray(ans);
// process the answer
int nFields = mxGetNumberOfFields(ans), i;
for (i=0; i<nFields; i++)
{
const char *name = mxGetFieldNameByNumber(ans,i);
mxArray *data = mxGetFieldByNumber(ans,0,i);
// @todo publish the structure
}
}
else
gl_error("result of call to matlab::%s did not return a structure", argv[0]);
#ifdef OPTIONAL
/* TODO: publish global variables (see class_define_map() for details) */
gl_global_create(char *name, ..., NULL);
/* TODO: use gl_global_setvar, gl_global_getvar, and gl_global_find for access */
#endif
/* always return the first class registered */
return oclass;
}
int testmatlab (void)
{
Engine *ep;
mxArray *T = NULL, *result = NULL;
char buffer[BUFSIZE+1];
double time[10] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
/*
* Start the MATLAB engine locally by executing the string
* "matlab"
*
* To start the session on a remote host, use the name of
* the host as the string rather than \0
*
* For more complicated cases, use any string with whitespace,
* and that string will be executed literally to start MATLAB
*/
if (!(ep = engOpen("\0"))) {
fprintf(stderr, "\nCan't start MATLAB engine\n");
return EXIT_FAILURE;
}
/*
* PART I
*
* For the first half of this demonstration, we will send data
* to MATLAB, analyze the data, and plot the result.
*/
/*
* Create a variable for our data
*/
T = mxCreateDoubleMatrix(1, 10, mxREAL);
memcpy((void *)mxGetPr(T), (void *)time, sizeof(time));
/*
* Place the variable T into the MATLAB workspace
*/
engPutVariable(ep, "T", T);
/*
* Evaluate a function of time, distance = (1/2)g.*t.^2
* (g is the acceleration due to gravity)
*/
engEvalString(ep, "D = .5.*(-9.8).*T.^2;");
/*
* Plot the result
*/
engEvalString(ep, "plot(T,D);");
engEvalString(ep, "title('Position vs. Time for a falling object');");
engEvalString(ep, "xlabel('Time (seconds)');");
engEvalString(ep, "ylabel('Position (meters)');");
/*
* use fgetc() to make sure that we pause long enough to be
* able to see the plot
*/
printf("Hit return to continue\n\n");
fgetc(stdin);
/*
* We're done for Part I! Free memory, close MATLAB figure.
*/
printf("Done for Part I.\n");
mxDestroyArray(T);
engEvalString(ep, "close;");
/*
* PART II
*
* For the second half of this demonstration, we will request
* a MATLAB string, which should define a variable X. MATLAB
* will evaluate the string and create the variable. We
* will then recover the variable, and determine its type.
*/
/*
* Use engOutputBuffer to capture MATLAB output, so we can
* echo it back. Ensure first that the buffer is always NULL
* terminated.
*/
buffer[BUFSIZE] = '\0';
engOutputBuffer(ep, buffer, BUFSIZE);
while (result == NULL) {
char str[BUFSIZE+1];
/*
* Get a string input from the user
*/
printf("Enter a MATLAB command to evaluate. This command should\n");
printf("create a variable X. This program will then determine\n");
printf("what kind of variable you created.\n");
printf("For example: X = 1:5\n");
printf(">> ");
fgets(str, BUFSIZE, stdin);
/*
* Evaluate input with engEvalString
*/
engEvalString(ep, str);
/*
* Echo the output from the command.
*/
printf("%s", buffer);
/*
* Get result of computation
*/
printf("\nRetrieving X...\n");
if ((result = engGetVariable(ep,"X")) == NULL)
printf("Oops! You didn't create a variable X.\n\n");
else {
printf("X is class %s\t\n", mxGetClassName(result));
}
}
/*
* We're done! Free memory, close MATLAB engine and exit.
*/
printf("Done!\n");
mxDestroyArray(result);
engClose(ep);
return EXIT_SUCCESS;
}
//#define BUFSIZE 1000
void AAM_Train::getMeanShape()
{
double threshold=0.002;
//transplate all the shapes to its gradivity
for (int i=0;i<shapeNum;i++)
{
shape[i]->centerPts(2);
}
//normalize shape[0],save as ref
int refInd=4;
//namedWindow("1");
//imshow("1",cvarrToMat(shape[refInd]->hostImage));
//waitKey();
//shape[refInd]->normalize(1);
//if we want to control the complexity, do it here
double *refshape=new double[shape[refInd]->ptsNum*2];
for (int i=0;i<shape[refInd]->ptsNum*2;i++)
{
refshape[i]=shape[refInd]->ptsForMatlab[i]*1.0;
}
shape_scale=normalize(refshape,shape[refInd]->ptsNum);
//align the shape
int width=shape[refInd]->ptsNum;
int height=2;
int arraysize=width*2*sizeof(double);
mxArray *referShape = NULL,*curMatMean=NULL,*newMatMean=NULL, *inputShape=NULL,*result = NULL;
if (!(ep = engOpen("\0"))) {
fprintf(stderr, "\nCan't start MATLAB engine\n");
return;
}
referShape=mxCreateDoubleMatrix(width,height,mxREAL);
curMatMean=mxCreateDoubleMatrix(width,height,mxREAL);
newMatMean=mxCreateDoubleMatrix(width,height,mxREAL);
inputShape=mxCreateDoubleMatrix(width,height,mxREAL);
result=mxCreateDoubleMatrix(width,height,mxREAL);
double *currentMean=new double[width*2];
double *newMean=new double[width*2];
//set the default refer shape
memcpy((void *)mxGetPr(referShape), (void *)refshape, arraysize);
//initialize currentMean to the refer shape
for (int i=0;i<width*2;i++)
{
currentMean[i]=refshape[i];
}
ofstream out3("F:/imgdata/AAM training data/train/refshape.txt",ios::out);
//for (int i=0;i<shapeNum;i++)
{
for(int j=0;j<width;j++)
{
out3<<refshape[j]<<" "<<refshape[width+j]<<endl;
}
}
out3.close();
//char buffer[BUFSIZE+1];
engPutVariable(ep, "referShape", referShape);
engPutVariable(ep, "result", result);
// engEvalString(ep,"save('F:/imgdata/AAM training data/train/refershape.mat','referShape');");
// engPutVariable(ep, "result", newMatMean);
while(1)
{
//set current mean
memcpy((void *)mxGetPr(curMatMean), (void *)currentMean, arraysize);
engPutVariable(ep, "curMatMean", curMatMean);
//allign all the shapes
for (int i=0;i<shapeNum;i++)
{
memcpy((void *)mxGetPr(inputShape), (void *)shape[i]->ptsForMatlab, arraysize);
engPutVariable(ep, "inputShape", inputShape);
engEvalString(ep, "[m,result]=procrustes(curMatMean,inputShape);");
result = engGetVariable(ep,"result");
// delete []shape[i]->ptsForMatlab;
shape[i]->ptsForMatlab=mxGetPr(result);
engEvalString(ep,"save('F:/imgdata/AAM training data/train/result.mat','result','curMatMean','inputShape');");
//shape[i]->scale(shape[i]->scaleParameter,1);//reconver the scale
}
//caculate newMean and allign it to ref and normalize
for (int i=0;i<width*2;i++)
{
newMean[i]=0;
}
for (int i=0;i<width*2;i++)
{
for (int j=0;j<shapeNum;j++)
{
newMean[i]+=shape[j]->ptsForMatlab[i];
}
newMean[i]/=shapeNum;
}
memcpy((void *)mxGetPr(newMatMean), (void *)newMean, arraysize);
engPutVariable(ep, "newMatMean", newMatMean);
engEvalString(ep, "[m,result]=procrustes(referShape,newMatMean);");
//engEvalString(ep,"save('F:/imgdata/AAM training data/train/result.mat','result','referShape','newMatMean');");
//delete []newMean;
newMean=mxGetPr( engGetVariable(ep,"result"));
//normalize newMean
normalize(newMean,width);
ofstream out1("F:/imgdata/AAM training data/train/meanshape_ori.txt",ios::out);
//for (int i=0;i<shapeNum;i++)
{
for(int j=0;j<width;j++)
{
out1<<newMean[j]<<" "<<newMean[width+j]<<endl;
}
}
out1.close();
//caculate the diff of means, if smaller than threshold, stop
double differ=0,n2_newmean=0;
for (int i=0;i<width;i++)
{
differ+=sqrt((newMean[i]-refshape[i])*(newMean[i]-refshape[i])+
(newMean[width+i]-refshape[width+i])*(newMean[width+i]-refshape[width+i]));
// n2_newmean+=sqrt(newMean[i]*newMean[i]+newMean[width+i]*newMean[width+i]);
}
cout<<"current difference: "<<differ/shape_scale<<endl;
if (differ/shape_scale<threshold)
{
//ofstream out("meanshape.txt",ios::out);
//for (int i=0;i<meanShape->ptsNum;i++)
//{
// out<<meanShape->pts[i][0]<<" "<<meanShape->pts[i][1]<<endl;
//}
//out.close();
//save the new mean
meanShape->getVertex(newMean,width,1,1);
meanShape->scale(shape_scale,1);
break;
}
//oldmean=newmean
for (int i=0;i<width*2;i++)
{
currentMean[i]=newMean[i];
}
}
//rescale all the shapes
engClose(ep);
//for (int i=0;i<shapeNum;i++)
//{
// shape[i]->scale(scaleParameter,2);//scale to normal size,only for traning data
//}
//tangent space if needed
ofstream out("F:/imgdata/AAM training data/train/allignedshape.txt",ios::out);
for (int i=0;i<shapeNum;i++)
{
for(int j=0;j<width;j++)
{
out<<shape[i]->ptsForMatlab[j]<<" "<<shape[i]->ptsForMatlab[width+j]<<endl;
}
}
out.close();
ofstream out1("F:/imgdata/AAM training data/train/meanshape.txt",ios::out);
//for (int i=0;i<shapeNum;i++)
{
for(int j=0;j<width;j++)
{
out1<<meanShape->ptsForMatlab[j]<<" "<<meanShape->ptsForMatlab[width+j]<<endl;
}
}
out1.close();
//delete []currentMean;
//delete []newMean;
//delete []refshape;
}
void DrawPic::drawPic(vector<double> edgeOldSfr,vector<double> edgeNewSfr,vector<double> allOldSfr,vector<double> allNewSfr) {
double edgeOldSfrArray[9];
double edgeNewSfrArray[9];
double allOldSfrArray[9];
double allNewSfrArray[9];
vector<double>::iterator iter = edgeOldSfr.begin();
int i=0;
while(iter!=edgeOldSfr.end()) {
edgeOldSfrArray[i] = *iter++;
i++;
}
iter = edgeNewSfr.begin();
i=0;
while(iter!=edgeNewSfr.end()) {
edgeNewSfrArray[i] = *iter++;
i++;
}
iter = allOldSfr.begin();
i=0;
while(iter!=allOldSfr.end()) {
allOldSfrArray[i] = *iter++;
i++;
}
iter = allNewSfr.begin();
i=0;
while(iter!=allNewSfr.end()) {
allNewSfrArray[i] = *iter++;
i++;
}
Engine* m_pEngine;
mxArray *_edgey1 = NULL;
mxArray *_edgey2 = NULL;
mxArray *_ally1 = NULL;
mxArray *_ally2 = NULL;
m_pEngine = engOpen(NULL);
if( m_pEngine == NULL ) {
cout<<"error!"<<endl;
exit(-1);
}
//double y1[9] = {0, 2.827/9 , 10.2687/9 , 15.465/9 , 19.3475/9 , 23.769/9 , 26.688/9 , 32.155/9 , 36.284/9};
//double y2[9] = {0, 3.292/9 , 8.2671/9 ,16.416/9 , 22.601/9 , 25.7154/9 , 29.183/9 , 34.855/9 , 40.9438/9};
engEvalString(m_pEngine, "x = 0:10:80;");
_edgey1 = mxCreateDoubleMatrix(1, 9, mxREAL);
_edgey2 = mxCreateDoubleMatrix(1, 9, mxREAL);
_ally1 = mxCreateDoubleMatrix(1, 9, mxREAL);
_ally2 = mxCreateDoubleMatrix(1, 9, mxREAL);
memcpy((void *)mxGetPr(_edgey1), (void *)edgeOldSfrArray, sizeof(edgeOldSfrArray));
memcpy((void *)mxGetPr(_edgey2), (void *)edgeNewSfrArray, sizeof(edgeNewSfrArray));
memcpy((void *)mxGetPr(_ally1), (void *)allOldSfrArray, sizeof(allOldSfrArray));
memcpy((void *)mxGetPr(_ally2), (void *)allNewSfrArray, sizeof(allNewSfrArray));
engPutVariable(m_pEngine, "edgeOldSfr", _edgey1);
engPutVariable(m_pEngine, "edgeNewSfr", _edgey2);
engPutVariable(m_pEngine, "allOldSfr", _ally1);
engPutVariable(m_pEngine, "allNewSfr", _ally2);
//engEvalString(m_pEngine,"y1 = [0 2.827/9 10.2687/9 15.465/9 19.3475/9 23.769/9 26.688/9 32.155/9 36.284/9]");
//engEvalString(m_pEngine,"y2 = [0 3.292/9 8.2671/9 16.416/9 22.601/9 25.7154/9 29.183/9 34.855/9 40.9438/9]");
engEvalString(m_pEngine,"subplot(2,1,1);");
engEvalString(m_pEngine, "plot(x,edgeOldSfr,x,edgeNewSfr,'o-.');");
engEvalString(m_pEngine, "xlabel('小区用户数(个)','FontSize',12);");
engEvalString(m_pEngine, "ylabel('小区边缘用户吞吐量(Mb/s)','FontSize',12);");
engEvalString(m_pEngine, "legend('固定SFR','D-SFR','FontSize',12,2);");
engEvalString(m_pEngine,"subplot(2,1,2);");
engEvalString(m_pEngine,"plot(x,allOldSfr,x,allNewSfr,'o-.');");
engEvalString(m_pEngine,"xlabel('小区用户数(个)','FontSize',12);");
engEvalString(m_pEngine, "ylabel('小区吞吐量(Mb/s)','FontSize',12);");
engEvalString(m_pEngine, "legend('固定SFR','D-SFR','FontSize',12,2);");
MessageBox(NULL,_T("已经得到固定软频率复用和动态软频率复用仿真结果"),_T("通知"),MB_OK);
engClose(m_pEngine);
}
int main(int argc, char* argv[]) {
cout<<"beta ="<<beta<<endl;
if (argc < 6) {
cout
<< "invalid format: <tasksets><hyperperiod length><computation utilization><interval> <seed>"
<< endl;
exit(1);
}
#if(MATLAB_ENABLE)
ep =engOpen(NULL);
if(ep==0)
{
cout<<"connection with matlab engine failed"<<endl;
}
#endif
#if (RT_ENABLE)
struct sched_param param;
signal(SIGINT, int_handler);
freq_set(CORE,"performance");
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(1,&mask);
cout<<"setting affinity to processor "<<CORE<<endl;
if(sched_setaffinity(0,CPU_COUNT(&mask),&mask)==-1)
{
perror("sched_setscheduler failed");
exit(-1);
}
param.sched_priority = MY_PRIORITY; //priority for the scheduler
if (sched_setscheduler(0, SCHED_FIFO, ¶m) == -1) { //scheduler has cooporative scheduling
perror("sched_setscheduler failed");
exit(-1);
}
//lock memory
if(mlockall(MCL_CURRENT | MCL_FUTURE)==-1)
{
perror("mlockall failed");
exit(-2);
}
stack_prefault();
#endif
corrected_threshold = corrected_temperature(THRESHOLD);
cout<<"beta "<<beta<<" corrected threshold "<<corrected_threshold<<endl;
// exit(1);
int iter = atoi(argv[1]);
int hyperperiod = atoi(argv[2]);
int comp_util = atoi(argv[3]);
int sched_interval=atoi(argv[4]);
seed = atoi(argv[5]);
string task_file;
if (argc == 7) {
task_file = argv[6];
}
srand(seed);
vector<task> tasks;
vector<schedule> edf;
vector<task> scaled_tasks;
vector<double> speeds;
vector<schedule> edf2;
vector<task> discrete_scaled;
vector<schedule> edf3;
vector<schedule> edl2;
vector<schedule> i_schedule;
vector<schedule> opt;
vector<schedule> opt_exact;
vector<float> possible_speeds;
vector<double> h_speed;
vector<double> s_speed;
vector<double> m_speed;
vector<double> i_speed;
vector<double> i_speed_temp;
vector<slack> slacks;
vector<schedule> edl;
vector<task> scaled_max_first;
vector<task> scaled_static;
vector<task> scaled_matlab;
vector<schedule> edf_max_first;
vector<schedule> edf_static;
vector<schedule> edf_matlab;
for (int z = 0; z < iter; z++) {
thermal_optimal = 0;
// generate_tasksets(&tasks,1,hyperperiod,50,100);
if (argc == 6) {
// generate_tasksets(&tasks, 1, hyperperiod, comp_util, comp_util);
} else {
read_tasksets(&tasks, task_file);
}
int_pointer=&tasks;
#if(OPT_ENABLE)
call_gams();
store_opt(&tasks);
#endif
double t_util;
// edf_schedule(&tasks, &edf);
// consolidate_schedule(&edf, &tasks);
thermal_optimal = 1;
// compute_profile(&edf, &tasks, t_util);
// edl_schedule2(&edl2, &edf);
// consolidate_schedule(&edl2, &tasks);
// populate_slacks(&slacks, &edf);
// edl_schedule(&edl, &edf, &tasks, &slacks);
// consolidate_schedule(&edl, &tasks);
#if(INST_ENABLE)
cout<<"entering optimize instances"<<endl;
vector<int>slack;
optimize_instances(&i_speed,&tasks,&i_schedule,&edl, &edl2,MIN_SPEED,MAX_SPEED,&i_speed_temp,&slack);
cout<<"exiting optimize instances"<<endl;
cout<<"printing optimal schedule"<<endl;
for(unsigned int i=0;i<i_schedule.size();i++)
{
cout<<"task "<<i_schedule[i].task_id<<" start "<<i_schedule[i].start<<" end "<<i_schedule[i].end
<<" speed "<<i_speed[i]<<" power "<<tasks[i_schedule[i].task_id].power*pow(i_speed[i],3.0)<<
" slack "<<slack[i]<<" deadline "<<(i_schedule[i].start/tasks[i_schedule[i].task_id].period+1)*tasks[i_schedule[i].task_id].period<<endl;
}
verify(&i_schedule,&tasks,&i_speed);
#endif
#if(SLACK_ENABLE)
verify(&edl, &tasks);
opt_schedule_exact(&opt_exact, &tasks);
opt_schedule(&opt, &tasks, &edl);
#endif
#if(MAX_ENABLE)
vector<float_task>ft;
vector<long_task>ltasks;
vector<long_schedule>lschedule;
vector<long_schedule>lschedule2;
vector<long_schedule>lschedule3;
vector<float_schedule>wsch;
vector<float_schedule>wsch2;
vector<float_schedule>wsch3;
vector<float_schedule>fedf;
vector<schedule>o_sch;
vector<interval_s>intervals;
// cout<<"generating task set "<<endl;
float thermal_util=0.98;
float computation_util=1.0;
int num_tasks=rand() % (11) + 10;
// generate_taskset(&ft, 1000, num_tasks,computation_util, thermal_util);
// w2fq_task_convert(<asks, &ft);
// generate_intervals_gps(&intervals, <asks);/
// w2fq_schedule(&lschedule, <asks,&intervals,0);
// edf_schedule(&ft,&fedf);
// w2fq_schedule_convert(&wsch, &lschedule);
//cout<<" printing float schedule "<<endl;
// compute_profile(&wsch, &ft, 1);
// compute_profile(&fedf, &ft, 4);
// instance_override(&ft);
// dynamic_instance_schedule(&lschedule2, <asks,&intervals,1);
// w2fq_schedule_convert(&wsch2, &lschedule2);
// compute_profile(&wsch2, &ft, 2);
// dynamic_instance_schedule(&lschedule3, <asks,&intervals,2);
// w2fq_schedule_convert(&wsch3, &lschedule3);
// compute_profile(&wsch3, &ft, 3);
ft.clear();
ltasks.clear();
lschedule.clear();
fedf.clear();
wsch.clear();
float power;
power=rand()/(float)RAND_MAX*20.00;
power=power+18.00;
cout<<power<<endl;
float comp_util=1.5;//0.6;
ofstream taskfile("taskset_file");
int ** matrix;
matrix = new int *[20];
for(unsigned int i=0;i<20;i++)
{
matrix[i] =new int[20];
}
resource_matrix(matrix,20,0.5);
stringstream command;
generate_taskset_multi(&ft, 100, 15,2.0);
gams_include(&ft, matrix);
ofstream tasksetfile("taskset");
for(unsigned int i=0;i<ft.size();i++)
{
tasksetfile<<"task"<<i<<"\t"<<ft[i].computation_time<<"\t"<<ft[i].period<<"\t"<<ft[i].power<<endl;
}
tasksetfile.close();
vector<instance>inst;
vector<interval>speed_intervals;
vector<long_schedule>lsch;
generate_intervals_multi(&speed_intervals, "instanceassign_speed.put");
for(unsigned int i=0;i<speed_intervals.size();i++)
{
cout<<"start "<<speed_intervals[i].start<<" end "<<speed_intervals[i].end<<endl;
for(unsigned int j=0;j<speed_intervals[i].get_size();j++)
{
cout<<"task "<<speed_intervals[i].exec[j].task<<"|"<<speed_intervals[i].exec[j].exec<<"|"<<speed_intervals[i].exec[j].core<<endl;
}
}
//exit(1);
instance_override_speed(&ft, &inst);
w2fq_task_convert(<asks, &ft);
dynamic_instance_schedule_speed(&lsch, <asks, &speed_intervals, &inst,0);
// vector<long_schedule>lsch2;
// dynamic_instance_schedule_speed(&lsch2, <asks, &speed_intervals, &inst,0);
float scaled_power[CORE];
double avg_power;
generate_power_trace(&lsch, "power_profile_scaled", hyperperiod, scaled_power);
multi_simulate("power_profile_scaled", "multi.flp",0,avg_power);
// dynamic_instance_schedule
exit(1);
float comps[CORE];
for(unsigned int i=0;i<speed_intervals.size();i++)
{
for(unsigned int j=0;j<CORE;j++)
{
comps[j]=0;
}
for(unsigned int j=0;j<speed_intervals[i].get_size();j++)
{
comps[speed_intervals[i].exec[j].core]=comps[speed_intervals[i].exec[j].core]+
speed_intervals[i].exec[j].exec;
}
cout<<speed_intervals[i].start<<"|"<<speed_intervals[i].end<<"|"<<comps[0]<<"|"<<comps[1]<<"|"<<comps[2]<<endl;
}
exit(1);
float bins[BIN_LENGTH]={0.5,0.6,0.7,0.8,0.9,1.0,1.1};
int bin_count[BIN_LENGTH]={0,0,0,0,0,0,0};
int task_num=0;
bool tutil_incomplete=true;
while(comp_util<3.0)//1.0)
{
cout<<"generating for computil"<<comp_util<<endl;
tutil_incomplete=true;
for(unsigned int b=0;b<BIN_LENGTH;b++)
{
bin_count[b]=0;
}
while(tutil_incomplete)
{
//cout<<" task num "<<task_num<<endl;
//generate_taskset(&ft, 100, 10, comp_util);
generate_taskset_multi(&ft, 100, 15,comp_util);
float avg_power=0.00;
float real_cutil=0.00;
for(unsigned int i=0;i<ft.size();i++)
{
avg_power=avg_power+ft[i].computation_time/ft[i].period*ft[i].power;
real_cutil=real_cutil+ft[i].computation_time/ft[i].period;
}
float tutil=avg_power/(beta*corrected_threshold);//UTIL_POWER;
bool accept=false;
for(unsigned int b=0;b<BIN_LENGTH;b++)
{
if(tutil> bins[b] && tutil<(bins[b]+0.1) && bin_count[b]<10)
{
accept=true;
bin_count[b]=bin_count[b]+1;
}
}
if(accept)
{
/*if(tutil<0.6 && comp_util>0.75)
{
ofstream tasksetfile("taskset");
for(unsigned int i=0;i<ft.size();i++)
{
tasksetfile<<"task"<<i<<"\t"<<ft[i].computation_time<<"\t"<<ft[i].period<<"\t"<<ft[i].power<<endl;
}
taskfile<<real_cutil<<"\t"<<tutil<<endl;
//w2fq_task_convert(<asks, &ft);
//generate_intervals_gps(&intervals, <asks);
//w2fq_schedule(&lschedule, <asks,&intervals,0);
//edf_schedule(&ft,&fedf);
//w2fq_schedule_convert(&wsch, &lschedule);
//cout<<" printing float schedule "<<endl;
//compute_profile(&wsch, &ft, 1);
//compute_profile(&fedf, &ft, 4);
//command<<"mkdir results_uni/"<<task_num<<";";
//command<<"cp profile_float results_uni/"<<task_num<<"/.;";
//command<<"cp profile_default results_uni/"<<task_num<<"/.;";
//command<<"cp taskset results_uni/"<<task_num<<"/.";
//system(command.str().c_str());
//command.str("");
tasksetfile.close();
//exit(1);
}*/
//cout<<"checkpoint 1 "<<endl;
gams_include(&ft, matrix);
//cout<<"checkpoint 2 "<<endl;
system("cd gams_files; ~rehan/gams/gams lower_bound.gms");
system("cd gams_files; ~rehan/gams/gams task_assign.gms");
command<<"mkdir results/"<<task_num<<";";
command<<"cp gams_files/results.put results/"<<task_num<<"/.;";
command<<"cp gams_files/taskassign.put results/"<<task_num<<"/.;";
command<<"cp gams_files/taskassign_assign.put results/"<<task_num<<"/.;";
command<<"cp gams_files/task_assign.lst results/"<<task_num<<"/.;";
command<<"cp gams_files/lower_bound.lst results/"<<task_num<<"/.;";
command<<"cp gams_files/taskset.put results/"<<task_num<<"/.";
system(command.str().c_str());
command.str("");
//cin.get();
//exit(1);
task_num=task_num+1;
tutil_incomplete=false;
for(unsigned int b=0;b<BIN_LENGTH;b++)
{
if(bin_count[b]<10)
{
tutil_incomplete=true;
}
}
//exit(1);
}
intervals.clear();
lschedule.clear();
ltasks.clear();
fedf.clear();
wsch.clear();
ft.clear();//only ft needs to be cleared for multicore simulation
}
//comp_util=comp_util+0.0025;//0.01;
comp_util=comp_util+0.01;//0.01;
}
exit(1);
/*
int task_num=0;
while(comp_util<3.0)
{
for(unsigned int m=0;m<10;m++)
{
generate_taskset_multi(&ft, 100, 15,comp_util);
float avg_power=0.00;
float real_cutil=0.00;
for(unsigned int i=0;i<ft.size();i++)
{
avg_power=avg_power+ft[i].computation_time/ft[i].period*ft[i].power;
real_cutil=real_cutil+ft[i].computation_time/ft[i].period;
}
float tutil=avg_power/UTIL_POWER;
if(tutil>0.5 && tutil<1.2)
{
taskfile<<real_cutil<<"\t"<<tutil<<endl;
cout<<"checkpoint 1 "<<endl;
gams_include(&ft, matrix);
cout<<"checkpoint 2 "<<endl;
system("cd gams_files; ~rehan/gams/gams lower_bound.gms");
system("cd gams_files; ~rehan/gams/gams task_assign.gms");
command<<"mkdir results/"<<task_num<<";";
command<<"cp gams_files/results.put results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/taskassign.put results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/taskassign_assign.put results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/task_assign.lst results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/lower_bound.lst results/"<<atoi(argv[5])<<"/.;";
command<<"cp gams_files/taskset.put results/"<<atoi(argv[5])<<"/.";
system(command.str().c_str());
command.str("");
task_num=task_num+1;
}
ft.clear();
}
comp_util=comp_util+0.001;
}
/*
exit(1);
// generate_taskset_multi(&ft, 100, 8,2.5, power);
//read_taskset_multi(&ft, "gams_folder/taskset.put");
float cutil=0;
float tutil=0;
for(unsigned int i=0;i<ft.size();i++)
{
cout<<"task "<<i<<" computation time "<<ft[i].computation_time<<" period "
<<ft[i].period<<" power "<<ft[i].power<<" comp util "<<ft[i].computation_time/ft[i].period
<<" thermal util "<<ft[i].computation_time*ft[i].power/(ft[i].period*beta*corrected_threshold)<<endl;
cutil=cutil+ft[i].computation_time/ft[i].period;
tutil=tutil+ft[i].computation_time*ft[i].power/(ft[i].period*beta*corrected_threshold);
}
cout<<" computation utilization "<<cutil<<" thermal utilization "<<tutil<<endl;
int int_size=gams_include(&ft, matrix);
populate_beta();
for(unsigned int i=0;i<CORE;i++)
{
for(unsigned int j=0;j<CORE;j++)
{
cout<<beta_multi[i][j]<<"\t";
}
cout<<endl;
}
system("cd gams_files; ~rehan/gams/gams task_assign.gms");//
//system("cd gams_files; ~rehan/gams/gams instance_assign.gms");//
//vector<trace>ttrace;
// read_ttrace("hotspot_files/thermal_profile", &ttrace);
intervals.clear();
vector<mprofile>prof;
generate_intervals_multi(&intervals,"gams_files/taskassign.put", &ft);
vector<long_schedule>multi_sch;
ltasks.clear();
w2fq_task_convert(<asks, &ft);
multi_schedule(&multi_sch,&intervals, <asks);
long hyperperiod=compute_lcm(<asks);
float avg_power[CORE];
generate_power_trace(&multi_sch, "power_profile", hyperperiod, avg_power);
generate_power_profile(&prof,&multi_sch, hyperperiod);
cout<<"power profile length "<<prof.size()<<endl;
double average_power;
for(unsigned int i=0;i<ltasks.size();i++)
{
average_power=average_power+(((double)ltasks[i].computation_time)/((double)ltasks[i].period))*ltasks[i].power;
}
//compute_profile_multi(&multi_sch, <asks);
//exit(1);
// multi_simulate("power_profile", "multi.flp",0,average_power);
exit(1);
multi_sch.clear();
intervals.clear();
generate_intervals_multi(&intervals,"gams_files/instanceassign.put", &ft);
multi_schedule(&multi_sch,&intervals, <asks);
generate_power_trace(&multi_sch, "power_profile", hyperperiod, avg_power);
//multi_simulate("power_profile", "multi.flp",1);
// exit(1);
system(command.str().c_str());
for(unsigned int i=0;i<intervals.size();i++)
{
cout<<" start "<<intervals[i].start<<" end "<<intervals[i].end<<endl;
for(unsigned int k=0;k<CORE;k++)
{
cout<<" core"<<k<<": ";
int total=0;
float average_power=0;
for(unsigned int j=0;j<ft.size();j++)
{
cout<<intervals[i].computations[j][k]<<" ";
total=total+intervals[i].computations[j][k];
average_power=average_power+((float)intervals[i].computations[j][k])*ft[j].power/((float)(intervals[i].end-intervals[i].start));
}
assert(total<=(intervals[i].end-intervals[i].start));
cout<<" total "<<total<<" average power "<<average_power<< endl;
}
}
cout<<endl<<endl;
for(unsigned int i=0;i<multi_sch.size();i++)
{
// cout<<"task "<<multi_sch[i].task_id<<" start "<<multi_sch[i].start<<" end "<<multi_sch[i].end<<" core "<<multi_sch[i].core<<endl;
}
//avg_power=(float*)malloc(sizeof(float)*CORE);
cout<<" printing average power"<<endl;
for(unsigned int i=0;i<CORE;i++)
{
cout<<"core"<<i<<" average power "<<avg_power[i]<<endl;
}
total_comps(&multi_sch,<asks,&intervals);
// exit(1);
// void w2fq_schedule(vector<long_schedule>*sch, vector<long_task>*tasks, vector<interval>*intervals, int core)
/* while(computation_util<=1.0)
{
thermal_util=0.99;
while(thermal_util<=1.0)
{
generate_taskset(&ft, 1000, computation_util, thermal_util);
w2fq_task_convert(<asks, &ft);
w2fq_schedule(&lschedule, <asks);
edf_schedule(&ft,&fedf);
w2fq_schedule_convert(&wsch, &lschedule);
//cout<<" printing float schedule "<<endl;
compute_profile(&wsch, &ft, 1);
compute_profile(&fedf, &ft, 2);
ft.clear();
ltasks.clear();
lschedule.clear();
fedf.clear();
wsch.clear();
thermal_util=thermal_util+0.001;
}
computation_util=computation_util+0.01;
}
*/
/*
// t_util=optimize_maxfirst(&h_speed,&tasks,0.75,1.2);
timespec start_time,end_time;
clock_gettime(1,&start_time);
t_util=optimize_maxmin(&h_speed,&tasks,MIN_SPEED,MAX_SPEED);
clock_gettime(1,&end_time);
scale(&scaled_max_first,&tasks,&h_speed);
edf_schedule(&scaled_max_first,&edf_max_first);
thermal_optimal=4;
compute_profile(&edf_max_first, &scaled_max_first,t_util);
float max_first_time=time_diff(&start_time,&end_time);
slacks.clear();
opt.clear();
opt_exact.clear();
edl.clear();
populate_slacks(&slacks, &edf_max_first);
edl_schedule(&edl, &edf_max_first, &scaled_max_first, &slacks);
consolidate_schedule(&edl, &scaled_max_first);
clock_gettime(1,&start_time);
//opt_schedule(&opt, &scaled_max_first, &edl);
clock_gettime(1,&end_time);
// opt_schedule_exact(&opt_exact, &scaled_max_first);
// cout<<" schedule size "<<opt_exact.size()<<endl;
// run_schedule(&opt,&scaled_max_first);
// cout<<"TIME to find the optimal schedule "<<time_diff(&start_time,&end_time)<<"ms"<< " Maxfirst time" << max_first_time<<" Hyperperiod "<<tasksets[0].hyperperiod<<" tasks "<< tasks.size()<<endl;
float max_speeds[tasks.size()];
for(unsigned int i=0;i<tasks.size();i++)
{
max_speeds[i]=((float)tasks[i].computation_time)/((float)scaled_max_first[i].computation_time);
}
vector<schedule>o_sch2;
//run_dynamic(&scaled_max_first,max_speeds);
vector<instance>dyn_inst;
dynamic_instances(&scaled_max_first,max_speeds ,&dyn_inst);
vector<instance>dyn_inst2;
for(unsigned int i=0;i<dyn_inst.size();i++)
{
dyn_inst2.push_back(dyn_inst[i]);
}
double tutil=0;
scheduler(&o_sch,&scaled_max_first,&dyn_inst,max_speeds,sched_interval);
compute_profile_dynamic(&o_sch, &tasks,tutil,"");
scheduler2(&o_sch2,&scaled_max_first,&dyn_inst2, max_speeds, sched_interval);
compute_profile_dynamic(&o_sch2, &tasks,tutil,"window");
/* for(unsigned int i=0;i<o_sch2.size();i++)
{
cout<<"task "<<o_sch2[i].task_id<<" start "<<o_sch2[i].start<<" end "<<o_sch2[i].end<<" speed "<<o_sch2[i].speed<<endl;
}
*/
#endif
#if(STATIC_ENABLE)
t_util=optimize_static(&s_speed,&tasks,MIN_SPEED,MAX_SPEED);
scale(&scaled_static,&tasks,&s_speed);
edf_schedule(&scaled_static,&edf_static);
thermal_optimal=5;
compute_profile(&edf_static, &scaled_static,t_util);
#endif
#if(MATLAB_ENABLE)
t_util=optimize_matlab(&m_speed,&tasks,MIN_SPEED,MAX_SPEED);
scale(&scaled_matlab,&tasks,&m_speed);
edf_schedule(&scaled_matlab,&edf_matlab);
thermal_optimal=6;
compute_profile(&edf_matlab, &scaled_matlab,t_util);
#endif
#if(NOCONS_ENABLE)
speed_scale(&scaled_tasks,&speeds,&tasks,1.0);
edf_schedule(&scaled_tasks,&edf2);
thermal_optimal=7;
compute_profile(&edf2,&scaled_tasks,t_util);
#endif
#if(SPEED_DEBUG)
for(int i=0;i<tasks.size();i++)
{
cout<<"matlab: "<<m_speed[i]<<" max first:"<<h_speed[i]<<" static speed:<<"<<s_speed[i]<<" nocons speed:"<< speeds[i]<<endl;
}
#endif
#if(ENABLE_PRINTS)
cout<<"max first taskset"<<endl;
for(int i=0;i<scaled_max_first.size();i++)
{
cout<<"task "<<i<<" computation time:"<<scaled_max_first[i].computation_time<<" period:"<<scaled_max_first[i].period<<" power:"<<scaled_max_first[i].power<<endl;
}
cout<<"static speed taskset"<<endl;
for(int i=0;i<scaled_max_first.size();i++)
{
cout<<"task "<<i<<" computation time:"<<scaled_static[i].computation_time<<" period:"<<scaled_static[i].period<<" power:"<<scaled_static[i].power<<endl;
}
#endif
#if(ENABLE_PRINTS)
for(unsigned int i=0;i<speeds.size();i++)
{
cout<<"speed for task: "<<i<<"|"<<speeds[i]<<endl;
}
#endif
for (unsigned int i = 0; i < tasks.size(); i++) {
// tasks[i].stat_stream->clear();
// tasks[i].stat_stream->close();
// util1=util1+(float)tasks[i].computation_time/(float)tasks[i].period;
// util2=util2+(float)scaled_tasks[i].computation_time/(float)scaled_tasks[i].period;
// util3=util3+(float)discrete_scaled[i].computation_time/(float)discrete_scaled[i].period;
}
#if(ENABLE_PRINTS)
// cout<<"util "<<util1<<"|"<<util2<<"|"<<util3<<endl;
// cout<<"globally optimal power"<<g_power<<endl;
//cout<<"computed thermally optimal schedule"<<endl;
#endif
tasks.clear();
edf.clear();
scaled_tasks.clear();
speeds.clear();
edf2.clear();
discrete_scaled.clear();
edf3.clear();
possible_speeds.clear();
tasksets.clear();
opt.clear();
possible_speeds.clear();
slacks.clear();
h_speed.clear();
s_speed.clear();
m_speed.clear();
i_speed.clear();
i_speed_temp.clear();
scaled_max_first.clear();
scaled_static.clear();
scaled_matlab.clear();
edf_max_first.clear();
edf_static.clear();
edf_matlab.clear();
edl2.clear();
edl.clear();
i_schedule.clear();
o_sch.clear();
}
#if(MATLAB_ENABLE)
engClose(ep);
#endif
}
int main(int argc, char** argv)
{
//OpenMesh::IO::Options r_options, w_options;
//string tmeshfile = "C:\\Users\\duan_qi\\Desktop\\Reconstruction\\PhotoSynthToolkit11\\templeRing\\pmvs\\models\\pmvs_options.txt.ply";
//string fmeshfile = "C:\\Users\\duan_qi\\Desktop\\Reconstruction\\PhotoSynthToolkit11\\templeRing\\pmvs\\models\\pmvs_options.txt.filtered.off";
//r_options.set(OpenMesh::IO::Options::VertexColor); w_options.set(OpenMesh::IO::Options::VertexColor);
//OpenMesh::IO::read_mesh(ObjTriMesh, tmeshfile, r_options);
//if ( !r_options.check( OpenMesh::IO::Options::VertexColor ) ) {
// cout << "Color is not loaded.." << endl;
//}
//int rcount = 0;
//for (MyMesh::VertexIter v_it = ObjTriMesh.vertices_begin(); v_it != ObjTriMesh.vertices_end(); ++ v_it) {
// OpenMesh::Vec3f tColor;
// tColor[0] = ObjTriMesh.color(v_it).data()[0];
// tColor[1] = ObjTriMesh.color(v_it).data()[1];
// tColor[2] = ObjTriMesh.color(v_it).data()[2];
// if (tColor.norm() < 40) {
// ObjTriMesh.delete_vertex(v_it, false);
// rcount ++;
// }
//}
//ObjTriMesh.garbage_collection();
//OpenMesh::IO::write_mesh(ObjTriMesh, fmeshfile, w_options);
ParseParam(argc,argv, MOptions);
ScaleDelta = MOptions.ScaleDelta;
AnisotropicLaplace = MOptions.AnisotropicLaplace;
RecordColor = MOptions.RecordColor;
if (MOptions.UseMatlabSolver) {
cout << "Use matlab solver for linear equations." << endl;
if (!(m_ep = engOpen("\0"))) {
std::cout << "Can not start Matlab engine" << std::endl;
return false;
}
engSetVisible(m_ep, false);
}
ScaleDelta?cout<<"Scale delta P each time. ":cout<<" "; AnisotropicLaplace?cout<<"Using anisotropic laplacian term.":cout<<" ";
RecordColor?cout<<"Record vertex color to mesh. ":cout<<" "; cout << endl;
path = MOptions.DirName;
printf("Number of threads %d\n",omp_get_num_procs());
omp_set_num_threads(omp_get_num_procs());
omp_set_num_threads(8);
double timer_start = (double)cv::getTickCount();
if (!FileExisted( (MOptions.DirName + "InitialPoissonModel.ply").c_str() )) {
if (!LoadMVSResult())
{
readMiddleBuryData2(MOptions.DirName);
chooseStereoPairs();
stereoMatching();
printf("\nTime = %lfs\n",((double)cv::getTickCount()-timer_start)/cv::getTickFrequency());
buildTracks();
printf("\nTime = %lfs\n",((double)cv::getTickCount()-timer_start)/cv::getTickFrequency());
//writeToOBJ();
//printf("\nTime = %lfs\n",((double)getTickCount()-timer_start)/getTickFrequency());
calNormals();
printf("\nTime = %lfs\n",((double)cv::getTickCount()-timer_start)/cv::getTickFrequency());
verifyTracks();
printf("\nTime = %lfs\n",((double)cv::getTickCount()-timer_start)/cv::getTickFrequency());
SaveMVSResult();
}
writeToNPTS2(tracks,(MOptions.DirName + "PointInfo.npts"));
//outputVerticesWithNormals(tracks,(MOptions.DirName + "PointModel.ply"));
printf("\nTime = %lfs\n",((double)cv::getTickCount()-timer_start)/cv::getTickFrequency());
//printf("\nTime = %lfs\n",((double)cv::getTickCount()-timer_start)w/cv::getTickFrequency());
string PlyModelName = MOptions.DirName + "PoissonModel";
PoissonReconstruction((MOptions.DirName + "PointInfo.npts"), PlyModelName);
MyCopyFile(PlyModelName, (MOptions.DirName + "InitialPoissonModel.ply"));
}
readMiddleBuryData2(MOptions.DirName);
//read the initial generated Poisson object model
OpenMesh::IO::Options read_options, write_options;
string ObjName = MOptions.DirName;
if (ObjName.find_last_of("\\") == ObjName.length()-1) {
ObjName.erase(ObjName.end()-1);
}
ObjName = ObjName.substr(ObjName.find_last_of("\\")+1, ObjName.length()); MOptions.meshname = ObjName;
string meshfile = (MOptions.DirName + ObjName +"-remeshed.off");
if (!FileExisted(meshfile.c_str())) {
string cmd = "meshfix.exe "; cmd += MOptions.DirName + "InitialPoissonModel.ply";
WinExec(cmd.c_str(),0);
::Sleep(5000);
MyMoveFile(MOptions.DirName + "InitialPoissonModel_fixed.off", MOptions.DirName + "temp.off");
for (int i = 0; i < 5; ++ i) {
cmd = "meshfix.exe "; cmd += MOptions.DirName + "temp.off";
WinExec(cmd.c_str(),0);
::Sleep(5000);
MyMoveFile(MOptions.DirName + "temp_fixed.off", MOptions.DirName + "temp.off");
}
MyMoveFile(MOptions.DirName + "temp.off", meshfile);
}
fstream fin(meshfile,ios::in); string tag, temp_str;
fin>>tag; fin>>temp_str;
if (temp_str[0] == '#') {
// need to load and rewrite the off file
char buffer[100];
fin.getline(buffer, 100); fin.getline(buffer, 100);
fstream fout(meshfile+"tmp",ios::out);
int vnum, trinum, flag; double x, y, z; int a1, v0, v1, v2;
fout<<tag<<endl;
fin>>vnum>>trinum>>flag; fout<<vnum<<" "<<trinum<<" "<<flag<<endl;
for (int i = 0; i < vnum; ++ i) {
fin>>x>>y>>z; fout<<x<<" "<<y<<" "<<z<<endl;
}
for (int i = 0; i < trinum; ++i) {
fin>>a1>>v0>>v1>>v2; fout<<a1<<" "<<v0<<" "<<v1<<" "<<v2<<endl;
}
fout.close();
MyMoveFile(meshfile+"tmp", meshfile);
} fin.close();
void GraphNodeCtr::run()
{
Logger<<"Start!.\n";
IndexType nbCluster = 5;
//read_label_file("labelInfo.txt");
//read_label_file("labelInfo_edit.txt");
//read_label_file("labelInfo_28.txt");
//read_corres_file("corInfo.txt");
//read_label_file("labelInfo_456.txt");
//read_corres_file("corInfo_456.txt");
read_label_file("tot_labels_dancer.txt");//dancer girl_f(91-110)
read_corres_file("tot_cor_dancer.txt");
pca_box_ctr();
Engine* ep;
if (! (ep = engOpen(NULL)) )
{
Logger<< "Can't not start Matlab engine.\n";
return;
}
// set buffer to display result
IndexType result_buffer_size = 1024*1000;
char* result_buffer = new char[result_buffer_size];
engOutputBuffer(ep, result_buffer, result_buffer_size);
//Get the executable file's path
char cur_path[FILENAME_MAX];
if (!get_current_dir(cur_path, sizeof(cur_path)))
{
return;
}
cur_path[sizeof(cur_path) - 1] = '\0';
strcat(cur_path,"\\nCut");
char cd_cur_path[FILENAME_MAX + 3] = "cd ";
strcat(cd_cur_path, cur_path);
engEvalString(ep, cd_cur_path );
IndexType n = cur_graph_index_;
mxArray *mx_distMat = NULL;
numeric::float64* dm_buffer;
dm_buffer = new numeric::float64[n*n];
mx_distMat = mxCreateDoubleMatrix(n,n,mxREAL);
ScalarType a_w = 0.01f;
//ScalarType avg_a_dis ,a_mid;
//compute_mid_and_avg(avg_a_dis,a_mid,&GraphNodeCtr::dist_inside_frame);
//Logger<<"avg and mid of adjacency"<<avg_a_dis<<" "<<a_mid<<endl;
//ScalarType avg_cor_dis,cor_dis;
//compute_mid_and_avg(avg_cor_dis,cor_dis,&GraphNodeCtr::dist_between_frame);
//Logger<<"avg and mid of corresponcdence"<<avg_cor_dis<<" "<<cor_dis<<endl;
for (int i=0; i<n;i++)
{
//dm_buffer[i*(n+1)] = exp(-a_w * a_w);
dm_buffer[i*(n+1)] = a_w;
for (int j=i+1; j<n; j++)
{
//ScalarType dist = weight2nodes(node_vec[i],node_vec[j]);
ScalarType dist = weight2nodes(node_vec[i],node_vec[j],a_w);
dm_buffer[i*n+j] = dm_buffer[j*n+i] = (numeric::float64)dist;
}
}
//FILE *out_file = fopen("disMat","w");
//for (int i=0;i<n;i++)
//{
// for (int j=0;j<n;j++)
// {
// //fprintf(out_file,"%lf ",dm_buffer[i*n+j]);
// fprintf(out_file,"%lf ",disMat(i,j));
// }
// fprintf(out_file,"\n");
//}
//fclose(out_file);
//FILE *in_file = fopen("weight_1_9","r");
//for (int i=0;i<n;i++)
//{
// for (int j=0;j<n;j++)
// {
// fscanf(in_file,"%lf",&dm_buffer[i*n+j]);
// }
//}
//fclose(in_file);
memcpy((char*)mxGetPr(mx_distMat),(char*)dm_buffer,n*n*sizeof(numeric::float64));
delete [] dm_buffer;
engPutVariable(ep,"W",mx_distMat);
char cmd_buf[128];
sprintf(cmd_buf,"[NcutDiscrete,NcutEigenvectors,NcutEigenvalues] = ncutW(W,%d);",nbCluster);
engEvalString(ep,cmd_buf);
//Display output information
Logger<<result_buffer<<std::endl;
mxArray *mx_NcutDiscrete = NULL;
mx_NcutDiscrete = engGetVariable(ep,"NcutDiscrete");
numeric::float64 *ncutDiscrete = mxGetPr(mx_NcutDiscrete);
IndexType k=0;
for ( IndexType i=0;i<nbCluster;i++ )
{
for (IndexType j=0;j<n;j++)
{
if ( ncutDiscrete[k++]!=0 )
{
node_vec[j]->graph_label = i;
}
}
}
//Visualize
SampleSet &smp_set = SampleSet::get_instance();
IndexType frames[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
for ( IndexType i=0; i<3;i++ )
{
for (IndexType j=0; j<smp_set[frames[i]].num_vertices(); j++)
{
smp_set[frames[i]][j].set_visble(false);
}
}
for ( IndexType i=0; i<n;i++ )
{
GraphCutNode &node = *(node_vec[i]);
smp_set[node.frame][node.index].set_label(node.graph_label);
smp_set[node.frame][node.index].set_visble(true);
}
Logger<<"finished\n";
}
int main()
{
Engine *ep;
mxArray *T = NULL, *result = NULL;
char buffer[BUFSIZE+1];
// double time[10] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
double time[6] = {
1.2, 0.4,
2.1, 0.8,
1.9, 0.1,
};
/*
* Call engOpen with a NULL string. This starts a MATLAB process
* on the current host using the command "matlab".
*/
if (!(ep = engOpen(""))) {
fprintf(stderr, "\nCan't start MATLAB engine\n");
return EXIT_FAILURE;
}
/*
* PART I
*
* For the first half of this demonstration, we will send data
* to MATLAB, analyze the data, and plot the result.
*/
/*
* Create a variable for our data
*/
// T = mxCreateDoubleMatrix(3, 2, mxREAL);
// memcpy((void *)mxGetPr(T), (void *)time, sizeof(time));
// /*
// * Place the variable T into the MATLAB workspace
// */
// engPutVariable(ep, "T", T);
std::string data_path = "X.csv";
std::string cmd = std::string("X = csvread('" + data_path + "');");
engEvalString(ep,cmd.c_str());
// engEvalString(ep, "X = csvread('X.csv');");
engEvalString(ep, "X = X(:,1:end-1);");
// /*
// * Evaluate a function of time, distance = (1/2)g.*t.^2
// * (g is the acceleration due to gravity)
// */
// engEvalString(ep, "D = .5.*(-9.8).*T.^2;");
// /*
// * Plot the result
// */
// engEvalString(ep, "plot(T,D);");
// engEvalString(ep, "title('Position vs. Time for a falling object');");
// engEvalString(ep, "xlabel('Time (seconds)');");
// engEvalString(ep, "ylabel('Position (meters)');");
engEvalString(ep, "[~,newX] = princomp(X);");
// engEvalString(ep, "newT = T';");
engEvalString(ep, "csvwrite('newX.csv',newX);");
// /*
// * use fgetc() to make sure that we pause long enough to be
// * able to see the plot
// */
// printf("Hit return to continue\n\n");
// fgetc(stdin);
/*
* We're done for Part I! Free memory, close MATLAB figure.
*/
printf("Done for Part I.\n");
mxDestroyArray(T);
engEvalString(ep, "close;");
/*
* We're done! Free memory, close MATLAB engine and exit.
*/
printf("Done!\n");
engClose(ep);
return EXIT_SUCCESS;
}
EXPORT bool glx_init(glxlink *mod)
{
gl_verbose("initializing matlab link");
gl_verbose("PATH=%s", getenv("PATH"));
// initialize matlab engine
MATLABLINK *matlab = (MATLABLINK*)mod->get_data();
matlab->status = 0;
#ifdef WIN32
if ( matlab->command )
matlab->engine = engOpen(matlab->command);
else
matlab->engine = engOpenSingleUse(NULL,NULL,&matlab->status);
if ( matlab->engine==NULL )
{
gl_error("matlab engine start failed, status code is '%d'", matlab->status);
return false;
}
#else
matlab->engine = engOpen(matlab->command);
if ( matlab->engine==NULL )
{
gl_error("matlab engine start failed");
return false;
}
#endif
// set the output buffer
if ( matlab->output_buffer!=NULL )
engOutputBuffer(matlab->engine,matlab->output_buffer,(int)matlab->output_size);
// setup matlab engine
engSetVisible(matlab->engine,window_show(matlab));
gl_debug("matlab link is open");
// special values needed by matlab
mxArray *ts_never = mxCreateDoubleScalar((double)(TIMESTAMP)TS_NEVER);
engPutVariable(matlab->engine,"TS_NEVER",ts_never);
mxArray *ts_error = mxCreateDoubleScalar((double)(TIMESTAMP)TS_INVALID);
engPutVariable(matlab->engine,"TS_ERROR",ts_error);
mxArray *gld_ok = mxCreateDoubleScalar((double)(bool)true);
engPutVariable(matlab->engine,"GLD_OK",gld_ok);
mxArray *gld_err = mxCreateDoubleScalar((double)(bool)false);
engPutVariable(matlab->engine,"GLD_ERROR",gld_err);
// set the workdir
if ( strcmp(matlab->workdir,"")!=0 )
{
#ifdef WIN32
_mkdir(matlab->workdir);
#else
mkdir(matlab->workdir,0750);
#endif
if ( matlab->workdir[0]=='/' )
matlab_exec(matlab,"cd '%s'", matlab->workdir);
else
matlab_exec(matlab,"cd '%s/%s'", getcwd(NULL,0),matlab->workdir);
}
// run the initialization command(s)
if ( matlab->init )
{
mxArray *ans = matlab_exec(matlab,"%s",matlab->init);
if ( ans && mxIsDouble(ans) && (bool)*mxGetPr(ans)==false )
{
gl_error("matlab init failed");
return false;
}
else if ( ans && mxIsChar(ans) )
{
int buflen = (mxGetM(ans) * mxGetN(ans)) + 1;
char *string =(char*)malloc(buflen);
int status_error = mxGetString(ans, string, buflen);
if (status_error == 0)
{
gl_error("'%s'",string);
return false;
}
else
{
gl_error("Did not catch Matlab error");
return false;
}
}
}
if ( matlab->rootname!=NULL )
{
// build gridlabd data
mwSize dims[] = {1,1};
mxArray *gridlabd_struct = mxCreateStructArray(2,dims,0,NULL);
///////////////////////////////////////////////////////////////////////////
// build global data
LINKLIST *item;
mxArray *global_struct = mxCreateStructArray(2,dims,0,NULL);
for ( item=mod->get_globals() ; item!=NULL ; item=mod->get_next(item) )
{
char *name = mod->get_name(item);
GLOBALVAR *var = mod->get_globalvar(item);
mxArray *var_struct = NULL;
mwIndex var_index;
if ( var==NULL ) continue;
// do not map module or structured globals
if ( strchr(var->prop->name,':')!=NULL )
{
// ignore module globals here
}
else if ( strchr(var->prop->name,'.')!=NULL )
{
char struct_name[256];
if ( sscanf(var->prop->name,"%[^.]",struct_name)==0 )
{
gld_property prop(var);
var_index = mxAddField(global_struct,prop.get_name());
var_struct = matlab_create_value(&prop);
if ( var_struct!=NULL )
{
//mod->add_copyto(var->prop->addr,mxGetData(var_struct));
mxSetFieldByNumber(global_struct,0,var_index,var_struct);
}
}
}
else // simple data
{
gld_property prop(var);
var_index = mxAddField(global_struct,prop.get_name());
var_struct = matlab_create_value(&prop);
if ( var_struct!=NULL )
{
//mod->add_copyto(var->prop->addr,mxGetData(var_struct));
mxSetFieldByNumber(global_struct,0,var_index,var_struct);
}
}
// update export list
if ( var_struct!=NULL )
{
mod->set_addr(item,(void*)var_struct);
mod->set_index(item,(size_t)var_index);
}
}
// add globals structure to gridlabd structure
mwIndex gridlabd_index = mxAddField(gridlabd_struct,"global");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,global_struct);
///////////////////////////////////////////////////////////////////////////
// build module data
dims[0] = dims[1] = 1;
mxArray *module_struct = mxCreateStructArray(2,dims,0,NULL);
// add modules
for ( MODULE *module = callback->module.getfirst() ; module!=NULL ; module=module->next )
{
// create module info struct
mwIndex dims[] = {1,1};
mxArray *module_data = mxCreateStructArray(2,dims,0,NULL);
mwIndex module_index = mxAddField(module_struct,module->name);
mxSetFieldByNumber(module_struct,0,module_index,module_data);
// create version info struct
const char *version_fields[] = {"major","minor"};
mxArray *version_data = mxCreateStructArray(2,dims,sizeof(version_fields)/sizeof(version_fields[0]),version_fields);
mxArray *major_data = mxCreateDoubleScalar((double)module->major);
mxArray *minor_data = mxCreateDoubleScalar((double)module->minor);
mxSetFieldByNumber(version_data,0,0,major_data);
mxSetFieldByNumber(version_data,0,1,minor_data);
// attach version info to module info
mwIndex version_index = mxAddField(module_data,"version");
mxSetFieldByNumber(module_data,0,version_index,version_data);
}
gridlabd_index = mxAddField(gridlabd_struct,"module");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,module_struct);
///////////////////////////////////////////////////////////////////////////
// build class data
dims[0] = dims[1] = 1;
mxArray *class_struct = mxCreateStructArray(2,dims,0,NULL);
gridlabd_index = mxAddField(gridlabd_struct,"class");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,class_struct);
mwIndex class_id[1024]; // index into class struct
memset(class_id,0,sizeof(class_id));
// add classes
for ( CLASS *oclass = callback->class_getfirst() ; oclass!=NULL ; oclass=oclass->next )
{
// count objects in this class
mwIndex dims[] = {0,1};
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL || obj->oclass!=oclass ) continue;
dims[0]++;
}
if ( dims[0]==0 ) continue;
mxArray *runtime_struct = mxCreateStructArray(2,dims,0,NULL);
// add class
mwIndex class_index = mxAddField(class_struct,oclass->name);
mxSetFieldByNumber(class_struct,0,class_index,runtime_struct);
// add properties to class
for ( PROPERTY *prop=oclass->pmap ; prop!=NULL && prop->oclass==oclass ; prop=prop->next )
{
mwIndex dims[] = {1,1};
mxArray *property_struct = mxCreateStructArray(2,dims,0,NULL);
mwIndex runtime_index = mxAddField(runtime_struct,prop->name);
mxSetFieldByNumber(runtime_struct,0,runtime_index,property_struct);
}
// add objects to class
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL || obj->oclass!=oclass ) continue;
mwIndex index = class_id[obj->oclass->id]++;
// add properties to class
for ( PROPERTY *prop=oclass->pmap ; prop!=NULL && prop->oclass==oclass ; prop=prop->next )
{
gld_property p(obj,prop);
mxArray *data = matlab_create_value(&p);
mxSetField(runtime_struct,index,prop->name,data);
}
// update export list
mod->set_addr(item,(void*)runtime_struct);
mod->set_index(item,(size_t)index);
}
}
///////////////////////////////////////////////////////////////////////////
// build the object data
dims[0] = 0;
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
if ( mod->get_object(item)!=NULL ) dims[0]++;
}
dims[1] = 1;
memset(class_id,0,sizeof(class_id));
const char *objfields[] = {"name","class","id","parent","rank","clock","valid_to","schedule_skew",
"latitude","longitude","in","out","rng_state","heartbeat","lock","flags"};
mxArray *object_struct = mxCreateStructArray(2,dims,sizeof(objfields)/sizeof(objfields[0]),objfields);
mwIndex n=0;
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL ) continue;
class_id[obj->oclass->id]++; // index into class struct
const char *objname[] = {obj->name&&isdigit(obj->name[0])?NULL:obj->name};
const char *oclassname[] = {obj->oclass->name};
if (obj->name) mxSetFieldByNumber(object_struct,n,0,mxCreateCharMatrixFromStrings(mwSize(1),objname));
mxSetFieldByNumber(object_struct,n,1,mxCreateCharMatrixFromStrings(mwSize(1),oclassname));
mxSetFieldByNumber(object_struct,n,2,mxCreateDoubleScalar((double)class_id[obj->oclass->id]));
if (obj->parent) mxSetFieldByNumber(object_struct,n,3,mxCreateDoubleScalar((double)obj->parent->id+1));
mxSetFieldByNumber(object_struct,n,4,mxCreateDoubleScalar((double)obj->rank));
mxSetFieldByNumber(object_struct,n,5,mxCreateDoubleScalar((double)obj->clock));
mxSetFieldByNumber(object_struct,n,6,mxCreateDoubleScalar((double)obj->valid_to));
mxSetFieldByNumber(object_struct,n,7,mxCreateDoubleScalar((double)obj->schedule_skew));
if ( isfinite(obj->latitude) ) mxSetFieldByNumber(object_struct,n,8,mxCreateDoubleScalar((double)obj->latitude));
if ( isfinite(obj->longitude) ) mxSetFieldByNumber(object_struct,n,9,mxCreateDoubleScalar((double)obj->longitude));
mxSetFieldByNumber(object_struct,n,10,mxCreateDoubleScalar((double)obj->in_svc));
mxSetFieldByNumber(object_struct,n,11,mxCreateDoubleScalar((double)obj->out_svc));
mxSetFieldByNumber(object_struct,n,12,mxCreateDoubleScalar((double)obj->rng_state));
mxSetFieldByNumber(object_struct,n,13,mxCreateDoubleScalar((double)obj->heartbeat));
mxSetFieldByNumber(object_struct,n,14,mxCreateDoubleScalar((double)obj->lock));
mxSetFieldByNumber(object_struct,n,15,mxCreateDoubleScalar((double)obj->flags));
n++;
}
gridlabd_index = mxAddField(gridlabd_struct,"object");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,object_struct);
///////////////////////////////////////////////////////////////////////////
// post the gridlabd structure
matlab->root = gridlabd_struct;
engPutVariable(matlab->engine,matlab->rootname,matlab->root);
}
///////////////////////////////////////////////////////////////////////////
// build the import/export data
for ( LINKLIST *item=mod->get_exports() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECTPROPERTY *objprop = mod->get_export(item);
if ( objprop==NULL ) continue;
// add to published items
gld_property prop(objprop->obj,objprop->prop);
item->addr = (mxArray*)matlab_create_value(&prop);
engPutVariable(matlab->engine,item->name,(mxArray*)item->addr);
}
for ( LINKLIST *item=mod->get_imports() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECTPROPERTY *objprop = mod->get_import(item);
if ( objprop==NULL ) continue;
// check that not already in export list
LINKLIST *export_item;
bool found=false;
for ( export_item=mod->get_exports() ; export_item!=NULL ; export_item=mod->get_next(export_item) )
{
OBJECTPROPERTY *other = mod->get_export(item);
if ( memcmp(objprop,other,sizeof(OBJECTPROPERTY)) )
found=true;
}
if ( !found )
{
gld_property prop(objprop->obj,objprop->prop);
item->addr = (mxArray*)matlab_create_value(&prop);
engPutVariable(matlab->engine,item->name,(mxArray*)item->addr);
}
}
static int32 matlab_flag = 1;
gl_global_create("MATLAB",PT_int32,&matlab_flag,PT_ACCESS,PA_REFERENCE,PT_DESCRIPTION,"indicates that MATLAB is available",NULL);
mod->last_t = gl_globalclock;
return true;
}
static int
server(char **argv, char *pname[2], int p[2])
{
Engine *ep;
FILE *f;
char buf[4096], buf1[4096], *msg, *s, *t;
int rc;
#if 0/*def SERVER_DEBUG*/
printf("Server got\tpname[0] = \"%s\"\nand\t\tpname[1] = \"%s\"\n",
pname[0], pname[1]);
if (*argv) {
int i;
printf("Args for MATLAB to interpret:\n");
for(i = 0; argv[i]; i++)
printf("\t\"%s\"\n", argv[i]);
}
#endif
if (exists(pname[0], 1) || exists(pname[1], 1))
return 1;
if (mkfifo(pname[0], 0600))
return mkfifo_fail(pname[0]);
if (mkfifo(pname[1], 0600)) {
unlink(pname[0]);
return mkfifo_fail(pname[1]);
}
s = *argv;
//if(s){ printf("%s\n",s); fflush(stdout);}
ep = engOpen(s ? s : "matlab -logfile engine.log");
if (!ep) {
Squawk("could not start MATLAB\n");
return 1;
}
/*DEBUG*/engOutputBuffer(ep, mbuf, sizeof(mbuf)-1);
if (s)
while(s = *++argv)
engEvalString(ep, s);
if (p[1] >= 0) {
close(p[0]);
write(p[1], "OK\n", 3);
close(p[1]);
}
rc = 1;
for(;;) {
f = fopen(pname[0], "r");
if (!f)
break;
s = fgets(buf, sizeof(buf), f);
if (!s) {
fclose(f);
break;
}
trim(s);
if (!*s) {
Squawk("server: empty parameters_file name\n");\
bailout:
fclose(f);
break;
}
if (!strcmp(s,"quit")) {
rc = 0;
goto bailout;
}
t = fgets(buf1, sizeof(buf1), f);
fclose(f);
if (!t) {
Squawk("server expected 2 lines from \"%s\"; only got 1.\n",
pname[0]);
break;
}
trim(t);
msg = process(ep, s, t) ? "evaluation error" : "results_file written";
f = fopen(pname[1],"w");
if (!f) {
Squawk("Could not open pipe2 file \"%s\"\n", pname[1]);
break;
}
fprintf(f, "%s\n", msg);
fclose(f);
}
engClose(ep);
unlink(pname[0]);
unlink(pname[1]);
return rc;
}
/* Function: main
*
* Description: Main function to extract frames from 2 video files and runs the
* rest of the program using them. Takes at least 10 commandline arguments,
* in the order:
* <number of camera pairs>
* <pair 1 camera 1 filename>
* <pair 1 camera 1 frame number>
* <pair 1 camera 2 filename>
* <pair 1 camera 2 frame number>
* <pair 1 view name>
* <pair 1 camera coefficients filename>
* ...
* <TPS smoothing parameter>
* <feature detector>
* <output directory>
*
* Parameters:
* argc: number of commandline arguments
* argv: string array of commandline arguments
*
* Returns: 0 on success, 1 on error.
*/
int main (int argc, char *argv[])
{
// check for minimum number of commandline arguments
if (argc < 11)
{
printf("Usage:\nvideos\n\t<number of camera pairs>\n\t<pair 1 camera 1 filename>\n\t<pair 1 camera 1 frame number>\n\t<pair 1 camera 2 filename>\n\t<pair 1 camera 2 frame number>\n\t<pair 1 view name>\n\t<pair 1 camera coefficients filename>\n\t...\n\t<TPS smoothing parameter>\n\t<feature detector>\n\t<output directory>\n");
exit(1);
}
// get the number of camera pairs
int numCameraPairs = atoi(argv[1]);
if (numCameraPairs <= 0)
{
printf("Invalid number of camera pairs.\n");
exit(1);
}
// number of commandline arguments should be numCameraPairs*6 + 5
if (argc != numCameraPairs*6 + 5)
{
printf("Usage:\nvideos\n\t<number of camera pairs>\n\t<pair 1 camera 1 filename>\n\t<pair 1 camera 1 frame number>\n\t<pair 1 camera 2 filename>\n\t<pair 1 camera 2 frame number>\n\t<pair 1 view name>\n\t<pair 1 camera coefficients filename>\n\t...\n\t<TPS smoothing parameter>\n\t<feature detector>\n\t<output directory>\n");
exit(1);
}
// allocate memory to store information for camera pairs
char **camera1Filenames = (char **)malloc(numCameraPairs * sizeof(char *));
int *camera1Frames = (int *)malloc(numCameraPairs * sizeof(int));
if (camera1Filenames == NULL || camera1Frames == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
char **camera2Filenames = (char **)malloc(numCameraPairs * sizeof(char *));
int *camera2Frames = (int *)malloc(numCameraPairs * sizeof(int));
if (camera2Filenames == NULL || camera2Frames == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
char **cameraNames = (char **)malloc(numCameraPairs * sizeof(char *));
if (cameraNames == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
char **cameraCoefficientsFilenames = (char **)malloc(numCameraPairs * sizeof(char *));
if (cameraCoefficientsFilenames == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
int argIndex = 2;
for (int i = 0; i < numCameraPairs; i++)
{
camera1Filenames[i] = argv[argIndex];
camera1Frames[i] = atoi(argv[argIndex+1]);
camera2Filenames[i] = argv[argIndex+2];
camera2Frames[i] = atoi(argv[argIndex+3]);
cameraNames[i] = argv[argIndex+4];
cameraCoefficientsFilenames[i] = argv[argIndex+5];
// make sure input video frames are valid
if (camera1Frames[i] <= 0)
{
printf("Invalid frame number for pair %d camera 1.\n", i+1);
exit(1);
}
if (camera2Frames[i] <= 0)
{
printf("Invalid frame number for pair %d camera 1.\n", i+1);
exit(1);
}
// make sure input filenames are valid
if (!fileExists(camera1Filenames[i]))
{
printf("Could not open pair %d camera 1 video file.\n", i+1);
exit(1);
}
if (!fileExists(camera2Filenames[i]))
{
printf("Could not open pair %d camera 2 video file.\n", i+1);
exit(1);
}
if (!fileExists(cameraCoefficientsFilenames[i]))
{
printf("Could not open pair %d camera coefficients file.\n", i+1);
exit(1);
}
argIndex += 6;
}
double regularization = atof(argv[argIndex]);
char *featureDetector = argv[argIndex+1];
char *outputDirectory = argv[argIndex+2];
// make sure input feature dectector is recognized
if (strcasecmp(featureDetector, FAST_FEATURE_DETECTOR) &&
strcasecmp(featureDetector, GFTT_FEATURE_DETECTOR) &&
strcasecmp(featureDetector, SURF_FEATURE_DETECTOR) &&
strcasecmp(featureDetector, SIFT_FEATURE_DETECTOR) &&
strcasecmp(featureDetector, SPEEDSIFT_FEATURE_DETECTOR))
{
printf("Feature Detector not recognized. Please select from the following:\n\t%s\n\t%s\n\t%s\n\t%s\n\t%s\n",
FAST_FEATURE_DETECTOR,
GFTT_FEATURE_DETECTOR,
SURF_FEATURE_DETECTOR,
SIFT_FEATURE_DETECTOR,
SPEEDSIFT_FEATURE_DETECTOR);
exit(1);
}
// make sure regularization parameter for TPS is valid
if (regularization <= 0.0 || regularization == HUGE_VAL)
{
printf("Invalid smoothing parameter value.\n");
exit(1);
}
// if output directory doesn't end with '/' char, append '/' to the string.
// this is so we can later append a filename to the directory when we want
// to write the file to that directory
if (outputDirectory[strlen(outputDirectory)-1] != '/')
{
strcat(outputDirectory, "/");
}
DIR *dir = opendir(outputDirectory);
// if output directory does not exist, create it with correct permissions
if (dir == NULL)
{
printf("Output directory does not exist.\n");
if (mkdir(outputDirectory, S_IRWXO | S_IRWXG | S_IRWXU))
{
printf("Could not create output directory.\n");
exit(1);
}
else
{
printf("Created output directory.\n");
}
}
else
{
closedir(dir);
}
// string for the MATLAB commands
char command[500];
Engine *matlabEngine;
// open MATLAB engine
if (!(matlabEngine = engOpen("\0")))
{
printf("Can't start MATLAB engine\n");
exit(1);
}
// create MATLAB arrays to retrieve values from MATLAB workspace
mxArray **c1ImageData = (mxArray **)malloc(numCameraPairs * sizeof(mxArray *));
mxArray **c1ImageDimensions = (mxArray **)malloc(numCameraPairs * sizeof(mxArray *));
mxArray **c1ImagePaddedWidths = (mxArray **)malloc(numCameraPairs * sizeof(mxArray *));
if (c1ImageData == NULL || c1ImageDimensions == NULL || c1ImagePaddedWidths == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
mxArray **c2ImageData = (mxArray **)malloc(numCameraPairs * sizeof(mxArray *));
mxArray **c2ImageDimensions = (mxArray **)malloc(numCameraPairs * sizeof(mxArray *));
mxArray **c2ImagePaddedWidths = (mxArray **)malloc(numCameraPairs * sizeof(mxArray *));
if (c2ImageData == NULL || c2ImageDimensions == NULL || c2ImagePaddedWidths == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
// create IplImage arrays for camera 1 and 2 images for all camera pairs
IplImage **c1Images = (IplImage **)malloc(numCameraPairs * sizeof(IplImage *));
IplImage **c2Images = (IplImage **)malloc(numCameraPairs * sizeof(IplImage *));
if (c1Images == NULL || c2Images == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
// for each camera pair, get the specified frames from cameras 1 and 2, using
// MATLAB functions
for (int i = 0; i < numCameraPairs; i++)
{
char video1Extension[6];
// get the video file extension for the first video file
if (getVideoFileExtension(camera1Filenames[i], video1Extension) == INVALID_VIDEO_FILE_EXTENSION_ERROR)
{
printf("Video files must be of extension .mrf or .cine.\n");
exit(1);
}
// call appropriate MATLAB function depending on whether video file is .cine
// or .mrf to extract the frame as a MATLAB image. If neither, error.
if ((strcasecmp(video1Extension, ".cine") == 0) || (strcasecmp(video1Extension, ".cin") == 0))
{
sprintf(command, "c1 = cineRead('%s', %d);", camera1Filenames[i], camera1Frames[i]);
engEvalString(matlabEngine, command);
}
else if (strcasecmp(video1Extension, ".mrf") == 0)
{
sprintf(command, "c1 = mrfRead('%s', %d);", camera1Filenames[i], camera1Frames[i]);
engEvalString(matlabEngine, command);
}
else
{
printf("Videos must be of extension .mrf or .cine.\n");
exit(1);
}
char video2Extension[6];
// get the video file extension for the second video file
if (getVideoFileExtension(camera2Filenames[i], video2Extension) == INVALID_VIDEO_FILE_EXTENSION_ERROR)
{
printf("Video files must be of extension .mrf or .cine.\n");
exit(1);
}
// call appropriate MATLAB function depending on whether video file is .cine
// or .mrf to extract the frame as a MATLAB image. If neither, error.
if ((strcasecmp(video2Extension, ".cine") == 0) || (strcasecmp(video2Extension, ".cin") == 0))
{
sprintf(command, "c2 = cineRead('%s', %d);", camera2Filenames[i], camera2Frames[i]);
engEvalString(matlabEngine, command);
}
else if (strcasecmp(video2Extension, ".mrf") == 0)
{
sprintf(command, "c2 = mrfRead('%s', %d);", camera2Filenames[i], camera2Frames[i]);
engEvalString(matlabEngine, command);
}
else
{
printf("Videos must be of extension .mrf or .cine.\n");
exit(1);
}
// call MATLAB function convert_image_matlab2cv_gs on MATLAB images to convert
// them into a format that will be compatible with the IplImages of OpenCV
sprintf(command, "[c1_img c1_dim c1_padded_width] = convert_image_matlab2cv_gs(c1);");
engEvalString(matlabEngine, command);
sprintf(command, "[c2_img c2_dim c2_padded_width] = convert_image_matlab2cv_gs(c2);");
engEvalString(matlabEngine, command);
// retrieve the image data, image dimensions, and image padded width variables
// from MATLAB for both camera images
c1ImageData[i] = engGetVariable(matlabEngine, "c1_img");
c1ImageDimensions[i] = engGetVariable(matlabEngine, "c1_dim");
c1ImagePaddedWidths[i] = engGetVariable(matlabEngine, "c1_padded_width");
c2ImageData[i] = engGetVariable(matlabEngine, "c2_img");
c2ImageDimensions[i] = engGetVariable(matlabEngine, "c2_dim");
c2ImagePaddedWidths[i] = engGetVariable(matlabEngine, "c2_padded_width");
if (c1ImageData[i] == NULL ||
c1ImageDimensions[i] == NULL ||
c1ImagePaddedWidths[i] == NULL)
{
printf("Could not retrieve all necessary information for pair %d camera 1 frame %d from MATLAB.\n", i+1, camera1Frames[i]);
exit(1);
}
if (c2ImageData[i] == NULL ||
c2ImageDimensions[i] == NULL ||
c2ImagePaddedWidths[i] == NULL)
{
printf("Could not retrieve all necessary information for pair %d camera 2 frame %d from MATLAB.\n", i+1, camera2Frames[i]);
exit(1);
}
int c1Status, c2Status;
ImageInfo c1ImageInfo, c2ImageInfo;
// extract the image information from the MATLAB variables in the form of
// mxArrays, and store in ImageInfo structs
c1Status = getInputImageInfo(&c1ImageInfo, c1ImageData[i], c1ImageDimensions[i], c1ImagePaddedWidths[i]);
c2Status = getInputImageInfo(&c2ImageInfo, c2ImageData[i], c2ImageDimensions[i], c2ImagePaddedWidths[i]);
if (c1Status == IMAGE_INFO_DATA_ERROR)
{
printf("Pair %d camera 1: Images must have two dimensions.\n", i+1);
exit(1);
}
if (c2Status == IMAGE_INFO_DATA_ERROR)
{
printf("Pair %d camera 2: Images must have two dimensions.\n", i+1);
exit(1);
}
if (c1Status == IMAGE_INFO_DIMENSIONS_ERROR)
{
printf("Pair %d camera 1: Image dimension vectors must contain two elements: [width, height].\n", i+1);
exit(1);
}
if (c2Status == IMAGE_INFO_DIMENSIONS_ERROR)
{
printf("Pair %d camera 2: Image dimension vectors must contain two elements: [width, height].\n", i+1);
exit(1);
}
if (c1Status == IMAGE_INFO_PADDED_WIDTH_ERROR)
{
printf("Pair %d camera 1: Padded image widths must be scalars.\n", i+1);
exit(1);
}
if (c2Status == IMAGE_INFO_PADDED_WIDTH_ERROR)
{
printf("Pair %d camera 2: Padded image widths must be scalars.\n", i+1);
exit(1);
}
if (c1Status == IMAGE_DEPTH_ERROR)
{
printf("Pair %d camera 1: Images must be represented by 8 or 16-bit integers.\n", i+1);
exit(1);
}
if (c2Status == IMAGE_DEPTH_ERROR)
{
printf("Pair %d camera 2: Images must be represented by 8 or 16-bit integers.\n", i+1);
exit(1);
}
// create IplImages using values in ImageInfo structs
c1Status = createIplImageFromImageInfo(&(c1Images[i]), c1ImageInfo);
c2Status = createIplImageFromImageInfo(&(c2Images[i]), c2ImageInfo);
if (c1Status == OUT_OF_MEMORY_ERROR ||
c2Status == OUT_OF_MEMORY_ERROR)
{
printf("Out of memory error.\n");
exit(1);
}
// flip the images over the y-axis to compensate for the differences in axial
// labels between MATLAB and OpenCV (camera coefficients would not correctly
// correspond to image otherwise)
cvFlip(c1Images[i], NULL, 1);
cvFlip(c2Images[i], NULL, 1);
}
char errorMessage[500];
int numContours;
char **contourNames;
CvPoint3D32f **features3D;
char **validFeatureIndicator;
int *numFeaturesInContours;
char contoursFilename[MAX_FILENAME_LENGTH];
// for each camera pair, run features and triangulation
for (int i = 0; i < numCameraPairs; i++)
{
// create the output 2D features filename as "frame<frame number>_features2D_<camera name>.txt"
char features2DFilename[MAX_FILENAME_LENGTH];
sprintf(features2DFilename, "%sframe%d_features2D_%s.txt", outputDirectory, camera1Frames[i], cameraNames[i]);
// create the output contours filename as "frame<frame number>_contours_<camera name>.txt"
char tempContoursFilename[MAX_FILENAME_LENGTH];
sprintf(tempContoursFilename, "%sframe%d_contours_%s.txt", outputDirectory, camera1Frames[i], cameraNames[i]);
printf("Camera pair for %s view:\n", cameraNames[i]);
// run the features program to extract matching 2D features from the 2
// images within user defined contour
if (features(c1Images[i], c2Images[i], features2DFilename, tempContoursFilename, featureDetector, errorMessage))
{
printf("Features: %s\n", errorMessage);
exit(1);
}
// we only need to save the contour(s) for the first camera pair, as that
// is the one we will use to create the meshes, and we only use the contours
// with the same name(s) in subsequent camera pairs
if (i == 0)
{
strcpy(contoursFilename, tempContoursFilename);
// get the contour names of the contours selected in features function for
// output file naming and contour matching in other camera pairs
int status = readContourNamesFromInputFile(&numContours, &contourNames, contoursFilename);
if (status == INPUT_FILE_OPEN_ERROR)
{
printf("Could not open contour vertices file.\n");
exit(1);
}
if (status == INCORRECT_INPUT_FILE_FORMAT_ERROR)
{
printf("Contour vertices file has incorrect format.\n");
exit(1);
}
if (status == OUT_OF_MEMORY_ERROR)
{
printf("Out of memory error.\n");
exit(1);
}
// allocate memory for 3D features
features3D = (CvPoint3D32f **)malloc(numContours * sizeof(CvPoint3D32f *));
validFeatureIndicator = (char **)malloc(numContours * sizeof(char *));
numFeaturesInContours = (int *)malloc(numContours * sizeof(int));
if (features3D == NULL || numFeaturesInContours == NULL || validFeatureIndicator == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
for (int j = 0; j < numContours; j++)
{
features3D[j] = (CvPoint3D32f *)malloc(MAX_FEATURES_IN_CONTOUR * sizeof(CvPoint3D32f));
validFeatureIndicator[j] = (char *)malloc(MAX_FEATURES_IN_CONTOUR * sizeof(char));
if (features3D[j] == NULL || validFeatureIndicator[j] == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
numFeaturesInContours[j] = 0;
}
}
// create the output 3D features filename as "frame<frame number>_features3D_<camera name>.txt"
char features3DFilename[MAX_FILENAME_LENGTH];
sprintf(features3DFilename, "%sframe%d_features3D_%s.txt", outputDirectory, camera1Frames[i], cameraNames[i]);
// triangulate the matching 2D features between cameras to find the 3D coordinates
// of the features, and remove invalid features
if (triangulation(cameraCoefficientsFilenames[i], features2DFilename, features3DFilename, c1Images[i], errorMessage))
{
printf("Triangulation: %s\n", errorMessage);
exit(1);
}
// if features from triangulation lie within contours that have the same
// names as those defined for the first camera pair, add them to the
// 3D features array for mesh creation
int status = read3DFeaturesFromFileForMatchingContours(features3DFilename, features3D, numFeaturesInContours, numContours, contourNames);
if (status == INPUT_FILE_OPEN_ERROR)
{
printf("Could not open 3D features file.\n");
exit(1);
}
if (status == INVALID_NUM_CONTOURS_ERROR)
{
printf("At least 1 contour region required.\n");
exit(1);
}
if (status == INCORRECT_INPUT_FILE_FORMAT_ERROR)
{
printf("3D features file has incorrect format.\n");
exit(1);
}
}
// for each contour (defined for the first camera pair), perform RANSAC on
// the cumulative 3D features from all camera pairs that lie within the contour
for (int i = 0; i < numContours; i++)
{
memset(validFeatureIndicator[i], 1, numFeaturesInContours[i] * sizeof(char));
// perform RANSAC to remove points that lie too far off a best-fit surface
if (ransac(features3D[i], validFeatureIndicator[i], numFeaturesInContours[i], errorMessage))
{
printf("RANSAC: %s\n", errorMessage);
exit(1);
}
int numValidFeatures = 0;
for (int j = 0; j < numFeaturesInContours[i]; j++)
{
if (validFeatureIndicator[i][j])
{
numValidFeatures++;
}
}
printf("Total valid features after RANSAC for contour %s: %d\n", contourNames[i], numValidFeatures);
}
// create the output 3D features filename for all camera pairs as
// "frame<frame number>_features3D.txt", and write the result of RANSAC to
// the file
char features3DFilename[MAX_FILENAME_LENGTH];
sprintf(features3DFilename, "%sframe%d_features3D.txt", outputDirectory, camera1Frames[0]);
int status = write3DFeaturesToFile(features3D, validFeatureIndicator, numFeaturesInContours, contourNames, numContours, features3DFilename);
if (status == OUTPUT_FILE_OPEN_ERROR)
{
sprintf(errorMessage, "Could not open output file.");
return 1;
}
char **meshFilenames = (char **)malloc(numContours * sizeof(char *));
if (meshFilenames == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
// for each contour, create a different mesh output file
for (int i = 0; i < numContours; i++)
{
meshFilenames[i] = (char *)malloc(MAX_FILENAME_LENGTH * sizeof(char));
if (meshFilenames[i] == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
// create the output mesh filename as "frame<frame number>_mesh_<contour name>_<camera name>.txt"
sprintf(meshFilenames[i], "%sframe%d_mesh_%s.txt", outputDirectory, camera1Frames[0], contourNames[i]);
}
// create the wing meshes from the triangulated 3D points and the user-selected
// contours, and write each mesh to a different file for each contour
if (mesh(features3DFilename, contoursFilename, cameraCoefficientsFilenames[0], meshFilenames, numContours, regularization, errorMessage))
{
printf("Mesh: %s\n", errorMessage);
exit(1);
}
// we only calculate the flow of a wing mesh if there is a mesh file with the
// same contour name in the output directory for the previous video frame
char **flowFilenames = (char **)malloc(numContours * sizeof(char *));
if (flowFilenames == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
for (int i = 0; i < numContours; i++)
{
flowFilenames[i] = NULL;
}
int numFilesInDirectory;
char **filenamesInDirectory = (char **)malloc(MAX_FILES_IN_DIRECTORY * sizeof(char *));
if (filenamesInDirectory == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
for (int i = 0; i < MAX_FILES_IN_DIRECTORY; i++)
{
filenamesInDirectory[i] = (char *)malloc(MAX_FILENAME_LENGTH * sizeof(char));
if (filenamesInDirectory[i] == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
}
// get all files in the output directory
getAllFilenamesInDirectory(outputDirectory, &numFilesInDirectory, filenamesInDirectory);
// for each contour check if previous frame mesh file for same contour exists
// in output directory
for (int i = 0; i < numContours; i++)
{
// set substring indicating match to be "frame<previous frame number>_mesh_<contour name>.txt"
char filenameToMatch[MAX_FILENAME_LENGTH];
sprintf(filenameToMatch, "frame%d_mesh_%s.txt", camera1Frames[0]-1, contourNames[i]);
// try to find a filename from the output directory that contains the
// substring indicating a match for a previous frame mesh for the same
// contour
int fileExists = getIndexOfMatchingString(filenamesInDirectory, numFilesInDirectory, filenameToMatch);
// if filename was found, create a flow output file for current contour
// and call flow to calculate the flow between previous contour mesh and
// current contour mesh
if (fileExists != -1)
{
flowFilenames[i] = (char *)malloc(MAX_FILENAME_LENGTH * sizeof(char));
if (flowFilenames[i] == NULL)
{
printf("Out of memory error.\n");
exit(1);
}
// create the output flow filename as "frame<frame number>_flow_<contour name>_<camera name>.txt"
sprintf(flowFilenames[i], "%sframe%d_flow_%s.txt", outputDirectory, camera1Frames[0], contourNames[i]);
// add the output directory name to the beginning of the previous mesh
// filename
char prevFrameMeshFile[MAX_FILENAME_LENGTH];
sprintf(prevFrameMeshFile, "%s%s", outputDirectory, filenameToMatch);
// call flow to find the flow between the previous mesh file and the
// current mesh file for each mesh point current contour
if (flow(prevFrameMeshFile, meshFilenames[i], flowFilenames[i], errorMessage))
{
printf("Flow: %s\n", errorMessage);
exit(1);
}
}
else
{
printf("Mesh points file for previous frame not found for contour %s. Unable to calculate flow.\n", contourNames[i]);
}
}
sprintf(command, "hold on;");
engEvalString(matlabEngine, command);
// for each contour, display MATLAB 3D plot of the mesh, as well as the flow
// for the mesh, if applicable
for (int i = 0; i < numContours; i++)
{
if (flowFilenames[i] != NULL)
{
sprintf(command, "flows = load('%s');", flowFilenames[i]);
engEvalString(matlabEngine, command);
// plot the flows of the mesh points
sprintf(command, "quiver3(flows(:,1), flows(:,2), flows(:,3), flows(:,4), flows(:,5), flows(:,6), 4, 'r-');");
engEvalString(matlabEngine, command);
}
sprintf(command, "mesh = importdata('%s', ' ', 1);", meshFilenames[i]);
engEvalString(matlabEngine, command);
// plot the mesh points
sprintf(command, "plot3(mesh.data(:,1), mesh.data(:,2), mesh.data(:,3), 'b.');");
engEvalString(matlabEngine, command);
}
// reverse the z and y coordinates in the display
sprintf(command, "set(gca,'zdir','reverse','ydir','reverse');");
engEvalString(matlabEngine, command);
// scale the axes to be equal
sprintf(command, "axis equal");
engEvalString(matlabEngine, command);
// wait for the user to hit enter
printf("Hit return to continue.\n");
fgetc(stdin);
// close MATLAB engine
engClose(matlabEngine);
// cleanup
free(camera1Filenames);
free(camera1Frames);
free(camera2Filenames);
free(camera2Frames);
free(cameraNames);
free(cameraCoefficientsFilenames);
for (int i = 0; i < numCameraPairs; i++)
{
mxDestroyArray(c1ImageData[i]);
mxDestroyArray(c1ImageDimensions[i]);
mxDestroyArray(c1ImagePaddedWidths[i]);
mxDestroyArray(c2ImageData[i]);
mxDestroyArray(c2ImageDimensions[i]);
mxDestroyArray(c2ImagePaddedWidths[i]);
free(c1Images[i]->imageData);
cvReleaseImageHeader(&c1Images[i]);
free(c2Images[i]->imageData);
cvReleaseImageHeader(&c2Images[i]);
}
free(c1ImageData);
free(c1ImageDimensions);
free(c1ImagePaddedWidths);
free(c2ImageData);
free(c2ImageDimensions);
free(c2ImagePaddedWidths);
free(c1Images);
free(c2Images);
for (int i = 0; i < MAX_FILES_IN_DIRECTORY; i++)
{
free(filenamesInDirectory[i]);
}
free(filenamesInDirectory);
for (int i = 0; i < numContours; i++)
{
free(contourNames[i]);
free(features3D[i]);
free(validFeatureIndicator[i]);
free(meshFilenames[i]);
if (flowFilenames[i] != NULL)
{
free(flowFilenames[i]);
}
}
free(contourNames);
free(features3D);
free(validFeatureIndicator);
free(numFeaturesInContours);
free(meshFilenames);
free(flowFilenames);
exit(0);
}
/* * matlabShell.c * * This is a simple program call MATLAB matlab.el * * Copyright (c) 1998 by Robert A. Morris * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * If you did not receive a copy of the GPL you can get it at * //http://www.fsf.org * * This program is a matlab shell which will run under WindowsNT, and possibly * any OS, and can be invoked either from from matlab.el or a native * command shell. * * See the usage notes at the end of this file, or invoke it with * -h argument for brief usage message * 02dec98 version 1.0 [email protected] * -remove echo; instead require * matlab-shell-process-echoes nil * in matlab-shell-mode-hook * -works with matlab.el ver 2.2 * 01nov98 version 0.91 [email protected] * Bugs fixed: * "exit" command processing should be case sensitive * input not echoed properly * line spacing different from Matlab standard window * * - Matlab "exit" command must be all lower case, so * replace isExitCommand() with simple strncmp() * - echo input because something is erasing it on NT. Maybe comint.el? * - make line spacing look like Matlab native shell * Known deficiencies in 0.91: * 1. Matlab standard command window pops up when starting * 2. Matlab window doesn't exit if *matlab* buffer is killed without * sending exit command to matlab from matlabShell * * 01nov98 version 0.9 [email protected] * Known deficencies in 0.9 * 1. should be quiet production mode and verbose C debugging modes * 2. Matlab Debug is untested, probably doesn't work * */ #include <stdlib.h> #include <stdio.h> #include "engine.h" #define MAXLEN 1024; /* default */ int main(int argc, char **argv) { char version[]="MatlabShell 1.0. 02Dec1998.\nCopyright 1998 Robert A. Morris. \nThis is Free Software licensed under the GNU Public License."; Engine *ep; int inputMax; /* buffer size */ char *inbuf; int outputMax; /*buffer size */ char *fromEngine; int noArgs; int len, pos; int debug = 0; int retval; /* for debug */ int isExitCommand(char* str); /* matlab.el always invokes the shell command with two arguments, the second of which is NULL unless the lisp variable matlab-shell-command-switches is set, in which case the string value of that variable is passed as the argv[1] to the shell program. In that case we have to parse this string. In the standalone case, we may see 1, 2, or 3 args, the first of which is always the program path */ printf("%s\n", version); noArgs = (argc==1) || (argv[1]==0 || argv[1][0] == 0); if ( (!noArgs) && (argv[1][0] == '?' || !strcmp(argv[1], "-h"))) { printf("usage: %s <inbufSize> <outbufSize>", argv[0]); exit(0); } /* Start the MATLAB engine */ if (!(ep = engOpen(NULL))) { printf("Can not start engine\n"); exit(-1); } inputMax = MAXLEN; outputMax = 0; /* if there are args they might be: 1. one string from matlab.el with either 1 or 2 numbers 2. one or two strings from a command shell invocation */ if ( !noArgs ){ inputMax = atoi(argv[1]); if (argc>2 && argv[2]) /* doesn't happen under matlab.el */ outputMax = atoi(argv[2]); else { /*matlab.el passes args as a single string */ len = strlen(argv[1]); pos = strcspn(argv[1], " \t\n"); /* scan to white space */ if (debug) printf("argv[1]=%s len=%d pos=%d\n", argv[1], len, pos); argv[1][pos]=0; /* split */ inputMax = atoi(argv[1]); if (pos < len) /* there was stuff left */ outputMax = atoi(1+pos+argv[1]); } } if (!outputMax) /* nobody set it */ outputMax = 8*inputMax; inbuf = malloc(inputMax+2); /* room for newline and \0 */ outputMax = inputMax*8; fromEngine = malloc(outputMax +2); engOutputBuffer(ep, fromEngine, outputMax); while (1) { printf(">> "); fflush(stdout); fgets(inbuf, inputMax, stdin); /* On NT, something erases input and I don't know what. It might be the way comint.el is passing input to this process. If this is platform dependent then other platforms may see doubled input */ // printf("%s",inbuf); fflush(stdout); /* re-echo input */ /* it would be good to test retval, but on NT it seems to return non-zero whether the engine is running or not, contrary to Matlab doc. In fact, I can't figure out how to know whether the engine is running, so special case "exit" */ retval = engEvalString(ep, inbuf); if (!strncmp(inbuf,"exit",4)) { printf("exiting\n"); fflush(stdout); exit(0); } if (fromEngine[0] == 0 ){ /*the command didn't return anything */ if(debug) printf("\ncmd returned nothing"); } else { printf("%s", fromEngine); /* show matlab reply */ fromEngine[0] = 0; /* clear buffer, else confusing */ if (debug) { printf("retval=%x\n"); fflush(stdout); } } } exit(0); }
// Init the MATLAB engine
// (no need to call it directly since it is automatically invoked by any other command)
IGL_INLINE void igl::mlinit(Engine** mlengine)
{
*mlengine = engOpen("\0");
}
void MainWindow::RunAdamsSim()
{
ButtonAdamsSim->setStyleSheet("QPushButton {border-radius: 2px;padding: 0.2em 0.2em 0.3em 0.2em;border: 1px solid rgb(100, 100,100);background: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #34f32d, stop: 1 #000000);color: white;}");
std::ostringstream ossStringLHip, ossStringRHip, ossStringLKnee, ossStringRKnee, ossStringTimeLeft, ossStringTimeRight,
ossPeriod, ossCycles, ossDelay;
vector <double> vTimeLeftLeg, vTimeRightLeg;
vector <double> vHipR, vHipL, vKneeR, vKneeL;
ossPeriod <<"period="<<lineEditPeriod->text().toStdString();
ossCycles <<"cycles="<<lineEditCycles->text().toStdString();
ossDelay <<"delay="<<lineEditDelay->text().toStdString();
// Getting Time Values
//GetTimeValues(vTimeValues);
pHipRight->GetSamples(vTimeRightLeg);
pHipLeft->GetSamples(vTimeLeftLeg);
GetRobotObjectSampledValues(pHipLeft, vHipL);
GetRobotObjectSampledValues(pHipRight, vHipR);
GetRobotObjectSampledValues(pKneeLeft, vKneeL);
GetRobotObjectSampledValues(pKneeRight, vKneeR);
//pHipLeft->ExportMarkers(vTimeValues, vHipL);
pHipLeft->GetValues(vTimeLeftLeg, vHipL);
pHipRight->GetValues(vTimeRightLeg, vHipR);
pKneeLeft->GetValues(vTimeLeftLeg, vKneeL);
pKneeRight->GetValues(vTimeRightLeg, vKneeR);
// Making string for left hip
ossStringLHip << "vHipL=[";
std::copy(vHipL.begin(), vHipL.end()-1, std::ostream_iterator <double>(ossStringLHip, " "));
ossStringLHip << vHipL.back();
ossStringLHip << "];";
std::cout<<ossStringLHip.str()<<std::endl;
// Making string for left hip
ossStringRHip << "vHipR=[";
std::copy(vHipR.begin(), vHipR.end()-1, std::ostream_iterator <double>(ossStringRHip, " "));
ossStringRHip << vHipR.back();
ossStringRHip << "];";
// Making string for left knee
ossStringLKnee << "vKneeL=[";
std::copy(vKneeL.begin(), vKneeL.end()-1, std::ostream_iterator <double>(ossStringLKnee, " "));
ossStringLKnee << vKneeL.back();
ossStringLKnee << "];";
// Making string for right knee
ossStringRKnee << "vKneeR=[";
std::copy(vKneeR.begin(), vKneeR.end()-1, std::ostream_iterator <double>(ossStringRKnee, " "));
ossStringRKnee << vKneeR.back();
ossStringRKnee << "];";
// Making string for time values for Left Leg
ossStringTimeLeft << "vTimeL=[";
std::copy(vTimeLeftLeg.begin(), vTimeLeftLeg.end()-1, std::ostream_iterator <double>(ossStringTimeLeft, " "));
ossStringTimeLeft << vTimeLeftLeg.back();
ossStringTimeLeft << "];";
std::cout<<ossStringTimeLeft.str()<<std::endl;
// Making string for time values for Right Leg
ossStringTimeRight << "vTimeR=[";
std::copy(vTimeRightLeg.begin(), vTimeRightLeg.end()-1, std::ostream_iterator <double>(ossStringTimeRight, " "));
ossStringTimeRight << vTimeRightLeg.back();
ossStringTimeRight << "];";
std::cout<<ossStringTimeRight.str()<<std::endl;
Engine* m_matlabEngine;
// Opening Matlab Engine
m_matlabEngine=engOpen("\0");
// Clearing
engEvalString(m_matlabEngine, "clear;");
engEvalString(m_matlabEngine, ossStringLHip.str().c_str());
engEvalString(m_matlabEngine, ossStringTimeLeft.str().c_str());
engEvalString(m_matlabEngine, ossStringTimeRight.str().c_str());
engEvalString(m_matlabEngine, ossStringRHip.str().c_str());
engEvalString(m_matlabEngine, ossStringRKnee.str().c_str());
engEvalString(m_matlabEngine, ossStringLKnee.str().c_str());
engEvalString(m_matlabEngine, ossPeriod.str().c_str());
engEvalString(m_matlabEngine, ossCycles.str().c_str());
engEvalString(m_matlabEngine, ossDelay.str().c_str());
QString runEval(QString("run('%1');").arg("C:/Users/Zahid/GUI/RobotSim2/test_final_m2.m"));
engEvalString(m_matlabEngine, "cd('C:/Users/Zahid/GUI/RobotSim2');");
//engEvalString(m_matlabEngine, "Controls_Plant_2705_1");
//engEvalString(m_matlabEngine, "open('test_final_model');");
//engEvalString(m_matlabEngine, "sim('test_final_model');");
engEvalString(m_matlabEngine, runEval.toUtf8().constData());
engClose(m_matlabEngine);
ButtonAdamsSim->setStyleSheet("QPushButton {border-radius: 2px;padding: 0.2em 0.2em 0.3em 0.2em;border: 1px solid rgb(100, 100,100);background: QLinearGradient( x1: 0, y1: 0.02, x2: 0, y2: 1.2, stop: 0 #220, stop: 1 #ffffff);color: white;}");
}
int PASCAL WinMain (HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow)
{
Engine *ep;
mxArray *T = NULL, *a = NULL, *d = NULL;
char buffer[BUFSIZE+1];
double *Dreal, *Dimag;
double time[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
/*
* Start the MATLAB engine
*/
if (!(ep = engOpen(NULL))) {
MessageBox ((HWND)NULL, (LPSTR)"Can't start MATLAB engine",
(LPSTR) "Engwindemo.c", MB_OK);
exit(-1);
}
/*
* PART I
*
* For the first half of this demonstration, we will send data
* to MATLAB, analyze the data, and plot the result.
*/
/*
* Create a variable from our data
*/
T = mxCreateDoubleMatrix(1, 10, mxREAL);
memcpy((char *) mxGetPr(T), (char *) time, 10*sizeof(double));
/*
* Place the variable T into the MATLAB workspace
*/
engPutVariable(ep, "T", T);
/*
* Evaluate a function of time, distance = (1/2)g.*t.^2
* (g is the acceleration due to gravity)
*/
engEvalString(ep, "D = .5.*(-9.8).*T.^2;");
/*
* Plot the result
*/
engEvalString(ep, "plot(T,D);");
engEvalString(ep, "title('Position vs. Time for a falling object');");
engEvalString(ep, "xlabel('Time (seconds)');");
engEvalString(ep, "ylabel('Position (meters)');");
/*
* PART II
*
* For the second half of this demonstration, we will create another mxArray
* put it into MATLAB and calculate its eigen values
*
*/
a = mxCreateDoubleMatrix(3, 2, mxREAL);
memcpy((char *) mxGetPr(a), (char *) Areal, 6*sizeof(double));
engPutVariable(ep, "A", a);
/*
* Calculate the eigen value
*/
engEvalString(ep, "d = eig(A*A')");
/*
* Use engOutputBuffer to capture MATLAB output. Ensure first that
* the buffer is always NULL terminated.
*/
buffer[BUFSIZE] = '\0';
engOutputBuffer(ep, buffer, BUFSIZE);
/*
* the evaluate string returns the result into the
* output buffer.
*/
engEvalString(ep, "whos");
MessageBox ((HWND)NULL, (LPSTR)buffer, (LPSTR) "MATLAB - whos", MB_OK);
/*
* Get the eigen value mxArray
*/
d = engGetVariable(ep, "d");
engClose(ep);
if (d == NULL) {
MessageBox ((HWND)NULL, (LPSTR)"Get Array Failed", (LPSTR)"Engwindemo.c", MB_OK);
}
else {
Dreal = mxGetPr(d);
Dimag = mxGetPi(d);
if (Dimag)
sprintf(buffer,"Eigenval 2: %g+%gi",Dreal[1],Dimag[1]);
else
sprintf(buffer,"Eigenval 2: %g",Dreal[1]);
MessageBox ((HWND)NULL, (LPSTR)buffer, (LPSTR)"Engwindemo.c", MB_OK);
mxDestroyArray(d);
}
/*
* We're done! Free memory, close MATLAB engine and exit.
*/
mxDestroyArray(T);
mxDestroyArray(a);
return(0);
}
void MultiObjectSeg::nCutProcess(HFrame& curFrame)
{
Loggger<<"Start Graph Cut!.\n";
IndexType nbCluster = 8;
Loggger<<"segment number = "<<nbCluster<<endl;
Engine* ep;
if (! (ep = engOpen(NULL)) )
{
Loggger<< "Can't not start Matlab engine.\n";
return;
}
// ///set buffer to display result
IndexType result_buffer_size = 1024*1000;
char* result_buffer = new char[result_buffer_size];
engOutputBuffer(ep, result_buffer, result_buffer_size);
///Get the executable file's path
char cur_path[FILENAME_MAX];
if (!get_current_dir(cur_path, sizeof(cur_path)))
{
return;
}
cur_path[sizeof(cur_path) - 1] = '\0';
strcat(cur_path,"\\nCut");
char cd_cur_path[FILENAME_MAX + 3] = "cd ";
strcat(cd_cur_path, cur_path);
engEvalString(ep, cd_cur_path );
IndexType fId = curFrame.frame_id;
IndexType n = boost::num_vertices(*curFrame.pcGraph); //cur_graph_index_;
// //
// //
mxArray *mx_distMat = NULL;
numeric::float64* dm_buffer;
dm_buffer = new numeric::float64[n*n];
mx_distMat = mxCreateDoubleMatrix(n,n,mxREAL);
// ///all
for (int rowId = 0; rowId < n; rowId++)
{
/*dm_buffer[rowId*(n+1)] = 0;*/
for (int colId = 0; colId < n; colId++)
{
ScalarType dist = 0.;//weight2nodes_smooth(node_vec[rowId],node_vec[colId]);
dm_buffer[rowId * n + colId] = (numeric::float64)dist;
}
}
memcpy((char*)mxGetPr(mx_distMat),(char*)dm_buffer,n*n*sizeof(numeric::float64));
delete [] dm_buffer;
engPutVariable(ep,"W",mx_distMat);
char cmd_buf[128];
sprintf(cmd_buf,"[NcutDiscrete,NcutEigenvectors,NcutEigenvalues] = ncutW(W,%d);",nbCluster);
engEvalString(ep,cmd_buf);
// ///Display output information
// Loggger<<result_buffer<<std::endl;
mxArray *mx_NcutDiscrete = NULL;
mx_NcutDiscrete = engGetVariable(ep,"NcutDiscrete");
numeric::float64 *ncutDiscrete = mxGetPr(mx_NcutDiscrete);
Loggger<<"End for each nCut.\n";
}
void Project_Engine::Matlab_execution()
{
Engine *ep;
mxArray *cust_array = mxCreateDoubleMatrix(CUSTOMERS_MAX-1,1,mxREAL);
mxArray *mov_avg_array = mxCreateDoubleMatrix(MOVIES_MAX-1,1,mxREAL);
mxArray *mov_count_array = mxCreateDoubleMatrix(MOVIES_MAX-1,1,mxREAL);
double *p_rating_count = mxGetPr(cust_array);
double *p_movie_avg = mxGetPr(mov_avg_array);
double *p_mov_count = mxGetPr(mov_count_array);
int i,j,counter;
float Current_movie,Current_cust;
intHashTable* movie_average = new intHashTable(9);
intHashTable* user_average = new intHashTable(9);
//======================USER AVERAGE DISTRIBUTION======================
for (i=1;i<CUSTOMERS_MAX;i++){
//Round up each customer rating average to the nearest 0.5 between 1 and 5
Current_cust = floor((2*Customer_spec[i].Cust_RateAvg)+0.5)/2;
for (j=0;j<9;j++){
if (Current_cust<(1+0.5*j)){
//According to the users rounded average, the corresponding id is inserted into a specific rating list
user_average->insert(i,Current_cust,j);
break;
}
}
}
mxArray *custrating_array = mxCreateDoubleMatrix(9,1,mxREAL);
mxArray *custcount_array = mxCreateDoubleMatrix(9,1,mxREAL);
double *pcustx = mxGetPr(custrating_array);
double *pcusty = mxGetPr(custcount_array);
Node** user_table = user_average->getTable();
for (j=0;j<9;j++){
counter = 0;
pcustx[j] = 1+0.5*j;
while(user_table[j]!=NULL){
counter++;
user_table[j] = user_table[j]->Next;
}
pcusty[j] = counter;
}
memcpy((void*)mxGetPr(custrating_array), (void*)pcustx, (9)*sizeof(float));
memcpy((void*)mxGetPr(custcount_array), (void*)pcusty, (9)*sizeof(float));
//======================USER AVERAGE DISTRIBUTION======================
//======================MOVIE AVERAGE DISTRIBUTION======================
for (i=1;i<MOVIES_MAX;i++){
Current_movie = floor((2*Movie_spec[i].Movie_RateAvg)+0.5)/2;
for (j=0;j<9;j++){
if (Current_movie<(1+0.5*j)){
movie_average->insert(i,Current_movie,j);
break;
}
}
}
mxArray *mrating_array = mxCreateDoubleMatrix(9,1,mxREAL);
mxArray *mcount_array = mxCreateDoubleMatrix(9,1,mxREAL);
double *px = mxGetPr(mrating_array);
double *py = mxGetPr(mcount_array);
Node** movie_table = movie_average->getTable();
for (j=0;j<9;j++){
counter = 0;
px[j] = 1+0.5*j;
while(movie_table[j]!=NULL){
counter++;
movie_table[j] = movie_table[j]->Next;
}
py[j] = counter;
}
memcpy((void*)mxGetPr(mrating_array), (void*)px, (9)*sizeof(float));
memcpy((void*)mxGetPr(mcount_array), (void*)py, (9)*sizeof(float));
//======================MOVIE AVERAGE DISTRIBUTION======================
if (!(ep = engOpen("\0")))
cerr << "Cant start MATLAB engine" << endl;
for (i=1;i<CUSTOMERS_MAX;i++){
p_rating_count[i-1] = Customer_spec[i].Cust_RateCount;
};
for (i=1;i<MOVIES_MAX;i++){
p_movie_avg[i-1] = Movie_spec[i].Movie_RateAvg;
p_mov_count[i-1] = Movie_spec[i].Movie_RateCount;
};
memcpy((void*)mxGetPr(cust_array), (void*)p_rating_count, (CUSTOMERS_MAX-1)*sizeof(float));
memcpy((void*)mxGetPr(mov_avg_array), (void*)p_movie_avg, (MOVIES_MAX-1)*sizeof(float));
memcpy((void*)mxGetPr(mov_count_array), (void*)p_mov_count, (MOVIES_MAX-1)*sizeof(float));
engPutVariable(ep,"rating_count",cust_array);
engPutVariable(ep,"movie_avg" ,mov_avg_array);
engPutVariable(ep,"mov_count" ,mov_count_array);
engEvalString(ep, "figure(1);");
engEvalString(ep, "B=sort(rating_count);");
engEvalString(ep, "numberOfBins = 100;[counts, binValues] = hist(B, numberOfBins);normalizedCounts = 100 * counts / sum(counts);");
engEvalString(ep, "bar(sort(binValues),normalizedCounts,'r');set(gca,'XTick', []);");
engEvalString(ep, "grid on;");
engEvalString(ep, "title('Customer Rating Count Distribution')");
engEvalString(ep, "ylabel('Rating Count [%]')");
engEvalString(ep, "figure(2);");
engEvalString(ep, "B=sort(movie_avg);plot(B,'-.r*');");
engEvalString(ep, "grid on;");
engEvalString(ep, "title('Movie Average Distribution')");
engEvalString(ep, "xlabel('Movie ID')");
engEvalString(ep, "ylabel('Rating Average')");
engEvalString(ep, "figure(3);");
engEvalString(ep, "C=sort(mov_count);");
engEvalString(ep, "numberOfBins = 100;[counts, binValues] = hist(C, numberOfBins);normalizedCounts = 100 * counts / sum(counts);");
engEvalString(ep, "bar(sort(binValues),normalizedCounts);");
engEvalString(ep, "grid on;");
engEvalString(ep, "title('Movie Rating Count Distribution')");
engEvalString(ep, "ylabel('Rating Count [%]')");
engPutVariable(ep,"x",mrating_array);
engPutVariable(ep,"y",mcount_array);
engPutVariable(ep,"custx",custrating_array);
engPutVariable(ep,"custy",custcount_array);
engEvalString(ep, "figure(4);");
engEvalString(ep, "bar(x,y/sum(y));");
engEvalString(ep, "grid on;");
engEvalString(ep, "title('Average Rating Distribution of Movies')");
engEvalString(ep, "xlabel('Rating')");
engEvalString(ep, "ylabel('Density')");
engEvalString(ep, "hold on");
engEvalString(ep, "plot(custx,custy/sum(custy),'--r','LineWidth',2);");
engEvalString(ep, "hold off");
string s;
cout << "Press Any Key to exit MATLAB and continue the program:" << endl;
getline(cin, s);
mxDestroyArray(cust_array);
mxDestroyArray(mov_avg_array);
mxDestroyArray(mov_count_array);
engEvalString(ep,"close;");
}
