Display Models
+
+
Generate the example file
+
To run the examples of this section, you must first move to the ~/pnbody_examples directory.
+If the latter does not exists, you can first create it with:
+
+
then inside this directory, type:
+
./scripts/mkmodel_for_display.py
+
+
This will create the N-body file snapd.dat.
+This file contains a rotating disk of radius 30, with a small plummer sphere centered on (15,15,10).
+
+
+
The display method
+
Any model may be displayed simply using the method NbodyDefault.display().
+This method takes several parameters that will be described in detail below.
+For our first example, we simply use the size parameter, which set the size of
+the displayed area:
+
>>> from pNbody import *
+>>> nb = Nbody("snapd.dat",ftype='gadget')
+>>> nb.display(size=(50,50))
+
+
+
If your default parameters are still the ones of the pNbody distribution, this should display the following image:
+
+
+
+
Display parameters
pNbody provides rather complex tools to display
N-body systems. The tools uses different parameters
that are sumarized in the following table:
| name |
meaning |
value |
type |
|---|
| obs |
observer |
None |
(ArrayObs) |
| xp |
observing position |
None |
(List) |
| x0 |
position of observer |
None |
(List) |
| alpha |
angle of the head |
None |
(Float) |
| view |
view |
xz |
(String) |
| r_obs |
dist. to the observer |
201732.223771 |
(Float) |
| clip |
clip planes |
(100866.11188556443, 403464.44754225772) |
(Tuple) |
| cut |
cut clip planes |
no |
(String) |
| eye |
name of the eye |
None |
(String) |
| dist_eye |
distance between eyes |
-0.0005 |
(Float) |
| foc |
focal |
300.0 |
(Float) |
| persp |
perspective |
off |
(String) |
| shape |
shape of the image |
(512, 512) |
(Tuple) |
| size |
pysical size |
(6000, 6000) |
(Tuple) |
| frsp |
frsp |
0.0 |
(Float) |
| space |
space |
pos |
(String) |
| mode |
mode |
m |
(String) |
| rendering |
rendering mode |
map |
(String) |
| filter_name |
name of the filter |
None |
(String) |
| filter_opts |
filter options |
[10, 10, 2, 2] |
(List) |
| scale |
scale |
log |
(String) |
| cd |
cd |
0.0 |
(Float) |
| mn |
mn |
0.0 |
(Float) |
| mx |
mx |
0.0 |
(Float) |
| l_n |
number of levels |
15 |
(Int) |
| l_min |
min level |
0.0 |
(Float) |
| l_max |
max level |
0.0 |
(Float) |
| l_kx |
l_kx |
10 |
(Int) |
| l_ky |
l_ky |
10 |
(Int) |
| l_color |
level color |
0 |
(Int) |
| l_crush |
crush background |
no |
(String) |
| b_weight |
box line weight |
0 |
(Int) |
| b_xopts |
x axis options |
None |
(Tuple) |
| b_yopts |
y axis options |
None |
(Tuple) |
| b_color |
line color |
255 |
(Int) |
The value of these parameters may be obtained by the command:
Set the observer position
When creating an image from a model, one has to choose the observer position, the look at
point and the orientation of the head. The user has tree possibilities to define these parameters :
- Define manually the observer matrix obs. obs is a 4x3 array matrix. Meaning of the four vectors composing this matrix is given in the following table :
| obs |
Meaning |
|---|
| obs[0] |
position of the observer |
| obs[1] |
position of the look at point (with respect to the position of the observer) |
| obs[2] |
position of the head (with respect to the position of the observer) |
| obs[3] |
position of the arm (with respect to the position of the observer) |
If obs is defined, it is used in priority.
- Using the parameters xp, x0 and alpha, where x0 is the observer position, xp is
the look at point and alpha the angle between the head and the z axis.
- Using the parameters view and r_obs. This simpler method is used if obs, xp and x0 are set to None.
The parameter view can be equal to xy, xz or yz, the projection
being parallel to one of the main axis. r_obs gives the distance between the observer and the look at point.
+
+
Example:
+
To see the disk face-on, projecting it along the z axis:
+
>>> nb.display(obs=None,x0=None,xp=None,size=(50,50),view='xy')
+
+
+
+
To align the center of the disk with the center of the sphere:
+
>>> nb.display(obs=None,x0=[30.,30.,20.],xp=[15,15,10],alpha=0,size=(50,50))
+
+
+
+
To look at the disk from the bottom, tilting the head from 45 degres:
+
>>> nb.display(obs=None,x0=[0,-50,-50],xp=[0,0,0],alpha=pi/4,size=(50,50))
+
+
+
+
Set the projection mode
pNbody offers two projection modes. If persp``='on', the model is projectec using a frustrum projection matrix.
In the other case, it uses an ortho matrix (orthogonal projection). The near and far clipping planes are given by
the parameter ``clip containing a tuple. The left, right, bottom and top clipping planes are given by the parameter size.
If cut is set to ‘yes’, particles outside the box defined by the 6 planes are not displayed.
+
+
Example:
+
Using the frustrum projection:
+
>>> nb.display(obs=None,x0=[0,-50,20],xp=[0,0,0],alpha=0,size=(5,5),persp='on',clip=(10,50))
+
+
+
The field of view is determined using clip and size.
+
+
If cut is set to yes, only particles inside the clip planes are displayed:
+
>>> nb.display(obs=None,x0=[0,-50,20],xp=[0,0,0],alpha=0,size=(5,5),persp='on',clip=(10,50),cut='yes')
+
+
+
+
Stero mode
In order to create stereo images, you can specify the eye you are looking with (‘right’,’left’).
When exposition the model using the method NbodyDefault.expose(), the observer will be rotate around
an axis parallel to its head, with a center rotation in the direction of the look at point, at a distance
foc of the eye. The angle of the rotation is such as to move the observer of a distance dist_eye/2.
+
+
Example:
+
Left and right images may be obtained respectively with:
+
>>> nb.display(obs=None,x0=[0,-50,20],xp=[0,0,0],alpha=0,size=(5,5),persp='on',clip=(10,50),foc=100,dist_eye=0.01,eye='left')
+>>> nb.display(obs=None,x0=[0,-50,20],xp=[0,0,0],alpha=0,size=(5,5),persp='on',clip=(10,50),foc=100,dist_eye=0.01,eye='left')
+
+
+
This gives the following image that may be seen using a cross-eyed vision:
+
+
+
Shape of the final image
The shape in pixel of the final image is set by the tuple shape.
Rendering
-
space
-mode
-rendering
+
The space parameter may be either pos (default) or vel.
+In the second case, the model is displayed in velocity space.
+
The mode parameter is very important. It tells the method NbodyDefault.display() which
+physical quantities to display. By default, it value is m, meaning the mass. When used, a projected mass map (surface density)
+is returned. The value of mode may be set to any scalar linked with each particle, for example the temperature. Other values,
+given in the following table may be used.
+
By default the parameter rendering is map.
+
+
Example:
+
The model in the velocity space gives:
+
>>> nb.display(obs=None,x0=None,size=(1,1),view='xy',space='vel')
+
+
+
+
We clearly see the ofset of (0.5,0,0) in velocity of the sphere.
+
A radial velocity map is obtained using mode=vr:
+
>>> nb.display(obs=None,x0=[0,-50,25],xp=[0,0,0],alpha=0,size=(30,30),mode='vr',scale='lin',palette='rainbow4')
+
+
+
+
Note that we have used a linear scale here.
+
Lets now display the sphere.dat model
+
>>> from pNbody import *
+>>> nb = Nbody("sphere.dat",ftype='gadget')
+>>> nb.display(obs=None,x0=[-50,-50,25],xp=[0,0,0],alpha=0,size=(2,2))
+
+
+
+
This model is a discretised sphere. It is possible to render it not a single points, but as a series of segments,
+using rendering='polygon':
+
>>> nb.display(obs=None,x0=[-50,-50,25],xp=[0,0,0],alpha=0,size=(2,2),rendering='polygon')
+
+
+
+
Set color range
scale
cd
mn
mx
Set filters
filter_name
filter_opts
frsp
Draw contours
l_n
l_min
l_max
l_kx
l_ky
l_color
l_crush
Draw axis
- b_weight
- b_xopts
b_yopts
b_color
