Image Processing

Kategoriearchiv

Du betrachtest das Archiv der Kategorie Image Processing.

Building OpenCV for Anaconda Python 3

Don’t judge me, I know how this title sounds. The harsh reality is — as per writing of this post — that I always have a hard time getting CMake to recognize the right Python path when I’m using an Anaconda environment. In theory it’s just

git clone https://github.com/opencv/opencv.git opencv
mkdir opencv/build && cd opencv/build
cmake -DCMAKE_INSTALL_PREFIX=/usr/local  ..
make -j8
(sudo) make install

and there you go. It will happily pick up your environment’s Python installation and build that for you. Of course, it looks more along the lines of

cmake \
    -DCMAKE_INSTALL_PREFIX="/usr/local" \
    -DOPENCV_EXTRA_MODULES_PATH="../opencv_contrib/modules" \
    -DBUILD_DOCS=OFF \
    -DBUILD_TESTS=OFF \
    -DBUILD_EXAMPLES=OFF \
    -DBUILD_PERF_TESTS=OFF \
    -DBUILD_opencv_dnn=OFF \
    -DENABLE_FAST_MATH=ON \
    -DWITH_OPENMP=ON \
    -DWITH_TBB=ON \
    -DMKL_WITH_TBB=ON \
    -DMKL_WITH_OPENMP=ON \
    -DCMAKE_CXX_COMPILER="/usr/bin/g++-5" \
    -DCMAKE_C_COMPILER="/usr/bin/gcc-5" \
    -DCUDA_HOST_COMPILER="/usr/bin/gcc-5" \
    -DCUDA_FAST_MATH=ON \
    -DCUDA_ARCH_BIN="5.2" \
    -DWITH_CUBLAS=ON \
    ..

Whenever you then add

conda activate my-environment

to the mix though, all hell breaks loose and you end up with partially configured Python 2 and no Python 3 support at all. The trick seems to be not to rely on OpenCV’s standard Python configuration values

PYTHON3_LIBRARY
PYTHON3_EXECUTABLE
PYTHON3_INCLUDE_DIR
PYTHON3_INCLUDE_DIR2
PYTHON3_NUMPY_INCLUDE_DIRS

but rather to use the seemingly undocumented values

PYTHON3_LIBRARIES
PYTHON3_INCLUDE_PATH

as well, giving it the nice appearance of

cmake \
    -DCMAKE_BUILD_TYPE=RELEASE \
    -DCMAKE_INSTALL_PREFIX="/your/anaconda3" \
    -DOPENCV_EXTRA_MODULES_PATH="../opencv_contrib/modules" \
    -DBUILD_DOCS=OFF \
    -DBUILD_TESTS=OFF \
    -DBUILD_EXAMPLES=OFF \
    -DBUILD_PERF_TESTS=OFF \
    -DBUILD_opencv_dnn=ON \
    -DTINYDNN_USE_NNPACK=OFF \
    -DTINYDNN_USE_TBB=ON \
    -DTINYDNN_USE_OMP=ON \
    -DENABLE_FAST_MATH=ON \
    -DWITH_OPENMP=ON \
    -DWITH_TBB=ON \
    -DMKL_WITH_TBB=ON \
    -DMKL_WITH_OPENMP=ON \
    -DCMAKE_CXX_COMPILER="/usr/bin/g++-5" \
    -DCMAKE_C_COMPILER="/usr/bin/gcc-5" \
    -DCUDA_HOST_COMPILER="/usr/bin/gcc-5" \
    -DCUDA_FAST_MATH=ON \
    -DCUDA_ARCH_BIN="5.2" \
    -DWITH_CUBLAS=ON \
    -DBUILD_opencv_python2=OFF \
    -DPYTHON_EXECUTABLE="/your/anaconda3/bin/python3" \
    -DPYTHON_LIBRARY="/your/anaconda3/lib/libpython3.6m.so" \
    -DPYTHON3_LIBRARY="/your/anaconda3/lib/libpython3.6m.so" \
    -DPYTHON3_EXECUTABLE="/your/anaconda3/bin/python3" \
    -DPYTHON3_INCLUDE_DIR="/your/anaconda3/include/python3.6m" \
    -DPYTHON3_INCLUDE_DIR2="/your/anaconda3/include" \
    -DPYTHON3_NUMPY_INCLUDE_DIRS="/your/anaconda3/lib/python3.6/site-packages/numpy/core/include" \
    -DPYTHON3_INCLUDE_PATH="/your/anaconda3/include/python3.6m" \
    -DPYTHON3_LIBRARIES="/your/anaconda3/lib/libpython3.6m.so" \
    -DHDF5_C_LIBRARY_z="/your/anaconda3/lib/libz.so" \
    ..

