11 lipca 2016

Gif-y w wysokiej jakości

Znakomity wpis na temat uzysykiwania gif-ów wysokiej jakości:
Moja stara wersja korzystała ze zbyt wielu kroków. W dodatku nie mogłem zmusić programu convert do ustawienia mniejszego opóźnienia pomiędzy ramkami niż 10. W przykładzie poniżej zrezygnowałem ze skalowania.
ffmpeg -i video.avi -r 10 -f image2pipe -vcodec ppm - | convert -delay 10 -loop 0 - gif:- | convert -layers Optimize - output.gif
Lepsza wersja (także bez skalowania). Kroków jest na tyle dużo, że zamknąłem wszystko w jednym skrypcie, ale convert nie jest już wykorzystywany, ponieważ sam ffmpeg dobrze sobie radzi z tworzeniem plików tego formatu:
#!/bin/sh

palette="palette.png"
video="video.avi"

# filters="fps=15,scale=320:-1:flags=lanczos"
filters="fps=25"

mogrify -crop 384x362+8+30 +repage $(ls -v *.png)
ffmpeg -r 100 -f image2 -i img-%3d.png $video
ffmpeg -v warning -i $video -vf "$filters,palettegen" -y $palette
ffmpeg -v warning -i $video -i $palette -lavfi "$filters [x]; [x][1:v] paletteuse" -y output.gif
Obraz jest znacznie płynniejszy.

2 lipca 2016

goto criticism

Przez lata przyjmowałem za pewnik słowa, że "nie należy korzystać z goto" i tak właściwie, to nie pamiętam, żebym to kiedyś zrobił, ba nawet nie miałem okazji widzieć takiego kodu zbyt często. Takie też jest moje wewnętrzne przekonanie. Program korzystający z takiego wyrażenia, nie byłby przyjemny w utrzymaniu. Właściwie więc, po co te mechanizmy w językach nadal istnieją? Wyjątkiem kodu, który miałem okazję analizować były funkcje kryptograficzne, których działanie było zawiłe samo w sobie. Postanowiłem jednak sięgnąć do źródeł całego trendu. I tutaj, nie jest już tak czarno-biało. Ze spostrzeżeń Edsgera Dijkstry ("za") i Donalda Knutha ("przeciw") stworzono dogmat, a sami autorzy zgadzają się, że dla pewnych problemów optymalizacyjnych skorzystanie z goto jest konieczne, chociaż w większości przypadków będzie to symptom źle zaprojektowanego kodu. Odbiegając od specyficznych przypadków dotyczących małej części całej aplikacji, sam Knuth miał jednak nadzieję, że powstaną w przyszłości mechanizmy umożliwiające tłumaczenie wysokopoziomowego kodu, na niskopoziomowy, bez wymogu korzystania z tego wyrażenia. Po 40 latach kompilatory już całkiem nieźle sobie radzą, ale to jeszcze kiedyś sprawdzę.

26 czerwca 2016

Rachunek wektorowy i książki

Kilka przydatnych książek, które znalazłem na wikibooks, ucząc się fizyki. Niektórym brakuje rozdziałów, ale i tak jestem pod wrażeniem. Warto się temu przyjrzeć, jako coś dodatkowego do klasycznych podręczników:
Coś z rachunku wektorowego - wirujący wektor, do którego stworzenia potrzebna jest macierz obrotu [1], [2].
Program koduj macierze przekształceń właściwą dla dwóch wymiarów:
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from visual import *
import ImageGrab

display(x=0, y=0, width=400, height=400, userzoom=False,
        center=(0, 0, 1), foreground=(0, 0, 0), background=(1, 1, 1))

ar = arrow(pos=(0, 0, 0), axis=(10, 0, 0), shaftwidth=0.3)

total_angle = 0
angle = 0.1 / (2 * math.pi)
frame = 0
while total_angle <= 2 * math.pi:
    rate(100)

    nx = ar.axis.x * math.cos(angle) - ar.axis.y * math.sin(angle)
    ny = ar.axis.x * math.sin(angle) + ar.axis.y * math.cos(angle)
    nz = 0
    ar.axis = (nx, ny, nz)

    file_name = 'img-' + '{fr:03d}'.format(fr=frame) + '.png'
    frame += 1

    im = ImageGrab.grab((0, 0, 400, 400))
    im.save(file_name)

    total_angle += angle
    print total_angle

exit()

24 czerwca 2016

[python] matplotlib - rysowanie wykresów

Kolejna biblioteka, którą zacząłem się bawić, służąca do rysowania wykresów: matplotlib. Bardzo przyjema dokumentacja, z dużą liczbą przykładów. Dla testu wykreśliłem pochodną i całkę oznaczoną dla funkcji:
$$ f(x) = -2x^{3} - 4x^{2} + 8x + 1 \\
f^\prime(x) = -6x^{2} - 8x + 8 \\
F(x) = \int f(x) dx = -\frac{1}{2}x^{4} - \frac{4}{3}x^{3} + 4x^{2} + x + C \\
F(-3) - F(1) = \int_{-3}^{1} f(x) dx = \left(-\frac{1}{2}x^{4} - \frac{4}{3}x^{3} + 4x^{2} + x + C\right)\Biggr|_{-3}^{1} $$
Kod programu:
#!/usr/bin/env python
# -*- coding: utf-8 -*-


