Generate contour charts over a 360*360 position map with weights from 0 to 1

Question

What technique can I use to generate graphics in the style of c and d of this figure?

Man input will be in the standard: X, Y and the weight of that position, where X and Y go from -180°; up to 180°, and the weight varies from 0 to 1 using 6 decimal places, this is the exemple1 this is example 2.

This file is created from the density map code, found here.

I have tested with Gnuplot using pm3d map and the pm3d interpolate, but I couldn’t generate the contours because it’s a very space graphic maybe...

I also tried to use the matplotlib with pcolormesh applying levels and then applying the countor or countorf, using this link as basis.

I mean, I can generate charts like this:

With matplotlib I tried using the following code:

import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
import matplotlib.colors as mcolors
import scipy.ndimage
import numpy as np

def make_colormap(seq):
    seq = [(None,) * 3, 0.0] + list(seq) + [1.0, (None,) * 3]
    cdict = {'red': [], 'green': [], 'blue': []}
    for i, item in enumerate(seq):
        if isinstance(item, float):
            r1, g1, b1 = seq[i - 1]
            r2, g2, b2 = seq[i + 1]
            cdict['red'].append([item, r1, r2])
            cdict['green'].append([item, g1, g2])
            cdict['blue'].append([item, b1, b2])
    return mcolors.LinearSegmentedColormap('CustomMap', cdict)

f = open("~/histogramaGLY.dat","r")
k = [[0 for x in xrange(359)] for x in xrange(359)] 
while 1:
    line = f.readline()
    if not line: break      
    line2 = ''.join(line).split()
    k[int(float(line2[0]))][int(float(line2[1]))] = float(line2[2])
f.close()
k = scipy.ndimage.zoom(k, 4)
z = np.array(k)

dx, dy = 0.25, 0.25

y, x = np.mgrid[slice(-180, 179 + dx, dx),
        slice(-180, 179 + dy, dy)
                ]
levels = MaxNLocator(nbins=1000).bin_boundaries(z.min(), z.max())

c = mcolors.ColorConverter().to_rgb
rvb = make_colormap(
    [c('white'), 0.05, c('cyan'), 0.1, c('blue'), 0.15, c('darkblue'), 0.2,  c('green'), 0.2,  c('lightgreen'), 0.3, c('yellow'), 0.4, c('red'), 0.5, c('darkred')])
N = 256

plt.contourf(x[:-1, :-1],
             y[:-1, :-1], k, levels=levels,
             cmap=rvb)
plt.show()

generating this graph:

However, I cannot generate the effect used in figure 1.

How to make the effect of smoothing or countor that the first photo presents, knowing that are 129600 lines to interpolate?

Answer 1

I decided to use the actual data, without interpolating, but I was able to get around the problem using an initial interpolation on the input data and using the 0.0 Interpolate in Gnuplot. I edited the text and already switched to solved my problem.

First I changed the input data generation, using a 4x4 interpolation and then applied the command "set pm3d map Interpolate 0.0" from GNUPlot, thus using the 0,0 standard itself GNUPlot choose the best data interpolation.

Below is the difference of no interpolar and interpolating the data.

Below follows the result using few input data.

However the disadvantage interpolating the data is that I end up losing details, which in my case are not noises, so I believe I will use the data without interpolating even.