Pod wpływem wpisu na blogu zajaczkowski.org , który od jakiegoś czasu przeglądam, postanowiłem podjąć się zadania przebiegnięcia 1000 km. Biegi zacząłem wczoraj (1 listopad). Myślę, że warto tu wspomnieć kilka szczegółów – mam 22 lata i z powodu wypadku na kręgosłup, który miałem kilka lat wcześniej za bardzo nie uprawiałem żadnych sportów. Ponieważ ostatnio sytuacja z moim kręgosłupem unormowała się mogę sobie pozwolić na odrobinę aktywnego ruchu (nie tylko rower…). Mam 183cm wzrostu, wagę zachowam dla siebie ;) – jeżeli uda mi się ją zredukować wtedy może przyznam się do tego ile tych kilogramów było. Co by nie mówić jest ich stanowczo za dużo. Jak można wyczytać na tym blogu studiuję informatykę i prowadzę raczej siedzący tryb pracy.

Wczoraj udało mi się przebiec 3,1km w czasie 25min, dzisiaj 3,8km w czasie 30min. Ogólnie kondycja mojego organizmu obecnie jest niezadowalająca. Po około 10min muszę z truchtu przechodzić do marszu, gdyż nie jestem w stanie dalej biec. Po unormowaniu oddechu (które trwa ok 3-4min) mogę biec dalej przez ok 5-7min. Biegi pierwszego dnia bardzo mnie zmęczyły, na drugi dzień było już trochę lepiej – łatwiej było mi panować nad oddechem oraz więcej czasu biec truchtem. Jedną z ważnych informacji jest również to, że ostatniego października rzuciłem palenie (mam nadzieję, że tym razem na stałe). Bieganie po części ma być sposobem by nie myśleć o papierosach… zobaczymy co z tego wyjdzie. Proszę trzymajcie kciuki. Co jakiś czas będę tu zamieszczał informacje na temat tego co udało mi się osiągnąć i jak zmienia się ogólna kondycja mojego organizmu. Mam nadzieję, że wytrwam i to co w tym momencie wydaje się dość nie realne – przebiegnięcie w sumie 1000km – może za jakiś czas okazać się czymś co jestem w stanie zrobić. Czas pokaże co z tego wyniknie. Myślę, że mimo wszystko warto spróbować.

Pierwszy raz w życiu postanowiłem zabrać się za przetłumaczenie tutoriala na język ojczysty. Dlaczego mój wybór padł na bibliotekę pymunk w pythonie? Uważam, że osoby związane z tym projektem (ściślej rzecz ujmując z projektem Chipmunk) mówiąc trochę kolokwialnie odwaliły kawał dobrej roboty.

