def __init__(self, geSource): self._geSource = self._decorateGESource(geSource) self._boundingRegionsAndGEsCorrespond = None self._areValsCategorical = TrackFormat.createInstanceFromGeSource(geSource).getValTypeName() == 'Category' self._areEdgeWeightsCategorical = TrackFormat.createInstanceFromGeSource(geSource).getWeightTypeName() == 'Category' self._valCategories = set() self._edgeWeightCategories = set() self._numElements = OrderedDefaultDict(int) self._maxStrLens = OrderedDefaultDict(partial(self._initMaxStrLens, self._getMaxStrLensKeys())) self._maxNumEdges = OrderedDefaultDict(int) self._hasCalculatedStats = False
def _assertIsCompatibleWith(self, tfReq, reqList): for start in [None, []]: for end in [None, []]: for val in [None, []]: for strand in [None, []]: for id,edges,weights in [(None,None,None), ([],None,None), ([],[],None), ([],[],[])]: for extra in [None, {'a':[],'b':[]}]: if [] in [start, end, val]: tf = TrackFormat(start, end, val, strand, id, edges, weights, extra) propList = [tf.isDense(), tf.isValued(), tf.isInterval(), tf.isLinked(), tf.hasStrand(), tf.hasId(), tf.isWeighted(), tf.hasExtra(), \ tf.getValTypeName() if tf.getValTypeName() != '' else False, \ tf.getWeightTypeName() if tf.getWeightTypeName() != '' else False, \ tf.getExtraNames() if tf.getExtraNames() != [] else False] isCompatible = (not False in [(r==None or r==p) for r,p in zip(reqList, propList)]) self.assertEqual(isCompatible, tfReq.isCompatibleWith(tf))
def loadTrackView(trackData, region, borderHandling, allowOverlaps, trackName=[]): """ trackData : see TrackSource.getTrackData {'id' : smartmemmap} region : see GenomeRegion """ #brShelve = BoundingRegionShelve(region.genome, trackName, allowOverlaps) brShelve = trackData.boundingRegionShelve brInfo = brShelve.getBoundingRegionInfo(region) if brShelve is not None else None extraArrayNames = [arrayName for arrayName in trackData if arrayName not in \ RESERVED_PREFIXES.keys() + ['leftIndex', 'rightIndex']] reservedArrays = [TrackViewLoader._getArray(trackData, arrayName, brInfo) for arrayName in RESERVED_PREFIXES] extraArrays = [TrackViewLoader._getArray(trackData, arrayName, brInfo) for arrayName in extraArrayNames] trackFormat = TrackFormat( *(reservedArrays + [OrderedDict(zip(extraArrayNames, extraArrays))]) ) if trackFormat.reprIsDense(): if brInfo is None: leftIndex = region.start rightIndex = region.end else: leftIndex = region.start - brInfo.start rightIndex = region.end - brInfo.start else: leftBin = CompBinManager.getBinNumber(region.start) rightBin = CompBinManager.getBinNumber(region.end-1) #leftBin = region.start/COMP_BIN_SIZE #rightBin = (region.end-1)/COMP_BIN_SIZE if trackData.get('leftIndex') is None or trackData.get('rightIndex') is None: raise IOError('Preprocessed track not found. TrackData: ' + ', '.join(trackData.keys())) leftIndex = TrackViewLoader._getArray(trackData, 'leftIndex', brInfo, leftBin) rightIndex = TrackViewLoader._getArray(trackData, 'rightIndex', brInfo, rightBin) slicedReservedArrays = [(array[leftIndex:rightIndex] if array is not None else None) for array in reservedArrays] slicedExtraArrays = [(array[leftIndex:rightIndex] if array is not None else None) for array in extraArrays] argList = [region] + slicedReservedArrays + [borderHandling, allowOverlaps] + [OrderedDict(zip(extraArrayNames, slicedExtraArrays))] tv = TrackView( *(argList) ) if not trackFormat.reprIsDense(): tv.sliceElementsAccordingToGenomeAnchor() #tv._doScatteredSlicing() return tv
def testExtra(self): tf = TrackFormat.createInstanceFromPrefixList(['start', 'a', 'b', 'c'], 'float64', 1, 'float64', 1) self.assertTrue(tf.hasExtra(specificExtra='a')) self.assertFalse(tf.hasExtra(specificExtra='d')) self.assertEqual(['a','b','c'], tf.getExtraNames()) tfq = TrackFormatReq(interval=False, extra=['a','b']) self.assertFalse(tfq.isCompatibleWith(tf))
def testWeightTypes(self): tf = TrackFormat.createInstanceFromPrefixList(['id', 'edges', 'weights'], 'float64', 1, 'S8', 3) self.assertTrue(tf.isWeighted(specificWeightType='category_vector')) self.assertFalse(tf.isWeighted(specificWeightType='number')) self.assertEqual('Vector of categories', tf.getWeightTypeName()) self.assertEqual('Linked base pairs', tf.getFormatName()) tfq = TrackFormatReq(linked=True, weights='number') self.assertFalse(tfq.isCompatibleWith(tf))
def testValTypes(self): tf = TrackFormat.createInstanceFromPrefixList(['start', 'val'], 'float128', 2, 'float64', 1) self.assertTrue(tf.isValued(specificValType='mean_sd')) self.assertFalse(tf.isValued(specificValType='number')) self.assertEqual('Mean and std.dev.', tf.getValTypeName()) self.assertEqual('Valued points', tf.getFormatName()) tfq = TrackFormatReq(interval=False, val='tc') self.assertFalse(tfq.isCompatibleWith(tf))
def testCompatibilityWithExceptions(self): tf = TrackFormat.createInstanceFromPrefixList(['start', 'val'], 'float64', 1, 'float64', 1) self.assertFalse(TrackFormatReq(interval=True, strand=True, val='number')\ .isCompatibleWith(tf)) self.assertFalse(TrackFormatReq(interval=True, strand=True, val='number')\ .isCompatibleWith(tf, ['interval'])) self.assertTrue(TrackFormatReq(interval=True, strand=True, val='number')\ .isCompatibleWith(tf, ['interval', 'hasStrand'])) self.assertFalse(TrackFormatReq(interval=True, strand=True, val='tc')\ .isCompatibleWith(tf, ['interval', 'hasStrand']))
def _getGESourceManagerFromGESource(self, geSource): tf = TrackFormat.createInstanceFromGeSource(geSource) if tf.reprIsDense(): if tf.getValTypeName() in ['Number', 'Number (integer)', 'Case-control']: return RegionBasedGESourceManager(geSource, self._regionList, \ calcStatsInExtraPass=False, countElsInBoundingRegions=False) else: raise NotSupportedError else: return RegionBasedGESourceManager(geSource, self._regionList, \ calcStatsInExtraPass=True, countElsInBoundingRegions=True)
def __iter__(self): self = copy(self) #does not support function, partitions and points: if (False in [attrs in self._geSource.getPrefixList() for attrs in ['start', 'end']]): raise NotSupportedError('Binning file must be segments. Current file format: ' + \ TrackFormat.createInstanceFromPrefixList(self._geSource.getPrefixList(), \ self._geSource.getValDataType(), \ self._geSource.getValDim(), \ self._geSource.getEdgeWeightDataType(), \ self._geSource.getEdgeWeightDim()).getFormatName() ) self._geIter = self._geSource.__iter__() return self
def _composeContents(self, out, hbColumns, columns, geSource, onlyNonDefault=True, singleDataLine=False): tf = TrackFormat.createInstanceFromGeSource(self._geSource) out.write(self._composeHeaderLines(onlyNonDefault)) out.write(self._composeColSpecLine(columns)) for br, geList in iterateOverBRTuplesWithContainedGEs(geSource, onlyYieldTwoGEs=singleDataLine): if br is not None: out.write(self._composeBoundingRegionLine(br)) for i, ge in enumerate(self._removeStartElementIfApplicable(tf, geList)): out.write(self._composeDataLine(ge, hbColumns, i + 1, i + 1 == len(geList))) if singleDataLine: break if singleDataLine: break
def __init__(self, genomeAnchor, startList, endList, valList, strandList, idList, edgesList, \ weightsList, borderHandling, allowOverlaps, extraLists=OrderedDict()): assert startList!=None or endList!=None or valList!=None or edgesList!=None assert borderHandling in ['crop'] self.genomeAnchor = copy(genomeAnchor) self.trackFormat = TrackFormat(startList, endList, valList, strandList, idList, edgesList, weightsList, extraLists) self.borderHandling = borderHandling self.allowOverlaps = allowOverlaps self._trackElement = TrackElement(self) #self._bpLevelArray = None self._startList = startList self._endList = endList self._valList = valList self._strandList = strandList self._idList = idList self._edgesList = edgesList self._weightsList = weightsList self._extraLists = copy(extraLists) self._handlePointsAndPartitions() if self._startList is None: self._trackElement.start = noneFunc if self._endList is None: self._trackElement.end = noneFunc if self._valList is None: self._trackElement.val = noneFunc if self._strandList is None: self._trackElement.strand = noneFunc if self._idList is None: self._trackElement.id = noneFunc if self._edgesList is None: self._trackElement.edges = noneFunc if self._weightsList is None: self._trackElement.weights = noneFunc self._updateNumListElements() for i, list in enumerate([self._startList, self._endList, self._valList, self._strandList, self._idList, self._edgesList, self._weightsList] \ + [extraList for extraList in self._extraLists.values()]): assert list is None or len(list) == self._numListElements, 'List (%s): ' % i + str(list) + ' (expected %s elements, found %s)' % (self._numListElements, len(list))
def _allGESourceManagers(self, trackName, allowOverlaps): collector = PreProcMetaDataCollector(self._genome, trackName) if allowOverlaps == False and collector.overlapRuleHasBeenFinalized(True): for i in range(1): self._status = 'Trying to prepare preprocessing for track "%s"' % ':'.join(trackName) + \ (' (allowOverlaps: %s)' % allowOverlaps) yield self._getGESourceManagerFromTrack(trackName) else: for geSource in self._allGESources(trackName): if allowOverlaps == True: tf = TrackFormat.createInstanceFromGeSource(geSource) if tf.isDense() or geSource.hasNoOverlappingElements(): return self._status = 'Trying to prepare preprocessing for track "%s"' % ':'.join(trackName) + \ (' (filename: "%s")' % geSource.getFileName() if geSource.hasOrigFile() else '') + \ (' (allowOverlaps: %s)' % allowOverlaps) if PreProcessUtils.shouldPreProcessGESource(trackName, geSource, allowOverlaps): yield self._getGESourceManagerFromGESource(geSource)
def testSorting(self): geSourceTest = self._commonSetup() for caseName in geSourceTest.cases: if not caseName.startswith('gtrack'): continue if 'no_sort' in caseName: print 'Test case skipped: ' + caseName continue print caseName print case = geSourceTest.cases[caseName] testFn = self._writeTestFile(case) print open(testFn).read() print sortedContents = sortGtrackFileAndReturnContents(testFn, case.genome) print sortedContents sourceClass = GenomeElementSource if case.sourceClass is None else case.sourceClass forPreProcessor = True if case.sourceClass is None else False sortedGeSource = GEDependentAttributesHolder(sourceClass('sortedFile.gtrack', case.genome, \ forPreProcessor=forPreProcessor, \ printWarnings=False, \ strToUseInsteadOfFn=sortedContents)) reprIsDense = TrackFormat.createInstanceFromGeSource(sortedGeSource).reprIsDense() if not reprIsDense: self.assertEquals(sorted(case.assertElementList), [ge for ge in sortedGeSource]) else: for ge in sortedGeSource: pass self.assertEquals(sorted(case.boundingRegionsAssertList), [br for br in sortedGeSource.getBoundingRegionTuples()])
def _compose(self, out): trackName = self._geSource.getTrackName() if trackName is not None: name = ':'.join(self._geSource.getTrackName()).replace(' ','_') else: name = None print >>out, 'track type=wiggle_0' + (' name=%s' % name if name is not None else '') tf = TrackFormat.createInstanceFromGeSource(self._geSource) span = self._geSource.getFixedLength() step = self._geSource.getFixedGapSize() + span isFixedStep = (tf.reprIsDense() or step > 1 or (step == 1 and span != 1)) for brt, geList in iterateOverBRTuplesWithContainedGEs(self._geSource): if len(geList) == 0: continue if isFixedStep: self._composeFixedStepDeclarationLine(out, brt.region, step, span) else: curChr, curSpan = self._composeVariableStepDeclarationLine(out, geList[0]) for i,ge in enumerate(geList): if i==0 and tf.isDense() and tf.isInterval() and \ self._geSource.addsStartElementToDenseIntervals(): continue val = self._commonFormatNumberVal(ge.val) if isFixedStep: cols = [val] else: if ge.chr != curChr or self._getVariableSpan(ge) != curSpan: curChr, curSpan = self._composeVariableStepDeclarationLine(out, ge) cols = [str(ge.start+1), val] print >>out, '\t'.join([str(x) for x in cols])
class TrackView(object): def _handlePointsAndPartitions(self): if self.trackFormat.isDense() and not self.trackFormat.reprIsDense(): self._startList = self._endList[:-1] self._endList = self._endList[1:] if self._valList != None: self._valList = self._valList[1:] if self._strandList != None: self._strandList = self._strandList[1:] if self._idList != None: self._idList = self._idList[1:] if self._edgesList != None: self._edgesList = self._edgesList[1:] if self._weightsList != None: self._weightsList = self._weightsList[1:] for key, extraList in self._extraLists.items(): if extraList != None: self._extraLists[key] = extraList[1:] if not self.trackFormat.isDense() and not self.trackFormat.isInterval(): self._endList = VirtualPointEnd(self._startList) def __init__(self, genomeAnchor, startList, endList, valList, strandList, idList, edgesList, \ weightsList, borderHandling, allowOverlaps, extraLists=OrderedDict()): assert startList!=None or endList!=None or valList!=None or edgesList!=None assert borderHandling in ['crop'] self.genomeAnchor = copy(genomeAnchor) self.trackFormat = TrackFormat(startList, endList, valList, strandList, idList, edgesList, weightsList, extraLists) self.borderHandling = borderHandling self.allowOverlaps = allowOverlaps self._trackElement = TrackElement(self) #self._bpLevelArray = None self._startList = startList self._endList = endList self._valList = valList self._strandList = strandList self._idList = idList self._edgesList = edgesList self._weightsList = weightsList self._extraLists = copy(extraLists) self._handlePointsAndPartitions() if self._startList is None: self._trackElement.start = noneFunc if self._endList is None: self._trackElement.end = noneFunc if self._valList is None: self._trackElement.val = noneFunc if self._strandList is None: self._trackElement.strand = noneFunc if self._idList is None: self._trackElement.id = noneFunc if self._edgesList is None: self._trackElement.edges = noneFunc if self._weightsList is None: self._trackElement.weights = noneFunc self._updateNumListElements() for i, list in enumerate([self._startList, self._endList, self._valList, self._strandList, self._idList, self._edgesList, self._weightsList] \ + [extraList for extraList in self._extraLists.values()]): assert list is None or len(list) == self._numListElements, 'List (%s): ' % i + str(list) + ' (expected %s elements, found %s)' % (self._numListElements, len(list)) def __iter__(self): self._trackElement._index = -1 return self def _updateNumListElements(self): if test_settings['count_elements_using_iterator']: # Note: Should only be used with allowOverlaps=False self._numIterElements = sum(1 for _ in self) self._numListElements = self._numIterElements return self._numListElements = self._computeNumListElements() if self.allowOverlaps and self._numListElements > 0: self._numIterElements = self._computeNumIterElements() else: self._numIterElements = self._numListElements def _computeNumListElements(self): for list in [self._startList, self._endList, self._valList, self._edgesList]: if list is not None: return len(list) raise ShouldNotOccurError def _computeNumIterElements(self): for list in [self._startList, self._endList, self._valList, self._edgesList]: if list is not None: if isinstance(list, numpy.ndarray): return len(self._removeBlindPassengersFromNumpyArray(list)) else: return sum(1 for x in self) raise ShouldNotOccurError def __len__(self): "" return self._bpSize() def getNumElements(self): return self._numIterElements def _bpSize(self): return len(self.genomeAnchor) def next(self): self._trackElement._index += 1 #To remove any blind passengers - segments entirely in front of genomeanchor, # but sorted after a larger segment crossing the border if self.allowOverlaps and not self.trackFormat.reprIsDense(): while self._trackElement._index < self._numListElements and self._endList[self._trackElement._index] <= self.genomeAnchor.start: #self._trackElement.end() <= 0: self._trackElement._index += 1 if self._trackElement._index < self._numListElements: return self._trackElement else: raise StopIteration def _findLeftIndex(self): leftIndex = 0 #remove track elements entirely to the left of the anchor while leftIndex < len(self._endList) and self._endList[leftIndex] <= self.genomeAnchor.start: leftIndex += 1 return leftIndex def _findRightIndex(self): rightIndex = self._numListElements while rightIndex > 0 and self._startList[rightIndex-1] >= self.genomeAnchor.end: rightIndex -= 1 return rightIndex def sliceElementsAccordingToGenomeAnchor(self): assert( not self.trackFormat.reprIsDense() ) self._doScatteredSlicing() def _doScatteredSlicing(self): leftIndex = self._findLeftIndex() rightIndex = self._findRightIndex() if self._bpSize() == 0: rightIndex = leftIndex self._startList = self._startList[leftIndex:rightIndex] self._endList = self._endList[leftIndex:rightIndex] if self._valList != None: self._valList = self._valList[leftIndex:rightIndex] if self._strandList != None: self._strandList = self._strandList[leftIndex:rightIndex] if self._idList != None: self._idList = self._idList[leftIndex:rightIndex] if self._edgesList != None: self._edgesList = self._edgesList[leftIndex:rightIndex] if self._weightsList != None: self._weightsList = self._weightsList[leftIndex:rightIndex] for key, extraList in self._extraLists.items(): self._extraLists[key] = extraList[leftIndex:rightIndex] self._updateNumListElements() def _doDenseSlicing(self, i, j): if self._valList != None: self._valList = self._valList[i:j] if self._strandList != None: self._strandList = self._strandList[i:j] if self._idList != None: self._idList = self._idList[i:j] if self._edgesList != None: self._edgesList = self._edgesList[i:j] if self._weightsList != None: self._weightsList = self._weightsList[i:j] for key, extraList in self._extraLists.items(): self._extraLists[key] = extraList[i:j] self._updateNumListElements() def __getslice__(self, i, j): slicedTV = TrackView(self.genomeAnchor, self._startList, self._endList, \ self._valList, self._strandList, self._idList, \ self._edgesList, self._weightsList, \ self.borderHandling, self.allowOverlaps, \ extraLists=self._extraLists) slicedTV.trackFormat = self.trackFormat slicedTV.genomeAnchor.start += i if j>=0: try: slicedTV.genomeAnchor.end = min(self.genomeAnchor.end, self.genomeAnchor.start + j) except FloatingPointError: # Caused by trackView[:] with self.genomeAnchor.start > 0 slicedTV.genomeAnchor.end = self.genomeAnchor.end if j<0: slicedTV.genomeAnchor.end += j if self.trackFormat.reprIsDense(): slicedTV._doDenseSlicing(i,j) else: slicedTV._doScatteredSlicing() return slicedTV def _getBpLevelModificationArray(self, indexes, vals): bpLevelMod = numpy.bincount(indexes, vals) origLen = len(bpLevelMod) bpLevelMod.resize(self._bpSize()+1) bpLevelMod[origLen:] = 0 return bpLevelMod def _commonGetBpLevelArray(self, vals): if self.trackFormat.reprIsDense(): if self.allowOverlaps: raise ShouldNotOccurError() return vals else: bpLevelArray = numpy.zeros(self._bpSize()+1) numElements = self.getNumElements() if numElements > 0: bpLevelArray += self._getBpLevelModificationArray(self.startsAsNumpyArray(), vals) bpLevelArray -= self._getBpLevelModificationArray(self.endsAsNumpyArray(), vals) bpLevelArray = bpLevelArray.cumsum() return bpLevelArray[:-1] def getBinaryBpLevelArray(self): vals = numpy.ones(self.getNumElements(), dtype='int32') return numpy.array(self._commonGetBpLevelArray(vals), dtype='bool8') def getCoverageBpLevelArray(self): vals = numpy.ones(self.getNumElements(), dtype='int32') return numpy.array(self._commonGetBpLevelArray(vals), dtype='int32') def getValueBpLevelArray(self, voidValue=0): ''' Creates a bp-level function of any valued track. In case of scattered tracks, uncovered aras are filled with voidValue (which would typically be set to 0 or numpy.nan). In the case of overlapping regions, the values are added.''' assert self.trackFormat.isValued('number'), self.trackFormat vals = self.valsAsNumpyArray() bpLevelArray = numpy.array(self._commonGetBpLevelArray(vals), dtype=vals.dtype) if voidValue != 0: bpLevelArray[~self.getBinaryBpLevelArray()] = voidValue return bpLevelArray def _removeBlindPassengersFromNumpyArray(self, numpyArray): ''' To remove any blind passengers - segments entirely in front of genomeanchor, but sorted after a larger segment crossing the border. ''' if self.allowOverlaps and len(numpyArray) > 0: numpyArray = numpyArray[numpy.where(self._endList > self.genomeAnchor.start)] return numpyArray def _commonAsNumpyArray(self, numpyArray, numpyArrayModMethod, name): assert(self.borderHandling in ['crop']) if numpyArray is None: return None numpyArray = self._removeBlindPassengersFromNumpyArray(numpyArray) if numpyArrayModMethod is not None: return numpyArrayModMethod(numpyArray) else: return numpyArray def startsAsNumpyArray(self): return self._commonAsNumpyArray(self._startList, self._startListModMethod, 'starts') def _startListModMethod(self, startList): return numpy.maximum(startList - self.genomeAnchor.start, \ numpy.zeros(len(startList), dtype='int32')) def endsAsNumpyArray(self): return self._commonAsNumpyArray(self._endList, self._endListModMethod, 'ends') def _endListModMethod(self, endList): return numpy.minimum(endList - self.genomeAnchor.start, \ numpy.zeros(len(endList), dtype='int32') + len(self.genomeAnchor)) def valsAsNumpyArray(self): return self._commonAsNumpyArray(self._valList, None, 'vals') def strandsAsNumpyArray(self): return self._commonAsNumpyArray(self._strandList, None, 'strands') def idsAsNumpyArray(self): return self._commonAsNumpyArray(self._idList, None, 'ids') def edgesAsNumpyArray(self): return self._commonAsNumpyArray(self._edgesList, None, 'edges') def weightsAsNumpyArray(self): return self._commonAsNumpyArray(self._weightsList, None, 'weights') def extrasAsNumpyArray(self, key): assert self.hasExtra(key) from functools import partial return self._commonAsNumpyArray(self._extraLists[key], None, 'extras') def allExtrasAsDictOfNumpyArrays(self): return OrderedDict([(key,self.extrasAsNumpyArray(key)) for key in self._extraLists]) def hasExtra(self, key): return key in self._extraLists
def getTrackFormat(self): return TrackFormat.createInstanceFromPrefixList(self._prefixList, \ self._valDataType, \ self._valDim, \ self._weightDataType, \ self._weightDim)
def _getRawTrackView(self, region, borderHandling, allowOverlaps): assert len(region) == 1 from collections import OrderedDict from gtrackcore_memmap.track.memmap.CommonMemmapFunctions import findEmptyVal from gtrackcore_memmap.track.core.TrackView import TrackView import numpy as np geSource = ExternalTrackManager.getGESourceFromGalaxyOrVirtualTN(self.trackName, region.genome) prefixList = geSource.getPrefixList() valDataType = geSource.getValDataType() valDim = geSource.getValDim() weightDataType = geSource.getEdgeWeightDataType() weightDim = geSource.getEdgeWeightDim() startList, endList, valList, strandList, idList, edgesList, weightsList = [None] * 7 extraLists = OrderedDict() tf = TrackFormat.createInstanceFromPrefixList(prefixList, valDataType, valDim, weightDataType, weightDim) if allowOverlaps and (tf.isDense() or geSource.hasNoOverlappingElements()): raise IncompatibleTracksError( prettyPrintTrackName(self.trackName) + " with format: " + str(tf) + " does not satisfy " + str(self._trackFormatReq) ) denseAndInterval = tf.isDense() and tf.isInterval() numEls = 2 if denseAndInterval else 1 if valDataType == "S": valDataType = "S2" if weightDataType == "S": weightDataType = "S2" for prefix in prefixList: if prefix == "start": startList = np.array([-1], dtype="int32") elif prefix == "end": if denseAndInterval: endList = np.array([0, 1], dtype="int32") else: endList = np.array([0], dtype="int32") elif prefix == "val": valList = np.array([findEmptyVal(valDataType)] * valDim * numEls, dtype=valDataType).reshape( (numEls, valDim) if valDim > 1 else numEls ) elif prefix == "strand": strandList = np.array([1] * numEls, dtype="int8") elif prefix == "id": idList = np.array([""] * numEls, dtype="S1") elif prefix == "edges": edgesList = np.array([[""]] * numEls, dtype="S1") elif prefix == "weights": weightsList = np.array( [[[findEmptyVal(weightDataType)]]] * weightDim * numEls, dtype=weightDataType ).reshape((numEls, 1, weightDim) if weightDim > 1 else (numEls, 1)) else: extraLists[prefix] = np.array([""] * numEls, dtype="S1") return TrackView( region, startList, endList, valList, strandList, idList, edgesList, weightsList, borderHandling, allowOverlaps, extraLists, )
def _init(self): self._allValsAreBedVals = False tf = TrackFormat.createInstanceFromGeSource(self._geSource) if tf.getValTypeName() == 'Number (integer)': self._allValsAreBedVals = all((0 <= ge.val <= 1000) for ge in self._geSource)