127b6b678948569c41e56db76db116e2a3836beb
braney
  Wed May 8 14:14:39 2019 -0700
Add a pack mode to bigLolly that shows the data as bigBed

diff --git src/hg/hgTracks/lollyTrack.c src/hg/hgTracks/lollyTrack.c
index 0127ed4..0328707 100644
--- src/hg/hgTracks/lollyTrack.c
+++ src/hg/hgTracks/lollyTrack.c
@@ -1,32 +1,31 @@
 /* lollyTrack -- load and draw lollys */
 
 /* Copyright (C) 2019 The Regents of the University of California 
  * See README in this or parent directory for licensing information. */
 
 #include "common.h"
 #include "obscure.h"
 #include "hgTracks.h"
 #include "bedCart.h"
 #include "bigWarn.h"
 #include "lolly.h"
 #include "limits.h"
 #include "float.h"
 #include "bigBedFilter.h"
 
-#define LOLLY_RADIUS    5
-#define LOLLY_DIAMETER    2 * LOLLY_RADIUS
+#define LOLLY_DIAMETER    2 * lollyCart->radius
 
 
 /* the lolly colors */
 static int lollyPalette[] =
 {
 0x1f77b4, 0xff7f0e, 0x2ca02c, 0xd62728, 0x9467bd, 0x8c564b, 0xe377c2, 0x7f7f7f, 0xbcbd22, 0x17becf
 };
 
 struct lolly
 {
 struct lolly *next;
 char *name;       /* the mouseover name */
 double val;       /* value in the data file */   
 unsigned start;   /* genomic start address */
 unsigned end;     /* genomic end address */
@@ -79,67 +78,80 @@
     {
     int sx = ((pop->start - seqStart) + .5) * scale + xOff; // x coord of center (lower region)
     hvGfxCircle(hvg, sx, yOff + trackHeight - pop->radius - pop->height, pop->radius, pop->color, TRUE);
     if (!noMapBoxes)
         mapBoxHgcOrHgGene(hvg, pop->start, pop->end, sx - pop->radius, yOff + trackHeight - pop->radius - pop->height - pop->radius, 2 * pop->radius,2 * pop->radius,
                           tg->track, pop->name, pop->name, NULL, TRUE, NULL);
     }
 }
 
 void lollyLeftLabels(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 the labels on the left margin
 {
+struct lollyCartOptions *lollyCart = tg->lollyCart;
 int fontHeight = tl.fontHeight+1;
 int centerLabel = (height/2)-(fontHeight/2);
 if ( tg->visibility == tvDense)
     {
     hvGfxText(hvg, xOff, yOff+fontHeight, color, font, tg->shortLabel);
     return;
     }
 
 hvGfxText(hvg, xOff, yOff+centerLabel, color, font, tg->shortLabel);
 
-if (isnan(tg->lollyCart->upperLimit))
+if (isnan(lollyCart->upperLimit))
     {
     hvGfxTextRight(hvg, xOff, yOff + LOLLY_DIAMETER, width - 1, fontHeight, color,
         font, "NO DATA");
     return;
     }
 
 char upper[1024];
-safef(upper, sizeof(upper), "%g -",   tg->lollyCart->upperLimit);
+safef(upper, sizeof(upper), "%g -",   lollyCart->upperLimit);
 hvGfxTextRight(hvg, xOff, yOff + LOLLY_DIAMETER, width - 1, fontHeight, color,
     font, upper);
 char lower[1024];
-if (tg->lollyCart->lowerLimit < tg->lollyCart->upperLimit)
+if (lollyCart->lowerLimit < lollyCart->upperLimit)
     {
-    safef(lower, sizeof(lower), "%g _", tg->lollyCart->lowerLimit);
+    safef(lower, sizeof(lower), "%g _", lollyCart->lowerLimit);
     hvGfxTextRight(hvg, xOff, yOff+height-fontHeight - LOLLY_DIAMETER, width - 1, fontHeight,
         color, font, lower);
     }
 }
 
 
 static int lollyHeight(struct track *tg, enum trackVisibility vis)
 /* calculate height of all the lollys being displayed */
 {
 if ( tg->visibility == tvDense)
     return  tl.fontHeight;
 
+// if we're pack, then use bigBed drawing
+if (tg->visibility == tvPack)
+    {
+    char *ourWords[2];
+    ourWords[0] = "bigBed";
+    ourWords[1] = "4";
+    bigBedMethods(tg, tg->tdb,2,ourWords);
+    tg->mapsSelf = FALSE;
+    tg->drawLeftLabels = NULL;
+    return tg->totalHeight(tg, vis);
+    }
+
 // return the height we calculated at load time
 return tg->lollyCart->height;
 }
 
 #ifdef NOTUSED
 double calcVarianceFromSums(double sum, double sumSquares, bits64 n)
 /* Calculate variance. */
 {   
 double var = sumSquares - sum*sum/n;
 if (n > 1)
     var /= n-1;
 return var;
 }   
     
 double calcStdFromSums(double sum, double sumSquares, bits64 n)
@@ -148,39 +160,44 @@
 return sqrt(calcVarianceFromSums(sum, sumSquares, n));
 }
 #endif // NOTUSED
 
 int cmpHeight(const void *va, const void *vb)
 // sort the lollies by height 
 {
 const struct lolly *a = *((struct lolly **)va);
 const struct lolly *b = *((struct lolly **)vb);
 return a->height - b->height;
 }
 
 void lollyLoadItems(struct track *tg)
 // load lollies from the data file
 {
+struct lollyCartOptions *lollyCart = tg->lollyCart;
+if (tg->visibility == tvSquish)
+    {
+    lollyCart->radius = 2;
+    lollyCart->height /= 3;
+    }
 struct lm *lm = lmInit(0);
 struct bbiFile *bbi =  fetchBbiForTrack(tg);
 struct bigBedInterval *bb, *bbList =  bigBedIntervalQuery(bbi, chromName, winStart, winEnd, 0, lm);
 char *bedRow[bbi->fieldCount];
 char startBuf[16], endBuf[16];
 struct lolly *popList = NULL, *pop;
 
 unsigned lollyField = 5;  // we use the score field by default
-struct lollyCartOptions *lollyCart = tg->lollyCart;
 char *setting = trackDbSetting(tg->tdb, "lollyField");
 if (setting != NULL)
     lollyField = atoi(setting);
 
 double minVal = DBL_MAX, maxVal = -DBL_MAX;
 //double sumData = 0.0, sumSquares = 0.0;
 unsigned count = 0;
 
 int trackHeight = tg->lollyCart->height;
 struct bigBedFilter *filters = bigBedBuildFilters(cart, bbi, tg->tdb);
                     
 for (bb = bbList; bb != NULL; bb = bb->next)
     {
     bigBedIntervalToRow(bb, chromName, startBuf, endBuf, bedRow, ArraySize(bedRow));
 
@@ -212,31 +229,31 @@
         minVal = val;
     }
 
 if (count == 0)
     lollyCart->upperLimit = lollyCart->lowerLimit = NAN; // no lollies in range
 else if (lollyCart->autoScale == wiggleScaleAuto)
     {
     lollyCart->upperLimit = maxVal;
     lollyCart->lowerLimit = minVal;
     }
 
 double range = lollyCart->upperLimit - lollyCart->lowerLimit;
 int usableHeight = trackHeight - 2 * LOLLY_DIAMETER; 
 for(pop = popList; pop; pop = pop->next)
     {
-    pop->radius = LOLLY_RADIUS;
+    pop->radius = lollyCart->radius;
     pop->color = MG_RED;
     if (range == 0.0)
         {
         pop->height = usableHeight ;
         pop->color = lollyPalette[0] | 0xff000000;
         }
     else
         {
         pop->height = usableHeight * (pop->val  - lollyCart->lowerLimit) / range + LOLLY_DIAMETER;
         int colorIndex = 8 * (pop->val  - lollyCart->lowerLimit) / range;
         pop->color = lollyPalette[colorIndex] | 0xff000000;
         }
     }
 
 #ifdef NOTUSED   // a method of scaling assuming a sort of normal distribution
@@ -292,28 +309,28 @@
 double tDbMinY;     /*  data range limits from trackDb type line */
 double tDbMaxY;     /*  data range limits from trackDb type line */
 char *trackWords[8];     /*  to parse the trackDb type line  */
 int trackWordCount = 0;  /*  to parse the trackDb type line  */
 wigFetchMinMaxYWithCart(cart, tdb, tdb->track, &lollyCart->minY, &lollyCart->maxY, &tDbMinY, &tDbMaxY, trackWordCount, trackWords);
 lollyCart->upperLimit = lollyCart->maxY;
 lollyCart->lowerLimit = lollyCart->minY;
 
 return lollyCart;
 }
 
 void lollyMethods(struct track *track, struct trackDb *tdb, 
                                 int wordCount, char *words[])
 /* bigLolly track type methods */
 {
-struct lollyCartOptions *lollyCart = lollyCartOptionsNew(cart, tdb, wordCount, words);
 char *ourWords[2];
 ourWords[0] = "bigBed";
 ourWords[1] = "4";
 bigBedMethods(track, tdb,2,ourWords);
-if (tdb->visibility == tvDense)
-    return;
+
+struct lollyCartOptions *lollyCart = lollyCartOptionsNew(cart, tdb, wordCount, words);
+lollyCart->radius = 5;
 track->loadItems = lollyLoadItems;
 track->drawItems = lollyDrawItems;
 track->totalHeight = lollyHeight; 
 track->drawLeftLabels = lollyLeftLabels;
 track->lollyCart = lollyCart;
 }