Get a single value in a position of the raster.

@param coordinate the coordinate in which the value is read.
@return the value read in the given coordinate.
1024
public double getValueAt( Coordinate coordinate ) {
        if (geodata == null) {
            throw new IllegalArgumentException("The data have first to be read!");
        }
        int[] coordinateToNearestRowCol = GrassLegacyUtilities.coordinateToNearestRowCol(inWindow, coordinate);
        if (coordinateToNearestRowCol != null) {
            int row = coordinateToNearestRowCol[0];
            int col = coordinateToNearestRowCol[1];
            if (row > 0 && row < geodata.length) {
                if (col > 0 && col < geodata[0].length) {
                    return geodata[row][col];
                }
            }
        }
        return HMConstants.doubleNovalue;
    }
794936
private double getValue(final double x, final double y, final double z,
            final Axis axis) {
        switch (axis) {
            case X:
                return x;
            case X_INVERTED:
                return -x;
            case Y:
                return y;
            case Y_INVERTED:
                return -y;
            case Z:
                return z;
            case Z_INVERTED:
                return -z;
            default:
                throw new IllegalArgumentException("Unsupported axis.");
        }
    }
718975
public Long getRelativePosition(Long position) {
		long relativePosition = 0L;
		for (Location location : locations) {
			if (location instanceof RemoteLocation) {
				relativePosition += location.getLength();
			} else {
				if (position < location.getBeginPosition()
						|| position > location.getEndPosition()) {
					relativePosition += location.getLength();
				} else {
					if (location.isComplement()) {
						relativePosition += (location.getEndPosition()
								- position + 1);
					} else {
						relativePosition += (position
								- location.getBeginPosition() + 1);
					}
					if (isComplement()) {
						relativePosition = getLength() - relativePosition + 1;
					}
					return relativePosition;
				}
			}
		}
		return null;
	}
166223
public ByteBuffer getValue(int index) throws IOException {
        if (index >= structure.valueSizes.size()) {
            throw new IOException("Index " + index + " is out of range.");
        }
        int length = structure.valueSizes.get(index);
        return ByteBuffer.wrap(value, structure.valueByteOffsets.get(index), length).asReadOnlyBuffer();
    }
452330
public T getValue(Object key) {
        Rsp<T> rsp=get(key);
        return rsp != null? rsp.getValue() : null;
    }
622638
public Object getValueByPosition(Integer position) throws NoSuchFieldException {
        String name = null;
        Object value = null;

        name = this.getNameByPosition(position);

        if (name != null) {
            value = this.getValue(name);
        } else {
            throw new NoSuchFieldException();
        }

        return value;
    }
591459
public Image getSprite(int x, int y) {
		target.init();
		initImpl();

		if ((x < 0) || (x >= subImages.length)) {
			throw new RuntimeException("SubImage out of sheet bounds: "+x+","+y);
		}
		if ((y < 0) || (y >= subImages[0].length)) {
			throw new RuntimeException("SubImage out of sheet bounds: "+x+","+y);
		}

		return target.getSubImage(x*(tw+spacing) + margin, y*(th+spacing) + margin,tw,th); 
	}
695604
public static double getValue( GridCoverage2D raster, double easting, double northing ) {
        double[] values = null;
        try {
            values = raster.evaluate(new Point2D.Double(easting, northing), (double[]) null);
        } catch (Exception e) {
            return doubleNovalue;
        }
        return values[0];
    }
653303
public E get(int index)
    {
        lock.readLock().lock();
        try
        {
            if (index >= size)
                return null;

            index++;
            int c = 0;
            Node<E> finger = head;
            for (int i = maxHeight - 1 ; i >= 0 ; i--)
            {
                while (c + finger.size[i] <= index)
                {
                    c += finger.size[i];
                    finger = finger.next(i);
                }
            }

            assert c == index;
            return finger.value;
        }
        finally
        {
            lock.readLock().unlock();
        }
    }
1189792
public float get(Layout.Axis axis) {
        switch (axis) {
            case X:
                return x;
            case Y:
                return y;
            case Z:
                return z;
            default:
                throw new RuntimeAssertion("Bad axis specified: %s", axis);
        }
    }
1315838
public org.tensorflow.framework.Summary.ValueOrBuilder getValueOrBuilder(
      int index) {
    return value_.get(index);
  }
604232
public SDVariable get(SDIndex... indices) {
        int ndims = indices.length;
        long[] begin = new long[ndims];
        long[] end = new long[ndims];
        long[] strides = new long[ndims];
        int[] begin_mask_arr = new int[ndims];
        int[] end_mask_arr = new int[ndims];
        int[] shrink_axis_mask_arr = new int[ndims];
        for (int i = 0; i < ndims; i++) {
            strides[i] = 1;
            SDIndex index = indices[i];
            SDIndex.IndexType indexType = index.getIndexType();
            if (indexType == SDIndex.IndexType.ALL) {
                begin_mask_arr[i] = 1;
                end_mask_arr[i] = 1;
            } else if (indexType == SDIndex.IndexType.POINT) {
                long pointIndex = index.getPointIndex();
                begin[i] = pointIndex;
                end[i] = pointIndex + 1;
                if(!index.isPointKeepDim()) {
                    shrink_axis_mask_arr[i] = 1;
                }
            } else if (indexType == SDIndex.IndexType.INTERVAL) {
                if (index.getIntervalBegin() == null) {
                    begin_mask_arr[i] = 1;
                } else {
                    begin[i] = index.getIntervalBegin();
                }
                if (index.getIntervalEnd() == null) {
                    end_mask_arr[i] = 1;
                } else {
                    end[i] = index.getIntervalEnd();
                }
                if (index.getIntervalStrides() == null) {
                    strides[i] = 1;
                } else {
                    strides[i] = index.getIntervalStrides();
                }
            }
        }

        // convert binary int[] to int
        int begin_mask = binArrToInt(begin_mask_arr);
        int end_mask = binArrToInt(end_mask_arr);
        int shrink_axis = binArrToInt(shrink_axis_mask_arr);

        return this.sameDiff.stridedSlice(this, begin, end, strides,
                begin_mask, end_mask, 0, 0, shrink_axis);
    }
11232
public boolean get(long index) {
    if (!(index < size))
      throw new IndexOutOfBoundsException();
    return (bytes.readLong(offset(index)) & (1l << (position(index)))) != 0;
  }
440927
public Object get (int index)
    {
        return _list[(_lastPos-index-1+_list.length)%_list.length];
    }
1245155
public int getLine(int pos) {
	for (int i = 0; i < lines.length; i++) {
	    if (pos <= lines[i].intValue()) return i + 1;
	}
	return lines.length;
    }
1147868
public void get1Value(int index, float[] valueDestination) {
        try {
            SFVec3f sfVec3f = value.get(index);
            valueDestination[0] = sfVec3f.x;
            valueDestination[1] = sfVec3f.y;
            valueDestination[2] = sfVec3f.z;
        }
        catch (IndexOutOfBoundsException e) {
            Log.e(TAG, "X3D MFVec3f get1Value(index) out of bounds." + e);
        }
        catch (Exception e) {
            Log.e(TAG, "X3D MFVec3f get1Value(index) exception " + e);
        }
    }
177456
public org.tensorflow.framework.Summary.Value getValue(int index) {
    return value_.get(index);
  }