def efficiency_analysis(features): im = features['im_no_fingers'] im_peaks = features['im_norm'][features['_peak_row_nums'], :] bbs = features['_busbar_cols'] # make sure no zero values im_peaks = im_peaks.copy() pixel_ops.ApplyThresholdLT_F32(im_peaks, im_peaks, 0.01, 0.01) im = im.copy() pixel_ops.ApplyThresholdLT_F32(im, im, 0.01, 0.01) # IDEA: # two defect mask: # 1. existing one (highlights anything dark) # 2. do a dark line (local mins). mask out & interpolate. # this one won't pick up grain boundaries # - slider blends between them ################# # DEFECT MASK 1 # ################# # - very sensitive to all dark areas # need to interpolate values along edges/busbars so defects in these regions can be found xs = np.arange(im_peaks.shape[0]) cols = [features['cell_edge_left'], features['cell_edge_right']] cols += list(np.where(features['mask_busbar_edges'][0, :])[0]) for c in cols: ys = im_peaks[:, c].copy() ys[ys > features['_bright_area_thresh']] = features['_bright_area_thresh'] params_op = optimize.fmin_powell(line_error, [0.0, ys.mean()], disp=0, args=(xs, ys), xtol=0.05, ftol=0.05) vals = xs * params_op[0] + params_op[1] im_peaks[:, c] = vals if False: print features['_bright_area_thresh'] mask = np.zeros_like(im, np.uint8) mask[:, c] = 1 ImageViewer(ip.overlay_mask(im, mask)) plt.figure() plt.plot(ys) plt.plot(vals) plt.show() # max of actual val and: interpolate vertical line at: # - left & right edge # - left & right of each BB # make monotonic (don't care about local mins) bb_mono = between_bb_mono(im_peaks, bbs) background1 = bb_mono background1 = cv2.GaussianBlur(background1, ksize=(0, 0), sigmaX=3, borderType=cv2.BORDER_REPLICATE) # relative difference foreground1 = background1 / im_peaks foreground1 -= 1 pixel_ops.ClipImage(foreground1, 0, 3.0) foreground1[:, features['mask_busbar_filled'][0, :]] = 0 # expand to full size full_size = np.zeros(im.shape, np.float32) pixel_ops.ExpandFingers(full_size, foreground1, features['_peak_row_nums']) foreground1 = full_size background_full = np.zeros(im.shape, np.float32) pixel_ops.ExpandFingers(background_full, background1, features['_peak_row_nums']) if False: view = ImageViewer(im) ImageViewer(foreground1) ImageViewer(background1) view.show() ################# # DEFECT MASK 2 # ################# # - less likely to include dark grains # - mask out local mins and areas of high gradient, and the interpolate background flatten_cols = np.r_[im.mean(axis=0)] im_flattened = im - flatten_cols flatten_rows = np.c_[im_flattened.mean(axis=1)] im_flattened -= flatten_rows im_flattened[features['mask_busbar_filled']] = 0 im_smoothed = cv2.GaussianBlur(im_flattened, ksize=(0, 0), sigmaX=2) # local mins dark_lines = np.zeros_like(im_flattened, np.uint8) pixel_ops.LocalMins(im_smoothed, dark_lines) s = ndimage.generate_binary_structure(2, 1) dark_lines = ndimage.binary_dilation(dark_lines, structure=s) # high gradient edgesH = cv2.Sobel(im_smoothed, cv2.CV_32F, 1, 0) edgesV = cv2.Sobel(im_smoothed, cv2.CV_32F, 0, 1) edges = cv2.magnitude(edgesH, edgesV) # combine defect_candidates = ((edges > 0.2) | dark_lines) if False: view = ImageViewer(im_flattened) ImageViewer(ip.overlay_mask(im_flattened, dark_lines)) ImageViewer(ip.overlay_mask(im_flattened, edges > 0.2)) ImageViewer(ip.overlay_mask(im_flattened, defect_candidates)) view.show() sys.exit() background2 = interpolate_background(im_flattened, defect_candidates.astype(np.uint8)) background2 += flatten_rows background2 += flatten_cols # relative difference foreground2 = background2 / im foreground2 -= 1 pixel_ops.ClipImage(foreground2, 0, 3.0) foreground2[features['mask_busbar_filled']] = 0 if False: view = ImageViewer(im) ImageViewer(background2) ImageViewer(foreground2) view.show() sys.exit() if False: features['_defect1'] = foreground1 features['_defect2'] = foreground2 # discrimination function x1, y1 = 0.0, 0.5 x2, y2 = 0.4, 0.0 foreground = (-1 * ((y2 - y1) * foreground2 - (x2 - x1) * foreground1 + x2 * y1 - y2 * x1) / np.sqrt((y2 - y1)**2 + (x2 - x1)**2)) foreground += 0.1 + parameters.CELL_DISLOCATION_SENSITIVITY foreground *= 0.25 pixel_ops.ClipImage(foreground, 0, 1) features['ov_dislocations_u8'] = (foreground * 255).astype(np.uint8) if False: view = ImageViewer(im) ImageViewer(foreground1) ImageViewer(foreground2) ImageViewer(foreground) #ImageViewer(background_full) # ImageViewer(foreground > 0.2) view.show() sys.exit() ################ # IMPURE AREAS # ################ def FindImpure(imp_profile, imp_profile_r, defects, debug=False): if False: ImageViewer(im) plt.figure() plt.plot(imp_profile) plt.plot(defects) plt.show() imp_ratio = (imp_profile / imp_profile_r).astype(np.float32) imp_ratio[imp_ratio > 0.9] = 0.9 imp_ratio /= 0.9 global_min = np.argmin(imp_ratio) local_mins = np.where((imp_ratio < np.roll(imp_ratio, 1)) & (imp_ratio < np.roll(imp_ratio, -1)))[0] # make monotonic from global minimum imp_mono = imp_ratio.copy() flip = False if global_min > len(imp_mono) // 2: flip = True imp_mono = imp_mono[::-1] global_min = np.argmin(imp_mono) rest = np.ascontiguousarray(imp_mono[global_min:]) rest_mono = np.empty_like(rest) pixel_ops.MakeMonotonic(rest, rest_mono) imp_mono[global_min:] = rest_mono # if edge_dist < 0.075: # imp_mono[:global_min] = imp_ratio[global_min] if flip: imp_mono = imp_mono[::-1] global_min = np.argmin(imp_mono) # for a real impure area, the global minimum should be close to an edge edge_dist = min(global_min, len(imp_ratio) - global_min) / float(len(imp_ratio)) edge_spot = int(0.03 * len(imp_mono)) imp_at_edge = min(imp_mono[edge_spot], imp_mono[-edge_spot]) imp_1d = np.ones_like(imp_mono) # check the defect content in the "impure" area if (imp_mono < 1.0).sum() == 0: defect_strength = 0 else: # defect_strength = defects[imp_mono < 1.0].mean() defect_strength = np.median(defects[imp_mono < 1.0]) if (edge_dist < 0.075 and # lowest point close to edge imp_at_edge < 0.8 and # edge is dark defect_strength < 0.1 and # not too many defects # (global_min == local_mins[0] or global_min == local_mins[-1]) and # no local mins closer to edge (imp_mono - imp_ratio).mean() < 0.035): # no large non-impure dips imp_1d = imp_mono.copy() imp_1d -= 0.3 if global_min < len(imp_profile) // 2: imp_1d[:global_min] = imp_1d[global_min] else: imp_1d[global_min:] = imp_1d[global_min] if debug: print edge_dist, edge_dist < 0.075 print imp_at_edge, imp_at_edge < 0.8 print defect_strength, defect_strength < 0.1 # print global_min, local_mins[0], (global_min == local_mins[0] or global_min == local_mins[-1]) print(imp_mono - imp_ratio).mean(), (imp_mono - imp_ratio).mean() < 0.035 ImageViewer(im) plt.figure() plt.plot(imp_profile, 'r') plt.plot(imp_mono, 'g') plt.plot(imp_ratio, 'b') # plt.plot((0, len(signal_var)), (0.1, 0.1)) plt.plot(defects, 'c') plt.plot(imp_1d, 'c') plt.show() # find impure edge width THRESH = 0.5 if imp_1d[0] < THRESH: edge_width = np.where(imp_1d < THRESH)[0][-1] / float( len(imp_profile)) left = True elif imp_1d[-1] < THRESH: edge_width = (len(imp_profile) - np.where(imp_1d < THRESH)[0][0]) / float( len(imp_profile)) left = False else: edge_width = 0 left = True return imp_1d, edge_width, left if False: # ignore defect areas defect_mask = foreground > 0.2 mx = ma.masked_array(im, mask=defect_mask) if False: view = ImageViewer(im) ImageViewer(defect_mask) view.show() ''' # left/right edges cols = np.apply_along_axis(stats.scoreatpercentile, 0, im, per=75) cols[cols > 1.0] = 1.0 imp_profile = ndimage.gaussian_filter1d(cols, sigma=3, mode="nearest") imp_profile_r = imp_profile[::-1] if len(bbs) >= 2: mid = (bbs[0] + bbs[-1]) // 2 else: mid = im.shape[1] // 2 imp_profile_r = np.roll(imp_profile_r, mid - (len(imp_profile) // 2)) col_defect = foreground.mean(axis=0) imp_h, ew_h, e_left = FindImpure(imp_profile, imp_profile_r, col_defect, debug=False) ''' # top/bottom edges rows = np.apply_along_axis(stats.scoreatpercentile, 1, im, per=75) rows[rows > 1.0] = 1.0 imp_profile = ndimage.gaussian_filter1d(rows, sigma=3, mode="nearest") imp_profile_r = imp_profile[::-1] row_defect = foreground.mean(axis=1) imp_v, ew_v, e_top = FindImpure(imp_profile, imp_profile_r, row_defect, debug=False) features['impure_edge_width'] = ew_v if e_top: features['impure_edge_side'] = 0 else: features['impure_edge_side'] = 2 impure = np.ones_like(im) impure[:, :] = np.c_[imp_v] if False: print features['impure_edge_width'], features['impure_edge_side'] view = ImageViewer(impure) view.show() sys.exit() imp_cutoff = 0.55 pixel_ops.ApplyThresholdGT_F32(impure, impure, imp_cutoff, imp_cutoff) impure /= imp_cutoff impure_overlay = np.log10(2 - impure) if False: plt.figure() plt.plot(impure[:, 0], 'r') plt.plot(np.log(impure[:, 0] + 1), 'g') plt.plot(np.log10(impure[:, 0] + 1), 'b') plt.show() view = ImageViewer(impure) view.show() pixel_ops.ClipImage(impure_overlay, 0, 1) features['ov_impure2_u8'] = (impure_overlay * 255).astype(np.uint8) ########### # METRICS # ########### num_pixels = im.shape[0] * im.shape[1] # impure impure_thresh = 0.9 # 0.8 dislocation_thresh = 0.1 num_impure_pixels = pixel_ops.CountThresholdLT_F32(impure, impure_thresh) features['impure_area_fraction'] = (num_impure_pixels / float(num_pixels)) if features['impure_area_fraction'] > 0.001: pure_mask = (impure > impure_thresh) & (foreground < dislocation_thresh) features['impure_strength'] = (im[pure_mask].mean() / im[impure < impure_thresh].mean()) - 1 else: features['impure_strength'] = 0 features['impure_area_fraction'] = 0 features['impure_strength2'] = features['impure_strength'] * features[ 'impure_area_fraction'] * 100 # dislocations num_dislocations = pixel_ops.CountThresholdGT_F32(foreground, dislocation_thresh) features['dislocation_area_fraction'] = (num_dislocations / float(num_pixels)) features['_foreground'] = foreground features['_dislocation_thresh'] = dislocation_thresh features['_impure'] = impure features['_impure_thresh'] = impure_thresh # find the average distance between dislocation pixels ys, xs = np.where(foreground > dislocation_thresh) points = np.c_[ys, xs] num_samples = 1500 if len(ys) > 0: points = points[::max(1, points.shape[0] // num_samples), :] pixel_dists = distance.pdist(points) avg_dist = np.mean(pixel_dists) avg_dist = (avg_dist - 0.3 * im.shape[0]) / (0.5 * im.shape[0]) else: avg_dist = 0 features['dislocation_density'] = 1.0 - avg_dist if len(ys) > 0: dis_vals = foreground[ys, xs] dislocation_strength = math.sqrt((dis_vals**2).mean()) features['dislocation_severity_A'] = dislocation_strength # create a second defect strength. ratio2 = background_full / im ratio2 = np.clip(ratio2, 1, 5) ratio2[:, features['mask_busbar_filled'][0, :]] = 1 features['dislocation_severity_B'] = ratio2[ys, xs].mean() if False: view = ImageViewer(background_full) ImageViewer(im) ImageViewer(ratio2) view.show() else: features['dislocation_severity_A'] = 0 features['dislocation_severity_B'] = 0 if False: view = ImageViewer(im) foreground[foreground < 0] = 0 ImageViewer(foreground) ImageViewer(background_full) view.show() sys.exit() # dislocation histogram features foreground_bins = np.zeros((5), np.float32) pixel_ops.BackgrounHistogram(foreground, foreground_bins) foreground_bins = (foreground_bins / num_pixels) * 100 features['dislocation_hist_01'] = foreground_bins[0] features['dislocation_hist_02'] = foreground_bins[1] features['dislocation_hist_03'] = foreground_bins[2] features['dislocation_hist_04'] = foreground_bins[3] features['dislocation_hist_05'] = foreground_bins[4] features['dislocation_strength'] = features[ 'dislocation_area_fraction'] * features['dislocation_severity_A'] if False: # print features['foreground_hist_01'], features['foreground_hist_02'], features['foreground_hist_03'], # print features['foreground_hist_04'], features['foreground_hist_05'] view = ImageViewer(im) ImageViewer(foreground) ImageViewer(impure) ImageViewer(create_overlay(features)) view.show()
def firing_defects(features): im = features['im_norm'] finger_rows = features['_finger_row_nums'] # im_fingers = features['_finger_im'] im_smooth = cv2.GaussianBlur(im, ksize=(0, 0), sigmaX=1) im_fingers = im_smooth[finger_rows, :] if False: view = ImageViewer(im) # view = ImageViewer(im_smooth) ImageViewer(im_fingers) view.show() sys.exit() # find depth of local minimums S = 5 dips = np.minimum(np.roll(im_fingers, S, axis=1), np.roll(im_fingers, -S, axis=1)) - im_fingers pixel_ops.ApplyThresholdLT_F32(dips, dips, 0, 0) dips[:, features['mask_busbar_filled'][0, :]] = 0 dips[:, :features['cell_edge_left']] = 0 dips[:, features['cell_edge_right']:] = 0 # TODO: add upper bound as well locs = ((im_fingers < np.roll(im_fingers, 1, axis=1)) & (im_fingers < np.roll(im_fingers, -1, axis=1)) & (dips > 0.02) & (dips < 0.05)).astype(np.float32) # count num dips in a region. ignore areas with only 1 w = im.shape[1] // 10 weights = np.ones(w, np.int32) local_count = ndimage.convolve1d(locs, weights, axis=1, mode="constant") dips_filtered = dips.copy() dips_filtered[local_count <= 1] = 0 if False: view = ImageViewer(im) ImageViewer(dips) # ImageViewer(locs) # ImageViewer(local_count) # ImageViewer(dips_filtered) view.show() im_dots = cv2.GaussianBlur(dips_filtered, ksize=(0, 0), sigmaX=10, sigmaY=2) # im_dots -= 0.001 if False: view = ImageViewer(dips_filtered) view = ImageViewer(im_dots) view.show() splotch = np.empty_like(im) pixel_ops.ExpandFingers(splotch, im_dots, finger_rows) splotch = ip.fast_smooth(splotch, sigma=10) features["_firing"] = splotch.copy() splotch *= 100.0 * (1.0 + parameters.FIRING_SENSITIVITY) pixel_ops.ClipImage(splotch, 0.0, 1.0) pixel_ops.ApplyThresholdGT_F32(features['im_center_dist_im'], splotch, features['wafer_radius'], 0) features["ov_splotches_u8"] = (splotch * 255).astype(np.uint8) # metrics if splotch.max() >= 0.2: features['firing_area_strength'] = splotch.mean() * 100 mask_firing = (splotch > 0.2).astype(np.uint8) im_pl = features['_cropped_f32'] firingPL = pixel_ops.MaskMean_F32(im_pl, mask_firing, 1) goodPL = pixel_ops.MaskMean_F32(im_pl, mask_firing, 0) features['firing_area_mean_PL'] = firingPL features['firing_area_fraction'] = mask_firing.mean() features['firing_area_PL_intensity_ratio'] = firingPL / max(1, goodPL) else: features['firing_area_strength'] = 0.0 features['firing_area_mean_PL'] = 0.0 features['firing_area_fraction'] = 0.0 features['firing_area_PL_intensity_ratio'] = 0.0 if False: print features['firing_area_strength'] view = ImageViewer(im) ImageViewer(splotch, vmin=0, vmax=1) ImageViewer(mask_firing) f2 = {'im_cropped_u8': features['im_cropped_u8'], 'ov_splotches_u8': features['ov_splotches_u8']} ImageViewer(create_overlay(f2)) view.show() sys.exit()
def finger_shape(features): if 'DEBUG' in features: DEBUG = features['DEBUG'] else: DEBUG = False # use an image that has been normalised to [0, 1] im = features['_cropped_f32'] / features['hist_percentile_99.9'] if parameters.CELL_BB_MID_POINTS: locs = np.round((features['_busbar_cols'][:-1] + features['_busbar_cols'][1:]) / 2.0).astype(np.int32) pixel_ops.InterpolateBBs(im, locs, 3) im_finger = im[features['_peak_row_nums']] # firing = np.zeros_like(im_finger) if False: view = ImageViewer(im) ImageViewer(im_finger) plt.figure() plt.plot(im_finger.mean(axis=0)) view.show() sys.exit() TRAINING_MODE = False if TRAINING_MODE: import os fn = "finger_shape.csv" # bb_locs = features['_busbar_cols'] bb_locs = np.r_[0, features['_busbar_cols'], im.shape[1] - 1] with open(fn, 'a') as f: def on_click(event): tb = plt.get_current_fig_manager().toolbar if event.xdata is None: return if tb.mode != '': print 'Not in click mode - turn of pan or zoom' return if event.button == 1: classification = "good" elif event.button == 3: classification = "bad" else: return y = round(event.ydata) x = int(round(event.xdata)) i = np.searchsorted(bb_locs, x) left, right = bb_locs[i - 1], bb_locs[i] assert left < x < right vals = im_finger[y, left:right] if x < im_finger.shape[1] // 2: vals = vals[::-1] plt.figure() plt.plot(vals) plt.show() valstr = ','.join(["%0.02f" % (v) for v in vals]) f.write("%s,%s\n" % (classification, valstr)) fig = plt.figure() fig.canvas.mpl_connect('button_press_event', on_click) plt.imshow(im_finger, cmap=plt.cm.gray, interpolation='nearest') plt.show() return if len(features['_busbar_cols']) > 1: bb_locs = features['_busbar_cols'] else: # only 1 busbar, so add left and right edges bb_locs = np.r_[0, features['_busbar_cols'], im.shape[1] - 1] S = 15 # analyse each finger independently peak_broken = [] peak_fine = [] finger_rs = [] finger_maes = [] if False: locs = [] for bb in range(len(bb_locs) - 1): locs.append((bb_locs[bb] + bb_locs[bb + 1]) // 2) im_finger2 = im_finger.copy() pixel_ops.InterpolateBBs(im_finger2, np.array(locs, np.int32), 4) view = ImageViewer(im_finger) ImageViewer(im_finger2) view.show() im_finger = im_finger2 for bb in range(len(bb_locs) - 1): segment = im_finger[:, bb_locs[bb] + S:bb_locs[bb + 1] - S] if segment.shape[1] == 0: continue xs = np.linspace(-1.0, 1.0, num=segment.shape[1]) for y in range(5, segment.shape[0] - 5): # fit a quadratic curve bbb = segment[y, :] params = np.polyfit(xs, bbb, 2) f = np.poly1d(params) ys = f(xs) # calculate the mean absolute error between the actual pixel values and the fitted parabola mae = np.abs(ys - bbb).mean() / bbb.mean() sigmoid = expit((mae - 0.02) / 0.001) # save curevature & goodness of fit finger_rs.append(params[0] * -1) finger_maes.append(mae) if sigmoid > 0.7: peak_broken.append(bbb.max()) elif sigmoid < 0.3: peak_fine.append(bbb.max()) # if True and bb == 0 and y == 5: if False and sigmoid > 0.7: print mae, sigmoid print bb, y im_fin = im_finger.copy() im_fin[y - 2, bb_locs[bb] + S:bb_locs[bb + 1] - S] = 0 im_fin[y + 2, bb_locs[bb] + S:bb_locs[bb + 1] - S] = 0 ImageViewer(im_fin) plt.figure() plt.plot(xs, bbb, label="x-profile") plt.plot(xs, ys, label="Fitted parabola") plt.legend() plt.show() if len(finger_rs) > 0: features['resistance_finger'] = np.median(finger_rs) features['resistance_finger_error'] = np.median(finger_maes) else: features['resistance_finger'] = 0 features['resistance_finger_error'] = 0 if len(peak_broken) > 0 or len(peak_fine) > 0: range_min = np.array(peak_broken + peak_fine).min() range_max = np.array(peak_broken + peak_fine).max() range_vals = np.linspace(range_min, range_max, num=100) peak_broken = np.array(peak_broken) peak_fine = np.array(peak_fine) broken_percent = peak_broken.shape[0] * 100 / float(peak_broken.shape[0] + peak_fine.shape[0]) features['fingers_non_para'] = broken_percent # compute distribution of peak vals of bad fingers bad_fingers_dist = None bad_mode = None if len(peak_broken) > 5: f_bad_fingers = stats.gaussian_kde(peak_broken) bad_fingers_dist = f_bad_fingers(range_vals) bad_maxs = np.where((bad_fingers_dist > np.roll(bad_fingers_dist, 1)) & (bad_fingers_dist > np.roll(bad_fingers_dist, -1)) & (bad_fingers_dist > 2.0))[0] if len(bad_maxs) > 0: bad_mode = range_vals[bad_maxs[np.argmax(bad_fingers_dist[bad_maxs])]] # compute distribution of peak vals of good fingers good_fingers_dist = None good_maxs = [] good_mode, good_mode_i = None, None if len(peak_fine) > 5: f_good_fingers = stats.gaussian_kde(peak_fine) good_fingers_dist = f_good_fingers(range_vals) good_maxs = np.where((good_fingers_dist > np.roll(good_fingers_dist, 1)) & (good_fingers_dist > np.roll(good_fingers_dist, -1)) & (good_fingers_dist > 2))[0] if len(good_maxs) > 0: good_mode_i = good_maxs[np.argmax(good_fingers_dist[good_maxs])] good_mode = range_vals[good_mode_i] if False: ImageViewer(im_finger) plt.figure() if good_fingers_dist is not None: plt.plot(range_vals, good_fingers_dist, 'g') if bad_fingers_dist is not None: plt.plot(range_vals, bad_fingers_dist, 'b') plt.show() sys.exit() if broken_percent >= 70: if DEBUG: print "0" # lots of broken, use fixed threshold threshold = 0.7 elif broken_percent >= 33 and (good_mode is None or bad_mode < good_mode): if DEBUG: print "1" # significant broken and "non-broken" fingers are brighter than broken ones threshold = 0.7 elif len(good_maxs) >= 2: # 2+ peaks in good dist. # - perhaps some good fingers are being classified as bad if broken_percent < 30 and (bad_mode is None or good_mode < bad_mode): if DEBUG: print "2" # mostly good and broken fingers brighter # - use the highest peak i = good_mode_i while True: if (good_fingers_dist[i] < 0.5 or i == good_fingers_dist.shape[0] - 1 or (good_fingers_dist[i] < good_fingers_dist[i + 1] and good_fingers_dist[i] < 3)): break i += 1 threshold = range_vals[i] elif broken_percent < 20 and bad_mode is not None and bad_mode < good_mode: if DEBUG: print "2B" # mostly good but broken fingers darker # - use the highest peak threshold = (range_vals[good_maxs[-2]] + range_vals[good_maxs[-1]]) / 2.0 elif bad_mode is not None: if DEBUG: print "3" # quite a few bad, or broken fingers darker # - use first peak i = good_maxs[0] while True: if (good_fingers_dist[i] < 0.5 or i == good_fingers_dist.shape[0] - 1 or (good_fingers_dist[i] < good_fingers_dist[i + 1] and good_fingers_dist[i] < 3)): break i += 1 threshold = min(range_vals[i], bad_mode - 0.1) else: threshold = good_mode elif (broken_percent <= 33 >= 1 and (bad_mode is None or good_mode < bad_mode) or broken_percent < 10) and len(good_maxs): # - majority good fingers, single peak & broken fingers (if they exist) are brighter # - base the treshold on the distribution of good finger peaks if DEBUG: print "4" # find main mode in good dist i = good_maxs[0] while True: if (good_fingers_dist[i] < 0.5 or i == good_fingers_dist.shape[0] - 1 or (good_fingers_dist[i] < good_fingers_dist[i + 1] and good_fingers_dist[i] < 3)): break i += 1 threshold = min(range_vals[good_maxs[-1]] + 0.2, range_vals[i]) else: if broken_percent > 33: # roughly 50/50. broken fingers are brighter # - use middle between good & bad if DEBUG: print "5" threshold = (good_mode + bad_mode) / 2.0 else: if DEBUG: print "6" # majority good. assume the "bad" ones aren't actually bad if good_mode_i is not None: i = good_mode_i else: i = np.argmax(good_fingers_dist) while True: if (good_fingers_dist[i] < 0.5 or i == good_fingers_dist.shape[0] - 1 or (good_fingers_dist[i] < good_fingers_dist[i + 1] and good_fingers_dist[i] < 3)): break i += 1 threshold = range_vals[i] else: threshold = 1.0 threshold -= parameters.BRIGHT_AREA_SENSITIVITY if False: print "Percent broken: ", broken_percent print "Threshold:", threshold view = ImageViewer(im) plt.figure() m1, m2 = 0, 0 if good_fingers_dist is not None: plt.plot(range_vals, good_fingers_dist, 'g', label="Not broken") m1 = good_fingers_dist.max() if bad_fingers_dist is not None: plt.plot(range_vals, bad_fingers_dist, 'r', label="Broken") m2 = bad_fingers_dist.max() plt.vlines(threshold, 0, max(m1, m2)) plt.legend() view.show() # highlight areas brighter than threshold # features['bright_line_threshold'] = threshold if threshold < 1.0: bright_lines = (im[features['_peak_row_nums']] - threshold) / (1.0 - threshold) else: bright_lines = np.zeros_like(im_finger) bright_lines *= 0.5 pixel_ops.ClipImage(bright_lines, 0, 1) # don't want to highlight single lines, so apply vertical median filter rows_filtered = np.zeros_like(bright_lines) pixel_ops.FilterV(bright_lines, rows_filtered) rows_filtered[:2, :] = bright_lines[:2, :] rows_filtered[-2:, :] = bright_lines[-2:, :] if False: view = ImageViewer(im_finger) ImageViewer(bright_lines) ImageViewer(rows_filtered) view.show() sys.exit() bright_lines = rows_filtered # create a full size image of bright areas bright_area_full = np.zeros_like(im) pixel_ops.ExpandFingers(bright_area_full, bright_lines, features['_peak_row_nums']) bright_area_full = cv2.GaussianBlur(bright_area_full, sigmaX=3, ksize=(0, 0)) bright_u8 = (bright_area_full * 255).astype(np.uint8) if 'ov_bright_area_u8' in features: assert False # features['ov_bright_area_u8'] = np.maximum(bright_u8, features['ov_bright_area_u8']) else: features['ov_bright_area_u8'] = bright_u8 features['bright_area_strength'] = bright_lines.mean() * 100 # bright area metrics mask_bright = (bright_area_full > 0.1).astype(np.uint8) im_pl = features['_cropped_f32'] brightPL = pixel_ops.MaskMean_F32(im_pl, mask_bright, 1) darkPL = pixel_ops.MaskMean_F32(im_pl, mask_bright, 0) features['bright_area_mean_PL'] = brightPL features['bright_area_fraction'] = mask_bright.mean() features['bright_area_PL_intensity_ratio'] = brightPL / max(1, darkPL) # firing problems # firing_full = np.zeros_like(im) # pixel_ops.ExpandFingers(firing_full, firing, features['_peak_row_nums']) if False: view = ImageViewer(im_finger) ImageViewer(bright_area_full) # view = ImageViewer(firing_full) ImageViewer(features['ov_bright_area_u8']) view.show() sys.exit()
def dark_areas(features): # dark areas (not dark spots) im = features['im_norm'] h, w = im.shape row_nums = features['_peak_row_nums'] cell_mask = features['bl_cropped_u8'][row_nums, :] bb_locs = features['_busbar_cols'] # fill edges & corners foreground = im[row_nums].copy() edge = features['cell_edge_tb'] rr, cc = draw.circle_perimeter(features['wafer_middle_y'], features['wafer_middle_x'], int(round(features['wafer_radius'])) - edge) mask = (cc >= 0) & (cc < w) & np.in1d(rr, row_nums) lut = np.zeros(h, np.int32) lut[row_nums] = np.arange(len(row_nums)) rr = rr[mask] cc = cc[mask] rr = np.take(lut, rr) pixel_ops.FillCorners(foreground, rr.astype(np.int32), cc.astype(np.int32)) foreground[:, :edge] = np.c_[foreground[:, edge]] foreground[:, -edge:] = np.c_[foreground[:, -edge]] # create background # 1. make monotonic between edges & BBs mono_lr = np.empty_like(foreground) mono_rl = np.empty_like(foreground) pixel_ops.MakeMonotonicBBs(foreground, mono_lr, bb_locs) pixel_ops.MakeMonotonicBBs(np.ascontiguousarray(foreground[:, ::-1]), mono_rl, np.ascontiguousarray(w - bb_locs[::-1])) mono_rl = mono_rl[:, ::-1] mono = np.minimum(mono_lr, mono_rl) background = mono da1 = background - foreground # fill BBs and flatten background2 = background.copy() pixel_ops.InterpolateBBs(background2, features['_busbar_cols'], features['busbar_width']) cols = background2.mean(axis=0) background2 -= np.r_[cols] rows = background2.mean(axis=1) background2 -= np.c_[rows] da2 = -1 * background2 pixel_ops.ApplyThresholdLT_F32(da2, da2, 0.0, 0.0) if False: view = ImageViewer(foreground) ImageViewer(background) ImageViewer(background2) ImageViewer(da1) ImageViewer(da2) ImageViewer(da1 + da2) # plt.figure() # for x in range(0, background.shape[1], 50): # plt.plot(background[:, x], label="Col %d"%(x)) # plt.legend() view.show() sys.exit() dark_areas = da1 + da2 dark_areas -= (0.1 - parameters.DARK_AREA_SENSITIVITY) dark_areas[(cell_mask == 1) | (cell_mask == 8)] = 0 # corners pixel_ops.ClipImage(dark_areas, 0.0, 1.0) dark_areas_full = np.empty_like(im) pixel_ops.ExpandFingers(dark_areas_full, dark_areas, features['_peak_row_nums']) if False: pixel_ops.ApplyThresholdGT_F32(features['im_center_dist_im'], dark_areas_full, features['wafer_radius'], 0) print features['wafer_radius'] view = ImageViewer(dark_areas) ImageViewer(dark_areas_full) ImageViewer(features['im_center_dist_im']) view.show() dark_areas_full = cv2.GaussianBlur(dark_areas_full, ksize=(0, 0), sigmaX=1) # metrics mask_dark = (dark_areas_full > 0.2).astype(np.uint8) features['dark_area_strength'] = dark_areas_full.mean() * 100 im_pl = features['_cropped_f32'] darkPL = pixel_ops.MaskMean_F32(im_pl, mask_dark, 1) brightPL = pixel_ops.MaskMean_F32(im_pl, mask_dark, 0) features['dark_area_mean_PL'] = darkPL features['dark_area_fraction'] = mask_dark.mean() features['dark_area_PL_intensity_ratio'] = brightPL / max(1, darkPL) features['ov_dark_areas_u8'] = (dark_areas_full * 255).astype(np.uint8) if False: print features['dark_area_fraction'], features['dark_area_strength'] # plt.figure() # plt.plot(cols) # plt.plot(cols_mono) view = ImageViewer(im) ImageViewer(foreground) ImageViewer(dark_areas) ImageViewer(mask_dark) ImageViewer(dark_areas_full) view.show()