Exemplo n.º 1
0
    def create_translate(x=None, y=None, z=None):
        from maths.matrix44 import Matrix44
        from maths.vector3d import Vector3d
        from maths.vector4d import Vector4d

        if type(x) == Vector3d:
            m = Matrix44.create_from_vector4d(Vector4d(1.0, 0.0, 0.0, 0.0),
                                              Vector4d(0.0, 1.0, 0.0, 0.0),
                                              Vector4d(0.0, 0.0, 1.0, 0.0),
                                              Vector4d(x.x, x.y, x.z, 1.0))

            m_inv = Matrix44.create_from_vector4d(Vector4d(1.0, 0.0, 0.0, 0.0),
                                                  Vector4d(0.0, 1.0, 0.0, 0.0),
                                                  Vector4d(0.0, 0.0, 1.0, 0.0),
                                                  Vector4d(-x.x, -x.y, -x.z, 1.0))
        else:
            m = Matrix44.create_from_vector4d(Vector4d(1.0, 0.0, 0.0, 0.0),
                                              Vector4d(0.0, 1.0, 0.0, 0.0),
                                              Vector4d(0.0, 0.0, 1.0, 0.0),
                                              Vector4d(x, y, z, 1.0))
            m_inv = Matrix44.create_from_vector4d(Vector4d(1.0, 0.0, 0.0, 0.0),
                                                  Vector4d(0.0, 1.0, 0.0, 0.0),
                                                  Vector4d(0.0, 0.0, 1.0, 0.0),
                                                  Vector4d(-x, -y, -z, 1.0))
        return Transform(m, m_inv)
Exemplo n.º 2
0
    def create_identity():
        from maths.matrix44 import Matrix44
        from maths.vector4d import Vector4d

        m = Matrix44.create_from_vector4d(Vector4d(1.0, 0.0, 0.0, 0.0), Vector4d(0.0, 1.0, 0.0, 0.0),
                                          Vector4d(0.0, 0.0, 1.0, 0.0), Vector4d(0.0, 0.0, 0.0, 1.0))
        return Transform(m, m)
Exemplo n.º 3
0
    def create_look_at(eye, at, up):
        from maths.vector4d import Vector4d
        from maths.vector3d import Vector3d

        # Initialize first three columns of viewing matrix
        z_axis = (at - eye).get_normalized()
        x_axis = maths.vector3d.Vector3d.cross(up, z_axis).get_normalized()
        y_axis = maths.vector3d.Vector3d.cross(z_axis, x_axis)

#        m = Matrix44.create_from_vector4d(
#            Vector4d.create_from_vector3d(x_axis, -maths.vector3d.Vector3d.dot(x_axis, eye)),
#            Vector4d.create_from_vector3d(y_axis, -maths.vector3d.Vector3d.dot(y_axis, eye)),
#            Vector4d.create_from_vector3d(z_axis, -maths.vector3d.Vector3d.dot(z_axis, eye)),
#            Vector4d(0.0, 0.0, 0.0, 1.0)
#        )
#        m = Matrix44.create_from_vector4d(
#            Vector4d.create_from_vector3d(x_axis, 0.0),
#            Vector4d.create_from_vector3d(y_axis, 0.0),
#            Vector4d.create_from_vector3d(z_axis, 0.0),
#            Vector4d(
#                -maths.vector3d.Vector3d.dot(x_axis, eye),
#                -maths.vector3d.Vector3d.dot(y_axis, eye),
#                -maths.vector3d.Vector3d.dot(z_axis, eye), 1.0)
#        )
        m = Matrix44.create_from_vector4d(
            Vector4d(x_axis.x, y_axis.x, z_axis.x, 0.0),
            Vector4d(x_axis.y, y_axis.y, z_axis.y, 0.0),
            Vector4d(x_axis.z, y_axis.z, z_axis.z, 0.0),
            Vector4d(
                -maths.vector3d.Vector3d.dot(x_axis, eye),
                -maths.vector3d.Vector3d.dot(y_axis, eye),
                -maths.vector3d.Vector3d.dot(z_axis, eye), 1.0)
        )
        return Transform(m.get_invert(), m)
Exemplo n.º 4
0
    def create_rot_z(angle):
        from maths.matrix44 import Matrix44
        from maths.vector4d import Vector4d

        c = math.cos(angle)
        s = math.sin(angle)
        m = Matrix44.create_from_vector4d(Vector4d(c, s, 0.0, 0.0),
                                          Vector4d(-s, c, 0.0, 0.0),
                                          Vector4d(0.0, 0.0, 1.0, 0.0),
                                          Vector4d(0.0, 0.0, 0.0, 1.0))
        return Transform(m, m.get_transpose())
