static _computeImageryCoverages(
    imageryLayer,
    imageryRange,
    imageryLevel,
    nativeInputRectangle,
    computeClippedImageryRectangle,
  ) {
    const imageryCoverages = [];

    for (let i = imageryRange.minX; i <= imageryRange.maxX; i++) {
      const clippedImageryRectangleU = computeClippedImageryRectangle(
        i,
        imageryRange.maxY,
        imageryLevel,
      );

      if (!defined(clippedImageryRectangleU)) {
        continue;
      }

      for (let j = imageryRange.minY; j <= imageryRange.maxY; j++) {
        const clippedImageryRectangleV = computeClippedImageryRectangle(
          i,
          j,
          imageryLevel,
        );

        if (!defined(clippedImageryRectangleV)) {
          continue;
        }

        const textureCoordinateRectangle =
          ImageryCoverage._localizeToCartesianRectangle(
            clippedImageryRectangleV,
            nativeInputRectangle,
            undefined,
          );

        // Note: The getImageryFromCache function will create the whole "chain"
        // of ancestor imageries, up to the root, and increases the reference
        // counter for each of them, even though it is not called
        // getImageryFromCacheAndCreateAllAncestorsAndAddReferences.
        // There is currently no way to have a single imagery, because
        // somewhere in TileImagery, the parent is assumed to be present.
        const imagery = imageryLayer.getImageryFromCache(i, j, imageryLevel);
        const imageryCoverage = new ImageryCoverage(
          i,
          j,
          imageryLevel,
          textureCoordinateRectangle,
          imagery,
        );
        imageryCoverages.push(imageryCoverage);
      }
    }
    return imageryCoverages;
  }
Computes the <code>ImageryCoverage</code> objects that describe the imagery and
the texture coordinates that are contained in the given range of
imagery tile coordinates, referring to the given input rectangle.

@param {ImageryLayer} imageryLayer The imagery layer
@param {CartesianRectangle} imageryRange The range of imagery tile coordinates
@param {number} imageryLevel The imagery level
@param {Rectangle} nativeInputRectangle The input rectangle, in coordinates
that are native for the tiling scheme
@param {Function} computeClippedImageryRectangle A function that returns
an imagery rectangle, based on (x, y, level), clipped to the imagery bounds
(or undefined if there is no intersection between the imagery rectangle
and the bounds)
@returns {ImageryCoverage[]} The objects describing the covered imagery
and the respective texture coordinates