Przekładnia zębata

Dzisiaj zaprezentuję jak modelować koła zębate.
Korzystamy z biblioteki Visual, tworzymy ścieżkę oraz kształt i wyciągamy:

#!/usr/bin/env python

# coding=utf-8

from __future__ import division

from visual import *

# moduł, liczba zębów, grubość koła, wysokość głowy zęba, kolor, ramka

def kolo(m,z,k,h,col,f):

  extrusion(frame=f,pos=[(0,0,k/2),(0,0,-k/2)],

  shape=shapes.gear(radius=m*z/2, n=z,

  addendum=h, dedendum=m*1.2), color=col)

Python - Tryb interaktywny

Pythona można używać nie tylko jako interpreter skryptów. Jednym ze sposobów uruchomienia Pythona jest interaktywna konsola.

W systemach unixopodobnych (Linux, Mac, itp.) wystarczy wykonać polecenie python, aby uruchomić Pythona w trybie interaktywnym.
Pod Windows można uruchomić program gdzieś w menu Start, lub za pomocą edytora Idle.

python

Python 2.7.1+ (r271:86832, Apr 11 2011, 18:05:24)
[GCC 4.5.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Za znakami '>>>' możemy wpisywać polecenia.

>>> print 'aaa'
aaa

Co ciekawe - w trybie interaktywnym wyświetlane są wszystkie zwracane wartości:

>>> 1+3
4

>>> x=3*2
>>> 1+x
7

Ostatnio piszę głównie o grafice trójwymiarowej, więc trzymajmy się tematu:
>>> from visual import *
>>> a=arrow()

 >>> a.color=(1,.7,.2)

Na dzisiaj tyle musi starczyć.

VPython: Zimowe fraktale

Jest zima, ale nie ma śniegu - coś na to poradzimy.

Wiele form występujących w przyrodzie posiada cechy samopodobieństwa - to znaczy że mały fragment jest podobny do całości. Jest to także cecha specyficzna fraktali, za pomocą których możemy opisać na przykład góry, rośliny i... płatki śniegu.

Dzisiaj zaprezentuję jak korzystając z biblioteki Visual narysować śnieżkę Kocha. Początkującym radzę, żeby się nie zrażali, bo rzeczy związane z fraktalami, czy ogólnie z rekurencją nie dla każdego są jasne od samego początku, ale - będzie dobrze. Śnieżkę Kocha rysuje się w następujący sposób:

1. Za pomocą linii rysujemy trójkąt równoboczny.
2. Każdą z linii dzielimy na 3 części
3. W miejscu środkowej części dodajemy dwie linie tak aby powstał trójkąt równoboczny.
4. Usuwamy podstawę trójkąta
5. Dla wszystkich istniejących linii, wykonujemy punkty od 2 do 5, do momentu aż się nam znudzi.

Na początek niezbędne formalności:

#!/usr/bin/env python
from __future__ import division (obsługa dzielenia niecałkowitego za pomocą znaku "/")
from visual import *


Tworzymy funkcję sniezka(), która:

• Przyjmuje parametry:
• etapy - ilość podziałów do wykonania
• l - długość boku trójkąta
• r - promień linii, którą rysujemy
• Tworzy ogólną ramkę "gwiazdka", która ma w sobie zawierać cały fraktal
• Tworzy 3 ramki dla każdej linii
• Obraca ramki w taki sposób, by narysowane w nich obiekty tworzyły zamknięty trójkąt
• Oblicza wysokość trójkąta, aby następnie narysować 3 linie w swoich ramkach
• Generuje fraktale oparte na stworzonych liniach
• Zwraca efekt końcowy

def sniezka(etapy,l,r):
    gwiazdka=frame()
    f1=frame(frame=gwiazdka)
    f2=frame(frame=gwiazdka)
    f3=frame(frame=gwiazdka)
    f2.rotate(angle=-2*pi/3, axis=(0,0,1))
    f3.rotate(angle=2*pi/3, axis=(0,0,1))
    h=(l)*3**(1/2)/2
    l1=curve(pos=((-l/2,h/3),(l/2,h/3)),frame=f1, radius=r)
    l2=curve(pos=((-l/2,h/3),(l/2,h/3)),frame=f2, radius=r)
    l3=curve(pos=((-l/2,h/3),(l/2,h/3)),frame=f3, radius=r)
    fract(l1,etapy,r,f1)
    fract(l2,etapy,r,f2)
    fract(l3,etapy,r,f3)
    return gwiazdka

Funkcja korzystała z funkcji generującej fraktale fract(), która wygląda następująco:

def fract(linia,etapy,r,f):   
    x1=linia.pos[0][0]
    y1=linia.pos[0][1]
    x2=linia.pos[1][0]
    y2=linia.pos[1][1]
    if etapy>0:
        rate(50) # opóźnienie w celu zrobienia animacji
        p1=(x1,y1,0)
        p2=(x1+(x2-x1)/3,y1+(y2-y1)/3,0)
        p3=(x2+(x1-x2)/3,y2+(y1-y2)/3,0)
        p4=(x2,y2,0)
        p5=obrocony(p3,p2,pi/3)
        c1=curve(frame=f, pos=(p1,p2),radius=r)
        c2=curve(frame=f, pos=(p2,p5),radius=r)
        c3=curve(frame=f, pos=(p5,p3),radius=r)
        c4=curve(frame=f, pos=(p3,p4),radius=r)
        linia.visible=False
        fract(c1,etapy-1,r,f)
        fract(c2,etapy-1,r,f)
        fract(c3,etapy-1,r,f)
        fract(c4,etapy-1,r,f)

 Funkcja działa w następujący sposób:

1. Określa współrzędne początku i końca linii, której podziału ma dokonać
2. Jeśli nie została wykonana określona ilość podziałów to:
1. Ogranicza ilość wyświetlanych klatek do 50
2. Oblicza współrzędne punktów podziałowych znajdujących się na linii
3. Oblicza współrzędne punktu, który ma być wierzchołkiem nowego trójkąta, za pomocą funkcji obrocony()
4. Usuwa starą linię
5. Rysuje 4 nowe linie (2 boczne + 2 tworzące boki nowego trójkąta)
6. Dokonuje podziałów nowo powstałych linii wywołując samą siebie (rekurencja)

Funkcja korzystała z funkcji obrocony(), która oblicza współrzędne punktu obróconego względem innego punktu o zadany kąt:

def obrocony(p,ps,L):
    X=p[0]
    Y=p[1]
    Xs=ps[0]
    Ys=ps[1]
    return ((X-Xs)*cos(L) - (Y-Ys)*sin(L) + Xs),((X-Xs)*sin(L) + (Y-Ys)*cos(L) + Ys),0

Parametry:

• p - punkt do obrócenia
• ps - punkt środkowy
• L - kąt obrotu podany w radianach

Na koniec wywołujemy naszą śnieżynkę i możemy cieszyć się efektem:

sniezka(5,5,0.02)

Można by się pokusić o obracającą się snieżkę:

def rot(f):
    while True:
        f.rotate(angle=radians(1), axis=(0,1,0))
        rate(50)

s = sniezka(4,5,0.02)
rot(s)

Znalazłem nawet praktyczne zastosowanie dla wyprodukowanego śniegu:

VPython - parametry obiektów 3D

Następujące parametry dotyczą wszystkich obiektów z biblioteki VPython:

visible - jeśli ma wartość False, obiekt nie jest wyświetlany; na przykład: kulka.visible = False
Użyj kulka.visible = True żeby kulka znów była widoczna.

frame - umieść obiekt w ramce, na przykład kulka = sphere(frame = f1)

make_trail = True - możesz określić, czy poruszające się obiekty typu: arrow, box, cone, cylinder, ellipsoid, pyramid, ring, lub sphere mają pozostawiać za sobą ślad.

display - kiedy uruchamiasz program, VPython tworzy okno i nadaje mu nazwę scene. Domyślnie obiekty które tworzysz trafiają do tego okna. Możesz wybrać inne okno w którym mają być wyświetlane obiekty w następujący sposób: 

okno2 = display( title = "Drugie okno" ) 

kulka = sphere( display = okno2 )

Wykonanie kodu: aktywny_ekran = display.get_selected() zwróci identyfikator ekranu,  na którym aktualnie domyślnie wyświetlane są wszystkie nowe obiekty. Aby ustawić wybrany ekran jako domyślny użyj np.: okno2.select(), co spowoduje że nowe obiekty będą na nim wyświetlane jeśli nie zdecydujesz inaczej.

Istnieje funkcja rotate(), którą możesz używać dla wszystkich obiektów, które nie są typu "tablicowego", czyli innych niż: curve, convex, extrusion, faces, text i points (które możesz wstawić do ramki i obrócić ramką: ramka.rotate()).

__class__ Nazwa klasy obiektu - na przykład kulka.__class__ to sphere. Są dwa znaki podkreślenia przed i za słowem class.

__copy__() tworzy kopię danego obiektu.

VPython - podstawowe obiekty

Dzisiaj przedstawię obiekty, które wystarczy wziąć i używać.

Wśród nich:
arrow(), box(), cone(), convex(), curve(), cylinder(), ellipsoid(), helix(), points(), pyramid(), ring(), sphere()

Większość obiektów zostanie wyświetlona zaraz po wpisaniu ich nazwy, bez żadnych dodatkowych parametrów.

Oczywiście najpierw trzeba zaimportować bibliotekę:

from visual import *

Wyjątki to:

• Convex()
• Curve()
• Points()

W ich przypadku trzeba dodać parametr pos, który oznacza tym razem listę punktów składających się na daną figurę.

Na przykład linia łamana:
curve(pos=((x1,y1,z1), (x2,y2,z2), (x3,y3,z3)))

I jeszcze krótki filmik demonstrujący wygląd wspomnianych obiektów:

VPython - wprowadzenie i instalacja

VPython jest programistyczną biblioteką 3D dla języka Python. Projekt powstał po to, żeby umożliwić studentom fizyki (którzy zazwyczaj nie mieli styczności z programowaniem) modelowanie różnych zjawisk fizycznych.

Najważniejszą cechą biblioteki VPython jest prostota. Od kiedy zobaczyłem jak łatwo można tworzyć trójwymiarowe programy - Python stał się moim ulubionym językiem programowania.

Instalacja
Pliki instalacyjne można pobrać ze strony projektu dla systemów Windows, Mac i Linux. Ważne żeby pliki zainstalować w domyślnej lokalizacji.

Moim zdaniem korzystając z Linuksa, wygodniej będzie jednak zainstalować bibliotekę korzystając z repozytoriów danej dystrybucji.

Na Ubuntu wystarczy wykonać polecenie:

sudo apt-get install python-visual libgtkglextmm-x11-1.2-dev

Niestety wersja znajdująca się w repozytorium Ubuntu 11.10 jest trochę przestarzała i brakuje w niej tylko kilku bardziej zaawansowanych funkcji takich jak wyciągnięcia, ale z tego co wyczytałem na liście dyskusyjnej developerów VPython, trwają prace nad włączeniem aktualnej wersji do najbliższego wydania Ubuntu.

Fedora ma już nowsze pakiety. Można je zainstalować w następujący sposób:

su -
yum install python-visual gtkglextmm-devel

Test
Najprostszy program wygląda następująco:

#!/usr/bin/env python
from visual import *
box()

Zapisujemy go w pliku z rozszerzeniem .py
Jeśli korzystasz z systemu Linux, lub Mac, możesz nadać mu uprawnienia do wykonania:

chmod +x plik.py

Program można uruchomić kliknięciem, lub w konsoli:

./plik.py

lub

python plik.py

Jeżeli wszystko przebiegło poprawnie, powinieneś otrzymać następujący efekt:

Aha - obracać można z wciśniętym prawym przyciskiem myszy, a przybliżać można trzymając wciśnięte oba przyciski.