跳转到内容

File:Transmission line animation.gif

页面内容不支持其他语言。
這個文件來自維基共享資源
维基百科,自由的百科全书
    原始文件 (300 × 100像素,文件大小:112 KB,MIME类型:image/gif、​循环、​30帧、​1.8秒)


    摘要

    描述
    English: A lossless transmission line, terminated at an impedance-matched load resistor (box on right). Red color indicates high voltage, and blue indicates low voltage. Black dots represent electrons. (See also File:Transmission_line_animation3.gif for a newer and simpler version.)
    日期
    来源 自己的作品
    作者 Sbyrnes321
    GIF开发
    InfoField
     本GIF 位图使用Python创作。

    许可协议

    我,本作品著作权人,特此采用以下许可协议发表本作品:
    Creative Commons CC-Zero 本作品采用知识共享CC0 1.0 通用公有领域贡献许可协议授权。
    采用本宣告发表本作品的人,已在法律允许的范围内,通过在全世界放弃其对本作品拥有的著作权法规定的所有权利(包括所有相关权利),将本作品贡献至公有领域。您可以复制、修改、传播和表演本作品,将其用于商业目的,无需要求授权。

    Source code

    """
    (C) Steven Byrnes, 2013. This code is released under the MIT license
    http://opensource.org/licenses/MIT
    
    This code runs in Python 2.7 or 3.3. It requires imagemagick to be installed;
    that's how it assembles images into animated GIFs.
    """
    
    from __future__ import division 
    
    import pygame as pg
    from numpy import cos, pi, sin, asarray
    
    import subprocess, os
    directory_now = os.path.dirname(os.path.realpath(__file__))
    
    frames_in_anim = 30
    animation_loop_seconds = 2 #time in seconds for animation to loop one cycle
    
    bgcolor = (255,255,255) #white
    linecolor = (0,0,0) #outline of resistor is black
    ecolor = (0,0,0) #electron color is black
    
    img_height = 100
    img_width = 300
    
    #transmission line wire length and thickness, and y-coordinate of each wire
    tl_length = img_width * 6//7
    tl_thickness = 5
    tl_top_y = img_height*4//9
    tl_bot_y = img_height*5//9 - tl_thickness//2 #second term is to keep it symmetric
    
    wavelength = 0.6 * tl_length
    
    resistor_length = img_height//2
    resistor_width = resistor_length//3
    
    resistor_center = (img_width - resistor_width*3//2, img_height//2)
    
    top_lead_path = [(tl_length, tl_top_y + tl_thickness-1),
                     (tl_length, img_height//9),
                     (resistor_center[0], img_height//9),
                     resistor_center]
    
    bot_lead_path = [(x,img_height-y+1) for (x,y) in top_lead_path]
    
    lead_thickness = 2
    
    def rgb_from_V(V):
        """
        voltage V varies -1 to +1. Return a color as a function of V.
        Color is a 3-tuple red,green,blue, each 0 to 255.
        """
        return (100+100*V, 100 - 100*V, 100-100*V)
    
    def tup_round(tup):
        """
        round each element of a tuple to nearest integer
        """
        return tuple(int(round(x)) for x in tup)
    
    def make_wire_surf(phase_at_left):
        """
        make a pygame surface representing a colored wire. startphase is phase
        at left side of the wire.
        """
        imgarray = [[rgb_from_V(cos(phase_at_left + 2*pi*x/wavelength))
                     for y in range(tl_thickness)] for x in range(tl_length)]
        return pg.surfarray.make_surface(asarray(imgarray))
    
    def make_resistor_surf(phase_at_top):
        """
        make a pygame surface representing the resistor. topphase is phase at top
        """
        imgarray = [[rgb_from_V(cos(phase_at_top) * (1 - 2*y/resistor_length))
                         for y in range(resistor_length)]
                        for x in range(resistor_width)]
        surf = pg.surfarray.make_surface(asarray(imgarray))
        pg.draw.rect(surf,linecolor,surf.get_rect(),1) #1-pixel black outline
        return surf
    
    def e_path(param, phase_top_left):
        """
        as param goes 0 to 1, this returns {'pos': (x, y), 'phase':phi},
        where (x,y) is the coordinates of the corresponding point on the electron
        dot path, and phi is the phase for an electron at that point on the path.
        phase_top_left is phase of the left side of the top wire.
        """
        d = 3 #pixels between electron path and corresponding wires
        path_length = ( 2*(tl_length - d) #transmission lines
                      + 2*(img_height//3) #left vertical leads
                      + 2*(resistor_center[0] - tl_length + 2*d + lead_thickness)
                      + 2*(resistor_length//2 - img_height//9) #right vertical leads
                      + resistor_length) #through resistor
        howfar = param * path_length
        
        #move right across top transmission line
        if howfar < tl_length - d:
            x = howfar
            y = tl_top_y - d
            phase = phase_top_left + 2 * pi * x / wavelength
            return {'pos':(x,y), 'phase':phase}
        howfar -= (tl_length - d)
        
        #move up lead
        if howfar < img_height//3:
            x = tl_length - d
            y = tl_top_y - d - howfar
            phase = phase_top_left + 2 * pi * tl_length / wavelength
            return {'pos':(x,y), 'phase':phase}
        howfar -= img_height//3
        
        #move right to above resistor
        if howfar < (resistor_center[0]- tl_length) + 2*d + lead_thickness:
            x = tl_length - d + howfar
            y = img_height//9 - d
            phase = phase_top_left + 2 * pi * tl_length / wavelength
            return {'pos':(x,y), 'phase':phase}
        howfar -= (resistor_center[0] - tl_length) + 2*d + lead_thickness
        
        #move down to top of resistor
        if howfar < (resistor_length//2 - img_height//9):
            x = resistor_center[0] + d + lead_thickness
            y = img_height//9 - d + howfar
            phase = phase_top_left + 2 * pi * tl_length / wavelength
            return {'pos':(x,y), 'phase':phase}
        howfar -= (resistor_length//2 - img_height//9)
        
        #move down resistor
        if howfar < resistor_length:
            x = resistor_center[0] + resistor_width//2 + d
            y = resistor_center[1] - resistor_length//2 + howfar
            phase = phase_top_left + 2 * pi * tl_length / wavelength
            return {'pos':(x,y), 'phase':phase}
        howfar -= resistor_length
        
        #beyond here use the mirror symmetry
        flipdata = e_path(1-param, phase_top_left)
        flipdata['pos'] = (flipdata['pos'][0], img_height - flipdata['pos'][1] + 2)
        return flipdata
    
    def main():
        #Make and save a drawing for each frame
        filename_list = [os.path.join(directory_now, 'temp' + str(n) + '.png')
                             for n in range(frames_in_anim)]
    
        for frame in range(frames_in_anim):
            phase_top_left = -2 * pi * frame / frames_in_anim
            phase_top_right = phase_top_left + 2 * pi * tl_length / wavelength
            
            #initialize surface
            surf = pg.Surface((img_width,img_height))
            surf.fill(bgcolor);
            
            #draw transmission line
            top_wire_surf = make_wire_surf(phase_top_left)
            bottom_wire_surf = make_wire_surf(phase_top_left + pi)
            surf.blit(top_wire_surf, (0, tl_top_y))
            surf.blit(bottom_wire_surf, (0, tl_bot_y))
            
            #draw lead wires
            color = rgb_from_V(cos(phase_top_right))
            pg.draw.lines(surf,color,False,top_lead_path,lead_thickness)
            color = rgb_from_V(cos(phase_top_right + pi))
            pg.draw.lines(surf,color,False,bot_lead_path,lead_thickness)
            
            #draw resistor
            resistor_surf = make_resistor_surf(phase_top_right)
            surf.blit(resistor_surf, (resistor_center[0] - resistor_width//2,
                                      resistor_center[1] - resistor_length//2))
            
            #draw electrons
            num_electrons = 100
            equilibrium_params = [x/(num_electrons-1) for x in range(num_electrons)]
            phases = [e_path(a, phase_top_left)['phase'] for a in equilibrium_params]
            now_params = [equilibrium_params[i] + sin(phases[i])/(1.3*num_electrons)
                               for i in range(num_electrons)]
            coords = [e_path(a, phase_top_left)['pos'] for a in now_params]
            for coord in coords:
                pg.draw.circle(surf, ecolor, tup_round(coord), 2, 0)
            
            pg.image.save(surf, filename_list[frame])
            
        seconds_per_frame = animation_loop_seconds / frames_in_anim
        frame_delay = str(int(seconds_per_frame * 100))
        command_list = ['convert', '-delay', frame_delay, '-loop', '0'] + filename_list + ['anim.gif']
        # Use the "convert" command (part of ImageMagick) to build the animation
        subprocess.call(command_list, cwd=directory_now)
        # Earlier, we saved an image file for each frame of the animation. Now
        # that the animation is assembled, we can (optionally) delete those files
        if True:
            for filename in filename_list:
                os.remove(filename)
    
    main()
    

    说明

    添加一行文字以描述该文件所表现的内容
    A lossless transmission line, terminated at an impedance-matched load resistor (box on right). Red color indicates high voltage, and blue indicates low voltage. Black dots represent electrons.

    此文件中描述的项目

    描繪內容

    30 7 2012

    114,327 字节

    100 像素

    300 像素

    ce7b803eeb86bea4e2127132c38e6d79cfa4062b

    文件历史

    点击某个日期/时间查看对应时刻的文件。

    日期/时间缩⁠略⁠图大小用户备注
    当前2014年2月24日 (一) 14:502014年2月24日 (一) 14:50版本的缩略图300 × 100​(112 KB)Sbyrnes321smaller file size, by switching from images2gif.py to imagemagick
    2012年7月30日 (一) 13:402012年7月30日 (一) 13:40版本的缩略图300 × 100​(258 KB)Sbyrnes321

    以下2个页面使用本文件:

    全域文件用途

    以下其他wiki使用此文件: