コード例 #1
0
def get_alpha(radius, dec):
    if abs(dec) + radius > 89.9:
        return 180
    return math.degrees(
        abs(
            math.atan(
                math.sin(math.radians(radius)) / np.sqrt(
                    abs(
                        math.cos(math.radians(dec - radius)) *
                        math.cos(math.radians(dec + radius)))))))
コード例 #2
0
def calc_volume_trilinic(a, b, c, alpha, beta, gamma):

    alpha = math.pi * alpha / 180.0
    beta = math.pi * beta / 180.0
    gamma = math.pi * gamma / 180.0
    ca = math.cos(alpha)
    cb = math.cos(beta)
    cg = math.cos(gamma)
    vol = a * b * c * math.sqrt(1.0 + 2 * ca * cb * cg - ca**2 - cb**2 - cg**2)
    return vol
コード例 #3
0
 def _get_alpha(self):
     if abs(self.dec) + self.radius > 89.9:
         return 180
     return math.degrees(
         abs(
             math.atan(
                 math.sin(math.radians(self.radius)) / np.sqrt(
                     abs(
                         math.cos(math.radians(self.dec - self.radius)) *
                         math.cos(math.radians(self.dec + self.radius)))))))
コード例 #4
0
ファイル: map.py プロジェクト: dlavell/tower
    def distance_on_unit_sphere(self, coord1, coord2, lat_lon=None):
        # todo: need to make this work with ellipsoid earth models for more accurate distance calculations
        # todo:
        """

        Calculate the distance on a spherical earth model with radius hard-coded.


        :param coord1: start coordinates
        :param coord2: end coordinates
        :param lat_lon: Optional: give either 'lat' or 'lon' to get just the lateral or longitudinal distances by
        themselves
        :return: return the distance in km

        """
        if lat_lon is not None:
            if lat_lon is 'lat':
                lat1, lon1 = coord1.lat, coord1.lon
                lat2, lon2 = coord1.lat, coord2.lon
            elif lat_lon is 'lon':
                lat1, lon1 = coord1.lat, coord1.lon
                lat2, lon2 = coord2.lat, coord1.lon
            else:
                raise Exception("lat or lon not specified")
        else:
            lat1, lon1 = coord1.lat, coord1.lon
            lat2, lon2 = coord2.lat, coord2.lon

        # Convert latitude and longitude to
        # spherical coordinates in radians
        degrees_to_radians = math.pi / 180.0

        # phi = 90 - latitude
        phi1 = (90.0 - lat1) * degrees_to_radians
        phi2 = (90.0 - lat2) * degrees_to_radians

        # theta = longitude
        theta1 = lon1 * degrees_to_radians
        theta2 = lon2 * degrees_to_radians

        # Compute spherical distance from spherical coordinates.

        # For two locations in spherical coordinates
        # (1, theta, phi) and (1, theta', phi')
        # cosine( arc length ) =
        #    sin phi sin phi' cos(theta-theta') + cos phi cos phi'
        # distance = rho * arc length

        cos = (math.sin(phi1) * math.sin(phi2) * math.cos(theta1 - theta2) +
               math.cos(phi1) * math.cos(phi2))
        """ @todo: need to implement domain check"""
        arc = math.acos(cos)

        return arc * self.semimajor  # scale to return in km
コード例 #5
0
def affine_registration(source,
                        target,
                        pyramidDepth,
                        minLevel=0,
                        downscale=2,
                        debug=False):
    '''
    Find affine transformation that registers source image to the target image.

    This function computes the image pyramid for source and target and calculates the transformation
    that minimizes the least-square error between images (starting at the lowest resolution).

    Args:
        source (np.ndarray): source image, the one that will be transformed.
        target (np.ndarray): target image, the one that will not move.
        pyramidDepth (int): number of pyramid levels, in addition to the original.
        minLevel (int): 0 for original level, >0 for coarser resolution.
    
    Return:
        tfrm (np.ndarray): (3,3) best transformation
    '''
    sourcePyramid = tuple(
        skimage.transform.pyramid_gaussian(source,
                                           max_layer=pyramidDepth,
                                           downscale=downscale))
    targetPyramid = tuple(
        skimage.transform.pyramid_gaussian(target,
                                           max_layer=pyramidDepth,
                                           downscale=downscale))
    # -- compute small scale rigid body transformation to provide the initial guess for the affine transformation --
    rtfrm = imreg.rigid_body_registration(sourcePyramid[minLevel],
                                          targetPyramid[minLevel],
                                          pyramidDepth - minLevel)
    rotmatrix = np.array([[math.cos(rtfrm[0]), -math.sin(rtfrm[0])],
                          [math.sin(rtfrm[0]),
                           math.cos(rtfrm[0])]])
    tfrm = np.append(rotmatrix, [[rtfrm[1]], [rtfrm[2]]], 1)
    tfrm[:, -1] /= pow(downscale, pyramidDepth - minLevel)
    tfrm = np.vstack((tfrm, [0, 0, 1]))
    #tfrm = np.array([[1,0,0],[0,1,0],[0,0,1]])
    for layer in range(pyramidDepth, minLevel - 1, -1):
        tfrm[:2,
             -1] *= downscale  # Scale translation for next level in pyramid
        tfrm = affine_least_squares(sourcePyramid[layer], targetPyramid[layer],
                                    tfrm, 10 * 2**(layer - 1))
        toptfrm = np.concatenate(
            (tfrm[:2, 0:2], tfrm[:2, -1:] * pow(downscale, layer)), axis=1)
        toptfrm = np.vstack((toptfrm, np.array([0, 0, 1])))
        if debug:
            pass  #some debugging stuff Santiago was using
            #print 'Layer {0}: {1}x{2}'.format(layer, *targetPyramid[layer].shape)
            #print 'th={0:0.4}, x={1:0.1f} , y={2:0.1f}'.format(*toptfrm) ### DEBUG
    return toptfrm
コード例 #6
0
 def _plotLayout(self):
     # Plot the cell with the nucleus, and the limits of the simulation
     xc = list(); yc = list()
     xe = list(); ye = list()
     for ii in range(0, 365):
         rangle = to_radian(ii)
         xc.append(self.nucleus.x + self.r * math.cos(rangle))
         yc.append(self.nucleus.y + self.r * math.sin(rangle))
         xe.append(self.nucleus.x + self.R * math.cos(rangle))
         ye.append(self.nucleus.y + self.R * math.sin(rangle))
     plot(xc, yc, "-k")
     plot(xe, ye, "--k")
コード例 #7
0
 def _plotLayout(self):
     # Plot the cell with the nucleus, and the limits of the simulation
     xc = list()
     yc = list()
     xe = list()
     ye = list()
     for ii in range(0, 365):
         rangle = to_radian(ii)
         xc.append(self.nucleus.x + self.r * math.cos(rangle))
         yc.append(self.nucleus.y + self.r * math.sin(rangle))
         xe.append(self.nucleus.x + self.R * math.cos(rangle))
         ye.append(self.nucleus.y + self.R * math.sin(rangle))
     plot(xc, yc, "-k")
     plot(xe, ye, "--k")
コード例 #8
0
def calcTvalue(p, df):
    t = None
    if (df == 1):
        t = math.cos(p*math.pi/2.)/math.sin(p*math.pi/2.)
    elif (df == 2):
        t = math.sqrt(2./(p*(2. - p)) - 2.)
    else:
        a = 1./(df - 0.5)
        b = 48./(a*a)
        c = ((20700.*a/b - 98.)*a - 16.)*a + 96.36
        d = ((94.5/(b + c) - 3.)/b + 1.)*math.sqrt(a*math.pi*0.5)*df
        x = d*p
        y = pow(x, 2./df)
        if (y > 0.05 + a):
            x = Norm_z(0.5*(1. - p))
            y = x*x
            if (df < 5.): 
                c = c + 0.3*(df - 4.5)*(x + 0.6)
            c = (((0.05*d*x - 5.)*x - 7.)*x - 2.)*x + b + c
            y = (((((0.4*y + 6.3)*y + 36.)*y + 94.5)/c - y - 3.)/b + 1.)*x
            y = a*y*y
            if (y > 0.002): 
                y = math.exp(y) - 1.
            else:
                y = 0.5*y*y + y
            t = sqrt(df*y)
        else:
            y = ((1./(((df + 6.)/(df*y) - 0.089*d - 0.822)*(df + 2.)*3.) + 0.5/(df + 4.))*y - 1.)*(df + 1.)/(df + 2.) + 1./y;
            t = math.sqrt(df*y)
    return t
コード例 #9
0
def combo(A, strX, strY, ang, shiftX, shiftY):
    c, s = math.cos(ang), math.sin(ang)
    strec = np.array([[strX, 0.], [0., strY]])
    rotat = np.array([[c, -s], [s, c]])
    shift = np.array([[shiftX], [shiftY]])
    newA = rotat.dot(strec).dot(A)+shift
    return newA
コード例 #10
0
ファイル: map.py プロジェクト: BrandonLuu/raster-mapping
    def distance_on_unit_sphere(coord1, coord2, units='km'):
        # todo: need to make this work with ellipsoid earth models for more accurate distance calculations
        # todo:
        """

        Calculate the distance on a spherical earth model with radius hard-coded.

        :param coord1: start coordinates
        :param coord2: end coordinates
        :param units: choose whether to return in km or feet
        :return: return the distance in km

        """

        lat1, lon1 = coord1.lat, coord1.lon
        lat2, lon2 = coord2.lat, coord2.lon

        # Convert latitude and longitude to
        # spherical coordinates in radians
        degrees_to_radians = math.pi / 180.0

        # phi = 90 - latitude
        phi1 = (90.0 - lat1) * degrees_to_radians
        phi2 = (90.0 - lat2) * degrees_to_radians

        # theta = longitude
        theta1 = lon1 * degrees_to_radians
        theta2 = lon2 * degrees_to_radians

        # Compute spherical distance from spherical coordinates.

        # For two locations in spherical coordinates
        # (1, theta, phi) and (1, theta', phi')
        # cosine( arc length ) =
        #    sin phi sin phi' cos(theta-theta') + cos phi cos phi'
        # distance = rho * arc length

        cos = (math.sin(phi1) * math.sin(phi2) * math.cos(theta1 - theta2) +
               math.cos(phi1) * math.cos(phi2))
        """ @todo: need to implement domain check"""
        arc = math.acos(cos)

        if units is 'km':
            return arc * 6373
        else:
            return arc * 3960
