def points_between_points(point1, point2, delta): """Creates an array of points between two points given a delta :param point1: The first point :type point1: numpy.ndarray :param point2: The second point :type point2: numpy.ndarray :param delta: The increment between inserted points :type delta: float :returns: Array of points. :rtype: numpy.ndarray Note: u = (x1-x0, y1-y0)/L, where L=sqrt( (x1-x0)^2 + (y1-y0)^2). If r is the resolution, then the points will be given by (x0, y0) + u * n * r for n = 1, 2, .... while len(n*u*r) < L """ x0, y0 = point1 x1, y1 = point2 L = math.sqrt(math.pow((x1 - x0), 2) + math.pow((y1 - y0), 2)) pieces = int(L / delta) uu = numpy.array([x1 - x0, y1 - y0]) / L points = [point1] for nn in range(pieces): point = point1 + uu * (nn + 1) * delta points.append(point) return numpy.array(points)
def countStatParams(self, u, N, label): if N: m = 0 for u1 in u: m += u1 m = (m + 0.0) / N sigma_2 = 0 gamma = 0 kapa = 0 for u1 in u: sigma_2 += math.pow(u1 - m, 2) gamma += math.pow(u1 - m, 3) kapa += math.pow(u1 - m, 4) sigma_2 = sigma_2 / (N - 1.0) sigma = math.sqrt(sigma_2) try: r = sigma / m except: r = 'inf' try: gamma = gamma / N / math.pow(sigma, 3) kapa = kapa / N / math.pow(sigma_2, 2) - 3 except: gamma = 'inf' kapa = 'inf' label.setText(u' Среднее: %s,\n Дисперсия: %s,\n Среднеквадратичное отклонение: %s,\n Коэффициент вариации: %s,\n Коээффициента асимметрии: %s,\n Коэффициент эксцесса: %s' % ( m, sigma_2, sigma, r, gamma, kapa)) self.analyzedSignal.emit()
def getCylinderCylinderIntersectionVolume(cylinderOneRadius, cylinderTwoRadius, angleInDegrees, pointsToGenerate = 10**5): angleInRadians = angleInDegrees * math.pi / 180 if angleInDegrees == 90: boundLength = cylinderOneRadius * 2.0 else: boundLength = (cylinderOneRadius * 2.0 / math.sin(angleInRadians)) + (cylinderTwoRadius * 2.0 / math.tan(angleInRadians)) cylinderOneRadiusSquared = math.pow(cylinderOneRadius, 2) cylinderTwoRadiusSquared = math.pow(cylinderTwoRadius, 2) points = pointsToGenerate = int(pointsToGenerate) pointsInIntersection = 0 while points > 0: points -= 1 randomPointInBound = Point.getRandomPointInCylinder(cylinderOneRadius, boundLength) rotatedPointInBound = Point((randomPointInBound.coordinates[0], randomPointInBound.coordinates[2])).rotate(angleInRadians) # Check intersection if math.pow(randomPointInBound.coordinates[1], 2) + math.pow(rotatedPointInBound.coordinates[1], 2) <= cylinderTwoRadiusSquared: pointsInIntersection += 1 cylinderOneVolume = math.pi * cylinderOneRadiusSquared * boundLength return pointsInIntersection * cylinderOneVolume / pointsToGenerate
def draw_car(x,y,th,canv): r = math.sqrt(math.pow(ROBOT_LENGTH,2) + math.pow(ROBOT_WIDTH,2))/2 x = x + 300.0/cm_to_pixels y = y + 300.0/cm_to_pixels # top left phi = th + math.pi/2+ math.atan2(ROBOT_LENGTH,ROBOT_WIDTH) topleft = (x + r*math.cos(phi),y+r*math.sin(phi)) #top right phi = th + math.atan2(ROBOT_WIDTH,ROBOT_LENGTH) topright = (x + r*math.cos(phi),y+r*math.sin(phi)) # bottom left phi = th + math.pi + math.atan2(ROBOT_WIDTH,ROBOT_LENGTH) bottomleft = (x + r*math.cos(phi),y+r*math.sin(phi)) # bottom right phi = th + 3*math.pi/2 + math.atan2(ROBOT_LENGTH,ROBOT_WIDTH) bottomright = (x + r*math.cos(phi),y+r*math.sin(phi)) canv.create_polygon(topleft[0]*cm_to_pixels,600 - topleft[1]*cm_to_pixels, bottomleft[0]*cm_to_pixels,600 - bottomleft[1]*cm_to_pixels, bottomright[0]*cm_to_pixels,600 - bottomright[1]*cm_to_pixels, topright[0]*cm_to_pixels,600 - topright[1]*cm_to_pixels, width = 1, outline = 'blue',fill = '') x1 = x*cm_to_pixels y1 = y*cm_to_pixels canv.create_oval(x1-1,600-(y1-1),x1+1,600-(y1+1),outline = 'green',fill = 'green')
def GetSpindownStuff(tc, age, l0, b0, emax0, n0): t = np.logspace(0,math.log10(1000.*age),300) lumt = [] emaxt = [] bt = [] nt = [] n = 0 for i in t: l = l0/math.pow(1.+i/tc,2.) btt = b0*math.sqrt(l/l0)*(1.+0.5*math.sin(0.1*n*3.14)) lumtt = l*(1.+0.5*math.cos(0.1*n*3.14)) emaxtt = emax0*math.pow(l/l0,0.25)*(1.+0.5*math.sin(0.05*n*3.14)) ntt = n0*math.pow(l/l0,0.25)*(1.+0.5*math.cos(0.05*n*3.14)) bt.append([]) bt[n].append(i) bt[n].append(btt) lumt.append([]) lumt[n].append(i) lumt[n].append(lumtt) emaxt.append([]) emaxt[n].append(i) emaxt[n].append(emaxtt) nt.append([]) nt[n].append(i) nt[n].append(ntt) n = n+1 return lumt,bt,emaxt,nt
def AgeIndividual(particle, fieldset, time, dt): #print("Ageing") particle.age += dt if (particle.age - (particle.monthly_age*30*24*60*60)) > (30*24*60*60): particle.monthly_age += 1 a=2.225841100458143# 0.7343607395421234 old parameters b=0.8348850216641774# 0.5006692114850767 old parameters Alengths = [3.00, 4.51, 6.02, 11.65, 16.91, 21.83, 26.43, 30.72, 34.73, 38.49, 41.99, 45.27, 48.33, 51.19, 53.86, 56.36, 58.70, 60.88, 62.92, 64.83, 66.61, 68.27, 69.83, 71.28, 72.64, 73.91, 75.10, 76.21, 77.25, 78.22, 79.12, 79.97, 80.76, 81.50, 82.19, 82.83, 83.44, 84.00, 84.53, 85.02, 85.48, 85.91, 86.31, 86.69, 87.04, 87.37, 87.68, 87.96, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42, 89.42] L = lengths[(particle.monthly_age-1)]/100 #L = GetLengthFromAge(monthly_age) vmax = a * math.pow(L, b) particle.Vmax = vmax MPmax=0.3 MPexp=0.1008314958945224 MSmax=0.006109001382111822 MSslope=0.8158285706493162 Mrange=0.00001430156 Mnat = MPmax*math.exp(-1*MPexp*particle.age) + MSmax*math.pow(particle.age, MSslope) Hexp = 1-fieldset.H[time, particle.lon, particle.lat, particle.depth]/2 Mvar = Mnat * math.pow((1 - Mrange), Hexp)#(1-fieldset.H[time, lon, lat, particle.depth]))#/2)) if random.uniform(0, 1) > Mvar: particle.active = 0 particle.release_time = 100000000*100000000 #Particle will not be reactivated particle.lon = 0 particle.lat = 0
def compute_euc_distance(self, point1, point2): x_distance = point1[0] - point2[0] x_distance = math.pow(x_distance, 2) y_distance = point1[1] - point2[1] y_distance = math.pow(y_distance, 2) return math.sqrt(x_distance + y_distance)
def main(): filename = time.strftime('%A-%Y%m%d-%H-%M-%S') + '.txt' # filename with system date time format f = open(filename , 'w') # opening the file with write 'w' permission f.write('+++++++++++++++++++++++++++++++++\n') # decoration with +++ print('+++++++++++++++++++++++++++++++++') #To add the characters/decorating output days = int(input("Please enter number of days: ") ) #Asking user input f.write('days: %s'%days) # Writing the user input 'days' to the text file if ( days > 0 and days <= 366 ): #condition to check valid days in a year n = math.pow(2, days-1) #power function ...2^n-1 m = n / 100 #Converting cents to dollars f.write('\n+++++++++++++++++++++++++++++++++\n') print('+++++++++++++++++++++++++++++++++') f.write(' Day Today\'s Salary \n------ -----------------\n %s $%s'%(days,m)) #%s-substitution %(days,m) using variable to display output print(' Day Today\'s Salary \n------ -----------------\n %s $%s'%(days,m)) #%s-substitution %(days,m) using variable to display output else: while True: #looping to check whether user has entered valid data f.write("\nInvalid number of days\n") # Writing invalid number of days to text file print("Invalid number of days\n") f.write('+++++++++++++++++++++++++++++++++\n') # decoration with +++ in the text file print('+++++++++++++++++++++++++++++++++\n') days = int(input("Please enter number of days: ") ) #Asking user input f.write('days: %s'%days) #print ('------------------------------') if ( days > 0 and days <= 366 ): n = int(math.pow(2, days-1)) m = n / 100 print ('+++++++++++++++++++++++++++++++++\n') f.write('\n+++++++++++++++++++++++++++++++++\n') f.write(' Day Today\'s Salary\n------ -------------------\n %s $%s'%(days,m)) print(' Day Today\'s Salary\n------ -------------------\n %s $%s'%(days,m)) break #breaking the loop
async def fetch_currencies(self, params={}): response = await self.publicGetCurrencyList(params) currencies = response['response']['entities'] precision = self.precision['amount'] result = {} for i in range(0, len(currencies)): currency = currencies[i] id = currency['currency_id'] code = self.common_currency_code(currency['iso'].upper()) result[code] = { 'id': id, 'code': code, 'name': currency['name'], 'active': True, 'status': 'ok', 'precision': precision, 'limits': { 'amount': { 'min': None, 'max': math.pow(10, precision), }, 'price': { 'min': math.pow(10, -precision), 'max': math.pow(10, precision), }, 'cost': { 'min': None, 'max': None, }, }, 'info': currency, } return result
def isInCircle(x,y, circle): dist = math.sqrt((math.pow(x-circle[0],2))+(math.pow(y-circle[1],2))) if dist <= int(100): return True else: cv2.circle(original,(x,y),1,(255,255,255)) return False
def evaluateLogLikelihood(params, D, N, M_min, M_max): alpha = params[0] # extract alpha # Compute normalisation constant. c = (1.0 - alpha)/(math.pow(M_max, 1.0-alpha) - math.pow(M_min, 1.0-alpha)) # return log likelihood. return N*math.log(c) - alpha*D
def convert_to_polar(mag): hmag = mag[0] vmag = mag[1] angle = math.atan2(float(vmag), float(hmag)) distance = math.sqrt(math.pow(mag[0], 2) + math.pow(mag[1], 2)) angle = 180 - math.degrees(angle) return (angle, distance)
def costFunctionGaussianResponses(datapoints, params, nClasses): responses = np.zeros((nClasses,len(datapoints))) var = [] for j in range(nClasses): var.append(getGaussianPdf(params[j][0], params[j][1])) for j in range(len(datapoints)): p = [datapoints[j][0], datapoints[j][1]] for i in range(nClasses): responses[i,j] = (1/float(nClasses)) * var[i].pdf(p) responses = responses / np.sum(responses,axis=0) sum = 0 for i in range(nClasses): withinVariance = 0 for j in range(0, len(datapoints)-1): difference = responses[i,j+1] - responses[i,j] differenceSquared = math.pow(difference, 2) withinVariance += differenceSquared v = math.pow(np.std(responses[i]), 2) betweenVariance = math.pow(v,2) sum += (withinVariance/float(betweenVariance)) return sum
def get_nearest(eye, at, up, phis, thetas): """ returns phi and theta settings that most closely match current view """ #todo: derive it instead of this brute force search best_phi = None best_theta = None best_dist = None best_up = None dist1 = math.sqrt(sum(math.pow(eye[x]-at[x],2) for x in [0,1,2])) for t,p in ((x,y) for x in thetas for y in phis): theta_rad = (float(t)) / 180.0 * math.pi phi_rad = float(p) / 180.0 * math.pi pos = [ float(at[0]) - math.cos(phi_rad) * dist1 * math.cos(theta_rad), float(at[1]) + math.sin(phi_rad) * dist1 * math.cos(theta_rad), float(at[2]) + math.sin(theta_rad) * dist1 ] nup = [ + math.cos(phi_rad) * math.sin(theta_rad), - math.sin(phi_rad) * math.sin(theta_rad), + math.cos(theta_rad) ] dist = math.sqrt(sum(math.pow(eye[x]-pos[x],2) for x in [0,1,2])) updiff = math.sqrt(sum(math.pow(up[x]-nup[x],2) for x in [0,1,2])) if best_dist == None or (dist<best_dist and updiff<1.0): best_phi = p best_theta = t best_dist = dist best_up = updiff return best_phi, best_theta
def distances_per_degree(lat, a=SEMI_MAJOR_AXIS, inverse_flattening=INVERSE_FLATTENING): """ Returns a tuple containing arc distances in the units of the semi-major axis. The first is the distance along an arc of one degree at a constant latitude (lat). The second is the distance along an arc of one degree at a constant lng centered on the given lat. Arguments: lat - the latitude at which the distances apply a - the semi-major axis of the ellipsoid for the coordinate reference system inverse_flattening - the inverse of the ellipsoid's flattening parameter """ f = 1.0 / inverse_flattening e_squared = f * (2.0 - f) # e^2 = 2f - f^2 # N - radius of curvature in the prime vertical, (tangent to ellipsoid at latitude) # N(lat) = a/(1-e^2*sin^2(lat))^0.5 N = a / math.sqrt(1.0 - e_squared * (math.pow(math.sin(lat * math.pi / 180.0), 2.0))) # M - radius of curvature in the prime meridian, (tangent to ellipsoid at latitude) # M(lat) = a(1-e^2)/(1-e^2*sin^2(lat))^1.5 M = a * (1.0 - e_squared) / math.pow(1.0 - e_squared * math.pow(math.sin(lat * math.pi / 180.0), 2.0), 1.5) # longitude is irrelevant for the calculations to follow so simplify by using longitude = 0, so Y = 0 # X = Ncos(lat)cos(long). long = 0, so cos(long) = 1.0 X = N * math.cos(lat * math.pi / 180.0) * 1.0 lngdistanceperdegree = math.pi * X / 180.0 latdistanceperdegree = math.pi * M / 180.0 return (lngdistanceperdegree, latdistanceperdegree)
def simulate(): error_sum = 0 for i in range(0, 10000): X = np.random.normal(loc=0, scale=1) Y = np.random.normal(loc=0, scale=1) error_sum += math.sqrt(math.pow(X, 2) + math.pow(Y, 2)) print('Average Distance is:', error_sum / 10000)
def DeltaVz(z): """Calculates the density contrast of a virialised region S{Delta}V(z), assuming a S{Lambda}CDM-type flat cosmology. See, e.g., Bryan & Norman 1998 (ApJ, 495, 80). @type z: float @param z: redshift @rtype: float @return: density contrast of a virialised region at redshift z @note: If OMEGA_M0+OMEGA_L0 is not equal to 1, this routine exits and prints an error message to the console. """ OMEGA_K = 1.0 - OMEGA_M0 - OMEGA_L0 if OMEGA_K == 0.0: Omega_Mz = OmegaMz(z) deltaVz = (18.0 * math.pow(math.pi, 2) + 82.0 * (Omega_Mz - 1.0) - 39.0 * math.pow(Omega_Mz - 1, 2)) return deltaVz else: raise Exception("cosmology is NOT flat.")
def trajectoire_rotation(t, dcfg_traj, rotation_type, deriv) : t1 = dcfg_traj['t1'] if rotation_type == 'r1' : x_r = dcfg_traj['x_cr1'] y_r = dcfg_traj['y_cr1'] R = 1.0 / dcfg_traj['Rinv_sp3_1'] theta0 = dcfg_traj['theta0_r1'] angle = dcfg_traj['angle_r1'] if rotation_type == 'r2' : x_r = dcfg_traj['x_cr2'] y_r = dcfg_traj['y_cr2'] R = 1.0 / dcfg_traj['Rinv_sp3_2'] theta0 = dcfg_traj['theta0_r2'] angle = dcfg_traj['angle_r2'] theta = theta0 + (t * angle) / t1 if (deriv == 0) : x = x_r + R * cos(theta) y = y_r + R * sin(theta) if angle < (dcfg_traj['angle_step'] / 2.0) : angle = angle + dcfg_traj['angle_step'] * 0.1 if (deriv == 1) : x = R * (angle/t1)*(-sin(theta)) y = R * (angle/t1)*cos(theta) if (deriv == 2) : x = R * pow(angle/t1, 2)*(-cos(theta)) y = R * pow(angle/t1, 2)*(-sin(theta)) return [x, y]
def _compute_sse(screen, clusters, weights): idx_map = {} for i,v in enumerate(clusters): idx_map[v] = idx_map.get(v, []) idx_map[v].append(i) wss = 0 bss = 0 means = {} for cl, rec in idx_map.iteritems(): m = len(rec) if m > 1: dm = np.zeros((m * (m - 1)) // 2, dtype=np.double) k = 0 for i in xrange(0, m - 1): for j in xrange(i + 1, m): i_idx = rec[i] j_idx = rec[j] dm[k] = cockatoo.metric.distance(screen.cocktails[i_idx], screen.cocktails[j_idx], weights=weights) k = k + 1 mean = dm.mean() means[cl] = mean for i in xrange(0, k): wss += math.pow(dm[i] - mean, 2) mean_arr = np.array(means.values()) mean = mean_arr.mean() for cl, rec in idx_map.iteritems(): m = len(rec) if cl in means: c_mean = means[cl] bss += m * math.pow(c_mean-mean, 2) return (len(idx_map), wss, bss)
def RMSE(mat_predict, mat_true): sha_predict = mat_predict.shape sha_true = mat_true.shape if sha_true != sha_predict: print('error! yay!') return 0 summy = float(0.0) count = float(0.0) # set up the data frame for outputting predict_out = np.matrix([[0,0,0]]) # you only care about the non-null values of mat_true for i in xrange(0,numusers): for j in xrange(0,nummovies): if mat_true[i,j] != 0: count = count + 1 summy = summy + math.pow((mat_true[i,j] - mat_predict[i,j]),2) # add to the output matrix predict_out = np.vstack((predict_out,np.matrix([i+1,j+1,mat_predict.item(i,j)]))) # complete the equation RSME_value = math.pow(summy/count,0.5) # return it after deleting the first rwo etc predict_out = np.delete(predict_out,(0),axis = 0) return RSME_value, predict_out
def lpnorm(vec,p): # convert p to a double regardless p = p + 0.0 # get the dimensions of the vector j = vec.shape # we want 1xn, so if it's nx1, change it to 1xn vec = vec.flatten() # print(vec) # create a variable to sum up the elements summy = 0 # get loop stuff loopmax = max(j) # print('loopmax:') # print(loopmax) # loop through and sum for i in range(0,loopmax): # print('inloop:') jeff = vec.item(i) # print(jeff) summy = summy + math.pow(jeff,p) # print(summy) summy = math.pow(summy,(1/p)) return summy
def gradient(image, mask_type='sobel'): indice_mascara = { "sobelx":[[-1.0, 0.0, 1.0], [-2.0, 0.0, 2.0], [-1.0, 0.0, 1.0]], "sobely":[[1.0, 2.0, 1.0], [0.0, 0.0, 0.0], [-1.0, -2.0, -1.0]], "prewittx":[[-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0], [-1.0, 0.0, 1.0]], "prewitty":[[1.0, 1.0, 1.0], [0.0, 0.0, 0.0], [-1.0, -1.0, -1.0]] } pic_copy = (image.copy()).load() pic = image.load() kernelx = indice_mascara[mask_type+'x'] kernely = indice_mascara[mask_type+'y'] max_value = 0 for i in range(image.size[0]): for j in range(image.size[1]): gx, gy = (0.0, 0.0) kernel_len = len(kernelx[0]) kernel_pos = 0 for h in range(i-1, i+2): for l in range(j-1, j+2): if h >= 0 and l >= 0 and h < image.size[0] and l < image.size[1]: pixel = pic_copy[h, l] pixel = max(pixel)/len(pixel) gx += pixel*kernelx[int(kernel_pos/3)][kernel_pos%3] gy += pixel*kernely[int(kernel_pos/3)][kernel_pos%3] kernel_pos += 1 gradiente = int(math.sqrt(math.pow(gx, 2) + math.pow(gy, 2))) pic[i, j] = tuple([gradiente]*3) if gradiente > max_value: max_value = gradiente return max_value
def gridToGeodetic(self, north, east): """ Transformation from grid coordinates to geodetic coordinates. @param north (corresponds to X in RT 90 and N in SWEREF 99.) @param east (corresponds to Y in RT 90 and E in SWEREF 99.) @return (latitude, longitude) """ if (self._initialized == False): return None deg_to_rad = math.pi / 180 lambda_zero = self._central_meridian * deg_to_rad xi = (north - self._false_northing) / (self._scale * self._a_roof) eta = (east - self._false_easting) / (self._scale * self._a_roof) xi_prim = xi - \ self._delta1*math.sin(2.0*xi) * math.cosh(2.0*eta) - \ self._delta2*math.sin(4.0*xi) * math.cosh(4.0*eta) - \ self._delta3*math.sin(6.0*xi) * math.cosh(6.0*eta) - \ self._delta4*math.sin(8.0*xi) * math.cosh(8.0*eta) eta_prim = eta - \ self._delta1*math.cos(2.0*xi) * math.sinh(2.0*eta) - \ self._delta2*math.cos(4.0*xi) * math.sinh(4.0*eta) - \ self._delta3*math.cos(6.0*xi) * math.sinh(6.0*eta) - \ self._delta4*math.cos(8.0*xi) * math.sinh(8.0*eta) phi_star = math.asin(math.sin(xi_prim) / math.cosh(eta_prim)) delta_lambda = math.atan(math.sinh(eta_prim) / math.cos(xi_prim)) lon_radian = lambda_zero + delta_lambda lat_radian = phi_star + math.sin(phi_star) * math.cos(phi_star) * \ (self._Astar + \ self._Bstar*math.pow(math.sin(phi_star), 2) + \ self._Cstar*math.pow(math.sin(phi_star), 4) + \ self._Dstar*math.pow(math.sin(phi_star), 6)) lat = lat_radian * 180.0 / math.pi lon = lon_radian * 180.0 / math.pi return (lat, lon)
def pythag_pos_diff(objPosArray1,objPosArray2): #calculates the pythagorian position difference between two n-dimensional position arrays pythagSum=0 for l in range(len(objPosArray1)): pythagSum+=math.pow(objPosArray1[l]-objPosArray2[l],2) return math.pow(pythagSum,1.0/2.0)
def testFixedNonUniform(self): """Sets up the quantile summary op test as follows. Creates array dividing range [0, 1] to 1<<16 elements equally spaced with weight same as the value. """ dense_float_tensor_0 = constant_op.constant( [(1.0 * i) / math.pow(2.0, 16) for i in range(0, int(math.pow(2, 16)) + 1)]) example_weights = constant_op.constant( [(1.0 * i) / math.pow(2.0, 16) for i in range(0, int(math.pow(2, 16)) + 1)]) config = self._gen_config(0.1, 10) with self.test_session(): dense_buckets, _ = quantile_ops.quantile_buckets( [dense_float_tensor_0], [], [], [], example_weights=example_weights, dense_config=[config], sparse_config=[]) self.assertAllClose( [0] + [math.sqrt((i + 1.0) / 10) for i in range(0, 10)], dense_buckets[0].eval(), atol=0.1)
def get_close_matches(term, fields, fuzziness=0.4, key=None): import math import difflib def _ratio(a, b): return difflib.SequenceMatcher(None, a, b).ratio() term = term.lower() matches = [] for field in fields: fld = field if key is None else key(field) if term == fld: matches.append((field, 1.0)) else: name = fld.lower() r = _ratio(term, name) if name.startswith(term): r = math.pow(r, 0.3) elif term in name: r = math.pow(r, 0.5) if r >= (1.0 - fuzziness): matches.append((field, min(r, 0.99))) return sorted(matches, key=lambda x: -x[1])
def getPointDist(self, pt): assert(self.face is not None) # fist, get my position p = PoseStamped() p.header.frame_id = "base_link" p.header.stamp = rospy.Time.now() - rospy.Duration(0.5) p.pose.position.x = 0 p.pose.position.y = 0 p.pose.position.z = 0 p.pose.orientation.x = 0 p.pose.orientation.y = 0 p.pose.orientation.z = 0 p.pose.orientation.w = 1 try: self._tf.waitForTransform(p.header.frame_id, self._robot_frame, p.header.stamp, rospy.Duration(2)) p = self._tf.transformPose(self._robot_frame, p) except: rospy.logerr("TF error!") return None return sqrt(pow(p.pose.position.x - pt.point.x, 2) + pow(p.pose.position.y - pt.point.y, 2) + pow(p.pose.position.z - pt.point.z, 2))
def test_math_functions(self): df = self.sc.parallelize([Row(a=i, b=2 * i) for i in range(10)]).toDF() from pyspark.sql import functions import math def get_values(l): return [j[0] for j in l] def assert_close(a, b): c = get_values(b) diff = [abs(v - c[k]) < 1e-6 for k, v in enumerate(a)] return sum(diff) == len(a) assert_close([math.cos(i) for i in range(10)], df.select(functions.cos(df.a)).collect()) assert_close([math.cos(i) for i in range(10)], df.select(functions.cos("a")).collect()) assert_close([math.sin(i) for i in range(10)], df.select(functions.sin(df.a)).collect()) assert_close([math.sin(i) for i in range(10)], df.select(functions.sin(df['a'])).collect()) assert_close([math.pow(i, 2 * i) for i in range(10)], df.select(functions.pow(df.a, df.b)).collect()) assert_close([math.pow(i, 2) for i in range(10)], df.select(functions.pow(df.a, 2)).collect()) assert_close([math.pow(i, 2) for i in range(10)], df.select(functions.pow(df.a, 2.0)).collect()) assert_close([math.hypot(i, 2 * i) for i in range(10)], df.select(functions.hypot(df.a, df.b)).collect())
def checkio(strdata): strdata = strdata.lower() alpha = [ chr(x) for x in range( ord('a'), ord('z')+1) ] for i in range(2, 36): radix = i bPassCheck1 = True for j in range(0, len(strdata)): if strdata[j].isdigit() and int( strdata[j] ) < radix: continue elif strdata[j].isalpha() and (10 + ord(strdata[j]) -ord('a') )< radix: continue else: bPassCheck1 = False continue if bPassCheck1 == True: mysum = 0 for k in range(0,len(strdata)): if strdata[k].isdigit(): mysum = mysum + math.pow( radix, len(strdata)-k-1)*int(strdata[k]) elif strdata[k].isalpha(): mysum = mysum + math.pow( radix, len(strdata)-k-1)*int(ord(strdata[k])-ord('a')+10) if mysum%(radix-1) == 0: print(radix) return radix print(0) return 0
def update(self,tNow,lon_int,lat_int,t,vel,h): # Compute how long it's been since the system updated dtReal = tNow - self.tLast # rejection criteria if self.gpsState.ready and (abs( 1.0e-7*float(lon_int)-self.gpsState.lon ) > 0.01 or abs( 1.0e-7*float(lat_int)-self.gpsState.lat ) > 0.01): self.tLast = tNow return if self.gpsState.ready==False: self.gpsState.update(lon_int,lat_int,t,vel,h) # initialize the filter xk0 = np.array([self.gpsState.x,self.gpsState.y,0.0,0.0,0.0,0.0]) # initial state Pk0 = np.diag([math.pow(filter_dynamics.sigma_gps,2.0),math.pow(filter_dynamics.sigma_gps,2.0),1.0,1.0,1.0,1.0]) # initial covariance self.EKF.init_P(xk0,Pk0,t) else: # update the raw GPS object self.gpsState.update(lon_int,lat_int,t,vel,h) # test that dt is not negative dt = t-self.EKF.t if dt>0 and dt<10.0*max([dtReal,1.0]): # propagate the filter to the current time self.EKF.propagateOde(dt) # update the filter self.EKF.update(t,np.array([self.gpsState.x,self.gpsState.y]),filter_dynamics.measurement,filter_dynamics.measurementGradient,filter_dynamics.Rkin) else: print("Reject for back in time: dt = %g, dtReal=%g" % (dt,dtReal)) pass # if the filter state matches the reading well enough, use it ''' if math.sqrt( np.sum(np.power(self.EKF.xhat[0:2]-np.array([self.gpsState.x,self.gpsState.y]),2.0)) ) < 10.0: # copy the filter state to local self.filterState[0:2] = self.EKF.xhat[0:2].copy() self.filterState[2] = np.sqrt( np.sum(np.power(self.EKF.xhat[2:4],2.0)) ) # If we're moving, use the velocity to approximate the heading; else, use the GPS heading if self.filterState[2] > 1.0: self.filterState[3] = np.arctan2( self.EKF.xhat[3],self.EKF.xhat[2] ) else: self.filterState[3] = self.gpsState.hdg else: self.filterState[0] = self.gpsState.x self.filterState[1] = self.gpsState.y self.filterState[2] = self.gpsState.v self.filterState[3] = self.gpsState.hdg ''' self.filterState[0] = self.gpsState.x self.filterState[1] = self.gpsState.y self.filterState[2] = self.gpsState.v self.filterState[3] = self.gpsState.hdg # Debug test print of state #print("%12.7g,%8.4g,%8.4g" % (tNow,self.filterState[2],self.filterState[3])) # reset the filter if things look bad # are the covariance diagonals zero or nan? if (self.EKF.Pk[0,0]==0.0) or (self.EKF.Pk[1,1]==0.0) or (self.EKF.Pk[2,2]==0.0) or (self.EKF.Pk[3,3]==0.0) or (self.EKF.Pk[4,4]==0.0) or (self.EKF.Pk[5,5]==0.0) or (np.any(np.isnan(np.diag(self.EKF.Pk)))): # initialize the filter xk0 = np.array([self.gpsState.x,self.gpsState.y,0.0,0.0,0.0,0.0]) # initial state Pk0 = np.diag([math.pow(filter_dynamics.sigma_gps,2.0),math.pow(filter_dynamics.sigma_gps,2.0),1.0,1.0,1.0,1.0]) # initial covariance self.EKF.init_P(xk0,Pk0,t) # call the log self.logFun(t,tNow) # update the time tracker self.tLast = tNow
def vect(_x, _y, _z): return int( math.sqrt( math.pow(_x - cX, 2 * x_mult) + math.pow(_y - cY, 2 * y_mult) + math.pow(_z - cZ, 2 * z_mult)))
# Введіть з клавіатури п'ять цілочисельних елементів масиву X. Виведіть на # кран значення коріння і квадратів кожного з елементів масиву. #licherep Artem import math import numpy as np a = [] for i in range(5): b = [] b.append(int(input("input: "))) #ввод a.append(b) c = np.array(a) for i in range(5): print("квадратний корінь з числа: ", a[i], "буде:", math.sqrt(c[i])) print(" ") for i in range(5): print("квадоат з числа:", a[i], "буде:", math.pow(c[i], 2))
def euclidean_distance(self, goal_pose): """Euclidean distance between current pose and the goal.""" return sqrt(pow((goal_pose.x - self.pose.x), 2) + pow((goal_pose.y - self.pose.y), 2))
def isCollision(enemyX, enemyY, bulletX, bulletY): distance = math.sqrt((math.pow(enemyX - bulletX, 2)) + (math.pow(enemyY - bulletY, 2))) if distance < 27: return True else: return False
def load_data(path="../data/transfer/", dataset="chn", preserve_order=1): """Load citation network dataset (cora only for now)""" print('Loading {} dataset...'.format(dataset)) idx_features_labels = np.genfromtxt("{}{}.content".format(path, dataset), dtype=np.dtype(str)) features = sp.csr_matrix(idx_features_labels[:, 1:-1], dtype=np.float32) labels = encode_onehot( idx_features_labels[:, -1]) # labels are at the end of each line #f = open("{}{}.multilabel".format(path, dataset)) #multilabels =np.genfromtxt("{}{}.multilabel".format(path, dataset), # dtype=np.dtype(str)) # build graph idx = np.array(idx_features_labels[:, 0], dtype=np.int32) idx_map = {j: i for i, j in enumerate(idx)} edges_unordered = np.genfromtxt("{}{}.cites".format(path, dataset), dtype=np.int32) edges = np.array(list(map(idx_map.get, edges_unordered.flatten())), dtype=np.int32).reshape(edges_unordered.shape) adj = sp.coo_matrix((np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])), shape=(labels.shape[0], labels.shape[0]), dtype=np.float32) # build symmetric adjacency matrix adj = sp.coo_matrix(adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)) for item in adj.__dict__.items(): print(item) print(adj.col) edge_ret = [] edge_weight = [] node_weight = [0.0 for i in range(0, len(idx))] if preserve_order == 1: adj_pres = adj else: adj_pres = sp.coo_matrix(adj**2) # sampling weight for i in range(0, len(adj.data)): edge_ret.append((adj_pres.row[i], adj_pres.col[i])) edge_weight.append(float(adj_pres.data[i])) node_weight[adj.row[i]] += adj.data[i] features = normalize(features) adj = adj + sp.eye(adj.shape[0]) D = sp.coo_matrix([[ 1.0 / math.sqrt(node_weight[j]) if j == i else 0 for j in range(len(idx)) ] for i in range(len(idx))]) adj = D * adj * D idx_train = range(140) idx_val = range(200, 500) idx_test = range(500, 1500) features = torch.FloatTensor(np.array(features.todense())) labels = torch.LongTensor(np.where(labels)[1]) adj = sparse_mx_to_torch_sparse_tensor(adj) idx_train = torch.LongTensor(idx_train) idx_val = torch.LongTensor(idx_val) idx_test = torch.LongTensor(idx_test) for i in range(0, len(node_weight)): node_weight[i] = math.pow(node_weight[i], 0.75) return adj, features, labels, idx_train, idx_val, idx_test, edge_ret, torch.tensor( edge_weight), torch.tensor(node_weight) #, multilabels
def parse_order(self, order, market=None): zeroExOrder = self.safe_value(order, 'zeroExOrder') id = self.safe_string(order, 'orderHash') if (id is None) and(zeroExOrder is not None): id = self.safe_string(zeroExOrder, 'orderHash') side = self.safe_string(order, 'side') type = self.safe_string(order, 'type') # injected from outside timestamp = self.safe_integer(order, 'creationTimestamp') if timestamp != 'None': timestamp = int(timestamp / 1000) symbol = None baseId = self.safe_string(order, 'baseTokenAddress') quoteId = self.safe_string(order, 'quoteTokenAddress') marketId = None if baseId is not None and quoteId is not None: marketId = baseId + '/' + quoteId market = self.safe_value(self.markets_by_id, marketId, market) base = None if market is not None: symbol = market['symbol'] base = market['base'] baseDecimals = self.safe_integer(self.options['decimals'], base, 18) price = self.safe_float(order, 'price') filledAmount = self.fromWei(self.safe_string(order, 'filledAmount'), 'ether', baseDecimals) settledAmount = self.fromWei(self.safe_string(order, 'settledAmount'), 'ether', baseDecimals) confirmedAmount = self.fromWei(self.safe_string(order, 'confirmedAmount'), 'ether', baseDecimals) failedAmount = self.fromWei(self.safe_string(order, 'failedAmount'), 'ether', baseDecimals) deadAmount = self.fromWei(self.safe_string(order, 'deadAmount'), 'ether', baseDecimals) prunedAmount = self.fromWei(self.safe_string(order, 'prunedAmount'), 'ether', baseDecimals) amount = self.fromWei(self.safe_string(order, 'initialAmount'), 'ether', baseDecimals) filled = self.sum(filledAmount, settledAmount, confirmedAmount) remaining = None lastTradeTimestamp = None timeline = self.safe_value(order, 'timeline') trades = None status = None if timeline is not None: numEvents = len(timeline) if numEvents > 0: timelineEventsGroupedByAction = self.group_by(timeline, 'action') if 'error' in timelineEventsGroupedByAction: status = 'failed' if 'filled' in timelineEventsGroupedByAction: fillEvents = self.safe_value(timelineEventsGroupedByAction, 'filled') numFillEvents = len(fillEvents) lastTradeTimestamp = self.safe_integer(fillEvents[numFillEvents - 1], 'timestamp') lastTradeTimestamp = lastTradeTimestamp if (lastTradeTimestamp is not None) else lastTradeTimestamp trades = [] for i in range(0, numFillEvents): trade = self.parse_trade(self.extend(fillEvents[i], { 'price': price, }), market) trades.append(self.extend(trade, { 'order': id, 'type': type, 'side': side, })) cost = None if filled is not None: if remaining is None: if amount is not None: remaining = amount - filled if price is not None: cost = filled * price fee = None feeCost = self.safe_string(order, 'feeAmount') if feeCost is not None: feeOption = self.safe_string(order, 'feeOption') feeCurrency = None if feeOption == 'feeInNative': if market is not None: feeCurrency = market['base'] elif feeOption == 'feeInZRX': feeCurrency = 'ZRX' else: raise NotSupported(self.id + ' encountered an unsupported order fee option: ' + feeOption) feeDecimals = self.safe_integer(self.options['decimals'], feeCurrency, 18) fee = { 'cost': self.fromWei(feeCost, 'ether', feeDecimals), 'currency': feeCurrency, } amountPrecision = market['precision']['amount'] if market else 8 if remaining is not None: if status is None: status = 'open' rest = remaining - failedAmount - deadAmount - prunedAmount if rest < math.pow(10, -amountPrecision): status = 'canceled' if (filled < amount) else 'closed' result = { 'info': order, 'id': id, 'symbol': symbol, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'lastTradeTimestamp': lastTradeTimestamp, 'type': type, 'side': side, 'price': price, 'cost': cost, 'amount': amount, 'remaining': remaining, 'filled': filled, 'status': status, 'fee': fee, 'trades': trades, } return result
def iscollision(gloveX, gloveY, ballX, ballY): distance = math.sqrt((math.pow(gloveX - ballX, 2)) + (math.pow(gloveY - ballY, 2))) if distance < 32: return True else: return False
data_s = de.Demode(QAM, symbol) # 초기 심볼 위치 for snr in range(SNR): symbol_y = sym.Addnoise(snr, symbol) # 초기 심볼 + 노이즈 # 초기화 부분 position = np.zeros(symbol_num, int) # 심볼의 사분면 위치를 담을 배열 rsc_TakeCenter = [[0] * 4 for i in range(3)] start = timeit.default_timer() # Dist 부분 for i in range(symbol_num): # dist 거리 재기 for j in range(4): part_Real = math.pow(symbol_y[i].real - init_center[j].real, 2) part_Imag = math.pow(symbol_y[i].imag - init_center[j].imag, 2) dist[j][i] = math.sqrt(part_Real + part_Imag) stop = timeit.default_timer() for i in range(symbol_num): # mindist 부분 - 사분면을 구함 temp = 0 for j in range(4): if j == 0: temp = dist[j][i] elif temp > dist[j][i]: temp = dist[j][i] for k in range(4): if dist[k][i] == temp: position[i] = k
Give me details of archival storage What is the amount of archived data ''' LEX_RESULT = { 'dialogAction': { 'type': 'Close', 'fulfillmentState': 'Fulfilled', 'message': { 'contentType': 'PlainText', # 'content': '%s' <--- This is filled in the end } } } TB = math.pow(10, 12) GB = math.pow(10, 9) MB = math.pow(10, 6) PRECISION = 1 ENDPOINT_ARCHIVAL_STORAGE = ( 'https://{0}/api/internal/stats/cloud_storage' ) def human_readable_size(bytes): tb = None gb = None mb = None bytes = int(bytes) tb = round(bytes / TB, PRECISION) if not tb:
def convert_mb(kb, unit): UNITS = {"B": -2, "KB": -1, "MB": 0, "GB": 1, "TB": 2} assert unit in UNITS, ("%s not a valid unit, valid units are %s." % (unit, list(UNITS.keys()))) return int(old_div(float(kb), float(math.pow(1024, UNITS[unit]))))
def binomial_phi_inv(d, p, x): return (math.pow(x, 1/d) + p-1) / p
def d2(c1, vec): #get distance return math.pow(euclidean_distances([c1], [vec]),2)
def isCollison(enemyx, enemyy, bulletx, bullety): res = math.sqrt(math.pow(bulletx - enemyx, 2) + math.pow(bullety - enemyy, 2)) if res < 27: return True else: return False
def Ri(anchorNode): addsum = 0 for i in range(len(anchorNode)): addsum += math.pow(anchorNode.coordinate[i], 2) return addsum
def isCollision(obstacleX, obstacleY, playerX, playerY): distance = math.sqrt((math.pow(obstacleX - playerX, 2)) + (math.pow(obstacleY - playerY, 2))) if distance < 28: return True else: return False
# -*- coding: utf-8 -*- #Faça um programa que leia o comprimento do cateto oposto e do cateto adjacente de um triângulo, # calcule e mostre o comprimento da hipotenusa from math import sqrt, pow print(" Calculo de Hipotenusa") print("-----------------------------------") a = float(input("Digite a medida do lado triângulo Retangulo: ")) b = float(input("Digite a medida do lado triângulo Retangulo: ")) hipotenusa = pow(a, 2) + pow(b, 2) hipotenusa = float(sqrt(hipotenusa)) input("A hipotenusa é {:.2f}".format(hipotenusa))
def euclideanDistance(vect1, vect2): sum = 0 for cont in vect1: sum += math.pow((vect1[cont] - vect2[cont]), 2) sum = math.sqrt(sum) return sum
import math Numero = int(input("Digite ")) if Numero > 0: print("Esse numero é PAR: {:.2f} ".format(math.sqrt(Numero))) else: print("Numero Negativo: {:.2f}".format(math.pow(Numero,2)))
def rgb2hsi(image): img = np.copy(image).astype(np.float) img = img/255 red = img[:,:,0] green = img[:,:,1] blue = img[:,:,2] theta = np.zeros((img.shape[0], img.shape[1])) H = np.zeros((img.shape[0], img.shape[1])) for y in range(img.shape[0]): for x in range(img.shape[1]): if(red[y, x] == green[y, x] == blue[y, x]): theta[y, x] = 0 H[y, x] = theta[y, x] else: theta[y, x] = math.acos((0.5 * ((red[y, x] - green[y, x]) + (red[y, x] - blue[y, x]))) / math.pow((math.pow((red[y, x] - green[y, x]), 2) + ((red[y, x] - blue[y, x]) * (green[y, x] - blue[y, x]))), 0.5)) theta[y, x] = np.degrees(theta[y, x]) if blue[y, x] > green[y, x]: H[y, x] = 360 - theta[y, x] else: H[y, x] = theta[y, x] S = np.zeros((img.shape[0], img.shape[1])) for y in range(img.shape[0]): for x in range(img.shape[1]): if(red[y, x] == green[y, x] == blue[y, x] == 0): S[y, x] = 1 else: S[y, x] = 1 - ((3/(red[y, x] + green[y, x] + blue[y, x])) * min(red[y, x], min(green[y, x], blue[y, x]))) I = (red + green + blue)/3 return np.dstack((H, S, I))
def CalcX(lista): x = 0 for j in range(len(lista)): x += lista[j] * math.pow(2, -j - 1) return x
def f(self, count): if count < 100: ratio = count / 100.0 return math.pow(ratio, 0.75) return 1.0
def bin2dec(bin_list): return sum([bin_list[i]*pow(2,len(bin_list)-i-1) for i in range(len(bin_list)-1,-1,-1)])
def varianza(lista): sum = 0.0 for i in range(0, len(lista)): sum = sum + math.pow((lista[i] - media(lista)), 2) return sum / (len(lista))
def getSize(self): size = self.end - self.start return optivis.geometry.Coordinates( math.sqrt(math.pow(size.x, 2) + math.pow(size.y, 2)), 0)
def pack_texture(self, context): obj = bpy.context.active_object name = material_prefix + obj.name if obj.mode != 'OBJECT': bpy.ops.object.mode_set(mode='OBJECT') # Determine size size_pixel = 8 size_square = math.ceil( math.sqrt(context.scene.texToolsSettings.color_ID_count)) size_image = size_square * size_pixel size_image_pow = int(math.pow(2, math.ceil(math.log(size_image, 2)))) # Maximize pixel size size_pixel = math.floor(size_image_pow / size_square) print("{0} colors = {1} x {1} = ({2}pix) {3} x {3} | {4} x {4}".format( context.scene.texToolsSettings.color_ID_count, size_square, size_pixel, size_image, size_image_pow)) # Create image image = bpy.data.images.new(name, width=size_image_pow, height=size_image_pow) pixels = [None] * size_image_pow * size_image_pow # Black pixels for x in range(size_image_pow): for y in range(size_image_pow): pixels[(y * size_image_pow) + x] = [0, 0, 0, 1] # Pixels for c in range(context.scene.texToolsSettings.color_ID_count): x = c % size_square y = math.floor(c / size_square) color = utilities_color.get_color(c).copy() for i in range(3): color[i] = pow(color[i], 1.0 / gamma) for sx in range(size_pixel): for sy in range(size_pixel): _x = x * size_pixel + sx _y = y * size_pixel + sy pixels[(_y * size_image_pow) + _x] = [color[0], color[1], color[2], 1] # flatten list & assign pixels pixels = [chan for px in pixels for chan in px] image.pixels = pixels # Set background image for area in bpy.context.screen.areas: if area.type == 'IMAGE_EDITOR': area.spaces[0].image = image # Edit mesh bpy.ops.object.mode_set(mode='EDIT') bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='FACE') bpy.ops.mesh.select_all(action='SELECT') # bpy.ops.uv.smart_project(angle_limit=1) bpy.ops.uv.unwrap(method='ANGLE_BASED', margin=0.0078) bm = bmesh.from_edit_mesh(bpy.context.active_object.data) uv_layers = bm.loops.layers.uv.verify() for face in bm.faces: index = face.material_index # Get UV coordinates for index x = index % size_square y = math.floor(index / size_square) x *= (size_pixel / size_image_pow) y *= (size_pixel / size_image_pow) x += size_pixel / size_image_pow / 2 y += size_pixel / size_image_pow / 2 for loop in face.loops: loop[uv_layers].uv = (x, y) # Remove Slots & add one bpy.ops.object.mode_set(mode='OBJECT') bpy.ops.uv.textools_color_clear() bpy.ops.object.material_slot_add() #Create material with image obj.material_slots[0].material = utilities_bake.get_image_material(image) #Display UVs bpy.ops.object.mode_set(mode='EDIT') # Switch textured shading for area in bpy.context.screen.areas: if area.type == 'VIEW_3D': for space in area.spaces: if space.type == 'VIEW_3D': space.shading.type = 'MATERIAL' bpy.ops.ui.textools_popup( 'INVOKE_DEFAULT', message="Packed texture with {} color IDs".format( context.scene.texToolsSettings.color_ID_count))
def calc_distance(a, b): return math.sqrt(math.pow(b.x - a.x, 2) + math.pow(b.y - a.y, 2) + math.pow(b.z - a.z, 2))
def mint(filename, contract, w3): url = "https://api.pinata.cloud/pinning/pinFileToIPFS" headers = { "pinata_api_key": os.getenv("PINATA_API_KEY"), "pinata_secret_api_key": os.getenv("PINATA_SECRET_API_KEY"), } files = {"file": open(filename, "rb")} response = requests.post(url, files=files, headers=headers, verify=False) asset_ipfs_hash = json.loads(response.content)["IpfsHash"] token_meta = { "asset_ipfs_hash": asset_ipfs_hash, "convenience_asset_url": f"https://ipfs.io/ipfs/{asset_ipfs_hash}", } token_meta_bytes = json.dumps(token_meta, indent=2).encode("utf-8") files = {"file": token_meta_bytes} response = requests.post(url, files=files, headers=headers, verify=False) json_ipfs_hash = json.loads(response.content)["IpfsHash"] token_uri = f"https://ipfs.io/ipfs/{asset_ipfs_hash}" metadata_uri = f"https://ipfs.io/ipfs/{json_ipfs_hash}" BLOCK_SIZE = 65536 content_sha = sha256() with open(filename, "rb") as f: fb = f.read(BLOCK_SIZE) while len(fb) > 0: content_sha.update(fb) fb = f.read(BLOCK_SIZE) content_sha = content_sha.digest() metadata_sha = sha256(json.dumps(token_meta).encode("utf-8")).digest() st.text(content_sha) st.text("\n") st.text(metadata_sha) share = math.pow(10, 18) share = int(share * 100) zora_data = { "tokenURI": token_uri, "metadataURI": metadata_uri, "contentHash": content_sha, "metadataHash": metadata_sha, } zora_bidshares = { "prevOwner": { "value": 0 }, "creator": { "value": 0 }, "owner": { "value": share }, } gas_estimate = contract.functions.mint( data=zora_data, bidShares=zora_bidshares).estimateGas() tx_hash = contract.functions.mint(data=zora_data, bidShares=zora_bidshares).transact() receipt = w3.eth.waitForTransactionReceipt(tx_hash) st.text(token_uri) st.text("\n") st.text(metadata_uri) st.text(zora_data) st.text("\n") st.text(zora_bidshares) st.text(gas_estimate) st.text("\n") st.text(tx_hash) st.text("\n") st.text(receipt)
if level==3 or level ==4: virusX[i] += virusX_change[i] virusY[i] += virusY_change[i] if virusX[i] <= -20: virusX_change[i] = 4 elif virusX[i] >= 736: virusX_change[i] = -4 if virusY[i] <= 0: virusY_change[i] = 2 elif virusY[i] >= 480: virusY[i] = 0 virus(virusX[i],virusY[i],i) #level 3 boss fight if level == 3 and in_boss_fight == True: if (math.sqrt(math.pow(virus_bossX+270 - bullet2X, 2) + (math.pow(virus_bossY+240 - bullet2Y, 2))))< 120: score_value += 1 bullet2Y = 480 bullet2_state = "ready" if (math.sqrt(math.pow(virus_bossX+270 - playerX, 2) + (math.pow(virus_bossY+240 - playerY, 2))))< 120: life_count -= 1 if life_count == 0: gameover() playerY = playerY+100 for i in range(num_of_enemies): #移動迷你病毒 mini_virusX[i] += mini_virusX_change[i] mini_virusY[i] += mini_virusY_change[i] if mini_virusX[i] <= -50: mini_virusX_change[i] = random.randint(0, 11) mini_virusY_change[i] = 4
def run_first_length(img, row): global is_slope_1_bigger global is_slope_2_bigger global steps_delta global bright_pixels_delta global dark_pixels_delta global pixels_delta global img_size global extant_val global distance_ratio global image_mean # image1=io.imread(image_path) # plt.imshow(image1) # df=pd.read_csv(csv_path) # df_new=df[df.name_id.eq(int(image_number))] # table = df_new.drop(columns=['name_id']).to_numpy() # #print(table) # # list=list(df_new) # # print(list) # i=0 # for row in table: #print(row) x1_vals = [row[0], row[2]] #print(x1_vals) y1_vals = [row[1], row[3]] x2_vals = [row[2], row[4]] y2_vals = [row[3], row[5]] x3_vals = [row[4], row[6]] y3_vals = [row[5], row[7]] x4_vals = [row[6], row[0]] y4_vals = [row[7], row[1]] # plt.plot(row[0], row[1], 'r.') # plt.plot(row[2], row[3], 'b.') # plt.plot(row[6], row[7], 'g.') # plt.plot(row[4], row[5], 'c.') dy1 = row[7] - row[1] dx1 = row[6] - row[0] dy2 = row[3] - row[1] dx2 = row[2] - row[0] distance1 = math.sqrt(math.pow(dx1, 2) + math.pow(dy1, 2)) try: angle1 = dy1 / dx1 except: return (45, 45) distance2 = math.sqrt(math.pow(dx2, 2) + math.pow(dy2, 2)) try: angle2 = dy2 / dx2 except: return (45, 45) if distance1 > distance2: car_len_slope = angle1 car_width_slope = angle2 car_len = distance1 car_width = distance2 else: car_len_slope = angle2 car_width_slope = angle1 car_len = distance2 car_width = distance1 middlex = row[8] middley = row[9] # plt.plot(middlex, middley , 'g.') #image = Image.open(image_path) image = img.convert('L') pixels = image.load() # print("pixels matrix is: ", pixels) reference_pixel = pixels_mean(pixels, middlex, middley, car_width_slope) stats = ImageStat.Stat(image).mean stats2 = ImageStat.Stat(image).median image_mean = stats2 # # print("function mean return value: ", mean(pixels, middlex, middley, 10)) # # img = np.array(image) # # img = img_as_float(img) # print("the average value of all pixels is: ", stats) # print("the median value of all pixels is: ", stats2) #print("the width slop is: ", car_width_slope, " the len slope is: ", car_len_slope) # print("the middle pixel value is: ", reference_pixel) length_edges, pass_bbox_l = find_roof_edges(middlex, middley, reference_pixel, car_len_slope, car_width_slope, pixels, row) # print("the values after going through the length is: ", length_edges) tmp_y = (length_edges[0][1] + length_edges[1][1]) / 2 tmp_x = (length_edges[0][0] + length_edges[1][0]) / 2 # plt.plot(tmp_x, tmp_y, 'r.') if (length_edges[0][2] > reference_pixel and length_edges[1][2] < reference_pixel): if not pass_bbox_l[0]: repeat1, pass_bbox = find_roof_edges(length_edges[0][0], length_edges[0][1], length_edges[0][2], car_len_slope, car_width_slope, pixels, row) else: repeat1 = length_edges if not pass_bbox_l[1]: repeat2, pass_bbox = find_roof_edges(length_edges[1][0], length_edges[1][1], length_edges[1][2] + 13, car_len_slope, car_width_slope, pixels, row) else: repeat2 = length_edges if repeat1[0][2] > reference_pixel + 45: repeat3, pass_bbox = find_roof_edges(repeat1[0][0], repeat1[0][1], repeat1[0][2], car_len_slope, car_width_slope, pixels, row) tmp_y = (repeat3[0][1] + repeat2[1][1]) / 2 tmp_x = (repeat3[0][0] + repeat2[1][0]) / 2 # print("values after fixing the length repeat3: ", repeat3) else: tmp_y = (repeat1[0][1] + repeat2[1][1]) / 2 tmp_x = (repeat1[0][0] + repeat2[1][0]) / 2 elif length_edges[0][2] < reference_pixel and length_edges[1][ 2] > reference_pixel: if not pass_bbox_l[0]: repeat1, pass_bbox = find_roof_edges(length_edges[0][0], length_edges[0][1], length_edges[0][2], car_len_slope, car_width_slope, pixels, row) else: repeat1 = length_edges if not pass_bbox_l[1]: repeat2, pass_bbox = find_roof_edges(length_edges[1][0], length_edges[1][1], length_edges[1][2], car_len_slope, car_width_slope, pixels, row) else: repeat2 = length_edges if repeat2[1][2] > reference_pixel + 45: repeat3, _ = find_roof_edges(repeat2[1][0], repeat2[1][1], repeat2[1][2], car_len_slope, car_width_slope, pixels, row) # print("12222312312312312321321312", repeat3[1][1]) tmp_y = (repeat3[1][1] + repeat1[0][1]) / 2 tmp_x = (repeat3[1][0] + repeat1[0][0]) / 2 # print("values after fixing the length repeat3: ", repeat3) # print("the tmp points are ", (tmp_x, tmp_y)) else: tmp_y = (repeat1[0][1] + repeat2[1][1]) / 2 tmp_x = (repeat1[0][0] + repeat2[1][0]) / 2 # print("values after fixing the length repeat1: ", repeat1) # print("values after fixing the length repeat2: ", repeat2) #=========================================================================================== # elif length_edges[0][2] > reference_pixel and length_edges[1][2] > reference_pixel: # if not pass_bbox_l[0]: repeat1, pass_bbox = find_roof_edges(length_edges[0][0], length_edges[0][1], length_edges[0][2], car_len_slope, car_width_slope) # else: repeat1 = length_edges # if not pass_bbox_l[1]: repeat2, pass_bbox = find_roof_edges(length_edges[1][0], length_edges[1][1], length_edges[1][2], car_len_slope, car_width_slope) # else: repeat2 = length_edges # # tmp_y = (repeat1[0][1] + repeat2[1][1]) / 2 # tmp_x = (repeat1[0][0] + repeat2[1][0]) / 2 # # print("values after fixing the length repeat1: ", repeat1) # print("values after fixing the length repeat2: ", repeat2) #============================================================== # print ("the points now are ", (tmp_x, tmp_y)) new_ref_pixel = pixels_mean(pixels, tmp_x, tmp_y, car_len_slope) width_edges, pass_bbox_w = find_roof_edges(tmp_x, tmp_y, new_ref_pixel, car_width_slope, car_len_slope, pixels, row) # print( # "=======================================================================================" # ) # print("values after going on the width of the car: ", width_edges, pass_bbox_w) # print("======================================================================================") # final_slope = (width_edges[1][1]-row[1])/(width_edges[1][0]-row[0]) # print("the final slope is: ", final_slope) # print(row[0],row[1]) # print(row[2],row[3]) # print(row[6],row[7]) if width_edges[0][2] > new_ref_pixel and width_edges[1][2] < new_ref_pixel: if pass_bbox_w[0] == 0: repeat1, pass_bbox = find_roof_edges(width_edges[0][0], width_edges[0][1], width_edges[0][2], car_width_slope, car_len_slope, pixels, row) else: repeat1 = width_edges if pass_bbox_w[1] == 0: repeat2, pass_bbox = find_roof_edges(width_edges[1][0], width_edges[1][1], width_edges[1][2], car_width_slope, car_len_slope, pixels, row) else: repeat2 = width_edges desired_y = (repeat1[0][1] + repeat2[1][1]) / 2 desired_x = (repeat1[0][0] + repeat2[1][0]) / 2 # print("after fixing the width: ", repeat1, pass_bbox_w) # print("after fixing the width: ", repeat2, pass_bbox_w) if repeat1[0][2] > new_ref_pixel + 45: repeat3, pass_bbox = find_roof_edges(repeat1[0][0], repeat1[0][1], repeat1[0][2], car_width_slope, car_len_slope, pixels, row) desired_y = (repeat3[0][1] + repeat2[1][1]) / 2 desired_x = (repeat3[0][0] + repeat2[1][0]) / 2 # print("values after fixing the width repeat3: ", repeat3) else: desired_y = (repeat1[0][1] + repeat2[1][1]) / 2 desired_x = (repeat1[0][0] + repeat2[1][0]) / 2 # print("values after fixing the width repeat1: ", repeat1) # print("values after fixing the width repeat2: ", repeat2) elif (width_edges[0][2] < new_ref_pixel and width_edges[1][2] > new_ref_pixel): if pass_bbox_w[0] == 0: repeat1, pass_bbox = find_roof_edges(width_edges[0][0], width_edges[0][1], width_edges[0][2], car_width_slope, car_len_slope, pixels, row) else: repeat1 = width_edges if pass_bbox_w[1] == 0: repeat2, pass_bbox = find_roof_edges(width_edges[1][0], width_edges[1][1], width_edges[1][2], car_width_slope, car_len_slope, pixels, row) else: repeat2 = width_edges if repeat2[1][2] > new_ref_pixel + 45: repeat3, pass_bbox = find_roof_edges(repeat2[1][0], repeat2[1][1], repeat2[1][2], car_width_slope, car_len_slope, pixels, row) desired_y = (repeat3[1][1] + repeat1[0][1]) / 2 desired_x = (repeat3[1][0] + repeat1[0][0]) / 2 # print("values after fixing the width repeat3: ", repeat3) else: desired_y = (repeat1[0][1] + repeat2[1][1]) / 2 desired_x = (repeat1[0][0] + repeat2[1][0]) / 2 # print("values after fixing the width repeat1: ", repeat1) # print("values after fixing the width repeat2: ", repeat2) else: desired_x = (width_edges[0][0] + width_edges[1][0]) / 2 desired_y = (width_edges[0][1] + width_edges[1][1]) / 2 # print(desired_x, desired_y) # plt.plot(desired_x, desired_y, 'y.') #plt.imshow(image, cmap='gray') #plt.show() return desired_x, desired_y
def generateCity(self, *args): map_file = cmds.textField(self.widgets["osmFileTextField"], q = True, fi = True) winds_file = cmds.textField(self.widgets["wrfFileTextField"], q = True, fi = True) heights_file = cmds.textField(self.widgets["demFileTextField"], q = True, fi = True) jams_file = cmds.textField(self.widgets["jamsFileTextField"], q = True, fi = True) raw_wrf = cmds.checkBox(self.widgets["wrfCheckBox"], q=True, v=True) raw_dem = cmds.checkBox(self.widgets["demCheckBox"], q=True, v=True) if raw_wrf: if platform.system() == 'Windows': s = subprocess.check_output(["where", "python"], shell=True) else: s = subprocess.check_output(["which", "python"], shell=False) python_path = s.splitlines()[-1] script_dir = os.path.dirname(os.path.realpath(__file__)) winds_file = subprocess.check_output([python_path, script_dir + "\NetCDF_converter.py", map_file, winds_file], shell=False).rstrip() if raw_dem: if platform.system() == 'Windows': s = subprocess.check_output(["where", "python"], shell=True) else: s = subprocess.check_output(["which", "python"], shell=False) python_path = s.splitlines()[-1] script_dir = os.path.dirname(os.path.realpath(__file__)) heights_file = subprocess.check_output([python_path, script_dir + "\DEM_converter.py", map_file, heights_file], shell=False).rstrip() if cmds.objExists('city'): cmds.delete('city') def calc_emmiter_level(waypoints): if (jams_file == ""): return 0 jams_data = open(jams_file, 'r') sum_jams_level = 0 jams_points = 0 shift_lat = -0.00766 shift_lon = 0.006868 for waypoint in waypoints: for line in jams_data: tmp = line.split(' ') lon = float(tmp[0]) - shift_lon lat = float(tmp[1]) - shift_lat if lat < minlat or lat > maxlat or lon < minlon or lon > maxlon: continue data = float(tmp[2]) jams_point = convert_coordinates(lon, lat) dist = math.sqrt(math.pow(waypoint[0]-jams_point[0], 2)+math.pow(waypoint[2]-jams_point[2], 2)) if dist < (25.0/size_multiplier): sum_jams_level += data jams_points += 1 if jams_points >= (len(waypoints) * 0.5): return 1.0*sum_jams_level/jams_points else: return 0 jams_data.close() def convert_coordinates(lon, lat): centered_lat = (lat-minlat) - (maxlat-minlat)/2 centered_lon = (lon-minlon) - (maxlon-minlon)/2 normalized_lat = centered_lat * norm_lat normalized_lon = centered_lon * norm_lon return [normalized_lon, 0, -normalized_lat] #meters size_multiplier = float(cmds.textField(self.widgets["sizeMultTextField"], q = True, tx = True)) emit_multiplier = float(cmds.textField(self.widgets["emitMultTextField"], q = True, tx = True)) hasl = float(cmds.textField(self.widgets["haslTextField"], q = True, tx = True)) xmlData = xml.dom.minidom.parse(map_file) points_ids = [] points = [] heights = [] bounds = xmlData.getElementsByTagName("bounds")[0] minlat = float(bounds.getAttribute('minlat')) maxlat = float(bounds.getAttribute('maxlat')) minlon = float(bounds.getAttribute('minlon')) maxlon = float(bounds.getAttribute('maxlon')) dist_lon = self.coordinates_dist(minlon, minlat, maxlon, minlat) dist_lat = self.coordinates_dist(minlon, minlat, minlon, maxlat) norm_lat = (dist_lat/size_multiplier)/(maxlat-minlat) norm_lon = (dist_lon/size_multiplier)/(maxlon-minlon) #============================Get heights=================================== heights_data = open(heights_file, 'r') rows = 0 cols = 0 start_lon = 0 start_lat = 0 delta_lon = 0 delta_lat = 0 heights_matrix = [] for line in heights_data: tmp = line.strip().split(' ') if rows == 0: rows = float(tmp[0]) cols = float(tmp[1]) elif start_lon == 0: start_lon = float(tmp[0]) start_lat = float(tmp[1]) elif delta_lon == 0: delta_lon = float(tmp[0]) delta_lat = float(tmp[1]) else: row = [] for cell in tmp: row.append(int(cell)-hasl) heights_matrix.append(row) #========================================================================== maxprogress = 0 ways = xmlData.getElementsByTagName('way') for way in ways: tags = way.getElementsByTagName('tag') for tag in tags: tag_type = str(tag.getAttribute('k')) if (tag_type == 'highway'): subtype = str(tag.getAttribute('v')) if not(subtype == 'pedestrian') and not(subtype == 'steps') and not(subtype == 'footway') and not(subtype == 'cycleway'): maxprogress += 1 if (tag_type == 'building'): maxprogress += 1 progress = 0 cmds.progressWindow(title='Generating city', min = 0, max = maxprogress, progress = progress, status = 'Processing nodes', isInterruptable = False) #============================Handle nodes================================== nodes = xmlData.getElementsByTagName('node') for node in nodes: lat = float(node.getAttribute('lat')) lon = float(node.getAttribute('lon')) if lat < minlat or lat > maxlat or lon < minlon or lon > maxlon: continue point = convert_coordinates(lon, lat) points_ids.append(int(node.getAttribute('id'))) points.append(point) heights.append(heights_matrix[int(math.floor((lon-start_lon)/delta_lon))][int(math.floor((lat-start_lat)/delta_lat))]) #========================================================================== #=============================Handle ways================================== roads = 0 buildings = 0 emitter = 0 cmds.particle(n='nParticle') cmds.particle('nParticle', e=True, at='mass', order=0, fv=1e-5) cmds.setAttr('nParticleShape.lifespanMode', 2) cmds.setAttr('nParticleShape.lifespan', 6) cmds.setAttr('nParticleShape.lifespanRandom', 2) cmds.select('nParticleShape', r=True) cmds.addAttr(longName='betterIllumination', at='bool', defaultValue=False ) cmds.addAttr(longName='surfaceShading', at='float', defaultValue=0, minValue=0, maxValue=1) cmds.addAttr(longName='threshold', at='float', defaultValue=0, minValue=0, maxValue=10) cmds.addAttr(longName='radius', at='float', defaultValue=1, minValue=0, maxValue=20) cmds.addAttr(longName='flatShaded', at='bool', defaultValue=False) cmds.setAttr('nParticleShape.particleRenderType', 8) cmds.setAttr('nParticleShape.radius', 0.06) cmds.setAttr('particleCloud1.transparency', 0.53, 0.53, 0.53, type='double3') cmds.setAttr('particleCloud1.color', 1.0, 0.0, 0.483, type='double3') cmds.setAttr('particleCloud1.incandescence', 1.0, 0.0, 0.850, type='double3') cmds.setAttr('particleCloud1.glowIntensity', 0.111) ways = xmlData.getElementsByTagName('way') for way in ways: waypoints = [] heights_sum = 0 nodes = way.getElementsByTagName('nd') tags = way.getElementsByTagName('tag') for node in nodes: ref = int(node.getAttribute('ref')) try: index = points_ids.index(ref) except ValueError: index = -1 if index != -1: waypoints.append(points[index]) heights_sum += heights[index] for tag in tags: tag_type = str(tag.getAttribute('k')) if tag_type == 'highway': subtype = str(tag.getAttribute('v')) if not(subtype == 'pedestrian') and not(subtype == 'steps') and not(subtype == 'footway') and not(subtype == 'cycleway'): roads += 1 progress += 1 cmds.progressWindow(edit=True, progress = progress, status='Generating road: ' + str(roads)) lanes = 2 for tag in tags: tag_type = str(tag.getAttribute('k')) if tag_type == 'lanes': lanes = float(str(tag.getAttribute('v'))) if len(waypoints) >= 2: cmds.curve(n='pathcurve_' + str(roads), p=waypoints, d=1) sx = waypoints[0][0] sz = waypoints[0][2] dx = waypoints[0][2]-waypoints[1][2] dz = waypoints[1][0]-waypoints[0][0] ln = math.sqrt(math.pow(2*dx, 2) + math.pow(2*dz, 2)) dx /= (ln*size_multiplier)/(3*lanes) dz /= (ln*size_multiplier)/(3*lanes) ln = 0 for i in range(0, len(waypoints)-2): ln += math.trunc(math.sqrt(math.pow(waypoints[i+1][0]-waypoints[i][0], 2) + math.pow(waypoints[i+1][2]-waypoints[i][2], 2))) + 1 cmds.curve(n='extrudecurve_' + str(roads), p=[(sx-dx, 0, sz-dz), (sx+dx, 0, sz+dz)], d=1) cmds.rebuildCurve('pathcurve_' + str(roads), rt=0, s=200) cmds.nurbsToPolygonsPref(f=2, pt=1, ut=1, un=2, vt=1, vn=ln * 5 + 30) cmds.extrude('extrudecurve_' + str(roads), 'pathcurve_' + str(roads), n='road_' + str(roads), et=2, po=1) cmds.delete('extrudecurve_' + str(roads),) emitter_level = calc_emmiter_level(waypoints) if emitter_level > 0: emitter += 1 cmds.select('pathcurve_' + str(roads), r=True) cmds.move(0, 0.03, 0) cmds.emitter(n='emitter_' + str(emitter), type='omni', r=emit_multiplier*emitter_level, spd=0.1, srn=0, sp=0) cmds.connectDynamic('nParticle', em='emitter_' + str(emitter)) cmds.select('road_' + str(roads), r=True) cmds.move(0, 0.004, 0) elif tag_type == 'building': temp = str(tag.getAttribute('v')) if temp == 'yes': buildings += 1 progress += 1 cmds.progressWindow(edit=True, progress = progress, status='Generating building: ' + str(buildings)) if len(waypoints) >= 3: cmds.polyCreateFacet(n='building_' + str(buildings), p=waypoints) cmds.select('building_' + str(buildings), r=True) normal = cmds.polyInfo(fn=True)[0].partition('0: ')[2].split(' ')[1] if float(normal) < 0: cmds.polyMirrorFace(direction=2, p=(0, 0, 0), mergeMode=0, worldSpace=1) cmds.polyDelFacet('building_' + str(buildings) + '.f[0]') avg_height = heights_sum / len(waypoints) cmds.polyExtrudeFacet('building_' + str(buildings) + '.f[0]', ltz=(1.0 * avg_height/size_multiplier)) cmds.select('building_' + str(buildings), r=True) cmds.collision('building_' + str(buildings), 'nParticle') #========================================================================== #============================Handle winds================================== winds_data = open(winds_file, 'r') winds = 0 cmds.progressWindow(edit=True, progress = progress, status='Setting winds') for line in winds_data: winds += 1 tmp = line.split(' ') lon = float(tmp[0]) lat = float(tmp[1]) x = float(tmp[2]) y = float(tmp[3]) z = float(tmp[4]) magn = math.sqrt(math.pow(x, 2) + math.pow(y, 2) + math.pow(z, 2)) max_dist = self.coordinates_dist(0, 0, 0.006364, 0.006364)/size_multiplier volume_size = self.coordinates_dist(0, 0, 0.0045, 0.0045)/size_multiplier position = convert_coordinates(lon, lat) cmds.air(n='wind_' + str(winds), pos=position, wns=True, dx=x, dy=y, dz=z, m=magn, s=1, mxd=max_dist) cmds.setAttr('wind_' + str(winds) + '.volumeShape', 1) cmds.setAttr('wind_' + str(winds) + '.volumeOffsetY', 1) cmds.scale(volume_size, volume_size/2, volume_size, 'wind_' + str(winds)) cmds.connectDynamic('nParticle', f='wind_' + str(winds)) cmds.select(cl=True) #========================================================================== cmds.gravity(n='gravity', m=9.8*1e-5) cmds.connectDynamic('nParticle', f='gravity') cmds.polyPlane(n='ground', sx=(maxlon-minlon), sy=(maxlat-minlat), w=(maxlon-minlon)*norm_lon, h=(maxlat-minlat)*norm_lat) cmds.collision('ground', 'nParticle') cmds.select('building_*', r=True) cmds.select('road_*', tgl=True) cmds.select('ground', tgl=True) cmds.select('nParticle', tgl=True) cmds.editRenderLayerGlobals(currentRenderLayer='AOLayer') cmds.editRenderLayerMembers('AOLayer') cmds.select('road_*', r=True) cmds.group(n='roads') cmds.select('building_*', r=True) cmds.group(n='buildings') cmds.select('pathcurve_*', r=True) cmds.group(n='emitters') cmds.select('roads', r=True) cmds.select('buildings', tgl=True) cmds.select('emitters', tgl=True) cmds.select('nParticle', tgl=True) cmds.select('gravity', tgl=True) cmds.select('ground', tgl=True) cmds.select('wind_1', tgl=True) cmds.group(n='city') xmlData.unlink() winds_data.close() heights_data.close() if raw_wrf: os.remove(winds_file) if raw_dem: os.remove(heights_file) cmds.progressWindow(endProgress = True)