Пример #1
0
def bind_phosphorus(frame, size):
    """
    Animating the process of phosfor binding to the Tyr
    """

    phosphorus_model = Texture(Pigment('color', [1, 0, 1], ), Finish('reflection', 0))
    text_model = Texture(Pigment('color', [1, 1, 0], ), Finish('reflection', 0))

    phosphorus = []
    s = size

    # frame 480 -> 570
    x_locs = [[-20, -5], [20, 5], [-20, -5], [20, 5]]
    y_locs = [13, 13, 10, 10]

    for _ in range(4):
        if frame < 570:
            x = (frame - 480) * ((x_locs[_][1]*s - x_locs[_][0]*s) / 90) + x_locs[_][0]*s
            y = 0 - y_locs[_] * s
        else:
            x = x_locs[_][1]*s
            y = 0 - y_locs[_]*s
        phosphorus.append(Sphere([x, y, 2], s * 1.2, phosphorus_model))
        phosphorus.append(Text('ttf', '"timrom.ttf"', '"{}"'.format(str('P')), 0.5, [0, 0, 0], text_model, 'scale', 7, 'translate', [x - 0.2*s, y-0.5*s, -1.5*s]))
    return phosphorus
Пример #2
0
def bind_schematic(frame, size):

    """
    Animating the binding part schematicly
    """

    insuline_model = Texture(Pigment('color', [0, 1, 0.5], ), Finish('reflection', 0))
    text_model = Texture(Pigment('color', [1, 1, 0], ), Finish('reflection', 0))

    insuline = []
    s = size

    # frame 30 -> 120
    if frame < 120:
        x = (frame - 30) * (24.5*s / 90) - 30*s
        y = (frame - 30) * (-15*s / 90) + 20*s 
    else:
        x = -5*s
        y = 5*s

    insuline.append(Sphere([x, y, 0], s * 1.5, insuline_model))
    insuline.append(Text('ttf', '"timrom.ttf"', '"{}"'.format(str('Insulin')), 0.5, [0, 0, 0], text_model, 'scale', 5, 'translate', [x - s, y-0.5*s, -2*s]))

    insuline.append(Sphere([0-x, y, 0], s * 1.5, insuline_model))
    insuline.append(Text('ttf', '"timrom.ttf"', '"{}"'.format(str('Insulin')), 0.5, [0, 0, 0], text_model, 'scale', 5, 'translate', [0-x -1.4*s, y-0.5*s, -2*s]))

    return insuline
Пример #3
0
def scene(step):
    ''' Returns the scene at step number (1 step per frame) '''
    A = np.array([-10, 8, 0])
    B = np.array([5, 2, -20])
    
    # Find a point with distance 3 from A
    BA = B-A # Vector B->A
    d = math.sqrt(sum(np.power(BA, 2))) # distance
    BA = BA / d # Normalize by its length; BA / ||BA||
    scale = 4
    N = A + scale * BA # Scale and add to A
    l = Cylinder(A, B, 0.05, Pigment('color', [0, 1, 0]))
    s1 = Sphere(N, 0.5, Texture(Pigment('color', [0.9, 0.05, 0.05])))
    
    scale = 15
    N = A + scale * BA # Scale and add to A
    s2 = Sphere(N, 0.5, Texture(Pigment('color', [0.9, 0.05, 0.05])))
    
    scale = 24
    N = A + scale * BA # Scale and add to A
    s3 = Sphere(N, 0.5, Texture(Pigment('color', [0.9, 0.05, 0.05])))
    
    return Scene(povray.floor_camera,
                 objects=[povray.default_light, povray.checkered_ground, 
                 l, s1, s2, s3],
                 included=['colors.inc'])
Пример #4
0
def frame(step):
    """ Creates a frame of 4 cones, 4 boxes, 1 sphere and a legend """

    # Define textures for different models
    sphere_model = Texture(Pigment('color', [1, 0, 1], ), Finish('reflection', 0.5))
    box_model = Texture(Pigment('color', [0, 1, 1], ), Finish('reflection', 0))
    cone_model = Texture(Pigment('color', [1, 0, 1], ), Finish('reflection', 0))

    # Create objects
    sphere = Sphere([0, 0, 0], 3, sphere_model)

    box_1 = Box([-5, -5, -4], [-3, 5, 4], box_model)
    box_2 = Box([3, -5, -4], [5, 5, 4], box_model)
    box_3 = Box([-5, 4, -4], [5, 6, 4], box_model)
    box_4 = Box([-5, -5, -4], [5, -3, 4], box_model)

    cone_1 = Cone([0, 6, 0], 3, [0, 10, 0], 0, cone_model)
    cone_2 = Cone([0, -6, 0], 3, [0, -10, 0], 0, cone_model)
    cone_3 = Cone([-5, 0, 0], 3, [-9, 0, 0], 0, cone_model)
    cone_4 = Cone([5, 0, 0], 3, [9, 0, 0], 0, cone_model)

    light_1 = LightSource([0, 10, -25], 'color', [1, 1, 1])
    light_2 = LightSource([0, 8, -7], 'color', [1, 1, 1])

    xyz_legend = legend([-15, 0, 0], 5)

    camera = Camera('location', [0, 7, -30], 'look_at', [0, 2, 1])

    # Return the Scene object for rendering
    return Scene(camera,
                 objects=[sphere, box_1, box_2, box_3, box_4,
                          cone_1, cone_2, cone_3, cone_4, light_1, light_2] + xyz_legend)
Пример #5
0
def legend(loc, length):
    """
    Creates a legend in a given location.
        Usage: legend([x, y, z], length)
    """

    # Defining textures for each axis
    x_model = Texture(Pigment(
        'color',
        [1, 0, 0],
    ), Finish('reflection', 0))
    z_model = Texture(Pigment(
        'color',
        [0, 0, 1],
    ), Finish('reflection', 0))
    y_model = Texture(Pigment(
        'color',
        [0, 1, 0],
    ), Finish('reflection', 0))

    # Create objects
    x_cyl = Cylinder(loc, [loc[0] + length, loc[1], loc[2]], 0.1, x_model)
    x_cone = Cone([loc[0] + length, loc[1], loc[2]], 0.3,
                  [loc[0] + length + 1, loc[1], loc[2]], 0, x_model)

    z_cyl = Cylinder(loc, [loc[0], loc[1], loc[2] + length], 0.1, y_model)
    z_cone = Cone([loc[0], loc[1], loc[2] + length], 0.3,
                  [loc[0], loc[1], loc[2] + length + 1], 0, y_model)

    y_cyl = Cylinder(loc, [loc[0], loc[1] + length, loc[2]], 0.1, z_model)
    y_cone = Cone([loc[0], loc[1] + length, loc[2]], 0.3,
                  [loc[0], loc[1] + length + 1, loc[2]], 0, z_model)

    return [x_cyl, x_cone, y_cyl, y_cone, z_cyl, z_cone]
