
1 CONVERT
        [GREG2\]CONVERT A0 D0 [Angle] [/TYPE Ptype]  [/UNIT  Unit]  [/SYSTEM
    System] [/VAR Varx Vary]

    This command assumes that the X,Y buffers (or the 1-D variables Varx and
    Vary  if  option  /VAR is used) contain data in the specified projection
    (or in absolute spherical coordinates if Ptype is  NONE)  in  the  given
    angular  unit  (Degree  Minute  Seconds  or  the default Radian), in the
    specified System (GALACTIC or EQUATORIAL, default  current  system)  and
    converts  them  to  the  current  system,  as defined by SET SYSTEM, and
    projection, as defined by command PROJECTION.  Note that  the  projected
    coordinates  are  always  natural units (i.e.  the equivalent of Radians
    after projection).  There is no provision for "hidden" parts  which  are
    treated exactly as visible ones.

      A0 D0 are Hours and Degrees if the input system is EQUATORIAL, Degrees
    otherwise.

    CAUTION: when using variables, the Varx and Vary arrays MUST BE  REAL*8,
    and WRITEABLE (see HELP DEFINE).

1 ELLIPSE
        [GREG2\]ELLIPSE Major [Minor [Position_Angle]] [/BOX X Y] [/USER X Y
    [code]] [/ARC Theta_min Theta_max] [/FILL [Colour]]

    This command draws at current pen position  (or  at  position  (X,Y)  if
    option  /BOX  or  /USER is present) an ellipse of given semi-major axis,
    semi-minor axis, (default Minor = Major) and  PositionAngle  (default  0
    degrees).

    Major, Minor, X and Y are in User  Coordinates,  but  Position_Angle  is
    ALWAYS in DEGREES, TRIGONOMETRIC ORIENTATION. Major, Minor, X and Y, can
    be  1-D  arrays  of  any  size,  provided  the  sizes  are   the   same.
    Position_Angle can be indifferently an array, a number, or omitted.

    The code suboption in the /USER  option,  if  present,  can  be  any  of
    `SECONDS',  `MINUTES',  `DEGREES',  `RADIANS' (in which case the X and Y
    coordinates are taken to be in the corresponding unit) or `ABSOLUTE' (in
    which  case  X and Y are taken as absolute coordinates, usually exprimed
    in sexagesimal format). The presence of the code suboption is valid only
    if a PROJECTION and a SYSTEM (EQUATORIAL or GALACTIC) are both defined.

    A portion of the ellipse can be drawn by specifying the boundary  angles
    in  option  /ARC  (in  degrees,  trigonometric  sense  from the position
    angle). Not compatible with the array mode.

    Option /FILL [Colour] will fill the  ellipse(s),  with  the  current  or
    specified colour. If the /ARC option is also present, the filled area is
    the corresponding pie part, not the subtended arc.

    This command is useful for plotting beam  sizes,  incertainty  ellipses,
    pie charts, etc...
1 EXTREMA
        [GREG2\]EXTREMA [/BLANKING Bval Eval] [/PLOT]  [/COMPUTE]

    Computes and shows the minimum and maximum values of  the  Regular  Grid
    array:   shows   XMIN,XMAX,YMIN,YMAX,ZMIN,ZMAX.  A  useful  command  for
    deciding where to set contour levels, or what size to give to the BOX if
    you  want  an  exact  aspect ratio between two coordinates.  The current
    blanking value is used, but can be overridden  using  option  /BLANKING.
    Option  /PLOT  specifies  that instead of computing global extrema LOCAL
    extrema values should be computed, and written at appropriate places  on
    the plot. This is a very good way to avoid ambiguities in contour map. A
    shortest format is used for writing the values, and the  character  size
    controls the label size.  If Option /COMPUTE is not present, the extrema
    are only computed if not already known (from a previous call to EXTREMA,
    or  from  an  image  header).  /COMPUTE forces computation from the data
    array. It should be used  if  for  any  reason  the  known  extrema  are
    incorrect  (invalid  image  header, killed bad pixel, change of blanking
    value...).

1 GRID
        [GREG2\]GRID [Astep [Dstep]] [/ALTERNATE]

    Plots a  grid  of  meridian  and  parallels  according  to  the  current
    projection  and  system.  Astep is the grid step for meridian in degrees
    (Default 15), Dstep for Parallels (Default Rstep). If  one  step  is  0,
    this  part  of  the  grid  is  not plotted.  If the /ALTERNATE option is
    present, the grid will be a grid  in  the  alternate  coordinate  system
    (Equatorial  or  Galactic).  This does not currently work for projection
    type AITOFF and RADIO.
