def compute_edge_ratio(mesh): """ :param mesh: a mesh :return: minimum, maximum and average edge ratio of the mesh """ p = mesh.get_nodes() t = mesh.get_faces() maximum = 0 avg = 0 #big number ! minimum = 1e10 for triangle in t: a, b, c = triangle pa, pb, pc = p[a], p[b], p[c] ab = length(pa - pb) ac = length(pa - pc) bc = length(pb - pc) local_min = min(min(ab, ac), bc) local_max = max(max(ab, ac), bc) edge_ratio = local_max / local_min minimum = minimum if minimum <= edge_ratio else edge_ratio maximum = maximum if maximum >= edge_ratio else edge_ratio avg += edge_ratio return minimum, maximum, avg / len(t)
def __init__(self, point_item): self.vertices = set() if not point_item.is_bounded(): return # Compute segments edges for other in point_item.others: v1, v2 = other.vertices() for v in [v1, v2]: EPSILON = 1e-4 distances = list(utils.distance2(v, i) for i in self.vertices) if len(distances) == 0 or min(distances) > EPSILON: self.vertices |= {v} # Sort vertices to make the shape convex self.vertices = list(self.vertices) OA = utils.vector(point_item.point, self.vertices[0]) len_OA = utils.length(OA) t = {(self.vertices[0], 0)} for vertex in self.vertices[1:]: OB = utils.vector(point_item.point, vertex) len_OB = utils.length(OB) cos_angle = utils.dot(OA, OB) / (len_OA * len_OB) if cos_angle < -1: cos_angle = -1 elif cos_angle > 1: cos_angle = 1 angle = math.acos(cos_angle) if utils.cross(OA, OB) < 0: # sign of sin angle = 2 * math.pi - angle t |= {(vertex, angle)} self.vertices = list(vertex for vertex, _ in sorted(t, key=lambda x: x[1]))
def scatter(self, r_in, rec, attenuation): refracted = np.zeros([3], dtype=np.float32) reflected = reflect(r_in.direction(), rec.normal) attenuation = np.array([1, 1, 1], dtype=np.float32) if np.dot(r_in.direction(), rec.normal) > 0: outward_normal = -rec.normal ni_over_nt = self.ref_idx cosine = self.ref_idx * np.dot( r_in.direction(), rec.normal) / length(r_in.direction()) # cosine = np.dot(r_in.direction(), rec.normal) / length(r_in.direction()) # print(1 - self.ref_idx * self.ref_idx * (1 - cosine ** 2), self.ref_idx, cosine) # cosine = math.sqrt(1 - self.ref_idx * self.ref_idx * (1 - cosine ** 2)) else: outward_normal = rec.normal ni_over_nt = 1.0 / self.ref_idx cosine = (0 - np.dot(r_in.direction(), rec.normal)) / length( r_in.direction()) boolean, refracted = refract(r_in.direction(), outward_normal, ni_over_nt, refracted) if boolean: reflect_prob = schlick(cosine, self.ref_idx) else: reflect_prob = 1.0 if (random() < reflect_prob): scattered = ray(rec.p, reflected) else: scattered = ray(rec.p, refracted) return True, attenuation, scattered
def castRay(self, origin, direction): material, intersect = self.sceneIntersect(origin, direction) if material is None: return self.currentColor lightDir = norm(sub(self.light.position, intersect.point)) lightDistance = length(sub(self.light.position, intersect.point)) offsetNormal = mul(intersect.normal, 1.1) shadowOrigin = sub(intersect.point, offsetNormal) if dot(lightDir, intersect.normal) < 0 else sum(intersect.point, offsetNormal) shadowMaterial, shadowIntersect = self.sceneIntersect(shadowOrigin, lightDir) shadowIntensity = 0 if shadowMaterial and length(sub(shadowIntersect.point, shadowOrigin)) < lightDistance: shadowIntensity = 0.9 intensity = self.light.intensity * max(0, dot(lightDir, intersect.normal)) * (1 - shadowIntensity) reflection = reflect(lightDir, intersect.normal) specularIntensity = self.light.intensity * ( max(0, -dot(reflection, direction)) ** material.spec ) diffuse = material.diffuse * intensity * material.albedo[0] specular = Color(255, 255, 255) * specularIntensity * material.albedo[1] return diffuse + specular
def castRay(self, origin, direction, recursion=0): material, intersect = self.sceneIntersect(origin, direction) if material is None or recursion >= MAX_RECURSION_DEPTH: return self.currentColor # Si el rayo no golpeo nada o si llego al limite de recursion lightDir = norm(sub(self.light.position, intersect.point)) lightDistance = length(sub(self.light.position, intersect.point)) offsetNormal = mul(intersect.normal, 1.1) shadowOrigin = sub( intersect.point, offsetNormal) if dot(lightDir, intersect.normal) < 0 else sum( intersect.point, offsetNormal) shadowMaterial, shadowIntersect = self.sceneIntersect( shadowOrigin, lightDir) shadowIntensity = 0 if shadowMaterial and length(sub(shadowIntersect.point, shadowOrigin)) < lightDistance: shadowIntensity = 0.9 intensity = self.light.intensity * max( 0, dot(lightDir, intersect.normal)) * (1 - shadowIntensity) reflection = reflect(lightDir, intersect.normal) specularIntensity = self.light.intensity * (max( 0, -dot(reflection, direction))**material.spec) if material.albedo[2] > 0: reflectDir = reflect(direction, intersect.normal) reflectOrigin = sub(intersect.point, offsetNormal) if dot( reflectDir, intersect.normal) < 0 else sum( intersect.point, offsetNormal) reflectedColor = self.castRay(reflectOrigin, reflectDir, recursion + 1) else: reflectedColor = self.currentColor if material.albedo[3] > 0: refractDir = refract(direction, intersect.normal, material.refractionIndex) refractOrigin = sub(intersect.point, offsetNormal) if dot( refractDir, intersect.normal) < 0 else sum( intersect.point, offsetNormal) refractedColor = self.castRay(refractOrigin, refractDir, recursion + 1) else: refractedColor = self.currentColor diffuse = material.diffuse * intensity * material.albedo[0] specular = Color(255, 255, 255) * specularIntensity * material.albedo[1] reflected = reflectedColor * material.albedo[2] refracted = refractedColor * material.albedo[3] return diffuse + specular + reflected + refracted
def calcEndDist(self): # Return the new tour distance if 2opt swap is performed at start, end. # In the new tour, the previous point will connect to the end and the start will # connect to the next point. endDist = self.parent.getEndDist() oldStartEdgeLen = utils.length(self.points[self.tour[self.parent.mapIndex(self.start - 1)]], self.points[self.tour[self.parent.mapIndex(self.start)]]) oldEndEdgeLen = utils.length(self.points[self.tour[self.parent.mapIndex(self.end)]], self.points[self.tour[self.parent.mapIndex((self.end + 1) % len(self.tour))]]) newStartEdgeLen = utils.length(self.points[self.tour[self.parent.mapIndex(self.start - 1)]], self.points[self.tour[self.parent.mapIndex(self.end)]]) newEndEdgeLen = utils.length(self.points[self.tour[self.parent.mapIndex(self.start)]], self.points[self.tour[self.parent.mapIndex((self.end + 1) % len(self.tour))]]) return endDist + (newStartEdgeLen - oldStartEdgeLen) + (newEndEdgeLen - oldEndEdgeLen)
def generate_connective_cylinders(points, radius, ndiv): """ Generate mesh of cylinders of given radius along the segments connecting given sequence of points. Each cylinder is generated by dividing cylinder side into ndiv rectangular strips. """ # Use template to reduce overhead of mesh generation. template_mesh = make_cylinder_mesh(ndiv) template_mesh.vertices[:, 0] *= radius template_mesh.vertices[:, 1] *= radius meshes = [] for point_1, point_2 in zip(points[:-1], points[1:]): # Compute orthonormal frame whose z-axis is given by the tangent # vector of the segment connecting two points. Then we will map the # template cylinder mesh along the z-axis. segment = point_2 - point_1 tangent = normalize(segment) try: normal = find_any_normal(tangent) except: normal = [1, 0, 0] binormal = np.cross(tangent, normal) frame = np.row_stack((normal, binormal, tangent)) # Map template mesh on the segment. stretch = length(segment) mesh = template_mesh.copy() mesh.vertices[:, 2] *= stretch mesh.vertices = np.dot(mesh.vertices, frame) + point_1 mesh.normals = np.dot(mesh.normals, frame) meshes.append(mesh) return meshes
def p_nickname(w, y, x, nickname, selected): nick = nickname.encode('utf-8') nicklen = utils.length(nick) try: w.addstr(y, x+(10-nicklen), nick, curses.A_UNDERLINE|curses.color_pair(1)|selected) except: pass
def compute_gravity_resistance(contacts, normals, num_facets, mu, gamma, object_mass, c_of_mass_height=0): """ Gravity produces some wrench on your object. Computes whether the grasp can produce and equal and opposite wrench Parameters ---------- contacts : :obj:`numpy.ndarray` obj mesh vertices on which the fingers will be placed normals : :obj:`numpy.ndarray` obj mesh normals at the contact points num_facets : int number of vectors to use to approximate the friction cone. these vectors will be along the friction cone boundary mu : float coefficient of friction gamma : float torsional friction coefficient object_mass : float mass of the object Returns ------- float : quality of the grasp """ # YOUR CODE HERE (contact forces exist may be useful here) # grasp_map = get_grasp_map(contacts, normals, num_facets, mu, gamma) #Linear Force due to gravity f = np.array([0, 0, -object_mass * 9.8]) #Torque due to gravity l = normalize(contacts[1] - contacts[0]) up = np.cross(contacts[0] - np.array([0, 0, c_of_mass_height]), l) r_length = length(up) r = normalize(np.cross(l, up)) * r_length torque = np.cross(r, f) #Total Wrench due to gravity Fe = np.append(f, torque).T #Get the least square soln fc, residual = contact_forces_exist(contacts, normals, num_facets, mu, gamma, -Fe) #Check contacts if torque inside friction cone if fc is not None: f0 = 0 f1 = 0 for i in range(32): f0 = f0 + fc[i] f1 = f1 + fc[33 + i] if fc[32] > gamma * f0 or fc[65] > gamma * f1: return float('inf') return residual
def random_scene(n=500): list = [] list.append( sphere(vec3(0, -1000, 0), 1000, lambertian(vec3(0.5, 0.5, 0.5)))) for a in range(-11, 11): for b in range(-11, 11): choose_mat = random() center = vec3(a + 0.9 * random(), 0.2, b + 0.9 * random()) if length(center - vec3(4, 0.2, 0)) > 0.9: if choose_mat < 0.8: list.append( sphere( center, 0.2, lambertian( vec3(random() * random(), random() * random(), random() * random())))) elif choose_mat < 0.95: list.append( sphere( center, 0.2, metal( vec3(0.5 * (1 + random()), 0.5 * (1 + random()), 0.5 * (1 + random())), 0.5 * random()))) else: list.append(sphere(center, 0.2, dielectric(1.5))) list.append(sphere(vec3(0, 1, 0), 1.0, dielectric(1.5))) list.append(sphere(vec3(-4, 1, 0), 1.0, lambertian(vec3(0.4, 0.2, 0.1)))) list.append(sphere(vec3(4, 1, 0), 1.0, metal(vec3(0.7, 0.6, 0.5), 0.0))) return list
def compute_aspect_ratio(mesh): """ :param mesh: a mesh :return: minimum, maximum and average aspect ratio of the mesh """ p = mesh.get_nodes() t = mesh.get_faces() maximum = 0 avg = 0 #big number ! minimum = 1e10 for triangle in t: a, b, c = triangle pa, pb, pc = p[a], p[b], p[c] ab = length(pa - pb) ac = length(pa - pc) bc = length(pb - pc) half_circumference = (ab + ac + bc) / 2. area = math.sqrt(half_circumference * (half_circumference - ab) * (half_circumference - ac) * (half_circumference - bc)) if area == 0: print pa, pb, pc, triangle inradius = area / half_circumference local_max = max(max(ab, ac), bc) if inradius == 0: inradius = 1e-12 aspect_ratio = local_max / (2 * math.sqrt(3) * inradius) minimum = minimum if minimum <= aspect_ratio else aspect_ratio maximum = maximum if maximum >= aspect_ratio else aspect_ratio avg += aspect_ratio return minimum, maximum, avg / len(t)
def compute_aspect_ratio(mesh): """ :param mesh: a mesh :return: minimum, maximum and average aspect ratio of the mesh """ p = mesh.get_nodes() t = mesh.get_faces() maximum = 0 avg = 0 #big number ! minimum = 1e10 for triangle in t: a, b, c = triangle pa, pb, pc = p[a], p[b], p[c] ab = length(pa-pb) ac = length(pa-pc) bc = length(pb-pc) half_circumference = (ab+ac+bc)/2. area = math.sqrt(half_circumference*(half_circumference-ab)*(half_circumference-ac)*(half_circumference-bc)) if area == 0: print pa, pb, pc, triangle inradius = area/half_circumference local_max = max(max(ab,ac), bc) if inradius == 0: inradius = 1e-12 aspect_ratio = local_max/(2*math.sqrt(3)*inradius) minimum = minimum if minimum <= aspect_ratio else aspect_ratio maximum = maximum if maximum >= aspect_ratio else aspect_ratio avg += aspect_ratio return minimum, maximum, avg/len(t)
def updateKnownRobots(self): '''update robots in the communicate limits after changing its position''' knownRobots=[] robotList=self._world.getRobotList() for robot in robotList: x,y = robot.xy() if self.getId()!=robot.getId() and utils.length(self._x,self._y,x,y) <= self._rc: knownRobots.append(robot) self._knownRobots=knownRobots
def calculate_array2D_cost(points, ants, cities): cost = np.empty((ants, cities)) for row in range(ants): for column in range(cities): if row != column: cost[row][column] = length(points[row], points[column]) else: cost[row][column] = -1 return cost
def compute_skewness(mesh): """ :param mesh: a mesh :return: minimum, maximum and average skewness of the mesh """ p = mesh.get_nodes() t = mesh.get_faces() maximum = 0 avg = 0 minimum = 1e10 for i, triangle in enumerate(t): a, b, c = triangle pa, pb, pc = p[a], p[b], p[c] ab = length(pa-pb) ac = length(pa-pc) bc = length(pb-pc) half_circumference = (ab+ac+bc)/2. area = math.sqrt(half_circumference*(half_circumference-ab)*(half_circumference-ac)*(half_circumference-bc)) if area==0: area= 1e-12 circumscribed_circle_r = ab*ac*bc/(4.*area) a = math.sqrt(3)*circumscribed_circle_r optimal_area = math.sqrt(3)/4. * a*a skewness = (optimal_area-area)/optimal_area minimum = minimum if minimum <= skewness else skewness maximum = maximum if maximum >= skewness else skewness avg += skewness return minimum, maximum, avg/len(t)
def sorted_contacts(vertices, normals, T_ar_object): """ takes mesh and returns pairs of contacts and the quality of grasp between the contacts, sorted by quality Parameters ---------- vertices : :obj:`numpy.ndarray` nx3 mesh vertices normals : :obj:`numpy.ndarray` nx3 mesh normals T_ar_object : :obj:`autolab_core.RigidTransform` transform from the AR tag on the paper to the object Returns ------- :obj:`list` of :obj:`numpy.ndarray` grasp_indices[i][0] and grasp_indices[i][1] are the indices of a pair of vertices. These are randomly sampled and their quality is saved in best_metric_indices :obj:`list` of int best_metric_indices is the indices of grasp_indices in order of grasp quality """ N = 1000 # prune vertices that are too close to the table so you dont smack into the table # you may want to change this line, to be how you see fit possible_indices = np.r_[:len(vertices)][vertices[:, 2] + T_ar_object[2, 3] >= 0.03] np.random.shuffle(possible_indices) # Finding grasp via vertex sampling. make sure to not consider grasps where the # vertices are too big for the gripper # possible metrics: compute_force_closure, compute_gravity_resistance, compute_custom_metric metric = compute_custom_metric grasp_indices = list() metric_scores = list() for i in range(N): candidate_indices = np.random.choice(possible_indices, 2, replace=False) point_dist = utils.length(vertices[candidate_indices[0]] - vertices[candidate_indices[1]]) grasp_indices.append(candidate_indices) # assign lowest possible scores to impossible grasps if point_dist < MIN_HAND_DISTANCE or point_dist > MAX_HAND_DISTANCE: metric_scores.append(-sys.maxint - 1) else: contacts = vertices[candidate_indices] contact_normals = normals[candidate_indices] score = metric(contacts, contact_normals, CONTACT_MU, CONTACT_GAMMA, OBJECT_MASS) metric_scores.append(score) # sort metrics and return the sorted order best_metric_indices = sorted(list(range(N)), key=lambda i: metric_scores[i], reverse=True) return grasp_indices, best_metric_indices
def draw_login_window(parent): global login_window global logo_window if login_window: login_window.erase() login_window.refresh() del login_window if logo_window: logo_window.erase() logo_window.refresh() del logo_window parent.erase() me2terminal.paint_background(parent) parent.refresh() LINES = parent.getmaxyx()[0] COLS = parent.getmaxyx()[1] # logo window logo_y = (LINES-LOGO_H) / 2 - 4 logo_window = curses.newwin(LOGO_H, LOGO_W, logo_y, (COLS-LOGO_W)/2) line = 1 for logo_line in LOGO: logo_window.addstr(line, 1, logo_line) line += 1 logo_window.refresh() # login window login_width, login_height = (42, 7) login_window = curses.newwin( login_height, login_width, logo_y + LOGO_H + 1, (COLS-login_width)/2) login_window.border() login_window.addstr(1, 1, expand_to(title, login_width-2), curses.A_REVERSE | curses.A_BOLD) login_window.addstr(3, 4, label_id) login_window.addstr(' ' * (login_width-2-length(label_id)-8), curses.A_UNDERLINE) login_window.addstr(5, login_width-2-length("[Enter]"), "[Enter]") login_window.refresh()
def compute_skewness(mesh): """ :param mesh: a mesh :return: minimum, maximum and average skewness of the mesh """ p = mesh.get_nodes() t = mesh.get_faces() maximum = 0 avg = 0 minimum = 1e10 for i, triangle in enumerate(t): a, b, c = triangle pa, pb, pc = p[a], p[b], p[c] ab = length(pa - pb) ac = length(pa - pc) bc = length(pb - pc) half_circumference = (ab + ac + bc) / 2. area = math.sqrt(half_circumference * (half_circumference - ab) * (half_circumference - ac) * (half_circumference - bc)) if area == 0: area = 1e-12 circumscribed_circle_r = ab * ac * bc / (4. * area) a = math.sqrt(3) * circumscribed_circle_r optimal_area = math.sqrt(3) / 4. * a * a skewness = (optimal_area - area) / optimal_area minimum = minimum if minimum <= skewness else skewness maximum = maximum if maximum >= skewness else skewness avg += skewness return minimum, maximum, avg / len(t)
def findNearestPoint(points, used, src): # If no nearest point, return max. dest = src minDist = sys.float_info.max i = (src + 1) % len(points) for j in range(len(points) - 1): if not used[i]: dist = utils.length(points[src], points[i]) if dist < minDist: dest = i minDist = dist i = (i + 1) % len(points) return dest, minDist
def solve(points): tour = [0 for i in range(len(points))] used = [False for i in range(len(points))] totalDist = 0.0 used[0] = True src = 0 for i in range(1, len(points)): dest, minDist = findNearestPoint(points, used, src) tour[i] = dest used[dest] = True src = dest totalDist += minDist return 0, totalDist + utils.length(points[tour[-1]], points[tour[0]]), tour
def find_any_normal(vec): """ Return a unit vector perpendicular to the given nonzero vector. """ x, y, z = vec candidates = [(y + z, -x, -x), (-y, z + x, -y), (-z, -z, x + y), (y - z, -x, x), (y, z - x, -y), (-z, z, x - y)] for n in candidates: norm = length(n) if norm > 0: return as_float_array(n) / norm raise Exception('cannot find a normal')
def init_context_embedding(self, embedded_terms): assert (isinstance(self.cfg, RCNNConfig)) text_length = utils.length(self.x) with tf.name_scope("bi-rnn"): fw_cell = RNN.get_cell( self.cfg.SurroundingOneSideContextEmbeddingSize, self.cfg.CellType) fw_cell = tf.nn.rnn_cell.DropoutWrapper( fw_cell, output_keep_prob=self.dropout_keep_prob) bw_cell = RNN.get_cell( self.cfg.SurroundingOneSideContextEmbeddingSize, self.cfg.CellType) bw_cell = tf.nn.rnn_cell.DropoutWrapper( bw_cell, output_keep_prob=self.dropout_keep_prob) (self.output_fw, self.output_bw), states = tf.nn.bidirectional_dynamic_rnn( cell_fw=fw_cell, cell_bw=bw_cell, inputs=embedded_terms, sequence_length=text_length, dtype=tf.float32) with tf.name_scope("context"): shape = [ tf.shape(self.output_fw)[0], 1, tf.shape(self.output_fw)[2] ] c_left = tf.concat([tf.zeros(shape), self.output_fw[:, :-1]], axis=1, name="context_left") c_right = tf.concat( [self.output_bw[:, 1:], tf.zeros(shape)], axis=1, name="context_right") with tf.name_scope("word-representation"): merged = tf.concat([c_left, embedded_terms, c_right], axis=2, name="merged") with tf.name_scope("text-representation"): y2 = tf.tanh(tf.einsum('aij,jk->aik', merged, self.W1) + self.b1) with tf.name_scope("max-pooling"): y3 = tf.reduce_max(y2, axis=1) if self.cfg.UseAttention: y3 = tf.concat([y3, self.init_attention_embedding()], axis=-1) return y3
def compute_edge_ratio(mesh): """ :param mesh: a mesh :return: minimum, maximum and average edge ratio of the mesh """ p = mesh.get_nodes() t = mesh.get_faces() maximum = 0 avg = 0 #big number ! minimum = 1e10 for triangle in t: a, b, c = triangle pa, pb, pc = p[a], p[b], p[c] ab = length(pa-pb) ac = length(pa-pc) bc = length(pb-pc) local_min = min(min(ab,ac), bc) local_max = max(max(ab,ac), bc) edge_ratio = local_max/local_min minimum = minimum if minimum <= edge_ratio else edge_ratio maximum = maximum if maximum >= edge_ratio else edge_ratio avg += edge_ratio return minimum, maximum, avg/len(t)
def init_context_embedding(self, embedded_terms): assert (isinstance(self.cfg, RNNConfig)) with tf.name_scope("rnn"): length = tf.cast(utils.length(self.x), tf.int32) cell = self.get_cell(self.cfg.HiddenSize, self.cfg.CellType) cell = tf.nn.rnn_cell.DropoutWrapper( cell, output_keep_prob=self.dropout_keep_prob) all_outputs, _ = tf.nn.dynamic_rnn(cell=cell, inputs=embedded_terms, sequence_length=length, dtype=tf.float32) h_outputs = self.last_relevant(all_outputs, length) return h_outputs
def ray_intersect(self, orig, direction): L = sub(self.center, orig) tca = dot(L, direction) l = length(L) d2 = l**2 - tca**2 if d2 > self.radius**2: return False thc = (self.radius**2 - d2)**1 / 2 t0 = tca - thc t1 = tca + thc if t0 < 0: t0 = t1 if t0 < 0: return False return True
def stat(self, path, name, timestamp): if name.endswith('.md') and (not name.__contains__('README')): file = open(path, 'r', encoding='utf-8') type = 'unfinished' num = 0 info = '' for i in file.readlines(): num += length(i.strip()) if i.__contains__('END'): type = 'fin' file.close() info = '|[' + name[0:-3] + '](' + name + ')|' info += str(num) + '|' if self.sort == 'time': info += changeTime(timestamp) + '|' self.write(info, type)
def __init__(self, vertices, faces, normals=None, colors=None): # Infer the direction of vertex normal as that of vector pointing # the vertex from the centroid of the vertices. This should give # fairly good normals for convex objects. if normals is None: center = np.mean(vertices, axis=0) normals = np.array(vertices) - center normals /= length(normals)[:, None] # Default color is white. if colors is None: colors = np.ones((len(vertices), 3)) self.vertices = vertices self.faces = faces self.normals = normals self.colors = colors
def stat(self, path, name): if name.endswith('.md') and (not name.__contains__('README')): file = open(path, 'r', encoding='utf-8') num = 0 for i in file.readlines(): num += length(i.strip()) file.close() before = 0 if name in self.history.keys(): before = self.history[name] if before != num: self.log.append('|' + name.replace('.md', '') + '|' + str(before) + '|' + str(num) + '|' + str(num - before) + '|') self.history[name] = num self.exist[name] = True
def rayIntersect(self, origin, direction): L = sub(self.center, origin) tca = dot(L, direction) l = length(L) # distancia al cuadrado dc = l**2 - tca**2 if dc > self.radius**2: return False thc = (self.radius**2 - dc)**0.5 t0 = tca - thc t1 = tca + thc if t0 < 0: t0 = t1 if t0 < 0: return False return True
def get_userid(parent): global logo_window global login_window draw_login_window(parent) user_id = _input(parent, login_window, 3, 4+length(label_id)) # It's show time! Let's move both windows to the right corner. if len(user_id) > 2: ly, lx = logo_window.getbegyx() y, x = login_window.getbegyx() for i in range(1, 1): newy = y+i*1 newly = ly-i*1 try: if newly <= 1: newly = 1 logo_window.mvwin(newly, lx) if newy >= parent.getmaxyx()[0]-8: newy = parent.getmaxyx()[0]-8 login_window.mvwin(newy, x) except: break me2terminal.paint_background(parent) parent.refresh() login_window.refresh() logo_window.refresh() time.sleep(0.09) else: return '' logo_window.erase() login_window.erase() logo_window.refresh() login_window.refresh() me2terminal.paint_background(parent) parent.refresh() del logo_window del login_window return user_id
def create_scene(args): modellers = load_chain_modellers(args.scheme) center = (0, 0, 0) scene_radius = 0.0 shaders = [] records = parse_input(args.coords) def extract_group_tag(record): return record[0] for tag, subrecords in itertools.groupby(records, key=extract_group_tag): # Interpret a part of the tag as the name of the modelling scheme to # use for this subrecords. modeller_name = tag.split(':')[0] if modeller_name not in modellers: raise Exception('unknown modelling scheme: ' + modeller_name) modeller = modellers[modeller_name] points = [] values = [] for _, x, y, z, value in subrecords: points.append((x, y, z)) values.append(value) points = as_float_array(points) shaders.append(modeller.make_shader(points, values)) scene_radius = max(scene_radius, length(points - center).max()) # Add wireframe spherical wall. if args.wall_radius > 0: color, opacity = args.wall_color.split(',', 1) color = vispy.color.Color(color).rgb opacity = float(opacity) wall = make_sphere_mesh(ndiv=WALL_SPHERE_NDIV) wall.vertices *= args.wall_radius wall.colors[:] = color shaders.append(WireframeShader(wall, opacity)) scene_radius = max(scene_radius, args.wall_radius) return TranslucentScene(shaders, args.bgcolor), scene_radius
def _check_overlap(self, word, orientation, x, y): i, j = x, y next_pos = calculate_next_pos[orientation](i, j, length(word, self.lang)) for a in get_letters(word, self.lang): try: (i, j) = next(next_pos) print("i={} j={}".format(i, j)) except StopIteration as e: print("stop iteration received after will fit word={} i, j={}". format(word, (i, j))) if self.puzzle_matrix[i][j] != " ": if self.puzzle_matrix[i][j] == a: continue else: print("Overlap of letter {} with {} at {}".format( a, self.puzzle_matrix[i][j], (i, j))) return True return False
def rayIntersect(self, origin, direction): L = sub(self.center, origin) tca = dot(L, direction) l = length(L) d2 = l ** 2 - tca ** 2 if d2 > self.radius ** 2: return None thc = (self.radius ** 2 - d2) ** 0.5 t0 = tca - thc t1 = tca + thc if t0 < 0: t0 = t1 if t0 < 0: return None hit = sum(origin, mul(direction, t0)) normal = norm(sub(hit, self.center)) return Intersect( distance=t0, point=hit, normal=normal )
def Greedy(customers, facilities): solution = [-1]*len(customers) capacity_remaining = [f.capacity for f in facilities] facility_index = 0 for customer in customers: if capacity_remaining[facility_index] >= customer.demand: solution[customer.index] = facility_index capacity_remaining[facility_index] -= customer.demand else: facility_index += 1 assert capacity_remaining[facility_index] >= customer.demand solution[customer.index] = facility_index capacity_remaining[facility_index] -= customer.demand used = [0]*len(facilities) for facility_index in solution: used[facility_index] = 1 # calculate the cost of the solution obj = sum([f.setup_cost*used[f.index] for f in facilities]) for customer in customers: obj += length(customer.location, facilities[solution[customer.index]].location) return obj, solution
def main(): # print get_divisors(28) # print zip(iter_triangle_numbers(), range(7))[-1] first = (x for x in iter_triangle_numbers() if length(get_divisors(x)) > 500).next() print get_divisors(first) print first
def primitive(name, value, vs, arity, k): if arity == length(vs): return k.resume(value(vs)) else: raise TypeError("incorrect arity {} {}".format(name, vs))
def invoke(self, vs, r, k): if length(vs) == 1: return self.resume(vs.car) else: raise TypeError( "Continuations expect one argument {} {} {}".format(vs, r, k))
defprimitive('null?', lambda args: is_null(args.car), 1) defprimitive('cons', lambda args: cons(args.car, args.cadr), 2) defprimitive('car', lambda args: args.caar, 1) defprimitive('cdr', lambda args: args.cdar, 1) defprimitive('+', lambda args: args.car + args.cadr, 2) defprimitive('-', lambda args: args.car - args.cadr, 2) defprimitive('*', lambda args: args.car * args.cadr, 2) defprimitive('/', lambda args: args.car / args.cadr, 2) definitial('println', Primitive('println', lambda args, r, k: k.resume( print() if is_null(args) else print(str(args)[1:-1])))) definitial( 'call/cc', Primitive( 'call/cc', lambda vs, r, k: vs.car.invoke(cons(k, Nil), r, k) if length( vs) == 1 else wrong( TypeError("incorrect arity {} {}".format('call/cc', vs))))) def wrong(e): raise e class BottomCont(Continuation): def __init__(self, f): super().__init__(None) self.f = f def resume(self, v): return self.f(v)
def focal_distance(self): return utils.length(utils.sub(self.look_at, self.look_from))
from utils import vecadd, length from math import sin, cos, degrees, radians, acos a = [2, 3] b = [4 * cos(radians(65)), 4 * sin(radians(65))] c = [-4, -6] d = [5 * cos(radians(-235)), 5 * sin(radians(-235))] apbpcpd = vecadd(vecadd(a, b), vecadd(c, d)) apbpcpd_mag = length(apbpcpd) costheta = apbpcpd[0] / apbpcpd_mag theta = acos(costheta) if __name__ == "__main__": print("a ", apbpcpd) print("b ", apbpcpd_mag) print("c ", degrees(theta))
def show_posts(state): offset = state.offset cur_post = state.cur_post cur_idx = state.cur_idx posts = state.posts post_window = state.post_window loc_map = state.loc_map post_window.erase() limit_y = post_window.getmaxyx()[0] - 1 printed_line = 0 y = 0 selected = 0 # curses attributes for highlighted item. for post in posts: if y > limit_y: break # 아이디 출력 x = 2 nick = post.author.nickname.encode('utf-8') nicklen = utils.length(nick) if cur_post==post.id and cur_idx==0: selected = curses.A_REVERSE else: selected = 0 p_nickname(post_window, y, x, post.author.nickname, selected) # 내용 x += 10 + 2 content_w = post_window.getmaxyx()[1]-x-10 body = post.body post_window.move(y, x) content_lines = p_wrap(post_window, y, x, body, limit_y, x+content_w) # 날짜 (UTC 문제 해결할 것) if y+1 > limit_y: break post_window.move(y+1, x-10-1) post_window.addstr("%2d일%02d:%02d" % (post.date.day, post.date.hour, post.date.minute), curses.A_NORMAL | curses.color_pair(3)) # 태그 if len(post.tags)>0: if y+content_lines > limit_y: break post_window.move(y+content_lines, x) tags = "# %s" % (' '.join(post.tags)) for tag_ch in tags: post_window.addstr(tag_ch.encode('utf-8'), curses.A_DIM | curses.color_pair(5)) if post_window.getyx()[1]+2 >= x+content_w: break # 긴 태그는 가볍게 무시 content_lines += 1 # 미투수 출력, 미투하기 링크 출력 x += content_w post_window.move(y, x) loc_map[post.id] = (post_window.getbegyx()[0]+y, x) if cur_post==post.id and cur_idx==1: selected = curses.A_REVERSE else: selected = 0 post_window.addstr("metoo", curses.A_NORMAL | curses.color_pair(2) | selected) if cur_post==post.id and cur_idx==2: selected = curses.A_REVERSE else: selected = 0 post_window.addstr(" ") post_window.addstr("%2d" % (post.metoo_count), curses.A_NORMAL | curses.color_pair(6) | selected) if y+1 > limit_y: break post_window.move(y+1, x+1) post_window.addstr( "댓글 ", curses.A_NORMAL) if cur_post==post.id and cur_idx==3: selected = curses.A_REVERSE else: selected = 0 post_window.addstr("%2d" % (post.comment_count), curses.A_UNDERLINE | curses.color_pair(6) | selected) # metoo, comment 출력을 위해 최소 라인을 2줄로 맞춤. if content_lines==1: content_lines = 2 y += content_lines printed_line += 1 post_window.refresh() state.printed_line = printed_line
def distance(self, element1, element2 ): from utils import length return length( self.displacement( element1, element2 ))