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)
{
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[])
{
char *string;
char *structure=NULL;
char *cstruc=NULL;
char *ns_bases=NULL;
char *c;
int n_seq;
int i;
int length;
int sym;
int endgaps = 0;
int mis = 0;
double min_en;
double real_en;
double sfact = 1.07;
int pf = 0;
int istty;
char *AS[MAX_NUM_NAMES]; /* aligned sequences */
char *names[MAX_NUM_NAMES]; /* sequence names */
AjPSeqset seq = NULL;
AjPFile confile = NULL;
AjPFile alifile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfile = NULL;
AjPStr constring = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
AjPSeq tseq = NULL;
AjPStr tname = NULL;
int circ = 0;
int doAlnPS = 0;
int doColor = 0;
embInitPV("vrnaalifoldpf",argc,argv,"VIENNA",VERSION);
constring = ajStrNew();
seq = ajAcdGetSeqset("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
mis = !!ajAcdGetBoolean("most");
endgaps = !!ajAcdGetBoolean("endgaps");
nc_fact = (double) ajAcdGetFloat("nspenalty");
cv_fact = (double) ajAcdGetFloat("covariance");
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
alifile = ajAcdGetOutfile("alignoutfile");
circ = !!ajAcdGetBoolean("circular");
doColor = !!ajAcdGetBoolean("colour");
dotfile = ajAcdGetOutfile("dotoutfile");
do_backtrack = 1;
pf = 1;
string = NULL;
istty = 0;
dangles = 2;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
sfact = (double) escale;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1;
c++;
}
while (*c!='\0')
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(alifile)
doAlnPS = 1;
if(confile)
vienna_GetConstraints(confile,&constring);
n_seq = ajSeqsetGetSize(seq);
if(n_seq > MAX_NUM_NAMES - 1)
ajFatal("[e]RNAalifold is restricted to %d sequences\n",
MAX_NUM_NAMES - 1);
if (n_seq==0)
ajFatal("No sequences found");
for(i=0;i<n_seq;++i)
{
tseq = (AjPSeq) ajSeqsetGetseqSeq(seq,i);
ajSeqGapStandard(tseq, '-');
tname = (AjPStr) ajSeqsetGetseqNameS(seq,i);
len = ajSeqGetLen(tseq);
AS[i] = (char *) space(len+1);
names[i] = (char *) space(ajStrGetLen(tname)+1);
strcpy(AS[i],ajSeqGetSeqC(tseq));
strcpy(names[i],ajStrGetPtr(tname));
}
AS[n_seq] = NULL;
names[n_seq] = NULL;
if (endgaps)
for (i=0; i<n_seq; i++)
mark_endgaps(AS[i], '~');
length = (int) strlen(AS[0]);
structure = (char *) space((unsigned) length+1);
if(confile)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
if (circ && noLonelyPairs)
ajWarn(
"warning, depending on the origin of the circular sequence, "
"some structures may be missed when using -noLP\n"
"Try rotating your sequence a few times\n");
if (circ)
min_en = circalifold((const char **)AS, structure);
else
min_en = alifold(AS, structure);
{
int i;
double s=0;
extern int eos_debug;
eos_debug=-1; /* shut off warnings about nonstandard pairs */
for (i=0; AS[i]!=NULL; i++)
if (circ)
s += energy_of_circ_struct(AS[i], structure);
else
s += energy_of_struct(AS[i], structure);
real_en = s/i;
}
string = (mis) ?
consens_mis((const char **) AS) : consensus((const char **) AS);
ajFmtPrintF(outf,"%s\n%s", string, structure);
ajFmtPrintF(outf," (%6.2f = %6.2f + %6.2f) \n", min_en, real_en,
min_en-real_en );
if (length<=2500) {
char **A;
A = annote(structure, (const char**) AS);
if (doColor)
(void) PS_rna_plot_a(string, structure, essfile, A[0], A[1]);
else
(void) PS_rna_plot_a(string, structure, essfile, NULL, A[1]);
free(A[0]); free(A[1]);free(A);
} else
ajWarn("INFO: structure too long, not doing xy_plot\n");
if (doAlnPS)
PS_color_aln(structure, alifile, AS, names);
{ /* free mfe arrays but preserve base_pair for PS_dot_plot */
struct bond *bp;
bp = base_pair; base_pair = space(16);
free_alifold_arrays(); /* free's base_pair */
free_alipf_arrays();
base_pair = bp;
}
if (pf) {
double energy, kT;
pair_info *pi;
char * mfe_struc;
mfe_struc = strdup(structure);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000)
ajWarn("scaling factor %f\n", pf_scale);
/* init_alipf_fold(length); */
if (confile)
strncpy(structure, ajStrGetPtr(constring), length+1);
energy = (circ) ? alipf_circ_fold(AS, structure, &pi) : alipf_fold(AS, structure, &pi);
if (do_backtrack) {
ajFmtPrintF(outf,"%s", structure);
ajFmtPrintF(outf," [%6.2f]\n", energy);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n", energy);
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g\n",
exp((energy-min_en)/kT));
if (do_backtrack) {
FILE *aliout;
cpair *cp;
short *ptable; int k;
ptable = make_pair_table(mfe_struc);
ajFmtPrintF(outf,"\n# Alignment section\n\n");
aliout = ajFileGetFileptr(outf);
fprintf(aliout, "%d sequences; length of alignment %d\n",
n_seq, length);
fprintf(aliout, "alifold output\n");
for (k=0; pi[k].i>0; k++) {
pi[k].comp = (ptable[pi[k].i] == pi[k].j) ? 1:0;
print_pi(pi[k], aliout);
}
fprintf(aliout, "%s\n", structure);
free(ptable);
cp = make_color_pinfo(pi);
(void) PS_color_dot_plot(string, cp, dotfile);
free(cp);
free(mfe_struc);
free(pi);
}
}
if (cstruc!=NULL) free(cstruc);
free(base_pair);
(void) fflush(stdout);
free(string);
free(structure);
for (i=0; AS[i]; i++) {
free(AS[i]); free(names[i]);
}
ajSeqsetDel(&seq);
ajStrDel(&constring);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajStrDel(&ensbases);
ajFileClose(&confile);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
ajFileClose(&alifile);
ajFileClose(&dotfile);
embExit();
return 0;
}
