Zuerst die Bilder mit ImageMagick zuschneiden (Originalauflösung 4288x2848), damit sie ein Seitenverhätlnis von 16:9 bekommen (4288x2412).
mogrify -verbose -shave '0x218' *.jpg
dann mit ffmpeg umwandeln
ffmpeg -i musik.mp3 -f image2 -r 10 -i %04d.jpg -b 10000000 -r 25 -s hd720 -vcodec mpeg4 -f mp4 -acodec libfaac -ab 320000 -vframes 800 output.mp4
Workaround in English: http://github.com/thoughtbot/paperclip/issues#issue/54/comment/276013
Wenn du beim Hochladen von Bildern mit Paperclip unter Windows diese Fehlermeldung (oder eine Ähnliche) bekommst:
Data C:/Users/Ben/AppData/Local/Temp/stream,1224,0.jpg is not recognized by the 'identify' command.
dann öffne [Paperclip Verzeichnis]/lib/paperclip.rb, suche (in meiner Version Zeile 133)
option.split("'").map{|m| "'#{m}'" }.join("\\'")
und ersetze sie mit
option.split("'").map{|m| "\"#{m}\""}.join("\\'")
Danach den Server neustarten und dann sollte es funktionieren.
There was a time, when I shared a blog. This post was written by Stephan. See all blogpost from him or stalk him on github.
Das Open Source Projekt OpenVIDIA : Parallel GPU Computer Vision beschäftigt sich mit Nvidias CUDA-Technology und Computer Vision. U.a gibt es die Beispielanwendung "CUDABOF" (CUDA Bayesian Real-time Optical Flow), in der es um Bewegungserkennung geht (mehr über die Theorie könnt ihr hier erfahren). Die CUDA-GPU soll dabei die Bewegungsberechnungen unterstützen.
Das Programm konnte mit der gegebenen Makefile aber nicht erfolgreich kompiliert werden. Darum gibt es hier eine angepasste Makefile für ein 32Bit System:
###
# Configuration
###
NVIDIA_INSTAL_DIR=$(HOME)/NVIDIA_GPU_Computing_SDK/C
CUDA_BASE=/usr/local/cuda
###
# You shouldn't have to change down from here
###
INCLUDE:= -I. \
-I/usr/local/cuda/include \
-I$(NVIDIA_INSTAL_DIR)/common/inc/ \
-I$(CUDA_BASE)/include
CXXFLAGS= -fno-strict-aliasing -DUNIX -O0 -ggdb $(shell pkg-config --cflags opencv)
LDFLAGS= -L$(NVIDIA_INSTAL_DIR)/lib \
-L$(NVIDIA_INSTAL_DIR)/common/lib \
-L$(NVIDIA_INSTAL_DIR) \
-L$(CUDA_BASE)/lib \
-lcutil_i386 -lcudart -lGL -lGLU -lglut -lGLEW \
$(shell pkg-config --libs opencv) \
NVCCFLAGS = --compile --host-compilation 'C++' \
--compiler-options -fno-strict-aliasing \
--compiler-options -ggdb $(INCLUDE) \
--compiler-bindir=/usr/bin/gcc-4.3
EXEC = test01 \
test02_spatialDerivs \
test03_gaussianPyramid \
test04_opticalFlow
all: $(EXEC)
VERBOSITY:=@
ECHO_COMPILING=@echo "compiling $@"
######
#
# COMPILATION OF OBJECT FILES
#
######
%.o: %.cu %.hpp CUDABOF.hpp
$(ECHO_COMPILING)
$(VERBOSITY)nvcc $(NVCCFLAGS) $<
%.o: %.cpp *.hpp
$(ECHO_COMPILING)
$(VERBOSITY)g++ -c $< $(INCLUDE) $(CXXFLAGS)
######
#
# TESTS
#
######
TEST_BUILD_RULE= $(VERBOSITY)g++ -fPIC -o $@ $^ $(LDFLAGS)
test01: test01_kernel.o test01.o Utils.o MathUtils.o
$(ECHO_COMPILING)
$(TEST_BUILD_RULE)
test02_spatialDerivs: test02_spatialDerivs.o Utils.o MathUtils.o BayesianOpticalFlowKernels.o
$(ECHO_COMPILING)
$(TEST_BUILD_RULE)
test03_gaussianPyramid: test03_gaussianPyramid.o Utils.o MathUtils.o GaussianPyramidKernel.o
$(ECHO_COMPILING)
$(TEST_BUILD_RULE)
test04_opticalFlow: test04_opticalFlow.o Utils.o MathUtils.o OpticalFlow.o BayesianOpticalFlowKernels.o GaussianPyramidKernel.o
$(ECHO_COMPILING)
$(TEST_BUILD_RULE)
######
#
# TESTS
#
######
clean:
rm -f *.o $(EXEC)
``
<strong>
Anmerkung:
Falls ihr bei der CUDA-Installation abweichende Pfade genommen habt (vor allem beim CUDA-SDK, das standardmäßig im Home-Ordner des Nutzers installiert wird), müsst ihr die Pfade natürlich anpassen (über die Variablen NVIDIA_INSTAL_DIR und CUDA_BASE am Anfang der Datei).
</strong>
Folgende Bibliotheken/Pakete sind zudem nötig:
<ol>
<li>OpenCV: libcv-dev</li>
<li>libhighgui-dev</li>
<li>Compiler g++ und gcc in Version 4.3 (mit Version 4.4 lässt sich dieses Programm und die Nvidia-Bespiele zu Cuda nicht kompilieren)</li>
</ol>
Nach dem ihr "make" erfolgreich ausgeführt habt, könnt ihr folgende Programme in der Konsole ausführen:
<ul>
<li>./test01</li>
<li>./test02_spatialDerivs (Aufruf mit einem Bild als Parameter)</li>
<li>./test03_gaussianPyramid (Aufruf mit einem Bild als Parameter)</li>
<li>./test04_opticalFlow</li>
</ul>
"test04_opticalFlow" verwendet bei der Bewegungsvorhersage die GPU und erzeugt auf meinem Laptop so nur 80 Prozent CPU-Auslastung (zum Start des Programms muss eine Webcam/Videokamera angeschlossen sein, die von OpenCV erkannt wird).
Bei Problemen mit der neuen Datei hilft es vielleicht, die originale Makefile mit der angepassten zu vergleichen.
Viele Grüße
Stephan
There was a time, when I shared a blog. This post was written by Stephan. See all blogpost from him or stalk him on github.
Heute möchte ich zeigen, wie man die Cuda-Code Examples unter Ubuntu 10.04 erfolgreich kompilieren kann.
Zuerst ladet ihr euch die benötigten Dateien von der Nvidia Homepage herunter:
sudo sh devdriver_3.0_linux_32_195.36.15.run
sudo sh cudatoolkit_3.0_linux_32_ubuntu9.04.run
sh gpucomputingsdk_3.0_linux.run # nicht mit Root-Rechten ausführen
Dann öffnet ihr die Konsole und bearbeitet die Bashkonfigurationsdatei
sudo nano $HOME/.bashrc
Folgende Codezeilen müsst ihr an das Ende der Datei einfügen:
export CUDA_BIN="/usr/local/cuda/bin"
export PATH=$PATH:$CUDA_BIN
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib
Anschließend die Bash neuladen:
source $HOME/.bashrc
Und testen ob alles geklappt hat:
nvcc -V
Die Ausgabe in der Konsole sollte etwas so aussehen:
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2009 NVIDIA Corporation
Built on Fri_Feb_19_18:18:31_PST_2010
Cuda compilation tools, release 3.0, V0.2.1221
Nun müssen wir einen Symlink zur Cuda-Bibliothek setzen:
sudo ln -s /usr/lib/nvidia-current/libcuda.so /usr/lib/libcuda.so
Damit verhindern wir, das beim Kompilieren "libcuda" nicht gefunden wird.
Nun müssen wir noch gcc und g++ in der Version 4.3 installieren:
sudo aptitude install g++-4.3 gcc-4.3
und in der Datei "common.mk", die ihr unter
cd $HOME/NVIDIA_GPU_Computing_SDK/C/common
findet, sucht ihr folgende Zeilen:
# architecture flag for nvcc and gcc compilers build
CUBIN_ARCH_FLAG :=
CXX_ARCH_FLAGS :=
NVCCFLAGS := --compiler-bindir=/usr/bin/gcc-4.4.3
LIB_ARCH := $(OSARCH)
Nach eurer Bearbeitung müsste es dann so aussehen:
# architecture flag for nvcc and gcc compilers build
CUBIN_ARCH_FLAG :=
CXX_ARCH_FLAGS :=
NVCCFLAGS := --compiler-bindir=/usr/bin/gcc-4.3
LIB_ARCH := $(OSARCH)
Ist alles erledigt, wechselt ihr in den Ordner der Cuda-Beispiele und startet die Kompilierung
cd $HOME/NVIDIA_GPU_Computing_SDK/C/
make
Die fertigen Programme findet ihr unter :
cd $HOME/NVIDIA_GPU_Computing_SDK/C/bin/linux/release
Viel Spaß dabei und ich hoffe, einigen etwas Arbeit erspart zu haben.
Gruß Stephan
There was a time, when I shared a blog. This post was written by Stephan. See all blogpost from him or stalk him on github.
Mit der Funktion cvCanny von OpenCV lassen sich Kanten in einem Bild erfassen. Hier ein Beispiel, wie man ein Bild auf der Festplatte erfolgreich mit cvCanny erfasst. Wichtig ist, dass das geladene Bild in einem Kanal vorliegt, also "grayscaled" ist. Dies erreicht man durch folgenden Aufruf, bei dem der zweite Parameter der Funktion cvLoadImage auf 0 gesetzt wird (weitere Infos hier).
IplImage* in = cvLoadImage(argv[1],0);
Dann erzeugt man ein neues Bild (Variable out), das die gleiche Dimensionen wie das Eingangsbild (Variable in) besitzt (und natürlich auch nur einen Kanal). Mehr zur Funktion cvCreateImage gibt es hier.
IplImage* out = cvCreateImage(
cvGetSize(in),
IPL_DEPTH_8U,
1
);
Anschließend muss nur noch die cvCanny-Funktion aufgerufen werden, mit den Parametern kann man anschließend etwas "herumspielen":
cvCanny(in, out, 0.3, 0.8);
//Bild darstellen
cvNamedWindow("Canny", CV_WINDOW_AUTOSIZE);
cvShowImage("Canny", out);
//ermöglicht, dass das Bild angezeigt wird, bis Taste gedrückt wird, da keine Schleife
cvWaitKey(0);
Enthält dein Eingangsbild mehrere Kanäle, wirst du beim Aufruf deines Programms folgende Fehlermeldung erhalten (kompilieren lässt es sich):
OpenCV ERROR: Unsupported format or combination of formats () in function cvCanny
Nachtrag:
Liest man Livebilder aus einer Kamera aus , benötigt man die Hilfe von
//Kamera auslesen
CvCapture* capture;
capture = cvCreateCameraCapture(0); // 0 muss gegebenenfalls angepasst werden
//aktuelles Bild der Videokamera erhalten
IplImage* in = cvQueryFrame(capture);
//Graubild erzeugen
IplImage* out = cvCreateImage(
cvGetSize(in),
IPL_DEPTH_8U,
1
);
cvCvtColor(in, out, CV_BGR2GRAY);
//Graubild anzeigen
cvNamedWindow("Gray Image", CV_WINDOW_AUTOSIZE);
cvShowImage("Gray Image", out);
//ermöglicht, dass das Bild angezeigt wird, bis Taste gedrückt wird, da keine Schleife
cvWaitKey(0);