Пример #1
0
    def __init__(self, **argd):
        """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
        super(OpenGLComponent, self).__init__()

        # get transformation data and convert to vectors
        self.size = Vector( *argd.get("size", (0,0,0)) )
        self.position = Vector( *argd.get("position", (0,0,0)) )
        self.rotation = Vector( *argd.get("rotation", (0.0,0.0,0.0)) )
        self.scaling = Vector( *argd.get("scaling", (1,1,1) ) )
        
        # for detection of changes
        self.oldrot = Vector()
        self.oldpos = Vector()
        self.oldscaling = Vector()

        self.transform = Transform()

        # name (mostly for debugging)
        self.name = argd.get("name", "nameless")

        # create clock
        self.clock = pygame.time.Clock()
        self.frametime = 0.0

        # get display service
        displayservice = OpenGLDisplay.getDisplayService()
        # link display_signal to displayservice
        self.link((self,"display_signal"), displayservice)
Пример #2
0
    def __init__(self, **argd):
        """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
        super(Container, self).__init__()
        
        # get transformation data and convert to vectors
        self.position = Vector( *argd.get("position", (0,0,0)) )
        self.rotation = Vector( *argd.get("rotation", (0.0,0.0,0.0)) )
        self.scaling = Vector( *argd.get("scaling", (1,1,1) ) )
        
        # for detection of changes
        self.oldrot = Vector()
        self.oldpos = Vector()
        self.oldscaling = Vector()

        # inital apply trasformations
        self.transform = Transform()

        self.components = []

        self.rel_positions = {}
        self.rel_rotations = {}
        self.rel_scalings = {}

        self.poscomms = {}
        self.rotcomms = {}
        self.scacomms = {}
        
        
        contents = argd.get("contents", None)
        if contents is not None:
            for (comp, params) in contents.items():
                self.addElement(comp, **params)
Пример #3
0
 def testRemoveWithDuplicates(self):   
     vec = Vector()
     vec.append("a")
     vec.append("b")
     vec.append("c")
     self.duplicatesVec.remove("b")
     self.assertEquals(vec, self.duplicatesVec)
Пример #4
0
def lanczos(A):
    k = len(A)

    b = Vector.rand(n=k)
    q = [Vector.new(n=k) for i in range(2)]
    q[1] = b / abs(b)

    b = [0]
    a = [0]

    for i in range(1, int(2 * sqrt(k))):
        z = Vector((A * q[i]).transpose()[0])
        a.append(float(Matrix([q[i]]) * z))
        z = z - q[i] * a[i] - q[i-1] * b[i-1]
        for j in q:
            z -= j * (z * j)
        for j in q:
            z -= j * (z * j)
        b.append(abs(z))
        if b[i] == 0:
            break
        q.append(z / b[i])

    Q = Matrix(q[-k-1:-1]).transpose()
    T = Q.transpose() * A * Q
    return (Q, T, )
Пример #5
0
 def testExtendByEmpty(self):
     vec = Vector()
     for i in range(BIG_VEC_SIZE):
         vec.append(i)
     self.bigVec.extend(Vector())
     self.assertEqual(self.bigVec, vec)
     self.assertEqual(self.bigVec, self.cleanBigVec)
Пример #6
0
    def collide(self, p1, p2):
        """Collission detection and handling method"""
        distance = Vector.distance_between(p1.pos, p2.pos)
        if distance < (p1.size + p2.size):

            angle = Vector.angle_between(p1.pos, p2.pos) + 0.5 * math.pi
            total_mass = p1.mass + p2.mass

            p1.direction = Vector(p1.direction.length * (p1.mass - p2.mass) / total_mass, p1.direction.angle) \
                + Vector(2 * p2.direction.length * p2.mass / total_mass, angle)
            p2.direction = Vector(p2.direction.length * (p2.mass - p1.mass) / total_mass, p2.direction.angle) \
                + Vector(2 * p1.direction.length * p1.mass / total_mass, angle)
            p1.direction.length *= self.elasticity
            p2.direction.length *= self.elasticity

            tangent = Vector.angle_between(p1.pos, p2.pos)
            # bounce on tangent
            #p1.direction.bounce(2 * tangent)
            #p2.direction.bounce(2 * tangent)
            # change speed
            #(p1.direction.length, p2.direction.length) = (p2.direction.length, p1.direction.length) 
            #avoid sticky problem
            angle = 0.5 * math.pi + tangent
            overlap = 0.5 * (p1.size + p2.size - distance + 1)
            p1.pos.x += math.sin(angle) + overlap
            p1.pos.y -= math.cos(angle) + overlap
            p2.pos.x -= math.sin(angle) + overlap
            p2.pos.y += math.cos(angle) + overlap
Пример #7
0
 def testInsertAtStartNegative(self):
     self.bigVec.insert(-BIG_VEC_SIZE, "a")
     vec = Vector()
     vec.append("a")
     for i in range(BIG_VEC_SIZE):
         vec.append(i)
     self.assertEqual(self.bigVec, vec)
Пример #8
0
 def resolve(self):
     """
     Return combined result of all steering behaviours.
     """
     acc=Vector(0,0)
     #if type(self.player.state) == Player.RxAttack:
     #    pdb.set_trace()
     if self._avoid_defenders_on:
         acc += self.avoid_defenders() * self.w_avoid_defenders
     if self._seek_on:
         acc += self.seek() * self.w_seek
     if self._seek_end_zone_on:
         acc += self.seek_end_zone() * self.w_seek_end_zone
     if self._avoid_walls_on:
         acc += self.avoid_walls() * self.w_avoid_walls
     if self._pursue_on:
         acc += self.pursue() * self.w_pursue
     if self._block_on:
         acc += self.block() * self.w_block
     if self._avoid_friends_on:
         acc += self.avoid_friends() * self.w_avoid_friends
     if self._zone_defend_on:
         acc += self.zone_defend() * self.w_zone_defend
     if self._guard_on:
         acc += self.guard() * self.w_guard
     if self._stay_in_range_on:
         acc += self.stay_in_range() * self.w_stay_in_range
     if self._avoid_end_zone_on:
         acc += self.avoid_end_zone() * self.w_avoid_end_zone
     if self._arrive_at_speed_on:
         acc += self.arrive_at_speed() * self.w_arrive_at_speed
     return acc.truncate(self.player.top_acc)
Пример #9
0
 def testInsertAtEnd(self):
     self.bigVec.insert(BIG_VEC_SIZE, "a")
     vec = Vector()
     for i in range(BIG_VEC_SIZE):
         vec.append(i)
     vec.append("a")
     self.assertEqual(self.bigVec, vec)
Пример #10
0
 def __init__(self, coords=(0, 0), speed=(0, 0)):
     self.coords = Vector(coords)
     self.speed = Vector(speed)
     self.color = (250, 0, 0)
     self.acsel = Vector((0, 0))
     self.status = MOVE
     self.angle_speed = 0.1
