# Chapter 13: Geographical Projections and Plotting Maps

This chapter presents different methods to project geographical coordinates onto a plane surface. Several base maps are stored in DISLIN for plotting maps.

## 13.1 Axis Systems and Secondary Axes

G R A F M P

The routine GRAFMP plots a geographical axis system.

The call is: | CALL GRAFMP (XA, XE, XOR, XSTP, YA, YE, YOR, YSTP) | level 1
or: | void grafmp (float xa, float xe, float xor, float xstp, float ya, float ye, float yor, float ystp);

XA, XE | are the lower and upper limits of the X-axis.
XOR, XSTP | are the first X-axis label and the step between labels.
YA, YE | are the lower and upper limits of the Y-axis.
YOR, YSTP | are the first Y-axis label and the step between labels.

Additional notes:

- GRAFMP must be called from level 1 and sets the level to 2.
- The axes must be linear and scaled in ascending order. In general, X-axes must be scaled between -180 and 180 degrees and Y-axes between -90 and 90 degrees.
- For elliptical projections, the plotting of an axis system will be suppressed. This will also be done for azimuthal projections with YE - YA > 90.
- The statement CALL GRIDMP (I, J) overlays an axis system with a longitude and latitude grid where I and J are the number of grid lines between labels in the X- and Y-direction.

X A X M A P

The routine XAXMAP plots a secondary X-axis.

The call is: | CALL XAXMAP (A, B, OR, STEP, CSTR, NT, NY) | level 2
or: | void xaxmap (float a, float b, float or, float step, const char *cstr, int nt, int ny);

A, B | are the lower and upper limits of the X-axis.
OR, STEP | are the first label and the step between labels.
CSTR | is a character string containing the axis name.
NT | indicates how ticks, labels and the axis name are plotted. If NT = 0, they are plotted in a clockwise direction. If NT = 1, they are plotted in a counter-clockwise direction.
NY | defines the horizontal position of the X-axis. A secondary axis must be located inside the axis system.

Y A X M A P

The routine YAXMAP plots a secondary Y-axis.

The call is: | CALL YAXMAP (A, B, OR, STEP, CSTR, NT, NX) | level 2
or: | void yaxmap (float a, float b, float or, float step, const char *cstr, int nt, int nx);

A, B | are the lower and upper limits of the Y-axis.
OR, STEP | are the first label and the step between labels.
CSTR | is a character string containing the axis name.
NT | indicates how ticks, labels and the axis name are plotted. If NT = 0, they are plotted in a clockwise direction. If NT = 1, they are plotted in a counter-clockwise direction.
NX | defines the vertical position of the Y-axis. A secondary axis must be located inside the axis system.

## 13.2 Defining the Projection

Since a globe cannot be unfolded into a plane surface, many different methods have been developed to represent a globe on a plane surface. In cartography, there are 4 basic methods differentiated by attributes such as equal distance, area and angle.

The 4 basic methods are:

- Cylindrical Projections
  The surface of the globe is projected onto a cylinder which can be unfolded into a plane surface and touches the globe at the equator. The latitudes and longitudes of the globe are projected as straight lines.

- Conical Projections
  The surface of the globe is projected onto a cone which can also be unfolded into a plane surface. The cone touches or intersects the globe at two latitudes. The longitudes are projected as straight lines intersecting at the top of the cone and the latitudes are projected as concentric circles around the top of the cone.

- Azimuthal Projections
  For azimuthal projections, a hemisphere is projected onto a plane which touches the hemisphere at a point called the map pole. The longitudes and latitudes are projected as circles.

- Elliptical Projections
  Elliptical projections project the entire surface of the globe onto an elliptical region.

P R O J C T

The routine PROJCT selects the geographical projection.

The call is: | CALL PROJCT (CTYPE) | level 1
or: | void projct (const char *ctype);

