def get_bound(self): v2 = self.vertexs[2] bound = Bound(list(v2), list(v2)) for j in range(3): v0 = self.vertexs[0][j] v1 = self.vertexs[1][j] if v0 < v1: if v0 < bound.lower[j]: bound.lower[j] = v0 if v1 > bound.upper[j]: bound.upper[j] = v1 else: if v1 < bound.lower[j]: bound.lower[j] = v1 if v0 > bound.upper[j]: bound.upper[j] = v0 bound.lower[j] -= (abs(bound.lower[j]) + 1.0) * TOLERANCE bound.upper[j] += (abs(bound.upper[j]) + 1.0) * TOLERANCE return bound
def inner_tiles(self, meta_bounds, scale): mw, mn, me, ms = meta_bounds meta = Bound(north = mn * 256, south = ms * 256, east = me * 256, west = mw * 256) for bound in meta.tiles_for(256): loc = Bound.from_tuple(bound).sub(meta).int().tuple() yield (loc, self.namer.name_for(scale, int(bound[1]/256), int(bound[0]/256)))
def __init__(self, dpi, meta_size, file_type, spherical_mercator, verbose=False): self.dpi = dpi self.meta_size = meta_size self.file_type = file_type self.spherical_mercator = spherical_mercator self.namer = XYZNamingScheme(file_type) self.verbose = verbose if self.spherical_mercator: self.max_bounds = Bound.spherical_mercator_max_extent() pass else: self.max_bounds = Bound.geographic_max_extent()
def inner_tiles(self, meta_bounds, scale): mw, mn, me, ms = meta_bounds meta = Bound(north=mn * 256, south=ms * 256, east=me * 256, west=mw * 256) for bound in meta.tiles_for(256): loc = Bound.from_tuple(bound).sub(meta).int().tuple() yield (loc, self.namer.name_for(scale, int(bound[1] / 256), int(bound[0] / 256)))
def __init__(self, eye_position, items): bound = Bound(list(eye_position), list(eye_position)) item_bounds = [] for item in items: item_bound = item.get_bound() item_bounds.append((item, item_bound)) bound.expand_to_fit(item_bound) bound.clamp() self.root = SpatialNode(bound, item_bounds, 0) self.deepest_level = self.root.deepest_level
def __init__(self, bound, item_bounds, level): self.bound = bound self.deepest_level = level self.is_branch = ( len(item_bounds) > MAX_ITEMS and level < MAX_LEVELS - 1) if self.is_branch: q1 = 0 self.children = [None] * 8 for sub_cell in range(8): sub_bound = Bound([], []) for m in range(3): if (sub_cell >> m) % 2 == 1: sub_bound.lower.append((self.bound.lower[m] + self.bound.upper[m]) * 0.5) sub_bound.upper.append(self.bound.upper[m]) else: sub_bound.lower.append(self.bound.lower[m]) sub_bound.upper.append((self.bound.lower[m] + self.bound.upper[m]) * 0.5) sub_item_bounds = [] for item, item_bound in item_bounds: if sub_bound.encloses(item_bound): sub_item_bounds.append((item, item_bound)) q1 += 1 if len(sub_item_bounds) == len(item_bounds) else 0 q2 = (sub_bound.upper[0] - sub_bound.lower[0]) < (TOLERANCE * 4.0) if len(sub_item_bounds) > 0: if q1 > 1 or q2: next_level = MAX_LEVELS else: next_level = level + 1 self.children[sub_cell] = SpatialNode( sub_bound, sub_item_bounds, next_level) if self.children[sub_cell].deepest_level > self.deepest_level: self.deepest_level = self.children[sub_cell].deepest_level else: self.items = [item for item, item_bound in item_bounds]
def bound(self): """Generates bounds""" for sn in range(1, self.n_source_nodes+1): for tn in range(1, self.n_transit_nodes+1): for dn in range(1, self.n_destination_nodes+1): bound = Bound() bound.create_constraint_flow(sn, tn, dn) self.add_line(bound) bound = Bound() bound.create_constraint_min() self.add_line(bound)
def __init__(self): Scene.__init__(self) self.bird = Bird(*BIRD_INITPOS) self.bounds = Bound.getUpperLowerBounds() # TODO: background image self.obstacles = [] self.add(self.bird) self.add(self.bounds[0]) self.add(self.bounds[1]) self.plannedObsGen = []
def calc_bounds(self, domain, scale): """ Calculate the set of xyz tiles to render for the domain, expressed as boundary objects in terms of xyz tile numbers. """ denom = self.scale_denominator(scale) tiles = Bound(north=self.lat_to_xyz(domain.north, denom), south=self.lat_to_xyz(domain.south, denom), east=self.lon_to_xyz(domain.east, denom), west=self.lon_to_xyz(domain.west, denom)) return tiles
def search_nearest(request): data = request.GET.dict() latitude = float(data.get('latitude')) longtitude = float(data.get('longtitude')) LC = Bound(latitude, longtitude) result = AED.objects.filter( Q(langt__range=[LC['langt_min'], LC['langt_max']]) & Q(longt__range=[LC['longt_min'], LC['longt_max']])) data = result.values() distance_result = [] for datum in data: point1 = (latitude, longtitude) point2 = (datum['langt'], datum['longt']) distance = haversine(point1, point2) if len(distance_result) >= 3: distance_result.sort() if distance < distance_result[-1][0]: distance_result.pop() distance_result += [(distance, datum['id'])] else: distance_result += [(distance, datum['id'])] len_d = len(distance_result) if len_d == 0: final = None elif len_d == 1: final = AED.objects.filter(Q(id=distance_result[0][1])) elif len_d == 2: final = AED.objects.filter( Q(id=distance_result[0][1]) | Q(id=distance_result[1][1])) elif len_d == 3: final = AED.objects.filter( Q(id=distance_result[0][1]) | Q(id=distance_result[1][1]) | Q(id=distance_result[2][1])) serializer = AEDSerializer(final, many=True) final = json.dumps(serializer.data, ensure_ascii=False) return HttpResponse(final)
def meta_tiles(self, domain, scale, base_dir): """ Create a generator for a list of (meta_extent, meta_pixels, meta_filename, [(tile_offset, tile_name)]) tuples. That can be used to generate tiles at 'scale' from 'domain'. meta_extent - the real-world unit extent to render into the metatile meta_pixels - the pixel width/height of the metatile (they're always square) meta_filename - the file name to store the metatile in tile_offset - the pixel offset of this tile within the meta tile tile_name - the file name to store this tile in """ tiles = self.calc_bounds(domain, scale) tiles.east = tiles.east + 1 tiles.south = tiles.south + 1 meta_width = self.appropriate_meta_width(tiles) meta_bounds = tiles.tiles_for(meta_width) north_max = self.max_bounds.north west_max = self.max_bounds.west scale_denom = self.scale_denominator(scale) for boundaries in meta_bounds: bw, bn, be, bs = boundaries meta_filename = "%s-%s-%s.%s" % (scale, bw, bn, self.file_type) meta_loc = os.path.join(base_dir, "meta_panels", meta_filename) extent = Bound(north=north_max - float(bn * scale_denom), south=north_max - float(bs * scale_denom), east=west_max + float(be * scale_denom), west=west_max + float(bw * scale_denom)) scale_filename = scale yield (extent, meta_width * 256, meta_loc, self.inner_tiles(boundaries, scale_filename))
def search_nearest(request): data = request.GET.dict() latitude = float(data.get('latitude')) longtitude = float(data.get('longtitude')) LC = Bound(latitude, longtitude) curday = data.get('curday') curtime = data.get('curtime') if curday == '1': result = Nerve.objects.filter( Q(langt__range=[LC['langt_min'], LC['langt_max']]) & Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty1=1) & Q(duty1_close__gte=curtime) & Q(duty1_open__lte=curtime)) elif curday == '2': result = Nerve.objects.filter( Q(langt__range=[LC['langt_min'], LC['langt_max']]) & Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty2=1) & Q(duty2_close__gte=curtime) & Q(duty2_open__lte=curtime)) elif curday == '3': result = Nerve.objects.filter( Q(langt__range=[LC['langt_min'], LC['langt_max']]) & Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty3=1) & Q(duty3_close__gte=curtime) & Q(duty3_open__lte=curtime)) elif curday == '4': result = Nerve.objects.filter( Q(langt__range=[LC['langt_min'], LC['langt_max']]) & Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty4=1) & Q(duty4_close__gte=curtime) & Q(duty4_open__lte=curtime)) elif curday == '5': result = Nerve.objects.filter( Q(langt__range=[LC['langt_min'], LC['langt_max']]) & Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty5=1) & Q(duty5_close__gte=curtime) & Q(duty5_open__lte=curtime)) elif curday == '6': result = Nerve.objects.filter( Q(langt__range=[LC['langt_min'], LC['langt_max']]) & Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty6=1) & Q(duty6_close__gte=curtime) & Q(duty6_open__lte=curtime)) elif curday == '7': result = Nerve.objects.filter( Q(langt__range=[LC['langt_min'], LC['langt_max']]) & Q(longt__range=[LC['longt_min'], LC['longt_max']]) & Q(duty7=1) & Q(duty7_close__gte=curtime) & Q(duty7_open__lte=curtime)) data = result.values() distance_result = [] for datum in data: point1 = (latitude, longtitude) point2 = (datum['langt'], datum['longt']) distance = haversine(point1, point2) if len(distance_result) >= 3: distance_result.sort() if distance < distance_result[-1][0]: distance_result.pop() distance_result += [(distance, datum['id'])] else: distance_result += [(distance, datum['id'])] len_d = len(distance_result) if len_d == 0: final = None elif len_d == 1: final = Nerve.objects.filter(Q(id=distance_result[0][1])) elif len_d == 2: final = Nerve.objects.filter( Q(id=distance_result[0][1]) | Q(id=distance_result[1][1])) elif len_d == 3: final = Nerve.objects.filter( Q(id=distance_result[0][1]) | Q(id=distance_result[1][1]) | Q(id=distance_result[2][1])) serializer = NerveSerializer(final, many=True) final = json.dumps(serializer.data, ensure_ascii=False) return HttpResponse(final)