And then it’ll do what you want it to do. Because I’m tired of retrying everytime, on github.com/sunsided/opencv-cmake is my repo with support for the OpenCV Extras Module and some documentation for this.

So, what paths go in there? Well, this blog post has a very flashy way of finding out.

For CMAKE_INSTALL_PREFIX you use

python3 -c "import sys; print(sys.prefix)"

so it will install OpenCV directly into your Anaconda installation.
For PYTHON3_EXECUTABLE you call

which python3

and PYTHON3_INCLUDE_DIR is given by

python3 -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())"

Finally, a PYTHON3_PACKAGES_PATH can be found using

python3 -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())"

which you a can use to determine the PYTHON3_NUMPY_INCLUDE_DIRS, although CMake strangely did that part right for me.

Getting an image into and out of TensorFlow
Let’s assume you already have an image in numpy’s ndarray format, e.g. because you loaded it with OpenCV’s imread() function, and you want to convert it to TensorFlow’s Tensor format and later back to ndarray.

That’s essentially three calls to TensorFlow:
```
import cv2
import tensorflow as tf
import numpy as np

# normalize the pixel values to 0..1 range and convert them 
# to a single-precision tensor
image_in = cv2.imread('image.png') / 255.
t = tf.convert_to_tensor(image_in, dtype=tf.float32)
assert isinstance(t, tf.Tensor)

# in order to convert the tensor back to an array, we need
# to evaluate it; for this, we need a session
with tf.Session() as sess:
    image_out = sess.run(fetches=t)
    assert isinstance(image_out, np.ndarray)

# for imshow to work, the image needs to be in 0..1 range
# whenever it is a float; that's why we normalized it.
cv2.imshow('Image', image_out)
cv2.readKey(0)
```
Note that instead of using sess.run(t) we could also have used
```
with tf.Session() as sess:
    image_out = t.eval(sess)
```
which essentially performs the same action. A benefit of using sess.run() directly is that we can fetch more than one tensor in the same pass through the (sub-)graph (say, tuple = sess.run(fetches=[t1, t2, t3])), whereas calling tensor.eval() always results in one separate pass per call.
Dezember 12th, 2016 GMT +2 von
Markus
2016-12-12T15:59:54+02:00 2016-12-12T15:59:54+02:00 · 0 Kommentare

OpenCV Python tensorflow

Image Processing TensorFlow Neural Networks

Fliptri/Flipquad Image Filtering
Neugierig und etwas gelangweilt kam ich heute auf die Idee, auszuprobieren, was wohl passieren würde, wenn man die beiden Supersampling-Verfahren Fliptri und Flipquad als Filter eines bestehenden Bildes interpretiert. Resultat des Abends: Wir reden nicht darüber.

Grundlage

Beiden Verfahren liegt zugrunde, dass zur Erzeugung eines Pixels mehrere umgebende (Sub-)Pixel ausgewertet werden, wobei das Muster der Auswertung für anliegende Bildpunkte horizontal und/oder vertikal gespiegelt — geflippt — wird. Die beiden Verfahren unterscheiden sich dabei lediglich hinsichtlich der Anzahl der Samplingpunkte.

Anschaulicher in der Grafik: Jeweils drei Samplingpunkte (rot) ergeben einen Bildpunkt (blau) bei Fliptri; Bei Flipquad sind es vier Samplingpunkte pro Bildpunkt.

Der resultierende Bildpunkt B ist dabei schlichtweg die gewichtete Summe aller Samplingpunkte S:

\begin{align}
B = \frac{1}{N} \sum \limits_{i=1}^N S_i
\end{align}

Implementierung in Matlab

Fliptri