CTYPE | is a character string defining the projection.
= 'CYLI' | defines a cylindrical equidistant projection.
= 'MERC' | selects the Mercator projection.
= 'EQUA' | defines a cylindrical equal-area projection.
= 'HAMM' | defines the elliptical projection of Hammer.
= 'AITO' | defines the elliptical projection of Aitoff.
= 'WINK' | defines the elliptical projection of Winkel.
= 'SANS' | defines the elliptical Mercator-Sanson projection.
= 'CONI' | defines a conical equidistant projection.
= 'ALBE' | defines a conical equal-area projection (Albers).
= 'CONF' | defines a conical conformal projection.
= 'AZIM' | defines an azimuthal equidistant projection.
= 'LAMB' | defines an azimuthal equal-area projection.
= 'STER' | defines an azimuthal stereographic projection.
= 'ORTH' | defines an azimuthal orthographic projection.
= 'MYPR' | defines a user-defined projection. Default: CTYPE = 'CYLI'.

Additional notes:

- For cylindrical equidistant projections, the scaling parameters in GRAFMP must be in the range:

                   -540 <= XA <= XE <= 540
                   -180 <= YA <= YE <= 180

- For Mercator projections:

                   -540 <= XA <= XE <= 540
                   - 85 <= YA <= YE <=  85

- For cylindrical equal-area projections:

                   -540 <= XA <= XE <= 540
                   - 90 <= YA <= YE <=  90

- For elliptical projections:

                   -540 <= XA <= XE <= 540
                       XE - XA <= 360
                   - 90 <= YA <= YE <=  90

- For conical projections:

                   -540 <= XA <= XE <= 540
                      0 <= YA <= YE <=  90  or
                   - 90 <= YA <= YE <=   0

  For azimuthal projections with YE - YA > 90, the hemisphere around the map pole is projected onto a circle. Therefore, the hemisphere can be selected with the map pole. The plotting of the axis system is by default suppressed.

  If YE - YA <= 90, the part of the globe defined by the axis scaling is projected onto a rectangle. The map pole will be set by GRAFMP to ((XA+XE)/2, (YE+YA)/2). The scaling parameters must be in the range:

                   -180 <= XA <= XE <= 180 and
                            XE - XA <= 180
                   - 90 <= YA <= YE <=  90

- For all projections except the default projection, longitude and latitude coordinates will be projected with the same scaling factor for the X- and Y-axis. The scaling factor is determined by the scaling of the Y-axis while the scaling of the X-axis is used to centre the map. The longitude (XA+XE)/2 always lies in the centre of the axis system.
- Geographical projections can only be used for routines described in this chapter or routines that plot contours.

## 13.3 Plotting Maps

W O R L D

The routine WORLD plots coastlines and lakes or political borders. Coastlines and lakes are plotted by default, political borders can be enabled with the routine MAPOPT.

The call is: | CALL WORLD | level 2
or: | void world (void);

Additional note:

- The routine WORLD supports also some external map coordinates (see MAPBAS).

S H D M A P

The routine SHDMAP plots shaded continents.

The call is: | CALL SHDMAP (CMAP) | level 2
or: | void shdmap (const char *cmap);

CMAP | is a character string defining the continent.
= 'AFRI' | means Africa.
= 'ANTA' | means the Antarctic.
= 'AUST' | means Australia.
= 'EURA' | means Europe and Asia.
= 'NORT' | means North America.
= 'SOUT' | means South America.
= 'LAKE' | means lakes.
= 'ALL' | means all continents and lakes.
= 'SEA' | means that oceans and lakes are shaded.
= 'LSEA' | means that oceans and lakes are shaded, where 'gshhs_l.b' is used for sea shading.
= 'ISEA' | means that oceans and lakes are shaded, where 'gshhs_i.b' is used for sea shading.
= 'HSEA' | means that oceans and lakes are shaded, where 'gshhs_h.b' is used for sea shading.
= 'LAND' | means that all land is shaded without lakes.
= 'GSHL' | means that 'gshhs_l.b' is used for all land shading.
= 'GSHI' | means that 'gshhs_l.i' is used for all land shading.
= 'GSHH' | dmeans that 'gshhs_l.h' is used for all land shading.

Additional note:

