Python math.asin() Examples

The following are code examples for showing how to use math.asin(). 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
Project: DITRAS   Author: jonpappalord   File: DITRAS.py    (license) View Source Project 7 votes vote down vote up
def earth_distance(lat_lng1, lat_lng2):
    """
    Compute the distance (in km) along earth between two latitude and longitude pairs

    Parameters
    ----------
    lat_lng1: tuple
        the first latitude and longitude pair
    lat_lng2: tuple
        the second latitude and longitude pair

    Returns
    -------
    float
        the distance along earth in km
    """
    lat1, lng1 = [l*pi/180 for l in lat_lng1]
    lat2, lng2 = [l*pi/180 for l in lat_lng2]
    dlat, dlng = lat1-lat2, lng1-lng2
    ds = 2 * asin(sqrt(sin(dlat/2.0) ** 2 + cos(lat1) * cos(lat2) * sin(dlng/2.0) ** 2))
    return 6371.01 * ds  # spherical earth... 
Example 2
Project: satellite-tracker   Author: lofaldli   File: coords.py    (MIT License) View Source Project 6 votes vote down vote up
def eci_to_latlon(pos, phi_0=0):
    (x, y, z) = pos
    rg = (x*x + y*y + z*z)**0.5
    z = z/rg
    if abs(z) > 1.0:
        z = int(z)

    lat = degrees(asin(z))
    lon = degrees(atan2(y, x)-phi_0)
    if lon > 180:
        lon -= 360
    elif lon < -180:
        lon += 360
    assert -90 <= lat <= 90
    assert -180 <= lon <= 180
    return lat, lon 
Example 3
Project: coralillo   Author: getfleety   File: datamodel.py    (license) View Source Project 6 votes vote down vote up
def distance(self, loc):
        """
        Calculate the great circle distance between two points
        on the earth (specified in decimal degrees)
        """
        assert type(loc) == type(self)

        # convert decimal degrees to radians
        lon1, lat1, lon2, lat2 = map(radians, [
            self.lon,
            self.lat,
            loc.lon,
            loc.lat,
        ])

        # haversine formula
        dlon = lon2 - lon1
        dlat = lat2 - lat1
        a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
        c = 2 * asin(sqrt(a))
        r = 6371000 # Radius of earth in meters.
        return c * r 
Example 4
Project: AboveTustin   Author: kevinabrandon   File: geomath.py    (license) View Source Project 6 votes vote down vote up
def distance(pointA, pointB):
	"""
	Calculate the great circle distance between two points 
	on the earth (specified in decimal degrees)

	http://stackoverflow.com/questions/15736995/how-can-i-quickly-estimate-the-distance-between-two-latitude-longitude-points
	"""
	# convert decimal degrees to radians 
	lon1, lat1, lon2, lat2 = map(math.radians, [pointA[1], pointA[0], pointB[1], pointB[0]])

	# haversine formula 
	dlon = lon2 - lon1 
	dlat = lat2 - lat1 
	a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
	c = 2 * math.asin(math.sqrt(a)) 
	r = 3956  # Radius of earth in miles. Use 6371 for kilometers
	return c * r 
Example 5
Project: gym-extensions   Author: Breakend   File: env_utils.py    (license) View Source Project 6 votes vote down vote up
def winding_angle(self, path, point):
        wa = 0
        for i in range(len(path)-1):
            p = np.array([path[i].x, path[i].y])
            pn = np.array([path[i+1].x, path[i+1].y])

            vp = p - point
            vpn = pn - point

            vp_norm = sqrt(vp[0]**2 + vp[1]**2)
            vpn_norm = sqrt(vpn[0]**2 + vpn[1]**2)

            assert (vp_norm > 0)
            assert (vpn_norm > 0)

            z = np.cross(vp, vpn)/(vp_norm * vpn_norm)
            z = min(max(z, -1.0), 1.0)
            wa += asin(z)

        return wa 
Example 6
Project: UrbanSearch   Author: urbansearchTUD   File: db_utils.py    (license) View Source Project 6 votes vote down vote up
def compute_all_ic_rels_with_threshold(threshold):
    """
    Computes all intercity relations for documents classified with higher probability
    than the given threshold.

    :param threshold: The minimum probability
    :result: A list of dictionaries with city_a, city_b, category and score fields.
    """
    query = '''
        UNWIND [{0}] AS category
        MATCH (a:City)-[:{1}]->(i:Index)<-[:{1}]-(b:City)
        WHERE ID(a) < ID(b) AND a.name <> b.name AND i[category] >= {2}
        MATCH (a)-[r:{3}]->(b)
        WITH a.name AS city_a, a.population AS pop_a, b.name AS city_b,
            b.population AS pop_b, r.total AS total, COUNT(i) AS count, category,
            2 * 6371 * asin(sqrt(haversin(radians(a.latitude - b.latitude)) +
            cos(radians(a.latitude)) * cos(radians(b.latitude)) *
            haversin(radians(a.longitude - b.longitude)))) AS dist
        RETURN city_a, pop_a, city_b, pop_b, dist, total, category, SUM(count) AS score
    '''.format(','.join('"{}"'.format(c) for c in CAT_NO_OTHER), OCCURS_IN, threshold, RELATES_TO)

    return perform_query(query, [], access_mode='read') 
