Kategoria: Komputerologia stosowana Strona 1 z 4

VideoEditor 1.0.0.20

o 11 września 2022

VideoEditor 1.0.0.20 to prosty program, będący narzędziem znacznie ułatwiającym pracę ze wspaniałym ffmpeg.

Na ten moment, program umożliwia konwertowanie plików video oraz ich łatwe przycinanie.

Po uruchomieniu programu, należy wejść w ustawienia i zdefiniować ścieżkę do samego ffmpeg.exe. Skąd go wziąć? Można oczywiście go sobie zbudować, ale polecam skorzystać ze strony CODEX FFMPEG, gdzie są dostępne zawsze aktualne binaria.

Następnie polecam przejrzeć zakładkę z presetami kodeków video. Kilka zawarłem jako domyślne. Jeśli umiesz obsługiwać ffmpeg, możesz zdefiniować swoje własne nowe ustawienia.

Po skonfigurowaniu programu, po prostu otwórz plik video, zaznacz punkty przycięcia filmu, jeśli chcesz, wybierz preset konwersji i naciśnij “Convert”. Podajesz nazwę nowego pliku i czekasz na zakończenie konwersji.

Program będę dalej rozwijał i dodawał nowe funkcjonalności. W planach również obsługa różnych języków i instalator.

Dla chętnych, dostępne są źródła na GitHubie.

Program można pobrać tutaj. Miłej zabawy! 🙂

Sound analysis for visualization purposes

przez utak3r

o 6 grudnia 2020

w Komputerologia stosowana, Zrób to sam

Music analysis – part 1

I’m working on a small project (which will be revealed once it reaches some useful stage), and one of the things I need to work on, is to enabling sound visualization.

Visualizing the sound usually incorporates two factors: the amplitudes (which creates the ‘wave’) and a frequencies spectrogram. In this part we will try to do those analysis, however not ready for realtime visualizing yet, this will be made on the next stage – first we need to understand, what’s going on, before we start optimizing it.

We’re using here Python 3.8, together with some additional libraries – see imports section below.

For now we will use simple scipy.io.wavfile library for reading the sound files. For real usage we need to use a better library, as this one is pretty much limited.

In [64]:

import matplotlib.pyplot as plt
from matplotlib import colors as clrs
plt.rcParams['agg.path.chunksize'] = 10000
from scipy.io import wavfile as wav
from scipy.fftpack import fft, fftfreq
import numpy as np
from skimage.util import img_as_int
from skimage.transform import resize
from skimage import io, color, exposure

Reading a file¶

In our analysis we take the mono signal, so we have to convert it, if needed. After loading, we will check the basic parameters of the loaded file, like its length and sample rating.

In [124]:

samplerate, audio = wav.read('test_signal_03.wav')
if audio.ndim > 1:
    audio = np.mean(audio, axis=1) # we want mono!

num_samples = audio.shape[0]
audio_length = num_samples / samplerate
max_value = np.max(audio)

print(f'Audio length: {audio_length:.2f} seconds')
print(f'Audio samples: {num_samples}')
print(f'Max value:{max_value}')

fig, axes = plt.subplots()
axes.plot(np.arange(num_samples) / samplerate, audio)
axes.set_xlabel('Time [s]')
axes.set_ylabel('Amplitude');
plt.show()
plt.close(fig)

Audio length: 146.00 seconds
Audio samples: 6438600
Max value:24741.0

Selecting a fragment¶

For visualization, the whole file won’t give us anything useful. Both the amplitudes and especially the spectrogram, need to reflect some small portion of thw whole. What portion?

Visualization is a video. Video is made of frames. For each frame we need the new portion of data. Fortunately, video framerate is way lower than sound samplerate. We can select a portion of samples that reflect a selected period of time between two frames – current and the next one.

As input parameters, we take the current time in seconds and the target video framerate.

In [129]:

fps = 30
total_frames = int(audio_length * fps)
current_position = 100 # in seconds
current_frame = int(current_position*fps)
number_of_frames = 1 # number of frames to analyse
print(f'Current frame: {current_frame}/{total_frames}')

sample_start = int(current_frame / fps * samplerate)
sample_end = int((current_frame + number_of_frames) / fps * samplerate)
N = sample_end - sample_start
T = 1.0 / samplerate

Current frame: 3000/4380

Performing an analysis¶

We’re ready to perform the analysis. First one, amplitudes, is pretty straightforward, we just read the data from the file.

