我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.hypot()。
def test_NotImplemented_not_returned(self): # See gh-5964 and gh-2091. Some of these functions are not operator # related and were fixed for other reasons in the past. binary_funcs = [ np.power, np.add, np.subtract, np.multiply, np.divide, np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or, np.bitwise_xor, np.left_shift, np.right_shift, np.fmax, np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2, np.logical_and, np.logical_or, np.logical_xor, np.maximum, np.minimum, np.mod ] # These functions still return NotImplemented. Will be fixed in # future. # bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal] a = np.array('1') b = 1 for f in binary_funcs: assert_raises(TypeError, f, a, b)
def _vlines(lines, ctrs=None, lengths=None, vecs=None, angle_lo=20, angle_hi=160, ransac_options=RANSAC_OPTIONS): ctrs = ctrs if ctrs is not None else lines.mean(1) vecs = vecs if vecs is not None else lines[:, 1, :] - lines[:, 0, :] lengths = lengths if lengths is not None else np.hypot(vecs[:, 0], vecs[:, 1]) angles = np.degrees(np.arccos(vecs[:, 0] / lengths)) points = np.column_stack([ctrs[:, 0], angles]) point_indices, = np.nonzero((angles > angle_lo) & (angles < angle_hi)) points = points[point_indices] if len(points) > 2: model_ransac = linear_model.RANSACRegressor(**ransac_options) model_ransac.fit(points[:, 0].reshape(-1, 1), points[:, 1].reshape(-1, 1)) inlier_mask = model_ransac.inlier_mask_ valid_lines = lines[point_indices[inlier_mask], :, :] else: valid_lines = [] return valid_lines
def _hlines(lines, ctrs=None, lengths=None, vecs=None, angle_lo=20, angle_hi=160, ransac_options=RANSAC_OPTIONS): ctrs = ctrs if ctrs is not None else lines.mean(1) vecs = vecs if vecs is not None else lines[:, 1, :] - lines[:, 0, :] lengths = lengths if lengths is not None else np.hypot(vecs[:, 0], vecs[:, 1]) angles = np.degrees(np.arccos(vecs[:, 1] / lengths)) points = np.column_stack([ctrs[:, 1], angles]) point_indices, = np.nonzero((angles > angle_lo) & (angles < angle_hi)) points = points[point_indices] if len(points) > 2: model_ransac = linear_model.RANSACRegressor(**ransac_options) model_ransac.fit(points[:, 0].reshape(-1, 1), points[:, 1].reshape(-1, 1)) inlier_mask = model_ransac.inlier_mask_ valid_lines = lines[point_indices[inlier_mask], :, :] else: valid_lines = [] return valid_lines
def get_ind_under_point(self, event): """ get the index of the vertex under point if within epsilon tolerance :param event: qt event :return: index of selected point """ # display coords distances = numpy.hypot(event.xdata - self.curData[:, 0], event.ydata - self.curData[:, 1]) indmin = distances.argmin() if distances[indmin] >= self.epsilon: ind = None else: ind = indmin self.lastind = ind return ind
def calcPi(n): """ Calculating Pi using Monte Carlo Integration. Quickly estimates the first 2 decimals, but it is terribly inefficient for estimating other decimals. Source: http://www.stealthcopter.com/blog/2009/09/python-calculating-pi-using-random-numbers/ """ inside = 0.0 for i in range(n): x = np.random.random() y = np.random.random() # Calculate the length of hypotenuse given the sides x and y if np.hypot(x, y) <= 1: inside += 1 return 4.0*inside/n # Run the calcPi function without timing
def _filter(img, method, k): if method == 'Edge gradient': sy = cv2.Sobel(img, ddepth=cv2.CV_64F, dx=0, dy=1, ksize=k) sx = cv2.Sobel(img, ddepth=cv2.CV_64F,dx=1, dy=0, ksize=k) # sx = sobel(img, axis=0, mode='constant') # sy = sobel(img, axis=1, mode='constant') return np.hypot(sx, sy) if method == 'Sobel-H': return cv2.Sobel(img, ddepth=cv2.CV_64F,dx=0, dy=1, ksize=k) #sobel(img, axis=0, mode='constant') if method == 'Sobel-V': return cv2.Sobel(img, ddepth=cv2.CV_64F,dx=1, dy=0, ksize=k) #sobel(img, axis=1, mode='constant') if method == 'Laplace': return cv2.Laplacian(img, ddepth=cv2.CV_64F,ksize=5) #laplace(img)
def _pixel_select(self, event): x, y = event.xdata, event.ydata # get index by assuming even spacing # TODO use kdtree? diff = np.hypot((self.x_pos - x), (self.y_pos - y)) y_ind, x_ind = np.unravel_index(np.argmin(diff), diff.shape) # get the spectrum for this point new_y_data = self.counts[y_ind, x_ind, :] self.mask = np.zeros(self.x_pos.shape, dtype='bool') self.mask[y_ind, x_ind] = True self.mask_im.set_data(self._overlay_image) self._pixel_txt.set_text( 'pixel: [{:d}, {:d}] ({:.3g}, {:.3g})'.format( y_ind, x_ind, self.x_pos[y_ind, x_ind], self.y_pos[y_ind, x_ind])) self.spec.set_ydata(new_y_data) self.ax_spec.relim() self.ax_spec.autoscale(True, axis='y') self.fig.canvas.draw_idle()
def line_ball_collision_check(line, ball): # checks if the ball is half the line length from the line middle if distance_less_equal(line.middle, ball.pos, line.length / 2 + config.ball_radius): # displacement vector from the first point to the ball displacement_to_ball = ball.pos - line.line[0] # displacement vector from the first point to the second point on the # line displacement_to_second_point = line.line[1] - line.line[0] normalised_point_diff_vector = displacement_to_second_point / \ np.hypot(*(displacement_to_second_point)) # distance from the first point on the line to the perpendicular # projection point from the ball projected_distance = np.dot(normalised_point_diff_vector, displacement_to_ball) # closest point on the line to the ball closest_line_point = projected_distance * normalised_point_diff_vector perpendicular_vector = np.array( [-normalised_point_diff_vector[1], normalised_point_diff_vector[0]]) # checking if closest point on the line is actually on the line (which is not always the case when projecting) # then checking if the distance from that point to the ball is less than the balls radius and finally # checking if the ball is moving towards the line with the dot product return -config.ball_radius / 3 <= projected_distance <= \ np.hypot(*(displacement_to_second_point)) + config.ball_radius / 3 and \ np.hypot(*(closest_line_point - ball.pos + line.line[0])) <= \ config.ball_radius and np.dot( perpendicular_vector, ball.velocity) <= 0
def go_to_with_planner(self, x, y, t): start = self.position()[:-1] end = np.array([x, y]) points = self.planner.get_points(start=start, end=end, robot=self) def add_t(points, t): points = np.array(points) lens = np.hypot(points[:, 0], points[:, 1]) tpm = t / np.add.reduce(lens) npoints = np.zeros(shape=(points.shape[0], 3)) npoints[:, :-1] = points npoints[:, -1] = tpm * lens return npoints npoints = add_t(points, t) if not points: logging.warning("no available path. start=%r, end=%r", start, end) else: self.follow(points, t)
def dist(apos, bpos): """ Angular separation between two points on a sphere. http://en.wikipedia.org/wiki/Great-circle_distance """ (a_ra, a_dec), (b_ra, b_dec) = apos, bpos lon1 = a_ra / 180 * pi lat1 = a_dec / 180 * pi lon2 = b_ra / 180 * pi lat2 = b_dec / 180 * pi sdlon = sin(lon2 - lon1) cdlon = cos(lon2 - lon1) slat1 = sin(lat1) slat2 = sin(lat2) clat1 = cos(lat1) clat2 = cos(lat2) num1 = clat2 * sdlon num2 = clat1 * slat2 - slat1 * clat2 * cdlon denominator = slat1 * slat2 + clat1 * clat2 * cdlon return arctan2(hypot(num1, num2), denominator) * 180 / pi
def direction_map(dmap: DistanceMap): r"""Computes normalized gradient of distance map. Not defined when length of the gradient is zero. .. math:: \hat{\mathbf{e}}_{S} = -\frac{\nabla S(\mathbf{x})}{\| \nabla S(\mathbf{x}) \|} Args: dmap (numpy.ndarray): Distance map. Returns: DirectionMap: Direction map. """ u, v = np.gradient(dmap) l = np.hypot(u, v) # Avoids zero division l[l == 0] = np.nan # Flip order from (row, col) to (x, y) return v / l, u / l # Potentials
def collide(self, p1, p2): np = self.np dx = p1.x - p2.x dy = p1.y - p2.y elasticity = 1 dist = np.hypot(dx, dy) if dist < p1.size + p2.size: tangent = np.arctan2(dy, dx) angle = 0.5 * np.pi + tangent angle1 = 2*tangent - p1.angle angle2 = 2*tangent - p2.angle speed1 = p2.speed*elasticity speed2 = p1.speed*elasticity (p1.angle, p1.speed) = (angle1, speed1) (p2.angle, p2.speed) = (angle2, speed2) p1.x += np.sin(angle) p1.y -= np.cos(angle) p2.x -= np.sin(angle) p2.y += np.cos(angle)
def angles_from_sphere(pts): """equirectangular projection, ie. map from sphere in R^3 to (0, 2*pi) x (-pi/2, pi/2) Parameters ---------- pts : array_like (3,...) pts[0,...], pts[1,...], and pts[2,...] are x,y, and z coordinates Returns ------- out : ndarray (2,...) pts transformed from x,y,z to longitude,latitude """ pts = np.asarray(pts) #turn into an ndarray if necessary x,y,z = pts[0], pts[1], pts[2] out = np.empty((2,) + pts.shape[1:]) #longitude: out[0] = np.arctan2(y,x) out[0] %= 2*pi #wrap negative values around the circle to positive #latitude: r = np.hypot(x,y) out[1] = np.arctan2(z,r) return out
def get_dH2(lab1, lab2): """squared hue difference term occurring in deltaE_cmc and deltaE_ciede94 Despite its name, "dH" is not a simple difference of hue values. We avoid working directly with the hue value, since differencing angles is troublesome. The hue term is usually written as: c1 = sqrt(a1**2 + b1**2) c2 = sqrt(a2**2 + b2**2) term = (a1-a2)**2 + (b1-b2)**2 - (c1-c2)**2 dH = sqrt(term) However, this has poor roundoff properties when a or b is dominant. Instead, ab is a vector with elements a and b. The same dH term can be re-written as: |ab1-ab2|**2 - (|ab1| - |ab2|)**2 and then simplified to: 2*|ab1|*|ab2| - 2*dot(ab1, ab2) """ lab1 = np.asarray(lab1) lab2 = np.asarray(lab2) a1, b1 = np.rollaxis(lab1, -1)[1:3] a2, b2 = np.rollaxis(lab2, -1)[1:3] # magnitude of (a, b) is the chroma C1 = np.hypot(a1, b1) C2 = np.hypot(a2, b2) term = (C1 * C2) - (a1 * a2 + b1 * b2) return 2 * term
def _cart2polar_2pi(x, y): """convert cartesian coordinates to polar (uses non-standard theta range!) NON-STANDARD RANGE! Maps to ``(0, 2*pi)`` rather than usual ``(-pi, +pi)`` """ r, t = np.hypot(x, y), np.arctan2(y, x) t += np.where(t < 0., 2 * np.pi, 0) return r, t
def xy2angles(x,y): elout = 90-np.hypot(x,y) azout = np.degrees(np.arctan2(x,y)) return (azout,elout)
def parse(fname): """ Parse FGM format data *fname*. Return :class:`DataFrame` containing all information found in the file. The FGM file format is used by CARISMA to store data and is described here: http://www.carisma.ca/carisma-data/fgm-data-format. """ with open(fname) as fid: siteid, lat, lon, date, pos_format, units, sample_rate = fid.next().split() dt = [] x = [] y = [] z = [] flag = [] for line in fid: cols = line.split() dt.append(datetime.strptime(cols[0], '%Y%m%d%H%M%S')) x.append(float(cols[1])) y.append(float(cols[2])) z.append(float(cols[3])) if cols[4] == '.': flag.append(False) elif cols[4] == 'x': flag.append(True) else: raise ValueError('unknown flag value {} encountered in {}'.format(cols[4], fname)) f = NP.hypot(x, NP.hypot(y, z)) df = PD.DataFrame(data={'x': x, 'y': y, 'z': z, 'f': f, 'flag': flag}, index=dt) df.siteid = siteid df.lat = float(lat) df.lon = float(lon) df.date = datetime.strptime(date, '%Y%m%d') df.pos_format = pos_format df.units = units df.sample_rate = sample_rate return df
def cart2sph(x, y, z): '''Converts cartesian coordinates x, y, z to spherical coordinates az, el, r.''' hxy = _np.hypot(x, y) r = _np.hypot(hxy, z) el = _np.arctan2(z, hxy) az = _np.arctan2(y, x) return az, el, r
def _vh_lines(lines, ctrs=None, lengths=None, vecs=None, angle_lo=20, angle_hi=160, ransac_options=RANSAC_OPTIONS): assert len(lines) > 0, "We need some lines to start with!" ctrs = ctrs if ctrs is not None else lines.mean(1) vecs = vecs if vecs is not None else lines[:, 1, :] - lines[:, 0, :] lengths = lengths if lengths is not None else np.hypot(vecs[:, 0], vecs[:, 1]) return (_vlines(lines, ctrs, lengths, vecs, angle_lo, angle_hi, ransac_options=RANSAC_OPTIONS), _hlines(lines, ctrs, lengths, vecs, angle_lo, angle_hi, ransac_options=RANSAC_OPTIONS))
def on_pick(self, event): # Checks the lenght of the event.ind (how much points are selected) N = len(event.ind) # If nothing was selected - exits function if not N: return True # If multiple points were selected (overlapping of the circles) - informs # the user and exits function - needs to exit function, because not a # unique datapoints can be (or was) selected - so no informations can # be displayed - also throws an exception/error! if N > 1: print "Multiple objects lie within selection range. Zoome in to select a single object!" return True # Gets the location of that click x = event.mouseevent.xdata y = event.mouseevent.ydata # Calculates the distance - hypothenuse distances = np.hypot(x - self.c[event.ind[0]], y - self.d[event.ind[0]]) # Returns the indices of the minimum values along an axis indmin = distances.argmin() # Gets the data index of the selected data dataind = event.ind[indmin] # If CTRL is pressed if self.ctrl_on == True: # Sets the index of the data which should be removed self.remi = dataind else: # Updates the variable if no change was made self.lastind = dataind # Calls the update function and sets the removal variable afterwards self.update() self.remi = -1 # Updating the plot
def distance_between(x1, y1, x2, y2): """ Calculates the distance between 2 points. """ return np.hypot(x1 - x2, y1 - y2)
def make_dist_mat(xy1, xy2, longlat=True): """ Return a distance matrix between two set of coordinates. Use geometric distance (default) or haversine distance (if longlat=True). Parameters ---------- xy1 : numpy.array The first set of coordinates as [(x, y), (x, y), (x, y)]. xy2 : numpy.array The second set of coordinates as [(x, y), (x, y), (x, y)]. longlat : boolean, optionnal Whether the coordinates are in geographic (longitude/latitude) format or not (default: False) Returns ------- mat_dist : numpy.array The distance matrix between xy1 and xy2 """ if longlat: return hav_dist(xy1[:, None], xy2) else: d0 = np.subtract.outer(xy1[:, 0], xy2[:, 0]) d1 = np.subtract.outer(xy1[:, 1], xy2[:, 1]) return np.hypot(d0, d1)
def edgedetect(channel): sobelx = cv2.Sobel(channel, cv2.CV_16S, 1, 0, ksize=3) sobely = cv2.Sobel(channel, cv2.CV_16S, 0, 1, ksize=3) sobel = np.hypot(sobelx, sobely) sobel[sobel > 255] = 255 return sobel
def get_pixelist_interp_iq( qp, iq, ring_mask, center): qind, pixelist = roi.extract_label_indices( ring_mask ) #pixely = pixelist%FD.md['nrows'] -center[1] #pixelx = pixelist//FD.md['nrows'] - center[0] pixely = pixelist%ring_mask.shape[1] -center[1] pixelx = pixelist//ring_mask.shape[1] - center[0] r= np.hypot(pixelx, pixely) #leave as float. #r= np.int_( np.hypot(pixelx, pixely) +0.5 ) + 0.5 return np.interp( r, qp, iq )
def transform(cls, value): value = np.asarray(value, dtype=np.float64) assert value.shape[-1] == 2 result = np.empty_like(value) result[...,0] = np.hypot(value[...,1], value[...,0]) result[...,1] = np.arctan2(value[...,1], value[...,0]) % (2 * np.pi) return result
def transform(cls, value): value = np.asarray(value, dtype=np.float64) result = np.empty_like(value) x, y, z = value.T xy = np.hypot(x, y) result[..., 0] = np.hypot(xy, z) result[..., 1] = np.arctan2(xy, z) % (2 * np.pi) result[..., 2] = np.arctan2(y, x) % (2 * np.pi) return result
def transform(cls, value): value = np.asarray(value, dtype=np.float64) result = np.empty_like(value) x, y, z = value.T result[..., 0] = np.hypot(x, y) # tho result[..., 1] = np.arctan2(y, x) % (2 * np.pi) # phi result[..., 2] = z return result
def ecef2geodetic(x, y, z): """http://www.astro.uni.torun.pl/~kb/Papers/geod/Geod-BG.htm This algorithm provides a converging solution to the latitude equation in terms of the parametric or reduced latitude form (v). This algorithm provides a uniform solution over all latitudes as it does not involve division by cos(phi) or sin(phi). """ ell = {} ell['a'] = 6378137. ell['f'] = 1. / 298.2572235630 ell['b'] = ell['a'] * (1 - ell['f']) ea = ell['a'] eb = ell['b'] rad = np.hypot(x, y) # Constant required for Latitude equation rho = np.arctan2(eb * z, ea * rad) #Constant required for latitude equation c = (ea**2 - eb**2) / np.hypot(ea * rad, eb * z) # Starter for the Newtons Iteration Method vnew = np.arctan2(ea * z, eb * rad) # Initializing the parametric latitude v = 0 count = 0 while (v != vnew).any() and count < 5: v = vnew.copy() # Newtons Method for computing iterations vnew = v - ((2 * np.sin(v - rho) - c * np.sin(2 * v)) / (2 * (np.cos(v - rho) - c * np.cos(2 * v)))) count += 1 # Computing latitude from the root of the latitude equation lat = np.arctan2(ea * np.tan(vnew), eb) lon = np.arctan2(y, x) alt = ((rad - ea * np.cos(vnew)) * np.cos(lat) + (z - eb * np.sin(vnew)) * np.sin(lat)) return lat, lon, alt
def _cart2polar(x, y, center): xx = x - center[0] yy = y - center[1] phi = np.arctan2(yy, xx) r = np.hypot(xx, yy) return r, phi
def _grid(self): tsne_norm = self.tsne_vectors[:, ] / float(self.ratio) used_imgs = np.equal(self.tsne_vectors[:, 0], None) image = np.ones((self.output_img_size, self.output_img_size, 3)) * self.background_color for x in tqdm(range(self.ratio)): x0 = x * self.each_img_size x05 = (x + 0.5) * self.each_img_size for y in range(self.ratio): y0 = y * self.each_img_size y05 = (y + 0.5) * self.each_img_size tmp_tsne = tsne_norm - [x05, y05] tmp_tsne[used_imgs] = 99999 # don't use the same img twice tsne_dist = np.hypot(tmp_tsne[:, 0], tmp_tsne[:, 1]) min_index = np.argmin(tsne_dist) used_imgs[min_index] = True img_path = self.image_list[min_index] small_img, x1, y1, dx, dy = get_image(img_path, self.each_img_size) if small_img is None: y -= 1 continue if x < 1 and all(side < self.each_img_size for side in [x1, y1]): self.each_img_size = min(x1, y1) dx = int(ceil(x1 / 2)) dy = int(ceil(y1 / 2)) image[x0 + dx:x0 + dx + x1, y0 + dy:y0 + dy + y1] = small_img return image
def on_button(self, event): # only consider events from the lines Axes if event.inaxes is not self.ln.axes: return # if not the left mouse button or a modifier key # is held down, bail if event.button != 1 or event.key not in (None, 'shift'): print('key+button: {!r}+{!r}'.format(event.key, event.button)) return if event.key == 'shift': # compute the distance to each point *in data space* d = np.hypot(np.asarray(self.xdata) - event.xdata, np.asarray(self.ydata) - event.ydata) # find the closest point ix = np.argmin(d) # remove that data point del self.xdata[ix] del self.ydata[ix] else: # get the event location in data-space # and add to internal data list self.xdata.append(event.xdata) self.ydata.append(event.ydata) # update the line self._update_line()
def point_distance(p1, p2): dist_diff = p1 - p2 return np.hypot(*dist_diff)
def collide_line_ball(line, ball): displacement_to_second_point = line.line[1] - line.line[0] normalised_point_diff_vector = displacement_to_second_point / \ np.hypot(*(displacement_to_second_point)) perpendicular_vector = np.array( [-normalised_point_diff_vector[1], normalised_point_diff_vector[0]]) ball.velocity -= 2 * np.dot(perpendicular_vector, ball.velocity) * perpendicular_vector
def __init__(self, line): self.line = np.array(line) self.middle = (self.line[0] + self.line[1]) / 2 self.size = np.round(np.abs(self.line[0] - self.line[1])) self.length = np.hypot(*self.size) if np.count_nonzero(self.size) != 2: # line is perpendicular to y or x axis if self.size[0] == 0: self.size[0] += 1 else: self.size[1] += 1 # draws the yellow part of the table
def ball_hit(self): new_velocity = -(self.displacement - config.ball_radius - config.cue_safe_displacement) * \ config.cue_hit_power * np.array([math.sin(self.angle), math.cos(self.angle)]) change_in_disp = np.hypot(*new_velocity) * 0.1 while self.displacement - change_in_disp > config.ball_radius: self.displacement -= change_in_disp self.update() pygame.display.flip() self.target_ball.ball.apply_force(new_velocity) self.displacement = config.ball_radius self.visible = False
def update(self, *args): if np.hypot(*self.ball.velocity) != 0: # updates label circle and number offset perpendicular_velocity = -np.cross(self.ball.velocity, [0, 0, 1]) # angle formula is angle=((ballspeed*2)/(pi*r*2))*2 rotation_angle = -np.hypot( *(self.ball.velocity)) * 2 / (config.ball_radius * np.pi) transformation_matrix = physics.rotation_matrix( perpendicular_velocity, rotation_angle) self.label_offset = np.matmul( self.label_offset, transformation_matrix) if self.ball_type == BallType.Striped: self.ball_stripe.update_stripe(transformation_matrix) self.update_sprite() self.ball.update()
def check_reg(fixed_img, moved_img, scale=15, norm=True, sigma=0.8, **kwargs): dim = list(moved_img.shape) resol = list(moved_img.header['pixdim'][1:4]) # Convert 4D image to 3D or raise error data = convert_to_3d(moved_img) # Check normalization if norm: data = apply_p2_98(data) # Set slice axis for mosaic grid slice_axis, cmap = check_sliceaxis_cmap(data, kwargs) cmap = 'YlOrRd' # Set grid shape data, slice_grid, size = set_mosaic_fig(data, dim, resol, slice_axis, scale) fig, axes = BrainPlot.mosaic(fixed_img, scale=scale, norm=norm, cmap='bone', **kwargs) # Applying inversion invert = check_invert(kwargs) data = apply_invert(data, *invert) # Plot image for i in range(slice_grid[1] * slice_grid[2]): ax = axes.flat[i] edge = data[:, :, i] edge = feature.canny(edge, sigma=sigma) # edge detection for second image # edge = ndimage.gaussian_filter(edge, 3) mask = np.ones(edge.shape) sx = ndimage.sobel(edge, axis=0, mode='constant') sy = ndimage.sobel(edge, axis=1, mode='constant') sob = np.hypot(sx, sy) mask[sob == False] = np.nan m_norm = colors.Normalize(vmin=0, vmax=1.5) if i < slice_grid[0] and False in np.isnan(mask.flatten()): ax.imshow(mask.T, origin='lower', interpolation='nearest', cmap=cmap, norm=m_norm, alpha=0.8) else: ax.imshow(np.zeros((dim[0], dim[1])).T, origin='lower', interpolation='nearest', cmap='bone') ax.set_axis_off() fig.set_facecolor('black') if notebook_env: display(fig) return fig, axes
def distance(vertex1, vertex2): x, y = vertex1 - vertex2 return np.hypot(x, y)
def angsep(lon1,lat1,lon2,lat2): """ Angular separation (deg) between two sky coordinates. Borrowed from astropy (www.astropy.org) Notes ----- The angular separation is calculated using the Vincenty formula [1], which is slighly more complex and computationally expensive than some alternatives, but is stable at at all distances, including the poles and antipodes. [1] http://en.wikipedia.org/wiki/Great-circle_distance """ lon1,lat1 = numpy.radians([lon1,lat1]) lon2,lat2 = numpy.radians([lon2,lat2]) sdlon = numpy.sin(lon2 - lon1) cdlon = numpy.cos(lon2 - lon1) slat1 = numpy.sin(lat1) slat2 = numpy.sin(lat2) clat1 = numpy.cos(lat1) clat2 = numpy.cos(lat2) num1 = clat2 * sdlon num2 = clat1 * slat2 - slat1 * clat2 * cdlon denominator = slat1 * slat2 + clat1 * clat2 * cdlon return numpy.degrees(numpy.arctan2(numpy.hypot(num1,num2), denominator)) ############################################################ # ADW: Reduce numpy array operations for speed
def generate_pattern(self, reference, size): """Extracts a pattern from the reference image. Firstly, the image is transformed to grayscale. A random square from image is picked. A pattern is extracted using the edge detection (Sobel's filter). :param reference: Reference image. :param int size: Size of a pattern (length of its edge). :returns: A pattern extracted from the image. """ # Import image from reference and convert it to grayscale. img = mpimg.imread(reference) gray = np.mean(img, -1) # Normalization of data to decimal (0.0 - 1.0) representation if gray.max() > 1.0: gray /= 255.0 # Extract a random slice with the pixel size given as parameter slice_center_x = random.randint(0, len(img[0]) - size - 1) slice_center_y = random.randint(0, len(img) - size - 1) slice = gray[slice_center_y: slice_center_y + size, slice_center_x: slice_center_x + size] # # Detects border to generate the pattern of the brush dx = ndimage.sobel(slice, 0) # horizontal derivative dy = ndimage.sobel(slice, 1) # vertical derivative pattern = np.hypot(dx, dy) # grayscale slice with border detection # Normalize pattern if pattern.max() > 1.0: return pattern / pattern.max() return pattern # Test
def _deproj(x, y, inc, pa, polar_out=True, polar_in=True, fourier_plan=False): if polar_in: y, x = x*np.cos(y), x*np.sin(y) else: y, x = x, y if fourier_plan: X = (x*np.cos(pa) + y*np.sin(pa))*np.cos(inc) Y = y*np.cos(pa) - x*np.sin(pa) else: X = x*np.cos(pa) + y*np.sin(pa) Y = (y*np.cos(pa) - x*np.sin(pa))/np.cos(inc) x, y = np.hypot(Y, X), (np.arctan2(X, Y)-pa) % (2*np.pi) if not polar_out: return x*np.cos(y), x*np.sin(y) return x, y
def psf(lOverd, masperpx): """ lOverd in radian masperpx in mas per px """ nbpts = (lOverd*4/(masperpx*MAS2RAD))//2*2+1 y, x = np.meshgrid(np.linspace(-1, 1, nbpts), np.linspace(-1, 1, nbpts)) psf = airy(np.hypot(y, x)*2*lOverd+1e-10, 1/lOverd)**2 psf /= psf.sum() return psf
def distance_matrix(x0, y0, x1, y1): '''Distance matrix for IDW calculation''' obs = np.vstack((x0, y0)).T interp = np.vstack((x1, y1)).T # Make a distance matrix between pairwise observations # Note: from <http://stackoverflow.com/questions/1871536> d0 = np.subtract.outer(obs[:,0], interp[:,0]) d1 = np.subtract.outer(obs[:,1], interp[:,1]) return np.hypot(d0, d1)