コード例 #11
0
def reset_heading(sensor, freq, delay, Mat11, Mat21, Mat31, Mat12, Mat22,
                  Mat32, Mat13, Mat23, Mat33):
    if sensor == 'Xsens':
        rotmat = [[Mat11[0], Mat12[0],
                   Mat13[0]], [Mat21[0], Mat22[0], Mat23[0]],
                  [Mat31[0], Mat32[0], Mat33[0]]]
    if sensor == 'Vicon':
        rotmat = [
            [Mat11[delay * freq], Mat12[delay * freq], Mat13[delay * freq]],
            [Mat21[delay * freq], Mat22[delay * freq], Mat23[delay * freq]],
            [Mat31[delay * freq], Mat32[delay * freq], Mat33[delay * freq]]
        ]

    # decomposition
    yaw = math.atan2(-rotmat[0][1], rotmat[0][0])
    print('   yaw correction = {} [rad]'.format(-yaw))

    Ryaw_reset = [[math.cos(-yaw), -math.sin(-yaw), 0],
                  [math.sin(-yaw), math.cos(-yaw), 0], [0, 0, 1]]

    length = len(Mat11)
    Mat11new, Mat21new, Mat31new, Mat12new, Mat22new, Mat32new, Mat13new, Mat23new, Mat33new = [
        0
    ] * length, [0] * length, [0] * length, [0] * length, [0] * length, [
        0
    ] * length, [0] * length, [0] * length, [0] * length

    count = 0
    for x in Mat11:
        rotmat = [[Mat11[count], Mat12[count], Mat13[count]],
                  [Mat21[count], Mat22[count], Mat23[count]],
                  [Mat31[count], Mat32[count], Mat33[count]]]
        rotmat_new = np.dot(Ryaw_reset, rotmat)
        Mat11new[count] = rotmat_new[0][0]
        Mat12new[count] = rotmat_new[0][1]
        Mat13new[count] = rotmat_new[0][2]
        Mat21new[count] = rotmat_new[1][0]
        Mat22new[count] = rotmat_new[1][1]
        Mat23new[count] = rotmat_new[1][2]
        Mat31new[count] = rotmat_new[2][0]
        Mat32new[count] = rotmat_new[2][1]
        Mat33new[count] = rotmat_new[2][2]
        count += 1

    return (Mat11new, Mat21new, Mat31new, Mat12new, Mat22new, Mat32new,
            Mat13new, Mat23new, Mat33new)
コード例 #12
0
ファイル: utils.py プロジェクト: BenoitBouillard/route-tiles
def distance(n1, n2):
    """Calculate distance in km between two nodes"""
    lat1, lon1 = n1[0], n1[1]
    lat2, lon2 = n2[0], n2[1]
    delta_lat = lat2 - lat1
    delta_lon = lon2 - lon1
    d = math.sin(math.radians(delta_lat) * 0.5) ** 2 + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) \
        * math.sin(math.radians(delta_lon) * 0.5) ** 2
    return math.asin(math.sqrt(d)) * 12742
コード例 #13
0
ファイル: map.py プロジェクト: BrandonLuu/raster-mapping
    def lat_lon_distance_on_unit_sphere(coord1, coord2, lat_lon, units='km'):
        """

        Compute either the lateral or longitudinal distance from on point to another;
        This corresponds to finding the length of one of the legs of the right triangle between
        the two points.

        :param coord1: start coordinates
        :param coord2: end coordinates
        :param units: choose whether to return in km or miles
        :return: distance in units specified by 'units' param

        """

        if lat_lon is 'lat':
            lat1, lon1 = coord1.lat, coord1.lon
            lat2, lon2 = coord1.lat, coord2.lon
        elif lat_lon is 'lon':
            lat1, lon1 = coord1.lat, coord1.lon
            lat2, lon2 = coord2.lat, coord1.lon
        else:
            raise Exception("lat or lon not specified")

        # Convert latitude and longitude to
        # spherical coordinates in radians
        degrees_to_radians = math.pi / 180.0

        # phi = 90 - latitude
        phi1 = (90.0 - lat1) * degrees_to_radians
        phi2 = (90.0 - lat2) * degrees_to_radians

        # theta = longitude
        theta1 = lon1 * degrees_to_radians
        theta2 = lon2 * degrees_to_radians
        cos = (math.sin(phi1) * math.sin(phi2) * math.cos(theta1 - theta2) +
               math.cos(phi1) * math.cos(phi2))
        arc = math.acos(cos)

        # Remember to multiply arc by the radius of the earth
        # in your favorite set of units to get length.
        if units is 'km':
            return arc * 6373
        else:
            return arc * 3960
コード例 #14
0
    def draw_line(self, pos):
        if self.viewer._ocr and self.x_clicked or self.y_clicked:
            img_line = cv.line(self.image.copy(),
                               (self.x_clicked, self.y_clicked),
                               (pos.x(), pos.y()), (0, 0, 0), 2)
            image_height, image_width, image_depth = img_line.shape
            QIm = cv.cvtColor(img_line, cv.COLOR_BGR2RGB)
            QIm = QImage(QIm.data, image_width, image_height,
                         image_width * image_depth, QImage.Format_RGB888)
            self.viewer.setPhoto(QPixmap.fromImage(QIm))
        # 终止画线
        if self.x_released or self.y_released:
            self.choosePoints = []  # 初始化存储点组
            inf = float("inf")
            if self.x_released or self.y_released:
                if (self.x_released - self.x_clicked) == 0:
                    slope = inf
                else:
                    slope = (self.y_released - self.y_clicked) / (
                        self.x_released - self.x_clicked)

                siteLenth = 0.5 * math.sqrt(
                    square(self.y_released - self.y_clicked) +
                    square(self.x_released - self.x_clicked))

                mySiteLenth = 2 * siteLenth
                self.siteLenth = ("%.2f" % mySiteLenth)
                self.editSiteLenth.setText(self.siteLenth)
                radian = math.atan(slope)
                self.siteSlope = ("%.2f" % radian)
                self.editSiteSlope.setText(self.siteSlope)
                x_bas = math.ceil(math.fabs(0.5 * siteLenth *
                                            math.sin(radian)))
                y_bas = math.ceil(math.fabs(0.5 * siteLenth *
                                            math.cos(radian)))

                if slope <= 0:
                    self.choosePoints.append([(self.x_clicked - x_bas),
                                              (self.y_clicked - y_bas)])
                    self.choosePoints.append([(self.x_clicked + x_bas),
                                              (self.y_clicked + y_bas)])
                    self.choosePoints.append([(self.x_released + x_bas),
                                              (self.y_released + y_bas)])
                    self.choosePoints.append([(self.x_released - x_bas),
                                              (self.y_released - y_bas)])
                elif slope > 0:
                    self.choosePoints.append([(self.x_clicked + x_bas),
                                              (self.y_clicked - y_bas)])
                    self.choosePoints.append([(self.x_clicked - x_bas),
                                              (self.y_clicked + y_bas)])
                    self.choosePoints.append([(self.x_released - x_bas),
                                              (self.y_released + y_bas)])
                    self.choosePoints.append([(self.x_released + x_bas),
                                              (self.y_released - y_bas)])
            self.viewer._ocr = False
コード例 #15
0
def BL2XYZ(lat, lon):
    R = 6371000.0
    #6371km
    eps = 1.0E-10
    xyz = zeros(3)
    if math.fabs(lat - 90) < eps:
        xyz[0] = 0
        xyz[1] = 0
        xyz[2] = R
    elif math.fabs(lat + 90) < eps:
        xyz[0] = 0
        xyz[1] = 0
        xyz[2] = -R
    else:
        xyz[0] = math.cos(lat * math.pi / 180.0) * math.cos(
            lon * math.pi / 180.0) * R
        xyz[1] = math.cos(lat * math.pi / 180.0) * math.sin(
            lon * math.pi / 180.0) * R
        xyz[2] = math.sin(lat * math.pi / 180.0) * R
    return xyz
コード例 #16
0
def imgR(img, ang):
    m, n = img.shape[:2]
    c, s = math.cos(ang), math.sin(ang)

    q = int(max(m, n)*1.5)
    newImg = np.ones((q, q, 3))
    for i in xrange(m):
        for j in xrange(n):
            k = int(round((i-m/2)*c+(j-n/2)*-s+q/2))
            l = int(round((i-m/2)*s+(j-n/2)*c+q/2))
            newImg[k, l,:] = img[i, j,:]
    plt.imshow(newImg)
    plt.show()
コード例 #17
0
ファイル: basis.py プロジェクト: m4webb/numerical_computing
def imgR(img, ang):
    m, n = img.shape[:2]
    c, s = math.cos(ang), math.sin(ang)

    q = int(max(m, n) * 1.5)
    newImg = np.ones((q, q, 3))
    for i in xrange(m):
        for j in xrange(n):
            k = int(round((i - m / 2) * c + (j - n / 2) * -s + q / 2))
            l = int(round((i - m / 2) * s + (j - n / 2) * c + q / 2))
            newImg[k, l, :] = img[i, j, :]
    plt.imshow(newImg)
    plt.show()
コード例 #18
0
ファイル: basis.py プロジェクト: m4webb/numerical_computing
def rotate(A, ang):
    c, s = math.cos(ang), math.sin(ang)

    rotat = np.array([[c, -s], [s, c]])
    newA = np.dot(rotat, A)

    plt.subplot(2, 1, 1)
    plt.plot(A[0], A[1], '.')
    plt.xlim(-5, 5)
    plt.ylim(-5, 5)
    plt.subplot(2, 1, 2)
    plt.plot(newA[0], newA[1], '.')
    plt.xlim(-5, 5)
    plt.ylim(-5, 5)
    plt.show()