Пример #6
0
def frame(step):
    """ Creates a sphere and 4 boxes, places this in a scene """
    lichtje = LightSource([2, 8, -5], 5.0)
    default_camera = Camera('location', [0, 4, -40], 'look_at', [0, 2, -5])

    stylebox = Texture(Pigment('color', [0.80, 0.00, 1.00], 'filter', 0.7),
                       Finish('phong', 0.6, 'reflection', 0.4))
    boxright = Box([3, -2, -3], [5, 6, 4], stylebox)
    boxleft = Box([-5, -2, -3], [-3, 6, 4], stylebox)
    boxupper = Box([-5, 6, -3], [5, 8, 4], stylebox)
    boxbottom = Box([-5, -4, -3], [5, -2, 4], stylebox)

    styleball = Texture(Pigment('color', [0.80, 0.00, 1.00], 'filter', 0.7))
    centerball = Sphere([0, 2, 0], 3, styleball)

    conetop = Cone([0, 8, 0], 3, [0, 12, 0], 0, stylebox)
    conebottom = Cone([0, -4, 0], 3, [0, -8, 0], 0, stylebox)
    coneleft = Cone([-5, 2, 0], 3, [-11, 2, 0], 0, stylebox)
    coneright = Cone([5, 2, 0], 3, [11, 2, 0], 0, stylebox)

    # Return the Scene object for rendering
    return Scene(default_camera,
                 objects=[
                     lichtje, centerball, boxright, boxleft, boxupper,
                     boxbottom, conetop, conebottom, coneleft, coneright
                 ])
Пример #7
0
def main():
    lookfrom = (13 / 1.5, 2 / 1.5, -5 / 1.5)
    lookat = (0, 0, 0)
    # dist_to_focus = 10.0
    # aperture = 0.1
    step = 1
    # camera
    camera = Camera('location', lookfrom, 'look_at', lookat)

    # background
    light = LightSource((0, 20, 0), 'color', (1, 1, 1))
    bg = Background('color', (0.5, 0.7, 1.0))
    base = Sphere((0, -1000, 0), 1000,
                  Texture(Pigment('color', (0.5, 0.5, 0.5))))
    htlist = [bg, base, light]
    for a in range(-11, 11, step):
        for b in range(-11, 11, step):
            choose_mat = random.random()
            center = (a + 0.9 * random.random(),
                      0.2, b + 0.9 * random.random())
            if distance(center, (4, 0.2, 0)) < 0.9:
                continue
            if choose_mat < 0.8:
                # diffuse
                color = (random.random() * random.random(),
                         random.random() * random.random(),
                         random.random() * random.random())
                htlist.append(
                    Sphere(center, 0.2, Texture(Finish('diffuse', 1), Pigment('color', color))))
            elif choose_mat < 0.95:
                # metal
                color = (0.5 * (1 + random.random()),
                         0.5 * (1 + random.random()),
                         0.5 * (1 + random.random()))
                # p1 = 0.5 * random.random()
                htlist.append(
                    Sphere(center, 0.2, Texture(Finish('Metal'), Pigment('color', color))))
            else:
                # glass
                htlist.append(Sphere(center, 0.2, Material('M_Glass')))

    # main 3 sphere
    htlist.append(
        Sphere((0, 1, 0), 1.0, Material('M_Glass')))
    htlist.append(
        Sphere((-4, 1, 0), 1.0, Texture(Finish('diffuse', 1), Pigment('color', (0.4, 0.2, 0.2)))))
    htlist.append(Sphere((4, 1, 0), 1.0, Texture('Chrome_Texture')))
    scene = Scene(camera, objects=htlist, included=[
                  'metals.inc', 'glass.inc', 'textures.inc', 'colors.inc'])
    with open("where-next.pov", "w") as ofp:
        print(str(scene), file=ofp)
    scene.render('where-next.png', width=800, height=600,
                 antialiasing=0.1, quality=10)
Пример #8
0
def make_membrane(loc, amount, size=5):
    """
    Create the membrane and returns the object
    """

    sphere_model = Texture(Pigment('color', [1, 0, 0], ), Finish('reflection', 0))
    cyl_model = Texture(Pigment('color', [0.7, 0.3, 0], ), Finish('reflection', 0))

    x_position = loc[0]
    y_position = loc[0] - size * 6
    objects = []
    for index in range(1, amount + 1):

        # Create top spheres
        objects.append(Sphere([x_position, loc[1], loc[2]], size, sphere_model))
        objects.append(Sphere([0 - x_position, loc[1], loc[2]], size, sphere_model))

        # Create top cylinders
        location = [x_position - size/3, loc[1], loc[2]], [x_position - size/3, loc[1] - size*2.5, loc[2]]
        objects.append(Cylinder(location[0], location[1], size/6, cyl_model))

        location = [x_position + size/3, loc[1], loc[2]], [x_position + size/3, loc[1] - size*2.5, loc[2]]
        objects.append(Cylinder(location[0], location[1], size/6, cyl_model))

        location = [0-x_position - size/3, loc[1], loc[2]], [0-x_position - size/3, loc[1] - size*2.5, loc[2]]
        objects.append(Cylinder(location[0], location[1], size/6, cyl_model))

        location = [0-x_position + size/3, loc[1], loc[2]], [0-x_position + size/3, loc[1] - size*2.5, loc[2]]
        objects.append(Cylinder(location[0], location[1], size/6, cyl_model))

        # Create bottom spheres
        objects.append(Sphere([x_position, y_position, loc[2]], size, sphere_model))
        objects.append(Sphere([0 - x_position, y_position, loc[2]], size, sphere_model))

        # Create bottom cylinders
        location = [x_position - size/3, y_position, loc[2]], [x_position - size/3, y_position + size*2.5, loc[2]]
        objects.append(Cylinder(location[0], location[1], size/6, cyl_model))

        location = [x_position + size/3, y_position, loc[2]], [x_position + size/3, y_position + size*2.5, loc[2]]
        objects.append(Cylinder(location[0], location[1], size/6, cyl_model))

        location = [0-x_position - size/3, y_position, loc[2]], [0-x_position - size/3, y_position + size*2.5, loc[2]]
        objects.append(Cylinder(location[0], location[1], size/6, cyl_model))

        location = [0-x_position + size/3, y_position, loc[2]], [0-x_position + size/3, y_position + size*2.5, loc[2]]
        objects.append(Cylinder(location[0], location[1], size/6, cyl_model))

        x_position += size * 2

    return objects