Пример #11
0
      def __init__(self, world, name, image, text):
            """Base class used to construct a game entity.

            Returns new GameEntity object
            with the specified variables world, name,image, text, location, destination, speed, brain and id, this is a super
            class and should ideally be used via inheritance

            world: holds a world object. For game entities this should ideally be the
            world game

            name: holds the name of the particular entity being constructed e.g. zombie

            image: holds the location of the image that will be used as the main image
            for whatever GameEntity is constructed. This image holder will also be used to
            store the image as a result of rotation for display

            start_image: holds the location of the image that will be used as the main image
            for whatever GameEntity is constructed. This one however will not be altered but
            used as a reference to reset the rotational image when a new rotation is required.

            text: holds the text that will be displayed in a textual entity; for example
            the TextBox Entity

            location: holds a default Vector of (0,0) that will be altered to set the location
            of the enity that is created

            destination: holds a default Vector of (0,0) that will be altered to set the destination
            location of the entity

            heading: holds a default Vector of (0,0) that will be altered to set the heading; vector
            between two points with no size. Can be seen as the direction

            last_heading: holds a default Vector of (0,0), this heading will typically be used
            to remember the last heading that was used for rotating an entity image, so that rotation
            does not get caught in an infinite loop

            speed: holds a number variable default 0. that will be altered to set the speed
            of the entity that is created

            brain: holds a StateManager object that is used to manage the states that the
            entity object will use

            id: holds the numerial id for the entity object that is being created

            """

            self.world = world
            self.name = name
            self.image = image
            self.start_image = image
            self.text = text
            self.location = Vector(0,0)
            self.destination = Vector(0,0)
            self.heading = Vector(0,0)
            self.last_heading = Vector(0,0)
            self.speed = 0.

            self.brain = StateManager()

            self.id = 0
Пример #12
0
 def volume(self):
     
     ps = Vector(self.p,self.s)
     qs = Vector(self.q,self.s)
     rs = Vector(self.r,self.s)
     
     return ps * (qs.cross(rs))/6.0
Пример #13
0
 def testRemoveAtEnd(self):
     vec = Vector()
     for i in range(BIG_VEC_SIZE-1):
         vec.append(i)
     
     self.bigVec.remove(BIG_VEC_SIZE-1)
     self.assertEqual(vec, self.bigVec)
Пример #14
0
 def testExtendGood(self):
     vec = Vector()
     for i in range(BIG_VEC_SIZE):
         vec.append(i)
     vec.append(10)
     
     self.bigVec.extend(self.oneVec)
     self.assertEqual(self.bigVec, vec)
Пример #15
0
 def testRemoveAtStart(self):
     vec = Vector()
     for i in range(1,BIG_VEC_SIZE):
         vec.append(i)
         
     self.bigVec.remove(0)
     vec.remove(0)
     self.assertEqual(vec, self.bigVec)
Пример #16
0
    def __init__(self, used, cut):
        """Create a new 'Rpg' instance
        """
        Vector.__init__(self, used, cut)

        self.rm_dupli = defaultdict(list)
        self.head_in_read = []
        self.min_size = 1
Пример #17
0
 def __init__(self, ax, ay, bx=0.0, by=0.0):
     "Start and end are Vectors"
     if isinstance(ax, Vector) and isinstance(ay, Vector):
         self.start = ax
         self.end = ay
     else:
         self.start = Vector(ax, ay)
         self.end = Vector(bx, by)
Пример #18
0
 def __init__(self, coords):
     self.coords = Vector(coords)
     self.image = pygame.Surface((50, 40), pygame.SRCALPHA)
     self.speed = Vector((10, 0))
     self.boost = 1
     self.direction = self.speed
     self.state = NORMAL
     self.draw()
Пример #19
0
 def __init__(self, used, cut, nb_sample, **opt):
     """Create a new 'Sample' instance
            
     """
     Vector.__init__(self, used, cut, **opt)
     
     self._nb_sample = nb_sample
     self.vector_val = ''
Пример #20
0
 def testManyRemoves(self):
     vec = Vector()
     for i in range(50, BIG_VEC_SIZE):
         vec.append(i)
         
     for i in range(50):
         self.bigVec.remove(i)
     self.assertEquals(vec, self.bigVec)
Пример #21
0
def test_Vector_attribute_setting_should_work(x,y, new_x,new_y):
    v = Vector(x,y)
    v.x = new_x
    assert v.x == new_x
    assert v.y == y
    v.y = new_y
    assert v.y == new_y
    assert v.x == new_x
Пример #22
0
 def test_length(self):
     obj = Vector.from_tuple(1, 0, 0)
     self.assertEqual(obj.length(), 1)
     obj = Vector.from_tuple(0, 0, 0)
     self.assertEqual(obj.length(), 0.0)
     obj = Vector.from_tuple(1, 1, 1)
     self.assertEqual(obj.length(), math.sqrt(3.0))
     self.assertEqual(obj.length_sqrd(), 3.0)
Пример #23
0
 def test_rot_align(self):
     obj1 = Vector.from_tuple(1, 0, 0)
     obj2 = Vector.from_tuple(0, 1, 0)
     transformation = Utils3d.get_rot_align(obj1, obj2)
     #print transformation
     result = transformation.mul_vec(obj1)
     #print result
     self.assertEqual(result, obj2)
Пример #24
0
 def test_shift(self):
     """shift vector with transformation matrix"""
     vector = Vector.from_tuple(1, 0, 0)
     # this should shift X Axis about 2
     shift_vector = Utils3d.get_shift_vector(2, 0, 0)
     # calculate linear transformation A*v
     t = shift_vector + vector
     # result should be shifted about 2 on x-axis
     self.assertEqual(t, Vector.from_tuple(3, 0, 0))
Пример #25
0
    def testludecomp(self):
        # TODO: Fix this test and the function under test!
        return
        A = Matrix([1, 2, 3], [4, 5, 6], [7, 8, 9])
        m2 = A.clone()
        (index, d) = m2.ludecomp()
        b = Vector(6, -1, 3)
        x = m2.lubacksub(index, b.clone())

        assert(False)
Пример #26
0
 def testInsertMiddle(self):
     vec1 = Vector()
     vec1.append("a")
     vec1.append("b")
     vec1.append("c")
     vec2 = Vector()
     vec2.append("a")
     vec2.append("c")
     vec2.insert(1,"b")
     self.assertEqual(vec1, vec2)
Пример #27
0
def distFromPointToLine(p, p1, p2):
        line = Vector(p2) - Vector(p1)
        toP = Vector(p) - Vector(p1)
        dot = toP.dot(line)
        if 0 <= dot <= line.length ** 2:
                projection = toP.proj(line)
                rejection = toP - projection
                return rejection.length
        else:
                return min(toP.length, (Vector(p) - Vector(p2)).length)
Пример #28
0
 def rule3(self, hoik):
     v = Vector(0, 0)
     if hoik.pos.x < 10:
         v.x = 20
     elif hoik.pos.x > C.SCREEN_SIZE.x-10:
         v.x = -20
     if hoik.pos.y < 10:
         v.y = 20
     elif hoik.pos.y > C.SCREEN_SIZE.y-10:
         v.y = -20
     return v
Пример #29
0
    def test_linearIndependenceWorks(self):
        one_1 = Vector([1, 1])
        three_3 = Vector([3, 3])
        self.assertFalse(Vector.areLinearlyIndependent([one_1, three_3]))

        one = Vector([1])
        three = Vector([3])
        self.assertFalse(Vector.areLinearlyIndependent([one, three]))

        one_3 = Vector([1, 3])
        self.assertTrue(Vector.areLinearlyIndependent([one_1, one_3]))