- Shading patterns can be selected with SHDPAT and MYPAT except for 'SEA' and 'LAND' shading, where a solid shading is used. Colours can be defined with COLOR and SETCLR.

S H D A F R

The routine SHDAFR plots shaded African countries.

The call is: | CALL SHDAFR (INRAY, IPRAY, ICRAY, N) | level 2
or: | void shdafr (const int *inray, const long *ipray, const int *icray, int n);

INRAY | is an integer array containing the countries to be shaded. INRAY can have the following values:
        1: Algeria           19: Gabon          37: Nigeria
        2: Angola            20: Gambia         38: Ruanda
        3: Benin             21: Ghana          39: Senegal
        4: Botswana          22: Guinea         40: Seychelles
        5: Burkina Faso      23: Guinea Bissau  41: Sierra Leone
        6: Burundi           24: Kenya          42: Somalia
        7: Cameroon          25: Lesotho        43: South Africa
        8: Central Afr. Rep. 26: Liberia        44: Sudan
        9: Chad              27: Libya          45: Swaziland
       10: Comoros           28: Madagascar     46: Tanzania
       11: Congo, Dem. Rep.  29: Malawi         47: Togo
       12: Congo, Rep.       30: Mali           48: Tunisia
       13: Cote d'Ivoire     31: Mauritania     49: Uganda
       14: Djibouti          32: Mauritius      50: West Sahara
       15: Egypt             33: Morocco        51: Zambia
       16: Equatorial Guinea 34: Mozambique     52: Zimbabwe
       17: Eritrea           35: Namibia
       18: Ethiopia          36: Niger           0: Africa
IPRAY | is an integer array containing shading patterns.
ICRAY | is an integer array containing colour numbers. The value -1 means that the current colour is used.
N | is the number of countries to be shaded.

S H D A S I

The routine SHDASI plots shaded Asiatic countries.

The call is: | CALL SHDASI (INRAY, IPRAY, ICRAY, N) | level 2
or: | void shdasi (const int *inray, const long *ipray, const int *icray, int n);

INRAY | is an integer array containing the countries to be shaded. INRAY can have the following values:
        1: Afghanistan     19: Jordan         37: Saudi Arabia
        2: Armenia         20: Kazakhstan     38: Sri Lanka
        3: Azerbaijan      21: Korea (North)  39: Singapore
        4: Bangladesh      22: Korea (South)  40: Spratly
        5: Bhutan          23: Kuwait         41: Syria
        6: Brunei          24: Kyrgyzstan     42: Taiwan
        7: Burma           25: Laos           43: Tajikistan
        8: Cambodia        26: Lebanon        44: Thailand
        9: China           27: Malaysia       45: Turkey
       10: Emirates        28: Maldives       46: Turkmenistan
       11: Gaza            29: Mongolia       47: Uzbekistan
       12: Georgia         30: Nepal          48: Vietnam
       13: India           31: Oman           49: Westbank
       14: Indonesia       32: Pakistan       50: Yemen
       15: Iran            33: Paracel        51: Bahrain
       16: Iraq            34: Philippines
       17: Israel          35: Qatar
       18: Japan           36: Russia          0: All
IPRAY | is an integer array containing shading patterns.
ICRAY | is an integer array containing colour numbers. The value -1 means that the current colour is used.
N | is the number of countries to be shaded.

S H D A U S

The routine SHDAUS plots shaded countries of Australia and Oceania.

The call is: | CALL SHDAUS (INRAY, IPRAY, ICRAY, N) | level 2
or: | void shdaus (const int *inray, const long *ipray, const int *icray, int n);

INRAY | is an integer array containing the countries to be shaded. INRAY can have the following values:
        1: Australia       6: Nauru            11: Solomon
        2: Fiji            7: New Caledonia    12: Tonga
        3: Kiribati        8: New Zealand      13: Tuvalu
        4: Marshall        9: Papua New Guinea 14: Vanuatu
        5: Micronesia     10: Samoa             0: All
IPRAY | is an integer array containing shading patterns.
ICRAY | is an integer array containing colour numbers. The value -1 means that the current colour is used.
N | is the number of countries to be shaded.

