Calls from Fortran take the identical arguments, except as noted (string lengths are omitted from Fortran calls). Sections are numbered from 1 instead of zero when calling from Fortran.

Header to include: warpfiles.h

int newWarpFile(int nx, int ny, int binning, float pixelSize, int flags)

int readWarpFile(char *filename, int *nx, int *ny, int *nz, int *binning, float *pixelSize, int *version, int *flags)

int writeWarpFile(const char *filename, int skipBackup)

int setCurrentWarpFile(int index)

int clearWarpFile(int index)

void warpFilesDone()

int getWarpFileSize(int *nx, int *ny, int *nz, int *ifControl)

int setLinearTransform(int iz, float *xform, int rows)

int setWarpGrid(int iz, int nxGrid, int nyGrid, float xStart, float yStart, float xInterval, float yInterval, float *dxGrid, float *dyGrid, int xdim)

int setWarpPoints(int iz, int nControl, float *xControl, float *yControl, float *xVector, float *yVector)

int addWarpPoint(int iz, float xControl, float yControl, float xVector, float yVector)

int removeWarpPoint(int iz, int index)

int getLinearTransform(int iz, float *xform, int rows)

int getNumWarpPoints(int iz, int *nControl)

int getWarpPoints(int iz, float *xControl, float *yControl, float *xVector, float *yVector)

int getWarpPointArrays(int iz, float **xControl, float **yControl, float **xVector, float **yVector)

int getWarpGridSize(int iz, int *nxMax, int *nyMax, int *prodMax)

int getGridParameters(int iz, int *nxGrid, int *nyGrid, float *xStart, float *yStart, float *xInterval, float *yInterval)

int setGridSizeToMake(int iz, int nxGrid, int nyGrid, float xStart, float yStart, float xInterval, float yInterval)

int controlPointRange(int iz, float *xmin, float *xmax, float *ymin, float *ymax)

int controlPointSpacing(int iz, float percentile, float *spacing)

int gridSizeFromSpacing(int iz, float percentile, float factor, int fullExtent)

int getWarpGrid(int iz, int *nxGrid, int *nyGrid, float *xStart, float *yStart, float *xInterval, float *yInterval, float *dxGrid, float *dyGrid, int xdim)

int separateLinearTransform(int iz)

void interpolateGrid(float x, float y, float *dxGrid, float *dyGrid, int ixgDim, int nxGrid, int nyGrid, float xGridStart, float yGridStart, float xGridIntrv, float yGridIntrv, float *dx, float *dy)

void findInversePoint(float x, float y, float *dxGrid, float *dyGrid, int ixgDim, int nxGrid, int nyGrid, float xGridStart, float yGridStart, float xGridIntrv, float yGridIntrv, float *xnew, float *ynew, float *dx, float *dy)

void invertWarpGrid(float *dxGrid, float *dyGrid, int ixgDim, int nxGrid, int nyGrid, float xGridStart, float yGridStart, float xGridIntrv, float yGridIntrv, float *xform, float xcen, float ycen, float *dxInv, float *dyInv, float *xfInv, int rows)

int multiplyWarpings(float *dxGrid1, float *dyGrid1, int ixgDim1, int nxGrid1, int nyGrid1, float xStart1, float yStart1, float xIntrv1, float yIntrv1, float *xform1, float xcen, float ycen, float *dxGrid2, float *dyGrid2, int ixgDim2, int nxGrid2, int nyGrid2, float xStart2, float yStart2, float xIntrv2, float yIntrv2, float *xform2, float *dxProd, float *dyProd, float *xfProd, int useSecond, int rows)

int extractLinearXform(float *xPos, float *yPos, float *xVector, float *yVector, int nPoints, float xcen, float ycen, float *newXvec, float *newYvec, float *xfinv, int rows)

int extrapolateGrid(float *dxGrid, float *dyGrid, char *solved, int xdim, int nxGrid, int nyGrid, float xInterval, float yInterval, int reuse)

void extrapolateDone()

int expandAndExtrapGrid(float *dxGrid, float *dyGrid, int xdim, int ydim, int *nxGrid, int *nyGrid, float *xStart, float *yStart, float xInterval, float yInterval, float xBigStr, float yBigStr, float xBigEnd, float yBigEnd, int ixmin, int ixmax, int iymin, int iymax)

