Small subset of the GDAL and ArcGDAL packages but with no extra dependencies. For the time being this sub-module is not intended to much direct use except some documented functions. Interested people should consult the GDAL & ArchGDAL docs.

contains(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns true if g1 contains g2.

arccircle(x0, y0, radius, start_angle, end_angle; z0=0, inc=2, gdataset=false)

Parameters

• x0: center X
• y0: center Y
• radius: radius of the circle.
• start_angle: angle to first point on arc (clockwise of X-positive)
• end_angle: angle to last point on arc (clockwise of X-positive)

Keywords

• z0: center Z. Optional, if not provided the output is flat 2D
• inc: the largest step in degrees along the arc. Default is 2 degree
• gdataset: Returns a GDAL IGeometry even when input are GMTdataset or Matrix

Returns

A GMT dataset or a GDAL IGeometry

arcellipse(x0, y0, primary_radius, secondary_radius, start_angle, end_angle; rotation=0, z0=0, inc=2, gdataset=false)

Parameters

• x0: center X
• y0: center Y
• primary_radius: X radius of ellipse.
• secondary_radius: Y radius of ellipse.
• start_angle: angle to first point on arc (clockwise of X-positive)
• end_angle: angle to last point on arc (clockwise of X-positive)

Keywords

• rotation: rotation of the ellipse clockwise.
• z0: center Z. Optional, if not provided the output is flat 2D
• inc: the largest step in degrees along the arc. Default is 2 degree
• gdataset: Returns a GDAL IGeometry even when input are GMTdataset or Matrix

Returns

A GMT dataset or a GDAL IGeometry

boundary(geom; gdataset=false)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• gdataset: Returns a GDAL IGeometry even when input are GMTdataset or Matrix

A new geometry object is created and returned containing the boundary of the geometry on which the method is invoked.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

buffer(geom, dist::Real, quadsegs::Integer=30; gdataset=false)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• dist: the buffer distance to be applied. Should be expressed into the same unit as the coordinates of the geometry.
• quadsegs: the number of segments used to approximate a 90 degree (quadrant) of curvature.
• gdataset: Returns a GDAL IGeometry even when input is a GMTdataset or Matrix

Compute buffer of geometry.

Builds a new geometry containing the buffer region around the geometry on which it is invoked. The buffer is a polygon containing the region within the buffer distance of the original geometry.

Some buffer sections are properly described as curves, but are converted to approximate polygons. The quadsegs parameter can be used to control how many segments should be used to define a 90 degree curve - a quadrant of a circle. A value of 30 is a reasonable default. Large values result in large numbers of vertices in the resulting buffer geometry while small numbers reduce the accuracy of the result.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

centroid(geom; gdataset=false)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of them), or a Matrix
• gdataset: Returns a GDAL IGeometry even when input is a GMTdataset or Matrix

Compute the geometry centroid.

The centroid is not necessarily within the geometry.

(This method relates to the SFCOM ISurface::get_Centroid() method however the current implementation based on GEOS can operate on other geometry types such as multipoint, linestring, geometrycollection such as multipolygons. OGC SF SQL 1.1 defines the operation for surfaces (polygons). SQL/MM-Part 3 defines the operation for surfaces and multisurfaces (multipolygons).)

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

concavehull(geom, ratio, allow_holes::Bool=true; gdataset=false)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• ratio: Ratio of the area of the convex hull and the concave hull.
• allow_holes: Whether holes are allowed.
• gdataset: Returns a GDAL IGeometry even when input are GMTdataset or Matrix

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

convexhull(geom; gdataset=false)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• gdataset: Returns a GDAL IGeometry even when input are GMTdataset or Matrix

A new geometry object is created and returned containing the convex hull of the geometry on which the method is invoked.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

