function YZWMS(options) {
  options = Cesium.defaultValue(options, Cesium.defaultValue.EMPTY_OBJECT);
  var mapServerUrl = options.url;

  var resourceUrl =
    mapServerUrl + "/WMTS?request=GetTile&Version=1.0.0&Service=WMTS";
  var resource = Cesium.Resource.createIfNeeded(resourceUrl);
  resource.appendForwardSlash();

  this._resource = resource;
  this._tileWidth = Cesium.defaultValue(options.tileWidth, 256);
  this._tileHeight = Cesium.defaultValue(options.tileHeight, 256);
  this._maximumLevel = 20;
  this._tilingScheme = Cesium.defaultValue(
    options.tilingScheme,
    new Cesium.GeographicTilingScheme({ ellipsoid: options.ellipsoid })
  );
  this._rectangle = Cesium.defaultValue(
    options.rectangle,
    this._tilingScheme.rectangle
  );
  this._layer = options.layer;
  this._style = options.style;
  this._format = "image/png";
  this.enablePickFeatures = Cesium.defaultValue(
    options.enablePickFeatures,
    true
  );
  this._ready = false;
  this._readyPromise = Cesium.when.defer();
}

function pixels2Meters(p, zoom) {
  return Double(p) * resolution(zoom) - originShift;
}
function titleBoundsBy(x, y, zoom) {
  let minX = pixels2Meters(x * titleSize, zoom);
  let maxY = -pixels2Meters(y * titleSize, zoom);
  let maxX = pixels2Meters((x + 1) * titleSize, zoom);
  let minY = -pixels2Meters((y + 1) * titleSize, zoom);

  return "(minX),(minY),(maxX),(maxY)";
}
function resolution(zoom) {
  return (2 * Math.PI * 6378137) / 256 / Math.pow(2.0, zoom);
}
function resolutionPoint(width, height, z) {
  var s = (2 * Math.PI * 6378137) / 256 / Math.pow(2, z);
  return [
    width * s - (2 * Math.PI * 6378137) / 2,
    height * s - (2 * Math.PI * 6378137) / 2
  ];
}
function requestImage(imageryProvider, col, row, level, request, interval) {

  var labels = imageryProvider._tileMatrixLabels;
  var tileMatrix = Cesium.defined(labels) ? labels[level] : level.toString();
  var subdomains = imageryProvider._subdomains;
  var staticDimensions = imageryProvider._dimensions;
  var dynamicIntervalData = Cesium.defined(interval)
    ? interval.data
    : undefined;

  var resource;

  var x = col;
  var y = row;
  var z = level;
  y = Math.pow(2, z) - y - 1;
  var minPoint = resolutionPoint(x * 256, y * 256, z);
  var maxPoint = resolutionPoint((x + 1) * 256, (y + 1) * 256, z);
  var bbox =
    minPoint[0] + "," + minPoint[1] + "," + maxPoint[0] + "," + maxPoint[1];

  // build KVP request
  var query = {};
  // query.tilematrix = tileMatrix;
  // query.tilerow = row;
  // query.tilecol = col;
  query.bbox = bbox;
  query.layer = imageryProvider._layer;
  query.style = imageryProvider._style;
  query.format = imageryProvider._format;

  if (Cesium.defined(staticDimensions)) {
    query = Cesium.combine(query, staticDimensions);
  }

  if (Cesium.defined(dynamicIntervalData)) {
    query = Cesium.combine(query, dynamicIntervalData);
  }
  resource = imageryProvider._resource.getDerivedResource({
    queryParameters: query,
    request: request
  });

  return Cesium.ImageryProvider.loadImage(imageryProvider, resource);
}
function YZWMS_buildImageResource(imageryProvider, x, y, level, request) {
  var resource;
  if (imageryProvider._useTiles) {
    resource = imageryProvider._resource.getDerivedResource({
      url: "tile/" + level + "/" + y + "/" + x,
      request: request
    });
  } else {
    var nativeRectangle = imageryProvider._tilingScheme.tileXYToNativeRectangle(
      x,
      y,
      level
    );
    var bbox =
      nativeRectangle.west +
      "," +
      nativeRectangle.south +
      "," +
      nativeRectangle.east +
      "," +
      nativeRectangle.north;

    var query = {
      bbox: bbox,
      size: imageryProvider._tileWidth + "," + imageryProvider._tileHeight,
      format: "png32",
      transparent: true,
      f: "image"
    };

    query.bboxSR = 4326;
    query.imageSR = 4326;

    if (imageryProvider.layers) {
      query.layers = "show:" + imageryProvider.layers;
    }

    resource = imageryProvider._resource.getDerivedResource({
      url: "export",
      request: request,
      queryParameters: query
    });
  }

  return resource;
}
Object.defineProperties(YZWMS.prototype, {
  tileWidth: {
    get: function() {
      return this._tileWidth;
    }
  },
  tileHeight: {
    get: function() {
      return this._tileHeight;
    }
  },
  defaultAlpha: {
    get: function() {
      return 1;
    }
  },
  hasAlphaChannel: {
    get: function() {
      return true;
    }
  },
  maximumLevel: {
    get: function() {
      return this._maximumLevel;
    }
  },
  minimumLevel: {
    get: function() {
      return this._minimumLevel;
    }
  },
  tilingScheme: {
    get: function() {
      return this._tilingScheme;
    }
  },
  rectangle: {
    get: function() {
      return this._rectangle;
    }
  },
  ready: {
    get: function() {
      return true;
    }
  },
  usingPrecachedTiles: {
    get: function() {
      return this._useTiles;
    }
  },
  readyPromise: {
    get: function() {
      return this._readyPromise.promise;
    }
  },
  minimumTerrainLevel: {
    get: function() {
      return 0;
    }
  },
  maximumTerrainLevel: {
    get: function() {
      return 17;
    }
  }
});
YZWMS.prototype.requestImage = function(x, y, level, request) {
  if (!this._ready) {
  }

  var result;
  var currentInterval;

  // Couldn't load from cache
  if (!Cesium.defined(result)) {
    result = requestImage(this, x, y, level, request, currentInterval);
  }

  return result;
};

