Python math.pi() Examples

The following are code examples for showing how to use math.pi(). 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: PGO-mapscan-opt   Author: seikur0   File: maplib.py    (license) View Source Project 6 votes vote down vote up
def neighbor_circle(location, pos, shift=False, factor=1.0):
    pos = pos % 6
    latrad = location[0] * pi / 180
    x_un = factor * safety / earth_Rrect / cos(latrad) * 180 / pi
    y_un = factor * safety / earth_Rrect * 180 / pi
    if not shift:
        y_un = y_un * (3.0 ** 0.5) / 2.0 * HEX_R
        x_un = x_un * HEX_R * 1.5
        yvals = [-2, -1, 1, 2, 1, -1]
        xvals = [0, 1, 1, 0, -1, -1]
    else:
        y_un = y_un * HEX_R * 1.5
        x_un = x_un * (3.0 ** 0.5) / 2.0 * HEX_R
        yvals = [-1, 0, 1, 1, 0, -1]
        xvals = [1, 2, 1, -1, -2, -1]

    newlat = location[0] + y_un * yvals[pos]
    newlng = ((location[1] + x_un * xvals[pos] + 180) % 360) - 180
    return (newlat, newlng) 
Example 2
Project: RasterFairy   Author: Quasimondo   File: rasterfairy.py    (BSD 3-Clause "New" or "Revised" License) View Source Project 6 votes vote down vote up
def getBestCircularMatch(n):
    bestc = n*2
    bestr = 0
    bestrp = 0.0
    
    minr = int(math.sqrt(n / math.pi))
    for rp in range(0,10):
        rpf = float(rp)/10.0
        for r in range(minr,minr+3):
            rlim = (r+rpf)*(r+rpf)
            c = 0
            for y in range(-r,r+1):
                yy = y*y
                for x in range(-r,r+1):
                    if x*x+yy<rlim:
                        c+=1
            if c == n:
                return r,rpf,c
               
            if c>n and c < bestc:
                bestrp = rpf
                bestr = r
                bestc = c
    return bestr,bestrp,bestc 
Example 3
Project: Deep360Pilot-optical-flow   Author: yenchenlin   File: HoF.py    (license) View Source Project 6 votes vote down vote up
def flow_orientation(orientation):
    """ Currently not use anymore """
    # Boolean map
    _greater_pi = orientation > math.pi/2
    _less_minuspi = orientation < -math.pi/2
    _remaining_part = ~(_greater_pi & _less_minuspi)

    # orientation map
    greater_pi = orientation*_greater_pi
    less_minuspi = orientation*_less_minuspi
    remaining_part = orientation*_remaining_part
    pi_map = math.pi * np.ones(orientation.shape)

    # converted orientation map
    convert_greater_pi = pi_map*_greater_pi - greater_pi
    convert_less_minuspi = -pi_map*_less_minuspi - less_minuspi

    new_orient = remaining_part + convert_greater_pi + convert_less_minuspi

    return new_orient 
Example 4
Project: astrobase   Author: waqasbhatti   File: coordutils.py    (MIT License) View Source Project 6 votes vote down vote up
def angle_wrap(angle,radians=False):
    '''
    Wraps the input angle to 360.0 degrees.

    if radians is True: input is assumed to be in radians, output is also in
    radians

    '''

    if radians:
        wrapped = angle % (2.0*PI)
        if wrapped < 0.0:
            wrapped = 2.0*PI + wrapped

    else:

        wrapped = angle % 360.0
        if wrapped < 0.0:
            wrapped = 360.0 + wrapped

    return wrapped 
Example 5
Project: Projects   Author: it2school   File: radar.py    (license) View Source Project 6 votes vote down vote up
def _compute(self):
        """Compute r min max and labels position"""
        delta = 2 * pi / self._len if self._len else 0
        self._x_pos = [.5 * pi + i * delta for i in range(self._len + 1)]
        for serie in self.all_series:
            serie.points = [
                (v, self._x_pos[i])
                for i, v in enumerate(serie.values)]
            if self.interpolate:
                extended_x_pos = (
                    [.5 * pi - delta] + self._x_pos)
                extended_vals = (serie.values[-1:] +
                                 serie.values)
                serie.interpolated = list(
                    map(tuple,
                        map(reversed,
                            self._interpolate(
                                extended_x_pos, extended_vals))))

        # x labels space
        self._box.margin *= 2
        self._rmin = self.zero
        self._rmax = self._max or 1
        self._box.set_polar_box(self._rmin, self._rmax)
        self._self_close = True 
Example 6
Project: Python4ScientificComputing_Fundamentals   Author: bnajafi   File: PlottingSpectralEmissivities.py    (MIT License) View Source Project 6 votes vote down vote up
def spectralBlackBody(Lambda=0.7, T=5800):
    """ here is the explanation of this function"""
    import math 

    c0 = 2.9979*10**8 #m/s speed of light in vacuum
    h_Plank=6.626069*10**-34 #J.s Plank's Constant
    sigma_stefan_Boltzmann= 5.67*10**-8 #Stefan-Boltzmann Constant
    n=1 #the index of refraction of that medium
    c=c0/n# the speed of propagation of a wave in the medium 
    F=c/Lambda #the frequency of the wave
    e_wave=h_Plank*F
    E_blackBody = sigma_stefan_Boltzmann*T**4
    k_Boltzmann=1.38065*10**-23 #J/K Boltzmann Constant
    
    #Plank's Law: 
    C1=2*math.pi*h_Plank*c0**2*(10**24)#J*s*m^2/s^2--W*m2 --->W 
    C2=h_Plank*c0/k_Boltzmann*(10**6) #microm m/K

    EmissiveSpectral= C1/(Lambda**5*(math.exp(C2/(Lambda*T))-1))
    outPut = {"EmissiveSpectral":EmissiveSpectral,"E_blackBody":E_blackBody}
    return outPut 
