Desenvolvimento Código Aberto

GlowScript é um ambiente fácil de usar, poderoso para a criação de animações em 3D e publicá-las na web.  No glowscript.org, você pode escrever e executar programas GlowScript diretamente no seu navegador, armazená-los na nuvem de graça, e facilmente compartilhá-los com outras pessoas.

GlowScript, foi inspirado pelo VPython e oferece uma seleção semelhante de objetos 3D (caixa, cilindro, etc) para os programas de JavaScript, usando a biblioteca gráfica WebGL  3D disponíveis em muitos navegadores atuais. A intenção é tornar mais fácil para escrever em tempo real objetos 3D navegáveis ​​que são executados em uma página do navegador web, enquanto que os programas VPython, sendo baseado em Python, não são executados em navegadores. Existe um programa Python que faz uma conversão parcial do VPython para GlowScript.

Com usar

GlowScript foi adotado pela Google e você pode programar diretamente das nuvens, para isto é necessário somente uma conta do Google e o navegador Google Chrome, caso queira utilizar o GlowScript de outro navegador basta instalar o plug-in Google Chrome Frame.

Entre no site http://www.glowscript.org/ e efetue um login, crie um novo programa, cole o código abaixo e rode o programa. Como o GlowScript roda diretamente do browser você pode usar este link para testar o código direto da web.

Rode direto da web: AtomicSolid

Exemplo:

Neste exemplo criamos vários objetos sphere 3D unidos  por objetos helix animados simulando efeitos de molas.

GlowScript

GlowScript 1.0
/* In GlowScript programs, rotate the camera by dragging with the right mouse button, or hold down the Ctrl key and drag.

To zoom, drag with the left+right mouse buttons, or hold down the Alt key and drag, or use the mouse wheel.*/

vec.axes = [vec(1,0,0), vec(0,1,0), vec(0,0,1)]

var k = 1
var m = 1
var spacing = 1.0
var atom_radius = 0.3*spacing
var L0 = spacing-1.8*atom_radius
var V0 = pi*pow(0.5*atom_radius,2)*L0 // initial volume of spring
var N = 3
var crystal = makeCrystal(N, atom_radius, spacing, 0.1*spacing*sqrt(k/m))
scene.center = 0.5*(N-1)*vec(1,1,1)
scene.autoscale = false
var dt = 0.04*(2*pi*sqrt(m/k))

function display_instructions() {
    var s1 = "In GlowScript programs:\n\n"
    var s2 = "    Rotate the camera by dragging with the right mouse button,\n        or hold down the Ctrl key and drag.\n\n"
    var s3 = "    To zoom, drag with the left+right mouse buttons,\n         or hold down the Alt key and drag,\n         or use the mouse wheel."
    scene.caption.text(s1+s2+s3)
}

// Display text below the 3D graphics:
scene.title.text("A model of a solid represented as atoms connected by interatomic bonds")
display_instructions()