S H D E U R

The routine SHDEUR plots shaded European countries.

The call is: | CALL SHDEUR (INRAY, IPRAY, ICRAY, N) | level 2
or: | void shdeur (const int *inray, const long *ipray, const int *icray, int n);

INRAY | is an integer array containing the countries to be shaded. INRAY can have the following values:
      1: Albania        17: Luxembourg    33: Belarus
      2: Andorra        18: Malta         34: Bosnia
      3: Belgium        19: Netherlands   35: Croatia
      4: Bulgaria       20: North Ireland 36: Czech Republic
      5: Germany        21: Norway        37: Estonia
      6: Denmark        22: Austria       38: Latvia
      7: Cyprus         23: Poland        39: Lithuania
      8: United Kingdom 24: Portugal      40: Macedonia
      9: Finland        25: Romania       41: Moldavia
     10: France         26: Sweden        42: Russia
     11: Greece         27: Switzerland   43: Serbia
     12: Ireland        28: Spain         44: Slovakia
     13: Iceland        29: CSFR          45: Slovenia
     14: Italy          30: Turkey        46: Ukraine
     15: Yugoslavia     31: USSR          47: Kosovo
     16: Liechtenstein  32: Hungary       48: Montenegro
     49: North Cyprus   50: South Cyprus   0: Europe
IPRAY | is an integer array containing shading patterns.
ICRAY | is an integer array containing colour numbers. The value -1 means that the current colour is used.
N | is the number of countries to be shaded.

Additional notes:

- The plotting of outlines can be suppressed with CALL NOARLN.
- To stay compatible with older programs, the number 15 (Yugoslavia) plots Bosnia, Croatia, Macedonia, Serbia and Slovenia, the number 29 (CSFR) plots Czech Republic and Slovakia and the number 31 (USSR) plots Belarus, Estonia, Latvia, Lithuania, Moldavia, Russia and Ukraine.

S H D N O R

The routine SHDNOR plots shaded countries of North and Central America.

The call is: | CALL SHDNOR (INRAY, IPRAY, ICRAY, N) | level 2
or: | void shdnor (const int *inray, const long *ipray, const int *icray, int n);

INRAY | is an integer array containing the states to be shaded. INRAY can have the following values:
       1: Alaska           13: El Salvador   25: Nicaragua
       2: Antigua, Barbuda 14: Greenland     26: Panama
       3: Bahamas          15: Grenada       27: Puerto Rico
       4: Barbados         16: Guadeloupe    28: St. Kitts, Nevis
       5: Belize           17: Guatemala     29: St. Lucia
       6: British Virgin   18: Haiti         30: St. Vincent
       7: Caiman Islands   19: Honduras      31: Trinidad
       8: Canada           20: Jamaica       32: USA
       9: Costa Rica       21: Martinique
      10: Cuba             22: Mexico
      11: Dominica         23: Montserrat
      12: Dominican Rep.   24: Neth. Antilles 0: All
IPRAY | is an integer array containing shading patterns.
ICRAY | is an integer array containing colour numbers. The value -1 means that the current colour is used.
N | is the number of states to be shaded.

S H D S O U

The routine SHDSOU plots shaded states of South America.

The call is: | CALL SHDSOU (INRAY, IPRAY, ICRAY, N) | level 2
or: | void shdsou (const int *inray, const long *ipray, const int *icray, int n);

INRAY | is an integer array containing the states to be shaded. INRAY can have the following values:
       1: Argentina      6: Ecuador        11: Suriname
       2: Bolivia        7: French Guyana  12: Uruguay
       3: Brazil         8: Guyana         13: Venezuela
       4: Chile          9: Paraguay
       5: Colombia      10: Peru           0: All
IPRAY | is an integer array containing shading patterns.
ICRAY | is an integer array containing colour numbers. The value -1 means that the current colour is used.
N | is the number of states to be shaded.

S H D U S A

The routine SHDUSA plots shaded USA states.