Example 7
Project: Gym_LineFollower   Author: Chachay   File: Gym_LineTracer.py    (license) View Source Project 6 votes vote down vote up
def __init__(self):
        # Angle at which to fail the episode
        self.theta_threshold_radians = 12 * 2 * math.pi / 360
        self.x_threshold = 2.4

        # Initializing Course : predfined Oval Course
        # ToDo: ????????????
        Rad = 190.0
        Poly = 16
        self.Course = Walls(240, 50, 640-(50+Rad),50)
        for i in range(1, Poly):
            self.Course.addPoint(Rad*math.cos(-np.pi/2.0 + np.pi*i/Poly)+640-(50+Rad), 
                                Rad*math.sin(-np.pi/2.0 + np.pi*i/Poly)+50+Rad)
        self.Course.addPoint(240, 50+Rad*2)
        for i in range(1, Poly):
            self.Course.addPoint(Rad*math.cos(np.pi/2.0 + np.pi*i/Poly)+(50+Rad), 
                                Rad*math.sin(np.pi/2.0 + np.pi*i/Poly)+50+Rad)
        self.Course.addPoint(240,50)
        
        # Outr Boundary Box
        self.BBox = Walls(640, 479, 0, 479)
        self.BBox.addPoint(0,0)
        self.BBox.addPoint(640,0)
        self.BBox.addPoint(640,479)
        
        # Mono Sensor Line Follower 
        self.A = Agent((640, 480), 240, 49)

        # Action Space : left wheel speed, right wheel speed
        # Observation Space : Detect Line (True, False)
        self.action_space = spaces.Box( np.array([-1.,-1.]), np.array([+1.,+1.])) 
        self.observation_space = spaces.Discrete(1)

        self._seed()
        self.reset()
        self.viewer = None

        self.steps_beyond_done = None

        self._configure() 
Example 8
Project: s2sphere   Author: sidewalklabs   File: sphere.py    (license) View Source Project 6 votes vote down vote up
def get_directed_hausdorff_distance(self, other):
        if other.contains(self):
            return 0.0
        if other.is_empty():
            return math.pi

        other_complement_center = other.get_complement_center()
        if self.contains(other_complement_center):
            return self.__class__.positive_distance(other.hi(),
                                                    other_complement_center)
        else:
            if self.__class__(other.hi(), other_complement_center) \
                    .contains(self.hi()):
                hi_hi = self.__class__.positive_distance(other.hi(), self.hi())
            else:
                hi_hi = 0

            if self.__class__(other_complement_center, other.lo()) \
                    .contains(self.lo()):
                lo_lo = self.__class__.positive_distance(self.lo(), other.lo())
            else:
                lo_lo = 0

            assert hi_hi > 0 or lo_lo > 0
            return max(hi_hi, lo_lo) 
Example 9
Project: s2sphere   Author: sidewalklabs   File: sphere_test.py    (license) View Source Project 6 votes vote down vote up
def testConstructorsAndAccessors(self):
        self.assertEqual(self.quad12.lo(), 0)
        self.assertEqual(self.quad12.hi(), math.pi)
        self.assertEqual(self.quad34.bound(0), math.pi)
        self.assertEqual(self.quad34.bound(1), 0)
        self.assertEqual(self.pi.lo(), math.pi)
        self.assertEqual(self.pi.hi(), math.pi)

        # Check that [-Pi, -Pi] is normalized to [Pi, Pi].
        self.assertEqual(self.mipi.lo(), math.pi)
        self.assertEqual(self.mipi.hi(), math.pi)
        self.assertEqual(self.quad23.lo(), math.pi / 2.0)
        self.assertEqual(self.quad23.hi(), -math.pi / 2.0)

        default_empty = SphereInterval()
        self.assertTrue(default_empty.is_valid())
        self.assertTrue(default_empty.is_empty())
        self.assertEqual(self.empty.lo(), default_empty.lo())
        self.assertEqual(self.empty.hi(), default_empty.hi())
        # Should check intervals can be modified here 
Example 10
Project: s2sphere   Author: sidewalklabs   File: sphere_test.py    (license) View Source Project 6 votes vote down vote up
def testSimplePredicates(self):
        # is_valid(), is_empty(), is_full(), is_inverted()
        self.assertTrue(self.zero.is_valid() and
                        not self.zero.is_empty() and
                        not self.zero.is_full())
        self.assertTrue(self.empty.is_valid() and
                        self.empty.is_empty() and
                        not self.empty.is_full())
        self.assertTrue(self.empty.is_inverted())
        self.assertTrue(self.full.is_valid() and
                        not self.full.is_empty() and
                        self.full.is_full())
        self.assertTrue(not self.quad12.is_empty() and
                        not self.quad12.is_full() and
                        not self.quad12.is_inverted())
        self.assertTrue(not self.quad23.is_empty() and
                        not self.quad23.is_full() and
                        self.quad23.is_inverted())
        self.assertTrue(self.pi.is_valid() and
                        not self.pi.is_empty() and
                        not self.pi.is_inverted())
        self.assertTrue(self.mipi.is_valid() and
                        not self.mipi.is_empty() and
                        not self.mipi.is_inverted()) 
Example 11
Project: s2sphere   Author: sidewalklabs   File: sphere_test.py    (license) View Source Project 6 votes vote down vote up
def testApproxEquals(self):

        self.assertTrue(self.empty.approx_equals(self.empty))
        self.assertTrue(self.zero.approx_equals(self.empty) and
                        self.empty.approx_equals(self.zero))
        self.assertTrue(self.pi.approx_equals(self.empty) and
                        self.empty.approx_equals(self.pi))
        self.assertTrue(self.mipi.approx_equals(self.empty) and
                        self.empty.approx_equals(self.mipi))
        self.assertTrue(self.pi.approx_equals(self.mipi) and
                        self.mipi.approx_equals(self.pi))
        self.assertTrue(self.pi.union(self.mipi).approx_equals(self.pi))
        self.assertTrue(self.mipi.union(self.pi).approx_equals(self.pi))
        self.assertTrue(self.pi.union(
            self.mid12).union(self.zero).approx_equals(self.quad12))
        self.assertTrue(self.quad2.intersection(
            self.quad3).approx_equals(self.pi))
        self.assertTrue(self.quad3.intersection(
            self.quad2).approx_equals(self.pi)) 
