Python numpy.deg2rad() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def augment(
        rotation_fn=lambda: np.random.random_integers(0, 360),
        translation_fn=lambda: (np.random.random_integers(-20, 20), np.random.random_integers(-20, 20)),
        scale_factor_fn=random_zoom_range(),
        shear_fn=lambda: np.random.random_integers(-10, 10)
):
    def call(x):
        rotation = rotation_fn()
        translation = translation_fn()
        scale = scale_factor_fn()
        shear = shear_fn()

        tf_augment = AffineTransform(scale=scale, rotation=np.deg2rad(rotation), translation=translation, shear=np.deg2rad(shear))
        tf = tf_center + tf_augment + tf_uncenter

        x = warp(x, tf, order=1, preserve_range=True, mode='symmetric')

        return x

    return call 

Example 2

def affine_skew(self, tilt, phi, img, mask=None):
        h, w = img.shape[:2]
        if mask is None:
            mask = np.zeros((h, w), np.uint8)
            mask[:] = 255
        A = np.float32([[1, 0, 0], [0, 1, 0]])
        if phi != 0.0:
            phi = np.deg2rad(phi)
            s, c = np.sin(phi), np.cos(phi)
            A = np.float32([[c, -s], [s, c]])
            corners = [[0, 0], [w, 0], [w, h], [0, h]]
            tcorners = np.int32(np.dot(corners, A.T))
            x, y, w, h = cv2.boundingRect(tcorners.reshape(1, -1, 2))
            A = np.hstack([A, [[-x], [-y]]])
            img = cv2.warpAffine(img, A, (w, h), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE)
        if tilt != 1.0:
            s = 0.8*np.sqrt(tilt * tilt - 1)
            img = cv2.GaussianBlur(img, (0, 0), sigmaX=s, sigmaY=0.01)
            img = cv2.resize(img, (0, 0), fx=1.0 / tilt, fy=1.0, interpolation=cv2.INTER_NEAREST)
            A[0] /= tilt
        if phi != 0.0 or tilt != 1.0:
            h, w = img.shape[:2]
            mask = cv2.warpAffine(mask, A, (w, h), flags=cv2.INTER_NEAREST)
        Ai = cv2.invertAffineTransform(A)
        return img, mask, Ai 

Example 3

def augment_deterministic(
        rotation=0,
        translation=0,
        scale_factor=1,
        shear=0
):
    def call(x):
        scale = scale_factor, scale_factor
        rotation_tmp = rotation

        tf_augment = AffineTransform(
            scale=scale,
            rotation=np.deg2rad(rotation_tmp),
            translation=translation,
            shear=np.deg2rad(shear)
        )
        tf = tf_center + tf_augment + tf_uncenter

        x = warp(x, tf, order=1, preserve_range=True, mode='symmetric')

        return x

    return call 

Example 4

def mass_streamfun(self):

        from scipy import integrate

        data = self._obj
#        lonlen = len(data.lon)
        if 'lon' in data.dims:
            data = data.fillna(0).mean('lon')
        levax = data.get_axis_num('lev')
        stream = integrate.cumtrapz(data * np.cos(np.deg2rad(data.lat)), x=data.lev * 1e2, initial=0., axis=levax)
        stream = stream * 2 * np.pi  / cc.g * cc.rearth * 1e-9
        stream = xr.DataArray(stream, coords=data.coords, dims=data.dims)
        stream = stream.rename('ovt')
        stream.attrs['long name'] = 'atmosphere overturning circulation'
        stream.attrs['unit'] = 'Sv (1e9 kg/s)'
        return stream 

Example 5

def draw_laser_frustum(pose, zmin=0.0, zmax=10, fov=np.deg2rad(60)): 

    N = 30
    curve = np.vstack([(
        RigidTransform.from_rpyxyz(0, 0, rad, 0, 0, 0) * np.array([[zmax, 0, 0]])) 
             for rad in np.linspace(-fov/2, fov/2, N)])
    
    curve_w = pose * curve

    faces, edges = [], []
    for cpt1, cpt2 in zip(curve_w[:-1], curve_w[1:]): 
        faces.extend([pose.translation, cpt1, cpt2])
        edges.extend([cpt1, cpt2])

    # Connect the last pt in the curve w/ the current pose, 
    # then connect the the first pt in the curve w/ the curr. pose
    edges.extend([edges[-1], pose.translation])
    edges.extend([edges[0], pose.translation])

    faces = np.vstack(faces)
    edges = np.vstack(edges)
    return (faces, edges) 

Example 6

def __init__(self, theta=np.deg2rad(20), displacement=0.25, lookup_history=10, 
                 get_sample=lambda item: item.pose,  
                 on_sampled_cb=lambda index, item: None, verbose=False): 
        PoseSampler.__init__(self, displacement=displacement, theta=theta, 
                             lookup_history=lookup_history, 
                             get_sample=get_sample, 
                             on_sampled_cb=on_sampled_cb, verbose=verbose)

# class KeyframeVolumeSampler(FrustumVolumeIntersectionPoseSampler): 
#     def __init__(self, iou=0.5, depth=20, fov=np.deg2rad(60), lookup_history=10, 
#                  get_sample=lambda item: item.pose,  
#                  on_sampled_cb=lambda index, item: None, verbose=False): 
#         FrustumVolumeIntersectionPoseSampler.__init__(self, iou=iou, depth=depth, fov=fov, 
#                                                       lookup_history=lookup_history, 
#                                                       get_sample=get_sample, 
#                                                       on_sampled_cb=on_sampled_cb, verbose=verbose) 

Example 7

