Beispiel #1
0
    def test_right_is_frozen(self):
        """
        Test to determine if is_frozen() correctly identifies a walking
        particle as frozen if the position one RIGHT from the current position
        is in stuck_list (is part of the cluster).

        Case: RIGHT    [x+1, y] in stuck_list
        """
        particle = Particle(axis_length=10, stuck_list=[[0, 0],])
        particle.x, particle.y = -1, 0
        particle.is_frozen()
        self.assertTrue(particle.frozen)
Beispiel #2
0
def addObject(newobject, object, velocity=None):

    newobject = scene.addObject(newobject, object)
    newobject["bonds"] = set()
    if newobject.name in ["Carbon", "Oxygen", "Nitrogen"]:
        newobject["doubles"] = set()
        newobject["triple"] = None
    if velocity != None:
        newobject.localLinearVelocity = velocity
    particle = Particle(newobject)

    return particle
Beispiel #3
0
    def test_down_is_frozen(self):
        """
        Test to determine if is_frozen() correctly identifies a walking
        particle as frozen if the position one DOWN from the current position
        is in stuck_list (is part of the cluster).

        Case: DOWN    [x, y-1] in stuck_list
        """
        particle = Particle(axis_length=10, stuck_list=[[0, 0],])
        particle.x, particle.y = 0, 1
        particle.is_frozen()
        self.assertTrue(particle.frozen)
Beispiel #4
0
 def __init__(self,
              problem: TigerProblem,
              belief=[Particle().state for _ in range(100)],
              exploration=7,
              tier=1):
     self.problem = problem
     self.N = 0  # visitation count
     self.total = 0
     self.V = 0  # score of state
     self.children = dict()
     self.tier = tier  # 1 . Action 0 . Observation
     self.exploration = exploration
Beispiel #5
0
    def _init_particles(self):
        for i in range(self.n_particles):
            particle = None
            particle = Particle(self.n_cluster, self.data)

            if particle.best_score < self.gbest_score:
                self.gbest_centroids = particle.centroids.copy()
                self.gbest_score = particle.best_score
            self.particles.append(particle)
            self.gbest_sse = min(particle.best_sse, self.gbest_sse)
            par = []
            par.append(self.gbest_sse)
 def gen_n_particles_robot(self, n):
     p = []
     for i in range(n):
         x_coord = self.myrobot.x + Random.gauss(0, self.sense_noise * 3)
         y_coord = self.myrobot.y + Random.gauss(0, self.sense_noise * 3)
         yaw = self.myrobot.yaw + Random.gauss(0, self.yaw_noise) * math.pi
         if yaw < 0:
             yaw = 2 * math.pi + yaw
         if yaw > 2 * math.pi:
             yaw %= (2 * math.pi)
         p.append([Particle(x_coord, y_coord, yaw), 0])
     return p