Example 12
Project: s2sphere   Author: sidewalklabs   File: sphere_test.py    (license) View Source Project 6 votes vote down vote up
def testGetVertex(self):
        r1 = LatLngRect(LineInterval(0, math.pi / 2.0),
                        SphereInterval(-math.pi, 0))
        self.assertEqual(r1.get_vertex(0), LatLng.from_radians(0, math.pi))
        self.assertEqual(r1.get_vertex(1), LatLng.from_radians(0, 0))
        self.assertEqual(r1.get_vertex(2),
                         LatLng.from_radians(math.pi / 2.0, 0))
        self.assertEqual(r1.get_vertex(3),
                         LatLng.from_radians(math.pi / 2.0, math.pi))

        # Make sure the get_vertex() returns vertices in CCW order.
        for i in range(4):
            lat = math.pi / 4.0 * (i - 2)
            lng = math.pi / 2.0 * (i - 2) + 0.2
            r = LatLngRect(LineInterval(lat, lat + math.pi / 4.0),
                           SphereInterval(s2sphere.drem(lng, 2 * math.pi),
                           s2sphere.drem(lng + math.pi / 2.0, 2 * math.pi)))
            for k in range(4):
                self.assertTrue(
                    s2sphere.simple_ccw(r.get_vertex((k - 1) & 3).to_point(),
                                        r.get_vertex(k).to_point(),
                                        r.get_vertex((k + 1) & 3).to_point())
                ) 
Example 13
Project: ssbio   Author: SBRG   File: cpv.py    (MIT License) View Source Project 6 votes vote down vote up
def get_angle_formed_by(p1,p2,p3): # angle formed by three positions in space

    # based on code submitted by Paul Sherwood
    r1 = distance(p1,p2)
    r2 = distance(p2,p3)
    r3 = distance(p1,p3)
    
    small = 1.0e-10
    
    if (r1 + r2 - r3) < small:
        # This seems to happen occasionally for 180 angles 
        theta = math.pi
    else:
        theta = math.acos( (r1*r1 + r2*r2  - r3*r3) / (2.0 * r1*r2) )
    return theta;

#------------------------------------------------------------------------------ 
Example 14
Project: mav_rtk_gps   Author: ethz-asl   File: bearing_from_mag.py    (BSD 3-Clause "New" or "Revised" License) View Source Project 6 votes vote down vote up
def mitsuta_mean(self, angles_array):
        # Function meant to work with degrees, covert inputs
        # from radians to degrees and output from degrees to radians
        D = math.degrees(angles_array[0])
        mysum = D
        for val in angles_array[1:]:
            val = math.degrees(val)
            delta = val - D
            if delta < -180.0:
                D = D + delta + 360.0
            elif delta < 180.0:
                D = D + delta
            else:
                D = D + delta - 360.0
            mysum = mysum + D
        m = mysum / len(angles_array)

        avg = math.radians((m + 360.0) % 360.0)
        # make sure avg is between -pi and pi
        if avg > math.pi:
            avg = avg - 2.0 * math.pi
        elif avg < -math.pi:
            avg = avg + 2.0 * math.pi

        return avg 
Example 15
Project: TrackToTrip   Author: ruipgil   File: point.py    (MIT License) View Source Project 6 votes vote down vote up
def distance(latitude_1, longitude_1, elevation_1, latitude_2, longitude_2, elevation_2,
             haversine=None):
    """ Distance between two points """

    # If points too distant -- compute haversine distance:
    if haversine or (abs(latitude_1 - latitude_2) > .2 or abs(longitude_1 - longitude_2) > .2):
        return haversine_distance(latitude_1, longitude_1, latitude_2, longitude_2)

    coef = math.cos(latitude_1 / 180. * math.pi)
    #pylint: disable=invalid-name
    x = latitude_1 - latitude_2
    y = (longitude_1 - longitude_2) * coef

    distance_2d = math.sqrt(x * x + y * y) * ONE_DEGREE

    if elevation_1 is None or elevation_2 is None or elevation_1 == elevation_2:
        return distance_2d

    return math.sqrt(distance_2d ** 2 + (elevation_1 - elevation_2) ** 2) 
Example 16
Project: pypilot   Author: pypilot   File: calibration_fit.py    (license) View Source Project 6 votes vote down vote up
def ComputeCoverage(sigma_points, bias):
    def ang(p):
        v = rotvecquat(vector.sub(p.compass, bias), vec2vec2quat(p.down, [0, 0, 1]))
        return math.atan2(v[1], v[0])

    angles = sorted(map(ang, sigma_points))
    #print 'angles', angles
                    
    max_diff = 0
    for i in range(len(angles)):
        diff = -angles[i]
        j = i+1
        if j == len(angles):
            diff += 2*math.pi
            j = 0
        diff += angles[j]
        max_diff = max(max_diff, diff)
    return max_diff 