int readCheckWarpFile(char *filename, int needDist, int needInv, int *nx, int *ny, int *nz, int *ibinning, float *pixelSize, int *iflags, char *errString, int lenString)

int findMaxGridSize(float xmin, float xmax, float ymin, float ymax, int *nControl, int *maxNxg, int *maxNyg, char *errString, int lenString)

int getSizeAdjustedGrid(int iz, float xnbig, float ynbig, float xOffset, float yOffset, int adjustStart, float warpScale, int iBinning, int *nxGrid, int *nyGrid, float *xGridStrt, float *yGridStrt, float *xGridIntrv, float *yGridIntrv, float *fieldDx, float *fieldDy, int ixgdim, int iygdim, char *errString, int lenString)

void warpInterp(float *array, float *bray, int nxa, int nya, int nxb, int nyb, float amat[2][2], float xc, float yc, float xt, float yt, float scale, float dmean, int linear, int linFirst, float *dxGrid, float *dyGrid, int ixgDim, int nxGrid, int nyGrid, float xGridStrt, float yGridStrt, float xGridIntrv, float yGridIntrv)

void makeMagGradField(float *idfDx, float *idfDy, float *gradDx, float *gradDy, int lmGrid, int imageNx, int imageNy, int *nxGrid, int *nyGrid, float *xGridStrt, float *yGridStrt, float *xGridIntrv, float *yGridIntrv, float xcen, float ycen, float pixelSize, float axisRot, float tilt, float dmagPerUm, float rotPerUm)

void magGradientShift(float xx, float yy, int imageNx, int imageNy, float xcen, float ycen, float pixelSize, float axisRot, float tilt, float dmagPerUm, float rotPerUm, float *dx, float *dy)

3 nx ny nz binning pixelSize flagsHere

`nx`

and `ny`

are the sizes of the images on which
a warping or distortion field was measured,
`binning`

is relevant only for distortion fields, and is the
absolute binning of the images, including any binning on the camera
`pixelSize`

is the pixel size in Angstroms of the images,
corresponding to the pixel spacing reported by the standard header output.
`flags`

is an OR of a set of bit flags:
1 if the warping component is an inverse transform

2 if the warping specified by control points instead of a regular grid

For a regular grid, each transformation then has the following lines

xStart xInterval nxGrid yStart yInterval nyGrid a11 a12 a21 a22 dx dy deltaX deltaY deltaX deltaY ... ...Here,

`xStart, yStart`

are coordinates of the lower left point of the grid
`xInterval, yInterval`

are the spacing between grid points in X
and Y
`nxGrid, nyGrid`

are the number of grid points in X and Y
`a11, a12, a21, a22, dx, dy`

specify a forward linear transform in the
usual way, i.e.
x' = a11 * (x - xci) + a12 * (y - yci) + xco y' = a21 * (x - xci) + a22 * (y - yci) + ycowhere

`(x, y)`

and `(x', y')`

are positions in the input and
output images, and `(xci, yci)`

and `(xco, yco)`

are the
centers of the input and output images. Finally,
`deltaX, deltaY`

are the displacement vectors at the grid points,
in order by increasing X for one Y, then by increasing Y.
There may be variable numbers of entries per line (up to 50), but vectors at a new Y
value should start a new line.
The vectors and positions describe an inverse transform: a point at a grid position in a transformed image corresponds to that position plus its displacement vector in the original image.

For a warping file with control points, each transformation has the following lines after the header:

nControl a11 a12 a21 a22 dx dy xControl yControl deltaX deltaY xControl yControl deltaX deltaY ...where

`nControl`

is the number of control points, which can be zero,
`a11, a12, a21, a22, dx, dy`

specify a forward linear transform as
above,
`xControl, yControl`

are the coordinates of one control point in
the warped image
`deltaX, deltaY`

is the displacement vector at that point, which
is added to the control point position to get the corresponding position in
the original image.
Version 2 files could contain multiple grids of displacements, which are assumed to be inverse transforms, and no linear transforms. Its form was:

2 nx ny nz binning pixelSize xStart xInterval nxGrid yStart yInterval nyGrid deltaX deltaY deltaX deltaY ... ... xStart xInterval nxGrid yStart yInterval nyGrid deltaX deltaY deltaX deltaY ... ...Here one grid follows another, starting with a line specifying the parameters for that grid

Version 1 files contained only a single grid of displacements, again assumed to be an inverse transform, and no linear transformations. Its form was:

1 nx ny binning pixelSize xStart xInterval nxGrid yStart yInterval nyGrid deltaX deltaY deltaX deltaY ...

Initialize for a new warp file based on image dimensions **nx**, **ny** at the given
**binning**, with the pixel size in Angstroms in **pixelSize** and **flags** containing the
sum of 1 for inverse warping and 2 for control points. Returns the index of the new
file, or -1 for a memory error.

Reads in a warping file whose name is in **filename**. Returns the X and Y sizes given
in the file in **nx** and **ny**, the number of sections of warpings in **nz**, the binning
factor into **binning**, the pixel size in Angstroms into **pixelSize**, the original file
version into **version**, and the sum of 1 for inverse warpings and 2 for control points
into **flags**. The return value is the index of the warp file, or
-1 for failure to open the file, -2 for an error reading values from the file, -3 for
the wrong number of values on the first line or nothing following that line, -4 for a
version number out of range or an error reading values or the wrong number of values
on the header line, -5 for **nz**, **ny**, **nz**, or **binning** out of range, -6 for memory
errors, or -7 for an error or inconsistency reading warpings. **version** will be -1
for errors -1, -2, or -3, or 0 if the error is -3 and there are 6 values on the first
line, which is a signal that the file contains ordinary transforms.

Writes the current warping file as a version 3 file to **filename**. Backs up an
existing file to filename~ unless **skipBackup** is non-zero. Returns -1 for
no filename or failure to open the file, or 1 for an error backing up an existing file.

Set the index of the current warping file to **index**. Returns -1 for error.

Deletes all data for the warp file at **index** and marks it as unused. Returns 1 for
index out of range or 2 for a warp file not in use.

Deletes all warp file data and resets pointers and indices; also calls extrapolateDone.

For the current warp file, returns the image size in **nx** and **ny**, number of sections
in **nz**, and 1 in **ifControl** if it has control points. Return value is 1 if there is
no current warp file.

Sets the linear transform for section **iz** in the current warp file to **xform**; **rows**
specifies the number of rows (2 or 3) in the **xform** array.
When calling from Fortran, omit **rows**; it is assumed to be 2.

Sets a warping grid for section **iz** in the current warp file. The grid consists of
**nxGrid** by **nyGrid** points, starting at **xStart**, **yStart** and at intervals of
**xInterval**, **yInterval**. The vectors are in 2D arrays **dxGrid**, **dyGrid**, and **xdim**
is the X dimension of the arrays. This call can replace an existing warping grid
but not eliminate a grid. Returns 1 for all errors.

Sets control points for section **iz** of the current warp file. The number of points
is in **nControl**, their locations are in **xVector**, **yVector**, and the displacements
at the points are in **xVector**, **yVector**. This call can replace an existing set of
control points or eliminate them. Returns 1 for errors.

Adds one control point specified by position **xControl**, **yControl** and displacement
**xVector**, **yVector** to section **iz** of the current warp file. Returns -1 for no
current warp file, not a control point file, **iz** out of range, or memory errors.

Removes the control point at **index** from section **iz** of the current warp file.
Returns 1 for **iz** or **index** out of range.

Returns the linear transform for section **iz** of the current warp file into **xform**,
which has **rows** rows (2 or 3). Returns 1 for **iz** out of range or no warp file.
When calling from Fortran, omit **rows**; it is assumed to be 2.

Returns in **nControl** either the number of warp points on section **iz** if **iz** >= 0,
or the maximum number of points over all sections, if **iz** < 0. Returns 1 if there
is no current warp file or **iz** is out of range.

Returns control points for section **iz** in the current warp file, with positions placed
into **xControl**, **yControl** and displacements placed into **xVector**, **yVector**.
Returns 1 for **iz** out if range or no warp file.

Returns pointers to control point arrays for section **iz** in the current warp file,
with positions pointers placed into **xControl**, **yControl** and displacement pointers
placed into **xVector**, **yVector**. Returns 1 for **iz** out if range or no warp file.

Returns the size of the warping grid for section **iz** of the current warp file, or the
maximum size of all grids in the file if **iz** < 0. Returns the size in X and Y into
**nxMax**, **nyMax**, and the total number of elements in the grid in **prodMax**. Returns
1 for **iz** out of range or no warping file.