Beispiel #7
0
 def take_damage(self, damage, origin=None):
     was_shield = False
     sa = min(damage, self.shield)
     if self.shield > 0:
         was_shield = True
     self.shield -= sa
     damage -= sa
     self.health -= damage
     if origin:
         delta = origin.pos - self.pos
         dn = helper.try_normalize(delta)
         hitpos = self.pos + dn * self.radius
         if was_shield:
             sound.play("shield")
             for i in range(10):
                 ang = dn.as_polar()[1]
                 ang *= 3.14159 / 180
                 rad = max(self.radius, 5) + 2
                 hp = self.pos + rad * helper.from_angle(
                     ang + random.random() - 0.5)
                 p = Particle([
                     PICO_GREEN, PICO_WHITE, PICO_BLUE, PICO_BLUE,
                     PICO_BLUE, PICO_BLUE, PICO_DARKBLUE
                 ], 1, hp, 0.65 + random.random() * 0.2, dn)
                 self.scene.game_group.add(p)
         else:
             sound.play("hit")
             particles = 10
             if self.radius > 6:
                 particles = 4
                 e = Explosion(hitpos, [PICO_WHITE, PICO_YELLOW, PICO_RED],
                               0.2, 5, "log", 2)
                 self.scene.game_group.add(e)
             for i in range(particles):
                 p = Particle([
                     PICO_WHITE, PICO_YELLOW, PICO_YELLOW, PICO_RED,
                     PICO_LIGHTGRAY
                 ], 1, hitpos, 0.25,
                              helper.random_angle() * 9)
                 self.scene.game_group.add(p)
    def __init__(self):
        self.initialized = False  # make sure we don't perform updates before everything is setup
        rospy.init_node(
            'pf')  # tell roscore that we are creating a new node named "pf"
        self.base_frame = "base_link"  # the frame of the robot base
        self.map_frame = "map"  # the name of the map coordinate frame
        self.odom_frame = "odom"  # the name of the odometry coordinate frame
        self.scan_topic = "scan"  # the topic where we will get laser scans from

        self.n_particles = 300  # the number of particles to use

        self.d_thresh = 0.2  # the amount of linear movement before performing an update
        self.a_thresh = math.pi / 6  # the amount of angular movement before performing an update

        self.laser_max_distance = 2.0  # maximum penalty to assess in the likelihood field model

        # TODO: define additional constants if needed
        self.sd_xy_theta = (0.5, 0.5, math.pi / 10)

        # Setup pubs and subs

        # pose_listener responds to selection of a new approximate robot location (for instance using rviz)
        self.pose_listener = rospy.Subscriber("initialpose",
                                              PoseWithCovarianceStamped,
                                              self.update_initial_pose)
        # publish the current particle cloud.  This enables viewing particles in rviz.
        self.particle_pub = rospy.Publisher("particlecloud",
                                            PoseArray,
                                            queue_size=10)

        # laser_subscriber listens for data from the lidar
        self.laser_subscriber = rospy.Subscriber(self.scan_topic, LaserScan,
                                                 self.scan_received)

        # enable listening for and broadcasting coordinate transforms
        self.tf_listener = TransformListener()
        self.tf_broadcaster = TransformBroadcaster()

        self.particle_cloud = []
        self.mean_particle = Particle()  # Save the most probable particle here

        self.current_odom_xy_theta = [0, 0, 0]

        # request the map from the map server, the map should be of type nav_msgs/OccupancyGrid
        # TODONE: fill in the appropriate service call here.  The resultant map should be assigned be passed
        #       into the init method for OccupancyField
        rospy.wait_for_service('static_map')
        self.map = rospy.ServiceProxy('static_map', GetMap)().map

        # DONE: uncommented the occupancy field initialization after you can successfully fetch the map
        self.occupancy_field = OccupancyField(self.map)
        self.initialized = True
Beispiel #9
0
    def test_take_step_right(self):
        """
        Check: particle.x is increased by one after take_step() moves the 
        particle RIGHT

        Case 2: Move RIGHT: [x+1, y]
        """
        particle = Particle(axis_length=10, stuck_list=[[0, 0],])
        particle.x, particle.y = 5, 5
        particle.take_step(3)     # Move particle RIGHT
        self.assertEqual(
            [6,5], [particle.x, particle.y]
        )
Beispiel #10
0
    def test_take_step_left(self):
        """
        Check: particle.x is decreased by one after take_step() moves the 
        particle LEFT

        Case 2: Move LEFT: [x-1, y]
        """
        particle = Particle(axis_length=10, stuck_list=[[0, 0],])
        particle.x, particle.y = 5, 5
        particle.take_step(2)     # Move particle LEFT
        self.assertEqual(
            [4, 5], [particle.x, particle.y]
        )
 def createParticles(self):
     particles = []
     for j in reversed(range(0, self.yMax, ceil(self.supportRadius * 0.5))):
         for i in range(round(self.xMax / 2), self.xMax,
                        ceil(self.supportRadius * 0.5)):
             if len(particles) >= self.numberOfParticles:
                 break
             positionVector = np.array([i, self.yMax - j])
             prevPositionVector = positionVector
             newParticle = Particle(positionVector)
             newParticle.prevPos = prevPositionVector
             particles.append(newParticle)
     self.particles = particles
	def __init__(self, h, initial_particle_properties):
		'''
			Constructor that initialised the system
			with the initial properties for all the 
			particles in the system, and the kernel 
			width. 
		'''
		self.h = h
		self.count = len(initial_particle_properties)
		self.particles = []
		for particle_properties in initial_particle_properties:
			new_particle = Particle(particle_properties)
			self.particle.append(new_particle)