In [133]:

audio_part = audio[sample_start:sample_end]

For the spectrogram, we perform a 1-D discrete Fourier transform and put the results over the frequencies axis. FFT produces both negative and positive values. If input values are real numbers (as ours are) negative results are exactly same as positive ones (but negative, of course) – hence we can draw only the positive ones.

In [134]:

freqs = fftfreq(N, T)
spectrum = abs(fft(audio_part))[:int(freqs.size/2)]

Now we can plot the figures and see both.

In [136]:

fig=plt.figure(figsize=(10, 3))
axes=[]
axes.append(fig.add_subplot(1, 2, (1, 1)))
axes.append(fig.add_subplot(1, 2, (2, 2)))

axes[0].plot(np.arange(N) / samplerate, audio_part)
axes[0].set_xlabel('Time [s]')
axes[1].plot(freqs[:int(freqs.size/2)], spectrum)
axes[1].set_xlabel('Frequency [Hz]')

fig.tight_layout()    
plt.show()
plt.close(fig)

Color mapping¶

Before we prepare our textures for further use, we will prepare a special color map. We want the values to be represented in the red channel, from pure black to pure saturated red.

In [138]:

reds = plt.get_cmap('Reds', 256)
black_reds = reds(np.linspace(0, 1, 256))
for i in range(256):
    black_reds[i:i+1, :] = np.array([i/256, 0, 0, 1])
map_black_reds = clrs.ListedColormap(black_reds)

The final texture¶

We’re making a 512×512 texture, where top 256 lines are frequencies spectrogram, while bottom 256 lines are amplitudes.

In [141]:

audio_part_img = exposure.rescale_intensity(audio_part, out_range=(-1.0, 1.0))
audio_part_img = np.expand_dims(audio_part_img, axis=0)
audio_part_img = resize(audio_part_img, (256, 512), anti_aliasing=True)

spectrum_img = exposure.rescale_intensity(spectrum, out_range=(0, 100))
spectrum_img = np.expand_dims(spectrum_img, axis=0)
spectrum_img = resize(spectrum_img, (256, 512), anti_aliasing=True)

fig=plt.figure(figsize=(5.12, 5.12), dpi=100)
fig.subplots_adjust(hspace=0)
fig.tight_layout()
axes=[]
axes.append(fig.add_subplot(2, 1, 1))
axes[0].set_axis_off()
axes[0].margins(0)
axes.append(fig.add_subplot(2, 1, 2))
axes[1].set_axis_off()
axes[1].margins(0)

axes[0].imshow(spectrum_img, cmap=map_black_reds)
axes[1].imshow(audio_part_img, cmap=map_black_reds)

plt.savefig("test_sound.png", dpi=fig.dpi)
plt.show()
plt.close(fig)

Our resulting texture is exactly what we need for sound visualization. The problem is, producing it takes too much time and cannot be used for realtime usage. This problem we’ll solve next time.

Pobieranie obrazów z Instagrama – aktualizacja

przez utak3r

o 8 maja 2020

w Komputerologia stosowana

Niedawno zorientowałem się dopiero 😉 że mój skrypt do pobierania obrazów z Instagrama już nie działa z powodu zmian w systemie Instagram. Zaktualizowałem więc skrypt i można go pobrać i zainstalować w TamperMonkey. Uwaga, skrypt działa na stronie postu, nie na stronie kolekcji. Aby przejść do strony postu z podglądu zdjęcia, należy wybrać opcję “Go to post”.

W efekcie, pod zdjęciem powinien pojawić się link do obrazu.

Pobieranie obrazów z Instagrama

przez utak3r

o 6 stycznia 2018

w Komputerologia stosowana

Czasem zachodzi potrzeba pobrania zdjęcia z Instagrama w pełnej dostępnej rozdzielczości. Wbrew pozorom jest to dość proste.

W zasadzie, jedyne, co należy wykonać, to odnaleźć wpis meta nazywający się “og:image”:

<meta property="og:image" content="https://serwer/zdjecie.jpg" />

Zawartość właściwości “content” to link do zdjęcia w pełnej rozdzielczości.

Jeśli jednak chcesz pobrać większą ilość zdjęć, bądź robisz to dość często, przyda się mała automatyzacja. Napisałem do tego celu mały skrypt, który działa pod kontrolą TamperMonkey. Wszystko, co ten skrypt robi, to na dole strony (pomiędzy zdjęciem a stopką) wstawia link do zdjęcia.

