mathplotlib imshow Komplexes 2D-array

Ist es eine gute Art und Weise, wie plot-2D-array von komplexen zahlen, die als Bild in mathplotlib ?

Macht es sehr viel Sinn, Karte Betrag des komplexen Nummer wie "Helligkeit" oder "Sättigung" und die phase als "Farbton" ( wie auch immer der Farbton ist nichts anderes, als die phase in RGB-Farbraum).
http://en.wikipedia.org/wiki/HSL_and_HSV

Aber soweit ich weiß, imshow akzeptiert nur Skalare Werte, die dann abgebildet mit einigen colorscale. Es gibt nichts wie ploting echten RGB-Bildern?

Ich glaube es wäre einfach nur implementieren Sie eine version, die akzeptiert 2D-array von Tupeln (Vektoren) von 3 floating-point-zahlen oder ndarray der Schwimmer von der Form [:,:,3]. Ich denke, das wäre in der Regel usefful Funktion. Es wäre auch nützlich für das zeichnen echte RGB-colord Bilder, wie Texturen ausgegeben, die von OpenCL

Finden Sie diese Antwort für eine andere Frage: stackoverflow.com/a/17113417/907575

InformationsquelleAutor Prokop Hapala | 2013-06-11

diese hat fast die gleichen von @Süchtig-code, aber sehr viel schneller.

import numpy as np
from numpy import pi
import pylab as plt
from colorsys import hls_to_rgb

def colorize(z):
    r = np.abs(z)
    arg = np.angle(z) 

    h = (arg + pi)  / (2 * pi) + 0.5
    l = 1.0 - 1.0/(1.0 + r**0.3)
    s = 0.8

    c = np.vectorize(hls_to_rgb) (h,l,s) # --> tuple
    c = np.array(c)  # -->  array of (3,n,m) shape, but need (n,m,3)
    c = c.swapaxes(0,2) 
    return c

N=1000
x,y = np.ogrid[-5:5:N*1j, -5:5:N*1j]
z = x + 1j*y

w = 1/(z+1j)**2 + 1/(z-2)**2
img = colorize(w)
plt.imshow(img)
plt.show()

Wenn Sie c.swapaxes(0,2) du bist die Veränderung der Ausrichtung des Originalbildes. Ich brauchte eine zusätzliche swapaxes(0,1) danach für mein Bild zu Rendern richtig. Allerdings habe ich verwendet meshgrid statt ogrid, da ich nicht weiß, wie genau letzteres funktioniert, vielleicht machte das einen Unterschied?

InformationsquelleAutor nadapez

7

Die Bibliothek mpmath verwendet matplotlib zu produzieren die schönen Bilder der komplexen Ebene. Auf der komplexen Ebene, die Sie in der Regel über die Pflege der Stöcke, so das argument der Funktion gibt die Farbe (also Stangen, wird eine Spirale). Regionen von extrem großen oder kleinen Werten gesteuert werden, indem die Sättigung an. Aus den docs:

Standardmäßig das komplexe argument (phase) wird gezeigt, wie Farbe (Farbton) und
die Größenordnung zeigen, wie Sie die Helligkeit. Sie können auch einen
custom-color-Funktion (Farbe). Diese Funktion sollte einen
komplexe Zahl als Eingabe und Rückkehr eines RGB 3-Tupel mit
schwimmt im Bereich von 0,0 bis 1,0.

Beispiel:
```
import mpmath
mpmath.cplot(mpmath.gamma, points=100000)
```
Weiteres Beispiel zeigt die zeta-Funktion, die trivialen Nullstellen und die kritische Streifen:
```
import mpmath
mpmath.cplot(mpmath.zeta, [-45,5],[-25,25], points=100000)
```
- Das sieht gut aus, aber es ist nur zum Plotten von Funktionen, bei denen ich weiß, analytinc Rezept. Es ist nicht mein Fall. Ich brauche etwas zum plot, komplexe Daten mit diskreten Stichproben, die ich gelesen habe von text-Datei und speichern in 2D narray. Ich habe keine explizite functionoal Rezept für diese Daten könnte sein Stichprobe in jedem Punkt.
InformationsquelleAutor Hooked
7

