import { Array } from "../dataType/Array";
import { PrintObject } from "./PrintObject";
import { Projection } from "./Projection";
import { Number } from "../dataType/Number";
import { String } from "../dataType/String";
import { Boolean } from "../dataType/Boolean";
import { FeatureCollection } from "./FeatureCollection";
import { Reducer } from "./Reducer";
import { Geometry } from "./Geometry";
import { Dictionary } from "./Dictionary";
import { List } from "../dataType/List";
import { Kernel } from "./Kernel";
import * as turf from "@turf/turf";
import { Classifier } from "./Classifier";
import { Http } from "../Http";
import proj4 from "proj4";
import { Table } from "./Table";
/**
 * @class gve.Image
 * @since gve
 * @alias gve.Image
 */
export class Image extends PrintObject {
  /**
   * 加载影像
   * @hideconstructor
   * @param {String|number|number[]} [param] 影像的url或常数、常数列表
   * @returns gve.Image
   */
  constructor(args?: any) {
    super();
    this.type = "Image";
    if (!(this instanceof Image)) {
      return new Image(args);
    }
  }

  type: string = "Image";

  /**
   * 对图像执行云推断，获取二值tiff
   * @returns Image
   * @alias gve.Image.cloudinference
   */
  cloudinference() {
    return new Image();
  }

  /**
   * 矢量化栅格数据
   * @returns Image
   * @alias gve.Image.polygonize
   */
  polygonize() {
    return new Image();
  }

  /**
   * 切pbf
   * @returns {VectorTileService} Image
   * @alias gve.Image.localServeAsVectorTile
   */
  localServeAsVectorTile() {
    return new Image();
  }

  /**
   * 影像裁切，返回裁切后的影像
   * @param {Object} geometry  待裁切的影像
   * @returns Image
   * @alias gve.Image.clip
   */
  clip(geometry: Object) {
    if (!geometry) {
      console.log("clip 必须有一个geometry参数");
      return;
    }
    return new Image();
  }

  /**
   *  计算单张影像的归一化植被指数NDVI.
   *  @param {String|Image} [img] 待计算图像NDVI的url或者Image对象
   *  @return Image
   * @alias gve.Image.ndvi
   */
  ndvi(img?: string | Image) {
    return new Image();
  }

  /**
   *  计算单张影像的差值植被指数DVI。
   *  @return Image
   * @alias gve.Image.dvi
   */
  dvi() {
    return new Image();
  }

  /**
   *  计算单张影像的比值植被指数RVI
   *  @return Image
   * @alias gve.Image.rvi
   */
  rvi() {
    return new Image();
  }

  /**
   *  影像相加
   *  @param {Image|number} image2 Image对象或数值
   *  @return Image
   * @alias gve.Image.add
   */
  add(image2: Image | number | Number) {
    return new Image();
  }

  /**
   *  执行影像计算的表达式
   *  @param {String} expression 待执行的表达式，例如计算NDVI
   *  @param {any} map 用于表达式求值的映射。
   *  @returns Image
   * @alias gve.Image.expression
   */
  expression(expression: string, map: any) {
    return new Image();
  }
  /**
   *  计算单张影像的土壤调整植被指数SAVI
   *  @return Image
   * @alias gve.Image.savi
   */
  savi() {
    return new Image();
  }

  /**
   *  计算单张影像的增强型植被指数EVI
   *  @return Image
   * @alias gve.Image.evi
   */
  evi() {
    return new Image();
  }

  /**
   *  计算单张影像的绿光归一化差值植被指数GNDVI
   *  @return Image
   * @alias gve.Image.gndvi
   */
  gndvi() {
    return new Image();
  }

  /**
   *  计算单张影像的垂直植被指数PVI
   *  @return Image
   * @alias gve.Image.pvi
   */
  pvi() {
    return new Image();
  }

  /**
   *  影像相减
   *  @param {Image|number} image2 Image对象或数值
   *  @return Image
   * @alias gve.Image.subtract
   */
  subtract(image2: Image | number | Number) {
    return new Image();
  }

  /**
   *  影像相除
   *  @param {Image|number} image2 Image对象或数值
   *  @return Image
   * @alias gve.Image.divide
   */
  divide(image2: Image | number | Number) {
    return new Image();
  }

  /**
   *  将一个图像乘以另一个图像
   *  @param {Image|number} image2 Image对象或数值
   *  @return Image
   * @alias gve.Image.multiply
   */
  multiply(image2: Image | number | Number) {
    return new Image();
  }

  /**
   *  从lmage中选择特定的波段。
   *  @param { string | string[]} bands 指定要选择的波段
   *  @param { string[] } [newBandIds] 波段重命名, 可选参数
   *  @return Image
   * @alias gve.Image.select
   */
  select(bands?: string | string[], newBandIds?: string[]) {
    return new Image();
  }
  /**
   *  Image对应像素的正弦运算
   *  @return Image
   * @alias gve.Image.sin
   */
  sin() {
    return new Image();
  }

  /**
   *  Image对应像素的余弦运算
   *  @return Image
   * @alias gve.Image.cos
   */
  cos() {
    return new Image();
  }
  /**
   *  计算图像的正切值
   *  @return Image
   * @alias gve.Image.tan
   */
  tan() {
    return new Image();
  }

  /**
   *  计算图像的余切值
   *  @return Image
   * @alias gve.Image.sqrt
   */
  sqrt() {
    return new Image();
  }

  /**
   * 绝对值
   * @returns Image
   * @alias gve.Image.abs
   */
  abs() {
    return new Image();
  }

  /**
   *  Image对应像素的反正弦运算（默认为弧度）
   *  @return Image
   * @alias gve.Image.arcsin
   */
  arcsin() {
    return new Image();
  }
  /**
   *  计算图像的反余弦值
   *  @return Image
   * @alias gve.Image.arccos
   */
  arccos() {
    return new Image();
  }

  /**
   *  计算图像的反正切值
   *  @return Image
   * @alias gve.Image.arctan
   */
  arctan() {
    return new Image();
  }

  /**
   *  计算图像的双曲正弦值
   *  @return Image
   * @alias gve.Image.sinh
   */
  sinh() {
    return new Image();
  }