Po zainstalowaniu TamperMonkey, jeśli go jeszcze nie masz, wystarczy zainstalować ten skrypt. Uwaga, skrypt działa na stronie postu, nie na stronach kolekcji. Aby przejść do strony postu z podglądu zdjęcia, należy wybrać opcję “Go to post“.

Selektor koloru z trybem float

przez utak3r

o 11 sierpnia 2016

w Fotografia i grafika, Komputerologia stosowana, Zrób to sam

Jest wiele selektorów kolorów online. Większość zwraca wyniki w wartościach RGB z zakresu <0..255>, w zapisie szesnastkowym, oraz HSL. Jednak brakuje w nich wszystkich jeszcze jednej formy podawania wyników: w formie wartości RGB w zakresie <0..1>, używanym w niektórych programach, zwłaszcza 3D. Osobiście często używam POV-Raya i za każdym razem muszę używać kalkulatora, aby przeliczyć wszystkie trzy wartości na odpowiedni zakres.

Początkowo miałem zamiar napisać malutki programik do tego celu, ale stwierdziłem, że wersja on-line będzie wygodniejsza w użyciu. Nie jest to żadne rocket science 😉 ale swoje zadanie spełnia. Może w przyszłości jakoś go rozbuduję i usprawnię, ale… nie obiecuję 😉

Jeszcze jedna uwaga… poniższe nie działa z IE… 🙁

Wybierz kolor:

Hex:

R:
G:
B:

RGB jako floaty:

Może się komuś przyda – mi na pewno 🙂

Pluginy aplikacji Qt5

przez utak3r

o 12 lipca 2016

w Komputerologia stosowana

Tworzenie systemu pluginów aplikacji działającej na różnych systemach wymagało zawsze wielokrotnej implementacji tego samego – dla każdego systemu oddzielnie, głównie z powodu sposobu dynamicznego ładowania bibliotek. W Qt jednak jest inaczej – framework ten udostępnia bardzo sprawnie działający system pluginów.

Na początek zdefiniujmy interfejs (API):

#ifndef DESIGNLAYER_API_H
#define DESIGNLAYER_API_H

#include 
#include 

namespace apophysis
	{		
	class DesignLayerAPI
		{
		public:
			virtual ~DesignLayerAPI() {};
			virtual QString getName() = 0;
		};
	}

#define DesignLayerAPI_iid "org.apophysis.DesignLayerAPI"

Q_DECLARE_INTERFACE(apophysis::DesignLayerAPI, DesignLayerAPI_iid)

#endif // DESIGNLAYER_API_H

Widzimy tu wirtualną klasę, definiującą metodę getName(). Po definicji API, następuje definicja interfejsu, po którym Qt będzie rozpoznawać nasze pluginy, implementujące te API.

Czas na plugin. Deklarujemy klasę implementującą API:

#ifndef DESIGNLAYER_IMAGE_H
#define DESIGNLAYER_IMAGE_H

#include 
#include 
#include 

class designLayerImage : public QObject, apophysis::DesignLayerAPI
	{
	Q_OBJECT
		Q_PLUGIN_METADATA(IID "org.apophysis.DesignLayerAPI" FILE "designLayerImage.json")
		Q_INTERFACES(apophysis::DesignLayerAPI)

	public:
		designLayerImage();
		QString getName() Q_DECL_OVERRIDE;
	private:
		QString theName;
	};

#endif // DESIGNLAYER_IMAGE_H

Oprócz deklaracji metod zadeklarowanych w interfejsie, widzimy tu jeszcze jedną rzecz: definicję metadanych. Po co to? Metadane pluginu można odczytać bez faktycznego ładowania biblioteki. Zapisujemy je w pliku JSON, np:

{
"type"			:	"Layer",
"name"			:	"Image layer plugin",
"shortname"		:	"ImageLayer",
"version"		:	"0.1",
"author"		:	"Apophysis internal",
"description"	:	"Used mainly for backgrounds: solid colour, gradients, images, etc."
}

Właściwa implementacja jest oczywista, żadnej magii tu nie ma:

#include "designLayerImage.h"

designLayerImage::designLayerImage()
	:
	theName(QLatin1Literal("Unnamed image layer"))
	{
	}

QString designLayerImage::getName()
	{
	return theName;
	}