Пример #30
0
 def __init__(self, pos = [130,0],vmax = 60., thePath=[]):
     self.currentNode = 0
     self.pathDir = 1
     self.nodes = thePath.getNodes()
     self.t = self.nodes[self.currentNode]
     self.max_v = vmax
     self.p = Vector(pos)
     self.v = Vector([0., 0.])
     self.max_see_ahead = 30
     self.max_avoid_force = 1.5
     self.obstacles = []
Пример #31
0
def generateSceneNode(file_name, xz_size, peak_height, base_height,
                      blur_iterations, max_size, lighter_is_higher, file):
    scene_node = SceneNode()

    mesh = MeshBuilder()  #初始化

    #  img = QImage(file_name)
    im = Image.open(file_name)
    #    if im.isNull():
    # Logger.log("e", "Image is corrupt.")
    #       return None

    #  width = max(img.width(), 2)
    #  height = max(img.height(), 2)
    width = max(im.size[0], 2)
    height = max(im.size[1], 2)
    aspect = height / width

    #    if im.width() < 2 or im.height() < 2:
    # img = img.scaled(width, height, Qt.IgnoreAspectRatio)
    #       im = im.resize(width, height, Image.ANTIALIAS)
    base_height = max(base_height, 0)
    peak_height = max(peak_height, -base_height)

    xz_size = max(xz_size, blur_iterations)
    scale_vector = Vector(xz_size, peak_height, xz_size)

    if width > height:
        scale_vector = scale_vector.set(z=scale_vector.z * aspect)
    elif height > width:
        scale_vector = scale_vector.set(x=scale_vector.x / aspect)

    if width > max_size or height > max_size:
        scale_factor = max_size / width
        if height > width:
            scale_factor = max_size / height

        width = int(max(round(width * scale_factor), 2))
        height = int(max(round(height * scale_factor), 2))
        # img = img.scaled(width, height, Qt.IgnoreAspectRatio)
        im = im.resize((width, height), Image.ANTIALIAS)
    width_minus_one = width - 1
    height_minus_one = height - 1

    #Job.yieldThread()

    texel_width = 1.0 / (width_minus_one) * scale_vector.x
    texel_height = 1.0 / (height_minus_one) * scale_vector.z

    height_data = numpy.zeros((height, width), dtype=numpy.float32)

    for x in range(0, width):
        for y in range(0, height):
            # qrgb = img.pixel(x, y)
            qrgb = im.getpixel((x, y))
            R = qrgb[0]
            G = qrgb[1]
            B = qrgb[2]
            avg = float(R + G + B) / (3 * 255)
            # qR=qRed(qrgb)
            # qG=qGreen(qrgb)
            # qB=qBlue(qrgb)
            # avg=float(qR+qG+qB)/(3 * 255)
            # avg = float(qRed(qrgb) + qGreen(qrgb) + qBlue(qrgb)) / (3 * 255)
            height_data[y, x] = avg

    #Job.yieldThread()

    if not lighter_is_higher:
        height_data = 1 - height_data

    for _ in range(0, blur_iterations):
        copy = numpy.pad(height_data, ((1, 1), (1, 1)), mode="edge")

        height_data += copy[1:-1, 2:]
        height_data += copy[1:-1, :-2]
        height_data += copy[2:, 1:-1]
        height_data += copy[:-2, 1:-1]

        height_data += copy[2:, 2:]
        height_data += copy[:-2, 2:]
        height_data += copy[2:, :-2]
        height_data += copy[:-2, :-2]

        height_data /= 9

    #  Job.yieldThread()

    height_data *= scale_vector.y
    height_data += base_height

    heightmap_face_count = 2 * height_minus_one * width_minus_one
    total_face_count = heightmap_face_count + (width_minus_one *
                                               2) * (height_minus_one * 2) + 2

    mesh.reserveFaceCount(total_face_count)

    # initialize to texel space vertex offsets.
    # 6 is for 6 vertices for each texel quad.
    heightmap_vertices = numpy.zeros(
        (width_minus_one * height_minus_one, 6, 3), dtype=numpy.float32)
    heightmap_vertices = heightmap_vertices + numpy.array(
        [[[0, base_height, 0], [0, base_height, texel_height],
          [texel_width, base_height, texel_height],
          [texel_width, base_height, texel_height],
          [texel_width, base_height, 0], [0, base_height, 0]]],
        dtype=numpy.float32)

    offsetsz, offsetsx = numpy.mgrid[0:height_minus_one, 0:width - 1]
    offsetsx = numpy.array(offsetsx, numpy.float32).reshape(-1,
                                                            1) * texel_width
    offsetsz = numpy.array(offsetsz, numpy.float32).reshape(-1,
                                                            1) * texel_height

    # offsets for each texel quad
    heightmap_vertex_offsets = numpy.concatenate([
        offsetsx,
        numpy.zeros((offsetsx.shape[0], offsetsx.shape[1]),
                    dtype=numpy.float32), offsetsz
    ], 1)
    heightmap_vertices += heightmap_vertex_offsets.repeat(6,
                                                          0).reshape(-1, 6, 3)

    # apply height data to y values
    heightmap_vertices[:, 0,
                       1] = heightmap_vertices[:, 5,
                                               1] = height_data[:-1, :
                                                                -1].reshape(-1)
    heightmap_vertices[:, 1, 1] = height_data[1:, :-1].reshape(-1)
    heightmap_vertices[:, 2,
                       1] = heightmap_vertices[:, 3,
                                               1] = height_data[1:,
                                                                1:].reshape(-1)
    heightmap_vertices[:, 4, 1] = height_data[:-1, 1:].reshape(-1)

    heightmap_indices = numpy.array(numpy.mgrid[0:heightmap_face_count * 3],
                                    dtype=numpy.int32).reshape(-1, 3)

    mesh._vertices[0:(heightmap_vertices.size //
                      3), :] = heightmap_vertices.reshape(-1, 3)
    mesh._indices[0:(heightmap_indices.size // 3), :] = heightmap_indices

    mesh._vertex_count = heightmap_vertices.size // 3
    mesh._face_count = heightmap_indices.size // 3

    geo_width = width_minus_one * texel_width
    geo_height = height_minus_one * texel_height

    # bottom
    mesh.addFaceByPoints(0, 0, 0, 0, 0, geo_height, geo_width, 0, geo_height)
    mesh.addFaceByPoints(geo_width, 0, geo_height, geo_width, 0, 0, 0, 0, 0)

    # north and south walls
    for n in range(0, width_minus_one):
        x = n * texel_width
        nx = (n + 1) * texel_width

        hn0 = height_data[0, n]
        hn1 = height_data[0, n + 1]

        hs0 = height_data[height_minus_one, n]
        hs1 = height_data[height_minus_one, n + 1]

        mesh.addFaceByPoints(x, 0, 0, nx, 0, 0, nx, hn1, 0)
        mesh.addFaceByPoints(nx, hn1, 0, x, hn0, 0, x, 0, 0)

        mesh.addFaceByPoints(x, 0, geo_height, nx, 0, geo_height, nx, hs1,
                             geo_height)
        mesh.addFaceByPoints(nx, hs1, geo_height, x, hs0, geo_height, x, 0,
                             geo_height)

    # west and east walls
    for n in range(0, height_minus_one):
        y = n * texel_height
        ny = (n + 1) * texel_height

        hw0 = height_data[n, 0]
        hw1 = height_data[n + 1, 0]

        he0 = height_data[n, width_minus_one]
        he1 = height_data[n + 1, width_minus_one]

        mesh.addFaceByPoints(0, 0, y, 0, 0, ny, 0, hw1, ny)
        mesh.addFaceByPoints(0, hw1, ny, 0, hw0, y, 0, 0, y)

        mesh.addFaceByPoints(geo_width, 0, y, geo_width, 0, ny, geo_width, he1,
                             ny)
        mesh.addFaceByPoints(geo_width, he1, ny, geo_width, he0, y, geo_width,
                             0, y)

    mesh.calculateNormals(fast=True)

    scene_node.setMeshData(mesh.build())
    saveScene(file, scene_node)
Пример #32
0
class VectorTest(unittest.TestCase):
    def setUp(self):
        p1 = Point()
        p2 = Point(1, 1, 1)
        p3 = Point(-1, -1, 1)

        self.v1 = Vector(p1, p2)
        self.v2 = Vector(p1, p3)

    def tearDown(self):
        self.v1 = None
        self.v2 = None

    def test_value(self):
        true = self.assertTrue

        true(self.v1.value, [1, 1, 1])
        true(self.v2.value, [-1, -1, 1])

    def test_length(self):
        true = self.assertTrue

        l1 = self.v1.length
        l2 = self.v2.length

        true(l1, 3**0.5)
        true(l2, l1)

    def test_direction(self):
        true = self.assertTrue

        d1 = self.v1.direction
        d2 = self.v2.direction
        ansv = 3**0.5
        ans1 = Vector(Point(), Point(ansv, ansv, ansv))
        ans2 = Vector(Point(), Point(-ansv, -ansv, ansv))

        true(d1.value, ans1.value)
        true(d2.value, ans2.value)

    def test_normalize(self):
        true = self.assertTrue

        self.v1.normalize
        self.v2.normalize
        ansv = 3**0.5
        ans1 = Vector(Point(), Point(ansv, ansv, ansv))
        ans2 = Vector(Point(), Point(-ansv, -ansv, ansv))

        true(self.v1.value, ans1.value)
        true(self.v2.value, ans2.value)

    def test_dot(self):
        true = self.assertTrue

        dot1 = self.v1.dot(self.v2)
        dot2 = self.v2.dot(self.v1)
        true(dot1, 1)
        true(dot1, dot2)

    def test_cross(self):
        true = self.assertTrue

        cross1 = self.v1.cross(self.v2)
        cross2 = self.v2.cross(self.v1)
        ans1 = Vector(Point(), Point(2, -2, 0))
        ans2 = Vector(Point(), Point(-2, 2, 0))
        true(cross1, ans1.value)
        true(cross2, ans2.value)

    def test_rotation(self):
        deg = self.v1.rotation(self.v2)
        self.assertTrue(deg, 70.52877936550934)

    def test_add(self):
        v = self.v1 + self.v2
        self.assertTrue(v.value, [0, 0, 2])

    def test_sub(self):
        v = self.v1 - self.v2
        self.assertTrue(v.value, [2, 2, 0])

    def test_mul(self):
        true = self.assertTrue

        v3 = self.v1 * 2
        v4 = self.v2 * -2
        true(v3.value, [2, 2, 2])
        true(v4.value, [2, 2, -2])

    def test_div(self):
        true = self.assertTrue

        v3 = self.v1 / 0.5
        v4 = self.v2 / -0.5
        true(v3.value, [2, 2, 2])
        true(v4.value, [2, 2, -2])

    def test_iadd(self):
        self.v1 += self.v2
        self.assertTrue(self.v1, [0, 0, 2])

    def test_isub(self):
        self.v1 -= self.v2
        self.assertTrue(self.v1, [2, 2, 0])

    def test_imul(self):
        true = self.assertTrue

        self.v1 *= 2
        self.v2 *= -2
        true(self.v1.value, [2, 2, 2])
        true(self.v2.value, [2, 2, -2])

    def test_idiv(self):
        true = self.assertTrue

        self.v1 /= 0.5
        self.v2 /= -0.5
        true(self.v1.value, [2, 2, 2])
        true(self.v2.value, [2, 2, -2])
Пример #33
0
def test_repr():
	assert repr(Vector(1,2)) == "Vector(1, 2)"
Пример #34
0
    def to_vector(vector):

        return Vector(vector)
Пример #35
0
 def _get_axial_vector(self, pos_type):
     return Vector(getattr(self.node1, pos_type), getattr(self.node2, pos_type))
Пример #36
0
class EigenStuff:

    def __init__(self, canvas, master, evRow, probRow, color, num, ebWidth):
        self.canvas = canvas['canvas']
        self.cDiag = canvas['diagonal']
        self.color = color
        self.evLabel = Label(master, text='', fg=color, width=20)
        self.evLabel.grid(row=evRow, columnspan=2)
        self.probLabel = Label(master, text='', fg=color, width=20)
        self.probLabel.grid(row=probRow, columnspan=2)
        self.ev = self.canvas.create_line(0,0,0,0,fill=color, dash=[10,15], tag='eigen')
        self.projEv = self.canvas.create_line(0,0,0,0, fill='cyan', arrow='last', width=1, tag='proj')
        self.projEvDash = self.canvas.create_line(0,0,0,0, fill='cyan', dash=[10,5], width=1, tag='proj')
        self.eb = Vector(canvas, master, None, color, ebWidth, 'eigen')
        self.num = num #for labels
        self.vals = None

    def setEvLabel(self, eigenVal):
        if eigenVal.imag == 0:
            self.evLabel['text'] = "λ" + str(self.num) + " = " + str(round(eigenVal.real, 2))
        else:
            self.evLabel['text'] = "λ" + str(self.num) + " = " + str(
                round(eigenVal.real, 2)) + ' + ' + str(round(eigenVal.imag, 2)) + 'i'

    def setProbLabel(self, prob):
        self.probLabel['text'] = 'P' + str(self.num) + ' = ' + str(round(prob, 2))

    def setVals(self, evs):
        self.vals = evs
        self.eb.setVals(evs)

    def drawLine(self, unitSize):
        cWidth = int(self.canvas['width'])
        cHeight = int(self.canvas['height'])
        x1, y1 = (-self.cDiag * self.vals).vals()
        x2, y2 = (self.cDiag * self.vals).vals()
        self.canvas.coords(self.ev,
                           cWidth/2 + x1*unitSize, cHeight/2 - y1*unitSize,
                           cWidth/2 + x2*unitSize, cHeight/2 - y2*unitSize)

    def setEvLabelBackground(self, color):
        self.evLabel['bg'] = color

    def probView(self, view):
        if view:
            self.probLabel.grid()
        else:
            self.probLabel.grid_remove()

    def drawProjections(self, x2, y2, amp, unitSize):
        cWidth = int(self.canvas['width'])
        cHeight = int(self.canvas['height'])
        x, y = (amp * self.vals).vals()
        self.canvas.coords(self.projEv,
                           cWidth/2, cHeight/2,
                           cWidth/2 + x*unitSize,
                           cHeight/2 + -y*unitSize
                           )
        self.canvas.coords(self.projEvDash,
                           cWidth/2+x*unitSize,
                           cHeight/2 + -y*unitSize,
                           cWidth/2 + x2*unitSize,
                           cHeight/2 + -y2*unitSize
                           )

    def drawEigenBasis(self, unitSize):
        self.eb.drawVector(unitSize)

    def setComplexMode(self, complexMode):
        self.eb.setComplexMode(complexMode)
        self.canvas.coords(self.ev, 0, 0, 0, 0)
Пример #37
0
class OpenGLComponent(Axon.AdaptiveCommsComponent.AdaptiveCommsComponent):
    """\
    OpenGLComponent(...) -> create a new OpenGL component (not very useful though; it is rather designed to inherit from).

    This components implements the interaction with the OpenGLDisplay
    service that is needed to setup, draw and move an object using OpenGL.

    Keyword arguments:
    
    - size      -- three dimensional size of component (default=(0,0,0))
    - rotation  -- rotation of component around (x,y,z) axis (defaul=(0,0,0))
    - scaling   -- scaling along the (x,y,z) axis (default=(1,1,1))
    - position  -- three dimensional position (default=(0,0,0))
    - name      -- name of component (mostly for debugging, default="nameless")
    """
    
    Inboxes = {
        "inbox": "not used",
        "control": "For shutdown messages",
        "callback": "for the response after a displayrequest",
        "events": "Input events",
        "position" : "receive position triple (x,y,z)",
        "rotation": "receive rotation triple (x,y,z)",
        "scaling": "receive scaling triple (x,y,z)",
        "rel_position" : "receive position triple (x,y,z)",
        "rel_rotation": "receive rotation triple (x,y,z)",
        "rel_scaling": "receive scaling triple (x,y,z)",
    }
    
    Outboxes = {
        "outbox": "not used",
        "signal": "For shutdown messages",
        "display_signal" : "Outbox used for communicating to the display surface",
        "position" : "send position status when updated",
        "rotation": "send rotation status when updated",
        "scaling": "send scaling status when updated",
    }
    
    def __init__(self, **argd):
        """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
        super(OpenGLComponent, self).__init__()

        # get transformation data and convert to vectors
        self.size = Vector( *argd.get("size", (0,0,0)) )
        self.position = Vector( *argd.get("position", (0,0,0)) )
        self.rotation = Vector( *argd.get("rotation", (0.0,0.0,0.0)) )
        self.scaling = Vector( *argd.get("scaling", (1,1,1) ) )
        
        # for detection of changes
        self.oldrot = Vector()
        self.oldpos = Vector()
        self.oldscaling = Vector()

        self.transform = Transform()

        # name (mostly for debugging)
        self.name = argd.get("name", "nameless")

        # create clock
        self.clock = pygame.time.Clock()
        self.frametime = 0.0

        # get display service
        displayservice = OpenGLDisplay.getDisplayService()
        # link display_signal to displayservice
        self.link((self,"display_signal"), displayservice)
        
            
            
    def main(self):
        # create display request
        self.disprequest = { "OGL_DISPLAYREQUEST" : True,
                             "objectid" : id(self),
                             "callback" : (self,"callback"),
                             "events" : (self, "events"),
                             "size": self.size
                           }
        # send display request
        self.send(self.disprequest, "display_signal")
        # inital apply trasformations
        self.applyTransforms()
        # setup function from derived objects
        self.setup()        
        # initial draw to display list
        self.redraw()

        # wait for response on displayrequest
        while not self.dataReady("callback"):  yield 1
        self.identifier = self.recv("callback")
        
        while 1:
            yield 1
            
            while self.dataReady("control"):
                cmsg = self.recv("control")
#                if isinstance(cmsg, producerFinished) or isinstance(cmsg, shutdownMicroprocess):
#                    self.send(cmsg, "signal")
#                    return
                   
            self.frametime = float(self.clock.tick())/1000.0
            self.handleMovement()
            self.handleEvents()
            self.applyTransforms()
            # frame function from derived objects
            self.frame()

                                          
    def applyTransforms(self):
        """ Use the objects translation/rotation/scaling values to generate a new transformation Matrix if changes have happened. """
        # generate new transformation matrix if needed
        if self.oldscaling != self.scaling or self.oldrot != self.rotation or self.oldpos != self.position:
            self.transform = Transform()
            self.transform.applyScaling(self.scaling)
            self.transform.applyRotation(self.rotation)
            self.transform.applyTranslation(self.position)

            if self.oldscaling != self.scaling:
                self.send(self.scaling.toTuple(), "scaling")
                self.oldscaling = self.scaling.copy()

            if self.oldrot != self.rotation:
                self.send(self.rotation.toTuple(), "rotation")
                self.oldrot = self.rotation.copy()

            if self.oldpos != self.position:
                self.send(self.position.toTuple(), "position")
                self.oldpos = self.position.copy()
                
            # send new transform to display service
            transform_update = { "TRANSFORM_UPDATE": True,
                                 "objectid": id(self),
                                 "transform": self.transform
                               }
            self.send(transform_update, "display_signal")


    def handleMovement(self):
        """ Handle movement commands received by corresponding inboxes. """
        while self.dataReady("position"):
            pos = self.recv("position")
            self.position = Vector(*pos)
        
        while self.dataReady("rotation"):
            rot = self.recv("rotation")
            self.rotation = Vector(*rot)
            
        while self.dataReady("scaling"):
            scaling = self.recv("scaling")
            self.scaling = Vector(*scaling)
            
        while self.dataReady("rel_position"):
            self.position += Vector(*self.recv("rel_position"))
            
        while self.dataReady("rel_rotation"):
            self.rotation += Vector(*self.recv("rel_rotation"))
            
        while self.dataReady("rel_scaling"):
            self.scaling = Vector(*self.recv("rel_scaling"))

    ##
    # Methods to be used by derived objects
    ##

    def addListenEvents(self, events):
        """\
            Sends listening request for pygame events to the display service.
            The events parameter is expected to be a list of pygame event constants.
        """
        for event in events:
            self.send({"ADDLISTENEVENT":event, "objectid":id(self)}, "display_signal")

    
    def removeListenEvents(self, events):
        """\
            Sends stop listening request for pygame events to the display service.
            The events parameter is expected to be a list of pygame event constants.
        """
        for event in events:
            self.send({"REMOVELISTENEVENT":event, "objectid":id(self)}, "display_signal")


    def redraw(self):
        """\
        Invoke draw() and save its commands to a newly generated displaylist.
        
        The displaylist name is then sent to the display service via a
        "DISPLAYLIST_UPDATE" request.
        """
        # display list id
        displaylist = glGenLists(1);
        # draw object to its displaylist
        glNewList(displaylist, GL_COMPILE)
        self.draw()
        glEndList()

        
        dl_update = { "DISPLAYLIST_UPDATE": True,
                      "objectid": id(self),
                      "displaylist": displaylist
                    }
        self.send(dl_update, "display_signal")
        


    ##
    # Method stubs to be overridden by derived objects
    ##

    def handleEvents(self):
        """
        Method stub
        
        Override this method to do event handling inside.
        Should look like this::
        
            while self.dataReady("events"):
                event = self.recv("events")
                # handle event ...
        
        """
        pass        


    def draw(self):
        """
        Method stub
        
        Override this method for drawing. Only use commands which are
        needed for drawing. Will not draw directly but be saved to a
        displaylist. Therefore, make sure not to use any commands which
        cannot be stored in displaylists (unlikely anyway).
        """
        pass

    
    def setup(self):
        """
        Method stub
        
        Override this method for component setup.
        It will be called on the first scheduling of the component.
        """
        pass

    def frame(self):
        """
        Method stub
        
        Override this method for operations you want to do every frame.
        It will be called every time the component is scheduled. Do not
        include infinite loops, the method has to return every time it
        gets called.
        """
        pass
Пример #38
0
try:
    import simplegui
except:
    import SimpleGUICS2Pygame.simpleguics2pygame as simplegui

from Vector import Vector
from LineMove import LineMove

myLine = LineMove((Vector(0, 0)), (Vector(600, 0)))
myLine2 = LineMove((Vector(0, 0)), (Vector(700, 0)))

frame = simplegui.create_frame("Half-Life 3", 500, 500)
frame.set_draw_handler(myLine.update)
frame.start()
Пример #39
0
 def handleEvents(self):
     while self.dataReady("events"):
         event = self.recv("events")
         if event.type == pygame.MOUSEBUTTONDOWN and self.identifier in event.hitobjects:
             self.rotation += Vector(0,0,10)
             self.rotation %= 360
Пример #40
0
 def __init__(self, center_x, center_y, restitution):
     self.center = Vector(center_x, center_y)
     self.restitution = restitution
     self.velocity = Vector(0, 0)
     self.acceleration = Vector(0, 0)
     self.collision_mask = (Body, )
Пример #41
0
    def sum_vector(vector1, vector2):

        return Vector(vector1.psi + vector2.psi)
Пример #42
0
#!/usr/bin/env python

import sys
from Vector import Vector

V1 = Vector(1, 1)
V2 = Vector(2, 2)

try:
    V3 = V1 + V2
except TypeError:
    print "Add Test failed!  Not defined"

try:
    assert (V3.getX() == 3 and V3.getY() == 3)
    print "Add Test succeeded!"
except AssertionError:
    print "Add Test failed!"

try:
    V3 = V1 - V2
except TypeError:
    print "Subtraction Test failed! Not defined"
try:
    assert (V3.getX() == -1 and V3.getY() == -1)
    print "Subtraction Test succeeded!"
except AssertionError:
    print "Subtraction Test failed!"
Пример #43
0
 def updateAcceleration(self):
     if self.inAir and not self.jumping:
         self.gravity = Vector(0, 3)
     else:
         self.gravity = Vector(0, 0)
Пример #44
0
 def Euler(x, y, z):
     # Z-->X-->Y
     rotX = Quaternion.AxisAngle(Vector(1, 0, 0), x)
     rotY = Quaternion.AxisAngle(Vector(0, 1, 0), y)
     rotZ = Quaternion.AxisAngle(Vector(0, 0, 1), z)
     return rotY * rotX * rotZ
Пример #45
0
class Player(Sprite):
    def __init__(self, image, image_alternate, columns, rows):
        super().__init__(image, image_alternate, columns, rows)
        pygame.mixer.pre_init(
            44100, -16, 1, 512
        )  # Prevents Pygame sound delay: https://www.reddit.com/r/pygame/comments/8gsoue/delayed_audio_in_pygame/
        self.lives = 2
        self.moving = False
        self.dead = False
        self.shooting = False
        self.jumping = False
        #self.rolling = False
        self.invincible = False
        self.bullets = []
        self.velocity = Vector(0, 0)
        self.pos = Vector(SCREENWIDTH / 2, SCREENHEIGHT - 20)
        self.gravity = Vector(0, 0)
        self.frameCounter = 0
        self.deadCounter = 0
        self.inAir = False

        # Sound effects for the player
        __location__ = os.path.realpath(
            os.path.join(os.getcwd(), os.path.dirname(__file__)))
        soundeffect = os.path.join(__location__, 'Sounds/classic_hurt.ogg')
        self.oof = simplegui._load_local_sound(soundeffect)

        __location__ = os.path.realpath(
            os.path.join(os.getcwd(), os.path.dirname(__file__)))
        soundeffect = os.path.join(__location__, 'Sounds/gunSound.ogg')
        self.pew = simplegui._load_local_sound(soundeffect)
        self.pew.set_volume(.25)

    def update(self):
        if self.frameCounter % 10 == 0:
            self.updateFrame()
        self.updateVel()
        self.updateAcceleration()
        self.pos += self.velocity
        # Checks to stop player going off the screen
        if self.pos.getP()[1] > SCREENHEIGHT - 100:
            self.pos = Vector(self.pos.getP()[0], 620)
        elif self.pos.getP()[1] < 0:
            self.pos = Vector(self.pos.getP()[0], 1)
            self.jumping = False
        if self.pos.getP()[0] > SCREENWIDTH - 25:
            self.pos = Vector(1255, self.pos.getP()[1])
        elif self.pos.getP()[0] < 25:
            self.pos = Vector(25, self.pos.getP()[1])
        self.frameCounter += 1

    # Custom draw method for the player sprite as the sprite sheet is more complex and had some issues
    def draw(self, canvas):
        if self.right:
            centreDest = (self.pos.getP()[0], self.pos.getP()[1])
            centerSource = [
                self.frameSize[i] * self.currentFrame[i] + self.frameCentre[i]
                for i in [0, 1]
            ]
            canvas.draw_image(self.image, centerSource, self.frameSize,
                              centreDest, self.sizeDest)
        else:
            centreDest = (self.pos.getP()[0], self.pos.getP()[1])
            centerSource = [
                (self.width - (self.frameSize[0] * self.currentFrame[0] +
                               self.frameCentre[0])),
                (self.frameSize[1] * self.currentFrame[1] +
                 self.frameCentre[1])
            ]
            canvas.draw_image(self.alternateimage, centerSource,
                              self.frameSize, centreDest, self.sizeDest)

    # Updating the frame depending on the animation
    def updateFrame(self):
        self.currentFrame[0] += 1

        # Death animation
        if self.lives <= 0:
            self.deadCounter += 1
            self.currentFrame[1] = 8
            if self.currentFrame[0] > 5:
                self.dead = True

        # Rolling Animation (Not used in final game)
        #elif self.rolling:
        #    self.currentFrame[1] = 7
        #  # Run rolling animation
        #    if self.currentFrame[0] >= 4:
        #        self.currentFrame[0] = 0
        #        self.rolling = False

        # Jumping while not shooting
        elif self.jumping and not self.shooting:
            self.currentFrame[1] = 5
            if self.currentFrame[0] >= 6:
                self.currentFrame[0] = 4

        # Shooting while still
        elif self.shooting and not self.moving:
            self.currentFrame[1] = 2
            if self.currentFrame[0] >= 8:
                self.currentFrame[0] = 0

        # Shooting while moving
        elif self.moving and self.shooting:
            self.currentFrame[1] = 4
            if self.currentFrame[0] >= 8:
                self.currentFrame[0] = 0

        # Moving while not shooting
        elif self.moving and not self.shooting:
            self.currentFrame[1] = 3
            if self.currentFrame[0] >= 8:
                self.currentFrame[0] = 0

        # Doing nothing
        else:
            self.currentFrame[1] = 1
            if self.currentFrame[0] >= 8:
                self.currentFrame[0] = 0

    # Updating the velocity
    def updateVel(self):
        if self.moving:
            # Change horizontal velocity
            if self.right:
                self.velocity = Vector(5, self.velocity.getP()[1])
            else:
                self.velocity = Vector(-5, self.velocity.getP()[1])

        self.velocity = Vector(self.velocity.getP()[0] * 0.94,
                               self.velocity.getP()[1])
        self.velocity += self.gravity
        if self.jumping:
            self.velocity = Vector(self.velocity.getP()[0], -10)

    # Updating the acceleration
    def updateAcceleration(self):
        if self.inAir and not self.jumping:
            self.gravity = Vector(0, 3)
        else:
            self.gravity = Vector(0, 0)

    # Spawns a non hostile bullet
    def shoot(self):
        self.pew.play()
        xStart, yStart = self.pos.getP()
        __location__ = os.path.realpath(
            os.path.join(os.getcwd(), os.path.dirname(__file__)))
        imagenormal = os.path.join(__location__,
                                   'images/sprites/boomerangbullet.png')
        imagealternate = os.path.join(
            __location__, 'images/sprites/boomerangbulletleft.png')

        # Sets velocity of bullet repective to direction the player is facing
        if self.right:
            vel = Vector(6, 0)
            right = True
            xStart += 60
        else:
            vel = Vector(-6, 0)
            right = False
            xStart -= 60
        startPos = Vector(xStart, yStart + 30)
        return Bullet(startPos, vel, False, "bullet", right, imagenormal,
                      imagealternate, 8, 1)

    # Following methods to be called in interaction class after user inputs to switch boolean variables
    def startMoving(self):
        if self.lives > 0:
            self.moving = True

    def startShooting(self):
        if self.lives > 0:
            self.shooting = True
            self.bullets.append(self.shoot())
            self.currentFrame[0] = 2

    #def startRoll(self):
    #    if self.lives > 0:
    #        self.rolling = True

    def startJump(self):
        if self.lives > 0:
            self.jumping = True
            self.inAir = True

    # Called from interaction class when user input ends
    def stopJump(self):
        if self.lives > 0:
            self.jumping = False

    def stopMoving(self):
        if self.lives > 0:
            self.moving = False

    def stopShooting(self):
        if self.lives > 0:
            self.shooting = False

    # Called from interaction class following collision
    def removeLife(self):
        if not self.invincible and self.lives > 0:
            self.lives -= 1
            self.oof.set_volume(1)
            self.oof.play()
            if self.lives == 0:
                self.currentFrame[0] = 0
Пример #46
0
from matrix import Matrix
from Vector import Vector

# m0 = Matrix((2, 3))

# m1 = Matrix([[1,3,4],[5,6,7]])

# m2 = Matrix([[1,3,4],[5,6,7]], (2, 3))

# A=Matrix([[1,4,-2],[3,5,-6]])

# B=Matrix([[5,2,8,-1], [3,6,4,5], [-2,9,7,-3]])

# C = A * B

# print(C.data)


A=Matrix([[1, -1,2], [0, -3, 1]])
B=Vector([2,1,0])

C = B*A

print(C.values)
Пример #47
0
'''
Created on Nov 21, 2016

@author: iaskarov
'''

from Vector import Vector
from VectorOperations import vadd, vsubtract, vcomponent, vdot, vangle, pythagorean, sohcahtoa, vcross, is_vparallel, vprojection, is_vorthogonal, vscalar_product

if __name__ == '__main__':
    v1 = Vector([1.5, 9.547, 3.691])
    v2 = Vector([-6.007, 0.124, 5.772])

    cross = vcross(v1.coordinates, v2.coordinates)
    print cross.magnitude / 2
Пример #48
0
def close(enemy, moving_point):
    p = Vector(moving_point[0][0], moving_point[0][1]) - enemy.position
    return abs(p.x) < Constants.CONTOUR_EPS and abs(
        p.y) < Constants.CONTOUR_EPS
Пример #49
0
 def calculateEstPosition(self, lastTransmittedSample, currentTime):
     deltaTime = currentTime - lastTransmittedSample.sample.time
     deltaTimeVector = Vector(deltaTime, deltaTime, deltaTime)
     deltaPosition = lastTransmittedSample.velocity * deltaTimeVector
     estimatedPosition = lastTransmittedSample.sample.position + deltaPosition
     return estimatedPosition
Пример #50
0
def test_addition():
	v1 = Vector(1,2)
	v2 = Vector(1,2)
	v3 = v1 + v2
	assert v3.x == 2
	assert v3.y == 4
Пример #51
0
def GeneratingOneImage(particle_center_x, particle_center_y, R, rho, nm, nP,
                       pol_X, pol_Y, pol_Z, pol_Vx, pol_Vy, pol_Vz, resolution,
                       lens_size, scattering_number_of_iterations):
    """
    This method generates an image based on the rays propagated from the light source, refracted through a particle,
        and towards a camera lens.
    :param particle_center_x: Particle center x coordinate.
    :param particle_center_y: Particle center y coordinate.
    :param R: Particle radius [m].
    :param rho: Ray density per square meter.
    :param nm: Refractive index of the medium before ray impact.
    :param nP: Refractive index of the medium after ray impact.
    :param pol_X: Polarization
    :param pol_Y: Polarization
    :param pol_Z: Polarization
    :param pol_Vx: Polarization
    :param pol_Vy: Polarization
    :param pol_Vz: Polarization
    :param resolution: Resolution of the generated image. Assuming quadratic image.
    :param lens_size: Camera lens size [m], assuming quadratic lens.
    :param scattering_number_of_iterations: # Maximum number of iterations the rays are scattered within the particle.
    :return: The particle captures by the camera as an image.
    """

    # Produce one image.
    c = Point(0, 0, 0)
    bead = ParticleSpherical(c, R, nm, nP)

    pixels = np.zeros(resolution * resolution)

    # Coordinates for the rays hitting the sphere
    x, y = GeneratingCoordinates(rho, R, 0, 0)
    number_of_rays = np.size(x)
    P = np.ones(number_of_rays)  # Power[W]
    z = np.zeros(number_of_rays)
    Vx = np.zeros(number_of_rays)
    Vy = np.zeros(number_of_rays)
    Vz = np.ones(number_of_rays)

    v = Vector(x * R, y * R, z, Vx, Vy, Vz)

    pol = Vector(pol_X, pol_Y, pol_Z, pol_Vx, pol_Vy, pol_Vz)
    pol = v.mtimes(pol)
    pol = pol.versor()

    r = Ray(v, P, pol)
    s = bead.scattering(r=r, N=scattering_number_of_iterations)

    plane_normal = np.array([0, 0, 1])  # Define lens plane
    plane_point = np.array([0, 0, 1])  # Any point on the plane

    exiting_rays = s[-1]["t"]
    ray_power = exiting_rays.P

    for i in range(0, np.size(exiting_rays.v.Vx) - 1):
        ray_direction = np.array(
            [exiting_rays.v.Vx[i], exiting_rays.v.Vy[i], exiting_rays.v.Vz[i]])
        ray_point = np.array([
            exiting_rays.v.X[i], exiting_rays.v.Y[i], exiting_rays.v.Z[i]
        ]) + np.array([particle_center_x, particle_center_y, 0])

        psi = LinePlaneCollision(plane_normal, plane_point, ray_direction,
                                 ray_point, lens_size)
        if psi is not None:  # Ray hits the camera lens
            x_pixel = np.round(
                (psi[0] + lens_size / 2) / lens_size * (resolution - 1))
            y_pixel = np.round(
                (psi[1] + lens_size / 2) / lens_size * resolution)
            pixel_index = y_pixel * resolution + x_pixel
            pixels[int(pixel_index)] = pixels[int(pixel_index)] + ray_power[i]

    # Normalize the sphere-rays
    if max(pixels) > 0:
        pixels = pixels / max(pixels)

    return np.reshape(pixels, (resolution, resolution))
Пример #52
0
def test_create_instance_with_defaults():
	v1 = Vector()
	assert v1.x == 0
	assert v1.y == 0
Пример #53
0
def test_coodinate_conversion():
    #Testing quadrant 1 coordinate conversion
    vec = Vector(vector=(1, 1))
    guiCoord = vec.getGUIVector1()
    assert guiCoord[0] == 261
    assert guiCoord[1] == 259

    #Testing quadrant 2 coordinate conversion
    vec = Vector(vector=(-3, 10))
    guiCoord = vec.getGUIVector1()
    assert guiCoord[0] == 257
    assert guiCoord[1] == 250

    #Testing quadrant 3 coordinate conversion
    vec = Vector(vector=(-5, -10))
    guiCoord = vec.getGUIVector1()
    assert guiCoord[0] == 255
    assert guiCoord[1] == 270

    #Testing quadrant 4 coordinate conversion
    vec = Vector(vector=(5, -10))
    guiCoord = vec.getGUIVector1()
    assert guiCoord[0] == 265
    assert guiCoord[1] == 270
Пример #54
0
def test_abs():
	v1 = Vector(3,4)
	assert abs(v1) == 5
Пример #55
0
def generate_new_enemys(enemys):
    for i in range(len(enemys), Constants.ENEMYS_NUM):
        enemys.append(
            Enemy(enemy_points[random.randint(0,
                                              len(enemy_points) - 1)]))
    return enemys


video_capture = cv2.VideoCapture(0)

ret, average_frame = video_capture.read()
average_frame = cv2.cvtColor(average_frame, cv2.COLOR_BGR2GRAY)
moving_provider = MovingProvider(average_frame)

HEIGTH, WIDTH = average_frame.shape
CENTER = Vector(WIDTH // 2, HEIGTH // 2)
base = Base(CENTER, CENTER, WIDTH // 2, HEIGTH // 2)

enemy_points = [
    Vector(0, 0),
    Vector(0, HEIGTH),
    Vector(WIDTH, 0),
    Vector(WIDTH, HEIGTH)
]
enemys = []
for i in range(Constants.ENEMYS_NUM):
    enemys.append(Enemy(enemy_points[random.randint(0,
                                                    len(enemy_points) - 1)]))

while True:
    # Capture frame-by-frame
Пример #56
0
    def generate(self, max_rooms, random_percentage, screen_size):
        """
        Generates a list of rooms with a size of `max_rooms`

        Keyword arguments:
        max_rooms - an integer with the maximum number of rooms wanted
        random_percentage - the percent of rooms to keep for adding randomly to the map
        screen_size - a tuple of ints that represent the screen size
        """
        self.__rooms = []
        linear_rooms = int((max_rooms + 1) * (1 - random_percentage))
        random_rooms = max_rooms - linear_rooms
        center = Vector(screen_size[0] / 2, screen_size[1] / 2)
        for i in range(linear_rooms):
            if (i == 0):
                r = Room(
                    center,
                    random.randrange(self.__min_width, self.__max_width,
                                     self.__tile_size),
                    random.randrange(self.__min_height, self.__max_height,
                                     self.__tile_size), "start")
            elif (i == linear_rooms - 1):
                r = Room(
                    center,
                    random.randrange(self.__min_width, self.__max_width,
                                     self.__tile_size),
                    random.randrange(self.__min_height, self.__max_height,
                                     self.__tile_size), "end")
            else:
                r = Room(
                    center,
                    random.randrange(self.__min_width, self.__max_width,
                                     self.__tile_size),
                    random.randrange(self.__min_height, self.__max_height,
                                     self.__tile_size))

            heading = self.__getRandomHeading()
            self.__rooms.append(r)
            if (i > 0):
                while (self.__rooms[i - 1].headingExists(heading)):
                    heading = self.__getRandomHeading()
                self.__rooms[i - 1].addNeighbour(r, heading)
                r.addNeighbour(self.__rooms[i - 1],
                               self.__invertHeading(heading))

        for i in range(random_rooms):
            chosen_room = self.__rooms[random.randint(0,
                                                      len(self.__rooms) - 1)]
            while (len(chosen_room.getEmptyNeighbours()) == 0
                   or chosen_room.isStart() or chosen_room.isEnd()):
                chosen_room = self.__rooms[random.randint(
                    0,
                    len(self.__rooms) - 1)]
            heading = self.__getRandomHeading()
            while (chosen_room.headingExists(heading)):
                heading = self.__getRandomHeading()
            r = Room(
                center,
                random.randrange(self.__min_width, self.__max_width,
                                 self.__tile_size),
                random.randrange(self.__min_height, self.__max_height,
                                 self.__tile_size))
            chosen_room.addNeighbour(r, heading)
            r.addNeighbour(chosen_room, self.__invertHeading(heading))
            self.__rooms.append(r)

        self.__addEnemies()
        print("Map Generated")
Пример #57
0
def test_subtraction():
	v1 = Vector(2,4)
	v2 = Vector(1,2)
	v3 = v1 - v2
	assert v3.x == 1
	assert v3.y == 2
Пример #58
0
    def clickBtn(self):
        self.clicked = True
        self.trigger()


# instead of using this the value should be bracketed to mean that it's a single arguement value
#instances of all types, without brackets it points to a class but doesnt make an instance



obj_explosion_spriteS=Spritesheet(Img_explosion,9,9,100,100,100,100,[9,9])

obj_usr_car_spriteS=Spritesheet(Img_user_Car,5,5,139,70,139,70,[4,4])

obj_user_car= User_Car(Vector((75,random.randrange(150,530))))

obj_Enemey_car=Enemy_Car(Vector((random.randrange(0,400),random.randrange(150,450))),Vector((1,0)),img_cars_array[random.randrange(0,5)])


obj_Tree=TreeAndWall()

obj_Kbd=keyboard()

obj_Int=Interaction(obj_user_car,obj_Kbd)



def click(pos):
    for x in range(0, len(arrayButton)):
        if(arrayButton[x].contains(pos)):
Пример #59
0
def test_multiplication():
	v1 = Vector(1,2)
	v2 = v1 * 2
	assert v2.x == 2
	assert v2.y == 4
Пример #60
0
 def setUp(self):
     self.v1 = Vector(1, 2)
     self.v2 = Vector(2, 1)