Esempio n. 1
0
    def generateTerrain(self, loader, heightMap):

        image = Image.open(heightMap)
        rgb_image = image.convert('RGB')
        VERTEX_COUNT = image.height
        image.close()

        self.heights = np.empty(shape=[VERTEX_COUNT, VERTEX_COUNT])

        vertices = []
        normals = []
        textureCoords = []
        for i in range(VERTEX_COUNT):
            for j in range(VERTEX_COUNT):
                height = self.__getHeight(j, i, rgb_image)
                self.heights[j][i] = height
                vertices.append(
                    Vector3([
                        j / (VERTEX_COUNT - 1) * self.__SIZE, height,
                        i / (VERTEX_COUNT - 1) * self.__SIZE
                    ]))
                normal = self.__calculateNormal(j, i, rgb_image)
                normals.append(normal)
                textureCoords.append(
                    Vector3(
                        [j / (VERTEX_COUNT - 1), i / (VERTEX_COUNT - 1), 0.0]))

        indices = []
        for gz in range(VERTEX_COUNT - 1):
            for gx in range(VERTEX_COUNT - 1):
                topLeft = (gz * VERTEX_COUNT) + gx
                topRight = topLeft + 1
                bottomLeft = ((gz + 1) * VERTEX_COUNT) + gx
                bottomRight = bottomLeft + 1
                indices.append(topLeft)
                indices.append(bottomLeft)
                indices.append(topRight)
                indices.append(topRight)
                indices.append(bottomLeft)
                indices.append(bottomRight)

        finalVertexList = []
        finalNormalList = []
        finalTextCoordsList = []
        for num in range(len(indices)):
            vertexNumber = indices[num]
            finalVertexList.append(Vector3(vertices[vertexNumber]))
            finalNormalList.append(Vector3(normals[vertexNumber]))
            finalTextCoordsList.append(Vector3(textureCoords[vertexNumber]))
        finalVertexList = np.array(finalVertexList)
        finalNormalList = np.array(finalNormalList)
        finalTextCoordsList = np.array(finalTextCoordsList)
        return loader.loadToVAO(finalVertexList, finalTextCoordsList,
                                finalNormalList)
Esempio n. 2
0
    def __init__(self):
        self.camera_pos = Vector3([0.0, 4.0, 3.0])
        self.camera_front = Vector3([0.0, 0.0, -1.0])
        self.camera_up = Vector3([0.0, 1.0, 0.0])
        self.camera_right = Vector3([1.0, 0.0, 0.0])

        self.mouse_sensitivity = 0.25
        self.jaw = -90
        self.pitch = 0

        self.projectionMatrix = matrix44.create_perspective_projection_matrix(65, Config.WINDOW_WIDTH / Config.WINDOW_HEIGHT, 0.1, 100.0)
