我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用random.random()。
def get_sample_results(cls): read = """QUERY - 'SELECT "auth_user"."id" FROM "auth_group"'""" \ """- PARAMS = ()""" write = """QUERY - 'UPDATE "auth_group" SET "name" = %s'""" \ """- PARAMS = ('bar',)""" other = """QUERY - 'BEGIN TRANSACTION' - PARAMS = ()""" def to_query(sql): return {'sql': sql, 'time': '%.3f' % random.random()} def to_single_result(*sqls): qc = cls() qc.queries = [to_query(sql) for sql in sqls] return qc.get_results_to_send() return [ to_single_result(*sqls) for sqls in [ [read], [read, write], [read, read], [write, write], [other, other], [read, write, other] ] ]
def system(): """initialize and iterate the system as appropriate""" axiom = [] con = int(__base_length__ / 0.1) s = random() * 0.2 + 0.9 for ind in range(con): axiom.append(LSymbol("!", {"w": s * (__base_width__ + ((con - ind) / con) ** 6 * 0.2)})) axiom.append(LSymbol("F", {"l": s * 0.1})) axiom.append(LSymbol("Q", {"w": s * __base_width__, "l": s * 0.1})) l_sys = LSystem(axiom=axiom, rules={"Q": q_prod, "A": a_prod}, tropism=Vector([0, 0, 0.2]), thickness=0.5, bendiness=0, leaf_shape=3, leaf_scale=0.17, leaf_bend=0.2) l_sys.iterate_n(12) return l_sys
def q_prod(sym): """Production rule for Q""" ret = [] prev_ang = 0 for _ in range(int(random() * 2 + 3)): ang = random() * 10 + 30 ret.extend([LSymbol("/", {"a": prev_ang + 75 + random() * 10}), LSymbol("&", {"a": ang}), LSymbol("!", {"w": sym.parameters["w"] * 0.2}), LSymbol("["), LSymbol("A", {"w": sym.parameters["w"] * 0.3, "l": 1.5 * sqrt(sym.parameters["w"]) * (random() * 0.2 + 0.9)}), LSymbol("]"), LSymbol("!", {"w": sym.parameters["w"]}), LSymbol("^", {"a": ang}), LSymbol("F", {"l": sym.parameters["l"]})]) ret.append(LSymbol("Q", {"w": max(0, sym.parameters["w"] - __base_width__ / 14), "l": sym.parameters["l"]})) return ret
def get_neighbors(words, word, window_size=2): if type(word) == str: idx = words.index(word) elif type(word) == int: idx = word else: raise Exception(" [!] Invalid type for word: %s" % type(word)) if idx < window_size: ans = words[-(window_size - idx):] + words[:idx + window_size + 1] elif idx >= len(words) - window_size: ans = words[idx-window_size:] + words[:window_size + idx - len(words) + 1] else: ans = words[idx-window_size:idx+window_size+1] for _ in xrange(15): if random.random() < 0.1: ans.append(random.choice(ans)) random.shuffle(ans) return ans
def begin(self): for i in range(1000): index1 = self.choose_gene(random.random()) index2 = self.choose_gene(random.random()) while index1 == index2: index2 = self.choose_gene(random.random()) if random.random() < self.mutation_prob: self.genes[index1].mutation() self.genes[index2].mutation() if random.random() < self.cross_prob: Gene.cross(self.genes[index1], self.genes[index2]) self.get_fit_value() # self.gene_pop() result = self.get_best_gene() print len(self.genes), result[0].bin2dec(), result[1]
def begin(self): x = random.randint(self.x_range[0], self.x_range[1]) f = self.func(x) T = self.T0 while T > self.T_min: for i in range(self.K): new_x = self.gen_new_x(x, T) f_x = self.func(new_x) delta_E = f_x - f # if delta_E < 0: f = f_x x = new_x break else: #p_k = 1.0 / (1 + np.exp(- delta_E / self.func(T))) p_k = np.exp(- delta_E / T) if random.random() < p_k: f = f_x x = new_x break T *= self.delta return x
def repeat(self): while True: try: self.displayTime() if (datetime.datetime.now() - self.sensor1ts).total_seconds() > self.expirationSeconds: self.canvas.itemconfigure(self.txtSensor1, text="") self.canvas.itemconfigure(self.txtSensor1BigIcon, text="") if (datetime.datetime.now() - self.sensor2ts).total_seconds() > self.expirationSeconds: self.canvas.itemconfigure(self.txtSensor2, text="") self.canvas.itemconfigure(self.txtSensor2BigIcon, text="") #t = random.random()*60-20 #self.displaySensor1(t, "test") except Exception as e: self.logger.exception(e) except: pass time.sleep(1)
def __call__(self, img, mask): if self.padding > 0: img = ImageOps.expand(img, border=self.padding, fill=0) mask = ImageOps.expand(mask, border=self.padding, fill=0) assert img.size == mask.size w, h = img.size th, tw = self.size if w == tw and h == th: return img, mask if w < tw or h < th: return img.resize((tw, th), Image.BILINEAR), mask.resize((tw, th), Image.NEAREST) x1 = random.randint(0, w - tw) y1 = random.randint(0, h - th) return img.crop((x1, y1, x1 + tw, y1 + th)), mask.crop((x1, y1, x1 + tw, y1 + th))
def wait_for(image, runescape_window): # adding a possible failsafe in here time_entered = time.time() # could add a failsafe in here incase we misclick or something, this # should be something to come back to failsafe_count = 0 while(True): found = pyautogui.locateOnScreen(image, region=(runescape_window.top_left_corner[0], runescape_window.top_left_corner[1], runescape_window.bottom_right_corner[ 0] - runescape_window.top_left_corner[0], runescape_window.bottom_right_corner[1] - runescape_window.top_left_corner[1])) if found != None: break elif failsafe_count > 10: print("We can't seem to fix the problem so the script is now aborting") quit() elif time.time()-time_entered > 5 : failsafe_count += 1 print('We appear to be stuck so attempting to move the mouse and see if this fixes it') #print('For debug:') #print(runescape_window.bottom_right_corner[0], runescape_window.top_left_corner[0]) #print(runescape_window.bottom_right_corner[1], runescape_window.top_left_corner[1]) realmouse.move_mouse_to(random.randint(runescape_window.top_left_corner[0], runescape_window.bottom_right_corner[0]), random.randint(runescape_window.top_left_corner[1], runescape_window.bottom_right_corner[1])) #pyautogui.click() time_entered = time.time()
def prevent_logout(top_left_corner, bottom_right_corner, runescape_window): seed = random.random() x, y = pyautogui.size() if seed > 0.5: # opens up the sale history tab for 5 seconds then returns to ge tab while(True): realmouse.move_mouse_to(random.randint(0,x), random.randint(0,y)) if len(list(pyautogui.locateAllOnScreen('Tools/screenshots/sale_history_button.png', region=(top_left_corner[0], top_left_corner[1], bottom_right_corner[0]-top_left_corner[0], bottom_right_corner[1]-top_left_corner[1]))))>0: move_mouse_to_box('Tools/screenshots/sale_history_button.png', top_left_corner, bottom_right_corner) pyautogui.click() time.sleep(9*random.random()+1) move_mouse_to_box('Tools/screenshots/grand_exchange_button.png', top_left_corner, bottom_right_corner) pyautogui.click() break else: # examines the money pouch examine_money(bottom_right_corner) # pass in an image and a search region
def move_mouse_to(x, y): """Function to simulate realistic mouse movements in python. The objective of this will be to take in coordinates x,y and move them in a realistic manner. We will be passing in an x,y, that is already 'random' so this function will move to the exact x,y""" # takes current mouse location and stores it while(True): try: curr_x, curr_y = pyautogui.position() # calculates the distance from current position to target position distance = int(((x - curr_x)**2 + (y - curr_y)**2)**0.5) # calculates a random time to make the move take based on the distance duration_of_move = (distance * random.random() / 2000) + 0.5 # move the mouse to our position and takes the time of our duration just # calculated pyautogui.moveTo(x, y, duration_of_move, pyautogui.easeInOutQuad) #pyautogui.moveTo(x, y, duration_of_move, pyautogui.easeOutElastic) break except: print('paused for 10 seconds') time.sleep(10)
def sample(self, batch_size): """Sample a batch of experiences. Parameters ---------- batch_size: int How many transitions to sample. Returns ------- obs_batch: np.array batch of observations act_batch: np.array batch of actions executed given obs_batch rew_batch: np.array rewards received as results of executing act_batch next_obs_batch: np.array next set of observations seen after executing act_batch done_mask: np.array done_mask[i] = 1 if executing act_batch[i] resulted in the end of an episode and 0 otherwise. """ idxes = [random.randint(0, len(self._storage) - 1) for _ in range(batch_size)] return self._encode_sample(idxes)
def test_against_numpy_nanstd(self): source = [np.random.random((16, 12, 5)) for _ in range(10)] for arr in source: arr[randint(0, 15), randint(0, 11), randint(0, 4)] = np.nan stack = np.stack(source, axis = -1) for axis in (0, 1, 2, None): for ddof in range(4): with self.subTest('axis = {}, ddof = {}'.format(axis, ddof)): from_numpy = np.nanstd(stack, axis = axis, ddof = ddof) from_ivar = last(istd(source, axis = axis, ddof = ddof, ignore_nan = True)) self.assertSequenceEqual(from_numpy.shape, from_ivar.shape) self.assertTrue(np.allclose(from_ivar, from_numpy))
def downsample_bam(in_name, out_name, downsample_rate, restrict_chrom=None): """ Downsamples a bam. Optionally also restricts the output to a single chromosome. """ f = create_bam_infile(in_name) g, tids = create_bam_outfile(out_name, None, None, template=f) if restrict_chrom is None: bam_iter = f else: bam_iter = f.fetch(restrict_chrom) should_write = {} for r in bam_iter: if should_write.has_key(r.qname): if should_write[r.qname]: g.write(r) else: if random.random() < downsample_rate: should_write[r.qname] = True g.write(r) else: should_write[r.qname] = False g.close()
def __init__(self, val_init, val_min, val_max, decimals=0, extreme=0): ''' Construct AutoParamMinMax object @param val_init: Initial value for parameter @param val_min: Minimum value for param @param val_max: Maximum value for parameter @param decimals: Number of decimals to include in the random number @param extreme: Either the maximum or minimum is chosen every extreme number of iterations. Using a value of one will be an extreme value every time. Using a value of zero will always choose a random value. ''' self.val = val_init self.val_init = val_init self.val_min = val_min self.val_max = val_max self.n = 0 self.n_max = extreme self.decimals = decimals
def perturb(self): ''' Peturb the paramter by choosing a random value between val_min and val_max. Will choose a random number with precision specified by decimals. Will optionally pick the min or the max value after a specified number of perturb calls ''' if self.n == self.n_max - 1: # Choose and extreme value self.val = random.sample([self.val_min, self.val_max], 1)[0] self.n = 0 else: if self.decimals == 0: self.val = random.randint(self.val_min,self.val_max) else: self.val = random.random() * (self.val_max - self.val_min + 10**-self.decimals) + (self.val_min - 0.5 * 10**-self.decimals) self.val = round(self.val, ndigits=self.decimals) if self.n_max > 0: self.n += 1
def __bootstrap(self): # Wrapper around the real bootstrap code that ignores # exceptions during interpreter cleanup. Those typically # happen when a daemon thread wakes up at an unfortunate # moment, finds the world around it destroyed, and raises some # random exception *** while trying to report the exception in # __bootstrap_inner() below ***. Those random exceptions # don't help anybody, and they confuse users, so we suppress # them. We suppress them only when it appears that the world # indeed has already been destroyed, so that exceptions in # __bootstrap_inner() during normal business hours are properly # reported. Also, we only suppress them for daemonic threads; # if a non-daemonic encounters this, something else is wrong. try: self.__bootstrap_inner() except: if self.__daemonic and _sys is None: return raise
def request(url, check, close=True, redirect=True, error=False, proxy=None, post=None, headers=None, mobile=False, XHR=False, limit=None, referer=None, cookie=None, timeout='30'): try: r = client.request(url, close=close, redirect=redirect, proxy=proxy, post=post, headers=headers, mobile=mobile, XHR=XHR, limit=limit, referer=referer, cookie=cookie, timeout=timeout) if r == None and error == False: return r if check in str(r) or str(r) == '': return r proxies = sorted(get(), key=lambda x: random.random()) proxies = sorted(proxies, key=lambda x: random.random()) proxies = proxies[:3] for p in proxies: p += urllib.quote_plus(url) if not post == None: p += urllib.quote_plus('?%s' % post) r = client.request(p, close=close, redirect=redirect, proxy=proxy, headers=headers, mobile=mobile, XHR=XHR, limit=limit, referer=referer, cookie=cookie, timeout='20') if check in str(r) or str(r) == '': return r except: pass
def geturl(url): try: r = client.request(url, output='geturl') if r == None: return r host1 = re.findall('([\w]+)[.][\w]+$', urlparse.urlparse(url.strip().lower()).netloc)[0] host2 = re.findall('([\w]+)[.][\w]+$', urlparse.urlparse(r.strip().lower()).netloc)[0] if host1 == host2: return r proxies = sorted(get(), key=lambda x: random.random()) proxies = sorted(proxies, key=lambda x: random.random()) proxies = proxies[:3] for p in proxies: p += urllib.quote_plus(url) r = client.request(p, output='geturl') if not r == None: return parse(r) except: pass
def generate_graphs(self, n_edges_list, use_seed=True): """For each number of edges (n_edges) in n_edges_list create an Erdos Renyi Precision Graph that allows us to sample from later. Parameters ---------- n_edges : list[int] or int list of number of edges for each graph or scalar if only one graph is wanted use_seed : bool indicates if seed shall be reset """ if use_seed and self.seed is not None: random.seed(self.seed) n_edges = n_edges_list if type(n_edges_list) is list \ else [n_edges_list] self.graphs = [ErdosRenyiPrecisionGraph(self.n_vertices, n_es) for n_es in n_edges]
def download_lyrics(artist, url): print url time.sleep(random() + 2) page = urllib2.urlopen(url).read() soup = BeautifulSoup(page, 'html.parser') # Get the song title song_title = soup.find('title').get_text().split(' - ')[1].lower().replace('/', ' ').replace(' ', '_') # Get the lyrics div lyrics = soup.findAll('div', {'class': ''}) for i in lyrics: lyrics = i.get_text().strip() if len(lyrics) > 10: with open('artists/' + artist + '/' + song_title + '.txt', 'wb') as w: cleaned_lyrics = lyrics.replace('\r\n', ' *BREAK* ').replace('\n', ' *BREAK* ').replace(' ', ' ') w.write(cleaned_lyrics.encode('utf-8'))
def download_songs(url): time.sleep(random.random() * 0.5) try: page = urllib2.urlopen(url).read() soup = BeautifulSoup(page, 'html.parser') # Get the artist name artist_name = soup.findAll('h1')[0].get_text()[:-7].lower().replace(' ', '_') # Store all songs for a given artist with open('artist_data/'+artist_name+'.txt', 'wb') as w: for song in soup.findAll('a', {'target': '_blank'}): if 'lyrics/' in song['href']: song_url = song['href'][1:].strip() w.write(song_url + '\n') except urllib2.HTTPError: print '404 not found'
def __init__(self, auth_provider, device_info=None): self.log = logging.getLogger(__name__) self._auth_provider = auth_provider # mystical unknown6 - resolved by PokemonGoDev self._signal_agglom_gen = False self._signature_lib = None if RpcApi.START_TIME == 0: RpcApi.START_TIME = get_time(ms=True) if RpcApi.RPC_ID == 0: RpcApi.RPC_ID = int(random.random() * 10 ** 18) self.log.debug('Generated new random RPC Request id: %s', RpcApi.RPC_ID) # data fields for unknown6 self.session_hash = os.urandom(32) self.token2 = random.randint(1,59) self.course = random.uniform(0, 360) self.device_info = device_info
def __init__(self, fd, request, chunksize=DEFAULT_CHUNK_SIZE): """Constructor. Args: fd: io.Base or file object, The stream in which to write the downloaded bytes. request: googleapiclient.http.HttpRequest, the media request to perform in chunks. chunksize: int, File will be downloaded in chunks of this many bytes. """ self._fd = fd self._request = request self._uri = request.uri self._chunksize = chunksize self._progress = 0 self._total_size = None self._done = False # Stubs for testing. self._sleep = time.sleep self._rand = random.random
def __init__(self, price=16, date='2015-01-05', datetime='2015-01-05 09:01:00', sending_time='2015-01-05 09:01:00', transact_time='', amount=10, towards=1, code='000001', user='root', strategy='example01', btype='0x01', bid_model='strategy', amount_model='amount', order_id=str(random.random()), trade_id='', status='100'): self.price = price self.date = date self.datetime = datetime self.sending_time = sending_time # ???? self.transact_time = transact_time self.amount = amount self.towards = towards # side self.code = code self.user = user self.strategy = strategy self.type = btype # see below self.bid_model = strategy self.amount_model = amount_model self.order_id = order_id self.trade_id = trade_id self.status = status
def setUp(self): # gc.collect() self.zeroVec = Vector2() self.e1 = Vector2(1, 0) self.e2 = Vector2(0, 1) # self.t1 = (random(), random()) self.t1 = (1.2, 3.4) self.l1 = list(self.t1) self.v1 = Vector2(self.t1) # self.t2 = (random(), random()) self.t2 = (5.6, 7.8) self.l2 = list(self.t2) self.v2 = Vector2(self.t2) # self.s1 = random() # self.s2 = random() self.s1 = 5.6 self.s2 = 7.8
def random_different_from(top_range, number_to_not_repeat): result = random.randint(0, top_range-1) while result == number_to_not_repeat: result = random.randint(0, top_range-1) return result
def __init__(self,location = None): random.seed() self.name = generate_name() self.location = location self.cities = []
def generate_name(): alphabet = 'abcdefghijklmnopqrstuvwxyz' wordlist = [] with open ("words", 'r') as fo: for word in fo: if len(word) < 5: continue else: wordlist.append(word.strip()) namelength = random.randrange(4) pref = random.choice(wordlist)[0:3] pref = pref[0].upper() + pref[1:3] if random.random() > 0.5: suff = random.choice(wordlist)[-3:] else: suff = random.choice(wordlist)[:3] for i in range(namelength): pref = pref + random.choice(alphabet) name = pref + suff return name
def random_sleep(mean=0.3, tolerance=0.15): sleep_time = mean - tolerance + 2 * tolerance * random() sleep(sleep_time)
def _update_square(self, terrain, x, y, square_len): """Update the midpoint of a square. Midpoint becomes average of square corners plus a random offset determined by noise. Args: terrain (Terrain): Terrain to update. x (int): X coordinate of center of square. y (int): Y coordinate of center of square. square_len (int): Length of one side of square. Returns: Terrain: New terrain with updated square center. """ half_len = square_len / 2 # Impossible to attempt to access neighbours out of terrain bounds mean_height = sum([terrain[x - half_len, y - half_len], terrain[x - half_len, y + half_len], terrain[x + half_len, y - half_len], terrain[x + half_len, y + half_len]]) / 4.0 frequency = terrain.length / square_len offset = (random.random() - 0.5) * self.amp_from_freq(frequency) if not 0 <= mean_height + offset <= 1: if mean_height + offset > 1: terrain[x, y] = 1 else: terrain[x, y] = 0 else: terrain[x, y] = mean_height + offset return terrain
def _update_diamond(self, terrain, x, y, diamond_len): """Update the midpoint of a diamond. Midpoint becomes average of diamond corners plus a random offset determined by noise. Args: terrain (Terrain): Terrain to update. x (int): X coordinate of center of diamond. y (int): Y coordinate of center of diamond. diamond_len (int): Length of one corner of diamond to other. Returns: Terrain: New terrain with updated square center. """ half_len = diamond_len / 2 # If on edge of terrain, only access 3 neighbours to avoid leaving terrain bounds neighbours = [] if x != 0: neighbours.append(terrain[x - half_len, y]) if y != 0: neighbours.append(terrain[x, y - half_len]) if x != terrain.width - 1: neighbours.append(terrain[x + half_len, y]) if y != terrain.length - 1: neighbours.append(terrain[x, y + half_len]) mean_height = sum(neighbours) / float(len(neighbours)) frequency = terrain.length / diamond_len offset = (random.random() - 0.5) * self.amp_from_freq(frequency) if not 0 <= mean_height + offset <= 1: if mean_height + offset > 1: terrain[x, y] = 1 else: terrain[x, y] = 0 else: terrain[x, y] = mean_height + offset return terrain
def _init_gradients(self, vec_magnitude): """Initialize all gradient vectors to be in random directions with the same magnitude. Args: vec_magnitude (float): Magnitude of all gradient vectors. """ self._grad_vecs = [[(0, 0) for _ in range(self._width_in_squares+1)] for _ in range(self._length_in_squares+1)] """list[list[tuple(float, float)]]: Grid of gradient vectors.""" for x in range(self._width_in_squares+1): for y in range(self._length_in_squares+1): x_val = (random.random() - 0.5) * 2 * vec_magnitude y_val = math.sqrt(vec_magnitude**2 - x_val**2) * random.choice([1, -1]) self._grad_vecs[y][x] = (x_val, y_val)
def _get_noise_at(self, x, y): """Get perlin noise at a point in terrain. Does this by choosing a random gradient vector for each grid corner (done at initialization) and taking their dot products with the displacement vectors to each point in the grid. The generated values are then interpolated between based on distance to each corner from the desired point. Args: x (int): X coordinate of requested point. y (int): Y coordinate of requested point. Returns: float: Height of point on terrain, between 0 and 1 inclusive. """ grid_x = x / float(self._square_len) # X value within grid of gradient vectors grid_y = y / float(self._square_len) # Y value within grid of gradient vectors left_x, right_x, upper_y, lower_y = self._get_corners(grid_x, grid_y) x_weight = grid_x - left_x y_weight = grid_y - upper_y # ul = upper left, lr = lower right, etc. ul_influence_val = self._get_influence_val(left_x, upper_y, grid_x, grid_y) ur_influence_val = self._get_influence_val(right_x, upper_y, grid_x, grid_y) ll_influence_val = self._get_influence_val(left_x, lower_y, grid_x, grid_y) lr_influence_val = self._get_influence_val(right_x, lower_y, grid_x, grid_y) # Interpolate between top two and bottom two influence vals, then interpolate between them using y_weight upper_influence_val = self._interpolate_between(ul_influence_val, ur_influence_val, x_weight) lower_influence_val = self._interpolate_between(ll_influence_val, lr_influence_val, x_weight) interpolated_val = self._interpolate_between(upper_influence_val, lower_influence_val, y_weight) # Normalize interpolated_val to be between 0 and 1, return as height # Can range from 0.5 to -0.5, add 0.5 to achieve proper result height = interpolated_val + 0.5 # Some margin of error, ensure is still between 0 and 1 return round(height) if not 0 <= height <= 1 else height
def generate_synthetic(): import random max_nodes=200 min_nodes=100 community_num_nodes=10 graphs=[] labels=[] com_1= nx.caveman_graph(1, community_num_nodes) com_2= nx.star_graph(community_num_nodes) for i in range(500): num_nodes= random.randint(min_nodes, max_nodes) graph= nx.fast_gnp_random_graph(num_nodes, 0.1) graph = nx.disjoint_union(graph,com_1) for i in range(num_nodes,graph.number_of_nodes()): for j in range(num_nodes): if random.random() > 0.9: graph.add_edge(graph.nodes()[i], graph.nodes()[j]) graphs.append(graph) labels.append(1) num_nodes = random.randint(min_nodes, max_nodes) graph = nx.fast_gnp_random_graph(num_nodes, 0.1) for i in range(num_nodes, graph.number_of_nodes()): for j in range(num_nodes): if random.random() > 0.9: graph.add_edge(graph.nodes[i], graph.nodes[j]) graphs.append(graph) labels.append(0) return graphs,labels
def _real_upload_video(self, insert_request): response = None error = None retry = 0 print('File upload in progress...', end='') while response is None: try: status, response = insert_request.next_chunk() print('.', end='') if 'id' in response: print() return response['id'] except HttpError as err: if err.resp.status in RETRIABLE_STATUS_CODES: error = True else: raise except RETRIABLE_EXCEPTIONS: error = True if error: retry += 1 if retry > MAX_RETRIES: raise Exception('Maximum retry are fail') sleep_seconds = random.random() * 2 ** retry time.sleep(sleep_seconds)
def random(): """Normalised vector containing random entries in all dimensions""" vec = Vector([random.random(), random.random(), random.random()]) vec.normalize() return vec
def rand_for_param_var(): """Generate random number between -1 and 1""" return random.choice([-1, 1]) * rand_in_range(0, 1)
def rand_in_range(lower, upper): """Generate random number between lower and upper""" return (random.random() * (upper - lower)) + lower
def points_for_floor_split(self): """Calculate Poissonly distributed points for stem start points""" array = [] # calculate approx spacing radius for dummy stem self.tree_scale = self.param.g_scale + self.param.g_scale_v stem = Stem(0, None) stem.length = self.calc_stem_length(stem) rad = 2.5 * self.calc_stem_radius(stem) # generate points for _ in range(self.param.floor_splits + 1): point_ok = False while not point_ok: # distance from center proportional for number of splits, tree scale and stem radius dis = sqrt(rand_in_range(0, 1) * self.param.floor_splits / 2.5 * self.param.g_scale * self.param.ratio) # angle random in circle theta = rand_in_range(0, 2 * pi) pos = Vector([dis * cos(theta), dis * sin(theta), 0]) # test point against those already in array to ensure it will not intersect point_m_ok = True for point in array: if (point[0] - pos).magnitude < rad: point_m_ok = False break if point_m_ok: point_ok = True array.append((pos, theta)) return array
def construct(params, seed=0, render=False, out_path=None): """Construct the tree""" if seed == 0: seed = int(random.random() * 9999999) # print('Seed: ', seed) random.seed(seed) Tree(TreeParam(params)).make() if render: bpy.data.scenes['Scene'].render.filepath = out_path bpy.ops.render.render(write_still=True) #mod = __import__('ch_trees.parametric.tree_params.quaking_aspen', fromlist=['']) #reload(mod) #construct(mod.params)
def q_prod(sym): """Production rule for Q""" ret = [] prev_ang = 0 n = int(random() * 2 + 7) for ind in range(8): offset = 1 - (__base_width__ - sym.parameters["w"]) / __base_width__ offset += ind / 8 / 12 dang = 30 + 85 * offset if offset <= 0.7: b_len = 0.4 + 0.6 * offset / 0.7 else: b_len = 0.4 + 0.6 * (1.0 - offset) / 0.3 ret.extend([LSymbol("/", {"a": prev_ang + 75 + random() * 10}), LSymbol("&", {"a": dang}), LSymbol("!", {"w": sym.parameters["w"] * 0.08 * b_len}), LSymbol("["), LSymbol("F", {"l": sym.parameters["w"] / 2}), LSymbol("A", {"w": 0.08 * b_len, "l": 0.6 * b_len}), LSymbol("]"), LSymbol("!", {"w": sym.parameters["w"]}), LSymbol("^", {"a": dang}), LSymbol("F", {"l": sym.parameters["l"]})]) ret.append(LSymbol("Q", {"w": max(0, sym.parameters["w"] - __base_width__ / 11), "l": sym.parameters["l"]})) return ret
def a_prod(sym): """Production rule for A""" ret = [] w_d = sym.parameters["w"] / 14 prev_rot = 0 n = int(random() * 3 + 15.5) for ind in range(n): wid = sym.parameters["w"] - ind * w_d l_count = int((sqrt(n - ind) + 2) * 4 * sym.parameters["l"]) ret.extend([LSymbol("!", {"w": wid}), LSymbol("F", {"l": sym.parameters["l"] / 3}), LSymbol("/", {"a": prev_rot + 140}), LSymbol("&", {"a": 60}), LSymbol("!", {"w": wid * 0.4}), LSymbol("["), LSymbol("F", {"l": sqrt(n - ind) * sym.parameters["l"] / 3, "leaves": l_count, "leaf_d_ang": 40, "leaf_r_ang": 140}), LSymbol("^", {"a": random() * 30 + 30}), LSymbol("F", {"l": sqrt(n - ind) * sym.parameters["l"] / 4, "leaves": l_count, "leaf_d_ang": 40, "leaf_r_ang": 140}), LSymbol("%"), LSymbol("]"), LSymbol("!", {"w": wid}), LSymbol("^", {"a": 60}), LSymbol("\\", {"a": prev_rot + 140}), LSymbol("+", {"a": -5 + random() * 10}), LSymbol("^", {"a": -7.5 + random() * 15})]) prev_rot += 140 ret.append(LSymbol("F", {"l": sym.parameters["l"] / 2})) return ret
def q_prod(sym): """Production rule for Q""" prop_off = sym.parameters["t"] / __t_max__ if prop_off < 1: res = [LSymbol("!", {"w": 0.85 + 0.15 * sin(sym.parameters["t"])}), LSymbol("^", {"a": random() - 0.65})] if prop_off > __p_max__: d_ang = 1 / (1 - __p_max__) * (1 - prop_off) * 110 + 15 res.extend([LSymbol("!", {"w": 0.1})]) for ind in range(int(random() * 2 + 5)): r_ang = sym.parameters["t"] * 10 + ind * (random() * 50 + 40) e_d_ang = d_ang * (random() * 0.4 + 0.8) res.extend([LSymbol("/", {"a": r_ang}), LSymbol("&", {"a": e_d_ang}), LSymbol("["), LSymbol("A"), LSymbol("]"), LSymbol("^", {"a": e_d_ang}), LSymbol("\\", {"a": r_ang})],) res.append(LSymbol("F", {"l": 0.05})) else: res.append(LSymbol("F", {"l": 0.15})) res.append(LSymbol("Q", {"t": sym.parameters["t"] + __d_t__})) else: res = [LSymbol("!", {"w": 0}), LSymbol("F", {"l": 0.15})] return res
def system(): """initialize and iterate the system as appropriate""" l_sys = LSystem(axiom=[LSymbol("!", {"w": 0.2}), LSymbol("/", {"a": random() * 360}), LSymbol("Q", {"t": 0})], rules={"Q": q_prod, "A": a_prod}, tropism=Vector([0, 0, -1]), thickness=0.2, bendiness=0, leaf_shape=10, leaf_scale=1, leaf_scale_x=0.1, leaf_bend=0) l_sys.iterate_n(100) return l_sys
def a_prod(sym): """Production rule for A""" ret = [] n = int(random() * 5 + 22.5) w_d = sym.parameters["w"] / (n - 1) prev_rot = 0 for ind in range(n): wid = sym.parameters["w"] - ind * w_d ang = random() * 10 + 25 ret.extend([LSymbol("!", {"w": wid}), LSymbol("F", {"l": sym.parameters["l"] / 3}), LSymbol("/", {"a": prev_rot + 140}), LSymbol("&", {"a": ang}), LSymbol("!", {"w": wid * 0.3}), LSymbol("["), LSymbol("F", {"l": 0.75 * sqrt(n - ind) * sym.parameters["l"] / 3, "leaves": 25, "leaf_d_ang": 40, "leaf_r_ang": 140}), LSymbol("^", {"a": 20}), LSymbol("F", {"l": 0.75 * sqrt(n - ind) * sym.parameters["l"] / 3, "leaves": 25, "leaf_d_ang": 40, "leaf_r_ang": 140}), LSymbol("%"), LSymbol("]"), LSymbol("!", {"w": wid}), LSymbol("^", {"a": ang}), LSymbol("\\", {"a": prev_rot + 140}), LSymbol("^", {"a": 1.2})]) prev_rot += 140 return ret
def d1_ang(): """return random first split angle""" return random() * 40 + 60
def d2_ang(): """return random second split angle""" return random() * 40 + 100
def q_prod(sym): """Production rule for Q""" ret = [LSymbol("!", {"w": sym.parameters["w"]}), LSymbol("&", {"a": 90}), LSymbol("+", {"a": random() * 360}), LSymbol("!", {"w": sym.parameters["bw"]})] b_count = int(random() * 2) + 5 for _ in range(b_count): rand = random() * 130 / b_count ret.extend([LSymbol("+", {"a": rand}), LSymbol("["), LSymbol("^", {"a": 5 / max(sym.parameters["bl"] * sym.parameters["bl"], 0.05 ) - 30 * (random() * 0.2 + 0.9)}), LSymbol("A", {"l": sym.parameters["bl"], "w": sym.parameters["bw"]}), LSymbol("]"), LSymbol("+", {"a": (360 / b_count) - rand})]) ret.extend([LSymbol("!", {"w": sym.parameters["w"]}), LSymbol("$"), LSymbol("F", {"l": sym.parameters["l"], "leaves": int(sym.parameters["l"] * __n_leaves__ / 3), "leaf_d_ang": 20, "leaf_r_ang": 140}), LSymbol("Q", {"w": sym.parameters["w"] - 0.2 / 15, "l": sym.parameters["l"] * 0.95, "bw": sym.parameters["bw"] * __width_r__, "bl": sym.parameters["bl"] * __branch_length_r__}), LSymbol("%")]) return ret
def a_prod(sym): """Production rule for A""" if random() < sym.parameters["l"]: ang = random() * __sec_branch_ang_v__ + __sec_branch_ang__ return [LSymbol("!", {"w": sym.parameters["w"]}), LSymbol("^", {"a": random() * 15 - 5}), LSymbol("F", {"l": sym.parameters["l"], "leaves": int(sym.parameters["l"] * __n_leaves__), "leaf_d_ang": 40, "leaf_r_ang": 140}), LSymbol("-", {"a": ang / 2}), LSymbol("["), LSymbol("A", {"l": sym.parameters["l"] * __length_r__, "w": sym.parameters["w"] * __width_r__}), LSymbol("]"), LSymbol("+", {"a": ang}), LSymbol("["), LSymbol("A", {"l": sym.parameters["l"] * __length_r__, "w": sym.parameters["w"] * __width_r__}), LSymbol("]"), LSymbol("-", {"a": ang / 2}), LSymbol("A", {"l": sym.parameters["l"] * __length_r__, "w": sym.parameters["w"] * __width_r__})] else: return [LSymbol("!", {"w": sym.parameters["w"]}), LSymbol("^", {"a": random() * 15 - 5}), LSymbol("F", {"l": sym.parameters["l"], "leaves": int(sym.parameters["l"] * __n_leaves__), "leaf_d_ang": 40, "leaf_r_ang": 140}), LSymbol("A", {"l": sym.parameters["l"] * __length_r__, "w": sym.parameters["w"] * __width_r__})]