def tsukuba_load_poses(fn): 
    """ 
    Retrieve poses
    X Y Z R P Y - > X -Y -Z R -P -Y
    
    np.deg2rad(p[3]),-np.deg2rad(p[4]),-np.deg2rad(p[5]),
        p[0]*.01,-p[1]*.01,-p[2]*.01, axes='sxyz') for p in P ]

    """ 
    P = np.loadtxt(os.path.expanduser(fn), dtype=np.float64, delimiter=',')
    return [ RigidTransform.from_rpyxyz(np.pi, 0, 0, 0, 0, 0) * \
             RigidTransform.from_rpyxyz(
                 np.deg2rad(p[3]),np.deg2rad(p[4]),np.deg2rad(p[5]),
                 p[0]*.01,p[1]*.01,p[2]*.01, axes='sxyz') * \
             RigidTransform.from_rpyxyz(np.pi, 0, 0, 0, 0, 0) for p in P ]
    
    # return [ RigidTransform.from_rpyxyz(
    #     np.deg2rad(p[3]),-np.deg2rad(p[4]),-np.deg2rad(p[5]),
    #     p[0]*.01,-p[1]*.01,-p[2]*.01, axes='sxyz') for p in P ] 

Example 8

def ct2lg(dX, dY, dZ, lat, lon):

    n = dX.size
    R = np.zeros((3, 3, n))

    R[0, 0, :] = -np.multiply(np.sin(np.deg2rad(lat)), np.cos(np.deg2rad(lon)))
    R[0, 1, :] = -np.multiply(np.sin(np.deg2rad(lat)), np.sin(np.deg2rad(lon)))
    R[0, 2, :] = np.cos(np.deg2rad(lat))
    R[1, 0, :] = -np.sin(np.deg2rad(lon))
    R[1, 1, :] = np.cos(np.deg2rad(lon))
    R[1, 2, :] = np.zeros((1, n))
    R[2, 0, :] = np.multiply(np.cos(np.deg2rad(lat)), np.cos(np.deg2rad(lon)))
    R[2, 1, :] = np.multiply(np.cos(np.deg2rad(lat)), np.sin(np.deg2rad(lon)))
    R[2, 2, :] = np.sin(np.deg2rad(lat))

    dxdydz = np.column_stack((np.column_stack((dX, dY)), dZ))

    RR = np.reshape(R[0, :, :], (3, n))
    dx = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
    RR = np.reshape(R[1, :, :], (3, n))
    dy = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
    RR = np.reshape(R[2, :, :], (3, n))
    dz = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)

    return dx, dy, dz 

Example 9