Beispiel #13
0
    def test_data_association(self):
        robot = Particle(100, 100, 0, is_robot=True)

        landmark1 = Landmark(20, 20)
        landmark2 = Landmark(40, 60)
        landmark_fake2 = Landmark(45, 60)
        landmark3 = Landmark(20, 110)
        robot.landmarks = [landmark1, landmark_fake2, landmark3]
        obs = robot.sense([landmark2], 1)
        o = obs[0]
        prob, idx, ass_obs, ass_jacobian, ass_adjcov = robot.find_data_association(
            o)
        self.assertEqual(idx, 1)
Beispiel #14
0
    def test_take_step_down(self):
        """
        Check: particle.y is decreased by one after take_step() moves the 
        particle DOWN

        Case 2: Move DOWN: [x, y-1]
        """
        particle = Particle(axis_length=10, stuck_list=[[0, 0],])
        particle.x, particle.y = 5, 5
        particle.take_step(1)     # Move particle DOWN
        self.assertEqual(
            [5, 4], [particle.x, particle.y]
        )
def select_new_particle_population(particles):
    number_particles = len(particles)
    weights = [particle.weight for particle in particles]
    population_selection = select_population_from_weights(weights)
    return [
        Particle(
            particles[i].latitude,
            particles[i].longitude,
            particles[i].velocity,
            particles[i].heading,
            1 / number_particles,
        ) for i in population_selection
    ]
Beispiel #16
0
 def onHit(self, amount):
     self.hp -= amount
     self.hitCount = 10
     self.slime_hurt.reset()
     diffX = self.x - self.world.player.x
     HIT_AMOUNT = 15
     self.x_vel += HIT_AMOUNT if diffX > 0 else -HIT_AMOUNT
     audio.onSlimeHit()
     for i in range(0, 10):
         particle = Particle(self.world, self.x + self.width / 2,
                             self.y + self.height / 2, (99, 199, 77))
         self.world.addEntity(particle)
     self.world.camera.shake(5)
Beispiel #17
0
def instantiateMolecule(particles,
                        color=MOLECULE_COLOR,
                        position=None,
                        velocity=None):
    if position == None:
        g_x = randint(0, GRID_X)
        g_y = randint(0, GRID_Y)
    else:
        g_x = int(position.x)
        g_y = int(position.y)

    if velocity == None:
        v_x = uniform(-1, 1)
        v_y = uniform(-1, 1)
        velocity = pygame.Vector2(v_x, v_y)

    if GRID[g_x][g_y]:
        p_x = g_x * MOLECULE_RADIUS * 2 + MOLECULE_RADIUS
        p_y = g_y * MOLECULE_RADIUS * 2 + MOLECULE_RADIUS
        GRID[g_x][g_y] = False
        position = pygame.Vector2(p_x, p_y)
        particles.append(
            Particle(position, velocity, MOLECULE_RADIUS, MOLECULE_MASS,
                     color))
        return

    else:
        for i in range(len(GRID)):
            for j in range(len(GRID[i])):
                if GRID[i][j]:
                    p_x = i * MOLECULE_RADIUS * 2 + MOLECULE_RADIUS
                    p_y = j * MOLECULE_RADIUS * 2 + MOLECULE_RADIUS
                    GRID[i][j] = False
                    position = pygame.Vector2(p_x, p_y)
                    particles.append(
                        Particle(position, velocity, MOLECULE_RADIUS,
                                 MOLECULE_MASS, color))
                    return
    print('The grid is full, too many molecules instantiated.')
Beispiel #18
0
 def particleSpawnerClicks(self, event, ls: list):
     if self.mouseDownPos.x < self.size[0] - 200:
         self.dragging = True
     elif self.withinRect(pygame.Rect((self.size[0] - 95, 420), (80, 40))):
         self.uIParticleSpawn = False
         self.uILandingOpen = True
         self.virtualParticle = Particle(0, Vector(0, 0))
     elif self.withinRect(pygame.Rect((self.size[0] - 190, 220),
                                      (175, 35))):
         self.massTextBoxEditable = True
     elif self.withinRect(pygame.Rect((self.size[0] - 190, 265),
                                      (175, 40))):
         self.positionTextBoxEditable = True
     elif self.withinRect(pygame.Rect((self.size[0] - 190, 320),
                                      (175, 35))):
         self.velocityTextBoxEditable = True
     elif self.withinRect(pygame.Rect((self.size[0] - 190, 365),
                                      (175, 35))):
         self.momentumTextBoxEditable = True
     elif self.withinRect(pygame.Rect((self.size[0] - 190, 420), (90, 40))):
         ls.append(self.virtualParticle)
         self.virtualParticle = Particle(0, Vector(0, 0))