Returns all positional parameters of the warping grid for section **iz** of the current
warp file: number of elements in **nxGrid** and **nyGrid**, starting coordinate in
**xStart**, **yStart**, and spacing between points in **xInterval** and **yInterval**.
Returns 1 for no warp file or **iz** out of range.

Sets the parameters for a grid to be interpolated from a set of control points for
section **iz** of the current warp file. **nxGrid**, **nyGrid** set the number of elements
in X and Y, **xStart**, **yStart** set the starting position, and **xInterval**,
**yInterval** set the intervals between points. Returns 1 if **iz** is out of range,
there is no warping file, or the warping file does not contain control points.

Returns the range of the control points for section **iz** of the current warp file,
with the X range in **xmin** and **xmax** and the Y range in **ymin** and **ymax**. Returns 1
if **iz** is out of range, there is no warping file, or the warping file does not
contain control points.

Computes a spacing between the control points on section **iz** of the current warp file.
Finds the distance to the nearest neighboring point for each point, then finds the
percentile point of this distribution requested in **percentile** (a value between 0
and 1), and returns that distance in **spacing**. If **percentile** is < 0, a value of
0.5 will be used to obtain the median. Returns 1 for no warp file, a warp
file not containing control points, **iz** or **percentile** out of range, or fewer than
2 control points.

Sets the grid size for an interpolated grid from the spacing between control points
for section **iz** of the current warp file. Calls controlPointSpacing to find the
given **percentile** value of the spacing between nearest neighboring control points, and
multiplies this spacing by the value in **factor** to get the interval of the grid.
If **percentile** is < 0, a value of * 0.5 will be used to obtain the median. If
**factor** <0, a default value of 0.25 will be used. The grid is set up over the range
of the control points unless **fullExtent** is nonzero, * in which case it is set up
over the full extent of the image. Returns 1 for an error:
**iz** out of range, no current warp file or no control points,
**percentile** > 1, or **factor** is not < 0 or between 0.05 and 2.

Returns a warping grid for section **iz** of the current warp file. The size of the
grid is returned into **nxGrid**, **nyGrid**, the starting position in **xStart**,
**yStart**, and the intervals in **xInterval**, **yInterval**. The vectors are returned
into the 2D arrays **dxGrid**, **dyGrid** using the X dimension given in **xdim**. If
**xdim** is <= 0, it will be set to **nxGrid** and data will be packed sequentially. For a
file of warping grids, the grid is returned directly; for a file of control points,
the grid is found by interpolation. Returns 1 for error if **iz** is out of range, there
is no warping file, or, for a file of control points, the grid parameters are not
defined, there are fewer than 3 control points, or a memory allocation fails.

Extracts the linear transform embedded in the warping for section **iz** of the current
warp file, modifies the vectors to remove this transform, and combines the transform
with the linear transform for this section. Returns 1 for no warp file, section out of
range, not an inverse warp file, fewer than 3 control or grid points, or a memory
error.

Returns a value from one position in a 2D warping grid.

**x**, **x** is the position in the grid

**dxGrid**, **dyGrid** are the grid arrays, with first dimension **ixgDim**

**nxGrid**, **nyGrid** are the number of grid points in X and Y

**xGridStart**, **yGridStart** are coordinates at which the grid starts

**xGridIntrv**, **yGridIntrv** are the spacing between grid points in X and Y

**dx** and **dy** are returned with the interpolated values at the given position.

Finds the point that a grid maps to **x**, **y** by iteration. Returns the coordinates
of that point in **xnew**, **ynew** (which can be the same as **x**, **y**) and the
interpolated grid values at that point in **dx** and **dy**. Grid parameters are the same
as in interpolateGrid.

Finds the inverse of a warping consisting of a linear transform in **xform** followed
by a grid of inverse warp displacements in **dxGrid**, **dyGrid**. The center of transform
is specified in **xcen**, **ycen**. The linear component of the inverse is returned in
**xfInv** and the inverse warp displacements of the inverse are returned in **dxInv**,
**dyInv**. **rows** specifies the number of rows of the transform (2 or 3; omitted when
calling from Fortran). Grid parameters are the same as in interpolateGrid.

