1680

pending completion

Build # 1680

Build Type

Pull #259

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/LCOGT/banzai/commit/<a class=hub.com/LCOGT/banzai/commit/01fb705effd5f6ed68326d99128367bd19458523">01fb705ef<a href="https://github.com/LCOGT/banzai/commit/01fb705effd5f6ed68326d99128367bd19458523">">Merge </a><a class="double-link" href="https://github.com/LCOGT/banzai/commit/<a class="double-link" href="https://github.com/LCOGT/banzai/commit/601b52b4f357f1ece12a49b11d980543c9b83477">601b52b4f</a>">601b52b4f</a><a href="https://github.com/LCOGT/banzai/commit/01fb705effd5f6ed68326d99128367bd19458523"> into 6d991a35a">6d991a35a</a>

Pull Request Pull Request #259: Add HDU re-ordering functionality to ObservationFrame. Add tests.

Run Details

14 of 14 new or added lines in 5 files covered. (100.0%)

1813 of 2834 relevant lines covered (63.97%)

0.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

9.52

/banzai/photometry.py

import logging

import numpy as np
from astropy.table import Table
import sep

from banzai.utils import stats, array_utils
from banzai.stages import Stage
from banzai.data import DataTable
from banzai import logs

logger = logging.getLogger('banzai')


