def dot_plan(self, t_step): return torch.from_numpy( np.hstack([ spalde(t_step, self._x_spl)[0], spalde(t_step, self._y_spl)[0], spalde(t_step, self._yaw_spl)[0] ])).to(device=getattr(self.x0, 'device', None), dtype=self.x0.dtype)
def getNormal(self, point): best = self.controlpoints[0] spot = 0 for i in np.linspace(0, 1, 50): sa = spalde(float(i), self.tck) new = (sa[0][0], sa[1][0]) if euclidean(point, new) < euclidean(point, best): best = new spot = i sa = spalde(float(spot), self.tck) dvector = np.array([sa[0][1], sa[1][1]]) normal = normalizeVector(rotateVector(dvector, angle=.5*pi)) return normal
def make_spline(points, config): # TODO: periodic in new version # tck, u = splprep([points[0, :], points[1, :]], k=3, s=points.shape[1] * config['s_factor'], per=1) points[1, :] *= -1. tck, u = splprep([points[0, :], points[1, :]], k=3, s=points.shape[1] * config['s_factor'], per=1) spline_size = (points.shape[1] - 1) * config['interp_factor'] # make a u vector that has much more values for interpolation new_u = np.arange(spline_size) new_u = new_u / float(spline_size - 1) # evaluate spline, out is Nx2 spline = np.asarray(splev(new_u, tck)).T # get thetas derivs = spalde(new_u, tck) Dx = np.asarray(derivs[0]) Dy = np.asarray(derivs[1]) dx = Dx[:, 1] dy = Dy[:, 1] ddx = Dx[:, 2] ddy = Dy[:, 2] curvature = (dx * ddy - dy * ddx) / ((dx * dx + dy * dy)**1.5) theta = np.arctan2(dy, dx) return spline, theta, curvature
def main(): args = get_argparser().parse_args() init_logger(args) dev = Client(args.server, args.port, "pdq2") freq = dev.get_freq() times = np.around(eval(args.times, globals(), {}) * freq) voltages = eval(args.voltages, globals(), dict(t=times / freq)) dt = np.diff(times.astype(np.int)) if args.order: tck = interpolate.splrep(times, voltages, k=args.order, s=0) u = interpolate.spalde(times, tck) else: u = voltages[:, None] segment = [] for dti, ui in zip(dt, u): segment.append({ "duration": int(dti), "channel_data": [{ "bias": { "amplitude": [float(uij) for uij in ui] } }] }) program = [[] for i in range(args.frame)] program.append(segment) dev.park() dev.program(program, [args.channel]) dev.unpark() dev.cmd("TRIGGER", args.free)
def main(dev=None): """Test a PDQ2 stack. Parse command line arguments, configures PDQ2 stack, interpolate the time/voltage data using a spline, generate a wavesynth program from the data and upload it to the specified channel. Then perform the desired arming/triggering/starting functions on the stack. """ parser = get_argparser() args = parser.parse_args() if args.debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.WARNING) if args.dump: dev = open(args.dump, "wb") dev = Pdq2(args.serial, dev) if args.reset: dev.write(b"\x00\x00") # flush any escape dev.cmd("RESET", True) time.sleep(.1) dev.cmd("DCM", args.multiplier) freq = 50e6 if args.multiplier: freq *= 2 times = np.around(eval(args.times, globals(), {})*freq) voltages = eval(args.voltages, globals(), dict(t=times/freq)) dev.cmd("START", False) dev.cmd("ARM", True) dev.cmd("TRIGGER", True) dt = np.diff(times.astype(np.int)) if args.order: tck = interpolate.splrep(times, voltages, k=args.order, s=0) u = interpolate.spalde(times, tck) else: u = voltages[:, None] segment = [] for dti, ui in zip(dt, u): segment.append({ "duration": int(dti), "channel_data": [{ "bias": { "amplitude": [float(uij) for uij in ui] } }] }) program = [[] for i in range(dev.channels[args.channel].num_frames)] program[args.frame] = segment dev.program(program, [args.channel]) dev.cmd("TRIGGER", args.free) dev.cmd("ARM", not args.disarm) dev.cmd("START", True)
def main(): args = get_argparser().parse_args() init_logger(args) dev = Client(args.server, args.port, "pdq2") freq = dev.get_freq() times = np.around(eval(args.times, globals(), {})*freq) voltages = eval(args.voltages, globals(), dict(t=times/freq)) dt = np.diff(times.astype(np.int)) if args.order: tck = interpolate.splrep(times, voltages, k=args.order, s=0) u = interpolate.spalde(times, tck) else: u = voltages[:, None] segment = [] for dti, ui in zip(dt, u): segment.append({ "duration": int(dti), "channel_data": [{ "bias": { "amplitude": [float(uij) for uij in ui] } }] }) program = [[] for i in range(args.frame)] program.append(segment) dev.park() dev.program(program, [args.channel]) dev.unpark() dev.cmd("TRIGGER", args.free)
def test_spalde_scalar_input(self): """Ticket #629""" x = np.linspace(0,10) y = x**3 tck = interp.splrep(x, y, k=3, t=[5]) res = interp.spalde(np.float64(1), tck) des = np.array([1., 3., 6., 6.]) assert_almost_equal(res, des)
def test_spalde_scalar_input(self): """Ticket #629""" x = np.linspace(0, 10) y = x**3 tck = interp.splrep(x, y, k=3, t=[5]) res = interp.spalde(np.float64(1), tck) des = np.array([1., 3., 6., 6.]) assert_almost_equal(res, des)
def computeScore(self, path, initial_direction=None): """ Computes the score for a given path. Considering also degenerate paths Parameters ---------- path : AriadnePath target path initial_direction : np.array initial direction used to compute the score of single-edge paths """ ####################################### # Path with k nodes ####################################### if path.size() <= self.k: return 1.0 ####################################### # Normal Path ####################################### spline = self.computeSpline(path) if spline is None: return 1.0 u = spline['u'] tck = spline['tck'] der = spalde(u, tck) total_curvature = 0.0 total_curvature_pos = 0.0 for i in range(0, len(u)): d1 = (der[0][i][1], der[1][i][1]) d2 = (der[0][i][2], der[1][i][2]) x1 = d1[0] y1 = d1[1] x2 = d2[0] y2 = d2[1] curvature = (x1 * y2 - y1 * x2) / \ ((x1 * x1 + y1 * y1)**(3.0 / 2.0)) total_curvature += curvature total_curvature_pos += math.fabs(curvature) normalized_curvature = total_curvature_pos / float(len(u)) final_curvature = min(1.0, 1.0 - normalized_curvature) return final_curvature
def eval_spline(self, dist): """Use spline to generate point Args: dist (float): lane change dist Returns: spalde: Evaluate all derivatives of a B-spline. https://docs.scipy.org/doc/scipy-0.18.1/reference/generated/scipy.interpolate.spalde.html """ center_line = self._track_data.center_line min_dist = self._lane["spline"][0][SPLINE_DEGREE] max_dist = self._lane["spline"][0][-SPLINE_DEGREE - 1] if dist < min_dist: dist += center_line.length if dist > max_dist: dist -= center_line.length return spalde(max(min_dist, min(dist, max_dist)), self._lane["spline"])
def computeCurvatures(self, spline): u = spline['u'] tck = spline['tck'] der = spalde(u, tck) curvatures = np.zeros((len(u), 1)) for i in range(0, len(u)): d1 = (der[0][i][1], der[1][i][1]) d2 = (der[0][i][2], der[1][i][2]) x1 = d1[0] y1 = d1[1] x2 = d2[0] y2 = d2[1] curvature = (x1 * y2 - y1 * x2) / \ ((x1 * x1 + y1 * y1)**(3.0 / 2.0)) curvatures[i] = curvature return curvatures
def _eval_spline(self, initial_dist, sim_time, spline): '''Use spline to generate point Args: initial_dist (float): bot car initial distance sim_time (float): current simulation time spline (splprep): B-spline representation of an N-dimensional curve. https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.interpolate.splprep.html Returns: spalde: Evaluate all derivatives of a B-spline. https://docs.scipy.org/doc/scipy-0.18.1/reference/generated/scipy.interpolate.spalde.html ''' center_line = self.track_data._center_line_ dist = self._get_dist_from_sim_time(initial_dist, sim_time) min_dist = spline[0][SPLINE_DEGREE] max_dist = spline[0][-SPLINE_DEGREE - 1] if dist < min_dist: dist += center_line.length if dist > max_dist: dist -= center_line.length return spalde(max(min_dist, min(dist, max_dist)), spline)
def splade(self,tx,tck): """ Task: wrapper around the scipy splade it computes the derivatives of the curves Input: tx 1d array of parameter values of the points interpolated 0 <= tx[i] <=1, and ordered increasingly e.g. np.linspace(0,1,m) tck the output of splprep: tck[0]= array of knots tck[1]= list of arrays =the coefficients of the spline polynomials in each point tck[2]= degree of the common polynomials Output: lder the values of the derivatives list of list of arrays D^k x_i[j]=lder[j][i][k] k degree of derivative i index of a point j component of point vector """ lder=spinterp.spalde(tx,tck) return(lder)
def preprocess_centerline(raw_centerline, config): # [x, y, theta, s] tck, u = splprep(raw_centerline[:, 0], raw_centerline[:, 1], s=config['preproc_smooth'], k=5, per=True) # unew = np.arange(0, 1.0, 0.002) unew = np.linspace(0., 1., config['num_preproc_points']) new_centerline = np.asarray(splev(unew, tck)).T diffs = np.linagl.norm(new_centerline[1:] - new_centerline[:-1], axis=1) s = np.cumsum(diffs) s = np.insert(s, 0, 0) derivs = spalde(unew, tck) Dx = np.asarray(derivs[0]) Dy = np.asarray(derivs[1]) dx = Dx[:, 1] dy = Dy[:, 1] theta = np.arctan2(dy, dx) waypoints = np.empty((new_centerline.shape[0], 4)) waypoints[:, 0:2] = new_centerline waypoints[:, 2] = theta waypoints[:, 3] = s return waypoints
def main(dev=None, args=None): """Test a PDQ stack. Parse command line arguments, configures PDQ stack, interpolate the time/voltage data using a spline, generate a wavesynth program from the data and upload it to the specified channel. Then perform the desired arming/triggering/starting functions on the stack. """ parser = get_argparser() args = parser.parse_args(args=args) if args.debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.WARNING) if args.dump: dev = open(args.dump, "wb") dev = PDQ(args.serial, dev) if args.reset: dev.write(b"") # flush eop dev.set_config(reset=True) time.sleep(.1) dev.set_crc(0) dev.checksum = 0 freq = 50e6 if args.multiplier: freq *= 2 times = np.around(eval(args.times, globals(), {})*freq) voltages = eval(args.voltages, globals(), dict(t=times/freq)) dev.set_config(reset=False, clk2x=args.multiplier, enable=False, trigger=False, aux_miso=args.aux_miso, aux_dac=args.aux_dac, board=0xf) dt = np.diff(times.astype(np.int)) if args.order and interpolate: tck = interpolate.splrep(times, voltages, k=args.order, s=0) u = interpolate.spalde(times, tck) else: u = voltages[:, None] segment = [] for dti, ui in zip(dt, u): segment.append({ "duration": int(dti), "channel_data": [{ "bias": { "amplitude": [float(uij) for uij in ui] } }] }) program = [[] for i in range(dev.channels[args.channel].num_frames)] program[args.frame] = segment dev.program(program, [args.channel]) dev.set_frame(args.frame) dev.set_config(reset=False, clk2x=args.multiplier, enable=not args.disarm, trigger=args.free, aux_miso=args.aux_miso, aux_dac=args.aux_dac, board=0xf)
def updateVesselWidthRelatedParameters(Img, dict_side1_updated, dict_side2_updated, dict_vesselAngles): if len(Img.shape) == 3: Img_green = Img[:, :, 1] else: Img_green = Img.copy() # clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) # Img_green = clahe.apply(Img_green) Img_green_illum = illuminationCorrection2(Img_green, kernel_size=35, filterOption=0) X = np.arange(0, Img_green.shape[0]) Y = np.arange(0, Img_green.shape[1]) InterpFunc = interpolate.RectBivariateSpline( X, Y, Img_green_illum) # Img_green_illum dict_vesselWidth_updated = {} dict_splinePoints_updated = {} ##no need to update splinePoints dict_smoothSide1_updated = {} dict_smoothSide2_updated = {} dict_profileIntensity_updated = {} for vesselKey in dict_side1_updated.keys(): if len(dict_side1_updated[vesselKey] [0]) > 20: #if the vessel is shorter than 20 then remove it dict_vesselWidth_updated[vesselKey] = np.hypot( (dict_side1_updated[vesselKey][0] - dict_side2_updated[vesselKey][0]), (dict_side1_updated[vesselKey][1] - dict_side2_updated[vesselKey][1])) # try: tempMaxWidth = np.max(dict_vesselWidth_updated[vesselKey]) tempMaxWidth = np.ceil(tempMaxWidth) + 2 """Later test the cases that part of the side1 and 2 are removed""" ##Update smoothside1 and 2 sidePointList1 = np.array([ dict_side1_updated[vesselKey][0].reshape(-1), dict_side1_updated[vesselKey][1].reshape(-1) ]) sidePointList2 = np.array([ dict_side2_updated[vesselKey][0].reshape(-1), dict_side2_updated[vesselKey][1].reshape(-1) ]) dict_smoothSide1_updated[vesselKey] = splineInterpolation( sidePointList1, order=2) dict_smoothSide2_updated[vesselKey] = splineInterpolation( sidePointList2, order=2) ##Update the dict_profileIntensity centerline0 = np.concatenate( ((dict_side1_updated[vesselKey][0].reshape(-1,1) + dict_side2_updated[vesselKey][0].reshape(-1,1)) / 2.0, \ (dict_side1_updated[vesselKey][1].reshape(-1,1)+ dict_side2_updated[vesselKey][1].reshape(-1,1)) / 2.0), axis=1) controlPoint = centerline0[::5, :] order = 1 tck, u = interpolate.splprep(controlPoint.transpose(), k=order, s=0) unew = np.linspace(0, 1.00, centerline0.shape[0]) out = interpolate.splev(unew, tck) dict_splinePoints_updated[vesselKey] = out derivative = interpolate.spalde( unew, tck ) ##two lists are returned, the first list is derivative for row, second is for col. der_row = np.array(derivative[0]) der_col = np.array(derivative[1]) der = np.array([der_row[:, 1], der_col[:, 1]]).transpose() normal1 = np.dot(der, np.array([[0, 1], [-1, 0]])) normal1 = np.float32(normal1) / np.tile( np.sqrt(normal1[:, 0]**2 + normal1[:, 1]**2), (2, 1)).transpose() dict_vesselAngles[vesselKey] = normal1 inc = np.arange(0, tempMaxWidth) - tempMaxWidth // 2 tempProfileRows = np.dot(normal1[:, 0].reshape( (-1, 1)), inc.reshape(1, -1)) + np.tile( out[0].reshape(-1, 1), (1, len(inc))) tempProfileCols = np.dot(normal1[:, 1].reshape( (-1, 1)), inc.reshape(1, -1)) + np.tile( out[1].reshape(-1, 1), (1, len(inc))) dict_profileIntensity_updated[vesselKey] = InterpFunc.ev( tempProfileRows, tempProfileCols) else: dict_side1_updated.pop(vesselKey) dict_side2_updated.pop(vesselKey) return dict_splinePoints_updated, dict_profileIntensity_updated, dict_side1_updated, dict_side2_updated, \ dict_smoothSide1_updated, dict_smoothSide2_updated, dict_vesselWidth_updated
def alde(self, x): u = np.array([spalde(x, si) for si in self.s]) if len(x) == 1: u = u[:, None, :] return u
def vesselWidthProfile(Img, IllumImage, Img_BW, Mask, dict_segmentPixelLocs): if len(Img.shape) == 3: Img_green = Img[:, :, 1] else: Img_green = Img Img_BW[Img_BW > 0] = 1 Mask[Mask > 0] = 1 height, width = Img_BW.shape[:2] if len(IllumImage.shape) == 3: IllumGreenReverse = np.uint8(255 - IllumImage[:, :, 1]) else: IllumGreenReverse = np.uint8(255 - IllumImage) #print IllumGreenReverse.shape, " =?= ", Mask.shape try: IllumGreenReverse = cv2.bitwise_and(IllumGreenReverse, IllumGreenReverse, mask=Mask) except: print 'error creating IllumGreenReverse' #Mask = np.array([np.append(Img_BW[k], 0) for k in range(0, len(Img_BW))]) import pdb pdb.set_trace() DistTransform_vessel = cv2.distanceTransform( Img_BW, distanceType=cv2.cv.CV_DIST_L2, maskSize=cv2.cv.CV_DIST_MASK_PRECISE) maxVesselWidth = 6 * np.max(DistTransform_vessel) """smooth the skeleton image into a spline image.""" ##for RectBivariateSpline X = np.arange(0, Img_green.shape[0]) Y = np.arange(0, Img_green.shape[1]) InterpFunc_Illum = interpolate.RectBivariateSpline( X, Y, IllumGreenReverse) #ImgGreenReverse InterpFunc = interpolate.RectBivariateSpline(X, Y, Img_green) #ImgGreenReverse ##The interpolated image should be the reverse image SplineImg = np.zeros(Img_BW.shape) dict_splinePoints = {} dict_centerPoint = {} dict_vesselAngles = {} dict_profileRows = {} dict_profileCols = {} dict_profileIntensity = {} dict_profileIntensity_Illum = {} for vesselLabel in dict_segmentPixelLocs.keys(): #['1', '2', '15', '25'] pixelLocs0 = dict_segmentPixelLocs[vesselLabel] if pixelLocs0.shape[ 0] >= 21: #11 previously. This means that vessel length <11 are not used for width calculation. pixelLocs = pixelLocs0[ 5: -5, :] #the first and end 5 pixels near branch points are removed controlPoint = pixelLocs[np.arange( len(pixelLocs))[::10], :] ##select every other 5 points. for loc in controlPoint: SplineImg[int(loc[0]), int(loc[1])] = 1 order = 1 tck, u = interpolate.splprep(controlPoint.transpose(), k=order, s=0) unew = np.linspace(0, 1.00, len(pixelLocs)) out = interpolate.splev(unew, tck) dict_splinePoints[vesselLabel] = out derivative = interpolate.spalde( unew, tck ) ##two lists are returned, the first list is derivative for row, second is for col. der_row = np.array(derivative[0]) der_col = np.array(derivative[1]) der = np.array([der_row[:, 1], der_col[:, 1]]).transpose() normal1 = np.dot(der, np.array([[0, 1], [-1, 0]])) normal1 = np.float32(normal1) / np.tile( np.sqrt(normal1[:, 0]**2 + normal1[:, 1]**2), (2, 1)).transpose() dict_centerPoint[vesselLabel] = (out[0], out[1]) dict_vesselAngles[vesselLabel] = normal1 inc = np.arange(0, maxVesselWidth) - maxVesselWidth // 2 dict_profileRows[vesselLabel] = np.dot( normal1[:, 0].reshape((-1, 1)), inc.reshape(1, -1)) + np.tile( out[0].reshape(-1, 1), (1, len(inc))) dict_profileCols[vesselLabel] = np.dot( normal1[:, 1].reshape((-1, 1)), inc.reshape(1, -1)) + np.tile( out[1].reshape(-1, 1), (1, len(inc))) """Remove the ones outside image region""" dict_profileRows[vesselLabel][ dict_profileRows[vesselLabel] >= height - 1] = np.nan dict_profileRows[vesselLabel][ dict_profileRows[vesselLabel] < 0] = np.nan dict_profileRows[vesselLabel][ dict_profileCols[vesselLabel] >= width - 1] = np.nan dict_profileRows[vesselLabel][ dict_profileCols[vesselLabel] < 0] = np.nan dict_profileCols[vesselLabel][np.isnan( dict_profileRows[vesselLabel])] = np.nan dict_profileRows[vesselLabel] = dict_profileRows[vesselLabel][ ~np.isnan(dict_profileRows[vesselLabel]).any(axis=1)] dict_profileCols[vesselLabel] = dict_profileCols[vesselLabel][ ~np.isnan(dict_profileCols[vesselLabel]).any(axis=1)] dict_profileIntensity[vesselLabel] = InterpFunc.ev( dict_profileRows[vesselLabel], dict_profileCols[vesselLabel]) dict_profileIntensity_Illum[vesselLabel] = InterpFunc_Illum.ev( dict_profileRows[vesselLabel], dict_profileCols[vesselLabel]) ################################################################## """To calculate the acurate vessel width and vessel edges""" smooth_scale_parallel = 3 smooth_scale_perpendicular = 0.15 enforce_connectedness = True dict_ProfileMap, dict_BWVesselProfiles, dict_BWRegionProfiles = createVesselProfileMasks( dict_profileRows, dict_profileCols, Img_BW, Mask) dict_side1 = {} dict_side2 = {} dict_smoothSide1 = {} dict_smoothSide2 = {} dict_vesselWidth = {} dict_profileSide = {} for vesselKey in dict_profileRows.keys(): #% Create the default side coordinates dict_side1[vesselKey] = (np.zeros(len(dict_centerPoint[vesselKey][0])), np.zeros(len(dict_centerPoint[vesselKey][1]))) dict_side2[vesselKey] = (np.zeros(len(dict_centerPoint[vesselKey][0])), np.zeros(len(dict_centerPoint[vesselKey][1]))) #Extract the profiles and coordinates im_profiles = dict_profileIntensity_Illum[vesselKey] im_profiles_rows = dict_profileRows[vesselKey] im_profiles_cols = dict_profileCols[vesselKey] n_profiles = dict_profileRows[vesselKey].shape[0] ##get the width estimate of each vessel col_central = dict_profileIntensity_Illum[vesselKey].shape[1] // 2 BW_vessel_profiles = dict_BWVesselProfiles[vesselKey] binary_sums = np.sum(BW_vessel_profiles, 1) width_estimate0 = np.median( binary_sums) #[BW_vessel_profiles[:, col_central]] if width_estimate0 > col_central: width_estimate0 = col_central ##Compute a mean profile for the entire vessel, omitting pixels closer to other vessels BW_regions = dict_BWRegionProfiles[vesselKey] im_profiles_closest = im_profiles.copy() im_profiles_closest[np.bitwise_not(BW_regions)] = np.NaN profile_mean = np.nanmean(im_profiles_closest, 0) try: left_mean_col, right_mean_col = find_maximum_gradient_columns( profile_mean.copy(), width_estimate0) #profile_mean will be changed inside the func except: pass width_estimate = right_mean_col - left_mean_col # Create 1D Gaussian filters for smoothing parallel and perpendicular to the vessel # Sigma values are based on the square root of the scaled width # estimates gv = gaussian_filter_1d_sigma( np.sqrt(width_estimate * smooth_scale_parallel)).reshape(-1, 1) gh = gaussian_filter_1d_sigma( np.sqrt(width_estimate * smooth_scale_perpendicular)).reshape( -1, 1) #Apply Gaussian smoothing im_profiles_filtered = filters.convolve(im_profiles, np.dot(gv, gh.transpose())) #Compute 2nd derivative perpendicular to vessel orientation im_profiles_2d = compute_discrete_2d_derivative(im_profiles_filtered) ##Remove from consideration pixels outside the search region im_profiles_2d[np.bitwise_not(BW_regions)] = np.NAN diffs = np.diff(im_profiles_2d, axis=1) cross_offsets = -im_profiles_2d[:, :-1] / diffs cross_offsets[np.bitwise_or(cross_offsets >= 1, cross_offsets < 0)] = np.NAN cross = cross_offsets + np.tile(np.arange(0, cross_offsets.shape[1]), (cross_offsets.shape[0], 1)) #Separate crossings according to whether they are positive -> negative #or negative -> positive, i.e. whether they are potentially rising or #falling edges, and only allow those on the appropriate size of the centerline cross_rising0 = cross.copy() cross_rising0[np.bitwise_or(diffs > 0, cross_rising0 > col_central)] = np.NAN cross_falling0 = cross.copy() cross_falling0[np.bitwise_or(diffs < 0, cross_falling0 < col_central)] = np.NAN #Look for the vessel edges, with or without a connectivity test. if not enforce_connectedness: search_left = im_profiles_2d[:, left_mean_col] <= 0 col_left = find_closest_crossing(cross_rising0.copy(), left_mean_col, search_left) search_left = im_profiles_2d[:, right_mean_col] >= 0 col_right = find_closest_crossing(cross_falling0.copy(), right_mean_col, search_left) else: cross_rising = find_most_connected_crossings( cross_rising0.copy(), left_mean_col, np.maximum(width_estimate / 3.0, 1)) col_left = np.nanmax(cross_rising, 1) cross_falling = find_most_connected_crossings( cross_falling0.copy(), right_mean_col, np.maximum(width_estimate / 3.0, 1)) col_right = np.nanmin(cross_falling, 1) #% Compute the side points, and store them rows = np.arange(0, n_profiles).reshape(-1, 1) inds_found = np.bitwise_and(np.isfinite(col_left), np.isfinite(col_right)) dict_side1[vesselKey] = get_side(im_profiles_rows, im_profiles_cols, rows[inds_found], col_left[inds_found].reshape(-1, 1)) dict_side2[vesselKey] = get_side(im_profiles_rows, im_profiles_cols, rows[inds_found], col_right[inds_found].reshape(-1, 1)) sidePointList1 = np.array([ dict_side1[vesselKey][0].reshape(-1), dict_side1[vesselKey][1].reshape(-1) ]) sidePointList2 = np.array([ dict_side2[vesselKey][0].reshape(-1), dict_side2[vesselKey][1].reshape(-1) ]) dict_smoothSide1[vesselKey] = splineInterpolation(sidePointList1, order=2) dict_smoothSide2[vesselKey] = splineInterpolation(sidePointList2, order=2) dict_vesselWidth[vesselKey] = np.hypot( (dict_side1[vesselKey][0] - dict_side2[vesselKey][0]), (dict_side1[vesselKey][1] - dict_side2[vesselKey][1])) # dict_vesselWidth[vesselKey] = np.hypot((dict_smoothSide1[vesselKey][0] - dict_smoothSide2[vesselKey][0]), # (dict_smoothSide1[vesselKey][1] - dict_smoothSide2[vesselKey][1])) """Remove the vessels where the vessel side is not detected correctly""" for vesselKey in dict_side1.keys(): if len(dict_side1[vesselKey][0]) >= 20: pass else: ##delete the vessels where the side is not detected correctly dict_side1.pop(vesselKey) dict_side2.pop(vesselKey) dict_smoothSide1.pop(vesselKey) dict_smoothSide2.pop(vesselKey) dict_splinePoints.pop(vesselKey) dict_profileIntensity.pop(vesselKey) dict_vesselWidth.pop(vesselKey) dict_vesselAngles.pop(vesselKey) ######################################################################## """End of vessel profile measurement""" return dict_splinePoints, dict_profileIntensity, dict_side1, dict_side2, \ dict_smoothSide1, dict_smoothSide2, dict_vesselWidth, dict_vesselAngles, dict_profileRows, dict_profileCols
import numpy as np from matplotlib import pyplot as plt from scipy import interpolate x = np.linspace(0, 2 * np.pi + np.pi / 4, 10) y = np.sin(x) x_new = np.linspace(0, 2 * np.pi + np.pi / 4, 100) f_linear = interpolate.interp1d(x, y) para_bspline = interpolate.spalde(x, y) y_bspline = interpolate.splev(x_new, para_bspline) plt.plot(x, y, "o", label=u"yuanshishuju") plt.plot(x_new, f_linear(x_new), label=u"xianxingchazhi") plt.plot(x_new, y_bspline, label=u"B-spline chazhi") plt.legend() plt.grid(True) plt.show()
def main(dev=None, args=None): """Test a PDQ stack. Parse command line arguments, configures PDQ stack, interpolate the time/voltage data using a spline, generate a wavesynth program from the data and upload it to the specified channel. Then perform the desired arming/triggering/starting functions on the stack. """ parser = get_argparser() args = parser.parse_args(args=args) if args.debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.WARNING) if args.dump: dev = open(args.dump, "wb") dev = PDQ(args.serial, dev) if args.reset: dev.write(b"") # flush eop dev.set_config(reset=True) time.sleep(.1) dev.set_crc(0) dev.checksum = 0 freq = 50e6 if args.multiplier: freq *= 2 times = np.around(eval(args.times, globals(), {})*freq) voltages = eval(args.voltages, globals(), dict(t=times/freq)) dev.set_config(reset=False, clk2x=args.multiplier, enable=False, trigger=False, aux_miso=args.aux_miso, aux_dac=args.aux_dac, board=0xf) dt = np.diff(times.astype(np.int)) if args.order and interpolate: tck = interpolate.splrep(times, voltages, k=args.order, s=0) u = interpolate.spalde(times, tck) else: u = voltages[:, None] segment = [] for dti, ui in zip(dt, u): segment.append({ "duration": int(dti), "channel_data": [{ "bias": { "amplitude": [float(uij) for uij in ui] } }] }) program = [[] for i in range(dev.channels[args.channel].num_frames)] program[args.frame] = segment if args.print: if args.print == '-': f = sys.stdout else: f = open(args.print, 'w') print('# Generated WaveSynth program\n\nprogram = \\', file=f) pprint.pprint(program, f) dev.program(program, [args.channel]) dev.set_frame(args.frame) dev.set_config(reset=False, clk2x=args.multiplier, enable=not args.disarm, trigger=args.free, aux_miso=args.aux_miso, aux_dac=args.aux_dac, board=0xf)
def spline_derivative(x_vector, y_vector): """Take a derivative using a spline""" tck = interpolate.splrep(x_vector, y_vector, k=3) deriv_y = np.array(interpolate.spalde(x_vector, tck)) deriv_y = deriv_y[:, 1] # take the first derivative of the spline return deriv_y
def main(dev=None): """Test a PDQ2 stack. Parse command line arguments, configures PDQ2 stack, interpolate the time/voltage data using a spline, generate a wavesynth program from the data and upload it to the specified channel. Then perform the desired arming/triggering/starting functions on the stack. """ parser = get_argparser() args = parser.parse_args() if args.debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.WARNING) if args.dump: dev = open(args.dump, "wb") dev = Pdq2(args.serial, dev) if args.reset: dev.write(b"\x00\x00") # flush any escape dev.cmd("RESET", True) time.sleep(.1) dev.cmd("DCM", args.multiplier) freq = 50e6 if args.multiplier: freq *= 2 times = np.around(eval(args.times, globals(), {}) * freq) voltages = eval(args.voltages, globals(), dict(t=times / freq)) dev.cmd("START", False) dev.cmd("ARM", True) dev.cmd("TRIGGER", True) dt = np.diff(times.astype(np.int)) if args.order: tck = interpolate.splrep(times, voltages, k=args.order, s=0) u = interpolate.spalde(times, tck) else: u = voltages[:, None] segment = [] for dti, ui in zip(dt, u): segment.append({ "duration": int(dti), "channel_data": [{ "bias": { "amplitude": [float(uij) for uij in ui] } }] }) program = [[] for i in range(dev.channels[args.channel].num_frames)] program[args.frame] = segment dev.program(program, [args.channel]) dev.cmd("TRIGGER", args.free) dev.cmd("ARM", not args.disarm) dev.cmd("START", True)
def processimage(imagefullpath='iimage-21.png', outputpath='./', pastresults=[]): try: imdata = scipy.misc.imread(imagefullpath)[:,:,0] except: imdata = scipy.misc.imread(imagefullpath) # structure: 0 outside, 255 inside imagename = imagefullpath.split('/')[-1] # find the starting point firstline = imdata[:,0] w = [scipy.where(firstline==255)[0][0],0] b = [w[0]-1,0] # state=0 means that white moves state = 0 maxx = scipy.shape(imdata)[0] maxy = scipy.shape(imdata)[1] ws = [w,] bs = [b,] rejcounter=0 while 1: if rejcounter<2: position, expectation = rotate(bs[-1], ws[-1], state) else: position, expectation = rotate(bs[-1], ws[-1], state, steps=2) if position[0]<0 or position[0]>=maxx or position[1]<0 or position[1]>=maxy: # out of bounds rejection if state == 0: rejcounter += 1 else: bs.append(position) rejcounter = 0 elif imdata[position[0], position[1]] == expectation: if state == 0: ws.append(position) else: bs.append(position) rejcounter=0 else: rejcounter += 1 state = (state + 1) % 2 # break if we have a closed loop if ws[-1] in ws[:10] and len(ws)>10: break ws = scipy.array(ws) lineimage = 255*scipy.ones(scipy.shape(imdata)) for w in ws: lineimage[w[0], w[1]] = 0. scipy.misc.imsave(outputpath + 'line-'+imagename, lineimage) t = scipy.linspace(0.,1.,len(ws[:,0])) tck, u = interpolate.splprep([ws[:,0], ws[:,1]], s=1e3, k=2, per=1) #unew = scipy.linspace(0.,1.,10000) data = interpolate.splev(t,tck) # pylab.plot(data[0], data[1]) pylab.plot(ws[:,1], ws[:,0], color='blue') der = scipy.array(interpolate.spalde(t,tck)) # format [[x,y], [n], [0,1,2,3der]] # following wolfram mathworld curvature = (der[0,:,1]*der[1,:,2] - der[1,:,1]*der[0,:,2])/(der[0,:,1]**2 + der[1,:,1]**2)**1.5 csmooth = scipy.ndimage.gaussian_filter1d(curvature, 7.) # splitting when the curvature changes limit = -0.01 splits1 = scipy.where(numpy.r_[csmooth[1:] < limit,] & numpy.r_[csmooth[:-1] > limit,])[0] splits2 = scipy.where(numpy.r_[csmooth[1:] > limit,] & numpy.r_[csmooth[:-1] < limit,])[0] res = scipy.concatenate((splits1,splits2)) res.sort() # clean up too short segments i=0 while i < len(res)-1: if res[i+1]-res[i]<35: try: res = scipy.concatenate([res[:i],res[i+2:]]) except: res = res[:i] else: i+=1 # pdb.set_trace() currentresults = [] used = [] # determine the maximum ID number used to date maxidnumber = 0 for set in pastresults: oldx,oldy, oldidnumber, olddata = set maxidnumber = max(maxidnumber, oldidnumber) for l,r in zip(res[:-1],res[1:]): c = curvature[l:r] if c.mean()>0: pylab.plot(data[1][l:r],data[0][l:r], color='red') else: x = data[0][l+sp:r-sp] y = data[1][l+sp:r-sp] pylab.plot(y, x, color='green') if y.mean()>50 and 50<x.mean()<maxx-50 and r-l>20+2*sp: # fit these points with a circle center, radius = getCenterRadius(ws[l+sp:r-sp,0], ws[l+sp:r-sp,1]) pylab.gca().add_patch(pylab.Circle([center[1],center[0]], radius=radius, fc='None')) pylab.text(y.mean(), x.mean(), '%1.2f'%radius, fontsize='x-small') select = [] newset = False for set in pastresults: oldx,oldy, oldidnumber, olddata = set distance = (x.mean()-oldx)**2 + (y.mean()-oldy)**2 select.append([distance, oldidnumber, olddata]) select.sort() try: newdata = select[0][-1] + [[x.mean(), y.mean(), radius,],] if used.__contains__(select[0][-1]): newset = True used.append(select[0][-1]) except: newdata = [[x.mean(), y.mean(), radius,],] newset = True if newset == True: maxidnumber += 1 idnumber = maxidnumber else: idnumber = select[0][1] print idnumber pylab.text(y.mean(), x.mean() - 20, '%d'%idnumber, fontsize='x-small') currentresults.append([x.mean(), y.mean(), idnumber, newdata]) pylab.axis([0.,maxy,0.,maxx]) # KEEP TIME SERIES THAT WERE NOT EXTENDED for set in pastresults: if not used.__contains__(set[-1]): set[-1] += [[scipy.nan, scipy.nan, scipy.nan,],] currentresults.append(set) pylab.savefig(outputpath + 'processed-'+imagename+'.pdf') pylab.clf() return currentresults