Esempio n. 3
0
def create_nodes_with_importance(layer_nodes: List[int],
                                 center_position: Vector3,
                                 x_range: Tuple[float, float],
                                 y_range: Tuple[float, float],
                                 z_range: Tuple[float, float],
                                 node_importance_data: List[np.array],
                                 node_size: float = None) -> List[List[Node]]:
    nodes: List[List[Node]] = []
    num_classes: int = layer_nodes[len(layer_nodes) - 1]
    padding: int = get_buffer_padding(num_classes, ADDITIONAL_NODE_BUFFER_DATA)
    for layer, node_count in enumerate(layer_nodes):
        input_edges: int = 0
        output_edges: int = 0
        if 0 < layer:
            input_edges = layer_nodes[layer - 1]
        if layer < len(layer_nodes) - 1:
            output_edges = layer_nodes[layer + 1]
        nodes_sqrt = math.ceil(math.sqrt(node_count))

        current_layer_nodes: List[Node] = []
        if node_count <= 1:
            position: Vector3 = Vector3([
                center_position.x, center_position.y,
                z_range[0] * (1 - layer / (len(layer_nodes) - 1)) +
                z_range[1] * layer / (len(layer_nodes) - 1)
            ])
            current_layer_nodes.append(
                Node(len(current_layer_nodes), input_edges,
                     output_edges).importance_init(
                         num_classes, padding, position,
                         node_importance_data[layer][0]))
        else:
            node_size_x: float = node_size
            node_size_y: float = node_size
            if node_size is None:
                node_size_x = abs(x_range[1] - x_range[0]) / nodes_sqrt
                node_size_y = abs(y_range[1] - y_range[0]) / nodes_sqrt
            for i in range(node_count):
                pos_x: float = (i % nodes_sqrt) - (nodes_sqrt - 1.0) / 2.0
                pos_y: float = (math.floor(
                    i / nodes_sqrt)) - (nodes_sqrt - 1.0) / 2.0
                position: Vector3 = Vector3([
                    pos_x * node_size_x + center_position.x,
                    pos_y * node_size_y + center_position.y,
                    z_range[0] * (1 - layer / (len(layer_nodes) - 1)) +
                    z_range[1] * layer / (len(layer_nodes) - 1)
                ])
                current_layer_nodes.append(
                    Node(len(current_layer_nodes), input_edges,
                         output_edges).importance_init(
                             num_classes, padding, position,
                             node_importance_data[layer][i]))
        nodes.append(current_layer_nodes)
    return nodes
Esempio n. 4
0
 def set_position(self, camera_position_index: CameraPose):
     self.move_vector = Vector3([0, 0, 0])
     self.camera_up = Vector3([0.0, 1.0, 0.0])
     self.camera_pos = CAMERA_POSE_POSITION[camera_position_index]
     self.camera_pos = self.base + self.camera_pos
     self.camera_front = Vector3(
         vector.normalise(self.base - self.camera_pos))
     self.set_yaw_pitch_from_front(not camera_position_index == 0)
     self.camera_right = Vector3(
         vector.normalise(np.cross(self.camera_up, self.camera_front)))
     self.yaw_offset = 0.0
 def refract(v: vec3, n: vec3, ni_over_nt: float, refracted: vec3) -> bool:
     uv = v.normalized
     dt = uv.dot(n)
     discriminant = 1.0 - ni_over_nt**2 * (1.0 - dt**2)
     if discriminant > 0:
         new_refracted = ni_over_nt * (uv - n * dt) - n * sqrt(discriminant)
         refracted.x = new_refracted.x
         refracted.y = new_refracted.y
         refracted.z = new_refracted.z
         return True
     return False
Esempio n. 6
0
 def __init__(self, radius: float, **kwargs):
     self._radius: float = radius
     self._pos: Vector3 = Vector3([0.0, 0.0, 0.0])
     self._center: Vector3 = Vector3(kwargs.get("center", [0.0, 0.0, 0.0]))
     self._axes_lengths: Vector3 = Vector3(
         kwargs.get("axes_lengths", [0.0, 0.0, 0.0]))
     self._velocities: Vector3 = Vector3(
         kwargs.get("velocities", [0.0, 0.0, 0.0]))
     self._phase: Vector3 = Vector3(kwargs.get("phase", [0.0, 0.0, 0.0]))
     self._color: (float, float,
                   float) = tuple(kwargs.get("color", (1.0, 1.0, 1.0)))
 def pTov(self, x, y, radius):
     x = (2.0 * x) / self.windowWidth - 1.0
     y = 1.0 - (2.0 * y) / self.windowHeight
     d = math.sqrt(x * x + y * y)
     z = 0
     if d < radius:
         z = math.sqrt(radius * radius - d * d)
         return Vector3([x, y, z])
     else:
         z = 0
         return Vector3([x / d * radius, y / d * radius, z])