Пример #9
0
def scene(step):
    # Storing the cylinders
    cylinders = []
    n = 7
    for i in range(n):
        cylinders.append(
            Cylinder([0, 0, 0], [1.2, 0, 0], 1.0, 1.0, 'scale', [1, 0.25, 1],
                     'rotate', [-30, 0, 0], 'translate', [1.25, 0, 0],
                     'rotate', [0, i * 360 / n, 0], Texture('Chrome_Texture'),
                     Pigment('color', [0.1, 0.1, 0.1]),
                     Finish('phong', 1, 'reflection', 1)))

    # Reset color for the center sphere
    degrees = (360 / (SETTINGS.Duration * SETTINGS.RenderFPS)) * step

    prop = Blob(
        'threshold',
        0.65,
        # Add a Sphere with radius and strength = 1
        Sphere(
            [0, 0, 0],
            1.00,
            1.00,
            # Double the heigth of the Sphere
            'scale',
            [1, 2, 1],
            # Make it shine
            Texture('Chrome_Texture', Pigment('color', [0.1, 0.1, 0.1]),
                    Finish('phong', 0.5, 'reflection', 0.5))),
        # unpack cylinders
        *cylinders,
        # Scale the whole objects (enlarge)
        'scale',
        1.8,
        # rotate counter-clockwise
        'rotate',
        [90, 0, degrees],
        # re-center
        'translate',
        [0, 0.5, 0])

    camera = Camera('location', [5, 10, -8], 'look_at', [0, 0, 0])
    xyz_legend = legend([-10, 0, 0], 3)
    return Scene(
        camera,
        objects=[prop] + xyz_legend + povray.default_spots,
        # The 'Chrome_Texture comes from the 'textures.inc' file
        included=['textures.inc'])
Пример #10
0
def make_receptor(loc, size=5):
    """
    Creates the receptor and returns the object
    """
    rec_model = Texture(Pigment('color', [0, 1, 1], ), Finish('reflection', 0))

    x = loc[0]
    y = loc[1]
    z = loc[2]

    rec = list()
    rec.append(Cylinder([x - size * 1.2, y - size * 15, z], [x - size * 1.2, y + size*2, z], size, rec_model))
    rec.append(Cylinder([x + size * 1.2, y - size * 15, z], [x + size * 1.2, y + size*2, z], size, rec_model))
    rec.append(Cylinder([x - size * 1.2, y + size * 1.2, z], [x - size * 5, y + size * 4, z], size, rec_model))
    rec.append(Cylinder([x - size * 7.2, y + size * 4, z - size/2],
                        [x - size * 3.2, y + size * 4, z - size/2],
                        size / 1.321, rec_model))

    rec.append(Cylinder([x + size * 1.2, y + size * 1.2, z], [x + size * 5, y + size * 4, z], size, rec_model))
    rec.append(Cylinder([x + size * 7.2, y + size * 4, z - size/2],
                        [x + size * 3.2, y + size * 4, z - size/2],
                        size / 1.321, rec_model))

    rec.append(Sphere([x, y - size * 6, z], size * 3, rec_model))

    return rec
def frame(step):
    curr_time = step / eval(SETTINGS.NumberFrames) * eval(SETTINGS.FrameTime)
    logger.info(" @Time: %.3fs, Step: %d", curr_time, step)

    nframes = eval(SETTINGS.NumberFrames)

    style = Texture(Pigment('color', [0.80, 0.00, 1.00], 'filter', 0.7),
                    Finish('phong', 0.6, 'reflection', 0.4))

    cylinder = Cylinder([-6, -1, 4], [-6, 7, 4], 3, style)
    sphere = Sphere([6, 2, -2], 3, style)
    leg = legend([-15, 0, 0], 5)

    radius = 25
    z_start = -25
    x_start = 0
    alpha = (-pi / 2) + (step * 2 * pi / nframes)
    x_coord = radius * cos(alpha)
    z_coord = radius * sin(alpha)
    x = x_start + x_coord
    z = z_start - z_coord

    camera_x = 0
    camera_z = -25

    # x gaat links en rechts en z verder de diepte in en terug -25?
    camera = Camera('location', [camera_x, 8, camera_z], 'look_at', [0, 0, 0])

    return Scene(
        camera,
        objects=[
            cylinder, sphere, models.default_light, models.checkered_ground
        ] + shapes,
        included=['colors.inc'])
Пример #12
0
def frame(step):
    """ Returns the scene at step number (1 step per frame) """
    curr_time = step / eval(SETTINGS.NumberFrames) * eval(SETTINGS.FrameTime)
    logger.info(" @Time: %.3fs, Step: %d", curr_time, step)

    nframes = eval(SETTINGS.NumberFrames)
    n_frames_loop = nframes / 5  # 16 frames per wave

    stylebox = Texture(Pigment('color', [0.80, 0.00, 1.00], 'filter', 0.7),
                       Finish('phong', 0.6, 'reflection', 0.4))

    x_start = -10
    x_end = 10
    x_distance = x_end - x_start
    distance_per_frame = x_distance / nframes

    y_start = 0
    y_end = 4
    y_distance = y_end - y_start
    y_distance_per_frame = y_distance / n_frames_loop
    iteratie = step // n_frames_loop

    x_coord = x_start + step * distance_per_frame
    correctie = iteratie * n_frames_loop
    print(iteratie)
    step = step - correctie
    if step <= (n_frames_loop / 2):
        y_coord = y_start + step * y_distance_per_frame
    else:
        y_coord = y_end - step * y_distance_per_frame

    box = Box([x_coord, y_coord, 0], [x_coord + 2, y_coord + 2, 2], stylebox)

    return Scene(models.default_camera,
                 objects=[box, models.default_ground, models.default_light])