The call is: | CALL SHDUSA (INRAY, IPRAY, ICRAY, N) | level 2
or: | void shdusa (const int *inray, const long *ipray, const int *icray, int n);

INRAY | is an integer array containing the states to be shaded. INRAY can have the following values:
      1: Alabama     19: Maine          37: Oregon
      2: Alaska      20: Maryland       38: Pennsylvania
      3: Arizona     21: Massachusetts  39: Rhode Island
      4: Arkansas    22: Michigan       40: South Carolina
      5: California  23: Minnesota      41: South Dakota
      6: Colorado    24: Mississippi    42: Tennessee
      7: Connecticut 25: Missouri       43: Texas
      8: Delaware    26: Montana        44: Utah
      9: Florida     27: Nebraska       45: Vermont
     10: Georgia     28: Nevada         46: Virginia
     11: Hawaii      29: New Hampshire  47: Washington
     12: Idaho       30: New Jersey     48: West Virginia
     13: Illinois    31: New Mexico     49: Wisconsin
     14: Indiana     32: New York       50: Wyoming
     15: Iowa        33: North Carolina 51: Washington DC
     16: Kansas      34: North Dakota
     17: Kentucky    35: Ohio
     18: Louisiana   36: Oklahoma        0: USA
IPRAY | is an integer array containing shading patterns.
ICRAY | is an integer array containing colour numbers. The value -1 means that the current colour is used.
N | is the number of states to be shaded.

M A P I M G

The routine MAPIMG plots a BMP or GIF raster image to an axis system. Some parameters which describe the location, scale and rotation of the map are passed to MAPIMG. The parameters have the same meaning as the attributes of the ESRI World File Format.

The call is: | CALL MAPIMG (CFIL, X1, X2, X3, X4, X5, X6) | level 2
or: | void mapimg (char *cfil, float x1, float x2, float x3, float x4, float x5, float x6);

CFIL | is a character string that contains the name of a BMP or GIF file.
X1 | is the pixel size in the X-direction in map units per pixel.
X2 | is the rotation about the Y-axis.
X3 | is the rotation about the X-axis.
X4 | is the pixel size in the Y-direction in map units per pixel. This value is normally a negative number.
X5 | is the X-coordinate of the centre of the upper left pixel.
X6 | is the Y-coordinate of the centre of the upper left pixel.

## 13.4 Plotting Data Points

C U R V M P

The routine CURVMP plots curves through data points or marks them with symbols.

The call is: | CALL CURVMP (XRAY, YRAY, N) | level 2
or: | void curvmp (const float *xray, const float *yray, int n);

XRAY, YRAY | are real arrays containing the data points.
N | is the number of data points.

Additional notes:

- CURVMP is similar to CURVE except that only a linear interpolation can be used.
- In general, a line between two points on the globe will not be projected as a straight line. Therefore, CURVMP interpolates lines linearly by small steps. An alternate plotting mode can be set with MAPMOD.

## 13.5 Parameter Setting Routines

M A P B A S

The routine MAPBAS defines the map data file used in the routine WORLD. An internal DISLIN map file, some external map files compiled by Paul Wessel and map files in Mapgen format can be used. The map files compiled by Paul Wessel can be copied via FTP anonymous from the sites

- http://www.ngdc.noaa.gov/mgg/shorelines/data/gshhs/
- ftp://ftp.soest.hawaii.edu/pwessel/gshhs/

The external map files 'gshhs_l.b', 'gshhs_i.b', 'gshhs_h.b' and 'gshhs_f.b' must be copied to the map subdirectory of the DISLIN directory, or the name of the map file must be specified with the routine MAPFIL.

Map files in Mapgen format are available from the Coastline Extractor:

- http://rimmer.ngdc.noaa.gov

The call is: | CALL MAPBAS (COPT) | level 1, 2
or: | void mapbas (const char *copt);