Example 7
Project: Houston   Author: squaresLab   File: util.py    (license) View Source Project 6 votes vote down vote up
def gps_newpos(lat, lon, bearing, distance):
    """Extrapolate latitude/longitude given a heading and distance
    thanks to http://www.movable-type.co.uk/scripts/latlong.html .
    """
    from math import sin, asin, cos, atan2, radians, degrees

    lat1 = radians(lat)
    lon1 = radians(lon)
    brng = radians(bearing)
    dr = distance / radius_of_earth

    lat2 = asin(sin(lat1) * cos(dr) +
                cos(lat1) * sin(dr) * cos(brng))
    lon2 = lon1 + atan2(sin(brng) * sin(dr) * cos(lat1),
                        cos(dr) - sin(lat1) * sin(lat2))
    return (degrees(lat2), degrees(lon2)) 
Example 8
Project: siren   Author: ozsolarwind   File: towns.py    (license) View Source Project 6 votes vote down vote up
def haversine(self, lat1, lon1, lat2, lon2):
        """
        Calculate the great circle distance between two points
        on the earth (specified in decimal degrees)
        """
     # convert decimal degrees to radians
        lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

     # haversine formula
        dlon = lon2 - lon1
        dlat = lat2 - lat1
        a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
        c = 2 * asin(sqrt(a))

     # 6367 km is the radius of the Earth
        km = 6367 * c
        return km

#   might extend capability to restrict towns to network boundary 
Example 9
Project: siren   Author: ozsolarwind   File: plotweather.py    (license) View Source Project 6 votes vote down vote up
def haversine(self, lat1, lon1, lat2, lon2):
        """
        Calculate the great circle distance between two points
        on the earth (specified in decimal degrees)
        """
   #     convert decimal degrees to radians
        lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

   #     haversine formula
        dlon = lon2 - lon1
        dlat = lat2 - lat1
        a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
        c = 2 * asin(sqrt(a))

   #     6367 km is the radius of the Earth
        km = 6367 * c
        return km 
Example 10
Project: siren   Author: ozsolarwind   File: powermodel.py    (license) View Source Project 6 votes vote down vote up
def haversine(self, lat1, lon1, lat2, lon2):
        """
        Calculate the great circle distance between two points
        on the earth (specified in decimal degrees)
        """
   #     convert decimal degrees to radians
        lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])

   #     haversine formula
        dlon = lon2 - lon1
        dlat = lat2 - lat1
        a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
        c = 2 * asin(sqrt(a))

   #     6367 km is the radius of the Earth
        km = 6367 * c
        return km 
Example 11
Project: tbp-next-basket   Author: GiulioRossetti   File: distance_functions.py    (license) View Source Project 6 votes vote down vote up
def spherical_distance(a, b):
    lat1 = a[1]
    lon1 = a[0]
    lat2 = b[1]
    lon2 = b[0]
    R = 6371000.0
    rlon1 = lon1 * math.pi / 180.0
    rlon2 = lon2 * math.pi / 180.0
    rlat1 = lat1 * math.pi / 180.0
    rlat2 = lat2 * math.pi / 180.0
    dlon = (rlon1 - rlon2) / 2.0
    dlat = (rlat1 - rlat2) / 2.0
    lat12 = (rlat1 + rlat2) / 2.0
    sindlat = math.sin(dlat)
    sindlon = math.sin(dlon)
    cosdlon = math.cos(dlon)
    coslat12 = math.cos(lat12)
    f = sindlat * sindlat * cosdlon * cosdlon + sindlon * sindlon * coslat12 * coslat12
    f = math.sqrt(f)
    f = math.asin(f) * 2.0 # the angle between the points
    f *= R
    return f 
Example 12
Project: krpc-library   Author: krpc   File: landing.py    (license) View Source Project 6 votes vote down vote up
def coords_down_bearing(lat, lon, bearing, distance, body):
        '''
        Takes a latitude, longitude and bearing in degrees, and a
        distance in meters over a given body.  Returns a tuple
        (latitude, longitude) of the point you've calculated.
        '''
        bearing = math.radians(bearing)
        R = body.equatorial_radius
        lat = math.radians(lat)
        lon = math.radians(lon)
        
        lat2 = math.asin( math.sin(lat)*math.cos(distance/R) +
                     math.cos(lat)*math.sin(distance/R)*math.cos(bearing))

        lon2 = lon + math.atan2(math.sin(bearing)*math.sin(distance/R
                        )*math.cos(lat),math.cos(distance/R)-math.sin(lat
                        )*math.sin(lat2))

        lat2 = math.degrees(lat2)
        lon2 = math.degrees(lon2)
        return (lat2, lon2) 
Example 13
Project: crazyswarm   Author: USC-ACTLab   File: crazyflieSim.py    (license) View Source Project 6 votes vote down vote up
def rpy(self):
        acc = self.acceleration()
        yaw = self.yaw()
        norm = np.linalg.norm(acc)
        # print(acc)
        if norm < 1e-6:
            return (0.0, 0.0, yaw)
        else:
            thrust = acc + np.array([0, 0, 9.81])
            z_body = thrust / np.linalg.norm(thrust)
            x_world = np.array([math.cos(yaw), math.sin(yaw), 0])
            y_body = np.cross(z_body, x_world)
            x_body = np.cross(y_body, z_body)
            pitch = math.asin(-x_body[2])
            roll = math.atan2(y_body[2], z_body[2])
            return (roll, pitch, yaw)

    # "private" methods 