Anpassung der Plot-code aus mpmath Plotten kann ein numpy-array , auch wenn Sie nicht bekannt die ursprüngliche Funktion mit numpy und matplotlib. Wenn Sie wissen, dass die Funktion, siehe meine ursprüngliche Antwort mit mpmath.cplot.
```
from colorsys import hls_to_rgb

def colorize(z):
    n,m = z.shape
    c = np.zeros((n,m,3))
    c[np.isinf(z)] = (1.0, 1.0, 1.0)
    c[np.isnan(z)] = (0.5, 0.5, 0.5)

    idx = ~(np.isinf(z) + np.isnan(z))
    A = (np.angle(z[idx]) + np.pi) / (2*np.pi)
    A = (A + 0.5) % 1.0
    B = 1.0 - 1.0/(1.0+abs(z[idx])**0.3)
    c[idx] = [hls_to_rgb(a, b, 0.8) for a,b in zip(A,B)]
    return c
```
Von hier aus können Sie zeichnen eine beliebige komplexe numpy-array:
```
N = 1000
A = np.zeros((N,N),dtype='complex')
axis_x = np.linspace(-5,5,N)
axis_y = np.linspace(-5,5,N)
X,Y = np.meshgrid(axis_x,axis_y)
Z = X + Y*1j

A = 1/(Z+1j)**2 + 1/(Z-2)**2

# Plot the array "A" using colorize
import pylab as plt
plt.imshow(colorize(A), interpolation='none',extent=(-5,5,-5,5))
plt.show()
```
- vielen Dank! Es ist ziemlich langsam, so dass es besser wäre, wenn es wäre, eine solche Funktion direkt hardcoded numpy (ich meine, etwas beschleunigt, in der gleichen Weise wie andere array-Operationen in numpy - ohne Iteration über array von python-Schleife ). Aber das wichtige ist, dass es funktioniert.
- Eigentlich die meiste Arbeit, die ist erfolgt mit numpy, außer für den Anruf zu hls_to_rgb die Sie könnte wahrscheinlich zu Vektorisieren. Sie können es viel schneller durch ändern der Anzahl der Punkte N, die Geschwindigkeit sollte proportional zu N^2.
InformationsquelleAutor Hooked

Können Sie matplotlib.colors.hsv_to_rgb statt colorsys.hls_to_rgb. Die matplotlib Funktion ist etwa 10 mal schneller! Sehen die Ergebnisse unter:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import hsv_to_rgb
import time

def Complex2HSV(z, rmin, rmax, hue_start=90):
    # get amplidude of z and limit to [rmin, rmax]
    amp = np.abs(z)
    amp = np.where(amp < rmin, rmin, amp)
    amp = np.where(amp > rmax, rmax, amp)
    ph = np.angle(z, deg=1) + hue_start
    # HSV are values in range [0,1]
    h = (ph % 360) / 360
    s = 0.85 * np.ones_like(h)
    v = (amp -rmin) / (rmax - rmin)
    return hsv_to_rgb(np.dstack((h,s,v)))

hier ist die Methode abgeholt Antwort von @nadapez:

from colorsys import hls_to_rgb
def colorize(z):
    r = np.abs(z)
    arg = np.angle(z) 

    h = (arg + np.pi)  / (2 * np.pi) + 0.5
    l = 1.0 - 1.0/(1.0 + r**0.3)
    s = 0.8

    c = np.vectorize(hls_to_rgb) (h,l,s) # --> tuple
    c = np.array(c)  # -->  array of (3,n,m) shape, but need (n,m,3)
    c = c.swapaxes(0,2) 
    return c

Prüfung der Ergebnisse aus den beiden Verfahren mit 1024*1024 2darray:

N=1024
x, y = np.ogrid[-4:4:N*1j, -4:4:N*1j]
z = x + 1j*y

t0 = time.time()
img = Complex2HSV(z, 0, 4)
t1 = time.time()
print "Complex2HSV method: "+ str (t1 - t0) +" s"

t0 = time.time()
img = colorize(z)
t1 = time.time()
print "colorize method: "+ str (t1 - t0) +" s"

Dieses Ergebnis auf meinem alten laptop:

Complex2HSV method: 0.250999927521 s
colorize method: 2.03200006485 s

InformationsquelleAutor w4m

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.