def latlong2osgbgrid_cupy(lat, long, input_degrees=True): ''' Converts latitude and longitude (ellipsoidal) coordinates into northing and easting (grid) coordinates, using a Transverse Mercator projection. Inputs: lat: latitude coordinate (north) long: longitude coordinate (east) input_degrees: if True (default), interprets the coordinates as degrees; otherwise, interprets coordinates as radians Output: (northing, easting) ''' if input_degrees: lat = lat * cp.pi / 180 long = long * cp.pi / 180 a = 6377563.396 b = 6356256.909 e2 = (a**2 - b**2) / a**2 N0 = -100000 # northing of true origin E0 = 400000 # easting of true origin F0 = .9996012717 # scale factor on central meridian phi0 = 49 * cp.pi / 180 # latitude of true origin lambda0 = -2 * cp.pi / 180 # longitude of true origin and central meridian sinlat = cp.sin(lat) coslat = cp.cos(lat) tanlat = cp.tan(lat) latdiff = lat - phi0 longdiff = long - lambda0 n = (a - b) / (a + b) nu = a * F0 * (1 - e2 * sinlat**2)**-.5 rho = a * F0 * (1 - e2) * (1 - e2 * sinlat**2)**-1.5 eta2 = nu / rho - 1 M = b * F0 * ( (1 + n + 5 / 4 * (n**2 + n**3)) * latdiff - (3 * (n + n**2) + 21 / 8 * n**3) * cp.sin(latdiff) * cp.cos(lat + phi0) + 15 / 8 * (n**2 + n**3) * cp.sin(2 * (latdiff)) * cp.cos(2 * (lat + phi0)) - 35 / 24 * n**3 * cp.sin(3 * (latdiff)) * cp.cos(3 * (lat + phi0))) I = M + N0 II = nu / 2 * sinlat * coslat III = nu / 24 * sinlat * coslat**3 * (5 - tanlat**2 + 9 * eta2) IIIA = nu / 720 * sinlat * coslat**5 * (61 - 58 * tanlat**2 + tanlat**4) IV = nu * coslat V = nu / 6 * coslat**3 * (nu / rho - cp.tan(lat)**2) VI = nu / 120 * coslat**5 * (5 - 18 * tanlat**2 + tanlat**4 + 14 * eta2 - 58 * tanlat**2 * eta2) northing = I + II * longdiff**2 + III * longdiff**4 + IIIA * longdiff**6 easting = E0 + IV * longdiff + V * longdiff**3 + VI * longdiff**5 return (northing, easting)
def get_phase(num_of_vort, pos, x_pts, y_pts, grid_x, grid_y, grid_len_x, grid_len_y, component): """ Gets phase distribution of N dipoles.""" # Phase initialisation theta_tot = cp.empty((x_pts, y_pts)) # Scale pts: x_tilde = 2 * cp.pi * ((grid_x - grid_x.min()) / grid_len_x) y_tilde = 2 * cp.pi * ((grid_y - grid_y.min()) / grid_len_y) if component == '2': switch = True else: switch = False for i in range(num_of_vort // 2): theta_k = cp.zeros((x_pts, y_pts)) if i % 24 == 0 and i > 0: switch ^= True if switch: x_p, y_p = next(pos) x_m, y_m = next(pos) else: x_m, y_m = next(pos) x_p, y_p = next(pos) # Scaling vortex positions: x_m_tilde = 2 * cp.pi * ((x_m - grid_x.min()) / grid_len_x) y_m_tilde = 2 * cp.pi * ((y_m - grid_y.min()) / grid_len_y) x_p_tilde = 2 * cp.pi * ((x_p - grid_x.min()) / grid_len_x) y_p_tilde = 2 * cp.pi * ((y_p - grid_y.min()) / grid_len_y) # Aux variables Y_minus = y_tilde - y_m_tilde X_minus = x_tilde - x_m_tilde Y_plus = y_tilde - y_p_tilde X_plus = x_tilde - x_p_tilde heav_xp = cp.asarray(np.heaviside(cp.asnumpy(X_plus), 1.)) heav_xm = cp.asarray(np.heaviside(cp.asnumpy(X_minus), 1.)) for nn in cp.arange(-5, 6): theta_k += cp.arctan(cp.tanh((Y_minus + 2 * cp.pi * nn) / 2) * cp.tan((X_minus - cp.pi) / 2)) \ - cp.arctan(cp.tanh((Y_plus + 2 * cp.pi * nn) / 2) * cp.tan((X_plus - cp.pi) / 2)) \ + cp.pi * (heav_xp - heav_xm) theta_k -= y_tilde * (x_p_tilde - x_m_tilde) / (2 * cp.pi) theta_tot += theta_k return theta_tot
def get_phase(num_of_vort, pos, grid_x, grid_y): """ num_of_vort: number of vortices to imprint pos: iterable of positions to imprint the vortices grid_x: X-meshgrid grid_y: Y-meshgrid """ # Constructing necessary grid parameters: x_pts, y_pts = len(grid_x[:, 0]), len(grid_y[0, :]) dx, dy = grid_x[0, 1] - grid_x[0, 0], grid_y[1, 0] - grid_y[0, 0] grid_len_x, grid_len_y = x_pts * dx, y_pts * dy # Phase initialisation theta_tot = cp.empty((x_pts, y_pts)) # Scale pts: x_tilde = 2 * cp.pi * ((grid_x - grid_x.min()) / grid_len_x) y_tilde = 2 * cp.pi * ((grid_y - grid_y.min()) / grid_len_y) for _ in range(num_of_vort // 2): theta_k = cp.zeros((x_pts, y_pts)) x_m, y_m = next(pos) x_p, y_p = next(pos) # Scaling vortex positions: x_m_tilde = 2 * cp.pi * ((x_m - grid_x.min()) / grid_len_x) y_m_tilde = 2 * cp.pi * ((y_m - grid_y.min()) / grid_len_y) x_p_tilde = 2 * cp.pi * ((x_p - grid_x.min()) / grid_len_x) y_p_tilde = 2 * cp.pi * ((y_p - grid_y.min()) / grid_len_y) # Aux variables Y_minus = y_tilde - y_m_tilde X_minus = x_tilde - x_m_tilde Y_plus = y_tilde - y_p_tilde X_plus = x_tilde - x_p_tilde heav_xp = cp.asarray(np.heaviside(cp.asnumpy(X_plus), 1.)) heav_xm = cp.asarray(np.heaviside(cp.asnumpy(X_minus), 1.)) for nn in cp.arange(-5, 6): theta_k += cp.arctan(cp.tanh((Y_minus + 2 * cp.pi * nn) / 2) * cp.tan((X_minus - cp.pi) / 2)) \ - cp.arctan(cp.tanh((Y_plus + 2 * cp.pi * nn) / 2) * cp.tan((X_plus - cp.pi) / 2)) \ + cp.pi * (heav_xp - heav_xm) theta_k -= y_tilde * (x_p_tilde - x_m_tilde) / (2 * cp.pi) theta_tot += theta_k return theta_tot
def jackson( num_moments, precision=32, ): """ This function generates the Jackson kernel for a given number of Chebyscev moments Parameters ---------- num_moments: (uint) number of Chebyshev moments Return ------ jackson_kernel: cupy array(shape=(num_moments,), dtype=tf_float) Note ---- See .. _The Kernel Polynomial Method: https://arxiv.org/pdf/cond-mat/0504627.pdf for more details """ cp_float = cp.float64 if precision == 32: cp_float = cp.float32 kernel_moments = cp.arange(num_moments, dtype=cp_float) norm = cp.pi / (num_moments + 1) phase_vec = norm * kernel_moments kernel = (num_moments - kernel_moments + 1) * cp.cos(phase_vec) kernel = kernel + cp.sin(phase_vec) / cp.tan(norm) kernel = kernel / (num_moments + 1) return kernel
def standard_cauchy(self, size=None, dtype=float): """Returns an array of samples drawn from the standard cauchy distribution. .. seealso:: :func:`cupy.random.standard_cauchy` for full documentation, :meth:`numpy.random.RandomState.standard_cauchy` """ x = self.uniform(size=size, dtype=dtype) return cupy.tan(cupy.pi * (x - 0.5))
def tan(x: Array, /) -> Array: """ Array API compatible wrapper for :py:func:`np.tan <numpy.tan>`. See its docstring for more information. """ if x.dtype not in _floating_dtypes: raise TypeError("Only floating-point dtypes are allowed in tan") return Array._new(np.tan(x._array))
def get_phase(num_of_vort, pos, x_pts, y_pts, grid_x, grid_y, grid_len_x, grid_len_y): # Phase initialisation theta_tot = cp.empty((x_pts, y_pts)) # Scale pts: x_tilde = 2 * cp.pi * ((grid_x - grid_x.min()) / grid_len_x) y_tilde = 2 * cp.pi * ((grid_y - grid_y.min()) / grid_len_y) for _ in range(num_of_vort // 2): theta_k = cp.zeros((x_pts, y_pts)) x_m, y_m = next(pos) x_p, y_p = next(pos) # Scaling vortex positions: x_m_tilde = 2 * cp.pi * ((x_m - grid_x.min()) / grid_len_x) y_m_tilde = 2 * cp.pi * ((y_m - grid_y.min()) / grid_len_y) x_p_tilde = 2 * cp.pi * ((x_p - grid_x.min()) / grid_len_x) y_p_tilde = 2 * cp.pi * ((y_p - grid_y.min()) / grid_len_y) # Aux variables Y_minus = y_tilde - y_m_tilde X_minus = x_tilde - x_m_tilde Y_plus = y_tilde - y_p_tilde X_plus = x_tilde - x_p_tilde heav_xp = cp.asarray(np.heaviside(cp.asnumpy(X_plus), 1.)) heav_xm = cp.asarray(np.heaviside(cp.asnumpy(X_minus), 1.)) for nn in cp.arange(-5, 6): theta_k += cp.arctan(cp.tanh((Y_minus + 2 * cp.pi * nn) / 2) * cp.tan((X_minus - cp.pi) / 2)) \ - cp.arctan(cp.tanh((Y_plus + 2 * cp.pi * nn) / 2) * cp.tan((X_plus - cp.pi) / 2)) \ + cp.pi * (heav_xp - heav_xm) theta_k -= y_tilde * (x_p_tilde - x_m_tilde) / (2 * cp.pi) theta_tot += theta_k return theta_tot
def __init__(self, lookfrom, lookat, vup, vfov, aspect_ratio, aperture, focus_dist): theta = degrees_to_radians(vfov) h = cp.tan(theta / 2) viewport_height = 2 * h viewport_width = aspect_ratio * viewport_height self.w = (lookfrom - lookat).unit_vector() self.u = vup.cross(self.w).unit_vector() self.v = self.w.cross(self.u) self.origin = lookfrom self.horizontal = self.u * viewport_width * focus_dist self.vertical = self.v * viewport_height * focus_dist self.top_left_corner = self.origin - self.horizontal / 2 + self.vertical / 2 - self.w * focus_dist self.lens_radius = aperture / 2
def __init__(self, lookfrom: Point3, lookat: Point3, vup: Vec3, vfov: float, aspect_ratio: float, aperture: float, focus_dist: float) -> None: """ vfov: vertical field-of-view in degress """ theta: float = degrees_to_radians(vfov) h: float = cp.tan(theta / 2) viewport_height: float = 2 * h viewport_width: float = aspect_ratio * viewport_height self.w: Vec3 = (lookfrom - lookat).unit_vector() self.u: Vec3 = vup.cross(self.w).unit_vector() self.v: Vec3 = self.w.cross(self.u) self.origin: Point3 = lookfrom self.horizontal: Vec3 = self.u * viewport_width * focus_dist self.vertical: Vec3 = self.v * viewport_height * focus_dist self.lower_left_corner: Point3 = (self.origin - self.horizontal / 2 - self.vertical / 2 - self.w * focus_dist) self.lens_radius: float = aperture / 2
def _hs(k, cs, rho, omega): c0 = (cs * cs * (1 + rho * rho) / (1 - rho * rho) / (1 - 2 * rho * rho * cos(2 * omega) + rho**4)) gamma = (1 - rho * rho) / (1 + rho * rho) / tan(omega) ak = abs(k) return c0 * rho**ak * (cos(omega * ak) + gamma * sin(omega * ak))
def cot__(z): return 1.0/cp.tan(z)
def RenderingUserViewLF_AllinOne5K(LF=None, LFDisparity=None, FB=None, viewpoint=None, DIR=None): sphereW = Params.WIDTH sphereH = Params.HEIGHT CENTERx = viewpoint.lon CENTERy = viewpoint.lat # output view is 3:4 ratio new_imgW = cp.floor(viewpoint.diag * 4 / 5 + 0.5) new_imgH = cp.floor(viewpoint.diag * 3 / 5 + 0.5) new_imgW = int(new_imgW) new_imgH = int(new_imgH) OutView = cp.zeros((new_imgH, new_imgW, 3)) TYwarp, TXwarp = cp.mgrid[0:new_imgH, 0:new_imgW] TX = TXwarp TY = TYwarp TX = (TX - 0.5 - new_imgW / 2) TY = (TY - 0.5 - new_imgH / 2) #의심 TX = TX + 1 TY = TY + 1 r = (viewpoint.diag / 2) / cp.tan(viewpoint.fov / 2) R = cp.sqrt(TY**2 + r**2) # Calculate LF_n ANGy = cp.arctan(-TY / r) ANGy = ANGy + CENTERy if (FB == 1): ANGn = cp.cos(ANGy) * cp.arctan(TX / r) ANGn = ANGn + CENTERx Pn = (Params.LFU_W / 2 - viewpoint.pos_y ) * cp.tan(ANGn) + viewpoint.pos_x + (3 * Params.LFU_W / 2) elif (FB == 2): ANGn = cp.cos(ANGy) * cp.arctan(-TX / r) ANGn = ANGn - CENTERx Pn = (Params.LFU_W / 2 + viewpoint.pos_y ) * cp.tan(ANGn) + viewpoint.pos_x + (3 * Params.LFU_W / 2) X = cp.sin(ANGy) * R Y = -cp.cos(ANGy) * R Z = TX ANGx = cp.arctan2(Z, -Y) RZY = cp.sqrt(Z**2 + Y**2) ANGy = cp.arctan(X / RZY) #or ANGy = atan2(X, RZY); RATIO = 1 ANGy = ANGy * RATIO ANGx = ANGx + CENTERx ANGx[abs(ANGy) > pi / 2] = ANGx[abs(ANGy) > pi / 2] + pi ANGx[ANGx > pi] = ANGx[ANGx > pi] - 2 * pi ANGy[ANGy > pi / 2] = pi / 2 - (ANGy[ANGy > pi / 2] - pi / 2) ANGy[ANGy < -pi / 2] = -pi / 2 + (ANGy[ANGy < -pi / 2] + pi / 2) Px = (ANGx + pi) / (2 * pi) * sphereW + 0.5 Py = ((-ANGy) + pi / 2) / pi * sphereH + 0.5 if (DIR == 2): Px = Px + Params.WIDTH / 4 elif (DIR == 3): Px = Px + Params.WIDTH / 2 elif (DIR == 4): Px = Px - Params.WIDTH / 4 Px[Px < 1] = Px[Px < 1] + Params.WIDTH Px[Px > Params.WIDTH] = Px[Px > Params.WIDTH] - Params.WIDTH INDxx = cp.argwhere(Px < 1) Px[INDxx] = Px[INDxx] + sphereW Pn0 = cp.floor(Pn) Pn1 = cp.ceil(Pn) Pnr = Pn - Pn0 Px0 = cp.floor(Px) Px1 = cp.ceil(Px) Pxr = Px - Px0 Py0 = cp.floor(Py) Py1 = cp.ceil(Py) Pyr = Py - Py0 Pnr = cp.rint((Pnr * 10000)) Pnr = Pnr / 10000 Pxr = cp.rint((Pxr * 10000)) Pxr = Pxr / 10000 Pyr = cp.rint((Pyr * 10000)) Pyr = Pyr / 10000 #210->012 rgb #cv2 사용 안하면 그대로 OutView[:, :, 2] = inter8_mat5K(LF, Pnr, Pn0, Pn1, Pxr, Px0, Px1, Pyr, Py0, Py1, 1) OutView[:, :, 1] = inter8_mat5K(LF, Pnr, Pn0, Pn1, Pxr, Px0, Px1, Pyr, Py0, Py1, 2) OutView[:, :, 0] = inter8_mat5K(LF, Pnr, Pn0, Pn1, Pxr, Px0, Px1, Pyr, Py0, Py1, 3) OutFlow = inter8_mat_flow5K(LFDisparity, Pnr, Pn0, Pn1, Pxr, Px0, Px1, Pyr, Py0, Py1) Py = cp.pad(Py, [(1, 1), (0, 0)], mode='edge') Py = cp.ceil((Py * 10000)) Py = Py / 10000 My = 2 / (Py[2:cp.size(Py, 0), :] - Py[0:(cp.size(Py, 0) - 2), :]) My[0, :] = My[0, :] / 2 My[cp.size(My, 0) - 1, :] = My[cp.size(My, 0) - 1, :] / 2 OutFlow = My * OutFlow return OutView, OutFlow