void loadGappedBed(struct track *tg) /* Convert bed info in window to linked feature. */ { struct sqlResult *sr; char **row; int rowOffset; struct bed *bed; struct linkedFeatures *lfList = NULL, *lf; struct trackDb *tdb = tg->tdb; int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0")); int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000")); boolean useItemRgb = FALSE; useItemRgb = bedItemRgb(tdb); if (tg->isBigBed) { // avoid opening an unneeded db connection for bigBed; required not to use mysql for parallel fetch tracks bigBedAddLinkedFeaturesFrom(tg, chromName, winStart, winEnd, scoreMin, scoreMax, useItemRgb, 12, &lfList); } else { /* Use tg->tdb->track because subtracks inherit composite track's tdb * by default, and the variable is named after the composite track. */ struct sqlConnection *conn = hAllocConn(database); char *scoreFilterClause = getScoreFilterClause(cart, tg->tdb,NULL); if (scoreFilterClause != NULL) { sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd,scoreFilterClause, &rowOffset); freeMem(scoreFilterClause); } else { sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, NULL, &rowOffset); } while ((row = sqlNextRow(sr)) != NULL) { bed = bedLoad12(row+rowOffset); adjustBedScoreGrayLevel(tdb, bed, scoreMin, scoreMax); lf = lfFromBedExtra(bed, scoreMin, scoreMax); if (useItemRgb) { lf->extra = (void *)USE_ITEM_RGB; /* signal for coloring */ lf->filterColor=bed->itemRgb; } slAddHead(&lfList, lf); bedFree(&bed); } sqlFreeResult(&sr); hFreeConn(&conn); } slReverse(&lfList); if(tg->extraUiData) filterBed(tg, &lfList); slSort(&lfList, linkedFeaturesCmp); tg->items = lfList; }
static char *wigCheckBinaryOption(struct trackDb *tdb, char *Default, char *notDefault, char *tdbString, char *secondTdbString) /* A common operation for binary options (two values possible) * check for trackDb.ra, then tdb->settings values * return one of the two possibilities if found * (the tdbString and secondTdbString are a result of * early naming conventions changing over time resulting in * two possible names for the same thing ...) */ { char *tdbDefault = trackDbSettingClosestToHomeOrDefault(tdb, tdbString, "NONE"); char *ret; ret = Default; /* the answer, unless found to be otherwise */ if (sameWord("NONE",tdbDefault) && (secondTdbString != (char *)NULL)) tdbDefault = trackDbSettingClosestToHomeOrDefault(tdb, secondTdbString, "NONE"); if (differentWord("NONE",tdbDefault)) { if (differentWord(Default,tdbDefault)) ret = notDefault; } else { struct hashEl *hel; /* no setting from trackDb, maybe it is in tdb->settings * (custom tracks keep settings here) */ if ((tdb->settings != (char *)NULL) && (tdb->settingsHash != (struct hash *)NULL)) { if ((hel = hashLookup(tdb->settingsHash, tdbString)) != NULL) { if (differentWord(Default,(char *)hel->val)) ret = notDefault; } else if (secondTdbString != (char *)NULL) { if ((hel = hashLookup(tdb->settingsHash, secondTdbString)) != NULL) { if (differentWord(Default,(char *)hel->val)) ret = notDefault; } } } } return(cloneString(ret)); }
void loadBed8(struct track *tg) /* Convert bed 8 info in window to linked feature. */ { struct bed *bed; struct linkedFeatures *lfList = NULL, *lf; struct trackDb *tdb = tg->tdb; int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0")); int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000")); boolean useItemRgb = FALSE; useItemRgb = bedItemRgb(tdb); if (tg->isBigBed) { // avoid opening an unneeded db connection for bigBed; required not to use mysql for parallel fetch tracks bigBedAddLinkedFeaturesFrom(tg, chromName, winStart, winEnd, scoreMin, scoreMax, useItemRgb, 8, &lfList); } else { struct sqlConnection *conn = hAllocConn(database); struct sqlResult *sr; char **row; int rowOffset; char *scoreFilterClause = getScoreFilterClause(cart, tg->tdb,NULL); if (scoreFilterClause != NULL) { sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd,scoreFilterClause, &rowOffset); freeMem(scoreFilterClause); } else { sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, NULL, &rowOffset); } while ((row = sqlNextRow(sr)) != NULL) { bed = bedLoadN(row+rowOffset, 8); lf = bedMungToLinkedFeatures(&bed, tdb, 8, scoreMin, scoreMax, useItemRgb); slAddHead(&lfList, lf); } sqlFreeResult(&sr); hFreeConn(&conn); } slReverse(&lfList); slSort(&lfList, linkedFeaturesCmp); tg->items = lfList; }
enum netLevelEnum netFetchLevelOption(struct cart *cart, struct trackDb *tdb, boolean compositeLevel) /****** netLevelOption - net level 0 (All levels) by default ***********/ { char *netLevel = NULL; enum netLevelEnum ret; netLevel = trackDbSettingClosestToHomeOrDefault(tdb, NET_LEVEL, "0"); /* trackDb can be netLevel=0 thru netLevel=1, need to translate that number into enum strings */ /* assume "All levels" first */ ret = netLevelStringToEnum(NET_LEVEL_0); switch(sqlUnsigned(netLevel)) { case 0: break; case 1: ret = netLevelStringToEnum(NET_LEVEL_1); break; case 2: ret = netLevelStringToEnum(NET_LEVEL_2); break; case 3: ret = netLevelStringToEnum(NET_LEVEL_3); break; case 4: ret = netLevelStringToEnum(NET_LEVEL_4); break; case 5: ret = netLevelStringToEnum(NET_LEVEL_5); break; case 6: ret = netLevelStringToEnum(NET_LEVEL_6); break; default: warn("trackDb setting %s=%s for track %s is unrecognized, should be in range [0-6]", NET_LEVEL, netLevel, tdb->track); break; } /* allow cart to override trackDb */ ret = netLevelStringToEnum( cartUsualStringClosestToHome(cart, tdb, compositeLevel, NET_LEVEL, netLevelEnumToString(ret))); return(ret); } /* enum netLevelEnum netFetchLevelOption() */
static void encodePeakLoadItemsBoth(struct track *tg, struct customTrack *ct) /* Load up an encodePeak table from the regular database or the customTrash one. */ { char *db, *table; struct sqlConnection *conn; struct sqlResult *sr = NULL; char **row; char *filterConstraints = NULL; int rowOffset; struct linkedFeatures *lfList = NULL; enum encodePeakType pt = 0; int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tg->tdb, "scoreMin", "0")); int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tg->tdb, "scoreMax", "1000")); if (ct) { db = CUSTOM_TRASH; table = ct->dbTableName; } else { db = database; table = tg->tdb->table; } conn = hAllocConn(db); pt = encodePeakInferTypeFromTable(db, table, tg->tdb->type); tg->customInt = pt; filterConstraints = encodePeakFilter(tg->tdb->track, tg->tdb, (ct!=NULL)); sr = hRangeQuery(conn, table, chromName, winStart, winEnd, filterConstraints, &rowOffset); while ((row = sqlNextRow(sr)) != NULL) { struct encodePeak *peak = encodePeakGeneralLoad(row + rowOffset, pt); struct linkedFeatures *lf = lfFromEncodePeak((struct slList *)peak, tg->tdb, scoreMin, scoreMax); if (lf) slAddHead(&lfList, lf); } sqlFreeResult(&sr); hFreeConn(&conn); slReverse(&lfList); slSort(&lfList, linkedFeaturesCmp); tg->items = lfList; }
enum wiggleAggregateFunctionEnum wigFetchAggregateFunctionWithCart(struct cart *theCart, struct trackDb *tdb, char *name, char **optString) /****** windowingFunction - Whiskers by default **************************/ { char *Default = wiggleAggregateFunctionEnumToString(wiggleAggregateTransparent); boolean parentLevel = isNameAtParentLevel(tdb,name); char *aggregateFunction = NULL; enum wiggleAggregateFunctionEnum ret; aggregateFunction = cloneString(cartOptionalStringClosestToHome(theCart, tdb, parentLevel, AGGREGATE)); /* If windowingFunction is a string, it came from the cart, otherwise * see if it is specified in the trackDb option, finally * return the default. */ if (!aggregateFunction) { char * tdbDefault = trackDbSettingClosestToHomeOrDefault(tdb, AGGREGATE, Default); freeMem(aggregateFunction); if (differentWord(Default,tdbDefault)) aggregateFunction = cloneString(tdbDefault); else { struct hashEl *hel; /* no aggregateFunction from trackDb, maybe it is in tdb->settings * (custom tracks keep settings here) */ aggregateFunction = cloneString(Default); if ((tdb->settings != (char *)NULL) && (tdb->settingsHash != (struct hash *)NULL)) { if ((hel =hashLookup(tdb->settingsHash, AGGREGATE)) !=NULL) if (differentWord(Default,(char *)hel->val)) { freeMem(aggregateFunction); aggregateFunction = cloneString((char *)hel->val); } } } } if (optString) *optString = cloneString(aggregateFunction); ret = wiggleAggregateFunctionStringToEnum(aggregateFunction); freeMem(aggregateFunction); return(ret); } /* enum wiggleWindowingEnum wigFetchWindowingFunctionWithCart() */
void bedDrawSimpleAt(struct track *tg, void *item, struct hvGfx *hvg, int xOff, int y, double scale, MgFont *font, Color color, enum trackVisibility vis) /* Draw a single simple bed item at position. */ { struct bed *bed = item; int heightPer = tg->heightPer; int s = max(bed->chromStart, winStart), e = min(bed->chromEnd, winEnd); if (s > e) return; int x1 = round((s-winStart)*scale) + xOff; int x2 = round((e-winStart)*scale) + xOff; int w = x2 - x1; if (w < 1) w = 1; struct trackDb *tdb = tg->tdb; int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0")); int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000")); char *directUrl = trackDbSetting(tdb, "directUrl"); boolean withHgsid = (trackDbSetting(tdb, "hgsid") != NULL); boolean thickDrawItem = (trackDbSetting(tdb, "thickDrawItem") != NULL); if (tg->itemColor != NULL) { color = tg->itemColor(tg, bed, hvg); } else if (tg->colorShades) { adjustBedScoreGrayLevel(tdb, bed, scoreMin, scoreMax); color = tg->colorShades[grayInRange(bed->score, scoreMin, scoreMax)]; } /* Keep the item at least 4 pixels wide at all viewpoints */ if (thickDrawItem && (w < 4)) { x1 -= ((5-w) >> 1); w = 4; x2 = x1 + w; }
void wigFetchYLineMarkValueWithCart(struct cart *theCart,struct trackDb *tdb, char *name, double *tDbYMark ) /* y= marker line value * User requested value is defined in the cart * A Default value can be defined as * yLineMark declaration from trackDb *****************************************************************************/ { boolean parentLevel = isNameAtParentLevel(tdb,name); char *yLineMarkValue = NULL; /* string from cart */ double yLineValue; /* value from cart or trackDb */ char * tdbDefault = cloneString( trackDbSettingClosestToHomeOrDefault(tdb, YLINEMARK, "NONE") ); if (sameWord("NONE",tdbDefault)) { struct hashEl *hel; /* no yLineMark from trackDb, maybe it is in tdb->settings * (custom tracks keep settings here) */ if ((tdb->settings != (char *)NULL) && (tdb->settingsHash != (struct hash *)NULL)) { if ((hel = hashLookup(tdb->settingsHash, YLINEMARK)) != NULL) { freeMem(tdbDefault); tdbDefault = cloneString((char *)hel->val); } } } /* If nothing else, it is zero */ yLineValue = 0.0; /* Let's see if a value is available in the cart */ yLineMarkValue = cartOptionalStringClosestToHome(theCart, tdb, parentLevel, YLINEMARK); /* if yLineMarkValue is non-Null, it is the requested value */ if (yLineMarkValue) yLineValue = atof(yLineMarkValue); else /* See if a default line is specified in the trackDb.ra file */ if (differentWord("NONE",tdbDefault)) yLineValue = atof(tdbDefault); /* If possible to return */ if (tDbYMark) *tDbYMark = yLineValue; freeMem(tdbDefault); } /* void wigFetchYLineMarkValueWithCart() */
enum wiggleSmoothingEnum wigFetchSmoothingWindowWithCart(struct cart *theCart, struct trackDb *tdb, char *name, char **optString) /****** smoothingWindow - OFF by default **************************/ { char * Default = wiggleSmoothingEnumToString(wiggleSmoothingOff); boolean parentLevel = isNameAtParentLevel(tdb,name); char * smoothingWindow = NULL; enum wiggleSmoothingEnum ret; smoothingWindow = cloneString(cartOptionalStringClosestToHome(theCart, tdb, parentLevel, SMOOTHINGWINDOW)); if (!smoothingWindow) /* if nothing from the Cart, check trackDb/settings */ { char * tdbDefault = trackDbSettingClosestToHomeOrDefault(tdb, SMOOTHINGWINDOW, Default); if (differentWord(Default,tdbDefault)) smoothingWindow = cloneString(tdbDefault); else { struct hashEl *hel; /* no smoothingWindow from trackDb, maybe it is in tdb->settings * (custom tracks keep settings here) */ smoothingWindow = cloneString(Default); if ((tdb->settings != (char *)NULL) && (tdb->settingsHash != (struct hash *)NULL)) { if ((hel = hashLookup(tdb->settingsHash, SMOOTHINGWINDOW)) != NULL) if (differentWord(Default,(char *)hel->val)) { freeMem(smoothingWindow); smoothingWindow = cloneString((char *)hel->val); } } } } if (optString) *optString = cloneString(smoothingWindow); ret = wiggleSmoothingStringToEnum(smoothingWindow); freeMem(smoothingWindow); return(ret); } /* enum wiggleSmoothingEnum wigFetchSmoothingWindowWithCart() */
enum netColorEnum netFetchColorOption(struct cart *cart, struct trackDb *tdb, boolean parentLevel) /****** netColorOption - Chrom colors by default **************************/ { char *netColor = NULL; enum netColorEnum ret; netColor = trackDbSettingClosestToHomeOrDefault(tdb, NET_COLOR, CHROM_COLORS); /* trackDb can be netColor=Chromosome or netColor=grayScale, need to translate grayScale into "Gray scale" */ if (sameWord(TDB_GRAY_SCALE,netColor)) netColor = GRAY_SCALE; /* and then, allow cart to override trackDb */ ret = netColorStringToEnum( cartUsualStringClosestToHome(cart, tdb, parentLevel, NET_COLOR, netColor)); return(ret); } /* enum netColorEnum netFetchColorOption() */
enum wiggleScaleOptEnum wigFetchAutoScaleWithCart(struct cart *theCart, struct trackDb *tdb, char *name, char **optString) /****** autoScale - off by default ***************************************/ { char *autoString = wiggleScaleEnumToString(wiggleScaleAuto); char *manualString = wiggleScaleEnumToString(wiggleScaleManual); char *Default = manualString; char *notDefault = autoString; boolean parentLevel = isNameAtParentLevel(tdb,name); char *autoScale = NULL; enum wiggleScaleOptEnum ret; autoScale = cloneString(cartOptionalStringClosestToHome(theCart, tdb, parentLevel, AUTOSCALE)); if (!autoScale) /* if nothing from the Cart, check trackDb/settings */ { /* It may be the autoScale=on/off situation from custom tracks */ char * tdbDefault = trackDbSettingClosestToHomeOrDefault(tdb, AUTOSCALE, "NONE"); if (sameWord(tdbDefault,"on")) autoScale = cloneString(autoString); else if (sameWord(tdbDefault,"off")) autoScale = cloneString(manualString); else { if (isCustomTrack(tdb->track)) // backwards defaults for custom tracks, autoScale on autoScale = wigCheckBinaryOption(tdb,notDefault,Default, AUTOSCALEDEFAULT, AUTOSCALE); else autoScale = wigCheckBinaryOption(tdb,Default,notDefault, AUTOSCALEDEFAULT, AUTOSCALE); } } if (optString) *optString = cloneString(autoScale); ret = wiggleScaleStringToEnum(autoScale); freeMem(autoScale); return(ret); } /* enum wiggleScaleOptEnum wigFetchAutoScaleWithCart() */
void wigFetchMinMaxYWithCart(struct cart *theCart, struct trackDb *tdb, char *name, double *retMin, double *retMax, double *retAbsMin, double *retAbsMax, int wordCount, char **words) /***************************************************************************** * Min, Max Y viewing limits * Absolute limits are defined on the trackDb type line for wiggle, * or MIN_LIMIT / MAX_LIMIT trackDb settings for bedGraph * User requested limits are defined in the cart * Default opening display limits are optionally defined with the * defaultViewLimits or viewLimits declaration from trackDb *****************************************************************************/ { boolean isBedGraph = (wordCount == 0 || sameString(words[0],"bedGraph")); // Determine absolute min and max. Someday hgTrackDb will enforce inclusion of data // range settings, but until then, there is some circular logic where either one // can provide a default for the other if the other is missing. double absMax = 0.0, absMin = 0.0; boolean missingAbsMin = FALSE, missingAbsMax = FALSE; if (isBedGraph) { char *tdbMin = trackDbSettingClosestToHomeOrDefault(tdb, MIN_LIMIT, NULL); char *tdbMax = trackDbSettingClosestToHomeOrDefault(tdb, MAX_LIMIT, NULL); if (tdbMin == NULL) missingAbsMin = TRUE; else absMin = sqlDouble(tdbMin); if (tdbMax == NULL) missingAbsMax = TRUE; else absMax = sqlDouble(tdbMax); } else { // Wiggle: get min and max from type setting, which has been chopped into words and wordCount: // type wig <min> <max> if (wordCount >= 3) absMax = atof(words[2]); else missingAbsMax = TRUE; if (wordCount >= 2) absMin = atof(words[1]); else missingAbsMin = TRUE; } correctOrder(absMin, absMax); // Determine current minY,maxY. // Precedence: 1. cart; 2. defaultViewLimits; 3. viewLimits; // 4. absolute [which may need to default to #2 or #3!] boolean parentLevel = isNameAtParentLevel(tdb, name); char *cartMinStr = cartOptionalStringClosestToHome(theCart, tdb, parentLevel, MIN_Y); char *cartMaxStr = cartOptionalStringClosestToHome(theCart, tdb, parentLevel, MAX_Y); double cartMin = 0.0, cartMax = 0.0; if(cartMinStr) *retMin = atof(cartMinStr); if(cartMaxStr) *retMax = atof(cartMaxStr); if (cartMinStr && cartMaxStr) correctOrder(*retMin, *retMax); // If it weren't for the the allowance for missing data range values, // we could set retAbs* and be done here. if(cartMinStr) cartMin = *retMin; if(cartMaxStr) cartMax = *retMax; // Get trackDb defaults, and resolve missing wiggle data range if necessary. char *defaultViewLimits = trackDbSettingClosestToHomeOrDefault(tdb, DEFAULTVIEWLIMITS, NULL); if (defaultViewLimits == NULL) defaultViewLimits = trackDbSettingClosestToHomeOrDefault(tdb, VIEWLIMITS, NULL); if (defaultViewLimits != NULL) { double viewLimitMin = 0.0, viewLimitMax = 0.0; parseColonRange(defaultViewLimits, &viewLimitMin, &viewLimitMax); *retMin = viewLimitMin; *retMax = viewLimitMax; if (missingAbsMax) absMax = viewLimitMax; if (missingAbsMin) absMin = viewLimitMin; } else if (missingAbsMin || missingAbsMax) { if (isBedGraph) { absMin = DEFAULT_MIN_BED_GRAPH; absMax = DEFAULT_MAX_BED_GRAPH; } else { absMin = DEFAULT_MIN_Yv; absMax = DEFAULT_MAX_Yv; } *retMin = absMin; *retMax = absMax; } else { *retMin = absMin; *retMax = absMax; } if (retAbsMin) *retAbsMin = absMin; if (retAbsMax) *retAbsMax = absMax; // After the dust settles from tdb's trackDb settings, now see if composite view // settings from tdb's parents override that stuff anyway: viewLimitsCompositeOverride(tdb, name, retMin, retMax, retAbsMin, retAbsMax); // And as the final word after composite override, reset retMin and retMax if from cart: if (cartMinStr) *retMin = cartMin; if (cartMaxStr) *retMax = cartMax; } /* void wigFetchMinMaxYWithCart() */
void bamDrawAt(struct track *tg, void *item, struct hvGfx *hvg, int xOff, int y, double scale, MgFont *font, Color color, enum trackVisibility vis) /* Draw a single bam linkedFeatures item. Borrows a lot from linkedFeaturesDrawAt, * but cuts a lot of unneeded features (like coding region) and adds a couple * additional sources of color. */ { struct linkedFeatures *lf = item; struct simpleFeature *sf; int heightPer = tg->heightPer; int x1 = round((double)((int)lf->start-winStart)*scale) + xOff; int x2 = round((double)((int)lf->end-winStart)*scale) + xOff; int w = x2-x1; int midY = y + (heightPer>>1); char *exonArrowsDense = trackDbSettingClosestToHome(tg->tdb, "exonArrowsDense"); boolean exonArrowsEvenWhenDense = (exonArrowsDense != NULL && SETTING_IS_ON(exonArrowsDense)); boolean exonArrows = (tg->exonArrows && (vis != tvDense || exonArrowsEvenWhenDense)); struct dnaSeq *mrnaSeq = NULL; enum baseColorDrawOpt drawOpt = baseColorDrawOff; boolean indelShowDoubleInsert, indelShowQueryInsert, indelShowPolyA; struct psl *psl = (struct psl *)(lf->original); char *colorMode = cartOrTdbString(cart, tg->tdb, BAM_COLOR_MODE, BAM_COLOR_MODE_DEFAULT); char *grayMode = cartOrTdbString(cart, tg->tdb, BAM_GRAY_MODE, BAM_GRAY_MODE_DEFAULT); bool baseQualMode = (sameString(colorMode, BAM_COLOR_MODE_GRAY) && sameString(grayMode, BAM_GRAY_MODE_BASE_QUAL)); char *qSeq = lf->extra; if (vis != tvDense && isNotEmpty(qSeq) && !sameString(qSeq, "*")) { drawOpt = baseColorDrawSetup(hvg, tg, lf, &mrnaSeq, &psl); if (drawOpt > baseColorDrawOff) exonArrows = FALSE; } static Color darkBlueColor = 0; static Color darkRedColor = 0; if (darkRedColor == 0) { darkRedColor = hvGfxFindColorIx(hvg, 100,0,0); darkBlueColor = hvGfxFindColorIx(hvg, 0,0,100); } if (sameString(colorMode, BAM_COLOR_MODE_STRAND)) color = (lf->orientation < 0) ? darkRedColor : darkBlueColor; else if (lf->filterColor != 0) { // In bamTrack, lf->filterColor is an RGBA value color = lf->filterColor; } else if (tg->colorShades) color = tg->colorShades[lf->grayIx]; else color = tg->ixColor; indelEnabled(cart, tg->tdb, basesPerPixel, &indelShowDoubleInsert, &indelShowQueryInsert, &indelShowPolyA); if (!indelShowDoubleInsert) innerLine(hvg, x1, midY, w, color); for (sf = lf->components; sf != NULL; sf = sf->next) { int s = sf->start, e = sf->end; if (e <= s || e < winStart || s > winEnd) continue; if (baseQualMode) color = tg->colorShades[sf->grayIx]; baseColorDrawItem(tg, lf, sf->grayIx, hvg, xOff, y, scale, font, s, e, heightPer, zoomedToCodonLevel, mrnaSeq, sf, psl, drawOpt, MAXPIXELS, winStart, color); if (tg->exonArrowsAlways || (exonArrows && (sf->start <= winStart || sf->start == lf->start) && (sf->end >= winEnd || sf->end == lf->end))) { Color barbColor = hvGfxContrastingColor(hvg, color); x1 = round((double)((int)s-winStart)*scale) + xOff; x2 = round((double)((int)e-winStart)*scale) + xOff; w = x2-x1; clippedBarbs(hvg, x1+1, midY, x2-x1-2, tl.barbHeight, tl.barbSpacing, lf->orientation, barbColor, TRUE); } } if (indelShowDoubleInsert && psl) { int intronGap = 0; if (vis != tvDense) intronGap = atoi(trackDbSettingClosestToHomeOrDefault(tg->tdb, "intronGap", "0")); lfDrawSpecialGaps(lf, intronGap, TRUE, 0, tg, hvg, xOff, y, scale, color, color, vis); } if (vis != tvDense) { /* If highlighting differences between aligned sequence and genome when * zoomed way out, this must be done in a separate pass after exons are * drawn so that exons sharing the pixel don't overdraw differences. */ if ((indelShowQueryInsert || indelShowPolyA) && psl) baseColorOverdrawQInsert(tg, lf, hvg, xOff, y, scale, heightPer, mrnaSeq, psl, winStart, drawOpt, indelShowQueryInsert, indelShowPolyA); baseColorOverdrawDiff(tg, lf, hvg, xOff, y, scale, heightPer, mrnaSeq, psl, winStart, drawOpt); baseColorDrawCleanup(lf, &mrnaSeq, &psl); } }
void bamLoadItemsCore(struct track *tg, boolean isPaired) /* Load BAM data into tg->items item list, unless zoomed out so far * that the data would just end up in dense mode and be super-slow. */ { /* protect against temporary network error */ struct errCatch *errCatch = errCatchNew(); if (errCatchStart(errCatch)) { struct hash *pairHash = isPaired ? hashNew(18) : NULL; int minAliQual = atoi(cartOrTdbString(cart, tg->tdb, BAM_MIN_ALI_QUAL, BAM_MIN_ALI_QUAL_DEFAULT)); char *colorMode = cartOrTdbString(cart, tg->tdb, BAM_COLOR_MODE, BAM_COLOR_MODE_DEFAULT); char *grayMode = cartOrTdbString(cart, tg->tdb, BAM_GRAY_MODE, BAM_GRAY_MODE_DEFAULT); char *userTag = cartOrTdbString(cart, tg->tdb, BAM_COLOR_TAG, BAM_COLOR_TAG_DEFAULT); int aliQualShadeMin = 0, aliQualShadeMax = 99, baseQualShadeMin = 0, baseQualShadeMax = 40; parseIntRangeSetting(tg->tdb, "aliQualRange", &aliQualShadeMin, &aliQualShadeMax); parseIntRangeSetting(tg->tdb, "baseQualRange", &baseQualShadeMin, &baseQualShadeMax); struct bamTrackData btd = {tg, pairHash, minAliQual, colorMode, grayMode, userTag, aliQualShadeMin, aliQualShadeMax, baseQualShadeMin, baseQualShadeMax}; char *fileName = trackDbSetting(tg->tdb, "bigDataUrl"); if (fileName == NULL) { if (tg->customPt) { errAbort("bamLoadItemsCore: can't find bigDataUrl for custom track %s", tg->track); } else { struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb); fileName = bamFileNameFromTable(conn, tg->table, chromName); hFreeConn(&conn); } } char *fileName2 = hReplaceGbdb(fileName); char posForBam[512]; safef(posForBam, sizeof(posForBam), "%s:%d-%d", chromName, winStart, winEnd); char *cacheDir = cfgOption("cramRef"); char *refUrl = trackDbSetting(tg->tdb, "refUrl"); if (!isPaired) bamFetchPlus(fileName2, posForBam, addBam, &btd, NULL, refUrl, cacheDir); else { char *setting = trackDbSettingClosestToHomeOrDefault(tg->tdb, "pairSearchRange", "20000"); int pairSearchRange = atoi(setting); if (pairSearchRange > 0) safef(posForBam, sizeof(posForBam), "%s:%d-%d", chromName, max(0, winStart-pairSearchRange), winEnd+pairSearchRange); bamFetchPlus(fileName2, posForBam, addBamPaired, &btd, NULL, refUrl, cacheDir); struct hashEl *hel; struct hashCookie cookie = hashFirst(btd.pairHash); while ((hel = hashNext(&cookie)) != NULL) { struct linkedFeatures *lf = hel->val; if (lf->start < winEnd && lf->end > winStart) slAddHead(&(tg->items), lfsFromLf(lf)); } } freez(&fileName2); if (tg->visibility != tvDense) { slReverse(&(tg->items)); if (isPaired) slSort(&(tg->items), linkedFeaturesSeriesCmp); else if (sameString(colorMode, BAM_COLOR_MODE_STRAND)) slSort(&(tg->items), linkedFeaturesCmpOri); else if (sameString(colorMode, BAM_COLOR_MODE_GRAY) && sameString(grayMode, BAM_GRAY_MODE_ALI_QUAL)) slSort(&(tg->items), linkedFeaturesCmpScore); else slSort(&(tg->items), linkedFeaturesCmpStart); if (slCount(tg->items) > MAX_ITEMS_FOR_MAPBOX) { // flag drawItems to make a mapBox for the whole track tg->customInt = 1; tg->mapItem = dontMapItem; } } } errCatchEnd(errCatch); if (errCatch->gotError) { tg->networkErrMsg = cloneString(errCatch->message->string); tg->drawItems = bigDrawWarning; tg->totalHeight = bigWarnTotalHeight; } errCatchFree(&errCatch); }
static void pubsLoadKeywordYearItems(struct track *tg) /* load items that fulfill keyword and year filter */ { pubsParseClassColors(); struct sqlConnection *conn = hAllocConn(database); char *keywords = cartOptionalStringClosestToHome(cart, tg->tdb, FALSE, "pubsFilterKeywords"); char *yearFilter = cartOptionalStringClosestToHome(cart, tg->tdb, FALSE, "pubsFilterYear"); char *publFilter = cartOptionalStringClosestToHome(cart, tg->tdb, FALSE, "pubsFilterPublisher"); char *articleTable = pubsArticleTable(tg); if(sameOk(yearFilter, "anytime")) yearFilter = NULL; if(sameOk(publFilter, "all")) publFilter = NULL; if(isNotEmpty(keywords)) keywords = makeMysqlMatchStr(keywords); if (isEmpty(yearFilter) && isEmpty(keywords) && isEmpty(publFilter)) { loadGappedBed(tg); } else { // put together an "extra" query to hExtendedRangeQuery that removes articles // without the keywords specified in hgTrackUi char *oldLabel = tg->longLabel; tg->longLabel = catTwoStrings(oldLabel, " (filter activated)"); freeMem(oldLabel); char **row; struct linkedFeatures *lfList = NULL; struct trackDb *tdb = tg->tdb; int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0")); int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000")); boolean useItemRgb = bedItemRgb(tdb); char *extra = NULL; struct dyString *extraDy = dyStringNew(0); struct hash *articleIds = searchForKeywords(conn, articleTable, keywords); if (!sameWord(tg->table, "pubsBlat")) // new table schema: filter fields are on main bed table { if (isNotEmpty(yearFilter)) sqlDyStringPrintfWithSep(extraDy, " AND ", " year >= '%s'", yearFilter); if (isNotEmpty(publFilter)) sqlDyStringPrintfWithSep(extraDy, " AND ", " publisher = '%s'", publFilter); } else // old table schema, filter by doing a join on article table { if(isNotEmpty(yearFilter)) sqlDyStringPrintfFrag(extraDy, "name IN (SELECT articleId FROM %s WHERE year>='%s')", articleTable, \ yearFilter); } if (extraDy->stringSize > 0) extra = extraDy->string; else extra = NULL; int rowOffset = 0; struct sqlResult *sr = hExtendedRangeQuery(conn, tg->table, chromName, winStart, winEnd, extra, FALSE, NULL, &rowOffset); freeDyString(&extraDy); while ((row = sqlNextRow(sr)) != NULL) { struct bed *bed = bedLoad12(row+rowOffset); if (articleIds==NULL || hashFindVal(articleIds, bed->name)) slAddHead(&lfList, bedMungToLinkedFeatures(&bed, tdb, 12, scoreMin, scoreMax, useItemRgb)); } sqlFreeResult(&sr); slReverse(&lfList); slSort(&lfList, linkedFeaturesCmp); tg->items = lfList; } hFreeConn(&conn); }