'); })();
遥感云计算
GISer
2022-05-14
目录

Image

# 简介

影像（Image）是PIE-Engine中的栅格影像对象，可直接添加到Map中进行显示。PIE-Engine Studio提供影像相关算法，包括但不限于影像加载、获取影像属性及几何信息、正反三角函数运算、按位运算、四则运算、逻辑运算、关系运算、掩膜计算、格式转换运算。

# Image

函数 返回值
Image(args) Image
参数 类型 说明
args String 数据路径
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");

# abs

Image对应像素的绝对值运算，返回一个Image对象。

函数 返回值
abs() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B1']);
var imageResult = image.abs();
Map.addLayer(imageResult,{min:0,max: 2500});
Map.setCenter(120.25,41.8,9);

# acos

对Image每一像素进行反余弦运算（默认为弧度），返回一个类型为Double的Image对象。

函数 返回值
acos() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.cos();
var imageAcos = imageResult.acos();
Map.addLayer(imageAcos,{min: 0,max: 3.14});
Map.setCenter(120.25,41.8,9);

# add

Image对应像素相加，返回一个数据类型为Double的Image对象。

函数 返回值
add(image) Image
参数 类型 说明
image Image|Double Image对象或数值
var image4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4');
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var image = image5.add(image4);
Map.addLayer(image,{min:292,max:5884});
Map.setCenter(120.25,41.8,9);

# addBands

将一幅影像的波段添加到另一幅影像中。

函数 返回值
addBands(srcImage,names=null,overwrite=fasle) Image
参数 类型 说明
this Image 要添加波段的影像对象
srcImage Image 包含被添加波段的影像
names List| String 加入后影像名称列表，默认为空，表示用原来的名称
overwrite Bool 如果要添加的波段已经存在是否覆盖，默认不覆盖
var id = "LC08/01/T1/LC08_121031_20181019";
var image = pie.Image(id).select(["B1","B2","B3","B4","B5","B6"]);
var b3 = image.select("B3");
var b4 = image.select("B4");
var b5 = image.select("B5");
var b6 = image.select("B6");

var ndvi = (b5.subtract(b4)).divide(b5.add(b4)).rename("NDVI");
var ndwi = (b3.subtract(b5)).divide(b3.add(b5)).rename("NDWI");
var ndbi = (b6.subtract(b5)).divide(b6.add(b5)).rename("NDBI");
image = image.addBands(ndvi).addBands(ndwi).addBands(ndbi);
print(image);

# and

Image与运算，返回一个Image对象，如果两个image中的每个匹配波段对的两个值都非零，则返回1，输出像素的类型是布尔型的。