Esempio n. 8
0
    def __init__(self):
        self.camera_pos = Vector3([0.0, 0, 3.0])
        self.camera_front = Vector3([0.0, 0.0, -1.0])
        self.camera_up = Vector3([0.0, 1.0, 0.0])
        self.camera_right = Vector3([1.0, 0.0, 0.0])

        self.mouse_sensitivity = 0.25
        self.jaw = -90
        self.pitch = 0
        self.pitch_constraint = 60
        self.move_disabled = False
Esempio n. 9
0
    def update_camera_vectors(self):
        front = Vector3([0.0, 0.0, 0.0])
        front.x = cos(radians(self.yaw)) * cos(radians(self.pitch))
        front.y = sin(radians(self.pitch))
        front.z = sin(radians(self.yaw)) * cos(radians(self.pitch))

        self.camera_front = vector.normalise(front)
        self.camera_right = vector.normalise(
            vector3.cross(self.camera_front, Vector3([0.0, 1.0, 0.0])))
        self.camera_up = vector.normalise(
            vector3.cross(self.camera_right, self.camera_front))
Esempio n. 10
0
    def __init__(self):
        self.camera_pos = Vector3([0.0, 0.0, 3.0])
        self.camera_front = Vector3([0.0, 0.0, -1.0])
        self.camera_up = Vector3([0.0, 1.0, 0.0])
        self.camera_right = Vector3([1.0, 0.0, 0.0])

        self.mouse_sensitivity = 0.25
        self.yaw = -90.0
        self.pitch = 0.0

        self.last_camera_y = 0
Esempio n. 11
0
 def __compute_view_matrix(self, drone_pose):
     # Camera view matrix
     return Matrix44.look_at(
         # eye: position of the camera in world coordinates
         drone_pose.translation,
         # target: position in world coordinates that the camera is looking at
         drone_pose.translation +
         (drone_pose.orientation * Vector3([1.0, 0.0, 0.0])),
         # up: up vector of the camera.
         drone_pose.orientation * Vector3([0.0, 0.0, 1.0]),
     )
    def calculateMouseRay(self, projectionMatrix, viewMAtrix, screenX, screenY,
                          mouse_x, mouse_y):
        x = (2.0 * mouse_x) / screenX - 1.0
        y = 1.0 - (2.0 * mouse_y) / screenY
        z = -1.0
        D_view = Vector4.from_vector3(Vector3([x, y, z]), w=1.0)
        ray_eye = projectionMatrix.inverse * D_view

        ray_eye = Vector4([ray_eye.x, ray_eye.y, -1.0, 0.0])

        ray_wor = ((viewMAtrix.inverse) * ray_eye).xyz
        return Vector3(ray_wor)
Esempio n. 13
0
    def __init__(self, width, height, view):
        self.camera_position = Vector3([0., 0., 3.])
        self.camera_front = Vector3([0., 0., -1.])
        self.view_loc = view

        self.sensitivity = .4
        self.last_frame = 0
        self.last_x = width / 2
        self.last_y = height / 2
        self.pitch = 0
        self.yaw = 0
        self.last_cam_y = 0
Esempio n. 14
0
def Axis_from_jaw_pitch(jaw, pitch):
    front = Vector3([0.0, 0.0, 0.0])

    # jaw, pitch are spherical coordinates that define a unit vector
    front.x = cos(radians(jaw)) * cos(radians(pitch))
    front.z = sin(radians(pitch))
    front.y = sin(radians(jaw)) * cos(radians(pitch))

    right = vector3.cross(front, Vector3([0.0, 0.0, 1.0]))
    up = vector3.cross(right, front)

    return (front, right, up)
 def __init__(self, x, y, radius):  #
     self.windowWidth = x
     self.windowHeight = y
     self.radius = radius
     self.startX = 0
     self.startY = 0
     self.trackballMove = False
     self.curPos = Vector3([0, 0, 0])
     self.lastPos = Vector3([0, 0, 0])
     self.angle = 0
     self.axis = Vector3([1, 0, 1])
     self.doingAnything = True