Beispiel #19
0
def SpawnParticle(position,
                  colour,
                  life=2,
                  magnitude=1,
                  size=5,
                  angle=None,
                  spread=math.pi / 4,
                  GRAV=0.25,
                  velocity=None,
                  outline=True):
    particles.append(
        Particle(position, colour, life, magnitude, size, angle, spread, GRAV,
                 velocity, outline))
Beispiel #20
0
 def SolvePso(self,fn="NONE"): 
     self.InitilizeSwarm()
     #the best fit is a particle
     GlobalFit = Particle(self.d)
     GlobalFit.bestFit = 10000
     #set the best fit to a high number
     #f = open(fn,'w')
     for i in range(self.epoch):
         self.UpdateVelocity(self.d,self.w,self.c1,self.c2,GlobalFit)
         GlobalFit = self.GetBestFit(GlobalFit)
         #Only used for creating the test file
         # f.write(str(GlobalFit.bestFit)+"\n")
     return GlobalFit.bestFit
Beispiel #21
0
def main():
    ### CONFIG
    screen_w = 500
    screen_h = 500
    border_on = True
    num_walls = 6
    num_rays = 180
    ### END CONFIG

    pg.init()
    screen = pg.display.set_mode((screen_w, screen_h))

    running = True
    pg.event.set_allowed([pg.QUIT, pg.KEYDOWN, pg.KEYUP])

    p = Particle()
    boundaries = []
    rays = []

    if border_on:
        boundaries.append(Boundary(screen, (0, 0), (screen_w, 0)))
        boundaries.append(Boundary(screen, (screen_w, 0),
                                   (screen_w, screen_h)))
        boundaries.append(Boundary(screen, (screen_w, screen_h),
                                   (0, screen_h)))
        boundaries.append(Boundary(screen, (0, screen_h), (0, 0)))

    for i in range(num_walls):
        boundaries.append(
            Boundary(screen, (randint(0, screen_w), randint(0, screen_h)),
                     (randint(0, screen_w), randint(0, screen_h))))

    for i in range(num_rays):
        rays.append(Ray(p, i * 360 / num_rays))

    while running:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                running = False

        screen.fill((0, 0, 0))

        for b in boundaries:
            b.update(screen)

        p.update(screen)
        for r in rays:
            r.update(screen, p, boundaries)

        pg.display.update()
        pg.time.wait(75)