Example 14
Project: pydelhi_mobile   Author: pydelhi   File: utils.py    (license) View Source Project 6 votes vote down vote up
def haversine(lon1, lat1, lon2, lat2):
    """
    Calculate the great circle distance between two points
    on the earth (specified in decimal degrees)

    Taken from: http://stackoverflow.com/questions/4913349/haversine-formula-in-python-bearing-and-distance-between-two-gps-points
    """
    # convert decimal degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
    # haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2

    c = 2 * asin(sqrt(a))
    km = 6367 * c
    return km 
Example 15
Project: HAB2017   Author: LBCC-SpaceClub   File: utils.py    (license) View Source Project 6 votes vote down vote up
def haversine(lon1, lat1, lon2, lat2):
    """
    Calculate the great circle distance between two points
    on the earth (specified in decimal degrees)

    Taken from: http://stackoverflow.com/questions/4913349/haversine-formula-in-python-bearing-and-distance-between-two-gps-points
    """
    # convert decimal degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
    # haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2

    c = 2 * asin(sqrt(a))
    km = 6367 * c
    return km 
Example 16
Project: SCOUT   Author: johngroves   File: navigation.py    (license) View Source Project 6 votes vote down vote up
def haversine(lat1, lon1, lat2, lon2):
    """
    Calculate the great circle distance between two points
    on the earth (specified in decimal degrees)
    """
    # convert decimal degrees to radians
    lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])

    # haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1

    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    r = 3956 # Radius of earth in miles

    return c * r 
Example 17
Project: open_landscape   Author: furti   File: open_landscape_math.py    (license) View Source Project 6 votes vote down vote up
def point_from_distance_and_angle(point: CoordinatePoint, distance_in_m: float,
                                  angle_in_degrees: int) -> CoordinatePoint:
    """Calculates a point with the given angle and distance meters away from the given point"""

    lat1 = math.radians(point.latitude)
    lon1 = math.radians(point.longitude)

    distance = distance_in_m / 1000 / 6371
    angle = math.radians(angle_in_degrees)

    lat2 = math.asin(math.sin(lat1) * math.cos(distance) +
                     math.cos(lat1) * math.sin(distance) * math.cos(angle))
    lon2 = lon1 + math.asin((math.sin(distance) /
                             math.cos(lat2)) * math.sin(angle))

    return CoordinatePoint(latitude=math.degrees(lat2), longitude=math.degrees(lon2)) 
Example 18
Project: dxf2gcode   Author: cnc-club   File: euclid.py    (license) View Source Project 6 votes vote down vote up
def get_euler(self):
        t = self.x * self.y + self.z * self.w
        if t > 0.4999:
            heading = 2 * math.atan2(self.x, self.w)
            attitude = math.pi / 2
            bank = 0
        elif t < -0.4999:
            heading = -2 * math.atan2(self.x, self.w)
            attitude = -math.pi / 2
            bank = 0
        else:
            sqx = self.x ** 2
            sqy = self.y ** 2
            sqz = self.z ** 2
            heading = math.atan2(2 * self.y * self.w - 2 * self.x * self.z,
                                 1 - 2 * sqy - 2 * sqz)
            attitude = math.asin(2 * t)
            bank = math.atan2(2 * self.x * self.w - 2 * self.y * self.z,
                              1 - 2 * sqx - 2 * sqz)
        return heading, attitude, bank 
Example 19
Project: IPLookup   Author: rookford343   File: gmplot.py    (license) View Source Project 6 votes vote down vote up
def get_cycle(self, lat, lng, rad):
        # unit of radius: meter
        cycle = []
        d = (rad / 1000.0) / 6378.8
        lat1 = (math.pi / 180.0) * lat
        lng1 = (math.pi / 180.0) * lng

        r = [x * 10 for x in range(36)]
        for a in r:
            tc = (math.pi / 180.0) * a
            y = math.asin(
                math.sin(lat1) * math.cos(d) + math.cos(lat1) * math.sin(d) * math.cos(tc))
            dlng = math.atan2(math.sin(
                tc) * math.sin(d) * math.cos(lat1), math.cos(d) - math.sin(lat1) * math.sin(y))
            x = ((lng1 - dlng + math.pi) % (2.0 * math.pi)) - math.pi
            cycle.append(
                (float(y * (180.0 / math.pi)), float(x * (180.0 / math.pi))))
        return cycle 
Example 20
Project: prototype   Author: chutsu   File: jpl.py    (license) View Source Project 6 votes vote down vote up
def quat2euler(q):
    x, y, z, w = q.ravel()

    ysqr = y * y

    t0 = +2.0 * (w * x + y * z)
    t1 = +1.0 - 2.0 * (x * x + ysqr)
    X = atan2(t0, t1)

    t2 = +2.0 * (w * y - z * x)
    t2 = +1.0 if t2 > +1.0 else t2
    t2 = -1.0 if t2 < -1.0 else t2
    Y = asin(t2)

    t3 = +2.0 * (w * z + x * y)
    t4 = +1.0 - 2.0 * (ysqr + z * z)
    Z = atan2(t3, t4)

    return np.array([[X], [Y], [Z]]) 