Multiply two warp transforms together. Each warping is specified by a linear
transform applied first, and the inverse of warp displacement vectors. The warp
transform applied first has its linear component in **xform1** and has displacements in
arrays **dxGrid1** and **dyGrid1**, with **nxGrid1** by **nyGrid1** elements and an X
dimension of **ixgDim1**. The grid starts at **xStart1**, **yStart1** and has intervals in X
and Y of **xIntrv1** and **yIntrv1**. The warp transform applied second is specified by
the corresponding arguments ending in 2. The center of transformation is given by
**xcen**, **ycen**. Set **useSecond** nonzero to make an output grid whose parameters match
that of the second input grid rather than the first. The number of rows of the
linear transforms is specified in **rows** (2 or 3, omit when calling from Fortran).
The output warp grid is returned in **dxProd**, **dyProd** and the linear transform is
returned in **xfProd**. The second warp grid may be omitted by setting **nxGrid** to zero,
but the first warp grid must exist. Returns 1 for memory or other errors.

Extracts the linear transform embedded in a set of positions and vectors, and modifies
the vectors to remove the transform. The positions of **nPoints** points are in **xPos**,
**yPos** and the X and Y displacements are in **xVector** and **yVector**. The center for
transformations is **xcen**, **ycen**. The modified vectors are returned in **newXvec** and
**newYvec**, which can be the same as **xVector** and **yVector**. The inverse of the
embedded transform is returned in **xfinv** with the number of rows specified in **rows**.
Returns 1 for a memory allocation error, fewer than 3 points, or **rows** not 2 or 3.

Extrapolates a grid from locations marked as solved to those not marked. The grid
of X and Y displacements is in **dxGrid** and **dyGrid**. **solved** is an corresponding
array with 0 for a location to be fille din, and 1 for a location with a vector.
The X dimension of **dxGrid**, **dyGrid**, and **solved** is given by **xdim**. **solved** must
be six times the size of this array (6 * xdim * nyGrid) in order to be used for
temporary storage. The number of grid elements in X and Y is given by **nxGrid** and
**nyGrid**; the intervals between grid points in X and Y are given by **xInterval** and
**yInterval**. If **reuse** is non-zero, it uses stored information about how to
extrapolate from the last grid analyzed; this should only be done if the the last grid
had the identical pattern of solved locations. Some of this information is stored in
the **solved** array and the rest is stored in arrays that are always kept, until
extrapolateDone is called. Returns 1 for a memory allocation error or an attempt to
reuse when there is no stored data.

Frees the arrays used by extrapolateGrid

Expand a grid to a larger area by shifting it and then extrapolating it with
extrapolateGrid.

**dxGrid**, **dyGrid** - grid arrays with displacements in X and Y

**xdim**, **ydim** - X and Y dimensions of arrays

**nxGrid**, **nyGrid** - call with original number of grid points in X and Y, returned
with new number

**xStart**, **yStart** - Starting X and Y coordinates of grid, returned with new values

**xInterval**, **yInterval** - Spacing between points in X and Y

**xBigStr**, **yBigStr** - Starting X and Y coordinates of larger area

**xBigEnd**, **yBigEnd** - Ending X and Y coordinates of larger area

**ixmin**, **ixmax** - limiting coordinates in X; grid will not go outside this

**iymin**, **iymax** - limiting coordinates in X; grid will not go outside this

The new area covered by the grid will be at least as large as the larger area, unless
that would make a grid point be out of bounds. Returns 1 for memory error.

Attempts to open a transform file in **filename** as a warping file and performs basic
checks on it. Set **needDist** to 1 if the file must be a distortion field file with
an inverse transform grid, or **needInv** to 1 if a warping file must contain inverse
transforms. The return value is a warping file index, -1 for a linear transform file,
or -2 for an error. In case of an error, **errString** is filled with an error message;
**lenString** is the size of **errString** (omitted when calling from Fortran). For a
warping file, returns the image size in **nx**, **ny**. number of sections in **nz**,
binning of images in **ibinning**, pixel size in **pixelSize**, and flags in **iflags**.

Determines the maximum grid size needed in X and Y for all of the transforms in the
current warping file. Set the needed minimum and maximum
X and Y coordinates to be composed in **xmin**, **xmax**, **ymin**, and **ymax**. The number
of control points, or 4 for a grid, is returned in **nControl**, which must be allocated
before calling. The maximum grid sizes in X amd Y are returned in **maxNxg** and
**maxNyg**. Returns -2 for an error and places an error message in **errString**;
**lenString** is the size of **errString** (omitted when calling from Fortran).

Gets a warping grid for section **iz** of the current warping file, expanded to fill
the needed area and adjusted for size changes and offsets.