COPT | is a character string defining the map data file.
= 'DISLIN' | defines the DISLIN base map.
= 'GSHL' | defines 'gshhs_l.b' as base map.
= 'GSHI' | defines 'gshhs_l.i' as base map.
= 'GSHH' | defines 'gshhs_l.h' as base map.
= 'GSHF' | defines 'gshhs_l.f' as base map.
= 'MAPFIL' | defines an external map file as base map that is specified with the routine MAPFIL. Default: COPT = 'DISLIN'.

M A P F I L

The routine MAPFIL defines an external map file. The map file can be used as base map if the routine MAPBAS is called with the parameter 'MAPFIL'.

The call is: | CALL MAPFIL (CFIL, COPT) | level 1, 2
or: | void mapfil (const char *cfil, const char *copt);

CFIL | is a character string containing the filename of the external map file.
COPT | is a character string describing the format of the map coordinates. COPT can have the values 'GSHHS' and 'MAPGEN'.

M A P D I R

DISLIN searches for map files in the subdirectory 'map' of the DISLIN directory. This behaviour can be changed with the routine MAPDIR.

The call is: | CALL MAPDIR (CFIL, COPT) | level 1, 2
or: | void mapdir (const char *cdir);

CDIR | is a character string containing the directory where DISLIN searches for map files.

M A P L E V

The routine MAPLEV defines land or lake coordinates for WORLD if the external map files from Paul Wessel are used.

The call is: | CALL MAPLEV (COPT) | level 1, 2
or: | void maplev (const char *copt);

COPT | is a character string that can have the values 'BOTH', 'LAND', 'LAKE' and 'RIVERS'. The keyword 'BOTH' means 'LAND' and 'LAKE'. If COPT = 'RIVERS', the WDB rivers distributed with the GSHHS coordinates are plotted. Default: COPT = 'BOTH'.

M A P P O L

MAPPOL defines the map pole used for azimuthal projections.

The call is: | CALL MAPPOL (XPOL, YPOL) | level 1
or: | void mappol (float xpol, float ypol);

XPOL, YPOL | are the longitude and latitude coordinates in degrees where:
                -180 <= XPOL <= 180 and
                 -90 <= YPOL <=  90.
Default: (0., 0.)

Additional note:

- For an azimuthal projection with YE - YA <= 90, the map pole will be set by GRAFMP to ((XA+XE)/2, (YA+YE)/2).

M A P S P H

For an azimuthal projection with YE - YA > 90, DISLIN automatically projects a hemisphere around the map pole onto a circle. The hemisphere can be reduced using MAPSPH.

The call is: | CALL MAPSPH (XRAD) | level 1
or: | void mapsph (float xrad);

XRAD | defines the region around the map pole that will be projected onto a circle (0 < XRAD <= 90). Default: XRAD = 90.

M A P R E F

The routine MAPREF defines, for conical projections, two latitudes where the cone intersects or touches the globe.

The call is: | CALL MAPREF (YLW, YUP) | level 1
or: | void mapref (float ylw, float yup);

YLW, YUP | are the lower and upper latitudes where:
                    0 <= YLW <= YUP <= 90 or
                 - 90 <= YLW <= YUP <=  0
Default: YLW = YA + 0.25 * (YE - YA), YUP = YA + 0.75 * (YE - YA)

Additional note:

- YLW and YUP can have identical values and lie outside of the axis scaling.

M A P L A B

The routine MAPLAB enables axis system labels for azimuthal and elliptical projections.

The call is: | CALL MAPLAB (COPT, CKEY) | level 1, 2
or: | void maplab (const char *copt, const char *ckey);

COPT | is a character string that can contain the options 'NONE', 'LEFT', 'RIGHT' and 'BOTH'.
CKEY | is a character string containing the keyword 'LATITUDE'. Default: ('NONE', 'LATITUDE').

M A P M O D

The routine MAPMOD determines how data points will be connected by CURVMP.

The call is: | CALL MAPMOD (CMODE) | level 1, 2
or: | void mapmod (const char *cmode);

CMODE | is a character string defining the connection mode.
= 'STRAIGHT' | defines straight lines.
= 'INTER' | means that lines will be interpolated linearly.
= 'GREAT' | means Great Circle interpolation. Default: CMODE = 'INTER'.