Example 21
Project: pimaa   Author: outboxafrica   File: lsm303d.py    (license) View Source Project 6 votes vote down vote up
def getTiltHeading(self):
		magValue=self.getMag()
		accelValue=self.getRealAccel()
		
		X=self.X
		Y=self.Y
		Z=self.Z
		
		pitch = math.asin(-accelValue[X])
		
		print(accelValue[Y],pitch,math.cos(pitch),accelValue[Y]/math.cos(pitch),math.asin(accelValue[Y]/math.cos(pitch)))
		roll = math.asin(accelValue[Y]/math.cos(pitch))

		xh = magValue[X] * math.cos(pitch) + magValue[Z] * math.sin(pitch)
		yh = magValue[X] * math.sin(roll) * math.sin(pitch) + magValue[Y] * math.cos(roll) - magValue[Z] * math.sin(roll) * math.cos(pitch)
		zh = -magValue[X] * (roll) * math.sin(pitch) + magValue[Y] * math.sin(roll) + magValue[Z] * math.cos(roll) * math.cos(pitch)
		heading = 180 * math.atan2(yh, xh)/math.pi

		if (yh >= 0):
			return heading
		else:
			return (360 + heading) 
Example 22
Project: kicad_scripts   Author: NilujePerchut   File: td.py    (license) View Source Project 6 votes vote down vote up
def __ComputeCurved(vpercent, w, vec, via, pts, segs):
    """Compute the curves part points"""

    radius = via[1]/2.0

    # Compute the bezier middle points
    req_angle = asin(vpercent/100.0)
    oppside = tan(req_angle)*(radius-(w/sin(req_angle)))
    length = sqrt(radius*radius + oppside*oppside)
    d = req_angle - acos(radius/length)
    vecBC = [vec[0]*cos(d)+vec[1]*sin(d), -vec[0]*sin(d)+vec[1]*cos(d)]
    pointBC = via[0] + wxPoint(int(vecBC[0] * length), int(vecBC[1] * length))
    d = -d
    vecAE = [vec[0]*cos(d)+vec[1]*sin(d), -vec[0]*sin(d)+vec[1]*cos(d)]
    pointAE = via[0] + wxPoint(int(vecAE[0] * length), int(vecAE[1] * length))

    curve1 = __Bezier(pts[1], pointBC, pts[2], n=segs)
    curve2 = __Bezier(pts[4], pointAE, pts[0], n=segs)

    return curve1 + [pts[3]] + curve2 
Example 23
Project: show-me-earthquakes   Author: compciv   File: mapping.py    (license) View Source Project 6 votes vote down vote up
def haversine(pt_a, pt_b):
    """
    `pt_a` and `pt_b` are tuples with two float numbers each, i.e.
    representing lng/lat pairs:
    (99,100)  (-42, 85)

    The geo distance between the two points is returned in kilometers
    """
    from math import radians, cos, sin, asin, sqrt

    lng_a = radians(float(pt_a[0]))
    lat_a = radians(float(pt_a[1]))

    lng_b = radians(float(pt_b[0]))
    lat_b = radians(float(pt_b[1]))
    # haversine formula
    dlng = lng_b - lng_a
    dlat = lat_b - lat_a
    whatevs = sin(dlat /2 ) ** 2 + cos(lat_a) * cos(lat_b) * sin(dlng / 2) ** 2
    c = 2 * asin(sqrt(whatevs))
    r = 6371 # Radius of earth in kilometers.
    # return the final calculation
    return c * r 
Example 24
Project: jwst_gtvt   Author: spacetelescope   File: rotationsx.py    (license) View Source Project 6 votes vote down vote up
def cvt_inert2att_Q_to_angles(Q):
   """Creates a angle tuple from Q, assuming an inertial to attitude Q"""
   V1_body = Vector(1.,0.,0.)
   V1_eci_pt = Q.inv_cnvrt(V1_body)
   coord1  = math.atan2(V1_eci_pt.y,V1_eci_pt.x)
   if coord1 < 0. : coord1 += PI2
   coord2 = math.asin(unit_limit(V1_eci_pt.z))

   V3_body = Vector(0.,0.,1.)
   V3_eci_pt = Q.inv_cnvrt(V3_body)
   NP_eci = Vector(0.,0.,1.)
   V_left = cross(NP_eci,V1_eci_pt)
   V_left = V_left / V_left.length()
   NP_in_plane = cross(V1_eci_pt,V_left)
   x = dot(V3_eci_pt,NP_in_plane)
   y = dot(V3_eci_pt,V_left)
   pa  = math.atan2(y,x)
   if pa < 0. : pa += PI2
   return (coord1,coord2,pa) 
Example 25
Project: jwst_gtvt   Author: spacetelescope   File: rotationsx.py    (license) View Source Project 6 votes vote down vote up
def cvt_v2v3_using_body2inertial_Q_to_c1c2pa_tuple(Q,v2,v3):
   """Given Q and v2,v3 gives pos on sky and V3 PA """
   Vp_body = Vector(0.,0.,0.)
   Vp_body.set_xyz_from_angs(v2,v3)
   Vp_eci_pt = Q.cnvrt(Vp_body)
   coord1  = atan2(Vp_eci_pt.y,Vp_eci_pt.x)
   if coord1 < 0. : coord1 += PI2
   coord2 = asin(unit_limit(Vp_eci_pt.z))

   V3_body = Vector(0.,0.,1.)
   V3_eci_pt = Q.cnvrt(V3_body)
   NP_eci = Vector(0.,0.,1.)
   V_left = cross(NP_eci,Vp_eci_pt)
   if V_left.length()>0.:
      V_left = V_left/V_left.length()
   NP_in_plane = cross(Vp_eci_pt,V_left)
   x = dot(V3_eci_pt,NP_in_plane)
   y = dot(V3_eci_pt,V_left)
   pa  = atan2(y,x)
   if pa < 0. : pa += PI2

   return (coord1,coord2,pa) 