**xnbig, ynbig** - Size of the needed area, in warp file coordinates

**xOffset**, **yOffset** - Offset of needed area from the image used to get the warping

**adjustStart** - Set to 1 to have starting coordinates adjusted for difference in size
and for the offset, and to have the grid vectors adjusted for the offset too

**warpScale** - Scaling between input image pixel size and warp file pixel size

**iBinning** - Binning of pixels for output. Vectors, starts, and intervals will be all
be multiplied by **warpScale** / **iBinning**

**nxGrid**, **nyGrid** - Number of positions in returned grid in X and Y

**xGridStrt**, **yGridStrt** - Returned starting coordinate of grid

**xGridIntrv**, **yGridIntrv** - Returned interval between grid points

**fieldDx**, **fieldDy** - Grid of displacements in X and Y

**ixgDim**, **iygDim** - Dimensions of grid arrays in X and Y

Returns -2 for an error and places an error message in **errString**, whose size should
be supplied in **lenString** (but not when calling from Fortran).

Corrects for a distortion field and then applies a linear transformation, or applies a linear transformation then a warping field, using cubic or linear interpolation.

**array** - The input image array

**bray** - The output image array

**nxa,nya** - The dimensions of **array**

**nxb,nyb** - The dimensions of **bray**

**amat** - A 2x2 matrix to specify rotation,scaling,skewing

**xc,yc** - The coordinates of the center of ARRAY

**xt,yt** - The translation to add in the linear transformation

**scale** - A multiplicative scale factor for the intensities

**dmean** - Mean intensity of image, or value to fill edges with

**linear** - Set greater than zero to do linear interpolation, or less than zero for
nearest neighbor interpolation

**linFirst** - Set non-zero to do linear transformation before warping

**dxGrid, dyGrid** - Grid of distortion displacements in X & Y;
each value is the shift to get from a desired position in the
undistorted or warped image to the corresponding position in the original image

**ixgDim** - The first dimension of **dxGrid** and **dyGrid**

**xGridStrt, yGridStrt** - Coordinates at which grid starts in output image

**xGridIntrv, yGridIntrv** - Spacing between grid points in X & Y

**nxGrid, nyGrid** - Number of grid points in X & Y

The linear transformation is done as:

Xo = a11(Xi - Xc) + a12(Yi - Yc) + NXB/2. + XT

Yo = a21(Xi - Xc) + a22(Yi - Yc) + NYB/2. + YT

where X coordinates run from 0 at the left edge of the first pixel
to **nxa** at the right edge of the last pixel, etc.

When calling from C, indices in **amat** are transposed: a11 = amat[0][0],
a12 = amat[1][0], a21 = amat[0][1], a22 = amat[1][1]

To call from Fortran, use arguments of the same type and in the same order.
Indices in **amat** are in logical order: a11 = amat(1,1), a12 = amat(1,2),
etc.

Both undistorting and warping are parallelized with OpenMP.

Makes a distortion field array with the shifts based on a mag gradient.

**gradDx**, **gradDy** are the arrays returned with the X and Y shifts at each location

**idfDx**, **idfDy** are arrays used for temporary storage

All of these are dimensioned **lmGrid** x **lmGrid**

**imageNx** and **imageNy** are the image size that gradients are being applied to.

**xGridStrt**, **yGridStrt** are coordinates at which the grid starts

**xGridIntrv**, **yGridIntrv** are the spacing between grid points in X & Y

**nxGrid**, **nyGrid** are the number of grid points in X & Y

**xcen**, **ycen** is the center coordinate for the mag and rotation changes

**pixelSize** is the pixel size in Angstroms

**axisRot** is the rotation of the tilt axis from the vertical

**tilt** is the tilt angle

**dmagPerUm** is the percent change in magnification per micron of Z

**rotPerUm** is the rotation in degrees per micron of Z height

Computes the shifts from a mag gradient at one point.

**xx**, **yy** is the coordinate of the point

**imageNx** and **imageNy** are the image size that gradients are being applied to.

**xcen**, **ycen** is the center coordinate for the mag and rotation changes

**pixelSize** is the pixel size in Angstroms

**axisRot** is the rotation of the tilt axis from the vertical

**tilt** is the tilt angle

**dmagPerUm** is the percent change in magnification per micron of Z

**rotPerUm** is the rotation in degrees per micron of Z height

**dx**, **dy** are returned with the shifts