Example 17
Project: pypilot   Author: pypilot   File: autopilot_calibration.py    (license) View Source Project 6 votes vote down vote up
def onMouseEventsBoatPlot( self, event ):
        self.BoatPlot.SetFocus()

        pos = event.GetPosition()
        if event.LeftDown():
            self.lastmouse = pos

        if event.Dragging():
            dx, dy = pos[0] - self.lastmouse[0], pos[1] - self.lastmouse[1]
            q = pypilot.quaternion.angvec2quat((dx**2 + dy**2)**.4/180*math.pi, [dy, dx, 0])
            
            self.boat_plot.Q = pypilot.quaternion.multiply(q, self.boat_plot.Q)
            self.BoatPlot.Refresh()
            self.lastmouse = pos

        rotation = event.GetWheelRotation() / 60
        if rotation:
            self.BoatPlot.Refresh()
        while rotation > 0:
            self.boat_plot.Scale /= .9
            rotation -= 1
        while rotation < 0:
            self.boat_plot.Scale *= .9
            rotation += 1 
Example 18
Project: Maps   Author: DarkPurple141   File: voronoi.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def __init__(self,seed):
        random.seed(seed)
        self.ISLAND_FACTOR = 1.13 # 1.0 means no small islands; 2.0 leads to a lot
        self.bumps = random.randrange(1,7)
        self.startAngle = random.uniform(0,2*math.pi)
        self.dipAngle = random.uniform(0,2*math.pi)
        self.dipWidth = random.uniform(0.2,0.7) 
Example 19
Project: joysix   Author: niberger   File: joystick.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def __init__(self):
		self.ser = serial.Serial('/dev/ttyACM0', 9600)

		#geometrical calibration
		self.rs = [50, 50, 50]
		self.ls = [95, 130, 95]
		self.pot_rad_per_unit = 1./3000.*math.pi
		angles = [2./3.*math.pi, 0., -2./3.*math.pi]

		#placements of the 3 joysticks
		self.placements = []
		#attach point on the ball
		self.attach_ps = []
		for r,l,a in zip(self.rs, self.ls, angles):
			p_init = pose.exp(col([0, 0, 0, 0, 0, -(r+l)]))
			p_rot = pose.exp(col([0, a, 0, 0, 0, 0]))
			placement = p_rot * p_init
			self.placements.append(placement)
			attach_p = placement * col([0, 0, l])
			self.attach_ps.append(attach_p)

		#last calculated pose in logarithmic coordinates
		self.last_x = col([0, 0, 0, 0, 0, 0])
		#definition of the numerical solver
		f = lambda x: self.getValuesFromPose(pose.exp(x))
		self.solver = solver.Solver(f) 
Example 20
Project: drl.pth   Author: seba-1511   File: policies.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, model, action_size=1, init_value=0.0, *args, **kwargs):
        super(DiagonalGaussianPolicy, self).__init__(model, *args, **kwargs)
        self.init_value = init_value
        self.logstd = th.zeros((1, action_size)) + self.init_value
        self.logstd = P(self.logstd)
        self.halflog2pie = V(T([2 * pi * exp(1)])) * 0.5
        self.halflog2pi = V(T([2.0 * pi])) * 0.5
        self.pi = V(T([pi])) 
Example 21
Project: drl.pth   Author: seba-1511   File: policies.py    (license) View Source Project 5 votes vote down vote up
def _normal(self, x, mean, logstd):
        std = logstd.exp()
        std_sq = std.pow(2)
        a = (-(x - mean).pow(2) / (2 * std_sq)).exp()
        b = (2 * std_sq * self.pi.expand_as(std_sq)).sqrt()
        return a / b 
Example 22
Project: BlenderRokuro   Author: satoyuichi   File: blender_rokuro.py    (MIT License) View Source Project 5 votes vote down vote up
def rokuro_add_euler(euler, r):
    props = bpy.context.window_manager.rokuro

    if props.rotate_direction:
        if (euler + r) < 0:
            new_euler = euler + r + (2.0 * math.pi)
        else:
            new_euler = euler + r
    else:
        if (euler + r) > (2.0 * math.pi):
            new_euler = euler + r - (2.0 * math.pi)
        else:
            new_euler = euler + r
        
    return new_euler 
Example 23
Project: BlenderRokuro   Author: satoyuichi   File: blender_rokuro.py    (MIT License) View Source Project 5 votes vote down vote up
def rokuro_proc(scene):
    props = bpy.context.window_manager.rokuro

    r = props.rotate_step * 2.0 * math.pi / (scene.frame_end - scene.frame_start)
    if props.rotate_direction:
        r *= -1.0
    
    if props.rotate_axis_x:
        bpy.context.object.rotation_euler[0] = rokuro_add_euler(bpy.context.object.rotation_euler[0], r)

    if props.rotate_axis_y:
        bpy.context.object.rotation_euler[1] = rokuro_add_euler(bpy.context.object.rotation_euler[1], r)

    if props.rotate_axis_z:
        bpy.context.object.rotation_euler[2] = rokuro_add_euler(bpy.context.object.rotation_euler[2], r) 
Example 24
Project: coa_tools   Author: ndee85   File: edit_armature.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def drag_bone(self,context, event ,bone=None):
        ### math.atan2(0.5, 0.5)*180/math.pi
        if bone != None:
            
            bone.hide = False
            mouse_vec_norm = (self.cursor_location - self.mouse_click_vec).normalized()
            mouse_vec = (self.cursor_location - self.mouse_click_vec)
            angle = (math.atan2(mouse_vec_norm[0], mouse_vec_norm[2])*180/math.pi)
            cursor_local = self.armature.matrix_world.inverted() * self.cursor_location
            cursor_local[1] = 0
            if event.shift:
                if angle > -22.5 and angle < 22.5:
                    ### up
                    bone.tail =  Vector((bone.head[0],cursor_local[1],cursor_local[2]))
                elif angle > 22.5 and angle < 67.5:
                    ### up right
                    bone.tail = (bone.head +  Vector((mouse_vec[0],0,mouse_vec[0])))
                elif angle > 67.5 and angle < 112.5:
                    ### right
                    bone.tail = Vector((cursor_local[0],cursor_local[1],bone.head[2]))
                elif angle > 112.5 and angle < 157.5:
                    ### down right
                    bone.tail = (bone.head +  Vector((mouse_vec[0],0,-mouse_vec[0])))
                elif angle > 157.5 or angle < -157.5:   
                    ### down
                    bone.tail = Vector((bone.head[0],cursor_local[1],cursor_local[2]))
                elif angle > -157.5 and angle < -112.5:
                    ### down left
                        bone.tail = (bone.head +  Vector((mouse_vec[0],0,mouse_vec[0])))
                elif angle > -112.5 and angle < -67.5:
                    ### left
                    bone.tail = Vector((cursor_local[0],cursor_local[1],bone.head[2]))
                elif angle > -67.5 and angle < -22.5:       
                    ### left up
                    bone.tail = (bone.head +  Vector((mouse_vec[0],0,-mouse_vec[0])))
            else:
                bone.tail = cursor_local 
