src/hg/instinct/hgBamBam/drawingCode.c 1.4
1.4 2010/05/31 00:02:34 jsanborn
big update
Index: src/hg/instinct/hgBamBam/drawingCode.c
===================================================================
RCS file: /projects/compbio/cvsroot/kent/src/hg/instinct/hgBamBam/drawingCode.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -b -B -U 1000000 -r1.3 -r1.4
--- src/hg/instinct/hgBamBam/drawingCode.c 26 May 2010 08:02:55 -0000 1.3
+++ src/hg/instinct/hgBamBam/drawingCode.c 31 May 2010 00:02:34 -0000 1.4
@@ -1,524 +1,803 @@
/********************************************************************************/
/* Copyright 2007-2009 -- The Regents of the University of California */
/********************************************************************************/
#include <limits.h>
#include "common.h"
#include "bed.h"
#include "cart.h"
#include "customTrack.h"
#include "errCatch.h"
#include "genoLay.h"
#include "trackLayout.h"
#include "hash.h"
#include "hdb.h"
#include "hgColors.h"
#include "hPrint.h"
#include "htmshell.h"
#include "jsHelper.h"
#include "psGfx.h"
#include "trashDir.h"
#include "vGfx.h"
#include "hvGfx.h"
#include "web.h"
#include "hgBamBam.h"
#include "spaceSaver.h"
#define MIN_LABEL_SIZE 100 // minimum size of labels
#define TEXT_BUFFER 5 // pixels to put between text and heatmap
-#define FOOT_HEIGHT 3
+#define FOOT_HEIGHT 5
+#define INTER_BREAK_HEIGHT 5
struct trackLayout tl; /* Dimensions of things, fonts, etc. */
/***** BEGIN HELPER *****/
#define CLIP(p,limit) if (p < 0) p = 0; if (p >= (limit)) p = (limit)-1;
void verticalTextLeft(struct vGfx *vg, int x, int y,
int width, int height, int colorIx, int fontHeight,
MgFont *font, char *string)
{
/* don't let this run wild */
//CLIP(width, vg->width);
//CLIP(height, vg->height);
if ((width <= 0) || (height <= 0))
return;
struct vGfx *vgHoriz;
int i, j;
/* reversed meanings of width and height here since this is going
* to rotate 90 degrees
*/
int offset = round((double) (width - fontHeight) / 2.0);
if (offset < 0)
offset = 0;
vgHoriz = vgOpenGif(height, width, "/dev/null", FALSE);
vgText(vgHoriz, 0, offset, colorIx, font, string);
/* now, blit from the horizontal to the vertical, rotate -90 (CCW) */
for (i = 0; i < height; i++) /* xSrc -> yDest */
{
int yDest = height - (i + 1);
for (j = 0; j < width; j++) /* ySrc -> xDest */
vgDot(vg, x + (j+1), y + yDest, vgGetDot(vgHoriz, i, j));
}
vgClose(&vgHoriz);
}
void vgMakeColorGradient(struct vGfx *vg,
struct rgbColor *start, struct rgbColor *end,
int steps, Color *colorIxs)
/* Make a color gradient that goes smoothly from start
* to end colors in given number of steps. Put indicesLis
* in color table in colorIxs */
{
double scale = 0, invScale;
double invStep;
int i; int r,g,b;
steps -= 1; /* Easier to do the calculation in an inclusive way. */
invStep = 1.0/steps;
for (i=0; i<=steps; ++i)
{
invScale = 1.0 - scale;
r = invScale * start->r + scale * end->r;
g = invScale * start->g + scale * end->g;
b = invScale * start->b + scale * end->b;
colorIxs[i] = vgFindColorIx(vg, r, g, b);
scale += invStep;
}
}
char *cartSettingsString(char *prefix, char *functionName)
{
if (!prefix || !functionName)
return NULL;
struct hashEl *hEl = cartFindPrefix(cart, prefix);
if (!hEl)
return NULL;
struct dyString *dy = newDyString(1000);
while (hEl)
{
char *name = hEl->name;
char *val = hEl->val;
dyStringPrintf(dy, "%s=%s,", name, val);
hEl = hEl->next;
}
dyStringPrintf(dy, "%s,%s", functionName, VERSION);
char *str = dyStringCannibalize(&dy);
return str;
}
void drawBackgroundLines(struct vGfx *vg, int startX, int startY, int width, int height)
-{
-int x, spacing = 20;
+{ // draw background lines like genome browser.
+int x, spacing = 12;
+
+/* First line is red */
+Color lightRed = vgFindColorIx(vg, 220, 0, 0);
+x = startX;
+vgBox(vg, x, startY, 1, height, lightRed);
+x += spacing;
+/* Remaining are blue */
Color lightBlue = vgFindColorIx(vg, 220, 220, 255);
vgSetClip(vg, startX, startY, width, height);
-for (x = startX; x < (startX + width); x += spacing)
+for ( ; x < (startX + width); x += spacing)
vgBox(vg, x, startY, 1, height, lightBlue);
vgUnclip(vg);
}
-static int calcX(struct chromLay *cl, int base, int max)
+void prepareImage(struct vGfx *vg, struct settings *settings)
+{
+drawBackgroundLines(vg, settings->dataOffsetX - 1, 0, settings->dataWidth + 1, settings->height);
+
+if (settings->title)
+ vgTextCentered(vg, settings->dataOffsetX, 0, settings->dataWidth, TITLE_HEIGHT,
+ MG_BLACK, settings->font, settings->title);
+}
+
+static int calcX(struct chromLay *cl, int base, int min, int max)
{
if (!cl)
return -1;
int x = round(cl->pxStart+cl->pxWidth*((float)(base - cl->baseStart)/cl->baseWidth));
-return (x > max) ? max : x;
+
+if (x < min)
+ x = min;
+if (x > max)
+ x = max;
+return x;
}
/***** END HELPER *****/
-void drawChromBreaks(struct vGfx *vg, struct spaceSaver *ss,
+struct chromLay *getChromLayBreaks(struct sqlConnection *conn,
+ struct breaks *breaks, struct settings *settings)
+{
+if (!breaks || !settings || slCount(settings->layoutList) > 1)
+ return NULL;
+
+char *currentChrom = settings->layoutList->chrom;
+
+/* Find all chroms that have inter chrom breakpoints */
+struct hash *chromHash = hashNew(0);
+struct breaks *br;
+for (br = breaks; br; br = br->next)
+ {
+
+ struct hashEl *el = hashLookup(chromHash, br->chrom);
+ if (!el)
+ hashAddInt(chromHash, br->chrom, 1);
+
+ el = hashLookup(chromHash, br->chrom2);
+ if (!el)
+ hashAddInt(chromHash, br->chrom2, 1);
+ }
+
+struct genoLayChrom *gl, *glList = genoLayDbChroms(conn, FALSE);
+
+float totalBases = 0.0;
+for (gl = glList; gl; gl = gl->next)
+ {
+ if (sameString(gl->fullName, currentChrom))
+ continue;
+
+ struct hashEl *el = hashLookup(chromHash, gl->fullName);
+ if (el)
+ totalBases += gl->size;
+ }
+
+float cbases = 0.0;
+struct chromLay *cl, *clList = NULL;
+for (gl = glList; gl; gl = gl->next)
+ {
+ if (sameString(gl->fullName, currentChrom))
+ continue;
+
+ struct hashEl *el = hashLookup(chromHash, gl->fullName);
+ if (el)
+ {
+ AllocVar(cl);
+ cl->chrom = cloneString(gl->fullName);
+ cl->baseStart = 0.0;
+ cl->baseEnd = (float) gl->size;
+ cl->baseWidth = cl->baseEnd - cl->baseStart;
+ cl->pxWidth = (float) settings->dataWidth * cl->baseWidth / totalBases;
+ cl->pxStart = (float) settings->dataWidth * cbases / totalBases + settings->dataOffsetX;
+ cbases += (float) gl->size;
+ slAddHead(&clList, cl);
+ }
+ }
+slReverse(&clList);
+return clList;
+}
+
+int breaksCmp(const void *va, const void *vb)
+/* Compare to sort columns based on priority. */
+{
+const struct breaks *a = *((struct breaks **)va);
+const struct breaks *b = *((struct breaks **)vb);
+
+float dif = 0;
+if (sameString(a->chrom, b->chrom))
+ dif = a->chromStart - b->chromStart;
+else if (sameString(a->chrom, b->chrom2))
+ dif = a->chromStart - b->chromStart2;
+else if (sameString(a->chrom2, b->chrom2))
+ dif = a->chromStart2 - b->chromStart2;
+
+if (dif < 0)
+ return 1;
+else if (dif > 0)
+ return -1;
+else
+ return 0;
+}
+
+
+void drawInterChromBreaks(struct hvGfx *hvg, struct breaks *breaks,
+ struct chromLay *clList, struct settings *settings)
+{
+if (!settings || slCount(settings->layoutList) > 1)
+ return;
+
+char *currentChrom = settings->layoutList->chrom;
+
+struct vGfx *vg = hvg->vg;
+
+struct breaks *br;
+struct chromLay *cl;
+struct hash *clHash = hashNew(0);
+for (cl = clList; cl; cl = cl->next)
+ {
+ if (sameString(cl->chrom, currentChrom))
+ continue;
+ hashAdd(clHash, cl->chrom, cl);
+ }
+
+int xl1, xl2, wl, xr1, xr2, wr, ldir, rdir;
+char *lstrand, *rstrand;
+struct chromLay *clL, *clR;
+struct hashEl *el;
+
+drawColorIdeogram(hvg, settings, clList, settings->dataOffsetY + DEFAULT_LABEL_HEIGHT);
+
+int yfoot = FOOT_HEIGHT;
+int yl = settings->height - settings->dataOffsetY - yfoot;
+int yr = yfoot + CYTO_HEIGHT + DEFAULT_LABEL_HEIGHT;
+
+vgSetClip(vg, settings->dataOffsetX, 0, settings->dataWidth, settings->height);
+
+int ibreak = 0;
+
+slSort(&breaks, breaksCmp);
+
+int yOff;
+for (br = breaks; br; br = br->next)
+ {
+ yOff = settings->dataOffsetY;
+ clL = NULL;
+ clR = NULL;
+
+ int yBreak = INTER_BREAK_HEIGHT * ibreak + CYTO_HEIGHT + DEFAULT_LABEL_HEIGHT + yfoot + INTER_BREAK_HEIGHT/2;
+ ibreak++;
+
+ int csL, ceL;
+ int csR, ceR;
+ if (sameString(currentChrom, br->chrom))
+ {
+ el = hashLookup(settings->layoutHash, br->chrom);
+ if (el)
+ clL = el->val;
+ csL = br->chromStart;
+ ceL = br->chromEnd;
+ lstrand = br->strand;
+
+ el = hashLookup(clHash, br->chrom2);
+ if (el)
+ clR = el->val;
+ csR = br->chromStart2;
+ ceR = br->chromEnd2;
+ rstrand = br->strand2;
+ }
+ else
+ {
+ el = hashLookup(settings->layoutHash, br->chrom2);
+ if (el)
+ clL = el->val;
+ csL = br->chromStart2;
+ ceL = br->chromEnd2;
+ lstrand = br->strand2;
+
+ el = hashLookup(clHash, br->chrom);
+ if (el)
+ clR = el->val;
+ csR = br->chromStart;
+ ceR = br->chromEnd;
+ rstrand = br->strand;
+ }
+
+ /* +/- FOOT_HEIGHT to push far away breakpoint outside of clipped regions, so
+ * they are not displayed */
+
+ xl1 = calcX(clL, csL, settings->dataOffsetX-FOOT_HEIGHT-1, settings->width+FOOT_HEIGHT);
+ xl2 = calcX(clL, ceL, settings->dataOffsetX-FOOT_HEIGHT-1, settings->width+FOOT_HEIGHT);
+ wl = (xl2 - xl1 > 0) ? (xl2 - xl1) : 1;
+
+ xr1 = calcX(clR, csR, settings->dataOffsetX-FOOT_HEIGHT-1, settings->width+FOOT_HEIGHT);
+ xr2 = calcX(clR, ceR, settings->dataOffsetX-FOOT_HEIGHT-1, settings->width+FOOT_HEIGHT);
+ wr = (xr2 - xr1 > 0) ? (xr2 - xr1) : 1;
+
+ ldir = 1;
+ if (sameString(lstrand, "+"))
+ ldir = -1;
+
+ rdir = 1; // reversed
+ if (sameString(rstrand, "+"))
+ rdir = -1;
+
+ Color col = getChromColor(vg, clR->chrom);
+ //vgLine(vg, xl2, yOff + yl, xr1, yOff + yr, col);
+ vgLine(vg, xl2, yOff + yBreak, xr1, yOff + yBreak, col);
+
+ if (xl1 >= 0 && xl2 >= 0)
+ {
+ vgBox(vg, xl1, yOff + yl, wl, 1, MG_BLACK);
+ vgLine(vg, xl1, yOff + yl, xl1 + ldir * FOOT_HEIGHT, yOff + yl + yfoot, MG_BLACK);
+ vgLine(vg, xl1, yOff + yl, xl1, yOff + yBreak, col);
+ }
+ if (xr1 >= 0 && xr2 >= 0)
+ {
+ vgBox(vg, xr1, yOff + yr, wr, 1, MG_BLACK);
+ vgLine(vg, xr1, yOff + yr, xr1 + rdir * FOOT_HEIGHT, yOff + yr - yfoot, MG_BLACK);
+ vgLine(vg, xr1, yOff + yr, xr1, yOff + yBreak, col);
+ }
+ }
+vgUnclip(vg);
+
+}
+
+char *interBreaksGif(struct sqlConnection *conn, struct breaks *breaks,
+ struct settings *settings)
+/* Create genome GIF file and HT that includes it. */
+{
+if (!breaks || !settings)
+ return NULL;
+
+if (settings->height <= 0 || settings->width <= 0)
+ return NULL;
+
+struct chromLay *clList = getChromLayBreaks(conn, breaks, settings);
+
+if (!clList)
+ return NULL;
+
+int numBreaks = slCount(breaks);
+
+settings->dataHeight = (numBreaks + 1) * INTER_BREAK_HEIGHT + CYTO_HEIGHT + DEFAULT_LABEL_HEIGHT + FOOT_HEIGHT * 2;
+settings->height = settings->dataHeight + TITLE_HEIGHT;
+
+struct hvGfx *vg;
+struct tempName md5Tn;
+char *strToHash = cartSettingsString(bbPrefix, "interBreaks");
+trashDirMD5File(&md5Tn, "hgg", ".gif", strToHash);
+
+off_t size = fileSize(md5Tn.forCgi);
+if (!fileExists(md5Tn.forCgi) || (size == 0) || DEBUG)
+ {
+ vg = hvGfxOpenGif(settings->width, settings->height, md5Tn.forCgi, FALSE);
+
+ prepareImage(vg->vg, settings);
+
+ drawInterChromBreaks(vg, breaks, clList, settings);
+
+ hvGfxClose(&vg);
+ }
+
+char *filename = replaceChars(md5Tn.forHtml, "..", "");
+return filename;
+}
+
+
+void drawIntraChromBreaks(struct vGfx *vg, struct spaceSaver *ss,
struct settings *settings)
{
struct breaks *br;
int xl1, xl2, wl, xr1, xr2, wr, ldir, rdir;
char *lstrand, *rstrand;
struct chromLay *clL, *clR;
struct hashEl *el;
int yfoot = 0;
int hline = 1;
int yline = FOOT_HEIGHT;
struct spaceNode *sn;
+vgSetClip(vg, settings->dataOffsetX, 0, settings->dataWidth, settings->height);
int yOff;
for (sn = ss->nodeList; sn; sn = sn->next)
{
- yOff = sn->row * FOOT_HEIGHT * 2;
+ yOff = sn->row * FOOT_HEIGHT * 2 + settings->dataOffsetY;
br = (struct breaks *)sn->val;
clL = NULL;
clR = NULL;
el = hashLookup(settings->layoutHash, br->chrom);
if (el)
clL = el->val;
el = hashLookup(settings->layoutHash, br->chrom2);
if (el)
clR = el->val;
- xl1 = calcX(clL, br->chromStart, settings->width);
- xl2 = calcX(clL, br->chromEnd, settings->width);
+ /* +/- FOOT_HEIGHT to push far away breakpoint outside of clipped regions, so
+ * they are not displayed */
+
+ xl1 = calcX(clL, br->chromStart, settings->dataOffsetX-FOOT_HEIGHT-1, settings->width+FOOT_HEIGHT);
+ xl2 = calcX(clL, br->chromEnd, settings->dataOffsetX-FOOT_HEIGHT-1, settings->width+FOOT_HEIGHT);
wl = (xl2 - xl1 > 0) ? (xl2 - xl1) : 1;
lstrand = br->strand;
- xr1 = calcX(clR, br->chromStart2, settings->width);
- xr2 = calcX(clR, br->chromEnd2, settings->width);
+ xr1 = calcX(clR, br->chromStart2, settings->dataOffsetX-FOOT_HEIGHT-1, settings->width+FOOT_HEIGHT);
+ xr2 = calcX(clR, br->chromEnd2, settings->dataOffsetX-FOOT_HEIGHT-1, settings->width+FOOT_HEIGHT);
wr = (xr2 - xr1 > 0) ? (xr2 - xr1) : 1;
rstrand = br->strand2;
if (xl1 > xr1)
{ // always go from left -> right, flip
int tmp1 = xl1;
int tmp2 = xl2;
int tmpw = wl;
char *tmpst = lstrand;
xl1 = xr1;
xl2 = xr2;
wl = wr;
lstrand = rstrand;
xr1 = tmp1;
xr2 = tmp2;
wr = tmpw;
rstrand = tmpst;
}
ldir = 1;
if (sameString(lstrand, "+"))
ldir = -1;
rdir = 1; // reversed
if (sameString(rstrand, "+"))
rdir = -1;
- if (xl2 >= 0 && xr1 >= 0 && xl2 < xr1)
+ if (xl2 < xr1)
vgBox(vg, xl2, yOff + yline, (xr1-xl2), hline, MG_RED);
- if (xl1 >= 0 && xr2 >= 0 && xr2 < xl1)
+ if (xr2 < xl1)
vgBox(vg, xr2, yOff + yline, (xl1-xr2), hline, MG_RED);
if (xl1 >= 0 && xl2 >= 0)
{
vgBox(vg, xl1, yOff + yline, wl, 1, MG_BLACK);
vgLine(vg, xl1, yOff + yline, xl1 + ldir * FOOT_HEIGHT, yOff + yfoot + (yline - yfoot) * 2, MG_BLACK);
}
if (xr1 >= 0 && xr2 >= 0)
{
vgBox(vg, xr1, yOff + yline, wr, 1, MG_BLACK);
vgLine(vg, xr1, yOff + yline, xr1 + rdir * FOOT_HEIGHT, yOff + yfoot + (yline - yfoot) * 2, MG_BLACK);
}
}
+vgUnclip(vg);
}
-struct spaceSaver *breaksToSS(struct breaks *breaks, struct settings *settings)
+struct spaceSaver *intraBreaksToSS(struct breaks *breaks, struct settings *settings)
{
struct spaceSaver *ss = spaceSaverNew(0, settings->width, 100);
struct breaks *br;
int x1, x2;
struct chromLay *clL, *clR;
struct hashEl *el;
for (br = breaks; br; br = br->next)
{
clL = NULL;
clR = NULL;
el = hashLookup(settings->layoutHash, br->chrom);
if (el)
clL = el->val;
el = hashLookup(settings->layoutHash, br->chrom2);
if (el)
clR = el->val;
if (!clL || !clR || !sameString(clL->chrom, clR->chrom))
continue;
- x1 = calcX(clL, br->chromStart, settings->width);
- x2 = calcX(clR, br->chromEnd2, settings->width);
+ x1 = calcX(clL, br->chromStart, settings->dataOffsetX, settings->width);
+ x2 = calcX(clR, br->chromEnd2, settings->dataOffsetX, settings->width);
spaceSaverAdd(ss, x1, x2, br);
}
spaceSaverFinish(ss);
return ss;
}
-char *breaksGif(struct sqlConnection *conn, struct breaks *breaks,
+char *intraBreaksGif(struct sqlConnection *conn, struct breaks *breaks,
struct settings *settings)
/* Create genome GIF file and HT that includes it. */
{
if (!breaks || !settings)
return NULL;
if (settings->height <= 0 || settings->width <= 0)
return NULL;
-struct spaceSaver *ss = breaksToSS(breaks, settings);
+struct spaceSaver *ss = intraBreaksToSS(breaks, settings);
int maxRow = -1;
struct spaceNode *sn;
for (sn = ss->nodeList; sn; sn = sn->next)
{
if (sn->row > maxRow)
maxRow = sn->row;
}
if (maxRow < 0)
return NULL;
-settings->height = (maxRow + 1) * FOOT_HEIGHT * 2;
+settings->dataHeight = (maxRow + 1) * FOOT_HEIGHT * 2;
+settings->height = settings->dataHeight + TITLE_HEIGHT;
struct hvGfx *vg;
struct tempName md5Tn;
-char *strToHash = cartSettingsString(bbPrefix, "breaks");
+char *strToHash = cartSettingsString(bbPrefix, "intraBreaks");
trashDirMD5File(&md5Tn, "hgg", ".gif", strToHash);
off_t size = fileSize(md5Tn.forCgi);
if (!fileExists(md5Tn.forCgi) || (size == 0) || DEBUG)
{
vg = hvGfxOpenGif(settings->width, settings->height, md5Tn.forCgi, FALSE);
- drawChromBreaks(vg->vg, ss, settings);
+ prepareImage(vg->vg, settings);
+
+ drawIntraChromBreaks(vg->vg, ss, settings);
hvGfxClose(&vg);
}
char *filename = replaceChars(md5Tn.forHtml, "..", "");
return filename;
}
-
-
void drawCopyNumber(struct vGfx *vg, struct bed *bedList,
struct settings *settings, float medVal, Color col)
{
int x1, x2, y, w;
float val;
struct bed *bed;
struct chromLay *cl = NULL;
char *prevChrom = NULL;
struct hash *pixelHash = hashNew(0);
struct hmPixel *hm, *hmList = NULL;
char pixelStr[256];
struct hashEl *el;
for (bed = bedList; bed; bed = bed->next)
{
if (!cl || !sameString(bed->chrom, prevChrom))
{
el = hashLookup(settings->layoutHash, bed->chrom);
if (!el)
errAbort("couldn't find chrom %s in layout", bed->chrom);
cl = el->val;
prevChrom = bed->chrom;
}
if (bed->chromStart > cl->baseEnd || bed->chromEnd < cl->baseStart)
continue;
- x1 = round( cl->pxStart + cl->pxWidth * ((float) (bed->chromStart - cl->baseStart) / cl->baseWidth) );
- if (x1 < 0)
- x1 = 0;
- if (x1 > settings->width)
- x1 = settings->width;
-
- x2 = round( cl->pxStart + cl->pxWidth * ((float) (bed->chromEnd - cl->baseStart) / cl->baseWidth) );
- if (x2 < 0)
- x2 = 0;
- if (x2 > settings->width)
- x2 = settings->width;
-
+ x1 = calcX(cl, bed->chromStart, settings->dataOffsetX, settings->width);
+ x2 = calcX(cl, bed->chromEnd, settings->dataOffsetX, settings->width);
w = (x2 - x1 > 0) ? x2 - x1 : 1;
val = sqlFloat(bed->name);
safef(pixelStr,sizeof (pixelStr), "%d", x1);
el = hashLookup(pixelHash, pixelStr);
if (!el)
{
hm = AllocA(struct hmPixel);
hm->x = x1;
hm->y = 0;
hm->w = w;
hm->h = 0;
hm->val = 0.0;
hm->count = 0;
slAddHead(&hmList, hm);
hashAdd(pixelHash, pixelStr, hm);
}
else
hm = el->val;
if (x2 - hm->x > hm->w)
hm->w = x2 - hm->x;
hm->val += val;
hm->count += 1;
}
struct rgbColor rgb = vgColorIxToRgb(vg, col);
int r = rgb.r + floor((float) (255 - rgb.r) * 0.8);
int g = rgb.g + floor((float) (255 - rgb.g) * 0.8);
int b = rgb.b + floor((float) (255 - rgb.b) * 0.8);
Color fillCol = vgFindColorIx(vg, r, g, b);
medVal = medVal / (settings->maxVal - settings->minVal);
if (medVal > 1.0)
medVal = 1.0;
-int medY = round((float) settings->height * (1.0 - medVal) );
+int medY = round((float) settings->dataHeight * (1.0 - medVal) ) + settings->dataOffsetY;
+
+vgSetClip(vg, settings->dataOffsetX, 0, settings->dataWidth, settings->height);
for (hm = hmList; hm ; hm = hm->next)
{
val = hm->val / hm->count;
val = val / (settings->maxVal - settings->minVal);
if (val > 1.0)
val = 1.0;
- y = round((float) settings->height * (1.0 - val) );
+ y = round((float) settings->dataHeight * (1.0 - val) ) + settings->dataOffsetY;
if (y > medY)
vgBox(vg, hm->x, medY, hm->w, y - medY, fillCol);
else
vgBox(vg, hm->x, y, hm->w, medY - y, fillCol);
vgBox(vg, hm->x, y-1, hm->w, 1, col);
}
-
+vgUnclip(vg);
}
char *copyNumberGif(struct sqlConnection *conn, struct bed *bed,
struct settings *settings, char *suffix, float medVal, Color col)
/* Create genome GIF file and HT that includes it. */
{
if (!bed || !settings)
return NULL;
if (settings->height <= 0 || settings->width <= 0)
return NULL;
struct hvGfx *vg;
struct tempName md5Tn;
char *strToHash = cartSettingsString(bbPrefix, suffix);
trashDirMD5File(&md5Tn, "hgg", ".gif", strToHash);
off_t size = fileSize(md5Tn.forCgi);
if (!fileExists(md5Tn.forCgi) || (size == 0) || DEBUG)
{
vg = hvGfxOpenGif(settings->width, settings->height, md5Tn.forCgi, FALSE);
+ prepareImage(vg->vg, settings);
+
drawCopyNumber(vg->vg, bed, settings, medVal, col);
hvGfxClose(&vg);
}
char *filename = replaceChars(md5Tn.forHtml, "..", "");
return filename;
}
struct settings *initSettings(struct sqlConnection *conn,
- char *pos, int width, int height, float minVal, float maxVal)
+ char *pos, char *name, int width, int height,
+ float minVal, float maxVal)
{
struct settings *settings = AllocA(struct settings);
trackLayoutInit(&tl, cart);
+
+settings->title = NULL;
+if (name)
+ settings->title = cloneString(name);
+
settings->fontHeight = tl.fontHeight;
settings->font = tl.font;
settings->width = width;
settings->height = height;
+settings->dataOffsetX = GUTTER_WIDTH;
+settings->dataWidth = settings->width - GUTTER_WIDTH;
+settings->dataOffsetY = TITLE_HEIGHT;
+settings->dataHeight = settings->height - TITLE_HEIGHT;
+
settings->minVal = minVal;
settings->maxVal = maxVal;
char *chrom = NULL;
int start = 0;
int stop = 0;
+settings->layoutHash = hashNew(0);
+settings->layoutList = NULL;
+settings->totalBases = 0.0;
+
+
if (pos)
{
if (!hgParseChromRange(NULL, pos, &chrom, &start, &stop))
return NULL;
}
-settings->totalBases = 0.0;
-
struct genoLayChrom *gl, *glList = genoLayDbChroms(conn, FALSE);
slSort(&glList, genoLayChromCmpName);
for (gl = glList; gl; gl = gl->next)
{
if (!chrom)
settings->totalBases += gl->size;
else if (chrom && sameString(chrom, gl->fullName))
{
settings->totalBases += (float) (stop - start);
break;
}
}
if (settings->totalBases == 0.0)
settings->totalBases = 1.0;
float cbases = 0.0;
struct chromLay *cl;
-settings->layoutHash = hashNew(0);
-settings->layoutList = NULL;
for (gl = glList; gl; gl = gl->next)
{
if (!chrom)
{
AllocVar(cl);
cl->chrom = cloneString(gl->fullName);
cl->baseStart = 0.0;
cl->baseEnd = (float) gl->size;
cl->baseWidth = cl->baseEnd - cl->baseStart;
- cl->pxWidth = (float) width * cl->baseWidth / settings->totalBases;
- cl->pxStart = (float) width * cbases / settings->totalBases;
+ cl->pxWidth = (float) settings->dataWidth * cl->baseWidth / settings->totalBases;
+ cl->pxStart = (float) settings->dataWidth * cbases / settings->totalBases + settings->dataOffsetX;
hashAdd(settings->layoutHash, cl->chrom, cl);
slAddHead(&settings->layoutList, cl);
cbases += (float) gl->size;
}
else if (chrom && sameString(chrom, gl->fullName))
{
AllocVar(cl);
cl->chrom = cloneString(gl->fullName);
cl->baseStart = (float) start;
cl->baseEnd = (float) stop;
cl->baseWidth = cl->baseEnd - cl->baseStart;
- cl->pxWidth = (float) width;
- cl->pxStart = 0.0;
-
- //cl->pxStart += 1.0;
- //cl->pxWidth -= 2.0;
+ cl->pxWidth = (float) settings->dataWidth;
+ cl->pxStart = settings->dataOffsetX;
hashAdd(settings->layoutHash, cl->chrom, cl);
slAddHead(&settings->layoutList, cl);
break;
}
}
slReverse(&settings->layoutList);
return settings;
}