function makeCrystal( N, atom_radius, spacing, momentumRange ) {
    var crystal = { atoms:[], springs:[] }
    var atom
    var x,y,z

    function atomAt(np) {
        if (np.x>=0 && np.y>=0 && np.z>=0 && np.x            return crystal.atoms[np.x + np.y*N + np.z*N*N]
        // Otherwise create an invisible wall and return it
        var w = box()
        w.visible = false  // comment out to see the true model
        w.size = atom_radius*vec(1,1,1)
        w.pos = np*spacing
        w.momentum = vec(0,0,0)
        return w
    }

    // Create N^3 atoms in a grid
    for(z=0; z<N; z++)
        for(y=0; y<N; y++)
            for(x=0; x<N; x++) {
                atom = sphere()
                atom.pos = vec(x,y,z)*spacing
                atom.size = 2*atom_radius*vec(1,1,1)
                atom.color = vec(0,0.58,0.69)
                atom.momentum = momentumRange*vec.random()
                crystal.atoms.push( atom )
            }

    // Create a grid of springs linking each atom to the adjacent atoms
    // in each dimension, or to invisible walls where no atom is adjacent
    for(var d=0; d<3; d++)
        for(z=-1; z<N; z++)
            for(y=-1; y<N; y++)
                for(x=-1; x<N; x++) {
                    atom = atomAt(vec(x,y,z))
                    var neighbor = atomAt(vec(x,y,z)+vec.axes[d])

                    if (atom.visible || neighbor.visible) {
                        var spring = helix()
                        spring.visible = atom.visible && neighbor.visible
                        spring.thickness = 0.05
                        spring.size = vec(spacing,atom_radius,atom_radius)
                        spring.up = vec(1,1,1) // prevent fibrillation of vertical springs
                        spring.atoms = [ atom, neighbor ]
                        spring.color = vec(1,0.5,0)
                        crystal.springs.push(spring)
                    }
                }
    return crystal
}

while (true) {
    rate(30,wait)
    for(var a=0; a<crystal.atoms.length; a++) {
        var atom = crystal.atoms[a]
        atom.pos = atom.pos + atom.momentum/m*dt
    }
    for(var s=0; s<crystal.springs.length; s++) {
        var spring = crystal.springs[s]
        spring.axis = spring.atoms[1].pos - spring.atoms[0].pos
        var L = mag(spring.axis)
        spring.axis = spring.axis.norm()
        spring.pos = spring.atoms[0].pos+0.5*atom_radius*spring.axis
        var Ls = L-1*atom_radius
        spring.size.x = Ls
        var Fdt = spring.axis * (k*dt * (1-spacing/L))
        spring.atoms[0].momentum = spring.atoms[0].momentum + Fdt
        spring.atoms[1].momentum = spring.atoms[1].momentum - Fdt
    }
}

VPython é a linguagem de programação Python, adicionada de um módulo de gráficos 3D chamado Visual. VPython permite aos usuários criar objetos como esferas e cones no espaço 3D e exibe esses objetos em uma janela. Isto torna mais fácil para criar visualizações simples, permitindo que os programadores se concentrar mais no aspecto computacional de seus programas. A simplicidade de VPython tornou uma ferramenta para a ilustração de física simples, especialmente no ambiente educacional.

Controles

• Rotação : use o botão direito do mouse para girar o objeto 3D
• Zoom: use os dois botões do mouse simultaneamente para dar zoom, posicionando o mouse para frente e para traz.

Requisitos

• Sistema Operacional  – Windows, Linux ou Mac.
• Python Versão 2.75
• VPython 6
• VIDLE – Ide Visual Python

Downloads

Python e VPython

Windows: http://www.vpython.org/contents/download_windows.html

Linux: http://www.vpython.org/contents/download_linux.html

Mac: http://www.vpython.org/contents/download_mac.html

Instalação

Primeiro você precisa instalar o Python 2.75 para o seu sistema operacional, depois instale o Vpython. O VPython utiliza sua própria IDE, ao invés de usar a IDE visual tradicional para o Python chamada IDLE, você precisa usar a IDE que é instalada automaticamente com o VPython chamada VIDLE.

Recomendação

É necessário saber o básico da linguagem Python, para isto use nosso Walktrought Python, usando o menu do lado esquerdo do site chamado Categoria e escolha a opção Python, os posts mais recentes vem em primeiro lugar, caso queira iniciar na linguagem Python vá para o primeiro post.

Exemplo:

Após a instalação do VPython, abra a IDE VIDLE e use o exemplo abaixo para testar o VPython, use os controles para efeito de zoom e rotação dos objetos 3D. Este exemplo ilustra a Lei de Faraday usada na área da Física.

Lei de Faraday

A lei de Faraday-Neumann-Lenz, ou lei da indução eletromagnética, é uma das quatro equações de Maxwell que regem o eletromagnetismo clássico. É com essa lei que se entende a produção de corrente elétrica em um circuito colocado sob efeito de um campo magnético variável ou por um circuito em movimento em um campo magnético constante. É a base do funcionamento dos alternadores, dínamos e transformadores.

VPython

from visual import *
#needs a code clean-up (seems to now work on Python 2.4/VPython 3.2.9)

print """
Electromagnetism: Faraday Law (v2.76) 2008-02-29
Rob Salgado (salgado@physics.syr.edu)

Electric Field vectors are blue. Magnetic Field vectors are red.

  The thick green vector representing
d|B|/dt ("time-rate-of-change-of-the-magnitude-of-the-magnetic-field")
is associated with the spatial arrangement of the electric field according to
the FARADAY Law (as evaluated on the green loop).
[The sense of circulation on the green loop (by the RightHandRule) determines
the direction of change of the magnetic field... OPPOSITE to your thumb.]

      CLICK the mouse to start and stop the animation
      TOGGLE: (f)araday
              (d)im-fields (n) color-scheme  (v)erbose"""

scene=display(
    width=800,height=600,
    x=0, y=0)

colorScheme=0          #key n (negative)
colorBackground=[color.black,color.white]
colorEdimmed=[(0.0,0,0.4),(0.5,0.5,1)]
scene.ambient=0.4
Ecolor=[color.blue,(0.5,0.5,1),color.green]
Ecolor[1]=colorEdimmed[colorScheme]

scene.background=colorBackground[colorScheme]
scene.background=color.black; Ecolor=[color.blue,(0,0,.4),color.green]
#scene.background=color.white; Ecolor=[color.blue,(0.9,0.9,0.9),color.yellow]
scene.title="FARADAY: Changing-Bs are associated with Curly-Es"
scene.range=(2.5,2.5,2.5)
scene.forward=(-2.85804, -1.26038, -2.96742)

#scene.forward=(0.089623,4.193811,0.983082)

#scene.range=(1.5,1.5,1.5)
#scene.forward=(2.102859,-3.185552,1.998194)

showFaraday=0
dimFields=0

B=[]
B.append( arrow(pos=vector(0.25,0,0),axis=vector(0,0,1e-3), shaftwidth=0.04,fixedwidth=1, color=color.red)  )
B.append( arrow(pos=vector(-0.25,0,0),axis=vector(0,0,1e-3),shaftwidth=0.04,fixedwidth=1, color=color.red)  )
B.append( arrow(pos=vector(0,0.25,0),axis=vector(0,0,1e-3), shaftwidth=0.04,fixedwidth=1, color=color.red)  )
B.append( arrow(pos=vector(0,-0.25,0),axis=vector(0,0,1e-3), shaftwidth=0.04,fixedwidth=1, color=color.red)  )
B.append( arrow(pos=vector(0.25,0,-2),axis=vector(0,0,1e-3), shaftwidth=0.04,fixedwidth=1, color=color.red)  )
B.append( arrow(pos=vector(-0.25,0,-2),axis=vector(0,0,1e-3),shaftwidth=0.04,fixedwidth=1, color=color.red)  )
B.append( arrow(pos=vector(0,0.25,-2),axis=vector(0,0,1e-3), shaftwidth=0.04,fixedwidth=1, color=color.red)  )
B.append( arrow(pos=vector(0,-0.25,-2),axis=vector(0,0,1e-3), shaftwidth=0.04,fixedwidth=1, color=color.red)  )

N=8
dBdt=0.2
E=[]
Ebox=[]

for z in [0]:
    for r in [0.5]:
        for i in arange(0,N):
            theta=2.*pi*i/N
            theta_hat=vector(-sin(theta), cos(theta), 0)
            Efield= -dBdt*theta_hat/r
            A=arrow(pos=vector(r*cos(theta),r*sin(theta),z) , axis=Efield,shaftwidth=0.04,fixedwidth=1,color=color.blue)
            E.append(A)
            Ebox.append( box(pos=A.pos+A.axis/4.,axis=A.axis,length=mag(A.axis)/2.,height=0.04,width=0.04,color=color.blue) )
    for r in [1,1.5]:
        for i in arange(0,N):
            theta=2.*pi*i/N
            theta_hat=vector(-sin(theta), cos(theta), 0)
            Efield= -dBdt*theta_hat/r
            A=arrow(pos=vector(r*cos(theta),r*sin(theta),z) , axis=Efield,shaftwidth=0.04,fixedwidth=1,color=color.blue)
            E.append(A)
            Ebox.append( box(pos=A.pos+A.axis/4.,axis=A.axis,length=mag(A.axis)/2.,height=0.04,width=0.04,color=color.blue) )

for z in [-0.5,0.5,-1,1]:
    for r in arange (.5,1.5,.5):
        for i in arange(0,N):
            theta=2.*pi*i/N
            theta_hat=vector(-sin(theta), cos(theta), 0)
            Efield= -dBdt*theta_hat/r
            A=arrow(pos=vector(r*cos(theta),r*sin(theta),z) , axis=Efield,shaftwidth=0.04,fixedwidth=1,color=color.blue)
            E.append(A)
            Ebox.append( box(pos=A.pos+A.axis/4.,axis=A.axis,length=mag(A.axis)/2.,height=0.04,width=0.04,color=color.blue) )

hcolor=Ecolor[2]

Bp=[]
for b in B:
    Bp.append( arrow(pos=b.pos+b.axis,axis=dBdt*norm(b.axis),
                     #length=dBdt,
                     fixedwidth=1, color=hcolor, shaftwidth=0.07,headwidth=0.14, visible=showFaraday)  )

Eloop_rad=mag(E[0].pos)
FaradayLoop=curve(color=hcolor, x=Eloop_rad*cos(2.*pi*arange(40)/40.), y=Eloop_rad*sin(2.*pi*arange(40)/40.), visible=showFaraday )

#I=cylinder(radius=0.04,pos=vector(0,0,-2),axis=vector(0,0,4), color=color.yellow)
#chgpos=[]
#chg=[]
#for i in arange(0,N):
#    chgpos.append(vector(I.pos+I.axis*i/N))
#    chg.append(sphere(pos=chgpos[-1],radius=0.05,color=I.color))

t=9.50
#t=10.0
#t=10.5

dt=1

#Now... WHEN AN OBJECT IS PICKED,
#TRANSLATE THE scene.center TO THE OBJECT'S POSITION
while 1:
    rate(10)
    t += dt
##    for i in arange(0,N):
##        chg[i].pos = chgpos[i]+(t%4)*vector(0,0,.125)
    bcount=0
    for b in B:
        b.length = (t%20)/10.+1e-3
        Bp[bcount].pos=b.pos+b.axis; bcount +=1

    if scene.mouse.clicked:
        scene.mouse.getclick()
        newPick=scene.mouse.pick
        if newPick !=None:
            ### ANIMATE TO SELECTED POSITION
            tempcolor=newPick.color
            newPick.color=color.yellow
            target=newPick.pos
            step=(target-scene.center)/20.
            for i in arange(1,20,1):
                rate(10)
                scene.center +=step
                scene.scale *= 1.037  #(1.037**19=1.99)
            newPick.color=tempcolor

    if scene.kb.keys: # is there an event waiting to be processed?
        s = scene.kb.getkey() # obtain keyboard information
        if s=='f':
            showFaraday +=1; showFaraday %=2; FaradayLoop.visible=showFaraday
            for i in Bp:
                i.visible=showFaraday

            if showFaraday==1:
                for i in arange(0,N):
                    E[i].color=hcolor
                    Ebox[i].color=hcolor
            else:
                for i in arange(0,N):
                    E[i].color=color.blue
                    Ebox[i].color=color.blue

        if s=='d':
            dimFields +=1; dimFields %=2;

            for i in arange(N,len(E)):
                E[i].color=Ecolor[dimFields]
                Ebox[i].color=Ecolor[dimFields]
            for i in arange(1,4*N+1):
                E[-i].visible=(1-dimFields)
                Ebox[-i].visible=(1-dimFields)

        if s=='n':
            colorScheme = (colorScheme+1)%2 #TOGGLE colorScheme
            scene.background=colorBackground[colorScheme]
            Ecolor[1]=colorEdimmed[colorScheme]
            scene.background=colorBackground[colorScheme]

            for i in arange(N,len(E)):
                E[i].color=Ecolor[dimFields]
                Ebox[i].color=Ecolor[dimFields]
            for i in arange(1,4*N+1):
                E[-i].visible=(1-dimFields)
                Ebox[-i].visible=(1-dimFields)

        if s=='z':
            print "scene.center=(%f,%f,%f)"  % tuple(scene.center)
            print "scene.forward=(%f,%f,%f)"  % tuple(scene.forward)
            print "scene.range=(%f,%f,%f)"  % tuple(scene.range)
            print "t=%f\n" %t

        if s==' ':
            dt  +=1; dt %=2;