crosses(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns true if the geometries are crossing.

delaunay(geom::AbstractGeometry, tol::Real=0, onlyedges::Bool=true; gdataset=false)

Parameters

• geom: the geometry.
• tol: optional snapping tolerance to use for improved robustness
• onlyedges: if true, will return a MULTILINESTRING, otherwise it will return a GEOMETRYCOLLECTION containing triangular POLYGONs.
• gdataset: Returns a GDAL IGeometry even when input is GMTdataset or Matrix

Return a Delaunay triangulation of the vertices of the geometry.

difference(geom1, geom2; gdataset=false)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type
• gdataset: Returns a GDAL IGeometry even when input is GMTdataset or Matrix

Generates a new geometry which is the region of this geometry with the region of the other geometry removed.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

disjoint(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns true if the geometries are disjoint.

distance(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns the distance between the geometries or -1 if an error occurs.

dither(indata; n_colors=256, save="", gdataset=false)

Convert a 24bit RGB image to 8bit paletted.

• Use the save=fname option to save the result to disk in a GeoTiff file fname. If fname has no extension a .tif one will be appended. Alternatively give file names with extension .png or .nc to save the file in one of those formats.
• gdataset=true: to return a GDAL dataset. The default is to return a GMTimage object.
• n_colors: Select the number of colors in the generated color table. Defaults to 256.

envelope(geom)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix

Computes and returns the bounding envelope for this geometry.

envelope3d(geom)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix

Computes and returns the bounding envelope (3D) for this geometry

equals(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns true if the geometries are equivalent.

fetchbool(strlist::Vector{String}, name::String)

In a StringList of "Name=Value" pairs, look to see if there is a key with the given name, and if it can be interpreted as being TRUE. If the key appears without any "=Value" portion it will be considered true. If the value is NO, FALSE or 0 it will be considered FALSE otherwise if the key appears in the list it will be considered TRUE. If the key doesn't appear at all, the indicated default value will be returned.

fillnodata!(data::GItype; nodata=nothing, kwargs...)

Fill selected raster regions by interpolation from the edges.

Parameters

• data: Input data. It can be a file name, a GMTgrid or GMTimage object.
• nodata: The nodata value that will be used to fill the regions. Otherwise use the nodata attribute of indata if it exists, or NaN if none of the above were set.
• kwargs:
  • band: the band number. Default is first layer in indata
  • maxdist: the maximum number of cels to search in all directions to find values to interpolate from. Default, fills all.
  • nsmooth: the number of 3x3 smoothing filter passes to run (0 or more).

Returns

The modified input data

GI = fillnodata(data::String; nodata=nothing, kwargs...) -> GMTgrid or GMTimage

Fill selected raster regions by interpolation from the edges.

Parameters

• data: Input data. The file name of a grid or image that can be read with gmtread.
• nodata: The nodata value that will be used to fill the regions. Otherwise use the nodata attribute of indata if it exists, or NaN if none of the above were set.
• kwargs:
  • band: the band number. Default is first layer in indata
  • maxdist: the maximum number of cels to search in all directions to find values to interpolate from. Default, fills all.
  • nsmooth: the number of 3x3 smoothing filter passes to run (0 or more).

Returns

A GMTgrid or GMTimage object with the band nodata values filled by interpolation.

gdaldem(dataset, method, options=String[]; dest="/vsimem/tmp", color=name|GMTcpt, kw...)

Tools to analyze and visualize DEMs.

Parameters

• dataset The source dataset.
• method the processing to apply (one of "hillshade", "slope", "aspect", "color-relief", "TRI", "TPI", "Roughness").
• options List of options (potentially including filename and open options). The accepted options are the ones of the gdaldem utility.

Keyword Arguments

• color color file (mandatory for "color-relief" processing, should be empty otherwise). If color is just a CPT name we compute a CPT from it and the input grid.

• kw... keyword=value arguments when method is hillshade.

Returns

A GMT grid or Image, or a GDAL dataset (or nothing if file was writen on disk).

G = gdalgrid(indata, method::StrSymb="", options=String[]; dest="/vsimem/tmp", kw...)

Parameters

• indata: The source dataset. It can be a file name, a GMTdataset, a Mx3 matrix or a GDAL dataset
• method: The interpolation method name. One of "invdist", "invdistnn", "average", "nearest", "linear", "minimum", "maximum", "range", "count", "averagedistance", "averagedistance_pts".
• options: List of options. The accepted options are the ones of the gdal_grid utility. This list can be in the form of a vector of strings, or joined in a single string.
• kwargs: The kwargs may also contain the GMT region (-R), inc (-I) and save=fname options.

Returns

A GMTgrid or a GDAL dataset (or nothing if file was writen on disk). To force the return of a GDAL dataset use the option gdataset=true.

gdaltranslate(indata, options=String[]; dest="/vsimem/tmp", kwargs...)

Convert raster data between different formats and other operations also provided by the GDAL 'gdal_translate' tool. Namely sub-region extraction and resampling. The kwargs options accept the GMT region (-R), increment (-I), target SRS (-J). Any of the keywords outgrid, outfile or save = outputname options to make this function save the result in disk in the file 'outputname'. The file format is picked from the 'outputname' file extension. When no output file name is provided it returns a GMT object (either a grid or an image, depending on the input type). To force the return of a GDAL dataset use the option gdataset=true.

• indata: Input data. It can be a file name, a GMTgrid or GMTimage object or a GDAL dataset
• options: List of options. The accepted options are the ones of the gdal_translate utility. This list can be in the form of a vector of strings, or joined in a single string.
• kwargs: Besides what was mentioned above one can also use meta=metadata, where metadata is a string vector with the form "NAME=...." for each of its elements. This data will be recognized by GDAL as Metadata. The kwargs may also contain the GMT region (-R), proj (-J), inc (-I) and save=fname options.

Returns

A GMT grid or Image, or a GDAL dataset (or nothing if file was writen on disk).

ogr2ogr(indata, options=String[]; dest="/vsimem/tmp", kwargs...)

Parameters

• indata The source dataset.
• options List of options (potentially including filename and open options). The accepted options are the ones of the gdalwarp utility.
• kw are kwargs that may contain the GMT region (-R), proj (-J), inc (-I) and save=fname options

Returns

A GMT dataset, or a GDAL dataset (or nothing if file was writen on disk).

gdalwarp(indata, options=String[]; dest="/vsimem/tmp", kwargs...)

Image/Grid reprojection and warping function.

Parameters

• indata: Input data. It can be a file name, a GMTgrid or GMTimage object or a GDAL dataset
• options: List of options. The accepted options are the ones of the gdal_translate utility. This list can be in the form of a vector of strings, or joined in a single string. The accepted options are the ones of the gdalwarp utility.
• kwargs: Besides what was mentioned above one can also use meta=metadata, where metadata is a string vector with the form "NAME=...." for each of its elements. This data will be recognized by GDAL as Metadata. The kwargs may also contain the GMT region (-R), proj (-J), inc (-I) and save=fname options.

Returns

A GMT grid or Image, or a GDAL dataset (or nothing if file was writen on disk).

geodesicarea(geom)

Compute geometry area, considered as a surface on the underlying ellipsoid of the SRS attached to the geometry. The returned area will always be in square meters, and assumes that polygon edges describe geodesic lines on the ellipsoid. If the geometry' SRS is not a geographic one, geometries are reprojected to the underlying geographic SRS of the geometry' SRS.

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix

Returns the area of the geometry in square meters or a negative value in case of error for unsupported geometry types.

geomarea(geom)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix

Returns the area of the geometry or 0.0 for unsupported geometry types.

geomlength(geom)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix

Returns the length of the geometry, or 0.0 for unsupported geometry types.

intersection(geom1, geom2; gdataset=false)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type
• gdataset: Returns a GDAL IGeometry even when input is GMTdataset or Matrix

Returns a new geometry representing the intersection of the geometries, or NULL if there is no intersection or an error occurs.

Generates a new geometry which is the region of intersection of the two geometries operated on. The intersects function can be used to test if two geometries intersect.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

intersects(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns whether the geometries intersect

Determines whether two geometries intersect. If GEOS is enabled, then this is done in rigorous fashion otherwise true is returned if the envelopes (bounding boxes) of the two geometries overlap.

overlaps(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns true if the geometries overlap.

pointalongline(geom, distance::Real; gdataset=false)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• distance: distance along the curve at which to sample position. This distance should be between zero and geomlength() for this curve.
• gdataset: Returns a GDAL IGeometry even when input are GMTdataset or Matrix

Fetch point (or NULL) at given distance along curve.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

D = polygonize(data::GItype; kwargs...) -> Vector{GMTdataset}

This method, which uses the GDAL GDALPolygonize function, creates vector polygons for all connected regions of pixels in the raster sharing a common pixel/cell value. The input may be a grid or an image. This function can be rather slow as it picks lots of polygons in pixels with slightly different values at transitions between colors. Its natural use is to digitize masks images.

Parameters

• data: Input data. It can be a GMTgrid or GMTimage object.
• kwargs:
  • min, nmin, npixels or ncells: The minimum number of cells/pixels for a polygon to be retained. Default is 1. This can be set to filter out small polygons.
  • min_area: Minimum area in m2 for a polygon to be retained. This option takes precedence over the one above that is based in the counting of cells. Note also that this is an approximate value because at this point we still don't know exactly the latitudes of the polygons.
  • max_area: Maximum area in m2 for a polygon to be retained.
  • simplify: Apply the Douglas-Peucker line simplification algorithm to the poligons. Provide a tolerence in meters. For example: simplify=0.5. But be warned that this is a risky option since a too large tolerance

can lead to loss of otherwise good polygons. A good rule of thumb is to use the cell size for the tolerance.
And in fact that is what we do when using `simplify=:auto`.

• sort: If true, will sort polygons by pixel count. Default is the order that GDAL decides internally.

polygonize(geom; gdataset=false)

Parameters

• geom: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• gdataset: Returns a GDAL IGeometry even when input are GMTdataset or Matrix

Polygonizes a set of sparse edges.

A new geometry object is created and returned containing a collection of reassembled Polygons: NULL will be returned if the input collection doesn't correspond to a MultiLinestring, or when reassembling Edges into Polygons is impossible due to topological inconsistencies.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

polyunion(geom1, geom2; gdataset=false)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type
• gdataset: Returns a GDAL IGeometry even when input is GMTdataset or Matrix

Computes a new geometry representing the union of the geometries.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

setproj!(type, proj)

Set a referencing system to the type object. This object can be a GMTgrid, a GMTimage, a GMTdataset or an AbstractDataset.

• proj Is either a Proj4 string or a WKT. Alternatively, it can also be another grid, image or dataset type, in which case its referencing system is copied into type

simplify(geom::AbstractGeometry, tol::Real; gdataset=false)

Compute a simplified geometry.

Parameters

• geom: the geometry.
• tol: the distance tolerance for the simplification.
• gdataset: Returns a GDAL IGeometry even when input is GMTdataset or Matrix

symdifference(geom1, geom2; gdataset=false)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type
• gdataset: Returns a GDAL IGeometry even when input is GMTdataset or Matrix

Generates a new geometry representing the symmetric difference of the geometries or NULL if the difference is empty or an error occurs.

Returns

A GMT dataset when input is a Matrix or a GMT type (except if gdaset=true), or a GDAL IGeometry otherwise

touches(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns true if the geometries are touching.

within(geom1, geom2)

Parameters

• geom1: the geometry. This can either be a GDAL AbstractGeometry or a GMTdataset (or vector of it), or a Matrix
• geom2: Second geometry. AbstractGeometry if geom1::AbstractGeometry or a GMTdataset/Matrix if geom1 is GMT type

Returns true if g1 is contained within g2.

ds = wrapgeom(geom::AbstractGeometry, proj="") -> Dataset

Wrap a geometry type into a GDAL dataset. Optionaly provide the SRS (proj4) via the PROJ option.
Handy function for saving a geometry on disk or visualize it with plot()

Submodule where the symbols of plot were elevated to the category of functions. The functions that are currently available are:

• circle(x, y, diameter, kw...)
• cross(x, y, diameter; kw...)
• custom(x, y, name, size; kw...)
• diamond(x, y, diameter; kw...)
• hexagon(x, y, diameter; kw...)
• itriangle(x, y, diameter; kw...)
• letter(x, y, size, str, font, just; kw...)
• minus(x, y, length; kw...)
• pentagon(x, y, diameter; kw...)
• plus(x, y, diameter; kw...)
• square(x, y, diameter; kw...)
• star(x, y, diameter; kw...)
• triangle(x, y, diameter; kw...)
• ydash(x, y, length; kw...)
• box(x, y, width, height; kw...)
• rect(x, y, width, height; kw...)
• ellipse(x, y, angle, majoraxis, minoraxis; kw...)
• ellipseAz(x, y, azimuth, majoraxis, minoraxis; kw...)
• rotrect(x, y, angle, width, height; kw...)
• rotrectAz(x, y, azimuth, width, height; kw...)
• roundrect(x, y, width, height, radius; kw...)

For all symbols, except box, diameter is the diameter of the circumscribing circle and x,y the coordinates of its center. box is the exception in that those are the coordinates of the lower left corner.

This submodule uses global variables to track the first, middle and last layers in the stack plot but in case of errors that track may be left in error state too. So, when one want to force the begining of a new figure use the kwarg first=true. Likewise, if we want to add to a previously, still open fig, use first=false.

By default the plot unites is $cm$ but we can select $points$ by doing units=:points. This takes care of setting the appropriate region (A4 by default) and fig scale. If other then A4 size is wished, use paper=:A3 (or any of the common paper sizes). When units is left to $cm$ the normal paper size ruple applies (i.e. A4 for PS format or ~unlimitted for others.)

The kw... in the functions arguments are the normal kwargs that one can use in the plot module.

Example, to draw a cute litte car:

ellipse(300,201,0, 200, 50, units=:points, fill=:purple, pen=1)
ellipse(340,206, 0,130, 66, fill=:purple, pen=1)
ellipse(318,222,0, 60, 26, fill=:blue)
box(200, 173, 205, 26, fill=:purple, pen=1)
circle(305,185,56, fill=:black)
circle(305,185,36, fill=:gray50)
circle(400,185,56, fill=:black)
circle(400,185,36, fill=:gray50, show=true)

GMT manipulating geographic and Cartesian data sets (including filtering, trend fitting, gridding, projecting, etc.) and producing high quality illustrations.

Full modules list and docs in terse GMT style at http://docs.generic-mapping-tools.org/latest/

Documentation for GMT.jl at https://www.generic-mapping-tools.org/GMT.jl/latest/

mutable struct GMTcpt

The fields of this struct are:

• colormap::Array{Float64,2}: Mx3 matrix equal to the first three columns of cpt
• alpha::Array{Float64,1}: Vector of alpha values. One for each color.
• range::Array{Float64,2}: Mx2 matrix with z range for each slice
• minmax::Array{Float64,1}: Two elements Vector with zmin,zmax
• bfn::Array{Float64,2}: A 3x3(4?) matrix with BFN colors (one per row) in [0 1] interval
• depth::Cint: Color depth: 24, 8, 1
• hinge::Cdouble: Z-value at discontinuous color break, or NaN
• cpt::Array{Float64,2}: Mx6 matrix with r1 g1 b1 r2 g2 b2 for z1 z2 of each slice
• egorical::Int: Is this CPT categorical? 0 = No, 1 = Yes, 2 = Yes and keys are strings.
• label::Vector{String}: Labels of a Categorical CPT
• key::Vector{String}: Keys of a Categorical CPT
• model::String: String with color model rgb, hsv, or cmyk [rgb]
• comment::Vector{String}: Cell array with any comments

mutable struct GMTdataset{T<:Real, N} <: AbstractArray{T,N}

The GMTdataset type is how tables, (geo)referenced or not, communicate in/out with the GMT and GDAL libraries. They implement the AbstractArray and Tables interface.

The fields of this struct are:

• data::Array{T,N}: Mx2 Matrix with segment data
• ds_bbox::Vector{Float64}: Global BoundingBox (for when there are many segments)
• bbox::Vector{Float64}: Segment BoundingBox
• attrib::Dict{String, Union{String, Vector{String}}}: Dictionary with attributes/values (optional)
• colnames::Vector{String}: Column names. Antecipate using this with a future Tables inerface
• text::Vector{String}: Array with text after data coordinates (mandatory only when plotting Text)
• header::String: String with segment header (Optional but sometimes very useful)
• comment::Vector{String}: Array with any dataset comments [empty after first segment]
• proj4::String: Projection string in PROJ4 syntax (Optional)
• wkt::String: Projection string in WKT syntax (Optional)
• epsg::Int: EPSG projection code (Optional)
• geom::Integer: Geometry type. One of the GDAL's enum (wkbPoint, wkbPolygon, etc...)

mutable struct GMTgrid{T<:Number,N} <: AbstractArray{T,N}

The GMTgrid type is how grids, 2D or multi-layered, (geo)referenced or not, communicate in/out with the GMT and GDAL libraries. They implement the AbstractArray interface.

The fields of this struct are:

• proj4::String: Projection string in PROJ4 syntax (Optional)
• wkt::String: Projection string in WKT syntax (Optional)
• epsg::Int: EPSG code
• geog::Int: Is geographic coords? 0 -> No; 1 -> [-180 180]; 2 -> [0 360]
• range::Vector{Float64}: 1x6[8] vector with [xmin, xmax, ymin, ymax, zmin, zmax [, vmin, vmax]]
• inc::Vector{Float64}: 1x2[3] vector with [xinc, yinc [,v_inc]]
• registration::Int: Registration type: 0 -> Grid registration; 1 -> Pixel registration
• nodata::Union{Float64, Float32}: The value of nodata
• title::String: Title (Optional)
• comment::String: Remark (Optional)
• command::String: Command used to create the grid (Optional)
• cpt::String: Name of a recommended GMT CPT name for this grid.
• names::Vector{String}: To use whith multi-layered and when layers have names (Optional)
• x::Vector{Float64}: [1 x n_columns] vector with XX coordinates
• y::Vector{Float64}: [1 x n_rows] vector with YY coordinates
• v::Union{Vector{<:Real}, Vector{String}}: [v x n_bands] vector with VV (vertical for 3D grids) coordinates
• z::Array{T,N}: [nrows x ncolumns] grid array
• x_unit::String: Units of XX axis (Optional)
• y_unit::String: Units of YY axis (Optional)
• v_unit::String: Units of Vertical axis (Optional)
• z_unit::String: Units of z vlues (Optional)
• layout::String: A three character string describing the grid memory layout
• scale::Union{Float64, Float32}=1f0: When saving in file apply z = z * scale + offset
• offset::Union{Float64, Float32}=0f0
• pad::Int=0: When != 0 means that the array is placed in a padded array of PAD rows/cols
• hasnans::Int=0: 0 -> "don't know"; 1 -> confirmed, "have no NaNs"; 2 -> confirmed, "have NaNs"

mutable struct GMTimage{T<:Union{Unsigned, Bool}, N} <: AbstractArray{T,N}

The GMTimage type is how images (UInt8, UInt16), 2D or multi-layered, (geo)referenced or not, communicate in/out with the GMT and GDAL libraries. They implement the AbstractArray interface.

The fields of this struct are:

• proj4::String: Projection string in PROJ4 syntax (Optional)
• wkt::String: Projection string in WKT syntax (Optional)
• epsg::Int: EPSG code
• geog::Int: Is geographic coords? 0 -> No; 1 -> [-180 180]; 2 -> [0 360]
• range::Vector{Float64}: 1x6[8] vector with [xmin, xmax, ymin, ymax, zmin, zmax [, vmin, vmax]]
• inc::Vector{Float64}: 1x2[3] vector with [xinc, yinc [,v_inc]]
• registration::Int: Registration type: 0 -> Grid registration; 1 -> Pixel registration
• nodata::Float32: The value of nodata
• color_interp::String: If equal to "Gray" an indexed image with no cmap will get a gray cmap
• metadata::Vector{String}: To store any metadata that can eventually be passed to GDAL (Optional)
• names::Vector{String}: To use whith multi-band and when bands have names (Optional)
• x::Vector{Float64}: [1 x n_columns] vector with XX coordinates
• y::Vector{Float64}: [1 x n_rows] vector with YY coordinates
• v::Vector{Float64}: [v x n_bands] vector with vertical coords or wavelengths in hypercubes (Optional)
• image::Array{T,N}: [nrows x ncolumns x n_bands] image array
• labels::Vector{String}: Labels of a Categorical CPT
• n_colors::Int: Number of colors stored in the vector 'colormap'
• colormap::Vector{Int32}: A vector with n_colors-by-4 saved column-wise
• alpha::Matrix{UInt8}: A [nrows x ncolumns] alpha array
• layout::String: A four character string describing the image memory layout
• pad::Int: When != 0 means that the array is placed in a padded array of PAD rows/cols

mutable struct GMTps

The fields of this struct are:

• postscript::String: Actual PS plot (text string)
• length::Int: Byte length of postscript
• mode::Int: 1 = Has header, 2 = Has trailer, 3 = Has both
• comment::Vector{String}: A vector with any eventual comments

Compute the logical complement of a boolean GMTimage. Inherits metadata from input image.

Intersect two boolean/uint8 mask images. It applies the logical I1 && I2 operation. Inherit header parameters from I1 image

Add two boolean mask/uint8 images. It applies the logical I1 || I2 operation. Inherit header parameters from I1 image

The infix operation I1 | I2 is a synonym for +(I1,I2).

delete!(d::Dict, symbs::Vector{T}) where T

example

delete!(d, [:a :b]) delete!(d, [:a, :b]) delete!(d, [[:a, :b], [:c]]) delete!(d, [[:a :b] [:c]])

Bitwise exclusive or of I1 and I2 boolean images. Inherits metadata from I1.

The infix operation I1 ⊻ I2 is a synonym for xor(I1,I2), and ⊻ can be typed by tab-completing \xor or \veebar in the Julia REPL.

t = ISOtime2unix(ts::AbstractString) -> Float64

Take a string representing a time and return the equivalent Unix time. The ts string may take one of these forms:

• "YYYY-mm-dd", or "YYYY-mm-ddThh", or "YYYY-mm-ddThh:mm", or "YYYY-mm-ddThh:mm:ss", or "dd-Jan-YY" or "dd-Jan-YYYY"

Examples

using Dates
t = ISOtime2unix("2019-01-01T12")
1.546344e9

t = ISOtime2unix("25-Apr-1974")
1.3608e8

Normal(x::Vector{<:Real})     # standard Normal distribution with zero mean and unit variance
Normal(x, μ)       # Normal distribution with mean μ and unit variance
Normal(x, μ, σ)    # Normal distribution with mean μ and variance σ^2

D = ODE2ds(sol; interp=0)

Extract data from a DifferentialEquations solution type and return it into a GMTdataset.

• interp: == 0 means we return the original points (no interpolation). == 2 => do data interpolation to the double of original number of points. == 3 => three times, == n => n times.

Uniform(x::Vector{<:Real}, a=-1.0, b=1.0)    # Uniform distribution over [a, b]

ablines(a, b; kw...)

or

ablines([a1, a2, ..., an], [b1, b2, ..., bn]; kw...)

or

ablines(D::GMTdataset; kw...)

Creates a straight line(s) defined by Y = a + b * X. Input can be a pair of a,b parameters or a vector of them, case in which multiple straight lines are plotted. Plot limits are passed through the usual region option in kw or, if missing, we plot lines in the x = [0 10] interval. The third form, when input is a GMTdataset type implies that this was computed with the linearfitxy function, which embeds the linear fit parameters in the data type attributes. All plot options are available via the kw arguments.

Examples:

ablines([1, 2, 3], [1, 1.5, 2], linecolor=[:red, :orange, :pink], linestyle=:dash, linewidth=2, show=true)

D = linearfitxy([0.0, 0.9, 1.8, 2.6, 3.3, 4.4, 5.2, 6.1, 6.5, 7.4], [5.9, 5.4, 4.4, 4.6, 3.5, 3.7, 2.8, 2.8, 2.4, 1.5],
                 sx = 1 ./ sqrt.([1000., 1000, 500, 800, 200, 80,  60, 20, 1.8, 1]), sy=1 ./
                 sqrt.([1., 1.8, 4, 8, 20, 20, 70, 70, 100, 500]));
plot(D, linefit=true, band_ab=true, band_CI=true, ellipses=true, Vd=2)
plot!(D, linefit=true, Vd=2)
ablines!(D, Vd=2)
ablines!(0,1, Vd=2)

add2PSfile(text)

Add commands to the GMT PostScript file while it is not yet finished.

• text: is a string, with optional line breaks in it, or a vector of strings.

This option is for PostScript gurus that want/need to mess with the PS plot file in the middle of its construction.

append2fig(fname::String)

Move the file fname to the default name and location (GMT_user.ps in tmp). The fname should be a PS file that has NOT been closed. Posterior calls to plotting methods will append to this file. Useful when creating figures that use a common base map that may be heavy (slow) to compute.

arrows(cmd0::String="", arg1=nothing; arrow=(...), kwargs...)

Plots an arrow field. When the keyword arrow=(...) or vector=(...) is used, the direction (in degrees counter-clockwise from horizontal) and length must be found in columns 3 and 4, and size, if not specified on the command-line, should be present in column 5. The size is the length of the vector head. Vector stem width is set by option pen or line_attrib.

The vecmap=(...) variation is similar to above except azimuth (in degrees east of north) should be given instead of direction. The azimuth will be mapped into an angle based on the chosen map projection. If length is not in plot units but in arbitrary user units (e.g., a rate in mm/yr) then you can use the input_col option to scale the corresponding column via the +sscale modifier.

The geovec=(...) or geovector=(...) keywords plot geovectors. In geovectors, azimuth (in degrees east from north) and geographical length must be found in columns 3 and 4. The size is the length of the vector head. Vector width is set by pen or line_attrib. Note: Geovector stems are drawn as thin filled polygons and hence pen attributes like dashed and dotted are not available. For allowable geographical units, see the units=() option.

The full arrow options list can be consulted at Vector Attributes

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• W | pen | line_attrib :: [Type => Str]

  Set pen attributes for lines or the outline of symbols

• savefig | figname | name :: [Type => Str]

  Save the figure with the figname=name.ext where ext chooses the figure format (e.g. figname="name.png")

Example:

arrows([0 8.2 0 6], limits=(-2,4,0,9), arrow=(len=2,stop=1,shape=0.5,fill=:red), axis=:a, pen="6p", show=true)

pix_x, pix_y = axes2pix(xy, dims, x, y, reg=0, layout::String="TC")

Convert axes coordinates to pixel/cell coordinates.

• xy: A Mx2 matrix with x & y coordinates in same units as those in the x,y vectors
• x,y: should be the coordinate vectors of a GMTgrid or GMTimage types
• dims: Tuple with the number of rows,columns as returned by size(GI)

Return two vectors of Int with the indices that map xy to x and y

band(cmd0::String="", arg1=nothing; width=0.0, envelope=false, kwargs...)

Plot a line with a symmetrical or asymmetrical band around it. If the band is not color filled then, by default, only the envelope outline is plotted.

Example: Plot the sinc function with a green band of width 0.1 (above and below the sinc line)

x = y = -10:0.11:10;
band(x, sin.(x)./x, width=0.1, fill="green@80", show=true)

or, the same but using a function

band(x->sin(x)/x, 10, width=0.1, fill="green@80", show=true)

bar(cmd0::String="", arg1=nothing; kwargs...)

Reads a file or (x,y) pairs and plots vertical bars extending from base to y.

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• fill :: [Type => Str –

  Select color or pattern for filling the bars

• base | bottom :: [Type => Str | Num] $key=value$

  By default, base = ymin. Use this option to change that value. If base is not appended then we read it. from the last input data column.

• size | width :: [Type => Str | Num] $key=value$

  The size or width is the bar width. Append u if size is in x-units. When width is used the default is plot-distance units.

• savefig | figname | name :: [Type => Str]

  Save the figure with the figname=name.ext where ext chooses the figure format (e.g. figname="name.png")

Example:

bar(sort(randn(10)), fill=:black, axis=:auto, show=true)

bar3(cmd0::String="", arg1=nothing; kwargs...)

Read a grid file, a grid or a MxN matrix and plots vertical bars extending from base to z.

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• fill :: [Type => Str] $key=color$

  Select color or pattern for filling the bars

• base :: [Type => Str | Num] $key=value$

  By default, base = ymin. Use this option to change that value. If base is not appended then we read it.

• p | view | perspective :: [Type => Str or List] $Arg = [x|y|z]azim[/elev[/zlevel]][+wlon0/lat0[/z0]][+vx0/y0]$

  Selects perspective view and sets the azimuth and elevation of the viewpoint [180/90].

• savefig | figname | name :: [Type => Str]

  Save the figure with the figname=name.ext where ext chooses the figure format (e.g. figname="name.png")

Example:

G = gmt("grdmath -R-15/15/-15/15 -I0.5 X Y HYPOT DUP 2 MUL PI MUL 8 DIV COS EXCH NEG 10 DIV EXP MUL =");
bar3(G, lw=:thinnest, show=true)

basemap(; kwargs...)

Plot base maps and frames.

See full GMT (not the jl one) docs at psbasemap

Parameters

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• A | polygon :: [Type => Str | []]

  No plotting is performed. Instead, we determine the geographical coordinates of the polygon outline for the (possibly oblique) rectangular map domain.

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• inset :: [Type => NamedTuple]

  Draw a simple map insert box on the map.

• F | box :: [Type => Str]

  Without further options, draws a rectangular border around any map insert (D), map scale (L) or map rose (T)

• Jz | zscale | zsize :: [Type => String]

• L | map_scale :: [Type => Str]

  Draw a map scale.

• P | portrait :: [Type => Bool or []]

  Tell GMT to NOT draw in portrait mode (that is, make a Landscape plot)

• Td | rose :: [Type => Str]

  Draws a map directional rose on the map at the location defined by the reference and anchor points.

• Tm | compass :: [Type => Str]

  Draws a map magnetic rose on the map at the location defined by the reference and anchor points.

• U | time_stamp | timestamp :: [Type => Str or Bool or []] $Arg = [[just]/dx/dy/][c|label]$

  Draw GMT time stamp logo on plot.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• X | x_offset | xshift :: [Type => Str] $Arg = [a|c|f|r][x-shift[u]]$

• Y | y_offset | yshift :: [Type => Str] $Arg = [a|c|f|r][y-shift[u]]$

  Shift plot origin relative to the current origin by (x-shift,y-shift) and optionally append the length unit (c, i, or p).

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• p | view | perspective :: [Type => Str or List] $Arg = [x|y|z]azim[/elev[/zlevel]][+wlon0/lat0[/z0]][+vx0/y0]$

  Selects perspective view and sets the azimuth and elevation of the viewpoint [180/90].

• t | alpha | transparency :: [Type => Str] $Arg = transp$

  Set PDF transparency level for an overlay, in (0-100] percent range. [Default is 0, i.e., opaque].

To see the full documentation type: $@? basemap$

Ibw = binarize(I::GMTimage, threshold; band=1, revert=false) -> GMTimage

Converts an image to a binary image (black-and-white) using a threshold. If revert=true, values below the threshold are set to 255, and values above the threshold are set to 0. If the I image has more than one band, use band to specify which one to binarize.

binstats(cmd0::String="", arg1=nothing; kwargs...)

Reads arbitrarily located (x,y[,z][,w]) points (2-4 columns) and for each node in the specified grid layout determines which points are within the given radius. These point are then used in the calculation of the specified statistic. The results may be presented as is or may be normalized by the circle area to perhaps give density estimates. Alternatively, select hexagonal tiling instead or a rectangular grid layout.

See full GMT (not the GMT.jl one) docs at gmtbinstats

Parameters

• C | stats | statistic :: [Type => String | NamedTuple]

  Choose the statistic that will be computed per node based on the points that are within radius distance of the node.

• I | inc | increment | spacing :: [Type => Str] $Arg = xinc[unit][+e|n][/yinc[unit][+e|n]]]$

  x_inc [and optionally y_inc] is the grid spacing. Optionally, append an increment unit.

• E | empty :: [Type => Number]

  Set the value assigned to empty nodes [NaN].

• G | save | outgrid | outfile :: [Type => Str]

  Output grid file name. Note that this is optional and to be used only when saving the result directly on disk. Otherwise, just use the G = gmtbinstats(....) form.

• N | normalize :: [Type => Bool]

  Normalize the resulting grid values by the area represented by the search_radius.

• S | search_radius :: [Type => Number]

  Sets the search_radius that determines which data points are considered close to a node. Not compatible with tiling

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• T | tiling | bins :: [Type => String | NamedTuple]

  Instead of circular, possibly overlapping areas, select non-overlapping tiling. Choose between rectangular hexagonal binning.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | weights :: [Type => Bool | String]

  Input data have a 4th column containing observation point weights.

• a | aspatial :: [Type => Str] $Arg = [col=]name[…]$

  Control how aspatial data are handled in GMT during input and output.

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• q | inrow | inrows :: [Type => Str] $Arg = [i|o][~]rows[+ccol][+a|f|s]$

  Select specific data rows to be read (-qi [Default]) or written (-qo) [all].

• r | reg | registration :: [Type => Bool or []]

  Force pixel node registration [Default is gridline registration].

• w | wrap | cyclic :: [Type => Str or Number] $Arg = [[-]n]$

  Convert input records to a cyclical coordinate.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

To see the full documentation type: $@? gmtbinstats$

blendimg!(color::GMTimage, shade::GMTimage; new=false, mode="", transparency=0.5, white=220, burn_up=180, screen_low=200)

Blend color GMTimage that is normally a RGB image with the shade intensity image (normally obtained with gdaldem or Blender ray tracer). However, for certain blender modes both $color$ or $shade$ can be RGB or grayscale images. It is highly instructive to watch this YouTube video on how to combine the "LinearBurn" and the "Screen" modes to create stunning "Shaded relief" effects. https://somethingaboutmaps.wordpress.com/2014/10/26/adding-shaded-relief-in-photoshop/

• mode:

  • mode="" or mode="gcalc": The blending method is the one explained at https://gis.stackexchange.com/questions/255537/merging-hillshade-dem-data-into-color-relief-single-geotiff-with-qgis-and-gdal/255574#255574

  • mode="blend": Simple 50% (default) blend is performed. Set transparency to other value in the ]0 1[ range to weight more one of the images. 0.75 will make img weight 3/4 of the total sum, and so forth.

  • mode="LinearBurn": (Same as Photoshop blender LinearBurn) Adds the pixel values of the upper and lower layers and then subtracts 255. It tends to make the image darker. The burn_up option sets the threshold value of $shade$ above which the $color$ image is not modified.

  • mode="ColorBurn": (Same as Photoshop blender ColorBurn) It inverts the pixel value of $color$ layer, divides that by the pixel value of the $shade$, then inverts the result. It tends to make the image darker.

  • mode="Screen": (Same as Photoshop blender Screen) Inverts the values of each of the visible pixels in the two images. (That is, it subtracts each of them from 255) Then it multiplies them together, and inverts this value again. The resulting image is usually brighter, and sometimes “washed out” in appearance. To control this washing effect, use the screen_low option that sets the threshold value of $shade$ below which the $color$ image is not modified. Note, this value is very case dependent and normally requires some trial and error to find the right value. A second way of controlling the washing effect is to use the white option different from 255. The default here is white=220 which makes the added bright be less bright.

• new: If true returns a new GMTimage object, otherwise it changes the color content.

blockmean(cmd0::String="", arg1=nothing; kwargs...)

Block average (x,y,z) data tables by L2 norm.

See full GMT (not the GMT.jl one) docs at blockmean

Parameters

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• I | inc | increment | spacing :: [Type => Str] $Arg = xinc[unit][+e|n][/yinc[unit][+e|n]]]$

  x_inc [and optionally y_inc] is the grid spacing. Optionally, append an increment unit.

• A | field | fields :: [Type => Str]

  Select which fields to write to individual grids. Append comma-separated codes for available fields: z (the mean data z, but see statistic), s (standard deviation), l (lowest value), h (highest value) and w (the output weight; requires weights). [Default is just z].

• C | center :: [Type => Bool]

  Use the center of the block as the output location [Default uses the mean location]. Not used when -A

• E | extend | extended :: [Type => Str | []]

  Provide Extended report which includes s (the standard deviation about the mean), l, the lowest value, and h, the high value for each block. Output order becomes x,y,z,s,l,h[,w]. [Default outputs x,y,z[,w]. See -W for w output. If -Ep is used we assume weights are 1/(sigma squared) and s becomes the propagated error of the mean.

• G | save | outgrid | outfile :: [Type => Str]

  Write one or more fields directly to grids on disk; no table data are return. If more than one fields are specified via A then grdfile must contain the format flag %s so that we can embed the field code in the file names. If not provided but A is used, return 1 or more GMTgrid type(s).

• S | statistic :: [Type => Str | Symb]

  Use statistic=:n to report the number of points inside each block, statistic=:s to report the sum of all z-values inside a block, statistic=:w to report the sum of weights [Default (or statistic=:m reports mean value].

• mean :: [Type => Any]

  Report the mean value of points inside each block

• npts | counts :: [Type => Any]

  Report the number of points inside each block

• sum :: [Type => Any]

  Report the sum of all z-values inside each block

• sum_weights :: [Type => Any]

  Report the the sum of weights

• grid :: [Type => Bool]

  With any of the above options (statistic, npts, sum) this option makes it return a grid instead of a GMTdataset.

• W | weights :: [Type => Str | []]

  Unweighted input and output have 3 columns x,y,z; Weighted i/o has 4 columns x,y,z,w. Weights can be used in input to construct weighted mean values for each block.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• q | inrow | inrows :: [Type => Str] $Arg = [i|o][~]rows[+ccol][+a|f|s]$

  Select specific data rows to be read (-qi [Default]) or written (-qo) [all].

• r | reg | registration :: [Type => Bool or []]

  Force pixel node registration [Default is gridline registration].

• w | wrap | cyclic :: [Type => Str or Number] $Arg = [[-]n]$

  Convert input records to a cyclical coordinate.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

blockmedian(cmd0::String="", arg1=nothing; kwargs...)

Block average (x,y,z) data tables by L1 norm.

See full GMT (not the GMT.jl one) docs at blockmedian

blockmode(cmd0::String="", arg1=nothing; kwargs...)

Block average (x,y,z) data tables by mode estimation.

See full GMT (not the GMT.jl one) docs at blockmode

boxplot(data, grp=[]; pos=nothing, kwargs...)

• data: A vector (plots a single box), a Matrix (plots n columns boxes), a MxNxG (plots G groups) of N columns boxes, a Vector{Vector} (plots n clumn boxes but from data of different sizes), a Vector{Vector{Vector}} (plots G groups - length(data) -, where groups may have variable number of elements and each have its own size.)
• grp: Categorical vector (made of integers or text strings) used to break down a the data column vector in cathegories (groups).
• pos: a coordinate vector (or a single location when data is a vector) where to plot the boxes. Default plots them at 1:nboxes or 1:ngroups.
• ccolor: Logical value indicating whether the groups have constant color (when fill=true is used) or have variable color (the default).
• fill: If fill=true paint the boxes with a pre-defined color scheme. Otherwise, give a list of colors to paint the boxes.
• fillalpha : When fill option is used, we can set the transparency of filled boxes with this option that takes in an array (vec or 1-row matrix) with numeric values between [0-1] or ]1-100],

      where 100 (or 1) means full transparency.

• boxwidth or cap: Sets the the boxplot width and, optionally, the cap width. Provide info as boxwidth="10p/3p" to set the boxwidth different from the cap's. Note, however, that this requires GMT6.5. Previous versions do not destinguish box and cap widths.
• groupWidth: Specify the proportion of the x-axis interval across which each x-group of boxes should be spread. The default is 0.75.
• notch: Logical value indicating whether the box should have a notch.
• outliers: If other than a NamedTuple, plots outliers (1.5IQR) with the default black 5pt stars. If argument is a NamedTuple (marker=??, size=??, color=??, markeredge=??), where marker is one of the plots marker symbols, plots the outliers with those specifications. Any missing spec default to the above values. i.e outliers=(size="3p") plots black 3 pt stars.
• horizontal or hbar: plot horizontal instead of vertical boxplots.
• weights: Array giving the weights for the data in data. The array must be the same size as data.
• region or limits: By default we estimate the plotting limits but sometimes that may not be convenient. Give a region=(xmin,xmax,ymin,ymax) tuple if you want to control the plotting limits.
• separator: If = true plot a black line separating the groups. Otherwise provide the pen settings of those lines.
• ticks or xticks or yticks: A tuple with annotations interval and labels. E.g. xticks=(1:5, ["a", "b", "c", "d"]) where first element is an AbstractArray and second an array or tuple of strings or symbols.

buffergeo(D::GMTdataset; width=0, unit=:m, np=120, flatstart=false, flatend=false, epsg::Integer=0, tol=0.01)

or

buffergeo(line::Matrix; width=0, unit=:m, np=120, flatstart=false, flatend=false, proj::String="", epsg::Integer=0, tol=0.01)

or

buffergeo(fname::String; width=0, unit=:m, np=120, flatstart=false, flatend=false, proj::String="", epsg::Integer=0, tol=0.01)

Computes a buffer arround a poly-line. This calculation is performed on a ellipsoidal Earth (or other planet) using the GeographicLib (via PROJ4) so it should be very accurate.

Parameters

• D | line | fname: - the geometry. This can either be a GMTdataset (or vector of it), a Mx2 matrix, the name of file that can be read as a GMTdataset by gmtread() or a GDAL AbstractDataset object
• width: - the buffer width to be applied. Expressed meters (the default), km or Miles (see unit)
• unit: - If width is not in meters use one of unit=:km, or unit=:Nautical or unit=:Miles
• np: - Number of points into which circles are descretized (Default = 120)
• flatstart - When computing buffers arround poly-lines make the start flat (no half-circle)
• flatend - Same as flatstart but for the buffer end
• proj - If line data is in Cartesians but with a known projection pass in a PROJ4 string to allow computing the buffer
• epsg - Same as proj but using an EPSG code
• tol - At the end simplify the buffer line with a Douglas-Peucker procedure. Use TOL=0 to NOT do the line simplification, or use any other value in degrees. Default computes it as 0.5% of buffer width.

Returns

A GMT dataset or a vector of it (when input is Vector{GMTdataset})

Example: Compute a buffer with 50000 m width

D = buffergeo([0 0; 10 10; 15 20], width=50000);

burn_alpha!(img::GMTimage{<:UInt8, 3}, alpha; bg=:white)

Burn the alpha channel into the image by compositing the image values with the background color at locations where alpha is non-zero.

• img: The RGB image to be modified by the alpha channel.
• alpha: A GMTimage or a matrix of uint8/boolean values indicating the locations where the corresponding locations in the image should be burned. All non-zero values will be used to composite the image with the background color. For example, a value of 255 will replace a pixel by the background color, a value of 127 will compose the image and background witha weight of 50% each.
• bg: The background color to be used in the compositing. It can be a 3-tuple of integers in the range [0 255] or a symbol or string that will a color name. e.g., bg=:blue. The default is :white.

theta, rho = cart2pol(x, y; deg=false)

Transform Cartesian to polar coordinates. Angles are returned in radians by default. Use deg=true to return the angles in degrees. Input can be scalar, vectors or matrices.

az, elev, rho = cart2sph(x, y, z; deg=false)

Transform Cartesian coordinates to spherical. Angles are returned in radians by default. Use deg=true to return the angles in degrees. Input can be scalar, vectors or matrices.

cpt = check_remote_cpt(cmd0::String) -> String

Check if cmd0 is a remote grid or a OceanColor one and return the default CPT if it is.

circgeo(lon, lat; radius=X, proj="", s_srs="", epsg=0, dataset=false, unit=:m, np=120, shape="")

or

circgeo(lonlat; radius=X, proj="", s_srs="", epsg=0, dataset=false, unit=:m, np=120, shape="")

Args:

• lonlat: - longitude, latitude (degrees). If a Mx2 matrix, returns as many segments as number of rows. Use this to compute multiple shapes at different positions. In this case output type is

			always a vector of GMTdatasets.

• radius: - The circle radius in meters (but see unit) or circumscribing circle for the other shapes
• proj or s_srs: - the given projection whose ellipsoid we move along. Can be a proj4 string or an WKT
• epsg: - Alternative way of specifying the projection [Default is WGS84]
• dataset: - If true returns a GMTdataset instead of matrix (with single shapes)
• unit: - If radius is not in meters use one of unit=:km, or unit=:Nautical or unit=:Miles
• np: - Number of points into which the circle is descretized (Default = 120)
• shape: - Optional string/symbol with "triangle", "square", "pentagon" or "hexagon" (or just the first char) to compute one of those geometries instead of a circle. np is ignored in these cases.

Returns

• circ - A Mx2 matrix or GMTdataset with the circle coordinates

Example: Compute circle about the (0,0) point with a radius of 50 km

c = circgeo([0.,0], radius=50, unit=:k)

clip(cmd0::String="", arg1=nothing; kwargs...)

Reads (length,azimuth) pairs from file and plot a windclip diagram.

See full GMT (not the GMT.jl one) docs at psclip

Parameters

• C | endclip :: [Type => Bool]

  Mark end of existing clip path. No input file is needed.

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• A | steps :: [Type => Str or []]

  By default, geographic line segments are connected as great circle arcs. To connect them as straight lines, use A

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• Jz | zscale | zsize :: [Type => String]

• N | invert :: [Type => Bool]

  Invert the sense of the test, i.e., clip regions where there is data coverage.

• P | portrait :: [Type => Bool or []]

  Tell GMT to NOT draw in portrait mode (that is, make a Landscape plot)

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• T | clipregion :: [Type => Bool]

  Rather than read any input files, simply turn on clipping for the current map region.

• U | time_stamp | timestamp :: [Type => Str or Bool or []] $Arg = [[just]/dx/dy/][c|label]$

  Draw GMT time stamp logo on plot.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• X | x_offset | xshift :: [Type => Str] $Arg = [a|c|f|r][x-shift[u]]$

• Y | y_offset | yshift :: [Type => Str] $Arg = [a|c|f|r][y-shift[u]]$

  Shift plot origin relative to the current origin by (x-shift,y-shift) and optionally append the length unit (c, i, or p).

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• p | view | perspective :: [Type => Str or List] $Arg = [x|y|z]azim[/elev[/zlevel]][+wlon0/lat0[/z0]][+vx0/y0]$

  Selects perspective view and sets the azimuth and elevation of the viewpoint [180/90].

• t | alpha | transparency :: [Type => Str] $Arg = transp$

  Set PDF transparency level for an overlay, in (0-100] percent range. [Default is 0, i.e., opaque].

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

To see the full documentation type: $@? clip$

C = map2cpt(I::GMTimage) -> GMTcpt

Converts the I colormap, which is a plain vector, into a GMTcpt.

coast(cmd0::String=""; kwargs...)

Plot continents, shorelines, rivers, and borders on maps. Plots grayshaded, colored, or textured land-masses [or water-masses] on maps and [optionally] draws coastlines, rivers, and political boundaries. A map projection must be supplied.

See full GMT (not the GMT.jl one) docs at coast

Parameters

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• A | area :: [Type => Str or Number]

  Features with an area smaller than minarea in km^2 or of hierarchical level that is lower than minlevel or higher than max_level will not be plotted.

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• C | river_fill :: [Type => Str]

  Set the shade, color, or pattern for lakes and river-lakes.

• D | res | resolution :: [Type => Str] $Arg = c|l|i|h|f|a$

  Selects the resolution of the data set to use ((f)ull, (h)igh, (i)ntermediate, (l)ow, (c)rude), or (a)uto).

• E | DCW :: [Type => Str]

  Select painting or dumping country polygons from the Digital Chart of the World.

  • Tuple("code", Str); Tuple(code, number); Tuple("code" [,"fill"], (pen)); Tuple((...),(...),...)
  • ex: ("PT",(0.5,"red","–")); (("PT","gblue",(0.5,"red"),("ES",(0.5,"yellow")))

  • DCW=:PT; DCW=(:PT, 1); DCW=("PT", :red)

• getR | getregion | get_region :: [Type => Str]

  Return the region corresponding to the code/list-of-codes passed in as argument.

• F | box :: [Type => Str]

  Draws a rectangular border around the map scale or rose.

• G | land :: [Type => Str]

  Select filling or clipping of “dry” areas.

• I | rivers :: [Type => Str]

  Draw rivers. Specify the type of rivers and [optionally] append pen attributes.

• L | map_scale :: [Type => Str]

  Draw a map scale.

• M | dump :: [Type => Str]

  Dumps a single multisegment ASCII output. No plotting occurs.

• N | borders :: [Type => Str]

  Draw political boundaries. Specify the type of boundary and [optionally] append pen attributes

• P | portrait :: [Type => Bool or []]

  Tell GMT to NOT draw in portrait mode (that is, make a Landscape plot)

• clip :: [Type => Str] $Arg = land|water|end$

  To clip land do clip=:land, clip=:water clips water. Use end to mark end of existing clip path. No projection information is needed.

• S | water | ocean :: [Type => Str]

  Select filling or clipping of “wet” areas.

• Td | rose` :: [Type => Str]

  Draws a map directional rose on the map at the location defined by the reference and anchor points.

• Tm | compass :: [Type => Str]

  Draws a map magnetic rose on the map at the location defined by the reference and anchor points.

• U | time_stamp | timestamp :: [Type => Str or Bool or []] $Arg = [[just]/dx/dy/][c|label]$

  Draw GMT time stamp logo on plot.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | shore | shorelines | coast | coastlines :: [Type => Str] Draw shorelines [Default is no shorelines]. Append pen attributes.

• X | x_offset | xshift :: [Type => Str] $Arg = [a|c|f|r][x-shift[u]]$

• Y | y_offset | yshift :: [Type => Str] $Arg = [a|c|f|r][y-shift[u]]$

  Shift plot origin relative to the current origin by (x-shift,y-shift) and optionally append the length unit (c, i, or p).

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• p | view | perspective :: [Type => Str or List] $Arg = [x|y|z]azim[/elev[/zlevel]][+wlon0/lat0[/z0]][+vx0/y0]$

  Selects perspective view and sets the azimuth and elevation of the viewpoint [180/90].

• t | alpha | transparency :: [Type => Str] $Arg = transp$

  Set PDF transparency level for an overlay, in (0-100] percent range. [Default is 0, i.e., opaque].

• savefig | figname | name :: [Type => Str]

  Save the figure with the figname=name.ext where ext chooses the figure format (e.g. figname="name.png")

To see the full documentation type: $@? coast$

cl = coastlinesproj(proj="?", res="crude", coastlines=nothing)

Extract the coastlines from GMT's GSHHG database and project them using PROJ (NOT the GMT projection machinery). This allows the use of many of the PROJ projections that are not available from pure GMT.

• proj: A proj4 string describing the projection (Mandatory).
• res: The GSHHG coastline resolution. Available options are: crude, low, intermediate, high and full
• coastlines: In alternative to the res option, one may pass a GMTdataset with coastlines previously loaded (with gmtread) from another source.
• limits: If not empty it must be a 2 elements array with lonmin, lonmax that is used to ask for coastlines that expand more than 360 degrees (worldrectangular uses this).

Returns

A Vector of GMTdataset containing the projected (or not) world GSHHG coastlines at resolution res.

Example

cl = coastlinesproj(proj="+proj=ob_tran +o_proj=moll +o_lon_p=40 +o_lat_p=50 +lon_0=60");

colorbar(arg1=nothing; kwargs...)

Plots gray scales or color scales on maps.

See full GMT (not the GMT.jl one) docs at psscale

• D | pos | position :: [Type => Str]

  Defines the reference point on the map for the color scale using one of four coordinate systems.

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• C | color | colormap | cmap | colorscale :: [Type => Str] $Arg = [cpt |master[+izinc] |color1,color2[,*color3*,…]]$

  Give a CPT name or specify -Ccolor1,color2[,color3,...] to build a linear continuous CPT from those colors automatically.

• F | box :: [Type => Str]

  Draws a rectangular border around the scale.

• G | truncate :: [Type => Str]

  Truncate the incoming CPT so that the lowest and highest z-levels are to zlo and zhi.

• I | shade :: [Type => Number | Str]

  Add illumination effects.

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• Jz | zscale | zsize :: [Type => String]

• L | equal | equal_size :: [Type => Str | Bool] Arg = [i][gap]

  Gives equal-sized color rectangles. Default scales rectangles according to the z-range in the CPT.

• M | monochrome :: [Type => Bool]

  Force conversion to monochrome image using the (television) YIQ transformation.

• N | dpi :: [Type => Str | Number]

  Controls how the color scale is represented by the PostScript language.

• Q | log :: [Type => Str]

  Selects a logarithmic interpolation scheme [Default is linear].

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• S | appearance | nolines :: [Type => Bool | []]

  Do not separate different color intervals with black grid lines.

• U | time_stamp | timestamp :: [Type => Str or Bool or []] $Arg = [[just]/dx/dy/][c|label]$

  Draw GMT time stamp logo on plot.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | scale :: [Type => Number]

  Multiply all z-values in the CPT by the provided scale.

• Z | zfile :: [Type => Str]

  File with colorbar-width per color entry.

• savefig | figname | name :: [Type => Str]

  Save the figure with the figname=name.ext where ext chooses the figure format (e.g. figname="name.png")

To see the full documentation type: $@? colorbar$

colorzones!(shapes::Vector{GMTdataset}[, fun::Function]; img::GMTimage=nothing,
            url::AbstractString="", layer=0, pixelsize::Int=0, append::Bool=true)

Paint the polygons in the shapes with the average color that those polygons ocupy in the img image. When the shapes are plotted the resulting image looks like a choropleth map. Alternatively, instead of transmitting the img image one can provide a WMS URL, layer number and pixelsize to download images from the Web Map Server service, covering each one the bounding box of each of the shapes polygons. This option is much slower than passing the entire image at once but consumes much less memory. Important when the total area is large (think Russia size) because even at a moderately resultion it can imply downloading a huge file.

Parameters

• shapes: A vector of GMTdataset containing the polygons to be painted. This container will be changed in the sense that the header field of each polygon (a GMTdataset) will be appended with the fill color (but see also the append option that controls how this change takes place.)
• fun: By default the average color is obtained by taking the square root of the average of squares of each of the three (RGB) bands (or just one for grayscale images). Give the name of another function to replace this default. For example median will assign the color by computing the median of each component inside the polygon area in question.
• img: the image from which the stats (fun) of each color for each polygon will be computed.
• url: In case the img option is not used, pass the Web Map Server URL (see the wmsinfo and wmsread functions) from where the images covering the BoundingBox of each polygon will be downloaded. Warning, this is a much slower method but potentially useful when the images to download risk to be very big.
• layer: When the url option is used this one becomes mandatory and represents the layer number or layer name of interest from those provided by the WMS service. That is, both forms are allowed: layer=3 or layer="Invented layer name"
• pixelsize: Sets the requested cell size in meters [default]. Use a string appended with a 'd' (e.g. resolution="0.001d") if the resolution is given in degrees. This way works only when the layer is in geogs.
• append: By default, the color assignment to each of the polygons in the shapes vector is achieved by appending the fill color to the possibly existing header field. Running the colorzones command more than once keeps adding (now ignored, because only the first is used) colors. Setting append=false forces rewriting the header field at each run and hence the assigned color is always the one used (but the previous header is cleared out).

See also: rasterzones!

Returns

It does't return anything but the input shapes is modified.

Example

Read the 2020 Sentinel2 Earth color for Portugal at 100 m resolution. Load the administrative
regions and compute their median colors.

wms = wmsinfo("http://tiles.maps.eox.at/wms?");
img = wmsread(wms, layer=3, region=(-9.6,-6,36.9,42.2), pixelsize=100);
Pt = gmtread("C:/programs/compa_libs/covid19pt/extra/mapas/concelhos/concelhos.shp");
colorzones!(Pt, median, img=img);
imshow(Pt, proj=:guess)

compacttype(T::Type, maxwidth::Int=8, initial::Bool=true)

Return compact string representation of type T. For displaying data frame we do not want string representation of type to be longer than maxwidth. This function implements rules how type names are cropped if they are longer than maxwidth.

lat = conf2geod(latin, flat)

Convert conformal latitude latin to geodetic latitude using the flattening of the ellipsoid.

Arguments

• latin: Conformal latitude(s) in radians
• flat: Flattening of ellipsoid (use 0.0 for is spherical)

Returns

• lat: Geodetic latitude(s) in radians

l1, l2 = connect_rectangles(R1, R2) -> Tuple{Matrix{Float64}, Matrix{Float64}}

Find the lines that connect two rectangles and do not intersect any of them (for zoom windows).

• R1 and R2 are the [xmin, xmax, ymin, ymax] coordinates of the two rectangles:

Example:

R1 = [0.0, 3, 0, 2]; R2 = [5., 10, 5, 8];
l1, l2 = connect_rectangles(R1, R2)

contour(cmd0::String="", arg1=nothing; kwargs...)

Reads a table data and produces a raw contour plot by triangulation.

See full GMT (not the GMT.jl one) docs at contour

Parameters

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• A | annot | annotation :: [Type => Str | Number] $Arg = [-|[+]annot_int][labelinfo]$

  annot_int is annotation interval in data units; it is ignored if contour levels are given in a file.

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• C | cont | contour | contours | levels :: [Type => Str | Number | GMTcpt] $Arg = [+]cont_int$

  Contours to be drawn may be specified in one of three possible ways.

• D | dump :: [Type => Str]

  Dump contours as data line segments; no plotting takes place.

• E | index :: [Type => Str | Mx3 array]

  Give name of file with network information. Each record must contain triplets of node numbers for a triangle.

• G | labels :: [Type => Str]

  Controls the placement of labels along the quoted lines.

• I | fill | colorize :: [Type => Bool]

  Color the triangles using the color scale provided via C.

• Jz | zscale | zsize :: [Type => String]

• L | mesh :: [Type => Str | Number]

  Draw the underlying triangular mesh using the specified pen attributes (if not provided, use default pen)

• N | no_clip :: [Type => Bool]

  Do NOT clip contours or image at the boundaries [Default will clip to fit inside region].

• P | portrait :: [Type => Bool or []]

  Tell GMT to NOT draw in portrait mode (that is, make a Landscape plot)

• Q | cut :: [Type => Str | Number] $Arg = [cut[unit]][+z]]$

  Do not draw contours with less than cut number of points.

• S | skip :: [Type => Str | []] $Arg = [p|t]$

  Skip all input xyz points that fall outside the region.

• T | ticks :: [Type => Str] $Arg = [+|-][+a][+dgap[/length]][+l[labels]]$

  Draw tick marks pointing in the downward direction every gap along the innermost closed contours.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• U | time_stamp | timestamp :: [Type => Str or Bool or []] $Arg = [[just]/dx/dy/][c|label]$

  Draw GMT time stamp logo on plot.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | pen :: [Type => Str | Number]

  Sets the attributes for the particular line.

• X | x_offset | xshift :: [Type => Str] $Arg = [a|c|f|r][x-shift[u]]$

• Y | y_offset | yshift :: [Type => Str] $Arg = [a|c|f|r][y-shift[u]]$

  Shift plot origin relative to the current origin by (x-shift,y-shift) and optionally append the length unit (c, i, or p).

• Z | scale :: [Type => Str]

  Use to subtract shift from the data and multiply the results by factor before contouring starts.

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• do | nodata_out :: [Type => Str or Number] $Arg = nodata$

  Examine all output columns and if any item equals NAN substitute it with the chosen missing data value.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• p | view | perspective :: [Type => Str or List] $Arg = [x|y|z]azim[/elev[/zlevel]][+wlon0/lat0[/z0]][+vx0/y0]$

  Selects perspective view and sets the azimuth and elevation of the viewpoint [180/90].

• t | alpha | transparency :: [Type => Str] $Arg = transp$

  Set PDF transparency level for an overlay, in (0-100] percent range. [Default is 0, i.e., opaque].

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

• savefig | figname | name :: [Type => Str]

  Save the figure with the figname=name.ext where ext chooses the figure format (e.g. figname="name.png")

To see the full documentation type: $@? contour$

contourf(cmd0::String="", arg1=nothing; kwargs...)

Performs Delaunay triangulation on x,y[,z] data, i.e., it find how the points should be connected to give the most equilateral triangulation possible.

See full GMT (not the GMT.jl one) docs at triangulate

Parameters

• A | annot :: [Type => Str | Number] $Arg = [-|[+]annot_int][labelinfo]$

  annot_int is annotation interval in data units; it is ignored if contour levels are given in a file.

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• C | cont | contour | contours | levels :: [Type => Str | Number | GMTcpt] $Arg = [+]cont_int$

  Contours to be drawn may be specified in one of three possible ways.

• E | index :: [Type => Str | Mx3 array]

  Give name of file with network information. Each record must contain triplets of node numbers for a triangle.

• G | labels :: [Type => Str]

  Controls the placement of labels along the quoted lines.

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• P | portrait :: [Type => Bool or []]

  Tell GMT to NOT draw in portrait mode (that is, make a Landscape plot)

• Q | cut :: [Type => Str | Number] $Arg = [cut[unit]][+z]]$

  Do not draw contours with less than cut number of points.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• S | skip :: [Type => Str | []] $Arg = [p|t]$

  Skip all input xyz points that fall outside the region (Used when input data is a table).

• S | smooth :: [Type => Number]

  Used to resample the contour lines at roughly every (gridbox_size/smoothfactor) interval. (Used when input data is a grid)

• T | ticks :: [Type => Str] $Arg = [+|-][+a][+dgap[/length]][+l[labels]]$

  Draw tick marks pointing in the downward direction every gap along the innermost closed contours.

• U | time_stamp | timestamp :: [Type => Str or Bool or []] $Arg = [[just]/dx/dy/][c|label]$

  Draw GMT time stamp logo on plot.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | pen :: [Type => Str | Number]

  Sets the attributes for the particular line.

• Z | xyz | triplets :: [Type => Bool]

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• p | view | perspective :: [Type => Str or List] $Arg = [x|y|z]azim[/elev[/zlevel]][+wlon0/lat0[/z0]][+vx0/y0]$

  Selects perspective view and sets the azimuth and elevation of the viewpoint [180/90].

• t | alpha | transparency :: [Type => Str] $Arg = transp$

  Set PDF transparency level for an overlay, in (0-100] percent range. [Default is 0, i.e., opaque].

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

Examples

    G = GMT.peaks();
    C = makecpt(T=(-7,9,2));

    contourf(G, show=1)
    contourf(G, C=[-2, 0, 2, 5], show=1)
    contourf(G, C, contour=[-2, 0, 2, 5], show=1)
    contourf(G, C, annot=[-2, 0, 2, 5], show=1)
    contourf(G, C, annot=2, show=1)
    contourf(G, C, contour=1, annot=[-2, 0, 2, 5], show=1)
    contourf(G, C, annot=:none, show=1)

    d = [0 2 5; 1 4 5; 2 0.5 5; 3 3 9; 4 4.5 5; 4.2 1.2 5; 6 3 1; 8 1 5; 9 4.5 5];
    contourf(d, limits=(-0.5,9.5,0,5), pen=0.25, labels=(line=(:min,:max),), show=1)

cornerplot(data; kwargs...)

Takes a nSamples-by-nDimensions array, and makes density plots of every combination of the dimensions. Plots as a triangular matrix of subplots showing the correlation among input variables. Input data can be a MxN matrix, a GMTdataset or a file name that upon reading with gmtread returns a GMTdataset.

The plot consists of histograms of each column along the diagonal and scatter or hexagonal bining plots for the inter-variable relations, depending on if the the number of samples is <= 1000. But this can be changed with options in kwargs.

• cornerplot(data): plots every 2D projection of a multidimensional data set.
• cornerplot(..., varnames): prints the names of each dimension. varnames is a vector of strings of length nDimensions. If not provided, column names in the GMTdaset are used.
• cornerplot(..., truths): indicates reference values on the plots.
• cornerplot(..., quantile): list of fractional quantiles to show on the 1-D histograms as vertical dashed lines.
• cornerplot(..., hexbin=true): Force hexbin plots even when number of points <= 1000.
• cornerplot(..., scatter=true): Force scatter plots even when number of points > 1000.
• cornerplot(..., histcolor|histfill=color): To paint diagonal histograms witha selected color (histcolor=:none to no paint).

Several more options in kwargs can be used to control plot details (and are passed to the subplot, binstats and plot functions.)

Example: cornerplot(randn(2500,3), cmap=:viridis, show=1)

count_chars(str::AbstractString, c::Char[=','])

Count the number of characters c in the AbstracString str

d = countries_iso3to2()

Return a dictionary with ISO 3166-1 Alpha-3 country codes as keys and ISO 3166-1 Alpha-2 country codes as values.

Example

    d = countries_iso3to2();
	d["AFG"]
	"AF"

coupe(cmd0::String="", arg1=nothing; kwargs...)

Plot cross-sections of focal mechanisms.

See full GMT (not the GMT.jl one) docs at pscoupe. Essentially the same as meca plus A. Run gmthelp(coupe) to see the list of options.

C = cpt4dcw(codes::String, vals::Vector{<:Real}; kwargs...)

Create a categorical CPT to use with the output of coast(dcw=...) to make Choropleth maps.

• codes is a comma separated string with two chars country codes (ex: "PT,ES,FR,IT")
• vals a vector with same size as country codes, with the values used to colorize the countries

Optionally provide a CPT in the kwarg cmap=CPT with a range sufficient to transform the vals in colors. As an alternative to the above, provide a makecpt type range numeric vector to create a CPT. If none of these are provided a default CPT = makecpt(range=(0,255,1)) will be used.

crop(arg::GItype; kw...)

Crop a subregion of a grid (GMTgrid) or a image (GMTimage). The subregion is specified with the $limits$ or $region$ keyword; the specified range must not exceed the range of the input. This function differs from $grdcut$ in the sense that it doesn't call the GMT lib and works only on in-memory array (i.e., no disk files).

Returns

A grid or an image, depending on the input type, plus two 1x2 matrices with the indices of the cropped zone.

Example

G = GMT.peaks();
crop(G, region=(-2,2,-2,2))

FV = cube(r=1.0)

Creates a cube mesh with radius r.

cubeplot(img1::Union{GMTimage, String}, img2::Union{GMTimage, String}="", img3::Union{GMTimage, String}="";
         back::Bool=false, show=false, notop::Bool=false, xlabel="", ylabel="", zlabel="", title="", kw...)

Plot images on the sides of a cube. Those images can be provided as file names, or GMTimage objects.

• img1,2,3: File names or GMTimages of the images to be plotted on the three sides of a cube. Of those three, only img1 is mandatory, case in which it will be repeated on the three visible sides of the cube. If img1 and img2, the second image is plotted on the two vertical sides. When the three images are provided, the first goes to top (or bottom if back=true) the second to the xz and third to yz planes.
• back: Boolean that defaults to false, meaning that images are printed on the front sides of the cube. If false, the images are printed in the back sides. Use this option when wanting to plot on the walls of a 3D lines/scatter or grid views. The default is to print on the front facades.
• notop: If true, do not plot the top side (implies back=false)
• show: If true, finish and display the figure.

The kw... keyword/value options may be used to pass:

• coast: If true, plot a coastline basemap on the top or bottom side. Use $coast=(options..)$ to pass options to the coast module. This option can only be used with cubes of geographical coordinates.
• region, limits: The limits extents that will be used to annotate the x,y,z axes. It uses the same syntax as all other modules that accept this option (e.g. $coast$). It defaults to "0/9/0/9/-9/0"
• figsize: Select the horizontal size(s). Defaults to 15x15 cm.
• zsize: Sets the size of z axis in cm. The default is 15.
• view: The view point. Default is (135,30). WARNING: only azimute views from the 4rth quadrant are implemented.
• transparency: Sets the image's transparency level in the [0,1] or [0 100] intervals. Default is opaque.
• inset or hole: Draws an inset hole in the cube's Southern wall. This option is a tuple with the form: $((img1,img2[,img3]), width=?, [depth=?])$ where $(img1,img2[,img3])$ are the images of the north (that is, the plane whose normal is y) and west (that is, the plane whose normal is x) and, optionally, bottom sides of the inset. The width and depth are the width and depth of the inset. If depth is not provided it defaults to width. These values must be given in percentage of the cube's width and can be given in the [0-1] or [0-100] interval.
• xlabel, ylabel, zlabel, title: Optional axes labels and title. Each one of these must be a string.
• cmap, colormap, cpt, colorscale: Add a colorbar at the bottom of the figure. The colormap can be passed as a single argument or as a tuple of arguments, where first must be the colormap and second [and optional a third] are the axes colorbar labels taking the form: cmap=(C, "xlabel=Blabla1"[, "ylabel=Blabla2"]).

cubeplot(G::GMTgrid; top=nothing, topshade=false, zdown::Bool=false, xlabel="", ylabel="", zlabel="", title="",
         show=false, interp::Float64=0.0, kw...)

Make a 3D plot of a 3D GMTgrid (a cube) with a top view perspective from the 4rth quadrant (only one implemented). There are several options to control the painting of the cube walls but off course not all possibilities are covered. For ultimate control, users can create the side wall images separately and feed them to the cubeplot method that accepts only images as input.

• cmap, colormap, cpt, colorscale: Pass in a GMTcpt colormap to be used to paint the vertical walls and optionally, the top wall. The default is to compute this from the cube's min/max values with the turbo colormap.

• colorbar: Add a colorbar at the bottom of the figure. The plotted colormap is either the auto-generated colormap (from the cube's min/max and the turbo colormap) or the one passed via the cmap option. The optional syntax of this option is either: colorbar=true or colorbar=(C, "xlabel=Blabla1"[, "ylabel=Blabla2"]). Attention that when the labels request are passed, thy MUST conform with the xlabel=... and ylabel=... prefix part.

• inset: Add an inset to the figure. This inset takes the form of a hole located in the lower right corner of the cube in which its inner walls are painted with partial vertical slices of the cube. The inset option may be passed as a two elements array or tuple where first element is the starting longitude (end is cube's easternmost coordinate) and second the ending latitude (start is southernmost lat): an alternative syntax is to use inset=(lon=?, lat=?).

• interp: When the cube layers are not equi-distant, the vertical side walls are not regular gris. This option, that is called by default, takes care of obtaining a regular grid by linear interpolation along the columns. This automatic interpolation uses the smallest increment in the vertical direction, but that may be overridden by the interp increment option (a float value).

• region, limits: A 4 elements array or Tuple (x_min, x_max, y_min, y_max) with the limits of a sub-region to display. Default uses the entire cube.

• show: If true display the figure. Default is false, i.e. it lets append further elements latter if wished.

• top: An optional GMTgrid or the file name of a GMTgrid to be used to create the top wall of the cube. If, instead, a GMTimage is passed we plot it directly (grids are converted to images using default colormaps or one passed via topcmap). The default is to use the cube's first slice as the top wall.

• topshade: Only used when the top option was used to pass a GMTgrid (or the name of one). When true, the top wall image is created with the cube's first slice and a shaded effect computed with grdgradient on the top grid (normally a topography grid). This creates a nice effect that shows both the cube's first layer and the topography where it lies. Optionally, the topshade option may be used with a grdgradient grid computed with any other grid.

• topcmap: An alternative colormap for the top wall. Default is the same as the turbo computed with cube G itself.

• xlabel, ylabel, zlabel, title: Optional axes labels and title. Each one of these must be a string.

• zdown: When true, the z-axis is positive down. Default is false (positive up).

• zsize: Vertical size of the plotted cube. Default is 6 cm. Use a negative value if the z-axis is positive down, but see also the alternative zdown option.

Example:

C = xyzw2cube("USTClitho2.0.wrst.sea_level.txt");
cubeplot(C, top="@earth_relief", inset=(lon=110,y=40), topshade=true, zdown=true, title="Vp model",
         colorbar=("xlabel=P-wave velocity","ylabel=km/s"), show=true)

date2doy(date) -> Integer

Compute the Day-Of-Year (DOY) from date that can be a string or a Date/DateTime type. If ommited, returns today's DOY

delrows!(A::Matrix, rows::VecOrMat)

Delete the rows of Matrix A listed in the vector rows

D = density(x::Vector{<:Real}; nbins::Integer=200, bins::Vector{<:Real}=Vector{Real}(),
            bandwidth=nothing, kernel::StrSymb="normal")

• x: calculate the kernel density 'd' of a dataset X for query points 'xd' The density, by default, is estimated using a gaussian kernel with a width obtained with the Silverman's rule. x may be a vector, a matrix or Vector{Vector{Real}}.
• nbins: points are queried between MIN(Y[:]) and MAX(Y[:]) where Y is the data vector.
• bins: Calculates the density for the query points specified by BINS. The values are used as the query points directly. Default is 200 points.
• bandwidth: uses the 'bandwidth' to calculate the kernel density. It must be a scalar. For the uniform case the bandwidth is set to 15% of the range, otherwise the bandwidth is chosen with the Silverman's rule.
• printbw: Logical value indicating to print the computed value of the bandwidth.
• kernel: Uses the kernel function specified by KERNEL name (a string or a symbol) to calculate the density. The kernel may be: 'Normal' (default) or 'Uniform'
• extend: By default the density curve is computed at the bins locatins or between data extrema as mentioned above. However, this is not normally enough to go down to zero. Use this option in terms of number of bandwidth to expand de curve. e.g. extend=2

The version G = density(data, x,y; weights=nothing, bandwidth=nothing, showbw=false)

Computes the smoothed kernel probability density estimate of a two-column matrix data. The estimate is based on a normal kernel function, and is evaluated at the points defined by the vectors x and y. The showbw option is used to print the bandwidth used. It returns a GMTgrid of the same size as x and y.

Example

  X = [0.5*rand(20,1) 5 .+ 2.5*rand(20,1); .75 .+ 0.25*rand(10,1) 8.75 .+ 1.25*rand(10,1)]
  G = density(X, -0.25:.05:1.25, 0:.1:15)[1];
  viz(G, figsize=(12,12), view=(225,30))

D = df2ds(df)

Extract numeric data from a DataFrame type and return it into a GMTdataset. Works only with 'simple' DataFrames.

dilate_mask(mask, ngrow)

Takes a mask and dilates each false with ngrow falses on either side. This is equivalent to boolean "convolution".

height (nrows), width (ncols) = dims(GI::GItype)

Return the width and height of the grid/cube or image. The difference from size is that the when the memory layout is 'rows' the array is transposed and we get the wrong info. Here, we use the sizes of the 'x,y' coordinate vectors to determine the array's true shape.

FV = dodecahedron(r=1.0)

Creates an dodecahedron mesh with radius r.

doy2date(doy[, year]) -> Date

Compute the date from the Day-Of-Year doy. If year is ommited we take it to mean the current year. Both doy and year can be strings or integers.

ids, ind = dsget_segment_ids(D)::Tuple{Vector{String}, Vector{Int}}

Where D is a GMTdataset or a vector of them, returns the segment ids (first text after the '>') and the indices of those segments.

[GI = ] earthregions(name=""; proj="guess", country=false, dataset="", grid=false,
                     res="", registration="", round=0, exact=false)

earthregions plots or automatically extracts grid/image over a named geographic region. A large number of predefined regions is provided via collections, which are lists of names, their rectangular geographic boundaries and a code to access them. Users pick a region by its code(s) and choose between making a map of that region or download topo/bathymetric data (a grid or image) of that area.

Parameters

• name: It can be either the name of one collection or the code of one geographic region. If it is a collection name (one of: $"DCW", "NatEarth", "UN", "Mainlands", "IHO", "Wiki", "Lakes"$) the regions of that collection are printed, displaying the region's boundaries, code and name. If, instead, a code is passed (codes are unique) then depending on the values of grid or dataset we either produce a map of that region (the default) or extract grid/image over it.

• proj: In case a map is requested, pass the desired projection in form of a proj4 string or use the GMT projection syntax for that map. By default, we guess a good projection based on the map limits.

• country: The particular case of the $DCW$ collection let us also plot the country(ies) border lines. Set country=true to do that. Note that the $DCW$ regions can be specified by a comma separated list of country codes, e.g. earthregions("PT,ES", country=true).

• dataset: This option is used to select data download instead of map plotting. The available datasets are those explained in https://www.generic-mapping-tools.org/remote-datasets/, which shortly are: $"earth_relief", "earth_synbath", "earth_gebco", "earth_mask", "earth_day", "earth_night", "earth_geoid", "earth_faa", "earth_mask", "eart_dist", "earth_mss", "earth_vgg", "earth_wdmam", "earth_age", "mars_relief", "moon_relief", "mercury_relief", "venus_relief", "pluto_relief"$.

  Note that $"earth_day", "earth_night"$ are images that are not stored as tilles in the server, so the entire file is downloaded (only once and stored in your local ~.gmt/server directory). So, this may take a while for the first-time usage.

• grid: A shorthand boolean option equivalent to dataset="earth_relief"

• res: The dataset resolution. Possible resolutions are: $"01d", "30m", "20m", "15m", "10m", "06m", "05m", "04m", "03m", "02m", "01m", "30s", "15s", "03s", "01s"$. However, they are not all available to all datasets. For example, only $"earth_relief", "earth_synbath", "earth_gebco"$ exist for all those resolutions. In case a dataset is specified but no resolution, we make estimate of that resolution based on map extents and what would be good to create a map with 15 cm width.

• registration: The dataset registration. Either grid or pixel. If not provided we choose one.

• exact: The region boundaries in the collections were rounded to more friendly numbers (few decimals). This means that they differ slightly from the pure $GMT$ (coast) numbers. Setting exact=true will force using the strict $GMT$ limits.

• round=inc: Adjust the region boundaries by rounding to multiples of the steps indicated by inc, (xinc,yinc), or (winc,einc,sinc,ninc). Aditionally, round can be a string but in that case it must strictly follow the hard core GMT syntax explained at https://docs.generic-mapping-tools.org/dev/coast.html#r

See also: coast, mosaic

Returns

A $GMTgrid$ or a $GMTimage$ if dataset is used or $nothing$ otherwise.

Examples

   earthregions("IHO")                      # List the ocean regions as named by the IHO

   earthregions("PT,ES,FR", country=true)   # Make a map of Portugal, Spain and France regions.

   G = earthregions("IHO31", grid=true);    # Get a grid of the "Sea of Azov"

   viz(G, shade=true, coast=true)           # and make a nice map.

To see the plots produced by these examples type: $@? earthregions$

earthtide(cmd0::String=""; kwargs...)

Compute grids or time-series of solid Earth tides.

See full GMT (not the GMT.jl one) docs at earthtide

	G = earthtide();
	imshow(G)

ecdfplot(x::AbstractVector{<:Real}; kwargs...)

Plot the empirical cumulative distribution function (ECDF) of x. The kwargs may contain any option used in the plot module.

Example: ecdfplot(randn(100), show=true)

epsg2proj(code::Integer)

Convert a EPSG code into the PROJ4 form.

epsg2wkt(code::Integer, pretty::Bool=false)

Convert a EPSG code into the WKT form. Use pretty=true to return a more human readable text.

extrema_cols(A; col=1)

Compute the minimum and maximum of a column of a matrix/vector A ignoring NaNs

n = facenorm(M::Matrix{<:Real}; normalize=true)

Calculates the normal vector of a polygon with vertices in M.

• normalize: By default, it returns the unit vector. If false, it returns the non-normalized vector that represents the area of the polygon.

Returns

A 3 elements vector with the components of the normal vector.

feather(cmd0::String="", arg1=nothing; arrow=(...), kwargs...)

fill_between(D1 [,D2]; kwargs...)

Fill the area between two horizontal curves.

The curves are defined by the points (x, y1, y2) in matrix or GMTdataset D1. This creates one or multiple polygons describing the filled area. Alternatively, give a second matrix, D2 (or a scalar y=cte) and the polygons are constructed from the intersections of curves D1 and D2.

• fill_between(..., fill=colors): Give a list with two colors to paint the 'up' and 'down' polygons.
• fill_between(..., fillalpha=[alpha1,alpha2]): Sets the transparency of the two sets of polygons (default 60%).
• fill_between(..., pen=...): Sets pen specifications for the two curves. Easiest is to use the shortcuts lt, lc and ls for the line thickness, color and style like it is used in the plot() module.
• fill_between(..., stairs=true): Plot stairs curves instead.
• fill_between(..., markers=true): Add marker points at the data locations.
• fill_between(..., white=true): Draw a thin white border between the curves and the fills.
• fill_between(..., labels=...): Pass labels to use in a legend.
  • labels=true wil use the column names in D1 and D2.
  • labels="Lab1,Lab2" or labels=["Lab1","Lab2"] (this one can be a Tuple too) use the text in Lab1, Lab2.
• fill_between(..., legend=...): If used as the above labels it behaves like wise, but its argument can also be a named tuple with legend=(labels="Lab1,Lab2", position=poscode, box=(...)).

Example:

theta = linspace(-2π, 2π, 150);
y1 = sin.(theta) ./ theta;
y2 = sin.(2*theta) ./ theta;
fill_between([theta y1], [theta y2], white=true, legend="Sinc1,Sinc2", show=1)

filter1d(cmd0::String="", arg1=nothing, kwargs...)

Time domain filtering of 1-D data tables.

See full GMT (not the GMT.jl one) docs at filter1d

Parameters

• F | filter :: [Type => Str] Arg = type width[modifiers]

  Sets the filter type. Choose among convolution and non-convolution filters. Append the filter code followed by the full filter width in same units as time column.

• D | inc | increment :: [Type => Number] Arg = increment

  $increment$ is used when series is NOT equidistantly sampled. Then increment will be the abscissae resolution.

• E | end | ends :: [Type => Bool | []]

  Include Ends of time series in output. Default loses half the filter-width of data at each end.

• L | gap_width :: [Type => Number | Str] Arg = width

  Checks for Lack of data condition. If input data has a gap exceeding width then no output will be given at that point.

• N | time_col | timecol :: [Type => Int] Arg = t_col

  Indicates which column contains the independent variable (time). The left-most column is # 0, the right-most is # (n_cols - 1). [Default is 0].

• Q | quality :: [Type => Number] Arg = q_factor

  Assess Quality of output value by checking mean weight in convolution. Enter q_factor between 0 and 1.

• S | symmetry :: [Type => Number] Arg = symmetry_factor

  Checks symmetry of data about window center. Enter a factor between 0 and 1.

• T | range | inc :: [Type => List | Str] Arg = [min/max/]inc[+a|n]

  Make evenly spaced time-steps from min to max by inc [Default uses input times].

• cumdist | cumsum: [Type => Bool]

  Compute the cumulative distance along the input line. Note that for this the first two columns must contain the spatial coordinates.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• b | binary :: [Type => Str]

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

fit_line(x, y)

Simple linear regression, returns (intercept, slope). https://en.wikipedia.org/wiki/Simplelinearregression

fitcircle(cmd0::String="", arg1=nothing, kwargs...)

Find mean position and great [or small] circle fit to points on a sphere.

See full GMT (not the GMT.jl one) docs at fitcircle

Parameters

• L | norm :: [Type => Int | []]

  Specify the desired norm as 1 or 2, or use [] or 3 to see both solutions.

• F | coord | coordinates :: [Type => Str] Arg = f|m|n|s|c

  Only return data coordinates, and append Arg to specify which coordinates you would like.

• S | small_circle :: [Type => Number] Arg = symmetry_factor

  Attempt to

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

code = floating_window(fig_W, fig_H, float_W, float_H, lims_zoom) -> String

Given the size of the figure, the size of the inset and the zoom limits, compute the anchor location of the inset such that it doesn't overlap with the zoom window. All inputs are in paper units.

It works like this: The figure window is divided in a 3x3 cells matrix. We compute in which cell falls the center of the zoom window. Next, we try to place the inset either above or below the zoom window. The rational for this is that if those positions are good it si almost sure that the inset will not overlap the data being displayed. If it doesn't fit, we try the next position to the right along the top or bottom rows of the 3x3 matrix. In each test, we always check if zoom and inset windows overlap.

• fig_W and fig_H are the size of the figure in paper units:
• float_W and float_H are the size of the inset in paper units:
• lims_zoom: is a vector of 4 numbers: [xmin xmax ymin ymax] in paper units with limits of the zoom window.

gadm(country, subregions...; children=false, names=false, children_raw=false, reportlevels=false)

Returns a GMTdataset for the requested country, or country subregion(s)

• country: ISO 3166 Alpha 3 country code .
• subregions: Full official names in hierarchial order (provinces, districts, etc...). To know the names of all administrative children of parent, use the option names.
• children: When true, function returns all subregions of parent.
• children_raw: When true, function returns two variables -> parent, children, where children is a GDAL object E.g. when children is set to true and when querying just the country, second return parameter are the states/provinces. If children we return a Vector of GMTdataset with the polygons. If children_raw the second output is a GDAL object much like in GADM.jl (less the Tables.jl)
• names: Return a string vector with all children names.
• reportlevels: just report the number of administrative levels (including the country) and exit.

Examples

# data of India's borders
data = gadm("IND")

# uttar -> the limits of the Uttar Pradesh state
uttar = gadm("IND", "Uttar Pradesh")

# uttar -> limits of all districts of the  Uttar Pradesh state
uttar = gadm("IND", "Uttar Pradesh", children=true)

# Names of all states of India
gadm("IND", names=true)

gammacorrection(I::GMTimage, gamma; contrast=[0.0, 1.0], brightness=[0.0, 1.0])

Apply a gamma correction to a 2D (intensity) GMTimage using the exponent gamma. Optionally set also contrast and/or brightness

Returns

A GMT intensity Image

O = gd2gmt(dataset; band=0, bands=[], sds=0, pad=0)

Convert a GDAL raster dataset into either a GMTgrid (if type is Int16 or Float) or a GMTimage type Use band to select a single band of the dataset. When you know that the dataset contains several bands of an image, use the kwarg bands with a vector the wished bands. By default it reads all bands of the image or grid object.

When DATASET is a string it may contain the file name or the name of a subdataset. In former case you can use the kwarg sds to selec the subdataset numerically. Alternatively, provide the full sds name. For files with sds with a scale_factor (e.g. MODIS data), that scale is applyied automaticaly.

Examples:

G = gd2gmt("AQUA_MODIS.20210228.L3m.DAY.NSST.sst.4km.NRT.nc", sds=1);

or

G = gd2gmt("SUBDATASET1NAME=NETCDF:AQUA_MODIS.20210228.L3m.DAY.NSST.sst.4km.NRT.nc:sst");

or

G = gd2gmt("NETCDF:AQUA_MODIS.20210228.L3m.DAY.NSST.sst.4km.NRT.nc:sst");

gdaldrivers(type="raster"; out::Bool=false)

List all the GDAL drivers available in this GMT.jl installation. By default it prints the names of the raster drivers, but if type="vector" it will print the names of the vector drivers. If out=true, instead of printing a table it will return the four columns of the table in separate 4 vectors.

gdalread(fname::AbstractString, opts=String[]; gdataset=false, kwargs...)

Read a raster or a vector file from a disk file and return the result either as a GMT type (the default) or a GDAL dataset.

• fname: Input data. It can be a file name, a GMTgrid or GMTimage object or a GDAL dataset
• opts: List of options. The accepted options are the ones of the gdal_translate utility. This list can be in the form of a vector of strings, or joined in a simgle string.
• gdataset: If set to true forces the return of a GDAL dataset instead of a GMT type.
• kwargs: This options accept the GMT region (-R) and increment (-I)

Returns

A GMT grid/image or a GDAL dataset

gdalshade(filename; kwargs...)

Create a shaded relief with the GDAL method (color image blended with shaded intensity).

• kwargs hold the keyword=value to pass the arguments to gdaldem hillshade

Example: I = gdalshade("hawaii_south.grd", C="faa.cpt", zfactor=4);

Returns

A GMT RGB Image

gdalwrite(fname::AbstractString, data, opts=String[]; kwargs...)

Write a raster or a vector file to disk

• fname: Output file name. If not explicitly selected via opts the used driver will be picked from the file extension.
• data: The data to be saved in file. It can be a GMT type or a GDAL dataset.
• opts: List of options. The accepted options are the ones of the gdal_translate or ogr2ogr utility. This list can be in the form of a vector of strings, or joined in a simgle string.
• kwargs: This options accept the GMT region (-R) and increment (-I)

or

gdalwrite(cube::GItype, fname::AbstractString, v=nothing; dim_name::String="time", dim_units::String="")

Write a MxNxP cube object to disk as a multilayered file.

• cube: A GMTgrid or GMTimage cube
• fname: The file name where to save the cube
• v: A vector with the coordinates of the Z layers (if omitted create one as 1:size(cube,3))
• dim_name: The name of the variable of the $vertical$ dimension.
• dim_units: The units of the v vector. If not provided, use the cube.z_units if exist (GMTgrid only)

D = geocoder(address::String; options=String[]) => GMTdataset

Get the geocoder info for a given address by calling the GDAL/OGR geocoding functions. See https://gdal.org/doxygen/ogr__geocoding_8h.html

Arguments

• address: The string to geocode.
• options: These are the options passed to GDAL and in the form of a vector of strings. For example, the default is equivalent to options=["SERVICE", "OSM_NOMINATIM"].
  • "CACHE_FILE" : Defaults to "ogr_geocode_cache.sqlite" (or otherwise "ogr_geocode_cache.csv" if the SQLite driver isn't available). Might be any CSV, SQLite or PostgreSQL datasource.
  • "READ_CACHE" : "TRUE" (default) or "FALSE"
  • "WRITE_CACHE" : "TRUE" (default) or "FALSE"
  • "SERVICE": "OSM_NOMINATIM" (default), "MAPQUEST_NOMINATIM", "YAHOO", "GEONAMES", "BING" or other value. Note: "YAHOO" is no longer available as a free service.
  • "EMAIL": used by OSM_NOMINATIM. Optional, but recommended.
  • "USERNAME": used by GEONAMES. Compulsory in that case.
  • "KEY": used by BING. Compulsory in that case.
  • "APPLICATION": used to set the User-Agent MIME header. Defaults to GDAL/OGR version string.
  • "LANGUAGE": used to set the Accept-Language MIME header. Preferred language order for showing search results.
  • "DELAY": minimum delay, in second, between 2 consecutive queries. Defaults to 1.0.
  • "QUERY_TEMPLATE": URL template for GET requests. Must contain one and only one occurrence of %s in it. If not specified, for SERVICE=OSM_NOMINATIM, MAPQUEST_NOMINATIM, YAHOO, GEONAMES or BING, the URL template is hard-coded.
  • "REVERSE_QUERY_TEMPLATE": URL template for GET requests for reverse geocoding. Must contain one and only one occurrence of {lon} and {lat} in it. If not specified, for SERVICE=OSM_NOMINATIM, MAPQUEST_NOMINATIM, YAHOO, GEONAMES or BING, the URL template is hard-coded.

Returns

A GMTdataset with the longitude, latitude, and full attribute dictionary returned by the geocoder for the input address. This dataset contains only one point but geocoding service resturns also a BoundingBox containing that point. When the address is very specific that BB is tiny arround the point, but when the query is general (for example,just the name of a city or even a country), the BB is large and may be very useful to use in the mosaic program. For that purpose, the returned BB is sored in the GMTdatset $ds_bbox$ field.

Example

geocoder("Paris, France")

dest, azim = geod(lonlat, azim, distance; proj::String="", s_srs::String="", epsg::Integer=0, dataset=false, unit=:m)

Solve the direct geodesic problem.

Args:

• lonlat: - longitude, latitude (degrees). This can be a vector or a matrix with one row only.
• azimuth: - azimuth (degrees) ∈ [-540, 540)
• distance: - distance to move from (lat,lon); can be vector and can be negative, Default is meters but see unit
• proj or s_srs: - the given projection whose ellipsoid we move along. Can be a proj4 string or an WKT
• epsg: - Alternative way of specifying the projection [Default is WGS84]
• dataset: - If true returns a GMTdataset instead of matrix
• unit: - If distance is not in meters use one of unit=:km, or unit=:Nautical or unit=:Miles

The distance argument can be a scalar, a Vector, a Vector{Vector} or an AbstractRange. The azimuth can be a scalar or a Vector.

When azimuth is a Vector we always return a GMTdataset with the multiple lines. Use this together with a non-scalar distance to get lines with multiple points along the line. The number of points along line does not need to be the same. For data, give the distance as a Vector{Vector} where each element of distance is a vector with the distances of the points along a line. In this case the number of distance elements must be equal to the number of azimuth.

Returns

• dest - destination after moving for [distance] metres in [azimuth] direction.
• azi - forward azimuth (degrees) at destination [dest].

Example: Compute two lines starting at (0,0) with lengths 111100 & 50000, heading at 15 and 45 degrees.

dest, = geod([0., 0], [15., 45], [[0, 10000, 50000, 111100.], [0., 50000]])[1]

latconf = geod2cnf(latin, flat)

Convert geodetic latitudes latin to conformal latitudes using the flattening flat of the ellipsoid.

Arguments

• latin: Geodetic latitude(s) in radians
• flat: Flattening of the ellipsoid (Use 0.0 for is spherical)

Returns

• Conformal latitude(s) in radians.

lat = geod2isometric(latin, flat)

Convert geodetic latitudes to isometric latitudes.

Arguments

• latin: Geodetic latitude(s) in degrees
• flat: Flattening of the ellipsoid (Use 0.0 for is spherical)

Returns

• Isometric latitude in degrees

function geodesic(D; step=0, unit=:m, np=0, proj::String="", epsg::Integer=0, longest::Bool=false)

or

function geodesic(lon1, lat1, lon2, lat2; step=0, unit=:m, np=0, proj::String="", epsg::Integer=0, longest::Bool=false)

Generate geodesic line(s) (shortest distace) on an ellipsoid. Input data can be two or more points. In later case each line segment is descretized at step increments,

Parameters

• D: - the input points. This can either be a GMTdataset (or vector of it), a Mx2 matrix, the name of file that can be read as a GMTdataset by gmtread() or a GDAL AbstractDataset object
• step: - Incremental distance at which the segment line is descretized in meters(the default), but see unit
• unit: - If step is not in meters use one of unit=:km, or unit=:Nautical or unit=:Miles
• np: - Number of intermediate points between poly-line vertices (alternative to step)
• proj - If line data is in Cartesians but with a known projection pass in a PROJ4 string
• epsg - Same as proj but using an EPSG code
• longest - Compute the 'long way around' of the geodesic. That is, going from point A to B taking the longest path. But mind you that geodesics other than meridians and equator are not closed paths (see https://en.wikipedia.org/wiki/Geodesicsonanellipsoid). This line is obtained by computing the azimuth from A to B, at B, and start the line at B with that azimuth and go around the Earth till we reach, _close to A, but not exactly A (except for the simple meridian cases).

Returns

A Mx2 matrix with the lon lat of the points along the geodesic when input is a matrix. A GMT dataset or a vector of it (when input is Vector{GMTdataset}).

Example: Compute an geodesic between points (0,0) and (30,50) discretized at 100 km steps.

mat = geodesic([0 0; 30 50], step=100, unit=:k);

xEast, yNorth, zUp = geodetic2enu(lon, lat, h, lon0, lat0, h0)

Convert from geodetic coordinates to local East, North, Up (ENU) coordinates.

x, y = geog2merc(lon, lat, pt_radius)

Convert from mercator to geographic coordinates in degrees. For a sphere, lat should be the geocentric latitude(s), but for an ellipsoid lat should contain the isometric latitude(s).

Returns

• x,y Mercator coordinates in meters.

FV = geosphere(n, r=1; radius=1.0)

Generate a geodesic sphere triangulation based on the number of refinement iterations n and the radius r. Geodesic spheres (aka Buckminster-Fuller spheres) are triangulations of a sphere that have near uniform edge lenghts. The algorithm starts with a regular icosahedron. Next this icosahedron is refined n times, while nodes are pushed to a sphere surface with radius r at each iteration.

• radius: the keyword radius is an alternative to the positional argument r.
• n: is the number of times of iterations used to obtain the sphere from the icosahedron.

Returns

A two elements vector of GMTdataset where first contains the vertices and the second the indices that define the faces.

desc = get_cube_layers_desc(fname::String, layers::Vector{Int}=Int[]) -> Vector{String}

• fname: The name of a disk file of a cube.

• layers: Only used when called from $find_layers()$ in $RemoteS$

WESN = get_geoglimits(GI::GItype)::Vector{Float64}

Get the geographical limits of grids or images and return them in a [West, East, South, North] vector. If grid/image is not referenced, returns an empty vector.

val get_pocket_call() -> Any

Pop the contents of the first non-empty slot in the pocket_call vector stack

bb = getbb(D::GDtype) -> Vector{Float64}

Get the bounding box of a dataset (or vector of them). Note: the returned data is based on information in Dmetadata, not in rescanning the actual data.

getbyattrib(D::Vector{<:GMTdataset}[, index::Bool=false]; kw...)

or

filter(D::Vector{<:GMTdataset}; kw...)

or

findall(D::Vector{<:GMTdataset}; kw...)

Take a GMTdataset vector and return only its elements that match the condition(s) set by the kw keywords. Note, this assumes that D has its attrib fields set with usable information.

NOTE: Instead of $getbyattrib$ one case use instead $filter$ (...,index=false) or $findall$ (..., index=true)

Parameters

• attrib name(s)=value(s): Easier to explain by examples: NAME="Antioquia", select all elements that have that attribute/value combination. NAME=("Antioquia", "Caldas"), pick elements that have thoseNAMEattributes. Add as many as wished. If using twokwargsthe second works as a condition.(..., NAME=("Antioquia", "Caldas"), feature_id=0)means select all elements fromAntioquiaandCaldasthat have the attributefeature_id` = 0.
• invert, or reverse, or not: If true return all segments that do NOT match the query condition(s).
• attrib or att: (OLD SYNTAX) A NamedTuple with the attribname, attribvalue as in att=(NAME_2="value",). Use more elements if wishing to do a composite match. E.g. att=(NAME_1="val1", NAME_2="val2") in which case only segments matching the two conditions are returned.
• index: Use this positional argument = true to return only the segment indices that match the att condition(s).

Returns

Either a vector of GMTdataset, or a vector of Int with the indices of the segments that match the query condition. Or nothing if the query results in an empty GMTdataset

Example:

D = filter(D, NAME_2="Porto");

Return the decimal part of a float number x

getprovider(name, zoom::Int; variant="", date::String="", key::String="")

Get information about a tile provider given its name and zoom level. The returned information is only relevant for internal use and is an implementation detail not documented here.

Arguments

• name: Name of the tile provider. Currently available are "Bing" (the default), "Google", "OSM", "Esri", "Nimbo". Optionally, the name can be a tuple of two strings, where the first string is the provider name and the second string is the variant name (see the variant bellow).

• The name argument can also be a Provider type from the TileProviders.jl package. For example, after importing TileProviders.jl, $provider = NASAGIBSTimeseries()$ and next pass it to getprovider.

• date: Currently only used with the 'Nimbo' provider. Pass date in 'YYYY_MM' or 'YYYY,MM' format.

• key: Currently only used with the 'Nimbo' provider. Pass your https://nimbo.earth/ API key.

• zoom: Requested zoom level. Will be capped at the provider's maximum.

• variant: Optional variant for providers with multiple map layers.

  • Bing: variants => "Aerial" (default), "Road", or "Hybrid".
  • Google: variants => "Satellite", "Road", "Terrain", or "Hybrid".
  • Esri: variants => "World_Street_Map" (default), "Elevation/World_Hillshade", or "World_Imagery".
  • Nimbo: variants => "RGB" (default), "NIR", "NDVI", or "RADAR".

x_min, x_max, y_min, y_max, x_inc_or_z_min, y_inc_or_z_max = getregion(dataset; gridreg=false, sds=0, GMT=false)

Inquire the region extents of a file or GMTgrid, GMTimage, GMTdataset or GDAL dataset.

Options gridreg and sds are only for GDAL datasets. When input is a string (a file name) the default is to use GDAL and the region comes in 'pixel registration' by default. Use gridreg=true to force 'grid registration'. Still for input as string, use GMT=true to force the result to be given by grdinfo. An unfortunate consequence of using either GMT or GDAL to inquire a file/object is that the 5th and 6th outputs (only 4 when input is a GMTdataset) have different contents. It will be either x_inc, y_inc when reading with GDAL, and z_min, z_max when reading with GMT.

width, height = getsize(GI::GItype) -> Tuple(Int, Int)

Return the width and height of the grid or image. The grid case is simple but images are more complicated due to the memory layout. To disambiguate this, we are not relying in 'size(GI)' but on the length of the x,y coordinates vectors, that are assumed to always be correct.

Call a GMT module. This function is not called directly by the users, except when using the $monolithic$ mode. Usage:

gmt("module_name `options`", args...)

ds = gmt2gd(GI)

Create GDAL dataset from the contents of GI that can be either a Grid or an Image

ds = gmt2gd(D, save="", geometry="")

Create GDAL dataset from the contents of D, which can be a GMTdataset, a vector of GMTdataset ir a MxN array. The save keyword instructs GDAL to save the contents as an OGR file. Format is determined by file estension. geometry can be a string with "polygon", where file will be converted to polygon/multipolygon depending on D is a single or a multi-segment object, or "point" to convert to a multipoint geometry.

gmt2kml(cmd0::String="", arg1=nothing, kwargs...)

Convert GMT data tables to KML files for Google Earth

See full GMT (not the `GMT.jl` one) docs at [`gmt2kml`](http://docs.generic-mapping-tools.org/latest/gmt2kml.html)

Parameters

• A | altitude_mode :: [Type => Str] $Arg = a|g|s[alt|xscale]$

  Select one of three altitude modes recognized by Google Earth that determines the altitude (in m) of the feature: $a$ absolute altitude, $g$ altitude relative to sea surface or ground, $s$ altitude relative to seafloor or ground.

• C | color | colormap | cmap | colorscale :: [Type => Str] $Arg = [cpt |master[+izinc] |color1,color2[,*color3*,…]]$

  Give a CPT name or specify -Ccolor1,color2[,color3,...] to build a linear continuous CPT from those colors automatically.

• D | descript :: [Type => Str] $Arg = descriptfile$

  File with HTML snippets that will be included as part of the main description content for the KML file.

• E | extrude :: [Type => Str | []] $Arg = [altitude]$

  Extrude feature down to ground level.

• F | feature_type :: [Type => Str] $Arg = e|s|t|l|p|w$

  Sets the feature type. Choose from points (event, symbol, or timespan), line, polygon, or wiggle.

• G | fill :: [Type => Str] $Arg = f|nfill$

  Sets color fill (G=:f) or label font color (G=:n).

• I | icon :: [Type => Str] $Arg = icon$

  Specify the URL to an alternative icon that should be used for the symbol [Default is a Google Earth circle].

• K | not_over :: [Type => Bool]

  Allow more KML code to be appended to the output later [finalize the KML file].

• L | extra_data :: [Type => Str] $Arg = name1,name2,…$

  Extended data given. Append one or more column names separated by commas.

• N | feature_name :: [Type => Str | Number] $Arg = [t|col |name_template|name]$

  By default, if segment headers contain a -L”label string” then we use that for the name of the KML feature.

• O | overlay :: [Type => Bool]

  Append KML code to an existing KML file [initialize a new KML file].

• Qa | wiggles :: [Type => Str] $Arg = azimuth$

  Option in support of wiggle plots (requires F=:w).

• Qs | wiggle_scale :: [Type => Str | Number] $Arg = scale[unit]$

  Required setting for wiggle plots (i.e., it requires F=:w). Sets a wiggle scale in z-data units per the user’s units

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• S | ilscale :: [Type => Str] $Arg = c|nscale$

  Scale icons or labels. Here, S=:c sets a scale for the symbol icon, whereas S=:n sets a scale for the name labels

• T | title :: [Type => Str] $Arg = title[/foldername]$

  Sets the document title [default is unset]. Optionally, append /FolderName;

• W | pen :: [Type => Str | []] $Arg = [pen][attr]$

  Set pen attributes for lines, wiggles or polygon outlines.

• Z | attrib :: [Type => Str] $Arg = args$

  Set one or more attributes of the Document and Region tags.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

To see the full documentation type: $@? gmt2kiml$

gmtbegin(name::String=""; fmt)

Start a GMT session in modern mode (GMT >= 6). 'name' contains the figure name with or without extension. If an extension is used (e.g. "map.pdf") it is used to select the image format.

As an alternative use 'fmt' as a string or symbol containing the format (ps, pdf, png, PNG, tif, jpg, eps).

By default name="GMTplot" and fmt="ps"

gmtconnect(cmd0::String="", arg1=nothing, kwargs...)

Connect individual lines whose end points match within tolerance

See full GMT (not the GMT.jl one) docs at gmtconnect

Parameters

• C | closed :: [Type => Str | []] Arg = [closed]

  Write all the closed polygons to closed [gmtgmtconnect_closed.txt] and return all other segments as they are. No gmtconnection takes place.

• D | dump :: [Type => Str | []] Arg = [template]

  For multiple segment data, dump each segment to a separate output file

• L | links | linkfile :: [Type => Str | []] Arg = [linkfile]

  Writes the link information to the specified file [gmtgmtconnect_link.txt].

• Q | list | listfile :: [Type => Str | []] Arg = [listfile]

  Used with D to write a list file with the names of the individual output files.

• T | tolerance :: [Type => Str | List] Arg = [cutoff[unit][/nn_dist]]

  Specifies the separation tolerance in the data coordinate units [0]; append distance unit. If two lines has end-points that are closer than this cutoff they will be joined.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• b | binary :: [Type => Str]

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

gmtconvert(cmd0::String="", arg1=nothing, kwargs...)

Convert, Paste, and/or Extract columns from data tables

See full GMT (not the GMT.jl one) docs at gmtconvert

Parameters

• A | hcat :: [Type => Str | []]

  The records from the input files should be pasted horizontally, not appended vertically [Default].

• C | n_records :: [Type => Str] $Arg = [+lmin][+umax][+i]$

  Only output segments whose number of records matches your given criteria:

• D | dump :: [Type => Str | []] $Arg = [template[+oorig]]$

  For multiple segment data, dump each segment to a separate output file.

• E | first_last :: [Type => Str | []] $Arg = [f|l|m|Mstride]$

  Only extract the first and last record for each segment of interest.

• F | conn_method :: [Type => Str | []] $Arg = [c|n|r|v][refpoint]$

  Alter the way points are connected (by specifying a scheme) and data are grouped (by specifying a method).

• I | invert | reverse :: [Type => Str | Bool] $Arg = [tsr]$

  Invert the order of items, i.e., output the items in reverse order, starting with the last and ending up with the first item.

• L | list_only :: -[Type => Bool]

  Only output a listing of all segment header records and no data records.

• N | sort :: [Type => Str | Number] $Arg = [-|+]col$

  Numerically sort each segment based on values in column col.

• Q | segments :: [Type => Str] $Arg = [~]selection$

  Only write segments whose number is included in $selection$ and skip all others.

• S | select_hdr :: [Type => Str] $Arg = [~]”search string” or [~]/regexp/[i]$

  Only output those segments whose header record contains the specified text string.

• T | suppress | skip :: [Type => Str | []] $Arg = [h|d]$

  Suppress the writing of certain records on output. Append h to suppress segment headers [Default] or d to suppress duplicate data records. Use T=:hd to suppress both types of records.

• W | word2num :: [Type => Str | []] $Arg = [+n]$

  Attempt to gmtconvert each word in the trialing text to a number and append such values to the numerical output columns.

• Z | transpose :: [Type => Str | []] $Arg = [first][:last]$

  Limit output to the specified record range. If first is not set it defaults to record 0 (very first record) and if last is not set then it defaults to the very last record.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• b | binary :: [Type => Str]

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• q | inrow | inrows :: [Type => Str] $Arg = [i|o][~]rows[+ccol][+a|f|s]$

  Select specific data rows to be read (-qi [Default]) or written (-qo) [all].

• s | skiprows | skip_NaN :: [Type => Str] $Arg = [cols][a|r]$

  Suppress output for records whose z-value equals NaN.

• w | wrap | cyclic :: [Type => Str or Number] $Arg = [[-]n]$

  Convert input records to a cyclical coordinate.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

gmtend(show=false, verbose=nothing)

Ends a GMT session in modern mode and optionaly shows the figure

gmtfig(name::String; fmt=nothing, opts="")

Set attributes for the current modern mode session figure.

• 'name' name of the new (or resumed) figure. It may contain an extension.
• 'fmt' figures graphics format (or formats, e.g. fmt="eps,pdf"). Not needed if 'name' has extension
• 'opts' Sets one or more comma-separated options (and possibly arguments) that can be passed to psconvert when preparing this figure.

gmtgravmag3d(cmd0::String=""; kwargs...)

Compute the gravity/magnetic anomaly of a 3-D body by the method of Okabe.

See full GMT (not the GMT.jl one) docs at gmtgravmag3d

Parameters

• C | density :: [Type => Str | GMTgrid]

  Sets body density in SI. Provide either a constant density or a grid with a variable one.

• F | track :: [Type => Str | Matrix | GMTdataset]

  Provide locations where the anomaly will be computed. Note this option is mutually exclusive with outgrid.

• G | save | outgrid | outfile :: [Type => Str]

  Output grid file name. Note that this is optional and to be used only when saving the result directly on disk. Otherwise, just use the G = gmtgravmag3d(....) form.

• H | mag_params :: [Type => Number]

  Sets parameters for computation of magnetic anomaly. Alternatively, provide a magnetic intensity grid.

• I | inc | increment | spacing :: [Type => Str] $Arg = xinc[unit][+e|n][/yinc[unit][+e|n]]]$

  x_inc [and optionally y_inc] is the grid spacing. Optionally, append an increment unit.

• L | z_obs | observation_level :: [Type => Number]

  Sets level of observation [Default = 0]. That is the height (z) at which anomalies are computed.

• M | body :: [Type => Str | Tuple]

  Create geometric bodies and compute their grav/mag effect.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• S | radius :: [Type => Number]

  Set search radius in km (valid only in the two grids mode OR when thickness) [Default = 30 km].

• Tv | index :: [Type => Str]

• Tr | raw_triang :: [Type => Str]

• Ts | stl :: [Type => Str]

  Gives names of a xyz and vertex (ndex="vert_file") files defining a close surface.

• Z | z_level | reference_level :: [Type => Number]

  Level of reference plane [Default = 0].

Example

	G = gmtgravmag3d(M=(shape=:prism, params=(1,1,1,5)), inc=1.0, region="-15/15/-15/15", mag_params="10/60/10/-10/40");
	imshow(G)

gmtinfo(cmd0::String="", arg1=nothing; kwargs...)

Reads files and finds the extreme values in each of the columns.

See full GMT (not the GMT.jl one) docs at gmtinfo

Parameters

• A | ranges :: [Type => Str]

  Specify how the range should be reported.

• C | numeric | per_column :: [Type => Bool]

  Report the min/max values per column in separate columns [Default uses <min/max> format].

• D | center :: [Type => Bool]

  Modifies results obtained by -I by shifting the region to better align with the center of the data.

• E | get_record :: [Type => Str | []]

  Returns the record whose column col contains the minimum (l) or maximum (h) value.

• F | counts :: [Type => Str | []]

  Returns the counts of various records depending on the appended mode.

• I | inc | increment | spacing :: [Type => Str | Number | Tuple]

  Report the min/max of the first n columns to the nearest multiple of the provided increments and output results in the form -Rw/e/s/n

• L | common_limits :: [Type => Bool]

  Determines common limits across tables or segments.

• S | forerrorbars :: [Type => Str | []]

  Add extra space for error bars. Useful together with I option and when later plotting with plot E.

• T | nearest_multiple :: [Type => Str | Number] $Arg = dz[+ccol]$

  Report the min/max of the first (0’th) column to the nearest multiple of dz and output this as the string -Tzmin/zmax/dz.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• r | reg | registration :: [Type => Bool or []]

  Force pixel node registration [Default is gridline registration].

• w | wrap | cyclic :: [Type => Str or Number] $Arg = [[-]n]$

  Convert input records to a cyclical coordinate.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

gmtisf(cmd0::String; kwargs...)

Read seismicity data in the a ISF formated file.

Parameters

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• D | date :: date="datestart[/dateend]"

  Limit the output to data >= datestart, or between datestart and dateend. <date> must be in ISO format, e.g, 2000-04-25.

• F | focal :: [Type => Bool or Str or Symbol]

  Select only events that have focal mechanisms. The default is Global CMT convention. Use focal=:a for the AKI convention

• N | notime :: [Type => Bool]

  Do NOT output time information.

• abstime or unixtime :: [Type => Integer]

  Convert the YYYY, MM, DD, HH, MM columns into a unixtime. Default puts it as first column, use abstime=2 to put it as last column.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

This module can also be called via gmtread. I.,e. `gmtread("file.isf", opts...)_

gmtmath(cmd::String, args...)

Call gmtmath with all commands in a single string 'cmd'. This is not useful in itself as compared to call gmt("gmtmath ....") but it's very useful in 'movie' because it can generate shell scripts from the julai command

See full GMT (not the GMT.jl one) docs at grdmath

gmtread(fname::String; kwargs...)

Read GMT object from file. The object is one of "grid" or "grd", "image" or "img", "data" or "table", "cmap" or "cpt" and "ps" (for postscript), and OGR formats (shp, kml, json). Use a type specificatin to force a certain reading path (e.g. grd=true to read grids) or take the chance of letting the data type be guessed via the file extension. Known extensions are:

• Grids: .grd .jp2 .nc
• Images: .jpg .jp2 .png, .tif, .tiff, .bmp, .webp
• Datasets: .dat .txt .csv .isf
• Datasets: .arrow .arrows .shp .kml .kmz .json .gmt .feather .fgb .gpkg .geojson .gpx .gml .ipc .parquet .sqlite
• CPT: .cpt
• PostScript: .ps, .eps

Parameters

Specify data type (with type=true, e.g. img=true). Choose among:

• grd | grid: Load a grid.

• img | image: Load an image.

• cpt | cmap: Load a GMT color palette.

• data | dataset | table: Load a dataset (a table of numbers).

• ogr: Load a dataset via GDAL OGR (a table of numbers). Many things can happen here.

• ps: Load a PostScript file

• gdal: Force reading the file via GDAL. Should only be used to read grids.

• varname: When netCDF files have more than one 2D (or higher) variables use varname to pick the wished variable. e.g. $varname=:slp$ to read the variable named $slp$. This option defaults data type to grid. This option can be used both with and without the gdal option. Former case uses GMT lib to read the cube and outputs and 3D array in column major order, later case (the one with gdal) uses GDAL to read the cube and outputs and 3D array in row major order. Remember that the $layout$ member of the GMTgrid type informs about memory layout.

• inrows: Select specific data rows to be read. Valid args include ranges or a string with an hard core GMT -q option.

• stride: When reading table data via GMT (but not GDAL), this option allows subsampling the data. Provide a number to be used as stride for the rows. A stride=2 will read every other row.

• layer| layers | band | bands: A string, a number or an Array. When files are multiband or nc files with 3D or 4D arrays, we access them via these keywords. layer=4 reads the fourth layer (or band) of the file. The file can be a grid or an image. If it is a grid, layer can be a scalar (to read 3D arrays) or an array of two elements (to read a 4D array). This option should not be used with the gdal option.

  If file is an image, layer can be a 1 or a 1x3 array (to read a RGB image). Note that in this later case bands do not need to be contiguous. A band=[1,5,2] composes an RGB out of those bands. See more at http://docs.generic-mapping-tools.org/latest//GMT_Docs.html#modifiers-for-coards-compliant-netcdf-files) but note that we use 1 based indexing here.

  Use $layers=:all$ to read all levels of a 3D cube netCDF file.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

Example: to read a nc called 'lixo.grd'

G = gmtread("lixo.grd");

to read a jpg image with the bands reversed

I = gmtread("image.jpg", band=[2,1,0]);

gmtselect(cmd0::String="", arg1=nothing, kwargs...)

Select data table subsets based on multiple spatial criteria.

See full GMT (not the GMT.jl one) docs at gmtselect

Parameters

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• A | area :: [Type => Str | Number]

  Features with an area smaller than minarea in km^2 or of hierarchical level that is lower than minlevel or higher than max_level will not be plotted.

• C | dist2pt | dist :: [Type => Str | NamedTuple] Arg = pointfile+ddist[unit] | (pts=Array, dist=xx)

  Pass all records whose location is within dist of any of the points in the ASCII file pointfile. If dist is zero then the 3rd column of pointfile must have each point’s individual radius of influence.

• D | res | resolution :: [Type => Str] Arg = c|l|i|h|f

  Ignored unless N is set. Selects the resolution of the coastline data set to use ((f)ull, (h)igh, (i)ntermediate, (l)ow, or (c)rude).

• E | boundary :: [Type => Str | []] Arg = [fn]

  Specify how points exactly on a polygon boundary should be considered.

• F | polygon :: [Type => Str | GMTdaset | Mx2 array] Arg = polygonfile

  Pass all records whose location is within one of the closed polygons in the multiple-segment file $polygonfile$ or a GMTdataset type or a Mx2 array defining the polygon.

• G | gridmask :: [Type => Str | GRDgrid] Arg = gridmask

  Pass all locations that are inside the valid data area of the grid gridmask. Nodes that are outside are either NaN or zero.

• I | invert | reverse :: [Type => Str | []] Arg = [cflrsz]

  Reverses the sense of the test for each of the criteria specified.

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• L | dist2line :: [Type => Str | NamedTuple] Arg = linefile+ddist[unit][+p] | (pts=Array, dist=xx, ortho=_)

  Pass all records whose location is within dist of any of the line segments in the ASCII multiple-segment file linefile.

• N | mask :: [Type => Str | List] Arg = ocean/land/lake/island/pond or wet/dry

  Pass all records whose location is inside specified geographical features.

• Z | in_range :: [Type => Str | List] Arg = min[/max][+a][+ccol][+i]

  Pass all records whose 3rd column (z; col = 2) lies within the given range or is NaN.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• b | binary :: [Type => Str]

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• w | wrap | cyclic :: [Type => Str or Number] $Arg = [[-]n]$

  Convert input records to a cyclical coordinate.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

gmtset(; kwargs...)

Adjust individual GMT defaults settings in the current directory’s gmt.conf file.

See full GMT (not the GMT.jl one) docs at gmtset

Parameters

• D | units :: [Type => Str | []]

  Modify the GMT defaults based on the system settings. Append u for US defaults or s for SI defaults.

• G | defaultsfile :: [Type => Str]

  Name of specific gmt.conf file to read and modify.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

Example:

gmtset(FONT_ANNOT_PRIMARY="12p,Helvetica", MAP_GRID_CROSS_SIZE_PRIMARY=0.25)

gmtsimplify(cmd0::String="", arg1=nothing; kwargs...)

Line reduction using the Douglas-Peucker algorithm.

See full GMT (not the GMT.jl one) docs at gmtsimplify

Parameters

• T | tol | tolerance :: [Type => Str | Number] Arg = tolerance[unit]

  Specifies the maximum mismatch tolerance in the user units. If the data is not Cartesian then append the distance unit. (http://docs.generic-mapping-tools.org/latest/gmtsimplify.html#t)

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• b | binary :: [Type => Str]

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

gmtspatial(cmd0::String="", arg1=nothing, kwargs...)

Geospatial operations on points, lines and polygons.

See full GMT (not the GMT.jl one) docs at gmtspatial

Parameters

• A | nn | nearest_neighbor :: [Type => Str] Arg = [amin_dist][unit]

  Perform spatial nearest neighbor (NN) analysis: Determine the nearest neighbor of each point and report the NN distances and the point IDs involved in each pair.

• C | clip :: [Type => Bool]

  Clips polygons to the map region, including map boundary to the polygon as needed. The result is a closed polygon.

• D | duplicates :: [Type => Str] Arg = [+ffile][+aamax][+ddmax][+c|Ccmax][+sfact]

  Check for duplicates among the input lines or polygons, or, if file is given via +f, check if the input features already exist among the features in file.

• E | handedness :: [Type => Str] Arg = +|-

  Reset the handedness of all polygons to match the given + (counter-clockwise) or - (clockwise). Implies Q+

• F | force_polygons :: [Type => Str | []] Arg = [l]

  Force input data to become polygons on output, i.e., close them explicitly if not already closed. Optionally, append l to force line geometry.

• I | intersections :: [Type => Str | []] Arg = [e|i]

  Determine the intersection locations between all pairs of polygons.

• N | in_polygons | in_polyg :: [Type => Str] Arg = pfile[+a][+pstart][+r][+z]

  Determine if one (or all, with +a) points of each feature in the input data are inside any of the polygons given in the pfile.

• Q | centroid or area or length :: [Type => Str] Arg = [[unit][+cmin[/max]][+h][+l][+p][+s[a|d]]

  Measure the area of all polygons or length of line segments.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• S | polygons :: [Type => Str] Arg = h|i|j|s|u

  Spatial processing of polygons.

• T | truncate :: [Type => Str | []] Arg = [clippolygon]

  Truncate polygons against the specified polygon given, possibly resulting in open polygons.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | extend :: [Type => Str | Tuple] Arg = <dist>[<unit>][+f|l]

  Extend all segments with extra first and last points that are <dist> units away from the original end points in the directions implied by the line ends.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• b | binary :: [Type => Str]

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

gmtsplit(cmd0::String="", arg1=nothing; kwargs...)

Reads a series of (x,y[,z]) records [or optionally (x,y,z,d,h)] and splits this into separate lists of (x,y[,z]) series, such that each series has a nearly constant azimuth through the x,y plane.

See full GMT (not the GMT.jl one) docs at gmtsplit

Parameters

• A | azim_tol :: [Type => Str | Array]

  Write out only those segments which are within +/- tolerance degrees of azimuth in heading, measured clockwise from North, [0 - 360].

• C | course_change :: [Type => Number]

  Terminate a segment when a course change exceeding course_change degrees of heading is detected.

• D | min_dist | min_distance :: [Type => Number]

  Do not write a segment out unless it is at least minimum_distance units long.

• F | filter :: [Type => Str | Array]

  Filter the z values and/or the x,y values, assuming these are functions of d coordinate. xyfilter and zfilter are filter widths in distance units.

• N | multi | multifile :: [Type => Bool | Str]

  Write each segment to a separate output file.

• Q | fields :: [Type => Str]

  Specify your desired output using any combination of xyzdh, in any order.

• S | dh | dist_head :: [Type => Bool]

  Both d and h are supplied. In this case, input contains x,y,z,d,h. [Default expects (x,y,z) input, and d,h are computed from delta x, delta y.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• bi | binary_in :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary format for primary input (secondary inputs are always ASCII).

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• di | nodata_in :: [Type => Str or Number] $Arg = nodata$

  Examine all input columns and if any item equals nodata we interpret this value as a missing data item and substitute the value NaN.

• do | nodata_out :: [Type => Str or Number] $Arg = nodata$

  Examine all output columns and if any item equals NAN substitute it with the chosen missing data value.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

To see the full documentation type: $@? splitxyz$

gmtvector(cmd0::String="", arg1=nothing, kwargs...)

Time domain filtering of 1-D data tables.

See full GMT (not the GMT.jl one) docs at gmtvector

Parameters

• A | primary_vec :: [Type => Str] Arg = m[conf]|vector

  Specify a single, primary vector instead of reading tables.

• C | cartesian :: [Type => Str | []] Arg = [i|o]

  Select Cartesian coordinates on input and output.

• E | geod2geoc :: [Type => Bool]

  Convert input geographic coordinates from geodetic to geocentric and output geographic coordinates from geocentric to geodetic.

• N | normalize :: [Type => Bool]

  Normalize the resultant vectors prior to reporting the output.

• S | secondary_vec :: [Type => Str | List] Arg = [vector]

  Specify a single, secondary vector in the same format as the first vector.

• T | transform :: [Type => Str | List] Arg = a|d|D|paz|s|r[arg|R|x]

  Specify the vector transformation of interest.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• b | binary :: [Type => Str]

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• g | gap :: [Type => Str] $Arg = [a]x|y|d|X|Y|D|[col]z[+|-]gap[u]$

  Examine the spacing between consecutive data points in order to impose breaks in the line.

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• i | incols | incol :: [Type => Str] $Arg = cols[+l][+sscale][+ooffset][,…]$

  Select specific data columns for primary input, in arbitrary order.

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• yx :: [Type => Str or Bool or []] $Arg = [i|o]$

  Swap 1st and 2nd column on input and/or output.

gmtwhich(cmd0::String; kwargs...)

Find full path to specified files

See full GMT (not the GMT.jl one) docs at gmtwhich

Parameters

• A | readable :: [Type => Bool]

Only consider files that the user has permission to read [Default consider all files found].

• C | confirm :: [Type => Bool]

Instead of reporting the paths, print the confirmation Y if the file is found and N if it is not.

• D | report_dir :: [Type => Bool]

Instead of reporting the paths, print the directories that contains the files.

• G | download :: [Type => Str | []] $Arg = [c|l|u]$

If a file argument is a downloadable file (either a full URL, a @file for downloading from
the GMT Site Cache, or @earth_relief_*.grd) we will try to download the file if it is not
found in your local data or cache dirs.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

gmtwrite(fname::AbstractString, data; kwargs...)

Write a GMT object to file. The object is one of "grid" or "grd", "image" or "img", "dataset" or "table", "cmap" or "cpt" and "ps" (for postscript).

When saving grids, images and datasets we have a panoply of formats at our disposal. For the datasets case if the file name ends in .arrow, .shp, .json, .feather, .geojson, .gmt, .gpkg, .gpx, .gml or .parquet then it automatically selects $gdalwrite$ and saves the GMT dataset in that OGR vector format. The .kml is treated as a special case because there are GMT modules (e.g. gmt2kml) that produce KML formatted data and so we write it directly as a text file.

Parameters

• id: [Type => Str]

  Use an $id$ code when not not saving a grid into a standard COARDS-compliant netCDF grid. This $id$ is made up of two characters like $ef$ to save in ESRI Arc/Info ASCII Grid Interchange format (ASCII float). See the full list of ids at http://docs.generic-mapping-tools.org/latest/grdconvert.html#format-identifier.

  (http://docs.generic-mapping-tools.org/latest/grdconvert.html#g)

• scale | offset: [Type => Number]

  You may optionally ask to scale the data and then offset them with the specified amounts. These modifiers are particularly practical when storing the data as integers, by first removing an offset and then scaling down the values.

• nan | novalue | invalid | missing: [Type => Number]

  Lets you supply a value that represents an invalid grid entry, i.e., ‘Not-a-Number’.

• gdal: [Type => Bool]

  Force the use of the GDAL library to write the grid (to be used only with grids). (http://docs.generic-mapping-tools.org/latest/GMT_Docs.html#grid-file-format-specifications)

• driver: [Type => Str]

  When saving in other than the netCDF format we must tell the GDAL library what is wished format. That is done by specifying the driver name used by GDAL itself (e.g., netCDF, GTiFF, etc...).

• datatype: [Type => Str] $Arg = u8|u16|i16|u32|i32|float32$

  When saving with GDAL we can specify the data type from u8|u16|i16|u32|i32|float32 where ‘i’ and ‘u’ denote signed and unsigned integers respectively.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

Example: write the GMTgrid 'G' object into a nc file called 'lixo.grd'

gmtwrite("lixo.grd", G);

grat = graticules(D, width=(30,20), grid=nothing, annot_x=nothing)

or

grat = graticules(; proj="projection", width=(30,20), pm=0, grid=nothing, annot_x=nothing)

Create a projected graticule GMTdataset with meridians and parallels at width intervals.

• D: A GMTdataset (or vector of them) holding the projection info. Instead of GMTdataset type, this argument may also be a referenced grid or image type.
• proj: Alternatively pass a proj4 string or Symbol describing the projection
• pm: The projection prime meridian (Default is 0 or whatever is in D.proj4).
• width: A scalar or two elements array/tuple with increments in longitude and latitude. If scalar, widthx = widthy.
• grid: Instead of using the width argument, that generates an automatic set of graticules, one may pass a two elements Vector{Vector{Real}} with the meridians (grid[1]) and parallels (grid[2]) to create.
• annot_x: By default, all meridians are annotated when grat is used in the plotgrid! function, but depending on the projection and the latlim argument used in worldrectangular we may have the longitude labels overlap close to the prime meridian. To minimize that pass a vector of longitudes to be annotated. e.g. annot_x=[-180,-150,0,150,180] will annotate only those longitudes.

Returns

A Vector of GMTdataset containing the projected meridians and parallels. grat[i] attributes store information about that element lon,lat.

Example

grat = graticules(proj="+proj=ob_tran +o_proj=moll +o_lon_p=40 +o_lat_p=50 +lon_0=60");

gravfft(cmd0::String="", arg1=nothing, arg2=nothing; kwargs...)

Spectral calculations of gravity, isostasy, admittance, and coherence for grids.

See full GMT (not the GMT.jl one) docs at gravfft

Parameters

• D | density :: [Type => Str | GMTgrid]

  Sets body density in SI. Provide either a constant density or a grid with a variable one.

• E | n_terms :: [Type => Number]

  Number of terms used in Parker expansion [Default = 3].

• F | geopotential :: [Type => Str | Tuple]

  Specify desired geopotential field: compute geoid rather than gravity

• I | admittance :: [Type => Number]

  Use ingrid2 and ingrid1 (a grid with topography/bathymetry) to estimate admittance|coherence and return a GMTdataset.

• N | inquire :: [Type => Str] $Arg = [a|f|m|r|s|nx/ny][+a|[+d|h|l][+e|n|m][+twidth][+v][+w[suffix]][+z[p]]$

  Choose or inquire about suitable grid dimensions for FFT and set optional parameters. Control the FFT dimension:

• Q | flex_topo | flexural_topography :: [Type => Bool]

  Computes grid with the flexural topography.

• S | subplate | subplate_load :: [Type => Bool]

  Computes predicted gravity or geoid grid due to a subplate load produced by the current bathymetry and the theoretical model.

• T | topo_load :: [Type => Str]

  Compute the isostatic compensation from the topography load (input grid file) on an elastic plate of thickness te.

• W | z_obs | observation_level :: [Type => Number]

  Set water depth (or observation height) relative to topography in meters [0]. Append k to indicate km.

• Z | moho_depth :: [Type => Number]

  Moho [and swell] average compensation depths (in meters positive down).

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

Example. Compute the gravity effect of the Gorringe bank.

    G = grdcut("@earth_relief_10m", region=(-12.5,-10,35.5,37.5));
	G2 = gravfft(G, density=1700, F=(faa=6,slab=4), f=:g);
	imshow(G2)

gravprisms(cmd0::String="", arg1=nothing; kwargs...)

Compute the gravity/magnetic anomaly of a 3-D body by the method of Okabe.

See full GMT (not the GMT.jl one) docs at gravprisms

Parameters

• A | zup :: [Type => Bool]

  The z-axis should be positive upwards [Default is down].

• C | density :: [Type => Str | GMTgrid]

  Sets body density in SI. Provide either a constant density or a grid with a variable one.

• E | dxdy | xy_sides :: [Type => Number | Tuple numbers]

  If all prisms in table have constant x/y-dimensions then they can be set here. In that case table must~ only contain the centers of each prism and the z range

• F | component :: [Type => Str]

  Specify desired gravitational field component.

• G | save | outgrid | outfile :: [Type => Str]

  Output grid file name. Note that this is optional and to be used only when saving the result directly on disk. Otherwise, just use the G = gravprisms(....) form.

• H | radial_rho :: [Type => Str | Tuple]

  Set reference seamount parameters for an ad-hoc variable radial density function with depth.

• I | inc | increment | spacing :: [Type => Str] $Arg = xinc[unit][+e|n][/yinc[unit][+e|n]]]$

  x_inc [and optionally y_inc] is the grid spacing. Optionally, append an increment unit.

• L | base :: [Type => Number ! Grid]

  Give name of the base surface grid for a layer we wish to approximate with prisms, or give a constant z-level [0].

• M | units :: [Type => Str]

  Sets distance units used. units=:horizontal to indicate that both horizontal distances are in km [m].

• N | track :: [Type => Str | Matrix | GMTdataset]

  Specifies individual (x, y[, z]) locations where we wish to compute the predicted value.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• S | topography :: [Type => Number]

  Give name of grid with the full seamount heights, either for making prisms or as required by H.

• T | top :: [Type => Number | Grid]

  Give name of the top surface grid for a layer we wish to approximate with prisms, or give a constant z-level.

• Z | z_obs | observation_level :: [Type => Number | Grid]

  Set observation level, either as a constant or variable by giving the name of a grid with observation levels.

• T | top :: [Type => Number | Grid]

  Give name of the top surface grid for a layer we wish to approximate with prisms, or give a constant z-level.

• W | outmeanrho :: [Type => Str]

  Give name of an output grid with spatially varying, vertically-averaged prism densities created by C and H.

[I =] grays2cube(layers::GMTimage{UInt8,2}...; names::Vector{String}=String[], save::String="") -> GMTimage

Take N grayscale UInt8 GMTimages and agregate them into an image cube. Optionally provide a vector of names for each layer. If the save option is provided, we save the cube as a GeoTIFF file. Note, no need to provide an extension as the output name will always be '*.tiff'.

Example

# Make a cube with the Cb, Cr, a* and b* comonents of YCbCR & La*b* color spaces of an RGB image
I = mat2image(rand(UInt8,128, 128, 3))		# Create sample RGB image
_,Cb,Cr = rgb2YCbCr(I, Cb=true, Cr=true);	# Extract Cb and Cr components
L,a,b   = rgb2lab(I, L=true);				# Extract La*b* components
Icube = grays2cube(Cb, Cr, a, b; names=["Cb", "Cr", "a", "b"]);

I = grays2rgb(bandR, bandG, bandB, GI=nothing) -> GMTimage

Take three grayscale images as UInt8 matrices or GMTimages and compose an RGB image by simply copying the values of each band into the respective color channel of the output image. When the inputs are UInt8 matrices optionally provide a GMTgrid or GMTimage as fourth argument to set georeferencing info on output. The output is always a GMTimage object.

Note, do not confuse this function with ind2rgb that takes a single indexed image and creates a RGB using the image's colormap.

Example

I1 = mat2img(rand(UInt8, 16,16)); I2 = mat2img(rand(UInt8, 16,16)); I3 = mat2img(rand(UInt8, 16,16));
Irgb = grays2rgb(I1,I2,I3)

grd2cpt(cmd0::String="", arg1=nothing, kwargs...)

Make linear or histogram-equalized color palette table from grid

See full GMT (not the GMT.jl one) docs at grd2cpt

Parameters

• A | alpha | transparency :: [Type => Str]

  Sets a constant level of transparency (0-100) for all color slices.

• C | color | colormap | cmap | colorscale :: [Type => Str] $Arg = [cpt |master[+izinc] |color1,color2[,*color3*,…]]$

  Give a CPT name or specify -Ccolor1,color2[,color3,...] to build a linear continuous CPT from those colors automatically.

• D | bg | background :: [Type => Str | []] Arg = [i|o]

  Select the back- and foreground colors to match the colors for lowest and highest z-values in the output CPT.

• E | nlevels :: [Type => Int | []] Arg = [nlevels]

  Create a linear color table by using the grid z-range as the new limits in the CPT. Alternatively, append nlevels and we will resample the color table into nlevels equidistant slices.

• F | color_model :: [Type => Str | []] Arg = [R|r|h|c][+c]]

  Force output CPT to written with r/g/b codes, gray-scale values or color name.

• G | truncate :: [Type => Str] Arg = zlo/zhi

  Truncate the incoming CPT so that the lowest and highest z-levels are to zlo and zhi.

• I | inverse | reverse :: [Type => Str] Arg = [c][z]

  Reverse the sense of color progression in the master CPT.

• L | datarange | clim :: [Type => Str] Arg = minlimit/maxlimit

  Limit range of CPT to minlimit/maxlimit, and don’t count data outside this range when estimating CDF(Z). [Default uses min and max of data.]

• M | overrule_bg :: [Type => Bool]

  Overrule background, foreground, and NaN colors specified in the master CPT with the values of the parameters COLORBACKGROUND, COLORFOREGROUND, and COLOR_NAN.

• N | no_bg | nobg :: [Type => Bool]

  Do not write out the background, foreground, and NaN-color fields.

• Q | log :: [Type => Bool]

  Selects a logarithmic interpolation scheme [Default is linear].

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• S | symmetric :: [Type => Str] Arg = h|l|m|u

  Force the color table to be symmetric about zero (from -R to +R).

• T | range :: [Type => Str] Arg = (min,max,inc) or = "n"

  Set steps in CPT. Calculate entries in CPT from zstart to zstop in steps of (zinc). Default chooses arbitrary values by a crazy scheme based on equidistant values for a Gaussian CDF.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | categorical :: [Type => Bool | Str | []] Arg = [w]

  Do not interpolate the input color table but pick the output colors starting at the beginning of the color table, until colors for all intervals are assigned.

• Z | continuous :: [Type => Bool]

  Creates a continuous CPT [Default is discontinuous, i.e., constant colors for each interval].

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

grd2kml(cmd0::String="", arg1=nothing, kwargs...)

Reads a 2-D grid file and makes a quadtree of PNG images and KML wrappers for Google Earth using the selected tile size [256x256 pixels].

See full GMT (not the GMT.jl one) docs at grd2kml

Parameters

• A | mode :: [Type => Str] Arg = url

  Select one of three altitude modes recognized by Google Earth that determines the altitude (in m) of the tile layer.

• C | color | colormap | cmap | colorscale :: [Type => Str] $Arg = [cpt |master[+izinc] |color1,color2[,*color3*,…]]$

  Give a CPT name or specify -Ccolor1,color2[,color3,...] to build a linear continuous CPT from those colors automatically.

• E | url :: [Type => Str] Arg = url

  Instead of hosting the files locally, prepend a site URL. The top-level prefix.kml file will then use this URL to find the other files it references.

• F | filter :: [Type => Str]

  Specifies the filter to use for the downsampling of the grid for more distant viewing. Choose among boxcar, cosine arch, gaussian, or median [Gaussian].

• H | sub_pixel | subpixel :: [Type => Int] Arg = factor

  Improve the quality of rasterization by passing the sub-pixel smoothing factor to psconvert.

• I | shade | shading | intensity :: [Type => Str | GMTgrid]

  Gives the name of a grid file or GMTgrid with intensities in the (-1,+1) range, or a grdgradient shading flags.

• L | tilesize | tile_size :: [Type => Number] Arg = tilesize

  Sets the fixed size of the image building blocks. Must be an integer that is radix 2. Typical values are 256 or 512 [256].

• N | prefix [Type => Str] Arg = prefix

  Sets a unique name prefixed used for the top-level KML filename and the directory where all referenced KML files and PNG images will be written [GMT_Quadtree].

• Q | nan_t | nan_alpha :: [Type => Bool]

  Make grid nodes with z = NaN transparent, using the color-masking feature in PostScript Level 3.

• S | extra_layers | extralayers :: [Type => Str]

  Add extra layers beyond that necessary to capture the full resolution of the data.

• T | title :: [Type => Str] Arg = title

  Sets the title of the top-level document (i.e., its description).

• W | contours :: [Type => Str] Arg = title

  Supply a file with records each holding a contour value and a contour pen.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• n | interp | interpolation :: [Type => Str] $Arg = [b|c|l|n][+a][+bBC][+c][+tthreshold]$

  Select grid interpolation mode by adding b for B-spline smoothing, c for bicubic interpolation, l for bilinear interpolation, or n for nearest-neighbor value.

grd2xyz(cmd0::String="", arg1=nothing, kwargs...)

Reads one 2-D grid and returns xyz-triplets.

See full GMT (not the GMT.jl one) docs at grd2xyz

Parameters

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• C | row_col | rowcol :: [Type => Bool]

  Replace the x- and y-coordinates on output with the corresponding column and row numbers.

• L | hvline :: [Type => String]

  Limit the output of records to a single row or column.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• T | stl | STL :: [Type => String]

  Compute a STL triangulation for 3-D printing.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | weight :: [Type => Str] Arg = [a|weight]

  Write out x,y,z,w, where w is the supplied weight (or 1 if not supplied) [Default writes x,y,z only].

• Z | onecol | one_col :: [Type => Str]

  Write a 1-column table. Output will be organized according to the specified ordering convention contained in $flags$.

• write | |> :: [Type => Str] $Arg = fname$

  Save result to ASCII file instead of returning to a Julia variable. Give file name as argument. Use the bo option to save as a binary file.

• append :: [Type => Str] $Arg = fname$

  Append result to an existing file named $fname$ instead of returning to a Julia variable. Use the bo option to save as a binary file.

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• d | nodata :: [Type => Str or Number] $Arg = [i|o]nodata$

  Control how user-coded missing data values are translated to official NaN values in GMT.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• o | outcols | outcol :: [Type => Str] $Arg = cols[,…]$

  Select specific data columns for primary output, in arbitrary order.

• s | skiprows | skip_NaN :: [Type => Str] $Arg = [cols][a|r]$

  Suppress output for records whose z-value equals NaN.

grdblend(cmd0::String="", arg1=nothing, arg2=nothing, kwargs...)

Reads a listing of grid files and blend parameters, or up to 2 GTMgrid types, and creates a grid by blending the other grids using cosine-taper weights.

See full GMT (not the GMT.jl one) docs at grdblend

Parameters

• I | inc | increment | spacing :: [Type => Str] $Arg = xinc[unit][+e|n][/yinc[unit][+e|n]]]$

  x_inc [and optionally y_inc] is the grid spacing. Optionally, append an increment unit. (http://docs.generic-mapping-tools.org/latest/grdblend.html#i)

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• G | save | outgrid | outfile :: [Type => Str]

  Output grid file name. Note that this is optional and to be used only when saving the result directly on disk. Otherwise, just use the G = grdblend(....) form.

• C | clobber :: [Type => Str | []] $Arg = f|l|o|u[±]$

  Clobber mode: Instead of blending, simply pick the value of one of the grids that covers a node.

• N | nodata :: [Type => Str | Number]

  No data. Set nodes with no input grid to this value [Default is NaN].

• Q | headless :: [Type => Bool]

  Create plain header-less grid file (for use with external tools). Requires that the output grid file is a native format (i.e., not netCDF). DO NOT USE WITH G.

• W | no_blend :: [Type => Str | []]

  Do not blend, just output the weights used for each node [Default makes the blend]. Append $z$ to write the weight*z sum instead.

• Z | scale :: [Type => Number]

  Scale output values by scale before writing to file.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• n | interp | interpolation :: [Type => Str] $Arg = [b|c|l|n][+a][+bBC][+c][+tthreshold]$

  Select grid interpolation mode by adding b for B-spline smoothing, c for bicubic interpolation, l for bilinear interpolation, or n for nearest-neighbor value.

• r | reg | registration :: [Type => Bool or []]

  Force pixel node registration [Default is gridline registration].

grdclip(cmd0::String="", arg1=nothing; kwargs...)

Clip the range of grid values. will set values < low to below and/or values > high to above. You can also specify one or more intervals where all values should be set to $between$, or replace individual values.

See full GMT (not the GMT.jl one) docs at grdclip

Parameters

• cmd0 :: [Type => Str]

  The input file name. Do not use this when the grid (a GMTgrid type) is passed via the $arg1$ argument.

• G | save | outgrid | outfile :: [Type => Str]

  Output grid file name. Note that this is optional and to be used only when saving the result directly on disk. Otherwise, just use the G = grdclip(....) form.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• above | high :: [Type => Array | Str]

  Two elements array with $high$ and $above$ or a string with "high/above". It sets all data[i] > $high$ to $above$.

• below | low :: [Type => Array | Str]

  Two elements array with $low$ and $below$ or a string with "low/below". It sets all data[i] < $low$ to $below$.

• between :: [Type => Array | Str]

  Three elements array with $low, high$ and $between$ or a string with "low/high/between". It sets all data[i] >= $low$ and <= $high$ to $between$.

• old | new :: [Type => Array | Str]

  Two elements array with $old$ and $new$ or a string with "old/new". It sets all data[i] == $old$ to $new$.

• S :: [Type => Str]

  Condense all replacement options above in a single string.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• Examples:

    G=gmt("grdmath", "-R0/10/0/10 -I1 X");
    G2=grdclip(G, above=[5 6], low=[2 2], between="3/4/3.5")

  or (note the use of -S for second on options because we can't repeat a kwarg name)

    G2=grdclip(G, S="a5/6 -Sb2/2 -Si3/4/3.5")

grdcontour(cmd0::String="", arg1=nothing; kwargs...)

Reads a 2-D grid file or a GMTgrid type and produces a contour map by tracing each contour through the grid.

See full GMT (not the GMT.jl one) docs at grdcontour

Parameters

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• A | annot | annotation :: [Type => Str or Number] $Arg = [-|[+]annot_int][labelinfo]$

  annot_int is annotation interval in data units; it is ignored if contour levels are given in a file.

• B | frame | axis | xaxis yaxis:: [Type => Str]

  Set map boundary frame and axes attributes.

• C | cont | contour | contours | levels :: [Type => Str | Number | GMTcpt] $Arg = [+]cont_int$

  Contours to be drawn may be specified in one of three possible ways.

• D | dump :: [Type => Str]

  Dump contours as data line segments; no plotting takes place.

• F | force :: [Type => Str | []]

  Force dumped contours to be oriented so that higher z-values are to the left (-Fl [Default]) or right.

• G | labels :: [Type => Str]

  Controls the placement of labels along the quoted lines.

• Jz | zscale | zsize :: [Type => String]

• L | range :: [Type => Str]

  Limit range: Do not draw contours for data values below low or above high.

• N | fill | colorize :: [Type => Bool]

  Fill the area between contours using the discrete color table given by cpt.

• P | portrait :: [Type => Bool or []]

  Tell GMT to NOT draw in portrait mode (that is, make a Landscape plot)

• Q | cut :: [Type => Str | Number]

  Do not draw contours with less than cut number of points.

• S | smooth :: [Type => Number]

  Used to resample the contour lines at roughly every (gridbox_size/smoothfactor) interval.

• T | ticks :: [Type => Str]

  Draw tick marks pointing in the downward direction every gap along the innermost closed contours.

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• U | time_stamp | timestamp :: [Type => Str or Bool or []] $Arg = [[just]/dx/dy/][c|label]$

  Draw GMT time stamp logo on plot.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• W | pen :: [Type => Str | Number]

  Sets the attributes for the particular line.

• X | x_offset | xshift :: [Type => Str] $Arg = [a|c|f|r][x-shift[u]]$

• Y | y_offset | yshift :: [Type => Str] $Arg = [a|c|f|r][y-shift[u]]$

  Shift plot origin relative to the current origin by (x-shift,y-shift) and optionally append the length unit (c, i, or p).

• Z | muladd | scale :: [Type => Str]

  Use to subtract shift from the data and multiply the results by factor before contouring starts.

• bo | binary_out :: [Type => Str] $Arg = [ncols][type][w][+L|+B]$

  Select native binary output.

• do | nodata_out :: [Type => Str or Number] $Arg = nodata$

  Examine all output columns and if any item equals NAN substitute it with the chosen missing data value.

• e | pattern | find :: [Type => Str] $Arg = [~]”pattern” | -e[~]/regexp/[i]$

  Only accept ASCII data records that contains the specified pattern.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).

• h | header :: [Type => Str] $Arg = [i|o][n][+c][+d][+rremark][+ttitle]$

  Primary input file(s) has header record(s).

• p | view | perspective :: [Type => Str or List] $Arg = [x|y|z]azim[/elev[/zlevel]][+wlon0/lat0[/z0]][+vx0/y0]$

  Selects perspective view and sets the azimuth and elevation of the viewpoint [180/90].

• t | alpha | transparency :: [Type => Str] $Arg = transp$

  Set PDF transparency level for an overlay, in (0-100] percent range. [Default is 0, i.e., opaque].

• savefig | figname | name :: [Type => Str]

  Save the figure with the figname=name.ext where ext chooses the figure format (e.g. figname="name.png")

To see the full documentation type: $@? grdcontour$

grdconvert(fname::AbstractString)

Read a gridded dataset stored in a $x y z$ text file with an extension $.xyz$ (note that this detail is mandatory) and return a GMTgrid object. By "gridded dataset" it is meant that the file contains an already gridded dataset. Scattered $xyz$ points are not wellcome here.

grdcut(cmd0::String="", arg1=[], kwargs...)

Produce a new outgrid which is a subregion of ingrid. The subregion is specified with $limits$ (the -R); the specified range must not exceed the range of ingrid (but see $extend$).

See full GMT (not the GMT.jl one) docs at grdcut

Parameters

• E | rowlice | colslice :: [Type => Number]

  Extract a vertical slice going along the x-column coord or along the y-row coord.

• F | clip | cutline :: [Type => Str | GMTdaset | Mx2 array | NamedTuple] Arg = array|fname[+c] | (polygon=Array|Str, crop2cutline=Bool, invert=Bool)

  Specify a closed polygon (either a file or a dataset). All grid nodes outside the polygon will be set to NaN.

• G | save | outgrid | outfile :: [Type => Str]

  Output grid file name. Note that this is optional and to be used only when saving the result directly on disk. Otherwise, just use the G = grdcut(....) form.

• img | usegdal | gdal :: [Type => Any]

  Force the cut operation to be done by GDAL. Works for images where GMT fails or even crash.

• J | proj | projection :: [Type => String]

  Select map projection. Defaults to 15x10 cm with linear (non-projected) maps.

• N | extend :: [Type => Str or []]

  Allow grid to be extended if new region exceeds existing boundaries. Append nodata value to initialize nodes outside current region [Default is NaN].

• R | region | limits :: [Type => Str or list or GMTgrid|image] $Arg = (xmin,xmax,ymin,ymax)$

  Specify the region of interest. Set to data minimum BoundinBox if not provided.

• S | circ_subregion :: [Type => Str] $Arg = [n]lon/lat/radius[unit]$

  Specify an origin and radius; append a distance unit and we determine the corresponding rectangular region so that all grid nodes on or inside the circle are contained in the subset.

• V | verbose :: [Type => Bool or Str] $Arg = [level]$

  Select verbosity level, which will send progress reports to stderr.

• Z | range :: [Type => Str] $Arg = [n|N |r][min/max]$

  Determine a new rectangular region so that all nodes outside this region are also outside the given z-range.

• f | geog | colinfo | coltypes | coltype :: [Type => Str] $Arg = [i|o]colinfo$

  Specify the data types of input and/or output columns (time or geographical data).