Zu jedem Punkt müssen drei umgebende Pixel aufgenommen werden. Im ungespiegelten Fall liegen diese an den Koordinaten (x-1, y-1), (x, y+1) und (x+1, y). Wie aus der Abbildung zu erkennen ist, müssen die X- und Y-Koordinaten (genauer: Deren Offsets -1, 0 und +1) für jede gerade Zeile gespiegelt werden, was man durch folgenden Kunstgriff erreicht:
```
x_sample = x_offset*(-1)^x + x;
y_sample = y_offset*(-1)^y + y;
```
Der Rest ist schnell erledigt:
```
function pixel = fliptri(x, y, rgb)

    %   1   2   3
    % +---+---+---+
    % | X |   |   |
    % +---+---+---+
    % |   |   | X |
    % +---+---+---+
    % |   | X |   |
    % +---+---+---+
    coords = [ -1  0 +1;  % X
               -1 +1  0]; % Y

    N = length(coords);

    % Flip 
    sgn_x = (-1)^x;
    sgn_y = (-1)^y;

    % Sample
    for s=1:N
        sample(s, 1:3) = rgb( ...
                 x+coords(1,s)*sgn_x, ...
                 y+coords(2,s)*sgn_y, ...
                 1:3);
    end

    % Combine
    pixel = sum(sample) / N;
end
```
Zuletzt muss das Bild noch geladen und gefiltert werden. (Da die Größe des gedachten Filterkernels der Größe drei entspricht, müssen die Start- und Endindizes jeweils um den Wert 1 reduziert werden.)
```
% Load the image
rgb = imread('aliased.png');

% Sample the image
imagesize   = size(rgb);
width       = imagesize(1);
height      = imagesize(2);
rgb_sampled = uint8(zeros(imagesize));
for y=2:height-1
    for x=2:width-1
        rgb_sampled(x, y, 1:3) = fliptri(x, y, rgb);
    end
end
```
Flipquad

Analog zum Fliptri funktioniert der Flipquad-Algorithmus, allerdings ist die Offsetkorrektur hier vom Wert zwei, und es werden vier, statt drei Werten verarbeitet:
```
function pixel = flipquad(x, y, rgb)

    %   1   2   3   4   5
    % +---+---+---+---+---+
    % |   | X |   |   |   |
    % +---+---+---+---+---+
    % |   |   |   |   | X |
    % +---+---+---+---+---+
    % |   |   |   |   |   |
    % +---+---+---+---+---+
    % | X |   |   |   |   |
    % +---+---+---+---+---+
    % |   |   |   | X |   |
    % +---+---+---+---+---+

    coords = [ -2 -1 +1 +2;  % X
               -1 +2 -2 +1]; % Y  

    N = length(coords);

    % Flip 
    sgn_x = (-1)^x;
    sgn_y = (-1)^y;

    % Sample
    sample = zeros(3,3);
    for s=1:N
        sample(s, 1:3) = rgb( x+coords(1,s)*sgn_x, ...
                              y+coords(2,s)*sgn_y, ...
                              1:3);
    end

    % Combine
    pixel = sum(sample) / N;
end
```
Der Rest funktioniert wie gehabt.

Das Ergebnis

Ernüchternd scheiße.

Originalbild

Fliptri-gefiltertes Bild

Flipquad-gefiltertes Bild

Und das war das.

Wie ich eingangs bereits erwähnte: … — aber wenigstens war man dabei. Prost.
November 4th, 2011 GMT +2 von
Markus
2011-11-4T03:58:08+02:00 2018-03-4T14:44:01+02:00 · 0 Kommentare

Matlab

MATLAB Image Processing

M	D	M	D	F	S	S
« Mrz
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30

2x1=10

Kategoriearchiv

Building OpenCV for Anaconda Python 3

Getting an image into and out of TensorFlow

Fliptri/Flipquad Image Filtering

Grundlage

Implementierung in Matlab

Fliptri

Flipquad

Das Ergebnis

Originalbild

Fliptri-gefiltertes Bild

Flipquad-gefiltertes Bild

Und das war das.

Kategorien

Neueste Beiträge

Letzte Kommetare

Blog durchsuchen

Self

Meta

Kategoriearchiv

Building OpenCV for Anaconda Python 3

Getting an image into and out of TensorFlow

Fliptri/Flipquad Image Filtering

Grundlage

Implementierung in Matlab

Fliptri

Flipquad

Das Ergebnis

Originalbild

Fliptri-gefiltertes Bild

Flipquad-gefiltertes Bild

Und das war das.

Kategorien

Neueste Beiträge

Kategorien

Tags

Letzte Kommetare

Blog durchsuchen

Self

Meta