Example 25
Project: coa_tools   Author: ndee85   File: export_dragonbones.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def get_bone_angle(armature,bone,relative=True):
    loc, rot, scale = get_bone_matrix(armature,bone,relative).decompose()
    compat_euler = Euler((0.0,0.0,math.pi),"XYZ")
    angle = -rot.to_euler().z  # negate angle to fit dragonbones angle
        
    return round(math.degrees(angle),2) 
Example 26
Project: tree-gen   Author: friggog   File: leaf.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def get_mesh(self, bend, base_shape, index):
        """produce leaf mesh at position of this leaf given base mesh as input"""
        # calculate angles to transform mesh to align with desired direction
        trf = self.direction.to_track_quat('Z', 'Y')
        right_t = self.right.rotated(trf.inverted())
        spin_ang = pi - right_t.angle(Vector([1, 0, 0]))

        # calculate bend transform if needed
        if bend > 0:
            bend_trf_1, bend_trf_2 = self.calc_bend_trf(bend)
        else:
            bend_trf_1 = bend_trf_2 = None

        vertices = []
        for vertex in base_shape[0]:
            # rotate to correct direction
            vertex = vertex.copy()
            vertex.rotate(Quaternion(Vector([0, 0, 1]), spin_ang))
            vertex.rotate(trf)
            # apply bend if needed
            if bend > 0:
                vertex.rotate(bend_trf_1)
                vertex.rotate(bend_trf_2)
            # move to right position
            vertex += self.position
            # add to vertex array
            vertices.append(vertex)
        # set face to refer to vertices at correct offset in big vertex list
        index *= len(vertices)
        faces = deepcopy(base_shape[1])
        for face in faces:
            for ind, elem in enumerate(face):
                face[ind] = elem + index
        return vertices, faces 
Example 27
Project: tree-gen   Author: friggog   File: leaf.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def calc_bend_trf(self, bend):
        """calculate the transformations required to 'bend' the leaf out/up from WP"""
        normal = self.direction.cross(self.right)
        theta_pos = atan2(self.position.y, self.position.x)
        theta_bend = theta_pos - atan2(normal.y, normal.x)
        bend_trf_1 = Quaternion(Vector([0, 0, 1]), theta_bend * bend)
        self.direction.rotate(bend_trf_1)
        self.right.rotate(bend_trf_1)
        normal = self.direction.cross(self.right)
        phi_bend = normal.declination()
        if phi_bend > pi / 2:
            phi_bend = phi_bend - pi
        bend_trf_2 = Quaternion(self.right, phi_bend * bend)
        return bend_trf_1, bend_trf_2 
Example 28
Project: tree-gen   Author: friggog   File: gen.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def calc_helix_points(turtle, rad, pitch):
    """ calculates required points to produce helix bezier curve with given radius and pitch in direction of turtle"""
    # alpha = radians(90)
    # pit = pitch/(2*pi)
    # a_x = rad*cos(alpha)
    # a_y = rad*sin(alpha)
    # a = pit*alpha*(rad - a_x)*(3*rad - a_x)/(a_y*(4*rad - a_x)*tan(alpha))
    # b_0 = Vector([a_x, -a_y, -alpha*pit])
    # b_1 = Vector([(4*rad - a_x)/3, -(rad - a_x)*(3*rad - a_x)/(3*a_y), -a])
    # b_2 = Vector([(4*rad - a_x)/3, (rad - a_x)*(3*rad - a_x)/(3*a_y), a])
    # b_3 = Vector([a_x, a_y, alpha*pit])
    # axis = Vector([0, 0, 1])

    # simplifies greatly for case inc_angle = 90
    points = [Vector([0, -rad, -pitch / 4]),
              Vector([(4 * rad) / 3, -rad, 0]),
              Vector([(4 * rad) / 3, rad, 0]),
              Vector([0, rad, pitch / 4])]

    # align helix points to turtle direction and randomize rotation around axis
    trf = turtle.dir.to_track_quat('Z', 'Y')
    spin_ang = rand_in_range(0, 2 * pi)
    for p in points:
        p.rotate(Quaternion(Vector([0, 0, 1]), spin_ang))
        p.rotate(trf)

    return points[1] - points[0], points[2] - points[0], points[3] - points[0], turtle.dir.copy() 
Example 29
Project: tree-gen   Author: friggog   File: gen.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def points_for_floor_split(self):
        """Calculate Poissonly distributed points for stem start points"""
        array = []
        # calculate approx spacing radius for dummy stem
        self.tree_scale = self.param.g_scale + self.param.g_scale_v
        stem = Stem(0, None)
        stem.length = self.calc_stem_length(stem)
        rad = 2.5 * self.calc_stem_radius(stem)
        # generate points
        for _ in range(self.param.floor_splits + 1):
            point_ok = False
            while not point_ok:
                # distance from center proportional for number of splits, tree scale and stem radius
                dis = sqrt(rand_in_range(0, 1) * self.param.floor_splits / 2.5 * self.param.g_scale * self.param.ratio)
                # angle random in circle
                theta = rand_in_range(0, 2 * pi)
                pos = Vector([dis * cos(theta), dis * sin(theta), 0])
                # test point against those already in array to ensure it will not intersect
                point_m_ok = True
                for point in array:
                    if (point[0] - pos).magnitude < rad:
                        point_m_ok = False
                        break
                if point_m_ok:
                    point_ok = True
                    array.append((pos, theta))
        return array 
