25d11f512ac8d8b6605b81a770e0a6d9b121ec12
braney
  Thu Sep 26 13:31:58 2024 -0700
Revert "Revert "if we go over the 32k PNG size limit, put all the tracks that can wiggle""

This reverts commit d7861537f514c72ecd89dd51389794cd8f07baef.

diff --git src/hg/hgTracks/hgTracks.c src/hg/hgTracks/hgTracks.c
index 08bd1d2..d281d45 100644
--- src/hg/hgTracks/hgTracks.c
+++ src/hg/hgTracks/hgTracks.c
@@ -4860,30 +4860,40 @@
         slReverse(&track->items);
         slReverse(&squishTrack->items);
         
         squishTrack->track = cloneString(buffer);
         squishTrack->originalTrack = cloneString(track->track);
         squishTrack->shortLabel = cloneString(track->shortLabel);
         squishTrack->longLabel = cloneString(track->longLabel);
 
         /* insert the squished track */
         track->next = squishTrack;
         squishTrack->next = nextTrack;
         }
     }
 }
 
+boolean forceWiggle; // we've run out of space so all tracks become coverage tracks
+
+static void addPreFlatTrack(struct trackRef **list, struct track *track)
+{
+struct trackRef *trackRef;
+AllocVar(trackRef);
+trackRef->track = track;
+slAddHead(list, trackRef);
+}
+
 void makeActiveImage(struct track *trackList, char *psOutput)
 /* Make image and image map. */
 {
 struct track *track;
 MgFont *font = tl.font;
 struct hvGfx *hvg;
 struct tempName pngTn;
 char *mapName = "map";
 int fontHeight = mgFontLineHeight(font);
 int trackPastTabX = (withLeftLabels ? trackTabWidth : 0);
 int trackTabX = gfxBorder;
 int trackPastTabWidth = tl.picWidth - trackPastTabX;
 int pixWidth, pixHeight;
 int y=0;
 int titleHeight = fontHeight;
@@ -5017,30 +5027,33 @@
 
 // For multiple windows, sets height and visibility
 //       as well as making the flatTrack list.
 
 // TODO there is a chance that for pack and squish
 // I might need to trigger a track-height check here
 // since it is after all items are loaded for all windows
 // but before things are checked for overflow or limitedVis?
 // The fixed non-overflow tracks like knownGene used to initialize
 // ss and track height during loadItems(). That was delayed
 // because we now need all windows to be fully loaded before
 // calculating their joint ss layout and height.
 
 // set heights and visibilities.
 struct window *window = NULL;
+
+// we may come through this way twice if we exceed the 32k limit for screen image
+retry:
 for(window=windows;window;window=window->next)
     {
     setGlobalsFromWindow(window);
     trackList = window->trackList;
     for (track = trackList; track != NULL; track = track->next)
 	{
 	if (tdbIsCompositeChild(track->tdb)) // When single track is requested via AJAX,
 	    {
 	    limitedVisFromComposite(track);  // it could be a subtrack
 	    }
 	else
 	    {
 	    limitVisibility(track);
 	    }
 
@@ -5085,65 +5098,108 @@
     }
 
 if (wigOrder != NULL)
     {
     orderedWiggles = slNameListFromString(wigOrder, ' ');
     struct slName *name = orderedWiggles;
     // if we're sorting, remove existing sort order for this composite
     for(; name; name = name->next)
         {
         char buffer[1024];
         safef(buffer, sizeof buffer,  "%s_imgOrd", name->name);
         cartRemove(cart, buffer);
         }
     }
 
-// Construct flatTracks
+// Construct pre-flatTracks 
+struct trackRef *preFlatTracks = NULL;
 for (track = trackList; track != NULL; track = track->next)
     {
     if (isLimitedVisHiddenForAllWindows(track))
         continue;
 
     if (tdbIsComposite(track->tdb))
         {
         struct track *subtrack;
         if (isCompositeInAggregate(track))
-            flatTracksAdd(&flatTracks, track, cart, orderedWiggles);
+            addPreFlatTrack(&preFlatTracks, track);
         else
             {
             boolean doHideEmpties = doHideEmptySubtracksNoMultiBed(cart, track);
                 // If multibed was found, it has been used to suppress loading,
                 // and subtracks lacking items in window are already set hidden
             for (subtrack = track->subtracks; subtrack != NULL; subtrack = subtrack->next)
                 {
                 if (!isSubtrackVisible(subtrack))
                     continue;
 
                 if (!isLimitedVisHiddenForAllWindows(subtrack) && 
                         !(doHideEmpties && slCount(subtrack->items) == 0))
                         // Ignore subtracks with no items in window
                     {
-                    flatTracksAdd(&flatTracks,subtrack,cart, orderedWiggles);
+                    addPreFlatTrack(&preFlatTracks, track);
                     }
                 }
             }
         }
     else
 	{	
-        flatTracksAdd(&flatTracks,track,cart, orderedWiggles);
+        addPreFlatTrack(&preFlatTracks, track);
+	}
+    }
+
+// check total height
+#define MAXSAFEHEIGHT "maxTrackImageHeightPx"
+int maxSafeHeight = atoi(cfgOptionDefault(MAXSAFEHEIGHT, "32000"));
+boolean safeHeight = TRUE;
+struct trackRef *pfRef;
+int tmpPixHeight = pixHeight;
+for(pfRef = preFlatTracks; pfRef; pfRef = pfRef->next)
+    {
+    struct track *pf = pfRef->track;
+    int totalHeight = tmpPixHeight+trackPlusLabelHeight(pf,fontHeight);
+    if (totalHeight > maxSafeHeight)
+        {
+        if (!forceWiggle)
+            {
+            forceWiggle = TRUE;
+            goto retry;
             }
+        char numBuf[SMALLBUF];
+        sprintLongWithCommas(numBuf, maxSafeHeight);
+        if (safeHeight)  // Only one message
+            warn("Image is over %s pixels high (%d pix) at the following track which is now "
+                 "hidden:<BR>\"%s\".%s", numBuf, totalHeight, pf->tdb->longLabel,
+                 (pf->next != NULL ?
+                      "\nAdditional tracks may have also been hidden at this zoom level." : ""));
+        safeHeight = FALSE;
+	struct track *winTrack;
+	for(winTrack=pf;winTrack;winTrack=winTrack->nextWindow)
+	    {
+	    pf->limitedVis = tvHide;
+	    pf->limitedVisSet = TRUE;
 	    }
+        }
+    if (!isLimitedVisHiddenForAllWindows(pf))
+        tmpPixHeight += trackPlusLabelHeight(pf, fontHeight);
+    }
+pixHeight = tmpPixHeight;
+
+// Construct flatTracks
+for(; preFlatTracks; preFlatTracks = preFlatTracks->next)
+    flatTracksAdd(&flatTracks,preFlatTracks->track,cart, orderedWiggles);
+
 flatTracksSort(&flatTracks); // Now we should have a perfectly good flat track list!
 
 if (orderedWiggles)
     {
     // save order to cart
     struct flatTracks *ft;
     char buffer[4096];
     int count = 1;
     for(ft = flatTracks; ft; ft = ft->next)
         {
         safef(buffer, sizeof buffer, "%s_imgOrd", ft->track->track);
         cartSetInt(cart, buffer, count++);
         }
     }
 
@@ -5151,70 +5207,45 @@
 for (flatTrack = flatTracks; flatTrack != NULL; flatTrack = flatTrack->next)
     {
     track = flatTrack->track;
 
     if (track->limitedVis == tvHide)
 	{
 	continue;
 	}
 
     setFlatTrackMaxHeight(flatTrack, fontHeight);
 
     }
 
 
 // fill out track->prevTrack, and check for maxSafeHeight
-boolean safeHeight = TRUE;
-/* firefox on Linux worked almost up to 34,000 at the default 620 width */
-/* More recent hardware/browsers may be able to handle more - we had a success with an 8192x64891 image */
-#define MAXSAFEHEIGHT "maxTrackImageHeightPx"
-int maxSafeHeight = atoi(cfgOptionDefault(MAXSAFEHEIGHT, "32000"));
 struct track *prevTrack = NULL;
 for (flatTrack = flatTracks,prevTrack=NULL; flatTrack != NULL; flatTrack = flatTrack->next)
     {
     track = flatTrack->track;
     assert(track->limitedVis != tvHide);
-    // ORIG int totalHeight = pixHeight+trackPlusLabelHeight(track,fontHeight);
-    int totalHeight = pixHeight+flatTrack->maxHeight;
-    if (totalHeight > maxSafeHeight)
-        {
-        char numBuf[SMALLBUF];
-        sprintLongWithCommas(numBuf, maxSafeHeight);
-        if (safeHeight)  // Only one message
-            warn("Image is over %s pixels high (%d pix) at the following track which is now "
-                 "hidden:<BR>\"%s\".%s", numBuf, totalHeight, track->tdb->longLabel,
-                 (flatTrack->next != NULL ?
-                      "\nAdditional tracks may have also been hidden at this zoom level." : ""));
-        safeHeight = FALSE;
-	struct track *winTrack;
-	for(winTrack=track;winTrack;winTrack=winTrack->nextWindow)
-	    {
-	    track->limitedVis = tvHide;
-	    track->limitedVisSet = TRUE;
-	    }
-        }
     if (!isLimitedVisHiddenForAllWindows(track))
         {
 	struct track *winTrack;
 	for(winTrack=track;winTrack;winTrack=winTrack->nextWindow)
 	    { // TODO this is currently still only using one prev track value.
 	    winTrack->prevTrack = prevTrack; // Important for keeping track of conditional center labels!
 	    }
         // ORIG pixHeight += trackPlusLabelHeight(track, fontHeight);
 	if (!theImgBox) // prevTrack may have altered the height, so recalc height
 	    setFlatTrackMaxHeight(flatTrack, fontHeight);
-	pixHeight += flatTrack->maxHeight;
         prevTrack = track;
         }
     }
 
 // allocate hvg png of pixWidth, pixHeight
 imagePixelHeight = pixHeight;
 if (psOutput)
     {
     hvg = hvGfxOpenPostScript(pixWidth, pixHeight, psOutput);
     hvgSide = hvg; // Always only one image
     }
 else
     {
     boolean transparentImage = FALSE;
     if (theImgBox!=NULL)