コード例 #19
0
def rotate(A, ang):
    c, s = math.cos(ang), math.sin(ang)

    rotat = np.array([[c, -s], [s, c]])
    newA = np.dot(rotat, A)
    
    plt.subplot(2, 1, 1)
    plt.plot(A[0], A[1], '.')
    plt.xlim(-5, 5)
    plt.ylim(-5, 5)
    plt.subplot(2, 1, 2)
    plt.plot(newA[0], newA[1], '.')
    plt.xlim(-5, 5)
    plt.ylim(-5, 5)
    plt.show()
コード例 #20
0
def combo(A, strX, strY, ang, shiftX, shiftY):
    c, s = math.cos(ang), math.sin(ang)

    strec = np.array([[strX, 0.], [0., strY]])
    rotat = np.array([[c, -s], [s, c]])
    shift = np.array([[shiftX], [shiftY]])
    newA = rotat.dot(strec).dot(A)+shift

    plt.subplot(2, 1, 1)
    plt.plot(A[0], A[1], '.')
    plt.xlim(-8, 8)
    plt.ylim(-8, 8)
    plt.subplot(2, 1, 2)
    plt.plot(newA[0], newA[1], '.')
    plt.xlim(-8, 8)
    plt.ylim(-8, 8)
    plt.show()
コード例 #21
0
 def _sampleMotionModel(self, noiseFaktor=30, noiseReposition=0.05):
     for i in range(self._numberOfParticles):
         v = max(self._robot._currentV, 0.01)
         omega = self._robot._currentOmega
         
         sigma_v_2 = (self._robot._k_d * noiseFaktor / self._robot._T) * abs(v)
         v_noisy = v + random.normal(0.05, math.sqrt(sigma_v_2))
 
         # Add noise to omega:
         sigma_omega_tr_2 = (self._robot._k_theta / self._robot._T) * abs(omega + 0.0001)  # turning rate noise
         sigma_omega_drift_2 = (self._robot._k_drift / self._robot._T) * abs(v)  # drift noise
         omega_noisy = omega + random.normal(0.0, math.sqrt(sigma_omega_tr_2))
         omega_noisy += random.normal(0.0, math.sqrt(sigma_omega_drift_2))
         
         omega = omega_noisy
         v = v_noisy
 
         # translational and rotational speed is limited:
         if omega > self._robot._maxOmega:
             omega = self._robot._maxOmega
         if omega < -self._robot._maxOmega:
             omega = -self._robot._maxOmega
         if v > self._robot._maxSpeed:
             v = self._robot._maxSpeed
         if v < -self._robot._maxSpeed:
             v = -self._robot._maxSpeed
 
         d = v * self._robot._T
         dTheta = omega * self._robot._T
         
         x = self._particles[i][self.X]
         y = self._particles[i][self.Y]
         theta = self._particles[i][self.THETA]
 
         x = (x + d * math.cos(theta + 0.5 * dTheta))
         y = (y + d * math.sin(theta + 0.5 * dTheta))
         theta = (theta + dTheta) % (2 * math.pi)
         
         if self.drawWayOfParticle:
             self.drawWayOfParticle(i, x, y)
     
         self._particles[i][self.X] = x + random.normal(0.0, noiseReposition)
         self._particles[i][self.Y] = y + random.normal(0.0, noiseReposition)
         self._particles[i][self.THETA] = theta
         self._particles[i][self.WEIGHT] = 0
         self._particles[i][self.SUM] = 0
コード例 #22
0
ファイル: basis.py プロジェクト: m4webb/numerical_computing
def combo(A, strX, strY, ang, shiftX, shiftY):
    c, s = math.cos(ang), math.sin(ang)

    strec = np.array([[strX, 0.], [0., strY]])
    rotat = np.array([[c, -s], [s, c]])
    shift = np.array([[shiftX], [shiftY]])
    newA = rotat.dot(strec).dot(A) + shift

    plt.subplot(2, 1, 1)
    plt.plot(A[0], A[1], '.')
    plt.xlim(-8, 8)
    plt.ylim(-8, 8)
    plt.subplot(2, 1, 2)
    plt.plot(newA[0], newA[1], '.')
    plt.xlim(-8, 8)
    plt.ylim(-8, 8)
    plt.show()
コード例 #23
0
ファイル: Robot.py プロジェクト: bestehle/RobotSimulator
    def move(self, motion):
        v = motion[0]
        omega = motion[1]
        self._currentV = v
        self._currentOmega = omega

        # translational and rotational speed is limited:
        if omega > self._maxOmega:
            omega = self._maxOmega
        if omega < -self._maxOmega:
            omega = -self._maxOmega
        if v > self._maxSpeed:
            v = self._maxSpeed
        if v < -self._maxSpeed:
            v = -self._maxSpeed

        # print ("motion ", v, omega * 180 / math.pi)

        # Odometry pose update (based on the motion command):
        d = v * self._T
        dTheta = omega * self._T
        self._odoX += d * math.cos(self._odoTheta + 0.5 * dTheta)
        self._odoY += d * math.sin(self._odoTheta + 0.5 * dTheta)
        self._odoTheta = (self._odoTheta + dTheta) % (2 * math.pi)
        
        # Add noise to v:
        if not self._motionNoise:
            return self._world.moveRobot(d, dTheta, self._T)    
        
        sigma_v_2 = (self._k_d / self._T) * abs(v)
        v_noisy = v + random.gauss(0.0, math.sqrt(sigma_v_2))

        # Add noise to omega:
        sigma_omega_tr_2 = (self._k_theta / self._T) * abs(omega)  # turning rate noise
        sigma_omega_drift_2 = (self._k_drift / self._T) * abs(v)  # drift noise
        omega_noisy = omega + random.gauss(0.0, math.sqrt(sigma_omega_tr_2))
        omega_noisy += random.gauss(0.0, math.sqrt(sigma_omega_drift_2))

        # Move robot in the world (with noise):
        d_noisy = v_noisy * self._T
        dTheta_noisy = omega_noisy * self._T
        
        # call the move listeners
        self._moveListener.emit()
        
        return self._world.moveRobot(d_noisy, dTheta_noisy, self._T)
コード例 #24
0
def rotate(pitch, roll, yaw):
    p = np.array([[ 1,                 0,                0],
                  [ 0,   math.cos(pitch), -math.sin(pitch)],
                  [ 0,   math.sin(pitch),  math.cos(pitch)]])

    r = np.array([[ math.cos(roll),    0,  math.sin(roll)],
                  [ 0,                 1,  0             ],
                  [-math.sin(roll),    0,  math.cos(roll)]])

    y = np.array([[ math.cos(yaw), -math.sin(yaw), 0],
                  [ math.sin(yaw),  math.cos(yaw), 0],
                  [ 0,                          0, 1]])
    ro = np.dot(p, np.dot(r, y))
    return ro
コード例 #25
0
def FindBusinessBasedOnLocation(categoriesToSearch, myLocation, maxDistance, saveLocation2, collection):
    temp = []
    for i in categoriesToSearch:
	     temp.append(i.title());
    abc = collection.find({"categories": {"$all": temp}})
    latit = float (myLocation[0])
    longi = float (myLocation[1])
    source_lat = radians(latit)
    source_long = radians(longi)
    R=3959
    file=open(saveLocation2,"w")
    for i in abc:
        dest_lat = radians(i['latitude'])
        dest_long = radians(i['longitude'])
	dist_lat = (dest_lat - source_lat)
        dist_long = (dest_long - source_long)
        a = math.sin(dist_lat / 2) * math.sin(dist_lat / 2)  + math.cos(source_lat) * math.cos(dest_lat) * math.sin(dist_long / 2) * math.sin(dist_long / 2)
        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
        distance = R * c
        if (distance <= maxDistance):
            file.write(i['name'].encode("utf-8").upper() + "\n")
    file.close()
コード例 #26
0
def cylindricalWarpImage(img1, K, savefig=False):
    f = K[0,0]

    im_h,im_w = img1.shape

    # go inverse from cylindrical coord to the image
    # (this way there are no gaps)
    cyl = np.zeros_like(img1)
    cyl_mask = np.zeros_like(img1)
    cyl_h,cyl_w = cyl.shape
    x_c = float(cyl_w) / 2.0
    y_c = float(cyl_h) / 2.0
    for x_cyl in np.arange(0,cyl_w):
        for y_cyl in np.arange(0,cyl_h):
            theta = (x_cyl - x_c) / f
            h     = (y_cyl - y_c) / f

            X = np.array([math.sin(theta), h, math.cos(theta)])
            X = np.dot(K,X)
            x_im = X[0] / X[2]
            if x_im < 0 or x_im >= im_w:
                continue

            y_im = X[1] / X[2]
            if y_im < 0 or y_im >= im_h:
                continue

            cyl[int(y_cyl),int(x_cyl)] = img1[int(y_im),int(x_im)]
            cyl_mask[int(y_cyl),int(x_cyl)] = 255


    if savefig:
        plt.imshow(cyl, cmap='gray')
        plt.savefig("cyl.png",bbox_inches='tight')

    return (cyl,cyl_mask)