Example 30
Project: tree-gen   Author: friggog   File: gen.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def shape_ratio(self, shape, ratio):
        """Calculate shape ratio as defined in paper"""
        if shape == 1:  # spherical
            result = 0.2 + 0.8 * sin(pi * ratio)
        elif shape == 2:  # hemispherical
            result = 0.2 + 0.8 * sin(0.5 * pi * ratio)
        elif shape == 3:  # cylindrical
            result = 1.0
        elif shape == 4:  # tapered cylindrical
            result = 0.5 + 0.5 * ratio
        elif shape == 5:  # flame
            if ratio <= 0.7:
                result = ratio / 0.7
            else:
                result = (1.0 - ratio) / 0.3
        elif shape == 6:  # inverse conical
            result = 1.0 - 0.8 * ratio
        elif shape == 7:  # tend flame
            if ratio <= 0.7:
                result = 0.5 + 0.5 * ratio / 0.7
            else:
                result = 0.5 + 0.5 * (1.0 - ratio) / 0.3
        elif shape == 8:  # envelope
            if ratio < 0 or ratio > 1:
                result = 0.0
            elif ratio < 1 - self.param.prune_width_peak:
                result = pow(ratio / (1 - self.param.prune_width_peak),
                             self.param.prune_power_high)
            else:
                result = pow((1 - ratio) / (1 - self.param.prune_width_peak),
                             self.param.prune_power_low)
        else:  # conical (0)
            result = 0.2 + 0.8 * ratio
        return result 
Example 31
Project: PGO-mapscan-opt   Author: seikur0   File: maplib.py    (license) View Source Project 5 votes vote down vote up
def get_border_cell(s2_id):
    locs = []
    s2_cell = Cell(s2_id)
    for i in [0, 1]:
        for j in [0, 1]:
            locs.append([s2_cell.get_latitude(i, j) * 180 / pi, s2_cell.get_longitude(i, j) * 180 / pi])
    output = [locs[0], locs[1], locs[3], locs[2], locs[0]]
    return output 
Example 32
Project: PGO-mapscan-opt   Author: seikur0   File: maplib.py    (license) View Source Project 5 votes vote down vote up
def init_lats(self):
        latrad = 0.0
        lats = []

        c = 0.5 * self.r_sight * self.safety
        while latrad < pi / 2:
            lats.append(latrad)
            latrad += c / self.earth_R
        return lats 
Example 33
Project: PGO-mapscan-opt   Author: seikur0   File: maplib.py    (license) View Source Project 5 votes vote down vote up
def init_grid(self):
        grid_all = []
        lats = self.init_lats()
        c = 2 * pi / (3 ** 0.5 * self.r_sight * self.safety) * self.earth_R

        even_lng = True

        strip_amount = int(ceil(c))
        grid_all.append((0, strip_amount, even_lng))
        ind_lat = 2

        while ind_lat < len(lats):
            amount = int(ceil(c * cos(lats[ind_lat])))
            if amount < strip_amount - (sin(lats[ind_lat]*2)*self.param_shift+self.param_stretch):
                ind_lat -= 1
                strip_amount = int(ceil(c * cos(lats[ind_lat])))
            else:
                even_lng = not even_lng

            if ind_lat + 1 < len(lats):
                lat = lats[ind_lat + 1] * 180 / pi
                grid_all.append((lat, strip_amount, even_lng))
            ind_lat += 3

        grid_all.append((90.0, 1, True))  # pole

        return grid_all 
Example 34
Project: PGO-mapscan-opt   Author: seikur0   File: maplib.py    (license) View Source Project 5 votes vote down vote up
def cover_circle(self,loc,radius):
        lat,lng = loc
        output = []
        r_lat = radius / earth_Rrect*180/pi
        r_lng = r_lat /cos(min(abs(lat)+r_lat,90.0)*pi/180)
        locations = self.cover_region((lat-r_lat,lng-r_lng),(lat+r_lat,lng+r_lng))
        for location in locations:
            dist = get_distance(loc,location)
            if dist < radius:
                output.append(location)
        return output 
Example 35
Project: RasterFairy   Author: Quasimondo   File: coonswarp.py    (BSD 3-Clause "New" or "Revised" License) View Source Project 5 votes vote down vote up
def getCircularBounds(fitCloud=None,width=64,height=64,smoothing=0.01):
    circumference = 2*(width+height)
    
    if not fitCloud is None:
        cx = np.mean(fitCloud[:,0])
        cy = np.mean(fitCloud[:,1])
        r = 0.5* max( np.max(fitCloud[:,0])- np.min(fitCloud[:,0]),np.max(fitCloud[:,1])- np.min(fitCloud[:,1]))
    else:
        r = circumference /(2.0*math.pi)
        cx = cy = r
    perimeterPoints = np.zeros((circumference,2),dtype=float)
    for i in range(circumference):
        angle = (2.0*math.pi)*float(i) / circumference - math.pi * 0.5 
        perimeterPoints[i][0] = cx + r * math.cos(angle)
        perimeterPoints[i][1] = cy + r * math.sin(angle)
        
        
    bounds = {'top':perimeterPoints[0:width],
              'right':perimeterPoints[width-1:width+height-1],
              'bottom':perimeterPoints[width+height-2:2*width+height-2],
              'left':perimeterPoints[2*width+height-3:]}
    
    bounds['s_top'],u = interpolate.splprep([bounds['top'][:,0], bounds['top'][:,1]],s=smoothing)
    bounds['s_right'],u = interpolate.splprep([bounds['right'][:,0],bounds['right'][:,1]],s=smoothing)
    bounds['s_bottom'],u = interpolate.splprep([bounds['bottom'][:,0],bounds['bottom'][:,1]],s=smoothing)
    bounds['s_left'],u = interpolate.splprep([bounds['left'][:,0],bounds['left'][:,1]],s=smoothing)
   
    
    return bounds 