Exemplo n.º 5
0
    def create_rotate(angle: float, axis):
        from maths.matrix44 import Matrix44
        from maths.vector4d import Vector4d

        a = axis.get_normalized()
        s = math.sin(angle)
        c = math.cos(angle)
        m = Matrix44.create_from_vector4d(Vector4d(a.x * a.x + (1.0 - a.x * a.x) * c, a.x * a.y * (1.0 - c) - a.z * s, a.x * a.z * (1.0 - c) + a.y * s, 0.0),
                                          Vector4d(a.x * a.y * (1.0 - c) + a.z * s, a.y * a.y + (1.0 - a.y * a.y) * c, a.y * a.z * (1.0 - c) - a.x * s, 0.0),
                                          Vector4d(a.x * a.z * (1.0 - c) - a.y * s, a.y * a.z * (1.0 - c) + a.x * s, a.z * a.z + (1.0 - a.z * a.z) * c, 0.0),
                                          Vector4d(0.0, 0.0, 0.0, 1.0))
        return Transform(m, m.get_transpose())
Exemplo n.º 6
0
    def create_scale(x=None, y=None, z=None):
        from maths.matrix44 import Matrix44
        from maths.vector3d import Vector3d
        from maths.vector4d import Vector4d

        if type(x) == Vector3d:
            m = Matrix44.create_from_vector4d(Vector4d(x.x, 0.0, 0.0, 0.0),
                                              Vector4d(0.0, x.y, 0.0, 0.0),
                                              Vector4d(0.0, 0.0, x.z, 0.0),
                                              Vector4d(0.0, 0.0, 0.0, 1.0))
            m_inv = Matrix44.create_from_vector4d(Vector4d(1.0 / x.x, 0.0, 0.0, 0.0),
                                                  Vector4d(0.0, 1.0 / x.y, 0.0, 0.0),
                                                  Vector4d(0.0, 0.0, 1.0 / x.z, 0.0),
                                                  Vector4d(0.0, 0.0, 0.0, 1.0))
        else:
            m = Matrix44.create_from_vector4d(Vector4d(x, 0.0, 0.0, 0.0),
                                              Vector4d(0.0, y, 0.0, 0.0),
                                              Vector4d(0.0, 0.0, z, 0.0),
                                              Vector4d(0.0, 0.0, 0.0, 1.0))
            m_inv = Matrix44.create_from_vector4d(Vector4d(1.0 / x, 0.0, 0.0, 0.0),
                                                  Vector4d(0.0, 1.0 / y, 0.0, 0.0),
                                                  Vector4d(0.0, 0.0, 1.0 / z, 0.0),
                                                  Vector4d(0.0, 0.0, 0.0, 1.0))
        return Transform(m, m_inv)
Exemplo n.º 7
0
    def create_perspective(fov: float=90, z_near: float=0.0, z_far: float=1.0):
        from maths.vector4d import Vector4d

        inv = 1.0 / (z_far - z_near)

        # Perform projective divide
        perspective_matrix = Matrix44.create_from_vector4d(
            Vector4d(1.0, 0.0, 0.0, 0.0),
            Vector4d(0.0, 1.0, 0.0, 0.0),
            Vector4d(0.0, 0.0, z_far * inv, 1.0),
            Vector4d(0.0, 0.0, -z_far * z_near * inv, 0.0)
        )

        # Scale to canonical viewing volume
        inv_tan = 1.0 / math.tan(math.radians(fov) * 0.5)

        return Transform(perspective_matrix) * Transform.create_scale(inv_tan, inv_tan, 1.0)
Exemplo n.º 8
0
def create_spotLight(paramSet: ParamSet, light2world: Transform) -> PointLight:
    from maths.matrix44 import Matrix44
    from maths.vector4d import Vector4d

    I = paramSet.find_spectrum("I", Spectrum(1.0))
    sc = paramSet.find_spectrum("scale", Spectrum(1.0))
    coneangle = paramSet.find_float("coneangle", 30.0)
    conedelta = paramSet.find_float("conedeltaangle", 5.0)

    # Compute spotlight world to light transformation
    frome = paramSet.find_point("from", Point3d(0.0, 0.0, 0.0))
    to = paramSet.find_point("to", Point3d(0.0, 0.0, 1.0))
    direction = (to - frome).get_normalized()
    du, dv = Transform.create_coordinateSystem(dir)
    m = Matrix44.create_from_vector4d(
        Vector4d(du.x, du.y, du.z, 0.0),
        Vector4d(dv.x, dv.y, dv.z, 0.0),
        Vector4d(direction.x, direction.y, direction.z, 0.0),
        Vector4d(0.0, 0.0, 0.0, 1.0))
    dirToZ = Transform(m)
    light2world = light2world * Transform.create_translate(frome.ex, frome.ey, frome.ez) * dirToZ.get_invert()
    return SpotLight(light2world, I * sc, coneangle, coneangle - conedelta)