fb0d415d29a5786b48478ef7fb87b8adc8d8af61
kent
  Sun Feb 17 10:51:11 2013 -0800
Changing way transparency is done so that it shows up in PDF, and also can be normalized when we add more cell lines.
diff --git src/hg/hgTracks/multiWig.c src/hg/hgTracks/multiWig.c
index 65f4500..9c07c61 100644
--- src/hg/hgTracks/multiWig.c
+++ src/hg/hgTracks/multiWig.c
@@ -1,255 +1,400 @@
 /* A container for multiple wiggles with a couple of options for combining them. */
 
 #include "common.h"
 #include "hash.h"
 #include "linefile.h"
 #include "jksql.h"
 #include "dystring.h"
 #include "hdb.h"
 #include "hgTracks.h"
 #include "container.h"
 #include "wiggle.h"
 #include "wigCommon.h"
 #include "hui.h"
 
+struct floatPic
+/* A picture that stores RGB values in floating point. */
+    {
+    float **lines;   /* points to start of each line of image */
+    float *image;
+    int width;	/* Width in pixels. */
+    int height; /* Heigh in pixels. */
+    };
+
+struct floatPic *floatPicNew(int width, int height)
+/* Return a new floatPic. */
+{
+long lineSize = 3L * width;
+long imageSize = lineSize * height;
+struct floatPic *pic = needMem(sizeof(struct floatPic));
+pic->width = width;
+pic->height = height;
+pic->image = needHugeMem(imageSize * sizeof(float));
+
+/* Create and initialize line start array */
+AllocArray(pic->lines, height);
+int i = height;
+float *line = pic->image;
+float **lines = pic->lines;
+while (--i >= 0)
+    {
+    *lines++ = line;
+    line += lineSize;
+    }
+return pic;
+}
+
+void floatPicFree(struct floatPic **pPic)
+/* Free up resources associated with floatPic. */
+{
+struct floatPic *pic = *pPic;
+if (pic != NULL)
+    {
+    freeMem(pic->lines);
+    freeMem(pic->image);
+    freez(pPic);
+    }
+}
+
+void floatPicSet(struct floatPic *pic, float r, float g, float b)
+/* Set full image to a single color */
+{
+long totalSize = pic->width * pic->height;
+float *p = pic->image;
+while (--totalSize >= 0)
+    {
+    *p++ = r;
+    *p++ = g;
+    *p++ = b;
+    }
+}
+
+void vLineViaFloat(void *image, int x, int y, int height, Color color)
+/* A vertical line drawer that works via floatPic. */
+{
+struct floatPic *pic = image;
+
+/* First do some clipping */
+if (x < 0 || x > pic->width)
+    return;
+if (y < 0)
+    {
+    height += y;
+    y = 0;
+    }
+int yEnd = y + height;
+if (yEnd > pic->height)
+    {
+    yEnd = pic->height;
+    height = yEnd - y;
+    }
+if (height <= 0)
+    return;
+
+int hOffset = x*3;
+const float scaleColor = 1/255.9;
+
+float r = COLOR_32_RED(color) * scaleColor;
+float g = COLOR_32_GREEN(color) * scaleColor;
+float b = COLOR_32_BLUE(color) * scaleColor;
+while (--height >= 0)
+    {
+    float *p = pic->lines[y++] + hOffset;
+    p[0] *= r;
+    p[1] *= g;
+    p[2] *= b;
+    }
+}
+
+struct wigGraphOutput *wigGraphOutputTransparent(struct floatPic *image)
+/* Get appropriate wigGraphOutput for non-transparent rendering */
+{
+struct wigGraphOutput *wgo;
+AllocVar(wgo);
+wgo->image = image;
+wgo->vLine = vLineViaFloat;
+return wgo;
+}
+
+void floatPicIntoHvg(struct floatPic *pic, int xOff, int yOff, struct hvGfx *hvg)
+/* Copy float pic into hvg at given offset. */
+{
+int width = pic->width, height = pic->height;
+Color *lineBuf;
+AllocArray(lineBuf, width);
+int y;
+for (y=0; y<height; ++y)
+    {
+    float *fp = pic->lines[y];
+    Color *cp = lineBuf;
+    int i = width;
+    while (--i >= 0)
+        {
+	int red = fp[0]*255.9;
+	int green = fp[1]*255.9;
+	int blue = fp[2]*255.9;
+	*cp++ = MAKECOLOR_32(red, green, blue);
+	fp += 3;
+	}
+    hvGfxVerticalSmear(hvg, xOff, y + yOff, width, 1, lineBuf, TRUE);
+    }
+freez(&lineBuf);
+}
+
+
 static void minMaxVals(struct slRef *refList, double *retMin, double *retMax,
      enum wiggleAlwaysZeroEnum alwaysZero)
 /* Figure out min/max of everything in list.  The refList contains pointers to
  * preDrawContainers */
 {
 /* Turns out to be *much* shorter to rewrite than to reuse preDrawAutoScale */
 double max = -BIGDOUBLE, min = BIGDOUBLE;
 struct slRef *ref;
 for (ref = refList; ref != NULL; ref = ref->next)
     {
-    struct preDrawContainer *pre;
-    for (pre = ref->val; pre != NULL; pre = pre->next)
-	{
+    struct preDrawContainer *pre = ref->val;
 	struct preDrawElement *p = pre->preDraw + pre->preDrawZero;
 	int width = pre->width;
 	int i;
 	for (i=0; i<width; ++i)
 	    {
 	    if (p->count)
 		{
 		if (min > p->min) min = p->min;
 		if (max < p->max) max = p->max;
 		}
 	    ++p;
 	    }
 	}
-    }
 if (alwaysZero == wiggleAlwaysZeroOn)
     {
     if ( max < 0)
 	max = 0.0;
     else if ( min > 0)
 	min = 0.0;
     }
 *retMax = max;
 *retMin = min;
 }
 
 static void multiWigDraw(struct track *tg, int seqStart, int seqEnd,
         struct hvGfx *hvg, int xOff, int yOff, int width, 
         MgFont *font, Color color, enum trackVisibility vis)
 /* Draw items in multiWig container. */
 {
 struct track *subtrack;
 char *aggregate = wigFetchAggregateValWithCart(cart, tg->tdb);
 boolean overlay = wigIsOverlayTypeAggregate(aggregate);
 boolean errMsgShown = FALSE;
 int y = yOff;
 boolean errMsgFound = FALSE;
 // determine if any subtracks had errors
 for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
     {
     if (isSubtrackVisible(subtrack) && subtrack->networkErrMsg)
 	errMsgFound = TRUE;
     }
 if (errMsgFound)
     {
     Color yellow = hvGfxFindRgb(hvg, &undefinedYellowColor);
     hvGfxBox(hvg, xOff, yOff, width, tg->height, yellow);
     }
 
 /* Cope with autoScale - we do it here rather than in the child tracks, so that
  * all children can be on same scale. */
 struct wigCartOptions *wigCart = tg->extraUiData;
 if (wigCart->autoScale)
     {
     /* Force load of all predraw arrays so can do calcs. Build up list, and then
      * figure out max/min.  No worries about multiple loading, the loaders protect
      * themselves. */
     struct slRef *refList = NULL;
     for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
         {
 	if (isSubtrackVisible(subtrack))
 	    {
 	    struct preDrawContainer *pre = subtrack->loadPreDraw(subtrack, seqStart, seqEnd, width);
 	    refAdd(&refList, pre);
 	    }
 	}
     double minVal, maxVal;
     minMaxVals(refList, &minVal, &maxVal, wigCart->alwaysZero);
     slFreeList(&refList);
 
     /* Cope with log transform if need be */
     if (wigCart->transformFunc == wiggleTransformFuncLog)
          {
 	 minVal = wiggleLogish(minVal);
 	 maxVal = wiggleLogish(maxVal);
 	 }
 
     /* Loop through again setting up the wigCarts of the children to have minY/maxY for
      * our limits and autoScale off. */
     for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
         {
 	struct wigCartOptions *wigCart = subtrack->extraUiData;
 	wigCart->minY = minVal;
 	wigCart->maxY = maxVal;
 	wigCart->autoScale = wiggleScaleManual;
 	}
     }
 
+/* Deal with tranparency possibly */
+struct wigGraphOutput *wgo;
+struct floatPic *floatPic = NULL;
+if (wigCart->transparent)
+    {
+    int height = tg->lineHeight;
+    floatPic = floatPicNew(width, height);
+    floatPicSet(floatPic, 1, 1, 1);
+    wgo = wigGraphOutputTransparent(floatPic);
+    }
+else
+    wgo = wigGraphOutputSolid(xOff, yOff, hvg);
+
 for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
     {
     if (isSubtrackVisible(subtrack))
 	{
         if (!subtrack->networkErrMsg || !errMsgShown)
 	    {
 	    if (subtrack->networkErrMsg)
 	       errMsgShown = TRUE;
+	    subtrack->wigGraphOutput = wgo;
 	    int height = subtrack->totalHeight(subtrack, vis);
 	    hvGfxSetClip(hvg, xOff, y, width, height);
-	    if (sameString(WIG_AGGREGATE_TRANSPARENT, aggregate))
-		hvGfxSetWriteMode(hvg, MG_WRITE_MODE_MULTIPLY);
 	    if (overlay)
 		subtrack->lineHeight = tg->lineHeight;
 	    subtrack->drawItems(subtrack, seqStart, seqEnd, hvg, xOff, y, width, font, color, vis);
 	    if (!overlay)
 		y += height + 1;
-	    hvGfxSetWriteMode(hvg, MG_WRITE_MODE_NORMAL);
 	    hvGfxUnclip(hvg);
 	    }
 	}
     }
+
+if (wigCart->transparent)
+   {
+   floatPicIntoHvg(floatPic, xOff, yOff, hvg);
+   floatPicFree(&floatPic);
+   }
+
 char *url = trackUrl(tg->track, chromName);
 mapBoxHgcOrHgGene(hvg, seqStart, seqEnd, xOff, y, width, tg->height, tg->track, tg->track, NULL,
 	      url, TRUE, NULL);
 }
 
 static int multiWigTotalHeight(struct track *tg, enum trackVisibility vis)
 /* Return total height of multiWigcontainer. */
 {
 char *aggregate = wigFetchAggregateValWithCart(cart, tg->tdb);
 boolean overlay = wigIsOverlayTypeAggregate(aggregate);
 int totalHeight =  0;
 if (overlay)                                                                                       
     totalHeight =  wigTotalHeight(tg, vis);                                                        
 struct track *subtrack;
 for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
     {
     if (isSubtrackVisible(subtrack))
 	{
 	// Logic is slightly complicated by fact we want to call the totalHeight
 	// method for each subtrack even if in overlay mode.
 	int oneHeight = subtrack->totalHeight(subtrack, vis);
 	if (!overlay)
 	    {
 	    if (totalHeight != 0)
 	       totalHeight += 1;
 	    totalHeight += oneHeight;
 	    }
 	}
     }
 tg->height = totalHeight;
 return totalHeight;
 }
 
 static boolean graphLimitsAllSame(struct track *trackList, struct track **retFirstTrack)
 /* Return TRUE if graphUpperLimit and graphLowerLimit same for all tracks. */
 {
 struct track *firstTrack = NULL;
 struct track *track;
 for (track = trackList; track != NULL; track = track->next)
     {
     if (isSubtrackVisible(track) && !track->networkErrMsg)
         {
 	if (firstTrack == NULL)
 	    *retFirstTrack = firstTrack = track;
 	else if (track->graphUpperLimit != firstTrack->graphUpperLimit 
 	    || track->graphLowerLimit != firstTrack->graphLowerLimit)
 	    return FALSE;
 	}
     }
 return firstTrack != NULL;
 }
 
 static void multiWigLeftLabels(struct track *tg, int seqStart, int seqEnd,
 	struct hvGfx *hvg, int xOff, int yOff, int width, int height,
 	boolean withCenterLabels, MgFont *font, Color color,
 	enum trackVisibility vis)
 /* Draw left labels - by deferring to first subtrack. */
 {
 char *aggregate = wigFetchAggregateValWithCart(cart, tg->tdb);
 boolean overlay = wigIsOverlayTypeAggregate(aggregate);
 if (overlay)
     {
     struct track *firstVisibleSubtrack = NULL;
     boolean showNumbers = graphLimitsAllSame(tg->subtracks, &firstVisibleSubtrack);
     struct track *subtrack = (showNumbers ? firstVisibleSubtrack : tg->subtracks);
     wigLeftAxisLabels(tg, seqStart, seqEnd, hvg, xOff, yOff, width, height, withCenterLabels,
 	    font, color, vis, tg->shortLabel, subtrack->graphUpperLimit, 
 	    subtrack->graphLowerLimit, showNumbers);
     }
 else
     {
     struct track *subtrack;
     int y = yOff;
     if (withCenterLabels)
        y += tl.fontHeight+1;
     for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
 	{
 	if (isSubtrackVisible(subtrack))
 	    {
 	    int height = subtrack->totalHeight(subtrack, vis);
 	    if (vis == tvDense)
 	        {
 		/* Avoid wigLeftAxisLabels here because it will repeatedly add center label 
 		 * offsets, and in dense mode we will only draw the one label. */
 		hvGfxTextRight(hvg, xOff, y, width - 1, height, subtrack->ixColor, font, 
 			subtrack->shortLabel);
 		}
 	    else
 		{
 		wigLeftAxisLabels(subtrack, seqStart, seqEnd, hvg, xOff, y, width, height, 
 			withCenterLabels, font, subtrack->ixColor, vis, subtrack->shortLabel, 
 			subtrack->graphUpperLimit, subtrack->graphLowerLimit, TRUE);
 		}
 	    y += height+1;
 	    }
 	}
     }
 }
 
 void multiWigLoadItems(struct track *track)
 /* Load multiWig items. */
 {
 containerLoadItems(track);
 struct track *subtrack;
 for (subtrack = track->subtracks; subtrack != NULL; subtrack = subtrack->next)
     {
     subtrack->mapsSelf = FALSE;	/* Round about way to tell wig not to do own mapping. */
     }
 }
 
 void multiWigContainerMethods(struct track *track)
 /* Override general container methods for multiWig. */
 {
 track->syncChildVisToSelf = TRUE;
 track->loadItems = multiWigLoadItems;
 track->totalHeight = multiWigTotalHeight;
 track->drawItems = multiWigDraw;
 track->drawLeftLabels = multiWigLeftLabels;
 }