Example 36
Project: tailbiter   Author: darius   File: test_basic.py    (MIT License) View Source Project 5 votes vote down vote up
def test_import(self):
        self.assert_ok("""\
            import math
            print(math.pi, math.e)
            from math import sqrt
            print(sqrt(2))
            """) 
Example 37
Project: core-framework   Author: RedhawkSDR   File: test_14_bluefile.py    (license) View Source Project 5 votes vote down vote up
def test_FileSourceTimecodeType2000Complex(self):
        # Create a test file with frequency on the X-axis and time on the
        # Y-axis (as one might see from an FFT)
        subsize = 200
        xdelta = 2.0*math.pi/subsize
        ydelta = 0.125
        hdr = bluefile.header(2000, 'CF', subsize=subsize)
        hdr['xstart'] = -math.pi/2.0
        hdr['xdelta'] = xdelta
        hdr['xunits'] = 3 # frequency
        hdr['ydelta'] = ydelta
        hdr['yunits'] = 1 # time
        data = numpy.arange(1000, dtype=numpy.complex64).reshape((-1,subsize))

        self._check_FileSourceTimecode(hdr, data, subsize*2, ydelta) 
Example 38
Project: zellij   Author: nedbat   File: drawing.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def rotate(self, degrees):
        # Cairo uses radians, let's be more convenient.
        self.ctx.rotate(degrees * math.pi / 180) 
Example 39
Project: zellij   Author: nedbat   File: drawing.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def circle(self, xc, yc, radius):
        self.arc(xc, yc, radius, 0, math.pi * 2) 
Example 40
Project: Fluent-Python   Author: Ehco1996   File: 10-7.py    (license) View Source Project 5 votes vote down vote up
def angle(self, n):
        # ?? n???? ???????????
        r = math.sqrt(sum(x * x for x in self[n:]))
        a = math.atan2(r, self[n - 1])
        if (n == len(self)) and (self[-1] < 0):
            return math.pi * 2 - a
        else:
            return a 
Example 41
Project: blender-scripting   Author: njanakiev   File: fisher_iris_visualization.py    (MIT License) View Source Project 5 votes vote down vote up
def createLabels(X, y, labels, cameraObj=None):
    labelIndices = set(y)
    objects = []

    # Draw labels
    for labelIdx in labelIndices:
        center = np.sum([x for x, idx in zip(X, y) \
            if idx == labelIdx], axis=0)
        counts = (y == labelIdx).sum()
        center = Vector(center) / counts

        label = labels[labelIdx]
        fontCurve = bpy.data.curves.new(type="FONT", name=label)
        fontCurve.body = label
        fontCurve.align_x = 'CENTER'
        fontCurve.align_y = 'BOTTOM'
        fontCurve.size = 0.6

        obj = bpy.data.objects.new("Label {}".format(label), fontCurve)
        obj.location = center + Vector((0, 0, 0.8))
        obj.rotation_mode = 'AXIS_ANGLE'
        obj.rotation_axis_angle = (pi/2, 1, 0, 0)
        bpy.context.scene.objects.link(obj)

        if cameraObj is not None:
            constraint = obj.constraints.new('LOCKED_TRACK')
            constraint.target = cameraObj
            constraint.track_axis = 'TRACK_Z'
            constraint.lock_axis = 'LOCK_Y'

        objects.append(obj)

    bpy.context.scene.update()

    return objects 
Example 42
Project: blender-scripting   Author: njanakiev   File: phyllotaxis_flower.py    (MIT License) View Source Project 5 votes vote down vote up
def __init__(self, scene):
        self.n, self.m = 40, 30
        self.r0, self.r1, self.r2 = 10, 2, 2
        self.h0, self.h1 = 10, 3
        self.frames = scene.frame_end - scene.frame_start + 1

        # Calculate and compensate for angle offset for infinite animation
        self.offset = (self.frames * goldenAngle) % TAU
        if self.offset > pi: self.offset -= TAU

        # Create object
        mesh = bpy.data.meshes.new('PhyllotaxisFlower')
        self.obj = bpy.data.objects.new('PhyllotaxisFlower', mesh)

        # Create mesh
        bm = self.geometry()
        bm.to_mesh(mesh)
        mesh.update()
        bm.free()

        # Link object to scene
        scene.objects.link(self.obj)
        scene.update()

        # Append new frame change handler to redraw geometry
        # for each frame change
        bpy.app.handlers.frame_change_pre.append(self.__frameChangeHandler) 
Example 43
Project: blender-scripting   Author: njanakiev   File: phyllotaxis_flower.py    (MIT License) View Source Project 5 votes vote down vote up
def geometry(self, frame=0):
        t = frame / self.frames
        Rot = Matrix.Rotation(0.5*pi, 4, 'Y')
        bm = bmesh.new()

        for i in range(self.n):
            t0 = i / self.n
            r0, theta = t0*self.r0, i*goldenAngle - frame*goldenAngle + t*self.offset

            x = r0*cos(theta)
            y = r0*sin(theta)
            z = self.h0/2 - (self.h0 / (self.r0*self.r0))*r0*r0
            p0 = Vector((x, y, z))

            T0, N0, B0 = getTNBfromVector(p0)
            M0 = Matrix([T0, B0, N0]).to_4x4().transposed()

            for j in range(self.m):
                t1 = j / self.m
                t2 = 0.4 + 0.6*t0
                r1, theta = t2*t1*self.r1, j*goldenAngle #- frame*goldenAngle + t*self.offset

                x = r1*cos(theta)
                y = r1*sin(theta)
                z = self.h1 - (self.h1 / (self.r1*self.r1))*r1*r1
                p1 = Vector((x, y, z))
                T1, N1, B1 = getTNBfromVector(p1)
                M1 = Matrix([T1, B1, N1]).to_4x4().transposed()

                p = p0 + M0*p1
                r2 = t2*t1*self.r2

                T = Matrix.Translation(p)
                bmesh.ops.create_cone(bm,
                                cap_ends=True, segments=6,
                                diameter1=r2, diameter2=r2,
                                depth=0.1*r2, matrix=T*M0*M1*Rot)
        return bm 