M A P O P T

The routine MAPOPT enables political borders plotted by the routine WORLD, or sets an option to adjust the length of the X-axis to the scaling.

The call is: | CALL MAPOPT (COPT, CKEY) | level 1, 2
or: | void mapopt (const char *copt, const char *ckey);

COPT | is a character string containing an option.
CKEY | is a character string containing a keyword:
= 'WORLD' | If CKEY = 'WORLD', COPT can have the values 'COAST', 'BORDERS' and 'BOTH'. The default value is COPT = 'COAST'.
= 'XAXIS' | If CKEY = 'XAXIS', COPT can have the values 'STANDARD' and 'AUTO'. Normally, longitude and latitude coordinates will be projected with the same scaling factor where the scaling factor is determined by the scaling of the Y-axis while the scaling of the X-axis is used to centre the map. For COPT = 'AUTO', DISLIN tries the change the length of the X-axis, so that the axis length corresponds to the scaling parameters in GRAFMP for the X-axis. The default value is COPT = 'STANDARD'.

## 13.6 Conversion of Coordinates

P O S 2 P T

The routine POS2PT converts map coordinates to plot coordinates.

The call is: | CALL POS2PT (XLONG, YLAT, XP, YP) | level 2
or: | void pos2pt (float xlong, float ylat, float *xp, float *yp);

XLONG, YLAT | are the map coordinates in degrees.
XP, YP | are the plot coordinates calculated by POS2PT.

The corresponding functions are:

- XP = X2DPOS (XLONG, YLAT)
- YP = Y2DPOS (XLONG, YLAT)

P T 2 P O S

The routine PT2POS is the inverse routine to POS2PT and converts plot coordinates to map coordinates. The plot coordinates should be located in the current axis system.

The call is: | CALL PT2POS (XP, YP, XLONG, YLAT) | level 2
or: | void pt2pos (float xp, float yp, float *xlong, float *ylat);

XP, YP | are the plot coordinates.
XLONG, YLAT | are the map coordinates claculated by PT2POS.

## 13.7 User-defined Projections

A user-defined projection can be enabled with the keyword 'MYPR' in the routine PROJCT. For a user-defined projection, the user must write a routine that converts longitude and latitude coordinates to axis coordinates (plot coordinates relative to the origin of the axis system). The name of the user written routine must then passed to DISLIN with the routine SETCBK.

S E T C B K

The routine SETCBK defines a user written callback routine.

The call is: | CALL SETCBK (ROUTINE, 'MYPR') | level 0, 1, 2, 3
or: | void setcbk ((void) (*routine)(float *xp, float *yp), "MYPR");

ROUTINE | is the name of a routine defined by the user. In Fortran, the routine must be declared as EXTERNAL.

In the following example, a cylindrical projection is implemented as an user-defined projection:

          PROGRAM MYPR
          EXTERNAL MYFUNC
          COMMON /MYCOMM/ XA,XE,YA,YE,NXL,NYL

          XA = -180.
          XE = 180.
          YA = -90.
          YE = 90.

          NXL = 2400
          NYL = 1200

          CALL METAFL ('cons')
          CALL DISINI
          CALL PAGERA
          CALL COMPLX
          CALL AXSLEN (NXL, NYL)

          CALL PROJCT ('MYPR')
          CALL SETCBK (MYFUNC, 'MYPR')

          CALL GRAFMP (XA, XE, XA, 90., YA, YE, YA, 30.)
          CALL GRIDMP (1,1)
          CALL WORLD
          CALL DISFIN
          END

          SUBROUTINE MYFUNC (XP, YP)
          COMMON /MYCOMM/ XA,XE,YA,YE,NXL,NYL
          XP = (XP - XA)/(XE - XA) * (NXL - 1)
          YP = (YP - YA)/(YE - YA) * (NYL - 1)
          END

## 13.8 Examples

- World Coastlines and Lakes

- Elliptical Projections

- Azimuthal Lambert Projections

- Conformal Conic Projection

Next | Previous | Contents