cml/libcm
1
0
Forka 0
Codice Problemi Pull Requests Rilasci Wiki Attività
655b2e6f3b
libcm/cmGnuPlot.c

1122 righe
29 KiB
C
Originale Blame Cronologia

#include "cmPrefix.h"
#include "cmGlobal.h"
#include "cmRpt.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmGnuPlot.h"
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h> // read/write/close
enum
{
kX_PdFl = 0x01, // the data set contains explicit x coordinates
kY_PdFl = 0x02, // the data set contains explicit y coordinates
kZ_PdFl = 0x04, // the data set contains explicit z coordinates
kImpulse_PdFl = 0x08, // plot using the gnuplot impulse style
kInvalidLineId = -2,
kSolidLineId = -1,
kDashedLineId = 0
};
typedef struct
{
unsigned flags; // see kXXX_PdFl
char* legendStrH; // plot legend label for this data set
char* colorStrH; // string containing a gnuplot color spec
double* xyzMtxPtr; // data to be plotted contained in a column major mtx with 1,2, or 3 columns
unsigned rn; //
unsigned cn; //
int lineId; // gnuplot line style id
int pointId; // gnuplot point style id
} cmPlotData;
//----------------------------------------------------------------------------------------------------------
enum
{
kTitleIdx = 0,
kXLabelIdx,
kYLabelIdx,
kZLabelIdx,
kPlotStrCnt
};
enum
{
kXMinRangeIdx,
kXMaxRangeIdx,
kYMinRangeIdx,
kYMaxRangeIdx,
kZMinRangeIdx,
kZMaxRangeIdx,
kRangeCnt
};
// There is one cmPlot per sub-plot. These records are held in cmPlotPage.plotPtrArray
typedef struct
{
cmChar_t* strArray[ kPlotStrCnt ]; // an array of various labels and titles
double range[ kRangeCnt ]; // a set of range limits for each dimension (used to automatically fill in coord values when they are not explicitely given)
unsigned rowIdx; // the plot page row index of this sub-plot
unsigned colIdx; // the plot page col index of this sub-plot
cmPlotData** dataPtrArray; // pointer to data sets containing data for this sub-plot
unsigned dataCnt;
} cmPlot;
//----------------------------------------------------------------------------------------------------------
// The plotter contains a single cmPlotPage (pointed to by _cmpp).
typedef struct
{
unsigned rowCnt; // number of rows of sub-plots
unsigned colCnt; // number of columns of sub-plots
cmChar_t* titleStrH; // page title
int pipeFd[2]; // communication pipe with gnuplot process
int pid; // process id of the gnuplot process
cmPlot** plotPtrArray; // vector of sub-plots
unsigned plotCnt; //
unsigned curPlotIdx; // the sub-plot currently receiving plotting commands and data
} cmPlotPage;
cmPlotPage _cmPlotPage = { 0,0,NULL,{-1,-1},-1,NULL,0,cmInvalidIdx};
cmPlotPage* _cmpp = NULL;
void _cmPrintf( int fd, const char* fmt, ... )
{
const int bufCnt = 255;
char buf[bufCnt+1];
buf[bufCnt]='\0';
va_list vl;
va_start(vl,fmt);
int n = vsnprintf(buf,bufCnt,fmt,vl);
assert( n < 255 );
write(fd,buf,n);
va_end(vl);
}
// unexpected event signal handler
void cmPlotSignalHandler( int sig )
{
switch( sig )
{
case SIGCHLD:
if( _cmpp != NULL )
_cmpp->pid = -1;
break;
case SIGBUS:
case SIGSEGV:
case SIGTERM:
cmPlotFinalize();
break;
}
}
unsigned _cmPlotError( cmPlotPage* p, unsigned rc, bool sysErrFl, const char* fmt, ... )
{
va_list vl;
va_start(vl,fmt);
fprintf(stderr,"cmPlot Error:");
vfprintf(stderr,fmt,vl);
if( sysErrFl )
fprintf(stderr," System Msg:%s\n",strerror(errno));
va_end(vl);
return rc;
}
//----------------------------------------------------------------------------------------------------------
void _cmPlotDataInit( cmPlotData* p )
{
p->flags = 0;
p->legendStrH = NULL;
p->colorStrH = NULL;
p->xyzMtxPtr = NULL;
p->rn = 0;
p->cn = 0;
p->lineId = kInvalidLineId;
p->pointId = kInvalidPlotPtId;
}
void _cmPlotDataCons( cmPlotData* p, unsigned flags, const char* legendStr, const char* colorStr, double* mtxPtr, unsigned rn, unsigned cn, unsigned styleFlags )
{
p->flags = flags + (cmIsFlag(styleFlags,kImpulsePlotFl) ? kImpulse_PdFl : 0);
p->legendStrH = cmMemAllocStr(legendStr);
p->colorStrH = cmMemAllocStr(colorStr);
p->xyzMtxPtr = mtxPtr;
p->rn = rn;
p->cn = cn;
p->lineId = ((styleFlags & kPlotLineMask) >> kPlotLineShift) - 2; // convert from the interface style flags to gnuplot id's
p->pointId = styleFlags & kPlotPtMask;
}
void _cmPlotDataFree( cmPlotData* p )
{
cmMemPtrFree(&p->legendStrH);
cmMemPtrFree(&p->colorStrH);
//cmDM_Free(&p->xyzMtxPtr);
cmMemPtrFree(&p->xyzMtxPtr);
}
/*
bool _cmPlotDataFreeFE( unsigned i, cmPlotData* p, void *vp )
{
_cmPlotDataFree(p);
return true;
}
*/
//----------------------------------------------------------------------------------------------------------
void _cmPlotInit( cmPlot* p )
{
unsigned i;
for(i=0; i<kPlotStrCnt; ++i)
p->strArray[i] = NULL;
for(i=0; i<kRangeCnt; ++i)
p->range[i] = 0;
p->rowIdx = cmInvalidIdx;
p->colIdx = cmInvalidIdx;
p->dataPtrArray = NULL;
p->dataCnt = 0;
}
void _cmPlotCons( cmPlot* p, unsigned ri, unsigned ci )
{
p->rowIdx = ri;
p->colIdx = ci;
assert( p->dataPtrArray == NULL );
//p->dataPtrArray = cmPlotDataVect_AllocEmpty();
}
void _cmPlotInsertData( cmPlot* p, cmPlotData* rp)
{
cmPlotData* nrp = cmMemAlloc(cmPlotData,1);
*nrp = *rp;
p->dataPtrArray = cmMemResizeP( cmPlotData*, p->dataPtrArray, p->dataCnt + 1 );
p->dataPtrArray[ p->dataCnt ] = nrp;
++p->dataCnt;
}
void _cmPlotClearData( cmPlot* p )
{
unsigned i;
// release the strings
for(i=0; i<kPlotStrCnt; ++i)
cmMemPtrFree(&p->strArray[i]);
// release the plot data
for(i=0; i<p->dataCnt; ++i)
{
_cmPlotDataFree( p->dataPtrArray[i] );
cmMemPtrFree( &p->dataPtrArray[i] );
}
// set the data cnt to 0
p->dataCnt = 0;
}
void _cmPlotFree( cmPlot* p )
{
_cmPlotClearData(p);
cmMemPtrFree(&p->dataPtrArray);
}
//----------------------------------------------------------------------------------------------------------
void _cmPlotPageInit( cmPlotPage* rp )
{
rp->rowCnt = 0;
rp->colCnt = 0;
rp->titleStrH = NULL;
rp->pipeFd[0] = -1;
rp->pipeFd[1] = -1;
rp->pid = -1;
rp->plotPtrArray = NULL;
rp->curPlotIdx = cmInvalidIdx;
}
cmRC_t _cmPlotPageCons( cmPlotPage* rp, int pid, int inFd, int outFd, const char* terminalStr )
{
cmRC_t rc = kOkPlRC;
rp->pid = pid;
rp->pipeFd[0] = inFd;
rp->pipeFd[1] = outFd;
rp->plotPtrArray = NULL; //cmPlotVect_AllocEmpty();
if(terminalStr != NULL )
_cmPrintf( outFd, "set terminal %s\n",terminalStr );
return rc;
}
void _cmPlotPageSetup( cmPlotPage* rp, const char* title, unsigned rowCnt, unsigned colCnt )
{
unsigned i,ri, ci;
rp->titleStrH = cmMemResizeStr(rp->titleStrH,title); // acStringAssign(&rp->titleStrH,title);
rp->rowCnt = rowCnt;
rp->colCnt = colCnt;
rp->curPlotIdx = rowCnt*colCnt > 0 ? 0 : cmInvalidIdx;
// free any resources held by each plot and empty the plot array
for(i=0; i<rp->plotCnt; ++i)
{
_cmPlotFree(rp->plotPtrArray[i]);
cmMemPtrFree( &rp->plotPtrArray[i] );
}
rp->plotCnt = 0;
// insert rowCnt*colCnt blank plot records
// allocate the plotVect[]
rp->plotPtrArray = cmMemResizeZ( cmPlot*, rp->plotPtrArray, rowCnt*colCnt );
rp->plotCnt = rowCnt * colCnt;
// initialize each cmPlot record
for(ri=0,i=0; ri<rowCnt; ++ri)
for(ci=0; ci<colCnt; ++ci,++i)
{
rp->plotPtrArray[i] = cmMemAllocZ(cmPlot,1);
_cmPlotInit( rp->plotPtrArray[i]);
_cmPlotCons( rp->plotPtrArray[i], ri, ci);
}
}
cmRC_t _cmPlotPageFree( cmPlotPage* rp )
{
unsigned i;
cmRC_t rc = kOkPlRC;
cmMemPtrFree(&rp->titleStrH);
//acStringDelete( &rp->titleStrH );
// if the plot process was successfully started - stop it here
if( rp->pid > 0)
{
int rc;
kill(rp->pid,SIGKILL);
wait(&rc);
rp->pid = -1;
}
// close the pipe input to the plot process
for(i=0; i<2; ++i)
{
if( rp->pipeFd[i] != -1 )
if( close(rp->pipeFd[i]) == -1 )
rc = _cmPlotError(rp,kPipeCloseFailedPlRC,true,"Pipe %i close() failed.",i);
rp->pipeFd[i] = -1;
}
// deallocate the plot array
if( rp->plotPtrArray != NULL )
{
for(i=0; i<rp->plotCnt; ++i)
{
_cmPlotFree(rp->plotPtrArray[i] );
cmMemPtrFree(&rp->plotPtrArray[i]);
}
cmMemPtrFree(&rp->plotPtrArray);
rp->plotCnt = 0;
}
return rc;
}
//----------------------------------------------------------------------------------------------------------
cmRC_t cmPlotInitialize( const char* terminalStr )
{
cmRC_t rc = kOkPlRC;
// if this is the first call to this function
if( _cmpp == NULL )
{
struct sigaction sa;
_cmpp = &_cmPlotPage;
_cmPlotPageInit(_cmpp);
sa.sa_handler = cmPlotSignalHandler;
sigemptyset(&sa.sa_mask);
if (sigaction(SIGBUS, &sa, NULL) == -1)
{
rc = _cmPlotError(_cmpp,kSignalFailedPlRC,true,"sigaction(SIGBUS) failed.");
goto errLabel;
}
sa.sa_handler = cmPlotSignalHandler;
sigemptyset(&sa.sa_mask);
if (sigaction(SIGSEGV, &sa, NULL) == -1)
{
rc = _cmPlotError(_cmpp,kSignalFailedPlRC,true,"sigaction(SIGSEGV) failed.");
goto errLabel;
}
sa.sa_handler = cmPlotSignalHandler;
sigemptyset(&sa.sa_mask);
if (sigaction(SIGTERM, &sa, NULL) == -1)
{
rc = _cmPlotError(_cmpp,kSignalFailedPlRC,true,"sigaction(SIGTERM) failed.");
goto errLabel;
}
sa.sa_handler = cmPlotSignalHandler;
sigemptyset(&sa.sa_mask);
if (sigaction(SIGCHLD, &sa, NULL) == -1)
{
rc = _cmPlotError(_cmpp,kSignalFailedPlRC,true,"sigaction(SIGCHLD) failed.");
goto errLabel;
}
}
else // if this is the second or greater call to this function
{
if((rc = cmPlotFinalize()) != kOkPlRC )
return rc;
}
int pipeFD[2];
// create the pipe
if( pipe(pipeFD) == -1 )
{
rc = _cmPlotError(_cmpp,kPipeFailedPlRC,true,"pipe() failed.");
goto errLabel;
}
int pid;
// create the child proces
switch( pid = fork() )
{
case -1:
printf("Error\n");
rc = _cmPlotError(_cmpp,kForkFailedPlRC,true,"fork() failed.");
goto errLabel;
break;
case 0:
close(fileno(stdin)); // close stdin
dup(pipeFD[0]); // replace stdin with the pipe input
execlp("gnuplot","gnuplot",NULL); // start gnuplot
// under normal conditions execlp() should never return
rc = _cmPlotError(_cmpp,kExecFailedPlRC,true,"exec() failed.");
goto errLabel;
break;
default:
// normal return for parent process
rc = _cmPlotPageCons(_cmpp,pid,pipeFD[0],pipeFD[1], terminalStr );
break;
}
return rc;
errLabel:
cmPlotFinalize();
return rc;
}
cmRC_t cmPlotFinalize()
{
cmRC_t rc = kOkPlRC, rc0;
struct sigaction sa;
if( _cmpp == NULL )
return kOkPlRC;
// install some unexpected event signal handlers to clean up if the application
// process crashes prior to calling cmPlotFinalize(). This will prevent unconnected gnuplot
// processes from being left in the process list.
sa.sa_handler = SIG_DFL;
sigemptyset(&sa.sa_mask);
if( sigaction( SIGCHLD,&sa,NULL) == -1 )
rc =_cmPlotError(_cmpp,kSignalFailedPlRC,true,"sigaction(SIGCHLD) restore failed.");
if( sigaction( SIGTERM,&sa,NULL) == -1 )
rc =_cmPlotError(_cmpp,kSignalFailedPlRC,true,"sigaction(SIGTERM) restore failed.");
if( sigaction( SIGSEGV,&sa,NULL) == -1 )
rc =_cmPlotError(_cmpp,kSignalFailedPlRC,true,"sigaction(SIGSEGV) restore failed.");
if( sigaction( SIGBUS,&sa,NULL) == -1 )
rc =_cmPlotError(_cmpp,kSignalFailedPlRC,true,"sigaction(SIGBUS) restore failed.");
// restore the child termination signal handler
signal(SIGCHLD,SIG_DFL);
rc0 = _cmPlotPageFree(_cmpp);
return rc==kOkPlRC ? rc0 : rc;
}
cmRC_t cmPlotInitialize2( const char* terminalStr, const char* title, unsigned rowCnt, unsigned colCnt )
{
cmRC_t rc;
if((rc = cmPlotInitialize(terminalStr)) != cmOkRC )
return rc;
return cmPlotSetup(title,rowCnt,colCnt);
}
cmRC_t cmPlotSetup( const char* title, unsigned rowCnt, unsigned colCnt )
{
_cmPlotPageSetup( _cmpp,title,rowCnt,colCnt);
return kOkPlRC;
}
// called to locate a cmPlot given plot row/col indexes
unsigned _cmRowColToPlotIndex( cmPlotPage* p, unsigned ri, unsigned ci )
{
unsigned i;
for(i=0; i<_cmpp->plotCnt; ++i)
if( _cmpp->plotPtrArray[i]->rowIdx==ri && _cmpp->plotPtrArray[i]->colIdx==ci )
return i;
_cmPlotError(_cmpp,kPlotNotFoundPlRC,false,"No plot exists at row:%i and col:%i\n",ri,ci);
return cmInvalidIdx;
}
cmRC_t cmPlotSelectSubPlot( unsigned ri, unsigned ci )
{
unsigned i;
if((i= _cmRowColToPlotIndex( _cmpp, ri, ci ) ) != cmInvalidIdx )
_cmpp->curPlotIdx = i;
return kOkPlRC;
}
cmPlot* _cmPlotGetCurPlotPtr()
{
if( _cmpp->curPlotIdx == cmInvalidIdx )
{
_cmPlotError(_cmpp,kNoCurPlotPlRC,false,"No plot exists for the current page.");
assert(0);
return NULL;
};
assert( _cmpp->curPlotIdx < _cmpp->plotCnt );
cmPlot* p = _cmpp->plotPtrArray[_cmpp->curPlotIdx];
assert( p != NULL );
return p;
}
cmRC_t cmPlotSetLabels( const char* titleStr, const char* xLabelStr, const char* yLabelStr, const char* zLabelStr )
{
cmPlot* p = _cmPlotGetCurPlotPtr();
p->strArray[kTitleIdx] = cmMemAllocStr( titleStr ); // acStringAssign( &p->strArray[ kTitleIdx ], titleStr );
p->strArray[kXLabelIdx] = cmMemAllocStr( xLabelStr ); // acStringAssign( &p->strArray[ kXLabelIdx ], xLabelStr );
p->strArray[kYLabelIdx] = cmMemAllocStr( yLabelStr ); // acStringAssign( &p->strArray[ kYLabelIdx ], yLabelStr );
p->strArray[kZLabelIdx] = cmMemAllocStr( zLabelStr ); //acStringAssign( &p->strArray[ kZLabelIdx ], zLabelStr );
return kOkPlRC;
}
cmRC_t cmPlotSetRange( double xMin, double xMax, double yMin, double yMax, double zMin, double zMax )
{
cmPlot* p = _cmPlotGetCurPlotPtr();
if( xMin != 0 || xMax != 0 )
{
p->range[ kXMinRangeIdx ] = xMin;
p->range[ kXMaxRangeIdx ] = xMax;
}
if( yMin != 0 || yMax != 0 )
{
p->range[ kYMinRangeIdx ] = yMin;
p->range[ kYMaxRangeIdx ] = yMax;
}
if( zMin != 0 || zMax != 0 )
{
p->range[ kZMinRangeIdx ] = zMin;
p->range[ kZMaxRangeIdx ] = zMax;
}
return kOkPlRC;
}
void cmPlot2DLine( const float* x, const float* y, unsigned n, const char* color, int lineType, int lineWidth, int pointType )
{
//char cmd[] = "reset\nset size 1,1\nset origin 0,0\nset multiplot layout 1,1\nplot '-' binary array=16 format='%float' origin=(16,0) dx=10 using 1 with lines\n";
char cmd[] = "reset\nset size 1,1\nset origin 0,0\nset multiplot layout 1,1\nplot '-' binary record=16 format='%float' using 1:2 with lines\n";
char cmd2[] = "unset multiplot\n";
unsigned i;
int rc = write(_cmpp->pipeFd[1],cmd,strlen(cmd));
//int rc = fprintf(fp,"%s",cmd);
for( i=0; i<n; ++i)
{
write(_cmpp->pipeFd[1],x+i,sizeof(float));
write(_cmpp->pipeFd[1],y+i,sizeof(float));
}
write(_cmpp->pipeFd[1],cmd2,strlen(cmd2));
printf("%i %s",rc,cmd);
}
void cmPlot2DLine1( const float* x, const float* y, unsigned n, const char* color, int lineType, int lineWidth, int pointType )
{
//char cmd[] = "reset\nset size 1,1\nset origin 0,0\nset multiplot layout 1,1\nplot '/home/kevin/src/gnuplot/data1.bin' binary record=16x2\n";
char cmd[] = "reset\nset size 1,1\nset origin 0,0\nset multiplot layout 1,1\nplot '-' binary record=16 format='%float' using 1:2 with lines\n";
char cmd2[] = "unset multiplot\n";
unsigned i;
int rc = write(_cmpp->pipeFd[1],cmd,strlen(cmd));
//int rc = fprintf(fp,"%s",cmd);
for( i=0; i<n; ++i)
{
write(_cmpp->pipeFd[1],x+i,sizeof(float));
write(_cmpp->pipeFd[1],y+i,sizeof(float));
}
write(_cmpp->pipeFd[1],cmd2,strlen(cmd2));
printf("%i %s",rc,cmd);
}
/// Clear the current current subplot
cmRC_t cmPlotClear()
{
cmPlot* p = _cmPlotGetCurPlotPtr();
_cmPlotClearData(p);
return kOkPlRC;
}
void _cmPlotInsertDataRecd( cmPlot* p, unsigned flags, const char* legendStr, const char* colorStr, unsigned styleFlags, double* mtxPtr, unsigned rn, unsigned cn )
{
cmPlotData r;
_cmPlotDataInit(&r);
_cmPlotDataCons(&r,flags,legendStr,colorStr,mtxPtr,rn,cn,styleFlags);
_cmPlotInsertData(p,&r);
}
cmRC_t cmPlotLineF( const char* legendStr, const float* x, const float* y, const float* z, unsigned n, const char* colorStr, unsigned styleFlags )
{
cmPlot* p = _cmPlotGetCurPlotPtr();
unsigned flags = 0;
unsigned rn = 0;
unsigned ri = 0;
const float* array[3] = {x,y,z};
unsigned i;
// determine which data vectors were provided
for(i=0; i<3; ++i)
if( array[i] != NULL )
{
++rn;
switch(i)
{
case 0: flags = cmSetFlag(flags,kX_PdFl); break;
case 1: flags = cmSetFlag(flags,kY_PdFl); break;
case 2: flags = cmSetFlag(flags,kZ_PdFl); break;
default:
{assert(0);}
}
}
// create the matrix to hold the data
double* mtxPtr = cmMemAlloc(double,rn*n);
// copy the data into the matrix
for(i=0; i<3; ++i)
if( array[i] != NULL )
{
unsigned ci;
for(ci=0; ci<n; ++ci)
mtxPtr[ ci*rn + ri ] = array[i][ci];
++ri;
}
// store the a record to represent this line
_cmPlotInsertDataRecd(p, flags, legendStr, colorStr, styleFlags, mtxPtr, rn, n );
return kOkPlRC;
}
cmRC_t cmPlotLineD( const char* legendStr, const double* x, const double* y, const double* z, unsigned n, const char* colorStr, unsigned styleFlags )
{
cmPlot* p = _cmPlotGetCurPlotPtr();
unsigned flags = 0;
unsigned rn = 0;
unsigned ri = 0;
const double* array[3] = { x,y,z};
unsigned i;
// determine wihc data vectors were provided
for(i=0; i<3; ++i)
if( array[i] != NULL )
{
++rn;
switch(i)
{
case 0: flags = cmSetFlag(flags,kX_PdFl); break;
case 1: flags = cmSetFlag(flags,kY_PdFl); break;
case 2: flags = cmSetFlag(flags,kZ_PdFl); break;
default:
{assert(0);}
}
}
// create the matrix to hold the data
double* mtxPtr = cmMemAlloc(double,rn*n);
// copy the data into the matrix
for(i=0; i<3; ++i)
if( array[i] != NULL )
{
unsigned ci;
for(ci=0; ci<n; ++ci)
mtxPtr[ ci*rn + ri ] = array[i][ci];
++ri;
}
// store the a record to represent this line
_cmPlotInsertDataRecd(p, flags, legendStr, colorStr, styleFlags, mtxPtr, rn, n );
return kOkPlRC;
}
cmRC_t cmPlotLineMD( const double* x, const double* y, const double* z, unsigned rn, unsigned cn, unsigned styleFlags )
{
cmRC_t rc;
unsigned i;
for(i=0; i<cn; ++i)
if((rc = cmPlotLineD( NULL, x==NULL ? NULL : x+(i*rn), y==NULL ? NULL : y+(i*rn), z==NULL ? NULL : z+(i*rn), rn, NULL, styleFlags )) != cmOkRC )
return rc;
return cmOkRC;
}
const double* _cmPrintData( int fd, unsigned i, const double* p, double minV, double fact )
{
if( p != NULL )
_cmPrintf(fd,"%f ",*p++);
else
if( fact != 0 )
{
double v = minV + (fact * i );
_cmPrintf(fd,"%f ",v);
}
return p;
}
cmRC_t _cmPlotDraw(int fd, bool printDataFl )
{
unsigned ri,ci,di;
_cmPrintf(fd,"reset\n");
_cmPrintf(fd,"set size 1,1\n");
_cmPrintf(fd,"set origin 0,0\n");
_cmPrintf(fd,"set multiplot layout %i,%i\n",_cmpp->rowCnt,_cmpp->colCnt);
for(ri=0; ri<_cmpp->rowCnt; ++ri)
for(ci=0; ci<_cmpp->colCnt; ++ci)
{
// get the plot at ri,ci
unsigned plotIdx = _cmRowColToPlotIndex(_cmpp,ri,ci);
assert( plotIdx != cmInvalidIdx );
cmPlot* p = _cmpp->plotPtrArray[plotIdx];
// get the count of data sets assigned to this plot
unsigned dataCnt = p->dataCnt;
if( dataCnt > 0 )
{
bool printPlotKeywordFl = false;
// note which ranges are valid
bool isXRangeFl = p->range[ kXMinRangeIdx ] != 0 || p->range[ kXMaxRangeIdx != 0 ];
bool isYRangeFl = p->range[ kYMinRangeIdx ] != 0 || p->range[ kYMaxRangeIdx != 0 ];
bool isZRangeFl = p->range[ kZMinRangeIdx ] != 0 || p->range[ kZMaxRangeIdx != 0 ];
// set the plot title
if( p->strArray[kTitleIdx] != NULL )
_cmPrintf(fd,"set title '%s'\n",(p->strArray[kTitleIdx]));
else
{
// if this is a one plot page use the page title as the plot title
if( _cmpp->titleStrH != NULL && _cmpp->rowCnt==1 && _cmpp->colCnt == 1 )
_cmPrintf(fd,"set title '%s'\n", _cmpp->titleStrH );
}
// set the plot x label
if( p->strArray[kXLabelIdx] != NULL )
_cmPrintf(fd,"set xlabel '%s'\n",(p->strArray[kXLabelIdx]));
// set the plot y label
if( p->strArray[kYLabelIdx] != NULL )
_cmPrintf(fd,"set ylabel '%s'\n",(p->strArray[kYLabelIdx]));
for(di=0; di<dataCnt; ++di)
{
cmPlotData* dp = p->dataPtrArray[di];
unsigned eleCnt = dp->cn; //acDM_Cols(dp->xyzMtxPtr);
unsigned dimCnt = dp->rn; //acDM_Rows(dp->xyzMtxPtr);
if( eleCnt == 0 || dimCnt==0 )
continue;
// must defer printing the 'plot' command until we are sure there is a non-empty matrix to print
if( printPlotKeywordFl == false )
{
_cmPrintf(fd,"plot ");
printPlotKeywordFl = true;
}
bool useXRangeFl = (cmIsFlag(dp->flags,kX_PdFl)==false) && isXRangeFl;
bool useYRangeFl = (cmIsFlag(dp->flags,kY_PdFl)==false) && isYRangeFl;
bool useZRangeFl = (cmIsFlag(dp->flags,kZ_PdFl)==false) && isZRangeFl;
bool useRangeFl = useXRangeFl | useYRangeFl | useZRangeFl;
_cmPrintf(fd," '-' binary %s=%i format='%%double' ", (dimCnt==1) && useRangeFl ? "array":"record",eleCnt);
if( (dimCnt == 1) && (useXRangeFl || useYRangeFl) )
{
_cmPrintf(fd," origin=(%f,%f) ", useXRangeFl ? p->range[ kXMinRangeIdx ] : 0, useYRangeFl ? p->range[ kYMinRangeIdx ] : 0);
if( useXRangeFl )
_cmPrintf(fd, " dx=%f ", (p->range[ kXMaxRangeIdx ] - p->range[ kXMinRangeIdx ]) / eleCnt );
if( useYRangeFl )
_cmPrintf(fd, " dy=%f ", (p->range[ kYMaxRangeIdx ] - p->range[ kYMinRangeIdx ]) / eleCnt );
_cmPrintf(fd," using %i ", 1 );
}
else
_cmPrintf(fd," using %i:%i ", dimCnt==1 ? 0 : 1, dimCnt==1 ? 1 : 2 );
if( dp->legendStrH != NULL )
_cmPrintf(fd," title '%s' ", dp->legendStrH);
else
_cmPrintf(fd, " notitle ");
bool impulseFl = cmIsFlag(dp->flags,kImpulse_PdFl );
if( impulseFl || (dp->lineId != kInvalidLineId) || (dp->pointId != kInvalidPlotPtId) )
{
_cmPrintf(fd," with ");
if( impulseFl )
_cmPrintf(fd,"impulses");
else
{
if( dp->lineId != kInvalidLineId )
_cmPrintf(fd,"lines");
if( dp->pointId != kInvalidPlotPtId )
_cmPrintf(fd,"points pt %i ", dp->pointId);
}
if( dp->colorStrH != NULL )
_cmPrintf(fd," lt rgb '%s' ", dp->colorStrH );
}
if( di+1 < dataCnt )
_cmPrintf(fd,",");
else
{
_cmPrintf(fd,"\n");
// for each data set contained in this plot
for(di=0; di<dataCnt; ++di)
{
cmPlotData* dp = p->dataPtrArray[di];
//acDM* mp = dp->xyzMtxPtr;
unsigned eleCnt = dp->cn; //acDM_Cols(mp);
const double* ddp = dp->xyzMtxPtr; //acDM_ConstPtr(mp);
// if we are printing the output to the console instead of sending it too gnuplot
if( fd == fileno(stdout) )
{
if( printDataFl )
{
unsigned i = 0;
for(i=0; i<eleCnt; ++i )
ddp=_cmPrintData( fd, i,ddp, 0, 0 );
}
}
else
{
// Note: each row contains a of the matrix contains the data for a given dimension
// (e.g. x coords are in row 0, y coords are in row 1, etc). If the matrix contains
// multiple rows then writing the matrix memory buffer out linearly will result
// in interleaving the coordinates as: x0 y0 x1 y1 x2 y2 ....
write(fd,ddp,dp->rn*eleCnt*sizeof(double));
}
}
}
} // if dataCnt > 0
} // for ci
} // for ri
/*
_cmPrintf(fd,"\n");
for(ri=0; ri<_cmpp->rowCnt; ++ri)
for(ci=0; ci<_cmpp->colCnt; ++ci)
{
// get the plot at ri,ci
cmPlot* p = cmPlotVect_Ptr(_cmpp->plotPtrArray,_acRowColToPlotIndex(_cmpp,ri,ci));
// get the count of data sets assigned to this plot
unsigned dataCnt = cmPlotDataVect_Count(p->dataPtrArray);
// for each data set contained in this plot
for(di=0; di<dataCnt; ++di)
{
cmPlotData* dp = cmPlotDataVect_Ptr(p->dataPtrArray,di);
acDM* mp = dp->xyzMtxPtr;
unsigned eleCnt = acDM_Cols(mp);
const double* ddp = acDM_ConstPtr(mp);
// if we are printing the output to the console instead of sending it too gnuplot
if( fd == fileno(stdout) )
{
if( printDataFl )
{
unsigned i = 0;
for(i=0; i<eleCnt; ++i )
ddp=_acPrintData( fd, i,ddp, 0, 0 );
}
}
else
{
// Note: each row contains a of the matrix contains the data for a given dimension
// (e.g. x coords are in row 0, y coords are in row 1, etc). If the matrix contains
// multiple rows then writing the matrix memory buffer out linearly will result
// in interleaving the coordinates as: x0 y0 x1 y1 x2 y2 ....
write(fd,ddp,acDM_Rows(mp)*eleCnt*sizeof(double));
}
}
}
*/
_cmPrintf(fd,"\nunset multiplot\n");
return kOkPlRC;
}
cmRC_t cmPlotDraw()
{
return _cmPlotDraw(_cmpp->pipeFd[1],false);
}
cmRC_t cmPlotPrint( bool printDataFl )
{
return _cmPlotDraw(fileno(stdout),printDataFl);
}
cmRC_t cmPlotDrawAndPrint( bool printDataFl )
{
cmPlotDraw();
return _cmPlotDraw(fileno(stdout),printDataFl);
}
// ncl - min column value
// nch - max column value
// nrl - min row value
// nrh - max row value
int fwrite_matrix(FILE* fout, float**m, int nrl, int nrh, int ncl, int nch, float* row_title, float* column_title)
{
int j;
float length;
int col_length;
int status;
// calc the number of columns
length = (float)(col_length = nch-ncl+1);
printf("cols:%i %f\n",col_length,length);
// write the number of columns
if((status = fwrite((char*)&length,sizeof(float),1,fout))!=1)
{
fprintf(stderr,"fwrite 1 returned %d\n",status);
return(0);
}
// write the column titles
fwrite((char*)column_title,sizeof(float),col_length,fout);
// write the row_title followed by the data on each line
for(j=nrl; j<=nrh; j++)
{
fwrite( (char*)&row_title[j], sizeof(float), 1, fout);
fwrite( (char*)(m[j]+ncl), sizeof(float), col_length,fout);
printf("%i %li\n",j,ftell(fout));
}
return(1);
}
// Generate a 'matrix-binary' data file for use with: plot "data0.bin" binary
void cmPlotWriteBinaryMatrix()
{
const char fn[] = "/home/kevin/src/gnuplot/data0.bin";
unsigned rn = 2; // row cnt
unsigned cn = 16; // col cnt
float srate = 16;
float d[rn*cn];
//float* m[rn];
float c[cn];
//float r[rn];
unsigned i;
for(i=0; i<cn; ++i)
{
d[i] = (float)sin(2*M_PI*i/srate);
d[cn + i] = (float)cos(2*M_PI*i/srate);
c[i] = i;
}
//m[0] = d;
//r[0] = 0;
FILE* fp = fopen(fn,"wb");
float fcn = cn;
fwrite((char*)&fcn,sizeof(fcn),1,fp); // write the count of columns
fwrite((char*)c,sizeof(float),cn,fp); // write the column labels
for(i=0; i<rn; ++i)
{
fwrite((char*)&i,sizeof(float),1,fp); // write the row label
fwrite((char*)(d +(i*cn)),sizeof(float),cn,fp); // write a data row
}
fclose(fp);
}
// Generate a 'matrix-binary' data file for use with: plot "data1.bin" binary record=16x2 using 1:2
void cmPlotWriteBinaryGeneralExample()
{
const char fn[] = "/home/kevin/src/gnuplot/data1.bin";
unsigned rn = 16; // row cnt
unsigned cn = 2; // col cnt
float srate = 16;
float d[rn*cn];
unsigned i;
for(i=0; i<rn; ++i)
{
d[(i*cn)+0] = (float)cos(2*M_PI*i/srate);
d[(i*cn)+1] = (float)sin(2*M_PI*i/srate);
}
FILE* fp = fopen(fn,"wb");
fwrite((char*)d,sizeof(float),rn*cn,fp);
fclose(fp);
}
Fai riferimento in un nuovo problema Visualizza Git Blame Copia Permalink