コード例 #27
0
def getLineData(pixels, x1, y1, x2, y2, lineW=2, theZ=0, theC=0, theT=0):
    """
    Grabs pixel data covering the specified line, and rotates it horizontally
    so that x1,y1 is to the left,
    Returning a numpy 2d array. Used by Kymograph.py script.
    Uses PIL to handle rotating and interpolating the data. Converts to numpy
    to PIL and back (may change dtype.)

    @param pixels:          PixelsWrapper object
    @param x1, y1, x2, y2:  Coordinates of line
    @param lineW:           Width of the line we want
    @param theZ:            Z index within pixels
    @param theC:            Channel index
    @param theT:            Time index
    """

    from numpy import asarray

    sizeX = pixels.getSizeX()
    sizeY = pixels.getSizeY()

    lineX = x2-x1
    lineY = 1 if y2-y1 == 0 else y2-y1

    rads = math.atan(float(lineX) / lineY)

    # How much extra Height do we need, top and bottom?
    extraH = abs(math.sin(rads) * lineW)
    bottom = int(max(y1, y2) + extraH/2)
    top = int(min(y1, y2) - extraH/2)

    # How much extra width do we need, left and right?
    extraW = abs(math.cos(rads) * lineW)
    left = int(min(x1, x2) - extraW)
    right = int(max(x1, x2) + extraW)

    # What's the larger area we need? - Are we outside the image?
    pad_left, pad_right, pad_top, pad_bottom = 0, 0, 0, 0
    if left < 0:
        pad_left = abs(left)
        left = 0
    x = left
    if top < 0:
        pad_top = abs(top)
        top = 0
    y = top
    if right > sizeX:
        pad_right = right - sizeX
        right = sizeX
    w = int(right - left)
    if bottom > sizeY:
        pad_bottom = bottom - sizeY
        bottom = sizeY
    h = int(bottom - top)
    tile = (x, y, w, h)

    # get the Tile
    plane = pixels.getTile(theZ, theC, theT, tile)

    # pad if we wanted a bigger region
    if pad_left > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((data_h, pad_left), dtype=plane.dtype)
        plane = hstack((pad_data, plane))
    if pad_right > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((data_h, pad_right), dtype=plane.dtype)
        plane = hstack((plane, pad_data))
    if pad_top > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((pad_top, data_w), dtype=plane.dtype)
        plane = vstack((pad_data, plane))
    if pad_bottom > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((pad_bottom, data_w), dtype=plane.dtype)
        plane = vstack((plane, pad_data))

    pil = numpyToImage(plane)
    # pil.show()

    # Now need to rotate so that x1,y1 is horizontally to the left of x2,y2
    toRotate = 90 - math.degrees(rads)

    if x1 > x2:
        toRotate += 180
    # filter=Image.BICUBIC see
    # http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2172449/
    rotated = pil.rotate(toRotate, expand=True)
    # rotated.show()

    # finally we need to crop to the length of the line
    length = int(math.sqrt(math.pow(lineX, 2) + math.pow(lineY, 2)))
    rotW, rotH = rotated.size
    cropX = (rotW - length)/2
    cropX2 = cropX + length
    cropY = (rotH - lineW)/2
    cropY2 = cropY + lineW
    cropped = rotated.crop((cropX, cropY, cropX2, cropY2))
    # cropped.show()
    return asarray(cropped)