Esempio n. 16
0
def barryCentric(p1, p2, p3, pos):
    # pos is a Vector2
    p1 = Vector3(p1)
    p2 = Vector3(p2)
    p3 = Vector3(p3)
    det = (p2.z - p3.z) * (p1.x - p3.x) + (p3.x - p2.x) * (p1.z - p3.z)
    l1 = ((p2.z - p3.z) * (pos[0] - p3.x) + (p3.x - p2.x) *
          (pos[1] - p3.z)) / det
    l2 = ((p3.z - p1.z) * (pos[0] - p3.x) + (p1.x - p3.x) *
          (pos[1] - p3.z)) / det
    l3 = 1.0 - l1 - l2
    return l1 * p1.y + l2 * p2.y + l3 * p3.y
Esempio n. 17
0
 def rotate(data, xs=1, ys=1, zs=1):
     out = []
     if xs != 1 or ys != 1 or zs != 1:
         scale = Vector3([xs, ys, zs])
     else:
         scale = None
     for i in xrange(0, len(data), 3):
         vec = rotation * Vector3(data[i:i + 3])
         if scale is not None:
             vec *= scale
         out += list(vec)
     return out
Esempio n. 18
0
    def __init__(self, ratio):
        self._field_of_view_degrees = 60.0
        self._z_near = 0.1
        self._z_far = 1000
        self._ratio = ratio
        self.build_projection()

        self._camera_position = Vector3([-20.0, 100.0, -20.0])
        self._camera_front = Vector3([50.0, -50.0, 50.0])
        self._camera_up = Vector3([0.0, 1.0, 0.0])
        self._cameras_target = (self._camera_position + self._camera_front)
        self.build_look_at()
Esempio n. 19
0
    def __init__(self):
        self.camera_pos = Vector3([0.0, 0.0, 0.0])
        self.camera_front = Vector3([0.0, 0.0, -1.0])
        self.camera_up = Vector3([0.0, 1.0, 0.0])
        self.camera_right = Vector3([1.0, 0.0, 0.0])

        self.mouse_sensitivity = 0.5
        self.velocity = 0.05
        self.yaw = 0.0
        self.pitch = 0.0

        self.lastX = 64
        self.lastY = 64
Esempio n. 20
0
 def OnDragValue(self, event):
     pos = Vector3([
         self.position_x.value, self.position_y.value, self.position_z.value
     ])
     up = Vector3([self.up_x.value, self.up_y.value, self.up_z.value])
     direction = Vector3([
         self.direction_x.value, self.direction_y.value,
         self.direction_z.value
     ])
     self.flythrough.camera.look_at(pos, pos + direction, up)
     self.gl_canvas.camera_interactor.reset_position(False)
     self.gl_canvas.Refresh()
     self.UpdateTimeline()
Esempio n. 21
0
    def get_position(self) -> Vector3:
        """ Get camera position in world coordinate system. """

        mat = self.matrix
        relative_pos = Vector3([mat[3, 0], mat[3, 1], mat[3, 2]])
        relative_pos *= -1
        actual_pos = Vector3()

        for i in range(3):
            actual_pos[i] = mat[i, 0] * relative_pos.x + mat[
                i, 1] * relative_pos.y + mat[i, 2] * relative_pos.z

        return actual_pos
Esempio n. 22
0
def parse_input(input_file: TextIO) -> list[Scanner]:
    scanners = []
    for line in input_file:
        line = line.strip()
        if line.startswith("---"):
            res = parse("--- scanner {idx:d} ---", line)
            scanner = Scanner(res.named["idx"], [], Vector3(),
                              Matrix33.identity())
            scanners.append(scanner)
        elif line:
            scanner.beacons.append(
                Vector3([int(p) for p in line.split(",")], dtype=np.int_))
    return scanners
