Glowing (neon) in vigore nel gnuplot

Question

voglio riprodurre questo effetto in gnuplot:

Come posso achive esso? Se non può essere fatto, quale software posso usare per riprodurlo?

Answer 1

Utilizzando un kernel 2d per ogni pixel può essere fatto all'interno gnuplot. In questo modo, gli accumuli più densi diventano più luminosi dei singoli pixel. Controllare show palette rgbformulae e il rispettivo capitolo nella guida per cambiare i colori.

set term wxt size 300,300 background rgb 0 
    set view map 
    set samp 140          
    set dgrid3d 180,180, gauss kdensity2d 0.2,0.2 
    set palette rgbform 4,4,3 
    splot "+" us 1:(sin($1/3)**2*20):(1) with pm3d notitle 

Answer 2

Impostare uno sfondo nero e quindi tracciare il set di dati più volte in colori diversi con punti decrescenti.

set term wxt backgr rgb "black" 
    plot sin(x) w p pt 7 ps 2 lc rgb 0x00003f not, \ 
     sin(x) w p pt 7 ps 1.5 lc rgb 0x00007f not, \ 
     sin(x) w p pt 7 ps 1 lc rgb 0x0000af not, \ 
     sin(x) w p pt 7 ps .5 lc rgb 0x0000ff 

In alternativa, una combinazione di splot with pm3d, set dgrid3d gauss kdensity2d, e set view map, in combinazione con una tavolozza adatto, può essere utilizzato, vedere la mia altra risposta.

Answer 3

Declinazione di responsabilità: Può essere eseguito con gnuplot come indicato in questa risposta, ma è consigliabile prendere in considerazione uno strumento diverso per disegnare questo particolare tipo di grafico.

C'è almeno un modo per farlo, con preelaborazione dei dati. L'idea è di imitare l'effetto bagliore usando un kernel gaussiano per imbrattare i punti dati. Prendere in considerazione i seguenti dati, contenuti in un file chiamato data:

1 2 
1 2.1 
1.1 2.2 
2 3 
3 4 

ho volutamente messo i primi 3 punti vicini tra loro per essere in grado di osservare il bagliore intensificato di punti vicini. Questi dati appaiono così:

Ora abbiamo striscio i punti dati che utilizzano un kernel gaussiano 2D. Ho scritto il seguente codice Python per aiutare con questo. Il codice ha un taglio di 4 deviazioni standard (sx e sy) attorno a ciascun punto. Se si desidera che il bagliore sia un cerchio, è necessario scegliere le deviazioni standard in modo che il rapporto sx/sy sia uguale al rapporto tra le lunghezze degli assi x/y in gnuplot. Altrimenti i punti sembreranno ellissi. Questo è il codice:

import numpy as np 
import sys 

filename = str(sys.argv[1]) 
sx = float(sys.argv[2]) 
sy = float(sys.argv[3]) 

def f(x,y,x0,y0,sx,sy): 
    return np.exp(-(x-x0)**2/2./sx**2 -(y-y0)**2/2./sy**2) 

datafile = open(filename, 'r') 

data = [] 
for datapoint in datafile: 
    a, b = datapoint.split() 
    data.append([float(a),float(b)]) 

xmin = data[0][0] 
xmax = data[0][0] 
ymin = data[0][1] 
ymax = data[0][1] 
for i in range(1, len(data)): 
    if(data[i][0] < xmin): 
     xmin = data[i][0] 
    if(data[i][0] > xmax): 
     xmax = data[i][0] 
    if(data[i][1] < ymin): 
     ymin = data[i][1] 
    if(data[i][1] > ymax): 
     ymax = data[i][1] 

xmin -= 4.*sx 
xmax += 4.*sx 
ymin -= 4.*sy 
ymax += 4.*sy 

dx = (xmax - xmin)/250. 
dy = (ymax - ymin)/250. 

for i in np.arange(xmin,xmax+dx, dx): 
    for j in np.arange(ymin,ymax+dy, dy): 
     s = 0. 
     for k in range(0, len(data)): 
      d2 = (i - data[k][0])**2 + (j - data[k][1])**2 
      if(d2 < (4.*sx)**2 + (4.*sy)**2): 
       s += f(i,j,data[k][0],data[k][1],sx,sy) 
     print i, j, s 

È usato come segue:

python script.py data sx sy 

dove script.py è il nome del file in cui si trova il codice, data è il nome del file di dati, e sx e sy sono le deviazioni standard.

Ora, tornando a gnuplot, definiamo una tavolozza che riproduce un motivo luminoso. Per i punti isolati, i gaussiani sommati danno 1 nella posizione del punto; per punti sovrapposti produce valori superiori a 1. È necessario tenerlo presente quando si definisce la tavolozza. Il seguente è solo un esempio:

set cbrange [0:3] 
unset colorbox 
set palette defined (0 "black", 0.5 "blue", 0.75 "cyan", 1 "white", 3 "white") 
plot "< python script.py data 0.05 0.05" w image 

Si può vedere che i punti sono effettivamente ellissi, poiché il rapporto degli assi lunghezze non è la stessa di quella delle deviazioni standard lungo le diverse direzioni .Questo può essere facilmente risolto:

plot "< python script.py data 0.05 0.06" w image