Пример #13
0
def frame(step):
    """ Returns the scene at step number (1 step per frame) """
    # Show some information about how far we are with rendering
    curr_time = step / eval(SETTINGS.NumberFrames) * eval(SETTINGS.FrameTime)
    logger.info(" @Time: %.3fs, Step: %d", curr_time, step)

    # Getting the total number of frames, see the configuration file
    nframes = eval(SETTINGS.NumberFrames)

    style = Texture(Pigment('color', [0.80, 0.00, 1.00], 'filter', 0.7),
                    Finish('phong', 0.6, 'reflection', 0.4))

    cylinder = Cylinder([-6, -1, 4], [-6, 7, 4], 3, style)
    sphere = Sphere([6, 2, -2], 3, style)
    leg = legend([-15, 0, 0], 5)
    radius = 25
    z_start = 0
    x_start = 0
    #werkt allbei
    # alpha = (-pi/2) + (step * 2 * pi / nframes)
    alpha = pi / (nframes / 2) * step + 1

    x_coord = radius * cos(alpha)
    z_coord = radius * sin(alpha)
    x = x_start + x_coord
    z = z_start - z_coord
    return Scene(
        Camera('location', [x, 8, z], 'look_at', [0, 0, 0]),
        objects=[
            models.checkered_ground, models.default_light, cylinder, sphere
        ] + leg)
Пример #14
0
def legend(start_position, axis_length):
    """ Legend function for calling importable legend"""

    # Reduce the AXIS_LENGTH by the length of the Cone (1) so that
    # the total length is exactly the AXIS_LENGTH
    axis_length -= 1

    # Initialize the Cylinder END-position to a COPY of the start position
    cylinder_coords_end = {
        'x': list(start_position),
        'y': list(start_position),
        'z': list(start_position)
    }

    # Add the AXIS_LENGTHs to the corresponding coordinate
    cylinder_coords_end['x'][0] += axis_length
    cylinder_coords_end['y'][1] += axis_length
    cylinder_coords_end['z'][2] += axis_length

    # creation of the Cylinders

    style = Texture(Pigment('color', [0.80, 0.00, 1.00], 'filter', 0.7),
                    Finish('phong', 0.6, 'reflection', 0.4))
    linex = Cylinder(start_position, cylinder_coords_end['x'], 0.1, style)
    liney = Cylinder(start_position, cylinder_coords_end['y'], 0.1, style)
    linez = Cylinder(start_position, cylinder_coords_end['z'], 0.1, style)

    cylinders = {'x': linex, 'y': liney, 'z': linez}

    # Cone START is the same as the Cylinder END, so we COPY these lists
    cones_coords_start = {
        'x': list(cylinder_coords_end['x']),
        'y': list(cylinder_coords_end['y']),
        'z': list(cylinder_coords_end['z'])
    }

    # Copy the START as END coordinate
    cones_coords_end = {
        'x': list(cones_coords_start['x']),
        'y': list(cones_coords_start['y']),
        'z': list(cones_coords_start['z'])
    }

    # Extend the tip of the cones with length 1
    cones_coords_end['x'][0] += 1
    cones_coords_end['y'][1] += 1
    cones_coords_end['z'][2] += 1

    # Creation of the Cones

    conex = Cone(cones_coords_start['x'], 0.5, cones_coords_end['x'], 0, style)
    coney = Cone(cones_coords_start['y'], 0.5, cones_coords_end['y'], 0, style)
    conez = Cone(cones_coords_start['z'], 0.5, cones_coords_end['z'], 0, style)

    cones = {'x': conex, 'y': coney, 'z': conez}

    # Add ALL objects to a LIST and return
    legend_objects = list(cylinders.values()) + list(cones.values())

    return legend_objects
Пример #15
0
def frame(step):
    """ Returns the scene at step number (1 step per frame) """

    curr_time = step / eval(SETTINGS.NumberFrames) * eval(SETTINGS.FrameTime)
    logger.info(" @Time: %.3fs, Step: %d", curr_time, step)

    nframes = eval(SETTINGS.NumberFrames)

    style = Texture(Pigment('color', [0.80, 0.00, 1.00], 'filter', 0.7),
                    Finish('phong', 0.6, 'reflection', 0.4))

    cylinder = Cylinder([-6, -1, 4], [-6, 7, 4], 3, style)
    sphere = Sphere([6, 2, -2], 3, style)
    leg = legend([-15, 0, 0], 5)
    radius = 25
    z_start = 0
    x_start = 0

    alpha = (-pi / 2) + (step * 2 * pi / nframes)
    # For each step, de difference in the x and z positions is equal to the radius time the sin and cos of alpha.
    x_coord = radius * cos(alpha)
    z_coord = radius * sin(alpha)
    # Adding or subtracting the difference of the position for each step from the original camera position.
    x = x_start + x_coord
    z = z_start - z_coord
    return Scene(
        Camera('location', [x, 8, z], 'look_at', [0, 0, 0]),
        objects=[
            models.checkered_ground, models.default_light, cylinder, sphere
        ] + leg)
Пример #16
0
def make_tyrine(loc, size):
    """
    Creates the tyrine molecules
    """
    text_model = Texture(Pigment('color', [1, 1, 0], ), Finish('reflection', 0))
    cyl_model = Texture(Pigment('color', [0, 1, 0.5], ), Finish('reflection', 0))

    tyr = []
    y_always = [13, 13, 10, 10]
    x_text = [-3, 5, -3, 5]
    x_end = [-5, 5, -5, 5]
    x = loc[0]
    y = loc[1]
    z = loc[2] + 7
    for _ in range(4):
        tyr.append(Cylinder([x, y-size * y_always[_], z], [x-size*x_end[_], y-size*y_always[_], z], size, cyl_model))
        text = Text('ttf', '"timrom.ttf"', '"{}"'.format(str('Tyr')), 2, [0, 0, 0], text_model, 'scale', 5, 'translate', [x-size*x_text[_], y-size*y_always[_], z - 7])
        tyr.append(text)
    return tyr
Пример #17
0
    def save_frame_image(self, path):
        meshes = [Background("color", [self.bk_r, self.bk_g, self.bk_b])]
        tex = Texture(Pigment('color', [self.cc_r, self.cc_g, self.cc_b]),
                      Finish('specular', self.specular))
        texo = Texture(Pigment('color', [self.cco_r, self.cco_g, self.cco_b]),
                       Finish('specular', self.specularo))
        for i in xrange(-1, self.expert.nr_obstacles_c()):
            vss, nss, iss = self.save_frame_mesh(i)
            meshes += [ClothMesh(vss, iss, nss, tex if i == -1 else texo)]

        #render
        scene = Scene(Camera('location', [self.cx, self.cy, self.cz], 'sky',
                             [self.ux, self.uy, self.uz], 'look_at',
                             [self.fx, self.fy, self.fz], 'right', [1, 0, 0],
                             'up', [0, -1, 0], 'angle', self.fovy),
                      objects=self.lights + meshes)
        scene.render(path,
                     width=self.w,
                     height=self.h,
                     antialiasing=self.aa if hasattr(self, "aa") else 0.0)