Example 26
Project: jwst_gtvt   Author: spacetelescope   File: rotationsx.py    (license) View Source Project 6 votes vote down vote up
def cvt_c1c2_using_body2inertial_Q_to_v2v3pa_tuple(Q,coord1,coord2):
   """Given Q and a position, returns v2,v3,V3PA tuple """
   Vp_eci = Vector(1.,0.,0.)
   Vp_eci.set_xyz_from_angs(coord1,coord2)
   Vp_body_pt = Q.inv_cnvrt(Vp_eci)
   v2 = atan2(Vp_body_pt.y,Vp_body_pt.x)
   v3 = asin(unit_limit(Vp_body_pt.z))
   V3_body = Vector(0.,0.,1.)
   V3_eci_pt = self.cnvrt(V3_body)
   NP_eci = Vector(0.,0.,1.)
   V_left = cross(NP_eci,Vp_eci)
   if V_left.length()>0.:
    V_left = V_left / V_left.length()
   NP_in_plane = cross(Vp_eci,V_left)
   x = dot(V3_eci_pt,NP_in_plane)
   y = dot(V3_eci_pt,V_left)
   pa  = atan2(y,x)
   if pa < 0. : pa += PI2
   return (v2,v3,pa)


############################################################ 
Example 27
Project: Tutorials   Author: harfang3d   File: 12_scene_physic_kapla_interactive.py    (license) View Source Project 6 votes vote down vote up
def add_kapla_tower(scn, width, height, length, radius, level_count: int, x=0, y=0, z=0):
	"""Create a Kapla tower, return a list of created nodes"""
	tower = []
	level_y = y + height / 2

	for i in range(level_count // 2):
		def fill_ring(r, ring_y, size, r_adjust, y_off):
			step = asin((size * 1.01) / 2 / (r - r_adjust)) * 2
			cube_count = (2 * pi) // step
			error = 2 * pi - step * cube_count
			step += error / cube_count  # distribute error

			a = 0
			while a < (2 * pi - error):
				world = gs.Matrix4.TransformationMatrix(gs.Vector3(cos(a) * r + x, ring_y, sin(a) * r + z), gs.Vector3(0, -a + y_off, 0))
				tower.append(plus.AddPhysicCube(scn, world, width, height, length, 2)[0])
				a += step

		fill_ring(radius - length / 2, level_y, width, length / 2, pi / 2)
		level_y += height
		fill_ring(radius - length + width / 2, level_y, length, width / 2, 0)
		fill_ring(radius - width / 2, level_y, length, width / 2, 0)
		level_y += height

	return tower 
Example 28
Project: Tutorials   Author: harfang3d   File: 11_scene_physic_kapla.py    (license) View Source Project 6 votes vote down vote up
def add_kapla_tower(scn, width, height, length, radius, level_count: int, x=0, y=0, z=0):
	"""Create a Kapla tower, return a list of created nodes"""
	level_y = y + height / 2

	for i in range(level_count // 2):
		def fill_ring(r, ring_y, size, r_adjust, y_off):
			step = asin((size * 1.01) / 2 / (r - r_adjust)) * 2
			cube_count = (2 * pi) // step
			error = 2 * pi - step * cube_count
			step += error / cube_count  # distribute error

			a = 0
			while a < (2 * pi - error):
				world = gs.Matrix4.TransformationMatrix((cos(a) * r + x, ring_y, sin(a) * r + z), (0, -a + y_off, 0))
				plus.AddPhysicCube(scn, world, width, height, length, 2)
				a += step

		fill_ring(radius - length / 2, level_y, width, length / 2, pi / 2)
		level_y += height
		fill_ring(radius - length + width / 2, level_y, length, width / 2, 0)
		fill_ring(radius - width / 2, level_y, length, width / 2, 0)
		level_y += height 
Example 29
Project: TauMeta   Author: slspencer   File: patternmath.py    (license) View Source Project 6 votes vote down vote up
def intersectChordCircle(C, P, chord_length):
    ''' 
    Accepts center of circle, a point on the circle, and chord length.  
    Returns a list of two points on the circle at chord_length distance away from original point
    '''
    C = dPnt(C)
    P = dPnt(P)
    d = chord_length
    r = distance(C, P)
    # point on circle given chordlength & starting point=2*asin(d/2r)
    d_div_2r = d / (2.0 * r)
    angle = 2 * asin(d_div_2r)
    P = []
    P.append(polar(C, r, angle))
    P.append(polar(C, r, - angle))
    return P

#def tangentOnCircleFromPoint(C, r, P): 
Example 30
Project: route2map   Author: xuboying   File: pygmaps.py    (license) View Source Project 6 votes vote down vote up
def getcycle(self,rpoint):
		cycle = []
		lat = rpoint[0]
		lng = rpoint[1]
		rad = rpoint[2] #unit: meter
		d = (rad/1000.0)/6378.8;
		lat1 = (math.pi/180.0)* lat
		lng1 = (math.pi/180.0)* lng

		r = [x*30 for x in range(12)]
		for a in r:
			tc = (math.pi/180.0)*a;
			y = math.asin(math.sin(lat1)*math.cos(d)+math.cos(lat1)*math.sin(d)*math.cos(tc))
			dlng = math.atan2(math.sin(tc)*math.sin(d)*math.cos(lat1),math.cos(d)-math.sin(lat1)*math.sin(y))
			x = ((lng1-dlng+math.pi) % (2.0*math.pi)) - math.pi 
			cycle.append( ( float(y*(180.0/math.pi)),float(x*(180.0/math.pi)) ) )
		return cycle 
Example 31
Project: snowballing   Author: JoaoFelipe   File: utils.py    (license) View Source Project 6 votes vote down vote up
def lines_len_in_circle(r, font_size=12, letter_width=7.2):
    """Return the amount of chars that fits each line in a circle according to
    its radius *r*

    Doctest:

    .. doctest::

        >>> lines_len_in_circle(20)
        [2, 5, 2]
    """
    lines = 2 * r // font_size
    positions = [
        x + (font_size // 2) * (-1 if x <= 0 else 1)
        for x in text_y(lines)
    ]
    return [
        int(2 * r * cos(asin(y / r)) / letter_width)
        for y in positions
    ] 
Example 32
Project: pokeslack   Author: timwah   File: pokesearch.py    (license) View Source Project 6 votes vote down vote up
def get_new_coords(init_loc, distance, bearing):
    """ Given an initial lat/lng, a distance(in kms), and a bearing (degrees),
    this will calculate the resulting lat/lng coordinates.
    """
    R = 6378.1 #km radius of the earth
    bearing = math.radians(bearing)

    init_coords = [math.radians(init_loc[0]), math.radians(init_loc[1])] # convert lat/lng to radians

    new_lat = math.asin( math.sin(init_coords[0])*math.cos(distance/R) +
        math.cos(init_coords[0])*math.sin(distance/R)*math.cos(bearing))

    new_lon = init_coords[1] + math.atan2(math.sin(bearing)*math.sin(distance/R)*math.cos(init_coords[0]),
        math.cos(distance/R)-math.sin(init_coords[0])*math.sin(new_lat))

    return [math.degrees(new_lat), math.degrees(new_lon)] 
Example 33
Project: Tiltometer   Author: djcopley   File: IMU.py    (license) View Source Project 6 votes vote down vote up
def calc_pitch():

    """ Calculates pitch value"""

    acc_x = read_acc_x()
    acc_y = read_acc_y()
    acc_z = read_acc_z()

    acc_x_norm = acc_x / math.sqrt(acc_x * acc_x + acc_y * acc_y + acc_z * acc_z)

    try:
        pitch = math.asin(acc_x_norm)
        return pitch

    except Exception as e:
        logging.debug(e)
    return 0 
Example 34
Project: Tiltometer   Author: djcopley   File: IMU.py    (license) View Source Project 6 votes vote down vote up
def calc_roll():

    """ Calculates roll value """

    acc_x = read_acc_x()
    acc_y = read_acc_y()
    acc_z = read_acc_z()

    acc_y_norm = acc_y / math.sqrt(acc_x * acc_x + acc_y * acc_y + acc_z * acc_z)

    try:
        roll = -math.asin(acc_y_norm / math.cos(calc_pitch()))
        return roll

    except Exception as e:
        logging.debug(e)
        return 0 
Example 35
Project: mobileinsight-mobile   Author: mobile-insight   File: utils.py    (license) View Source Project 6 votes vote down vote up
def haversine(lon1, lat1, lon2, lat2):
    """
    Calculate the great circle distance between two points
    on the earth (specified in decimal degrees)

    Taken from: http://stackoverflow.com/questions/4913349/haversine-formula-in-python-bearing-and-distance-between-two-gps-points
    """
    # convert decimal degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
    # haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2

    c = 2 * asin(sqrt(a))
    km = 6367 * c
    return km 
Example 36
Project: geojson-python-utils   Author: brandonxiang   File: geojson_utils.py    (license) View Source Project 6 votes vote down vote up
def draw_circle(radius_in_meters, center_point, steps=15):
    """
    get a circle shape polygon based on centerPoint and radius

    Keyword arguments:
    point1  -- point one geojson object
    point2  -- point two geojson object

    if(point inside multipoly) return true else false
    """
    steps = steps if steps > 15 else 15
    center = [center_point['coordinates'][1], center_point['coordinates'][0]]
    dist = (radius_in_meters / 1000) / 6371
    # convert meters to radiant
    rad_center = [number2radius(center[0]), number2radius(center[1])]
    # 15 sided circle
    poly = []
    for step in range(0, steps):
        brng = 2 * math.pi * step / steps
        lat = math.asin(math.sin(rad_center[0]) * math.cos(dist) +
                        math.cos(rad_center[0]) * math.sin(dist) * math.cos(brng))
        lng = rad_center[1] + math.atan2(math.sin(brng) * math.sin(dist)
                                         * math.cos(rad_center[0]), math.cos(dist) - math.sin(rad_center[0]) * math.sin(lat))
        poly.append([number2degree(lng), number2degree(lat)])
    return {"type": "Polygon", "coordinates": [poly]} 
Example 37
Project: geojson-python-utils   Author: brandonxiang   File: geojson_utils.py    (license) View Source Project 6 votes vote down vote up
def destination_point(point, brng, dist):
    """
    Calculate a destination Point base on a base point and a distance

    Keyword arguments:
    pt   -- polygon geojson object
    brng -- an angle in degrees
    dist -- distance in Kilometer between destination and base point

    return destination point object

    """
    dist = float(dist) / 6371  # convert dist to angular distance in radians
    brng = number2radius(brng)

    lon1 = number2radius(point['coordinates'][0])
    lat1 = number2radius(point['coordinates'][1])

    lat2 = math.asin(math.sin(lat1) * math.cos(dist) +
                     math.cos(lat1) * math.sin(dist) * math.cos(brng))
    lon2 = lon1 + math.atan2(math.sin(brng) * math.sin(dist) *
                             math.cos(lat1), math.cos(dist) - math.sin(lat1) * math.sin(lat2))
    lon2 = (lon2 + 3 * math.pi) % (2 * math.pi) - math.pi  # normalise to -180 degree +180 degree

    return {'type': 'Point', 'coordinates': [number2degree(lon2), number2degree(lat2)]} 
Example 38
Project: alib   Author: vnep-approx   File: scenariogeneration.py    (license) View Source Project 6 votes vote down vote up
def haversine(lon1, lat1, lon2, lat2):
    """
    Calculate the great circle distance between two points
    on the earth (specified in decimal degrees)
    """
    # convert decimal degrees to radians
    lon1, lat1, lon2, lat2 = map(math.radians, [lon1, lat1, lon2, lat2])

    # haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
    c = 2 * math.asin(math.sqrt(a))
    # 6367 km is the radius of the Earth
    km = 6367 * c
    latency = km / 200000
    return latency 
Example 39
Project: pyhiro   Author: wanweiwei07   File: hrp2kik.py    (license) View Source Project 6 votes vote down vote up
def eubik(pos, armid="rgt"):
    """
    compute the euristic waist rotation
    ew = euristic waist

    :param pos: object position
    :return: waistangle in degree

    author: weiwei
    date: 20170410
    """

    anglecomponent1 = 0
    try:
        anglecomponent1 = math.asin(80/np.linalg.norm(pos[0:2]))
    except:
        pass
    waistangle = (math.atan2(pos[1], pos[0]) + anglecomponent1)*180/math.pi
    if armid=="lft":
        waistangle = 180.0-2*math.atan2(pos[0], pos[1])*180.0/math.pi-waistangle
    return waistangle 
Example 40
Project: pyhiro   Author: wanweiwei07   File: hrp5nik.py    (license) View Source Project 6 votes vote down vote up
def eubik(pos, armid="rgt"):
    """
    compute the euristic waist rotation
    ew = euristic waist

    :param pos: object position
    :return: waistangle in degree

    author: weiwei
    date: 20170410
    """

    anglecomponent1 = 0
    try:
        anglecomponent1 = math.asin(80/np.linalg.norm(pos[0:2]))
    except:
        pass
    waistangle = (math.atan2(pos[1], pos[0]) + anglecomponent1)*180/math.pi
    if armid=="lft":
        waistangle = 180.0-2*math.atan2(pos[0], pos[1])*180.0/math.pi-waistangle
    return waistangle 
Example 41
Project: taxi   Author: xuguanggen   File: utils.py    (license) View Source Project 6 votes vote down vote up
def compute_hdistance(lon1,lat1,lon2,lat2):
    lon1 = float(lon1)
    lat1 = float(lat1)
    lon2 = float(lon2)
    lat2 = float(lat2)

    radLat1 = rad(lat1)
    radLat2 = rad(lat2)
    a = radLat1 - radLat2
    b = rad(lon1) - rad(lon2)
    s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a/2),2) + 
        Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b/2),2)))
    s = s * 6378.137
    s = round(s * 10000) / 10
    return s