class SourceDetector(Stage):
    # Note that threshold is number of sigma, not an absolute number because we provide the error
    # array to SEP.
    threshold = 10.0
    min_area = 9

    def __init__(self, runtime_context):
        super(SourceDetector, self).__init__(runtime_context)

    def do_stage(self, image):
        try:
            # Set the number of source pixels to be 5% of the total. This keeps us safe from
            # satellites and airplanes.
            ny, nx = image.shape
            sep.set_extract_pixstack(int(nx * ny * 0.05))

            data = image.data.copy()
            error = image.uncertainty
            mask = image.mask > 0

            # Fits can be backwards byte order, so fix that if need be and subtract
            # the background
            try:
                bkg = sep.Background(data, mask=mask, bw=32, bh=32, fw=3, fh=3)
            except ValueError:
                data = data.byteswap(True).newbyteorder()
                bkg = sep.Background(data, mask=mask, bw=32, bh=32, fw=3, fh=3)
            bkg.subfrom(data)

            # Do an initial source detection
            sources = sep.extract(data, self.threshold, mask=mask, minarea=self.min_area,
                                  err=error, deblend_cont=0.005)

            # Convert the detections into a table
            sources = Table(sources)

            # We remove anything with a detection flag >= 8
            # This includes memory overflows and objects that are too close the edge
            sources = sources[sources['flag'] < 8]

            sources = array_utils.prune_nans_from_table(sources)

            # Calculate the ellipticity
            sources['ellipticity'] = 1.0 - (sources['b'] / sources['a'])

            # Fix any value of theta that are invalid due to floating point rounding
            # -pi / 2 < theta < pi / 2
            sources['theta'][sources['theta'] > (np.pi / 2.0)] -= np.pi
            sources['theta'][sources['theta'] < (-np.pi / 2.0)] += np.pi

            # Calculate the kron radius
            kronrad, krflag = sep.kron_radius(data, sources['x'], sources['y'],
                                              sources['a'], sources['b'],
                                              sources['theta'], 6.0)
            sources['flag'] |= krflag
            sources['kronrad'] = kronrad

            # Calcuate the equivilent of flux_auto
            flux, fluxerr, flag = sep.sum_ellipse(data, sources['x'], sources['y'],
                                                  sources['a'], sources['b'],
                                                  np.pi / 2.0, 2.5 * kronrad,
                                                  subpix=1, err=error)
            sources['flux'] = flux
            sources['fluxerr'] = fluxerr
            sources['flag'] |= flag

            # Do circular aperture photometry for diameters of 1" to 6"
            for diameter in [1, 2, 3, 4, 5, 6]:
                flux, fluxerr, flag = sep.sum_circle(data, sources['x'], sources['y'],
                                                     diameter / 2.0 / image.pixel_scale, gain=1.0, err=error)
                sources['fluxaper{0}'.format(diameter)] = flux
                sources['fluxerr{0}'.format(diameter)] = fluxerr
                sources['flag'] |= flag

            # Calculate the FWHMs of the stars:
            fwhm = 2.0 * (np.log(2) * (sources['a'] ** 2.0 + sources['b'] ** 2.0)) ** 0.5
            sources['fwhm'] = fwhm

            # Cut individual bright pixels. Often cosmic rays
            sources = sources[fwhm > 1.0]

            # Measure the flux profile
            flux_radii, flag = sep.flux_radius(data, sources['x'], sources['y'],
                                               6.0 * sources['a'], [0.25, 0.5, 0.75],
                                               normflux=sources['flux'], subpix=5)
            sources['flag'] |= flag
            sources['fluxrad25'] = flux_radii[:, 0]
            sources['fluxrad50'] = flux_radii[:, 1]
            sources['fluxrad75'] = flux_radii[:, 2]

            # Calculate the windowed positions
            sig = 2.0 / 2.35 * sources['fluxrad50']
            xwin, ywin, flag = sep.winpos(data, sources['x'], sources['y'], sig)
            sources['flag'] |= flag
            sources['xwin'] = xwin
            sources['ywin'] = ywin

            # Calculate the average background at each source
            bkgflux, fluxerr, flag = sep.sum_ellipse(bkg.back(), sources['x'], sources['y'],
                                                     sources['a'], sources['b'], np.pi / 2.0,
                                                     2.5 * sources['kronrad'], subpix=1)
            # masksum, fluxerr, flag = sep.sum_ellipse(mask, sources['x'], sources['y'],
            #                                         sources['a'], sources['b'], np.pi / 2.0,
            #                                         2.5 * kronrad, subpix=1)

            background_area = (2.5 * sources['kronrad']) ** 2.0 * sources['a'] * sources['b'] * np.pi # - masksum
            sources['background'] = bkgflux
            sources['background'][background_area > 0] /= background_area[background_area > 0]
            # Update the catalog to match fits convention instead of python array convention
            sources['x'] += 1.0
            sources['y'] += 1.0

            sources['xpeak'] += 1
            sources['ypeak'] += 1

            sources['xwin'] += 1.0
            sources['ywin'] += 1.0

            sources['theta'] = np.degrees(sources['theta'])

            catalog = sources['x', 'y', 'xwin', 'ywin', 'xpeak', 'ypeak',
                              'flux', 'fluxerr', 'peak', 'fluxaper1', 'fluxerr1',
                              'fluxaper2', 'fluxerr2', 'fluxaper3', 'fluxerr3',
                              'fluxaper4', 'fluxerr4', 'fluxaper5', 'fluxerr5',
                              'fluxaper6', 'fluxerr6', 'background', 'fwhm',
                              'a', 'b', 'theta', 'kronrad', 'ellipticity',
                              'fluxrad25', 'fluxrad50', 'fluxrad75',
                              'x2', 'y2', 'xy', 'flag']

            # Add the units and description to the catalogs
            catalog['x'].unit = 'pixel'
            catalog['x'].description = 'X coordinate of the object'
            catalog['y'].unit = 'pixel'
            catalog['y'].description = 'Y coordinate of the object'
            catalog['xwin'].unit = 'pixel'
            catalog['xwin'].description = 'Windowed X coordinate of the object'
            catalog['ywin'].unit = 'pixel'
            catalog['ywin'].description = 'Windowed Y coordinate of the object'
            catalog['xpeak'].unit = 'pixel'
            catalog['xpeak'].description = 'X coordinate of the peak'
            catalog['ypeak'].unit = 'pixel'
            catalog['ypeak'].description = 'Windowed Y coordinate of the peak'
            catalog['flux'].unit = 'count'
            catalog['flux'].description = 'Flux within a Kron-like elliptical aperture'
            catalog['fluxerr'].unit = 'count'
            catalog['fluxerr'].description = 'Error on the flux within Kron aperture'
            catalog['peak'].unit = 'count'
            catalog['peak'].description = 'Peak flux (flux at xpeak, ypeak)'
            for diameter in [1, 2, 3, 4, 5, 6]:
                catalog['fluxaper{0}'.format(diameter)].unit = 'count'
                catalog['fluxaper{0}'.format(diameter)].description = 'Flux from fixed circular aperture: {0}" diameter'.format(diameter)
                catalog['fluxerr{0}'.format(diameter)].unit = 'count'
                catalog['fluxerr{0}'.format(diameter)].description = 'Error on Flux from circular aperture: {0}"'.format(diameter)

            catalog['background'].unit = 'count'
            catalog['background'].description = 'Average background value in the aperture'
            catalog['fwhm'].unit = 'pixel'
            catalog['fwhm'].description = 'FWHM of the object'
            catalog['a'].unit = 'pixel'
            catalog['a'].description = 'Semi-major axis of the object'
            catalog['b'].unit = 'pixel'
            catalog['b'].description = 'Semi-minor axis of the object'
            catalog['theta'].unit = 'degree'
            catalog['theta'].description = 'Position angle of the object'
            catalog['kronrad'].unit = 'pixel'
            catalog['kronrad'].description = 'Kron radius used for extraction'
            catalog['ellipticity'].description = 'Ellipticity'
            catalog['fluxrad25'].unit = 'pixel'
            catalog['fluxrad25'].description = 'Radius containing 25% of the flux'
            catalog['fluxrad50'].unit = 'pixel'
            catalog['fluxrad50'].description = 'Radius containing 50% of the flux'
            catalog['fluxrad75'].unit = 'pixel'
            catalog['fluxrad75'].description = 'Radius containing 75% of the flux'
            catalog['x2'].unit = 'pixel^2'
            catalog['x2'].description = 'Variance on X coordinate of the object'
            catalog['y2'].unit = 'pixel^2'
            catalog['y2'].description = 'Variance on Y coordinate of the object'
            catalog['xy'].unit = 'pixel^2'
            catalog['xy'].description = 'XY covariance of the object'
            catalog['flag'].description = 'Bit mask of extraction/photometry flags'

            catalog.sort('flux')
            catalog.reverse()

            # Save some background statistics in the header
            mean_background = stats.sigma_clipped_mean(bkg.back(), 5.0)
            image.meta['L1MEAN'] = (mean_background,
                                      '[counts] Sigma clipped mean of frame background')

            median_background = np.median(bkg.back())
            image.meta['L1MEDIAN'] = (median_background,
                                        '[counts] Median of frame background')

            std_background = stats.robust_standard_deviation(bkg.back())
            image.meta['L1SIGMA'] = (std_background,
                                       '[counts] Robust std dev of frame background')

            # Save some image statistics to the header
            good_objects = catalog['flag'] == 0
            for quantity in ['fwhm', 'ellipticity', 'theta']:
                good_objects = np.logical_and(good_objects, np.logical_not(np.isnan(catalog[quantity])))
            if good_objects.sum() == 0:
                image.meta['L1FWHM'] = ('NaN', '[arcsec] Frame FWHM in arcsec')
                image.meta['L1ELLIP'] = ('NaN', 'Mean image ellipticity (1-B/A)')
                image.meta['L1ELLIPA'] = ('NaN', '[deg] PA of mean image ellipticity')
            else:
                seeing = np.median(catalog['fwhm'][good_objects]) * image.pixel_scale
                image.meta['L1FWHM'] = (seeing, '[arcsec] Frame FWHM in arcsec')

                mean_ellipticity = stats.sigma_clipped_mean(catalog['ellipticity'][good_objects],
                                                            3.0)
                image.meta['L1ELLIP'] = (mean_ellipticity, 'Mean image ellipticity (1-B/A)')

                mean_position_angle = stats.sigma_clipped_mean(catalog['theta'][good_objects], 3.0)
                image.meta['L1ELLIPA'] = (mean_position_angle,
                                            '[deg] PA of mean image ellipticity')

            logging_tags = {key: float(image.meta[key]) for key in ['L1MEAN', 'L1MEDIAN', 'L1SIGMA',
                                                                      'L1FWHM', 'L1ELLIP', 'L1ELLIPA']}

            logger.info('Extracted sources', image=image, extra_tags=logging_tags)
            # adding catalog (a data table) to the appropriate images attribute.
            image.catalog = DataTable(catalog, name='CAT')
        except Exception:
            logger.error(logs.format_exception(), image=image)
        return image