Пример #18
0
def rdmb_povray_save(out_file,
                     vs,
                     ucs, vcs,
                     width=800, height=600,
                     rotx=0, roty=0, rotz=0,
                     angle=14):
    """Render and save RD results using Pov-Ray

    Render and save RD results using Pov-Ray

    Args:
        out_file: output file
        vs: vertices
        ucs, vcs: u/v conc.
        width, height: width and height of output image
        rotx, roty, rotz: rotation angle
        angle: camera angle

    """

    ucmax = 6.0
    ucs = ucs / ucmax
    ucs[ucs > 1.0] = 1.0
    # ucs = ucs / np.max(ucs)

    rot1 = [rotx, 0, 0]
    rot2 = [0, roty, 0]
    rot3 = [0, 0, rotz]

    camera = Camera('location', [0, 0, -25],
                    'look_at', [0, 0, 0],
                    'angle', angle,
                    'right x*image_width/image_height')

    light = LightSource([-3, 2, -6], 'color', [1.0, 1.0, 1.0], 'parallel')
    light2 = LightSource([2, -2, -6], 'color', [0.6, 0.6, 0.6], 'parallel')
    background = Background('color', [1, 1, 1, 1])

    spheres = [Sphere(v, 0.02,
                      Finish('ambient', 0.2, 'diffuse', 0.8, 'phong', 1.0),
                      Texture(Pigment('color',
                                      [0.3+uc*0.7, 0.2+uc*0.8, 0.2+uc*0.8])),
                      'rotate', rot1,
                      'rotate', rot2,
                      'rotate', rot3) for v, uc in zip(vs, ucs)]

    objects = [light, light2, background] + spheres

    scene = Scene(camera, objects=objects)
    scene.render(out_file, width=width, height=height,
                 output_alpha=True, antialiasing=0.001,
                 tempfile=out_file+"__temp__.pov")
def sphere_circle():
    """ Creates a circle made up of 20 small spheres.
        A list of Sphere objects is returnded ready for rendering. """
    spheres = 20  # number of spheres to create
    ring = []
    ring_node_size = 0.6
    smodel = Texture(Pigment('color', [1, 0, 0], 'filter', 0.5),
                     Finish('phong', 0.8, 'reflection', 0.5))
    for i in range(spheres):
        ring.append(Sphere([0, 0, 0], ring_node_size, smodel,
                           'translate', [RADIUS, 0, 0],
                           'rotate', [0, 360/spheres * i, 0]))
    return ring
Пример #20
0
def bind_IRS(frame, size):
    """
    Animating the process of IRS binding to the phosfor
    """

    IRS_model = Texture(Pigment('color', [1, 0, 1], ), Finish('reflection', 0))
    text_model = Texture(Pigment('color', [1, 1, 0], ), Finish('reflection', 0))

    IRS = []
    s = size

    # frame 570 -> 630
    if frame < 630:
        x = (frame - 570) * ((7*s-30*s) / 60) + 30*s
        y = -12*s
    else:
        x = 7*s
        y = -12*s

    IRS.append(Sphere([x, y, 0], s * 2, IRS_model))
    IRS.append(Text('ttf', '"timrom.ttf"', '"{}"'.format(str('IRS')), 0.5, [0, 0, 0], text_model, 'scale', 5, 'translate', [x - s, y, -2*s]))
    return IRS
def frame(step):
    """ Creates the objects and places this in a scene """
    # Creates the lines in each directions
    x_cylinder = Cylinder([-15, 0, 0], [-10, 0, 0], 0.1, Texture(Pigment('color', [1, 0, 0]), Finish('reflection', 1)))
    y_cylinder = Cylinder([-15, 0, 0], [-15, 5, 0], 0.1, Texture(Pigment('color', [0, 0, 1]), Finish('reflection', 1)))
    z_cylinder = Cylinder([-15, 0, 0], [-15, 0, 5], 0.1, Texture(Pigment('color', [0, 1, 0]), Finish('reflection', 1)))
    # Creates the arrows of each directions
    x_cone = Cone([-10, 0, 0], 0.3, [-9, 0, 0], 0, Texture(Pigment('color', [1, 0, 0]), Finish('reflection', 1)))
    y_cone = Cone([-15, 5, 0], 0.3, [-15, 6, 0], 0, Texture(Pigment('color', [0, 0, 1]), Finish('reflection', 1)))
    z_cone = Cone([-15, 0, 5], 0.3, [-15, 0, 6], 0, Texture(Pigment('color', [0, 1, 0]), Finish('reflection', 1)))
    # Return the Scene object for rendering
    return Scene(models.default_camera,
                 objects=[LightSource([2, 8, -20], 2), x_cylinder, y_cylinder, z_cylinder, x_cone, y_cone, z_cone])
Пример #22
0
def render_povray(vs, rotx=0, roty=0, rotz=0,
                  width=400, height=400, angle=14, antialiasing=0.001):
    """Render vertices using Pov-Ray (Vapory)

    Render vertices using Pov-Ray (Vapory)

    Args:
        vs: vertices
        rotx, roty, rotz: rotation angle
        width, height:
        angle: camera angle

    Returns:
        rendered_scene:

    """

    rot1 = [rotx, 0, 0]
    rot2 = [0, roty, 0]
    rot3 = [0, 0, rotz]

    camera = Camera('location', [0, 0, -25],
                    'look_at', [0, 0, 0],
                    'angle', angle,
                    'right x*image_width/image_height')

    light = LightSource([-3, 2, -6], 'color', [1.0, 1.0, 1.0], 'parallel')
    light2 = LightSource([2, -2, -6], 'color', [0.6, 0.6, 0.6], 'parallel')
    background = Background('color', [1, 1, 1])

    spheres = [Sphere(v, 0.05,
                      Finish('ambient', 0.2, 'diffuse', 0.8, 'phong', 1.0),
                      Texture(Pigment('color', [1.0, 1.0, 1.0])),
                      'rotate', rot1,
                      'rotate', rot2,
                      'rotate', rot3) for v in vs]

    objects = [light, light2, background] + spheres

    scene = Scene(camera, objects=objects)

    return scene.render('ipython',
                        width=width, height=height,
                        antialiasing=antialiasing)
