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() # Creation of RNA molecule if step in range(0, n_frames // 5 * 2): GUANINE.move_to([10, 0, 0]) ADENINE.move_to([-10, 0, 0]) CYTOSINE.move_to([0, 10, 0]) URACIL.move_to([0, -10, 0]) # # Sphere covering the RNA molecule # if step in range(n_frames // 5 * 2, n_frames // 5 * 3): # # # RNA division # if step in range(n_frames // 5 * 3, n_frames // 5 * 4): # # # Sphere division # if step in range(n_frames // 5 * 4, n_frames): # Return the Scene object for rendering return Scene(models.floor_camera, objects=[models.default_light] + GUANINE.povray_molecule)
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])
def frame(step): """ Creates a frame of a given frame (step) number. """ # 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) # Calculates rotation positions angle_per_frame = math.pi * 2 / nframes # Calculates how much the angle needs to move per frame angle = angle_per_frame * step # Calculates the angle of the frame # Gets locations x = math.cos(angle) * 20 z = math.sin(angle) * 20 # Create objects sphere = Sphere([6, 2, -2], 3, models.default_sphere_model) cylinder = Cylinder([-6, -1, 4], [-6, 7, 4], 3, models.default_sphere_model) legend_1 = legend([-15, 0, 0], 5) camera = Camera('location', [x, 8, z], 'look_at', [0, 0, 0]) # Return the Scene object containing all objects for rendering return Scene(camera, objects=[sphere, models.default_light, models.checkered_ground, cylinder] + legend_1)
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)
def main(args): """ Main function of this program """ make_objects() logger.info(" Total time: %d (frames: %d)", SETTINGS.Duration, eval(SETTINGS.NumberFrames)) pypovray.render_scene_to_mp4(frame) return 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) # Start- and end-points x_start = -10 x_end = 10 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 # Create sphere at calculated x-coordinate using default model sphere = Sphere([x_coord, 0, 0], 2, models.default_sphere_model) # Return the Scene object containing all objects for rendering return Scene(models.default_camera, objects=[sphere, models.default_ground, models.default_light])
def main(args): """ Main function performing the rendering """ logger.info(" Total time: %d (frames: %d)", SETTINGS.Duration, eval(SETTINGS.NumberFrames)) pypovray.render_scene_to_mp4(frame) return 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)
def frame(step): """ Makes an image/frame """ time_point = (step / TOTAL_FRAMES) * SETTINGS.Duration logger.info(" @Time: %.4fs, Step: %d", time_point, step) # Declaration of the end times of the scenes global TP_END TP_END = [4, 8, 11, 15, 18, 26, 32, 38, 44, 50, 58, 64] # scene 0 1 2 3 4 5 6 7 8 9 10, 11 # Globals that change per frame global TP_START, TP_DUR, TWITCH1, TWITCH2 TP_START, TP_DUR = get_time_point_data(TP_END) TWITCH1, TWITCH2 = make_random_int() if time_point < TP_END[0]: scene = s0_intro_text() elif time_point < TP_END[1]: scene = s1_cell_overview() elif time_point < TP_END[2]: scene = s2_cell_zoom(step) elif time_point < TP_END[3]: scene = s3_in_cell() elif time_point < TP_END[4]: scene = s4_zoom_to_mrna(step) elif time_point < TP_END[11]: scene = scenes_mrna(step, time_point) else: text = Text('ttf', '"timrom.ttf"', '"Uh-oh, this ain\'t right"', 0, 0, 'translate', [-4, 0, 0], 'scale', [2, 2, 0], models.text_model) scene = Scene(models.default_camera, objects=[models.default_light, text]) return scene
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'])
def main(): """ Main function performing the rendering Prints user information to sceen and grabs settings from settings file. Starts main render and creates .mp4 file """ logger.info(" Total time: %d (frames: %d)", SETTINGS.Duration, eval(SETTINGS.NumberFrames)) pypovray.SETTINGS = load_config('default.ini') pypovray.render_scene_to_mp4(frame) return 0
def frame(step): """ Returns a scene at a step number in which a sphere is visualised. """ # 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) # Calculate the frames per wave repeats = 5 n_frames_wave = n_frames / repeats # amount of frames per wave # Calculates starting coordinates of the sphere increase = 4 # amount of increase per wave x_start = -10 x_end = x_start + increase y_start = -4 y_end = 4 # Calculates total distance and distance per frame x_distance = x_end - x_start y_distance = y_end - y_start x_distance_per_frame = (x_distance / (n_frames_wave / 2)) y_distance_per_frame = (y_distance / (n_frames_wave / 2)) # Determine in which wave this step is if step // n_frames_wave == 0: wave = 0 else: wave = step // n_frames_wave # Step has to reset for every wave, so subtract frames of previous wave(s) frame_in_wave = step - (wave * n_frames_wave) # If it is in the first part of the wave if frame_in_wave <= (n_frames_wave / 2): x_coord = x_start + ( wave * increase ) + frame_in_wave * x_distance_per_frame # Increases linear y_coord = y_start + frame_in_wave * y_distance_per_frame # Increases linear # Second part of the wave else: x_coord = x_end + (wave * increase ) # Stays constant and increases 4 for every wave y_coord = y_end - ( frame_in_wave - (n_frames_wave / 2)) * y_distance_per_frame # Decreases linear # Makes a sphere at given x- and Y-coordinates with the default style sphere = Sphere([x_coord, y_coord, 0], 0.5, models.default_sphere_model) # Returns the objects of the scene using the default camera settings return Scene(models.default_camera, objects=[sphere, models.default_ground, models.default_light])
def frame(step): """ Renders an ATP molecule centered in the scene """ # 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) # Calculates distance per frame for the to be splitted molecule parts x_start = 0 x_end = 8 x_distance = x_end - x_start x_distance_per_frame = (x_distance / (n_frames / 2)) # Variables used for rotating of molecules full_circle = 2 * pi # One full circle equals exactly 2 times pi rotation_per_frame = full_circle / (n_frames / 2) # creating the nucleotide gtp = pdb.PDBMolecule('{}/pdb/gtp.pdb'.format(SETTINGS.AppLocation), center=True) gtp.rotate([1, 1, 1], [pi * 1.5, pi, pi / 2]) gtp.divide([11, 12, 13, 14, 15, 16, 17, 18], 'phosphate', offset=[ 0, 0, 0 ]) # removes two phosphate groups to create guanine nucleotide guanine = gtp.divide( [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 28, 29, 34, 35], 'base', offset=[4, 0, 0]) # splits into ribose-phosphate and the gaunine base # In the first half of the animation: split the guanine nucleotide into guanine and ribose-phosphate if step in range(0, n_frames // 2): gtp.move_to([-step * x_distance_per_frame, 0, 0]) guanine.move_to([step * x_distance_per_frame, 0, 0]) # In the second half of the animation: rotate both molecules one full circle if step in range(n_frames // 2, n_frames): gtp.rotate([0, 1, 0], rotation_per_frame * (step - (n_frames / 2))) guanine.rotate([1, 0, 0], rotation_per_frame * (step - (n_frames / 2))) gtp.move_to([-n_frames // 2 * x_distance_per_frame, 0, 0]) guanine.move_to([n_frames // 2 * x_distance_per_frame, 0, 0]) # Return the Scene object for rendering return Scene(models.floor_camera, objects=[models.default_light] + gtp.povray_molecule + guanine.povray_molecule)
def frame(step): """ Returns the scene at step number (1 step per frame) """ # Rotate the molecules updating its orientation (a persistent modification) ETHANOL.rotate([1, 1, 0], RAD_PER_SCENE) VIAGRA.rotate([1, 0, 1], RAD_PER_SCENE) BENZENE.rotate([0, 1, 1], RAD_PER_SCENE) # Combine molecule objects (an object.povray_molecule is a list of atoms, they need # to be concatenated to be added to the scene) molecules = ETHANOL.povray_molecule + VIAGRA.povray_molecule + BENZENE.povray_molecule logger.info(' @Step: %s', step) # Return a 'Scene' object containing -all- objects to render, i.e. the camera, # light(s) and in this case, molecules too. return Scene(models.default_camera, objects=[models.default_light, FRONT_LIGHT] + molecules, included=['colors.inc'])
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() new_molecule = pdb(pdb=None, atoms= GUANINE , ADENINE) print(new_molecule) # Creation of RNA molecule step_in_frame = step two_fifth_of_animation = n_frames // 5 * 2
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) # Create molecule atp = pdb.PDBMolecule('{}/pdb/ATP_ideal.pdb'.format(SETTINGS.AppLocation), center=True) atp.move_to([0, 5, 0]) # Creates phospate sliced molecule phosphate = atp.divide([0, 1, 2, 3, 7, 31, 32], 'phosphate') # Creates other objects camera = Camera('location', [25, 5, 10], 'look_at', [0, 5, 0]) light = LightSource([25, 5, 10], 'color', [1, 1, 1]) # Splicing the molecules animation if step <= 20 and step > 5: y = (0 - 4 / 15) * (step - 5) # Moves for 15 frames, -4x in total phosphate.move_offset([0, y, 0]) # Keeping the phospate in it's position after it moved elif step > 5: y = (0 - 4 / 15) * ( 20 - 5) # Moves it like the 20th frame to keep it's position phosphate.move_offset([0, y, 0]) # Rotating the molecules if step >= 30 and step < 70: phosphate.rotate([1, 0, 0], np.pi * 2 / 40 * (step - 30)) # Rotates it for 40 frames, 1 - 2pi atp.rotate([0, 1, 0], np.pi * 2 / 40 * (step - 30)) # Return the Scene object containing all objects for rendering return Scene( camera, objects=[models.checkered_ground, models.default_light, light] + atp.povray_molecule + phosphate.povray_molecule)
def __init__(self, pdb_file, center=True, offset=[0, 0, 0], atoms=False, model=None): """ Parses and renders the molecule given a PDB file """ # If a list of atoms is provided, use these instead of a PDB file # This allows dividing the molecule in segments, see divide() if atoms: self.atoms = atoms else: self._parse_pdb(pdb_file) self.povray_molecule = [] # Molecule name self.molecule = pdb_file self.warnings = set() # If an offset is provided, apply this self.offset = np.array(offset) if np.count_nonzero(self.offset) > 0: self._recenter_molecule() self.center = self._center_of_mass() # Center the molecule based on the 'pseudo' center of mass if center: self.center_molecule() self.center = self._center_of_mass() logger.info( "Created a molecule from '%s' placed at [%s] (centered is %d)", pdb_file, ', '.join([str(coord) for coord in np.around(self.center, 2)]), center) # Required for the labels self.show_name = False self.show_index = False self.camera = None self.model = model self.render_molecule(offset)
def _run_ffmpeg(): """ Builds the ffmpeg command to render an MP4 movie file using the h.x264 codex and yuv420p format """ ff = ffmpy.FFmpeg( # Input is a pattern for all image files ordered by number (padded) inputs={ '': '-framerate {} -pattern_type glob -i {}/{}_*.png'.format( SETTINGS.RenderFPS, SETTINGS.OutputImageDir, SETTINGS.OutputPrefix) }, outputs={ '{}/{}.mp4'.format(SETTINGS.OutputMovieDir, SETTINGS.OutputPrefix): '-c:v libx264 -r {} -crf 2 -pix_fmt yuv420p -loglevel warning'. format(SETTINGS.MovieFPS) }) # Run ffmpeg and create output movie file logger.info('["%s"] - ffmpeg command: "%s"', sys._getframe().f_code.co_name, ff.cmd) ff.run()
def frame(step): """ Returns a scene at a step number while camera is moving """ # 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) # Calculates coordinates for the camera position radius = 25 degrees = pi / (n_frames / 2) * (step + 1) x_coord = radius * sin(degrees) z_coord = radius * cos(degrees) # Returns the objects of the scene using the default camera settings return Scene( Camera('location', [x_coord, 8, z_coord], 'look_at', [0, 0, 0]), objects=[LightSource([2, 8, -20], 2), models.checkered_ground] + SPHERE + CYLINDER + LEGEND)
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) # Getting the total number of frames, see the configuration file nframes = eval(SETTINGS.NumberFrames) x_start = -10 x_end = 10 distance_x = x_end - x_start distance_per_frame_x = (distance_x / nframes) * 2 x_coord = x_start + step * distance_per_frame_x y_coord = sin(x_coord) sphere = (Sphere([x_coord, y_coord, 0], 3, models.default_sphere_model)) return Scene(models.default_camera, objects=[sphere, models.default_ground, models.default_light])
def frame(step): """ Renders an animation in which the molecules are split and rotate one full circle around its axis """ # 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) # Calculates distance per frame for the two molecules x_start = 0 x_end = 8 x_distance = x_end - x_start x_distance_per_frame = (x_distance / (n_frames / 2)) # Variables used for rotating of molecules full_circle = 2 * pi # One full circle equals exactly 2 times pi rotation_per_frame = full_circle / (n_frames / 2) # obtain molecules from function create_molecules() # In the 1st half of animation: split the guanine nucleotide into guanine and ribose-phosphate if step in range(0, n_frames // 2): GTP.move_to([-step * x_distance_per_frame, 0, 0]) GUANINE.move_to([step * x_distance_per_frame, 0, 0]) # In the 2nd half of animation: rotate both molecules one full circle if step in range(n_frames // 2, n_frames): GTP.rotate([0, 1, 0], rotation_per_frame * (step - (n_frames / 2))) GUANINE.rotate([1, 0, 0], rotation_per_frame * (step - (n_frames / 2))) GTP.move_to([-n_frames // 2 * x_distance_per_frame, 0, 0]) GUANINE.move_to([n_frames // 2 * x_distance_per_frame, 0, 0]) # Return the Scene object for rendering return Scene(models.floor_camera, objects=[models.default_light] + GTP.povray_molecule + GUANINE.povray_molecule)
def frame(step): """ Returns the scene at step number (1 step per frame) """ logger.info("@ Step %d", step) # The Ethanol molecule is moved on a trajectory representing a 'figure 8' or the infinity # symbol by calculating the x- and y-coordinates using the lemniscate of Bernoulli. alpha = 9 scale = alpha * math.sqrt(2) radians = step * RAD_PER_SCENE x = scale * math.cos(radians) / \ (math.sin(radians) ** 2 + 1) y = scale * math.cos(radians) * \ math.sin(radians) / \ (math.sin(radians)**2 + 1) # Draws spheres on each of the calculated x,y coordinates TRACER.append(Sphere([x, y, -4], 0.2, models.default_sphere_model)) # Copying the full molecule - only needed for multithreading # This is required for multithreading ethanol = copy.deepcopy(ETHANOL) # Move the molecule to the calculated coordinates ethanol.move_to([x, y, -5]) # Rotate the molecule on x- and y-axes # NOTE: default rotate does NOT work when using a thread-pool, # use the molecule.rotate_by_step method instead ethanol.rotate_by_step([1, 0, 0], RAD_PER_SCENE, step) # Return a 'Scene' object containing -all- objects to render, i.e. the camera, # lights and in this case, a molecule and a list of spheres (TRACER). return Scene(models.default_camera, objects=[models.default_light, FRONT_LIGHT] + ethanol.povray_molecule + TRACER, included=['colors.inc'])
def frame(step): """ Returns the scene at the given step """ # Show some information about how far we are with rendering curr_time = step * eval(SETTINGS.FrameTime) logger.info(" @Time: %.3fs, Step: %d", curr_time, step) ## Rotating sphere, placed in the center sphere_rad = 1.8 sphere = Sphere([0, 0, 0], sphere_rad, Pigment('color', [0.9, 0.05, 0.05], 'filter', 0.7), Interior('ior', 1), Finish('phong', 0.6, 'reflection', 0.4)) # Intersecting cylinder object rod = Cylinder([0, 0, 3], [0, 0, -3], 1.0, 'open', Pigment('color', [1, 0, 0], 'filter', 0.8), Interior('ior', 1), Finish('phong', 0, 'reflection', 0)) # 'Hollow out' the rotating sphere with the intersecting cylinder using the Difference, # move to a spot on the circle (top) and rotate on the x-axis traveller = Difference(sphere, rod, 'translate', [RADIUS, 0, 0], 'rotate', [0, 360/eval(SETTINGS.NumberFrames)*step*2, 0]) return Scene(CAMERA, objects=[GROUND, MAIN_LIGHT, BACK_LIGHT, traveller] + RING)
def frame(step): curr_time = step / eval(SETTINGS.NumberFrames) * eval(SETTINGS.FrameTime) logger.info(" @Time: %.3fs, Step: %d", curr_time, step) n_frames = eval(SETTINGS.NumberFrames) n_frames_loop = n_frames / 5 # amount of frames per loop x_start = -10 x_end = x_start + 4 x_distance = x_end - x_start x_distance_per_frame = (x_distance / (n_frames_loop / 2)) y_start = -4 y_end = 4 y_distance = y_end - y_start y_distance_per_frame = (y_distance / (n_frames_loop / 2)) # determine loop step if step - 1 // n_frames_loop == 0: loop = 0 else: loop = step // n_frames_loop frame_in_loop = step - (loop * n_frames_loop) if frame_in_loop <= (n_frames_loop / 2): x_coord = x_start + (loop * 4) + frame_in_loop * x_distance_per_frame y_coord = y_start + frame_in_loop * y_distance_per_frame else: x_coord = x_end + (loop * 4) y_coord = y_end - (frame_in_loop - (n_frames_loop / 2)) * y_distance_per_frame sphere = Sphere([x_coord, y_coord, 0], 0.5, models.default_sphere_model) return Scene(models.default_camera, objects=[sphere, models.default_ground, 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) # obtain molecules from function create_molecules() # Creation of RNA molecule step_in_frame = step two_fifth_of_animation = n_frames // 5 * 2 if step in range(0, two_fifth_of_animation): create_first_part(step_in_frame, two_fifth_of_animation) # Return the Scene object for rendering return Scene(Camera('location', [0, 0, -50], 'look_at', [0, 0, 0]), objects=[models.default_light] + URACIL_ONE.povray_molecule + ADENINE.povray_molecule + ADENINE_TWO.povray_molecule + GUANINE.povray_molecule + CYTOSINE.povray_molecule)
def frame(step): """ Returns a scene at a step number while camera is moving. """ # 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) # Calculates coordinates for the camera position radius = 25 degrees = pi / (n_frames / 2) * (step + 1) x_coord = radius * sin(degrees) z_coord = radius * cos(degrees) # Makes objects at given coordinates sphere = Sphere([6, 2, -2], 3, models.default_sphere_model) cylinder = Cylinder([-6, -1, 4], [-6, 7, 4], 3, models.default_sphere_model) xyz_legend = legend([-15, 0, 0], 5) # Returns the objects of the scene using the default camera settings return Scene(Camera('location', [x_coord, 8, z_coord], 'look_at', [0, 0, 0]), objects=[LightSource([2, 8, -20], 2), models.checkered_ground, sphere, cylinder] + xyz_legend)
def frame(step): """ Returns the scene at step number (1 step per frame) """ cylinder = Cylinder([-6, -1, 4], [-6, 8, 4], 4, models.default_sphere_model) sphere = Sphere([6, 2, -2], 3, models.default_sphere_model) xyz_legend = legend([-15, 0, 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) distance_per_frame = 50 / nframes z_start = -25 z_end = 25 if step < (nframes / 2): z = z_start + step * distance_per_frame x = math.sqrt(25**2 - z**2) else: z = z_end - step * distance_per_frame x = -1 * math.sqrt(25**2 - z**2) camera = Camera('location', [x, 8, z], 'look_at', [0, 0, 0]) # Return the Scene object containing all objects for rendering return Scene(camera, objects=[ sphere, cylinder, models.checkered_ground, models.default_light ])
def main(args): """ Main function that will run other functions """ logger.info(" Total time: %d (frames: %d)", SETTINGS.Duration, eval(SETTINGS.NumberFrames)) pypovray.render_scene_to_gif(frame) return 0
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)
if time_point < TP_END[0]: scene = s0_intro_text() elif time_point < TP_END[1]: scene = s1_cell_overview() elif time_point < TP_END[2]: scene = s2_cell_zoom(step) elif time_point < TP_END[3]: scene = s3_in_cell() elif time_point < TP_END[4]: scene = s4_zoom_to_mrna(step) elif time_point < TP_END[11]: scene = scenes_mrna(step, time_point) else: text = Text('ttf', '"timrom.ttf"', '"Uh-oh, this ain\'t right"', 0, 0, 'translate', [-4, 0, 0], 'scale', [2, 2, 0], models.text_model) scene = Scene(models.default_camera, objects=[models.default_light, text]) return scene if __name__ == "__main__": logger.info(" Total time: %ds (frames: %d)", SETTINGS.Duration, TOTAL_FRAMES) time_points = [56, 64] render_frames = [int(i * SETTINGS.RenderFPS) for i in time_points] pypovray.render_scene_to_mp4(frame) # pypovray.render_scene_to_mp4(frame, range(render_frames[0], render_frames[1]))