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);