## Documentation Center |

Construct affine spatial-referencing matrix

`R = makerefmat(x11, y11, dx, dy)R = makerefmat(lon11, lat11, dlon, dlat)R = makerefmat(param1, val1, param2, val2, ...)`

`R = makerefmat(x11, y11, dx, dy)`,
with scalars `dx` and `dy`, constructs
a referencing matrix that aligns image or data grid rows to map *x* and
columns to map *y*. Scalars `x11` and `y11` specify
the map location of the center of the first (1,1) pixel in the image
or the first element of the data grid, so that

[x11 y11] = pix2map(R,1,1)

`dx` is the difference in *x* (or
longitude) between pixels in successive columns, and `dy` is
the difference in *y* (or latitude) between pixels
in successive rows. More abstractly, `R` is defined
such that

[x11 + (col-1) * dx, y11 + (row-1) * dy] = pix2map(R, row, col)

Pixels cover squares on the map when `abs(dx) = abs(dy)`.
To achieve the most typical kind of alignment, where *x* increases
from column to column and *y* decreases from row
to row, make `dx` positive and `dy` negative.
In order to specify such an alignment along with square pixels, make `dx` positive
and make `dy` equal to `-dx`:

R = makerefmat(x11, y11, dx, -dx)

`R = makerefmat(x11, y11, dx, dy)`, with two-element
vectors `dx` and `dy`, constructs
the most general possible kind of referencing matrix, for which

[x11 + ([row col]-1) * dx(:), y11 + ([row col]-1) * dy(:)] ... = pix2map(R, row, col)

In this general case, each pixel can become a parallelogram
on the map, with neither edge necessarily aligned to map *x* or *y*.
The vector `[dx(1) dy(1)]` is the difference in map
location between a pixel in one row and its neighbor in the preceding
row. Likewise, `[dx(2) dy(2)]` is the difference
in map location between a pixel in one column and its neighbor in
the preceding column.

To specify pixels that are rectangular or square (but possibly
rotated), choose `dx` and `dy` such
that `prod(dx) + prod(dy) = 0`. To specify square
(but possibly rotated) pixels, choose `dx` and `dy` such
that the 2-by-2 matrix `[dx(:) dy(:)]` is a scalar
multiple of an orthogonal matrix (that is, its two eigenvalues are
real, nonzero, and equal in absolute value). This amounts to either
rotation, a mirror image, or a combination of both. Note that for
scalars `dx` and `dy`,

R = makerefmat(x11, y11, [0 dx], [dy 0])

is equivalent to

R = makerefmat(x11, y11, dx, dy)

`R = makerefmat(lon11, lat11, dlon, dlat)`,
with longitude preceding latitude, constructs a referencing matrix
for use with geographic coordinates. In this case,

[lat11,lon11] = pix2latlon(R,1,1), [lat11+(row-1)*dlat,lon11+(col-1)*dlon] = pix2latlon(R,row,col)

for scalar `dlat` and `dlon`,
and

[lat11+[row col]-1)*dlat,lon11+([row col]-1)*dlon] = ... pix2latlon(R, row,col)

for vector `dlat` and `dlon`.
Images or data grids aligned with latitude and longitude might already
have referencing vectors. In this case you can use function `refvec2mat` to convert to a referencing matrix.

`R = makerefmat(param1, val1, param2, val2, ...)` uses
parameter name-value pairs to construct a referencing matrix for an
image or raster grid that is referenced to and aligned with a geographic
coordinate system. There can be no rotation or skew: each column must
fall along a meridian, and each row must fall along a parallel. Each
parameter name must be specified exactly as shown, including case.

Parameter Name | Data Type | Value |
---|---|---|

RasterSize | Two-element size vector [M N] | The number of rows ( With R = makerefmat('RasterSize', ... size(RGB), ...) where |

LatitudeLimits | Two-element row vector of the form: [southern_limit,
northern_limit], in units of degrees. | The limits in latitude of the geographic quadrangle bounding the georeferenced raster. The default value is [0 1]. |

LongitudeLimits | Two-element row vector of the form: [western_limit,
eastern_limit], in units of degrees. | The limits in longitude of the geographic quadrangle bounding
the georeferenced raster. The elements of the 'LongitudeLimits' vector
must be ascending in value. In other words, the limits must be unwrapped.
The default value is [0 1]. |

ColumnsStartFrom | String | Indicates the column direction of the raster (south-to-north
vs. north-to-south) in terms of the edge from which row indexing starts.
The input string can have the value 'south' or 'north',
can be shortened, and is case-insensitive. In a typical terrain grid,
row indexing starts at southern edge. In images, row indexing starts
at northern edge. The default value is 'south'. |

RowsStartFrom | String | Indicates the row direction of the raster (west-to-east vs.
east-to-west) in terms of the edge from which column indexing starts.
The input string can have the value 'west' or 'east',
can be shortened, and is case-insensitive. Rows almost always run
from west to east. The default value is 'west'. |

Create a referencing matrix for an image with square, four-meter
pixels and with its upper left corner (in a map coordinate system)
at *x* = 207000 meters, *y* =
913000 meters. The image follows the typical orientation: *x* increasing
from column to column and *y* decreasing from row
to row.

x11 = 207002; % Two meters east of the upper left corner y11 = 912998; % Two meters south of the upper left corner dx = 4; dy = -4; R = makerefmat(x11, y11, dx, dy)

Create a referencing matrix for a global geoid grid.

% Add array 'geoid' to the workspace: load geoid %'geoid' contains a model of the Earth's geoid sampled in % one-degree-by-one-degree cells. Each column of 'geoid' % contains geoid heights in meters for 180 cells starting % at latitude -90 degrees and extending to +90 degrees, for % a given longitude. Each row contains geoid heights for 360 % cells starting at longitude 0 and extending 360 degrees. geoidR = makerefmat('RasterSize', size(geoid), ... 'Latlim', [-90 90], 'Lonlim', [0 360]) % At its most extreme, the geoid reaches a minimum of slightly % less than -100 meters. This minimum occurs in the Indian Ocean % at approximately 4.5 degrees latitude, 78.5 degrees longitude. % Check the geoid height at its most extreme by using latlon2pix % with the referencing matrix. [row, col] = latlon2pix(geoidR, 4.5, 78.5) geoid(round(row),round(col))

`latlon2pix` | `map2pix` | `pix2latlon` | `pix2map` | `refvec2mat` | `worldfileread` | `worldfilewrite`

Was this topic helpful?