Pymunk jest biblioteką symulującą grawitację na potrzeby symulacji fizycznych w 2D, co za tym idzie w łatwy sposób możemy dzięki tej bibliotece stworzyć symulację zjawisk fizycznych w naszych grach komputerowych. Biblioteka ta udostępniona jest na zasadach licencji MIT – jednym słowem daje nam nieograniczone prawa modyfikacji /udostępniania /redystrybucji źródeł z zastrzeżeniem zawarcia informacji o autorach. Na głównej stronie pymunk`a (hostowanej przez google code) znajduje się tutorial ‘SlideAndPinJointsExample’ autorstwa v…@viblo.se, który to właśnie zamierzam (w większej części) przetłumaczyć. Chciałbym by czytelnik zapoznał się z grubsza z funkcjami oferowanymi przez tą bibliotekę. Jeżeli kogoś zainteresuje ten wpis i chciałby poznać lepiej pymunk powinien poszukać informacji na stronach projektu. Jak na razie pymunk nie doczekał się porządnego udokumentowania, co miejmy nadzieję szybko się zmieni.

Chciałbym zaznaczyć, iż moje tłumaczenie miejscami nie jest w 100% ścisłe z tekstem zamieszczonym przez autora oryginału, poza tym jest to jedynie tłumaczenie części tutoriala. Dość gadania bierzmy się do pracy:

1 – Nim zaczniemy

W tym tutorialu będziesz potrzebował:

1. Python (oczywiście…)
2. ctypes (dołączony do Python 2.5)
3. pygame (znajdziesz na stronie www.pygame.org)
4. Skompilowaną bibliotekę chipmunk
5. pymunk

(pygame jest wymagany jedynie dla tego tutoriala oraz kilku załączonych programów demonstracyjnych, nie jest on niezbędny do uruchomienia pymunk)

W celu uruchomienia pymunk będziesz potrzebował skompilowaną bibliotekę chipmunk. Jeżeli pracujesz pod systemem Windows, najprościej będzie jeżeli rozpakujesz ściągniętą przez ciebie paczkę z pymunk do katalogu gdzie znajduje się chipmunk.dll (bądź lepiej, ściągnij pymunk bezpośrednio ze źródeł svn). Jeżeli pracujesz na platformie, dla której nie ma prekompilowanej paczki z chipmunk (np. Linux bądź OSX), będziesz musiał skompilować ją samemu. Chipmunk (oraz instrukcje jak go skompilować) możesz znaleźć na stronie http://wiki.slembcke.net/main/published/Chipmunk

2 – Pusta symulacja

Ok, zaczynamy na poważnie… Chipmunk (co za tym idzie pymunk) ma kilka podstawowych założeń, które świetnie są wytłumaczone w cytowanym fragmencie dokumentacji:

* Ciała Sztywne: Ciało sztywne jako obiekt posiada właściwości fizyczne (masa, pozycja, rotacja, prędkość itp.) Samo w sobie nie posiada jednak kształtu.
* Zderzenia ciał: Nadając kształt ciału, możesz definiować zachowanie się ciała.
* Łączność: Możesz łączyć ciała zmuszając je do interakcji.
* Przestrzenność: Przestrzeń jest podstawową jednostką symulacji w Chipmunk. Możesz dodawać obiekty (ciała sztywne), nadawać im kształty a na koniec zawrzeć te wytwory w przestrzeni – następnie możesz symulować przestrzeń jako całość.

Dokumentację chipmunk możesz znaleźć pod adresem: http://files.slembcke.net/chipmunk/chipmunk-docs.html Dobrym pomysłem jest byś ją przeczytał, więc najlepiej zrób to teraz ;)

Teraz jesteśmy gotowi by w końcu napisać trochę kodu:

import sys
import pygame
from pygame.locals import *
from pygame.color import *
import pymunk as pm #1

def main():
    pygame.init()
    screen = pygame.display.set_mode((600, 600))
    pygame.display.set_caption("Joints. Just wait and the L will tip over")
    clock = pygame.time.Clock()
    running = True

    pm.init_pymunk() #2
    space = pm.Space() #3
    space.gravity = (0.0, -900.0)

    while running:
        for event in pygame.event.get():
            if event.type == QUIT:
                running = False
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                running = False

        screen.fill(THECOLORS["white"])

        space.step(1/50.0) #4

        pygame.display.flip()
        clock.tick(50)

if __name__ == '__main__':
    sys.exit(main())

Wywołanie naszego kodu spowoduje wyświetlenie pustego okna oraz uruchomienie symulacji fizyki dla pustej przestrzeni.

1. Potrzebujemy zaimportować pymunk aby go używać…
2. Pierwszą rzeczą, którą musimy zrobić jest inicjalizacja pymunk, którą robimy w tej linii kodu.
3. Następnie tworzymy przestrzeń i ustawiamy grawitację
4. W naszej głównej pętli gry wywołujemy funkcję step() – odpowiada za odświerzanie naszej “fizyki”.

3 – Spadające kulki

Najprostszym kształtem do obsługi (oraz rysowania) jest okrąg. Dlatego też naszym następnym krokiem będzie dodanie spadająych piłek do naszej przestrzeni. W większości przykładowych programów cały kod znajduje się w funkcji main(). Jednak my utworzymy kilka metod w tym tutorialu by nasz kod był łatwiejszy do zrozumienia. Po pierwsze, funkcja dodawania piłek do naszej przestrzeni:

def add_ball(space):
    mass = 1
    radius = 14
    inertia = pm.moment_for_circle(mass, 0, radius, (0,0)) # 1
    body = pm.Body(mass, inertia) # 2
    x = random.randint(120,380)
    body.position = x, 550 # 3
    shape = pm.Circle(body, radius, (0,0)) # 4
    space.add(body, shape) # 5
    return shape

1. Wszystkie ciała muszę mieć zdefiniowany własny moment bezwładności. Jeżeli naszym obiektem jest normalna piłka (kulka) możemy użyć predefiniowanej funkcji moment_for_circle do ustawienia jej masy i promienia.
2. Następnie mając zdefiniowany moment bezwładności możemy utworzyć “ciało” naszej piłki
3. Oraz ustawić jej pozycję
4. W przypadku zderzenia z innymi obiektami, potrzebujemy zdefiniować zachowanie się obiektów
5. Ostatecznie, dodajemy ciało i kształt naszego obiektu do przestrzeni naszej symulacji.

Teraz gdy utworzyliśmy kulki chcemy je wyświetlić:

def draw_ball(screen, ball):
    p = int(ball.body.position.x), 600-int(ball.body.position.y)
    pygame.draw.circle(screen, THECOLORS["blue"], p, int(ball.radius), 2)

W tym przykładzie używamy pygame, jednak nie jest to konieczne. Kolejnym krokiem jest wyliczenie pozycji kulki.

Z tymi dwoma funkcjami oraz kawałkiem mniej ważnego z punktu widzenia tego tutoriala kodu powinieneś zobaczyć spadające piłki. Yupi!!

import sys, random
import pygame
from pygame.locals import *
from pygame.color import *
import pymunk as pm

#def add_ball(space):
#def draw_ball(screen, ball):

def main():
    pygame.init()
    screen = pygame.display.set_mode((600, 600))
    pygame.display.set_caption("Joints. Just wait and the L will tip over")
    clock = pygame.time.Clock()
    running = True

    pm.init_pymunk()
    space = pm.Space()
    space.gravity = (0.0, -900.0)

    balls = []

    ticks_to_next_ball = 10
    while running:
        for event in pygame.event.get():
            if event.type == QUIT:
                running = False
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                running = False

        ticks_to_next_ball -= 1
        if ticks_to_next_ball <= 0:
            ticks_to_next_ball = 25
            ball_shape = add_ball(space)
            balls.append(ball_shape)

        screen.fill(THECOLORS["white"])

        for ball in balls:
            draw_ball(screen, ball)

        space.step(1/50.0)

        pygame.display.flip()
        clock.tick(50)

if __name__ == '__main__':
    sys.exit(main())

To już koniec. Jak nadmieniłem wcześniej jest to moje pierwsze tłumaczenie więc proszę o wyrozumiałość. Mam nadzieję, że pymunk zainteresuje chociaż jedną osobę po przeczytaniu tego mini tutoriala. Zapraszam do dyskusji. Proszę o komentarze i wasze opinie – miło by było wiedzieć, czy to co robię ma sens i czy zabierać się w przyszłości za inne tłumaczenia…

Dziś chciałbym zainaugurować nową kategorię wpisów na moim blogu – będzie w niej mowa o moich podróżach. Jak na razie ponieważ czas nie pozwala mi na dokładne opisy chciałbym jedynie zamieścić mapkę krajów, które dotychczas odwiedziłem i ich opisy już niedługo znajdą się na blogu.

create your own visited country map
or check our Venice travel guide

Do wygenerowania tej mapy posłużyłem się apletem znajdującym się na stronie: http://www.world66.com

Wiem, że mało ludzi to interesuje lecz chciałbym dzisiaj przedstawić dalszą część moich dygresji na temat triangulacji Delaunay. Po co właściwie zajmować się takim rodzajem triangulacji? Otóż sprawa jest dość prosta – jeżeli zamierzamy napisać własną grę 3D, w której postacie będą poruszały się po scenie, w jakiś sposób musimy wygenerować naszą scenę. Triangulacja Delaunay jest jednym ze sposobów generowania takiej przestrzennej siatki. Jak na razie, zajmijmy się jednak aspektami triangulacji w 2D.

Oczywiście jeżeli zamierzamy pisać grę najlepiej będzie nam zaimplementować ten algorytm w C, C++ lub innym języku obiektowym wysokiego poziomu. By zrozumieć ideę implementacja w C czy C++ nie będzie konieczna, dlatego też wykorzystałem do tego celu Matlaba w wersji 7.3.

Jak pisałem w jednym z poprzednich postów by dokonać triangulacji Delaunay w Matlabie wystarczy skorzystać z jednej z gotowych funkcji oferowanych przez ten program. Przykładowa implementacja mogłaby wyglądać mniej więcej tak:

d=change_kote1;
T=delaunay(d(:,1),d(:,2));
triplot(T,d(:,1),d(:,2),'red');

‘change_kote1′ jest tablicą dwuwymiarową zawierającą współrzędne punktów (x,y).

Co jednak zrobić by sprawdzić czy triangulacja jest prawidłowa? Musimy zbudować okręgi opisane na każdym z trójkątów. Jeżeli w środku każdego z nich nie będzie znajdował się ani jeden wierzchołek triangulacji będzie to oznaczać, że nasza triangulacja działa prawidłowo. Jak się do tego zabrać? Najlepiej do tego celu stworzyć oddzielną funkcję, która dla każdych trzech wierzchołków będzie zwracała promień oraz środek okręgu opisanego na trójkącie utworzonym z tych wierzchołków.

function [kola] = circle(x1,y1,x2,y2,x3,y3)
%obliczenie promienia
a=sqrt((x1-x2)^2+(y1-y2)^2);
b=sqrt((x2-x3)^2+(y2-y3)^2);
c=sqrt((x3-x1)^2+(y3-y1)^2);
promien=a*b*c/sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c));
%obliczenie srodka okregu opisanego na trojkacie
A_x=x1;
A_y=y1;
B_x=x2;
B_y=y2;
C_x=x3;
C_y=y3;
D=2*(A_y*C_x+B_y*A_x-B_y*C_x-A_y*B_x-C_y*A_x+C_y*B_x);
sx=(B_y*A_x^2-C_y*A_x^2-B_y^2*A_y+C_y^2*A_y+B_x^2*C_y+A_y^2*B_y+C_x^2*A_y-C_y^2*B_y-C_x^2*B_y-B_x^2*A_y+B_y^2*C_y-A_y^2*C_y)/D;
sy=(A_x^2*C_x+A_y^2*C_x+B_x^2*A_x-B_x^2*C_x+B_y^2*A_x-B_y^2*C_x-A_x^2*B_x-A_y^2*B_x-C_x^2*A_x+C_x^2*B_x-C_y^2*A_x+C_y^2*B_x)/D;
%zwraca promien oraz wspolrzedne x,y srodka okregu opisanego na trojkacie
kola=[promien, sx, sy];

Z ciekawszych rzeczy, na które warto zwrócić uwagę jest wzór na wyrażenie D, sx oraz sy. (sx, sy) – to współrzędne środka okręgu opisanego na trójkącie (w wolnej chwili warto by poszukać lepszego wzoru na ten punkt jeżeli do dyspozycji mamy jedynie wierzchołki trójkąta :P mi lepszego znaleźć się nie udało…).

Ostatnią rzeczą, która została nam do zaimplementowania jest wyświetlanie wszystkich okręgów opisanych:

hold on;
for i=1:1:(max(size(T))-2)
M=circle(d(T(i,1),1),d(T(i,1),2),d(T(i,2),1),d(T(i,2),2),d(T(i,3),1),d(T(i,3),2));
% okrąg o środku (a,b) i promieniu r we wsp. biegunowych
r=M(1); a=M(2); b=M(3); t = linspace(0,2*pi,200); x = a+r*cos(t); y = b+r*sin(t);
plot(x,y,'-','LineWidth',0.1);
axis auto; %axis equal
end

Teraz możemy cieszyć się efektami naszej pracy:

delaunay empty circle

Jeżeli kogoś zainteresował temat triangulacji Delaunay więcej interesujących materiałów można znaleźć na stronach:

• http://en.wikipedia.org/wiki/Delaunay_triangulation
• http://local.wasp.uwa.edu.au/~pbourke/papers/triangulate/

Zmarnowałem dzisiaj sporo czasu by to znaleźć… Aby w Matlabie móc rysować w niezależnych oknach należy skorzystać z funkcji ‘figure’. Nie było dla mnie problemem rysowanie wielu wykresów w jednym oknie lecz właśnie narysowanie wykresów w dwóch niezależnych oknach. Trudno jest znaleźć coś co nie wiadomo właściwie jak się nazywa… Jeżeli ktoś miałby z tym problem to po wpisaniu w pomocy hasła ‘ figure’ znajdzie już wszystkie niezbędne informacje odnośnie szczegółów.

Dla zbioru punktów (x, y) zapisanych w tablicy ‘dane’ przeprowadzenie triangulacji Delaunay odbywa się następująco:

%triangulacja Delaunay
T=delaunayn(dane)
triplot(T,dane(:,1),dane(:,2),'red')


Poniżej zamieszczam efekt triangulacji dla przykładowego zbioru (ponad 1200) punktów:

triangulacja

Na początku każdego semestru studiów staram się wyszukać maksymalnie dużo materiałów źródłowych do każdego z przedmiotów. Jak wiadomo, każdy student cierpi na brak wystarczających funduszy by kupić sobie interesujące go książki… pożyczanie ich z biblioteki wiąże się z tym, że trzeba potem je oddawać lub prolongować termin oddania co czasem bywa dość nużące. Dobrą alternatywą jest znalezienie e-booków w internecie (oczywiście mowa tylko o takich, które są udostępniane darmowo ;) ).

Parę dni temu mój znajomy pokazał mi stronkę http://gigapedia.com/ gdzie po darmowej rejestracji ma się dostęp do pokaźnej bazy e-booków. Większość z nich jest w języku angielskim ale w dzisiejszych czasach dla większości ludzi język ten nie jest już językiem obcym lecz staje się językiem zawodowym, więc nie powinno to być problemem. A jeżeli jest to i tak trzeba kiedyś popracować nad tym… Naprawdę gorąco polecam przyjrzeć się dostępnym tam zasobom.

Po rejestracji mamy dostęp do przeszukiwania zasobów korzystając z czterech wyszukiwarek – osobiście polecam korzystać z wyszukiwarki gigapedia. Przynajmniej dla mnie zwracała ona najwięcej sensownych rezultatów. Warto nadmienić, że do rejestracji wymagany jest adres e-mail na gmail`u (jak na razie nie zauważyłem by wiązało się to ze zwiększeniem otrzymywania spamu na skrzynkę pocztową).