def ct2lg(self, dX, dY, dZ, lat, lon):

        n = dX.size
        R = numpy.zeros((3, 3, n))

        R[0, 0, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
        R[0, 1, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
        R[0, 2, :] = numpy.cos(numpy.deg2rad(lat))
        R[1, 0, :] = -numpy.sin(numpy.deg2rad(lon))
        R[1, 1, :] = numpy.cos(numpy.deg2rad(lon))
        R[1, 2, :] = numpy.zeros((1, n))
        R[2, 0, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
        R[2, 1, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
        R[2, 2, :] = numpy.sin(numpy.deg2rad(lat))

        dxdydz = numpy.column_stack((numpy.column_stack((dX, dY)), dZ))

        RR = numpy.reshape(R[0, :, :], (3, n))
        dx = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
        RR = numpy.reshape(R[1, :, :], (3, n))
        dy = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
        RR = numpy.reshape(R[2, :, :], (3, n))
        dz = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)

        return dx, dy, dz 

Example 10

def ct2lg(dX, dY, dZ, lat, lon):

    n = dX.size
    R = np.zeros((3, 3, n))

    R[0, 0, :] = -np.multiply(np.sin(np.deg2rad(lat)), np.cos(np.deg2rad(lon)))
    R[0, 1, :] = -np.multiply(np.sin(np.deg2rad(lat)), np.sin(np.deg2rad(lon)))
    R[0, 2, :] = np.cos(np.deg2rad(lat))
    R[1, 0, :] = -np.sin(np.deg2rad(lon))
    R[1, 1, :] = np.cos(np.deg2rad(lon))
    R[1, 2, :] = np.zeros((1, n))
    R[2, 0, :] = np.multiply(np.cos(np.deg2rad(lat)), np.cos(np.deg2rad(lon)))
    R[2, 1, :] = np.multiply(np.cos(np.deg2rad(lat)), np.sin(np.deg2rad(lon)))
    R[2, 2, :] = np.sin(np.deg2rad(lat))

    dxdydz = np.column_stack((np.column_stack((dX, dY)), dZ))

    RR = np.reshape(R[0, :, :], (3, n))
    dx = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
    RR = np.reshape(R[1, :, :], (3, n))
    dy = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)
    RR = np.reshape(R[2, :, :], (3, n))
    dz = np.sum(np.multiply(RR, dxdydz.transpose()), axis=0)

    return dx, dy, dz 

Example 11

def ct2lg(self, dX, dY, dZ, lat, lon):

        n = dX.size
        R = numpy.zeros((3, 3, n))

        R[0, 0, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
        R[0, 1, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
        R[0, 2, :] = numpy.cos(numpy.deg2rad(lat))
        R[1, 0, :] = -numpy.sin(numpy.deg2rad(lon))
        R[1, 1, :] = numpy.cos(numpy.deg2rad(lon))
        R[1, 2, :] = numpy.zeros((1, n))
        R[2, 0, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
        R[2, 1, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
        R[2, 2, :] = numpy.sin(numpy.deg2rad(lat))

        dxdydz = numpy.column_stack((numpy.column_stack((dX, dY)), dZ))

        RR = numpy.reshape(R[0, :, :], (3, n))
        dx = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
        RR = numpy.reshape(R[1, :, :], (3, n))
        dy = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
        RR = numpy.reshape(R[2, :, :], (3, n))
        dz = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)

        return dx, dy, dz 

Example 12

def ct2lg(self, dX, dY, dZ, lat, lon):

        n = dX.size
        R = numpy.zeros((3, 3, n))

        R[0, 0, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
        R[0, 1, :] = -numpy.multiply(numpy.sin(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
        R[0, 2, :] = numpy.cos(numpy.deg2rad(lat))
        R[1, 0, :] = -numpy.sin(numpy.deg2rad(lon))
        R[1, 1, :] = numpy.cos(numpy.deg2rad(lon))
        R[1, 2, :] = numpy.zeros((1, n))
        R[2, 0, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.cos(numpy.deg2rad(lon)))
        R[2, 1, :] = numpy.multiply(numpy.cos(numpy.deg2rad(lat)), numpy.sin(numpy.deg2rad(lon)))
        R[2, 2, :] = numpy.sin(numpy.deg2rad(lat))

        dxdydz = numpy.column_stack((numpy.column_stack((dX, dY)), dZ))

        RR = numpy.reshape(R[0, :, :], (3, n))
        dx = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
        RR = numpy.reshape(R[1, :, :], (3, n))
        dy = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)
        RR = numpy.reshape(R[2, :, :], (3, n))
        dz = numpy.sum(numpy.multiply(RR, dxdydz.transpose()), axis=0)

        return dx, dy, dz 

Example 13

def effect(self, point):
        res = []
        # print(self.centers)
        for center in self.centers:
            center_x, center_y = center
            src_x, src_y = point.pos
            # Check angle
            angle = np.arctan((center_x - src_x) / (center_y - src_y))
            if np.abs(angle) > self.angle / 2:
                continue
            angle = np.deg2rad(90) + angle
            u_len = np.sqrt((center_x - src_x) ** 2 + (center_y - src_y) ** 2)
            reverse_v = (self.r_index - 1) / self.radius - self.r_index / u_len
            v_len = 1 / reverse_v
            if v_len > 0:
                p_type = 'real'
            else:
                p_type = 'fake'

            target = line_end(point.pos, angle, u_len + v_len)
            p = Point(target, p_type, 1)
            # point.passed.append(self)
            res.append(p)
        return tuple(res) 

Example 14

def setRotation(self, rot, smallangle=True):
        '''
        Rotation angle in degrees
        '''
        rad = np.deg2rad(rot)
        if smallangle:
            # bring rad close to zero.
            rad = np.fmod(rad, 2.*pi)
            if rad > pi:
                rad -= 2.*pi
            if rad < -pi:
                rad += 2.*pi
            self.T = [ 0., -rad, rad, 0. ]
        else:
            cr = np.cos(rad)
            sr = np.sin(rad)
            self.T = [ cr - 1, -sr, sr, cr - 1 ] 

Example 15

def plot(self, values, *args, **kw):
        """Plot a concept's cause-effect repertoire on the radarchart.

        Examples:
            >>> full_rep = np.hstack([cause_rep, effect_rep])
            >>> radar.plot(full_rep, '-', lw=2, label=mechanism_label)

        Args:
            values (np.ndarray): A flat array of state probabilitites, given in
                the same order as the `titles` argument to the ConstellationRadar
                constructor.

        Also takes standard matplotlib linespec arguments, such as color, style,
            linewidth, etc.
        """
        angle = np.deg2rad(np.r_[self.angles, self.angles[0]])
        values = np.r_[values, values[0]]
        self.ax.plot(angle, values, *args, **kw) 

Example 16

def _rotate_interp(array, alpha, center, mode='constant', cval=0):
    '''
    Rotation around a provided center

    This is the only way to be sure where exactly is the center of rotation.

    '''
    dtype = array.dtype
    dims  = array.shape
    alpha_rad = -np.deg2rad(alpha)

    x, y = np.meshgrid(np.arange(dims[1], dtype=dtype), np.arange(dims[0], dtype=dtype))

    xp = (x-center[0])*np.cos(alpha_rad) + (y-center[1])*np.sin(alpha_rad) + center[0]
    yp = -(x-center[0])*np.sin(alpha_rad) + (y-center[1])*np.cos(alpha_rad) + center[1]

    rotated = ndimage.map_coordinates(img, [yp, xp], mode=mode, cval=cval, order=3)
    
    return rotated 

Example 17

def calc_coord(self, transCoord, p, d, a, e, i, w):
        # cx, cy, cz ?? ??
        # p, ?? d, ?? ??
        # a ??, e ???
        # i ?? ???
        unitAng = 360/p
        ang = (unitAng * d) % 360
        theta = np.deg2rad(ang)
        b = a * np.sqrt(1 - np.power(e, 2))
        x = transCoord[0] + a * np.cos(theta)
        y = transCoord[1] + b * np.sin(theta)
        z = 0.0

        #rotate
        w = np.deg2rad(w)
        x1, y1 = x, y
        #x = transCoord[0] + (x1 * np.cos(w) - y1 * np.sin(w))
        #y = transCoord[1] + (x1 * np.sin(w) + y1 * np.cos(w))

        coord = [x, y, z]
        return coord 

Example 18

def mt_diff( mt1, mt2):

    fps = np.deg2rad([mt1.get_fps(), mt2.get_fps()])
    diff = [999999999, 999999999]
    for i in range(2):
        for j in range(2):

            test = haversine(lon1=fps[0][i][0], phi1=fps[0][i][1], lon2=fps[1][j][0], phi2=fps[1][j][1], radius=1.)

            while test>np.pi/2:
                test -= np.pi/2

            if test < diff[i]:
                diff[i] = test

    return np.rad2deg(np.mean(diff)) 

Example 19

def __init__(self, f0=997, fs=96000, duration=None, gaindb=0, nofsamples=0,
                 phasedeg=0, harmonics=7,):
        """Construct a square wave by adding odd harmonics with decreasing
        amplitude, i.e. Fourier Series.
        """
        Sinetone.__init__(self, f0=f0, phasedeg=phasedeg, fs=fs, nofsamples=nofsamples,
                          duration=duration, gaindb=0)
        
        assert harmonics >= 0
        
        self.harmonics = harmonics
        self._logger.debug("fundamental f0: %.1f" %f0)
        
        for n in range(3, 2*(self.harmonics+1), 2):
            if n <= 15:
                self._logger.debug("adding harmonic n: %2i with amplitude 1/%i" %(n, n))
            if n == 17:
                self._logger.debug("adding %i more harmonics..." %(self.harmonics-(n-3)//2))
            
            #self.samples[:,0] += np.sin(2*np.pi*(n*f0)*self.get_time()+np.deg2rad(phasedeg*n))/n
            self.samples[:,0] += (1/n)*self._sine_gen(n*f0, n*phasedeg)
        self.gain(gaindb) 

Example 20

def construct_K(image_size, focal_len=None, fov_degrees=None, fov_radians=None):
  """ create calibration matrix K using the image size and focal length or field of view angle
  Assumes 0 skew and principal point at center of image
  Note that image_size = (width, height)
  Note that fov is assumed to be measured horizontally
  """
  if not np.sum([focal_len is not None, fov_degrees is not None, fov_radians is not None]) == 1:
    raise Exception('Specify exactly one of [focal_len, fov_degrees, fov_radians]')

  if fov_degrees is not None:
    fov_radians = np.deg2rad(fov_degrees)
  if fov_radians is not None:
    focal_len = image_size[0] / (2.0 * np.tan(fov_radians/2.0))

  K = np.array([[focal_len, 0, image_size[0]/2.0], [0, focal_len, image_size[1]/2.0], [0, 0, 1]])
  return K 

Example 21

def gaussian(height, center_x, center_y, width_x, width_y, rotation):
    """Returns a gaussian function with the given parameters"""
    width_x = float(width_x)
    width_y = float(width_y)

    rotation = np.deg2rad(rotation)
    center_x = center_x * np.cos(rotation) - center_y * np.sin(rotation)
    center_y = center_x * np.sin(rotation) + center_y * np.cos(rotation)

    def rotgauss(x,y):
        xp = x * np.cos(rotation) - y * np.sin(rotation)
        yp = x * np.sin(rotation) + y * np.cos(rotation)
        g = height*np.exp(
            -(((center_x-xp)/width_x)**2+
              ((center_y-yp)/width_y)**2)/2.)
        return g
    return rotgauss 

Example 22

def _add_table(self, name):
        p = PoseStamped()
        p.header.frame_id = self._robot.get_planning_frame()
        p.header.stamp = rospy.Time.now()

        p.pose.position.x = 0.2
        p.pose.position.y = 0.0
        p.pose.position.z = 0.1

        q = quaternion_from_euler(0.0, 0.0, numpy.deg2rad(90.0))
        p.pose.orientation = Quaternion(*q)

        # Table size from ~/.gazebo/models/table/model.sdf, using the values
        # for the surface link.
        self._scene.add_box(name, p, (0.005, 0.005, 0.005))

        return p.pose 

Example 23

def traj_diff(t1, t2):
    """Compute trajectory difference.

    Parameters
    ----------
    t1, t2 : DataFrame
        Trajectories.

    Returns
    -------
    diff : DataFrame
        Trajectory difference. It can be interpreted as errors in `t1` relative
        to `t2`.
    """
    diff = t1 - t2
    diff['lat'] *= np.deg2rad(earth.R0)
    diff['lon'] *= np.deg2rad(earth.R0) * np.cos(0.5 *
                                                 np.deg2rad(t1.lat + t2.lat))
    diff['h'] %= 360
    diff.h[diff.h < -180] += 360
    diff.h[diff.h > 180] -= 360

    return diff.loc[t1.index.intersection(t2.index)] 

Example 24

def reset(self):
        """Clear computed trajectory except the initial point."""
        lat, lon, VE, VN, h, p, r, stamp = self._init_values

        self.lat_arr[0] = np.deg2rad(lat)
        self.lon_arr[0] = np.deg2rad(lon)
        self.VE_arr[0] = VE
        self.VN_arr[0] = VN
        self.Cnb_arr[0] = dcm.from_hpr(h, p, r)

        self.traj = pd.DataFrame(index=pd.Index([stamp], name='stamp'))
        self.traj['lat'] = [lat]
        self.traj['lon'] = [lon]
        self.traj['VE'] = [VE]
        self.traj['VN'] = [VN]
        self.traj['h'] = [h]
        self.traj['p'] = [p]
        self.traj['r'] = [r] 

Example 25

def equinox(date, eop_correction=True, terms=106, kinematic=True):
    """Equinox equation in degrees
    """
    epsilon_bar, delta_psi, delta_eps = _nutation(date, eop_correction, terms)

    equin = delta_psi * 3600. * np.cos(np.deg2rad(epsilon_bar))

    if date.d >= 50506 and kinematic:
        # Starting 1992-02-27, we apply the effect of the moon
        ttt = date.change_scale('TT').julian_century
        om_m = 125.04455501 - (5 * 360. + 134.1361851) * ttt\
            + 0.0020756 * ttt ** 2 + 2.139e-6 * ttt ** 3

        equin += 0.00264 * np.sin(np.deg2rad(om_m)) + 6.3e-5 * np.sin(np.deg2rad(2 * om_m))

    # print("esquinox = {}\n".format(equin / 3600))
    return equin / 3600. 

Example 26

def test_read():

    tle = Tle(ref)

    assert tle.name == "ISS (ZARYA)"
    assert tle.norad_id == 25544
    assert tle.cospar_id == "1998-067A"
    assert tle.epoch == Date(2008, 9, 20, 12, 25, 40, 104192)
    assert tle.ndot == -2.182e-5
    assert tle.ndotdot == 0.
    assert tle.bstar == -0.11606e-4
    assert tle.i == np.deg2rad(51.6416)
    assert tle.? == np.deg2rad(247.4627)
    assert tle.e == 6.703e-4
    assert tle.? == np.deg2rad(130.5360)
    assert tle.M == np.deg2rad(325.0288)
    assert tle.n == 15.72125391 * 2 * np.pi / 86400.

    tle = Tle(ref.splitlines()[1:])

    assert tle.name == ""

    with raises(ValueError):
        ref2 = ref[:-1] + "8"
        Tle(ref2) 

Example 27

def gaussian(height, center_x, center_y, width_x, width_y, rotation):
    """Returns a gaussian function with the given parameters"""
    width_x = float(width_x)
    width_y = float(width_y)

    rotation = np.deg2rad(rotation)
    center_x = center_x * np.cos(rotation) - center_y * np.sin(rotation)
    center_y = center_x * np.sin(rotation) + center_y * np.cos(rotation)

    def rotgauss(x,y):
        xp = x * np.cos(rotation) - y * np.sin(rotation)
        yp = x * np.sin(rotation) + y * np.cos(rotation)
        g = height*np.exp(
            -(((center_x-xp)/width_x)**2+
              ((center_y-yp)/width_y)**2)/2.)
        return g
    return rotgauss 

Example 28

def gaussian_pdf(height, center_x, center_y, width_x, width_y, rotation):
    """Returns a pdf function with the given parameters"""
    width_x = float(width_x)
    width_y = float(width_y)
    rotation = np.deg2rad(rotation)
    center_x = center_x * np.cos(rotation) - center_y * np.sin(rotation)
    center_y = center_x * np.sin(rotation) + center_y * np.cos(rotation)
    def rotgauss(x,y):
        xp = x * np.cos(rotation) - y * np.sin(rotation)
        yp = x * np.sin(rotation) + y * np.cos(rotation)
        g = height*np.exp(
            -(((center_x-xp)/width_x)**2+
              ((center_y-yp)/width_y)**2)/2.)
        return g
    return rotgauss

# doesn't allow for flattening or mean shifting, otherwise occasionally
# we get gaussians that are in the wrong place or drastically the wrong shape 

Example 29

def get_area_extent(self, size, offsets, factors, platform_height):
        """Get the area extent of the file."""
        nlines, ncols = size
        h = platform_height

        # count starts at 1
        cols = 1 - 0.5
        lines = 1 - 0.5
        ll_x, ll_y = self.get_xy_from_linecol(lines, cols, offsets, factors)

        cols += ncols
        lines += nlines
        ur_x, ur_y = self.get_xy_from_linecol(lines, cols, offsets, factors)

        return (np.deg2rad(ll_x) * h, np.deg2rad(ll_y) * h,
                np.deg2rad(ur_x) * h, np.deg2rad(ur_y) * h) 

Example 30

def test_get_geostationary_angle_extent(self):
        """Get max geostationary angles."""
        geos_area = mock.MagicMock()
        geos_area.proj_dict = {'a': 6378169.00,
                               'b': 6356583.80,
                               'h': 35785831.00}

        expected = (0.15185342867090912, 0.15133555510297725)

        np.testing.assert_allclose(expected,
                                   hf.get_geostationary_angle_extent(geos_area))

        geos_area.proj_dict = {'a': 1000.0,
                               'b': 1000.0,
                               'h': np.sqrt(2) * 1000.0 - 1000.0}

        expected = (np.deg2rad(45), np.deg2rad(45))

        np.testing.assert_allclose(expected,
                                   hf.get_geostationary_angle_extent(geos_area)) 

Example 31

def augmentate(self):
        angles = [45, 90, 135, 180, 225, 270, 315]
        scale = 1.0
        for img in self.images:
            print "image shape : ", img.shape
            w = img.shape[1]
            h = img.shape[0]
            img_vmirror = cv2.flip(img,1)
            skimage.io.imsave("testv"+".jpg", img_vmirror )
            for angle in angles:
            #rangle = np.deg2rad(angle)
            # nw = (abs(np.sin(rangle)*h) + abs(np.cos(rangle)*w))*scale
            # nh = (abs(np.cos(rangle)*h) + abs(np.sin(rangle)*w))*scale
                rot_mat = cv2.getRotationMatrix2D((w*0.5, h*0.5), angle, scale)
            # rot_move = np.dot(rot_mat, np.array([(nw-w)*0.5, (nh-h)*0.5,0]))
            # rot_mat[0,2] += rot_move[0]
            # rot_mat[1,2] += rot_move[1]
                new_img = cv2.warpAffine(img, rot_mat, (int(math.ceil(w)), int(math.ceil(h))), flags=cv2.INTER_LANCZOS4)
                skimage.io.imsave("test"+str(angle)+".jpg", new_img)
                new_img_vmirror = cv2.flip(new_img, 1)
                skimage.io.imsave("testv"+str(angle)+".jpg", new_img_vmirror)
                # img_rmirror = cv2.flip(new_img, 0)
                # skimage.io.imsave("testh"+str(angle)+".jpg", img_rmirror) 

Example 32

def sphericalToXYZ(lat,lon,radius=1):
    ''' 
    Convert spherical coordinates to x,y,z

    @param lat: Latitude, scalar or array
    @param lon: Longitude, scalar or array
    @param radius: Sphere's radius

    @return Numpy array of x,y,z coordinates
    '''
    phi = np.deg2rad(90.0 - lat)
    theta = np.deg2rad(lon % 360)
    x = radius * np.cos(theta)*np.sin(phi)
    y = radius * np.sin(theta)*np.sin(phi)
    z = radius * np.cos(phi)
    
    if np.isscalar(x) == False:
        return np.vstack([x,y,z]).T
    else:
        return np.array([x,y,z]) 

Example 33

def plot_chara(self, angle, step,Rstar = 1):

        counter = 1000
        i = np.arange(counter)
        Rstar_tmp = self.Rstar_min + i / counter
        Rstar_tmp = Rstar_tmp[Rstar_tmp < 1]
        fai = self.chara_line(Rstar_tmp)
        for j in range(0, angle, step):
            x1 = self.chara_x(Rstar_tmp * Rstar, fai - self.const + np.deg2rad(j))
            y1 = self.chara_y(Rstar_tmp * Rstar, fai - self.const + np.deg2rad(j))
            x2 = self.chara_x(Rstar_tmp * Rstar, - (fai - self.const - np.deg2rad(j)))
            y2 = self.chara_y(Rstar_tmp * Rstar, - (fai - self.const - np.deg2rad(j)))

            plt.plot(x1, y1, "r")
            plt.plot(x2, y2, "k")
        plt.xlim(-1, 1)
        plt.ylim(-1, 1)
        plt.gca().set_aspect('equal', adjustable='box')
        plt.show()

    # top arc angle is 0
    # v1 must be smaller than v2 

Example 34

def make_upper_straight_line(self):
        """ make upper straight line """
        targetx = self.lower_concave_in_x_end
        x = self.upper_convex_in_x_end
        y = self.upper_convex_in_y_end
        targety = np.tan(np.deg2rad(self.beta_in)) * targetx + y - np.tan(np.deg2rad(self.beta_in)) * x
        self.upper_straight_in_x = [targetx, x]
        self.upper_straight_in_y = [targety, y]
        self.shift = - abs(self.lower_concave_in_y_end - targety)

        targetx = self.lower_concave_out_x_end
        x = self.upper_convex_out_x_end
        y = self.upper_convex_out_y_end
        targety = np.tan(np.deg2rad(self.beta_out)) * targetx + y - np.tan(np.deg2rad(self.beta_out)) * x
        self.upper_straight_out_x = [targetx, x]
        self.upper_straight_out_y = [targety, y] 

Example 35

def distort_affine_skimage(image, rotation=10.0, shear=5.0, random_state=None):
    if random_state is None:
        random_state = np.random.RandomState(None)

    rot = np.deg2rad(np.random.uniform(-rotation, rotation))
    sheer = np.deg2rad(np.random.uniform(-shear, shear))

    shape = image.shape
    shape_size = shape[:2]
    center = np.float32(shape_size) / 2. - 0.5

    pre = transform.SimilarityTransform(translation=-center)
    affine = transform.AffineTransform(rotation=rot, shear=sheer, translation=center)
    tform = pre + affine

    distorted_image = transform.warp(image, tform.params, mode='reflect')

    return distorted_image.astype(np.float32) 

Example 36

def __init__(self, fig, variables, ranges, n_ordinate_levels=6):
        angles = np.arange(0, 360, 360./len(variables))

        axes = [fig.add_axes([0,0, 1,1],polar=True,
                label = "axes{}".format(i)) 
                for i in range(len(variables))]
        l, text = axes[0].set_thetagrids(angles, labels = variables)
        [txt.set_rotation(angle-90) for txt, angle in zip(text, angles)]
        for ax in axes[1:]:
            ax.patch.set_visible(False)
            ax.grid("off")
            ax.xaxis.set_visible(False)
        for i, ax in enumerate(axes):
            grid = np.linspace(*ranges[i], num=n_ordinate_levels)
            gridlabel = ["{}".format(round(x,2)) for x in grid]
            if ranges[i][0] > ranges[i][1]:
                grid = grid[::-1] # hack to invert grid
                          # gridlabels aren't reversed
            gridlabel[0] = "" # clean up origin
            ax.set_rgrids(grid, labels=gridlabel, angle=angles[i])           
            ax.set_ylim(*ranges[i])
        # variables for plotting
        self.angle = np.deg2rad(np.r_[angles, angles[0]])
        self.ranges = ranges
        self.ax = axes[0] 

Example 37

def generate_circle_points(radius, initial_angle, final_angle, points=199):
    """
    This methods generates points in a circle shape at (0,0) with a specific radius and from a 
    starting angle to a final angle.

    Args:
        radius: radius of the circle in microns
        initial_angle: initial angle of the drawing in degrees
        final_angle: final angle of the drawing in degrees
        points: amount of points to be generated (default 199)

    Returns:
        Set of points that form the circle
    """
    theta = np.linspace(    np.deg2rad(initial_angle), 
                            np.deg2rad(final_angle), 
                            points)

    return  radius * np.cos(theta) , radius * np.sin(theta) 

Example 38

def disttoedge(self, x, y, d):
        rd = numpy.deg2rad(d)
        dx, dy = numpy.cos(rd), numpy.sin(rd)

        maxx = self.width()
        maxy = self.height()

        if dx == 0:
            lefthit, righthit = sys.maxsize, sys.maxsize
            tophit, bothit = (maxy - y) / dy, (-y) / dy
        elif dy == 0:
            lefthit, righthit = (-x) / dx, (maxx - x) / dx
            tophit, bothit = sys.maxsize, sys.maxsize
        else:
            lefthit, righthit = (-x) / dx, (maxx - x) / dx
            tophit, bothit = (maxy - y) / dy, (-y) / dy

        # Return smallest positive
        dists = list(filter(lambda s: s > 0, [lefthit, righthit, tophit, bothit]))
        if len(dists) == 0:
            return 0
        else:
            return min(dists) 

Example 39

def rotation_matrix_axis(C_values):
    # Change coordinate system through matrix C
    rx = np.deg2rad(float(C_values[0]))
    ry = np.deg2rad(float(C_values[1]))
    rz = np.deg2rad(float(C_values[2]))

    Cx = np.matrix([[1, 0, 0],
                    [0, np.cos(rx), np.sin(rx)],
                    [0, -np.sin(rx), np.cos(rx)]])

    Cy = np.matrix([[np.cos(ry), 0, -np.sin(ry)],
                    [0, 1, 0],
                    [np.sin(ry), 0, np.cos(ry)]])

    Cz = np.matrix([[np.cos(rz), np.sin(rz), 0],
                    [-np.sin(rz), np.cos(rz), 0],
                    [0, 0, 1]])

    C = Cx * Cy * Cz
    Cinv = np.linalg.inv(C)
    return C, Cinv 

Example 40

def rotation_matrix(bone, tx, ty, tz):
    # Construct rotation matrix M
    tx = np.deg2rad(tx)
    ty = np.deg2rad(ty)
    tz = np.deg2rad(tz)

    Mx = np.matrix([[1, 0, 0],
                    [0, np.cos(tx), np.sin(tx)],
                    [0, -np.sin(tx), np.cos(tx)]])

    My = np.matrix([[np.cos(ty), 0, -np.sin(ty)],
                    [0, 1, 0],
                    [np.sin(ty), 0, np.cos(ty)]])

    Mz = np.matrix([[np.cos(tz), np.sin(tz), 0],
                    [-np.sin(tz), np.cos(tz), 0],
                    [0, 0, 1]])
    M = Mx * My * Mz
    L = bone.Cinv * M * bone.C
    return L 

Example 41

def keyframedb(self, theta=np.deg2rad(20), displacement=0.25, lookup_history=10, verbose=True): 
        sampler = PoseSampler(theta=theta, displacement=displacement, lookup_history=lookup_history, 
                              get_sample=lambda (t, channel, frame): frame.pose, verbose=verbose)
        self.iterframes = partial(sampler.iteritems, self.iterframes())
        return self

    # def list_annotations(self, target_name=None): 
    #     " List of lists"
    #     inds = self.annotated_inds
    #     return [ filter(lambda frame: 
    #                     target_name is None or name is in target_name, 
    #                     self.dataset.annotationdb.iterframes(inds))
                      


    # def _build_graph(self): 
    #     # Keep a queue of finite length to ensure 
    #     # time-sync with RGB and IMU
    #     self.__pose_q = deque(maxlen=10)

    #     self.nodes_ = []

    #     for (t,ch,data) in self.dataset_.itercursors(topics=[]): 
    #         if ch == TANGO_VIO_CHANNEL: 
    #             self.__pose_q.append(data)
    #             continue
            
    #         if not len(self.__pose_q): 
    #             continue

    #         assert(ch == TANGO_RGB_CHANNEL)
    #         self.nodes_.append(dict(img=data, pose=self.__pose_q[-1]))
            

# Basic type for tango frame (includes pose, image, timestamp) 

Example 42

def draw_camera(pose, zmin=0.0, zmax=0.1, fov=np.deg2rad(60)): 

    frustum = Frustum(pose, zmin=zmin, zmax=zmax, fov=fov)
    nul, nll, nlr, nur, ful, fll, flr, fur = frustum.vertices
    # nll, nlr, nur, nul, fll, flr, fur, ful = frustum.vertices

    faces = []

    # Triangles: Front Face
    faces.extend([ful, fur, flr])
    faces.extend([flr, ful, fll])

    # Triangles: Back Face
    faces.extend([nul, nur, nlr])
    faces.extend([nlr, nul, nll])

    # Triangles: Four walls (2-triangles per face)
    left, top, right, bottom = [fll, nll, ful, ful, nll, nul], \
                               [ful, nul, fur, fur, nul, nur], \
                               [fur, nur, flr, flr, nur, nlr], \
                               [flr, nlr, fll, fll, nlr, nll]
    faces.extend([left, top, right, bottom]) # left, top, right, bottom wall
    faces = np.vstack(faces)

    # Lines: zmin-zmax
    pts = []
    pts.extend([ful, fur, flr, fll, ful])
    pts.extend([ful, fll, nll, nul, ful])
    pts.extend([ful, nul, nur, fur, ful])
    pts.extend([fur, nur, nlr, flr, fur])
    pts.extend([flr, nlr, nll, fll, flr])
    pts = np.vstack(pts)
    
    return (faces, np.hstack([pts[:-1], pts[1:]]).reshape((-1,3))) 

Example 43

def __init__(self, pose, zmin=0.0, zmax=0.1, fov=np.deg2rad(60)): 
        # FoV derived from fx,fy,cx,cy=500,500,320,240
        # fovx, fovy = 65.23848614  51.28201165
        rx, ry = 0.638, 0.478

        self.pose = pose
        arr = [np.array([-rx, -ry, 1.]) * zmin,
               np.array([-rx,  ry, 1.]) * zmin,
               np.array([ rx,  ry, 1.]) * zmin,
               np.array([ rx, -ry, 1.]) * zmin,

               np.array([-rx, -ry, 1.]) * zmax,
               np.array([-rx,  ry, 1.]) * zmax,
               np.array([ rx,  ry, 1.]) * zmax,
               np.array([ rx, -ry, 1.]) * zmax]

        # vertices: nul, nll, nlr, nur, ful, fll, flr, fur
        self.vertices_ = self.pose * np.vstack(arr)

        # self.near, self.far = np.array([0,0,zmin]), np.array([0,0,zmax])
        # self.near_off, self.far_off = np.tan(fov / 2) * zmin, np.tan(fov / 2) * zmax

        # arr = [self.near + np.array([-1, -1, 0]) * self.near_off, 
        #        self.near + np.array([1, -1, 0]) * self.near_off, 
        #        self.near + np.array([1, 1, 0]) * self.near_off, 
        #        self.near + np.array([-1, 1, 0]) * self.near_off, 
               
        #        self.far + np.array([-1, -1, 0]) * self.far_off, 
        #        self.far + np.array([1, -1, 0]) * self.far_off, 
        #        self.far + np.array([1, 1, 0]) * self.far_off, 
        #        self.far + np.array([-1, 1, 0]) * self.far_off]
        
        # nll, nlr, nur, nul, fll, flr, fur, ful = self.pose * np.vstack(arr)
        # return nll, nlr, nur, nul, fll, flr, fur, ful 

Example 44

def __init__(self, theta=np.deg2rad(20), displacement=0.25, lookup_history=10, 
                 get_sample=lambda item: item, 
                 on_sampled_cb=lambda index, item: None, verbose=False): 
        Sampler.__init__(self, lookup_history=lookup_history, 
                         get_sample=get_sample, 
                         on_sampled_cb=on_sampled_cb, verbose=verbose)

        self.displacement_ = displacement
        self.theta_ = theta 

Example 45

def obj_set_position_target(self, handle, angle):
		return self.RAPI_rc(vrep.simxSetJointTargetPosition( self.cID,handle,
			-np.deg2rad(angle),
			vrep.simx_opmode_blocking)) 

Example 46

def getJitteredParams(self, num, center=(0.0, 0.0), maxRot=(-5.0, 5.0), maxTranslate=(-2.0, 2.0),
                          maxScale=(-0.1, 0.1), mirror=True):

        if not (type(maxRot) is tuple):
            maxRot = (-maxRot, maxRot)
        if not (type(maxTranslate) is tuple):
            maxTranslate = (-maxTranslate, maxTranslate)
        if not (type(maxScale) is tuple):
            maxScale = (-maxScale, maxScale)

        alphas = self.rng.rand(num) * (maxRot[1] - maxRot[0]) + maxRot[0]
        alphas = numpy.deg2rad(alphas)

        tx = self.rng.rand(num) * (maxTranslate[1] - maxTranslate[0]) + maxTranslate[0]
        ty = self.rng.rand(num) * (maxTranslate[1] - maxTranslate[0]) + maxTranslate[0]

        sc = 2 ** -(self.rng.rand(num) * (maxScale[1] - maxScale[0]) + maxScale[0])

        if mirror:
            mi = self.rng.randint(2, size=num)  # mirror true or false
        else:
            mi = numpy.zeros(num)

        transformationMats = []
        for i in range(num):
            # First is not modified
            if i == 0:
                t = numpy.array([0, 0, 0, 1, 0])
            else:
                t = numpy.array([alphas[i], tx[i], ty[i], sc[i], mi[i]])
            transformationMats.append(t)

        return transformationMats 

Example 47

def rotate(self, deg, center = (0,0)):
        ''' rotates the image by set degree'''
        #where c is the cosine of the angle, s is the sine of the angle and
        #x0, y0 are used to correctly translate the rotated image.
        
        # size of source image
        src_dimsx = self.data.shape[0]
        src_dimsy = self.data.shape[1]
        
        # get the radians and calculate sin and cos
        rad = np.deg2rad(deg)
        c = np.cos(rad)
        s = np.sin(rad)
        
        # calculate center of image
        cx = center[0] + src_dimsx/2
        cy = center[1] + src_dimsy/2
        
        # factor that moves the index to the center
        x0 = cx - c*cx - s*cx
        y0 = cy - c*cy + s*cy
        
        # initialize destination image
        dest = MyImage(self.data.shape)
        for y in range(src_dimsy):
            for x in range(src_dimsx):
                # get the source indexes
                src_x = int(c*x + s*y + x0)
                src_y = int(-s*x + c*y + y0)
                if src_y > 0 and src_y < src_dimsy and src_x > 0 and src_x < src_dimsx:
                    #paste the value in the destination image
                    dest.data[x][y] = self.data[src_x][src_y]
                    
        self.data = dest.data 

Example 48

def normalize_cord(latitude, longitude):
        '''
        Normalize GPS cord array, assuming the earth is shpherical
        :param latitude: latitude array to normalize
        :param longitude: longitude array to normalize
        :return: normalized arrays (np.array)
        '''
        rad_lat = np.deg2rad(latitude)
        rad_lon = np.deg2rad(longitude)

        x = np.cos(rad_lat) * np.cos(rad_lon)
        y = np.cos(rad_lat) * np.sin(rad_lon)
        z = np.sin(rad_lat)

        return x, y, z 

Example 49

def d_xy(self):
        """
        The sampling interval along the (X, Y) spatial dimensions,
        translated from the pixel size.
        Unit: [Mpc]

        Reference: Ref.[liu2014].Eq.(A7)
        """
        pixelsize = self.pixelsize / 3600  # [arcsec] -> [deg]
        d_xy = self.DMz * np.deg2rad(pixelsize)
        return d_xy 

Example 50

def rotate_about_center(src, angle, scale=1.):
    w = src.shape[1]
    h = src.shape[0]
    rangle = np.deg2rad(angle)  # angle in radians
    nw = (abs(np.sin(rangle)*h) + abs(np.cos(rangle)*w))*scale
    nh = (abs(np.cos(rangle)*h) + abs(np.sin(rangle)*w))*scale
    rot_mat = cv2.getRotationMatrix2D((nw*0.5, nh*0.5), angle, scale)
    rot_move = np.dot(rot_mat, np.array([(nw-w)*0.5, (nh-h)*0.5,0]))
    rot_mat[0,2] += rot_move[0]
    rot_mat[1,2] += rot_move[1]
    return cv2.warpAffine(src, rot_mat, (int(math.ceil(nw)), int(math.ceil(nh))), flags=cv2.INTER_LANCZOS4) 
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注