lib/fuzzyShow.c File Reference

#include "common.h"
#include "dnautil.h"
#include "memgfx.h"
#include "fuzzyFind.h"
#include "htmshell.h"
#include "cda.h"
#include "seqOut.h"

Include dependency graph for fuzzyShow.c:

Go to the source code of this file.

Functions
static void	ffShNeedle (FILE *f, DNA *needle, int needleSize, int needleNumOffset, char *colorFlags, struct ffAli *aliList, boolean upcMatch, int cdsS, int cdsE, boolean accentRange, int accentStart, int accentEnd)
int	ffShAliPart (FILE *f, struct ffAli *aliList, char *needleName, DNA *needle, int needleSize, int needleNumOffset, char *haystackName, DNA *haystack, int haySize, int hayNumOffset, int blockMaxGap, boolean rcNeedle, boolean rcHaystack, boolean showJumpTable, boolean showNeedle, boolean showHaystack, boolean showSideBySide, boolean upcMatch, int cdsS, int cdsE, int hayPartS, int hayPartE)
int	ffShAli (FILE *f, struct ffAli *aliList, char *needleName, DNA *needle, int needleSize, int needleNumOffset, char *haystackName, DNA *haystack, int haySize, int hayNumOffset, int blockMaxGap, boolean rcNeedle)
void	ffShowAli (struct ffAli *aliList, char *needleName, DNA *needle, int needleNumOffset, char *haystackName, DNA *haystack, int hayNumOffset, boolean rcNeedle)
Variables
static char const	rcsid [] = "$Id: fuzzyShow.c,v 1.23 2007/03/27 23:21:25 angie Exp $"

---

Function Documentation

int ffShAli	(	FILE *	f,
		struct ffAli *	aliList,
		char *	needleName,
		DNA *	needle,
		int	needleSize,
		int	needleNumOffset,
		char *	haystackName,
		DNA *	haystack,
		int	haySize,
		int	hayNumOffset,
		int	blockMaxGap,
		boolean	rcNeedle
	)

Definition at line 368 of file fuzzyShow.c.

References FALSE, ffShAliPart(), and TRUE.

Referenced by ffShowAli().