Esempio n. 23
0
    def __init__(self, ctx, vao):
        """
        Construct the Fresnel helper class.

        :param ctx: The OpenGL context to render in.
        :param vao: The model to render.
        """
        self.ctx = ctx
        self.vao = vao

        self.light_pos = Vector3([0.0, 0.0, 2.0], dtype='f4')
        self.light_color = Vector3([1.0, 1.0, 1.0], dtype='f4')
        self.object_color = Vector3([1.0, 0.5, 0.31], dtype='f4')
Esempio n. 24
0
def test_intersects_bbox():
    bbox = BoundingBox(0, 0, 0, 100, 100, 20)
    origin = Vector3(numpy.array([105, 105, 25], dtype=numpy.float32))
    world_origin = Vector3(numpy.array([0, 0, 0], dtype=numpy.float32))
    up = Vector3([0, 0, 1], numpy.float32)
    c = Camera()
    c.look_at(origin, world_origin, up)
    direction = c.get_direction()
    ray = Ray(origin, direction)
    assert ray.intersects_bbox(bbox)
    ray.origin = -origin  # Move ray past bbox
    assert not ray.intersects_bbox(bbox)
    ray.direction = -direction  # Now look at it from opposite side
    assert ray.intersects_bbox(bbox)
Esempio n. 25
0
    def spawn_initial_planets(self):
        # create sun
        self.sun = Circle(
            position=Vector3([PsauxConfig.width / 2.0, PsauxConfig.height / 2.0, 0.0]),
            mass=1e6,
            velocity=Vector3([0.0, 0.0, 0.0]),
            color=RED,
            batch=self.drawing_batch,
        )
        self.entities.append(self.sun)

        # create starting planets
        self.spawn_planet(
            position=Vector3([200.0, 700.0, 0.0]),
            velocity=Vector3([3e-4, 4e-5, 0.0]),
            mass=1e4,
            color=GREEN,
        )
        self.spawn_planet(Vector3([213.3, 700.0, 0.0]), Vector3([-3e-4, 4e-5, 0.0]))
        self.spawn_planet(
            position=Vector3([400.0, 480.0, 0.0]),
            velocity=Vector3([5e-4, 2e-4, 0.0]),
            mass=1e4,
            color=GREEN,
        )
Esempio n. 26
0
    def create_transformation(self, rotation=None, translation=None):
        """Convenient transformation method doing rotations and translation"""
        mat = None
        if rotation is not None:
            mat = Matrix44.from_eulers(Vector3(rotation))

        if translation is not None:
            trans = matrix44.create_from_translation(Vector3(translation))
            if mat is None:
                mat = trans
            else:
                mat = matrix44.multiply(mat, trans)

        return mat