Cały czas zabieram się za to by wziąć się porządnie do roboty i systematycznie aktualizować bloga… Zaczął się dla mnie nowy rok akademicki (tak już we wrześniu…) i mam nadzieję, że w ramach relaksu od codziennych obowiązków wezmę się za skrobanie nowych artykułów.


if (gflBitmapHasEXIF(gfl_bitmap)!=GFL_TRUE)
{
string="Plik nie zawiera informacji EXIF";
WxMemo1->AppendText(_TEXT(string));
}
else
{
exif=gflBitmapGetEXIF(gfl_bitmap,0);
unsigned i;
for (i=0;iNumberOfItems;i++)
{
string=exif->ItemsList[i].Name;
string+=" - ";
string+=exif->ItemsList[i].Value;
string+="\n";
WxMemo1->AppendText(_TEXT(string));
}
gflFreeEXIF(exif);
}


Przykładowy skrypt do wysyłki maila z podsumowaniem danych wpisanych w formularzu:

##########################################
#podaj tu odpowiednie dane:
$backurl = "BACK_URL";
$backname = "BACK_NAME";
$mailprog = '/bin/mail';
$youmail = $mail;
##########################################
open (MAIL, "|$mailprog $youmail") || die "Error: $mailprog!\n";
print MAIL ("Do: $youmail\n");
print MAIL ("Od: WMichal\n");
print MAIL ("Temat: Example\n\n");
###
print MAIL "Takie dane podano w formularzu: \n";
print MAIL "Imie $imie \n";
print MAIL "Nazwisko $nazw \n";
close (MAIL);

Zmienne $imie i $nazw możemy sczytać sobie zwykłym splitem… Pomoc znajdziecie w necie ;)