函数 返回值
and(image) Image
参数 类型 说明
Image Image|Number Image对象或数值
// Landsat8数据云区域显示
var image_BQA = pie.Image("LC08/01/T1/LC08_121031_20181019").select("BQA");
var cloudShadowBitMask = 1 << 3;
var cloudsBitMask = 1 << 4;
var mask1 = image_BQA.bitwiseAnd(cloudShadowBitMask).eq(0)
var mask2 = image_BQA.bitwiseAnd(cloudsBitMask).eq(0);
var mask = mask1.and(mask2);
Map.addLayer(mask,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# asin

对Image每一像素进行反正弦运算（默认为弧度），返回一个类型为Double的Image对象。

函数 返回值
asin() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.sin();
var imageAsin = imageResult.asin();
Map.addLayer(imageAsin,{min: -1.57,max: 1.57});
Map.setCenter(120.25,41.8,9);

# atan

对Image每一像素进行反正切运算（默认为弧度），返回一个类型为Double的Image对象。

函数 返回值
atan() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.tan();
var imageAtan = imageResult.atan();
Map.addLayer(imageAtan,{min: -1.57,max: 1.57});
Map.setCenter(120.25,41.8,9);

# bandNames

返回Image对象的波段列表信息。

函数 返回值
bandNames() List
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
var id = image.bandNames().getInfo();

# bandTypes

以字典形式返回Image对象的波段类型信息。

函数 返回值
bandTypes() Dictionary
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
var types = image.bandTypes();
print(types);

# bitwiseAnd

Image按位与运算，返回一个Image对象。

函数 返回值
bitwiseAnd(image) Image
参数 类型 说明
Image Image|Number Image对象或数值
// Landsat8数据云区域显示
var image_BQA = pie.Image("LC08/01/T1/LC08_121031_20181019").select("BQA");
var cloudShadowBitMask = 1 << 3;
var cloudsBitMask = 1 << 4;
var mask1 = image_BQA.bitwiseAnd(cloudShadowBitMask).eq(0)
var mask2 = image_BQA.bitwiseAnd(cloudsBitMask).eq(0);
var mask = mask1.and(mask2);
Map.addLayer(mask,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# bitwiseNot

Image按位非运算，返回一个Image对象。

函数 返回值
bitwiseNot(image) Image
参数 类型 说明
Image Image|Number Image对象或数值
var image1 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1');
var image = image1.bitwiseNot(); 
Map.addLayer(image,{min:0,max: 2000});
Map.setCenter(120.25,41.8,9);

# bitwiseOr

Image按位或运算，返回一个Image对象。

函数 返回值
bitwiseOr(image) Image
参数 类型 说明
Image Image|Number Image对象或数值
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var mask1 = image5.lt(1000)
var mask2 = image5.gt(3000);
var mask = mask1.bitwiseOr(mask2);
Map.addLayer(mask,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# bitwiseXor

Image按位异或运算，返回一个Image对象。

函数 返回值
bitwiseXor(image) Image
参数 类型 说明
Image Image|Number Image对象或数值
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var mask1 = image5.lt(1000)
var mask2 = image5.gt(3000);
var mask = mask1.bitwiseXor(mask2);
Map.addLayer(mask,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# cat

组合多个Image中的波段为一个Image。

函数 返回值
cat (args) Image
参数 类型 说明
args Array 要组合的影像的列表
var id = "LC08/01/T1/LC08_121031_20181019";
var image = pie.Image(id).select(["B3","B4","B5","B6"]);
var b3 = image.select("B3");
var b4 = image.select("B4");
var b5 = image.select("B5");
var b6 = image.select("B6");
var ndvi = (b5.subtract(b4)).divide(b5.add(b4)).rename("NDVI");
var ndwi = (b3.subtract(b5)).divide(b3.add(b5)).rename("NDWI");
var ndbi = (b6.subtract(b5)).divide(b6.add(b5)).rename("NDBI");
image = image.cat([ndvi,ndwi,ndbi]);
print(image);

# classify

进行监督分类，返回结果为分类后的影像。

函数 返回值
classify(classifier, outputName) Image
参数 类型 说明
classifier Classifier 监督分类分类器
outputName String 分类影像的波段名称，“classfiy”为默认值
var image = pie.Image('user/17090142114/PGDB001/World84').select(["B1","B2","B3"]);
var featureCollection = pie.FeatureCollection('user/17090142114/PGDB001/WorldROI');
var training = image.sampleRegions(featureCollection,["type"],50000);
var classifier = pie.Classifier.svm().train(training,"type",["B1","B2","B3"]);
var resultImage = image.classify(classifier,"classifyA");
var visParam = {
    opacity:1,
    uniqueValue:'1,2,3,4',
    palette: 'EAF2F5,000032,1F3600,FAFFC8'
};
Map.addLayer(resultImage,visParam);
Map.setCenter(0,0,0);

# clip

根据给定的Geometry裁剪Image对象，生成剪裁后影像与原影像的波段信息及元数据相同。

函数 返回值
clip(geometry) Image
参数 类型 说明
geometry Geometry 几何图形对象
var id = "LC08/01/T1/LC08_121031_20181019";
var image = pie.Image(id).select("B1");
var geometry = pie.Geometry.Polygon([[[119.5, 41.5], [120, 41.5], [120, 42],[119.5,42],[119.5, 41.5]]], null);
var imageClip = image.clip(geometry);
Map.addLayer(imageClip,{min:1073,max:4596});
Map.centerObject(geometry,10);

# cluster

进行非监督分类，返回结果为分类后的影像。

函数 返回值
cluster(clusterer,outputName) Image
参数 类型 说明
clusterer Cluster 分类器
outputName String 分类影像的波段名称，“cluster”为默认值
var geometry = pie.Geometry.Polygon([[[116.953, 39.419], [117.078, 39.419], [117.078, 39.477],[116.953,39.477],[116.953, 39.419]]], null);
var image = pie.Image("user/101/public/Raster/GF1_Clip").select(["B1","B2","B3"]);
var training = image.sample(geometry,20,"","",200);
var cluster = pie.Clusterer.kMeans(5).train(training);
var resultImage = image.cluster(cluster,"clusterA");
var visParam = {
    opacity:1,
    classify:'0,1,2,3,4,5,6',
    palette: 'FF0000,00FFFF,00FF00,FF00FF,0000FF,FFFF00,FF8000,00AAFF'
};
Map.addLayer(resultImage,visParam);
Map.setCenter(117.01,39.45,13);

# constant

创建一个Image对象，其中每个像素都有相同的值。

函数 返回值
constant(value) Image
参数 类型 说明
value Number 像素值
var image1 = pie.Image().constant(1);
Map.addLayer(image1, null, '1');

# convolve

Image滤波运算，返回一个Image对象。

函数 返回值
convolve(value) Image
参数 类型 说明
value Image|Number 滤波器
// 滤波功能
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var kernel = pie.Kernel().sobel(1, 1);    //实际为高通滤波
// var kernel = pie.Kernel().lowPass();    //低通滤波
// var kernel = pie.Kernel().summary();    //快速滤波
// var kernel = pie.Kernel().laplacian();    //拉普拉斯滤波
// var kernel = pie.Kernel().horizontal();    //水平滤波
// var kernel = pie.Kernel().vertical();    //垂直滤波
var imageKernel = image.convolve(kernel);
Map.addLayer(imageKernel,{min:1000,max:3000});
Map.setCenter(120.25,41.8,11);

# cos

Image对应像素的余弦运算（默认为弧度），返回一个类型为Double的Image对象。

函数 返回值
cos() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.cos();
Map.addLayer(imageResult,{min: -1,max: 1});
Map.setCenter(120.25,41.8,9);

# date

返回Image对象的数据获取日期。

函数 返回值
date() Date
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
var date = image.date().getInfo();
print(date);

# divide

Image对应像素相除，若除数为0则值为0，返回一个数据类型为Double的Image对象。

函数 返回值
divide(image) Image
参数 类型 说明
image Image|Double Image对象或数值
var image4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4');
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageAdd = image5.add(image4);
var imageSubtract = image5.subtract(image4);
var imageNDVI = imageSubtract.divide(imageAdd);
Map.addLayer(imageNDVI,{min:-0.2,max:1});
Map.setCenter(120.25,41.8,9);

# eq

Image对应像素判断是否相等，返回一个类型为Byte的Image对象。

函数 返回值
eq(value) Image
参数 类型 说明
value Image|Number Image对象或数值
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1');
var image2 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B2');
var imageNew = image.eq(image2);
Map.addLayer(imageNew,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,6);

# exp

对影像进行以自然常数e为底的指数运算，返回一个数据类型为Double的Image对象。

函数 返回值
exp() Image
var image = pie.Image("user/101/public/Raster/GF1_Clip").select("B1");
var imageResult = image.exp();
Map.addLayer(imageResult,{min:500,max: 500000000000000000000});
Map.setCenter(117.01,39.45,13);

# expression

表达式运算，返回一个数据类型为Double的Image对象。

函数 返回值
expression(expression,map) Image
参数 类型 说明
expression String 表达式字符串
map Json 操作波段的Json对象
// PIE下Landsat数据选择
var b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4');
var b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');

// NDVI计算
var ndvi = b5.expression(
    '(nir - red) / (nir + red)',
    {
        nir: b5,
        red: b4
    });

// NDVI数据显示
var vis = {
    min: -0.2,
    max: 1,
    palette: 'FFFFFF,CE7E45,DF923D,F1B555,FCD163,99B718,74A901,66A000,529400'
};
Map.addLayer(ndvi, vis, "LC08_NDVI", true);
Map.setCenter(120.25,41.8,9);

# expressionFunction

表达式运算，返回一个数据类型为Double的Image对象。

函数 返回值
expressionFunction(func,map) Image
参数 类型 说明
func function 表达式方法
map Json 操作波段的Json对象
// PIE下Landsat数据选择
var b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4');
var b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');

// NDVI计算
function computePixel(nir, red) {
    return (nir - red) / (nir + red);
}
var ndvi = b5.expressionFunction(
    computePixel,
    {
        nir: b5,
        red: b4
    });

// NDVI数据显示
var vis = {
    min: -0.2,
    max: 1,
    palette: 'FFFFFF,CE7E45,DF923D,F1B555,FCD163,99B718,74A901,66A000,529400'
};
Map.addLayer(ndvi, vis, "LC08_NDVI", true);
Map.setCenter(120.25,41.8,9);

# focal_max

进行形态学膨胀运算，膨胀会使目标区域范围“变大”，将于目标区域接触的背景点合并到该目标物中，使目标边界向外部扩张。可以用来填补目标区域中某些空洞以及消除包含在目标区域中的小颗粒噪声。返回结果是膨胀以后的影像。

函数 返回值
focal_max(radius,kernelType,iterations,units) Image
参数 类型 说明
this Image 要进行形态学变换的影像
radius Number 核半径
kernelType String 核类型，可以是circle、rect和cross，默认是circle
iterations Number 形态学运算的次数
units String 单位，默认是pixels，目前未启用
var image = pie.Image("user/pieadmin/maize_2020-4-21_2020-4-26").select(["B1"]);
var imagePZ = image.focal_max(10);
var imageFS = image.focal_min(10);
var imageKC = imageFS.focal_max(10);
var imageBC = imagePZ.focal_min(10);

// 定义要素数据集A和B
var imageCollectionA = pie.ImageCollection().fromImages([imagePZ,imageFS,imageKC,imageBC]);
print(imageCollectionA);

Map.addLayer(imageKC);
Map.addLayer(imageBC);
Map.setCenter(114.347, 35.69,12);

# focal_median

利用中值滤波，返回处理后影像。

函数 返回值
Image.focal_median(radius) Image
参数 类型 说明
this: image Image 待处理影像
radius Int 滤波窗口大小，需大于1且为奇数，如33，55，7*7
var image = pie.Image("LC08/01/T1/LC08_121031_20181019")
        .select(["B1"]);

// 利用3*3的窗口进行中值滤波处理影像
var result = image.focal_median(3);
Map.setCenter(120.254, 41.726, 6);
Map.addLayer(result, {min: 0, max: 3000}, "image");

# focal_min

进行形态学腐蚀运算，造成图像的边界收缩，用来消除小且无意义的目标物，返回结果是腐蚀以后的影像。

函数 返回值
focal_min(radius,kernelType,iterations,units) Image
参数 类型 说明
this Image 要进行形态学变换的影像
radius Number 核半径
kernelType String 核类型，可以是circle、rect和cross，默认是circle
iterations Number 形态学运算的次数
units String 单位，默认是pixels，目前未启用
var image = pie.Image("user/pieadmin/maize_2020-4-21_2020-4-26").select(["B1"]);
var imagePZ = image.focal_max(10);
var imageFS = image.focal_min(10);
var imageKC = imageFS.focal_max(10);
var imageBC = imagePZ.focal_min(10);

// 定义要素数据集A和B
var imageCollectionA = pie.ImageCollection().fromImages([imagePZ,imageFS,imageKC,imageBC]);
print(imageCollectionA);

Map.addLayer(imageKC);
Map.addLayer(imageBC);
Map.setCenter(114.347, 35.69,12);

# geometry

返回Image对象的边界对应的外接矩形对象。

函数 返回值
geometry(maxError, proj, geodesics) Geometry
参数 类型 说明
maxError MaxError 未启用
proj Projection 未启用
geodesic Boolean 未启用
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(["B1","B2","B3"]);
var geo = image.geometry();
Map.addLayer(image,{min:100,max:8000});
var visParams = { color: "ff0000ff", fillColor:"00000000"};
Map.addLayer(geo, visParams, "geo");
Map.centerObject(geo, 6);

# get

根据属性名获得Image下的属性值信息。

函数 返回值
get(key) String|Number|Boolean|Object|List
参数 类型 说明
key String 属性名
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
print(image)
image = image.set("key1",{name:123});
var value = image.get("key1");
print(value);
var v = image.get("key1").getInfo()["name"];
print(v);

# getNumber

根据属性名获得Image下的属性值信息，并且将其转换为数值类型。

函数 返回值
getNumber(property) Number
参数 类型 说明
property String 属性名
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
var dict = {key1: {name:"abc", value:123}, key2: 12.34, key3: "12.34"};
image = image.setMulti(dict);
var value3 = image.getNumber("key3").getInfo();
print(value3);

# getString

根据属性名获得Image下的属性值信息，并且将其转换为字符串类型。

函数 返回值
getString(property) String
参数 类型 说明
property String 属性名
var imageCollection = pie.ImageCollection("LC08/01/T1").filterDate("2019-12-01", "2019-12-02");
var dict = {key1: {name:"abc", value:123}, key2: 12.34, key3: "12.34"};
imageCollection = imageCollection.setMulti(dict);
var value2 = imageCollection.get("key2");
print(value2);

# glcmTexture

进行灰度矩阵相关纹理特征运算，计算的特征包括均值、方差、标准差、同质性/逆差矩、非相似性、对比度、墒、能量/角二矩阵、相关性等，返回特征影像，波段的名称为原始影像波段id+特征标识，如b1波段的均值特征波段名称为“b1_MEAN”、方差特征波段名称为“b1_VARIANCE”。

函数 返回值
glcmTexture(maxLevel,min,max,dx,dy,size) Image
参数 类型 说明
this Image 要进行灰度共生矩阵纹理特征计算的影像
maxLevel Number 灰度级别，默认是8
min Number 原始波段最小值，默认0
max Number 原始波段最小值，默认255
dx Number 灰度矩阵的x方向距离，默认是3
dy Number 灰度矩阵的y方向距离，默认是3；dx、dy组合起来可以计算出灰度共生矩阵的方向，都为0表示四个方向距离为3的同时运算
size Number 滑动窗口的大小，默认为5
var image = pie.Image("user/101/public/Raster/GF1_Clip").select(["B1"]);
// var bandName = "_MEAN"; // 均值
// var bandName = "_VARIANCE"; // 方差
// var bandName = "_STD"; // 标准差
// var bandName = "_HOMOGENITY"; // 同质性/逆差矩
// var bandName = "_CONTRAST"; // 对比度
// var bandName = "_DISSMILARTY"; // 非相似性
// var bandName = "_ENTROPY"; // 墒
// var bandName = "_ENERGY"; // 能量/角二矩阵
// var bandName = "_CORRELATION"; // 相关性
var lastBandName = "_MEAN";
var imageGLCM = image.glcmTexture(16,0,255,0,0,7).select("B1" + lastBandName);
Map.addLayer(imageGLCM,{min:0,max:5},"GLCM");
Map.addLayer(image,{min:0,max:255},"SRC");
Map.setCenter(117.01,39.45,13);

# gt

Image对应像素判断是否大于，返回一个类型为Byte的Image对象。

函数 返回值
gt(value) Image
参数 类型 说明
value Image|Number Image对象或数值
var image1 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1');
var image2 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B2');
var imageNew = image1.gt(image2);
Map.addLayer(imageNew,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# gte

Image对应像素判断是否大于等于，返回一个类型为Byte的Image对象。

函数 返回值
gte(value) Image
参数 类型 说明
value Image|Number Image对象或数值
var image1 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1');
var image2 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B2');
var imageNew = image1.gte(image2);
Map.addLayer(imageNew,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# id

返回Image对象的id。

函数 返回值
id() String
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
var id = image.id().getInfo();

# leftShift

Image左移位运算，返回一个Image对象。

函数 返回值
leftShift(image) Image
参数 类型 说明
Image Image|Number Image对象或数值
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var mask1 = image5.lt(1000)
var mask2 = image5.gt(3000);
var mask = mask1.leftShift(mask2);
Map.addLayer(mask,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# load

Image对象加载数据，一般在Image初始化的时候会默认调用该方法。

函数 返回值
load(id) Image
参数 类型 说明
id String 数据路径
var image = pie.Image().load("LC08/01/T1/LC08_121031_20181019");

# log

Image对应像素的自然对数计算，返回一个类型为Double的Image对象。

函数 返回值
log() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B1']);
var imageResult = image.log();
Map.addLayer(imageResult,{min:0,max: 10});
Map.setCenter(120.25,41.8,9);

# log10

Image对应像素的以10为底的对数计算，返回一个类型为Double的Image对象。

函数 返回值
log10() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B1']);
var imageResult = image.log10();
Map.addLayer(imageResult,{min:0,max: 5});
Map.setCenter(120.25,41.8,9);

# lt

Image对应像素判断是否小于，返回一个类型为Byte的Image对象。

函数 返回值
lt(value) Image
参数 类型 说明
value Image|Number Image对象或数值
var image1 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1');
var image2 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B2');
var imageNew = image1.lt(image2);
Map.addLayer(imageNew,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# lte

Image对应像素判断是否小于等于，返回一个类型为Byte的Image对象。

函数 返回值
lte(value) Image
参数 类型 说明
value Image|Number Image对象或数值
var image1 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1');
var image2 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B2');
var imageNew = image1.lte(image2);
Map.addLayer(imageNew,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# matrixMultiply

返回左右影像中每对相对应波段的矩阵乘法。如果左右两影像中任意一个只有一个波段，那么该波段将与另一影像中所有波段做运算。如果两影像波段数相同但波段名称不同，则根据自然顺序来对两影像波段进行配对。输出波段名为两输入波段名中更长的一个，如果两输入波段名长度相同，则用左边影响的波段名作为输出波段名。要求左操作数影像的列数和右操作数影像的行数相同，返回结果为左右操作影像的对应编号的波段的矩阵乘法影像。

函数 返回值
matrixMultiply(right) Image
参数 类型 说明
this Image 影像矩阵相乘左操作影像
right Image 影像矩阵相乘右操作影像
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1').toDouble();
var result = image.matrixMultiply(image);
Map.addLayer(result,{min:1000000,max:20000000},"Layer",true);
Map.setCenter(119.9,41.9,7);

# multiply

Image对应像素相乘，返回一个数据类型为Double的Image对象。

函数 返回值
mulitply(image) Image
参数 类型 说明
image Image|Double Image对象或数值
var image4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4');
var image = image4.multiply(3);
Map.addLayer(image,{min:500,max:5000});
Map.setCenter(120.25,41.8,9);

# not

Image非运算，返回一个Image对象。

函数 返回值
not(value) Image
参数 类型 说明
Image Image|Number Image对象或数值
var image1 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1');
var image = image1.not(); 
Map.addLayer(image,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# or

Image或运算，返回一个Image对象。

函数 返回值
or(image) Image
参数 类型 说明
Image Image|Number Image对象或数值
// 显示近红外波段中1000-3000之间数据范围
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var mask1 = image5.lt(1000)
var mask2 = image5.gt(3000);
var mask = mask1.or(mask2);
Map.addLayer(mask,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# paint

绘制FeatureCollection到Image上，返回一个数据类型为short的Image对象；针对面，如果设置了width就不再显示填充色。

函数 返回值
paint(featureCollection,color=0,width=0) Image
参数 类型 说明
paint FeatureCollection 要绘制的FeatureCollection对象
color Int|String 绘制的颜色或颜色字段，范围0-255
width Int|String 绘制的宽度或宽度字段
var roi = pie.FeatureCollection("user/101/public/shape/Shi_HeBei");
var image = pie.Image().paint(roi,150,3);
Map.addLayer(image);
Map.centerObject(roi,7);

# pca

根据特征向量计算主成分分析，返回结果为包含“pc_”开头波段的影像。

函数 返回值
pca(eigenVector) Image
var geometry = pie.Geometry.Polygon([[[-170, 65],[170, 65],[170,-65],[-170,-65],[-170,65]]], null);
var image = pie.Image('user/17090142114/WorldFSub01').select(["B1","B2","B3"]);
var eigenDic = image.pcaEigen(geometry, 31283.5);
var eigenVector = pie.Array(eigenDic.get("eigenVector"));
var resultImg = image.pca(eigenVector);
Map.addLayer(resultImg.select("pc_2"),{min:-71,max:350},"ImageLayer");
Map.setCenter(0,0,2);

var image = pie.Image('user/17090142114/WorldFSub01').select(["B1","B2","B3"]);
var eigenVector = pie.Array([[0.679226,-0.258706,0.686822],[-0.733874,-0.227847,0.639934],[0.00906444,0.9387,0.344617]]); 
var resultImg = image.pca(eigenVector);
Map.addLayer(resultImg.select("pc_2"),{min:-71,max:350},"ImageLayer");
Map.setCenter(0,0,2);
参数 类型 说明
eigenVector PIE.Array 特征向量矩阵

# pcaEigen

计算指定范围和分辨率下影像主成分分析的特征值和特征向量，返回的结果是一个包含特征值“eigenValue”和特征向量“eigenVector”的对象，特征值和特征向量都是矩阵（PIEArray）对象。

函数 返回值
pcaEigen (geometry,scale) PIE.Dictionary
参数 类型 说明
geometry Geometry 几何形体对象，确定要进行计算的数据的范围
scale Number 要进行计算的影像的分辨率
var geometry = pie.Geometry.Polygon([[[-170, 65],[170, 65],[170,-65],[-170,-65],[-170,65]]], null);
var image = pie.Image('user/17090142114/WorldFSub01').select(["B1","B2","B3"]);
var eigenDic = image.pcaEigen(geometry, 31283.5);
print(eigenDic);

# pixelArea

生成新地图影像对象，其每个像素的值是原图像像素的面积（单位，平方米）。

函数 返回值
pixelArea() Image
// 打开数据，计算NDWI
var image = pie.Image("LC08/01/T1/LC08_121038_20170101");
var b3 = image.select("B3");
var b5 = image.select("B5");
var ndwi = (b3.subtract(b5)).divide(b3.add(b5));

// 数据去云处理
var qa = image.select("BQA");
var cloudMask = qa.bitwiseAnd(1<<4).eq(0);
ndwi = ndwi.updateMask(cloudMask);

// 水体区域提取并裁剪
ndwi = ndwi.updateMask(ndwi.gt(0.3));
var geometry = pie.Geometry.Polygon([[[117.25,31.74],[117.85,31.74],[117.85,31.42],[117.25,31.42],[117.25,31.74]]], null);
ndwi = ndwi.clip(geometry);

// 添加水体区域到地图，并设置显示范围
Map.addLayer(ndwi, {min:-1, max:1, palette: "0000ff"}, "2017");
Map.centerObject(geometry,10);

// 水体区域面积统计计算
var areaImage = ndwi.pixelArea().multiply(ndwi);
var water = areaImage.reduceRegion(pie.Reducer.sum(), geometry, 30);
print(water);

# power

做左边影像中每一像素与右边影像中对应像素或数值的幂运算，返回一个数据类型为Double的Image对象。

函数 返回值
power(value) Image
参数 类型 说明
value Image|Double Image对象或数值
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B1']);
var imageResult = image.power(2);
Map.addLayer(imageResult,{min:5000,max: 5000000});
Map.setCenter(120.25,41.8,9);

# propertyNames

返回Image对象的属性信息。

函数 返回值
propertyNames() List
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
var image = image.set("key1",{name:123});
var id = image.propertyNames();
print(id);
var n = image.get("key1").getInfo()["name"]
print(n)

# reduce

应用一个Reducer到影像集合的所有影像，Reducer必须具有单个输入，并且针对影像集的每张影像进行计算，计算的结果是一张影像。

函数 返回值
reduce(reducer) Image
参数 类型 说明
this ImageCollection 要进行计算的影像集合
reducer Reducer 统计计算器
var filterCloud = pie.Filter.lte("cloudCover",5);
var filterPro1 = pie.Filter.eq("wrsPath","119");
var filterPro2 = pie.Filter.eq("wrsRow","38");
var imageCollection = pie.ImageCollection().load("LC08/01/T1_SR")
                .filterDate("2013-04-01", "2020-01-01")
                .filter(filterCloud)
                .filter(filterPro1)
                .filter(filterPro2);
var result = imageCollection.reduce(pie.Reducer.first());
Map.addLayer(result.select("B1"),{min:0,max:6000},"Layer",true);
Map.setCenter(120.5,31.5,6);

# reduceRegion

按照区域进行统计，返回结果需调用getInfo方法，以得到结果，结果为一个JSON对象，返回结果也可以直接调用print进行打印。目前可完成最大、最小和求和统计计算。

函数 返回值
reduceRegion(reducer,geometry,scale) Json
参数 类型 说明
reducer Reducer 统计类型，包括最大值、最小值和求和
geometry Geometry 统计区域范围，空表示当前屏幕范围
scale Number 进行统计时所采用的影像分辨率，单位：米
// 最大、最小、求和、均值和中值统计计算
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B4',"B5"]);
var geometry = pie.Geometry.Polygon([[[119.5, 41.5], [120, 41.5], [120, 42],[119.5,42],[119.5, 41.5]]], null);
var image_Min = image.reduceRegion(pie.Reducer.min(), geometry, 300);
print(image_Min);
var image_Max = image.reduceRegion(pie.Reducer.max(), geometry, 300);
print(image_Max);
var image_Sum = image.reduceRegion(pie.Reducer.sum(), geometry, 300);
print(image_Sum);
var image_Mean = image.reduceRegion(pie.Reducer.mean(), geometry, 300);
print(image_Mean); 
var image_Median = image.reduceRegion(pie.Reducer.median(), geometry, 300);
print(image_Median);
var image_Count = image.reduceRegion(pie.Reducer.count(), geometry, 300);
print(image_Count);

var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B4',"B3","B2"]);
Map.addLayer(image,{min:0,max:3000},"img")
var geometry =  pie.Geometry.Point([120.54170550923686,41.8884053833099], null);;
var image_Min = image.reduceRegion(pie.Reducer.max(), geometry, 1);
print(image_Min);
var image_Max = image.reduceRegion(pie.Reducer.max(), geometry, 1);
print(image_Max);

Image对象波段重新命名。

函数 返回值
rename(bandNames) Image
参数 类型 说明
bandNames String|Array 波段名称或波段名称列表
var visParam = {
  min: 0,
  max: [150,250,255],
  opacity:0.9,
  bands:["R","G","B"]
};
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(["B1","B2","B3"]).rename(["B","G","R"]);
print(image);
Map.addLayer(image,{min:0,max:2500});
Map.setCenter(120.25,41.8,9);

# reproject

Image重投影，返回投影后的Image对象。

函数 返回值
reproject(crsProject, crsTransform,scale) Image
参数 类型 说明
project String|Projection 投影坐标系对象
transform Transform 未启用
scale Float 未启用
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var image1 = image.reproject('EPSG:3857');
Map.addLayer(image1,{min:0,max:2500});
Map.setCenter(120.25,41.8,9);

# rightShift

Image右移位运算，返回一个Image对象。

函数 返回值
rightShift(image) Image
参数 类型 说明
Image Image|Number Image对象或数值
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var mask1 = image5.lt(1000)
var mask2 = image5.gt(3000);
var mask = mask1.rightShift(mask2);
Map.addLayer(mask,{uniqueValue:'0,1',palette: 'FFFFFF,FF0000'});
Map.setCenter(120.25,41.8,9);

# sample

从Image中随机采样，返回结果是一个FeatureCollection，FeatureCollection下的每一个Feature中存储采样点的相应波段的信息。

函数 返回值
sample(region,scale,projection,factor,numPixels,seed,dropNulls,tileScale,geometries) FeatureCollection
参数 类型 说明
region Geometry 要进行采样的范围
scale Float 进行采样时所采用的影像分辨率，单位：米
projection String 未启用
factor Float 采样横和纵方向的比例，当设置为空时，表示不采用此种方式
numPixels Long 采样的点的个数，当factor不为空的时候，其不起作用
seed Interger 未启用
dropNulls Boolean 未启用
tileScale Float 未启用
geometries Boolean true表示加载显示，false表示不加载显示
var geometry = pie.Geometry.Polygon([[[116.953, 39.419], [117.078, 39.419], [117.078, 39.477],[116.953,39.477],[116.953, 39.419]]], null);
var image = pie.Image("user/101/public/Raster/GF1_Clip").select(["B1","B2","B3"]);
var training = image.sample(geometry,20,"","",200,"","","",true);
print(training);
Map.addLayer(training,{color:"red"},"point");
Map.centerObject(training,12)

# sampleRegions

Image中根据样本点采样，返回结果是一个FeatureCollection，FeatureCollection下的每一个Feature中存储采样点的相应波段的信息和分类标签信息。

函数 返回值
sampleRegions(collection,properties,scale,projection,tileScale,geometries) FeatureCollection
参数 类型 说明
collection FeatureCollection 样本点，需要包括分类字段
properties List 采样保留字段集合
scale Float 进行采样时所采用的影像分辨率，单位：米
projection String 未启用
tileScale Float 未启用
geometries Boolean 未启用
var image = pie.Image('user/17090142114/PGDB001/World84').select(["B1","B2","B3"]);
var featureCollection = pie.FeatureCollection('user/17090142114/PGDB001/WorldROI');
var training = image.sampleRegions(featureCollection,["type"],50000);
var classifer = pie.Classifier.svm().train(training,"type",["B1","B2","B3"]).getInfo();
var resultImage = image.classify(classifer,"classifyA");
var visParam = {
    opacity:1,
    uniqueValue:'1,2,3,4',
    palette: 'EAF2F5,000032,1F3600,FAFFC8'
};
Map.addLayer(resultImage,visParam);
Map.setCenter(0,0,0);

# select

根据波段名称从Image中选择波段，返回一个Image对象。

函数 返回值
select(args) Image
参数 类型 说明
args String|Array 波段名称或波段名称列表
var image = pie.Image().load("LC08/01/T1/LC08_121031_20181019").select('B1');
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B1',"B2"]);
Map.addLayer(image,{min:292,max:5884});
Map.setCenter(120.25,41.8,9);

# set

设置Image下的属性信息，如果存在就覆盖更新，如果不存在则直接创建。

函数 返回值
set(key,value) Void
参数 类型 说明
key String 属性名
value String|Number|Boolean|Object|List 属性值
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
print(image)
image = image.set("key1",{name:123});
var value = image.get("key1");
print(value);
var v = image.get("key1").getInfo()["name"];
print(v);

var image = pie.Image("LC08/01/T1/LC08_121031_20181019")
print(image);
var year = image.date().getInfo().split("-")[0];
print("year",year);
var newimage = image.set("time",year);
print(newimage);

# setMaskValue

设置过滤值，相当于设置无效值，返回过滤后的影像对象。

函数 返回值
setMaskValue(value) Image
参数 类型 说明
value Number 过滤值
var image = pie.Image("user/101/public/Raster/GF1_Clip").select("B1");
Map.addLayer(image.setMaskValue(40));
Map.setCenter(117.01,39.45,13);

# setMulti

批量设置Image下的属性信息，如果存在就覆盖更新，如果不存在则直接创建。

函数 返回值
setMulti(properties) Void
参数 类型 说明
properties Dictionary 属性键值对，以字典形式传入
var image = pie.Image("LC08/01/T1/LC08_121031_20181019");
var dict = {key1: {name:"abc", value:123}, key2: 12.34, key3: "12.34"};
image = image.setMulti(dict);
print(image);

# sin

Image对应像素的正弦运算（默认为弧度），返回一个类型为Double的Image对象。

函数 返回值
sin() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.sin();
Map.addLayer(imageResult,{min: -1,max: 1});
Map.setCenter(120.25,41.8,9);

# sqrt

Image对应像素的平方根运算，返回一个类型为Double的Image对象。

函数 返回值
sqrt() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B1']);
var imageResult = image.sqrt();
Map.addLayer(imageResult,{min:0,max: 50});
Map.setCenter(120.25,41.8,9);

# subtract

Image对应像素相减，返回一个数据类型为Double的Image对象。

函数 返回值
subtract(image) Image
参数 类型 说明
image Image|Double Image对象或数值
var image4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4');
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var image = image5.subtract(image4);
Map.addLayer(image,{min:0,max:2500});
Map.setCenter(120.25,41.8,9);

# tan

对Image每一像素进行正切运算（默认为弧度），返回一个类型为Double的Image对象。

函数 返回值
tan() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.tan();
Map.addLayer(imageResult,{min: -10,max: 10});
Map.setCenter(120.25,41.8,9);

# toByte

Image数据类型转换成Byte，强制转换，高精度向低精度转换会发生数据丢失，返回Byte类型的Image。

函数 返回值
toByte() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.toByte();
Map.addLayer(imageResult);
Map.setCenter(120.25,41.8,9);

# toDouble

Image数据类型转换成Double，强制转换，高精度向低精度转换会发生数据丢失，返回Double类型的Image。

函数 返回值
toDouble Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.toDouble();
Map.addLayer(imageResult);
Map.setCenter(120.25,41.8,9);

# toFloat

Image数据类型转换成Float，强制转换，高精度向低精度转换会发生数据丢失，返回Float类型的Image。

函数 返回值
toFloat() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.toFloat();
Map.addLayer(imageResult);
Map.setCenter(120.25,41.8,9);

# toInt16

Image数据类型转换成Int16，强制转换，高精度向低精度转换会发生数据丢失，返回Int16类型的Image。

函数 返回值
toInt16() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.toInt16();
Map.addLayer(imageResult);
Map.setCenter(120.25,41.8,9);

# toInt32

Image数据类型转换成Int32，强制转换，高精度向低精度转换会发生数据丢失，返回Int32类型的Image。

函数 返回值
toInt32() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.toInt32();
Map.addLayer(imageResult);
Map.setCenter(120.25,41.8,9);

# toUInt16

Image数据类型转换成UInt16，强制转换，高精度向低精度转换会发生数据丢失，返回UInt16类型的Image。

函数 返回值
toUInt16() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.toUInt16();
Map.addLayer(imageResult);
Map.setCenter(120.25,41.8,9);

# toUInt32

Image数据类型转换成UInt32，强制转换，高精度向低精度转换会发生数据丢失，返回UInt32类型的Image。

函数 返回值
toUInt32() Image
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
var imageResult = image.toUInt32();
Map.addLayer(imageResult);
Map.setCenter(120.25,41.8,9);

# unitScale

将指定区间（[min,max]）内的数值转换到[0,1]区间内，结果影像中像素值为浮点型。当输入影像的像素值小于min值时，取min值进行计算；当输入影像的像素值大于max值时，取max值进行计算。

函数 返回值
unitScale (min,max) Image
参数 类型 说明
min Float 指定区间的最小值
max Float 指定区间的最大值
var geometry = pie.Geometry.Polygon([
  [
    [
      119.5838339843574,
      42.4443108533047
    ],
    [
      120.89120703122887,
      42.4443108533047
    ],
    [
      120.89120703122887,
      41.01780658466245
    ],
    [
      119.5838339843574,
      41.01780658466245
    ],
    [
      119.5838339843574,
      42.4443108533047
    ]
  ]
], null);
var image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(["B1"]);
var minmax = image.reduceRegion(pie.Reducer.minMax(), geometry, 8000);
var min = pie.Number(pie.Dictionary(minmax).get("B1_min"));
var max = pie.Number(pie.Dictionary(minmax).get("B1_max"));
var out = image.unitScale(min,max);
Map.setCenter(120.254, 41.726, 6);
Map.addLayer(out, {min: 0, max: 1}, "out");

# updateMask

Image掩膜运算，参数image需要是一个0和1的二值图，返回一个Image对象。

函数 返回值
Image.updateMask(image, unmaskValue) Image
参数 类型 说明
Image Image|Number Image对象或数值
unmaskValue Number 设置被掩膜掉的区域的输出值，当设置为Null时被掩膜掉的区域输出值为image的无效值。默认为Null。如：设置为-9999则被掩膜掉的区域的值为-9999。
var image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5');
// 定义像元值小于3000的掩膜，小于3000的值为1，大于3000的为0
var mask2 = image5.lt(3000);
// 显示影像中像元值小于3000的像元,大于3000的部分像元值设置为-9999
var image =image5.updateMask(mask2,-9999);
Map.addLayer(image,{min:600,max:3000});
Map.setCenter(120.25,41.8,9);

# where

Image判断运算，满足condition条件的区域采用value下的值，不满足的部分采用image的值，返回结果为一个Image对象。

函数 返回值
where(condition,value) Image
参数 类型 说明
condition Image Image对象，需要是一个0和1的二值图
value Image|Number Image对象或数值
// 葵花数据云掩膜计算
var image = pie.ImageCollection('H08/AHI-L1-G').first();
var imageSunZ = pie.Image(90).subtract(image.select("B18").divide(100));
var imageSunZMask = imageSunZ.lte(90);
var imageRef0064 = image.select("B3").divide(10000);
var imageTb112 = image.select("B14").divide(100);
var imageCloudDay = imageRef0064.gt(0.05).and(imageRef0064.lt(1)).and(imageTb112.lt(275));
var imageCloudNight = imageTb112.lt(270);
var imageCloud = imageCloudNight.where(imageSunZMask,imageCloudDay);
Map.addLayer(imageCloud,{uniqueValue:'1',palette: 'FFFFFF'},"cloud", true);
Map.setCenter(112.6, 32.5, 2);
有问题，我来改改 (opens new window)
上次更新: 2022/05/25, 03:27:07
Geometry
ImageCollection

← ImageCollection→

最近更新
01
太湖水体浑浊度计算
05-25
02
太湖水域蓝藻密度分析
05-25
03
北京城市建设用地情况分析
05-25
更多文章>
Theme by Vdoing | Copyright © 2021-2022 蜀ICP备2021024989号-3