Esempio n. 27
0
    def __compute_bbox_coords(self, mesh, view):
        upright = Quaternion.from_y_rotation(np.pi / 2)
        rotation = Quaternion(mesh['rotation'])
        center = mesh['translation']
        world_corners = {
            'top_left':
            Vector3([center[0], center[1], center[2]]) +
            (rotation * upright *
             Vector3([0, mesh['width'] / 2, mesh['height'] / 2])),
            'top_right':
            Vector3([center[0], center[1], center[2]]) +
            (rotation * upright *
             Vector3([0, -mesh['width'] / 2, mesh['height'] / 2])),
            'bottom_right':
            Vector3([center[0], center[1], center[2]]) +
            (rotation * upright *
             Vector3([0, -mesh['width'] / 2, -mesh['height'] / 2])),
            'bottom_left':
            Vector3([center[0], center[1], center[2]]) +
            (rotation * upright *
             Vector3([0, mesh['width'] / 2, -mesh['height'] / 2]))
        }

        hidden_corners = 0
        left = right = top = bottom = None

        for key, value in world_corners.items():
            img_coords = self.__project_to_img_frame(value, view)
            if (img_coords[0] < 10 or img_coords[0] > (self.width - 10)
                    or img_coords[1] < 10 or img_coords[1] >
                (self.height - 10)):
                hidden_corners += 1
            if left is None or (img_coords[0] < left['x']):
                left = {'x': img_coords[0], 'y': img_coords[1]}
            if top is None or (img_coords[1] < top['y']):
                top = {'x': img_coords[0], 'y': img_coords[1]}
            if bottom is None or (img_coords[1] > bottom['y']):
                bottom = {'x': img_coords[0], 'y': img_coords[1]}
            if right is None or (img_coords[0] > right['x']):
                right = {'x': img_coords[0], 'y': img_coords[1]}

        image_corners = {
            'min': [int(left['x']), int(top['y'])],
            'max': [int(right['x']), int(bottom['y'])]
        }

        if hidden_corners > 3:
            return {}
        elif hidden_corners > 0:
            for key, img_coords in image_corners.items():
                for i in range(0, 2):
                    if img_coords[i] < 0:
                        img_coords[i] = 0
                    elif img_coords[i] > (self.width
                                          if i == 0 else self.height):
                        img_coords[i] = self.width if i == 0 else self.height
                image_corners[key] = img_coords

        return image_corners
Esempio n. 28
0
    def on_mouse_release(self, x: float, y: float, button: int,
                         modifiers: int):
        if self.drag and modifiers ^ pyglet.window.key.MOD_SHIFT:
            start_x, start_y = self.click_coord
            movement_vector = Vector3([x - start_x, y - start_y, 0])
            delta_x, delta_y, _ = movement_vector * self.world.settings.drag_sensitivity

            self.world.spawn_planet(
                position=Vector3([start_x, start_y, 0.0]),
                velocity=Vector3([delta_x, delta_y, 0.0]),
            )

        self.click_coord = None
        self.drag = False
        self.mouse_line.visible = False
Esempio n. 29
0
    def render(self, time: float, frametime: float):
        self.ctx.enable_only(moderngl.CULL_FACE | moderngl.DEPTH_TEST)

        m_rot = Matrix44.from_eulers(Vector3((time, time, time)))
        m_trans = matrix44.create_from_translation(Vector3((0.0, 0.0, -3.0)))
        m_mv = matrix44.multiply(m_rot, m_trans)

        self.prog['m_proj'].write(self.camera.projection.tobytes())
        self.prog['m_model'].write(m_mv.astype('f4').tobytes())
        self.prog['m_camera'].write(self.camera.matrix.astype('f4').tobytes())
        self.prog['layer'].value = math.fmod(time, 10)

        self.prog['texture0'].value = 0
        self.texture.use(location=0)
        self.cube.render(self.prog)
 def create_perspective_projection():
     view = matrix44.create_from_translation(Vector3([0.0, 0.0, -2.0]))
     projection = matrix44.create_perspective_projection_matrix(45.0, 1280.0 / 720.0, 0.1, 100.0)
     vp = matrix44.multiply(view, projection).flatten().astype("float32")
     c_vp = numpy.ctypeslib.as_ctypes(vp)
     vp_loc = glGetUniformLocation(InitShader.shader, b"vp")
     glUniformMatrix4fv(vp_loc, 1, GL_FALSE, c_vp)
Esempio n. 31
0
    def test_conversions(self):
        from pyrr import Quaternion, Matrix33, Matrix44, Vector3, Vector4

        v3 = Vector3([1.,0.,0.])
        v4 = Vector4.from_vector3(v3, w=1.0)
        v3, w = Vector3.from_vector4(v4)

        m44 = Matrix44()
        q = Quaternion(m44)
        m33 = Matrix33(q)

        m33 = Matrix44().matrix33
        m44 = Matrix33().matrix44
        q = Matrix44().quaternion
        q = Matrix33().quaternion

        m33 = Quaternion().matrix33
        m44 = Quaternion().matrix44