{
return ffShAliPart(f, aliList, needleName, needle, needleSize, needleNumOffset,
    haystackName, haystack, haySize, hayNumOffset, blockMaxGap, rcNeedle, FALSE,
    TRUE, TRUE, TRUE, TRUE, FALSE, 0, 0, 0, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ffShAliPart	(	FILE *	f,
		struct ffAli *	aliList,
		char *	needleName,
		DNA *	needle,
		int	needleSize,
		int	needleNumOffset,
		char *	haystackName,
		DNA *	haystack,
		int	haySize,
		int	hayNumOffset,
		int	blockMaxGap,
		boolean	rcNeedle,
		boolean	rcHaystack,
		boolean	showJumpTable,
		boolean	showNeedle,
		boolean	showHaystack,
		boolean	showSideBySide,
		boolean	upcMatch,
		int	cdsS,
		int	cdsE,
		int	hayPartS,
		int	hayPartE
	)

Definition at line 82 of file fuzzyShow.c.

References FALSE, ffAli::hEnd, ffAli::hStart, ffAli::left, needMem(), ffAli::nEnd, ffAli::nStart, ffAli::right, and TRUE.

Referenced by ffShAli().

{
long i;
struct ffAli *ali;
struct ffAli *lastAli;
struct ffAli *leftAli = aliList;
struct ffAli *rightAli = aliList;
int charsInLine;
struct baf baf;
int maxSize = (needleSize > haySize ? needleSize : haySize);
char *colorFlags = needMem(maxSize);
int anchorCount = 0;
boolean restrictToWindow = FALSE;
int hayOffStart = 0, hayOffEnd = haySize;
int hayPaddedOffStart = 0, hayPaddedOffEnd = haySize;
int hayExtremity = rcHaystack ? (hayNumOffset + haySize) : hayNumOffset;
int nPartS=0, nPartE=0;

if (aliList != NULL)
    {
    while (leftAli->left != NULL) leftAli = leftAli->left;
    while (rightAli->right != NULL) rightAli = rightAli->right;
    }

/* If we are only showing part of the alignment, translate haystack window
 * coords to needle window coords and haystack-offset window coords: */
if (hayPartS > (hayNumOffset + (leftAli->hStart - haystack)) ||
    (hayPartE > 0 && hayPartE < (hayNumOffset + (rightAli->hEnd - haystack))))
    {
    DNA *haystackPartS;
    DNA *haystackPartE;
    restrictToWindow = TRUE;
    if (rcHaystack)
        {
        haystackPartS = haystack + (haySize - (hayPartE - hayNumOffset));
        haystackPartE = haystack + (haySize - (hayPartS - hayNumOffset));
        }
    else
        {
        haystackPartS = haystack + hayPartS - hayNumOffset;
        haystackPartE = haystack + hayPartE - hayNumOffset;
        }
    boolean foundStart = FALSE;
    hayOffStart = haystackPartS - haystack;
    hayOffEnd = haystackPartE - haystack;
    for (ali = leftAli;  ali != NULL;  ali = ali->right)
        {
        if (haystackPartS < ali->hEnd && !foundStart)
            {
            int offset = haystackPartS - ali->hStart;
            if (offset < 0)
                offset = 0;
            nPartS = offset + ali->nStart - needle;
            hayOffStart = offset + ali->hStart - haystack;
            foundStart = TRUE;
            }
        if (haystackPartE > ali->hStart)
            {
            if (haystackPartE > ali->hEnd)
                {
                nPartE = ali->nEnd - needle;
                hayOffEnd = ali->hEnd - haystack;
                }
            else
                {
                nPartE = haystackPartE - ali->hStart + ali->nStart - needle;
                hayOffEnd = haystackPartE - haystack;
                }
            }
        }
    hayPaddedOffStart = max(0, (hayOffStart - 100));
    hayPaddedOffEnd = min(haySize, (hayOffEnd + 100));
    if (rcHaystack)
        hayExtremity = hayNumOffset + haySize - hayPaddedOffStart;
    else
        hayExtremity = hayNumOffset + hayPaddedOffEnd;
    }

if (showJumpTable)
    {
    fputs("<CENTER><P><TABLE BORDER=1 WIDTH=\"97%\"><TR>", f);
    fputs("<TD WIDTH=\"23%\"><P ALIGN=CENTER><A HREF=\"#cDNA\">cDNA Sequence</A></TD>", f);
    if (restrictToWindow)
        fputs("<TD WIDTH=\"23%\"><P ALIGN=CENTER><A HREF=\"#cDNAStart\">cDNA Sequence in window</A></TD>", f);
    fputs("<TD WIDTH=\"27%\"><P ALIGN=\"CENTER\"><A HREF=\"#genomic\">Genomic Sequence</A></TD>", f);
    fputs("<TD WIDTH=\"29%\"><P ALIGN=\"CENTER\"><A HREF=\"#1\">cDNA in Genomic</A></TD>", f);
    fputs("<TD WIDTH=\"21%\"><P ALIGN=\"CENTER\"><A HREF=\"#ali\">Side by Side</A></TD>", f);
    fputs("</TR></TABLE>\n", f);
    }
if (cdsE > 0) 
    {
    fprintf(f, "Matching bases in coding regions of cDNA and genomic sequences are colored blue%s. ", 
            (upcMatch ? " and capitalized" : ""));
    fprintf(f, "Matching bases in UTR regions of cDNA and genomic sequences are colored red%s. ", 
            (upcMatch ? " and capitalized" : ""));
    fputs("Light blue (coding) or orange (UTR) bases mark the boundaries of gaps in either sequence "
          "(often splice sites).\n", f);
    } 
else 
    {
    fprintf(f, "Matching bases in cDNA and genomic sequences are colored blue%s. ", 
            (upcMatch ? " and capitalized" : ""));
    fputs("Light blue bases mark the boundaries of gaps in either sequence "
          "(often splice sites).\n", f);
    } 
if (showNeedle && restrictToWindow)
    fputs("Bases that were in the selected browser region are shown in bold "
          "and underlined, "
          "and only the alignment for these bases is displayed in the "
          "Genomic and Side by Side sections.\n", f);

if (showJumpTable)
    fputs("</P></CENTER>\n", f);
htmHorizontalLine(f);

fprintf(f, "<H4><A NAME=cDNA></A>cDNA %s%s</H4>\n", needleName, (rcNeedle ? " (reverse complemented)" : ""));

/* NOTE: if rcHaystack, hayNumOffset changes here into the end, not start! */
if (rcHaystack) 
    hayNumOffset += haySize;

if (rcNeedle)
    reverseComplement(needle, needleSize);

if (showNeedle)
    {
    ffShNeedle(f, needle, needleSize, needleNumOffset, colorFlags,
               aliList, upcMatch, cdsS, cdsE,
               restrictToWindow, nPartS, nPartE);
    }

if (showHaystack)
    {
    struct cfm *cfm = cfmNew(10, 50, TRUE, rcHaystack, f, hayExtremity);
    char *h = cloneMem(haystack, haySize);
    char *accentFlags = needMem(haySize);
    zeroBytes(accentFlags, haySize);
    fprintf(f, "<H4><A NAME=genomic></A>Genomic %s %s:</H4>\n", 
        haystackName,
        (rcHaystack ? "(reverse strand)" : ""));
    fprintf(f, "<TT><PRE>\n");
    zeroBytes(colorFlags, haySize);
    for (ali = leftAli; ali != NULL; ali = ali->right)
        {
        boolean utr = FALSE;
        int i;
        int off = ali->hStart-haystack;
        int count = ali->hEnd - ali->hStart;
        int offn = ali->nStart-needle;
        if ((cdsE > 0) && ((cdsS-offn-1) > 0)) 
            utr = TRUE;
        for (i=0; i<count; ++i)
            {
            if (!utr && (i > (cdsE-offn-1)) && (cdsE > 0))
                utr = TRUE;
            if (utr && (i == (cdsS-offn)))
                utr = FALSE;
            if (toupper(ali->hStart[i]) == toupper(ali->nStart[i]))
                {
                if (utr)
                    colorFlags[off+i] = ((i == 0 || i == count-1) ? socOrange : socRed);
                else
                    colorFlags[off+i] = ((i == 0 || i == count-1) ? socBrightBlue : socBlue);
                if (upcMatch)
                    h[off+i] = toupper(h[off+i]);
                }
            if (restrictToWindow && off+i >= hayOffStart && off+i < hayOffEnd)
                accentFlags[off+i] = TRUE;
            }
        }
    ali = leftAli;
    lastAli = NULL;
    while (ali && (ali->hEnd - haystack) <= hayPaddedOffStart)
        ali = ali->right;
    for (i = hayPaddedOffStart; i < hayPaddedOffEnd; ++i)
        {
        /* Put down "anchor" on first match position in haystack
         * so user can hop here with a click on the needle. */
        if (ali != NULL &&  i == ali->hStart - haystack)
            {
            if (lastAli == NULL || ali->hStart - lastAli->hEnd > blockMaxGap)
                {
                fprintf(f, "<A NAME=%d></A>", ++anchorCount);
                }
            lastAli = ali;
            ali = ali->right;
            }
        cfmOutExt(cfm, h[i], seqOutColorLookup[(int)colorFlags[i]],
                  accentFlags[i], accentFlags[i], FALSE);
        }
    cfmFree(&cfm);
    freeMem(h);
    fprintf(f, "</TT></PRE>\n");
    htmHorizontalLine(f);
    }

if (showSideBySide)
    {
    fprintf(f, "<H4><A NAME=ali></A>Side by Side Alignment</H4>\n");
    fprintf(f, "<TT><PRE>\n");
    lastAli = NULL;
    charsInLine = 0;
    bafInit(&baf, needle, needleNumOffset, FALSE, 
        haystack, hayNumOffset, rcHaystack, f, 50, FALSE);
    for (ali=leftAli; ali!=NULL; ali = ali->right)
        {
        boolean doBreak = TRUE;
        int aliLen;
        int i;

        if ((ali->hEnd - haystack) <= hayOffStart ||
            (ali->hStart - haystack) >= hayOffEnd)
            continue;

        /* Decide whether to put in a line break and/or blank characters */
        if (lastAli != NULL)
            {
            int nSkip = ali->nStart - lastAli->nEnd;
            int hSkip = ali->hStart - lastAli->hEnd;
            if (nSkip > 0 && nSkip <= blockMaxGap && hSkip == 0)
                {
                for (i=0; i<nSkip; ++i)
                    bafOut(&baf, lastAli->nEnd[i],'.');
                doBreak = FALSE; 
                }
            else if (hSkip > 0 && hSkip <= blockMaxGap && nSkip == 0)
                {
                for (i=0; i<hSkip; ++i)
                    bafOut(&baf, '.', lastAli->hEnd[i]);
                doBreak = FALSE;
                }
            else if (hSkip == nSkip && hSkip <= blockMaxGap)
                {
                for (i=0; i<hSkip; ++i)
                    bafOut(&baf, lastAli->nEnd[i], lastAli->hEnd[i]);
                doBreak = FALSE;
                }
            }
        else
            {
            doBreak = FALSE;
            }
        if (doBreak)
            bafFlushLine(&baf);
        int offset = max(0, (hayOffStart - (ali->hStart - haystack)));
        int nStart = offset + ali->nStart - needle;
        int hStart = offset + ali->hStart - haystack;
        bafSetPos(&baf, nStart, hStart);
        if (doBreak || lastAli == NULL)
            bafStartLine(&baf);
        aliLen = ali->nEnd - ali->nStart;
        for (i=0; i<aliLen; ++i)
            {
            int hayOff = i + (ali->hStart - haystack);
            if (hayOff < hayOffStart)
                continue;
            if (hayOff >= hayOffEnd)
                break;
            bafOut(&baf, ali->nStart[i], ali->hStart[i]);
            }
        lastAli = ali;
        }
    if (leftAli != NULL)
        bafFlushLine(&baf);
    fprintf(f, "</TT></PRE>\n");
    fprintf(f, "<EM>*Aligned Blocks with gaps &lt;= %d bases are merged for "
            "this display when only one sequence has a gap, or when gaps in "
            "both sequences are of the same size.</EM>\n", blockMaxGap);
    }
if (rcNeedle)
    reverseComplement(needle, needleSize);
return anchorCount;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ffShNeedle	(	FILE *	f,
		DNA *	needle,
		int	needleSize,
		int	needleNumOffset,
		char *	colorFlags,
		struct ffAli *	aliList,
		boolean	upcMatch,
		int	cdsS,
		int	cdsE,
		boolean	accentRange,
		int	accentStart,
		int	accentEnd
	)			[static]

Definition at line 17 of file fuzzyShow.c.

References cfmNew(), cloneMem(), FALSE, ffAli::hStart, ffAli::left, needMem(), ffAli::nEnd, ffAli::nStart, ffAli::right, socBlue, socBrightBlue, socOrange, socRed, TRUE, and zeroBytes().

{
struct cfm *cfm = cfmNew(10, 50, TRUE, FALSE, f, needleNumOffset);
char *n = cloneMem(needle, needleSize);
char *accentFlags = needMem(needleSize);
struct ffAli *leftAli = aliList;
struct ffAli *ali;
long i;

zeroBytes(colorFlags, needleSize);
zeroBytes(accentFlags, needleSize);
fprintf(f, "<TT><PRE>\n");
if (aliList != NULL)
    {
    for (leftAli = aliList; leftAli->left != NULL; leftAli = leftAli->left)
        ;
    }
for (ali = leftAli; ali != NULL; ali = ali->right)
    {
    boolean utr = FALSE;
    int off = ali->nStart-needle;
    int count = ali->nEnd - ali->nStart;
    if ((cdsE > 0) && ((cdsS-off-1) > 0)) 
        utr = TRUE;
    for (i=0; i<count; ++i)
        {
        if (!utr && (i > (cdsE-off-1)) && (cdsE > 0))
            utr = TRUE;
        if (utr && (i == (cdsS-off)))
            utr = FALSE;
        if (toupper(ali->hStart[i]) == toupper(ali->nStart[i]))
            {
            if (utr)
                colorFlags[off+i] = ((i == 0 || i == count-1) ? socOrange : socRed);
            else
                colorFlags[off+i] = ((i == 0 || i == count-1) ? socBrightBlue : socBlue);
            if (upcMatch)
                n[off+i] = toupper(n[off+i]);
            }
        if (accentRange)
            {
            if (off+i >= accentStart && off+i < accentEnd)
                accentFlags[off+i] = TRUE;
            }
        }
    }
for (i=0; i<needleSize; ++i)
    {
    if (accentRange && i == accentStart)
        fprintf(f, "<A NAME=cDNAStart></A>");
    cfmOutExt(cfm, n[i], seqOutColorLookup[(int)colorFlags[i]],
              accentFlags[i], accentFlags[i], FALSE);
    }
cfmFree(&cfm);
freeMem(n);
freeMem(accentFlags);
fprintf(f, "</TT></PRE>\n");
htmHorizontalLine(f);
}

Here is the call graph for this function:

void ffShowAli	(	struct ffAli *	aliList,
		char *	needleName,
		DNA *	needle,
		int	needleNumOffset,
		char *	haystackName,
		DNA *	haystack,
		int	hayNumOffset,
		boolean	rcNeedle
	)

Definition at line 380 of file fuzzyShow.c.

References ffShAli().

{
ffShAli(stdout, aliList, needleName, needle, strlen(needle), needleNumOffset,
    haystackName, haystack, strlen(haystack), hayNumOffset, 8, rcNeedle);
}

Here is the call graph for this function:

---

Variable Documentation

char const rcsid[] = "$Id: fuzzyShow.c,v 1.23 2007/03/27 23:21:25 angie Exp $" [static]

Definition at line 15 of file fuzzyShow.c.

---