A raster outline occupies a rectangle bounded on the lower left by the origin, having coordinates (say) (x0, y0), and on the upper right by (x1, y1): these are properties easily discovered of any raster. You can use this information to move any points outside the raster's extent onto the nearest point on the raster's boundary and extract the raster values at the new locations.
Tasks like this are often readily worked out by considering lower dimensions. A one-dimensional raster's extent is just an interval of numbers, say from x0 to x1 > x0, conventionally written [x0,x1]. Suppose you want to find the nearest point in this interval to a given number x. There are three cases: x < x0 (x is to the left), x0 <= x <= x1 (x is in the interval), and x1 < x (x is to the right). Clearly the nearest points are x0, x, and x1, respectively. A formula for this result is
x --> min(max(x,x0),x1),
as you can see by contemplating each of the three cases separately.
Because the extent of a raster is the Cartesian product of two intervals, [x0,x1] * [y0,y1], the same formula works in two dimensions. Just apply it to each interval. Thus the projected point's coordinates can be computed (in a Field Calculator, say) as
(x,y) --> ( min(max(x,x0),x1), min(max(y,y0),y1 ).
Here is this formula in action with 100 points randomly placed around and within a grid's extent:
The dashed lines visually associate points outside the extent to the locations where they will be moved.
Create a point layer from these computed coordinates and apply the Sample tool to extract the raster values. Join the results back to the original point layer.
As a practical matter, to avoid problems with floating point roundoff that might keep the new points from lying within the grid's extent, it would be wise to make x0 and y0 slightly bigger than the true origin (you might add half the cellsize to them) and, similarly, make x1 and y1 slightly smaller.
In summary, the workflow consists of calculating two fields (the new coordinates) in the original point layer's table, creating a point event layer from those new coordinates, running the Sample tool, and performing a database join (not a spatial join).
When you have many more vector points than there are cells in the raster, you should prefer the solution given by @celenius (who proposes converting the raster to points and using a spatial join). Normally, though, rasters have lots of cells--millions to billions--and the conversion to points is so time-consuming and disk-consuming that it should be approached with caution.
Alternatively, you could expedite Celenius' solution by using a raster calculation to make an integer grid with values only along its boundary. Converting that to a point layer is quick and easy because it will have few points. Let's call this the "boundary layer." Sample the grid at the boundary layer points, thereby copying the grid values into the boundary layer's attribute table. After running Sample with the original point layer, remove all points where a sample was successfully obtained. Spatially join the boundary layer to the remaining points to complete the sampling process.
(One way to make a grid with values only along its boundary is to apply a focal neighborhood operation that fails along the boundary: examples include finding slopes, hillshading, 3 x 3 neighborhood focal stats. This creates a grid with a one-cell-thick ring of NoData around its edge. Using IsNull and SetNull to detect NoData cells and convert between NoData and data cells produces a grid full of NoData values except around the boundary.)
You can calculate an incrementing ID based on the row and column numbers which will uniquely identify the cell that the points are in.
Add a column to your point feature class named CELLID (type = long integer).
In the field calculator, select the python parser, tick the show code-block box and in the pre-logic script code section enter:
import arcpy
def calc_cell_id(shape, raster):
raster = arcpy.Raster(raster)
xmin = raster.extent.XMin
ymax = raster.extent.YMax
px = raster.meanCellWidth
py = raster.meanCellHeight
ncols = raster.width
col = int(abs((xmin - shape.getPart(0).X) / px))
row = int(abs((ymax - shape.getPart(0).Y) / -py))
id = row * ncols + col + 1
return id
In the "CELLID = " section enter:
calc_cell_id( !SHAPE!, "NAME_OF_YOUR_RASTER_LAYER")
For example:
To create a raster with the same values, open the ArcMap python window and enter the following:
raster = arcpy.Raster("NAME_OF_YOUR_RASTER_LAYER")
arcpy.env.extent = raster
arcpy.env.mask = raster
arcpy.env.cellSize = raster
arcpy.env.extent = raster
ncols = raster.width
arcpy.gp.singleoutputmapalgebra("$$ROWMAP * %s + $$COLMAP + 1" % ncols, "path/to/save/your/output_unique_id_raster")
Best Answer
In ArcGIS 10 you can use the Lookup tool (requires a Spatial Analyst license though) which is used to create a new raster based on the value in the attribute table of another raster.