Example 44
Project: hip-mdp-public   Author: dtak   File: BayesianNeuralNetwork.py    (MIT License) View Source Project 5 votes vote down vote up
def __log_likelihood_factor__(self, samples_q, v_noise, X, wb, y):
		# Account for occasions where we're optimizing the latent weighting distributions
		if wb.shape[0] == 1:
			if wb.shape[1] > self.num_latent_params: # Further account
				# Reshape the wb to be a full matrix and build full latent array
				Wb = np.reshape(wb, [-1,self.num_latent_params])
				latent_weights = np.array([Wb[int(X[tt,-1]),:] for tt in range(X.shape[0])])
				outputs = self.__predict__(samples_q, np.hstack([X[:,:-1], latent_weights]))
			else:
				outputs = self.__predict__(samples_q, np.hstack([X, np.tile(wb,(X.shape[0],1))]))
		else:
			outputs = self.__predict__(samples_q, np.hstack([X, wb]))
		return (-0.5*np.log(2*math.pi*v_noise)) - (0.5*(np.tile(np.expand_dims(y,axis=0), (self.num_weight_samples,1,1))-outputs)**2)/v_noise 
Example 45
Project: hip-mdp-public   Author: dtak   File: BayesianNeuralNetwork.py    (MIT License) View Source Project 5 votes vote down vote up
def __log_normalizer__(self, q): 
		return np.sum(0.5*np.log(q['v']*2*math.pi) + 0.5*q['m']**2/q['v']) 
Example 46
Project: hip-mdp-public   Author: dtak   File: BayesianNeuralNetwork.py    (MIT License) View Source Project 5 votes vote down vote up
def __log_Z_prior__(self):
		return self.num_weights * 0.5 * np.log(self.v_prior*2*math.pi) 
Example 47
Project: hip-mdp-public   Author: dtak   File: BayesianNeuralNetwork.py    (MIT License) View Source Project 5 votes vote down vote up
def get_error_and_ll(self, X, y, location, scale):
		v_noise = np.exp(self.parser.get(self.weights, 'log_v_noise')[0,0]) * scale**2
		q = self.__get_parameters_q__()
		samples_q = self.__draw_samples__(q)
		outputs = self.__predict__(samples_q, X)
		log_factor = -0.5*np.log(2*math.pi*v_noise) - 0.5*(np.tile(np.expand_dims(y,axis=0), (self.num_weight_samples,1,1))-np.array(outputs))**2/v_noise
		ll = np.mean(logsumexp(np.sum(log_factor,2)-np.log(self.num_weight_samples), 0))
		error = np.sqrt(np.mean((y-np.mean(outputs, axis=0))**2))
		return error, ll 
Example 48
Project: Deep360Pilot-optical-flow   Author: yenchenlin   File: HoF.py    (license) View Source Project 5 votes vote down vote up
def show_result(hists, bin_edges):
    """ check results """
    for b_edge in bin_edges/math.pi*180:
        print '{0:.2f}\t'.format(round(b_edge)),
    print
    for hist in hists:
        print '{0:.2f}\t'.format(hist),
    print 
Example 49
Project: Deep360Pilot-optical-flow   Author: yenchenlin   File: HoF.py    (license) View Source Project 5 votes vote down vote up
def gradient_histogram(flow_img, binsize=12):
    """ calculate histogram """
    assert len(flow_img.shape) == 3, "Wrong flow image."

    # NOTE the frame is in RGB, while cv2 is in BGR, so do REMEMBER to reverse it.
    img_mag, img_v, img_u = np.split(flow_img, 3, 2)

    # NOTE the role reversal: the "y-coordinate" is the first function parameter, the "x-coordinate" is the second.
    # NOTE that we use same axis configure as image axis(x is larger to the right, y is larger to the bottom),
    # so add a minus sign before img_v, to make the two axis align.
    orientation = np.arctan2(-img_v, img_u)

    # Original result not applicable
    # Directly use full 360 degree
    new_orient = orientation

    # Prune zero motion
    _mag_greater_zero = img_mag > 0.0
    pruned_orient = new_orient[_mag_greater_zero]

    # Histogram of optical flow
    hofbins = np.arange(-math.pi, math.pi+1e-6, 2*math.pi/binsize)
    hist, bin_edges = np.histogram(pruned_orient.flatten(), bins= hofbins) #, density=True)

    # Normalize
    hist = hist.astype(np.float32) / (np.sum(_mag_greater_zero) + 1e-6)

    return hist, bin_edges 
Example 50
Project: aws-greengrass-mini-fulfillment   Author: awslabs   File: stages.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def cart2polar(x, y, degrees=True):
    """
    Convert cartesian X and Y to polar RHO and THETA.
    :param x: x cartesian coordinate
    :param y: y cartesian coordinate
    :param degrees: True = return theta in degrees, False = return theta in
        radians. [default: True]
    :return: r, theta
    """
    rho = ma.sqrt(x ** 2 + y ** 2)
    theta = ma.arctan2(y, x)
    if degrees:
        theta *= (180 / math.pi)

    return rho, theta