1 Language
                        GREG2\ Language Summary
    CONVERT         : Convert data in the X,Y buffer in the current projection.
    ELLIPSE         : Draw an ellipse in User coordinate.
    EXTREMA         : Shows minimum and maximum of the Regular Grid array
    GRID            : Plot a Grid in (A,D) with steps As and Ds (in degrees)
    LEVELS          : Sets the contour levels
    MASK            : Mask part of a regular grid map
    MEAN            : Computes statistics on map values
    PERSPECTIVE     : Makes a 3-D perspective of the Regular Grid array.
    PLOT            ; Plot a SIC image variable to the window
    POLYGON         : Defines a polygon for use by MASK and MEAN.
    PROJECTION      : Define a spherical projection.
    RANDOM_MAP      : Create a Regular Grid array from randomly sampled data.
    RESAMPLE        : Resample the Regular Grid array on a different Grid.
    RGDATA          : Reads/Creates a 2-D map and put it in the Regular Grid array.
    RGMAP           : Draws contour lines for the Regular Grid array
    STRIP           : Extract a strip from the Regular Grid array
    WRITE           : Saves an internal buffer on a file.
    WEDGE           : Draws wedges.
2 NEWS

    See HELP GREG1\ News for information

1 LEVELS
        [GREG2\]LEVELS C1 C2 TO C3 BY C4 ...

    sets the contour levels to be C1, C2, C2+C4, C2+2*C4, ..C3, and  so  on,
    using  the same list format as SIC\ command FOR.  The contour levels are
    used to make contour plots of  the  Regular  Grid  array  using  command
    RGMAP.  Up  to  30 contours can be given at a time. Note that it is more
    efficient to use a single RGMAP command with many levels than many RGMAP
    commands with a single level each.

    LEVELS without arguments will display the  contour  levels,  and  LEVELS
    NONE reset the level list.
1 MASK
        [GREG2\]MASK [IN] [OUT] [/BLANKING Bval]

    masks all pixels of the Regular Grid array lying inside (if argument  is
    IN)  or  outside  (if argument is OUT or by DEFAULT) the current polygon
    (see command POLYGON) by attributing them a blanking value.  This  value
    is  defined  by  command  SET  BLANKING,  or  specified using the option
    /BLANKING Bval.
1 MEAN
        [GREG2\]MEAN [/CLIP Nsigma]

    computes crude statistics on the part of the Regular  Grid  array  lying
    inside  the  current polygon. Blanking values as defined in SET BLANKING
    are ignored. The results are displayed (some of them  according  to  the
    current ANGLEUNIT), and stored in the variables POLY$SUM and POLY$AREA.

    If option /CLIP is present, iterative kappa sigma rejection is  used  to
    reject outlier pixels.

1 PERSPECTIVE
        [GREG2\]PERSPECTIVE [Altitude  Azimuth]  [/FACTOR  Fv  Ov]  [/LOWER]
    [/LINES]   [/STEP  nsx  nsy]  [/AXES  Xmin  Xmax  Ymin  Ymax]  [/CENTER]
    [/VERTICAL Vmin Vmax]

    Makes a parallel projective view of the Regular Grid array, with  hidden
    lines  removed. Altitude and Azimuth are the values of the corresponding
    viewing angles  in  Degrees.  Default  values  are  45  and  45  at  the
    beginning,  and  then  the  last values given.  The upper part is drawn,
    unless the /LOWER option is present.

    Automatic scaling to match approximately the current box is used, but it
    is only a rough guess and may fail if extrema of the Regular Grid occurs
    near the edges. Fine tuning of the plot scale can be obtained using  the
    /FACTOR  option.  It  controls scaling of the Regular Grid values by the
    factor Fv (default 1) and an offset Ov which is in physical units  along
    the Y direction of the plot.

    The Regular Grid array is plotted according to the  orientation  implied
    by command LIMITS, but the whole array is plotted.  The /STEP option may
    be used to indicate to take only 1 pixel over Nsx ones for  the  X  axis
    (resp.  Nsy  and  Y).  The /AXES option plots (X,Y) axes.  The /VERTICAL
    option controls the max, min of plotted perpsective and plots a Z  axis.
    The  /CENTER  option  centers  (?)  the perspective.  BLANKED PIXELS are
    forced to the  minimum  value  of  the  map,  or  the  Vmin  value  when
    the/VERTICAL option is in use.