OK, mamy plugin. Jak go użyć? Na szczęście, to również jest proste (i przenośne! Na pewno działa bez zmian pod Windows i Linux, pod OSX nie sprawdzałem).

Najpierw sprawdzimy w działaniu system metadanych. Załóżmy, że pluginy mamy w podkatalogu plugins (niespodzianka!):

#include 
#include 

void listPlugins()
	{
	QDir pluginsDir(qApp->applicationDirPath());
	pluginsDir.cd(QLatin1Literal("plugins"));
	foreach(QString fileName, pluginsDir.entryList(QDir::Files, QDir::Name))
		{
		QString libExt;
#if defined(Q_OS_WIN)
		libExt = QLatin1Literal("dll");
#elif defined(Q_OS_MAC)
		libExt = QLatin1Literal("bundle");
#elif defined(Q_OS_LINUX)
		libExt = QLatin1Literal("so");
#endif
		if (QFileInfo(fileName).suffix().toLower() == libExt)
			{
			QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(fileName));
			qDebug() << "File:" << fileName;
			QJsonObject jsonMetaData = pluginLoader.metaData().value(QLatin1Literal("MetaData")).toObject();
			qDebug() << jsonMetaData.value(QLatin1Literal("type")).toString();
			qDebug() << jsonMetaData.value(QLatin1Literal("name")).toString();
			qDebug() << jsonMetaData.value(QLatin1Literal("shortname")).toString();
			qDebug() << jsonMetaData.value(QLatin1Literal("version")).toString();
			qDebug() << jsonMetaData.value(QLatin1Literal("author")).toString();
			qDebug() << jsonMetaData.value(QLatin1Literal("description")).toString();
			}
		}
	}

W zasadzie moglibyśmy się obejść bez sekcji sprawdzania rozszerzenia plików, ale używam tego w razie, gdyby w katalogu były jeszcze jakieś inne pliki (ot, chociażby PDB).

OK, czas na crème de la crème, czyli stworzenie instancji klasy zaimplementowanej w pluginie:

void apophysis::Design::addLayer(const QString & aLayerType)
	{
	QDir pluginsDir(qApp->applicationDirPath());
	pluginsDir.cd(QLatin1Literal("plugins"));
	foreach(QString fileName, pluginsDir.entryList(QDir::Files, QDir::Name))
		{
		QString libExt;
#if defined(Q_OS_WIN)
		libExt = QLatin1Literal("dll");
#elif defined(Q_OS_MAC)
		libExt = QLatin1Literal("bundle");
#elif defined(Q_OS_LINUX)
		libExt = QLatin1Literal("so");
#endif
		if (QFileInfo(fileName).suffix().toLower() == libExt)
			{
			QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(fileName));
			QString plugintype = pluginLoader.metaData().value(QLatin1Literal("MetaData")).toObject().value(QLatin1Literal("type")).toString();
			QString pluginshortname = pluginLoader.metaData().value(QLatin1Literal("MetaData")).toObject().value(QLatin1Literal("shortname")).toString();
			if ((plugintype == QLatin1Literal("Layer")) && (pluginshortname == aLayerType))
				{
				QObject *plugin = pluginLoader.instance();
				if (plugin)
					{
					apophysis::DesignLayerAPI *layer = qobject_cast(plugin);
					if (layer)
						theLayers.append(layer);
					}
				}
			}
		}
	}

Jak widać, zarówno tworzenie, jak i używanie pluginów w tym systemie jest trywialne - i jest całkowicie przenośne.

Happy coding!

Git a automatyczne budowanie Jenkinsem

przez utak3r

o 15 kwietnia 2016

w Komputerologia stosowana

Do tej pory, na cele Continuous Integration, w Jenkinsie miałem ustawione sprawdzanie repozytorium Git (opcja SCM polling) co 15 minut. W zasadzie to działało, ale bywały momenty, że owe 15 minut było okresem zbyt długim. Można oczywiście (nikt nie broni…) ustawić okres sprawdzania na * * * * *, czyli sprawdzanie co minutę, ale to również nie jest dobre rozwiązanie, z oczywistych powodów. Dlatego też postanowiłem powiesić akcję odpytywania Gita przez Jenkinsa na haku, żeby automagicznie każdy push od developera powodował start Jenkinsa.

Oczywiście, Jenkins musi być wyposażony we wtyczkę Git.