コード例 #28
0
@author: Benjamín Castro Pohl
"""
from numpy import math
from matplotlib import pyplot
import numpy as np

n = 4  #Cantidad de triángulos que parten circunferencia de radio 1

listarea = [
]  #Lista de las áreas desde la partición n hasta una partición de 2 triángulos
listaerror = []  #Lista de errores entre área n y área n-1
listaerror1 = []  #Lista de errores entre área n y área n-1
a = []
while n > 2:
    theta = math.pi * 2 / n  #Ángulo según partición
    area = n * (math.sin(theta / 2) * math.cos(theta / 2)
                )  #Suma de las áreas de todos los triángulos
    listarea.append(area)
    n -= 1

la32 = np.asarray(
    listarea,
    dtype=np.float32)  #La lista de áreas se convierte en un arreglo float32
la64 = np.asarray(
    listarea,
    dtype=np.float64)  #La lista de áreas se convierte en un arreglo float64

for i in range(len(la32) - 1):
    listaerror.append(
        -la32[i + 1] +
        la32[i])  #Se agrega la diferencia de áreas consecutivas a una lista
コード例 #29
0
ファイル: msbr.py プロジェクト: supaidauen/Mod3-MHW-Importer
def calculateMSBR(hull_points_2d):
    #print "Input convex hull points: "
    #print hull_points_2d

    # Compute edges (x2-x1,y2-y1)
    edges = zeros( (len(hull_points_2d)-1,2) ) # empty 2 column array
    for i in range( len(edges) ):
        edge_x = hull_points_2d[i+1][0] - hull_points_2d[i][0]
        edge_y = hull_points_2d[i+1][1] - hull_points_2d[i][1]
        edges[i] = [edge_x,edge_y]

    # Calculate edge angles   atan2(y/x)
    edge_angles = zeros( (len(edges)) ) # empty 1 column array
    for i in range( len(edge_angles) ):
        edge_angles[i] = math.atan2( edges[i][1], edges[i][0] )

    # Check for angles in 1st quadrant
    for i in range( len(edge_angles) ):
        edge_angles[i] = abs( edge_angles[i] % (math.pi/2) ) # want strictly positive answers

    # Remove duplicate angles
    edge_angles = unique(edge_angles)

    # Test each angle to find bounding box with smallest area
    min_bbox = (0, float("inf"), 0, 0, 0, 0, 0, 0) # rot_angle, area, width, height, min_x, max_x, min_y, max_y
    for i in range( len(edge_angles) ):

        # Create rotation matrix to shift points to baseline
        # R = [ cos(theta)      , cos(theta-PI/2)
        #       cos(theta+PI/2) , cos(theta)     ]
        R = array([ [ math.cos(edge_angles[i]), math.cos(edge_angles[i]-(math.pi/2)) ], [ math.cos(edge_angles[i]+(math.pi/2)), math.cos(edge_angles[i]) ] ])

        # Apply this rotation to convex hull points
        rot_points = dot(R, transpose(hull_points_2d) ) # 2x2 * 2xn

        # Find min/max x,y points
        min_x = nanmin(rot_points[0], axis=0)
        max_x = nanmax(rot_points[0], axis=0)
        min_y = nanmin(rot_points[1], axis=0)
        max_y = nanmax(rot_points[1], axis=0)

        # Calculate height/width/area of this bounding rectangle
        width = max_x - min_x
        height = max_y - min_y
        area = width*height

        # Store the smallest rect found first (a simple convex hull might have 2 answers with same area)
        if (area < min_bbox[1]):
            min_bbox = ( edge_angles[i], area, width, height, min_x, max_x, min_y, max_y )
        # Bypass, return the last found rect
        #min_bbox = ( edge_angles[i], area, width, height, min_x, max_x, min_y, max_y )

    # Re-create rotation matrix for smallest rect
    angle = min_bbox[0]   
    R = array([ [ math.cos(angle), math.cos(angle-(math.pi/2)) ], [ math.cos(angle+(math.pi/2)), math.cos(angle) ] ])

    # Project convex hull points onto rotated frame
    #proj_points = dot(R, transpose(hull_points_2d) ) # 2x2 * 2xn

    # min/max x,y points are against baseline
    min_x = min_bbox[4]
    max_x = min_bbox[5]
    min_y = min_bbox[6]
    max_y = min_bbox[7]

    # Calculate center point and project onto rotated frame
    center_x = (min_x + max_x)/2
    center_y = (min_y + max_y)/2
    center_point = dot( [ center_x, center_y ], R )

    # Calculate corner points and project onto rotated frame
    corner_points = zeros( (4,2) ) # empty 2 column array
    corner_points[0] = dot( [ max_x, min_y ], R )
    corner_points[1] = dot( [ min_x, min_y ], R )
    corner_points[2] = dot( [ min_x, max_y ], R )
    corner_points[3] = dot( [ max_x, max_y ], R )

    return (angle, min_bbox[1], min_bbox[2], min_bbox[3], center_point, corner_points) 
コード例 #30
0
ファイル: map.py プロジェクト: BrandonLuu/raster-mapping
    def vinc_inv(f, a, coordinate_a, coordinate_b):
        """

        Returns the distance between two geographic points on the ellipsoid
        and the forward and reverse azimuths between these points.
        lats, longs and azimuths are in radians, distance in metres

        :param f: flattening of the geodesic
        :param a: the semimajor axis of the geodesic
        :param coordinate_a: decimal coordinate given as named tuple coordinate
        :param coordinate_b: decimal coordinate given as named tuple coordinate
        Note: The problem calculates forward and reverse azimuths as: coordinate_a -> coordinate_b

        """
        phi1 = math.radians(coordinate_a.lat)
        lembda1 = math.radians(coordinate_a.lon)

        phi2 = math.radians(coordinate_b.lat)
        lembda2 = math.radians(coordinate_b.lon)

        if (abs(phi2 - phi1) < 1e-8) and (abs(lembda2 - lembda1) < 1e-8):
            return {'distance': 0.0, 'forward_azimuth': 0.0, 'reverse_azimuth': 0.0}

        two_pi = 2.0 * math.pi

        b = a * (1 - f)

        TanU1 = (1 - f) * math.tan(phi1)
        TanU2 = (1 - f) * math.tan(phi2)

        U1 = math.atan(TanU1)
        U2 = math.atan(TanU2)

        lembda = lembda2 - lembda1
        last_lembda = -4000000.0  # an impossibe value
        omega = lembda

        # Iterate the following equations,
        #  until there is no significant change in lembda

        while (last_lembda < -3000000.0 or lembda != 0 and abs((last_lembda - lembda) / lembda) > 1.0e-9):
            sqr_sin_sigma = pow(math.cos(U2) * math.sin(lembda), 2) + \
                            pow((math.cos(U1) * math.sin(U2) -
                                 math.sin(U1) * math.cos(U2) * math.cos(lembda)), 2)

            Sin_sigma = math.sqrt(sqr_sin_sigma)

            Cos_sigma = math.sin(U1) * math.sin(U2) + math.cos(U1) * math.cos(U2) * math.cos(lembda)

            sigma = math.atan2(Sin_sigma, Cos_sigma)

            Sin_alpha = math.cos(U1) * math.cos(U2) * math.sin(lembda) / math.sin(sigma)
            alpha = math.asin(Sin_alpha)

            Cos2sigma_m = math.cos(sigma) - (2 * math.sin(U1) * math.sin(U2) / pow(math.cos(alpha), 2))

            C = (f / 16) * pow(math.cos(alpha), 2) * (4 + f * (4 - 3 * pow(math.cos(alpha), 2)))

            last_lembda = lembda

            lembda = omega + (1 - C) * f * math.sin(alpha) * (sigma + C * math.sin(sigma) * \
                                                              (Cos2sigma_m + C * math.cos(sigma) * (
                                                                  -1 + 2 * pow(Cos2sigma_m, 2))))

        u2 = pow(math.cos(alpha), 2) * (a * a - b * b) / (b * b)

        A = 1 + (u2 / 16384) * (4096 + u2 * (-768 + u2 * (320 - 175 * u2)))

        B = (u2 / 1024) * (256 + u2 * (-128 + u2 * (74 - 47 * u2)))

        delta_sigma = B * Sin_sigma * (Cos2sigma_m + (B / 4) * \
                                       (Cos_sigma * (-1 + 2 * pow(Cos2sigma_m, 2)) - \
                                        (B / 6) * Cos2sigma_m * (-3 + 4 * sqr_sin_sigma) * \
                                        (-3 + 4 * pow(Cos2sigma_m, 2))))

        s = b * A * (sigma - delta_sigma)

        alpha12 = math.atan2((math.cos(U2) * math.sin(lembda)), \
                             (math.cos(U1) * math.sin(U2) - math.sin(U1) * math.cos(U2) * math.cos(lembda)))

        alpha21 = math.atan2((math.cos(U1) * math.sin(lembda)), \
                             (-math.sin(U1) * math.cos(U2) + math.cos(U1) * math.sin(U2) * math.cos(lembda)))

        if (alpha12 < 0.0):
            alpha12 += two_pi
        if (alpha12 > two_pi):
            alpha12 -= two_pi

        alpha21 += two_pi / 2.0
        if alpha21 < 0.0:
            alpha21 += alpha21 + two_pi
        if alpha21 > two_pi:
            alpha21 -= two_pi

        return {"distance": s, "forward_azimuth": alpha12, "reverse_azimuth": alpha21}
コード例 #31
0
def get_line_data(pixels, x1, y1, x2, y2, line_w=2, the_z=0, the_c=0, the_t=0):
    """
    Grabs pixel data covering the specified line, and rotates it horizontally
    so that x1,y1 is to the left,
    Returning a numpy 2d array. Used by Kymograph.py script.
    Uses PIL to handle rotating and interpolating the data. Converts to numpy
    to PIL and back (may change dtype.)

    @param pixels:          PixelsWrapper object
    @param x1, y1, x2, y2:  Coordinates of line
    @param line_w:          Width of the line we want
    @param the_z:           Z index within pixels
    @param the_c:           Channel index
    @param the_t:           Time index
    """

    size_x = pixels.getSizeX()
    size_y = pixels.getSizeY()

    line_x = x2 - x1
    line_y = y2 - y1

    rads = math.atan(float(line_x) / line_y)

    # How much extra Height do we need, top and bottom?
    extra_h = abs(math.sin(rads) * line_w)
    bottom = int(max(y1, y2) + extra_h / 2)
    top = int(min(y1, y2) - extra_h / 2)

    # How much extra width do we need, left and right?
    extra_w = abs(math.cos(rads) * line_w)
    left = int(min(x1, x2) - extra_w)
    right = int(max(x1, x2) + extra_w)

    # What's the larger area we need? - Are we outside the image?
    pad_left, pad_right, pad_top, pad_bottom = 0, 0, 0, 0
    if left < 0:
        pad_left = abs(left)
        left = 0
    x = left
    if top < 0:
        pad_top = abs(top)
        top = 0
    y = top
    if right > size_x:
        pad_right = right - size_x
        right = size_x
    w = int(right - left)
    if bottom > size_y:
        pad_bottom = bottom - size_y
        bottom = size_y
    h = int(bottom - top)
    tile = (x, y, w, h)

    # get the Tile
    plane = pixels.getTile(the_z, the_c, the_t, tile)

    # pad if we wanted a bigger region
    if pad_left > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((data_h, pad_left), dtype=plane.dtype)
        plane = hstack((pad_data, plane))
    if pad_right > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((data_h, pad_right), dtype=plane.dtype)
        plane = hstack((plane, pad_data))
    if pad_top > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((pad_top, data_w), dtype=plane.dtype)
        plane = vstack((pad_data, plane))
    if pad_bottom > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((pad_bottom, data_w), dtype=plane.dtype)
        plane = vstack((plane, pad_data))

    pil = script_utils.numpy_to_image(plane, (plane.min(), plane.max()), int32)

    # Now need to rotate so that x1,y1 is horizontally to the left of x2,y2
    to_rotate = 90 - math.degrees(rads)

    if x1 > x2:
        to_rotate += 180
    # filter=Image.BICUBIC see
    # http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2172449/
    rotated = pil.rotate(to_rotate, expand=True)
    # rotated.show()

    # finally we need to crop to the length of the line
    length = int(math.sqrt(math.pow(line_x, 2) + math.pow(line_y, 2)))
    rot_w, rot_h = rotated.size
    crop_x = (rot_w - length) / 2
    crop_x2 = crop_x + length
    crop_y = (rot_h - line_w) / 2
    crop_y2 = crop_y + line_w
    cropped = rotated.crop((crop_x, crop_y, crop_x2, crop_y2))
    return asarray(cropped)
コード例 #32
0
def zturnangle(a):           #sin and cos of the turning matrix of angle a
    print("ztunangle")
    s = math.sin(a)
    c = math.cos(a)
    print([c,s])
    return [c,s]
コード例 #33
0
    def Evolvent(self):
        '''Расчет эвольвенты зуба
        '''
        #Расчет эвольветы зуба 
        # Читаем данные из полей формы
        # z = Количество зубьев
        z = self.doubleSpinBox_Z.value() 
        # m = Модуль зуба
        m = self.doubleSpinBox_m.value() 
        # a = Угол главного профиля
        a = self.doubleSpinBox_a.value()
        #b = Угол наклона зубьев
        b = self.doubleSpinBox_b.value()
        #ha = Коэффициент высоты головки
        ha = self.doubleSpinBox_ha.value()
        #pf = К-т радиуса кривизны переходной кривой
        pf = self.doubleSpinBox_pf.value()
        #c = Коэффициент радиального зазора
        c = self.doubleSpinBox_c.value()
        #x = К-т смещения исходного контура
        x = self.doubleSpinBox_x.value()
        #y =Коэффициент уравнительного смещения
        y = self.doubleSpinBox_y.value()
        # n= Количество точек (точность построения)
        #n=int(self.doubleSpinBox_n.value())
        n=100
        # заполня переменные 
        # Делительный диаметр
        d = z * m
        # Высота зуба h=
        h = 2.25 * m
        # Высота головки ha =
        hav = m
        # Высота ножки hf=
        hf = 1.25 * m
        #Диаметр вершин зубьев
        #da = d + (2 * m)*(ha+x+y)
        da = d + 2 * (ha + x - y) * m
        #Диаметр впадин (справочно)
        #df = d -(2 * hf)
        df = d -2 * (ha + c - x) * m
        #Окружной шаг зубьев или Шаг зацепления по дуге делительной окружности: Pt или p
        pt = math.pi * m
        #Окружная толщина зуба или Толщина зуба по дуге делительной окружности: St или S
        #Суммарный коэффициент смещений: XΣ
        X = 0.60 + 0.12
       # St = 0.5 * pf
       # St = 0.5 * pt
        St = 0.5 * pt + 2 * x * m * math.tan(math.radians(a))
        #inv a 
        inva=math.tan(math.radians(a))-math.radians(a)
        #Угол зацепления invαw
        invaw= (2 * X - math.tan(math.radians(a))) / (10+26) + inva
        #Угол профиля
        at = math.ceil(math.degrees(math.atan(math.tan(math.radians(a))
            /math.cos( math.radians(b)))))
        # Диаметр основной окружности
        db = d * math.cos(math.radians(at)) 
        #Диаметр начала выкружки зуба
        D  = 2 * m * ( ( z/( 2 * math.cos(math.radians(b)) )-(1-x)) ** 2 +
            ((1-x)/math.tan(math.radians(at)))**2)**0.5
        #Промежуточные данные
        yi = math.pi/2-math.radians(at)

        hy = yi/(n-1)

        x0 = math.pi/(4*math.cos(math.radians(b))
             )+pf*math.cos(math.radians(at))+math.tan(math.radians(at))

        y0 = 1-pf*math.sin(math.radians(at))-x

        C  = (math.pi/2+2*x*math.tan(math.radians(a))
             )/z+math.tan(math.radians(at))-math.radians(at)
        #Расчетный шаг точек эвольвенты
        hdy = (da-D)/(n-1)
        dyi = da
        fi = 2*math.cos(math.radians(b))/z*(x0+y0*math.tan(yi))
        #Заполняем текстовые поля в форме
        # Делительный диаметр
    #    self.lineEdit_d.setText(str(d))
        # Высота зуба h=
    #    self.lineEdit_h.setText(str(h))
        # Высота головки ha =
    #    self.lineEdit_ha.setText(str(hav))
        # Высота ножки hf=
    #    self.lineEdit_hf.setText(str(hf))
        # Диаметр вершин зубьев
    #    self.lineEdit_da.setText(str(da))
        # Диаметр впадин (справочно)
    #    self.lineEdit_df.setText(str(df))
        # Окружной шаг зубьев Pt=
    #    self.lineEdit_Pt.setText(str(math.ceil(pt)))
        # Окружная толщина зуба St=
    #    self.lineEdit_St.setText(str(math.ceil(St)))
        # Угол профиля
    #    self.lineEdit_at.setText(str(at))
        # Диаметр основной окружности
    #    self.lineEdit_db.setText(str(math.ceil(db)))
        
        # Создаем списки 
        List_dyi=[]
        List_Di=[]
        List_Yei=[]
        List_Xei=[]
        List_Minus_Xei=[]
        List_Xdai=[]
        List_Ydai=[]
        List_yi=[]
        List_Ai=[]
        List_Bi=[]
        List_fi=[]
        List_Ypki=[]
        List_Xpki=[]
        List_Minus_Xpki=[]
        # Заполняем нуливой (первый )индекс списка значениями
        List_dyi.append(dyi)
        List_Di.append( math.acos( db/ List_dyi[0] ) - math.tan( math.acos( db / List_dyi[0] ) ) + C )
        List_Yei.append(dyi / 2*math.cos( List_Di[0]))
        List_Xei.append(List_Yei[0]*math.tan(List_Di[0]))
        List_Minus_Xei.append(-List_Xei[0])
        List_Xdai.append(-List_Xei[0])
        List_Ydai.append(((da/2)**2-List_Xdai[0]**2)**0.5)
        hda=(List_Xei[0]-List_Minus_Xei[0])/(n-1)
        # Заполняем первый (второй по счету )индекс списка значениями 
        List_dyi.append(dyi-hdy)
        List_Di.append( math.acos(db/List_dyi[1])-math.tan(math.acos(db/List_dyi[1]))+C)
        List_Yei.append( List_dyi[1]/2*math.cos(List_Di[1]))
        List_Xei.append( List_Yei[1]* math.tan(List_Di[1]))
        List_Minus_Xei.append(-List_Xei[1])
        List_Xdai.append(List_Xdai[0]+hda)
        List_Ydai.append(((da/2)**2-List_Xdai[1]**2)**0.5)
        Xdai=List_Xdai[1]
        dyi=dyi-hdy
        # Начинаем  заполнять списки в цикле 
        i=0
        while i < n-2:  
            i=i+1
            dyi=dyi-hdy
            List_Di.append(math.acos(db/dyi)-math.tan(math.acos(db/dyi))+C)
            Di=math.acos(db/dyi)-math.tan(math.acos(db/dyi))+C
            Yei=dyi/2*math.cos(Di)
            Xei=Yei*math.tan(Di) 
            List_dyi.append(dyi) 
            List_Yei.append(dyi/2*math.cos(Di))
            List_Xei.append(Yei*math.tan(Di))
            List_Minus_Xei.append(-Xei) 
            Xdai=Xdai+hda
            List_Xdai.append(Xdai)
            List_Ydai.append(((da/2)**2-Xdai**2)**0.5)
        #Заполняем последний индекс  списка    
        List_dyi[n-1]=D
        # Заполняем нуливой (первый )индекс списка значениями
        List_yi.append(yi)
        List_Ai.append(z/(2*math.cos(math.radians(b)))-y0-pf*math.cos(List_yi[0]) )
        List_Bi.append(y0*math.tan(List_yi[0])+pf*math.sin(List_yi[0]))
        List_fi.append(fi)
        List_Ypki.append((List_Ai[0] * math.cos(fi)+List_Bi[0] * math.sin(fi)) * m)
        List_Xpki.append((List_Ai[0] * math.sin(fi)-List_Bi[0] * math.cos(fi)) * m)
        List_Minus_Xpki.append(-List_Xpki[0])
        # Начинаем  заполнять списки в цикле 
        i=0
        while i < n-2:
            i=i+1
            yi=yi-hy
            List_yi.append(yi)
            Ai = z / (2 * math.cos(math.radians(b)))-y0-pf*math.cos(yi)
            List_Ai.append( z / (2 * math.cos(math.radians(b)))-y0-pf*math.cos(yi))
            Bi =y0*math.tan(yi)+pf*math.sin(yi)
            List_Bi.append(y0*math.tan(yi)+pf*math.sin(yi))
            fi = 2*math.cos(math.radians(b))/z*(x0+y0*math.tan(yi))
            List_fi.append(2*math.cos(math.radians(b))/z*(x0+y0*math.tan(yi)))
            List_Ypki.append((Ai*math.cos(fi)+Bi*math.sin(fi))*m)
            Ypki=(Ai*math.cos(fi)+Bi*math.sin(fi))*m
            Xpki=(Ai*math.sin(fi)-Bi*math.cos(fi))*m
            List_Xpki.append((Ai*math.sin(fi)-Bi*math.cos(fi))*m)
            List_Minus_Xpki.append(-Xpki)
        #Заполняем последний индекс  списка  
        List_yi.append(yi-yi)
        List_Ai.append(z/(2*math.cos(math.radians(b)))-y0-pf*math.cos(List_yi[n-1]) )  
        List_Bi.append(y0*math.tan(List_yi[n-1])+pf*math.sin(List_yi[n-1])) 
        List_fi.append(2*math.cos(math.radians(b))/z*(x0+y0*math.tan(List_yi[n-1])))
        List_Ypki.append((List_Ai[n-1] * math.cos(fi)+List_Bi[n-1] * math.sin(List_fi[n-1])) * m)
        List_Xpki.append((List_Ai[n-1] * math.sin(fi)-List_Bi[n-1] * math.cos(List_fi[n-1])) * m)
        List_Minus_Xpki.append(-List_Xpki[n-1])

       # self.WiPfileZub(List_Yei,List_Xei,List_Minus_Xei,List_Ypki,List_Xpki,List_Minus_Xpki,List_Ydai,List_Xdai)
        self.GragEvolvent(List_Minus_Xei+List_Minus_Xpki,List_Yei+List_Ypki,n)

        DFreza = self.lineEditDFreza.text()
        VisotaYAxis = self.lineEditVisota.text()
        Diametr = self.lineEditDiametr.text()
        if DFreza and VisotaYAxis:
            E30 = (int(DFreza)/2) +float(VisotaYAxis)
        else:
            E30 = 0
        angi_B=0
        if ValkosZub:
            angie_A:float = 90# угол А треугольника по высоте детали 
            angie_B:float = float(b) #угол B треугольника по высоте детали ( угол наклона зуба по чертежу)
            angie_Y:float = 180 - (angie_A + angie_B) # трерий уго треугольника по высоте детали 
            side_c:float = float(E30)# высота детали первая сторона треугольника 
            side_a = side_c * math.sin(math.radians(angie_A)) / math.sin(math.radians(angie_Y))# вторая сторона треугольника 
            side_b = side_c * math.sin(math.radians(angie_B)) / math.sin(math.radians(angie_Y))# третия сторона треугольника ( ось Х)
            sid_a:float = float(Diametr)/2 # радиус детали первая и вторая тророны треугольника по торцу
           # sid_a:float = float(self.lineEdit_da.text())/2 # радиус детали первая и вторая тророны треугольника по торцу
            sid_c:float = sid_a
            if sid_c < 10 :
                sid_a:float = 10
                sid_c:float = 10
                angi_B = float('{:.3f}'.format(math.degrees(math.acos((sid_a**2+sid_c**2-side_b**2)/(2*sid_a*sid_c)))))
                QMessageBox.about (self, "Ошибка " , "Диаметр шестерни задан меньше 20 мм. \n Введите риальный диаметр шестерни " )
            else:
                angi_B = float('{:.3f}'.format(math.degrees(math.acos((sid_a**2+sid_c**2-side_b**2)/(2*sid_a*sid_c)))))# результат угол поворота стола 


        self.label_da.setText(str(round(da,1)))
        self.label_d.setText(str(round(d,1)))
        self.label_at.setText(str(round(at,1)))
        self.label_db.setText(str(round(db,1)))
        self.label_df.setText(str(round(df,1)))
        self.label_St.setText(str(round(St,1)))
        self.label_Pt.setText(str(round(pt,1)))
        self.label_hf.setText(str(round(hf,1)))
        self.label_ha.setText(str(round(ha,1)))
        self.label_h.setText(str(round(h,1)))
        self.lineEditDiametr.setText(str(da))
        self.lineEditUgol.setText(str(angi_B))
コード例 #34
0
def zturn():           #sin and cos of the turning matrix
    pos=client.getPose()
    s = math.sin(pos.orientation.z_rad)
    c = math.cos(pos.orientation.z_rad)
    return [c,s]
コード例 #35
0
def cone_search(ra,
                dec,
                radius,
                time_start,
                time_end,
                flag,
                aws_profile,
                aws_region,
                s3_output_location,
                local_output_location,
                athena_database,
                athena_workgroup,
                query_life=10,
                wait_time=0.1,
                single_query=True):
    def query_athena(query, query_args):
        query = query.format(*query_args)
        response = athena_client.start_query_execution(
            QueryString=query,
            QueryExecutionContext={'Database': athena_database},
            ResultConfiguration={'OutputLocation': s3_output_location},
            WorkGroup=athena_workgroup)
        print('Query submitted:\n{}\n'.format(query))
        rsp = athena_client.get_query_execution(
            QueryExecutionId=response['QueryExecutionId'])
        succeeded_query = True if rsp['QueryExecution']['Status'][
            'State'] == 'SUCCEEDED' else False
        num_sec_query_has_been_running = 0
        # check to see if the query has succeeded
        while not succeeded_query:
            if num_sec_query_has_been_running >= query_life:
                print(
                    'QUERY CANCELLED: Query {} has been running for ~{} seconds.'
                    .format(response['QueryExecutionId'],
                            num_sec_query_has_been_running))
                _ = athena_client.stop_query_execution(
                    QueryExecutionId=response['QueryExecutionId'])
                return None
            if num_sec_query_has_been_running % 60 == 0 and num_sec_query_has_been_running:
                duration = int(num_sec_query_has_been_running / 60)
                word = 'minutes' if duration > 1 else 'minute'
                print('...Query has been running for ~{} {}.'.format(
                    duration, word))
            # wait until query has succeeded to start the next query
            if num_sec_query_has_been_running + wait_time > query_life:
                sleep_time = query_life - num_sec_query_has_been_running
            else:
                sleep_time = wait_time
            time.sleep(sleep_time)
            num_sec_query_has_been_running += sleep_time
            rsp = athena_client.get_query_execution(
                QueryExecutionId=response['QueryExecutionId'])
            succeeded_query = True if rsp['QueryExecution']['Status'][
                'State'] == 'SUCCEEDED' else False
        return response['QueryExecutionId']

    sess = boto3.Session(profile_name=aws_profile, region_name=aws_region)
    athena_client = sess.client('athena')
    s3_client = sess.client('s3')
    s3_output_path = s3_output_location.replace('s3://', '').split('/')
    bucket = s3_output_path[0]
    additional_s3_path = s3_output_location.replace('s3://{}/'.format(bucket),
                                                    '')
    queries = {
        'single':
        '''
            SELECT *
            FROM gPhoton_partitioned
            WHERE zoneID BETWEEN {} AND {}
                AND dec BETWEEN {} AND {}
                AND ra BETWEEN {} AND {}
                AND ({}*cx + {}*cy + {}*cz) > {}
                AND time >= {} AND time < {}
                AND flag = {};
         ''',
        'multiple':
        '''
            SELECT *
            FROM gPhoton_partitioned
            WHERE zoneID = {}
                AND dec BETWEEN {} AND {}
                AND ra BETWEEN {} AND {}
                AND ({}*cx + {}*cy + {}*cz) > {}
                AND time >= {} AND time < {}
                AND flag = {};
         '''
    }

    cx = math.cos(math.radians(dec)) * math.cos(math.radians(ra))
    cy = math.cos(math.radians(dec)) * math.sin(math.radians(ra))
    cz = math.sin(math.radians(dec))
    alpha = get_alpha(radius, dec)
    if (ra - alpha) < 0:
        ra = ra + 360
    zoneHeight = 30.0 / 3600.0
    min_zoneid = int(np.floor((dec - radius + 90.0) / zoneHeight))
    max_zoneid = int(np.floor((dec + radius + 90.0) / zoneHeight))

    query_args_collection = {
        'non-conditional': [
            dec - radius, dec + radius, ra - alpha, ra + alpha, cx, cy, cz,
            math.cos(math.radians(radius)), time_start, time_end, flag
        ],
        'conditional': [
            dec - radius, dec + radius, 0, ra - 360 + alpha, cx, cy, cz,
            math.cos(math.radians(radius)), time_start, time_end, flag
        ]
    }

    query_collection = ''
    query_argument_collection = []
    for zoneid in range(min_zoneid, max_zoneid + 1):
        query = queries['single'] if single_query else queries['multiple']
        zone_args = [min_zoneid, max_zoneid] if single_query else [zoneid]
        query_args = zone_args + query_args_collection['non-conditional']
        if (ra + alpha) > 360:
            query = query.replace(';',
                                  '') + '\n            UNION ALL\n' + query
            additional_args = [min_zoneid, max_zoneid
                               ] if single_query else [zoneid]
            query_args = query_args + additional_args + query_args_collection[
                'conditional']
        temp_query = query.replace(
            ';', ''
        ) + '\n            UNION ALL\n' if not single_query and zoneid != max_zoneid else query
        query_collection += temp_query
        query_argument_collection.extend(query_args)
        if single_query:
            break
    start_time = time.time()
    execution_id = query_athena(query_collection, query_argument_collection)
    print('Time taken to query: ~{:.4f} seconds'.format(time.time() -
                                                        start_time))

    # get single CSV or accumulate the CSVs from the different SELECT statements
    dfs = []
    download_paths = []
    if execution_id is not None:
        path_to_csv = os.path.join(additional_s3_path, execution_id + '.csv')
        download_path = os.path.join(local_output_location,
                                     execution_id + '.csv')
        start_time = time.time()
        s3_client.download_file(bucket, path_to_csv, download_path)
        print('Time taken to download: ~{:.4f} seconds'.format(time.time() -
                                                               start_time))
        dfs.append(pd.read_csv(download_path, engine='python'))
        download_paths.append(download_path)
    if len(dfs):
        df = pd.concat(dfs)
        output_location = os.path.join(local_output_location,
                                       str(uuid4()) + '.csv')
        df.to_csv(output_location, index=False)
        print('\nData written to {}\n'.format(output_location))
        for download_path in download_paths:
            os.remove(download_path)
        print(df.head())
    else:
        print('No CSVs were found.')
コード例 #36
0
def getLineData(pixels, x1, y1, x2, y2, lineW=2, theZ=0, theC=0, theT=0):
    """
    Grabs pixel data covering the specified line, and rotates it horizontally
    so that x1,y1 is to the left,
    Returning a numpy 2d array. Used by Kymograph.py script.
    Uses PIL to handle rotating and interpolating the data. Converts to numpy
    to PIL and back (may change dtype.)

    @param pixels:          PixelsWrapper object
    @param x1, y1, x2, y2:  Coordinates of line
    @param lineW:           Width of the line we want
    @param theZ:            Z index within pixels
    @param theC:            Channel index
    @param theT:            Time index
    """

    from numpy import asarray

    sizeX = pixels.getSizeX()
    sizeY = pixels.getSizeY()

    lineX = x2 - x1
    lineY = y2 - y1

    rads = math.atan(float(lineX) / lineY)

    # How much extra Height do we need, top and bottom?
    extraH = abs(math.sin(rads) * lineW)
    bottom = int(max(y1, y2) + extraH / 2)
    top = int(min(y1, y2) - extraH / 2)

    # How much extra width do we need, left and right?
    extraW = abs(math.cos(rads) * lineW)
    left = int(min(x1, x2) - extraW)
    right = int(max(x1, x2) + extraW)

    # What's the larger area we need? - Are we outside the image?
    pad_left, pad_right, pad_top, pad_bottom = 0, 0, 0, 0
    if left < 0:
        pad_left = abs(left)
        left = 0
    x = left
    if top < 0:
        pad_top = abs(top)
        top = 0
    y = top
    if right > sizeX:
        pad_right = right - sizeX
        right = sizeX
    w = int(right - left)
    if bottom > sizeY:
        pad_bottom = bottom - sizeY
        bottom = sizeY
    h = int(bottom - top)
    tile = (x, y, w, h)

    # get the Tile
    plane = pixels.getTile(theZ, theC, theT, tile)

    # pad if we wanted a bigger region
    if pad_left > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((data_h, pad_left), dtype=plane.dtype)
        plane = hstack((pad_data, plane))
    if pad_right > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((data_h, pad_right), dtype=plane.dtype)
        plane = hstack((plane, pad_data))
    if pad_top > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((pad_top, data_w), dtype=plane.dtype)
        plane = vstack((pad_data, plane))
    if pad_bottom > 0:
        data_h, data_w = plane.shape
        pad_data = zeros((pad_bottom, data_w), dtype=plane.dtype)
        plane = vstack((plane, pad_data))

    pil = numpyToImage(plane)
    #pil.show()

    # Now need to rotate so that x1,y1 is horizontally to the left of x2,y2
    toRotate = 90 - math.degrees(rads)

    if x1 > x2:
        toRotate += 180
    # filter=Image.BICUBIC see
    # http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2172449/
    rotated = pil.rotate(toRotate, expand=True)
    #rotated.show()

    # finally we need to crop to the length of the line
    length = int(math.sqrt(math.pow(lineX, 2) + math.pow(lineY, 2)))
    rotW, rotH = rotated.size
    cropX = (rotW - length) / 2
    cropX2 = cropX + length
    cropY = (rotH - lineW) / 2
    cropY2 = cropY + lineW
    cropped = rotated.crop((cropX, cropY, cropX2, cropY2))
    #cropped.show()
    return asarray(cropped)
コード例 #37
0
ファイル: Kymograph.py プロジェクト: ome/omero-guide-python
def get_line_data(image, x1, y1, x2, y2, line_w=2, the_z=0, the_c=0, the_t=0):
    """
    Grab pixel data covering the specified line, and rotates it horizontally.

    Uses current rendering settings and returns 8-bit data.
    Rotates it so that x1,y1 is to the left,
    Returning a numpy 2d array. Used by Kymograph.py script.
    Uses PIL to handle rotating and interpolating the data. Converts to numpy
    to PIL and back (may change dtype.)

    @param pixels:          PixelsWrapper object
    @param x1, y1, x2, y2:  Coordinates of line
    @param line_w:          Width of the line we want
    @param the_z:           Z index within pixels
    @param the_c:           Channel index
    @param the_t:           Time index
    """
    size_x = image.getSizeX()
    size_y = image.getSizeY()

    line_x = x2 - x1
    line_y = y2 - y1

    rads = math.atan2(line_y, line_x)

    # How much extra Height do we need, top and bottom?
    extra_h = abs(math.sin(rads) * line_w)
    bottom = int(max(y1, y2) + extra_h / 2)
    top = int(min(y1, y2) - extra_h / 2)

    # How much extra width do we need, left and right?
    extra_w = abs(math.cos(rads) * line_w)
    left = int(min(x1, x2) - extra_w)
    right = int(max(x1, x2) + extra_w)

    # What's the larger area we need? - Are we outside the image?
    pad_left, pad_right, pad_top, pad_bottom = 0, 0, 0, 0
    if left < 0:
        pad_left = abs(left)
        left = 0
    x = left
    if top < 0:
        pad_top = abs(top)
        top = 0
    y = top
    if right > size_x:
        pad_right = right - size_x
        right = size_x
    w = int(right - left)
    if bottom > size_y:
        pad_bottom = bottom - size_y
        bottom = size_y
    h = int(bottom - top)

    # get the Tile - render single channel white
    image.set_active_channels([the_c + 1], None, ['FFFFFF'])
    jpeg_data = image.renderJpegRegion(the_z, the_t, x, y, w, h)
    pil = Image.open(StringIO(jpeg_data))

    # pad if we wanted a bigger region
    if pad_left > 0 or pad_right > 0 or pad_top > 0 or pad_bottom > 0:
        img_w, img_h = pil.size
        new_w = img_w + pad_left + pad_right
        new_h = img_h + pad_top + pad_bottom
        canvas = Image.new('RGB', (new_w, new_h), '#ff0000')
        canvas.paste(pil, (pad_left, pad_top))
        pil = canvas

    # Now need to rotate so that x1,y1 is horizontally to the left of x2,y2
    to_rotate = math.degrees(rads)

    # filter=Image.BICUBIC see
    # http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2172449/
    rotated = pil.rotate(to_rotate, expand=True)

    # finally we need to crop to the length of the line
    length = int(math.sqrt(math.pow(line_x, 2) + math.pow(line_y, 2)))
    rot_w, rot_h = rotated.size
    crop_x = (rot_w - length) / 2
    crop_x2 = crop_x + length
    crop_y = (rot_h - line_w) / 2
    crop_y2 = crop_y + line_w
    cropped = rotated.crop((crop_x, crop_y, crop_x2, crop_y2))

    # return numpy array
    rgb_plane = asarray(cropped)
    # greyscale image. r, g, b all same. Just use first
    return rgb_plane[::, ::, 0]
コード例 #38
0
    def __init__(self,
                 ra,
                 dec,
                 radius,
                 time_start,
                 time_end,
                 flag,
                 aws_profile,
                 aws_region,
                 s3_output_location,
                 local_output_location,
                 athena_database,
                 athena_workgroup,
                 query_life=10,
                 wait_time=0.1,
                 single_query=True):
        self.ra = ra
        self.dec = dec
        self.radius = radius
        self.time_start = time_start
        self.time_end = time_end
        self.flag = flag
        self.s3_output_location = s3_output_location
        self.local_output_location = local_output_location
        self.athena_database = athena_database
        self.athena_workgroup = athena_workgroup
        self.query_life = query_life
        self.wait_time = wait_time
        self.single_query = single_query
        sess = boto3.Session(profile_name=aws_profile, region_name=aws_region)
        global athena_client, s3_client
        athena_client = sess.client('athena')
        s3_client = sess.client('s3')
        self.s3_output_path = s3_output_location.replace('s3://',
                                                         '').split('/')
        self.bucket = self.s3_output_path[0]
        self.additional_s3_path = s3_output_location.replace(
            's3://{}/'.format(self.bucket), '')
        self.query = '''
                SELECT *
                FROM gPhoton_partitioned
                WHERE zoneID = {}
                AND dec BETWEEN {} AND {}
                AND ra BETWEEN {} AND {}
                AND ({}*cx + {}*cy + {}*cz) > {}
                AND time >= {} AND time < {}
                AND flag = {};
            '''

        # calculate_query_parameters
        self.cx = math.cos(math.radians(self.dec)) * math.cos(
            math.radians(self.ra))
        self.cy = math.cos(math.radians(self.dec)) * math.sin(
            math.radians(self.ra))
        self.cz = math.sin(math.radians(self.dec))
        self.alpha = self._get_alpha()
        if (self.ra - self.alpha) < 0:
            self.ra = self.ra + 360
        self.zoneHeight = 30.0 / 3600.0
        self.min_zoneid = int(
            np.floor((self.dec - self.radius + 90.0) / self.zoneHeight))
        self.max_zoneid = int(
            np.floor((self.dec + self.radius + 90.0) / self.zoneHeight))

        self.query_args_collection = {
            'non-conditional': [
                self.dec - self.radius, self.dec + self.radius,
                self.ra - self.alpha, self.ra + self.alpha, self.cx, self.cy,
                self.cz,
                math.cos(math.radians(self.radius)), self.time_start,
                self.time_end, self.flag
            ],
            'conditional': [
                self.dec - self.radius, self.dec + self.radius, 0,
                self.ra - 360 + self.alpha, self.cx, self.cy, self.cz,
                math.cos(math.radians(self.radius)), self.time_start,
                self.time_end, self.flag
            ]
        }
コード例 #39
0
def rotate(A, ang):
    c, s = math.cos(ang), math.sin(ang)
    L = np.array([[c, -s], [s, c]])
    newA = np.dot(L, A)
    return newA
コード例 #40
0
    V[k][i] = Vn

# Simulando modelo de onda cinemática (valores en k+1):
k = k + 1
dt = dx * NC / Vn  # [segundos] Cambio temporal inicial
t.append(t[k - 1] + dt)  # [segundos] Tiempo en k=1
while t[k] <= 60. * tf:
    # Inicializando campo para almacenar datos:
    Q.append(zeros(ni)), y.append(zeros(ni)), A.append(zeros(ni)), V.append(
        zeros(ni))

    # Calculando caudal en i=0
    angle = math.pi * t[k] / (60. * 75.)
    if angle < 2. * math.pi:  # Condición causal de la perturbación
        # [pies^3*s-1] Caudal total durante el evento de perturbación
        Q[k][0] = Qn + 750. * (1. - math.cos(angle)) / math.pi
    else:  # Final de la perturbación
        Q[k][0] = Qn  # [pies^3/s] Flujo base

    # Calculando el esténcil:
    for i in range(ni):
        # Altura de agua en nodo i [pies]:
        y[k][i] = ynormal(und, n, S, z, b, Q[k][i])
        # Área mojada en nodo i [pies^2]:
        A[k][i] = y[k][i] * (b + z * y[k][i])
        # Velocidad media en nodo i [pies/s]:
        V[k][i] = Q[k][i] / A[k][i]
        # Caudal en nodo i+1 [pies^3/s]:
        if i < ni - 1:
            Q[k][i + 1] = Q[k][i] - (dx / dt) * (A[k][i] - A[k - 1][i])
コード例 #41
0
ファイル: map.py プロジェクト: BrandonLuu/raster-mapping
    def vinc_dir(f, a, coordinate_a, alpha12, s):
        """

        Returns the lat and long of projected point and reverse azimuth
        given a reference point and a distance and azimuth to project.
        lats, longs and azimuths are passed in decimal degrees
        Returns ( phi2,  lambda2,  alpha21 ) as a tuple

        """

        phi1, lambda1 = coordinate_a.lat, coordinate_a.lon
        piD4 = math.atan(1.0)
        two_pi = piD4 * 8.0
        phi1 = phi1 * piD4 / 45.0
        lambda1 = lambda1 * piD4 / 45.0
        alpha12 = alpha12 * piD4 / 45.0
        if alpha12 < 0.0:
            alpha12 += two_pi
        if alpha12 > two_pi:
            alpha12 -= two_pi

        b = a * (1.0 - f)
        tan_u1 = (1 - f) * math.tan(phi1)
        u1 = math.atan(tan_u1)
        sigma1 = math.atan2(tan_u1, math.cos(alpha12))
        sin_alpha = math.cos(u1) * math.sin(alpha12)
        cos_alpha_sq = 1.0 - sin_alpha * sin_alpha
        u2 = cos_alpha_sq * (a * a - b * b) / (b * b)

        # @todo: look into replacing A and B with vincenty's amendment, see if speed/accuracy is good
        A = 1.0 + (u2 / 16384) * (4096 + u2 * (-768 + u2 * (320 - 175 * u2)))
        B = (u2 / 1024) * (256 + u2 * (-128 + u2 * (74 - 47 * u2)))

        # Starting with the approx
        sigma = (s / (b * A))
        last_sigma = 2.0 * sigma + 2.0  # something impossible

        # Iterate the following 3 eqs unitl no sig change in sigma
        # two_sigma_m , delta_sigma
        while abs((last_sigma - sigma) / sigma) > 1.0e-9:
            two_sigma_m = 2 * sigma1 + sigma
            delta_sigma = B * math.sin(sigma) * (math.cos(two_sigma_m) + (B / 4) * (math.cos(sigma) *
                                                                                    (-1 + 2 * math.pow(
                                                                                        math.cos(two_sigma_m), 2) -
                                                                                     (B / 6) * math.cos(two_sigma_m) *
                                                                                     (-3 + 4 * math.pow(math.sin(sigma),
                                                                                                        2)) *
                                                                                     (-3 + 4 * math.pow(
                                                                                         math.cos(two_sigma_m), 2)))))
            last_sigma = sigma
            sigma = (s / (b * A)) + delta_sigma

        phi2 = math.atan2((math.sin(u1) * math.cos(sigma) + math.cos(u1) * math.sin(sigma) * math.cos(alpha12)),
                          ((1 - f) * math.sqrt(math.pow(sin_alpha, 2) +
                                               pow(math.sin(u1) * math.sin(sigma) - math.cos(u1) * math.cos(
                                                   sigma) * math.cos(alpha12), 2))))

        lmbda = math.atan2((math.sin(sigma) * math.sin(alpha12)), (math.cos(u1) * math.cos(sigma) -
                                                                   math.sin(u1) * math.sin(sigma) * math.cos(alpha12)))

        C = (f / 16) * cos_alpha_sq * (4 + f * (4 - 3 * cos_alpha_sq))
        omega = lmbda - (1 - C) * f * sin_alpha * (sigma + C * math.sin(sigma) *
                                                   (math.cos(two_sigma_m) + C * math.cos(sigma) *
                                                    (-1 + 2 * math.pow(math.cos(two_sigma_m), 2))))

        lambda2 = lambda1 + omega
        alpha21 = math.atan2(sin_alpha, (-math.sin(u1) * math.sin(sigma) +
                                         math.cos(u1) * math.cos(sigma) * math.cos(alpha12)))

        alpha21 += two_pi / 2.0
        if alpha21 < 0.0:
            alpha21 += two_pi
        if alpha21 > two_pi:
            alpha21 -= two_pi

        phi2 = phi2 * 45.0 / piD4
        lambda2 = lambda2 * 45.0 / piD4
        alpha21 = alpha21 * 45.0 / piD4
        return Coordinate(lat=phi2, lon=lambda2), alpha21
コード例 #42
0
def m_to_long(m, lat):
    return -1.0 / (111320 * math.cos(lat)) * m