def calc_borders_step(image, sob, pr, ccl, ccr, sign=1, refine=False, plot=True, barid=0, px=0): cut1 = sob[pr, ccl:ccr + 1] mcut1 = image[pr, ccl:ccr + 1] res = feat.peak_local_max(sign * cut1, exclude_border=4, num_peaks=2) if len(res) != 0: res1 = res[:, 0] else: res1 = [] if sign > 0: bar_s = 'l' else: bar_s = 'r' if plot: xdummy = np.arange(ccl, ccr + 1) plt.title("{}bar {}, prow={} px={}".format(bar_s, barid, pr, px)) plt.plot(xdummy, sign * cut1) plt.axvline(px, color='g') ax1 = plt.gca() ax2 = ax1.twinx() ax2.plot(xdummy, mcut1, '--') for r in res1: plt.axvline(ccl + r, color='red') for r in res[:, 0]: plt.axvline(ccl + r, color='red', linestyle='--') xpeak = None if len(res1) != 0: idx = (sign * cut1)[res1].argmax() xpeak = ccl + res1[idx] if plot: if xpeak: plt.axvline(xpeak, color='black') plt.show() if xpeak: if refine: x_t, y_t = refine_peaks(sign * sob[pr], np.array([xpeak]), window_width=3) xpeak_ref = x_t else: xpeak_ref = xpeak return pr, xpeak, xpeak_ref else: return None
def run_on_image(self, rssdata, tracemap, current_vph): """Extract spectra, find peaks and compute FWHM.""" # Extract the polynomials # FIXME: a little hackish valid_traces = get_valid_traces(tracemap) pols = [t.polynomial for t in tracemap.contents] vph_t = vph_thr['default'] this_val = vph_t.get(current_vph) if this_val: flux_limit = this_val.get('flux_limit', 200000) else: flux_limit = 40000 nwinwidth = 5 times_sigma = 50.0 lwidth = 20 fpeaks = {} # FIXME: We are using here only one in 10 fibers for fibid in valid_traces[::10]: # sampling every 10 fibers... idx = fibid - 1 row = rssdata[idx, :] the_pol = pols[idx] # FIXME: using here a different peak routine than in arc # find peaks threshold = numpy.median(row) + times_sigma * sigmaG(row) ipeaks_int1 = find_peaks_indexes(row, nwinwidth, threshold) # filter by flux self.logger.info('Filtering peaks over %5.0f', flux_limit) ipeaks_vals = row[ipeaks_int1] mask = ipeaks_vals < flux_limit ipeaks_int = ipeaks_int1[mask] self.logger.debug('LEN (ipeaks_int): %s', len(ipeaks_int)) self.logger.debug('ipeaks_int: %s', ipeaks_int) ipeaks_float = refine_peaks(row, ipeaks_int, nwinwidth)[0] # self.pintarGrafica(refine_peaks(row, ipeaks_int, nwinwidth)[0] - refinePeaks_spectrum(row, ipeaks_int, nwinwidth)) fpeaks[idx] = [] for peak, peak_f in zip(ipeaks_int, ipeaks_float): try: sl = numina.array.utils.slice_create(peak, lwidth) rel_peak = peak - sl.start qslit = row[sl] peak_val, fwhm = fmod.compute_fwhm_1d_simple(qslit, rel_peak) peak_on_trace = the_pol(peak) fpeaks[idx].append((peak_f, peak_on_trace, fwhm)) except ValueError as error: self.logger.warning('Error %s computing FWHM in fiber %d', error, idx + 1) except IndexError as error: self.logger.warning('Error %s computing FWHM in fiber %d', error, idx + 1) self.logger.debug('found %d peaks in fiber %d', len(fpeaks[idx]), idx) return fpeaks
def run_on_image(self, img, tracemap, flux_limit=40000, valid_traces=None, times_sigma=50): """Extract spectra, find peaks and compute FWHM.""" rssdata = img[0].data if valid_traces: valid_traces_s = set(valid_traces) # use set for fast membership valid_apers = [aper for aper in tracemap.contents if aper.valid and aper.fibid in valid_traces_s] else: valid_apers = [aper for aper in tracemap.contents if aper.valid] nwinwidth = 5 lwidth = 20 fpeaks = {} for aper in valid_apers: fibid = aper.fibid idx = fibid - 1 row = rssdata[idx, :] the_pol = aper.polynomial # FIXME: using here a different peak routine than in arc # find peaks threshold = numpy.median(row) + times_sigma * sigmaG(row) self.logger.debug('values for threshold: median: %f, scale: %f, sigma: %f', numpy.median(row), times_sigma, sigmaG(row)) self.logger.debug('threshold is: %f', threshold) ipeaks_int1 = find_peaks_indexes(row, nwinwidth, threshold) # filter by flux self.logger.info('Filtering peaks over %5.0f', flux_limit) ipeaks_vals = row[ipeaks_int1] mask = ipeaks_vals < flux_limit ipeaks_int = ipeaks_int1[mask] self.logger.debug('LEN (ipeaks_int): %s', len(ipeaks_int)) self.logger.debug('ipeaks_int: %s', ipeaks_int) ipeaks_float = refine_peaks(row, ipeaks_int, nwinwidth)[0] # self.pintarGrafica(refine_peaks(row, ipeaks_int, nwinwidth)[0] - refinePeaks_spectrum(row, ipeaks_int, nwinwidth)) fpeaks[fibid] = [] for peak, peak_f in zip(ipeaks_int, ipeaks_float): try: sl = numina.array.utils.slice_create(peak, lwidth) rel_peak = peak - sl.start qslit = row[sl] peak_val, fwhm = fmod.compute_fwhm_1d_simple(qslit, rel_peak) peak_on_trace = the_pol(peak) fpeaks[fibid].append((peak_f, peak_on_trace, fwhm)) except ValueError as error: self.logger.warning('Error %s computing FWHM in fiber %d', error, fibid) except IndexError as error: self.logger.warning('Error %s computing FWHM in fiber %d', error, fibid) self.logger.debug('found %d peaks in fiber %d', len(fpeaks[fibid]), fibid) return fpeaks
def refine_bar_centroid(arr_deriv, centerx, centery, wx, wy, threshold, sign): # Refine values logger = logging.getLogger('emir.recipes.bardetect') logger.debug('collapsing a %d x %d region', 2 * wx + 1, 2 * wy + 1) # slicey = slice_create(centery, wy, start=1, stop=2047) slicex = slice_create(centerx, wx, start=1, stop=2047) region = arr_deriv[slicey, slicex] if region.size == 0: logger.debug('region to collapse is empty') return 0, 0, 1 collapsed = sign * region.mean(axis=0) # Fine tunning idxs_t = find_peaks_indexes(collapsed, window_width=3, threshold=threshold) # Use only the peak nearest the original peak if len(idxs_t) == 0: logger.debug('no peaks after fine-tunning') return 0, 0, 2 dist_t = numpy.abs(idxs_t - wx) only_this = dist_t.argmin() idxs_p = numpy.atleast_1d(idxs_t[only_this]) x_t, y_t = refine_peaks(collapsed, idxs_p, window_width=3) if len(x_t) == 0: logger.debug('no peaks to refine after fitting') return 0, 0, 2 if x_t[0] >= collapsed.shape[0]: logger.debug('wrong position %d when refining', x_t[0]) return 0, 0, 2 _, fwhm_x = fmod.compute_fwhm_1d_simple(collapsed, x_t[0]) xl = centerx - wx + x_t[0] return xl, fwhm_x, 0
def refine_bar_centroid(arr_deriv, centerx, centery, wx, wy, threshold, sign): # Refine values logger = logging.getLogger('emir.recipes.bardetect') logger.debug('collapsing a %d x %d region', 2 * wx + 1 , 2 * wy + 1) # slicey = slice_create(centery, wy, start=1, stop=2047) slicex = slice_create(centerx, wx, start=1, stop=2047) region = arr_deriv[slicey, slicex] if region.size == 0: logger.debug('region to collapse is empty') return 0, 0, 1 collapsed = sign * region.mean(axis=0) # Fine tunning idxs_t = find_peaks_indexes(collapsed, window_width=3, threshold=threshold) # Use only the peak nearest the original peak if len(idxs_t) == 0: logger.debug('no peaks after fine-tunning') return 0, 0, 2 dist_t = numpy.abs(idxs_t - wx) only_this = dist_t.argmin() idxs_p = numpy.atleast_1d(idxs_t[only_this]) x_t, y_t = refine_peaks(collapsed, idxs_p, window_width=3) if len(x_t) == 0: logger.debug('no peaks to refine after fitting') return 0, 0, 2 if x_t[0] >= collapsed.shape[0]: logger.debug('wrong position %d when refining', x_t[0]) return 0, 0, 2 _, fwhm_x = fmod.compute_fwhm_1d_simple(collapsed, x_t[0]) xl = centerx - wx + x_t[0] return xl, fwhm_x, 0
def init_traces(image, center, hs, boxes, box_borders, tol=1.5, threshold=0.37, debug_plot=0): _logger = logging.getLogger(__name__) cut_region = slice(center-hs, center+hs) cut = image[:, cut_region] colcut = cut.mean(axis=1) # trace local background with a min filter mincol = minimum_filter(colcut, size=7) _logger.debug('initial pairing fibers in column %d', center) fiber_traces = [] total_peaks = 0 lastid = 0 counted_fibers = 0 boxes_with_missing_fibers = [] for boxid, box in enumerate(boxes): nfibers = box['nfibers'] mfibers = box.get('missing', []) nfibers_max = nfibers - len(mfibers) sfibers = box.get('skipcount', []) _logger.debug('pseudoslit box: %s, id: %d', box['name'], boxid) _logger.debug('nfibers: %d, missing: %s',nfibers, mfibers) counted_fibers += nfibers b1 = int(box_borders[boxid]) b2 = int(box_borders[boxid + 1]) _logger.debug('box borders: %s %s', b1, b2) borders = [b1, b2] region = colcut[borders[0]:borders[1]+1] # Region for background computation # Remove the space of 1.5 fibers bb1 = b1 + 9 bb2 = b2 - 9 # a conservative background lowt = numpy.min(mincol[bb1:bb2+1]) _logger.debug('conservative background in box is %f', lowt) # Find exactly the number of peaks expected _logger.debug('find %d peaks (max)', nfibers_max) ipeaks_int = peak_local_max(region, min_distance=3, threshold_abs=lowt, threshold_rel=threshold, num_peaks=nfibers_max, )[:, 0] npeaks = len(ipeaks_int) total_peaks += npeaks if npeaks == 0: # skip everything, go to next box boxes_with_missing_fibers.append((box['name'], nfibers)) _logger.debug('no peaks detected, go to next box') continue # We always want the result sorted. The order changes in different versions # of scikit-image ipeaks_int.sort() ipeaks_float = refine_peaks(region, ipeaks_int, 3)[0] peaks_dist = numpy.diff(ipeaks_float) measured_scale = numpy.median(peaks_dist) _logger.debug('median distance between peaks is %s', measured_scale) peaks_y = numpy.ones((ipeaks_int.shape[0], 3)) peaks_y[:, 0] = ipeaks_int + b1 peaks_y[:, 1] = ipeaks_float + b1 peaks_y[:, 2] = region[ipeaks_int] if debug_plot: plt.plot(region) plt.plot(ipeaks_int, region[ipeaks_int], 'r*') plt.savefig('central_cut_{:02d}.png'.format(boxid)) plt.close() startid = lastid + 1 fiber_model = fibermatch.generate_box_model(nfibers, start=startid, missing_relids=mfibers, skip_fibids=sfibers ) lastid = fiber_model[-1].fibid _logger.debug('fibids %s - %s', startid, lastid) matched_peaks = fibermatch.count_peaks(peaks_y[:, 1]) nmatched = len(matched_peaks) missing = nfibers - nmatched if missing != 0: boxes_with_missing_fibers.append((box['name'], missing)) _logger.debug('matched %s, missing: %s', nmatched, missing) pos_solutions = fibermatch.complete_solutions(fiber_model, matched_peaks, borders, scale=measured_scale) for fibid, match in fibermatch.iter_best_solution(fiber_model, matched_peaks, pos_solutions): fti = FiberTraceInfo(fibid, boxid) if match is not None: fti.start = (center, peaks_y[match, 1], peaks_y[match, 2]) fiber_traces.append(fti) _logger.debug('total found peaks: %d', total_peaks) _logger.debug('total found + recovered peaks: %d', counted_fibers) if boxes_with_missing_fibers: for m1, n2 in boxes_with_missing_fibers: _logger.debug('missing %d fibers in box %s', n2, m1) return fiber_traces
def init_traces(image, center, hs, boxes, box_borders, tol=1.5, threshold=0.37): _logger = logging.getLogger(__name__) cut_region = slice(center-hs, center+hs) cut = image[:,cut_region] colcut = cut.mean(axis=1) counted_fibers = 0 fiber_traces = [] total_peaks = 0 total_peaks_pos = [] # ipeaks_int = peak_local_max(colcut, min_distance=2, threshold_rel=0.2)[:, 0] ipeaks_int = peak_local_max(colcut, min_distance=3, threshold_rel=threshold)[:, 0] # All VPH if False: import matplotlib.pyplot as plt plt.plot(colcut) plt.plot(ipeaks_int, colcut[ipeaks_int], 'r*') for border in box_borders: plt.axvline(border, color='k') plt.show() ipeaks_float = refine_peaks(colcut, ipeaks_int, 3)[0] peaks_y = numpy.ones((ipeaks_int.shape[0], 3)) peaks_y[:, 0] = ipeaks_int peaks_y[:, 1] = ipeaks_float peaks_y[:, 2] = colcut[ipeaks_int] box_match = numpy.digitize(peaks_y[:, 0], box_borders) _logger.debug('initial pairing fibers in column %d', center) for boxid, box in enumerate(boxes): nfibers = box['nfibers'] dist_b_fibs = (box_borders[boxid + 1] - box_borders[boxid]) / (nfibers + 2.0) mask_fibers = (box_match == (boxid + 1)) # Peaks in this box thispeaks = peaks_y[mask_fibers] npeaks = len(thispeaks) total_peaks += npeaks for elem in thispeaks: total_peaks_pos.append(elem.tolist()) _logger.debug('pseudoslit box: %s, id: %d', box['name'], boxid) # Start by matching the first peak # with the first fiber fid = 0 current_peak = 0 pairs_1 = [(fid, current_peak)] fid += 1 scale = 1 while (current_peak < npeaks - 1) and (fid < nfibers): # Expected distance to next fiber expected_distance = scale * dist_b_fibs # _logger.debug('expected %s current peak %s', expected_distance, current_peak) for idx in range(current_peak + 1, npeaks): distance = abs(thispeaks[idx, 1] - thispeaks[current_peak, 1]) if abs(distance - expected_distance) <= tol: # We have a match # We could update # dist_b_fibs = distance / scale # But is not clear this is better # Store this match pairs_1.append((fid, idx)) current_peak = idx # Next scale = 1 break else: # This fiber has no match pairs_1.append((fid, None)) # Try a fiber further away scale += 1 # Match next fiber fid += 1 _logger.debug('matched %s \t missing: %s', len(pairs_1),nfibers-len(pairs_1)) remainig = nfibers - len(pairs_1) if remainig > 0: _logger.debug('we have to pair %d miising fibers', remainig) # Position of first match fiber # Position of last match fiber for fid, peakid in reversed(pairs_1): if peakid is not None: last_matched_peak = peakid last_matched_fiber = fid break else: raise ValueError('None matched') _logger.debug('peaks: %s \t %s', thispeaks[0, 1], thispeaks[last_matched_peak, 1]) _logger.debug('borders: %s \t %s', box_borders[boxid], box_borders[boxid+1]) ldist = thispeaks[0, 1] - box_borders[boxid] rdist = box_borders[boxid + 1] - thispeaks[last_matched_peak, 1] lcap = ldist / dist_b_fibs - 1 rcap = rdist / dist_b_fibs - 1 _logger.debug('L distance %s \t %s', ldist, lcap) _logger.debug('R distance %s \t %s', rdist, rcap) lcapi = int(lcap + 0.5) rcapi = int(rcap + 0.5) on_r = rcapi <= lcapi mincap = min(lcapi, rcapi) maxcap = max(lcapi, rcapi) cap1 = min(mincap, remainig) cap2 = min(maxcap, remainig - cap1) cap3 = remainig - cap1 - cap2 if cap3 > 0: _logger.debug('we dont have space %s fibers no allocated', cap3) if on_r: # Fill rcap fibers, then lcap capr = cap1 capl = cap2 else: capr = cap2 capl = cap1 addl = [(x, None) for x in range(-capl, 0)] addr = [(x, None) for x in range(last_matched_fiber + 1, last_matched_fiber + 1 + capr)] _logger.debug('add %s fibers on the right', capr) _logger.debug('add %s fibers on the left', capl) pairs_1 = addl + pairs_1 + addr for fibid, (relfibid, match) in enumerate(pairs_1, counted_fibers): fti = FiberTraceInfo(fibid + 1, boxid) if match is not None: fti.start = (center, thispeaks[match, 1], thispeaks[match, 2]) fiber_traces.append(fti) # else: # fiber_traces[fibid].start = (center, 0, 0) counted_fibers += nfibers # import matplotlib.pyplot as plt # plt.xlim([box_borders[boxid], box_borders[boxid + 1]]) # plt.plot(colcut, 'b-') # plt.plot(thispeaks[:, 1], thispeaks[:, 2], 'ro') # plt.plot(peaks_y[:,1], peaks_y[:, 2], 'ro') # plt.title('Box %s' %box['id']) # plt.show() # import matplotlib.pyplot as plt # total_peaks_pos = np.array(total_peaks_pos) # plt.plot(colcut, 'b-') # plt.plot(total_peaks_pos[:, 1], total_peaks_pos[:, 2], 'ro') # plt.show() _logger.debug('total found peaks: %d', total_peaks) _logger.debug('total found + recovered peaks: %d', counted_fibers) return fiber_traces
def calibrate_wl(self, rss, lines_catalog, poldeg, tracemap, nlines, threshold=0.27, min_distance=30): wv_master = lines_catalog[:, 0] ntriplets_master, ratios_master_sorted, triplets_master_sorted_list = \ gen_triplets_master(wv_master) nwinwidth = 5 error_contador = 0 missing_fib = 0 data_wlcalib = WavelengthCalibration(instrument='MEGARA') data_wlcalib.total_fibers = tracemap.total_fibers for trace in tracemap.contents: fibid = trace.fibid idx = trace.fibid - 1 if trace.valid: row = rss[idx] trend = detrend(row) fibdata_detrend = row - trend # A fix for LR-V Jun 2016 test images # that only have lines there row = fibdata_detrend self.logger.info('Starting row %d, fibid %d', idx, fibid) # find peaks (initial search providing integer numbers) ipeaks_int = peak_local_max(row, threshold_rel=threshold, min_distance=min_distance)[:, 0] self.logger.debug('ipeaks_int.........: %s', ipeaks_int) # Filter by flux, selecting a maximum number of brightest # lines in each region region_size = (len(row)-1)/(len(nlines)) ipeaks_int_filtered = numpy.array([], dtype=int) for iregion, nlines_in_region in enumerate(nlines): if nlines_in_region > 0: imin = int(iregion * region_size) imax = int((iregion + 1) * region_size) if iregion > 0: imin += 1 ipeaks_int_region = ipeaks_int[numpy.logical_and( ipeaks_int >= imin, ipeaks_int <= imax )] if len(ipeaks_int_region) > 0: peak_fluxes = row[ipeaks_int_region] spos = peak_fluxes.argsort() ipeaks_tmp = ipeaks_int_region[ spos[-nlines_in_region:] ] ipeaks_tmp.sort() # in-place sort self.logger.debug('ipeaks_in_region...: %s', ipeaks_tmp) ipeaks_int_filtered=numpy.concatenate( (ipeaks_int_filtered, ipeaks_tmp) ) self.logger.debug('ipeaks_int_filtered: %s', ipeaks_int_filtered) ipeaks_float = refine_peaks(row, ipeaks_int_filtered, nwinwidth)[0] # if idx==299: if False: import matplotlib.pyplot as plt plt.title('fibid %d' % fibid) plt.plot(row) plt.plot(ipeaks_int, row[ipeaks_int], 'ro', alpha=.9, ms=7, label="ipeaks_int") plt.plot(ipeaks_int_filtered, row[ipeaks_int_filtered], 'ro', alpha=.9, ms=7, label="ipeaks_int_filtered") plt.legend() plt.show() # FIXME: xchannel ??? # This comes from Nico's code, so probably pixels # will start in 1 naxis1 = row.shape[0] crpix1 = 1.0 xchannel = numpy.arange(1, naxis1 + 1) finterp_channel = interp1d(range(xchannel.size), xchannel, kind='linear', bounds_error=False, fill_value=0.0) xpeaks_refined = finterp_channel(ipeaks_float) wv_range_catalog = lines_catalog[-1][0] - lines_catalog[0][0] delta_wv = 0.05 * wv_range_catalog wv_ini_search = int(lines_catalog[0][0] - delta_wv) wv_end_search = int(lines_catalog[-1][0] + delta_wv) try: self.logger.info('wv_ini_search %s', wv_ini_search) self.logger.info('wv_end_search %s', wv_end_search) list_of_wvfeatures = arccalibration_direct( wv_master, ntriplets_master, ratios_master_sorted, triplets_master_sorted_list, xpeaks_refined, naxis1, crpix1=crpix1, wv_ini_search=wv_ini_search, wv_end_search=wv_end_search, error_xpos_arc=2.3, # initially: 2.0 times_sigma_r=3.0, frac_triplets_for_sum=0.50, times_sigma_theil_sen=10.0, poly_degree_wfit=poldeg, times_sigma_polfilt=10.0, times_sigma_cook=10.0, times_sigma_inclusion=5.0 ) self.logger.info('Solution for row %d completed', idx) self.logger.info('Fitting solution for row %d', idx) solution_wv = fit_list_of_wvfeatures( list_of_wvfeatures, naxis1_arc=naxis1, crpix1=crpix1, poly_degree_wfit=poldeg, weighted=False, debugplot=0, plot_title=None ) self.logger.info('linear crval1, cdelt1: %f %f', solution_wv.cr_linear.crval, solution_wv.cr_linear.cdelt) self.logger.info('fitted coefficients %s', solution_wv.coeff) trace_pol = trace.polynomial # Update feature with measurements of Y coord in original image # Peak and FWHM in RSS for feature in solution_wv.features: # Compute Y feature.ypos = trace_pol(feature.xpos) # FIXME: check here FITS vs PYTHON coordinates, etc peak_int = int(feature.xpos) try: peak, fwhm = self.calc_fwhm_of_line(row, peak_int, lwidth=20) except Exception as error: self.logger.error("%s", error) self.logger.error('error in feature %s', feature) # workaround peak = row[peak_int] fwhm = 0.0 # I would call this peak instead... feature.peak = peak feature.fwhm = fwhm # if True: # plt.title('fibid %d' % fibid) # plt.plot(row) # plt.plot(ipeaks_int, row[ipeaks_int],'ro', alpha=.9, ms=7, label="ipeaks_int") # # # plt.plot(ipeaks_int2, row[ipeaks_int2],'gs', alpha=.5 , ms=10) # plt.legend() # plt.show() new = FiberSolutionArcCalibration(fibid, solution_wv) data_wlcalib.contents.append(new) except (ValueError, TypeError, IndexError) as error: self.logger.error("%s", error) self.logger.error('error in row %d, fibid %d', idx, fibid) traceback.print_exc() data_wlcalib.error_fitting.append(fibid) if False: import matplotlib.pyplot as plt plt.title('fibid %d' % fibid) rrow = row[::-1] rpeaks = 4096-ipeaks_int_filtered[::-1] plt.plot(rrow) plt.plot(rpeaks, rrow[rpeaks], 'ro', alpha=.9, ms=7, label="ipeaks_int_filtered") # # plt.plot(ipeaks_int2, row[ipeaks_int2],'gs', alpha=.5 , ms=10) plt.legend() plt.show() error_contador += 1 else: self.logger.info('skipping row %d, fibid %d, not extracted', idx, fibid) missing_fib += 1 data_wlcalib.missing_fibers.append(fibid) self.logger.info('Errors in fitting: %s', error_contador) self.logger.info('Missing fibers: %s', missing_fib) self.logger.info('Generating fwhm_image...') image = self.generate_fwhm_image(data_wlcalib.contents) fwhm_image = fits.PrimaryHDU(image) fwhm_hdulist = fits.HDUList([fwhm_image]) self.logger.info('End arc calibration') return data_wlcalib, fwhm_hdulist
def char_bar_height(arr_deriv_alt, xpos1, xpos2, centery, threshold, wh=35, wfit=3): logger = logging.getLogger('emir.recipes.bardetect') pcentery = coor_to_pix_1d(centery) slicey = slice_create(pcentery, wh, start=1, stop=2047) ref_pcentery = pcentery - slicey.start mm = arr_deriv_alt[slicey, xpos1:xpos2 + 1].mean(axis=-1) idxs_t = find_peaks_indexes(mm, window_width=3, threshold=threshold) idxs_u = find_peaks_indexes(-mm, window_width=3, threshold=threshold) # Peaks on the right status = 0 npeaks_u = len(idxs_u) if npeaks_u == 0: # This is a problem, no peak on the right b2 = 0 status = 4 logger.debug('no bottom border found') else: # Filter over reference g_idxs_u = idxs_u[idxs_u >= ref_pcentery] if len(g_idxs_u) == 0: logger.debug('no peak over center') b2 = 0 status = 4 else: x_u, y_u = refine_peaks(-mm, g_idxs_u, window_width=wfit) # Select the peak with max derivative if len(x_u) == 0 or len(y_u) == 0: logger.warning("no 1st peak found after refine") b2 = 0 status = 4 else: idmax = y_u.argmax() b2 = x_u[idmax] b2val = y_u[idmax] logger.debug('main border in %f', slicey.start + b2) # peaks on the left npeaks_t = len(idxs_t) if npeaks_t == 0: # This is a problem, no peak on the left b1 = 0 logger.debug('no top border found') status = 40 + status else: g_idxs_t = idxs_t[idxs_t <= ref_pcentery] if len(g_idxs_t) == 0: logger.debug('no peak under center') b1 = 0 status = 40 + status else: x_t, y_t = refine_peaks(mm, g_idxs_t, window_width=wfit) # Select the peak with max derivative if len(x_t) == 0 or len(y_t) == 0: logger.warning("no 2nd peak found after refine") b1 = 0 status = 40 + status else: idmax = y_t.argmax() b1 = x_t[idmax] b1val = y_t[idmax] logger.debug('second border in %f', slicey.start + b1) return slicey.start + b1, slicey.start + b2, status
def char_bar_height(arr_deriv_alt, xpos1, xpos2, centery, threshold, wh=35, wfit=3): logger = logging.getLogger('emir.recipes.bardetect') pcentery = coor_to_pix_1d(centery) slicey = slice_create(pcentery, wh, start=1, stop=2047) ref_pcentery = pcentery - slicey.start mm = arr_deriv_alt[slicey, xpos1:xpos2 + 1].mean(axis=-1) idxs_t = find_peaks_indexes(mm, window_width=3,threshold=threshold) idxs_u = find_peaks_indexes(-mm, window_width=3,threshold=threshold) # Peaks on the right status = 0 npeaks_u = len(idxs_u) if npeaks_u == 0: # This is a problem, no peak on the right b2 = 0 status = 4 logger.debug('no bottom border found') else: # Filter over reference g_idxs_u = idxs_u[idxs_u >= ref_pcentery] if len(g_idxs_u) == 0: logger.debug('no peak over center') b2 = 0 status = 4 else: x_u, y_u = refine_peaks(-mm, g_idxs_u, window_width=wfit) # Select the peak with max derivative if len(x_u) == 0 or len(y_u) == 0: logger.warning("no 1st peak found after refine") b2 = 0 status = 4 else: idmax = y_u.argmax() b2 = x_u[idmax] b2val = y_u[idmax] logger.debug('main border in %f', slicey.start + b2) # peaks on the left npeaks_t = len(idxs_t) if npeaks_t == 0: # This is a problem, no peak on the left b1 = 0 logger.debug('no top border found') status = 40 + status else: g_idxs_t = idxs_t[idxs_t <= ref_pcentery] if len(g_idxs_t) == 0: logger.debug('no peak under center') b1 = 0 status = 40 + status else: x_t, y_t = refine_peaks(mm, g_idxs_t, window_width=wfit) # Select the peak with max derivative if len(x_t) == 0 or len(y_t) == 0: logger.warning("no 2nd peak found after refine") b1 = 0 status = 40 + status else: idmax = y_t.argmax() b1 = x_t[idmax] b1val = y_t[idmax] logger.debug('second border in %f', slicey.start + b1) return slicey.start + b1, slicey.start + b2, status