def evaluate_pair(self, threshold, distance): #, visualize): """ Funtion to load the overlapping keypoints and check the number of matches using adjacency matrix """ H = np.loadtxt(self.homography_path) point_qry, point_trg, point_qry_proj_on_trg, point_trg_proj_on_qry = get_overlapping_kp( kp_qry, kp_trg, H, qry_img_shape, trg_img_shape) point_qry_len = len(point_qry) point_trg_len = len(point_trg) # Get the distance matrix if point_qry_len == 0 or point_trg_len == 0: dist_in_trg_img = np.array([]) dist_in_qry_img = np.array([]) else: dist_in_trg_img = get_dist(point_qry_proj_on_trg, point_trg, distance) dist_in_qry_img = get_dist(point_trg_proj_on_qry, point_qry, distance) eval_results = evaluate_matches(dist_in_trg_img, dist_in_qry_img, point_qry_len, point_trg_len, threshold) cache_wg.append((self.sequence, self.homography_name, distance, threshold, eval_results))
def get_local_max_grad_1d(grad_func, line, pt, resolution=0.1): x, y = pt a, b, c = line max_grad1, max_grad2 = grad_func(x, y), grad_func(x, y) target1, target2 = np.array((x, y)), np.array((x, y)) drop_cnt1, drop_cnt2 = 0, 0 center = False idx = 1 while (drop_cnt1 < int(1/resolution)) or (drop_cnt2 < int(1/resolution)): if abs(a) <= abs(b): # flatten slope x1 = x - idx * resolution x2 = x + idx * resolution y1 = - (a * x1 + c) / b y2 = - (a * x2 + c) / b else: # steep slope y1 = y - idx * resolution y2 = y + idx * resolution x1 = - (b * y1 + c) / a x2 = - (b * y2 + c) / a grad1, grad2 = grad_func(x1, y1), grad_func(x2, y2) if (idx == 1) and (grad_func(x, y) > max(grad1, grad2)): center = True if drop_cnt1 < int(1/resolution): if (grad1 > max_grad1): max_grad1 = grad1 target1 = np.array((x1, y1)) drop_cnt1 = 0 else: drop_cnt1 += 1 if drop_cnt2 < int(1/resolution): if (grad2 > max_grad2): max_grad2 = grad2 target2 = np.array((x2, y2)) drop_cnt2 = 0 else: drop_cnt2 += 1 idx += 1 # dist1 = np.sqrt(np.sum((target1 - np.array((x, y)))**2)) # dist2 = np.sqrt(np.sum((target2 - np.array((x, y)))**2)) dist1 = get_dist(target1, np.array((x, y))) dist2 = get_dist(target2, np.array((x, y))) if dist1 == dist2: if max_grad1 > max_grad2: return target1 else: return target2 elif dist1 > dist2: if dist2 > 0 or center: return target2 else: return target1 else: if dist1 > 0 or center: return target1 else: return target2
def grad_improve(img, lines, terminals, num_dpts=8, line_thresh=-1, pt_thresh=-1): assert len(lines) == len(terminals), f"[grad_improve]: # of lines ({len(lines)}) != # of terminal pairs ({len(terminals)})!" grad_func = get_gradient_func(img) new_lines, new_terminals = list(), list() num_improved_lines = 0 for line, terminal in zip(lines, terminals): # line, terminal = lines[7], terminals[7] new_pts = list() dpts, dls = get_dividing_pts_and_lines(line, terminal, num=num_dpts) # dividing points & lines for dpt, dl in zip(dpts, dls): # improve sampled points on vertical direction new_pt = get_local_max_grad_1d(grad_func, dl, dpt) # improved point # fig, axes = display_improved_grad(img, dpt, dl, new_pt, grad_func) # plt.show() new_pts.append(new_pt) # exit() new_pts = np.vstack(new_pts) # improved points for the 'line' ## estimation of the white border width ## segment_length = get_dist(terminal[0, :], terminal[1, :]) segment_width = W2L * segment_length ## check point threshold: any new point should be bounded by the threshold, otherwise the original point is kept ## if (0 <= pt_thresh <= 1): outlider_idx = get_dist(dpts, new_pts) > (pt_thresh * segment_width) new_pts[outlider_idx, :] = np.vstack(dpts)[outlider_idx, :] ## check line threshold: number of improved points within threshold should be more than half ## if (0 <= line_thresh <= 1) and \ (np.sum(get_dist(dpts, new_pts) <= (line_thresh * segment_width)) <= 0.5 * num_dpts): # less than half - abondon improvement new_line, new_terminal = line.copy(), terminal.copy() else: # keep improvement [new_line], [new_terminal] = generate_lines(new_pts, 1, dist_thresh=0.5, correctness_thresh=2, kernel_size=2, faster=False, keep_trace=False) num_improved_lines += 1 ## terminal adjustment ## if abs(new_line[0]) <= abs(new_line[1]): # flatten slope xmin = min(terminal[0, 0], terminal[1, 0], new_terminal[0, 0], new_terminal[1, 0]) xmax = max(terminal[0, 0], terminal[1, 0], new_terminal[0, 0], new_terminal[1, 0]) new_terminal = np.array([ [xmin, - (new_line[0]*xmin + new_line[2]) / new_line[1]], [xmax, - (new_line[0]*xmax + new_line[2]) / new_line[1]] ]) else: # steep slope ymin = min(terminal[0, 1], terminal[1, 1], new_terminal[0, 1], new_terminal[1, 1]) ymax = max(terminal[0, 1], terminal[1, 1], new_terminal[0, 1], new_terminal[1, 1]) new_terminal = np.array([ [- (new_line[1]*ymin + new_line[2]) / new_line[0], ymin], [- (new_line[1]*ymax + new_line[2]) / new_line[0], ymax] ]) new_lines.append(new_line) new_terminals.append(new_terminal) return new_lines, new_terminals, num_improved_lines
def eval_pairs(user_vecs, rel_mat, t, dist_func): mean, std, max, min = ut.get_stats(user_vecs, dist_func) pairs = find_pairs_above_threshold(rel_mat, t) num_pairs_found = 0 dist_sum = 0 for ui, uj in pairs: dist = ut.get_dist(user_vecs, ui, uj, dist_func) if dist is not None: num_pairs_found += 1 norm_dist = np.divide(np.subtract(dist, mean), std) dist_sum += norm_dist return dist_sum/num_pairs_found
def __init__(self, useDevelopmentRelease=False, useProposed=False, forceLTS=False, forceDownload=False): self._debug("MetaRelease.__init__() useDevel=%s useProposed=%s" % (useDevelopmentRelease, useProposed)) # force download instead of sending if-modified-since self.forceDownload = forceDownload # information about the available dists self.downloading = True self.new_dist = None self.current_dist_name = get_dist() self.no_longer_supported = None # default (if the conf file is missing) self.METARELEASE_URI = "http://changelogs.ubuntu.com/meta-release" self.METARELEASE_URI_LTS = "http://changelogs.ubuntu.com/meta-release-lts" self.METARELEASE_URI_UNSTABLE_POSTFIX = "-development" self.METARELEASE_URI_PROPOSED_POSTFIX = "-development" # check the meta-release config first parser = ConfigParser.ConfigParser() if os.path.exists(self.CONF_METARELEASE): try: parser.read(self.CONF_METARELEASE) except ConfigParser.Error, e: sys.stderr.write("ERROR: failed to read '%s':\n%s" % (self.CONF_METARELEASE, e)) return # make changing the metarelease file and the location # for the files easy if parser.has_section("METARELEASE"): sec = "METARELEASE" for k in [ "URI", "URI_LTS", "URI_UNSTABLE_POSTFIX", "URI_PROPOSED_POSTFIX" ]: if parser.has_option(sec, k): self._debug( "%s: %s " % (self.CONF_METARELEASE, parser.get(sec, k))) setattr(self, "%s_%s" % (sec, k), parser.get(sec, k))
def taxi(): startloc = request.args.get('loc1') endloc = request.args.get('loc2') dist = utils.get_dist(startloc, endloc) price = "" print(dist) if dist == None: dist = "unknown miles" price = "unknown price" else: if 'm' in dist: index = dist.index('m') - 1 dist = dist[:index] price = utils.findTaxiFare(float(dist)) elif 'f' in dist: dist = "unknown miles" return render_template('anal.html', dist=dist, price=round(price,2))
def __init__(self, useDevelopmentRelease=False, useProposed=False, forceLTS=False, forceDownload=False): self._debug("MetaRelease.__init__() useDevel=%s useProposed=%s" % (useDevelopmentRelease, useProposed)) # force download instead of sending if-modified-since self.forceDownload = forceDownload # information about the available dists self.downloading = True self.new_dist = None self.current_dist_name = get_dist() self.no_longer_supported = None # default (if the conf file is missing) self.METARELEASE_URI = "http://changelogs.ubuntu.com/meta-release" self.METARELEASE_URI_LTS = "http://changelogs.ubuntu.com/meta-release-lts" self.METARELEASE_URI_UNSTABLE_POSTFIX = "-development" self.METARELEASE_URI_PROPOSED_POSTFIX = "-development" # check the meta-release config first parser = ConfigParser.ConfigParser() if os.path.exists(self.CONF_METARELEASE): try: parser.read(self.CONF_METARELEASE) except ConfigParser.Error, e: sys.stderr.write("ERROR: failed to read '%s':\n%s" % ( self.CONF_METARELEASE, e)) return # make changing the metarelease file and the location # for the files easy if parser.has_section("METARELEASE"): sec = "METARELEASE" for k in ["URI", "URI_LTS", "URI_UNSTABLE_POSTFIX", "URI_PROPOSED_POSTFIX"]: if parser.has_option(sec, k): self._debug("%s: %s " % (self.CONF_METARELEASE, parser.get(sec,k))) setattr(self, "%s_%s" % (sec, k), parser.get(sec, k))
def citire_fisier(filename): with open(filename) as fp: lines = fp.readlines() lines = lines[3:] n = int(lines[0].split(" ")[2]) lines = lines[3:-1] net = {} net['noNodes'] = n mat = [] for i in range(n): mat.append([]) for _ in range(n): mat[i].append(0) pos = [] for line in lines: vect = line.split(" ") pos.append([int(vect[0]), int(vect[1]), int(vect[2])]) for i in range(n): for j in range(n): mat[pos[i][0] - 1][pos[j][0] - 1] = int( get_dist([pos[i][1], pos[i][2]], [pos[j][1], pos[j][2]])) net["mat"] = mat degrees = [] noEdges = 0 for i in range(n): d = 0 for j in range(n): if (mat[i][j] == 1): d += 1 if (j > i): noEdges += 1 degrees.append(d) net["noEdges"] = noEdges net["degrees"] = degrees return net
def __init__(self, new_dist, progress): self.new_dist = new_dist self.current_dist_name = get_dist() self._progress = progress # options to pass to the release upgrader when it is run self.run_options = []
def __init__(self): self.config = setting self.code = 1 self.messages = [] self.dist, self.version, self.release = health_check_utils.get_dist()
def attack(self, inputs, targets): # GRADIENT ESTIMATION EVAL def get_grad_est(x, batch_lab, num_batches): losses = [] grads = [] for _ in range(num_batches): final_losses, grad_estimate = self.sess.run( [self.final_losses, self.grad_estimate], { self.img: x, self.lab: batch_lab }) losses.append(final_losses) grads.append(grad_estimate) grads = np.array(grads) losses = np.array(losses) return losses.mean(), np.mean(grads, axis=0, keepdims=True) adv = [] adv = np.array(inputs) query_images = [] query_images = np.zeros((len(inputs))) time_images = [] time_images = np.zeros((len(inputs))) succ = 0 for i in range(len(inputs)): start = time.time() batch_data = inputs[i:i + 1] batch_lab = targets[i:i + 1] x = batch_data num_batches = 1 max_lr = self.lr current_ep = self.epsilon * self.lambd num_queries = 0 last_ls = [] print('--------------------') for iteration in range(self.nb_iter): loss, pred, eval_adv, true_grad = self.sess.run( [self.tloss, self.pred, self.eval_adv, self.gradients], { self.img: x, self.lab: batch_lab }) # Get zeroth-order gradient estimates l, grad = get_grad_est(x, batch_lab, num_batches) num_queries += num_batches * self.grad_est_batch_size * 2 # LR Decaying current_lr = self.lr / (iteration + 1)**0.5 grad_normalized = grad_normalization(grad, self.ord) # grad_normalized = grad_normalization(true_grad, self.ord) v = -current_ep * grad_normalized + batch_data d = v - x g = self.epsilon * np.sum(np.abs(true_grad)) - np.sum( (batch_data - x) * true_grad) x = x + current_lr * d eta = x - batch_data x = batch_data + norm_ball_proj_inner(eta, self.ord, self.epsilon) x = np.clip(x, self.clip_min, self.clip_max) succ += eval_adv if self.test: if succ == 1: print('succ, queries: ', num_queries) print(g) if g < 1: break else: if iteration % self.output_steps == 0: dist = get_dist(x, batch_data, self.ord) print( "Iter: {}, Loss: {:0.5f}, Queries: {}, Dist: {:0.5f}, Eps: {}, lr: {:.5f}, Pred: {}, Eval: {}, g: {}" .format(iteration, l, num_queries, dist, current_ep, current_lr, pred, eval_adv, g)) if eval_adv: break time_images[i] = time.time() - start query_images[i] = num_queries if eval_adv: adv[i] = x print('Succ ', succ, ' / ', (i + 1), ' rate: ', succ / (i + 1)) print('Total Succ ', succ, ' / ', len(inputs), ' rate: ', succ / len(inputs)) # print (adv[0], query_images) return adv, query_images, time_images, succ / len(inputs)
def attack(self, inputs, targets): eps = eps_search(self.epsilon, self.ord) adv = [] adv = np.array(inputs) time_images = np.zeros((len(inputs))) stop_iter = np.zeros((len(inputs))) index_set = np.arange(0,len(inputs)) for ep in eps: print ('Searching for ep@', ep) if(len(index_set) != 0): preds = [] adv_remain = [] time_remain = [] stop_iter_remain = [] current_ep = ep*self.lambd for i in range(0,len(index_set),self.batch_size): start_time = time.time() start = i end = min(i+self.batch_size, len(inputs)) ind = index_set[start:end] if len(ind) < self.batch_size: ind = np.pad(ind, (0, self.batch_size - len(ind)), mode='constant', constant_values=0) batch_data = inputs[ind] batch_lab = targets[ind] x = np.copy(batch_data) last_ls = [] max_lr = self.lr print ('--------------------') for iteration in range(self.nb_iter): loss, pred, eval_adv, grad = self.sess.run([self.tloss, self.pred, self.eval_adv, self.gradients], {self.img: x, self.lab: batch_lab}) grad_normalized = grad_normalization(grad, self.ord) v = - current_ep * grad_normalized + batch_data d = v - x g = np.sum(d* -grad) current_lr = max_lr x = x + current_lr * d eta = x - batch_data x = batch_data + norm_ball_proj_inner(eta, self.ord, ep) x = np.clip(x, self.clip_min, self.clip_max) if self.test: print (g) if g < 1: break else: if iteration % self.output_steps == 0: dist = get_dist(x, batch_data, self.ord) print ('Iter: ', iteration, 'Loss: ', loss, ' Dist: ', dist , ' Pred: ' , pred, ' Eval: ', eval_adv.all(), ' g: ', g) if eval_adv.all(): break last_ls.append(loss) last_ls = last_ls[-5:] if last_ls[-1] > 0.999 * last_ls[0] and len(last_ls) == 5: print (last_ls) print("Early stopping because there is no improvement") break preds.extend(eval_adv) adv_remain.extend(x) time_remain.extend(np.ones(len(batch_lab))*(time.time() - start_time)/len(batch_lab)) stop_iter_remain.append(iteration) preds = np.array(preds) adv_remain = np.array(adv_remain) time_remain = np.array(time_remain) stop_iter_remain = np.array(stop_iter_remain) succ_ind = [j for j in range(len(index_set)) if preds[j] == True] if(self.epsilon == 0.): adv[index_set[succ_ind]] = adv_remain[succ_ind] time_images[index_set[succ_ind]] = time_remain[succ_ind] stop_iter[index_set[succ_ind]] = stop_iter_remain[succ_ind] else: adv = adv_remain time_images = time_remain stop_iter = stop_iter_remain index_set = np.delete(index_set, succ_ind, 0) print('Remaining: ', len(index_set)) print ('Succ ', len(inputs) - len(index_set), ' / ', len(inputs), ' rate: ', 1 - len(index_set)/ len(inputs)) # print (adv[0], stop_iter) return adv, time_images, 1 - len(index_set)/ len(inputs), stop_iter
def main(): cfg = get_default_config() # init detector network print('init detector network...') odapi = DetectorAPI(path_to_ckpt=cfg.detector.load_weights) print("done!") # init intel camera print('init intel camera...') pipe = rs.pipeline() config = rs.config() config.enable_stream(rs.stream.color, 1280, 720, rs.format.bgr8, 30) # Start streaming pipe.start(config) print("done!") # init banks print("init gallary...") body_bank = [] # gallery array of persons body_bank_dist = [] # # body_bank_bb = [] body_im_array = [] print("done!") if cfg.visualisation.key: print("start visualisation mode...") plt.ion() print("done!") curTime = 0 with tf.Session() as sess: args_save = True if args_save: video_writer = cv2.VideoWriter(cfg.video.path, cv2.VideoWriter_fourcc(*'XVID'), 6, (cfg.image.width, cfg.image.height)) while True: curTime += 1 #print(curTime) #----------------------------------------- # pipe to get image from intel cam frameset = pipe.wait_for_frames() color_frame = frameset.get_color_frame() color = np.asanyarray(color_frame.get_data()).copy() #print(np.shape(color), type(color)) # rgb_frame = make_rgb(color) frameL = cv2.resize(color, (cfg.image.width, cfg.image.height)) # ----------------------------------------- # choose start frame point if curTime < 10: continue # choose fps if curTime % 1 != 0: continue # ----------------------------------------- if frameL is None: break # ----------------------------------------- # ----------------------------------------- # get bbox of objects detections, scores, classes, num = odapi.processFrame(frameL) # get bbox of persons mask = np.array([ a & b for a, b in zip( np.array(classes) == 1, np.array(scores) > cfg.detector.threshold) ]) detections = np.array(detections) if np.sum(mask) != 0: detections = detections[mask] else: detections = [] # apply ion filter detections_iou = [] for slow_loop_idx in range(len(detections)): if detections[slow_loop_idx][0] == -1: continue for fast_loop_idx in range(len(detections)): if detections[fast_loop_idx][0] == -1: continue r = bb_intersection_over_union(detections[slow_loop_idx], detections[fast_loop_idx]) if r > cfg.detector.iou_threshold and slow_loop_idx != fast_loop_idx: detections[fast_loop_idx][0] = -1 for box in detections: if box[0] == -1: continue detections_iou.append(box) # save detections after filter detections = detections_iou # ----------------------------------------- # start tracking part if len(detections) != 0: # init body_bank result_arr = [] # ids of detected persons result_features = [ ] # features of detected persons respectively to result_arr idxes result_dist_arr = [ ] # distance of detected persons respectively to result_arr idxes body_bank_tmp = body_bank.copy( ) # body bank copy for next loop to exclude person after search len_body_bank_tmp = len( body_bank_tmp) # decreasing length of body_bank_tmp # search loop for i, body_detection_xy in enumerate(detections): # if body bank (gallary) is not empty if len(body_bank) != 0: # if tmp body bank (gallary) is empty but we still have detected persons if len_body_bank_tmp == 0: # get coordinates of person p = detections[i] p = check_coords(p) # do preparations for image to fit it into reid network img = np.transpose( frameL[int(p[0]):int(p[2]), int(p[1]):int(p[3])]).astype('f') / 255. img = np.expand_dims(img, axis=0) # extract features features_img_query = F.normalize( extract_features(torch.from_numpy( img).cuda())).cpu().numpy()[0] # add features of new pearson to gallary body_bank.append(features_img_query) result = len(body_bank) result_arr.append(result) #body_bank_bb.append(detections[i]) # init distance of new person body_bank_dist.append(0) continue # get distance of person to persons in gallery distmat_arr, query_f = get_dist( [np.array(body_detection_xy)], frameL, body_bank_tmp) # get id of person in gallery result = np.argmin(distmat_arr, 1)[0] #print(distmat_arr[0][result]) # if minimum distance is lower cfg.model.threshold it is the same person if (distmat_arr[0][result] < cfg.model.threshold): # add id to result array result_arr.append(result) # exclude person from search body_bank_tmp[result] = [] # decrease lenght of tmp body bank len_body_bank_tmp -= 1 # save features and distance result_features.append(query_f[result]) result_dist_arr.append(np.min(distmat_arr, 1)[0]) else: # save features and distance body_bank.append(query_f[result]) body_bank_dist.append(0) else: print("add new user") #result = len(body_bank) + 1 # get coordinates of person p = detections[i] p = check_coords(p) # do preparations for image to fit it into reid network img = np.transpose( frameL[int(p[0]):int(p[2]), int(p[1]):int(p[3])]).astype('f') / 255. img = np.expand_dims(img, axis=0) # extract features features_img_query = F.normalize( extract_features( torch.from_numpy(img).cuda())).cpu().numpy()[0] # save features and distance body_bank.append(features_img_query) result = len(body_bank) result_arr.append(result) #body_bank_bb.append(detections[i]) body_bank_dist.append(0) # ax for visualisation of features ax = [0] * len(result_arr) if cfg.visualisation.key: if len(body_bank) != 0: fig, ax = plt.subplots( nrows=len(body_bank), ncols=3, gridspec_kw={'width_ratios': [2, 10, 10]}, figsize=(10, 2)) if len(body_bank) == 1: ax = [ax] for i, pack in enumerate(zip(result_arr, result_dist_arr, ax)): id, result, row = pack # add new human if % is too low # refresh bank if cfg.visualisation.key: if len(body_bank) != 0: for idx, col in enumerate(row): if idx == 0: p = detections[i] p = check_coords(p) col.imshow(frameL[int(p[0]):int(p[2]), int(p[1]):int(p[3])]) if idx == 1: col.plot(range(0, len(body_bank[id]) + 1), list(body_bank[id]) + [0.40]) if idx == 2: print( int( "".join( str(int(x)) for x in [ x > 0.1 and y > 0.1 for x, y in zip( body_bank[id], result_features[i]) ]), 2)) # refresh image in gallery if image is good if result < cfg.model.threshold: p = detections[i] p = check_coords(p) body_bank_dist[ id] = result # + body_bank_dist[id]) / 2 body_bank[id] = result_features[ i] #+ body_bank[id]) / 2 #frameL[int(p[1]):int(p[3]), int(p[0]):int(p[2])] text = "_ID_{} <{}>".format(str(id), str(round(result, 3))) cv2.putText(frameL, text, (int(detections[i][1]) - 10, int(detections[i][0]) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2) if cfg.visualisation.key: plt.show() plt.pause(4) plt.close() frameL = frameL / 255 for p in detections: cv2.rectangle(frameL, (p[1], p[0]), (p[3], p[2]), (50, 50, 250), 2) cv2.imshow("L", frameL) #print("shape ", frameL.shape) if args_save: video_writer.write((frameL * 255).astype(np.uint8)) cv2.waitKey(1)
def find_path(lines, paths, paths_color): x = 0 y = 0 way_points_draw = np.empty((0, 3)) open_list = np.arange(0, len(lines) + len(paths)) prev_color = None for i in range(len(lines) + len(paths)): min_dist = float('inf') arg_min_dist = open_list[0] in_same_direction = False is_spline = False tie_list = np.empty((0, 2)) for j in open_list: is_j_spline = j >= len(lines) if is_j_spline: dist_u = get_dist(x, y, *paths[j - len(lines)][0][:2]) dist_v = get_dist(x, y, *paths[j - len(lines)][-1][:2]) else: dist_u = get_dist(x, y, *lines[j].u) dist_v = get_dist(x, y, *lines[j].v) if min_dist > dist_u: min_dist = dist_u arg_min_dist = j in_same_direction = True is_spline = is_j_spline if tie_list.size > 0: tie_list = np.empty((0, 2)) elif min_dist == dist_u: # keep track of ties tie_list = np.vstack([tie_list, [j, True]]) if min_dist > dist_v: min_dist = dist_v arg_min_dist = j in_same_direction = False is_spline = is_j_spline if tie_list.size > 0: tie_list = np.empty((0, 2)) elif min_dist == dist_v: # keep track of ties tie_list = np.vstack([tie_list, [j, False]]) if tie_list.size > 0: # break ties if prev_color is not None: same_color_filter = [] for tie_index in tie_list[:, 0]: if tie_index >= len(lines): curr_color = paths_color[tie_index - len(lines)] else: curr_color = lines[int(tie_index)].color if curr_color == prev_color: same_color_filter.append(int(tie_index)) if len(same_color_filter) > 0: tie_list = tie_list[same_color_filter] arg_min_dist, in_same_direction = tie_list[0] arg_min_dist = int(arg_min_dist) is_spline = arg_min_dist >= len(lines) if is_spline: arg_min_dist -= len(lines) if in_same_direction: x, y = paths[arg_min_dist][-1][:2] else: x, y = paths[arg_min_dist][0][:2] open_list = open_list[open_list != (arg_min_dist + len(lines))] prev_color = paths_color[arg_min_dist] else: if in_same_direction: x, y = lines[arg_min_dist].v else: x, y = lines[arg_min_dist].u open_list = open_list[open_list != arg_min_dist] prev_color = lines[arg_min_dist] way_points_draw = np.vstack([ way_points_draw, [arg_min_dist, in_same_direction, is_spline] ]) return way_points_draw
def get_sim(a, b, alist): if alist is None: alist = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.] s = [get_dist(a, b, i) for i in alist] return s
def read(humfile, sonpath, cs2cs_args, c, draft, doplot, t, bedpick, flip_lr, model, calc_bearing, filt_bearing, chunk): #cog = 1, ''' Read a .DAT and associated set of .SON files recorded by a Humminbird(R) instrument. Parse the data into a set of memory mapped files that will subsequently be used by the other functions of the PyHum module. Export time-series data and metadata in other formats. Create a kml file for visualising boat track Syntax ---------- [] = PyHum.read(humfile, sonpath, cs2cs_args, c, draft, doplot, t, bedpick, flip_lr, chunksize, model, calc_bearing, filt_bearing, chunk) Parameters ------------ humfile : str path to the .DAT file sonpath : str path where the *.SON files are cs2cs_args : int, *optional* [Default="epsg:26949"] arguments to create coordinates in a projected coordinate system this argument gets given to pyproj to turn wgs84 (lat/lon) coordinates into any projection supported by the proj.4 libraries c : float, *optional* [Default=1450.0] speed of sound in water (m/s). Defaults to a value of freshwater draft : float, *optional* [Default=0.3] draft from water surface to transducer face (m) doplot : float, *optional* [Default=1] if 1, plots will be made t : float, *optional* [Default=0.108] length of transducer array (m). Default value is that of the 998 series Humminbird(R) bedpick : int, *optional* [Default=1] if 1, bedpicking with be carried out automatically if 0, user will be prompted to pick the bed location on screen flip_lr : int, *optional* [Default=0] if 1, port and starboard scans will be flipped (for situations where the transducer is flipped 180 degrees) model: int, *optional* [Default=998] A 3 or 4 number code indicating the model number Examples: 998, 997, 1198, 1199 calc_bearing : float, *optional* [Default=0] if 1, bearing will be calculated from coordinates filt_bearing : float, *optional* [Default=0] if 1, bearing will be filtered chunk : str, *optional* [Default='d100' (distance, 100 m)] letter, followed by a number. There are the following letter options: 'd' - parse chunks based on distance, then number which is distance in m 'p' - parse chunks based on number of pings, then number which is number of pings 'h' - parse chunks based on change in heading, then number which is the change in heading in degrees '1' - process just 1 chunk Returns --------- sonpath+base+'_data_port.dat': memory-mapped file contains the raw echogram from the port side sidescan sonar (where present) sonpath+base+'_data_port.dat': memory-mapped file contains the raw echogram from the starboard side sidescan sonar (where present) sonpath+base+'_data_dwnhi.dat': memory-mapped file contains the raw echogram from the high-frequency echosounder (where present) sonpath+base+'_data_dwnlow.dat': memory-mapped file contains the raw echogram from the low-frequency echosounder (where present) sonpath+base+"trackline.kml": google-earth kml file contains the trackline of the vessel during data acquisition sonpath+base+'rawdat.csv': comma separated value file contains time-series data. columns corresponding to longitude latitude easting (m) northing (m) depth to bed (m) alongtrack cumulative distance (m) vessel heading (deg.) sonpath+base+'meta.mat': .mat file matlab format file containing a dictionary object holding metadata information. Fields are: e : ndarray, easting (m) n : ndarray, northing (m) es : ndarray, low-pass filtered easting (m) ns : ndarray, low-pass filtered northing (m) lat : ndarray, latitude lon : ndarray, longitude shape_port : tuple, shape of port scans in memory mapped file shape_star : tuple, shape of starboard scans in memory mapped file shape_hi : tuple, shape of high-freq. scans in memory mapped file shape_low : tuple, shape of low-freq. scans in memory mapped file dep_m : ndarray, depth to bed (m) dist_m : ndarray, distance along track (m) heading : ndarray, heading of vessel (deg. N) pix_m: float, size of 1 pixel in across-track dimension (m) bed : ndarray, depth to bed (m) c : float, speed of sound in water (m/s) t : length of sidescan transducer array (m) spd : ndarray, vessel speed (m/s) time_s : ndarray, time elapsed (s) caltime : ndarray, unix epoch time (s) ''' # prompt user to supply file if no input file given if not humfile: print('An input file is required!!!!!!') Tk().withdraw( ) # we don't want a full GUI, so keep the root window from appearing humfile = askopenfilename(filetypes=[("DAT files", "*.DAT")]) # prompt user to supply directory if no input sonpath is given if not sonpath: print('A *.SON directory is required!!!!!!') Tk().withdraw( ) # we don't want a full GUI, so keep the root window from appearing sonpath = askdirectory() # print given arguments to screen and convert data type where necessary if humfile: print('Input file is %s' % (humfile)) if sonpath: print('Son files are in %s' % (sonpath)) if cs2cs_args: print('cs2cs arguments are %s' % (cs2cs_args)) if draft: draft = float(draft) print('Draft: %s' % (str(draft))) if c: c = float(c) print('Celerity of sound: %s m/s' % (str(c))) if doplot: doplot = int(doplot) if doplot == 0: print("Plots will not be made") if flip_lr: flip_lr = int(flip_lr) if flip_lr == 1: print("Port and starboard will be flipped") if t: t = np.asarray(t, float) print('Transducer length is %s m' % (str(t))) if bedpick: bedpick = np.asarray(bedpick, int) if bedpick == 1: print('Bed picking is auto') elif bedpick == 0: print('Bed picking is manual') else: print('User will be prompted per chunk about bed picking method') if chunk: chunk = str(chunk) if chunk[0] == 'd': chunkmode = 1 chunkval = int(chunk[1:]) print('Chunks based on distance of %s m' % (str(chunkval))) elif chunk[0] == 'p': chunkmode = 2 chunkval = int(chunk[1:]) print('Chunks based on %s pings' % (str(chunkval))) elif chunk[0] == 'h': chunkmode = 3 chunkval = int(chunk[1:]) print('Chunks based on heading devation of %s degrees' % (str(chunkval))) elif chunk[0] == '1': chunkmode = 4 chunkval = 1 print('Only 1 chunk will be produced') else: print( "Chunk mode not understood - should be 'd', 'p', or 'h' - using defaults" ) chunkmode = 1 chunkval = 100 print('Chunks based on distance of %s m' % (str(chunkval))) if model: try: model = int(model) print("Data is from the %s series" % (str(model))) except: if model == 'onix': model = 0 print("Data is from the ONIX series") elif model == 'helix': model = 1 print("Data is from the HELIX series") elif model == 'mega': model = 2 print("Data is from the MEGA series") # if cog: # cog = int(cog) # if cog==1: # print "Heading based on course-over-ground" if calc_bearing: calc_bearing = int(calc_bearing) if calc_bearing == 1: print("Bearing will be calculated from coordinates") if filt_bearing: filt_bearing = int(filt_bearing) if filt_bearing == 1: print("Bearing will be filtered") ## for debugging #humfile = r"test.DAT"; sonpath = "test_data" #cs2cs_args = "epsg:26949"; doplot = 1; draft = 0 #c=1450; bedpick=1; fliplr=1; chunk = 'd100' #model=998; cog=1; calc_bearing=0; filt_bearing=0 #if model==2: # f = 1000 #else: f = 455 try: print( "Checking the epsg code you have chosen for compatibility with Basemap ... " ) from mpl_toolkits.basemap import Basemap m = Basemap(projection='merc', epsg=cs2cs_args.split(':')[1], resolution='i', llcrnrlon=10, llcrnrlat=10, urcrnrlon=30, urcrnrlat=30) del m print("... epsg code compatible") except (ValueError): print( "Error: the epsg code you have chosen is not compatible with Basemap" ) print( "please choose a different epsg code (http://spatialreference.org/)" ) print("program will now close") sys.exit() # start timer if os.name == 'posix': # true if linux/mac or cygwin on windows start = time.time() else: # windows start = time.clock() # if son path name supplied has no separator at end, put one on if sonpath[-1] != os.sep: sonpath = sonpath + os.sep # get the SON files from this directory sonfiles = glob.glob(sonpath + '*.SON') if not sonfiles: sonfiles = glob.glob(os.getcwd() + os.sep + sonpath + '*.SON') base = humfile.split('.DAT') # get base of file name for output base = base[0].split(os.sep)[-1] # remove underscores, negatives and spaces from basename base = humutils.strip_base(base) print("WARNING: Because files have to be read in byte by byte,") print("this could take a very long time ...") #reading each sonfile in parallel should be faster ... try: o = Parallel(n_jobs=np.min([len(sonfiles), cpu_count()]), verbose=0)( delayed(getscans)(sonfiles[k], humfile, c, model, cs2cs_args) for k in range(len(sonfiles))) X, Y, A, B = zip(*o) for k in range(len(Y)): if Y[k] == 'sidescan_port': dat = A[k] #data.gethumdat() metadat = B[k] #data.getmetadata() if flip_lr == 0: data_port = X[k].astype('int16') else: data_star = X[k].astype('int16') elif Y[k] == 'sidescan_starboard': if flip_lr == 0: data_star = X[k].astype('int16') else: data_port = X[k].astype('int16') elif Y[k] == 'down_lowfreq': data_dwnlow = X[k].astype('int16') elif Y[k] == 'down_highfreq': data_dwnhi = X[k].astype('int16') elif Y[k] == 'down_vhighfreq': #hopefully this only applies to mega systems data_dwnhi = X[k].astype('int16') del X, Y, A, B, o old_pyread = 0 if 'data_port' not in locals(): data_port = '' print("portside scan not available") if 'data_star' not in locals(): data_star = '' print("starboardside scan not available") if 'data_dwnhi' not in locals(): data_dwnlow = '' print("high-frq. downward scan not available") if 'data_dwnlow' not in locals(): data_dwnlow = '' print("low-frq. downward scan not available") except: # revert back to older version if paralleleised version fails print( "something went wrong with the parallelised version of pyread ...") try: import pyread except: from . import pyread data = pyread.pyread(sonfiles, humfile, c, model, cs2cs_args) dat = data.gethumdat() metadat = data.getmetadata() old_pyread = 1 nrec = len(metadat['n']) metadat['instr_heading'] = metadat['heading'][:nrec] #metadat['heading'] = humutils.get_bearing(calc_bearing, filt_bearing, cog, metadat['lat'], metadat['lon'], metadat['instr_heading']) try: es = humutils.runningMeanFast(metadat['e'][:nrec], len(metadat['e'][:nrec]) / 100) ns = humutils.runningMeanFast(metadat['n'][:nrec], len(metadat['n'][:nrec]) / 100) except: es = metadat['e'][:nrec] ns = metadat['n'][:nrec] metadat['es'] = es metadat['ns'] = ns try: trans = pyproj.Proj(init=cs2cs_args) except: trans = pyproj.Proj(cs2cs_args.lstrip(), inverse=True) lon, lat = trans(es, ns, inverse=True) metadat['lon'] = lon metadat['lat'] = lat metadat['heading'] = humutils.get_bearing(calc_bearing, filt_bearing, metadat['lat'], metadat['lon'], metadat['instr_heading']) #cog dist_m = humutils.get_dist(lat, lon) metadat['dist_m'] = dist_m if calc_bearing == 1: # recalculate speed, m/s ds = np.gradient(np.squeeze(metadat['time_s'])) dx = np.gradient(np.squeeze(metadat['dist_m'])) metadat['spd'] = dx[:nrec] / ds[:nrec] # theta at 3dB in the horizontal theta3dB = np.arcsin(c / (t * (f * 1000))) #resolution of 1 sidescan pixel to nadir ft = (np.pi / 2) * (1 / theta3dB) #/ (f/455) dep_m = humutils.get_depth(metadat['dep_m'][:nrec]) if old_pyread == 1: #older pyread version # port scan try: if flip_lr == 0: data_port = data.getportscans().astype('int16') else: data_port = data.getstarscans().astype('int16') except: data_port = '' print("portside scan not available") if data_port != '': Zt, ind_port = makechunks_scan(chunkmode, chunkval, metadat, data_port, 0) del data_port ## create memory mapped file for Z shape_port = io.set_mmap_data(sonpath, base, '_data_port.dat', 'int16', Zt) ##we are only going to access the portion of memory required port_fp = io.get_mmap_data(sonpath, base, '_data_port.dat', 'int16', shape_port) if old_pyread == 1: #older pyread version # starboard scan try: if flip_lr == 0: data_star = data.getstarscans().astype('int16') else: data_star = data.getportscans().astype('int16') except: data_star = '' print("starboardside scan not available") if data_star != '': Zt, ind_star = makechunks_scan(chunkmode, chunkval, metadat, data_star, 1) del data_star # create memory mapped file for Z shape_star = io.set_mmap_data(sonpath, base, '_data_star.dat', 'int16', Zt) star_fp = io.get_mmap_data(sonpath, base, '_data_star.dat', 'int16', shape_star) if 'star_fp' in locals() and 'port_fp' in locals(): # check that port and starboard are same size # and trim if not if np.shape(star_fp) != np.shape(port_fp): print( "port and starboard scans are different sizes ... rectifying") if np.shape(port_fp[0])[1] > np.shape(star_fp[0])[1]: tmp = port_fp.copy() tmp2 = np.empty_like(star_fp) for k in range(len(tmp)): tmp2[k] = tmp[k][:, :np.shape(star_fp[k])[1]] del tmp # create memory mapped file for Z shape_port = io.set_mmap_data(sonpath, base, '_data_port2.dat', 'int16', tmp2) #shape_star = shape_port.copy() shape_star = tuple(np.asarray(shape_port).copy()) ##we are only going to access the portion of memory required port_fp = io.get_mmap_data(sonpath, base, '_data_port2.dat', 'int16', shape_port) ind_port = list(ind_port) ind_port[-1] = np.shape(star_fp[0])[1] ind_port = tuple(ind_port) elif np.shape(port_fp[0])[1] < np.shape(star_fp[0])[1]: tmp = star_fp.copy() tmp2 = np.empty_like(port_fp) for k in range(len(tmp)): tmp2[k] = tmp[k][:, :np.shape(port_fp[k])[1]] del tmp # create memory mapped file for Z shape_port = io.set_mmap_data(sonpath, base, '_data_star2.dat', 'int16', tmp2) #shape_star = shape_port.copy() shape_star = tuple(np.asarray(shape_port).copy()) #we are only going to access the portion of memory required star_fp = io.get_mmap_data(sonpath, base, '_data_star2.dat', 'int16', shape_star) ind_star = list(ind_star) ind_star[-1] = np.shape(port_fp[0])[1] ind_star = tuple(ind_star) if old_pyread == 1: #older pyread version # low-freq. sonar try: data_dwnlow = data.getlowscans().astype('int16') except: data_dwnlow = '' print("low-freq. scan not available") if data_dwnlow != '': Zt, ind_low = makechunks_scan(chunkmode, chunkval, metadat, data_dwnlow, 2) del data_dwnlow # create memory mapped file for Z shape_low = io.set_mmap_data(sonpath, base, '_data_dwnlow.dat', 'int16', Zt) ##we are only going to access the portion of memory required dwnlow_fp = io.get_mmap_data(sonpath, base, '_data_dwnlow.dat', 'int16', shape_low) if old_pyread == 1: #older pyread version # hi-freq. sonar try: data_dwnhi = data.gethiscans().astype('int16') except: data_dwnhi = '' print("high-freq. scan not available") if data_dwnhi != '': Zt, ind_hi = makechunks_scan(chunkmode, chunkval, metadat, data_dwnhi, 3) del data_dwnhi # create memory mapped file for Z shape_hi = io.set_mmap_data(sonpath, base, '_data_dwnhi.dat', 'int16', Zt) dwnhi_fp = io.get_mmap_data(sonpath, base, '_data_dwnhi.dat', 'int16', shape_hi) if 'dwnhi_fp' in locals() and 'dwnlow_fp' in locals(): # check that low and high are same size # and trim if not if (np.shape(dwnhi_fp) != np.shape(dwnlow_fp)) and (chunkmode != 4): print("dwnhi and dwnlow are different sizes ... rectifying") if np.shape(dwnhi_fp[0])[1] > np.shape(dwnlow_fp[0])[1]: tmp = dwnhi_fp.copy() tmp2 = np.empty_like(dwnlow_fp) for k in range(len(tmp)): tmp2[k] = tmp[k][:, :np.shape(dwnlow_fp[k])[1]] del tmp # create memory mapped file for Z shape_low = io.set_mmap_data(sonpath, base, '_data_dwnhi2.dat', 'int16', tmp2) #shape_hi = shape_low.copy() shape_hi = tuple(np.asarray(shape_low).copy()) ##we are only going to access the portion of memory required dwnhi_fp = io.get_mmap_data(sonpath, base, '_data_dwnhi2.dat', 'int16', shape_hi) ind_hi = list(ind_hi) ind_hi[-1] = np.shape(dwnlow_fp[0])[1] ind_hi = tuple(ind_hi) elif np.shape(dwnhi_fp[0])[1] < np.shape(dwnlow_fp[0])[1]: tmp = dwnlow_fp.copy() tmp2 = np.empty_like(dwnhi_fp) for k in range(len(tmp)): tmp2[k] = tmp[k][:, :np.shape(dwnhi_fp[k])[1]] del tmp # create memory mapped file for Z shape_low = io.set_mmap_data(sonpath, base, '_data_dwnlow2.dat', 'int16', tmp2) #shape_hi = shape_low.copy() shape_hi = tuple(np.asarray(shape_low).copy()) ##we are only going to access the portion of memory required dwnlow_fp = io.get_mmap_data(sonpath, base, '_data_dwnlow2.dat', 'int16', shape_low) ind_low = list(ind_low) ind_low[-1] = np.shape(dwnhi_fp[0])[1] ind_low = tuple(ind_low) if old_pyread == 1: #older pyread version del data if ('shape_port' in locals()) and (chunkmode != 4): metadat['shape_port'] = shape_port nrec = metadat['shape_port'][0] * metadat['shape_port'][2] elif ('shape_port' in locals()) and (chunkmode == 4): metadat['shape_port'] = shape_port nrec = metadat['shape_port'][1] else: metadat['shape_port'] = '' if ('shape_star' in locals()) and (chunkmode != 4): metadat['shape_star'] = shape_star nrec = metadat['shape_star'][0] * metadat['shape_star'][2] elif ('shape_star' in locals()) and (chunkmode == 4): metadat['shape_star'] = shape_star nrec = metadat['shape_star'][1] else: metadat['shape_star'] = '' if ('shape_hi' in locals()) and (chunkmode != 4): metadat['shape_hi'] = shape_hi #nrec = metadat['shape_hi'][0] * metadat['shape_hi'][2] * 2 elif ('shape_hi' in locals()) and (chunkmode == 4): metadat['shape_hi'] = shape_hi else: metadat['shape_hi'] = '' if ('shape_low' in locals()) and (chunkmode != 4): metadat['shape_low'] = shape_low #nrec = metadat['shape_low'][0] * metadat['shape_low'][2] * 2 elif ('shape_low' in locals()) and (chunkmode == 4): metadat['shape_low'] = shape_low else: metadat['shape_low'] = '' #make kml boat trackline humutils.make_trackline(lon, lat, sonpath, base) if 'port_fp' in locals() and 'star_fp' in locals(): #if not os.path.isfile(os.path.normpath(os.path.join(sonpath,base+'meta.mat'))): if 2 > 1: if bedpick == 1: # auto x, bed = humutils.auto_bedpick(ft, dep_m, chunkmode, port_fp, c) if len(dist_m) < len(bed): dist_m = np.append( dist_m, dist_m[-1] * np.ones(len(bed) - len(dist_m))) if doplot == 1: if chunkmode != 4: for k in range(len(star_fp)): plot_2bedpicks( port_fp[k], star_fp[k], bed[ind_port[-1] * k:ind_port[-1] * (k + 1)], dist_m[ind_port[-1] * k:ind_port[-1] * (k + 1)], x[ind_port[-1] * k:ind_port[-1] * (k + 1)], ft, shape_port, sonpath, k, chunkmode) else: plot_2bedpicks(port_fp, star_fp, bed, dist_m, x, ft, shape_port, sonpath, 0, chunkmode) # 'real' bed is estimated to be the minimum of the two bed = np.min(np.vstack((bed[:nrec], np.squeeze(x[:nrec]))), axis=0) bed = humutils.runningMeanFast(bed, 3) elif bedpick > 1: # user prompt x, bed = humutils.auto_bedpick(ft, dep_m, chunkmode, port_fp, c) if len(dist_m) < len(bed): dist_m = np.append( dist_m, dist_m[-1] * np.ones(len(bed) - len(dist_m))) # 'real' bed is estimated to be the minimum of the two bed = np.min(np.vstack((bed[:nrec], np.squeeze(x[:nrec]))), axis=0) bed = humutils.runningMeanFast(bed, 3) # manually intervene fig = plt.figure() ax = plt.gca() if chunkmode != 4: im = ax.imshow(np.hstack(port_fp), cmap='gray', origin='upper') else: im = ax.imshow(port_fp, cmap='gray', origin='upper') plt.plot(bed, 'r') plt.axis('normal') plt.axis('tight') pts1 = plt.ginput( n=300, timeout=30) # it will wait for 200 clicks or 60 seconds x1 = map(lambda x: x[0], pts1) # map applies the function passed as y1 = map(lambda x: x[1], pts1) # first parameter to each element of pts plt.close() del fig if x1 != []: # if x1 is not empty tree = KDTree(zip(np.arange(1, len(bed)), bed)) try: dist, inds = tree.query(zip(x1, y1), k=100, eps=5, n_jobs=-1) except: dist, inds = tree.query(zip(x1, y1), k=100, eps=5) b = np.interp(inds, x1, y1) bed2 = bed.copy() bed2[inds] = b bed = bed2 if doplot == 1: if chunkmode != 4: for k in range(len(star_fp)): plot_2bedpicks( port_fp[k], star_fp[k], bed[ind_port[-1] * k:ind_port[-1] * (k + 1)], dist_m[ind_port[-1] * k:ind_port[-1] * (k + 1)], x[ind_port[-1] * k:ind_port[-1] * (k + 1)], ft, shape_port, sonpath, k, chunkmode) else: plot_2bedpicks(port_fp, star_fp, bed, dist_m, x, ft, shape_port, sonpath, 0, chunkmode) else: #manual beds = [] if chunkmode != 4: for k in range(len(port_fp)): raw_input( "Bed picking " + str(k + 1) + " of " + str(len(port_fp)) + ", are you ready? 30 seconds. Press Enter to continue..." ) bed = {} fig = plt.figure() ax = plt.gca() im = ax.imshow(port_fp[k], cmap='gray', origin='upper') pts1 = plt.ginput( n=300, timeout=30 ) # it will wait for 200 clicks or 60 seconds x1 = map(lambda x: x[0], pts1) # map applies the function passed as y1 = map( lambda x: x[1], pts1) # first parameter to each element of pts bed = np.interp(np.r_[:ind_port[-1]], x1, y1) plt.close() del fig beds.append(bed) extent = np.shape(port_fp[k])[0] bed = np.asarray(np.hstack(beds), 'float') else: raw_input( "Bed picking - are you ready? 30 seconds. Press Enter to continue..." ) bed = {} fig = plt.figure() ax = plt.gca() im = ax.imshow(port_fp, cmap='gray', origin='upper') pts1 = plt.ginput( n=300, timeout=30 ) # it will wait for 200 clicks or 60 seconds x1 = map(lambda x: x[0], pts1) # map applies the function passed as y1 = map(lambda x: x[1], pts1) # first parameter to each element of pts bed = np.interp(np.r_[:ind_port[-1]], x1, y1) plt.close() del fig beds.append(bed) extent = np.shape(port_fp)[1] bed = np.asarray(np.hstack(beds), 'float') # now revise the depth in metres dep_m = (1 / ft) * bed if doplot == 1: if chunkmode != 4: for k in range(len(star_fp)): plot_bedpick( port_fp[k], star_fp[k], (1 / ft) * bed[ind_port[-1] * k:ind_port[-1] * (k + 1)], dist_m[ind_port[-1] * k:ind_port[-1] * (k + 1)], ft, shape_port, sonpath, k, chunkmode) else: plot_bedpick(port_fp, star_fp, (1 / ft) * bed, dist_m, ft, shape_port, sonpath, 0, chunkmode) metadat['bed'] = bed[:nrec] else: metadat['bed'] = dep_m[:nrec] * ft metadat['heading'] = metadat['heading'][:nrec] metadat['lon'] = lon[:nrec] metadat['lat'] = lat[:nrec] metadat['dist_m'] = dist_m[:nrec] metadat['dep_m'] = dep_m[:nrec] metadat['pix_m'] = 1 / ft metadat['bed'] = metadat['bed'][:nrec] metadat['c'] = c metadat['t'] = t if model == 2: metadat['f'] = f * 2 else: metadat['f'] = f metadat['spd'] = metadat['spd'][:nrec] metadat['time_s'] = metadat['time_s'][:nrec] metadat['e'] = metadat['e'][:nrec] metadat['n'] = metadat['n'][:nrec] metadat['es'] = metadat['es'][:nrec] metadat['ns'] = metadat['ns'][:nrec] try: metadat['caltime'] = metadat['caltime'][:nrec] except: metadat['caltime'] = metadat['caltime'] savemat(os.path.normpath(os.path.join(sonpath, base + 'meta.mat')), metadat, oned_as='row') f = open(os.path.normpath(os.path.join(sonpath, base + 'rawdat.csv')), 'wt') writer = csv.writer(f) writer.writerow( ('longitude', 'latitude', 'easting', 'northing', 'depth (m)', 'distance (m)', 'instr. heading (deg)', 'heading (deg.)')) for i in range(0, nrec): writer.writerow( (float(lon[i]), float(lat[i]), float(es[i]), float(ns[i]), float(dep_m[i]), float(dist_m[i]), float(metadat['instr_heading'][i]), float(metadat['heading'][i]))) f.close() del lat, lon, dep_m #, dist_m if doplot == 1: plot_pos(sonpath, metadat, es, ns) if 'dwnlow_fp' in locals(): plot_dwnlow(dwnlow_fp, chunkmode, sonpath) if 'dwnhi_fp' in locals(): plot_dwnhi(dwnhi_fp, chunkmode, sonpath) if os.name == 'posix': # true if linux/mac elapsed = (time.time() - start) else: # windows elapsed = (time.clock() - start) print("Processing took " + str(elapsed) + "seconds to analyse") print("Done!") print("===================================================")