def cubic_curve_example(): # create the plot fig, ax = plt.subplots() # sample per segment num_samples = 100 # first segment p0 = SPoint(1, 1, 0) p1 = SPoint(3, 2, 45) # compute the coeff to fit the points coeff = cubic_curve(p0, p1) # add the segment x_sample, y_segment = compute_segment_points(p0.x, p1.x, coeff) utils.add_points(x_sample, y_segment, ax) # second segment p0 = SPoint(3, 2, 45) p1 = SPoint(3.5, 3.5, 80) coeff = cubic_curve(p0, p1) x_sample, y_segment = compute_segment_points(p0.x, p1.x, coeff) utils.add_points(x_sample, y_segment, ax, "r") # plot everything utils.plot_build(fig, ax) plt.show()
def command_not8th(self, data): if on_cooldown(self.cooldowns['!not8th'], three_mins): return True for better in self.betters: add_points(self, better, 1) self.cooldowns['!not8th'] = set_cooldown() return 'Yay not 8th! All betters get 1 %s! (%s)' % ( self.fmt_currency_name(1), ', '.join(self.betters))
def draw_long_spline(spline_sequence, xlim, ylim, plot_vectors=False): """Draw a spline_sequence on a plot spline_sequence = [all_points, all_points, ...] """ logg = logging.getLogger(f"c.{__name__}.draw_long_spline") # logg.setLevel("INFO") logg.debug(f"Starting draw_long_spline") fig, ax = plt.subplots() ax.set_xlim(*xlim) ax.set_ylim(*ylim) for all_points in spline_sequence: for i in range(len(all_points) - 1): p0 = all_points[i] p1 = all_points[i + 1] if plot_vectors: utils.add_vector(p0, ax, color="k", vec_len=20) # spline_x, spline_y = compute_spline(p0, p1) spline_x, spline_y = compute_thick_spline(p0, p1, 40) utils.add_points(spline_x, spline_y, ax, color="y", marker=".", ls="") if plot_vectors: utils.add_vector(p1, ax, color="k", vec_len=20) utils.plot_build(fig, ax) plt.show()
def command_bonus(self, data): if on_cooldown(self.cooldowns['!bonus'], three_mins): return True for better in self.betters: add_points(self, better, 5) self.cooldowns['!bonus'] = set_cooldown() return 'Yay Bonus! All betters get 5 %s! (%s)' % ( self.fmt_currency_name(5), ', '.join(self.betters))
def example_spline(): """ """ logg = logging.getLogger(f"c.{__name__}.example_spline") logg.setLevel("INFO") logg.debug(f"Starting example_spline") # create the plot fig, ax = plt.subplots() ax.set_xlim(0, 4) ax.set_ylim(-3, 4) # sample per segment num_samples = 100 # first segment p0 = SPoint(1, 1, 30) # p1 = SPoint(3, 2, 45) p1 = SPoint(2.6, 3, 60) logg.debug(f"p0: {p0} p1: {p1}") # plot the points utils.add_vector(p0, ax, color="k") utils.add_vector(p1, ax, color="k") # compute the spline spline_x, spline_y = compute_spline(p0, p1, ax=ax) # plot the finished spline utils.add_points(spline_x, spline_y, ax, color="y") # plot everything utils.plot_build(fig, ax) plt.show()
def example_thick_spline(p0, p1, thickness, scale): """ """ logg = logging.getLogger(f"c.{__name__}.example_thick_spline") logg.setLevel("INFO") logg.debug(f"\nStarting example_thick_spline") logg.debug(f"p0: {p0} p1: {p1}") # create the plot fig, ax = plt.subplots() ax.set_xlim(-2 * scale, 5 * scale) ax.set_ylim(-3 * scale, 5 * scale) # ax.set_xlim(-1 * scale, 1.5 * scale) # ax.set_ylim(-2.5 * scale, 2.5 * scale) # compute the spline spline_x, spline_y = compute_thick_spline(p0, p1, thickness, ax=ax) # spline_x, spline_y = compute_thick_spline(p0, p1, thickness) # plot the finished spline utils.add_points(spline_x, spline_y, ax, color="k", marker=".", ls="") # plot everything utils.plot_build(fig, ax) plt.show()
def compute_spline(p0, p1, num_samples=100, ax=None): """Compute the cubic spline between two points * translate to the origin and rotate the points to have both on the x axis * compute the spline * rotate and translate to original position """ logg = logging.getLogger(f"c.{__name__}.compute_spline") logg.setLevel("INFO") logg.debug(f"Starting compute_spline") # translate and rotate the point to the origin rot_p0, rot_p1, dir_01 = translate_points_to_origin(p0, p1) # plot the rotated vectors if not ax is None: utils.add_vector(rot_p0, ax, color="r") utils.add_vector(rot_p1, ax, color="r") # compute the spline points coeff = cubic_curve(rot_p0, rot_p1) x_sample, y_segment = compute_segment_points(rot_p0.x, rot_p1.x, coeff) if not ax is None: utils.add_points(x_sample, y_segment, ax, color="g") # rototranslate points to the original position rototran_x, rototran_y = rototranslate_points( x_sample, y_segment, -dir_01, p0.x, p0.y, ) return rototran_x, rototran_y
def get_seat_for_direction(grid: Grid, point: Point, direction: Point) -> Optional[str]: next_stop = add_points(point, direction) next_point = grid.get(next_stop, None) while True: if next_point is None or is_seat(next_point): return next_point next_stop = add_points(next_stop, direction) next_point = grid.get(next_stop, None)
def command_beg(self, data): if get_points(self, self.user) < 5: success = add_points(self, self.user, 5) if success: return '%s tosses %s 5 %s out of pity.' % (NICKNAME, self.user, self.currency_name) else: return 'Get outta here %s! You\'re not broke!' % self.user
def to_tile(self): tile_grid: Grid = Grid() for puzzle_point, tile in self.grid.items(): stripped = tile.strip_border() scaled_point = (puzzle_point[0] * stripped.width, puzzle_point[1] * stripped.width) for child_point, value in stripped.grid.items(): actual_point = add_points(scaled_point, child_point) tile_grid[actual_point] = value return Tile(-1, tile_grid, set())
def command_wipe(self, data): if not self.raid: return True gil = 1 if not on_cooldown(self.cooldowns['!wipe'], one_min): gil = 5 self.cooldowns['!wipe'] = set_cooldown() if add_points(self, self.user, gil): return 'Thanks %s! Have %s %s!' % (self.user, gil, self.fmt_currency_name(gil)) else: return 'Thanks %s!' % self.user
def command_give(self, data): try: amount = int(data[2]) recipient = data[1].lower() if user_exists(self, recipient): if self.user == CHANNEL_NAME: if add_points(self, recipient, amount): return '%s gives %s %s %s' % ( NICKNAME, data[1], amount, self.fmt_currency_name(amount)) if self.user == recipient: return True if amount < 0: return True if sub_points(self, self.user, amount): if add_points(self, recipient, amount): return '%s gives %s %s %s' % ( self.user, data[1], amount, self.fmt_currency_name(amount)) except: pass return True
def run_race(self): winners = list() all_winners = True for racer in self.racers.keys(): result = choice(['win', 'lose']) if result == 'win': if add_points(self.instance, racer, int(self.racers[racer]) * 2): winners.append(racer) else: all_winners = False self.racers = dict() self.instance.cooldowns['!race'] = set_cooldown() self.race_pending = False if len(winners) == 0: return "The briars were everywhere today. No one won their race." if all_winners: return "Everyone won their race! Congratulations %s!" % ', '.join(winners) else: return "The race is over. Congratulations to the winners: %s!" % ', '.join(winners)
def main(): ROOT.gROOT.SetBatch() limits = [ ( 'ExclusionContours_2HDMTypeI_tanb_vs_cba.root', '#bf{2HDM Type I, #it{m_{H}} = 200 GeV}', 1, 10, 26, -0.9, 0.9, 'cos(#beta-#alpha)', utils.h_to_zz_to + utils.lepp + utils.lepm + utils.lepp + utils.lepm, None ), ( 'ExclusionContours_2HDMTypeII_tanb_vs_cba.root', '#bf{2HDM Type II, #it{m_{H}} = 200 GeV}', 1, 10, 26, -0.9, 0.9, 'cos(#beta-#alpha)', utils.h_to_zz_to + utils.lepp + utils.lepm + utils.lepp + utils.lepm, None ), ( 'ExclusionContours_2HDMTypeI_tanb_vs_mH.root', '#bf{2HDM Type I, cos(#beta-#alpha) = -0.1}', 0.5, 18, 80, 200, 400, '#it{m_{H}} [GeV]', utils.h_to_zz_to + utils.lepp + utils.lepm + utils.lepp + utils.lepm + ' + ' + utils.lepp + utils.lepm + utils.nu + utils.nubar, ( 320, 324, 31 ) ), ( 'ExclusionContours_2HDMTypeII_tanb_vs_mH.root', '#bf{2HDM Type II, cos(#beta-#alpha) = -0.1}', 0.5, 10, 35, 200, 400, '#it{m_{H}} [GeV]', utils.h_to_zz_to + utils.lepp + utils.lepm + utils.lepp + utils.lepm + ' + ' + utils.lepp + utils.lepm + utils.nu + utils.nubar, ( 320, 324, 15.6 ) ), ] for file_name, mod_type, minY, maxY, max_maxY, minX, maxX, x_title, channel, patch_vals in limits: file = ROOT.TFile( 'inputs/' + file_name ) first_base_hist = file.Get( 'h_med' ) base_hist = ROOT.TH2F( first_base_hist.GetName() + '_extended', ';%s;tan#beta' % x_title, first_base_hist.GetXaxis().GetNbins(), first_base_hist.GetXaxis().GetXmin(), first_base_hist.GetXaxis().GetXmax(), 100 * first_base_hist.GetYaxis().GetNbins(), first_base_hist.GetYaxis().GetXmin(), 1000 ) obs_name = 'obs' if 'tanb_vs_mH' in file_name: obs_name = 'obsc' types = [ utils.graph_info( 'n2sig', file, 5, 1, 1001 ), utils.graph_info( 'n1sig', file, 3, 1, 1001 ), utils.graph_info( 'p1sig', file, 5, 1, 1001 ), utils.graph_info( 'p2sig', file, ROOT.kWhite, 1, 1001 ), #utils.graph_info( 'med', file, ROOT.kWhite, 1001 ), utils.graph_info( 'medc', file, ROOT.kAzure + 2, 2 ), utils.graph_info( 'obsf', file, ROOT.kOrange + 10, 1, 3844 ), utils.graph_info( obs_name, file, ROOT.kBlack, 1 ), ] graphs = {} single_graphs = {} for item in types: for index in range( item.number ): full_name = 'h_%s_contour_%d' % ( item.name, index ) graphs[ full_name ] = ( utils.add_points( file.Get( full_name ), [] ), item ) single_graphs[ item.name ] = graphs[ full_name ] canvas = ROOT.TCanvas( 'plot_' + file_name.replace( '.root', '' ), '', 600, 600 ) base_hist.Draw( 'axis' ) order = [ 'n2sig', 'n1sig', 'p1sig', 'p2sig', 'med', 'medc', 'obsf', obs_name ] for key1 in order: for key2, ( g, g_info ) in graphs.iteritems(): if key1 in key2: g.SetLineColor( g_info.color ) g.SetLineStyle( g_info.line ) g.SetLineWidth( 2 ) option = 'c' if g_info.fill: g.SetFillColor( g_info.color ) g.SetFillStyle( g_info.fill ) g.SetLineStyle( 1 ) g.SetLineColor( ROOT.kBlack ) option = 'fc' #if 'sig' in g_info.name: # option = '3' g.Draw( option ) base_hist.GetXaxis().SetRangeUser( minX, maxX ) base_hist.GetYaxis().SetRangeUser( minY, max_maxY ) #utils.get_bound( minY, maxY ) ) canvas.Update() the_box = utils.get_box( ROOT.gPad.GetUxmin(), ROOT.gPad.GetUxmax(), maxY, ROOT.gPad.GetUymax() ) base_hist.Draw( 'axis same' ) the_box.Draw( 'l' ) x_l1, y_l1, latex1 = utils.draw_latex( utils.lumi, False ) latex1.DrawLatex( x_l1, y_l1 - 0.105, channel ) latex1.SetTextSize( 20 ) #latex1.DrawLatex( x_l1, y_l1 - 0.16, '2HDM Type I, #it{m_{H}}=200 GeV' ) latex1.SetTextAlign( 22 ) latex1.DrawLatex( 0.535, y_l1 - 0.16, mod_type ) xLeg = 0.62 yLeg = 0.89 leg = utils.create_legend_2hdm( 3 ) leg.AddEntry( single_graphs[ obs_name ][ 0 ], 'Observed', 'l' ) leg.AddEntry( single_graphs[ 'n1sig' ][ 0 ], '#pm1#sigma band', 'f' ) leg.AddEntry( single_graphs[ 'medc' ][ 0 ], 'Expected', 'l' ) leg.AddEntry( single_graphs[ 'n2sig' ][ 0 ], '#pm2#sigma band', 'f' ) leg.AddEntry( None, '', '' ) leg.AddEntry( single_graphs[ 'obsf' ][ 0 ], 'Excluded', 'f' ) leg.Draw() #if patch_vals: # p_x1, p_x2, p_y = patch_vals # utils.patch_bar( p_x1, p_x2, p_y, p_y ) canvas.SetLogy() utils.save( canvas )
def move_south(self, amount: int): self.waypoint_position = add_points(self.waypoint_position, (0, -amount))
def compute_thick_spline(p0, p1, thickness, num_samples=100, ax=None): """Compute the thick cubic spline between two points * translate to the origin and rotate the points to have both on the x axis * compute the spline * make it thicker * rotate and translate to original position """ logg = logging.getLogger(f"c.{__name__}.compute_spline") logg.setLevel("INFO") logg.debug(f"Starting compute_spline") # translate and rotate the point to the origin rot_p0, rot_p1, dir_01 = translate_points_to_origin(p0, p1) logg.debug(f"rot_p0: {rot_p0} rot_p1: {rot_p1}") # compute the normal direction to the vectors np0_ori_rad = rot_p0.ori_rad + pi / 2 np1_ori_rad = rot_p1.ori_rad + pi / 2 # compute the corner points of the thick spline offset_x_0 = cos(np0_ori_rad) * thickness offset_y_0 = sin(np0_ori_rad) * thickness logg.debug(f"offset_x_0: {offset_x_0} offset_y_0: {offset_y_0}") p0t = SPoint(rot_p0.x + offset_x_0, rot_p0.y + offset_y_0, rot_p0.ori_deg) p0b = SPoint(rot_p0.x - offset_x_0, rot_p0.y - offset_y_0, rot_p0.ori_deg) logg.debug(f"p0t: {p0t} p0b: {p0b}") offset_x_1 = cos(np1_ori_rad) * thickness offset_y_1 = sin(np1_ori_rad) * thickness logg.debug(f"offset_x_1: {offset_x_1} offset_y_1: {offset_y_1}") p1t = SPoint(rot_p1.x + offset_x_1, rot_p1.y + offset_y_1, rot_p1.ori_deg) p1b = SPoint(rot_p1.x - offset_x_1, rot_p1.y - offset_y_1, rot_p1.ori_deg) logg.debug(f"p1t: {p1t} p1b: {p1b}") # compute the coeff of the line passing through the points coeff_l = line_curve(p0t, p0b) coeff_r = line_curve(p1t, p1b) logg.debug(f"coeff_l: {coeff_l} coeff_r: {coeff_r}") # compute the spline points coeff_t = cubic_curve(p0t, p1t) coeff_b = cubic_curve(p0b, p1b) x_sample_t, y_segment_t = sample_segment_points(p0t.x, p1t.x, coeff_t) x_sample_b, y_segment_b = sample_segment_points(p0b.x, p1b.x, coeff_b) logg.debug(f"x_sample_t.shape: {x_sample_t.shape}") logg.debug(f"x_sample_b.shape: {x_sample_b.shape}") contour_t, contour_b, x_sample = build_contour( p0t, p0b, p1t, p1b, coeff_l, coeff_r, x_sample_t, y_segment_t, x_sample_b, y_segment_b, ax, ) # compute the top and bottom contours logg.debug(f"x_sample.shape: {x_sample.shape}") logg.debug(f"contour_t.shape: {contour_t.shape}") logg.debug(f"contour_b.shape: {contour_b.shape}") # get the max and min y, aligned on the grid max_y = np.amax(contour_t) min_y = np.amin(contour_b) logg.debug(f"max_y: {max_y} min_y: {min_y}") max_y_aligned = floor(max_y) min_y_aligned = ceil(min_y) logg.debug(f"max_y_aligned: {max_y_aligned} min_y_aligned: {min_y_aligned}") # sample all the points inside the spline, aligned on the grid on_points_x = [] on_points_y = [] for i, x_curr in enumerate(x_sample): for y_curr in range(min_y_aligned, max_y_aligned + 1): if contour_b[i] <= y_curr <= contour_t[i]: on_points_x.append(x_curr) on_points_y.append(y_curr) # rototranslate points to the original position rototran_x, rototran_y = rototranslate_points( on_points_x, on_points_y, -dir_01, p0.x, p0.y, ) # plot everything to debug things if not ax is None: vec_len = 3 ## plot the points utils.add_vector(p0, ax, color="r", vec_len=vec_len) utils.add_vector(p1, ax, color="r", vec_len=vec_len) ## plot the rotated vectors utils.add_vector(rot_p0, ax, color="k", vec_len=vec_len) utils.add_vector(rot_p1, ax, color="k", vec_len=vec_len) ## plot the corner of the spline utils.add_vector(p0t, ax, color="k", vec_len=vec_len) utils.add_vector(p1t, ax, color="k", vec_len=vec_len) utils.add_vector(p0b, ax, color="k", vec_len=vec_len) utils.add_vector(p1b, ax, color="k", vec_len=vec_len) ## plot top and bottom splines # utils.add_points(x_sample_t, y_segment_t, ax, color="b", marker=".", ls="") # utils.add_points(x_sample_b, y_segment_b, ax, color="b", marker=".", ls="") utils.add_points(x_sample_t, y_segment_t, ax, color="r", marker="", ls="-") utils.add_points(x_sample_b, y_segment_b, ax, color="r", marker="", ls="-") ## plot top and bottom contours utils.add_points(x_sample, contour_t, ax, color="r", marker=".", ls="") utils.add_points(x_sample, contour_b, ax, color="r", marker=".", ls="") ## plot on point utils.add_points(on_points_x, on_points_y, ax, color="b", marker=".", ls="") ## plot on point translated back to original position utils.add_points(rototran_x, rototran_y, ax, color="b", marker=".", ls="") return rototran_x, rototran_y
def build_contour( p0t, p0b, p1t, p1b, coeff_l, coeff_r, x_sample_t, y_segment_t, x_sample_b, y_segment_b, ax, ): """TODO: Docstring for build_contour. :p0t: TODO :p0b: TODO :p1t: TODO :p1b: TODO :coeff_l: TODO :coeff_r: TODO :x_sample_t: TODO :y_segment_t: TODO :x_sample_b: TODO :y_segment_b: TODO :returns: TODO """ logg = logging.getLogger(f"c.{__name__}.build_contour") logg.setLevel("INFO") logg.debug(f"Starting build_contour") # regular case, no overlaps if p0t.x <= p1t.x and p0b.x <= p1b.x: # sample the whole line x_sample_l, y_segment_l = sample_segment_points(p0t.x, p0b.x, coeff_l) x_sample_r, y_segment_r = sample_segment_points(p1t.x, p1b.x, coeff_r) logg.debug(f"x_sample_l.shape: {x_sample_l.shape}") logg.debug(f"x_sample_r.shape: {x_sample_r.shape}") # plot everything to debug things if not ax is None: # plot left and right segments utils.add_points(x_sample_l, y_segment_l, ax, color="g", marker=".", ls="") utils.add_points(x_sample_r, y_segment_r, ax, color="g", marker=".", ls="") # /\ if coeff_l[0] >= 0 and coeff_r[0] <= 0: logg.debug(f"/\ coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l, x_sample_t, x_sample_r)) contour_t = np.hstack((y_segment_l, y_segment_t, y_segment_r)) contour_b = y_segment_b # // elif coeff_l[0] >= 0 and coeff_r[0] >= 0: logg.debug(f"// coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l, x_sample_t)) contour_t = np.hstack((y_segment_l, y_segment_t)) contour_b = np.hstack((y_segment_b, y_segment_r)) # \\ elif coeff_l[0] <= 0 and coeff_r[0] <= 0: logg.debug(f"\\\\ coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l, x_sample_b)) contour_t = np.hstack((y_segment_t, y_segment_r)) contour_b = np.hstack((y_segment_l, y_segment_b)) # \/ elif coeff_l[0] <= 0 and coeff_r[0] >= 0: logg.debug(f"\\/ coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l, x_sample_b, x_sample_r)) contour_t = y_segment_t contour_b = np.hstack((y_segment_l, y_segment_b, y_segment_r)) return contour_t, contour_b, x_sample # both ends of p1tb are left of p0bt, this should not happen elif p0t.x <= p1t.x and p0b.x <= p1b.x: # MAYBE call this again with them swapped raise ValueError(f"Swap the points and try again {p0t} {p0b} {p1t} {p1b}") # compute the intersection between the two lines # x = (b2-b1)/(a1-a2) i_x = (coeff_l[1] - coeff_r[1]) / (coeff_r[0] - coeff_l[0]) i_y = coeff_l[0] * i_x + coeff_l[1] logg.debug(f"i_x: {i_x} i_y: {i_y}") # /\ // \\ type, keep the lower part if p0t.x > p1t.x and p0b.x <= p1b.x: x_sample = 0 contour_t = 0 contour_b = 0 x_sample_l, y_segment_l = sample_segment_points(p0b.x, i_x, coeff_l) x_sample_r, y_segment_r = sample_segment_points(p1b.x, i_x, coeff_r) # /\ if coeff_l[0] >= 0 and coeff_r[0] <= 0: logg.debug(f"/\ coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l, x_sample_r)) contour_t = np.hstack((y_segment_l, y_segment_r)) contour_b = y_segment_b # // elif coeff_l[0] >= 0 and coeff_r[0] >= 0: logg.debug(f"// coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l)) contour_t = np.hstack((y_segment_l)) contour_b = np.hstack((y_segment_b, y_segment_r)) # \\ elif coeff_l[0] <= 0 and coeff_r[0] <= 0: logg.debug(f"\\\\ coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_r)) contour_t = np.hstack((y_segment_r)) contour_b = np.hstack((y_segment_l, y_segment_b)) # \/ // \\ type, keep the upper part elif p0t.x <= p1t.x and p0b.x > p1b.x: x_sample = 0 contour_t = 0 contour_b = 0 x_sample_l, y_segment_l = sample_segment_points(p0t.x, i_x, coeff_l) x_sample_r, y_segment_r = sample_segment_points(p1t.x, i_x, coeff_r) # // if coeff_l[0] >= 0 and coeff_r[0] >= 0: logg.debug(f"// coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l, x_sample_t)) contour_t = np.hstack((y_segment_l, y_segment_t)) contour_b = np.hstack((y_segment_r)) # \\ elif coeff_l[0] <= 0 and coeff_r[0] <= 0: logg.debug(f"\\\\ coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l)) contour_t = np.hstack((y_segment_t, y_segment_r)) contour_b = np.hstack((y_segment_l)) # \/ elif coeff_l[0] <= 0 and coeff_r[0] >= 0: logg.debug(f"\\/ coeff_l[0]: {coeff_l[0]} coeff_r[0]: {coeff_r[0]}") x_sample = np.hstack((x_sample_l, x_sample_r)) contour_t = y_segment_t contour_b = np.hstack((y_segment_l, y_segment_r)) # plot everything to debug things if not ax is None: ## plot left and right segments utils.add_points(x_sample_l, y_segment_l, ax, color="g", marker=".", ls="") utils.add_points(x_sample_r, y_segment_r, ax, color="g", marker=".", ls="") ## intersection point utils.add_points([i_x], [i_y], ax, color="g", marker="x", ls="") ## plot the segments utils.add_points( [p0t.x, p0b.x], [p0t.y, p0b.y], ax, color="b", marker="", ls="-" ) utils.add_points( [p1t.x, p1b.x], [p1t.y, p1b.y], ax, color="b", marker="", ls="-" ) return contour_t, contour_b, x_sample
def move_north(self, amount: int): self.current_position = add_points(self.current_position, (0, amount))
def move_east(self, amount: int): self.current_position = add_points(self.current_position, (amount, 0))
def move_forward(self, amount: int): vector: Point = (amount * self.waypoint_position[0], amount * self.waypoint_position[1]) self.current_position = add_points(self.current_position, vector)
def has_sea_monster(self, point: Point) -> bool: transformed_points = [add_points(point, monster_point) for monster_point in sea_monster_points] matches = [self.grid.get(transformed_point, None) == '#' for transformed_point in transformed_points] return all(matches)
def move_west(self, amount: int): self.waypoint_position = add_points(self.waypoint_position, (-amount, 0))