Zaczynamy od próby ręcznego zdalnego wywołania Jenkinsa. Otóż wtyczka Git otwiera takową drogę właśnie na okoliczność notyfikacji o nowym commicie. Jak czytamy w dokumentacji wtyczki, można powiadomić Jenkinsa o konkretnym commicie, ale ja na cele Continuous Integration i tak chcę pobrać najnowsze w danej chwili źródła, aby sprawdzić integrację poszczególnych prac właśnie. Dlatego użyjemy najprostszej formy wywołania wtyczki, która spowoduje wymuszenie odpytania repozytorium o zmiany.

Na początek, w konfiguracji zadania Jenkinsowego, usuwamy wszelkie terminarze, jakie mieliśmy – ale samą opcję Poll SCM musimy pozostawić włączoną (ale pustą):

Jenkins SCM Polling

Następnie, będąc na serwerze gitowym, instalujemy pakiet curl, jeśli go tam jeszcze nie ma. Gdy już go mamy, wywołujemy testową komendę:

curl http://moj.jenkins.com:8080/git/notifyCommit?url=git@moj.git.com:WspanialeRepo

Ścieżka do repozytorium powinna być dokładnie taka sama, jaką podajemy przy jego klonowaniu. Jeśli wszystko pójdzie dobrze, przeczytamy, że zostało zlecone odpytanie repozytorium. Sprawdzamy w logach Jenkinsa Git Polling Log, czy rzeczywiście tak było.

Jeśli wszystko zadziałało, czas ten proces zautomatyzować. Aby wywołać jakąś akcję po każdym pushu od developera, musimy zdefiniować hak post-receive. W katalogu repozytorium znajduje się podkatalog hooks. Tworzymy nowy plik i nadajemy mu właściwe uprawnienia:

touch post-receive
chown git:git post-receive
chmod 775 post-receive

i edytujemy go:

#!/bin/sh
curl http://moj.jenkins.com:8080/git/notifyCommit?url=git@moj.git.com:WspanialeRepo

Od tej pory, za każdym razem, gdy developer zrobi pusha, Jenkins wykona swoją robotę 🙂 A my cieszymy się z Continuous Integration 😉

Android – dobór koloru tekstu pod kolor tła

przez utak3r

o 16 listopada 2015

w Komputerologia stosowana, Zrób to sam

Gdy dodajemy tekst na jakimś tle, którego kolor ustawiany jest dynamicznie, mamy problem: jaki kolor tekstu? Czarny czy biały?

Aby rozwiązać ten problem, należy sprawdzić, jak jasny jest kolor tła. Problem w tym, że wpływ poszczególnych komponentów RGB na ogólną jasność jest różna, stąd trzeba ową jasność policzyć uwzględniając tę zasadę. Ja użyłem dość popularnej w internecie formuły – i spisuje się naprawdę dobrze.

    /**
     * Find the right color of the text, depending on the color of the background.
     * @param aColor Color, to which we're adjusting by contrast.
     * @return Black or white color.
     */
    public int getBlackOrWhite(int aColor)
    {
        int red = (aColor >> 16) & 0xFF;
        int green = (aColor >> 8) & 0xFF;
        int blue = (aColor >> 0) & 0xFF;
        int result = 0;
        if (((double)red*0.299 + (double)green*0.587 + (double)blue*0.114) > 186)
            result = Color.BLACK;
        else
            result = Color.WHITE;
        return result;
    }

Parametrem wejściowym jest kolor tła, wartość zwracana to kolor czarny lub biały. Formuła doboru wygląda na dobrą, bo spośród tych kolorów, które przetestowałem, wybór: czarny-biały zawsze był trafny, stąd mogę ją z czystym sumieniem polecić – co też czynię.

Zmiana parametrów ekranu z C++ pod Windows 7

przez utak3r

o 7 października 2015

w Komputerologia stosowana

Czasem zachodzi potrzeba zmiany ustawień monitora z poziomu aplikacji. Czasem chodzi nam o rozdzielczość, czasem o odświeżanie. Mi akurat chodziło o odświeżanie – aplikacja wyświetla materiał video w różnych formatach i potrzebowałem dostosować monitor do materiału, aby osiągnąć jak najlepszą synchronizację.

Moja aplikacja jest w Qt (a jakże), więc zaczynam od sprawdzenia, na którym monitorze jest wyświetlona moja aplikacja:

int monitor = QApplication::desktop()->screenNumber(ui.centralWidget);