Пример #23
0
    def render_frame(self, step, outn):

        particles = []
        for i in range(self.sm.NUM_PARTICLES):
            clr = speed2color(speed=self.speeds[step][i],
                              speed_limit=self.maxspeed,
                              alpha=False)
            p = Sphere(
                [
                    self.r_vecs[step][i][1], self.r_vecs[step][i][2],
                    self.r_vecs[step][i][0]
                ],
                self.sm.RADIUS_PARTICLE,
                Texture(Pigment("color", clr)),
            )
            particles.append(p)

        self.scene = Scene(self.camera, objects=self.objects + particles)

        self.scene.render(f"{self.sm.png_path}/img{outn:06}.png",
                          width=600,
                          height=400)
def frame(step):
    lichtje = LightSource([2, 8, -5], 5.0)
    default_camera = Camera('location', [-5, 8, -20], 'look_at', [-5, 0, -5])
    style = Texture(Pigment('color', [0.80, 0.00, 1.00], 'filter', 0.7),
                       Finish('phong', 0.6, 'reflection', 0.4))

    linex = Cylinder([-15, 0, 0], [-10, 0, 0.5],0.1, style)
    liney = Cylinder([-15, 0, 0], [-15, 5, 0.2],0.1, style)
    linez = Cylinder([-15, 0, 0], [-15, 0.2, 5],0.1, style)


    conex = Cone([-10, 0, 0.5], 0.5,
                [-9, 0, 0.5], 0,
                style)
    coney = Cone([-15, 5, 0], 0.5,
                 [-15, 6, 0], 0,
                 style)
    conez = Cone([-15, 0, 5], 0.5,
                 [-15, 0, 6], 0,
                 style)

    # Return the Scene object for rendering
    return Scene(default_camera,
                 objects=[lichtje,linex,liney,linez,conex,coney,conez])
Пример #25
0
def frame(step):
    """ Returns the scene at step number (1 step per frame) """
    sphere_model = Texture(Pigment(
        'color',
        [250, 0, 0],
    ), Finish('reflection', 0.5))

    # Show some information about how far we are with rendering
    curr_time = step / eval(SETTINGS.NumberFrames) * eval(SETTINGS.FrameTime)
    logger.info(" @Time: %.3fs, Step: %d", curr_time, step)

    # Getting the total number of frames, see the configuration file
    nframes = eval(SETTINGS.NumberFrames)

    # Start- and end-points
    x_start = -5
    x_end = 5
    distance = x_end - x_start

    # Calculate distance to move at each step
    distance_per_frame = (distance / nframes) * 2

    # Calculate new x-coordinate
    if step < (nframes / 2):
        # Move from left to right (starting at x = -10)
        x_coord = x_start + step * distance_per_frame
    else:
        # Move from right to left (starting at x = 10)
        x_coord = x_end - (step - (nframes / 2)) * distance_per_frame

    y_coord = 2 * math.sin((2 * math.pi / 2) * (x_coord - 1)) + 0.5
    # Create sphere at calculated x-coordinate using default model
    sphere = Sphere([x_coord, y_coord, 0], 1, sphere_model)

    # Return the Scene object containing all objects for rendering
    return Scene(models.default_camera, objects=[sphere, models.default_light])