1 PLOT
        [GREG2\]PLOT [Varname]  [/SCALING  Type  Low [/BLANKING  Bval  Eval]
    [/POSITION  Posx1  Posx2  Posy1  Posy2]  [/LIMITS  Userx1  Userx2 Usery1
    Usery2] [/VISIBLE]

    PLOT will put a pixel image (pixels contained in the  variable  Varname)
    inside the current BOX. Varname is a 2-D SIC variable name that defaults
    to the RG variable if ommitted. Subsets like A[4] where A is a  3-D  sic
    variable  are  not  yet  allowed.  How  to  create  and handle images in
    programs calling the GREG2\ language (including GREG)  is  described  in
    the subtopic IMAGE_HOWTO.

    This command is normally used in the following sequence:

    Greg> SET BOX LOCATION Gx1 Gx2 Gy1 Gy2  ! Define box position
    Greg> RGDATA Varname /VARIABLE          ! Put image in the RG variable,
                                            ! read associated header variables
    Greg> LIMITS/RGDATA                     ! Computes associated limits
    Greg> PLOT                              ! Plot the array in the box
    Greg> BOX                               ! Draws the box
2 /BLANKING
        [GREG2\]PLOT /BLANKING Bval Eval

    Blanking value (Bval) and tolerance (Eval).  Default  values  are  those
    defined by SET BLANKING command (q.v.)
2 /LIMITS
        [GREG2\]PLOT /LIMITS Userx1 Userx2 Usery1 Usery2

    User coordinates corresponding to the image  boundary.  The  default  is
    those of the plotted image (when the image has any), or the current user
    limits if not.

2 /POSITION
        [GREG2\]PLOT /POSITION Posx1 Posx2 Posy1 Posy2

    Box location  in  physical  units  (default  is  the  current  GreG  box
    location)

2 /SCALING
        [GREG2\]PLOT /SCALING Type [Low_cut High_cut]

    Defines the type of transfer function to be used. Type can be  LIN(EAR),
    LOG(ARITHMIC)  of  EQU(ALIZATION),  and the Low_cut and High_cut are the
    lowest and highest represented values respectively. The default ``cuts''
    are  the image extrema. The current cuts are stored in variable LCUT and
    HCUT. The current scaling (as an integer)  is  stored  in  the  variable
    SCALING.  The LOG transfer function computes the logarithm of the pixels
    values, so does not like negative  or  null  pixels.   The  EQUalization
    scaling  tries its best to put the same number of pixels in each slot of
    the color table,  thus  increasing  immensely  the  visibility  of  low-
    contrast  images.  This scaling mode has problem (and warns user) when a
    large number of pixels have exactly the same value (i.e., no contrast at
    all). Beware that most "real" images are obtained with receivers working
    with a small number (11 to 16)  bits,  thus  restricting  the  range  of
    available Real numbers in the data.

    The SIC  variables  EQUAL_NLEV  and  EQUAL_LEV  contain  the  number  of
    different  levels computed in EQUALIZATION mode, and the values of these
    levels. Useful to know which contour levels to draw, and  necessary  for
    the WEDGE command.

2 /VISIBLE
        [GREG2\]PLOT /VISIBLE

    Specify that the image is to be always drawn, even when  totally  masked
    by  an  overlapping image. This allows special features like movies when
    typing ZOOM REFRESH.

2 IMAGE_HOWTO
        There exist a number of ways to get pixels into GREG2\.
  - Read the X, Y, Z values of a Z=f(X,Y) "image", use RGDATA (if  X  and  Y
    define  a  regularly  sampled  grid)  or  RANDOM (if X and Y are "random
    points") to make a Regular Grid Map (see help GREG1\COLUMN, GREG2\RGDATA
    and GREG2\RANDOM)
  - Read a RGDATA-format file with the RGDATA command (see topic RGDATA)
  - Define a 2-D SIC variable and fill it with  values,  or  connect  a  SIC
    variable  with  an  existing  GILDAS  DATA  FORMAT (GDF) image (See HELP
    SIC\DEFINE), or use the SIC\ACCEPT command to read formatted/unformatted
    streams  of  values  and  put  them  in  a  SIC  2-D  variable (see HELP
    SIC\ACCEPT).  Then give this 2-D variable to the internal  image  buffer
    by the RGDATA Varname/VARIABLE command.
  - The command GRAPHIC\IMAGE of GRAPHIC,  which  is  a  superset  of  GREG,
    connects  directly an existing 2,3 or 4-D GILDA DATA FORMAT image in the
    GREG image buffer. Use the GRAPHIC program instead of GREG and  look  at
    HELP IMAGE.
  - GRAPHIC enable the parallel run of image-processing  programs.  Use  the
    VECTOR\RUN  FITS_GILDAS command to convert a FITS image to a GDF (Gildas
    Data Format) image that will be  directly  readable  afterwards  by  the
    GRAPHIC program.
  - The GFITS program reads FITS images and converts them to GDF format, and
    the reverse.
  - "on-the-fly" automatic conversion from FITS to GDF format for SIC\DEFINE
    IMAGE and GRAPHIC\IMAGE commands.

1 POLYGON
        [GREG2\]POLYGON [(File)Name] [/PLOT] [/VARIABLE] [/FILL [Colour]]

    If no argument and no option, it calls the interactive cursor to  define
    the  polygon  summits.   Type any key to go to next summit, D to correct
    the last one and type E to end the polygon definition. The last  polygon
    side  will  then appear. The polygon definition may be aborted by typing
    Q. For X11 displays, you may use the mouse  buttons  for  the  commands.
    The  left  mouse  button draws a vertex, the middle mouse button deletes
    the  last  vertex,  and   the  right  mouse  button  ends  the   polygon
    definition.

    The drawing of the polygon is not stored in the plot, and will disappear
    if  you refresh the plot. The polygon values are stored internally; they
    can be printed with the command GREG1\WRITE POLYGON, and they correspond
    to  the  variables POLY$NXY (number of vertexes), POLY$X and POLY$Y (the
    corresponding coordinates). The currently defined POLYGON is used by the
    commands MEAN and MASK.

    If a Name is given as argument, the cursor is not called but the  summit
    coordinates are read from the corresponding file (X is in column 1, Y in
    column 2), or corresponding SIC Variable if the option /VARIABLE is also
    present.

    If you specify the option /PLOT, the current polygon will be plotted  as
    real  vectors  in the plot, and no longer as temporary vectors as above.
    Option /FILL [Colour] will fill the current polygon, with the current or
    specified colour.

1 PROJECTION
        [GREG2\]PROJECTION [A0 D0 [Angle]] [/TYPE Ptype]

    Define a projection of the (celestial) sphere  from  point  of  (A0,D0),
    (which  are  Longitude and Latitude respectively) of the specified type.
    Angle is the angle between the Y axis and the North pole.  The  previous
    values are kept if no argument is specified.  All angles are in degrees,
    except if the SYSTEM is  EQUATORIAL  in  which  case  A0  is  the  right
    ascension  and must be specified in hours. Formats like  -dd:mm:ss.s  or
      hh:mm.mmm  in sexagesimal notation up to the point field are  allowed.
    After the point, decimal values are assumed.

    When a projection is active, the User  coordinates  are  assumed  to  be
    projected  coordinates  of  the  sphere,  and hence in the case of small
    field of view where distortion are  negligible,  correspond  to  angular
    offsets  MEASURED  IN  RADIANS.  The  field of view of the projection is
    defined by command LIMITS. For convenience (?), LIMITS may be  specified
    in  a  so-called  ANGLE_UNIT  which  can  be  set to Seconds, Minutes or
    Degrees. Note that only the numbers you give are assumed to be  in  this
    "ANGLE_UNIT" :  they  are immediately converted to the natural projected
    unit (equivalent to Radian in case of small field) by  division  by  the
    appropriate  scaling  factor.   That  is  all what this improperly named
    ANGLE_UNIT means.

    The TYPE can be
      - NONE            Disables the  projection  system.  User  coordinates
        then  loose  their interpretation in terms of projected coordinates.
        The ANGLE_UNIT is then totally ignored.
      - GNOMONIC        Radial projection on the tangent plane. Being R  and
        P the (angular) polar coordinates from the projection point (tangent
        point), the projected coordinates are given by X = Tan(R).Sin(P) and
        Y = Tan(R).Cos(P) .
      - ORTHOGRAPHIC   View  from  infinity.  X  =  Sin(R).Sin(P)  and  Y  =
        Sin(R).Cos(P)
      - AZIMUTHAL      Spherical offsets from the projection  center.   X  =
        R.Sin(P) and Y = R.Cos(P).
      - STEREOGRAPHIC  Uses Tan(R/2) instead of Tan(R),  and  is  thus  less
        distorted  than  the  Gnomonic projection. This is an inversion from
        the opposite pole.
      - LAMBERT        Equal  area   projection.   Projected   distance   is
        2*Sin(R)/Sqrt(2*(1+Cos(R)).
      - AITOFF         Equal area projection. Angle and D0 are ignored
      - RADIO          The standard  radio  astronomy  single  dish  mapping
        "projection", in which X = (A-A0).COS(D0) and Y = D-D0. The Angle is
        obviously ignored.

1 RANDOM_MAP
        [GREG2\]RANDOM_MAP  [Arg1  [Arg2]]  [/NEIGHBOURS  Nb]   [/TRIANGLES]
    [/EXTRAPOLATE] [/BLANKING Bval]

    This command is a general purpose interpolation  task  which  uses  data
    from  the X, Y and Z arrays to fill in a Regular Grid array representing
    the same surface Z=f(X,Y) by an interpolation process. X, Y  and  Z  are
    arrays defined by the COLUMN command (see HELP COLUMN).  It triangulates
    the data for interpolation. If a triangulation already exists, and  only
    the   Z  array  has  been  changed,  RANDOM_MAP  does  not  make  a  new
    triangulation.

    Usually, the user-provided Z=f(X,Y) surface is REGULARLY  SAMPLED,  even
    if  NOT  COMPLETELY  SAMPLED.  In this case, one SHOULD USE directly the
    RGDATA command to create a Regular-grid map, since RANDOM  is  known  to
    perform awkwardly with regularly sampled data.

    The interpolated grid can be  defined  by  the  arguments.  If  Arg1  is
    "RGMAP",  the  interpolated  grid  will  be  exactly coincident with the
    current Regular Grid array, else Arg1 and Arg2 are used to indicate  the
    number of pixels in X and Y directions and Arg2 = Arg1 if not specified.

    Note that several hypothesis are made about the geometry of triangles in
    the  plot  page space (hence the geometry may be changed by changing the
    LIMIT or the BOX_LOCATION). You should thus use  limits  which  gives  a
    reasonable  representation  of  what  are the neighbours of a given data
    point. Moreover, this is an interpolation process. Hence  if  the  basic
    sampling theory is not respected by your choice of input data points and
    output grid, spurious oscillations may occur in the resulting grid.
2 /NEIGHBOURS
        [GREG2\]RANDOM_MAP /NEIGHBOURS Nb

    The  argument  Nb  changes  the  number  of   points   influencing   the
    interpolated values. Default is 4 and values up to 8 may be used in some
    cases. Caution, it slows down the program, and may enhance  oscillations
    in some cases.
2 /TRIANGLES
        [GREG2\]RANDOM_MAP /TRIANGLES

    Plot the triangles selected by the program for interpolation.  A  single
    graphic segment will contain all triangles.
2 /EXTRAPOLATE
        [GREG2\]RANDOM_MAP /EXTRAPOLATE

    Control wether extrapolation outside the convex hull of the triangles is
    to  be  done or not. The default is not, i.e. the command fills with the
    blanking  value  the  exterior  of  the   convex   hull.   Beware   that
    extrapolation is always hazardous.
2 /BLANKING
        [GREG2\]RANDOM_MAP /BLANKING Bval

    Specify the value Bval to be attributed for  pixels  lying  outside  the
    convex  hull  of triangles. The default value is that defined in the SET
    BLANKING command. This switch is mandatory if no default blanking  value
    is preset and no extrapolation required.
1 RESAMPLE
        [GREG2\]RESAMPLE Nx Ny [/X Xref  Xval  Xinc]  [/Y  Yref  Yval  Yinc]
    [/BLANKING Bval]

    This command resamples (by bilinear interpolation) the  current  regular
    grid  array  on  a different grid.  The number of pixels of the new grid
    must be specified. Unless the  user  specifies  an  explicit  conversion
    formula  in  the  /X and /Y options, the program adjusts it to match the
    current Regular Grid array.  A blanking value MUST BE specified  (either
    by  default  in  SET  BLANKING or using the option /BLANKING) because no
    extrapolation is performed. For the  same  reason,  any  output  pixel's
    value  that would be interpolated from at least one input blanked pixel,
    is itself blanked.

1 RGDATA
        [GREG2\]RGDATA [Name|Array_X Array_Y Array_Z]   [/SUBSET NXmin NYmin
    NXmax  NYmax]  [/VARIABLE]   [/FORMAT Fmt [code]] [/INCREMENT IncX IncY]
    [/BLANKING Bval]

    This command optionally creates, then loads a two-dimensional  map  into
    the  Regular  Grid array (to be contoured by RGMAP, plotted by PLOT...).
    This is THE basic command needed for subsequent 2-dimensional treatment.
    "Regular Grid" means that data is internally stored as a two-dimensional
    array, thus lies on a Regularly sampled Grid. The  user-provided  "pixel
    values"  may  come from various "descriptions" of such regularly sampled
    (but possibly uncompletely sampled) data:
       1) Three 1-dimensional arrays, say, X Y and Z, that contain  Z=f(X,Y)
        at regular intervals in X and Y.
       2) A preexisting internal 2-D array (possibly a section of a 3D or 4D
        array).
       3) An external, specially formatted, file.

    For data NOT REGULARLY ("randomly") sampled,  use  the  GREG2\RANDOM_MAP
    command  instead. The Regular Grid is itself a 2D SIC variable under the
    name "RG". Once loaded, the RG can be saved on a file with  the  command
    GREG2\WRITE.

    The following command syntax is used to deduce  which  "description"  is
    provided:
      - Without arguments following the command, or with 3 arguments, RGDATA
        will  try  to assemble Z=f(X,Y) either form the X,Y and Z arrays (as
        defined by command COLUMN) or from "Array_X Array_Y  Array_Z",  that
        should be 1D SIC variables previously created by command SIC\DEFINE.
        The option /INCREMENT is used to force the X and Y sampling interval
        to  (IncX,IncY)  in  case of roundoff errors. If a blanking value is
        currently defined, non-sampled pixels will be attributed this value,
        which  is  overriden by the Bval value of the /BLANKING option. Note
        that, if a blanking value is currently defined, pixels for  which  X
        or Y are in the blanking range are themselves blanked.
      - With ONE argument (Name) following the command, Name is taken as the
        name  of an existing SIC 2D variable if option /VARIABLE is present.
        Otherwise, Name is a  specially  formatted  file  (see  HELP  RGDATA
        FILE_FORMAT) from which the Regular Grid array must be read in.
    A rectangular SUBSET of the array, defined by the pixel  coordinates  of
    the  Bottom  Left  Corner  and Top Right Corner can be selected.  RGDATA
    allocates virtual memory according to the map size, so that there is  no
    limit  on the array dimensions. Beware however that handling maps larger
    than 512 by 512 pixels may be slow...