import numpy as np
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt


def main():
    red_patch = mpatches.Patch(color='red', label=r'$f(x)$ - moja funkcja')
    blue_patch = mpatches.Patch(color='blue', label=r'$f^\prime(x)$ - obliczone numerycznie')
    cyan_patch = mpatches.Patch(color='cyan', label=r'$f^\prime(x)$ - obliczone recznie')
    green_patch = mpatches.Patch(color='green', label=r"$\int_{-3}^{1}f(x)$ - obliczone numerycznie")

    plt.legend(handles=[red_patch, blue_patch, cyan_patch, green_patch], loc='lower right')

    x = np.linspace(-4, 2, 10)
    x_dense = np.linspace(-4, 2)

    y_f = func(x)
    plt.plot(x, y_f, 'red', linewidth=2)

    y_deriv = derivative(func, x)
    plt.plot(x, y_deriv, 'blue', linewidth=2)

    y_own_deriv = own_deriv_func(x_dense)
    plt.plot(x_dense, y_own_deriv, 'cyan', linewidth=1)

    summo1 = definite_integral(func, a=-3, b=1)
    summo2 = own_integral_func(a=-3, b=1)
    print 'Całka oznaczona, numerycznie: %f' % summo1
    print 'Całka oznaczona, ręcznie: %f' % summo2

    current_figure = plt.gcf()
    current_figure.savefig('rachunek_rozniczkowy.png')

    plt.show()


def func(x):
    return -2 * (x ** 3) - 4 * (x ** 2) + (8 * x) + 1


def own_deriv_func(x):
    return -6 * (x ** 2) - 8 * x + 8


def own_integral_func(a, b):
    F = lambda x: -(1/2.0) * (x ** 4) - (4/3.0) * (x ** 3) + 4 * (x ** 2) + x
    return F(b) - F(a)


def derivative(fun, x):
    h = 0.2 # dx
    return (fun(x + h) - fun(x)) / h


def definite_integral(fun, a, b):
    axes = plt.gca()
    dx = (b - a) / 20.0

    summo = 0
    x = a
    while x < b:
        axes.add_patch(mpatches.Rectangle(xy=(x, 0), width=dx, height=fun(x), facecolor='green'))
        summo += dx * fun(x)
        x += dx

    return summo


if __name__ == '__main__':
    main()
Wynik:
Całka oznaczona, numerycznie: -26.080000
Całka oznaczona, ręcznie: -25.333333

19 czerwca 2016

MathJax - Hello World

Test MathJax do zapisywania formuł matematycznych.
Niech \(f\) będzie funkcją ciągła zdefiniowaną dla \( a \leq x \leq b \). Przedział \( [a, b] \) będzie podzielony \( n \) podprzedziałów o równej długości wynoszącej \( \Delta x = \frac{(b - a)}{n} \), tak że \(x_{0} = a \), a \( x_{n} = b \), będącymi końcami tych podprzedziałów i niech \( x_{1}^*, x_{2}^*,... , x_{n}^* \) będą dowolnymi punktami próbkującymi w tych przedziałach, \( x_{i}^* \in [x_{i-1}, x_{i}] \). Wówczas całkę oznaczoną z funkcji \( f \) w przedziale od \( a \) do \( b \) oznaczamy i definiujemy jako:
$$ \int_{a}^{b} f(x) dx = \lim_{n\to\infty} f(x)\sum_{i=1}^{n} f(x_{i}^*) \Delta x $$

3 maja 2016

{Machine Learning} Recipes

Google Developers na swoim kanale, rozpoczął serię filmów traktujących o nauczaniu maszynowym. Krótka i ciekawa forma, bardzo mi się podoba.



Odrobinę przerobiony przykład "Hello Wrold"
# http://scikit-learn.org/stable/
# https://www.continuum.io/
# sudo apt-get install python-scikits-learn

from sklearn import tree

# Collect training data
SMOOTH = 1
BUMPY = 0
APPLE = 0
ORANGE = 1

features = [[140, SMOOTH], [130, SMOOTH], [150, BUMPY], [170, BUMPY]]
labels = [APPLE, APPLE, ORANGE, ORANGE]

# Train classifier
clf = tree.DecisionTreeClassifier()
clf = clf.fit(features, labels)

# Make predictions
result = clf.predict([[160, 0]])

if result[0] == APPLE:
    print 'APPLE'
elif result[0] == ORANGE:
    print 'ORANGE'
else:
    'Result unknown'
Wynik:
ORANGE