def frame(step):
    """ """
    # Feedback to user in terminal about render status
    curr_time = step / eval(SETTINGS.NumberFrames) * eval(SETTINGS.FrameTime)
    logger.info(" @Time: %.3fs, Step: %d", curr_time, step)

    # Calculates the total frames
    n_frames = eval(SETTINGS.NumberFrames)

    full_circle = 2 * pi  # One full circle equals exactly 2 times pi

    # obtain molecules from function
    create_molecules()

    step_in_frame = step
    two_fifth_of_animation = n_frames // 5 * 2
    three_fifth_of_animation = n_frames // 5 * 3

    VESICLE = Sphere([100, 0, 0], 20, Texture(Pigment('color', [0.7, 1, 1], 'filter', 0.6),
                                              Finish('phong', 0.4, 'reflection', 0.2)))

    camera_z = -100
    # Creation of RNA molecule
    if step in range(0, two_fifth_of_animation):
        create_first_part(step_in_frame, two_fifth_of_animation + 1)

    # Sphere covering the RNA molecule
    if step in range(two_fifth_of_animation, three_fifth_of_animation + 1):
        NUCL_1.move_offset([50, 0, 0])
        NUCL_2.move_offset([50, 0, 0])
        NUCL_3.move_offset([50, 0, 0])
        NUCL_4.move_offset([50, 0, 0])
        NUCL_5.move_offset([50, 0, 0])
        NUCL_6.move_offset([50, 0, 0])
        NUCL_7.move_offset([50, 0, 0])

        step_in_frame = step - two_fifth_of_animation
        x_start = 100
        x_end = -50

        distance_x = x_end - x_start
        distance_per_frame_x = (distance_x / three_fifth_of_animation) * 2

        x_coord = x_start + step_in_frame * distance_per_frame_x
        y_coord = 2 * sin(x_coord/5)
        print(y_coord)

        VESICLE = Sphere([x_coord, y_coord, 0], 20, Texture(Pigment('color', [0.7, 1, 1], 'filter', 0.6),
                                                            Finish('phong', 0.4, 'reflection', 0.2)))


    # Vesicle growth
    if step in range(n_frames // 5 * 3, n_frames // 5 * 4 + 1):
        NUCL_1.move_offset([50, 0, 0])
        NUCL_2.move_offset([50, 0, 0])
        NUCL_3.move_offset([50, 0, 0])
        NUCL_4.move_offset([50, 0, 0])
        NUCL_5.move_offset([50, 0, 0])
        NUCL_6.move_offset([50, 0, 0])
        NUCL_7.move_offset([50, 0, 0])
        VESICLE = Sphere([0, 0, 0], 20, Texture(Pigment('color', [0.7, 1, 1], 'filter', 0.6),
                                                            Finish('phong', 0.4, 'reflection', 0.2)))
        # camere movement
        if step in range(n_frames // 5 * 3, n_frames // 5 * 4 // 2):
            camera_z_start = -100
            camera_z_end = -150
            distance_camera_z = camera_z_end - camera_z_start
            z_camera_coord = step_in_frame * distance_per_frame - camera_z_start
    # # Sphere division
    # if step in range(n_frames // 5 * 4, n_frames):

    # Return the Scene object for rendering
    return Scene(Camera('location', [0, 0, camera_z], 'look_at', [0, 0, 0]),
                 objects=[models.default_light, VESICLE] + NUCL_1.povray_molecule + NUCL_2.povray_molecule +
                 NUCL_3.povray_molecule + NUCL_4.povray_molecule + NUCL_5.povray_molecule +
                         NUCL_6.povray_molecule + NUCL_7.povray_molecule)
Пример #27
0
def legend(start_position, axis_length):
    """
    Returns the objects of a legend
    :param start_position: the position where the legend is rendered
    :param axis_length: the length of each line+arrow in the x, y and z direction
    :return legend_objects: the objects of a legend
    """

    # Reduce the AXIS_LENGTH by the length of the Cone (1) so that
    # the total length is exactly the AXIS_LENGTH
    axis_length -= 1

    # Initialize the Cylinder END-position to a COPY of the start position
    cylinder_coords_end = {
        'x': list(start_position),
        'y': list(start_position),
        'z': list(start_position)
    }

    # Add the AXIS_LENGTHs to the corresponding coordinate
    cylinder_coords_end['x'][0] += axis_length
    cylinder_coords_end['y'][1] += axis_length
    cylinder_coords_end['z'][2] += axis_length
    ''' CREATE THE CYLINDERS'''
    cylinders = {
        'x':
        Cylinder(start_position, cylinder_coords_end['x'], 0.1,
                 Texture(Pigment('color', [1, 0, 0]), Finish('reflection',
                                                             1))),
        'y':
        Cylinder(start_position, cylinder_coords_end['y'], 0.1,
                 Texture(Pigment('color', [0, 0, 1]), Finish('reflection',
                                                             1))),
        'z':
        Cylinder(start_position, cylinder_coords_end['z'], 0.1,
                 Texture(Pigment('color', [0, 1, 0]), Finish('reflection', 1)))
    }

    # Cone START is the same as the Cylinder END, so we COPY these lists
    cones_coords_start = {
        'x': list(cylinder_coords_end['x']),
        'y': list(cylinder_coords_end['y']),
        'z': list(cylinder_coords_end['z'])
    }

    # Copy the START as END coordinate
    cones_coords_end = {
        'x': list(cones_coords_start['x']),
        'y': list(cones_coords_start['y']),
        'z': list(cones_coords_start['z'])
    }

    # Extend the tip of the cones with length 1
    cones_coords_end['x'][0] += 1
    cones_coords_end['y'][1] += 1
    cones_coords_end['z'][2] += 1
    ''' CREATE THE CONES '''
    cones = {
        'x':
        Cone(cones_coords_start['x'], 0.3, cones_coords_end['x'], 0,
             Texture(Pigment('color', [1, 0, 0]), Finish('reflection', 1))),
        'y':
        Cone(cones_coords_start['y'], 0.3, cones_coords_end['y'], 0,
             Texture(Pigment('color', [0, 0, 1]), Finish('reflection', 1))),
        'z':
        Cone(cones_coords_start['z'], 0.3, cones_coords_end['z'], 0,
             Texture(Pigment('color', [0, 1, 0]), Finish('reflection', 1))),
    }

    # Add ALL objects to a LIST and return
    legend_objects = list(cylinders.values()) + list(cones.values())
    return legend_objects
Пример #28
0
    def _render_structure(self, change=None):
        """Render the structure with POVRAY."""

        if not isinstance(self.structure, Atoms):
            return

        self.render_btn.disabled = True
        omat = np.array(self._viewer._camera_orientation).reshape(
            4, 4).transpose()

        zfactor = norm(omat[0, 0:3])
        omat[0:3, 0:3] = omat[0:3, 0:3] / zfactor

        bb = deepcopy(self.structure)
        bb.pbc = (False, False, False)

        for i in bb:
            ixyz = omat[0:3, 0:3].dot(np.array([i.x, i.y, i.z]) + omat[0:3, 3])
            i.x, i.y, i.z = -ixyz[0], ixyz[1], ixyz[2]

        vertices = []

        cell = bb.get_cell()
        vertices.append(np.array([0, 0, 0]))
        vertices.extend(cell)
        vertices.extend([
            cell[0] + cell[1],
            cell[0] + cell[2],
            cell[1] + cell[2],
            cell[0] + cell[1] + cell[2],
        ])

        for n, i in enumerate(vertices):
            ixyz = omat[0:3, 0:3].dot(i + omat[0:3, 3])
            vertices[n] = np.array([-ixyz[0], ixyz[1], ixyz[2]])

        bonds = []

        cutOff = neighborlist.natural_cutoffs(
            bb)  # Takes the cutoffs from the ASE database
        neighborList = neighborlist.NeighborList(cutOff,
                                                 self_interaction=False,
                                                 bothways=False)
        neighborList.update(bb)
        matrix = neighborList.get_connectivity_matrix()

        for k in matrix.keys():
            i = bb[k[0]]
            j = bb[k[1]]

            v1 = np.array([i.x, i.y, i.z])
            v2 = np.array([j.x, j.y, j.z])
            midi = v1 + (v2 - v1) * Radius[i.symbol] / (Radius[i.symbol] +
                                                        Radius[j.symbol])
            bond = Cylinder(
                v1,
                midi,
                0.2,
                Pigment("color", np.array(Colors[i.symbol])),
                Finish("phong", 0.8, "reflection", 0.05),
            )
            bonds.append(bond)
            bond = Cylinder(
                v2,
                midi,
                0.2,
                Pigment("color", np.array(Colors[j.symbol])),
                Finish("phong", 0.8, "reflection", 0.05),
            )
            bonds.append(bond)

        edges = []
        for x, i in enumerate(vertices):
            for j in vertices[x + 1:]:
                if (norm(np.cross(i - j, vertices[1] - vertices[0])) < 0.001
                        or norm(np.cross(i - j,
                                         vertices[2] - vertices[0])) < 0.001
                        or norm(np.cross(i - j,
                                         vertices[3] - vertices[0])) < 0.001):
                    edge = Cylinder(
                        i,
                        j,
                        0.06,
                        Texture(
                            Pigment("color",
                                    [212 / 255.0, 175 / 255.0, 55 / 255.0])),
                        Finish("phong", 0.9, "reflection", 0.01),
                    )
                    edges.append(edge)

        camera = Camera(
            "perspective",
            "location",
            [0, 0, -zfactor / 1.5],
            "look_at",
            [0.0, 0.0, 0.0],
        )
        light = LightSource([0, 0, -100.0], "color", [1.5, 1.5, 1.5])

        spheres = [
            Sphere(
                [i.x, i.y, i.z],
                Radius[i.symbol],
                Texture(Pigment("color", np.array(Colors[i.symbol]))),
                Finish("phong", 0.9, "reflection", 0.05),
            ) for i in bb
        ]

        objects = (
            [light] + spheres + edges + bonds +
            [Background("color", np.array(to_rgb(self._viewer.background)))])

        scene = Scene(camera, objects=objects)
        fname = bb.get_chemical_formula() + ".png"
        scene.render(
            fname,
            width=2560,
            height=1440,
            antialiasing=0.000,
            quality=11,
            remove_temp=False,
        )
        with open(fname, "rb") as raw:
            payload = base64.b64encode(raw.read()).decode()
        self._download(payload=payload, filename=fname)
        self.render_btn.disabled = False
Пример #29
0
def single_virus_gen():
    """
    single_virus_gen()
    Generates a virus object.
    :return virus object
    """
    object_texture = Texture(Pigment('color', [1, 1, 1], 'transmit', 0),
                             Finish('phong', 0.5, 'reflection', 0.9))

    helix_test = 'f_helix1(x, y, z, 1, 1 * 4 * pi, 0.07, 0.8, 1, 0.3, 0)'
    iso_spine = Isosurface(Function(helix_test), ContainedBy(Box(-5, 5)),
                           'translate', [0, 0, 0],
                           models.default_sphere_model)  # spine helix

    cyl = Cylinder([0, -5, 0], [0, 5, 0], 0.5,
                   object_texture)  # spine cylinder

    icosahedral = 'abs(x)+abs(y)+abs(z)-4.9'
    ico_head = Isosurface(Function(icosahedral), ContainedBy(Box(-3.5, 3.5)),
                          'max_gradient', 5, 'translate', [0, 7, 0],
                          object_texture)  # head object

    ring = Torus(1.2, 0.3, 'translate', [0, -5, 0],
                 object_texture)  # hip ring spine

    # berelem radian, bijv: 1.05 * math.cos(radian * 3) 3 = step, 1.05 = straal
    radian = (360 / 6) * (math.pi / 180)

    x_tail_list = []
    for coordinate_offset in range(1, 7, 2):
        coordinate_offset += 0.05
        x_tail_list.append(coordinate_offset)  # [1.05, 3.05, 5.05]

    x_axis_tail_list = []
    z_axis_tail_list = []
    for tail_nr in range(1, 7):
        tail_steps = tail_nr
        for coordinate in x_tail_list:
            x_axis_tail_list.append(coordinate * math.cos(radian * tail_steps))
            z_axis_tail_list.append(coordinate * math.sin(radian * tail_steps))

    tails = []
    for tail_coordinate in range(0, len(x_axis_tail_list), 3):
        tails.append(
            SphereSweep('linear_spline', 3, [
                x_axis_tail_list[tail_coordinate], -5.00,
                z_axis_tail_list[tail_coordinate]
            ], 0.1, [
                x_axis_tail_list[tail_coordinate + 1], -1.00,
                z_axis_tail_list[tail_coordinate + 1]
            ], 0.15, [
                x_axis_tail_list[tail_coordinate + 2], -9.00,
                z_axis_tail_list[tail_coordinate + 2]
            ], 0.1, object_texture))
        # 6 tails

    virus_object = Merge(iso_spine, ico_head, ring, cyl)

    for tail in tails:
        virus_object.args.append(tail)

    return virus_object
Пример #30
0
def sph(vs, ucs, A, C, x, y, z, rotx=0, roty=0, rotz=0, mode="C"):
    """Colored spheres for rendering RD results

    Colored spheres for rendering RD results

    Args:
        vs: vertices
        ucs: u conc.
        A, C: RD parameters
        x, y, z: translation
        rotx, roty, rotz: rotation angle
        mode: color mode for parameters

    """
    sph = []

    if mode == "A":
        nA = (A-0.07)/(0.12-0.07)
        nC = (C+0.1)/(0.31+0.1)
    elif mode == "C":
        nA = (A-0.07)/(0.12-0.07)
        nC = C/0.307
    elif mode == "AC":
        nA = (A-0.07)/(0.12-0.07)
        nC = (C+0.1)/(0.31+0.1)
    else:
        nA = (A-0.07)/(0.12-0.07)
        nC = C/0.307

    if (type(nA) is np.float64):
        nA = np.full(len(vs), nA)
    if (type(nC) is np.float64):
        nC = np.full(len(vs), nC)

    for v, uc, a, c in zip(vs, ucs, nA, nC):
        if mode == "A":
            H0 = a
            L0 = 1/(1+np.exp((-2.8*((a-0.52)*2.4))))
            # R0, G0, B0 = colorsys.hls_to_rgb(0.02+H0*0.35, 0.5-L0*0.4, 1.0)
            R0, G0, B0 = colorsys.hls_to_rgb(1.0-H0*0.40, 0.5-L0*0.4, 1.0)

        elif mode == "C":
            H0 = c
            L0 = 1/(1+np.exp((-2.8*((c-0.52)*2.4))))
            R0, G0, B0 = colorsys.hls_to_rgb(0.02+H0*0.35, 0.5-L0*0.4, 1.0)

        elif mode == "AC":
            R0 = a*1.0
            # G0 = max(0.8-(max(a+c, 0)), 0)
            G0 = 0.0
            B0 = c*1.0

        else:
            R0 = 0.3
            G0 = 0.2
            B0 = 0.2

        R1 = 1.0 - R0
        G1 = 1.0 - G0
        B1 = 1.0 - B0

        sph.append(Sphere(v, 0.022,
                          Texture(Pigment('color',
                                          [R0+uc*R1, G0+uc*G1, B0+uc*B1]),
                                  Finish('phong', 0.7,
                                         'specular', 0.2,
                                         'diffuse', 0.9,
                                         'ambient', 0.1)),
                          'rotate', [rotx, 0, 0],
                          'rotate', [0, roty, 0],
                          'rotate', [0, 0, rotz],
                          'translate', [x, y, z],
                          'no_shadow'))

    return sph