YZWMS.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
  if (!this._ready) {
  }

  if (!this.enablePickFeatures) {
    return undefined;
  }

  var rectangle = this._tilingScheme.tileXYToNativeRectangle(x, y, level);

  var horizontal;
  var vertical;
  var sr;
  if (this._tilingScheme.projection instanceof GeographicProjection) {
    horizontal = CesiumMath.toDegrees(longitude);
    vertical = CesiumMath.toDegrees(latitude);
    sr = "4326";
  } else {
    var projected = this._tilingScheme.projection.project(
      new Cartographic(longitude, latitude, 0.0)
    );
    horizontal = projected.x;
    vertical = projected.y;
    sr = "3857";
  }

  var layers = "visible";
  if (defined(this._layer)) {
    layers += ":" + this._layer;
  }

  var query = {
    f: "json",
    tolerance: 2,
    geometryType: "esriGeometryPoint",
    geometry: horizontal + "," + vertical,
    mapExtent:
      rectangle.west +
      "," +
      rectangle.south +
      "," +
      rectangle.east +
      "," +
      rectangle.north,
    imageDisplay: this._tileWidth + "," + this._tileHeight + ",96",
    sr: sr,
    layers: layers
  };

  var resource = this._resource.getDerivedResource({
    url: "identify",
    queryParameters: query
  });

  return resource.fetchJson().then(function(json) {
    var result = [];

    var features = json.results;
    if (!defined(features)) {
      return result;
    }

    for (var i = 0; i < features.length; ++i) {
      var feature = features[i];

      var featureInfo = new ImageryLayerFeatureInfo();
      featureInfo.data = feature;
      featureInfo.name = feature.value;
      featureInfo.properties = feature.attributes;
      featureInfo.configureDescriptionFromProperties(feature.attributes);

      // If this is a point feature, use the coordinates of the point.
      if (feature.geometryType === "esriGeometryPoint" && feature.geometry) {
        var wkid =
          feature.geometry.spatialReference &&
          feature.geometry.spatialReference.wkid
            ? feature.geometry.spatialReference.wkid
            : 4326;
        if (wkid === 4326 || wkid === 4283) {
          featureInfo.position = Cartographic.fromDegrees(
            feature.geometry.x,
            feature.geometry.y,
            feature.geometry.z
          );
        } else if (wkid === 102100 || wkid === 900913 || wkid === 3857) {
          var projection = new WebMercatorProjection();
          featureInfo.position = projection.unproject(
            new Cartesian3(
              feature.geometry.x,
              feature.geometry.y,
              feature.geometry.z
            )
          );
        }
      }

      result.push(featureInfo);
    }

    return result;
  });
};