### return odistance ############################ 
Example 42
Project: vrProjector   Author: bhautikj   File: SideBySideFisheyeProjection.py    (license) View Source Project 6 votes vote down vote up
def angular_position(texcoord):
    up = texcoord[0]
    v = texcoord[1]
    # correct for hemisphere
    if up>=0.5:
      u = 2.0*(up-0.5)
    else:
      u = 2.0*up

    # ignore points outside of circles
    if ((u-0.5)*(u-0.5) + (v-0.5)*(v-0.5))>0.25:
      return None, None

    # v: 0..1-> vp: -1..1
    phi = math.asin(2.0*(v-0.5))

    # u = math.cos(phi)*math.cos(theta)
    # u: 0..1 -> upp: -1..1
    u = 1.0-u
    theta = math.acos( 2.0*(u-0.5) / math.cos(phi) )

    if up<0.5:
       theta = theta-math.pi

    return (theta,phi) 
Example 43
Project: ins_nav   Author: MomsFriendlyRobotCompany   File: utils.py    (license) View Source Project 6 votes vote down vote up
def quat2euler(q):
	"""
	Returns the euler representation (in degrees) of a quaternion. Note, the
	heading is wrapped between 0-360 degrees.

	In:
		[q0 q1 q2 q3] = [w x y z]
	out:
		(roll, pitch, yaw) in degrees
	"""
	q0, q1, q2, q3 = q
	roll = atan2(2.0*q2*q3-2.0*q0*q1, 2.0*q0*q0+2.0*q3*q3-1.0)
	pitch = -asin(2.0*q1*q3+2.0*q0*q2)
	heading = atan2(2.0*q1*q2-2.0*q0*q3, 2.0*q0*q0+2.0*q1*q1-1.0)

	heading = heading if heading <= 2*pi else heading-2*pi
	heading = heading if heading >= 0 else heading+2*pi

	return map(rad2deg, (roll, pitch, heading)) 