  /**
   *  计算图像的双曲余弦值
   *  @return Image
   * @alias gve.Image.cosh
   */
  cosh() {
    return new Image();
  }
  /**
   *  计算图像的双曲正切值
   *  @return Image
   * @alias gve.Image.tanh
   */
  tanh() {
    return new Image();
  }
  /**
   *  计算图像的反双曲正弦值
   *  @return Image
   * @alias gve.Image.arcsinh
   */
  arcsinh() {
    return new Image();
  }

  /**
   *  计算图像的反双曲余弦值
   *  @return Image
   * @alias gve.Image.arccosh
   */
  arccosh() {
    return new Image();
  }

  /**
   *  计算图像的反双曲正切值
   *  @return Image
   * @alias gve.Image.arctanh
   */
  arctanh() {
    return new Image();
  }

  /**
   *  向下取整
   *  @return Image
   * @alias gve.Image.floor
   */
  floor() {
    return new Image();
  }

  /**
   *  向上取整
   *  @return Image
   * @alias gve.Image.ceil
   */
  ceil() {
    return new Image();
  }
  /**
   *  对数
   *  @return Image
   * @alias gve.Image.log
   */
  log() {
    return new Image();
  }

  /**
   *  10为底的对数
   *  @return Image
   * @alias gve.Image.log10
   */
  log10() {
    return new Image();
  }
  /**
   *  获取影像原始投影信息
   *  @return Image
   * @alias gve.Image.projection
   */
  projection() {
    return new Projection();
  }
  /**
   *  将image重新投影到一个新的坐标系
   *  @param {String} crs 目标坐标参考系统(CRS)的已知文本(WKT)格式或项目字符串。
   *  @param {any[] | null} crsTransform 表示二维仿射变换矩阵的六个数字的数组。
   *  @param {Number | null} scale 如果指定了比例，则通过将指定的比例值除以指定的投影中仪表的标称尺寸来缩放投影。如果没有指定比例，则将使用给定投影的比例。
   *  @return Image
   * @alias gve.Image.reproject
   */
  reproject(crs: string, crsTransform?: any[] | null, scale?: Number | null) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
  重采样图像
  @param {Number} [factor=1] 采样因子，默认1，取值范围(0,2]
  @param {String} [mode="nearest"] 重采样算法，默认nearest，支持：nearest|bilinear|cubic|cubic_spline|lanczos|average|mode|gauss|max|min|med|q1|q3|sum|rm
  @return Image
   * @alias gve.Image.resample
  */
  resample(factor: number, mode: string) {
    return new Image();
  }
  /**
   *  更改图像数据类型
   *  @param {String} type 将数据类型更改为如 ( 'Byte', 'Int16', 'Float').
   *  @return Image
   * @alias gve.Image.changeType
   */
  changeType(type: string) {
    return new Image();
  }
  /**
   * 获取影像的统计直方图，数据统计是针对一景影像的所有波段的，每个波段一组统计结果
   * @param {Number|Array<Number>} [num] 可选参数，tif中的波段（通道）
   *  @param {number} [scale] 分辨率，可选参数，float，默认值300
   * @returns Object
   * @alias gve.Image.statistics
   */
  statistics(num?: number | Array<number> | Number, scale?: number) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new PrintObject();
  }
  /**
   *  计算多波段栅格对象的燃烧面积指数 (BAI)，并返回具有该指数值的栅格对象。
   *  @return Image
   * @alias gve.Image.bai
   */
  bai() {
    return new Image();
  }
  /**
   *  计算单张影像的裸土指数BSI。
   *  @return Image
   * @alias gve.Image.bsi
   */
  bsi() {
    return new Image();
  }
  /**
   *  计算单张影像的植被覆盖度指数（FVC）影像
   *  @return Image
   * @alias gve.Image.fvc
   */
  fvc() {
    return new Image();
  }
  /**
   *  计算单张影像的植被水分含量指数LSWI
   *  @param {Image} [image] 可选参数,影像
   *  @return Image
   * @alias gve.Image.lswi
   */
  lswi(image?: Image) {
    return new Image();
  }
  /**
   *  计算单张影像的改进的归一化水指数NDWI
   *  @return Image
   * @alias gve.Image.mndwi
   */
  mndwi() {
    return new Image();
  }
  /**
   *  计算单张影像归一化燃烧指数NBR
   *  @return Image
   * @alias gve.Image.nbr
   */
  nbr() {
    return new Image();
  }
  /**
   *  计算单张影像的改进的归一化建筑指数NDBI
   *  @return Image
   * @alias gve.Image.ndbi
   */
  ndbi() {
    return new Image();
  }
  /**
   *  计算单张影像的归一化差值雪指数NDSI
   *  @return Image
   * @alias gve.Image.ndsi
   */
  ndsi() {
    return new Image();
  }
  /**
   *  计算单张影像的归一化水指数NDWI
   *  @return Image
   * @alias gve.Image.ndwi
   */
  ndwi() {
    return new Image();
  }

  /**
   *  获取指定波段的最小值
   *  @param {Object} info 统计信息
   *  @param {String} band 波段名
   *  @param {String} id 通道名
   *  @return Number
   * @alias gve.Image.getMin
   */
  getMin(info: Object, band: string, id: string) {
    return new Number();
  }

  /**
   *  获取指定波段的最大值
   *  @param {Object} info 统计信息
   *  @param {String} band 波段名
   *  @param {String} id 通道名
   *  @return Number
   * @alias gve.Image.getMax
   */
  getMax(info: Object, band: string, id: string) {
    return new Number();
  }

  /**
   *  获取指定波段的直方图
   *  @param {Object} info 统计信息
   *  @param {String} band 波段名
   *  @param {String} id 通道名
   *  @return Array
   * @alias gve.Image.getHistogram
   */
  getHistogram(info: Object, band: string, id: string) {
    return new Array();
  }

  /**
   *  波段合成
   *  @param {String} band 需要合成的波段值
   *  @return Image
   * @alias gve.Image.compositeBands
   */
  compositeBands(band: string[] | string[][]) {
    return new Image();
  }

  /**
   *  制作训练数据
   *  @param {Object} args 采样的参数
   *  @return FeatureCollection
   * @alias gve.Image.sample
   */
  sample(args: Object) {
    return new FeatureCollection();
  }

  /**
   *  使用训练过的聚类器对输入进行聚类
   *  @param {Object} clusterer 聚类器
   *  @return Image
   * @alias gve.Image.cluster
   */
  cluster(clusterer: Object) {
    return new Image();
  }

  /**
   * 通过坐标文件获取影像
   * @param {String} path 文件路径
   * @param {number} [scale] 分辨率
   * @param {number} [nodata] 缺失值
   * @param {boolean} [reverse] 经纬度坐标顺序，默认为false，按照lon,lat,value顺序
   * @return Image
   * @alias gve.Image.fromXYZ
   */
  fromXYZ(
    path: string,
    scale?: number | Number,
    nodata?: number | Number,
    reverse?: boolean
  ) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
   * 统计计算指定区域geometry中最小值, 目前仅支持mix max, mean 三种方法
   * @param {Reducer} reducer Reducer实例，统计类型，包括最大值、最小值和求和
   * @param {Geometry} geometry Geometry实例，统计区域范围
   * @param {number} scale 缩放倍数
   * @param {Projection} [crs] 可选参数，使用的投影
   * @param {List} [crsTransform] 可选参数，投影变换值列表
   * @param {boolean} [bestEffort] 可选参数，确保使用更大比例计算更多像素成功
   * @param {number | Number} [maxPixels] 可选参数，reducer计算的最大像素值
   * @param {number | Number} [tileScale] 可选参数，调整tile尺寸的缩放系数，范围是0.1~16之间
   * @return Dictionary
   * @alias gve.Image.reduceRegion
   */
  reduceRegion(
    reducer: Reducer,
    geometry: Geometry,
    scale: number | Number,
    crs?: Projection,
    crsTransform?: List<any>,
    bestEffort?: boolean,
    maxPixels?: number | Number,
    tileScale?: number | Number
  ) {
    // if(scale){
    //   Http.scale = scale.toString();
    // }
    return new Dictionary();
  }

  /**
   * 对影像数据做与位运算
   * @param {Image|number} image2 Image类型或者整型
   * @param {number} [scale] 可选参数，分辨率，默认值300
   * @return Image
   * @alias gve.Image.bitwiseAnd
   */
  bitwiseAnd(image2: Image | number | Number, scale?: number | Number) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
   * 对影像数据做或位运算
   * @param {Image|number} image2 Image类型或者整型
   * @param {number} [scale] 可选参数，分辨率，默认值300
   * @return Image
   * @alias gve.Image.bitwiseOr
   */
  bitwiseOr(image2: Image | number | Number, scale?: number | Number) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
   * 对影像数据做异或位运算
   * @param {Image|number} image2 Image类型或者整型
   * @param {number} [scale] 可选参数，分辨率，默认值300
   * @return Image
   * @alias gve.Image.bitwiseXor
   */
  bitwiseXor(image2: Image | number | Number, scale?: number | Number) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
   * 对影像数据做非位运算
   * @param {number} [scale] 可选参数，分辨率，默认值300
   * @return Image
   * @alias gve.Image.bitwiseNot
   */
  bitwiseNot(scale?: number | Number) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
   * 获取指定区域tif数据，返回Image类型
   * @param {Geometry} geometry Geometry实例
   * @param {string} source 数据来源
   * @param {Object} options 指定分辨率、外扩等
   * @return Image
   * @tutorial gve.Image
   * @alias gve.Image.fromGeometry
   */
  static fromGeometry(geometry: Geometry, source: string, options: Object) {
    if (typeof geometry.gtype != "string" && (geometry as any).reference) {
      // console.log("不能直接计算")
      return new Image();
    }
    if (
      (geometry as any).gtype != "Polygon" &&
      (geometry as any).gtype != "MultiPolygon"
    ) {
      // window['httpp'].abortSubject$.next();
      throw new Error("geometry参数仅支持凸多边形");
    }

    return new Image();
  }

  /**
   * 获取指定区域tif数据，返回FeatureCollection类型
   * @param {Geometry} geometry Geometry实例
   * @param {string} source 数据来源
   * @param {Object} options 指定分辨率、外扩等
   * @return FeatureCollection
   * @tutorial gve.Image
   * @alias gve.Image.fromGeometryWithVector
   */
  static fromGeometryWithVector(
    geometry: Geometry,
    source: string,
    options: Object
  ) {
    if (typeof geometry.gtype != "string" && (geometry as any).reference) {
      // console.log("不能直接计算")
      return new FeatureCollection();
    }
    if (
      (geometry as any).gtype != "Polygon" &&
      (geometry as any).gtype != "MultiPolygon"
    ) {
      // window['httpp'].abortSubject$.next();
      throw new Error("geometry参数仅支持凸多边形");
    }
    let area = 0;
    if ((geometry as any).gtype == "Polygon") {
      let turfPolgyon = turf.polygon(geometry.coordinate);
      area = turf.area(turfPolgyon);
    }
    if ((geometry as any).gtype == "MultiPolygon") {
      let turfPolgyon = turf.multiPolygon((geometry as any).coordinate);
      area = turf.area(turfPolgyon);
    }
    let lastChar = source[source.length - 1];
    if (lastChar == "1" && area > 37000000) {
      //判断source的最后一个字符是1还是2，如果是1则geometry的面积不能超过37平方公里，否则报错
      // console.log("超过37平方公里", geometry)
      window["httpp"].abortSubject$.next();
      throw new Error("超出可计算范围");
    } else if (lastChar == "2" && area > 13000000) {
      // 如果是2则geometry的面积不能超过13平方公里，否则报错
      // console.log("超过13平方公里", geometry)
      window["httpp"].abortSubject$.next();
      throw new Error("超出可计算范围");
    }
    // console.log("符合面积要求")
    return new FeatureCollection();
  }

  /**
   * 影像像素相等运算 Image对应像素判断是否相等，返回一个类型为Byte的Image对象
   * @param {Image|number} image2 Image对象或数值
   * @return Image
   * @alias gve.Image.eq
   */
  eq(image2: number | Image | Number) {
    return new Image();
  }

  /**
   * 影像像素不相等运算
   * @param {Image|number} image2 Image对象或数值
   * @return Image
   * @alias gve.Image.neq
   */
  neq(image2: number | Image | Number) {
    return new Image();
  }

  /**
   * 影像像素小于运算
   * @param {Image|number} image2 Image对象或数值
   * @return Image
   * @alias gve.Image.lt
   */
  lt(image2: number | Image | Number) {
    return new Image();
  }

  /**
   * 影像数据小于等于运算
   * @param {Image|number} image2 Image对象或数值
   * @return Image
   * @alias gve.Image.lte
   */
  lte(image2: number | Image | Number) {
    return new Image();
  }

  /**
   * 影像像素大于运算
   * @param {Image|number} image2 Image对象或数值
   * @return Image
   * @alias gve.Image.gt
   */
  gt(image2: number | Image | Number) {
    return new Image();
  }

  /**
   * 影像像素大于等于运算
   * @param {Image|number} image2 Image对象或数值
   * @return Image
   * @alias gve.Image.gte
   */
  gte(image2: number | Image | Number) {
    return new Image();
  }

  /**
   * Image与运算，返回Image对象，如果两个image中的每个匹配波段对的两个值都非零，则返回1，输出像素的类型是布尔型的
   * @param {Image|number} image2 Image对象或数值
   * @return Image
   * @alias gve.Image.and
   */
  and(image2: number | Image | Number) {
    return new Image();
  }

  /**
   * Image或运算，返回Image对象
   * @param {Image|number} image2 Image对象或数值
   * @return Image
   * @alias gve.Image.or
   */
  or(image2: number | Image | Number) {
    return new Image();
  }

  /**
   * Image非运算，返回Image对象
   * @return Image
   * @alias gve.Image.not
   */
  not() {
    return new Image();
  }

  /**
   * Image对象波段重新命名
   * @param {string|string[]} var_args 波段名称或波段名称列表，如果是Array，则必须跟波段数一致
   * @return Image
   * @alias gve.Image.rename
   */
  rename(var_args: string | string[]) {
    return new Image();
  }

  /**
   * 添加波段 将一幅影像的波段添加到另一幅影像中
   * @param {Image} srcImg 包含被添加波段的影像
   * @param {string[]} [names] 可选参数，加入后影像名称列表，默认值null，表示用原来的名称
   * @param {boolean} [overwrite] 可选参数  如果要添加的波段已经存在是否覆盖，默认不覆盖
   * @return Image
   * @alias gve.Image.addBands
   */
  addBands(srcImg: Image, names?: string[], overwrite?: boolean) {
    return new Image();
  }

  /**
   * Image掩膜运算，返回一个Image对象
   * @param {Image} mask Image实例
   * @return Image
   * @alias gve.Image.updateMask
   */
  updateMask(mask: Image) {
    return new Image();
  }

  /**
   * 生成新地图影像对象，其每个像素的值是原图像像素的面积（单位，平方米）
   * @return Image
   * @alias gve.Image.pixelArea
   * @tutorial gve.Image
   */
  static pixelArea() {
    return new Image();
  }

  /**
   *   Image判断运算，满足condition条件的区域采用value下的值，不满足的部分采用image的值，返回结果为一个Image对象
   *  @param {Image} test Image对象，需要是一个0和1的二值图
   *  @param {Image|number} value Image对象或数值
   *  @return Image
   * @alias gve.Image.where
   */
  where(test: Image, value: Image | number | Number) {
    return new Image();
  }

  /**
   *  设置影像的属性值
   *  @param {string} var_args 属性名
   *  @param {any} val 属性值
   *  @return Image
   * @alias gve.Image.set
   */
  set(var_args: string, val: any) {
    return new Image();
  }

  /**
   *  获取影像的属性值
   *  @param {string} property 属性名
   *  @return object
   * @alias gve.Image.get
   */
  get(property: string): any {
    return new PrintObject();
  }

  /**
   *  返回影像的maskc
   *  @return Image
   * @alias gve.Image.mask
   */
  mask() {
    return new Image();
  }

  /**
   *  返回波段名称列表
   *  @return List
   * @alias gve.Image.bandNames
   */
  bandNames() {
    return new List();
  }

  /**
   *  对影像进行掩膜运算
   *  @param {number|Image} value 掩膜区域影像的替换值
   *  @return Image
   * @alias gve.Image.unmask
   */
  unmask(value: number | Image | Number): any {
    return new Image();
  }

  /**
   * 基于自然语言理解来计算影像的ndvi
   * @param {string} text_target 自然语言指令
   * @returns Image
   * @alias gve.Image.NLUCalculator
   */
  NLUCalculator(text_target: string) {
    return new Image();
  }

  /**
   * 将影像融合成为一张影像Image，返回最后一个有像素的Image对象
   * @param {string} [method] 选择影像镶嵌的方法，可选，"median|mean|max|min"，默认值median
   * @param {number} [scale] 分辨率，可选，默认300
   * @returns Image
   * @alias gve.Image.mosaic
   */

  mosaic(method?: string, scale?: number | Number) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
   * 返回Geometry对象
   * @returns Geometry
   * @alias gve.Image.geometry
   */
  geometry() {
    return new Geometry();
  }

  /**
   * 图像类型转换函数
   * @param {object} bandTypes 要转换的波段和类型
   * @param {string[]} bandOrder 返回波段的顺序
   * @returns Image
   * @alias gve.Image.cast
   */
  cast(bandTypes: object, bandOrder: string[]) {
    return new Image();
  }

  /**
   * 构建常数影像
   * @param {number|number[]} param 常数或常数列表
   * @returns Image
   * @alias gve.Image.constant
   */
  constant(param: number | number[] | Number) {
    return new Image();
  }

  /**
   * 构建常数影像
   * @param {number|number[]} param 常数或常数列表
   * @returns Image
   * @alias gve.Image.buildConstant
   */
  buildConstant(param: number | number[] | Number) {
    return new Image();
  }

  /**
   * 图像进行卷积操作
   * @param {Kernel} kernel Kernal算子
   * @returns Image
   * @alias gve.Image.convolve
   */
  convolve(kernel: Kernel) {
    return new Image();
  }

  /**
   * 影像邻域归约
   * @param {Reducer} reducer Reducer实例
   * @param {Kernel} kernel Kernal算子
   * @param {number} scale 分辨率
   * @returns Image
   * @alias gve.Image.reduceNeighborhood
   */
  reduceNeighborhood(reducer: Reducer, kernel: Kernel, scale: number | Number) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
   * 计算地图上某点的像素值
   * @param {Image} image Image实例
   * @param {number} x 经度
   * @param {number} y 纬度
   * @returns Object
   * @alias gve.Image.pixelValue
   */
  pixelValue(
    image: Image,
    x: number | Number | Number,
    y: number | Number | Number
  ) {
    return new PrintObject();
  }

  // /**
  //  * 下载影像
  //  * @returns Image
  //  */
  // forceLocal() {
  //   return new Image();
  // }

  /**
   * 超分运算
   * @returns Image
   * @alias gve.Image.super_resolution
   */
  super_resolution() {
    return new Image();
  }

  /**
   * 选取RGB波段和全色波段进行brovey变换
   * @param {Image} img1 RGB波段影像
   * @param {Image} img2 全色波段影像
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.broveySharpen
   */
  static broveySharpen(img1: Image, img2: Image) {
    return new Image();
  }

  /**
   * AI影像超分运算
   * @returns Image
   * @alias gve.Image.ai_super_resolution
   */
  ai_super_resolution() {
    return new Image();
  }

  /**
   * 波段影像融合
   * @param {Image} img1 Image实例数组
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.cat
   */
  static cat(imgArray: Image[]) {
    return new Image();
  }

  /**
   * 选取RGB波段转换到HSV色彩空间
   * @returns Image
   * @alias gve.Image.rgbToHsv
   */
  rgbToHsv() {
    return new Image();
  }

  /**
   * 全色波段融合
   * @returns Image
   * @alias gve.Image.hsvToRgb
   */
  hsvToRgb() {
    return new Image();
  }

  /**
   * 选取RGB波段转换到IHS色彩空间
   * @returns Image
   * @alias gve.Image.rgbToIhs
   */
  rgbToIhs() {
    return new Image();
  }

  /**
   * IHS影像转换到RGB
   * @returns Image
   * @alias gve.Image.ihsToRgb
   */
  ihsToRgb() {
    return new Image();
  }

  /**
   * 选取RGB波段和全色波段进行hsv变换
   * @param {Image} img1 RGB波段影像
   * @param {Image} img2 全色波段影像
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.hsvSharpen
   */
  static hsvSharpen(img1: Image, img2: Image) {
    return new Image();
  }

  /**
   * 选取RGB波段和全色波段进行ihs变换
   * @param {Image} img1 RGB波段影像
   * @param {Image} img2 全色波段影像
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.ihsSharpen
   */
  static ihsSharpen(img1: Image, img2: Image) {
    return new Image();
  }

  /**
   * 对rgb影像进行超分，返回一张影像
   * @param {Image} img 影像实例
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.ai_super_resolution
   */
  static ai_super_resolution(img: Image) {
    return new Image();
  }

  /**
   * SwinIR超分模型
   * @returns Image
   * @alias gve.Image.SwinIR
   */
  SwinIR() {
    return new Image();
  }

  /**
   * ESRGAN超分模型
   * @returns Image
   * @alias gve.Image.ESRGAN
   */
  ESRGAN() {
    return new Image();
  }

  /**
   * Real_ESRGAN超分模型
   * @returns Image
   * @alias gve.Image.Real_ESRGAN
   */
  Real_ESRGAN() {
    return new Image();
  }

  /**
   * Real_ESRGAN_Small超分模型
   * @returns Image
   * @alias gve.Image.Real_ESRGAN_Small
   */
  Real_ESRGAN_Small() {
    return new Image();
  }

  /**
   * 选取RGB波段和全色波段进行pca变换
   * @param {Image} img1 RGB波段影像
   * @param {Image} img2 全色波段影像
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.pcaSharpen
   */
  static pcaSharpen(img1: Image, img2: Image) {
    return new Image();
  }

  /**
   * 将image转换为无符号8位整数
   * @returns Image
   * @alias gve.Image.toByte
   */
  toByte() {
    return new Image();
  }

  /**
   * 将image转换为32位浮点数
   * @returns Image
   * @alias gve.Image.toFloat
   */
  toFloat() {
    return new Image();
  }

  /**
   * 将image转换为64位浮点数
   * @returns Image
   * @alias gve.Image.toDouble
   */
  toDouble() {
    return new Image();
  }

  /**
   * 影像波段分层采样
   * @param {number} numPoints 波段采样的数量
   * @param {string} [classBand] 可选参数，分类波段id
   * @param {Geometry} [region] 可选参数，采样区域
   * @param {number} [scale] 可选参数，缩放
   * @returns FeatureCollection
   * @alias gve.Image.stratifiedSample
   */
  stratifiedSample(
    numPoints: number | Number,
    classBand?: string,
    region?: Geometry,
    scale?: number
  ) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new FeatureCollection();
  }

  /**
   * 影像重映射
   * @param {List<number>} from 输入列表值
   * @param {List<number>} to 输出列表值
   * @param {any} [defaultValue] 可选参数，默认值，未指定，屏蔽掉不匹配的值
   * @param {string} [bandName] 可选参数，需要重新映射的波段id
   * @param {number} [scale] 可选参数，缩放
   * @returns Image
   * @alias gve.Image.remap
   */
  remap(
    from: number[] | List<number>,
    to: number[] | List<number>,
    defaultValue?: any,
    bandName?: string,
    scale?: number
  ) {
    if (scale) {
      Http.scale = scale.toString();
    }
    return new Image();
  }

  /**
   * 对一个影像进行分类
   * @param {Classifier} classifier 使用的分类器
   * @param {string|any[]} [outputName] 可选参数，输出属性
   * @returns Image
   * @alias gve.Image.classify
   */
  classify(classifier: Classifier, outputName?: string | any[]) {
    return new Image();
  }

  /**
   * 返回图像波段类型的字典
   * @returns Dictionary
   * @alias gve.Image.bandTypes
   */
  bandTypes() {
    return new Dictionary();
  }

  /**
   * 返回像素值计算结果所组成的Image实例
   * @returns Image
   * @alias gve.Image.exp
   */
  exp() {
    return new Image();
  }

  /**
   * 返回归一化差异值所组成的Image实例
   * @param {string[]} [bandNames] 波段名称列表，默认值为null
   * @returns Image
   * @alias gve.Image.normalizedDifference
   */
  normalizedDifference(bandNames?: string[]) {
    return new Image();
  }

  /**
   * Image对象转等值面FeatureCollection对象，仅支持glc格式的数据
   * @param {string|String} field 生成的属性值，用来存不同的像素值，默认：elev
   * @param {any[]|List<any>} levels 要转矢量图层的像素值列表
   * @param {number} sigma 平滑参数，取值0-1，默认0不平滑，1平滑最大
   * @param {number} [buffer] 可选参数，缓冲区半径，单位跟tif一致，4326为度
   * @returns FeatureCollection
   * @alias gve.Image.imageToIsosurface
   */
  imageToIsosurface(
    field: string | String,
    levels: any[] | List<any>,
    sigma: number | Number,
    buffer?: number | Number
  ) {
    return new FeatureCollection();
  }

  /**
   * Image对象转FeatureCollection对象（gdal方法）
   * @param {string|String} field 生成的属性值，用来存不同的像素值，默认：elev
   * @param {any[]|List<any>} levels 要转矢量图层的像素值列表
   * @returns FeatureCollection
   * @alias gve.Image.imageToFeatureCollection
   */
  imageToFeatureCollection(field: string | String, levels: any[] | List<any>) {
    return new FeatureCollection();
  }

  /**
   * 计算每对匹配波段计算2D矢量[x，y]形成的角度
   * @param {Image} image2 Image实例
   * @returns Image
   * @alias gve.Image.atan2
   */
  atan2(image2: Image) {
    return new Image();
  }

  /**
   * 对于图像1和图像2中的每对匹配的波段，将第一个值提高到第二个值的幂
   * @param {Image} image2 Image实例
   * @returns Image
   * @alias gve.Image.pow
   */
  pow(image2: Image) {
    return new Image();
  }

  /**
   * 将输入值强制转换为带符号的16位整数
   * @returns Image
   * @alias gve.Image.toInt16
   */
  toInt16() {
    return new Image();
  }

  /**
   * 强制转换RGB，只支持用户上传文件
   * @param {Image} redBandIndex 红色波段序号
   * @param {Image} greenBandIndex 绿色波段序号
   * @param {Image} blueBandIndex 蓝色波段序号
   * @param {Image} [nodata] 可选参数，无效值
   * @param {Image} [crs] 可选参数，坐标系
   * @returns Image
   * @alias gve.Image.forceRGB
   */
  forceRGB(
    redBandIndex: number,
    greenBandIndex: number,
    blueBandIndex: number,
    nodata?: number,
    crs?: string
  ) {
    return new Image();
  }

  // /**
  //  * 检测黑水体
  //  * @param {any[]} [indexs] 波段合并的顺序
  //  * @returns Image
  //  */
  // detectionBlackWater(indexs?: any[]) {
  //   return new Image();
  // }

  /**
   * 使用命名或自定义内核将形态均值滤波器应用于图像的每个波段。
   * @param {number} [radius] 可选参数，kernel内核的半径
   * @param {string} [kernelType] 可选参数，内核的类型，默认是circle
   * @param {string} [units] 可选参数，内核的单位，默认是像素，pixels, 可选meters
   * @param {number} [iterations] 可选参数，应用给定内核的次数
   * @param {Kernel} [kernel] 可选参数，自定义内核。如果使用，则忽略kernelType和radius
   * @returns Image
   * @alias gve.Image.focalMean
   */
  focalMean(
    radius?: number,
    kernelType?: string,
    units?: string,
    iterations?: number,
    kernel?: Kernel
  ) {
    return new Image();
  }

  /**
   * 将图像中一个或者多个相交区域的像素转换为Feature，返回一个FeatureCollection
   * @param {FeatureCollection} collection 采样的区域
   * @param {List<any>|any[]|Array<any>} [properties] 可选参数，每个输入特征的属性集合List
   * @param {number} [scale] 可选参数，采样中投影的比例，默认为null
   * @param {Projection} [projection] 可选参数，采样的投影。如果没有指定，将使用图像第一条带的投影。如果在指定的比例之外还指定了投影，则将其重新缩放到指定的比例，默认为null
   * @param {number} [tileScale] 可选参数，默认为1
   * @param {boolean} [geometries] 可选参数，该参数为true时,结果中包含每个采样的像素点，否则不包合，默认为false
   * @returns FeatureCollection
   * @alias gve.Image.sampleRegions
   */
  sampleRegions(
    collection: FeatureCollection,
    properties?: List<any> | any[] | Array<any>,
    scale?: number,
    projection?: Projection,
    tileScale?: number,
    geometries?: boolean
  ) {
    return new FeatureCollection();
  }

  /**
   * 更新图像的掩码值，返回一个新的图像
   * @returns Image
   * @alias gve.Image.selfMask
   */
  selfMask() {
    return new Image();
  }

  /**
   * 复制影像的属性信息,返回一个影像
   * @param {Image} source 复制属性信息的源影像
   * @param {List<any>|any[]|Array<any>} properties 将复制的属性信息列表，默认为空
   * @param {List<any>|any[]|Array<any>} exclude 排除的属性信息列表，默认为空
   * @returns Image
   * @alias gve.Image.copyProperties
   */
  copyProperties(
    source: Image,
    properties: List<any> | any[] | Array<any>,
    exclude: List<any> | any[] | Array<any>
  ) {
    return new Image();
  }

  /**
   * 从指定TMS服务中获取指定区域瓦片数据，并将其转换为tif数据
   * @param {Geometry} geometry Geometry实例
   * @param {string} source TMS，服务地址
   * @param {object} options 图层等级zoom、投影crs等设置项
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.fromTMS
   */
  static fromTMS(geometry: Geometry, source: string, options: object) {
    return new Image();
  }

  /**
   * 从指定WMTS服务中获取指定区域瓦片数据，并将其转换为tif数据
   * @param {Geometry} geometry Geometry实例
   * @param {object} source WMTS对象
   * @param {object} options 图层等级zoom、投影crs等设置项
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.fromWMTS
   */
  static fromWMTS(geometry: Geometry, source: object, options: object) {
    return new Image();
  }

  /**
   * 计算两个图像之间的每个像素光谱距离
   * @param {Image} image 参与计算的第二张影像
   * @param {string} [metric] 可选参数，光谱距离使用的指标（sam(光谱角映射器)|sid（光谱信息差异）|sed（平方欧几里得距离）|emd（地球移动距离））
   * @returns Image
   * @alias gve.Image.spectralDistance
   */
  spectralDistance(image: Image, metric?: string) {
    return new Image();
  }

  /**
   * 分割算法的ImageToFeatureCollection
   * @param {number} [threshold] 可选参数，阈值
   * @param {number} [minSize] 可选参数，分割像素块的最小尺寸
   * @param {number} [minSize] 可选参数，分割像素块的最大尺寸
   * @returns FeatureCollection
   * @alias gve.Image.segmentImageToFeatureCollection
   */
  segmentImageToFeatureCollection(
    threshold?: number,
    minSize?: number,
    maxSize?: number
  ) {
    return new FeatureCollection();
  }

  /**
   * 植被覆盖度指数计算
   * @param {String} ndviBandName 计算植被指数波段名
   * @param {Number} ndviMin NDVI 的最小值，无范围限制，经验值，从统计值里面获取
   * @param {Number} ndviMax NDVI 的最大值，无范围限制，经验值，从统计值里面获取
   * @param {String} [resultBandName] 可选参数，返回值波段名，默认值VFC
   * @returns Image
   * @alias gve.Image.vfc
   */
  vfc(
    ndviBandName: string,
    ndviMin: Number|number,
    ndviMax: Number|number,
    resultBandName?: string
  ) {
    return new Image();
  }

  /**
   * Equal Interval方法计算区间统计值
   * @param {number} classes 分类数目
   * @returns Dictionary
   * @alias gve.Image.histogramByEqualInterval
   */
  histogramByEqualInterval(classes: number) {
    return new Dictionary();
  }

  /**
   * 手动设置分类的区间统计值
   * @param {List} breakpoints 分类数目
   * @returns Dictionary
   * @alias gve.Image.histogramByManual
   */
  histogramByManual(breakpoints: List<any>) {
    return new Dictionary();
  }

  /**
   * 创建一个图像，其中每个像素都是一个给定大小的二维单位矩阵。
   * @param {object} size 每个轴的长度
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.matrixIdentity
   */
  static matrixIdentity(size: number) {
    return new Image();
  }

  /**
   * 在每个像素位置生成一个随机数。使用“uniform”分布时，输出范围为[0到1)。使用“normal”分布时，输出的均值为μ=0，标准差为σ=1，但没有明确的限制。
   * @param {number} [seed] 可选参数，随机数生成器的种子，默认: 0。
   * @param {string} [mode] 可选参数，生成的随机数的分布类型，默认uniform，支持：uniform|normal
   * @returns Image
   * @tutorial gve.Image
   * @alias gve.Image.random
   */
  static random(seed: number = 0, distribution: string = "uniform") {
    return new Image();
  }
  /**
   * 在每个像素位置生成一个随机数。使用“uniform”分布时，输出范围为[0到1)。使用“normal”分布时，输出的均值为μ=0，标准差为σ=1，但没有明确的限制。
   * @param {number} axis 进行累积求和的轴
   * @param {Reducer} [reducer] 可选参数，默认值为 SUM，用于生成给定轴上每个向量的累积和。
   * @returns Image
   * @alias gve.Image.arrayAccum
   */
  arrayAccum(axis: number, reducer?: Reducer) {
    return new Image();
  }

  /**
   * 计算图像中数组值最大值的坐标索引。如果最大值出现多次，则索引反映第一个出现的最大值。
   * @returns Image
   * @alias gve.Image.arrayArgmax
   */
  arrayArgmax() {
    return new Image();
  }

  /**
   * 通过在每个波段上沿给定轴连接每个数组像素来创建数组图像。
   * @param {Image} image1 将第一个数组图像进行拼接。
   * @param {Image} image2 将第二个数组图像进行拼接。
   * @returns Image
   * @alias gve.Image.arrayCat
   */
  arrayCat(image1: Image, image2: Image) {
    return new Image();
  }

  /**
   * 解混图像
   * @param {List|[]} endmembers 需要解混的成员
   * @param {Boolean} [sumToOne] 可选参数，将输出进行限制为1
   * @param {Boolean} [nonNegative] 可选参数，将输出限制为负值
   * @returns Image
   * @alias gve.Image.unmix
   */
  unmix(endmembers: List<any> | [], sumToOne?: boolean, nonNegative?: boolean) {
    return new Image();
  }
  /**
   * Geometrical Interval方法计算区间的统计值
   * @param {number} classes 分类数目
   * @returns Dictionary
   * @alias gve.Image.histogramByGeometricalInterval
   */
  histogramByGeometricalInterval(classes: number) {
    return new Dictionary();
  }

  /**
   * 按照预定义间隔计算区间的统计值
   * @param {number} classes 分类数目
   * @param {number} interval 分类间隔
   * @returns Dictionary
   * @alias gve.Image.histogramByDefinedInterval
   */
  histogramByDefinedInterval(classes: number, interval: number) {
    return new Dictionary();
  }

  /**
   * Quantile方法计算区间的统计值
   * @param {number} classes 分类数目
   * @returns Dictionary
   * @alias gve.Image.histogramByQuantile
   */
  histogramByQuantile(classes: number) {
    return new Dictionary();
  }

  /**
   * Natural Breaks方法计算同一区间的统计值差别最小，不同区间差别最大
   * @param {number} classes 分类数目
   * @returns Dictionary
   * @alias gve.Image.histogramByNaturalBreaks
   */
  histogramByNaturalBreaks(classes: number) {
    return new Dictionary();
  }

  /**
   * 基于数据的标准差计算区间的统计值围绕均值的分布情况
   * @returns Dictionary
   * @alias gve.Image.histogramByStandDeviation
   */
  histogramByStandDeviation() {
    return new Dictionary();
  }

  /**
   * 基于百分比计算区间的统计值的最大值
   * @param {List<any>|any[]} percentages 输入的区间间隔
   * @returns Dictionary
   * @alias gve.Image.histogramDNbyPercent
   */
  histogramDNbyPercent(percentages: List<any> | any[]) {
    return new Dictionary();
  }
    /**
   * 根据输入的面要素和影像，计算面要素提取到的区域的均值
   * @param {FeatureCollection} collection 面要素的区域
   * @returns List
   * @alias gve.Image.extractEndmembers
   */
    extractEndmembers(collection: FeatureCollection) {
      return new List();
    }

  /**
   * 返回每个数组波段的维度数量，对于标量影像波段则返回 0
   * @returns Image
   * @alias gve.Image.arrayDimensions
   */
    arrayDimensions(){
      return new Image();
    }
  
  /**
   * 对输入影像与输入矢量相交区域内像素各类统计
   * @return Table
   * @param {FeatureCollection} featureCollection 输入的矢量
   * @param {List<any>|any[]|Array<any>} stats 需要统计的算法，支持：sum|count|min|max|median
   * @param {string} [addStats] 自定义的算法，目前仅支持'area',
   * @param {Geometry} [geometry]  保留矢量字段
   * @param {string} [primaryKey]  主键字段
   * @param {boolean} [categorical]  是否像素值分类
   * @alias gve.Image.zonalStats
   */
  zonalStats(featureCollection:FeatureCollection, stats:List<any>|any[]|Array<any>, addStats?:string, geometry?:Geometry, primaryKey?:string, categorical?:boolean) {
    return new Table();
  }

  /**
   * 计算输入影像波段中每对一维数组的点积
   * @param {Image} image  待计算的影像
   * @returns Image
   * @alias gve.Image.arrayDotProduct
   */
  arrayDotProduct(image:Image){
    return new Image();
  }

  /**
   * 将集合的几何图形绘制到图像上
   * @param {FeatureCollection} featureCollection 待绘制的集合
   * @param {any} [color] 颜色
   * @param {any} [width] 线宽
   * @alias gve.Image.paint
   * @returns Image
   */
  paint(featureCollection:FeatureCollection, color?:any, width?:any){
    return new Image();
  }

  /**
   * 返回每个像素沿指定轴的数组长度
   * @param {Number} axis 指定轴
   * @alias gve.Image.arrayLength
   * @returns Image
   */
  arrayLength(axis:number){
    return new Image();
  }

  /**
   * 计算输入的立方根
   * @alias gve.Image.cbrt
   * @returns Image
   */
  cbrt(){
    return new Image();
  }

  /**
   * 随机为图像中的每个类别（整数值）分配一种颜色
   * @alias gve.Image.randomVisualizer
   * @returns Image
   */
  randomVisualizer(){
    return new Image();
  }
  /**
   * 将一幅影像覆盖在另一幅影像之上。这些影像通过使用掩模作为透明度进行混合。如果任一影像只有一个波段，它将被复制以匹配另一个影像的波段数量。
   * @param {Image} top 上层影像
   * @alias gve.Image.blend
   * @returns Image
   */
  blend(top:Image){
    return new Image();
  }

  

  /**
   * 对每个“对象”内部的所有像素应用一个减速器。如果像素被连接（8路）并且在“标签”频带中具有相同的值，则认为它们属于一个对象。标签带仅用于识别连通性；其余部分作为减速器的输入。
   * @param {Reducer} reducer 减速器
   * @param {String} [labelBand] 波段名
   * @param {Number} [maxSize] 邻域聚合时最大的像素值
   * @alias gve.Image.reduceConnectedComponents
   * @returns Image
   */
  reduceConnectedComponents(reducer:Reducer, labelBand?:string, maxSize?:number){
    return new Image();
  }
  /**
   * 计算输入的64位二进制补码表示中的1位数
   * @alias gve.Image.bitCount
   * @returns Image
   */
  bitCount(){
    return new Image();
  }
  /**
   * 计算输入的二伽马函数
   * @alias gve.Image.digamma
   * @returns Image
   */
    digamma(){
      return new Image();
    }
 
  /**
   * 将图像所有波段的值限制在指定范围内
   * @param {Number} low 范围内最小值
   * @param {Number} high 范围内最大值
   * @alias gve.Image.clamp
   * @returns Image
   */
    clamp(low:number, high:number){
      return new Image();
    }
  /**
   * 以像素坐标计算输入图像中每个波段的 X 和 Y 离散导数
   * @alias gve.Image.derivative
   * @returns Image
   */
    derivative(){
      return new Image();
    }
  /**
   * 计算影像误差函数
   * @alias gve.Image.erf
   * @returns Image
   */
  erf(){
    return new Image();
  }
  /**
   * 加载http类似地址tif成Image对象
   * @param {String} uri 要加载的 GeoTIFF 的云存储 URI（http类似地址）
   * @tutorial gve.Image
   * @alias gve.Image.loadGeoTIFF
   * @returns Image
   */
  static loadGeoTIFF(uri:string){
    return new Image();
  }

  /**
   * 计算图像的光谱/空间膨胀
   * @param {String} [metric]  可选参数，默认值sam，要使用的光谱距离度量。可以是 'sam'（光谱角映射器）、'sid'（光谱信息散度）、'sed'（平方欧几里得距离）或 'emd'（地球搬运工距离）
   * @param {Kernel} [kernel]  可选参数，连通性核。默认半径为1的正方形（8向连通）
   * @param {Boolean} [useCentroid] 可选参数，默认值false，如果是true，距离是根据核下所有像素的平均值计算的，而不是根据核的中心像素
   * @alias gve.Image.spectralDilation
   * @returns Image
   */
  spectralDilation(metric?:string, kernel?:Kernel, useCentroid?:boolean){
    return new Image();
  }

  /**
   * 多区域统计
   * @param {FeatureCollection} collection 需要统计的矢量特征
   * @param {Reducer} reducer 应用的Reducer
   * @param {Number} [scale] 可选，投影，以米为单位
   * @param {Projection} [crs] 可选，投影类型
   * @param {List<any>|any[]} [crsTransform] 可选， crs转换值列表
   * @param {Number} [tileScale] 可选，用于缩小聚合瓦片大小的缩放因子
   * @returns FeatureCollection
   * @alias gve.Image.reduceRegions
   */
  reduceRegions(collection:FeatureCollection, reducer:Reducer, scale?:number, crs?:Projection, crsTransform?:List<any>|any[], tileScale?:number){
    return new FeatureCollection();
  }

  /**
   * 将输入值转换为有符号的 8 位整数
   * @returns Image
   * @alias gve.Image.int8
   */
  int8(){
    return new Image();
  }
}