平滑地绘制二维点

Question

Primary question:

I wrote a small ray-tracing code. It's called forward ray-tracing, so rays are actually created at the source, travel to the one and only mirror and are reflected. Subsequently i calculate the intersection of each ray with a plane of my choice i call the detector. And what i get on the detector, printing each hit as a pixel, is a scatter plot of (x,y)'s. Like this one:

import matplotlib.pyplot as plt
import numpy as np
import random

x = np.zeros(1000)
y = np.zeros(1000)
for i in range(len(x)):
    x[i] = random.random()
    y[i] = random.random()

plt.plot(x,y,'k,')
plt.show()

Now i'm looking for a way to represent the density distribution of the hits (the intensity) as a smooth image, like this one.

So the gray-scale of each pixel should correspond to the density in the surrounding patch. But everything that looks like what i need is for 3d-arrays like z=f(x,y).

Also tried hexbin(), but it's not smooth enough and for very small bins it gets too slow and only resembles what i have anyway.

So is there anything i could use?

Secondary question:

I somehow need to add another dimension, because i'm interested in the parallelism of the incident rays. One option is to define it as follows:

1. calculating a + a*b, where:

a = the angle between the incident ray and the detector normal

b = the angle between the incident ray and the yz-plane (the rays are travelling roughly parallel to this plane)

1. mean value of this quantity

2. deviation from the mean value for each hit

I thought of incorporating both of these informations in one plot by adding colour to the gray-scale. Is this feasible?

I'm new to programming, any hint, explanation or alternative idea will be much appreciated.

Answer 1

I don't think you can get away with making a 2d image, just like you mentioned... you need the 3rd dimension to describe the intensity of signal at (x, y). Here's just a quick and dirty example:

import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np


# just creating random data with a bunch of 2d gaussians

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

imsize = 1000
im = np.zeros((imsize, imsize), dtype=float)

ng = 50
x0s = imsize * np.random.random(ng)
y0s = imsize * np.random.random(ng)
sxs = 100. * np.random.random(ng)
sys = sxs #100. * np.random.random(ng)
amps = 100 + 100 * np.random.random(ng)

for x0, y0, sx, sy, amp in zip(x0s, y0s, sxs, sys, amps):
    nsig = 5.
    xlo, xhi = int(x0 - nsig * sx), int(x0 + nsig * sx)
    ylo, yhi = int(y0 - nsig * sy), int(y0 + nsig * sy)

    xlo = xlo if xlo >= 0 else 0
    xhi = xhi if xhi <= imsize else imsize
    ylo = ylo if ylo >= 0 else 0
    yhi = yhi if yhi <= imsize else imsize

    nx = xhi - xlo
    ny = yhi - ylo

    imx = np.tile(np.arange(xlo, xhi, 1), ny).reshape((ny, nx))
    imy = np.tile(np.arange(ylo, yhi, 1), nx).reshape((nx, ny)).transpose()

    im[ylo:yhi, xlo:xhi] += gauss2d(imx, imy, amp, x0, y0, sx, sy)


plt.imshow(im, cmap=cm.gray)

plt.show()

Basically you treat the data like a 2d image from CCD, each pixel containing the signal strength.

(I would actually add that depending on what in data you are trying to highlight, you might want to use scatter plot but vary the size/opacity of points to show your information... it really depends what you are trying to achieve.)

I don't actually understand exactly what you want to plot from ray intensity, but if you are taking about the a ray hitting the image at an angle, you need to compute the projected intensity of the ray onto the plane. And that's a different question from how you plot with Matplotlib.

Answer 2

I guess your primary question involves two main steps: First, computing the density function for the scatter points, and second actually plotting it. So, if you have a function z = f(x,y), where z is the estimated density at point (x,y), you could use the matplotlib methods you have already researched.

As for the first step, I would suggest to have a look at the kernel density estimation routines in scipy.stats.kde . Basically you do

density = scipy.stats.gaussian_kde(scatterpoints)

and then can evaluate the density for each point from

z = density([x,y])