Example 44
Project: wafer   Author: hariedo   File: vectors.py    (license) View Source Project 6 votes vote down vote up
def rotation(self):
        '''Extracts Euler angles of rotation from this matrix.
        This attempts to find alternate rotations in case of gimbal lock,
        but all of the usual problems with Euler angles apply here.
        All Euler angles are in radians.
        '''
        (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) = self._v
        rotY = D = math.asin(c)
        C = math.cos(rotY)
        if (abs(C) > 0.005):
            trX = k/C ; trY = -g/C ; rotX = math.atan2(trY, trX)
            trX = a/C ; trY = -b/C ; rotZ = math.atan2(trY, trX)
        else:
            rotX = 0
            trX = f ; trY = e ; rotZ = math.atan2(trY, trX)
        return V(rotX,rotY,rotZ) 
Example 45
Project: Deploy_XXNET_Server   Author: jzp820927   File: geo_util.py    (license) View Source Project 6 votes vote down vote up
def __sub__(self, other):
    """Subtraction.

    Args:
      other: the LatLng which this LatLng is subtracted by.

    Returns:
      the great circle distance between two LatLng objects as computed
      by the Haversine formula.
    """

    assert isinstance(other, LatLng)

    lat_rad = math.radians(self._lat)
    lng_rad = math.radians(self._lng)
    other_lat_rad = math.radians(other.latitude)
    other_lng_rad = math.radians(other.longitude)

    dlat = lat_rad - other_lat_rad
    dlng = lng_rad - other_lng_rad
    a1 = math.sin(dlat / 2)**2
    a2 = math.cos(lat_rad) * math.cos(other_lat_rad) * math.sin(dlng / 2)**2
    return 2 * self._EARTH_RADIUS_METERS * math.asin(math.sqrt(a1 + a2)) 