2 /FORMAT

        The /FORMAT option governs how the data part (pixel values)  of  the
    RGDATA file must be read by GreG. fmt is a valid fortran format (default
    is 10z8, the minimal way to encode real*4 data). code may be BY ,  R4  ,
    R8  ,  I4  ,  I2,  depending  if the data written in the file are BYtes,
    Real4, Real8, Integer4 or Integer2. (the values in  the  GreG  map  will
    always be Reals*4 after the read is done).

2 FILE_FORMAT

        The format for the input file consits of a four line header as such:
    1st line : NX XREF XVAL XINC
    2nd line : (any comment for first axis, could be blank)
    3rd line : NY YREF YVAL YINC
    4th line : (any comment for 2nd axis, could be blank)
    followed by the data (NX times NY pixel values) in a format which can be
    specified with the /FORMAT option when the default 10z8 is not used.
    NX is the number of pixels in the 1st dimension of the map  (on  the  "X
    axis"),  XREF  the  index  of  the pixel for which the actual X abscissa
    value is XVAL, the increment between two pixels being XINC, and the same
    for  the  y  axis.  Thus,  the  abcissa X of the pixel 'I' is just X=(I-
    XREF)*XINC+XVAL
    This format is very simple-minded (so that any inexperienced  programmer
    can  use  it  in  less  than 5 minutes), but highly non efficient in I/O
    processing.  A more elaborate data format ("IMAGES"),  specially  suited
    for astronomical applications and large maps is available in the GRAPHIC
    program (a superset of GreG), or directly using SIC  variables  (command
    SIC\DEFINE)  and  the /VARIABLE option of this command.  One should read
    once its data in RGDATA format in GreG, then convert it for  future  use
    in IMAGE format with the command GREG2\WRITE IMAGE filename.

    See also the IMAGE_HOWTO subtopic of the GREG2\PLOT command.

1 RGMAP

        [GREG2\]RGMAP [Quiet|Fast|chunksize] [/PERCENT  P1]  [/ABSOLUTE  A1]
    [/BLANKING Bval Eval] [/GREY COLOUR N] [/KEEP File_Name [Blank]]

    Draws (or Fills) isocontours of the Regular Grid array.  The  RG  is  an
    internal   2D   "map"   created/loaded   by  various  commands  (RGDATA,
    RANDOM_MAP, RESAMPLE, IMAGE), or loaded by a calling program. The levels
    are  those specified by command LEVELS, but may be affected by a scaling
    factor by option /PERCENT or /ABSOLUTE.

    This command is normally used in the following sequence:
    Greg> SET BOX LOCATION Gx1 Gx2 Gy1 Gy2  ! Define box position
    Greg> RGDATA (options...)               ! Put image in the RG variable,
                                            ! read associated header variables
    Greg> LIMITS/RGDATA                     ! Computes associated limits
    Greg> PLOT                              ! Plot the array in the box
    Greg> BOX                               ! Draws the box
    Greg> LEVELS 0.1 to 0.9 by 0.1          ! define contour levels
    Greg> RGMAP/PERCENT 1                   ! Draw contour levels  (in this
                                            ! case, as percentage of peak)

    The "Quiet" mode does contouring silently. For  "Fast"  and  "chunksize"
    modifiers, see subtopic MEMORY_OPTIONS

2 MEMORY_OPTIONS

        The program normally allocates less that 1/5 of the total number  of
    pixels in the map to store the contour segments, and warns the user when
    that limit is reached. Besides, contouring may be slow  on  large  maps.
    The  modifier  "Fast"  cuts  the  map  in  smaller "chunks" and performs
    contouring on those submaps, without the 1/5 above limitation.

    The Contour-filling mode (/GREY) can consume (temporary) a large  amount
    of  memory,  so  is  always performed on subsets of the image ("chunks")
    when the image size is greater than a system-dependent limit (256*256 on
    UNIX systems). When the contours are too involved, an internal limit can
    nevertheless be reached. One  can  then  retry  the  contour-filling  by
    specifying  a  smaller  "Chunksize"  (in  pixels). For example, to force
    contour-filling on subsets of 64 "lines" of a 512x512 pixel image,  type
    RGMAP 64*512 /GREY

2 /PERCENT
        [GREG2\]RGMAP /PERCENT P1

    Computes M=MAX(ABS(min),ABS(max)) of the data to be  contoured.  Contour
    levels  selected with LEVELS are multiples of P1 percent  of M.  E.g. if
    P1 = 10  and  LEVELS 1 2 5 9,  the contour levels are 10, 20, 50 and 90%
    of the peak value.
2 /ABSOLUTE
        [GREG2\]RGMAP /ABSOLUTE A1

    Contour levels are multiples of A1, e.g. for LEVELS 1 2 3,  the  contour
    used will be A1 2*A1 3*A1.
2 /BLANKING
        [GREG2\]RGMAP /BLANKING Bval Eval

    Override the current blanking value as defined by command SET  BLANKING.
    Contours  are  not  drawn in pixels touching pixels with value V so that
    ABS(V-Bval) <= Eval . This is extremely useful for  regular  grids  only
    partially filled as often occur in astronomy.
2 /GREY
        [GREG2\]RGMAP /GREY [start [step] [background]]

    On graphic displays with area filling capabilities, fills contours  with
    up to 16 different color pens (but the number of contours is not limited
    to 16). These pen colors may be changed in the same manner  as  for  the
    pixels  colors  (see  HELP  LUT /PEN).   "start"  (default 0) and "step"
    (default 1) may be used to change the exploration of the 16-pen palette.
    "background"  is  the  number  of  a  color  used to fill the map before
    contour-filling,  thus  providing  a  user-defined  background  for  the
    contour-filled map.

    In case of Filling problems, see the  subtopic  MEMORY_OPTIONS  of  this
    HELP.

2 /KEEP
        [GREG2\]RGMAP /KEEP File_Name [Blank]

    Will keep a formatted copy of the coordinates of the  contour points  in
    the  specified  file.   This file can later be used as an input file for
    COLUMN. X coordinates are in column 1 and Y coordinates in column 2. The
    Blank  value  is written as a separator value for later CONNECT/BLANKING
    Blank. Blank defaults to the SET BLANKING value if it exists, else Blank
    is mandatory.
2 /PENS
        [GREG2\]RGMAP /PENS [Pos Neg]

    Selects the pens for positive and  negative  contours.  Three  modes  of
    operation are possible :
      - Without option /PENS, positive contour levels use pen 0 and negative
        contour  levels  use  pen 15. Positive means that the value given in
        command LEVELS is positive, not the final contour level value  which
        is affected by a possibly negative factor.
      - With option /PENS, all contours use the current pen.
      - With /PENS Pos  Neg,  positive  contours  use  pen  number  Pos  and
        negative contours use pen number Neg.

1 STRIP
        [GREG2\]STRIP [X1 Y1 X2 Y2]

    Will  extract   from the current  Regular  Grid  array  a   strip  going
    through points (X1,Y1)  and (X2,Y2) in User coordinates. If no arguments
    are present,  it will call the cursor  to set the two points.   Although
    the  end  points  need not  be on the  map boundaries, STRIP will always
    produce a full strip across the map.

    For strip parallel  to the X or Y map axis, the nearest pixel is used to
    fill the values. For any other strip orientation,  if the tangent of the
    angle is less  than (NY-1)/(NX-1)  (i.e. if  you scan  the  X  map  axis
    faster   than the  Y map axis),  the  number  of resulting points on the
    strip profile will be NX and the user coordinates along the  strip  will
    be   the  map  X  coordinate.  For each pixel, interpolation along the Y
    axis is done using the three nearby Y pixels. A similar situation with X
    replacing  Y occurs if the angle is larger.

    The map user coordinates are put into the X buffer, and map values  into
    the  Y  buffer.   The  strip   can  then   be plotted using CONNECT, but
    remember to set decent limits before.
1 WEDGE
        [GREG2\]WEDGE [Top|Bottom|Left|Right [Size]]  [/SCALING  Lin|Log|Equ
    Min Max] [/LEVEL [Label] ]

    Will plot a WEDGE along the current BOX. WEDGES are used  after  a  PLOT
    command to show the relationship between pixel hues and image values.

    The default position is Right, i.e., on the right side of the  box,  but
    the  other location and size modifiers are self-explanatory. The SCALING
    defaults to the current scaling of the last image PLOTted,  but  can  be
    changed (as in command PLOT) with the /SCALING option.

    The /LEVEL option will draw levels (as defined by the LEVEL command)  at
    their  appropriate  location on the wedge. The modifier Label will label
    the wedge axis with the level values. This is the  default  (i.e.,  some
    levels  should  be  defined)  for  the  EQUALIZATION Mode, for which the
    relationship between pixel hues and image values is strongly non-linear.

1 WRITE
        [GREG2\]WRITE Item File_Name [/TABLE [X Nx] [Y Ny] [Z Nz]]

    This command is used to saves some GreG internal buffers  on  an  output
    file for later processing. The item specify what is to be saved, and the
    format of saving, and can be :
      - POLYGON    Saves the current polygon in formatted way on two columns
        easily  readable  by  command  COLUMN  or POLYGON later. The default
        extension is .POL.
      - RGDATA     Saves the current Regular Grid  array  on  a  RGDATA-like
        output  file  (to  preserve  the result of a masking, or of a random
        mapping interpolation). The default extension is .DAT.
      - IMAGE      Same as above but uses the more  efficient  and  complete
        IMAGE data format of GILDAS. The default extension is .GDF.
      - COLUMN     Saves the current X Y Z buffers  on  a  formatted  output
        file (after a SORT or a STRIP for example). The default extension is
        .DAT.

    [GREG2\]WRITE COLUMN File_Name [NEW]/TABLE [X Nx] [Y Ny] [Z Nz]

    also saves the X Y Z buffers but on column  Nx,Ny,Nz  of  the  specified
    output  table (GILDAS format). A new table is created if argument NEW is
    specified, otherwise the table must already exists.  The  table  may  be
    expanded  if  any  of Nx,Ny or Nz exceed the table column number ; exact
    match on the number of lines is required. The  tables  can  be  read  by
    command COLUMN/TABLE.
1 END















