[Previous]
[Next]
NAME:
ra_fictitious_sun
PURPOSE:
Returns right ascension of fictitious sun for specified UT time
CATEGORY:
gen/idl/ephem
CALLING SEQUENCE:
FUNCTION ra_fictitious_sun, tt, degrees=degrees, scalar=scalar
INPUTS:
tt array; standard time structure
OPTIONAL INPUT PARAMETERS:
/degrees if set, returned RA is in degrees; default: radians
OUTPUTS:
ra scalar or array; right ascension
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AngleRange, TimeGet, ToDegrees
CALLED BY:
cv, smei_normal, smei_sgp4_orbits
PROCEDURE:
MODIFICATION HISTORY:
MAR-2011, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
rank_array
PURPOSE:
Calculates rank array for a given index array
CATEGORY:
gen/idl/toolbox/math
CALLING SEQUENCE:
rank = rank_array(index)
INPUTS:
index array; type: integer
index array, i.e. array of indices returned
by the IDL sort function
OUTPUTS:
rank array; type: integer
rank array
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
IsType
CALLED BY:
boost
PROCEDURE:
The rank array inverts the index array. Applying rank to the sorted
array returns the array back into its original order: A[rank[index]] = A
MODIFICATION HISTORY:
JAN-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
ReadSynopticMap
PURPOSE:
Read a synoptic map file in standard form
CATEGORY:
I/O
CALLING SEQUENCE:
FUNCTION ReadSynopticMap, Rotation, spred = SPRed, spgreen = SPGreen
INPUTS:
Rotation integer scalar Carrington rotation number
OPTIONAL INPUT PARAMETERS:
/spgreen if set, Sac Peak Fe XIV map is read
/spred if set, Sac Peak Fe X map is read
OUTPUTS:
map 2D float array
OPTIONAL OUTPUT PARAMETERS:
CALLS: ***
FILEPATH, InitVar, flt_read
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView_Init_Display, Sky_ColorView [1], Sky_ColorView [2]
RESTRICTIONS:
keywords are processed in the order given above. The first
keyword present is processed; all others are ignored.
PROCEDURE:
The Sac Peak should be located in the $dat/map/sacpeak directory.
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS, pphick@ucsd.edu)
[Previous]
[Next]
NAME:
refine_pointing
PURPOSE:
CATEGORY:
CALLING SEQUENCE:
abg = refine_pointing(good_pos, bad_pos, /degrees)
INPUTS:
good_pos
bad_pos
OPTIONAL INPUT PARAMETERS:
OUTPUTS:
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
MEAN, ToRadians
PROCEDURE:
MODIFICATION HISTORY:
MAR-2003, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView
PURPOSE:
Calculates image of sky from 3D density matrix for a given viewer location
and viewing direction.
CATEGORY:
Volume rendering
CALLING SEQUENCE:
PRO RemoteView, $
getcube = getcube , $
fovcube = FOVCube , $ ; Output only when /getcube is set
cube = Cube , $
drawecliptic= DrawEcliptic , $
meshecliptic= MeshEcliptic , $
meshhcs = MeshHCS , $
;mergehcs = MergeHCS , $
voxel = Voxel , $
base_name = base_name , $
noplot = NoPlot , $
upto = upto , $
_extra = _extra , $
images = images , $
M3D = M3D , $
V3D = V3D , $
D3D = D3D , $
silent = silent
OPTIONAL INPUT PARAMETERS:
Most keywords are those described in RemoteView_Init.
/cube add bounding cube
/drawecliptic add ecliptic boundary
/meshecliptic add mesh in ecliptic
/noplot suppresses all plotting activity
/meshhcs add heliospheric current sheet as mesh surface
voxel array, type: integer; default: 1
up to a 4 element array of values 0,1,2 or 3.
Values 0,1 and 2 result in a 3D remote view (see
RemoteView_Display3D:
0: skip rgbo calculation (bodies and orbits only)
1: use IDL Voxel_Proj function
2: home-brew rgbo rendering (needs work)
Value 3 results in a 2D image (see RemoteView_Display2D.
The keyword f3dfnc determines the content of the 2D image
(the default is the Thomson scattering brightness)
base_dir scalar; type: string; default: getenv('TUB')
destination directory for output image files
base_name array; type: string
base name used for output image files. A 3-digit counter for
each of the views rendered is appended to the base name.
Especially if keyword 'voxel' is specified as an array (i.e.
multiple images are calculated for each view) then a separate
base_name should be specified for each of the 'voxel' entries.
/getcube ?
upto = upto passed to remoteview_display2d and remoteview_display3d
OUTPUTS:
(to screen or image file)
images=images
scalar or array; type: string
fully-qualified names of all output images created
fovcube=FOVCube
Output only when /getcube is set
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, CvSky, InitVar, IsType, REVERSE, RemoteView_BodyLoc, RemoteView_BodySize
RemoteView_CubeFrame, RemoteView_CurrentSheet, RemoteView_Destroy
RemoteView_Destroy_FOV, RemoteView_Display2D, RemoteView_Display3D
RemoteView_FOV, RemoteView_FOV_loc, RemoteView_Init, RemoteView_VertexMap
RemoteView_ZEclipticPlane, SuperArray, T3D, big_orbit, boost, destroyvar, gridgen
jpl_body
CALLED BY:
qRemoteView_Calculate, vu_remoteview
PROCEDURE:
MODIFICATION HISTORY:
APR-2001, Paul Hick (UCSD/CASS)
JUN-2004, Paul Hick (UCSD/CASS)
Added option to plot orbits for planets and Moon (depends on JPL
ephemeris). A negative Voxel value now suppresses labeling in
RemoteView_Display3D.
JUN-2010, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Explicitly added keyword upto=upto.
[Previous]
[Next]
NAME:
RemoteView_BodyLoc
PURPOSE:
Get position coordinates of Earth in a Cartesian
heliographic coordinate system (see SkyGrid for
definition coordinate system).
CATEGORY:
CALLING SEQUENCE:
FUNCTION RemoteView_BodyLoc, TT, body=body, silent=silent
INPUTS:
TT array[1]; type: time structure
time
OPTIONAL INPUT PARAMETERS:
body=body scalar; type: string
name of body
/silent if set, suppresses informational messages
OUTPUTS:
Earth array[3] X,Y,Z coordinates of Earth (in data units)
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, CvSky, InitVar, KeplerOrbit, TimeGet, TimeOp, TimeSet, big_eph, jpl_body
jpl_eph, sgp_body
CALLED BY:
RemoteView
RESTRICTIONS:
PROCEDURE:
NewcombSun is used to get the geocentric ecliptic coordinates
of the Sun. The heliocentric ecliptic coordinates of Earth
are given by the opposite point (add 180 deg to longitude;
change sign on the latitude. Then Ecliptic_Heliog is used to
convert to heliographic coordinates.
MODIFICATION HISTORY:
FEB-1997, Paul Hick (UCSD/CASS)
OCT-2006, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Replaced call to jpl_eph by call to big_eph. This makes it easier
to add bodies processed by the USNO asteroid ephemeris and any
ephemerides downloaded from the Minor Planet Center.
[Previous]
[Next]
NAME:
RemoteView_BodySize
PURPOSE:
Determine angular size of body
CATEGORY:
sat/idl/remoteview
CALLING SEQUENCE:
FUNCTION RemoteView_BodySize, rView, rSphere, fake, rOuter, fov, degrees=degrees
INPUTS:
rView scalar; type: float
distance of viewing location to body (AU)
rSphere scalar; type: float
actual radius of body (AU)
fake scalar; type: float
fake angular size to be used for displaying body
as a fraction of the FOV size
rOuter scalar; type: float
outer radius of data sphere
fov array[2]; type: double
size of FOV in hor and vert direction
OPTIONAL INPUT PARAMETERS:
/degrees if set, all angles are in degrees (default: radians)
OUTPUTS:
Result angular size of body (but never less than fake size)
expressed as fraction of the FOV size
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
ToRadians
CALLED BY:
RemoteView
PROCEDURE:
MODIFICATION HISTORY:
JULY-2001, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_CMEDensity
PURPOSE:
Adds CME density to remoteview
CATEGORY:
CALLING SEQUENCE:
FUNCTION RemoteView_CMEDensity, TT0, TT, nDim, rEdge, CMEmin, CMEmax, $
rot_cme=rot_cme, degrees=degrees, cme_smooth=cme_smooth, cme_average=cme_average
INPUTS:
TT0 array[1]; type: time structure
time assigned to the CME density matrix read from file
Usually the same as the 3D solar wind density matrix with
which the CME density is merged.
TT array[1]; type: time structure
time at which CME is displayed; the CME matrix expands
at a constant speed of V=400 km/s from time TT0 to TT
(usually TT will be a couple of days later than TT0)
The heliospheric matrix is defined by:
nDim array[3]; type: integer
# longitudinal, latitudinal and radial grid points
rEdge array[2]; type: float
inner and outer radius of radial grid (AU)
OPTIONAL INPUTS:
rot_cme=rot_cme scalar or array[2]
extra rotations applied to the CME
OUTPUTS:
CMEmin scalar; type: float
CMEmax scalar; type: float
min and max normalized density in CME matrix
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
ArrayLocation, CV_COORD, EulerRotate, FILEPATH, MEAN, TimeGet, TimeOp, TimeUnit
ToRadians, flt_read, gridgen
CALLED BY:
RemoteView_Init_Matrix
PROCEDURE:
MODIFICATION HISTORY:
SEP-1999, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Colors
PURPOSE:
Defines colors to be used for coloring heliospheric bodies
CATEGORY:
RemoteView package: volume rendering
CALLING SEQUENCE:
PRO RemoteView_Colors, colortable, $
White, Black, Purple, Red, Green, $
Greyish, Yellowish, Blueish, Reddish, Greenish
INPUTS:
(none)
OUTPUTS:
colortable
array[N,3]; type: byte; currently N=236
RGB color table used for coloring heliospheric objects
(planets, etc.).
The color table is patched together from a number of IDL
color tables. The file skycolor.pro describes the color table
Black : 0 1
White : 2 3
Purple : 4 5
Red : 6 7
Green : 8 9
Blue : 10 11
Earth : 12 15
Greyish : 16 59
Blueish : 60 103
Yellowish: 104 147
Reddish : 148 191
Greenish : 192 235
Each of these entries is returned as a two-element argument.
White, Black, Purple, Red, Green
. Greyish, Yellowish, Blueish, Reddish, Greenish
array[2]; type: integer
indices into the color arrays 'reds','green','blues' for
beginning and start color
INCLUDE:
@compile_opt.pro ; On error, return to caller
@skycolors.pro ; Dummy comment for Linux
CALLS: ***
FILEPATH, flt_read, who_am_i
INCLUDE:
@skycolors.pro
CALLED BY:
RemoteView_Init_Display
SIDE EFFECTS:
Needs files remoteview_colors_info.txt and remoteview_colors.txt,
storing the color table information.
RESTRICTIONS:
PROCEDURE:
Currently the number of elements is restricte to 236 colors to make things work
on Windows NT.
MODIFICATION HISTORY:
JUN-2000, Paul Hick (UCSD/CASS)
Split off from old skycolors.pro (now obsolete)
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
The two ascii files with color table info is now
looked for in the same directory as the source code.
[Previous]
[Next]
NAME:
RemoteView_CubeFrame
PURPOSE:
Draws outline of 3D data cube
CATEGORY:
Graphics
CALLING SEQUENCE:
FUNCTION RemoteView_CubeFrame, nS, color=Color, corners=Corners
INPUTS:
nS integer; type: float
cube size in data units
(if nL is fo type float it is rounded up to the
next integer)
OPTIONAL INPUT PARAMETERS:
color=Color scalar color index used for drawing
(if omitted then !p.color is used)
OUTPUTS:
Cube
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
IsType, gridgen
CALLED BY:
RemoteView
PROCEDURE:
Make sure the proper 3D transformation is set up.
The cube drawn extends from 0 to nDim-1 in all three dimensions.
MODIFICATION HISTORY:
Feb-1997, Paul Hick (UCSD)
[Previous]
[Next]
NAME:
RemoteView_CurrentSheet
PURPOSE:
Find the polygons of the currentsheet surface in cartesian coordinates
for a given helographic-sperical B3D matrix.
CATEGORY:
tool
CALLING SEQUENCE:
FUNCTION RemoteView_CurrentSheet, FOVInfo, P
INPUTS:
FOVInfo array[1]; type: structure
structure set up by RemoteView_Init_FOV
B3D array[lng,lat,rad]; type: float
3D magnetic data;
OUTPUTS:
Result array[3,*]; type: float
polygon coordinates in rectangular coordinates
Units are data units (usually AU).
P array[*]; type: integer
information about polygons (# points for each polygon,
and index lists for all points in each polygon)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AngleRange, BadValue, CV_COORD, IsType, gridgen
CALLED BY:
RemoteView
PROCEDURE:
> Taking a B3D array in heliographic spherical convert to cartesian.
> Create a currentsheet based on B3D information
> Build a contoured surface at that currentsheet out of polygons
> Return the list of vertices and polygon-connectivity
MODIFICATION HISTORY:
OCT-2001, T. Dunn (tdunn@ucsd.edu)
JUL-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Integrated into RemoteView package
[Previous]
[Next]
NAME:
RemoteView_Destroy
PURPOSE:
Clean up heap variables
CATEGORY:
RemoteView package
CALLING SEQUENCE:
PRO RemoteView_Destroy, M3D=M3D, V3D=V3D, D3D=D3D
INPUTS:
M3D array[1]; type: structure
V3D array[1]; type: structure
D3D array[1]; type: structure
OUTPUTS:
(none)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView, RemoteView_Init
PROCEDURE:
Destroy heap variables associated with the M3D, V3D and D3D structures
MODIFICATION HISTORY:
JULY-2001, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Destroy_FOV
PURPOSE:
Clean up heap variables
CATEGORY:
RemoteView package
CALLING SEQUENCE:
PRO RemoteView_Destroy_FOV, FOVInfo
INPUTS:
FOVInfo array; type: structure
array of FOVInfo structures
OUTPUTS:
(none>
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView, RemoteView_Init
PROCEDURE:
Destroy heap variables associated with FOVInfo.view_elo and FOVInfo.matrix
The FOVInfo structure contains three pointers to heap variables.
FOVInfo.view_elo always needs to be cleared.
FOVInfo.matrix and FOVInfo.matrixb only need to be cleared if they point
to an interpolated matrix (see RemoteView_Init_FOV).
MODIFICATION HISTORY:
JULY-2001, Paul Hick (UCSD/CASS)
JULY-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Updated to handle pointer to magnetic field.
[Previous]
[Next]
NAME:
RemoteView_Display2D
PURPOSE:
Calculates a line-of-sight integration throught the 3D volume data in
FOVCube.
CATEGORY:
RemoteView project
CALLING SEQUENCE:
PRO RemoteView_Display2D, D3D, FOVInfo, FOVCube, FOVLoc, iView, $
voxel = Voxel , $
f3dfnc = f3dfnc , $
w3dfnc = w3dfnc , $
losarg = losarg , $
base_dir = base_dir , $
base_name = base_name , $
images = images , $
title = title , $
format = format , $
logo = logo , $
rim = rim , $
silent = silent , $
range = range , $ ; obsolete
full_range = full_range, $
view_nr = view_nr , $
radialfilter= radialfilter, $
upto = upto , $
_extra = _extra
INPUTS:
D3D array[1]; type: structure
contains information about volume data (see
RemoteView_Init)
FOVInfo
FOVCube array[nX,nY,nZ]; type: float
function values covering fov of nX,nY lines of sight
at nZ positions along line of sight
FOVLoc array[3,nX,nY,nZ]; type: float
heliographic locations at all of the line of sight
segments. Always in spherical coordinates (even for
rectangular matrix) i.e. heliographic longitude,
latitude in radians; and heliocentric distance in AU.
iView scalar; type: integer
image number (used only in file name construction)
OPTIONAL INPUT PARAMETERS:
base_dir=base_dir
scalar; type: string; default: getenv('TUB')
destination directory for all image files
base_name=base_name
scalar; type: string; default: f3dfnc
base name for output image files
view_nr=view_nr scalar; type: integer; default: none
overrides argument 'iView'
iView is the loop parameter used in the calling
procedure RemoteView to loop over multiple
view. Often RemoteView itself is called in a loop
processing a single view per call. iView will
always be 1 in this case, and image files would
be overwritten. Keyword view_nr can be added to
the RemoteView call to replace iView and avoid
overwriting of images.
full_range=full_range
array[2]; type: float; default: [0.1,1.0]
range of data values displayed
f3dfnc = f3dfnc
w3dfnc = w3dfnc
losarg = losarg
logo=logo scalar; type: string; default: none
if "logo" is not an existing file the string is
plotted in the lower left corner of the display.
alternatively it is the name of a tiny image file to
be put in lowerleft corner of display.
(This must be a truecolor image).
upto = upto scalar; type: integer; default: TimeUnit(/sec)
controls precision of time string added to image
OUTPUTS:
(images to display or file)
images=images scalar or array; type: string
fully-qualified names of all image files created
(if no image was created, 'images' will be undefined)
INCLUDE:
@compile_opt.pro ; On error, return to caller
@vu_fnc_include.pro ;
EXTERNAL:
ThomsonBrightness
CALLS: ***
BadValue, CONGRID, CheckDir, CvSky, FILEPATH, GetColors [1], GetColors [2]
GetColors [3], IPS_params, InitVar, IntegrateLOS, IsType, LOADCT, REVERSE, SuperArray
ThomsonRadialFilter, ThomsonUBVConst, TimeGet, TimeUnit, WRITE_BMP, WRITE_GIF
WRITE_PPM, big_eph, boost, destroyvar, flip_colors, gridgen, img_read, twin, vu_fnc
CALLED BY:
RemoteView
COMMON BLOCKS:
common SkyDisplaySave, PreviousImage
PROCEDURE:
MODIFICATION HISTORY:
JUN-2001, Paul Hick (UCSD/CASS)
SEP-2008, Paul Hick (UCSD/CASS)
Added legend. Modified labeling.
JUN-2010, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added keyword upto to control precision of output string
[Previous]
[Next]
NAME:
RemoteView_Display3D
PURPOSE:
Collapses the 3D volume data in FOVCube to a 2D view ready for display using
some form of rgbo rendering
CATEGORY:
RemoteView project
CALLING SEQUENCE:
PRO RemoteView_Display3D, D3D, FOVInfo, FOVCube, FOVLoc, iView, $
FOVCubeB = FOVCubeB , $
voxel = Voxel , $
base_dir = base_dir , $
base_name = base_name , $
images = images , $
title = title , $
format = format , $
logo = logo , $
rim = rim , $
silent = silent , $
view_nr = view_nr , $
upto = upto , $
_extra = _extra
INPUTS:
D3D array[1]; type: structure
info about volume data (see RemoteView_Init)
FOVCube array[nX,nY,nZ]; type: float
function values covering fov of nX,nY lines of sight
at nZ positions along line of sight
FOVLoc array[3,nX,nY,nZ]; type: float
heliographic locations at all line of sight segments.
Always returned in spherical coordinates (even for
rectangular matrix) i.e. heliographic longitude,
latitude in radians; and heliocentric distance in AU.
iView scalar; type: integer
image number (used only in file name construction)
OPTIONAL INPUT PARAMETERS:
FOVCubeB=FOVCubeB
array[nX,nY,nZ]; type: float
magnetic field values covering fov of nX,nY lines of
sight at nZ positions along line of sight
voxel=Voxel scalar; type: integer; default: 0
0: skip rgbo calculation (bodies and orbits only)
1: use IDL Voxel_Proj function
(doesn't work in IDL 5.4 unless the patch
Voxel_Proj2 is available)
2: home-brew rgbo rendering (needs work)
base_dir=base_dir
scalar; type: string; default: getenv('TUB')
destination directory for all image files
base_name-base_name
scalar; type: string; default: f3dfnc
base name for output image files
view_nr=view_nr scalar; type: integer; default: none
overrides argument 'iView'
iView is the loop parameter used in the calling
procedure RemoteView to loop over multiple
view. Often RemoteView itself is called in a loop
processing a single view per call. iView will
always be 1 in this case, and image files would
be overwritten. Keyword view_nr can be added to
the RemoteView call to replace iView and avoid
overwriting of images.
logo=logo scalar; type: string; default: none
if "logo" is not an existing file the string is
plotted in the lower left corner of the display.
alternatively it is the name of a tiny image file to
be put in lowerleft corner of display.
(This must be a truecolor image).
rim=rim array[4]; type: float; default: [0.0,0.15,0.1,0.1]
upto = upto scalar; type: integer; default: TimeUnit(/sec)
controls precision of time string added to image
OUTPUTS:
(images to display or file)
images=images scalar or array; type: string
fully-qualified names of image files
(if no images were created, 'images' will be undefined)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CONGRID, CheckDir, FILEPATH, InitVar, IsType, LOADCT, REVERSE, RGBO_DepthCue
RGBO_Project, RemoteView_Matte, SuperArray, TimeGet, TimeUnit, WRITE_BMP, WRITE_GIF
WRITE_PPM, boost, destroyvar, flip_colors, img_read, twin
CALLED BY:
RemoteView
COMMON BLOCKS:
common SkyDisplaySave, PreviousImage
PROCEDURE:
The common block is used to store the left image when an interleaved
image is requested. (after the right image is calculated the left and
right images are merged).
MODIFICATION HISTORY:
AUG-2000, Paul Hick (UCSD/CASS)
AUG-2002, Paul Hick (UCSD/CASS)
Our home-made rgbo rendering engine (voxel=2) seems to work now.
Added option to include depth cueing, and an option to do 'radial
cueing' (multiply opacity with a radial distance-dependent function).
Added color legend to display, together with minimal annotation.
JUN-2004, Paul Hick (UCSD/CASS)
A negative Voxel value now suppresses the labeling and color bar.
JUN-2010, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_EqTrans
PURPOSE:
Sets integer ID of mapping used to map sky to display
CATEGORY:
RemoteView project
CALLING SEQUENCE:
FUNCTION RemoteView_eqtrans, EqTrans, eqdistance=EqDistance, eqangle=EqAngle, eqarea=EqArea
OPTIONAL INPUT PARAMETERS:
/eqdistance preserve distance to line of sight through center of image
(this is the default if no keywords are set)
/eqangle preserve angular distance to line of sight through center of image
/eqarea preserve area on sky;
OUTPUTS:
Result scalar; type: integer
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView_FOV_Edge, RemoteView_FOV_loc, RemoteView_FOV_xyz
RemoteView_Init_View
PROCEDURE:
MODIFICATION HISTORY:
SEP-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_FOV
PURPOSE:
Calculates image of sky from 3D density matrix for a given viewer location
and viewing direction.
CATEGORY:
RemoteView package: Image construction
CALLING SEQUENCE:
FUNCTION RemoteView_FOV, V3D, M3D, FOVCube, FOVInfo, FOVLoc, $
view_index=view_index, FOVCubeB=FOVCubeB, silent=silent
INPUTS:
V3D array[1]; type; structure
structure array containing information about the views
to be calculated.
M3D array[1]; type: structure
structure containing 3D density matrices and associated
information; passed to RemoteView_Init_FOV
OPTIONAL INPUT PARAMETERS:
view_index=view_index
scalar; type: integer
index of a single view to be processed
/silent suppress informational messages
OUTPUTS:
FOVCube array[nDim[0],nDim[1],nDim[2],nView]
Output matrix with interpolated data values.
This is the matrix that needs to be integrated along the 3rd
(line-of-sight) dimension to create the 2D sky image
FOVInfo array[nView]; type: structure
structure array combining information about a the 3D density
matrices for all views.
FOVLoc array[3,nDim[0],nDim[1],nDim[2]]; type: float
(only returned when 'view_index' is specified)
heliographic locations at all of the line of sight segments.
Always returned in spherical coordinates (even for rectangular
matrix) i.e. heliographic longitude, latitude in radians; and
heliocentric distance in AU.
FOVCubeB = FOVCubeB
array[nDim[0],nDim[1],nDim[2],nView]
Output matrix with interpolated data values for magnetic field.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
InitVar, IsType, RemoteView_FOV_Cube, RemoteView_Init_FOV, SuperArray, TimeGet
TimeSystem, TimeUnit, destroyvar
CALLED BY:
RemoteView, RemoteView_Init
PROCEDURE:
The FOVCube matrix is set up as a float array using the sizes of the two input
structures.
For each view Sky_Grid_Struct is called, returning a new structure combining
all the necessary information (3D density matrix and view).
RemoteView_FOV_Cube does the actual actual calculation; its output is used to fill the
FOVCube array.
MODIFICATION HISTORY:
DEC-2000, Paul Hick (UCSD/CASS)
OCT-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added keyword /silent
[Previous]
[Next]
NAME:
RemoteView_FOV_Cube
PURPOSE:
CATEGORY:
3D viewing
CALLING SEQUENCE:
FUNCTION RemoteView_FOV_Cube, FOVInfo, x, R=R, bcube=BCube
INPUTS:
FOVInfo array[1]; type: structure
OUTPUTS:
status 0: no data inside field of view for specified viewing direction
1: there are data inside the field of view
FOVCube array[nX,nY,nZ]; type: float
function values covering fov of nX,nY lines of sight
at nZ positions along line of sight
OPTIONAL OUTPUT PARAMETERS:
R=R array[3,nX,nY,nZ]; type: float
heliographic locations at all of the line of sight
segments. Always returned in spherical coordinates (even
for rectangular matrix) i.e. heliographic longitude,
latitude in radians, and heliocentric distance in AU.
bcube=BCube array[nX,nY,nZ]; type: float
function values for magnetic field covering fov of nX,nY
lines of sight at nZ positions along line of sight
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AngleRange, CV_COORD, CvT3d, RemoteView_FOV_xyz, sphere_distance
CALLED BY:
RemoteView_FOV
PROCEDURE:
> Read the RemoteView document (in D:\work\doc\remoteview.doc) for a
detailed description.
> The 3D data set is specified in an arbitrary Cartesian coordinate
system x-y-z.
> The data set is contained within a sphere of radius DataRadius centered
on the origin.
> Put a rectangle with sides 2*tan(FOVInfo.view_fov) in a plane perpendicular
to the viewer direction at a distance of one unit. Define a rectangular
grid of dimension nX x nY covering the rectangle. Connect the origin with
each of the nX x nY grid points to define an angular grid.
> Define a radial grid of dimension nZ extending outward from the
observer between FOVInfo.view_extent[0] and FOVInfo.view_extent[1].
> The radial and angular grid define a 'sky grid' covering the portion of
space along the viewing direction which may contain data.
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS)
DEC-1998, Paul Hick (UCSD/CASS, pphick@ucsd.edu), rewrite
[Previous]
[Next]
NAME:
RemoteView_FOV_Edge
PURPOSE:
CATEGORY:
RemoteView project
CALLING SEQUENCE:
FUNCTION RemoteView_FOV_Edge, fov, EqTrans
INPUTS:
fov scalar; type: float
half-width of field of view (radians)
EqTrans scalar; type: integer
defines the type of transformation between fov and sky.
OUTPUTS:
fovedge scalar; type: float
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
RemoteView_EqTrans
CALLED BY:
RemoteView_FOV_loc, RemoteView_FOV_xyz
PROCEDURE:
MODIFICATION HISTORY:
DEC-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_FOV_loc
PURPOSE:
CATEGORY:
3D viewing
CALLING SEQUENCE:
FUNCTION RemoteView_FOV_loc, vector, FOVInfo, $
rectangular = rectangular , $
dloc = dloc
INPUTS:
vector array[3,*]; type: float
heliographic coordinates (spherical or, if
/rectangular, Cartesian) of points to be
converted to display coordinates.
Distances are in data units (usually AU).
FOVInfo array[1]; type: structure
structure set up by RemoteView_FOV
OPTIONAL INPUT:
/rectangular if set then 'vector' is in rectangular heliographic
coordinates (default is spherical coordinates).
OUTPUTS:
Result arrays[3,*]
input vector points converted to sky coordinates.
These are normal coordinates, i.e. points inside
the fov range from 0 to 1.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
BadValue, CV_COORD, CvT3d, InitVar, RemoteView_EqTrans, RemoteView_FOV_Edge
SyncDims
CALLED BY:
RemoteView
PROCEDURE:
> Read the RemoteView document (remoteview.doc) for
a detailed description.
> The 3D data set is specified in an arbitrary Cartesian
coordinate system x-y-z.
> The data set is contained within a sphere of radius DataRadius
centered on the origin.
> Put a rectangle with sides 2*tan(Fov) in a plane
perpendicular to the viewer direction at a distance of one unit.
Define a rectangular grid of dimension nDimX x nDimY covering
the rectangle. Connect the origin with each of the nDimX x nDimY
grid points to define an angular grid.
> Define a radial grid of dimension nDimZ covering the range
FOVInfo.view_extent
> The radial and angular grid define a 'sky grid' covering the
portion of space along the viewing direction which may
contain data.
STRUCTURES:
FOVInfo.view_loc, FOVInfo.view_dir, FOVInfo.view_fov,
FOVInfo.view_tilt, FOVInfo.view_eqtrans, FOVInfo.view_extent
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS)
Rewrite
SEP-2008, Paul Hick (UCSD/CASS, pphick@ucsd.edu)
Bug fix?. The calculation of the z-component
(depth) for the FOV coordinates did not
preserve the sign of the z-component of the
native camera coordinates system. As a result
point "behind" the camera where put "in front"
of the camera.
Coordinates for points "behind" the camera are
now explicitly set to NaN in the return array.
[Previous]
[Next]
NAME:
RemoteView_FOV_xyz
PURPOSE:
Internal use. Should be called by RemoteView_FOV_Cube only.
CATEGORY:
RemoteView project
CALLING SEQUENCE:
FUNCTION RemoteView_FOV_xyz, x, FOVInfo, bigmemory=bigmemory, $
fov=fov, eqtrans=eqtrans
INPUTS:
x float array[4,nDimX,nDimY,nDimZ]
Initialized in calling program RemoteView_FOV_Cube with:
x = fltarr(4,nDimX,nDimY,nDimZ, /nozero)
Only x[0:2,*,*,*] is filled here.
FOVInfo array[1]; type: structure
structure set up by RemoteView_Init_FOV
OPTIONAL INPUT PARAMETERS:
/bigmemory if set then no explicit do-loops are used in the calculations.
This will be significantly faster if lots of memory is available
(i.e. as long as no disk swapping is needed)
OUTPUTS:
Result float array[4,nDimX*nDimY*nDimZ]
Cartesian coordinates of locations where interpolated
densities are required. The coordinate system is the X,Y,Z
coordinate system defined in the RemoteView document.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
InitVar, IsType, RemoteView_EqTrans, RemoteView_FOV_Edge, gridgen
CALLED BY:
RemoteView_FOV_Cube, RemoteView_Init_FOV
PROCEDURE:
If the output array is reformed to Result[4,nDimX,nDimY,nDimZ] then the nDimX and
nDimY dimensions cover field of view. The nDimZ dimension is the 'depth' dimension.
It stores the distance to the viewer location starting at the maximum distance from
the viewer, i.e. R[*,*,*,0] is the depth layer farthest away from the viewer along
the line of sight; R[*,*,*,nDimZ-1] is closest to the viewer.
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS, pphick@ucsd.edu), adapted for handling of
time-dependent tomography
[Previous]
[Next]
NAME:
RemoteView_FovTilt
PURPOSE:
Calculates the angle between the projections of
the solar north and ecliptic north in the fov
CATEGORY:
sat/idl/remoteview
CALLING SEQUENCE:
FUNCTION RemoteView_FovTilt, TT, Dir, degrees=degrees
INPUTS:
TT array[1] or array[K]
Dir array[2] or array[2,K]
Viewing direction in heliographic spherical
coordinates
OPTIONAL INPUT PARAMETERS:
/degrees if set all angles are in degrees (default is radians)
OUTPUTS:
R array[2,K]
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CvSky, CvT3d, ToRadians
CALLED BY:
RemoteView_Init_View
PROCEDURE:
MODIFICATION HISTORY:
MAR-2000, Paul Hick (UCSD/CASS)
SEP-2008, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Total rewrite. The old version was only valid for
the special case where the viewing direction was
straight back to the Sun
[Previous]
[Next]
NAME:
RemoteView_Init
PURPOSE:
Sets up structure for volume data and viewing information
CATEGORY:
sat/idl/remoteview
CALLING SEQUENCE:
PRO RemoteView_Init, M3D, V3D, D3D, getcube=GetCube, fovcube=FOVCube, silent=silent, _extra=_extra
OPTIONAL INPUT PARAMETERS:
/silent controls display of messages
/getcube
if set, only the volume data array FOVCube is returned.
None of the structures will exist on return.
Keywords defining the volume data (passed to RemoteView_Init_Matrix)
f3dmat
b3dmat
matrix_time
matrix_rect
volsize
start_lng
degrees
cme
Keywords passed to RemoteView_Init_View are explained there:
degrees
view_rect
ecliptic
location
direction
view_time
fovsize
fovtilt
stereo
ngrid
eqdistance
eqangle
eqarea
Keywords passed to RemoteView_Init_Display are explained there:
xysize
gif
tiff8
tiff24
bmp8
bmp24
interleave
probe
helios
twinsc
spgreen
spred
earth
rotation (????)
Keywords passed to RemoteView_rgbo are explained there:
full_color,
full_opacity
mid_range
mid_color
mid_opacity
opacity_power
update
rotation=Rotation scalar; type: float
The value of Rotation is used in three ways:
1. the fractional part is used to set the starting heliographic longitude,
e.g. 1884.0 starts at 0 degrees; 1884.25 at 270 degrees.
2. if the image time in the States array is set to !values.f_nan, it is
assumed to be the time at which the longitude corresponding to 'Rotation'
crossed the central meridian (i.e. it is set to CarringtonT(Rotation))
3. Rotation is passed to ReadSynopticMap to read in a map to be wrapped around
the surface of the Sun
OUTPUTS:
M3D array[1]; type: structure
contains information about volume data
V3D array[1]; type: structure
contains information about view
D3D array[1]; type: structure
contains information about display
OPTIONAL OUTPUT PARAMETERS:
fovcube = FOVCube
4-dim array; type: float
Output only when /getcube is set. Contains the volume data
for all views.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
InitVar, IsType, RemoteView_Destroy, RemoteView_Destroy_FOV, RemoteView_FOV
RemoteView_Init_Display, RemoteView_Init_Matrix, RemoteView_Init_View
CALLED BY:
RemoteView
PROCEDURE:
The structures are actually set up by the RemoteView_Init_* functions. This procedure just
functions as a wrapper to keep everything in one place.
MODIFICATION HISTORY:
APR-2001, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Init_Display
PURPOSE:
Set up the SKY_DISPLAY3D structure.
CATEGORY:
RemoteView project
CALLING SEQUENCE:
FUNCTION RemoteView_Init_Display, fminmax, $
xysize = xysize , $
binary = Binary , $
tiff8 = Tiff8 , $
tiff24 = Tiff24 , $
bmp8 = Bmp8 , $
bmp24 = Bmp24 , $
gif = Gif , $
ppm = Ppm , $
png = Png , $
jpg = Jpg , $
interleave = Interleave, $
body = body , $
rotation = Rotation , $
spgreen = SPGreen , $
spred = SPRed , $
full_range = full_range, $
mergehcs = mergehcs , $
tinysize = tinysize , $
_extra = _extra
INPUTS:
fminmax array[2]; type: float
used if 'full_range' not specified. Typically, this
is set to minimum and maximum of the volume data by
the calling procedure (e.g. RemoteView_Init).
OPTIONAL INPUT PARAMETERS:
full_range=full_range
scalar or array[2]; type: any; no default
(MUST be specified)
A scalar is interpreted as [0,full_range]
The full range of values of rendered data in data
units. These keywords is processed by
RemoteView_rgbo and are after return stored
in the output structure.
xysize = xysize scalar or array[2]; default: [400,400]
dimension of plot window and z-buffer
/tiff8, /tiff24, /bmp8, /bmp24, /gif, /ppm, /png
if one of these is set then the image is build in the
z-buffer and then written to the appropriate image file.
/binary
writes a binary file
/interleave
body=body array; type: string; default: ['Sun','Earth&']
names of bodies to be embedded in the display
names can be any of the bodies from the JPL ephem
(see jpl_body), one of the USNO asteroids
(see usno_body), a body for which ephemerides
are available from the Minor Planet Center (see
mpc_body), or one of
'Helios 1','Helios 2','Fire','SMEX','Stereo-E','Stereo-W'
If the symbol '&' is tag on the end of the name the orbit
is also embedded. This does not work for the spacecraft.
If the symbol '@' is added then a map is wrapped around
the body. This works only for Earth.
rotation=Rotation scalar; type: integer
Rotation is passed to ReadSynopticMap to read in a map
to be wrapped around the surface of the Sun (together
with /spgreen or /spred setting).
/spgreen, /spred if set then this can be used to select the Sac Peak
green or red line map for the rotation set with keyword
Rotation.
OUTPUTS:
S array[1]; SKYVIEW_DISPLAY structure
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
FILEPATH, InitVar, READ_BMP, ReadSynopticMap, RemoteView_Colors
RemoteView_VertexSphere, RemoteView_rgbo, big_body, jpl_body
CALLED BY:
RemoteView_Init
PROCEDURE:
The SKY_DISPLAY3D structure contains information which does not depend on
the viewing location and direction (mainly which celestial bodies to
display).
MODIFICATION HISTORY:
JUN-2000, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu), adapted for handling of
sequence of matrices from time-dependent tomography.
JUN-2004, Paul Hick (UCSD/CASS)
Added markorbit to contol plotting of planetary orbits
OCT-2006, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added /linear, /neat, /bradley
[Previous]
[Next]
NAME:
RemoteView_Init_FOV
PURPOSE:
Set up structure for RemoteView_FOV
CATEGORY:
RemoteView project
CALLING SEQUENCE:
FUNCTION RemoteView_Init_FOV, iT, V3D, M3D
INPUTS:
iT scalar; type: integer
counter for current view (as index into V3D)
V3D array[1]; type; structure
structure array containing information about the views
to be calculated.
M3D array[1]; type: structure
structure containing 3D density matrices and associated
information; passed to Sky_Grid_Struct
OUTPUTS:
FOVInfo array[1]; type: structure
structure combining information about a single 3D density
matrix and a single view. The single density matrix and
view are derived from the two input structure arrays.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AlignHeliosphere, CV_COORD, EulerRotate, RemoteView_FOV_xyz, TimeOp, TimeUnit
sphere_distance
CALLED BY:
RemoteView_FOV
RESTRICTIONS:
The interpolation scheme assumes that the matrices are sorted into
chronological order.
PROCEDURE:
> The time for view iT is compared with the matrix times. A new matrix is
calculated by interpolating between two matrices.
> If the view time coincides exactly with a matrix time then no
interpolation is needed. In this case the FOVInfo structure will just
point to the appropriate original matrix.
> If only one matrix is specified then this matrix is always used (i.e.
the specified times are ignored.
> The V3D and M3D contain information about ALL views and ALL matrices,
respectively. The SKYVIEW_FOV structure is assembled from the two
structures and describes a single view and matrix.
matrix This is a pointer to a 3D density matrix
matrix_index Time index into 3D matrix (=0 for interpolated matrix)
matrix_rect Set to 1 for rectangular matrix
matrix_rEdge Inner and outer radius of data (AU)
matrix_dR AU/grid spacing
matrix_Origin Location of origin (grid spacings; only for rectangular data)
matrix_lng0 Start heliographic longitude of matrix
view_loc Viewing location : lng, lat in radians; distance in AU
view_dir Viewing direction: lng, lat in radians
view_fov Angular half-width field of view (radians)
view_tilt Field of view tilt angle (radians)
view_ndim Dimensions of field of view cube
view_eqtrans
view_extent Minimum, maximum distance along line of sight
view_elo Elongation across field of view
MODIFICATION HISTORY:
DEC-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Init_Matrix
PURPOSE:
Defines structure for storing 3D matrix and associated information
CATEGORY:
Sky project: structure definition
CALLING SEQUENCE:
FUNCTION RemoteView_Init_Matrix, $
f3dmat = F3Dmat, $
b3dmat = B3Dmat, $
matrix_time = matrix_time, $
matrix_rect = matrix_rect, $
volsize = volsize, $
start_lng = start_lng, $
degrees = degrees, $
; keyword view_time and rot_cme are accessed only if /cme is set.
; They SHOULD NOT BE MODIFIED.
cme = cme, $
view_time = view_time, $
rot_cme = rot_cme, $
silent = silent
INPUTS:
F3Dmat array[N,L,M,K]; type: float
array[N,L,M ] (K = 1)
Specifies a sequence of 3D heliospheric volume data to be rendered.
The array must have at 3 or 4 dimensions. The first three are the
spatial dimensions; the last usually is the time dimension. The matrix
can be specified on a Cartesian or a spherical grid, but always refers
to heliographic coordinates:
Each matrix F3Dmat[*,*,*,k] (k=0,K-1) represents a spatial
scalar solar wind quantity at time TT[k].
The matrix covers a whole Carrington rotation (360 degree
in heliographic longitude) starting at longitude start_lng (see below)
Rectangular: N=L=M; cube of data with the location of the Sun
as implied by 'volsize' keyword (see below).
Spherical: N=# longitudes covering 360 deg
L=# latitudes covering -90,90 deg
M=# heliocentric distances covering [volsize[0],volsize[1]]
The Sun is located at radial distance 0.
B3Dmat array[N,L,M,K]; type: float
array[N,L,M ] (K = 1)
Radial component of the magnetic field, corresponding to F3Dmat volume date.
OPTIONAL INPUT PARAMETERS:
Parameters used to define the volume data matrix.
matrix_time=matrix_time
array[1] or array[K]; type: time structure
times for each of the K 3D matrices in F3Dmat
For K=1 no time needs to be specified.
/matrix_rect
if set then F3Dmat refers to a Cartesian (rectangular) coordinate system
(default is a spherical coordinate system).
volsize=volsize
scalar, array[2]; type: float; default: [0,1.5]
A scalar is interpreted as [0,volsize]
Cartesian: volsize[1] is half the size of the cube covered by F3Dmat
(volsize[0] is not used)
Spherical: heliocentric distance range covered by F3Dmat
volsize=volsize
Determines the spatial extent of the volume covered by F3Dmat (in AU).
If tomography files are read then this keyword can be used to limit the extent.
of the volume rendered.
If /matrix_rect NOT set (spherical data set)
scalar or array[2]; type: float; default: [0,1.5]
A scalar is interpreted as [0,volsize].
volsize[0] and volsize[1] are the inner and outer radial boundary of F3Dmat
If /matrix_rect set (rectangular data set)
scalar, array[2], array[3], array[2,3]
volsize determines the edges of the cube in x, y and z dimension, respectively.
-A scalar volsize is interpreted as
[[-volsize,volsize], [-volsize,volsize], [-volsize,volsize]] i.e. the
origin of the coordinate system is in the center of a cube with sides 2*volsize.
- An array[2] is interpreted as
[[-volsize[0],volsize[1]], [-volsize[0],volsize[1]], [-volsize[0],volsize[1]]]
i.e. the volume is a cube with sides volsize[1]-volsize[0], but the origin is
not necessarily in the center.
-An array[3] is interpreted as
[[-volsize[0],volsize[0]], [-volsize[1],volsize[1]], [-volsize[2],volsize[2]]]
i.e. the size of the volume is different for all dimensions, but the
origin is still in the center of the volume.
start_lng=start_lng
scalar or array[K]; type: float: default: 0.0
start heliographic longitude of the matrices in F3Dmat
If K > 1 then start_lng can be an array with different start
longitudes for each of the K matrices in F3Dmat.
(if scalar is used then the same value is used for all K matrices).
/degrees if set then start_lng is assumed to be in degrees.
cme=cme if set then RemoteView_CMEDensity is called to add the density of a CME to
the input F3Dmat density matrix. This is an old trick which superposes
a 3D HELIOS CME density on the input volume data.
if /matrix_rect is set then this keyword is ignored
If /cme is set then:
The CME density matrix is assigned the same time as the matrix time.
The CME is expanded from matrix_time to view_time (usually the view times
will be a couple of days later than the matrix time).
rot_cme are two angles (in radians) used to rotate the CME matrix to
the desired part of the heliosphere
OUTPUTS:
M3D array[1]; type: Sky_Matrix3D structure
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView_Init
RESTRICTIONS:
For matrices referring to Cartesian coordinates the grid spacings in all three dimensions
must correspond to the same physical distance in AU. So it is not permitted e.g to use
a grid spacing of 0.2 AU for the x-dimension and 0.1 for y and z.
CALLS: ***
AngleRange, BadValue, InitVar, IsType, MEAN, RemoteView_CMEDensity, SuperArray
TimeSystem, ToRadians
PROCEDURE:
> The 3D matrix F3Dmat is specified in a heliographic coordinate system, with
x and y axis in the solar equator and z-axis toward solar north. The Sun is
located in the origin. The heliographic longitude of the x-axis is given by
'start_lng'.
> If only one spatial matrix is specified (i.e. K=1) then the time keyword need not be specified
(unless /cme is set)
> The structure used to carry around information about the 3D matrix.
time array[K] time of matrix (pointer to heap variable)
F3Dmat array[n,m,l,K] the matrix itself (pointer)
Lng0 array[K] heliographic longitude at start of matrix (pointer)
dR float spatial resolution (AU/grid spacing)
rEdge fltarr(2) inner and outer edge (grid spacings)
Origin float(3) location of Sun (grid spacings) (0,0,0) for spherical matrix)
rectangular integer 0: spherical coordinates; 1: Cartesian coordinates
MODIFICATION HISTORY:
MAY-2000, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu), adapted to handle a sequence of
matrices from time-dependent tomography
[Previous]
[Next]
NAME:
RemoteView_Init_View
PURPOSE:
CATEGORY:
CALLING SEQUENCE:
FUNCTION RemoteView_Init_View, $
view_rect = view_rect, $
ecliptic = ecliptic, $
location = location, $
direction = direction, $
time = time, $
view_time = view_time, $
fovsize = fovsize, $
fovtilt = fovtilt, $
degrees = degrees, $
ngrid = ngrid, $
stereo = stereo, $
eqdistance = EqDistance, $
eqangle = EqAngle, $
eqarea = EqArea, $
earth = earth, $
silent = silent
OPTIONAL INPUT PARAMETERS:
(only one of location, direction, view_time, fovsize and
fovtilt needs to be specified as an array with trailing
dimension K to set up an array of views, e.g. if the same
view is needed for different times then view_time will be an
array[K], while location is an array[3], direction an
array[2] and fovsize and fovtilt are scalars).
/degrees
if set then all angles are in degrees (default is radians)
/view_rect
By default, spherical coordinates are used (longitude,
latitude, heliocentric distance). If /view_rect is set
rectangular coordinates are used.
This applies to Location and Direction
/ecliptic
By default, a heliographic coordinates are used. If /ecliptic is
set an ecliptic coordinate system is used.
This applies to Location, Direction and fovtilt
location = location
array[3] or array[3,K]; type: float
viewing locations
Longitude, latitude, heliocentric distance (if /view_rect NOT set),
or x, y and z coordinates relative to Sun (if /view_rect set).
The distance unit is AU. The unit for angles depends on the /degree setting.
If location is not set then a default location is selected
based on the location of Earth. Currently the default location
has the same ecliptic longitude as Earth, ecliptic latitude
of 30 degrees, and a distance of 3 times the Sun-Earth distance.
If keyword location is also specified then parts of location
that are not set to bad will be inserted in the default viewing
location.
/earth selects the position of Earth as the viewing location
If keyword location is also specified then parts of location
that are not set to bad will be inserted in the viewing
location.
direction = direction
array[2] or array[2,K] (if /view_rect NOT set); type: float
viewing direction for center of field of view as longitude and latitude
array[3] or array[3,K] (if /view_rect set); type: float
viewing direction in rectangular coordinates (in AU). Only the direction
will be used.
The direction is specified in the same coordinate system as the viewer
location, but with the viewer in the origin. If no direction is specified
then the direction towards the origin is used.
view_time = view_time
array[1] or array[K]; type: time structure
times for all views; if not specified then keyword 'time' is used;
if this also is not specified the the system time is used.
fovsize = fovsize
scalar, array[2], array[2,K]; type: float
Angular half-widths (horizontal and vertical) of rectangular field of view
If scalar is specified then horizontal and vertical
size are assumed to be the same.
fovtilt = fovtilt
scalar or array[K]; type: float
??? Tilt angle of field of view. Zero tilt means that the horizontal
direction in the image is parallel to the ecliptic or solar
equator (depending on the setting of keyword /ecliptic)
Tilt angle increases counterclockwise.
ngrid = ngrid
scalar or array[3]; type: integer; default: [31,31,31]
dimension of the 3D matrix describing the view. The first and second
dimension is the 'horizontal' and 'vertical' direction in the field of view.
The third is the 'depth' dimension (along the lines of sight)
/stereo
stereo = [Angle,Distance]
/stereo if set, stereo pairs are produced using default
settings for stereo angle (6 degrees) and
distance (Sun-viewer distance)
stereo=[Angle, Distance]
if specified as a two-element array, the first
element is used as stereo angle, the second as
stereo distance. If the distance is set to zero
then the viewer-origin distance Loc[2,*] is used.
/eqdistance preserve distance to line of sight through center of image
/eqangle preserve angular distance to line of sight through center of image
/eqarea preserve area on sky;
OUTPUTS:
Result array[1]; type: SMEIremoteView structure
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AngleRange, CV_COORD, Carrington, CvSky, InitVar, IsType, RemoteView_EqTrans
RemoteView_FovTilt, RemoteView_StereoStates, SuperArray, TimeSystem, ToRadians
big_eph, jpl_body
CALLED BY:
RemoteView_Init
PROCEDURE:
nview # views
time time structure (pointer)
Loc viewing location: heliographic lng, lat (radians)
and r (AU) (pointer)
Dir viewing direction: heliographic lng, lat (radians)
Fov angular half-width field of view (radians)
Tilt field of view tilt angle (radians)
nDim dimensions of fov cube
rNear AU
eqtrans int scalar 1,2 or 3
1: preserve distance to line of sight through center of image
2: preserve angular distance to line of sight through center of image
3: preserve area on sky;
stereo 0: stereo off; 1: stereo on (with left image in even,
and right image in odd view locations)
silent=silent controls display of informational messages
MODIFICATION HISTORY:
MAY-2000, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS)
adapted to handle matrix sequences from time-dependent tomography.
NOV-2001, Paul Hick (UCSD/CASS)
fixed bug processing /ecliptic keyword when no viewing location is specified
APR-2002, Paul Hick (UCSD/CASS)
fixed bug processing location when specified explicitly with keyword /ecliptic
JUN-2004, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Made sure that input is converted to double precision to avoid problems
with integer input.
[Previous]
[Next]
NAME:
RemoteView_Matte
PURPOSE:
Sets up the opacity matte values for a volume data set
CATEGORY:
Visualization
CALLING SEQUENCE:
PRO RemoteView_Matte, FOVLoc, cue_radial=cue_radial, matte=matte, silent=silent
INPUTS:
FOVLoc array[3,n,l,m]; type: float
locations of volume elements in FOVCube in
heliographic coordinates
(longitude, latitude, heliocentric distance).
OPTIONAL INPUT PARAMETERS:
cue_radial=cue_radial
array[4]; type: float
[rmin, rmax, depth, depth_power]
If depth_power is not specified then 1.0 is assumed.
Causes an opacity that drops off with distance from
1 at 'rmin' to 'depth' at 'rmax'.
The opacity drops off as a power law with power
'depth_power' (the power should be positive)
OUTPUTS:
matte=matte array[n,l,m]; type: float
opacity matrix (values between 0 and 1)
This matrix is passed to RGBO_Project, where
it is multiplied with the rgbo vector.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
InitVar, IsType
CALLED BY:
RemoteView_Display3D
PROCEDURE:
This procedures applies modification to the
opacities which depend on location in the volume data (rather
than just the color). The resulting opacities are folded into
the rgb color indices before returning.
MODIFICATION HISTORY:
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_PlotVertices
PURPOSE:
CATEGORY:
CALLING SEQUENCE:
PRO RemoteView_PlotVertices, V, P
INPUTS:
OPTIONAL INPUT PARAMETERS:
OUTPUTS:
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
EXTERNAL:
CALLS: ***
RemoteView_VertexSphere, WhatIs, setup3d, twin
SEE ALSO:
COMMON BLOCKS:
SIDE EFFECTS:
RESTRICTIONS:
EXAMPLE:
PROCEDURE:
MODIFICATION HISTORY:
OCT-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_rgbo
PURPOSE:
Sets up the RGBO vector for volume rendering
CATEGORY:
Volume rendering: RemoteView
CALLING SEQUENCE:
FUNCTION RemoteView_rgbo, $
rgbo = rgbo, $
rgb_range = rgb_range, $
full_range = full_range, $
full_color = full_color, $
full_opacity = full_opacity, $
mid_range = mid_range, $
mid_color = mid_color, $
mid_opacity = mid_opacity, $
opacity_power = opacity_power, $
update = update, $
postfix = postfix, $
data_range = data_range, $
rgb_index = rgb_index, $
silent = silent
INPUTS:
full_range=full_range
scalar or array[2]; type: any; no default (MUST be specified)
A scalar is interpreted as [0,full_range]
The full range of values of rendered data in data units
(e.g. cm^-3 for a rendering of densities)
This range is converted to the byte range 'rgb_range' (using bytscl).
OPTIONAL INPUT PARAMETERS:
rgbo=rgbo array[256,4]; type: float
rgbo vector to be updated. If 'rgbo' does not exist and /update
is not set then a new rgbo vector is created.
/update if set then the input rgbo vector is updated
(ignored if rgbo is not defined)
rgb_range = rgb_range
scalar or array[2]; type: byte; default: [0B,255B]
Range of elements in rgbo assigned to the data set.
mid_range = mid_range
scalar or array[2]; type: any; default: full_range
A scalar is interpreted as [0,full_range]
Internally this is restricted to be a subrange of 'full_range'
Range of data values defining 'intermediate data values'
full_color = full_color
scalar or array[2]; default: [0,235]
A scalar is interpreted as [0,full_color].
Range of colors to be used in the rendering.
Internally this is restricted to the available colors (currently 236).
color_range[0] is matched to data value full_range[0]
color_range[1] is matched to data value full_range[1]
mid_color = mid_color
scalar or array[2]; default: full_color
Internally this is restricted to be a subrange of 'full_color'
Range of colors used for rendering the intermediate data values
full_opacity = full_opacity
scalar or array[2]; type: float; default: [0,1]
range of opacity values
mid_opacity = mid_opacity
scalar or array[2]; type: float; default: full_opacity
Internally this is restricted to be a subrange of 'full_opacity'
Opacity applied to data values to mid-range data values
opacity_power = opacity_power
scalar; type: float; default: 1
power applied to opacity for mid-range data values
OUTPUTS:
rgbo array[256,4]; type: float
rgbo color vector needed for volume rendering
The first index [0,255] represent the data values.
Only the range 'rgb_range' is filled. The rest is zero
(if rgbo is created), or unmodified (if rgbo is updated)
The colors values rgbo[0:2,*] are not yet multiplied
with the opacities.
data_range= data_range
array[2], type: float
The actual range of values of rendered data in data units.
This is derived from the input 'full_range'
rgb_index = rgb_index
array[2], type: byte
Actual range of elements in rgbo assigned to the data set.
This is derived from the input 'rgb_range'
INCLUDE:
@compile_opt.pro ; On error, return to caller
@skycolors.pro ; Dummy comment for Linux
CALLS: ***
FILEPATH, InitVar, IsType, SetRange, flt_read, gridgen, who_am_i
CALLED BY:
RemoteView_Init_Display, qRemoteView_Calculate
SIDE EFFECTS:
Needs file remoteview_rgbo.txt, storing the color table information
RESTRICTIONS:
PROCEDURE:
The original 3D matrix will cover a certain range of data values. Volume rendering
can only handle a maximum of 256 different 'density values'.
We first need to decide how many of these 256 colors we want to assign to the
3D density matrix. If only one 3D volume data set is rendered then the full
range [0,255] can be used, but when several 3D volume data sets are merged
each set is assigned its own subrange. This is done with keyword 'rgb_range'
Next we need to set the range of data values in the 3D matrix to be rendered.
'full_range' sets the data range to be scaled to 'rgb_range'. The 3D matrix has
to be converted to byte by the IDL bytscl command (as e.g. in RemoteView_Display3D)
rgb_range[0]+bytscl( Matrix, top=rgb_range[1]-rgb_range[0], min=full_range[0], max=full_range[1])
This scales the data values to the proper range 'rgb_range'
Note that data values below full_range[0] are treated the same as full_range[0], and data
values above full_range[1] the same as full_range[1]).
'mid_range' selects a subrange of 'full_range'. These two values separate the full range
in three sections:
low data values: [full_range[0], mid_range[0]]
intermediate values: [mid_range [0], mid_range[1]]
high data values: [midrange [1], full_range[0]]
These three ranges are treated separately.
To set up the rgbo vector an 8-bit color table and an opacity needs to be defined.
The color table information is stored in two files (see RESTRICTIONS).
Keywords 'full_color' and 'mid_color' select color ranges from this table.
Keywords 'full_opacity' and 'mid_opacity' set the opacities.
Data values, color indices and opacities are matched as follows:
full_range[0] <-----> full_color[0] <------> full_opacity[0]
mid_range [0] <-----> mid_color [0] <------> mid_opacity [0]
mid_range [1] <-----> mid_color [1] <------> mid_opacity [1]
full_range[1] <-----> full_color[1] <------> full_opacity[1]
For the low data values (between full_range[0] and mid_range[1]) both color index
and opacity are obtained by a linear scaling with the data values; the same is
the case for the high data values (between mid_range[1] and full_range[1]).
For the intermediate data values the color index scales linearly with the
data values. The opacity scales as a power law of data value with the power
specified in keyword opacity_power.
MODIFICATION HISTORY:
JUN-2000, Paul Hick (UCSD/CASS)
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Color table file is now looked for in same directory as
this source code file.
[Previous]
[Next]
NAME:
RemoteView_StereoStates
PURPOSE:
Takes a single viewing state and splits it up into two states
representing a stereo pair
CATEGORY:
Number strangling
CALLING SEQUENCE:
FUNCTION RemoteView_StereoStates, nView, TT, Loc, Dir, Fov, Tilt, stereo=Stereo, degrees=degrees
INPUTS:
TT[n], Loc[3,n], Dir[2,n], Fov[n], Tilt[n]
arrays describing n viewing states (see RemoteView)
/stereo
stereo=[Angle,Distance]
/stereo if set, stereo pairs are produced using default
settings for stereo angle (6 degrees) and
distance (Sun-viewer distance)
stereo=[Angle, Distance]
if specified as a two-element array, the first
element is used as stereo angle, the second as
stereo distance. If the distance is set to zero
then the viewer-origin distance Loc[2,*] is used.
OPTIONAL INPUT PARAMETERS:
/degrees if set, all angles are in degrees (default: radians)
OUTPUTS:
R scalar; type: integer
0 if no stereo states were calculated
1 if stereo states were calculate
OPTIONAL OUTPUT PARAMETERS:
(Only calculated if return value R = 1)
TT[2*n], Loc[3,2*n], Dir[2,2*n], Fov[2,2*n], Tilt[2*n]
The stereo pairs for the n input states are stored as
TT[2*i ] right eye view for state i=0,n-1
TT[2*i+1] left eye view for state i=0,n-1
(Note that TT, Fov and Tilt values will be the
same for left and right view; Loc and Dir will be
slightly different from the input Loc and Dir)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, EulerRotate, SuperArray, ToRadians
CALLED BY:
RemoteView_Init_View
PROCEDURE:
> Called by RemoteView to set up stereo pairs
In stereo mode each state is split into a stereo pair.
> Coordinate systems are defined in document SkyGrid.doc (probably in D:\work\doc).
> The stereo pair states are defined in the X,Y,Z coordinate system (+Y is the
horizontal direction toward the right). In this coordinate system the viewer
location is at the origin and the viewing direction is the positive Z-axis.
> The stereo pair is defined by two viewing locations close to the origin and
two viewing direction close to the +Z axis.
Take a point P on the +Z axis at distance StereoDist. Take viewing locations
R on the +Y axis and L on -Y axis at equal distance to the origin such that
the lines RP and YP connecting these points to P make an angle StereoAngle
L and R are the positions of left and right eye, respectively.
LP and RP are the viewing directions from left and right eye, respectively.
The separation LR is 2*Dist*tan(StereoAngle/2.)
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS)
MAY-2000, Paul Hick (UCSD/CASS, pphick@ucsd.edu); converted from procedure to function
[Previous]
[Next]
NAME:
RemoteView_VertexMap
PURPOSE:
Map a given synoptic map to a color index range.
CATEGORY:
CALLING SEQUENCE:
FUNCTION RemoteView_VertexMap, Vertex, VMap, Colors, $
polygon=Polygon, scale=Scale, nearestneighbour=NearestNeighbour
INPUTS:
Vertex float array[3,n]
x,y,z coordinates of the vertices of a spherical
polygon surface (as returned by VertexSphere)
VMap array[nLng,nLat]
synoptic map to be mapped to sphere, covering range
[0,360] degrees in longitude, and [-90,90] deg in latitude
OPTIONAL INPUT PARAMETERS:
Colors int array[2]
defines a range of color indices. VMap is rescaled
into the specified color range: the minimum is mapped
to Colors[0], the maximum to Colors[1].
If VMap already is an array of color indices than
this argument can be omitted.
Scale int scalar
use only Scale evenly space colors between
Color[0] and Color[1]
/nearestneighbour if set, the map value at each vertex is calculated by
taking the value of the neares point of VMap.
polygon=Polygon
long array[m]
polygon list for the spherical surface (as returned by
VertexSphere). See IDL Help for shade_volume for
description of the structure of Polygon
OUTPUTS:
Result No polygon array specified:
long array[n] color indices; one for each vertex.
To be used in the 'shade' keyword to polyshade
Polygon array specied:
long array[m] color indices; one for each polygon
To be used in the 'shade_polygon' keyword to polyshade
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, SCALE2LEVELS
CALLED BY:
RemoteView
COMMON BLOCKS:
SIDE EFFECTS:
RESTRICTIONS:
PROCEDURE:
> The synoptic map VMap is 2D array giving function values on a spherical surface
on the regular grid in longitude ([0,360] degrees) and latitude ([-90,90] degrees).
> The Vertex array and Polygon array describe the surface of the sphere in terms
of polygons.
> Function values at the vertices are calculated by interpolation or nearest neighbour
method, and converted to integer color indices, using the round function.
MODIFICATION HISTORY:
[Previous]
[Next]
NAME:
RemoteView_VertexSphere
PURPOSE:
Calulate the vertices for shading a sphere.
CATEGORY:
Skyview package
CALLING SEQUENCE:
PRO RemoteView_VertexSphere, nS, Vertex, Polygon
INPUTS:
nS scalar determines the resolution of the sphere.
25 is a reasonable value
OUTPUTS:
Vertex, Polygon
arrays determined by IDL shade_volume procedure
the vertices are points on the unit sphere,
relative to the origin of the sphere.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
gridgen
CALLED BY:
RemoteView_Init_Display, RemoteView_PlotVertices
PROCEDURE:
Set up a 3D volume data array containing the distance
to the sphere center. Then calculate the vertex and polygon arrays.
The vertices usually need to be scaled to the appropriate size, and/or
the origin needs to be shifted.
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS, pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_ZEclipticPlane
PURPOSE:
Get coordinate arrays describing ecliptic plane in
a Cartesian heliographic coordinate system.
CATEGORY:
Sky graphics
CALLING SEQUENCE:
FUNCTION RemoteView_ZEclipticPlane, TT, X, $
corners = Corners , $
grid = Grid , $
angle = Angle , $
degrees = Degrees , $
color = color
INPUTS:
TT array[1]; type: standard time structure;
time
X array[2,*]
X and Y coordinates of points in the solar
equatorial plane.
OPTIONAL INPUT PARAMETERS:
/corners if set then only the first 2 points X[*,0:1] are used. The output
arrays will be an array[3,5], in the sequence
(0,0),(1,0),(1,1),(0,1),(0,0), i.e. the Z array can be used to
draw a square representing the ecliptic plane.
/grid if set, every value in X[0,*] is combined with every X[1,*]. This
defines a square grid of points covering the ecliptic plane
angle=Angle scalar; default: 0
the input coordinates are rotated over Angle in the solar
equatorial plane before the Z-coordinates are calculated
/degrees if set, Angle is in degrees (default: radians)
OUTPUTS:
ZEcliptic array[*], array[*,*]
X array[*], array[*,*]
X,Y,Z coordinates of points in ecliptic plane
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CvSky, InitVar, IsType, ToRadians
CALLED BY:
RemoteView
PROCEDURE:
The X-Y-Z coordinate system is associated with heliographic coordinates:
X-Y plane is the solar equator; X-axis has heliographic longitude zero;
Z-axis points to solar North pole.
Ecliptic north has has ecliptic latitude !pi/2 (the longitude doesn't matter,
use 0). Converting this to heliographic coordinates gives the heliographic
longitude, rLng, and latitude, rLat of ecliptic North.
If [A,B,C] is a unit vector pointing to ecliptic north, then
A = cos(rLat)*cos(rLng)
B = cos(rLat)*sin(rLng)
C = sin(rLat)
The equation of the ecliptic plane in heliographic coordinates is given
by the A*x+B*y+C*z=0. So for given x,y: z = -(A*x+B*y)/C
MODIFICATION HISTORY:
28-Feb-1997, Paul Hick (UCSD, pphick@ucsd.edu)
[Previous]
[Next]
NAME:
remove_stars
CALLING SEQUENCE:
PRO remove_stars, year, camera=camera, force=force
INCLUDE:
@compile_opt.pro
CALLS: ***
FILEPATH, InitVar, smei_star_remove
[Previous]
[Next]
NAME:
remove_stars_c3s
CALLING SEQUENCE:
PRO remove_stars_c3s, year, force=force
INCLUDE:
@compile_opt.pro
CALLS: ***
FILEPATH, InitVar, smei_star_remove
[Previous]
[Next]
NAME:
remove_stars_m0
CALLING SEQUENCE:
PRO remove_stars_m0, year, camera=camera, force=force, keepbkgnd=keepbkgnd
INCLUDE:
@compile_opt.pro
CALLS: ***
FILEPATH, InitVar, smei_star_remove
[Previous]
[Next]
NAME:
rename_mrk
CALLING SEQUENCE:
pro rename_mrk
INCLUDE;
@compile_opt.pro
CALLS: ***
GetFileSpec
[Previous]
[Next]
NAME:
reset_colors
CALLING SEQUENCE:
PRO reset_colors, reverse=reverse
INCLUDE:
@compile_opt.pro
CALLS: ***
FLIP_BLACK_AND_WHITE
CALLED BY:
GetColors [2], GetColors [3], PlotEarthSkymap [2], PlotEarthSkymap [3]
PlotEarthSkymap [4], allsky [1], allsky [2], allsky [3], allsky_f
vu_thomson_antifish, vu_thomson_hammer
[Previous]
[Next]
NAME:
RGBO_DepthCue
PURPOSE:
Returns a matte matrix for a depth cue operation
CATEGORY:
gen/idl/toolbox/graphics
CALLING SEQUENCE:
PRO RGBO_DepthCue, cue_depth=cue_depth, size=sz, dimension=dimension, matte=matte
INPUTS:
cue_depth=cue_depth scalar or array[2]; type: float
scalar is interpreted as [depth,depth]
depth[0]: opacity at maximum depth
depth[1]: power applied to dropoff from minimum to
maximum depth (should be positive)
OPTIONAL INPUT PARAMETERS:
size=sz array; type: integer
IDL size vector for 3D array
only the dimensions sz[1:sz[0]] are used
dimension=dimension array[3]; type: integer
dimensions of 3D array
Either one of these keyword is used to specify the dimensions
of a 3D array [N,L,M]
matte=matte array[N,L,M]; type: float
The matte matrix for the depth cue is multiplied into
the input matte, if it exists
OUTPUTS:
matte=matte array[N,L,M]; type: float
resulting matte matrix (input matte times depth cue matte)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
IsType, SuperArray
CALLED BY:
RemoteView_Display3D
SEE ALSO:
RGBO_Project
PROCEDURE:
The 3rd dimension of M is taken to be the z-dimension.
m=0 has maximum depth (farthest away from the viewer) and gets opacity
depth[0]. m=M-1 has minimum depth (nearest to the viewer) and gets opacity
of one. The dropoff between the two is given by the power value:
o = depth[0]+(1-depth[0])*( z/(ndim[2]-1) )^depth[1]
The resulting values are constrained to stay between 0 and 1.
MODIFICATION HISTORY:
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RGBO_Project
PURPOSE:
Merges content of z-buffer with color and opacity
array of volume data set
CATEGORY:
CALLING SEQUENCE:
FUNCTION RGBO_Project, zvol, rgbo, $
zpix = zpix , $
zbuf = zbuf , $
ctrgb = ctrgb , $
background = background , $
bad_data = bad_data , $
bad_opacity = bad_opacity , $
low_data = low_data , $
low_opacity = low_opacity , $
high_data = high_data , $
high_opacity= high_opacity , $
matte = matte
INPUTS:
zvol array[N,M,L]; type: byte
byte array for volume data
rgbo array[256,4]; type; float
rgbo vector; rgbo[*,0]=o*r, rgbo[*,1]=o*g, rgbo[*,2]=o*b
rgbo[*,3] = o*255. o = opacity (0 <= o <= 1), r,g,b = red,green
blue color indices (0 <= r,g,b <= 255).
OPTIONAL INPUT PARAMETERS:
zpix=zpix array[n,m]; type: byte
Z-buffer content (the Z-buffer iis a 256-color device)
array[n,m,3]; type: byte
Z-buffer content as true color image
zbuf=zbuf array[n,m]; type: integer
Z-buffer depth array
background=background
scalar; type: byte
background color index in Z-buffer
If not specified then !p.background is used.
array[3]; type: byte
(only if zpix is true color image)
background color rgb values in Z-buffer
ctrgb=ctrgb array[256,3]; type: byte
(only if zpix is 256-color image)
rgb values for color table to be used to interpret zpix
If not specified then the current color table is retrieved
with the IDL tvlct function.
matte=matte array[N,M,L] or array[N,M,L,4]
matrix of values between 0 and 1 to be applied to
zvol after conversion to rgbo values and before projecting onto
the image plane. This can be used e.g. to implement depth cueing.
An array[N,M,L] is applied to each channel (r,g,b,o).
OUTPUTS:
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
ArrayLocation, CONGRID, InitVar, IsType, SuperArray
CALLED BY:
RemoteView_Display3D
SEE ALSO:
SIDE EFFECTS:
RESTRICTIONS:
PROCEDURE:
MODIFICATION HISTORY:
JUL-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RotationMeasure
PURPOSE:
Calculates component of vector field n*B along line of sight
CATEGORY:
sat/idl/toolbox/faraday
CALLING SEQUENCE:
FUNCTION RotationMeasure, REarth, R, F, w3darg, $
ut_earth = ut_earth , $
pa_earth = pa_earth , $
elo_earth = elo_earth , $
elo_sun = elo_sun , $
degrees = degrees , $
get_blos = get_blos
INPUTS:
REarth not used
R array[3,N,L,M] heliographic coordinates of points in a 2D grid
of NxL lines of sight with M segments along each
R[0,*,*,*] : heliographic longitude
R[1,*,*,*] : heliographic latitude
R[2,*,*,*] : heliocentric distance (AU)
F array[N,L,M,3] magnetic field vector, multiplied by the
density, in RTN coordinates
w3darg w3darg[0]: los step size (AU)
w3darg[1]: wavelength (m)
w3darg[2]: density normalization (default: 2)
w3darg[3]: Br normalization (default: 2)
w3darg[4]: Bt normalization (default: 1)
w3darg[5]: Bn (default: 1)
OPTIONAL INPUT PARAMETERS:
/degrees if set all input angles are in degrees
pa_earth array[N,L,M] position angle from ecliptic north
elo_earth array[N,L,M] angle Sun-Earth-LOS segment (i.e. conventional
elongation angle)
elo_sun array[N,L,M] angle Earth-Sun-LOS segment
/get_blos if set, then the F-component along the line of sight is
returned. Note that this can be used to get the magnetic
field component along the line of sight by setting F to the
magnetic field (omitting multiplication with density), and
setting w3dard[2]=0.
OUTPUTS:
R array[N,L,M] rotation measure in degrees/m^2; see PROCEDURE
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, CvSky, CvSky_RTN, EulerRotate, InitVar, SubArray, ToRadians, scalarproduct
CALLED BY:
vu_lineofsight
PROCEDURE:
RM = e^3/(2*pi*m^2*c^4) Integral( n_e * H.dl ) radians cm^-2
In Gaussian units:
e = 4.8 x 10^-10 esu
m = 9.1 x 10^-28 gr
c = 3.0 x 10^-10 cm/s
n_e in cm^-3; H in Gauss; dl in cm
RM = 2.6311927 x 10^-17 Integral( n_e x H.dl ) radians cm^-2
The tomography magnetic files contain magnetic field in nT = 10^-5 Gauss
The distance scale for the integration is AU = 1.5 x 10^13 cm
The wavelengths are in the meter range, so we change
to radians m^-2. Multiplying with the resulting
10^-5 x 1.5 x 10^13 x 10^4 = 1.5 x 10^12:
RM = 3.9362082 x 10^-5 Integral( n_e[cm^-3] x H[nT].dl[AU] ) radians m^-2
The integrand is returned here in degrees m^-2:
RM = 3.9362082 x 10^-5 n_e[cm^-3] x H[nT].dl[AU] radians m^-2
RM = 3.9362082 x 10^-5 n_e[cm^-3] x H[nT].dl[AU] x (180/pi) degrees m^-2
= 2.2552811 x 10^-3 n_e[cm^-3] x H[nT].dl[AU] degrees m^-2
The constant 3.9362082 x 10^-05 is calculated from fields in the
!sun and !physics structures:
3.9362082 x 10^-05 = !sun.au*0.01d0*!physics.chargeofelectron^3/ $
(2*!dpi*!physics.massofelectron^2*!physics.speedoflight^4)
The integration step size dl[AU] is stored in w3darg[0]
If w3darg[1] exists it should contain the wavelength in meters.
In this case RM*w3darg[1]^2 is returned, i.e. the Faraday rotation
in degrees.
A typical integration will extend over 2 AU from Earth. So in order of
magnitude the integrated RM will be:
RM = 0.045 n_e[cm^-3] x H[nT] degrees m^-2
Typical background values are n_e ~ 10-20 cm^-3 and H ~ 1-2 nT, so typical
background RM values will be in the range 0.5 to 2 degrees m^-2
MODIFICATION HISTORY:
OCT-2006, Paul Hick (UCSD/CASS)
JUN-2007, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Bug identified by Liz Jensen. The integration step size needs to
be absorbed in the return value.
Changed sign on return value (effectively this changes the direction
of the integration, which now runs in the direction of the wave vector
of the incoming radio waves (toward Earth).
[Previous]
[Next]
NAME:
run_forecast_insitu
PURPOSE:
IDL main program. Run on Linux as a cron job.
CATEGORY:
CALLING SEQUENCE:
idl run_forecast_insitu
INPUTS:
(through environment variables)
OUTPUTS:
(none)
CALLS:
Instrument, TimeSet, TimeUnit, compareinsitu
RESTRICTIONS:
Environment variables:
ea_dir directory where ea*.* are located
dt_offset for-/aftcast offset specified in days
instrument in situ data
PROCEDURE:
After completion IDL exits again.
MODIFICATION HISTORY:
MAR-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
DEC-2000, B. Jackson (UCSD/CASS; bvjackson@ucsd.edu)
[Previous]
[Next]
NAME:
run_help
PURPOSE:
IDL main program to update the software help files. Run on Linux as a cron job.
CATEGORY:
WWW
CALLING SEQUENCE:
idl run_help
INPUTS:
(none)
OUTPUTS:
(none)
CALLS:
www_help_smei, www_help_sync.py
PROCEDURE:
After executing the startup files, www_help_smei is run and IDL exits again.
MODIFICATION HISTORY:
AUG-2000, Paul Hick (UCSD/CASS)
FEB-2003, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added call to www_help_rsync.py
[Previous]
[Next]
NAME:
run_map
PURPOSE:
IDL main program to update the IPS forecast Web pages.
Run on Linux as a cron job.
CATEGORY:
WWW
CALLING SEQUENCE:
idl run_map
INPUTS:
(none)
OUTPUTS:
(none)
CALLS:
IsType, TimeOp, TimeSystem, TimeUnit, destroyvar, forecast, forecast_env, is_running
vu_prefix
RESTRICTIONS:
Can onLy be run on Linux
idl_startup.pro needs to be run. This requires that the environment
variable IDL_STARTUP is set.
PROCEDURE:
After completion IDL exits again.
MODIFICATION HISTORY:
MAR-2000, Paul Hick (UCSD/CASS)
SEP-2002, Paul Hick (UCSD/CASS)
Added processing of magnetic field for corotating tomography
JUL-2003, Paul Hick (UCSD/CASS)
Write file $TUB/run_map.txt to indicate that a copy of run_map
is already running. The file is deleted on completion.
This prevents multiple copies of run_map to run when the hourly
forecasts take more than an hour to complete.
JUL-2004, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Introduced function vu_prefix and forecast_env for better
external control of input files.
[Previous]
[Next]
NAME:
run_marker
PURPOSE:
IDL main program to update final (averaged) files for the
time-dependent tomography.
CATEGORY:
pro/tool
CALLING SEQUENCE:
idl $pro/run_marker
INPUTS:
(none)
OUTPUTS:
(none)
CALLED_BY:
sync_daily_ips
CALLS:
forecast_ice, vu_prefix, vu_update_marker
RESTRICTIONS:
Can onLy be run on Linux
idl_startup.pro needs to be run. This requires that the environment
variable IDL_STARTUP is set.
PROCEDURE:
This is run as part of the cron job sync_daily_ips after new
time-dependent tomography files have been created.
vu_update_marker picks up all files with the highest marker value
(these should be the files created by the last tomography run).
All times in this list are combined with all other files for the
same time (but with lower marker values) into a new 'best' tomography
files for these times.
MODIFICATION HISTORY:
APR-2000, Paul Hick (UCSD/CASS)
SEP-2002, Paul Hick (UCSD/CASS)
Added call to forecast_ice to move older files out of the way.
Added processing of magnetic bb3d files.
JUN-2003, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
bb3d files are now called wson files.
[Previous]
[Next]
NAME:
run_mean
PURPOSE:
IDL main program to update final (average) files for
corotating tomography.
CATEGORY:
WWW
CALLING SEQUENCE:
idl $pro/run_mean
INPUTS:
(none)
OUTPUTS:
(none)
CALLED_BY:
sync_daily_ips
CALLS:
forecast_env, forecast_ice, vu_prefix, vu_update_hours
RESTRICTIONS:
Can only be run on Linux.
idl_startup.pro needs to be run. This requires that the environment
variable IDL_STARTUP is set.
PROCEDURE:
This is run as part of the cron job sync_daily_ips after new
tomography files have been created.
First all hourly tomography files that are affected by the
new tomography file are updated (by overwriting them).
Then a number of new hourly files are created by extending
the range of hourly to at most 3 days beyond the time of
the new tomography file.
MODIFICATION HISTORY:
APR-2000, Paul Hick (UCSD/CASS)
SEP-2002, Paul Hick (UCSD/CASS)
Added processing of 'bb3d' files
Added call to forecast_ice to move older files out of the way.
JUN-2003, Paul Hick (UCSD/CASS)
bb3d files are now called wson files.
JUL-2004, Paul Hick (UCSD/CASS)
Modified to process more than one type of magnetic field data.
[Previous]
[Next]
NAME:
run_movie
PURPOSE:
IDL main program to create gif animations. Run on Linux as a cron job.
CATEGORY:
pro/tool
CALLING SEQUENCE:
idl $pro/run_movie
INPUTS:
(none)
OUTPUTS:
(none)
CALLS:
forecast_env, forecast_movie, jpl_body, vu_prefix
RESTRICTIONS:
Can only be run on Linux
idl_startup.pro needs to be run. This requires that the environment
variable IDL_STARTUP is set.
PROCEDURE:
This is run as part of the cron job bash=sync_daily_ips= after new
hourly-averaged tomography files have been created.
MODIFICATION HISTORY:
APR-2000, Paul Hick (UCSD/CASS)
SEP-2002, Paul Hick (UCSD/CASS)
Added magnetic field movies for corotating tomography
Added magnetic field movies for time-dependent tomography
JUL-2004, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Introduced functions vu_prefix and forecast_env for better
external control of input files.
[Previous]
[Next]
NAME:
run_ssw
PURPOSE:
IDL main program to update the SSW help files.
CATEGORY:
www_help
CALLING SEQUENCE:
idl $pro/run_ssw
INPUTS:
(none)
OUTPUTS:
(html files)
CALLS:
www_help_sync.py, www_help_tree
PROCEDURE:
After completion IDL exits again.
MODIFICATION HISTORY:
JAN-2002, Paul Hick (UCSD/CASS)
FEB-2003, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added www_help_sync.py call
[Previous]
[Next]
NAME:
run_ssw_smei
PURPOSE:
IDL main program to update the SSW help files.
CATEGORY:
www_help
CALLING SEQUENCE:
idl run_ssw_smei
INPUTS:
(none)
OUTPUTS:
(html files)
CALLS:
do_file, www_help_tree
PROCEDURE:
After completion IDL exits again.
MODIFICATION HISTORY:
JAN-2002, Paul Hick (UCSD/CASS)
FEB-2003, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added www_help_sync.py call