Example 46
Project: joysix   Author: niberger   File: quaternion.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def pitch(self):
		return math.asin(2*(self.w*self.y() - self.z()*self.x())) 
Example 47
Project: PGO-mapscan-opt   Author: seikur0   File: maplib.py    (license) View Source Project 5 votes vote down vote up
def get_distance(location1, location2):
    lat1, lng1 = location1
    lat2, lng2 = location2

    lat1, lng1, lat2, lng2 = map(radians, (lat1, lng1, lat2, lng2))

    d = sin(0.5*(lat2 - lat1)) ** 2 + cos(lat1) * cos(lat2) * sin(0.5*(lng2 - lng1)) ** 2
    return 2 * earth_Rrect * asin(sqrt(d)) 
Example 48
Project: netra   Author: akshah   File: runRIPETraceroute.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def haversine(lon1, lat1, lon2, lat2):
    """
    Calculate the great circle distance between two points
    on the earth (specified in decimal degrees)
    """
    # convert decimal degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
    # haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    km = 6367 * c
    return km 
Example 49
Project: sc8pr   Author: dmaccarthy   File: electric.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def ondraw(self):

        # Calculate electric force
        sk = self.sketch
        dr = delta(self.pos, sk["blue"].pos)
        r = hypot(*dr) / sk.scale / 100
        F = delta(dr, mag = 8.99e-3 * sk.q1 * sk.q2 / (r * r))

        # Add electric plus gravitational forces 
        F = F[0], F[1] + sk.mass * 9.81e-3

        # Tangential acceleration
        s = sk["string"]
        u = s.u
        t = 1 / sk.frameRate
        F = (F[0] * u[1] - F[1] * u[0]) / (sk.mass / 1000) * (sk.scale / 100) / t ** 2
        ax, ay = F * u[1], -F * u[0]

        # Kinematics
        v1x, v1y = tuple(0.95 * v for v in self.vel)
        v2x = v1x + ax * t
        v2y = v1y + ay * t
        self.vel = v2x, v2y
        x, y = self.pos
        x += (v1x + v2x) * t / 2
        y += (v1y + v2y) * t / 2
        x, y = delta((x,y), s.pos, 20 * sk.scale)
        self.pos = s.pos[0] + x, s.pos[1] + y
        s.__init__(s.pos, self.pos)

        # Protractor
        if s.u[1] > 0:
            a = round(2 * degrees(asin(s.u[0]))) / 2
            a = "Angle = {:.1f}° ".format(abs(a))
        else: a = "Angle = ? "
        sk["angle"].config(data=a) 
Example 50
Project: sc8pr   Author: dmaccarthy   File: robot.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def checkFront(self):
        "Update the front color sensor"

        # Get sensor position
        pos = delta(self.pos, vec2d(-self.radius, self.angle))

        # Sensor distance to edge of sketch
        sk = self.sketch
        if sk.weight:
            obj = sk
            prox = _distToWall(pos, self.angle, self.sensorWidth, *sk.size)
        else: obj = prox = None

        # Find closest object within sensor width
        u = vec2d(1, self.angle)
        sw = self.sensorWidth * DEG
        for gr in self.sensorObjects(sk):
            if gr is not self and gr.avgColor and hasattr(gr, "rect"):
                dr = delta(gr.rect.center, pos)
                d = hypot(*dr)
                r = gr.radius
                if r >= d:
                    prox = 0
                    obj = gr
                elif prox is None or d - r < prox:
                    minDot = cos(min(sw + asin(r/d), pi / 2))
                    x = (1 - sprod(u, dr) / d) / (1 - minDot)
                    if x < 1:
                        obj = gr
                        prox = (d - r) * (1 - x) + x * sqrt(d*d-r*r)

        # Save data
        self.closestObject = obj
        c = rgba(sk.border if obj is sk
            else obj.avgColor if obj else (0,0,0))
        self.sensorFront = noise(divAlpha(c), self.sensorNoise, 255)
        self.proximity = None if prox is None else round(prox)