Glowing (neon) effect in gnuplot

Question

I want to reproduce this effect in gnuplot:

How can I achive it? If it can't be done, what software can I use to reproduce it?

Answer 1

Set a black background, and then plot your dataset several time in different colours with decreasing pointsize.

  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

Alternatively, some combination of splot with pm3d,set dgrid3d gauss kdensity2d, and set view map, combined with a suitable palette, can be used, see my other answer.

Answer 2

Disclaimer: It can be done with gnuplot as instructed in this answer but you should probably consider a different tool to draw this particular type of plot.

There is at least one way to do it, with preprocessing of the data. The idea is to mimic the glow effect by using a Gaussian kernel to smear the data points. Consider the following data, contained in a file called data:

1   2
1   2.1
1.1 2.2
2   3
3   4

I have purposely placed the first 3 points close to each other to be able to observe the intensified glow of neighboring points. These data look like this:

Now we smear the data points using a 2D Gaussian kernel. I have written the following python code to help with this. The code has a cutoff of 4 standard deviations (sx and sy) around each point. If you want the glow to be a circle, you should choose the standard deviations so that the sx / sy ratio is the same as the ratio of the x/y axes lengths in gnuplot. Otherwise the points will look like ellipses. This is the code:

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

It is used as follows:

python script.py data sx sy

where script.py is the name of the file where the code is located, data is the name of the data file, and sx and sy are the standard deviations.

Now, back to gnuplot, we define a palette that mimics a glowing pattern. For isolated points, the summed Gaussians yield 1 at the position of the point; for overlapping points it yields values higher than 1. You must consider that when defining the palette. The following is just an example:

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

You can see that the points are actually ellipses, because the ratio of the axes lengths is not the same as that of the standard deviations along the different directions. This can be easily fixed:

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