Autonumerowanie równań w Word 2010

Tworzymy tabelę z jednym wierszem i dwoma kolumnami. Dostosowujemy wielkość pierwszej kolumny tak by była jak największa – w niej będzie się znajdować nasze równanie. W drugiej kolumnie będzie znajdować się numer równania. Klikamy Ctrl+F9 i wpisujemy {SEQ Equation \* MERGEFORMAT}, dodatkowo możemy to wyrażenie otoczyć nawiasami „( )”. Klikamy Alt+F9 i pojawia się numerek równania. Aby w tekście odwołać się do danego równania zaznaczamy je i wybieramy opcję Zakładka w menu Wstawianie, podajemy nazwę zakładki – przykładowo „r1″. Tam gdzie chcemy dodać odwołanie klikamy Ctrl+F9 i wpisujemy {REF r1 \* MERGEFORMAT} a następnie Alt+F9. Jeżeli chcemy dokonać aktualizacji numeracji w całym dokumencie: Ctrl+A, F9.

Seam Carving

Zachęcam wszystkich do oglądnięcia filmiku: http://vimeo.com/1347424

Problem z kropką i przecinkiem w Matlabie

Jak w prosty sposób poradzić sobie ze zmianą domyślnego separatora dziesiętnego z „angielskiej” kropki na „polski” przecinek jeżeli zamiana ręczna nie wchodzi w grę?

Poniżej zamieszczam rozwiązanie:

fid =fopen('stats_dots.txt','r');
fid2 =fopen('stats_coma.txt','w'); 

A =[]; 

while(~feof(fid))
    s = fgetl(fid);
    cidx = find(s=='.'); %znajdz wszystkie kropki
    s(cidx)=','; %zamien je na przecinki 

    txt=sprintf('%s\n',s); 

    fwrite(fid2,txt);
end 

fclose(fid);
fclose(fid2);

Zapis składowych YUV do pliku

Ostatnio zajmuję się zagadnieniem konwersji między systemami PAL<->NTSC<->SECAM. Pracuję na składowych Y,U,V obrazu. Spotkałem się z problemem jak zapisać sekwencję danych (fragment filmu) w nich przechowywane do pliku *.YUV. Oto moje autorskie rozwiązanie:

%***************************************************
% Function to store Y, U, V data into a *.YUV file
%
% To use this funtion, call it with:
% writeyuv(y,u,v,filename,type,frames)
% y,u,v - YUV components (three 2D or 3D arrays)
% type - 1: append, 0: overwrite
% frames - number of frames to save in file
%
% coded by Michal Walus
% wmichal.wordpress.com
%***************************************************

function []=writeyuv(y,u,v,filename,type,frames)

if type == 1
    fid = fopen(filename,'ab');
else
    fid = fopen(filename,'w');
end

if nargin==5
    fwrite(fid,y','uint8');
    fwrite(fid,u','uint8');
    fwrite(fid,v','uint8');
elseif nargin==6
    for i=1:1:frames
        yy=y(:,:,i); uu=u(:,:,i); vv=v(:,:,i);

        fwrite(fid,yy','uint8');
        fwrite(fid,uu','uint8');
        fwrite(fid,vv','uint8');
    end
end

clear y u v yy uu vv

fclose(fid);

drand48();

Wczoraj stanąłem przed nieoczekiwanym problemem – kolega podesłał mi projekt, który pisał pod ubuntu i miałem go skompilować pod windowsem. Wydaje się, że nie powinno być z tym problemów… ale jednak były ;] . Wykorzystanie funkcji drand48() , która jest obsługiwana pod linuksem, nie było dobrym pomysłem – windows (w stdlib.h)  nie przewiduje dla niej wsparcia. Jedynie co mamy do dyspozycji to rand(). Jak sobie poradzić z tym problemem? Po pół godziny googlowania znalazłem rozwiązanie:

drand48() można zastąpić przez (double(rand()) / RAND_MAX)

Slide and Pin Joint Demo Step by Step tutorial

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…

podróże

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 personalized map of europe

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

Delaunay triangulation, Delaunay empty circles

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/

rysowanie w niezależnych oknach

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.

triangulacja Delaunay

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