def __init__(self, run_name, filename, window, stride, arguments, size=-1, start=0, test=False): # Create the two files using the preprocessing pipeline in_file, out_file = preprocess(run_name, filename, arguments.split(','), test=test) # Load the input waveform_in, _ = torchaudio.load(in_file) self.x = waveform_in[0] # Split it using the sliding window self.x = sliding_window(self.x, window, stride) # Only keep necessary samples self.x = self.x[start:start + size, None, :] # Load the output waveform_out, _ = torchaudio.load(out_file) self.y = waveform_out[0] # Split it using the sliding window self.y = sliding_window(self.y, window, stride) # Only keep necessary samples self.y = self.y[start:start + size, None, :]
def test_sliding_window(self): l = range(4) # print(l) it = sliding_window(l, 2, 1) targets = [c[1] for c in list(islice(sliding_window(l, 2, 1), 3))] # print targets self.assertEqual(targets, [[1,2],[2,3],[1,2]])
def getLaneCurve(img): imgCopy = img.copy() h, w, c = img.shape points = utils.valTrackbars() imgThres = utils.thresholding(img) # imgWarp = utils.warpImg(img, points, w, h) imgWarpThres = utils.warpImg(imgThres, points, w, h) imgWarpPoints = utils.drawPoints(imgCopy, points) imgLane = img.copy() # imgCanny = utils.canny(imgWarp) basePoint, imgHist = utils.getHistogram(imgWarpThres, display=True) imgSliding, curves, lanes, ploty = utils.sliding_window(imgWarpThres, draw_windows=True) curverad = utils.get_curve(imgLane, curves[0], curves[1]) lane_curve = np.mean([curverad[0], curverad[1]]) imgLane = utils.drawLanes(img, curves[0], curves[1], frameWidth, frameHeight, src=points) # print(round((lane_curve-84.41)/7.5,2)) imgStack = utils.stackImages( 0.6, ([img, imgWarpThres, imgWarpPoints], [imgHist, imgSliding, imgLane])) cv2.imshow('Stack', imgStack) return cv2.resize(imgStack, (2 * frameHeight, frameHeight))
def gen_hard_features(file, clf, downscale, min_hw=(128, 64), step_size=(10, 10), orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), normalize='L2-Hys'): img = imread(file, as_gray=True) feat_list = [] for im_scaled in pyramid_gaussian(img, downscale=downscale, multichannel=False): if im_scaled.shape[0] < min_hw[0] or im_scaled.shape[1] < min_hw[1]: break for (x, y, im_window) in sliding_window(im_scaled, min_hw, step_size): if im_window.shape[0] != min_hw[0] or im_window.shape[1] != min_hw[ 1]: continue features = hog(im_window, orientations, pixels_per_cell, cells_per_block, normalize) features = np.reshape(features, (1, -1)) pred = clf.predict(features) # dist = clf.decision_function(features) if pred == 1: feat_list.append(features) return feat_list
def print_score(): df = get_pure_cases_df() X, y = sliding_window(df, 28, 14) assert X.shape[0] == y.shape[0] X = X.numpy() y = y.numpy() mae = [] rmse = [] mape = [] for i in range(X.shape[0]): mae.append( mean_absolute_error(y[i], np.broadcast_to(X[i][-1], (y.shape[1], 1)))) rmse.append( mean_squared_error(y[i], np.broadcast_to(X[i][-1], (y.shape[1], 1)), squared=False)) mape.append( mean_absolute_percentage_error( y[i], np.broadcast_to(X[i][-1], (y.shape[1], 1)))) mae = np.array(mae) rmse = np.array(rmse) mape = np.array(mape) print(f"RMSE: {rmse.mean()}, MAE: {mae.mean()}, MAPE: {mape.mean()}")
def find_clumps_faster(genome: str, k: int, L: int, t: int) -> List[str]: """Find pattens forming (L, t)-clump Computational complexity: O(L * len(genome)) Clump (L, t) means that k-mers appear at least t times in a length-L window of a genome. >>> find_clumps_faster("CGGACTCGACAGATGTGAAGAACGACAATGTGAAGACTCGACACGACAGAGTGAAGAGAAGAGGAAACATTGTAA", 5, 50, 4) ['CGACA', 'GAAGA'] """ assert L <= len(genome) interval = genome[:L] kmer_counts = collections.Counter("".join(xs) for xs in sliding_window(interval, k)) res = {w for w, cnt in kmer_counts.items() if cnt >= t} offset = 0 while offset + L <= len(genome): w_out = genome[offset:offset + k] w_in = genome[offset + L - k + 1:offset + L + 1] kmer_counts[w_out] -= 1 kmer_counts[w_in] += 1 if kmer_counts[w_in] >= t: res.add(w_in) offset += 1 return sorted(res)
def main(): # Create TIF reader reader = TIFReader(args.file, args.level) # Load image and create tissue mask print("Loading image...", end='\r') wsi = reader.load_image() print("Loading image...Done.") # Get the sliding window and padding params windows, padding = utils.sliding_window( wsi.shape, (args.window_shape, args.window_shape)) # Pad the WSI wsi_padded = np.pad(wsi, ((0, padding['y']), (0, padding['x']), (0, 0)), mode='constant', constant_values=255) print("Segmenting tissue...", end='\r') tissue_mask = reader.segment_tissue(wsi_padded) print("Segmenting tissue...Done.") # Prediction tumor_map = predict_tumor_regions(wsi_padded, tissue_mask, windows) # Save np.save('figures/{}.npy'.format(args.file.split('.')[0]), tumor_map) cmapper = cm.get_cmap('plasma') colorized = Image.fromarray( np.uint8(cmapper(np.clip(tumor_map, 0, 1)) * 255)) colorized.save('figures/{}.tif'.format(args.file.split('.')[0]))
def detect(self, image): clone = image.copy() image = rgb2gray(image) # list to store the detections detections = [] # current scale of the image downscale_power = 0 # downscale the image and iterate for im_scaled in pyramid(image, downscale=self.downscale, min_size=self.window_size): # if the width or height of the scaled image is less than # the width or height of the window, then end the iterations if im_scaled.shape[0] < self.window_size[1] or im_scaled.shape[ 1] < self.window_size[0]: break for (x, y, im_window) in sliding_window(im_scaled, self.window_step_size, self.window_size): if im_window.shape[0] != self.window_size[ 1] or im_window.shape[1] != self.window_size[0]: continue # calculate the HOG features feature_vector = hog(im_window) X = np.array([feature_vector]) prediction = self.clf.predict(X) if prediction == 1: x1 = int(x * (self.downscale**downscale_power)) y1 = int(y * (self.downscale**downscale_power)) detections.append( (x1, y1, x1 + int(self.window_size[0] * (self.downscale**downscale_power)), y1 + int(self.window_size[1] * (self.downscale**downscale_power)))) # Move the the next scale downscale_power += 1 # Display the results before performing NMS clone_before_nms = clone.copy() for (x1, y1, x2, y2) in detections: # Draw the detections cv2.rectangle(clone_before_nms, (x1, y1), (x2, y2), (0, 255, 0), thickness=2) # Perform Non Maxima Suppression detections = non_max_suppression(np.array(detections), self.threshold) clone_after_nms = clone # Display the results after performing NMS for (x1, y1, x2, y2) in detections: # Draw the detections cv2.rectangle(clone_after_nms, (x1, y1), (x2, y2), (0, 255, 0), thickness=2) return clone_before_nms, clone_after_nms
def most_probable_kmer(text: str, k: int, profile: Profile) -> str: """Find the most likelihood kmer given probability distribution profile such that argmax_{kmer} P(kmer | profile) >>> text = "ACCTGTTTATTGCCTAAGTTCCGAACAAACCCAATATAGCCCGAGGGCCT" >>> profile = [[0.2, 0.2, 0.3, 0.2, 0.3], [0.4, 0.3, 0.1, 0.5, 0.1], [0.3, 0.3, 0.5, 0.2, 0.4], [0.1, 0.2, 0.1, 0.1, 0.2]] >>> most_probable_kmer(text, 5, profile) 'CCGAG' """ nuc2idx = dict(zip("ACGT", range(4))) assert len(profile) == 4 assert len(profile[0]) == k max_sofar = -1000 ans = None for kmer in sliding_window(text, k): indices = [nuc2idx[c] for c in kmer] iter = (ps[i] for i, ps in zip(indices, zip(*profile))) prob = functools.reduce(operator.mul, iter) if prob > max_sofar: max_sofar = prob ans = kmer if ans is None: raise ValueError("Something is wrong!") return "".join(ans)
def find_faces(model, imgs, threshold=None, step=WINDOW_STEP): '''Slide a window and find predictions that are over a threshold (or all if threshold is None)''' if threshold is None: threshold = -np.Inf rects_dict = {} scores_dict = {} for img_id, img in tqdm(imgs.items(), desc='Predicting faces'): rects = [] windows = [] for scale in SCALES: img_scaled = rescale(img, scale, multichannel=False) for rect, window in sliding_window(img_scaled, step=step): rect.scale(1 / scale) rects.append(rect) windows.append(window) rects = np.array(rects) features = [] for window in tqdm(windows, desc='Computing features'): features.append(features_extract_fn(window)) try: pred_proba = model.predict_proba(features)[:, 1] except AttributeError: pred_proba = model.decision_function(features) mask = pred_proba >= threshold rects_dict.update({img_id: rects[mask]}) scores_dict.update({img_id: pred_proba[mask]}) return remove_duplicate_rects(rects_dict, scores_dict)
def detect(self, img_name, image, stepSize=None, windowSize=None, scale=None, minSize=None): windowSize = windowSize if windowSize is not None else self.windowSize stepSize = stepSize if stepSize is not None else self.stepSize scale = scale if scale is not None else self.scale minSize = minSize if minSize is not None else self.minSize window_num = 0 polygons_metal = list() polygons_thatch = list() rects_metal = list() rects_thatch = list() #loop through pyramid for level, resized in enumerate(utils.pyramid(image, scale=scale, minSize=minSize)): for (x, y, window) in utils.sliding_window(resized, stepSize=stepSize, windowSize=windowSize): #self.debug_scaling(image, img_name, resized, x, y, level): # if the window does not meet our desired window size, ignore it if window.shape[0] != windowSize[0] or window.shape[1] != windowSize[1]: continue window_num += 1 #save the correctly translated coordinates of this window polygon, rectangle = self.get_translated_coords(x, y, level, scale, windowSize) polygons_metal.append(polygon) rects_metal.append(rectangle) polygons_thatch.append(polygon) rects_thatch.append(rectangle) self.total_window_num += window_num rects = {'thatch': rects_thatch, 'metal': rects_metal} polygons = {'thatch': polygons_thatch, 'metal': polygons_metal} return polygons, rects
def get_all_nonfaces(train_imgs, labels): '''Get all nonfaces images from sliding window of size BOX_SIZE''' for id, img in tqdm(train_imgs.items(), desc='Extracting all nonfaces'): for scale in SCALES: img_scaled = rescale(img, scale, multichannel=False) true_rects = [r.scale(scale) for r in labels[id]] for rect, window in sliding_window(img_scaled): rect.scale(1 / scale) if not rect.overlap(*true_rects, threshold=0.4): yield window
def frequent_words(text: str, k: int) -> Patterns: """ >>> frequent_words("ACTGACTCCCACCCC", 3) {'CCC': 3} """ counter = Counter("".join(chunk) for chunk in sliding_window(text, k)) max_count = max(counter.values()) res = {k: cnt for k, cnt in counter.items() if cnt == max_count} return res
def approx_pattern_matching(pattern: str, genome: str, d: int) -> List[int]: """Find locations of k-mer (pattern') in the genome with hamming_distance(pattern, pattern') <= d >>> approx_pattern_matching("ATTCTGGA", "CGCCCGAATCCAGAACGCATTCCCATATTTCGGGACCACTGGCCTCCACGGTACGGACGTCAATCAAAT", 3) [6, 7, 26, 27] """ intervals = sliding_window(genome, len(pattern)) return [ i for i, interval in enumerate(intervals) if hamming_distance(pattern, interval) <= d ]
def checkImage(image_file): image = cv2.imread(image_file) smoke_count = 0 window_count = 0 for (x, y, window) in sliding_window( image, stepSize, (winW, winH)): window_count = window_count + 1 prediction = classifier2.predict_proba( process_image(window, feature.getFeature))[0] if(prediction[1] >= threshold): smoke_count = smoke_count + 1 logger.info("%d smoke in %d widnows of %s." % ( smoke_count, window_count, os.path.basename(image_file)))
def test(net, img, hyperparams): """ Test a model on a specific image """ net.eval() patch_size = hyperparams['patch_size'] center_pixel = hyperparams['center_pixel'] batch_size, device = hyperparams['batch_size'], hyperparams['device'] n_classes = hyperparams['n_classes'] kwargs = { 'step': hyperparams['test_stride'], 'window_size': (patch_size, patch_size) } probs = np.zeros(img.shape[:2] + (n_classes, )) iterations = count_sliding_window(img, **kwargs) // batch_size for batch in tqdm(grouper(batch_size, sliding_window(img, **kwargs)), total=(iterations), desc="Inference on the image"): with torch.no_grad(): if patch_size == 1: data = [b[0][0, 0] for b in batch] data = np.copy(data) data = torch.from_numpy(data) else: data = [b[0] for b in batch] data = np.copy(data) data = data.transpose(0, 3, 1, 2) data = torch.from_numpy(data) # data = data.unsqueeze(1) # 3DConv时执行 indices = [b[1:] for b in batch] data = data.to(device) output = net(data) if isinstance(output, tuple): output = output[0] output = output.to('cpu') # 将cpu 改为 cuda if patch_size == 1 or center_pixel: output = output.numpy() else: output = np.transpose(output.numpy(), (0, 2, 3, 1)) for (x, y, w, h), out in zip(indices, output): if center_pixel: # probs[x, y] += out probs[x + w // 2, y + h // 2] += out # probs[x:x + w, y:y + h] += out else: probs[x:x + w, y:y + h] += out return probs
def test(net, img, hyperparams): """ Test a model on a specific image """ net.eval() patch_size = hyperparams["patch_size"] center_pixel = hyperparams["center_pixel"] batch_size, device = hyperparams["batch_size"], hyperparams["device"] n_classes = hyperparams["n_classes"] kwargs = { "step": hyperparams["test_stride"], "window_size": (patch_size, patch_size), } probs = np.zeros(img.shape[:2] + (n_classes,)) iterations = count_sliding_window(img, **kwargs) // batch_size for batch in tqdm( grouper(batch_size, sliding_window(img, **kwargs)), total=(iterations), desc="Inference on the image", ): with torch.no_grad(): if patch_size == 1: data = [b[0][0, 0] for b in batch] data = np.copy(data) data = torch.from_numpy(data) else: data = [b[0] for b in batch] data = np.copy(data) data = data.transpose(0, 3, 1, 2) data = torch.from_numpy(data) data = data.unsqueeze(1) indices = [b[1:] for b in batch] data = data.to(device) output = net(data) if isinstance(output, tuple): output = output[0] output = output.to("cpu") if patch_size == 1 or center_pixel: output = output.numpy() else: output = np.transpose(output.numpy(), (0, 2, 3, 1)) for (x, y, w, h), out in zip(indices, output): if center_pixel: probs[x + w // 2, y + h // 2] += out else: probs[x : x + w, y : y + h] += out return probs
def test(net, img, args): """ Test a model on a specific image """ net.eval() patch_size = args.patch_size center_pixel = args.center_pixel batch_size, device = args.batch_size, torch.device(args.device) n_classes = args.n_classes kwargs = { 'step': args.test_stride, 'window_size': (patch_size, patch_size) } probs = np.zeros(img.shape[:2] + (n_classes, )) iterations = utils.count_sliding_window(img, **kwargs) // batch_size for batch in tqdm(utils.grouper(batch_size, utils.sliding_window(img, **kwargs)), total=(iterations), desc="Inference on the image"): with torch.no_grad(): if patch_size == 1: data = [b[0][0, 0] for b in batch] data = np.copy(data) data = torch.from_numpy(data) else: data = [b[0] for b in batch] data = np.copy(data) data = data.transpose(0, 3, 1, 2) data = torch.from_numpy(data) data = data.unsqueeze(1) indices = [b[1:] for b in batch] data = data.to(device) output = net(data) if isinstance(output, tuple): output = output[0] output = output.to('cpu') if patch_size == 1 or center_pixel: output = output.numpy() else: output = np.transpose(output.numpy(), (0, 2, 3, 1)) for (x, y, w, h), out in zip(indices, output): if center_pixel: probs[x + w // 2, y + h // 2] += out else: probs[x:x + w, y:y + h] += out return probs
def run_pipe(config, data, model_file, output_file, output_format): print("pipe mode") model = keras.models.load_model(model_file) model.summary() data.load_indexed_features(model_file + '_ft.pickle') data.load_embeddings() reader = data.get_reader() writer = get_writer(output_file, output_format) labels_index_inverted = {} for key, value in data.labels_index.iteritems(): labels_index_inverted[value] = key token_features_generator = data.get_token_feature_generator() while True: document = reader.nextDocument() if document is None: break token_features_generator.generateFeatures(document) for sentence in document.getSentences(): sentence_seq = data.process_sentence(sentence) sequences = [] for w in sliding_window(sentence_seq, data.window_size, data.window_size): sequences.append(w) x = [] for seq in sequences: x.append(data.get_vector_sequence(seq)) y_pred = model.predict(branched_bi_gru_lstm.get_x(np.asarray(x))) y_pred = map(lambda v: labels_index_inverted[v.argmax()], y_pred) for idx, a in enumerate(y_pred): if a == data.irrelevant_class: continue annotation = create_annotation(idx, idx, a, sentence) sentence.addChunk(annotation) writer.writeDocument(document) reader.close() writer.close()
def RPN_trainloader(): # Skip ever 100 no intersection pos_count = 0 for i, image_loc in enumerate(image_list): print("NEW IMAGE") name = image_loc[:image_loc.index(".")] cur_image = np.asarray(Image.open(os.path.join(IMAGE_DIR, image_loc))) bboxes = json.loads(open(os.path.join(BBOX_DIR, name + ".json"), "r").read()) rectArr = list(map(lambda x: utils.Rectangle(int(min(x[0], x[1])), int(min(x[2], x[3])), int(max(x[0], x[1])), int(max(x[2], x[3]))), bboxes)) image = cur_image sizes = [(image.shape[1] // 15, image.shape[0] // 20), (image.shape[1] // 30, image.shape[0] // 30), (image.shape[1] // 20, image.shape[0] // 15), (image.shape[1] // 30, image.shape[0] // 40)] for width, height in sizes: for window in utils.sliding_window(image, (10, 10), windowSize=(width, height)): curRect = utils.Rectangle(window[0], window[1], window[0] + width, window[1] + height) area = calculateIntersectArea(curRect, rectArr) ratio = area / curRect.area label = 0 if ratio > .3: label = 1 if ratio > .7: label = 2 if label == 0: pos_count += 1 if pos_count % 10 != 0: continue # print(area, curRect.area) # if area > 500: # plt.imshow(window[2]) # plt.show() img = image_loader(Image.fromarray(window[2])) # pilTrans = transforms.ToPILImage() # pilImg = pilTrans(img.cpu()) # plt.imshow(np.asarray(pilImg)) # plt.show() yield (img, label)
def process_document(self, document, token_features_generator = None, sequences=None): if not token_features_generator: token_features_generator = self.get_token_feature_generator() if sequences is None: sequences = [] token_features_generator.generateFeatures(document) for sentence in document.getSentences(): sentence_seq = self.process_sentence(sentence) for w in sliding_window(sentence_seq, self.window_size, self.window_size): sequences.append(w) return sequences
def gen_context(self, sent): size = self.window_size # pad zeros pad_word_idx = np.pad(sent, (size, size), 'constant', constant_values=self.padding_index) # following is correct but not easy to understand wds = sliding_window(pad_word_idx, size) ctx = np.concatenate((wds[:-(size+1)], wds[(size+1):]), axis=1) # dynamic window size dyn_padding = np.random.randint(self.window_size + 1, size=len(sent)) for word_ctx, d in zip(ctx, dyn_padding): word_ctx[:d] = self.padding_index word_ctx[-d:] = self.padding_index return ctx
def detect(self, img_name, image, stepSize=None, windowSize=None, scale=None, minSize=None): windowSize = windowSize if windowSize is not None else self.windowSize stepSize = stepSize if stepSize is not None else self.stepSize scale = scale if scale is not None else self.scale minSize = minSize if minSize is not None else self.minSize window_num = 0 polygons_metal = list() polygons_thatch = list() rects_metal = list() rects_thatch = list() #loop through pyramid for level, resized in enumerate( utils.pyramid(image, scale=scale, minSize=minSize)): for (x, y, window) in utils.sliding_window(resized, stepSize=stepSize, windowSize=windowSize): #self.debug_scaling(image, img_name, resized, x, y, level): # if the window does not meet our desired window size, ignore it if window.shape[0] != windowSize[0] or window.shape[ 1] != windowSize[1]: continue window_num += 1 #save the correctly translated coordinates of this window polygon, rectangle = self.get_translated_coords( x, y, level, scale, windowSize) polygons_metal.append(polygon) rects_metal.append(rectangle) polygons_thatch.append(polygon) rects_thatch.append(rectangle) self.total_window_num += window_num rects = {'thatch': rects_thatch, 'metal': rects_metal} polygons = {'thatch': polygons_thatch, 'metal': polygons_metal} return polygons, rects
def depth_blur(self, img): (winW, winH) = (self.winsize, self.winsize) alpha = self.attenuation for (x, y, window) in utils.sliding_window(img, stepSize=self.winsize - 6, windowSize=(winW, winH)): if window.shape[0] != winH or window.shape[1] != winW: continue #print(int(y+winW/3)) #print(int(x+winH/3)) img[y:y + winW, x:x + winH] = cv2.GaussianBlur( img[y:y + winW, x:x + winH], (winW, winH), alpha * self.depth_img[int(y + winW / 2), int(x + winH / 2)]) return img
def __init__(self, run_name, filename, window, stride, rate, size=-1, start=0, test=False): file_in_out, out_file = preprocess(run_name, filename, ["scale " + str(rate)], test=test) waveform, sample_rate = torchaudio.load(file_in_out) input = waveform[0] inputs = sliding_window(input, window, stride) self.x = inputs[start:start + size, None, :]
def audio_data_to_expectation_of_next_sample(data, labels): orig_type = data.dtype data_max = data.max() data = data / data_max expectations = data window_size = 512 padding = np.zeros((data.shape[0], window_size), dtype=data.dtype) data = np.concatenate((padding, data), axis=1) def denormalize(normalized_data): return (normalized_data * data_max).astype(orig_type) chunks = sliding_window( data, size=window_size)[:, :-1] # drop the last one, which has no prediction # todo include the label data somehow # todo maybe also include the index of the next sample? return chunks, expectations, denormalize
def detect_roofs(self, image): # loop over the image pyramid for resized in utils.pyramid(image, scale=1.5): # loop over the sliding window for each layer of the pyramid for (x, y, window) in utils.sliding_window(resized, stepSize=32, windowSize=(winW, winH)): # if the window does not meet our desired window size, ignore it if window.shape[0] != winH or window.shape[1] != winW: continue # THIS IS WHERE YOU WOULD PROCESS YOUR WINDOW, SUCH AS APPLYING A # MACHINE LEARNING CLASSIFIER TO CLASSIFY THE CONTENTS OF THE # WINDOW # since we do not have a classifier, we'll just draw the window clone = resized.copy() cv2.rectangle(clone, (x, y), (x + winW, y + winH), (0, 255, 0), 2) cv2.imshow("Window", clone) cv2.waitKey(1) time.sleep(0.025)
def detect(origin_img, hog, clf): windows = [] for img, scale in pyramid(origin_img): points = [] features = [] for (x1, y1, window) in sliding_window(img, 8, (128, 128)): if window.shape[0] == 128 and window.shape[1] == 128: features.append(hog.compute(window).reshape(-1)) points.append([x1, y1]) if len(features) == 0: continue Y = clf.predict(features) points = np.asarray(points)[Y==1] * scale w = np.concatenate((points, points + 128*scale), axis=1).astype(int) if w.shape[0] > 0: windows.append(w.tolist()) return windows
def detect(self, image): clone = image.copy() image = rgb2gray(image) detections = [] # 记录识别的目标 downscale_power = 0 # 当前下采样系数 # 迭代下采样 for im_scaled in pyramid(image, downscale=self.downscale, min_size=self.window_size): if im_scaled.shape[0] < self.window_size[1] or im_scaled.shape[ 1] < self.window_size[0]: # 如果采样尺度小于模板窗,就停止迭代 break for (x, y, im_window) in sliding_window(im_scaled, self.window_step_size, self.window_size): if im_window.shape[0] != self.window_size[ 1] or im_window.shape[1] != self.window_size[0]: continue feature_vector = hog(im_window, block_norm="L1") # 计算HOG特征 X = np.array([feature_vector]) prediction = self.clf.predict(X) if prediction == 1: x1 = int(x * (self.downscale**downscale_power)) y1 = int(y * (self.downscale**downscale_power)) detections.append( (x1, y1, x1 + int(self.window_size[0] * (self.downscale**downscale_power)), y1 + int(self.window_size[1] * (self.downscale**downscale_power)))) downscale_power += 1 # 移动到下一个尺度 clone_before_nms = clone.copy() # 用来显示NMS处理前的结果 for (x1, y1, x2, y2) in detections: cv2.rectangle(clone_before_nms, (x1, y1), (x2, y2), (0, 255, 0), thickness=2) # 描框 detections = non_max_suppression(np.array(detections), self.threshold) # NMS处理后的结果 clone_after_nms = clone # NMS处理后的结果 for (x1, y1, x2, y2) in detections: cv2.rectangle(clone_after_nms, (x1, y1), (x2, y2), (0, 255, 0), thickness=2) # 描框 return clone_before_nms, clone_after_nms
def _greedy_motifs_search_template( dna: List[str], k: int, t: int, to_profile ) -> List[str]: assert len(dna) == t best_motifs = [] best_score = 10000000 iter = sliding_window(dna[0], k) iter = map(lambda cs: "".join(cs), iter) for kmer in iter: motifs = [kmer] for seq in dna[1:]: prof = to_profile(motifs) motif = most_probable_kmer(seq, k, prof) motifs.append(motif) if score(motifs) < best_score: best_score = score(motifs) best_motifs = motifs return best_motifs
def stream_train_images(dir_path, true_rectangles_dict, window_size=(128, 128), window_step=32, visualize=False): # define the window width and height winW, winH = window_size for image_path in list_images(dir_path): if not is_image_file(image_path): continue # Read the image image = scipy.misc.imread(image_path) parent_dir_path, image_name = os.path.split(image_path) parent_dir_name = os.path.split(parent_dir_path)[-1] image_name_key = os.path.join(parent_dir_name, image_name) true_rectangles = true_rectangles_dict[image_name_key] if visualize: clone = image.copy() for rect in true_rectangles: cv2.rectangle(clone, (rect[0], rect[1]), (rect[2], rect[3]), RED, thickness=2) for (x, y, window) in sliding_window(image, step_size=window_step, window_size=(winW, winH)): # if the window does not meet our desired window size, ignore it if window.shape[0] != winH or window.shape[1] != winW: continue if visualize: copy = clone.copy() cv2.rectangle(copy, (x, y), (x + winW, y + winH), BLUE, thickness=2) cv2.imshow(image_path, copy) cv2.waitKey(1) if all(bb_intersection_over_union((x, y, x + winW, y + winH), rect) == 0 for rect in true_rectangles): if visualize: cv2.rectangle(clone, (x, y), (x + winW, y + winH), GREEN, thickness=2) cv2.imshow(image_path, clone) cv2.waitKey(1) yield image_name, window if visualize: cv2.destroyAllWindows()
def motif_enumeration(dna: List[str], k: int, d: int) -> Set[str]: """Search for all (k, d)-motifs in dna with brute force. O(t * n * X * t * n) where t = len(dna) n = len(dna[0]) X = time complexity of neighbors() >>> motif_enumeration({"ATTTGGC", "TGCCTTA", "CGGTATC", "GAAAATT"}, 3, 1) == {"ATA", "ATT", "GTT", "TTT"} True """ seen = set() res = set() for seq in dna: for seed in sliding_window(seq, k): if seed in seen: continue seen.add(seed) for pattern in neighbors(seed, d): if all(hamming_distance_str(pattern, s) <= d for s in dna): res.add(pattern) return res
def practice_list(request, club = None): club = get_object_or_404(Club, Slug = club) practices = club.practice_set.all().annotate(NumPeople = Count('person')).order_by('-Date') if practices.count() > 10: chart = GChart(ctype = 'line') data = sliding_window(practices) chart.dataset(data[:500]).axes.type('xy') if request.method == 'POST': form = PracticeModelForm(request.POST) new_practice = form.save(commit = False) new_practice.Club = club new_practice.save() return HttpResponseRedirect(new_practice.get_absolute_url()) else: form = PracticeModelForm() return render_to_response('Dojo/Practice_object_list.html', locals(), context_instance = RequestContext(request))
def find_bbox(mean, evecs, image, width, height, is_upper, jaw_split, show=False): """Finds a bounding box around the four upper or lower incisors. A sliding window is moved over the given image. The window which matches best with the given appearance model is returned. Args: mean: PCA mean. evecs: PCA eigen vectors. image: The dental radiograph on which the incisors should be located. width (int): The default width of the search window. height (int): The default height of the search window. is_upper (bool): Wheter to look for the upper (True) or lower (False) incisors. jaw_split (Path): The jaw split. Returns: A bounding box around what looks like four incisors. The region of the image selected by the bounding box. """ h, w = image.shape # [b1, a1]--------------- # ----------------------- # ----------------------- # ----------------------- # ---------------[b2, a2] if is_upper: b1 = int(w/2 - w/10) b2 = int(w/2 + w/10) a1 = int(np.max(jaw_split.get_part(b1, b2), axis=0)[1]) - 350 a2 = int(np.max(jaw_split.get_part(b1, b2), axis=0)[1]) else: b1 = int(w/2 - w/12) b2 = int(w/2 + w/12) a1 = int(np.min(jaw_split.get_part(b1, b2), axis=0)[1]) a2 = int(np.min(jaw_split.get_part(b1, b2), axis=0)[1]) + 350 search_region = [(b1, a1), (b2, a2)] best_score = float("inf") best_score_bbox = [(-1, -1), (-1, -1)] best_score_img = np.zeros((500, 400)) for wscale in np.arange(0.8, 1.3, 0.1): for hscale in np.arange(0.7, 1.3, 0.1): winW = int(width * wscale) winH = int(height * hscale) for (x, y, window) in sliding_window(image, search_region, step_size=36, window_size=(winW, winH)): # if the window does not meet our desired window size, ignore it if window.shape[0] != winH or window.shape[1] != winW: continue reCut = cv2.resize(window, (width, height)) X = reCut.flatten() Y = project(evecs, X, mean) Xacc = reconstruct(evecs, Y, mean) score = np.linalg.norm(Xacc - X) if score < best_score: best_score = score best_score_bbox = [(x, y), (x + winW, y + winH)] best_score_img = reCut if show: window = [(x, y), (x + winW, y + winH)] Plotter.plot_autoinit(image, window, score, jaw_split, search_region, best_score_bbox, title="wscale="+str(wscale)+" hscale="+str(hscale)) return (best_score_bbox, best_score_img)
if __name__ == '__main__': if(len(sys.argv) != 2): logger.critical("请输入测试图片路径!") sys.exit() else: image_path = sys.argv[1] # 全局模型 overallModel_file = config["model"]["overallModel_file"] with open(overallModel_file, 'rb') as fid: classifier1 = cPickle.load(fid) # logger.info("overall model imported successfully.") # 局部模型 localModel_file = config["model"]["localModel_file"] with open(localModel_file, 'rb') as fid: classifier2 = cPickle.load(fid) # logger.info("overall model imported successfully.") image = cv2.imread(image_path) pred = classifier1.predict_proba(process_image( image, feature.getFeature))[0] # threshold_window = 1 - min(0.5, pred[1]) * 5 / 7.0 # 窗口上的阈值取决于整体上的概率 threshold_window = 0.6 result = list() for (x, y, window) in sliding_window(image, stepSize, (winW, winH)): prediction = classifier2.predict_proba( process_image(window, feature.getFeature))[0] if(prediction[1] >= threshold_window): result.append([x, y, x+winW, y+winH]) print result