int main(int argc, char **argv)
{
AjPSeq seq;
AjPGraph graph = 0;
AjPFile outf = NULL;
AjPFile file = NULL;
AjPStr buffer = NULL;
float twist[4][4][4];
float roll[4][4][4];
float tilt[4][4][4];
float rbend;
float rcurve;
float bendscale;
float curvescale;
float twistsum = (float) 0.0;
float pi = (float) 3.14159;
float pifac = (pi/(float) 180.0);
float pi2 = pi/(float) 2.0;
ajint *iseq = NULL;
float *x;
float *y;
float *xave;
float *yave;
float *curve;
float *bend;
const char *ptr;
ajint i;
ajint ii;
ajint k;
ajint j;
char residue[2];
float maxbend;
float minbend;
float bendfactor;
float maxcurve;
float mincurve;
float curvefactor;
float fxp;
float fyp;
float yincr;
float yy1;
ajint ixlen;
ajint iylen;
ajint ixoff;
ajint iyoff;
float ystart;
float defheight;
float currentheight;
ajint count;
ajint portrait = 0;
ajint title = 0;
ajint numres;
ajint ibeg;
ajint iend;
ajint ilen;
AjPStr sstr = NULL;
ajint ipos;
float dx;
float dy;
float rxsum;
float rysum;
float yp1;
float yp2;
double td;
embInit("banana", argc, argv);
seq = ajAcdGetSeq("sequence");
file = ajAcdGetDatafile("anglesfile");
outf = ajAcdGetOutfile("outfile");
graph = ajAcdGetGraph("graph");
numres = ajAcdGetInt("residuesperline");
ibeg = ajSeqGetBegin(seq);
iend = ajSeqGetEnd(seq);
ajStrAssignSubS(&sstr, ajSeqGetSeqS(seq), ibeg-1, iend-1);
ilen = ajStrGetLen(sstr);
AJCNEW0(iseq,ilen+1);
AJCNEW0(x,ilen+1);
AJCNEW0(y,ilen+1);
AJCNEW0(xave,ilen+1);
AJCNEW0(yave,ilen+1);
AJCNEW0(curve,ilen+1);
AJCNEW0(bend,ilen+1);
ptr= ajStrGetPtr(sstr);
for(ii=0;ii<ilen;ii++)
{
if(*ptr=='A' || *ptr=='a')
iseq[ii+1] = 0;
else if(*ptr=='T' || *ptr=='t')
iseq[ii+1] = 1;
else if(*ptr=='G' || *ptr=='g')
iseq[ii+1] = 2;
else if(*ptr=='C' || *ptr=='c')
iseq[ii+1] = 3;
else
ajErr("%c is not an ATCG hence not valid",*ptr);
ptr++;
}
if(!file)
ajErr("Banana failed to open angle file");
ajReadline(file,&buffer); /* 3 junk lines */
ajReadline(file,&buffer);
ajReadline(file,&buffer);
for(k=0;k<4;k++)
for(ii=0;ii<4;ii++)
{
if(ajReadline(file,&buffer))
{
sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",
&twist[ii][0][k],&twist[ii][1][k],&twist[ii][2][k],
&twist[ii][3][k]);
}
else
ajErr("Error reading angle file");
for(j=0;j<4;j++)
twist[ii][j][k] *= pifac;
}
for(k=0;k<4;k++)
for(ii=0;ii<4;ii++)
if(ajReadline(file,&buffer))
{
sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&roll[ii][0][k],
&roll[ii][1][k],&roll[ii][2][k],&roll[ii][3][k]);
}
else
ajErr("Error reading angle file");
for(k=0;k<4;k++)
for(ii=0;ii<4;ii++)
if(ajReadline(file,&buffer))
sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&tilt[ii][0][k],
&tilt[ii][1][k],&tilt[ii][2][k],&tilt[ii][3][k]);
else
ajErr("Error reading angle file");
if(ajReadline(file,&buffer))
sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&rbend,&rcurve,
&bendscale,&curvescale);
else
ajErr("Error reading angle file");
ajFileClose(&file);
ajStrDel(&buffer);
for(ii=1;ii<ilen-1;ii++)
{
twistsum += twist[iseq[ii]][iseq[ii+1]][iseq[ii+2]];
dx = (roll[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*sinfban(twistsum)) +
(tilt[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*sinfban(twistsum-pi2));
dy = roll[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*cosfban(twistsum) +
tilt[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*cosfban(twistsum-pi2);
x[ii+1] = x[ii]+dx;
y[ii+1] = y[ii]+dy;
}
for(ii=6;ii<ilen-6;ii++)
{
rxsum = 0.0;
rysum = 0.0;
for(k=-4;k<=4;k++)
{
rxsum+=x[ii+k];
rysum+=y[ii+k];
}
rxsum+=(x[ii+5]*(float)0.5);
rysum+=(y[ii+5]*(float)0.5);
rxsum+=(x[ii-5]*(float)0.5);
rysum+=(y[ii-5]*(float)0.5);
xave[ii] = rxsum*(float)0.1;
yave[ii] = rysum*(float)0.1;
}
for(i=(ajint)rbend+1;i<=ilen-(ajint)rbend-1;i++)
{
td = sqrt(((x[i+(ajint)rbend]-x[i-(ajint)rbend])*
(x[i+(ajint)rbend]-x[i-(ajint)rbend])) +
((y[i+(ajint)rbend]-y[i-(ajint)rbend])*
(y[i+(ajint)rbend]-y[i-(ajint)rbend])));
bend[i] = (float) td;
bend[i]*=bendscale;
}
for(i=(ajint)rcurve+6;i<=ilen-(ajint)rcurve-6;i++)
{
td = sqrt(((xave[i+(ajint)rcurve]-
xave[i-(ajint)rcurve])*(xave[i+(ajint)rcurve]-
xave[i-(ajint)rcurve]))+
((yave[i+(ajint)rcurve]-yave[i-(ajint)rcurve])*
(yave[i+(ajint)rcurve]-yave[i-(ajint)rcurve])));
curve[i] = (float) td;
}
if(outf)
{
ajFmtPrintF(outf,"Base Bend Curve\n");
ptr = ajStrGetPtr(sstr);
for(ii=1;ii<=ilen;ii++)
{
ajFmtPrintF(outf,"%c %6.1f %6.1f\n",
*ptr, bend[ii], curve[ii]);
ptr++;
}
ajFileClose(&outf);
}
if(graph)
{
maxbend = minbend = 0.0;
maxcurve = mincurve = 0.0;
for(ii=1;ii<=ilen;ii++)
{
if(bend[ii] > maxbend)
maxbend = bend[ii];
if(bend[ii] < minbend)
minbend = bend[ii];
if(curve[ii] > maxcurve)
maxcurve = curve[ii];
if(curve[ii] < mincurve)
mincurve = curve[ii];
}
ystart = 75.0;
ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq));
ajGraphicsSetPagesize(960, 768);
ajGraphOpenWin(graph,(float)-1.0, (float)numres+(float)10.0,
(float)0.0, ystart+(float)5.0);
ajGraphicsGetParamsPage(&fxp,&fyp,&ixlen,&iylen,&ixoff,&iyoff);
if(portrait)
{
ixlen = 768;
iylen = 960;
}
else
{
ixlen = 960;
iylen = 768;
}
ajGraphicsGetCharsize(&defheight,¤theight);
if(!currentheight)
{
defheight = currentheight = (float) 4.440072;
currentheight = defheight *
((float)ixlen/ ((float)(numres)*(currentheight+(float)1.0)))
/currentheight;
}
ajGraphicsSetCharscale(((float)ixlen/((float)(numres)*
(currentheight+(float)1.0)))/
currentheight);
ajGraphicsGetCharsize(&defheight,¤theight);
yincr = (currentheight + (float)3.0)*(float)0.3;
if(!title)
yy1 = ystart;
else
yy1 = ystart-(float)5.0;
count = 1;
residue[1]='\0';
bendfactor = (3*yincr)/maxbend;
curvefactor = (3*yincr)/maxcurve;
ptr = ajStrGetPtr(sstr);
yy1 = yy1-(yincr*((float)5.0));
for(ii=1;ii<=ilen;ii++)
{
if(count > numres)
{
yy1 = yy1-(yincr*((float)5.0));
if(yy1<1.0)
{
if(!title)
yy1=ystart;
else
yy1 = ystart-(float)5.0;
yy1 = yy1-(yincr*((float)5.0));
ajGraphNewpage(graph,AJFALSE);
}
count = 1;
}
residue[0] = *ptr;
ajGraphicsDrawposTextAtend((float)(count)+(float)2.0,yy1,residue);
if(ii>1 && ii < ilen)
{
yp1 = yy1+yincr + (bend[ii]*bendfactor);
yp2 = yy1+yincr + (bend[ii+1]*bendfactor);
ajGraphicsDrawposLine((float)count+(float)1.5,yp1,
(float)(count)+(float)2.5,yp2);
}
ipos = ilen-(ajint)rcurve-7;
if(ipos < 0)
ipos = 0;
if(ii>rcurve+5 && ii<ipos)
{
yp1 = yy1+yincr + (curve[ii]*curvefactor);
yp2 = yy1+yincr + (curve[ii+1]*curvefactor);
ajGraphicsDrawposLine((float)count+(float)1.7,yp1,
(float)(count)+(float)2.3,yp2);
}
ajGraphicsDrawposLine((float)count+(float)1.5,yy1+yincr,
(float)(count)+(float)2.5,yy1+yincr);
count++;
ptr++;
}
ajGraphicsClose();
}
AJFREE(iseq);
AJFREE(x);
AJFREE(y);
AJFREE(xave);
AJFREE(yave);
AJFREE(curve);
AJFREE(bend);
ajStrDel(&sstr);
ajSeqDel(&seq);
ajFileClose(&file);
ajFileClose(&outf);
ajGraphxyDel(&graph);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPFile infile = NULL;
AjPFile outfile = NULL;
AjPStr line;
AjPGraph graphLB = NULL;
AjPGraphdata xygraph = NULL;
AjPGraphdata xygraph2 = NULL;
AjBool doplot;
ajint N=0;
float *xdata = NULL;
float *ydata = NULL;
float *V = NULL;
float *S = NULL;
float a;
float b;
float upperXlimit;
float upperYlimit;
float A;
float B;
float C;
float D;
float xmin;
float xmax;
float ymin;
float ymax;
float xmin2;
float xmax2;
float ymin2;
float ymax2;
float Vmax;
float Km;
float cutx;
float cuty;
float amin = 0.;
float amax = 0.;
float bmin = 0.;
float bmax = 0.;
embInit("findkm", argc, argv);
infile = ajAcdGetInfile("infile");
outfile = ajAcdGetOutfile ("outfile");
doplot = ajAcdGetBoolean("plot");
graphLB = ajAcdGetGraphxy("graphLB");
line = ajStrNew();
/* Determine N by reading infile */
while(ajReadlineTrim(infile, &line))
if(ajStrGetLen(line) >0)
N++;
/* only allocate memory to the arrays */
AJCNEW(xdata, N);
AJCNEW(ydata, N);
AJCNEW(S, N);
AJCNEW(V, N);
ajFileSeek(infile, 0L, 0);
N=0;
while(ajReadlineTrim(infile, &line))
{
if(ajStrGetLen(line) > 0)
{
sscanf(ajStrGetPtr(line),"%f %f",&S[N],&V[N]);
if(S[N] > 0.0 && V[N] > 0.0)
{
xdata[N] = S[N];
ydata[N] = S[N]/V[N];
N++;
}
}
}
/* find the max and min values for the graph parameters*/
xmin = (float)0.5*findkm_findmin(xdata, N);
xmax = (float)1.5*findkm_findmax(xdata, N);
ymin = (float)0.5*findkm_findmin(ydata, N);
ymax = (float)1.5*findkm_findmax(ydata, N);
xmin2 = (float)0.5*findkm_findmin(S, N);
xmax2 = (float)1.5*findkm_findmax(S, N);
ymin2 = (float)0.5*findkm_findmin(V, N);
ymax2 = (float)1.5*findkm_findmax(V, N);
/*
** In case the casted ints turn out to be same number on the axis,
** make the max number larger than the min so graph can be seen.
*/
if((ajint)xmax == (ajint)xmin)
++xmax;
if((ajint)ymax == (ajint)ymin)
++ymax;
if((ajint)xmax2 == (ajint)xmin2)
++xmax2;
if((ajint)ymax2 == (ajint)ymin2)
++ymax2;
/*
** Gaussian Elimination for Best-fit curve plotting and
** calculating Km and Vmax
*/
A = findkm_summation(xdata, N);
B = findkm_summation(ydata, N);
C = findkm_multisum(xdata, ydata, N);
D = findkm_multisum(xdata, xdata, N);
/*
** To find the best fit line, Least Squares Fit: y =ax +b;
** Two Simultaneous equations, REARRANGE FOR b
**
** findkm_summation(ydata, N) - findkm_summation(xdata,N)*a - N*b =0;
** b = (findkm_summation(ydata,N) - findkm_summation(xdata,N)*a) / N;
** b = (B - A*a)/ N;
**
** C - D*a - A*((B - A*a)/ N) =0;
** C - D*a - A*B/N + A*A*a/N =0;
** C - A*B/N = D*a - A*A*a/N;
*/
/* REARRANGE FOR a */
a = (N*C - A*B)/ (N*D - A*A);
b = (B - A*a)/ N;
/*
** Equation of Line - Lineweaver burk eqn
** 1/V = (Km/Vmax)*(1/S) + 1/Vmax;
*/
Vmax = 1/a;
Km = b/a;
cutx = -1/Km;
cuty = Km/Vmax;
/* set limits for last point on graph */
upperXlimit = findkm_findmax(xdata,N)+3;
upperYlimit = (upperXlimit)*a + b;
ajFmtPrintF(outfile, "---Hanes Woolf Plot Calculations---\n");
ajFmtPrintF(outfile, "Slope of best fit line is a = %.2f\n", a);
ajFmtPrintF(outfile,"Coefficient in Eqn of line y = ma +b is b "
"= %.2f\n", b);
ajFmtPrintF(outfile, "Where line cuts x axis = (%.2f, 0)\n", cutx);
ajFmtPrintF(outfile, "Where line cuts y axis = (0, %.2f)\n", cuty);
ajFmtPrintF(outfile, "Limit-point of graph for plot = (%.2f, %.2f)\n\n",
upperXlimit, upperYlimit);
ajFmtPrintF(outfile, "Vmax = %.2f, Km = %f\n",Vmax, Km);
/* draw graphs */
if(doplot)
{
xygraph = ajGraphdataNewI(N);
ajGraphdataAddXY(xygraph, S, V);
ajGraphDataAdd(graphLB, xygraph);
ajGraphdataSetTitleC(xygraph, "Michaelis Menten Plot");
ajGraphdataSetXlabelC(xygraph, "[S]");
ajGraphdataSetYlabelC(xygraph, "V");
ajGraphxySetXstartF(graphLB, 0.0);
ajGraphxySetXendF(graphLB, xmax2);
ajGraphxySetYstartF(graphLB, 0.0);
ajGraphxySetYendF(graphLB, ymax2);
ajGraphxySetXrangeII(graphLB, (ajint)0.0, (ajint)xmax2);
ajGraphxySetYrangeII(graphLB, (ajint)0.0, (ajint)ymax2);
ajGraphdataAddposLine(xygraph, 0.0, 0.0, S[0], V[0], (ajint)BLACK);
ajGraphxyShowPointsCircle(graphLB, ajTrue);
ajGraphdataSetMinmax(xygraph,0.0,xmax2,0.0,ymax2);
ajGraphicsCalcRange(S,N,&amin,&amax);
ajGraphicsCalcRange(V,N,&bmin,&bmax);
ajGraphdataSetTruescale(xygraph,amin,amax,bmin,bmax);
ajGraphdataSetTypeC(xygraph,"2D Plot Float");
xygraph2 = ajGraphdataNewI(N);
ajGraphdataAddXY(xygraph2, xdata, ydata);
ajGraphDataAdd(graphLB, xygraph2);
ajGraphdataSetTitleC(xygraph2, "Hanes Woolf Plot");
ajGraphdataSetXlabelC(xygraph2, "[S]");
ajGraphdataSetYlabelC(xygraph2, "[S]/V");
ajGraphxySetXstartF(graphLB, cutx);
ajGraphxySetXendF(graphLB, upperXlimit);
ajGraphxySetYstartF(graphLB, 0.0);
ajGraphxySetYendF(graphLB, upperYlimit);
ajGraphxySetXrangeII(graphLB, (ajint)cutx, (ajint)upperXlimit);
ajGraphxySetYrangeII(graphLB, (ajint)0.0, (ajint)upperYlimit);
ajGraphxyShowPointsCircle(graphLB, ajTrue);
ajGraphdataSetMinmax(xygraph2, cutx,upperXlimit,0.0,upperYlimit);
ajGraphicsCalcRange(xdata,N,&amin,&amax);
ajGraphicsCalcRange(ydata,N,&bmin,&bmax);
ajGraphdataSetTruescale(xygraph2,amin,amax,bmin,bmax);
ajGraphdataSetTypeC(xygraph2,"2D Plot");
ajGraphSetTitleC(graphLB,"FindKm");
ajGraphxySetflagOverlay(graphLB,ajFalse);
ajGraphxyDisplay(graphLB, ajTrue);
}
AJFREE(xdata);
AJFREE(ydata);
AJFREE(S);
AJFREE(V);
ajFileClose(&infile);
ajFileClose(&outfile);
ajGraphxyDel(&graphLB);
ajStrDel(&line);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeq seq1;
AjPSeq seq2;
ajint wordlen;
AjPTable seq1MatchTable = 0;
AjPList matchlist = NULL;
AjPGraph graph = NULL;
AjPGraph xygraph = NULL;
AjBool boxit;
/*
** Different ticks as they need to be different for x and y due to
** length of string being important on x
*/
ajuint acceptableticksx[]=
{
1,10,50,100,500,1000,1500,10000,
500000,1000000,5000000
};
ajuint acceptableticks[]=
{
1,10,50,100,200,500,1000,2000,5000,10000,15000,
500000,1000000,5000000
};
ajint numbofticks = 10;
float xmargin;
float ymargin;
float ticklen;
float tickgap;
float onefifth = 0.0;
ajint i;
float k;
float max;
char ptr[10];
ajint begin1;
ajint begin2;
ajint end1;
ajint end2;
ajuint len1;
ajuint len2;
float fbegin1;
float fbegin2;
float fend1;
float fend2;
float flen1;
float flen2;
AjBool stretch;
embInit("dottup", argc, argv);
wordlen = ajAcdGetInt("wordsize");
seq1 = ajAcdGetSeq("asequence");
seq2 = ajAcdGetSeq("bsequence");
graph = ajAcdGetGraph("graph");
boxit = ajAcdGetBoolean("boxit");
stretch = ajAcdGetToggle("stretch");
xygraph = ajAcdGetGraphxy("xygraph");
begin1 = ajSeqGetBegin(seq1);
begin2 = ajSeqGetBegin(seq2);
end1 = ajSeqGetEnd(seq1);
end2 = ajSeqGetEnd(seq2);
len1 = end1 - begin1 + 1;
len2 = end2 - begin2 + 1;
flen1 = (float) len1;
flen2 = (float) len2;
fbegin1 = (float) begin1;
fbegin2 = (float) begin2;
fend1 = (float) end1;
fend2 = (float) end2;
offset1 = fbegin1;
offset2 = fbegin2;
ajSeqTrim(seq1);
ajSeqTrim(seq2);
embWordLength(wordlen);
if(embWordGetTable(&seq1MatchTable, seq1))
matchlist = embWordBuildMatchTable(seq1MatchTable, seq2, ajTrue);
if(stretch)
{
dottup_stretchplot(xygraph,matchlist,seq1,seq2,begin1,begin2,end1,
end2);
if(matchlist)
embWordMatchListDelete(&matchlist); /* free the match structures */
}
else
{
/* only here if stretch is false */
max= flen1;
if(flen2 > max)
max = flen2;
xmargin = ymargin = max * (float)0.15;
ajGraphOpenWin(graph, fbegin1-ymargin,fend1+ymargin,
fbegin2-xmargin,(float)fend2+xmargin);
ajGraphicsSetCharscale(0.5);
if(matchlist)
dottup_plotMatches(matchlist);
if(boxit)
{
ajGraphicsDrawposRect(fbegin1, fbegin2, fend1, fend2);
i = 0;
while(acceptableticksx[i]*numbofticks < len1)
i++;
if(i<=13)
tickgap = (float) acceptableticksx[i];
else
tickgap = (float) acceptableticksx[10];
ticklen = xmargin * (float) 0.1;
onefifth = xmargin * (float)0.2;
ajGraphicsDrawposTextAtmid(fbegin1+flen1*(float)0.5,
fbegin1-(onefifth*(float)3.0),
ajGraphGetYlabelC(graph));
if(len2/len1 > 10 )
{
/* a lot smaller then just label start and end */
ajGraphicsDrawposLine(fbegin1,fbegin2,fbegin1,
fbegin2-ticklen);
sprintf(ptr,"%u",ajSeqGetOffset(seq1));
ajGraphicsDrawposTextAtmid(fbegin1,fbegin2-(onefifth),ptr);
ajGraphicsDrawposLine(fend1,fbegin2,
fend1,fbegin2-ticklen);
sprintf(ptr,"%d",end1);
ajGraphicsDrawposTextAtmid(fend1,fbegin2-(onefifth),ptr);
}
else
for(k=fbegin1;k<fend1;k+=tickgap)
{
ajGraphicsDrawposLine(k,fbegin2,k,fbegin2-ticklen);
sprintf(ptr,"%d",(ajint)k);
ajGraphicsDrawposTextAtmid( k,fbegin2-(onefifth),ptr);
}
i = 0;
while(acceptableticks[i]*numbofticks < len2)
i++;
tickgap = (float) acceptableticks[i];
ticklen = ymargin*(float)0.1;
onefifth = ymargin*(float)0.2;
ajGraphicsDrawposTextAtlineJustify(fbegin1-(onefifth*(float)4.),
fbegin2+flen2*(float)0.5,
fbegin2-(onefifth*(float)4.),
fbegin2+flen2,
ajGraphGetXlabelC(graph),
0.5);
if(len1/len2 > 10 )
{
/* a lot smaller then just label start and end */
ajGraphicsDrawposLine(fbegin1,fbegin2,fbegin1-ticklen,
fbegin2);
sprintf(ptr,"%u",ajSeqGetOffset(seq2));
ajGraphicsDrawposTextAtend(fbegin1-(onefifth),fbegin2,ptr);
ajGraphicsDrawposLine(fbegin1,fend2,fbegin1-ticklen,
fend2);
sprintf(ptr,"%d",end2);
ajGraphicsDrawposTextAtend(fbegin2-(onefifth),fend2,ptr);
}
else
for(k=fbegin2;k<fend2;k+=tickgap)
{
ajGraphicsDrawposLine(fbegin1,k,fbegin1-ticklen,k);
sprintf(ptr,"%d",(ajint)k);
ajGraphicsDrawposTextAtend(fbegin1-(onefifth),k,ptr);
}
}
}
ajGraphicsClose();
ajSeqDel(&seq1);
ajSeqDel(&seq2);
ajGraphxyDel(&graph);
ajGraphxyDel(&xygraph);
embWordFreeTable(&seq1MatchTable);
if(matchlist)
embWordMatchListDelete(&matchlist); /* free the match structures */
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList list = NULL;
AjPSeq seq;
AjPSeq seq2;
AjPStr aa0str = 0;
AjPStr aa1str = 0;
const char *s1;
const char *s2;
char *strret = NULL;
ajuint i;
ajuint j;
ajuint k;
ajint l;
ajint abovethresh;
ajint total;
ajint starti = 0;
ajint startj = 0;
ajint windowsize;
float thresh;
AjPGraph graph = NULL;
AjPGraph xygraph = NULL;
float flen1;
float flen2;
ajuint len1;
ajuint len2;
AjPTime ajtime = NULL;
time_t tim;
AjBool boxit=AJTRUE;
/* Different ticks as they need to be different for x and y due to
length of string being important on x */
ajuint acceptableticksx[]=
{
1,10,50,100,500,1000,1500,10000,
500000,1000000,5000000
};
ajuint acceptableticks[]=
{
1,10,50,100,200,500,1000,2000,5000,10000,15000,
500000,1000000,5000000
};
ajint numbofticks = 10;
float xmargin;
float ymargin;
float ticklen;
float tickgap;
float onefifth;
float k2;
float max;
char ptr[10];
AjPMatrix matrix = NULL;
ajint** sub;
AjPSeqCvt cvt;
AjPStr subt = NULL;
ajint b1;
ajint b2;
ajint e1;
ajint e2;
AjPStr se1;
AjPStr se2;
ajint ithresh;
AjBool stretch;
PPoint ppt = NULL;
float xa[1];
float ya[1];
AjPGraphdata gdata=NULL;
AjPStr tit = NULL;
AjIList iter = NULL;
float x1 = 0.;
float x2 = 0.;
float y1 = 0.;
float y2 = 0.;
ajuint tui;
se1 = ajStrNew();
se2 = ajStrNew();
embInit("dotmatcher", argc, argv);
seq = ajAcdGetSeq("asequence");
seq2 = ajAcdGetSeq("bsequence");
stretch = ajAcdGetToggle("stretch");
graph = ajAcdGetGraph("graph");
xygraph = ajAcdGetGraphxy("xygraph");
windowsize = ajAcdGetInt("windowsize");
ithresh = ajAcdGetInt("threshold");
matrix = ajAcdGetMatrix("matrixfile");
sub = ajMatrixGetMatrix(matrix);
cvt = ajMatrixGetCvt(matrix);
thresh = (float)ithresh;
ajtime = ajTimeNew();
tim = time(0);
ajTimeSetLocal(ajtime, tim);
b1 = ajSeqGetBegin(seq);
b2 = ajSeqGetBegin(seq2);
e1 = ajSeqGetEnd(seq);
e2 = ajSeqGetEnd(seq2);
len1 = ajSeqGetLen(seq);
len2 = ajSeqGetLen(seq2);
tui = ajSeqGetLen(seq);
flen1 = (float) tui;
tui = ajSeqGetLen(seq2);
flen2 = (float) tui;
ajStrAssignSubC(&se1,ajSeqGetSeqC(seq),b1-1,e1-1);
ajStrAssignSubC(&se2,ajSeqGetSeqC(seq2),b2-1,e2-1);
ajSeqAssignSeqS(seq,se1);
ajSeqAssignSeqS(seq2,se2);
s1 = ajStrGetPtr(ajSeqGetSeqS(seq));
s2 = ajStrGetPtr(ajSeqGetSeqS(seq2));
aa0str = ajStrNewRes(1+len1); /* length plus trailing blank */
aa1str = ajStrNewRes(1+len2);
list = ajListNew();
for(i=0;i<len1;i++)
ajStrAppendK(&aa0str,(char)ajSeqcvtGetCodeK(cvt, *s1++));
for(i=0;i<len2;i++)
ajStrAppendK(&aa1str,(char)ajSeqcvtGetCodeK(cvt, *s2++));
max = (float)len1;
if(len2 > max)
max = (float) len2;
xmargin = ymargin = max *(float)0.15;
ticklen = xmargin*(float)0.1;
onefifth = xmargin*(float)0.2;
subt = ajStrNewC((strret=
ajFmtString("(windowsize = %d, threshold = %3.2f %D)",
windowsize,thresh,ajtime)));
if(!stretch)
{
if( ajStrGetLen(ajGraphGetSubtitleS(graph)) <=1)
ajGraphSetSubtitleS(graph,subt);
ajGraphOpenWin(graph, (float)0.0-ymargin,(max*(float)1.35)+ymargin,
(float)0.0-xmargin,(float)max+xmargin);
ajGraphicsDrawposTextAtmid(flen1*(float)0.5,
(float)0.0-(xmargin/(float)2.0),
ajGraphGetXlabelC(graph));
ajGraphicsDrawposTextAtlineJustify((float)0.0-(xmargin*(float)0.75),
flen2*(float)0.5,
(float)0.0-(xmargin*(float)0.75),flen1,
ajGraphGetYlabelC(graph),0.5);
ajGraphicsSetCharscale(0.5);
}
s1= ajStrGetPtr(aa0str);
s2 = ajStrGetPtr(aa1str);
for(j=0; (ajint)j < (ajint)len2-windowsize;j++)
{
i =0;
total = 0;
abovethresh =0;
k = j;
for(l=0;l<windowsize;l++)
total = total + sub[(ajint)s1[i++]][(ajint)s2[k++]];
if(total >= thresh)
{
abovethresh=1;
starti = i-windowsize;
startj = k-windowsize;
}
while(i < len1 && k < len2)
{
total = total - sub[(ajint)s1[i-windowsize]]
[(ajint)s2[k-windowsize]];
total = total + sub[(ajint)s1[i]][(ajint)s2[k]];
if(abovethresh)
{
if(total < thresh)
{
abovethresh = 0;
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)i-1,(float)k-1,stretch);
}
}
else if(total >= thresh)
{
starti = i-windowsize;
startj = k-windowsize;
abovethresh= 1;
}
i++;
k++;
}
if(abovethresh)
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)i-1,(float)k-1,
stretch);
}
for(i=0; (ajint)i < (ajint)len1-windowsize;i++)
{
j = 0;
total = 0;
abovethresh =0;
k = i;
for(l=0;l<windowsize;l++)
total = total + sub[(ajint)s1[k++]][(ajint)s2[j++]];
if(total >= thresh)
{
abovethresh=1;
starti = k-windowsize;
startj = j-windowsize;
}
while(k < len1 && j < len2)
{
total = total - sub[(ajint)s1[k-windowsize]]
[(ajint)s2[j-windowsize]];
total = total + sub[(ajint)s1[k]][(ajint)s2[j]];
if(abovethresh)
{
if(total < thresh)
{
abovethresh = 0;
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)k-1,(float)j-1,stretch);
}
}
else if(total >= thresh)
{
starti = k-windowsize;
startj = j-windowsize;
abovethresh= 1;
}
j++;
k++;
}
if(abovethresh)
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)k-1,(float)j-1,
stretch);
}
if(boxit && !stretch)
{
ajGraphicsDrawposRect(0.0,0.0,flen1, flen2);
i=0;
while(acceptableticksx[i]*numbofticks < len1)
i++;
if(i<=13)
tickgap = (float)acceptableticksx[i];
else
tickgap = (float)acceptableticksx[10];
ticklen = xmargin*(float)0.1;
onefifth = xmargin*(float)0.2;
if(len2/len1 > 10 )
{
/* if a lot smaller then just label start and end */
ajGraphicsDrawposLine((float)0.0,(float)0.0,(float)0.0,(float)0.0-ticklen);
sprintf(ptr,"%d",b1-1);
ajGraphicsDrawposTextAtmid((float)0.0,(float)0.0-(onefifth),ptr);
ajGraphicsDrawposLine(flen1,(float)0.0,
flen1,(float)0.0-ticklen);
sprintf(ptr,"%d",len1+b1-1);
ajGraphicsDrawposTextAtmid(flen1,(float)0.0-(onefifth),ptr);
}
else
for(k2=0.0;k2<len1;k2+=tickgap)
{
ajGraphicsDrawposLine(k2,(float)0.0,k2,(float)0.0-ticklen);
sprintf(ptr,"%d",(ajint)k2+b1-1);
ajGraphicsDrawposTextAtmid(k2,(float)0.0-(onefifth),ptr);
}
i = 0;
while(acceptableticks[i]*numbofticks < len2)
i++;
tickgap = (float)acceptableticks[i];
ticklen = ymargin*(float)0.01;
onefifth = ymargin*(float)0.02;
if(len1/len2 > 10 )
{
/* if a lot smaller then just label start and end */
ajGraphicsDrawposLine((float)0.0,(float)0.0,(float)0.0-ticklen,(float)0.0);
sprintf(ptr,"%d",b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),(float)0.0,ptr);
ajGraphicsDrawposLine((float)0.0,flen2,(float)0.0-ticklen,
flen2);
sprintf(ptr,"%d",len2+b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),flen2,ptr);
}
else
for(k2=0.0;k2<len2;k2+=tickgap)
{
ajGraphicsDrawposLine((float)0.0,k2,(float)0.0-ticklen,k2);
sprintf(ptr,"%d",(ajint)k2+b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),k2,ptr);
}
}
if(!stretch)
ajGraphicsClose();
else /* the xy graph for -stretch */
{
tit = ajStrNew();
ajFmtPrintS(&tit,"%S",ajGraphGetTitleS(xygraph));
gdata = ajGraphdataNewI(1);
xa[0] = (float)b1;
ya[0] = (float)b2;
ajGraphSetTitleC(xygraph,ajStrGetPtr(tit));
ajGraphSetXlabelC(xygraph,ajSeqGetNameC(seq));
ajGraphSetYlabelC(xygraph,ajSeqGetNameC(seq2));
ajGraphdataSetTypeC(gdata,"2D Plot Float");
ajGraphdataSetTitleS(gdata,subt);
ajGraphdataSetMinmax(gdata,(float)b1,(float)e1,(float)b2,
(float)e2);
ajGraphdataSetTruescale(gdata,(float)b1,(float)e1,(float)b2,
(float)e2);
ajGraphxySetXstartF(xygraph,(float)b1);
ajGraphxySetXendF(xygraph,(float)e1);
ajGraphxySetYstartF(xygraph,(float)b2);
ajGraphxySetYendF(xygraph,(float)e2);
ajGraphxySetXrangeII(xygraph,b1,e1);
ajGraphxySetYrangeII(xygraph,b2,e2);
if(list)
{
iter = ajListIterNewread(list);
while((ppt = ajListIterGet(iter)))
{
x1 = ppt->x1+b1-1;
y1 = ppt->y1+b2-1;
x2 = ppt->x2+b1-1;
y2 = ppt->y2+b2-1;
ajGraphAddLine(xygraph,x1,y1,x2,y2,0);
AJFREE(ppt);
}
ajListIterDel(&iter);
}
ajGraphdataAddXY(gdata,xa,ya);
ajGraphDataReplace(xygraph,gdata);
ajGraphxyDisplay(xygraph,ajFalse);
ajGraphicsClose();
ajStrDel(&tit);
}
ajListFree(&list);
ajSeqDel(&seq);
ajSeqDel(&seq2);
ajGraphxyDel(&graph);
ajGraphxyDel(&xygraph);
ajMatrixDel(&matrix);
ajTimeDel(&ajtime);
/* deallocate memory */
ajStrDel(&aa0str);
ajStrDel(&aa1str);
ajStrDel(&se1);
ajStrDel(&se2);
ajStrDel(&subt);
AJFREE(strret); /* created withing ajFmtString */
embExit();
return 0;
}
int main(int argc, char **argv)
{
ajint i;
ajint numseq;
ajint j = 0;
ajint numres;
ajint count;
ajint k;
ajint kmax;
float defheight;
float currentscale;
AjPStr shade = NULL;
AjPFloat pair = NULL;
AjPGraph graph = NULL;
AjPMatrix cmpmatrix = NULL;
AjPSeqCvt cvt = NULL;
AjPStr matcodes = NULL;
AjBool consensus;
AjBool colourbyconsensus;
AjBool colourbyresidues;
AjBool colourbyshade = AJFALSE;
AjBool boxit;
AjBool boxcol;
AjBool portrait;
AjBool collision;
ajint identity;
AjBool listoptions;
ajint alternative;
AjPStr altstr = NULL;
AjPStr sidentity = NULL;
AjPStr ssimilarity = NULL;
AjPStr sother = NULL;
AjPStr sboxcolval = NULL;
AjPStr options = NULL;
/* ajint showscore = 0; */
ajint iboxcolval = 0;
ajint cidentity = RED;
ajint csimilarity = GREEN;
ajint cother = BLACK;
float fxp;
float fyp;
float yincr;
float y;
ajint ixlen;
ajint iylen;
ajint ixoff;
ajint iyoff;
char res[2] = " ";
float *score = 0;
float scoremax = 0;
float *identical = NULL;
ajint identicalmaxindex;
float *matching = NULL;
ajint matchingmaxindex;
float *colcheck = NULL;
ajint **matrix;
ajint m1 = 0;
ajint m2 = 0;
ajint ms = 0;
ajint highindex = 0;
ajint myindex;
ajint *previous = 0;
AjBool iscons = ajFalse;
ajint currentstate = 0;
ajint oldfg = 0;
float fold = 0.0;
ajint *colmat = 0;
ajint *shadecolour = 0;
/* float identthresh = 1.5; */
/* float simthresh = 1.0; */
/* float relthresh = 0.5; */
float part = 0.0;
const char *cptr;
ajint resbreak;
float fplural;
float ystart;
float xmin;
float xmax;
float xmid;
AjPTime ajtime;
ajint gapcount = 0;
ajint countforgap = 0;
ajint boxindex;
float max;
ajint matsize;
ajint seqperpage = 0;
ajint startseq;
ajint endseq;
ajint newILend = 0;
ajint newILstart;
void *freeptr;
ajint itmp;
embInit("prettyplot", argc, argv);
seqset = ajAcdGetSeqset("sequences");
numres = ajAcdGetInt("residuesperline");
resbreak = ajAcdGetInt("resbreak");
ajSeqsetFill(seqset); /* Pads sequence set with gap characters */
numseq = ajSeqsetGetSize(seqset);
graph = ajAcdGetGraph("graph");
colourbyconsensus = ajAcdGetBoolean("ccolours");
colourbyresidues = ajAcdGetBoolean("docolour");
shade = ajAcdGetString("shade");
pair = ajAcdGetArray("pair");
identity = ajAcdGetInt("identity");
boxit = ajAcdGetBoolean("box");
ajtime = ajTimeNewTodayFmt("daytime");
ajSeqsetTrim(seqset);
/* offset = ajSeqsetGetOffset(seqset); Unused */
ajGraphAppendTitleS(graph, ajSeqsetGetUsa(seqset));
if(boxit)
{
AJCNEW(seqboxptr, numseq);
for(i=0;i<numseq;i++)
AJCNEW(seqboxptr[i], ajSeqsetGetLen(seqset));
}
boxcol = ajAcdGetBoolean("boxcol");
sboxcolval = ajAcdGetString("boxuse");
if(boxcol)
{
iboxcolval = ajGraphicsCheckColourS(sboxcolval);
if(iboxcolval == -1)
iboxcolval = GREY;
}
consensus = ajAcdGetBoolean("consensus");
if(consensus)
{
AJCNEW(constr, ajSeqsetGetLen(seqset)+1);
constr[0] = '\0';
}
shownames = ajAcdGetBoolean("name");
shownumbers = ajAcdGetBoolean("number");
charlen = ajAcdGetInt("maxnamelen");
fplural = ajAcdGetFloat("plurality");
portrait = ajAcdGetBoolean("portrait");
collision = ajAcdGetBoolean("collision");
listoptions = ajAcdGetBoolean("listoptions");
altstr = ajAcdGetListSingle("alternative");
cmpmatrix = ajAcdGetMatrix("matrixfile");
ajStrToInt(altstr, &alternative);
matrix = ajMatrixGetMatrix(cmpmatrix);
cvt = ajMatrixGetCvt(cmpmatrix);
matsize = ajMatrixGetSize(cmpmatrix);
AJCNEW(identical,matsize);
AJCNEW(matching,matsize);
AJCNEW(colcheck,matsize);
numgaps = numres/resbreak;
numgaps--;
if(portrait)
{
ajGraphicsSetPortrait(1);
ystart = (float) 75.0;
}
else
ystart = (float) 75.0;
/* pair is an array of three non-negative floats */
/* identthresh = ajFloatGet(pair,0); Unused */
/* simthresh = ajFloatGet(pair,1); Unused */
/* relthresh = ajFloatGet(pair,2); Unused */
/*
** shade is a formatted 4-character string. Characters BLPW only.
** controlled by a pattern in ACD.
*/
if(ajStrGetLen(shade))
{
AJCNEW(shadecolour,4);
cptr = ajStrGetPtr(shade);
for(i=0;i<4;i++){
if(cptr[i]== 'B' || cptr[i]== 'b')
shadecolour[i] = BLACK;
else if(cptr[i]== 'L' || cptr[i]== 'l')
shadecolour[i] = BROWN;
else if(cptr[i]== 'P' || cptr[i]== 'p')
shadecolour[i] = WHEAT;
else if(cptr[i]== 'W' || cptr[i]== 'w')
shadecolour[i] = WHITE;
}
colourbyconsensus = colourbyresidues = ajFalse;
colourbyshade = ajTrue;
}
/*
** we can colour by consensus or residue but not both
** if we have to choose, use the consensus
*/
if(colourbyconsensus && colourbyresidues)
colourbyconsensus = AJFALSE;
sidentity = ajAcdGetString("cidentity");
ssimilarity = ajAcdGetString("csimilarity");
sother = ajAcdGetString("cother");
if(colourbyconsensus)
{
cidentity = ajGraphicsCheckColourS(sidentity);
if(cidentity == -1)
cidentity = RED;
csimilarity = ajGraphicsCheckColourS(ssimilarity);
if(csimilarity == -1)
csimilarity = GREEN;
cother = ajGraphicsCheckColourS(sother);
if(cother == -1)
cother = BLACK;
}
else if(colourbyresidues)
{
matcodes = ajMatrixGetCodes(cmpmatrix);
if(ajSeqsetIsProt(seqset))
colmat = ajGraphicsBasecolourNewProt(matcodes);
else
colmat = ajGraphicsBasecolourNewNuc(matcodes);
}
/* output the options used as the subtitle for the bottom of the graph */
if(listoptions)
{
ajStrAssignC(&options,"");
ajFmtPrintAppS(&options,"-plurality %.1f",fplural);
if(collision)
ajStrAppendC(&options," -collision");
else
ajStrAppendC(&options," -nocollision");
if(boxit)
ajStrAppendC(&options," -box");
else
ajStrAppendC(&options," -nobox");
if(boxcol)
ajStrAppendC(&options," -boxcol");
else
ajStrAppendC(&options," -noboxcol");
if(colourbyconsensus)
ajStrAppendC(&options," -colbyconsensus");
else if(colourbyresidues)
ajStrAppendC(&options," -colbyresidues");
else if(colourbyshade)
ajStrAppendC(&options," -colbyshade");
else
ajStrAppendC(&options," -nocolour");
if(alternative==2)
ajStrAppendC(&options," -alt 2");
else if(alternative==1)
ajStrAppendC(&options," -alt 1");
else if(alternative==3)
ajStrAppendC(&options," -alt 3");
}
AJCNEW(seqcolptr, numseq);
for(i=0;i<numseq;i++)
AJCNEW(seqcolptr[i], ajSeqsetGetLen(seqset));
AJCNEW(seqcharptr, numseq);
AJCNEW(seqnames, numseq);
AJCNEW(score, numseq);
AJCNEW(previous, numseq);
AJCNEW(seqcount, numseq);
for(i=0;i<numseq;i++)
{
ajSeqsetFmtUpper(seqset);
seqcharptr[i] = ajSeqsetGetseqSeqC(seqset, i);
seqnames[i] = 0;
ajStrAppendS(&seqnames[i],ajSeqsetGetseqNameS(seqset, i));
ajStrTruncateLen(&seqnames[i],charlen);
previous[i] = 0;
seqcount[i] = 0;
}
/*
** user will pass the number of residues to fit a page
** therefore we now need to calculate the size of the chars
** based on this and get the new char width.
** 'charlen' maximum characters for the name (truncated above)
*/
ajGraphicsGetCharsize(&defheight,¤tscale);
xmin = -charlen - (float)2.0;
xmax = (float)numres+(float)11.0+(float)(numres/resbreak);
xmid = (xmax + xmin)/(float)2.0;
ajGraphOpenWin(graph, xmin, xmax,
(float)0.0, ystart+(float)1.0);
ajGraphGetParamsPage(graph, &fxp,&fyp,&ixlen,&iylen,&ixoff,&iyoff);
if(portrait)
{
itmp = ixlen;
ixlen = iylen;
iylen = itmp;
}
ajGraphicsGetCharsize(&defheight,¤tscale);
ajGraphicsSetCharscale(((float)ixlen/((float)(numres+charlen+1)*
(currentscale * (float) 1.5)))/
currentscale);
/* ajGraphicsSetCharscale(((float)ixlen/((float)(numres+charlen)*
(currentscale+(float)1.0)))/
currentscale); */
ajGraphicsGetCharsize(&defheight,¤tscale);
yincr = (currentscale + (float)3.0)*(float)0.3;
/*
** If we have titles (now the standard graph title and subtitle and footer)
** leave 7 rows of space for them
*/
y=ystart-(float)7.0;
if(ajStrGetLen(options))
{
fold = ajGraphicsSetCharscale(1.0);
ajGraphicsDrawposTextAtmid(xmid,2.0,
ajStrGetPtr(options));
ajGraphicsSetCharscale(fold);
}
/* if sequences per page not set then calculate it */
if(!seqperpage)
{
seqperpage = prettyplot_calcseqperpage(yincr,y,consensus);
if(seqperpage>numseq)
seqperpage=numseq;
}
count = 0;
/*
** for boxes we need to set a foreground colour for the box lines
** and save the current foreground colour
*/
if(boxit && boxcol)
oldfg = ajGraphicsSetFgcolour(iboxcolval);
/*
** step through each residue position
*/
kmax = ajSeqsetGetLen(seqset) - 1;
for(k=0; k<= kmax; k++)
{
/* reset column score array */
for(i=0;i<numseq;i++)
score[i] = 0.0;
/* reset matrix character testing arrays */
for(i=0;i<matsize;i++)
{
identical[i] = 0.0;
matching[i] = 0.0;
colcheck[i] = 0.0;
}
/* generate a score for this residue in each sequence */
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if(m1 && m2)
score[i] += (float)matrix[m1][m2]*
ajSeqsetGetseqWeight(seqset, j);
}
if(m1)
identical[m1] += ajSeqsetGetseqWeight(seqset, i);
}
/* find the highest score */
highindex = -1;
scoremax = INT_MIN;
/*ajDebug("Scores at position %d:\n", k);*/
for(i=0;i<numseq;i++)
{
/*ajDebug(" seq %d: '%c' %f\n",i,seqcharptr[i][k],score[i]);*/
if(score[i] > scoremax)
{
scoremax = score[i];
highindex = i;
}
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(!matching[m1])
{
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if(m1 && m2 && matrix[m1][m2] > 0)
matching[m1] += ajSeqsetGetseqWeight(seqset, j);
}
}
}
/* find highs for matching and identical */
matchingmaxindex = 0;
identicalmaxindex = 0;
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] > identical[identicalmaxindex])
identicalmaxindex = m1;
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(matching[m1] > matching[matchingmaxindex])
matchingmaxindex = m1;
else if(matching[m1] == matching[matchingmaxindex])
{
if(identical[m1] > identical[matchingmaxindex])
matchingmaxindex= m1;
}
}
iscons = ajFalse;
boxindex = -1;
max = -3;
ajDebug("k:%2d highindex:%2d matching:%4.2f\n",
k, highindex,
matching[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])]);
if(highindex != -1 &&
matching[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])] >= fplural)
{
iscons = ajTrue;
boxindex = highindex;
}
else
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(matching[m1] > max)
{
max = matching[m1];
highindex = i;
}
else if(matching[m1] == max)
{
if(identical[m1] >
identical[ajSeqcvtGetCodeK(cvt,
seqcharptr[highindex][k])] )
{
max = matching[m1];
highindex = i;
}
}
}
if(matching[ajSeqcvtGetCodeK(cvt,
seqcharptr[highindex][k])] >= fplural)
{
iscons = ajTrue;
boxindex = highindex;
}
}
if(iscons)
{
if(!collision)
{
/* check for collisions */
if(alternative == 1)
{
/* check to see if this is unique for collisions */
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] >= identical[identicalmaxindex] &&
m1 != identicalmaxindex)
iscons = ajFalse;
}
/*ajDebug("after (alt=1) iscons: %B",iscons);*/
}
else if(alternative == 2)
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if((matching[m1] >= matching[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] < 0.1)||
(identical[m1] >= identical[matchingmaxindex]
&& m1 != matchingmaxindex))
iscons = ajFalse;
}
}
else if(alternative == 3)
{
/*
** to do this check one is NOT in consensus to see if
** another score of fplural has been found
*/
ms = ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k]);
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(ms != m1 && colcheck[m1] == 0.0)
/* NOT in the current consensus */
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if( matrix[ms][m2] < 0.1)
{
/* NOT in the current consensus */
if( matrix[m1][m2] > 0.1)
colcheck[m1] +=
ajSeqsetGetseqWeight(seqset,
j);
}
}
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
/* if any other matches then we have a collision */
if(colcheck[m1] >= fplural)
iscons = ajFalse;
}
/*ajDebug("after alt=2 iscons: %B", iscons);*/
}
else
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if((matching[m1] >= matching[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] < 0.1))
iscons = ajFalse;
if(identical[m1] >= identical[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] > 0.1)
iscons = ajFalse;
}
if(!iscons)
{ /* matches failed try identicals */
if(identical[identicalmaxindex] >= fplural)
{
iscons = ajTrue;
/*
** if nothing has an equal or higher match that
** does not match highest then false
*/
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] >=
identical[identicalmaxindex] &&
m1 != identicalmaxindex)
iscons = ajFalse;
else if(matching[m1] >=
matching[identicalmaxindex] &&
matrix[m1][matchingmaxindex] <= 0.0)
iscons = ajFalse;
else if(m1 == identicalmaxindex)
j = i;
}
if(iscons)
highindex = j;
}
}
}
}
if(identity)
{
j = 0;
for(i=0;i<numseq;i++)
if(seqcharptr[highindex][k] == seqcharptr[i][k])
j++;
if(j<identity)
iscons = ajFalse;
}
}
/*
** Done a full line of residues
** Boxes have been defined up to this point
*/
if(count >= numres )
{
/* check y position for next set */
y=y-(yincr*((float)numseq+(float)2.0+((float)consensus*(float)2)));
if(y<yincr*((float)numseq+(float)2.0+((float)consensus*(float)2)))
{
/* full page - print it */
y=ystart-(float)6.0;
startseq = 0;
endseq = seqperpage;
newILstart = newILend;
newILend = k;
while(startseq < numseq)
{
/* AJB */
/*if(startseq != 0)
ajGraphNewpage(graph, AJFALSE);*/
/*ajDebug("Inner loop: startseq: %d numseq: %d endseq: %d\n",
startseq, numseq, endseq);*/
if(endseq>numseq)
endseq=numseq;
prettyplot_fillinboxes(numseq,ajSeqsetGetLen(seqset),
startseq,endseq,
newILstart,newILend,
numres,resbreak,
boxit,boxcol,consensus,
ystart,yincr,cvt);
startseq = endseq;
endseq += seqperpage;
ajGraphNewpage(graph, AJFALSE);
}
}
count = 0;
gapcount = 0;
}
count++;
countforgap++;
for(j=0;j<numseq;j++)
{
/* START OF BOXES */
if(boxit)
{
seqboxptr[j][k] = 0;
if(boxindex!=-1)
{
myindex = boxindex;
if(matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[myindex][k])] > 0)
part = 1.0;
else
{
if(identical[ajSeqcvtGetCodeK(cvt,
seqcharptr[j][k])] >=
fplural)
part = 1.0;
else
part = 0.0;
}
if(previous[j] != part)
/* draw vertical line */
seqboxptr[j][k] |= BOXLEF;
if(j==0)
{
/* special case for horizontal line */
if(part)
{
currentstate = 1;
/* draw hori line */
seqboxptr[j][k] |= BOXTOP;
}
else
currentstate = 0;
}
else
{
/* j != 0 Normal case for horizontal line */
if(part != currentstate)
{
/*draw hori line */
seqboxptr[j][k] |= BOXTOP;
currentstate = (ajint) part;
}
}
if(j== numseq-1 && currentstate)
/* draw horiline at bottom */
seqboxptr[j][k] |= BOXBOT;
previous[j] = (ajint) part;
}
else
{
part = 0;
if(previous[j])
{
/* draw vertical line */
seqboxptr[j][k] |= BOXLEF;
}
previous[j] = 0;
}
if(count == numres || k == kmax || countforgap >= resbreak )
{ /* last one on the row or a break*/
if(previous[j])
{
/* draw vertical line */
seqboxptr[j][k] |= BOXRIG;
}
previous[j] = 0;
}
} /* end box */
if(boxit && boxcol)
if(boxindex != -1)
{
myindex = boxindex;
if(matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[myindex][k])] > 0
|| identical[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])] >=
fplural )
seqboxptr[j][k] |= BOXCOLOURED;
}
/* END OF BOXES */
if(ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]))
res[0] = seqcharptr[j][k];
else
res[0] = '-';
if(colourbyconsensus)
{
part = (float) matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])];
if(iscons && seqcharptr[highindex][k] == seqcharptr[j][k])
seqcolptr[j][k] = cidentity;
else if(part > 0.0)
seqcolptr[j][k] = csimilarity;
else
seqcolptr[j][k] = cother;
}
else if(colourbyresidues)
seqcolptr[j][k] = colmat[ajSeqcvtGetCodeK(cvt,
seqcharptr[j][k])];
else if(iscons && colourbyshade)
{
part = (float) matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])];
if(part >= 1.5)
seqcolptr[j][k] = shadecolour[0];
else if(part >= 1.0)
seqcolptr[j][k] = shadecolour[1];
else if(part >= 0.5)
seqcolptr[j][k] = shadecolour[2];
else
seqcolptr[j][k] = shadecolour[3];
}
else if(colourbyshade)
seqcolptr[j][k] = shadecolour[3];
else
seqcolptr[j][k] = BLACK;
}
if(consensus)
{
if(iscons)
res[0] = seqcharptr[highindex][k];
else
res[0] = '-';
strcat(constr,res);
}
if(countforgap >= resbreak)
{
gapcount++;
countforgap=0;
}
}
startseq = 0;
endseq=seqperpage;
newILstart = newILend;
newILend = k;
while(startseq < numseq)
{
if(startseq)
ajGraphNewpage(graph, AJFALSE);
/*ajDebug("Final loop: startseq: %d numseq: %d endseq: %d\n",
startseq, numseq, endseq);*/
if(endseq>numseq)
endseq = numseq;
prettyplot_fillinboxes(numseq,ajSeqsetGetLen(seqset),
startseq,endseq,
newILstart,newILend,
numres,resbreak,
boxit,boxcol,consensus,
ystart,yincr,cvt);
startseq = endseq;
endseq += seqperpage;
}
ajGraphicsGetCharsize(&defheight,¤tscale);
if(boxit && boxcol)
oldfg = ajGraphicsSetFgcolour(oldfg);
ajGraphicsCloseWin();
ajGraphxyDel(&graph);
ajStrDel(&sidentity);
ajStrDel(&ssimilarity);
ajStrDel(&sother);
ajStrDel(&options);
ajStrDel(&altstr);
ajStrDel(&matcodes);
for(i=0;i<numseq;i++)
{
ajStrDel(&seqnames[i]);
AJFREE(seqcolptr[i]);
if(seqboxptr)
AJFREE(seqboxptr[i]);
}
AJFREE(seqcolptr);
AJFREE(seqboxptr);
AJFREE(seqnames);
AJFREE(score);
AJFREE(previous);
AJFREE(seqcount);
AJFREE(colmat);
AJFREE(shadecolour);
freeptr = (void *) seqcharptr;
AJFREE(freeptr);
AJFREE(identical);
AJFREE(matching);
AJFREE(colcheck);
ajSeqsetDel(&seqset);
ajMatrixDel(&cmpmatrix);
ajStrDel(&shade);
ajStrDel(&sboxcolval);
ajStrDel(&sidentity);
ajStrDel(&ssimilarity);
ajStrDel(&sother);
ajFloatDel(&pair);
ajTimeDel(&ajtime);
AJFREE(constr);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqset seqset;
const AjPSeq seq1;
const AjPSeq seq2;
ajint wordlen;
AjPTable seq1MatchTable = NULL;
AjPList matchlist ;
AjPGraph graph = 0;
ajuint i;
ajuint j;
float total=0;
ajuint acceptableticks[]=
{
1,10,50,100,200,500,1000,1500,10000,50000,
100000,500000,1000000,5000000
};
ajint numbofticks = 10;
ajint gap,tickgap;
AjBool boxit = AJTRUE;
AjBool dumpfeat = AJFALSE;
float xmargin;
float ymargin;
float k;
char ptr[10];
float ticklen;
float onefifth;
AjPFeattable *tabptr = NULL;
AjPFeattabOut seq1out = NULL;
AjPStr sajb = NULL;
float flen1;
float flen2;
ajuint tui;
embInit("polydot", argc, argv);
wordlen = ajAcdGetInt("wordsize");
seqset = ajAcdGetSeqset("sequences");
graph = ajAcdGetGraph("graph");
gap = ajAcdGetInt("gap");
boxit = ajAcdGetBoolean("boxit");
seq1out = ajAcdGetFeatout("outfeat");
dumpfeat = ajAcdGetToggle("dumpfeat");
sajb = ajStrNew();
embWordLength(wordlen);
AJCNEW(lines,ajSeqsetGetSize(seqset));
AJCNEW(pts,ajSeqsetGetSize(seqset));
AJCNEW(tabptr,ajSeqsetGetSize(seqset));
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
seq1 = ajSeqsetGetseqSeq(seqset, i);
total += ajSeqGetLen(seq1);
}
total +=(float)(gap*(ajSeqsetGetSize(seqset)-1));
xmargin = total*(float)0.15;
ymargin = total*(float)0.15;
ticklen = xmargin*(float)0.1;
onefifth = xmargin*(float)0.2;
i = 0;
while(acceptableticks[i]*numbofticks < ajSeqsetGetLen(seqset))
i++;
if(i<=13)
tickgap = acceptableticks[i];
else
tickgap = acceptableticks[13];
ajGraphAppendTitleS(graph, ajSeqsetGetUsa(seqset));
ajGraphOpenWin(graph, (float)0.0-xmargin,(total+xmargin)*(float)1.35,
(float)0.0-ymargin,
total+ymargin);
ajGraphicsSetCharscale((float)0.3);
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
which = i;
seq1 = ajSeqsetGetseqSeq(seqset, i);
tui = ajSeqGetLen(seq1);
flen1 = (float) tui;
if(embWordGetTable(&seq1MatchTable, seq1)){ /* get table of words */
for(j=0;j<ajSeqsetGetSize(seqset);j++)
{
seq2 = ajSeqsetGetseqSeq(seqset, j);
tui = ajSeqGetLen(seq2);
flen2 = (float) tui;
if(boxit)
ajGraphicsDrawposRect(xstart,ystart,
xstart+flen1,
ystart+flen2);
matchlist = embWordBuildMatchTable(seq1MatchTable, seq2,
ajTrue);
if(matchlist)
polydot_plotMatches(matchlist);
if(i<j && dumpfeat)
embWordMatchListConvToFeat(matchlist,&tabptr[i],
&tabptr[j],seq1,
seq2);
if(matchlist) /* free the match structures */
embWordMatchListDelete(&matchlist);
if(j==0)
{
for(k=0.0;k<ajSeqGetLen(seq1);k+=tickgap)
{
ajGraphicsDrawposLine(xstart+k,ystart,xstart+k,
ystart-ticklen);
sprintf(ptr,"%d",(ajint)k);
ajGraphicsDrawposTextAtmid(xstart+k,
ystart-(onefifth),
ptr);
}
ajGraphicsDrawposTextAtmid(
xstart+(flen1/(float)2.0),
ystart-(3*onefifth),
ajStrGetPtr(ajSeqsetGetseqNameS(seqset, i)));
}
if(i==0)
{
for(k=0.0;k<ajSeqGetLen(seq2);k+=tickgap)
{
ajGraphicsDrawposLine(xstart,ystart+k,xstart-ticklen,
ystart+k);
sprintf(ptr,"%d",(ajint)k);
ajGraphicsDrawposTextAtend(xstart-(onefifth),
ystart+k,
ptr);
}
ajGraphicsDrawposTextAtlineJustify(
xstart-(3*onefifth),
ystart+(flen2/(float)2.0),
xstart-(3*onefifth),ystart+flen2,
ajStrGetPtr(ajSeqsetGetseqNameS(seqset, j)),0.5);
}
ystart += flen2+(float)gap;
}
}
embWordFreeTable(&seq1MatchTable);
seq1MatchTable = NULL;
xstart += flen1+(float)gap;
ystart = 0.0;
}
ajGraphicsDrawposTextAtstart(total+onefifth,total-(onefifth),
"No. Length Lines Points Sequence");
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
seq1 = ajSeqsetGetseqSeq(seqset, i);
ajFmtPrintS(&sajb,"%3u %6d %5d %6d %s",i+1,
ajSeqGetLen(seq1),lines[i],
pts[i],ajSeqGetNameC(seq1));
ajGraphicsDrawposTextAtstart(total+onefifth,total-(onefifth*(i+2)),
ajStrGetPtr(sajb));
}
if(dumpfeat && seq1out)
{
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
ajFeattableWrite(seq1out, tabptr[i]);
ajFeattableDel(&tabptr[i]);
}
}
ajGraphicsClose();
ajGraphxyDel(&graph);
ajStrDel(&sajb);
AJFREE(lines);
AJFREE(pts);
AJFREE(tabptr);
ajSeqsetDel(&seqset);
ajFeattabOutDel(&seq1out);;
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeq seq = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr squares = NULL;
AjPStr diamonds = NULL;
AjPStr octags = NULL;
AjBool amphipathic;
AjPStr txt = NULL;
AjPGraph graph = NULL;
ajint begin;
ajint end;
ajint lc;
ajint i;
ajint j;
ajint r;
ajint count;
ajint pstart;
ajint pstop;
float xmin = 0.0;
float xmax = 150.0;
float ymin = 0.0;
float ymax = 112.5;
float xstart;
float ystart;
float ch = (float)1.8;
float xinc;
float yinc;
AjPStr fstr = NULL;
float x;
float y;
embInit("pepnet", argc, argv);
seq = ajAcdGetSeq("sequence");
graph = ajAcdGetGraph("graph");
octags = ajAcdGetString("octags");
squares = ajAcdGetString("squares");
diamonds = ajAcdGetString("diamonds");
amphipathic = ajAcdGetToggle("amphipathic");
ajStrFmtUpper(&octags);
ajStrFmtUpper(&squares);
ajStrFmtUpper(&diamonds);
if(amphipathic)
{
ajStrAssignC(&squares,"ACFGILMVWY");
ajStrAssignC(&diamonds,"");
ajStrAssignC(&octags,"");
}
substr = ajStrNew();
txt = ajStrNew();
fstr = ajStrNew();
begin = ajSeqGetBegin(seq);
end = ajSeqGetEnd(seq);
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq));
ajGraphOpenWin(graph, xmin,xmax,ymin,ymax);
for(count=begin-1,r=0;count<end;count+=231)
{
if (count > begin)
ajGraphNewpage(graph, ajFalse);
pstart=count;
pstop = AJMIN(end-1, count+230);
ajGraphicsSetCharscale(0.75);
xstart = 145.0;
ystart = 80.0;
yinc = ch * (float)2.5;
xinc = yinc / (float)2.5;
x = xstart;
for(i=pstart;i<=pstop;i+=7)
{
lc = i;
if(x < 10.0*xinc)
{
x = xstart;
ystart -= (float)7.5*yinc;
}
y=ystart;
ajFmtPrintS(&txt,"%d",i+1);
ajGraphicsSetFgcolour(RED);
ajGraphicsDrawposTextJustify(x-xinc,y-yinc-1,ajStrGetPtr(txt),0.5);
for(j=0;j<4;++j)
{
x -= xinc;
y += yinc;
if(lc <= pstop)
pepnet_plotresidue(*(ajStrGetPtr(substr)+r),x,y,
ajStrGetPtr(squares),ajStrGetPtr(octags),
ajStrGetPtr(diamonds));
++r;
++lc;
}
y=ystart+yinc/(float)2.0;
for(j=4;j<7;++j)
{
x -= xinc;
y += yinc;
if(lc <= pstop)
pepnet_plotresidue(*(ajStrGetPtr(substr)+r),x,y,
ajStrGetPtr(squares),ajStrGetPtr(octags),
ajStrGetPtr(diamonds));
++r;
++lc;
}
}
}
ajGraphicsClose();
ajGraphxyDel(&graph);
ajStrDel(&strand);
ajStrDel(&fstr);
ajSeqDel(&seq);
ajStrDel(&substr);
ajStrDel(&squares);
ajStrDel(&diamonds);
ajStrDel(&octags);
ajStrDel(&txt);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeq seq = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr squares = NULL;
AjPStr diamonds = NULL;
AjPStr octags = NULL;
AjBool wheel;
AjBool amphipathic;
AjPGraph graph=0;
AjBool first;
AjBool startloop;
ajint begin;
ajint end;
ajint len;
ajint steps;
ajint turns;
ajint lc;
ajint i;
ajint j;
ajint k;
float xmin = (float) -1.0;
float xmax = (float) 1.0;
float ymin = (float) -0.75;
float ymax = (float) 0.75;
float minresplot = (float) 36.0;
float resgap = (float) 0.0533;
float wheelgap = (float) 0.00;
float nresgap = (float) 0.08;
float angle;
float oldangle;
float ang;
float radius;
float wradius;
float xx1;
float xx2;
float yy1;
float yy2;
embInit("pepwheel", argc, argv);
seq = ajAcdGetSeq("sequence");
steps = ajAcdGetInt("steps");
turns = ajAcdGetInt("turns");
graph = ajAcdGetGraph("graph");
octags = ajAcdGetString("octags");
squares = ajAcdGetString("squares");
diamonds = ajAcdGetString("diamonds");
wheel = ajAcdGetBoolean("wheel");
amphipathic = ajAcdGetToggle("amphipathic");
ajStrFmtUpper(&octags);
ajStrFmtUpper(&squares);
ajStrFmtUpper(&diamonds);
if(amphipathic)
{
ajStrAssignC(&squares,"ACFGILMVWY");
ajStrAssignC(&diamonds,"");
ajStrAssignC(&octags,"");
}
substr = ajStrNew();
begin = ajSeqGetBegin(seq);
end = ajSeqGetEnd(seq);
ajDebug("begin: %d end: %d\n", begin, end);
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
len = ajStrGetLen(substr);
ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq));
ajGraphOpenWin(graph,xmin,xmax,ymin,ymax);
ajGraphicsSetFgcolour(AJB_BLACK);
ang = ((float)360.0 / (float)steps) * (float)turns;
first = ajTrue;
angle = (float) 90.0 + ang;
if(end-begin > (ajint)minresplot)
wradius = (float) 0.2;
else
wradius = (float) 0.40;
for(i=0,lc=0,radius=wradius+wheelgap;i<len;i+=steps)
{
wradius += wheelgap;
startloop = ajTrue;
k = AJMIN(i+steps, end);
for(j=i;j<k;++j)
{
oldangle = angle;
angle = oldangle-ang;
if(first)
startloop = first = ajFalse;
else
{
if(startloop)
{
if(wheel)
{
ajCvtPolToRec(wradius-wheelgap,oldangle,&xx1,&yy1);
ajCvtPolToRec(wradius,angle,&xx2,&yy2);
ajGraphicsDrawposLine(xx1,yy1,xx2,yy2);
}
startloop=ajFalse;
}
else
if(wheel)
{
ajCvtPolToRec(wradius,oldangle,&xx1,&yy1);
ajCvtPolToRec(wradius,angle,&xx2,&yy2);
ajGraphicsDrawposLine(xx1,yy1,xx2,yy2);
}
}
pepwheel_plotresidue(*(ajStrGetPtr(substr)+lc),radius+resgap,angle,
ajStrGetPtr(squares),ajStrGetPtr(octags),
ajStrGetPtr(diamonds),
xmin,xmax,ymin,ymax);
++lc;
if(lc==len)
break;
}
radius += nresgap;
}
ajGraphicsClose();
ajGraphxyDel(&graph);
ajStrDel(&strand);
ajStrDel(&substr);
ajSeqDel(&seq);
ajStrDel(&squares);
ajStrDel(&diamonds);
ajStrDel(&octags);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPGraphdata graphdata;
ajint i;
AjPGraph mult;
AjBool overlap;
embInit("testplot", argc, argv);
mult = ajAcdGetGraphxy("graph");
ipoints = ajAcdGetInt("points");
overlap = ajAcdGetBoolean("overlap");
ajUser("Plotting sin, cos and tan for %d degrees",ipoints);
/* Create multiple graph store for a set of graphs */
/* This is used for drawing several graphs in one window */
/* create a new graph */
graphdata = ajGraphdataNewI(ipoints);
/* add graph to list in a multiple graph */
ajGraphDataAdd(mult,graphdata);
/* set overlap based on bool*/
ajGraphxySetflagOverlay(mult, overlap);
/* create the point values for this graph */
for(i=0;i<ipoints; i++)
{
graphdata->x[i] = (float)i;
graphdata->y[i] = sin(ajCvtDegToRad(i));
}
/* embGraphSetData(graphdata,&array[0][0]);*/
ajGraphdataSetYlabelC(graphdata,"SINE(degrees)");
ajGraphdataSetXlabelC(graphdata,"degrees");
ajGraphdataSetTitleC(graphdata,"hello");
ajGraphdataSetColour(graphdata,GREEN);
if(!overlap)
{
ajGraphdataAddposRect(graphdata,70.0,0.55,80.0,0.45,GREEN,1);
ajGraphdataAddposTextC(graphdata,82.0,0.5,GREEN,"Sine");
}
graphdata = ajGraphdataNewI(ipoints);
ajGraphDataAdd(mult,graphdata);
for(i=0;i<ipoints; i++)
{
graphdata->x[i] = (float)i;
graphdata->y[i] = cos(ajCvtDegToRad((float)i));
}
ajGraphdataSetXlabelC(graphdata,"degrees");
ajGraphdataSetYlabelC(graphdata,"COS(degrees)");
ajGraphdataSetTitleC(graphdata,"hello");
ajGraphdataSetColour(graphdata,RED);
if(!overlap)
{
ajGraphdataAddposLine(graphdata,5.0,0.1,15.0,0.1,RED);
ajGraphdataAddposTextC(graphdata,17.0,0.1,RED,"Cosine");
}
/* now set larger axis than needed */
ajGraphdataSetMinmax(graphdata,0.0,(float)ipoints,-0.5,1.5);
graphdata = ajGraphdataNewI(ipoints);
ajGraphdataSetLinetype(graphdata, 3);
ajGraphDataAdd(mult,graphdata);
for(i=0;i<ipoints; i++)
{
graphdata->x[i] = (float)i;
graphdata->y[i] = (tan(ajCvtDegToRad(i))*0.2);
}
ajGraphdataSetXlabelC(graphdata,"degrees");
ajGraphdataSetYlabelC(graphdata,"TAN(degrees)");
ajGraphdataSetTitleC(graphdata,"hello");
ajGraphdataSetLinetype(graphdata, 2);
ajGraphdataSetColour(graphdata,BLUE);
if(!overlap)
{
ajGraphdataAddposRect(graphdata,5.0,9.0,15.0,8.5,BLUE,0);
ajGraphdataAddposTextC(graphdata,17.0,8.75,BLUE,"Tangent");
}
ajGraphSetYlabelC(mult,"sin,cos,tan");
ajGraphSetXlabelC(mult,"degrees");
ajGraphSetTitleC(mult,"Trig functions");
ajGraphxySetYstartF(mult,0.0);
ajGraphxySetYendF(mult,2.0);
if(overlap)
{
ajGraphAddRect(mult,5.0,9.0,15.0,8.5,BLUE,0);
ajGraphAddRect(mult,5.0,8.0,15.0,7.5,GREEN,1);
ajGraphAddLine(mult,5.0,6.75,15.0,6.75,RED);
ajGraphAddTextC(mult,17.0,8.75,BLUE,"Tangent");
ajGraphAddTextC(mult,17.0,7.75,GREEN,"Sine");
ajGraphAddTextC(mult,17.0,6.75,RED,"Cosine");
}
ajGraphxyDisplay(mult,AJTRUE);
ajGraphxyDel(&mult);
embExit();
return 0;
}