def test2X3X4(self):
self.assertEqual(
((0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (0, 1, 0), (0, 1, 1),
(0, 1, 2), (0, 1, 3), (0, 2, 0), (0, 2, 1), (0, 2, 2), (0, 2, 3),
(1, 0, 0), (1, 0, 1), (1, 0, 2), (1, 0, 3), (1, 1, 0), (1, 1, 1),
(1, 1, 2), (1, 1, 3), (1, 2, 0), (1, 2, 1), (1, 2, 2), (1, 2, 3)),
tuple(dimensionalIterator((2, 3, 4))))
def testStarX3LimitedTo10Items(self):
self.assertEqual(
((0, 0), (0, 1), (0, 2),
(1, 0), (1, 1), (1, 2),
(2, 0), (2, 1), (2, 2),
(3, 0)),
tuple(dimensionalIterator(('*', 3), maxItems=10)))
def test2X2LimitedTo4Items(self):
"""
If the passed maximum number of items is the same as the number
of items we'd expect to get with no limit, we should get all
items.
"""
self.assertEqual(((0, 0), (0, 1), (1, 0), (1, 1)),
tuple(dimensionalIterator((2, 2), maxItems=4)))
def testNegativeDimension(self):
"""
Passing a negative dimension must result in a ValueError with the
expected error string.
"""
error = r'^Dimensions not all positive! \(2, -1, 3\)$'
assertRaisesRegex(self, ValueError, error, next,
dimensionalIterator((2, -1, 3)))
def test2X3X4(self):
self.assertEqual(
((0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3),
(0, 1, 0), (0, 1, 1), (0, 1, 2), (0, 1, 3),
(0, 2, 0), (0, 2, 1), (0, 2, 2), (0, 2, 3),
(1, 0, 0), (1, 0, 1), (1, 0, 2), (1, 0, 3),
(1, 1, 0), (1, 1, 1), (1, 1, 2), (1, 1, 3),
(1, 2, 0), (1, 2, 1), (1, 2, 2), (1, 2, 3)),
tuple(dimensionalIterator((2, 3, 4))))
def test2X2LimitedTo4Items(self):
"""
If the passed maximum number of items is the same as the number
of items we'd expect to get with no limit, we should get all
items.
"""
self.assertEqual(
((0, 0), (0, 1),
(1, 0), (1, 1)),
tuple(dimensionalIterator((2, 2), maxItems=4)))
def test3X2XStarX4(self):
"""
If '*' is used in a dimension that's not the first, iteration
should get 'stuck' there. I.e., the earlier dimensions will always
return zero as the '*' dimension is never exhauted.
"""
self.assertEqual(
((0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3),
(0, 0, 1, 0), (0, 0, 1, 1), (0, 0, 1, 2), (0, 0, 1, 3),
(0, 0, 2, 0), (0, 0, 2, 1), (0, 0, 2, 2), (0, 0, 2, 3),
(0, 0, 3, 0), (0, 0, 3, 1), (0, 0, 3, 2), (0, 0, 3, 3),
(0, 0, 4, 0), (0, 0, 4, 1), (0, 0, 4, 2), (0, 0, 4, 3)),
tuple(dimensionalIterator((3, 2, '*', 4), maxItems=20)))
def pathogenPanel(self, filename):
"""
Make a panel of images, with each image being a graph giving pathogen
de-duplicated (by id) read count (Y axis) versus sample id (X axis).
@param filename: A C{str} file name to write the image to.
"""
import matplotlib
matplotlib.use('PDF')
import matplotlib.pyplot as plt
self._computeUniqueReadCounts()
pathogenNames = sorted(self.pathogenNames)
sampleNames = sorted(self.sampleNames)
cols = 5
rows = int(len(pathogenNames) / cols) + (
0 if len(pathogenNames) % cols == 0 else 1)
figure, ax = plt.subplots(rows, cols, squeeze=False)
coords = dimensionalIterator((rows, cols))
for i, pathogenName in enumerate(pathogenNames):
row, col = next(coords)
self._pathogenSamplePlot(pathogenName, sampleNames, ax[row][col])
# Hide the final panel graphs (if any) that have no content. We do
# this because the panel is a rectangular grid and some of the
# plots at the end of the last row may be unused.
for row, col in coords:
ax[row][col].axis('off')
figure.suptitle(
('Per-sample read count for %d pathogen%s and %d sample%s.\n\n'
'Sample name%s: %s') % (
len(pathogenNames),
'' if len(pathogenNames) == 1 else 's',
len(sampleNames),
'' if len(sampleNames) == 1 else 's',
'' if len(sampleNames) == 1 else 's',
fill(', '.join(sampleNames), 50)),
fontsize=20)
figure.set_size_inches(5.0 * cols, 2.0 * rows, forward=True)
plt.subplots_adjust(hspace=0.4)
figure.savefig(filename)
def pathogenPanel(self, filename):
"""
Make a panel of images, with each image being a graph giving pathogen
de-duplicated (by id) read count (Y axis) versus sample id (X axis).
@param filename: A C{str} file name to write the image to.
"""
self._computeUniqueReadCounts()
pathogenNames = sorted(self.pathogenNames)
sampleNames = sorted(self.sampleNames)
cols = 5
rows = int(len(pathogenNames) / cols) + (
0 if len(pathogenNames) % cols == 0 else 1)
figure, ax = plt.subplots(rows, cols, squeeze=False)
coords = dimensionalIterator((rows, cols))
for i, pathogenName in enumerate(pathogenNames):
row, col = next(coords)
self._pathogenSamplePlot(pathogenName, sampleNames, ax[row][col])
# Hide the final panel graphs (if any) that have no content. We do
# this because the panel is a rectangular grid and some of the
# plots at the end of the last row may be unused.
for row, col in coords:
ax[row][col].axis('off')
figure.suptitle(
('Per-sample read count for %d pathogen%s and %d sample%s.\n\n'
'Sample name%s: %s') % (
len(pathogenNames),
'' if len(pathogenNames) == 1 else 's',
len(sampleNames),
'' if len(sampleNames) == 1 else 's',
'' if len(sampleNames) == 1 else 's',
fill(', '.join(sampleNames), 50)),
fontsize=20)
figure.set_size_inches(5.0 * cols, 2.0 * rows, forward=True)
plt.subplots_adjust(hspace=0.4)
figure.savefig(filename)
def test1X1X1(self):
self.assertEqual(
((0, 0, 0),),
tuple(dimensionalIterator((1, 1, 1))))
def testLimitedTo0Items(self):
self.assertEqual(
(),
tuple(dimensionalIterator((2, 2), maxItems=0)))
def alignmentPanel(titlesAlignments,
sortOn='maxScore',
interactive=True,
outputDir=None,
idList=False,
equalizeXAxes=False,
xRange='subject',
logLinearXAxis=False,
logBase=DEFAULT_LOG_LINEAR_X_AXIS_BASE,
rankScores=False,
showFeatures=True):
"""
Produces a rectangular panel of graphs that each contain an alignment graph
against a given sequence.
@param titlesAlignments: A L{dark.titles.TitlesAlignments} instance.
@param sortOn: The attribute to sort subplots on. Either "maxScore",
"medianScore", "readCount", "length", or "title".
@param interactive: If C{True}, we are interactive and should display the
panel using figure.show etc.
@param outputDir: If not None, specifies a directory to write an HTML
summary to. If the directory does not exist it will be created.
@param idList: a dictionary. Keys are colors and values are lists of read
ids that should be colored using that color.
@param equalizeXAxes: if C{True}, adjust the X axis on each alignment plot
to be the same.
@param xRange: set to either 'subject' or 'reads' to indicate the range of
the X axis.
@param logLinearXAxis: if C{True}, convert read offsets so that empty
regions in the plots we're preparing will only be as wide as their
logged actual values.
@param logBase: The base of the logarithm to use if logLinearXAxis is
C{True}.
@param: rankScores: If C{True}, change the scores for the reads for each
title to be their rank (worst to best).
@param showFeatures: if C{True}, look online for features of the subject
sequences.
"""
assert xRange in ('subject',
'reads'), ('xRange must be either "subject" or "reads".')
if not (interactive or outputDir):
raise ValueError('Either interactive or outputDir must be True')
start = time()
titles = titlesAlignments.sortTitles(sortOn)
cols = 5
rows = int(len(titles) / cols) + (0 if len(titles) % cols == 0 else 1)
figure, ax = plt.subplots(rows, cols, squeeze=False)
if interactive:
report('Plotting %d titles in %dx%d grid, sorted on %s' %
(len(titles), rows, cols, sortOn))
allGraphInfo = {}
if outputDir:
if os.access(outputDir, os.F_OK):
# outputDir exists. Check it's a directory.
mode = os.stat(outputDir).st_mode
assert S_ISDIR(mode), "%r is not a directory." % outputDir
else:
os.mkdir(outputDir)
htmlOutput = AlignmentPanelHTML(outputDir, titlesAlignments)
coords = dimensionalIterator((rows, cols))
for i, title in enumerate(titles):
titleAlignments = titlesAlignments[title]
row, col = next(coords)
if interactive:
print('%d: %s %s' % (i, title, NCBISequenceLinkURL(title, '')))
# If we are writing data to a file too, create a separate file with
# a plot (this will be linked from the summary HTML).
if outputDir:
imageBasename = '%d.png' % i
imageFile = '%s/%s' % (outputDir, imageBasename)
graphInfo = alignmentGraph(titlesAlignments,
title,
addQueryLines=True,
showFeatures=showFeatures,
rankScores=rankScores,
logLinearXAxis=logLinearXAxis,
logBase=logBase,
colorQueryBases=False,
showFigure=False,
imageFile=imageFile,
quiet=True,
idList=idList,
xRange=xRange,
showOrfs=True)
# Close the image plot, otherwise it will be displayed if we
# call plt.show below.
plt.close()
htmlOutput.addImage(imageBasename, title, graphInfo)
# Add a small plot to the alignment panel.
graphInfo = alignmentGraph(titlesAlignments,
title,
addQueryLines=True,
showFeatures=showFeatures,
rankScores=rankScores,
logLinearXAxis=logLinearXAxis,
logBase=logBase,
colorQueryBases=False,
createFigure=False,
showFigure=False,
readsAx=ax[row][col],
quiet=True,
idList=idList,
xRange=xRange,
showOrfs=False)
allGraphInfo[title] = graphInfo
readCount = titleAlignments.readCount()
hspCount = titleAlignments.hspCount()
plotTitle = ('%d: %s\nLength %d, %d read%s, %d HSP%s.' %
(i, title.split(' ', 1)[1][:40],
titleAlignments.subjectLength, readCount, '' if readCount
== 1 else 's', hspCount, '' if hspCount == 1 else 's'))
if hspCount:
if rankScores:
plotTitle += '\nY axis is ranked score'
else:
plotTitle += '\nmax %.2f, median %.2f' % (
titleAlignments.bestHsp().score.score,
titleAlignments.medianScore())
ax[row][col].set_title(plotTitle, fontsize=10)
maxX = max(graphInfo['maxX'] for graphInfo in allGraphInfo.values())
minX = min(graphInfo['minX'] for graphInfo in allGraphInfo.values())
maxY = max(graphInfo['maxY'] for graphInfo in allGraphInfo.values())
minY = min(graphInfo['minY'] for graphInfo in allGraphInfo.values())
# Post-process graphs to adjust axes, etc.
coords = dimensionalIterator((rows, cols))
for title in titles:
titleAlignments = titlesAlignments[title]
row, col = next(coords)
a = ax[row][col]
a.set_ylim([0, int(maxY * Y_AXIS_UPPER_PADDING)])
if equalizeXAxes:
a.set_xlim([minX, maxX])
a.set_yticks([])
a.set_xticks([])
if xRange == 'subject' and minX < 0:
# Add a vertical line at x=0 so we can see the 'whiskers' of
# reads that extend to the left of the sequence we're aligning
# against.
a.axvline(x=0, color='#cccccc')
# Add a line on the right of each sub-plot so we can see where the
# sequence ends (as all panel graphs have the same width and we
# otherwise couldn't tell).
sequenceLen = titleAlignments.subjectLength
if logLinearXAxis:
sequenceLen = allGraphInfo[title]['adjustOffset'](sequenceLen)
a.axvline(x=sequenceLen, color='#cccccc')
# Hide the final panel graphs (if any) that have no content. We do this
# because the panel is a rectangular grid and some of the plots at the
# end of the last row may be unused.
for row, col in coords:
ax[row][col].axis('off')
# plt.subplots_adjust(left=0.01, bottom=0.01, right=0.99, top=0.93,
# wspace=0.1, hspace=None)
plt.subplots_adjust(hspace=0.4)
figure.suptitle(
'X: %d to %d, Y (%s): %d to %d' %
(minX, maxX, titlesAlignments.readsAlignments.params.scoreTitle,
int(minY), int(maxY)),
fontsize=20)
figure.set_size_inches(5 * cols, 3 * rows, forward=True)
if outputDir:
panelFilename = 'alignment-panel.png'
figure.savefig('%s/%s' % (outputDir, panelFilename))
htmlOutput.close(panelFilename)
if interactive:
figure.show()
stop = time()
if interactive:
report('Alignment panel generated in %.3f mins.' %
((stop - start) / 60.0))
def testNoDimensions(self):
self.assertEqual(
(),
tuple(dimensionalIterator(())))
def alignmentPanel(titlesAlignments, sortOn='maxScore', idList=False,
equalizeXAxes=False, xRange='subject', logLinearXAxis=False,
rankScores=False, showFeatures=True,
logBase=DEFAULT_LOG_LINEAR_X_AXIS_BASE):
"""
Produces a rectangular panel of graphs that each contain an alignment graph
against a given sequence.
@param titlesAlignments: A L{dark.titles.TitlesAlignments} instance.
@param sortOn: The attribute to sort subplots on. Either "maxScore",
"medianScore", "readCount", "length", or "title".
@param idList: A dictionary. Keys are colors and values are lists of read
ids that should be colored using that color.
@param equalizeXAxes: If C{True}, adjust the X axis on each alignment plot
to be the same.
@param xRange: Set to either 'subject' or 'reads' to indicate the range of
the X axis.
@param logLinearXAxis: If C{True}, convert read offsets so that empty
regions in the plots we're preparing will only be as wide as their
logged actual values.
@param logBase: The logarithm base to use if logLinearXAxis is C{True}.
@param: rankScores: If C{True}, change the scores for the reads for each
title to be their rank (worst to best).
@param showFeatures: If C{True}, look online for features of the subject
sequences.
@raise ValueError: If C{outputDir} exists but is not a directory or if
C{xRange} is not "subject" or "reads".
"""
if xRange not in ('subject', 'reads'):
raise ValueError('xRange must be either "subject" or "reads".')
start = time()
titles = titlesAlignments.sortTitles(sortOn)
cols = 5
rows = int(len(titles) / cols) + (0 if len(titles) % cols == 0 else 1)
figure, ax = plt.subplots(rows, cols, squeeze=False)
allGraphInfo = {}
coords = dimensionalIterator((rows, cols))
report('Plotting %d titles in %dx%d grid, sorted on %s' %
(len(titles), rows, cols, sortOn))
for i, title in enumerate(titles):
titleAlignments = titlesAlignments[title]
row, col = next(coords)
report('%d: %s %s' % (i, title, NCBISequenceLinkURL(title, '')))
# Add a small plot to the alignment panel.
graphInfo = alignmentGraph(
titlesAlignments, title, addQueryLines=True,
showFeatures=showFeatures, rankScores=rankScores,
logLinearXAxis=logLinearXAxis, logBase=logBase,
colorQueryBases=False, createFigure=False, showFigure=False,
readsAx=ax[row][col], quiet=True, idList=idList, xRange=xRange,
showOrfs=False)
allGraphInfo[title] = graphInfo
readCount = titleAlignments.readCount()
hspCount = titleAlignments.hspCount()
# Make a short title for the small panel blue plot, ignoring any
# leading NCBI gi / accession numbers.
if title.startswith('gi|') and title.find(' ') > -1:
shortTitle = title.split(' ', 1)[1][:40]
else:
shortTitle = title[:40]
plotTitle = ('%d: %s\nLength %d, %d read%s, %d HSP%s.' % (
i, shortTitle, titleAlignments.subjectLength,
readCount, '' if readCount == 1 else 's',
hspCount, '' if hspCount == 1 else 's'))
if hspCount:
if rankScores:
plotTitle += '\nY axis is ranked score'
else:
plotTitle += '\nmax %.2f, median %.2f' % (
titleAlignments.bestHsp().score.score,
titleAlignments.medianScore())
ax[row][col].set_title(plotTitle, fontsize=10)
maxX = max(graphInfo['maxX'] for graphInfo in allGraphInfo.values())
minX = min(graphInfo['minX'] for graphInfo in allGraphInfo.values())
maxY = max(graphInfo['maxY'] for graphInfo in allGraphInfo.values())
minY = min(graphInfo['minY'] for graphInfo in allGraphInfo.values())
# Post-process graphs to adjust axes, etc.
coords = dimensionalIterator((rows, cols))
for title in titles:
titleAlignments = titlesAlignments[title]
row, col = next(coords)
a = ax[row][col]
a.set_ylim([0, int(maxY * Y_AXIS_UPPER_PADDING)])
if equalizeXAxes:
a.set_xlim([minX, maxX])
a.set_yticks([])
a.set_xticks([])
if xRange == 'subject' and minX < 0:
# Add a vertical line at x=0 so we can see the 'whiskers' of
# reads that extend to the left of the sequence we're aligning
# against.
a.axvline(x=0, color='#cccccc')
# Add a line on the right of each sub-plot so we can see where the
# sequence ends (as all panel graphs have the same width and we
# otherwise couldn't tell).
sequenceLen = titleAlignments.subjectLength
if logLinearXAxis:
sequenceLen = allGraphInfo[title]['adjustOffset'](sequenceLen)
a.axvline(x=sequenceLen, color='#cccccc')
# Hide the final panel graphs (if any) that have no content. We do this
# because the panel is a rectangular grid and some of the plots at the
# end of the last row may be unused.
for row, col in coords:
ax[row][col].axis('off')
# plt.subplots_adjust(left=0.01, bottom=0.01, right=0.99, top=0.93,
# wspace=0.1, hspace=None)
plt.subplots_adjust(hspace=0.4)
figure.suptitle('X: %d to %d, Y (%s): %d to %d' %
(minX, maxX,
titlesAlignments.readsAlignments.params.scoreTitle,
int(minY), int(maxY)), fontsize=20)
figure.set_size_inches(5 * cols, 3 * rows, forward=True)
figure.show()
stop = time()
report('Alignment panel generated in %.3f mins.' % ((stop - start) / 60.0))
def alignmentPanel(titlesAlignments, sortOn='maxScore', interactive=True,
outputDir=None, idList=False, equalizeXAxes=False,
xRange='subject', logLinearXAxis=False,
logBase=DEFAULT_LOG_LINEAR_X_AXIS_BASE, rankScores=False):
"""
Produces a rectangular panel of graphs that each contain an alignment graph
against a given sequence.
@param titlesAlignments: A L{dark.titles.TitlesAlignments} instance.
@param sortOn: The attribute to sort subplots on. Either "maxScore",
"medianScore", "readCount", "length", or "title".
@param interactive: If C{True}, we are interactive and should display the
panel using figure.show etc.
@param outputDir: If not None, specifies a directory to write an HTML
summary to. If the directory does not exist it will be created.
@param idList: a dictionary. Keys are colors and values are lists of read
ids that should be colored using that color.
@param equalizeXAxes: if C{True}, adjust the X axis on each alignment plot
to be the same.
@param xRange: set to either 'subject' or 'reads' to indicate the range of
the X axis.
@param logLinearXAxis: if C{True}, convert read offsets so that empty
regions in the plots we're preparing will only be as wide as their
logged actual values.
@param logBase: The base of the logarithm to use if logLinearXAxis is
C{True}.
@param: rankScores: If C{True}, change the scores for the reads for each
title to be their rank (worst to best).
"""
assert xRange in ('subject', 'reads'), (
'xRange must be either "subject" or "reads".')
if not (interactive or outputDir):
raise ValueError('Either interactive or outputDir must be True')
start = time()
titles = titlesAlignments.sortTitles(sortOn)
cols = 5
rows = int(len(titles) / cols) + (0 if len(titles) % cols == 0 else 1)
figure, ax = plt.subplots(rows, cols, squeeze=False)
report('Plotting %d titles in %dx%d grid, sorted on %s' %
(len(titles), rows, cols, sortOn))
allGraphInfo = {}
if outputDir:
if os.access(outputDir, os.F_OK):
# outputDir exists. Check it's a directory.
mode = os.stat(outputDir).st_mode
assert S_ISDIR(mode), "%r is not a directory." % outputDir
else:
os.mkdir(outputDir)
htmlOutput = AlignmentPanelHTML(outputDir, titlesAlignments)
coords = dimensionalIterator((rows, cols))
for i, title in enumerate(titles):
titleAlignments = titlesAlignments[title]
row, col = coords.next()
print '%d: %s %s' % (i, title, NCBISequenceLinkURL(title, ''))
if interactive:
graphInfo = alignmentGraph(
titlesAlignments, title, addQueryLines=True,
showFeatures=False, rankScores=rankScores,
logLinearXAxis=logLinearXAxis, logBase=logBase,
colorQueryBases=False, createFigure=False, showFigure=False,
readsAx=ax[row][col], quiet=True, idList=idList, xRange=xRange,
showOrfs=False)
if outputDir:
imageBasename = '%d.png' % i
imageFile = '%s/%s' % (outputDir, imageBasename)
graphInfo = alignmentGraph(
titlesAlignments, title, addQueryLines=True, showFeatures=True,
rankScores=rankScores, logLinearXAxis=logLinearXAxis,
logBase=logBase, colorQueryBases=False, showFigure=False,
imageFile=imageFile, quiet=True, idList=idList, xRange=xRange,
showOrfs=True)
# Close the image plot, otherwise it will be displayed when we
# call plt.show below.
plt.close()
htmlOutput.addImage(imageBasename, title, graphInfo)
allGraphInfo[title] = graphInfo
readCount = titleAlignments.readCount()
hspCount = titleAlignments.hspCount()
plotTitle = ('%d: %s\nLength %d, %d read%s, %d HSP%s.' % (
i, title.split(' ', 1)[1][:40],
titleAlignments.subjectLength,
readCount, '' if readCount == 1 else 's',
hspCount, '' if hspCount == 1 else 's'))
if hspCount:
if rankScores:
plotTitle += '\nY axis is ranked score'
else:
plotTitle += '\nmax %.2f, median %.2f' % (
titleAlignments.bestHsp().score.score,
titleAlignments.medianScore())
ax[row][col].set_title(plotTitle, fontsize=10)
maxX = max(graphInfo['maxX'] for graphInfo in allGraphInfo.itervalues())
minX = min(graphInfo['minX'] for graphInfo in allGraphInfo.itervalues())
maxY = max(graphInfo['maxY'] for graphInfo in allGraphInfo.itervalues())
minY = min(graphInfo['minY'] for graphInfo in allGraphInfo.itervalues())
# Post-process graphs to adjust axes, etc.
coords = dimensionalIterator((rows, cols))
for title in titles:
titleAlignments = titlesAlignments[title]
row, col = coords.next()
a = ax[row][col]
a.set_ylim([0, int(maxY * Y_AXIS_UPPER_PADDING)])
if equalizeXAxes:
a.set_xlim([minX, maxX])
a.set_yticks([])
a.set_xticks([])
if xRange == 'subject' and minX < 0:
# Add a vertical line at x=0 so we can see the 'whiskers' of
# reads that extend to the left of the sequence we're aligning
# against.
a.axvline(x=0, color='#cccccc')
# Add a line on the right of each sub-plot so we can see where the
# sequence ends (as all panel graphs have the same width and we
# otherwise couldn't tell).
sequenceLen = titleAlignments.subjectLength
if logLinearXAxis:
sequenceLen = allGraphInfo[title]['adjustOffset'](sequenceLen)
a.axvline(x=sequenceLen, color='#cccccc')
# Hide the final panel graphs (if any) that have no content. We do this
# because the panel is a rectangular grid and some of the plots at the
# end of the last row may be unused.
for row, col in coords:
ax[row][col].axis('off')
# plt.subplots_adjust(left=0.01, bottom=0.01, right=0.99, top=0.93,
# wspace=0.1, hspace=None)
plt.subplots_adjust(hspace=0.4)
figure.suptitle('X: %d to %d, Y (%s): %d to %d' %
(minX, maxX,
titlesAlignments.readsAlignments.params.scoreTitle,
int(minY), int(maxY)), fontsize=20)
figure.set_size_inches(5 * cols, 3 * rows, forward=True)
if outputDir:
panelFilename = 'alignment-panel.png'
figure.savefig('%s/%s' % (outputDir, panelFilename))
htmlOutput.close(panelFilename)
if interactive:
figure.show()
stop = time()
report('Alignment panel generated in %.3f mins.' % ((stop - start) / 60.0))
def test2X2LimitedTo3Items(self):
self.assertEqual(
((0, 0), (0, 1),
(1, 0)),
tuple(dimensionalIterator((2, 2), maxItems=3)))
def scoreGraph(titlesAlignments, find=None, showTitles=False, figureWidth=5,
figureHeight=5):
"""
NOTE: This function has probably bit rotted (but only a little).
Produce a rectangular panel of graphs, each of which shows sorted scores
for a title. Matches against a certain sequence title, as determined by
C{find}, (see below) are highlighted.
@param find: A function that can be passed a sequence title. If the
function returns C{True} a red dot is put into the graph at that point
to highlight the match.
@param showTitles: If C{True} display read sequence names. The panel tends
to look terrible when titles are displayed. If C{False}, show no title.
@param figureWidth: The C{float} width of the figure, in inches.
@param figureHeight: The C{float} height of the figure, in inches.
"""
maxScore = None
maxHsps = 0
cols = 5
rows = int(len(titlesAlignments) / cols) + (
0 if len(titlesAlignments) % cols == 0 else 1)
f, ax = plt.subplots(rows, cols)
coords = dimensionalIterator((rows, cols))
for title in titlesAlignments:
titleAlignments = titlesAlignments[title]
row, col = next(coords)
hspCount = titleAlignments.hspCount()
if hspCount > maxHsps:
maxHsps = hspCount
scores = []
highlightX = []
highlightY = []
for x, titleAlignment in enumerate(titleAlignments):
score = titleAlignment.hsps[0].score.score
scores.append(score)
if find and find(titleAlignment.subjectTitle):
highlightX.append(x)
highlightY.append(score)
a = ax[row][col]
if scores:
max_ = max(scores)
if maxScore is None or max_ > maxScore:
maxScore = max_
x = np.arange(0, len(scores))
a.plot(x, scores)
if highlightX:
a.plot(highlightX, highlightY, 'ro')
if showTitles:
a.set_title('%s' % title, fontsize=10)
# Adjust all plots to have the same dimensions.
coords = dimensionalIterator((rows, cols))
for _ in range(len(titlesAlignments)):
row, col = next(coords)
a = ax[row][col]
a.axis([0, maxHsps, 0, maxScore])
# a.set_yscale('log')
a.set_yticks([])
a.set_xticks([])
# Hide the final panel graphs (if any) that have no content. We do this
# because the panel is a rectangular grid and some of the plots at the
# end of the last row may be unused.
for row, col in coords:
ax[row][col].axis('off')
plt.subplots_adjust(left=0.01, bottom=0.01, right=0.99, top=0.93,
wspace=0.1, hspace=None)
f.suptitle('max HSPs %d, max score %f' % (maxHsps, maxScore))
f.set_size_inches(figureWidth, figureHeight, forward=True)
# f.savefig('scores.png')
plt.show()
def test2X2(self):
self.assertEqual(
((0, 0), (0, 1),
(1, 0), (1, 1)),
tuple(dimensionalIterator((2, 2))))
def testZeroDimension(self):
self.assertRaises(ValueError, next, dimensionalIterator((2, 0, 3)))
def testNegativeDimension(self):
self.assertRaises(ValueError, next, dimensionalIterator((2, -1, 3)))