Aby napisać działającą poprawnie metodę zmieniającą parametry wyświetlania pod Windows 7, musimy podać dokładną nazwę urządzenia. Podawanie NULL, która wg dokumentacji MSDN powinna zadziałać na domyślnym urządzeniu, pod Windows 7 kończy się błędem niepoprawnego parametru. Dlatego najpierw listujemy wszystkie dostępne urządzenia – i jeśli jest to nasze urządzenie, pobieramy jego aktualne ustawienia i modyfikujemy je:

DEVMODE winMode;
DISPLAY_DEVICE displayDevice;
memset(&displayDevice, 0, sizeof(DISPLAY_DEVICE));
displayDevice.cb = sizeof(displayDevice);
DWORD iDevNum = 0;
if (EnumDisplayDevices(NULL, iDevNum, &displayDevice, EDD_GET_DEVICE_INTERFACE_NAME))
{
	if (EnumDisplaySettings(displayDevice.DeviceName, ENUM_CURRENT_SETTINGS, &winMode) != 0)
	{
		winMode.dmPelsWidth = aWidth;
		winMode.dmPelsHeight = aHeight;
		winMode.dmDisplayFrequency = aFreq;
		ChangeDisplaySettingsEx(displayDevice.DeviceName, &winMode, NULL, CDS_NORESET | CDS_UPDATEREGISTRY, NULL);
	}
}

Wg dokumentacji, po użyciu ChangeDisplaySettingsEx powinniśmy jeszcze spowodować rozesłanie komunikatu do wszystkich aplikacji, wywołując ją jeszcze raz w ten sposób:

ChangeDisplaySettings(NULL, 0);

Składając wszystko do kupy, napisałem sobie metodę, która bierze parametry ustawień (rozdzielczość i odświeżanie) i sprawdza, czy podałem wartość większą od zera (gdybym chciał ustawić tylko niektóre z tych parametrów):

//! Change display (monitor) settings. If you don't want to change any of the values, pass 0 for them.
static bool setCurrentDisplayMode(int aWidth, int aHeight, int aFreq, int aDisplay = 0);

bool sysWindowsApi::setCurrentDisplayMode(int aWidth, int aHeight, int aFreq, int aDisplay)
{
	bool ret = false;
	DEVMODE winMode;
	DISPLAY_DEVICE displayDevice;
	memset(&displayDevice, 0, sizeof(DISPLAY_DEVICE));
	displayDevice.cb = sizeof(displayDevice);
	if (EnumDisplayDevices(NULL, aDisplay, &displayDevice, EDD_GET_DEVICE_INTERFACE_NAME))
	{
		if (EnumDisplaySettings(displayDevice.DeviceName, ENUM_CURRENT_SETTINGS, &winMode) != 0)
		{
			if (aWidth > 0) winMode.dmPelsWidth = aWidth;
			if (aHeight > 0) winMode.dmPelsHeight = aHeight;
			if (aFreq > 0) winMode.dmDisplayFrequency = aFreq;
			if (ChangeDisplaySettingsEx(displayDevice.DeviceName, &winMode, NULL, CDS_NORESET | CDS_UPDATEREGISTRY, NULL) == DISP_CHANGE_SUCCESSFUL)
			{
				ChangeDisplaySettings(NULL, 0);
				ret = true;
			}
		}
	}
	return ret;
}

Z głównej aplikacji wywołuję ją np. tak:

sysWindowsApi::setCurrentDisplayMode(0, 0, 60, QApplication::desktop()->screenNumber(ui.centralWidget));

powoduje to zmianę tylko częstotliwości odświeżania, pozostawiając rozdzielczość bez zmian – i tylko na tym monitorze, na którym znajduje się nasza aplikacja.

Bend of Joy – fraktal 3D

przez utak3r

o 5 października 2015

w Komputerologia stosowana, Różności, Rozrywka

Dawno nic nie pisałem… postaram się to nadrobić 🙂

Przez ostatnie dwa tygodnie wieczorami pracowałem nad nową animacją – fraktalem 3D. Poniżej możecie sobie obejrzeć efekt. Dla najlepszego odbioru, przejdźcie na stronę vimeo, żeby obejrzeć ten filmik w jakości HD – oczywiście, na pełnym ekranie.

Muzyka jest autorstwa Scotta Althama.

Zawartość niedostępna.
Wyraź zgodę na używanie plików cookie.