Beispiel #22
0
def make_univer(n_particles=int(10e6)):
    max_v = 1
    min_v = -1
    particles = [
        Particle(r=Vector2d(random.uniform(-box_size // 2, box_size // 2),
                            random.uniform(-box_size // 2, box_size // 2)),
                 v=Vector2d(random.uniform(min_v, max_v),
                            random.uniform(min_v, max_v)))
    ]
    # global box_size

    i = 1
    while True:
        # if i % (n_particles//100) == 0:
        #     print('box:', i // (n_particles//100) + 1)
        tmp_par = Particle(r=Vector2d(
            random.uniform(-box_size // 2, box_size // 2),
            random.uniform(-box_size // 2, box_size // 2)),
                           v=Vector2d(random.uniform(min_v, max_v),
                                      random.uniform(min_v, max_v)))
        flag = 1
        # for particle1 in particles:
        #     tmp_e = particle1.r - tmp_par.r
        #     if abs(tmp_e) == 0:
        #         continue
        #     tmp_f = forces.base_force(particle1, tmp_par)
        #     if (tmp_f.x*tmp_e.x + tmp_f.y*tmp_e.y) < 0:
        #         flag = 0

        if flag == 1:
            particles.append(tmp_par)
            i += 1

        if i >= n_particles:
            break

        # print(i)
    return particles
Beispiel #23
0
def read(read_path, mode=None):
    particles = []
    with open(read_path, 'r') as inputfile:
        s_tmp = inputfile.read()
        for el in s_tmp.split('\n')[2:]:
            if el != '':
                if mode is None:
                    rx, ry, rz, r, g, b = el.split()
                else:
                    с, rx, ry, rz, c = el.split()
                particles.append(
                    Particle(r=Vector3d(float(rx), float(ry), float(rz)),
                             name=len(particles)))
    return particles
Beispiel #24
0
    def start_population(self):
        population_list = []

        for i in range(self.population):
            x = random.uniform(-512, 512)
            y = random.uniform(-512, 512)

            particle = Particle(x, y, self.x_speed, self.y_speed)
            fitness = particle.run_fitness()
            particle.set_fitness(fitness)

            population_list.append(particle)

        return population_list
Beispiel #25
0
 def initParticle(self):
     self.particleArray = []
     x = -0.625
     #Creating the boundary element
     rho = 1.0
     p = 1.0
     u = 0
     delx = 0.0015625
     h = 2 * 0.006250
     mass = delx
     for i in range(400):
         self.particleArray.append(Particle(x, rho, u, p, mass, h))
         x = x + delx
     x = 0
     delx = 0.00625
     p = 0.1
     mass = 0.00156250
     rho = 0.25
     for i in range(100):
         x = x + delx
         self.particleArray.append(Particle(x, rho, u, p, mass, h))
     self.sP = 80
     self.eP = 480
Beispiel #26
0
def create_particle(states, input_symbols, output_symbols, codec):
    row_size = len(input_symbols) * len(states)
    column_size = len(output_symbols) * len(states)
    pos = np.eye(row_size, column_size, dtype=bool)
    for row in pos:
        np.random.shuffle(row)
    # REVIEW: Whether initializing vel=0  works well
    vel = np.zeros((row_size, column_size))

    particle = Particle(pos, vel)
    particle.mealymachine = create_mealymachine(states,    \
            input_symbols, output_symbols, pos, codec)

    return particle
Beispiel #27
0
 def particle_burst(self, time: float, pos: Vec3, normal: Vec3, count: int,
                    team: int):
     color = (50, 180, 255) if team == 0 else (255, 168, 50)
     self.particles.extend([
         Particle(
             int(4 + 4 * random.random()),
             pos,
             600 * (normal + 0.7 * Vec3.random()),
             Vec3(z=-500),
             0.02,
             color if random.random() < 0.55 else
             (255, 255, 255),  # Some chance for white instead
             time + 0.3 + 0.8 * random.random()) for _ in range(count)
     ])
 def make_particles(self, n_dims, n_particles, **kwargs):
     self.particles = []
     pos = np.random.random((n_particles, n_dims))
     spd = self.speedscale * (np.random.random((n_particles, n_dims)) - 0.5)
     if "value_ranges" in kwargs:
         assert kwargs["value_ranges"].shape == (n_dims, 2)
         kwargs["value_ranges"] = np.asarray(kwargs["value_ranges"])
         pos = pos * (kwargs["value_ranges"][:, 1] - kwargs["value_ranges"]
                      [:, 0]) + kwargs["value_ranges"][:, 0]
     else:
         kwargs["value_ranges"] = None
     for i in range(n_particles):
         self.particles.append(
             Particle(pos[i], spd[i], self.fitness, **kwargs))
Beispiel #29
0
def createInitialParticles():
	global particle_count, robotGuess
	particle_count = int(sys.argv[2])
	for p in range(0, particle_count):
		positionTuple = findRandomPosition()
		i = positionTuple[0]
		j = positionTuple[1]
		theta = positionTuple[2]
		
		#add particle to particle_list
		particle = Particle(i, j, theta, 0)
		particle.set_noise(0.05, 0.05, 5.0)
		particle_list.append(particle)
	robotGuess = meanLocation(particle_list)
Beispiel #30
0
    def test_take_step_up(self):
        """
        Check: particle.y is increased by one after take_step() moves the 
        particle UP

        Case 1: Move UP: [x, y+1]
        """
        particle = Particle(axis_length=10, stuck_list=[[0, 0],])
        particle.x, particle.y = 5, 5
        np.random.seed(0)
        particle.take_step(0)      # Move particle UP
        self.assertEqual(
            [5, 6], [particle.x, particle.y]
        )