1	import logging	1✔
2
3	import numpy as np	1✔
4	from astropy.table import Table	1✔
5	import sep	1✔
6
7	from banzai.utils import stats, array_utils	1✔
8	from banzai.stages import Stage	1✔
9	from banzai.data import DataTable	1✔
10	from banzai import logs	1✔
11
12	logger = logging.getLogger('banzai')	1✔
13
14
15	class SourceDetector(Stage):	1✔
16	# Note that threshold is number of sigma, not an absolute number because we provide the error
17	# array to SEP.
18	threshold = 10.0	1✔
19	min_area = 9	1✔
20
21	def __init__(self, runtime_context):	1✔
22	super(SourceDetector, self).__init__(runtime_context)	×
23
24	def do_stage(self, image):	1✔
25	try:	×
26	# Set the number of source pixels to be 5% of the total. This keeps us safe from
27	# satellites and airplanes.
28	ny, nx = image.shape	×
29	sep.set_extract_pixstack(int(nx * ny * 0.05))	×
30
31	data = image.data.copy()	×
32	error = image.uncertainty	×
33	mask = image.mask > 0	×
34
35	# Fits can be backwards byte order, so fix that if need be and subtract
36	# the background
37	try:	×
38	bkg = sep.Background(data, mask=mask, bw=32, bh=32, fw=3, fh=3)	×
39	except ValueError:	×
40	data = data.byteswap(True).newbyteorder()	×
41	bkg = sep.Background(data, mask=mask, bw=32, bh=32, fw=3, fh=3)	×
42	bkg.subfrom(data)	×
43
44	# Do an initial source detection
45	sources = sep.extract(data, self.threshold, mask=mask, minarea=self.min_area,	×
46	err=error, deblend_cont=0.005)
47
48	# Convert the detections into a table
49	sources = Table(sources)	×
50
51	# We remove anything with a detection flag >= 8
52	# This includes memory overflows and objects that are too close the edge
53	sources = sources[sources['flag'] < 8]	×
54
55	sources = array_utils.prune_nans_from_table(sources)	×
56
57	# Calculate the ellipticity
58	sources['ellipticity'] = 1.0 - (sources['b'] / sources['a'])	×
59
60	# Fix any value of theta that are invalid due to floating point rounding
61	# -pi / 2 < theta < pi / 2
62	sources['theta'][sources['theta'] > (np.pi / 2.0)] -= np.pi	×
63	sources['theta'][sources['theta'] < (-np.pi / 2.0)] += np.pi	×
64
65	# Calculate the kron radius
66	kronrad, krflag = sep.kron_radius(data, sources['x'], sources['y'],	×
67	sources['a'], sources['b'],
68	sources['theta'], 6.0)
69	sources['flag'] \|= krflag	×
70	sources['kronrad'] = kronrad	×
71
72	# Calcuate the equivilent of flux_auto
73	flux, fluxerr, flag = sep.sum_ellipse(data, sources['x'], sources['y'],	×
74	sources['a'], sources['b'],
75	np.pi / 2.0, 2.5 * kronrad,
76	subpix=1, err=error)
77	sources['flux'] = flux	×
78	sources['fluxerr'] = fluxerr	×
79	sources['flag'] \|= flag	×
80
81	# Do circular aperture photometry for diameters of 1" to 6"
82	for diameter in [1, 2, 3, 4, 5, 6]:	×
83	flux, fluxerr, flag = sep.sum_circle(data, sources['x'], sources['y'],	×
84	diameter / 2.0 / image.pixel_scale, gain=1.0, err=error)
85	sources['fluxaper{0}'.format(diameter)] = flux	×
86	sources['fluxerr{0}'.format(diameter)] = fluxerr	×
87	sources['flag'] \|= flag	×
88
89	# Calculate the FWHMs of the stars:
90	fwhm = 2.0 * (np.log(2) * (sources['a'] 2.0 + sources['b'] 2.0)) ** 0.5	×
91	sources['fwhm'] = fwhm	×
92
93	# Cut individual bright pixels. Often cosmic rays
94	sources = sources[fwhm > 1.0]	×
95
96	# Measure the flux profile
97	flux_radii, flag = sep.flux_radius(data, sources['x'], sources['y'],	×
98	6.0 * sources['a'], [0.25, 0.5, 0.75],
99	normflux=sources['flux'], subpix=5)
100	sources['flag'] \|= flag	×
101	sources['fluxrad25'] = flux_radii[:, 0]	×
102	sources['fluxrad50'] = flux_radii[:, 1]	×
103	sources['fluxrad75'] = flux_radii[:, 2]	×
104
105	# Calculate the windowed positions
106	sig = 2.0 / 2.35 * sources['fluxrad50']	×
107	xwin, ywin, flag = sep.winpos(data, sources['x'], sources['y'], sig)	×
108	sources['flag'] \|= flag	×
109	sources['xwin'] = xwin	×
110	sources['ywin'] = ywin	×
111
112	# Calculate the average background at each source
113	bkgflux, fluxerr, flag = sep.sum_ellipse(bkg.back(), sources['x'], sources['y'],	×
114	sources['a'], sources['b'], np.pi / 2.0,
115	2.5 * sources['kronrad'], subpix=1)
116	# masksum, fluxerr, flag = sep.sum_ellipse(mask, sources['x'], sources['y'],
117	# sources['a'], sources['b'], np.pi / 2.0,
118	# 2.5 * kronrad, subpix=1)
119
120	background_area = (2.5 * sources['kronrad']) ** 2.0 * sources['a'] * sources['b'] * np.pi # - masksum	×
121	sources['background'] = bkgflux	×
122	sources['background'][background_area > 0] /= background_area[background_area > 0]	×
123	# Update the catalog to match fits convention instead of python array convention
124	sources['x'] += 1.0	×
125	sources['y'] += 1.0	×
126
127	sources['xpeak'] += 1	×
128	sources['ypeak'] += 1	×
129
130	sources['xwin'] += 1.0	×
131	sources['ywin'] += 1.0	×
132
133	sources['theta'] = np.degrees(sources['theta'])	×
134
135	catalog = sources['x', 'y', 'xwin', 'ywin', 'xpeak', 'ypeak',	×
136	'flux', 'fluxerr', 'peak', 'fluxaper1', 'fluxerr1',
137	'fluxaper2', 'fluxerr2', 'fluxaper3', 'fluxerr3',
138	'fluxaper4', 'fluxerr4', 'fluxaper5', 'fluxerr5',
139	'fluxaper6', 'fluxerr6', 'background', 'fwhm',
140	'a', 'b', 'theta', 'kronrad', 'ellipticity',
141	'fluxrad25', 'fluxrad50', 'fluxrad75',
142	'x2', 'y2', 'xy', 'flag']
143
144	# Add the units and description to the catalogs
145	catalog['x'].unit = 'pixel'	×
146	catalog['x'].description = 'X coordinate of the object'	×
147	catalog['y'].unit = 'pixel'	×
148	catalog['y'].description = 'Y coordinate of the object'	×
149	catalog['xwin'].unit = 'pixel'	×
150	catalog['xwin'].description = 'Windowed X coordinate of the object'	×
151	catalog['ywin'].unit = 'pixel'	×
152	catalog['ywin'].description = 'Windowed Y coordinate of the object'	×
153	catalog['xpeak'].unit = 'pixel'	×
154	catalog['xpeak'].description = 'X coordinate of the peak'	×
155	catalog['ypeak'].unit = 'pixel'	×
156	catalog['ypeak'].description = 'Windowed Y coordinate of the peak'	×
157	catalog['flux'].unit = 'count'	×
158	catalog['flux'].description = 'Flux within a Kron-like elliptical aperture'	×
159	catalog['fluxerr'].unit = 'count'	×
160	catalog['fluxerr'].description = 'Error on the flux within Kron aperture'	×
161	catalog['peak'].unit = 'count'	×
162	catalog['peak'].description = 'Peak flux (flux at xpeak, ypeak)'	×
163	for diameter in [1, 2, 3, 4, 5, 6]:	×
164	catalog['fluxaper{0}'.format(diameter)].unit = 'count'	×
165	catalog['fluxaper{0}'.format(diameter)].description = 'Flux from fixed circular aperture: {0}" diameter'.format(diameter)	×
166	catalog['fluxerr{0}'.format(diameter)].unit = 'count'	×
167	catalog['fluxerr{0}'.format(diameter)].description = 'Error on Flux from circular aperture: {0}"'.format(diameter)	×
168
169	catalog['background'].unit = 'count'	×
170	catalog['background'].description = 'Average background value in the aperture'	×
171	catalog['fwhm'].unit = 'pixel'	×
172	catalog['fwhm'].description = 'FWHM of the object'	×
173	catalog['a'].unit = 'pixel'	×
174	catalog['a'].description = 'Semi-major axis of the object'	×
175	catalog['b'].unit = 'pixel'	×
176	catalog['b'].description = 'Semi-minor axis of the object'	×
177	catalog['theta'].unit = 'degree'	×
178	catalog['theta'].description = 'Position angle of the object'	×
179	catalog['kronrad'].unit = 'pixel'	×
180	catalog['kronrad'].description = 'Kron radius used for extraction'	×
181	catalog['ellipticity'].description = 'Ellipticity'	×
182	catalog['fluxrad25'].unit = 'pixel'	×
183	catalog['fluxrad25'].description = 'Radius containing 25% of the flux'	×
184	catalog['fluxrad50'].unit = 'pixel'	×
185	catalog['fluxrad50'].description = 'Radius containing 50% of the flux'	×
186	catalog['fluxrad75'].unit = 'pixel'	×
187	catalog['fluxrad75'].description = 'Radius containing 75% of the flux'	×
188	catalog['x2'].unit = 'pixel^2'	×
189	catalog['x2'].description = 'Variance on X coordinate of the object'	×
190	catalog['y2'].unit = 'pixel^2'	×
191	catalog['y2'].description = 'Variance on Y coordinate of the object'	×
192	catalog['xy'].unit = 'pixel^2'	×
193	catalog['xy'].description = 'XY covariance of the object'	×
194	catalog['flag'].description = 'Bit mask of extraction/photometry flags'	×
195
196	catalog.sort('flux')	×
197	catalog.reverse()	×
198
199	# Save some background statistics in the header
200	mean_background = stats.sigma_clipped_mean(bkg.back(), 5.0)	×
201	image.meta['L1MEAN'] = (mean_background,	×
202	'[counts] Sigma clipped mean of frame background')
203
204	median_background = np.median(bkg.back())	×
205	image.meta['L1MEDIAN'] = (median_background,	×
206	'[counts] Median of frame background')
207
208	std_background = stats.robust_standard_deviation(bkg.back())	×
209	image.meta['L1SIGMA'] = (std_background,	×
210	'[counts] Robust std dev of frame background')
211
212	# Save some image statistics to the header
213	good_objects = catalog['flag'] == 0	×
214	for quantity in ['fwhm', 'ellipticity', 'theta']:	×
215	good_objects = np.logical_and(good_objects, np.logical_not(np.isnan(catalog[quantity])))	×
216	if good_objects.sum() == 0:	×
217	image.meta['L1FWHM'] = ('NaN', '[arcsec] Frame FWHM in arcsec')	×
218	image.meta['L1ELLIP'] = ('NaN', 'Mean image ellipticity (1-B/A)')	×
219	image.meta['L1ELLIPA'] = ('NaN', '[deg] PA of mean image ellipticity')	×
220	else:
221	seeing = np.median(catalog['fwhm'][good_objects]) * image.pixel_scale	×
222	image.meta['L1FWHM'] = (seeing, '[arcsec] Frame FWHM in arcsec')	×
223
224	mean_ellipticity = stats.sigma_clipped_mean(catalog['ellipticity'][good_objects],	×
225	3.0)
226	image.meta['L1ELLIP'] = (mean_ellipticity, 'Mean image ellipticity (1-B/A)')	×
227
228	mean_position_angle = stats.sigma_clipped_mean(catalog['theta'][good_objects], 3.0)	×
229	image.meta['L1ELLIPA'] = (mean_position_angle,	×
230	'[deg] PA of mean image ellipticity')
231
232	logging_tags = {key: float(image.meta[key]) for key in ['L1MEAN', 'L1MEDIAN', 'L1SIGMA',	×
233	'L1FWHM', 'L1ELLIP', 'L1ELLIPA']}
234
235	logger.info('Extracted sources', image=image, extra_tags=logging_tags)	×
236	# adding catalog (a data table) to the appropriate images attribute.
237	image.catalog = DataTable(catalog, name='CAT')	×
238	except Exception:	×
239	logger.error(logs.format_exception(), image=image)	×
240	return image	×

LCOGT / banzai / 1680

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous