Image
# 简介
影像(Image)是PIE-Engine中的栅格影像对象,可直接添加到Map中进行显示。PIE-Engine Studio提供影像相关算法,包括但不限于影像加载、获取影像属性及几何信息、正反三角函数运算、按位运算、四则运算、逻辑运算、关系运算、掩膜计算、格式转换运算。
# Image
函数 | 返回值 |
---|---|
Image(args) | Image |
参数 | 类型 | 说明 |
---|---|---|
args | String | 数据路径 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20170101")
# abs
对Image每一像素进行绝对值运算,返回一个Image对象。
函数 | 返回值 |
---|---|
abs(self) | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.abs()
# acos
对Image每一像素进行反余弦运算(默认为弧度),返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
acos() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1')
newImage=image.acos()
print(newImage.getInfo())
# add
做左边影像中每一像素与右边影像中对应像素或数值相加的运算,返回一个数据类型为Double的Image对象。
函数 | 返回值 |
---|---|
add(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Double | Image对象或数值 |
# 示例
image4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
image = image5.add(image4)
# addBands
添加影像中的波段到当前影像。
函数 | 返回值 |
---|---|
addBands(self,srcImage,names=None,overwrite=False) | Image |
参数 | 类型 | 说明 |
---|---|---|
srcImage | String|Array | 波段名称或波段名称列表 |
names | string | 默认为None |
overwrite | boolean | 默认为False |
# 示例
geometry = pie.Geometry.Polygon([[
[
116.29721542611139,
39.961859016358545
],
[
116.30175848687782,
39.8352246197168
],
[
116.46530867451116,
39.83755029383428
],
[
116.46379432092459,
39.96534105732522
],
[
116.29721542611139,
39.961859016358545
]
]], None)
l8 = pie.ImageCollection('LC08/01/T1').filterBounds(geometry).filterDate("2019-01-01","2019-03-01")
i1 = l8.getAt(0)
i2 = l8.getAt(1)
i1 = i1.addBands(i2)
print(i1.bandNames().getInfo())
# And
对Image每一像素与另一影像中对应像素或数值进行与运算,返回一个二值的Image对象。
函数 | 返回值 |
---|---|
And(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
mask1 = image5.gt(1000)
mask2 = image5.lt(3000)
mask = mask1.And(mask2)
print(mask.getInfo())
# asin
对Image每一像素进行反正弦运算(默认为弧度),返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
asin() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1')
newImage=image.asin()
print(newImage.getInfo())
# atan
对Image每一像素进行反正切运算(默认为弧度),返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
atan() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1')
newImage=image.atan()
print(newImage.getInfo())
# bandnames
返回一个包含Image对象中所有波段名的列表。
函数 | 返回值 |
---|---|
bandnames(self) | List |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20170101")
print(image.bandnames().getInfo())
# bandTypes
返回Image对象的波段类型信息。
函数 | 返回值 |
---|---|
bandTypes() | Dictionary |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019")
types = image.bandTypes()
print(types.getInfo())
# bitwiseAnd
对Image进行按位与运算,返回一个Image对象。
函数 | 返回值 |
---|---|
bitwiseAnd(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image_BQA = pie.Image("LC08/01/T1/LC08_121031_20181019").select("BQA")
cloudShadowBitMask = 1 << 3
mask1 = image_BQA.bitwiseAnd(cloudShadowBitMask).eq(0)
print(mask1.getInfo())
# bitwiseNot
对Image进行按位非运算,返回一个Image对象。
函数 | 返回值 |
---|---|
bitwiseNot(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image_BQA = pie.Image("LC08/01/T1/LC08_121031_20181019").select("BQA")
cloudShadowBitMask = 1 << 3
cloudsBitMask = 1 << 4
mask1 = image_BQA.bitwiseNot().eq(0)
mask2 = image_BQA.bitwiseNot().eq(0)
mask = mask1.And(mask2)
print(mask.getInfo())
# bitwiseOr
对Image进行按位或运算,返回一个Image对象。
函数 | 返回值 |
---|---|
bitwiseOr(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image_BQA = pie.Image("LC08/01/T1/LC08_121031_20181019").select("BQA")
cloudShadowBitMask = 1 << 3
mask1 = image_BQA.bitwiseOr(cloudShadowBitMask).eq(0)
print(mask1.getInfo())
# bitwiseXor
对Image进行按位异或运算,返回一个Image对象。
函数 | 返回值 |
---|---|
bitwiseXor(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image_BQA = pie.Image("LC08/01/T1/LC08_121031_20181019").select("BQA")
cloudShadowBitMask = 1 << 3
mask1 = image_BQA.bitwiseXor(cloudShadowBitMask).eq(0)
print(mask1.getInfo())
# classify
进行监督分类,返回结果为分类后的影像。
函数 | 返回值 |
---|---|
classify(classifier, outputName) | Image |
参数 | 类型 | 说明 |
---|---|---|
this | Image | 要进行分类的影像 |
classifier | Cluster | 监督分类分类器 |
outputName | String | 分类影像的波段名称,“classfiy”为默认值 |
# 示例
image = pie.Image('user/17090142114/PGDB001/World84').select(["B1","B2","B3"])
featureCollection = pie.FeatureCollection('user/17090142114/PGDB001/WorldROI')
training = image.sampleRegions(featureCollection,["type"],50000)
classifer = pie.SVM().train(training,"type",["B1","B2","B3"])
resultImage = image.classify(classifer,"classifyA")
visParam = {
'opacity':1,
'uniqueValue':'1,2,3,4',
'palette': 'EAF2F5,000032,1F3600,FAFFC8'
}
Map = pie.Map()
Map.addLayer(resultImage,visParam,'resultImage')
Map.setCenter(0,0,0)
Map
# clip
根据给定的Geometry裁剪Image对象,生成剪裁后影像与原影像的波段信息及元数据相同。
函数 | 返回值 |
---|---|
clip(geometry) | Image |
参数 | 类型 | 说明 |
---|---|---|
geometry | Geometry | 几何图形对象 |
# 示例
id = "LC08/01/T1/LC08_121031_20181019"
image = pie.Image(id).select("B1")
geometry = pie.Geometry.Polygon([[[119.5, 41.5], [120, 41.5], [120, 42],[119.5,42],[119.5, 41.5]]], None)
imageClip = image.clip(geometry)
Map = pie.Map()
Map.addLayer(imageClip,{'min':1073,'max':3000}, 'imageClip')
Map.centerObject(imageClip,9)
Map
# cluster
进行非监督分类,返回结果为分类后的影像。
函数 | 返回值 |
---|---|
cluster(clusterer,outputName) | Image |
参数 | 类型 | 说明 |
---|---|---|
this | Image | 要进行分类的影像 |
clusterer | Cluster | 分类器 |
outputName | String | 分类影像的波段名称,“cluster”为默认值 |
# 示例
m = pie.Map()
geometry = pie.Geometry.Polygon([[[116.953, 39.419], [117.078, 39.419], [117.078, 39.477],[116.953,39.477],[116.953, 39.419]]], None)
image = pie.Image("user/101/public/Raster/GF1_Clip").select(["B1","B2","B3"])
training = image.sample(geometry,20,"","",200)
cluster = pie.KMeans(nClusters=5).train(training)
resultImage = image.cluster(cluster,"clusterA")
visParam = {
'opacity':1,
'classify':'0,1,2,3,4,5,6',
'palette': 'FF0000,00FFFF,00FF00,FF00FF,0000FF,FFFF00,FF8000,00AAFF'
}
m.addLayer(resultImage,visParam,'resultImage')
m.setCenter(117.01,39.45,12)
m
# constant
构造一个常数值的图像。
函数 | 返回值 |
---|---|
constant(bandValue) | Value |
参数 | 类型 | 说明 |
---|---|---|
bandValue | String | 波段编号 |
# 示例
image10000 = pie.Image.constant(10000)
print(image10000.getInfo())
# convolve
Image滤波运算,返回一个Image对象。
函数 | 返回值 |
---|---|
convolve(value) | Image |
参数 | 类型 | 说明 |
---|---|---|
value | Image|Number | 滤波器 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
kernel = pie.Kernel().sobel(1, 1)
imageKernel = image.convolve(kernel)
Map = pie.Map()
Map.addLayer(imageKernel,{'min':1000,'max':3000},'imageKernel')
Map.setCenter(120.25, 41.8, 7)
Map
# cos
对Image每一像素进行余弦运算(默认为弧度),返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
cos() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.cos()
# date
返回Image对象的日期。
函数 | 返回值 |
---|---|
date() | Date |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019")
date = image.date().getInfo()
print(date)
# divide
做左边影像中每一像素除以右边影像中对应像素或数值的运算,若除数为0则值为0。返回一个数据类型为Double的Image对象。
函数 | 返回值 |
---|---|
divide(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Double | Image对象或数值 |
# 示例
image4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
image = image5.divide(image4)
# eq
对Image中每一像素判断是否等于右边影像中对应像素或数值,返回一个二值的Image对象。
函数 | 返回值 |
---|---|
eq(value) | Image |
参数 | 类型 | 说明 |
---|---|---|
value | Image|Number | Image对象或数值 |
# 示例
b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
A = b5.subtract(b4)
B = b5.add(b4)
ndvi = A.divide(B)
image = ndvi.eq(0)
Map = pie.Map()
Map.addLayer(image, {'min':-10, 'max':1}, 'image')
Map.centerObject(b4,7)
Map
# exp
对影像进行以自然常数e为底的指数运算,返回一个数据类型为Double的Image对象。
函数 | 返回值 |
---|---|
exp() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select("B1")
newImage=image.exp()
print(newImage.getInfo())
# expression
根据所提供的表达式对影像进行运算,返回运算结果为数据类型为Double的Image对象。
函数 | 返回值 |
---|---|
expression(expression, map) | Image |
参数 | 类型 | 说明 |
---|---|---|
expression | String | 表达式字符串 |
map | JSON | 操作波段的JSON对象 |
# 示例
b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
# NDVI计算
ndvi = b5.expression('(nir - red)/(nir + red)',{'nir':b5,'red':b4})
Map = pie.Map()
Map.addLayer(pieObject=ndvi, style={'min':-1, 'max':1}, name='ndvi')
Map.centerObject(b4,7)
Map
# expressionFunction
根据所提供的表达式对影像进行运算,返回运算结果为数据类型为Double的Image对象。
函数 | 返回值 |
---|---|
expression(func,map) | Image |
参数 | 类型 | 说明 |
---|---|---|
func | Function | 表达式方法 |
map | JSON | 操作波段的JSON对象 |
# 示例
b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
ndvi_expression = {'expression': '(nir-red)/(nir+red)'}
ndvi_res = b5.expressionFunction(ndvi_expression, {'nir':b5, 'red':b4})
Map = pie.Map()
Map.addLayer(ndvi_res, {'min':-1, 'max':1}, 'ndvi_res')
Map.centerObject(b4,7)
Map
# geometry
返回几何对象。
函数 | 返回值 |
---|---|
geometry(self, maxError=None, proj=None, geodesics=None) | Dictionary |
参数 | 类型 | 说明 |
---|---|---|
maxError | String | 默认为None |
proj | Dictionary | 默认为None |
geodesics | String | 默认为None |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20170101").select(["B4","B3","B2"])
print(image.geometry().getInfo())
Map = pie.Map()
Map.addLayer(image,{'max':3000,'min':0},'image')
Map.addLayer(image.geometry(),{'color':'red'},'geometry')
Map.setCenter(120,41.5,7)
Map
# Get
根据属性名获得Image下的该属性值。
函数 | 返回值 |
---|---|
Get(self,key) | Value |
参数 | 类型 | 说明 |
---|---|---|
Key | String | 指定键的名称 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019")
image.set("key1",{'name':123}).getInfo()
value = image.get("key1").getInfo()
print(value)
# getNumber
根据属性名获得Image下的属性值信息,并且将其转换为数值类型。
函数 | 返回值 |
---|---|
getNumber(property) | Number |
参数 | 类型 | 说明 |
---|---|---|
property | String | 属性名 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019")
dict = {key1: {name:"abc", value:123}, key2: 12.34, key3: "12.34"}
image = image.setMulti(dict)
value3 = image.getNumber("key3").getInfo()
print(value3.getInfo())
# getString
根据属性名获得Image下的属性值信息,并且将其转换为数值类型。
函数 | 返回值 |
---|---|
getString(property) | String |
参数 | 类型 | 说明 |
---|---|---|
property | String | 属性名 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019")
dict = {key1: {name:"abc", value:123}, key2: 12.34, key3: "12.34"}
image = image.setMulti(dict)
value3 = image.getNumber("key3").getInfo()
print(value3.getInfo())
# gt
对Image中每一像素判断是否大于右边影像中对应像素或数值,返回一个二值的Image对象。
函数 | 返回值 |
---|---|
gt(value) | Image |
参数 | 类型 | 说明 |
---|---|---|
value | Image|Number | Image对象或数值 |
# 示例
b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
ndvi = b5.subtract(b4).divide(b5).add(b4)
image = ndvi.gt(0)
# gte
对Image中每一像素判断是否大于等于右边影像中对应像素或数值,返回一个二值的Image对象。
函数 | 返回值 |
---|---|
gte(value) | Image |
参数 | 类型 | 说明 |
---|---|---|
value | Image|Number | Image对象或数值 |
# 示例
b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
ndvi = b5.subtract(b4).divide(b5).add(b4))
image = ndvi.gte(0)
# Id
返回Image对象的在所属ImageCollection中的id。若该影像不属于任何ImageCollection则不一定有id值。
函数 | 返回值 |
---|---|
Id(self) | String |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20170101")
print(image.id().getInfo())
# leftShift
对左右两影像中每一对对应的波段进行左移位运算,返回一个Image对象。如果两影像中任意一个只有一个波段,则将该波段用于对另一影像的所有波段计算中。如果两影像波段数相同,但波段名称不同,则按自然顺序将波段配对。生成的波段名将以两输入影像中名称更长的一个命名,若两输入值长度相同,则以左边影像的波段名命名。
函数 | 返回值 |
---|---|
leftShift(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
mask1 = image5.lt(1000)
mask2 = image5.gt(3000)
mask = mask1.leftShift(mask2)
Map = pie.Map()
Map.addLayer(mask,{'uniqueValue':'0,1','palette': 'FFFFFF,FF0000'}, 'mask_image')
Map.setCenter(120.25,41.8, 9)
Map
# load
加载Image对象数据,一般在Image初始化的时候会默认调用该方法。
函数 | 返回值 |
---|---|
load(imageId) | Image |
参数 | 类型 | 说明 |
---|---|---|
imageId | String | 数据路径 |
# 示例
image = pie.Image().load("LC08/01/T1/LC08_121031_20181019")
# log
对Image每一像素进行自然对数计算,返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
log() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.log()
# log10
对Image每一像素进行以10为底的对数计算,返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
log10() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.log10()
# lt
对Image中每一像素判断是否小于右边影像中对应像素或数值,返回一个二值的Image对象。
函数 | 返回值 |
---|---|
lt(value) | Image |
参数 | 类型 | 说明 |
---|---|---|
value | Image|Number | Image对象或数值 |
# 示例
b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
ndvi = b5.subtract(b4).divide((b5).add(b4))
image = ndvi.lt(0)
# lte
对Image中每一像素判断是否小于等于右边影像中对应像素或数值,返回一个二值的Image对象。
函数 | 返回值 |
---|---|
lte(value) | Image |
参数 | 类型 | 说明 |
---|---|---|
value | Image|Number | Image对象或数值 |
# 示例
b4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
b5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
ndvi = b5.subtract(b4).divide(b5).add(b4))
image = ndvi.lte(0)
# matrixMultiply
影像矩阵乘法,要求左操作数影像的列数和右操作数影像的行数相同,返回结果为左右操作影像的对应编号的波段的矩阵乘法影像。
函数 | 返回值 |
---|---|
matrixMultiply(right) | Image |
参数 | 类型 | 说明 |
---|---|---|
right | Image | 影像矩阵相乘右操作影像 |
# 示例
geometry0 = pie.Geometry.Polygon([
[
[
120.33098111580796,
41.77378692294579
],
[
121.04583702008586,
41.77378692294579
],
[
121.04583702008586,
41.11888189806936
],
[
120.33098111580796,
41.11888189806936
],
[
120.33098111580796,
41.77378692294579
]
]
], None)
palette1 = pie.Palette().getPalette("YlOrRd",3)
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageB1 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1')
result = image.matrixMultiply(imageB1).clip(geometry0)
# 数据加载显示
Map = pie.Map()
Map.addLayer(result,{'min':-100,'max':2000,'palette':palette1},"result")
# 数据范围显示
Map.setCenter(120.54371172669457,41.48639364649069, 8)
Map
# multiply
做左边影像中每一像素与右边影像中对应像素或数值相乘的运算,返回一个数据类型为Double的Image对象。
函数 | 返回值 |
---|---|
mulitply(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Double | Image对象或数值 |
# 示例
image4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
image = image5.multiply(image4)
# not
对Image每一像素与另一影像中对应像素或数值进行非运算,返回一个二值的Image对象。
函数 | 返回值 |
---|---|
not(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
mask1 = image5.lt(1000)
mask2 = image5.gt(3000)
mask = mask1.not(mask2)
print(mask.getInfo())
# or
对Image每一像素与另一影像中对应像素或数值进行或运算,返回一个二值的Image对象。
函数 | 返回值 |
---|---|
or(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
mask1 = image5.lt(1000)
mask2 = image5.gt(3000)
mask = mask1.or(mask2)
print(mask.getInfo())
# paint
绘制FeatureCollection到Image上,返回一个数据类型为short的Image对象;针对面,如果设置了width就不再显示填充色。
函数 | 返回值 |
---|---|
paint(featureCollection, color=0, width=0) | Image |
参数 | 类型 | 说明 |
---|---|---|
featureCollection | FeatureCollection | 要绘制的FeatureCollection对象 |
color | Int|String | 绘制的颜色或颜色字段,范围0-255 |
width | Int|String | 绘制的宽度或宽度字段 |
# 示例
geometry1 = pie.Geometry.Polygon([[
[
120.25399999999945,
41.80396593974288
],
[
120.42978124999689,
41.713817711114245
],
[
120.23202734374973,
41.48377827918594
],
[
120.25399999999945,
41.80396593974288
]
]], None)
geometry2 = pie.Geometry.Polygon([[
[
117.69459718093134,
31.574910322015583
],
[
117.7206897102269,
31.579590140299885
],
[
117.71107667312071,
31.555018473537515
],
[
117.69597047194566,
31.572570324771092
],
[
117.69459718093134,
31.574910322015583
]
]], None)
featC = pie.FeatureCollection([geometry1, geometry2])
image = pie.Image("LC08/01/T1/LC08_121031_20170101").select("B1")
print(image.paint(featC).getInfo())
# pixelArea
生成新地图影像对象,其每个像素的值是原图像像素的面积(单位,平方米)。
函数 | 返回值 |
---|---|
pixelArea() | Image |
# 示例
geometry0 = pie.Geometry.Polygon([
[
[
122.60517035958742,
33.38786845854327
],
[
124.05299075717437,
33.38786845854327
],
[
124.05299075717437,
32.436165307518976
],
[
122.60517035958742,
32.436165307518976
],
[
122.60517035958742,
33.38786845854327
]
]
], None)
Map = pie.Map()
image=pie.Image("LC08/01/T1/LC08_121031_20181019").select("B1")
palette1 = pie.Palette().getPalette("YlGn",7)
areaImage=image.pixelArea().clip(geometry0)
Map.addLayer(areaImage, {'palette':palette1}, "areaImage")
Map.setCenter(123.30134551050402, 32.95462415584206, 7)
Map
# power
对Image每一像素进行幂运算,返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
power(self, value) | Image |
参数 | 类型 | 说明 |
---|---|---|
value | Int,Float | 设置幂的数值 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.power(2)
# propertyNames
返回一个包含Image对象所有属性名的列表。
函数 | 返回值 |
---|---|
propertyNames(self) | List |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20170101")
print(image.propertyNames().getInfo())
# reduce
应用一个Reducer到影像的所有波段,Reducer必须具有单个输入,并且针对影像的每个像素进行计算,计算的结果是一个影像。
函数 | 返回值 |
---|---|
reduce(reducer) | Image |
参数 | 类型 | 说明 |
---|---|---|
reducer | Reducer | 统计计算器 |
# 示例
Map = pie.Map()
image=pie.Image("LC08/01/T1/LC08_121031_20181019").select("B1")
geo = image.geometry()
print(geo.getInfo())
Map.addLayer(image, {'min':0.01, "max":3000}, 'image1')
result = image.reduce(pie.Reducer.sum())
Map.addLayer(result,{'min':0,'max':2550},"Layer")
Map.setCenter(120.4,41.8,7)
Map
# reduceRegion
对指定区域内的所有像素进行统计,返回结果需调用getInfo方法,以得到结果,结果为一个JSON对象,返回结果也可以直接调用print进行打印。目前可完成最大、最小和求和统计计算。
函数 | 返回值 |
---|---|
reduceRegion(reducer,geometry,scale) | JSON |
参数 | 类型 | 说明 |
---|---|---|
reducer | Reducer | 统计类型,包括最大值、最小值和求和 |
geometry | Geometry | 统计区域范围 |
scale | Number | 进行统计时所采用的影像分辨率,单位:米 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select(['B4', "B5"])
geometry = pie.Geometry.Polygon([[[119.5, 41.5], [120, 41.5], [120, 42],[119.5,42],[119.5, 41.5]]], None)
image_Min = image.reduceRegion(pie.Reducer.min(), geometry, 30)
print(image_Min.getInfo())
# rename
对Image对象的波段重新命名。
函数 | 返回值 |
---|---|
rename(self, name) | Image |
参数 | 类型 | 说明 |
---|---|---|
name | String | 自定义波段名称 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20170101")
img = image.select(['B2','B3','B4']).rename(['B','G','R'])
print(img.bandNames().getInfo())
# reproject
将Image在指定坐标系下重新投影,返回投影后的Image对象。
函数 | 返回值 |
---|---|
reproject(crsProject, crsTransform, scale) | Image |
参数 | 类型 | 说明 |
---|---|---|
project | String|Projection | 投影坐标系对象 |
transform | Transform | 未启用 |
scale | Float | 未启用 |
# 示例
Map = pie.Map()
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
image1 = image.reproject('EPSG:3857')
Map.addLayer(pieObject=image1,style={'min':0,'max':2500},name='image1')
Map.setCenter(120.25,41.8,9)
Map
# rightShift
对左右两影像中每一对对应的波段进行右移位运算,返回一个Image对象。如果两影像中任意一个只有一个波段,则将该波段用于对另一影像的所有波段计算中。如果两影像波段数相同,但波段名称不同,则按自然顺序将波段配对。生成的波段名将以两输入影像中名称更长的一个命名,若两输入值长度相同,则以左边影像的波段名命名。
函数 | 返回值 |
---|---|
rightShift(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
mask1 = image5.lt(1000)
mask2 = image5.gt(3000)
mask = mask1.rightShift(mask2)
Map = pie.Map()
Map.addLayer(mask,{'uniqueValue':'0,1','palette':'FFFFFF,FF0000'}, 'mask_image')
Map.setCenter(120.25,41.8,9)
Map
# 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不为0的时候,其不起作用 |
seed | Interger | 未启用 |
dropNulls | Boolean | 未启用 |
tileScale | Float | 未启用 |
geometries | Boolean | 未启用 |
# 示例
geometry = pie.Geometry.Polygon([[[116.953, 39.419], [117.078, 39.419], [117.078, 39.477],[116.953,39.477],[116.953, 39.419]]], None)
image = pie.Image("user/101/public/Raster/GF1_Clip").select(["B1","B2","B3"])
training = image.sample(geometry,20,"","",200)
print(training)
# 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 | 未启用 |
# 示例
m = pie.Map()
image=pie.Image('user/17090142114/PGDB001/World84').select(["B1","B2","B3"])
featureCollection = pie.FeatureCollection('user/17090142114/PGDB001/WorldROI')
training = image.sampleRegions(featureCollection,["type"],50000)
classifer = pie.SVM().train(training,"type",["B1","B2","B3"])
resultImage = image.classify(classifer,"classifyA")
visParam = {
'opacity':1,
'uniqueValue':'1,2,3,4',
'palette': 'EAF2F5,000032,1F3600,FAFFC8'
}
m.addLayer(resultImage,visParam, "resultImage")
m.setCenter(0,0,0)
m
# select
根据波段名称从Image中选择波段,返回含有选择波段的Image对象。
函数 | 返回值 |
---|---|
select(args) | Image |
参数 | 类型 | 说明 |
---|---|---|
args | String|Array | 波段名称或波段名称列表 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20170101").select(['B2','B3','B4'])
# set
设置Image下的指定属性的属性值,如果存在就覆盖更新,如果不存在则直接创建。
函数 | 返回值 |
---|---|
set(self, key, value) | None |
参数 | 类型 | 说明 |
---|---|---|
key | String | 指定键的名称 |
value | String | 指定属性的值 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1')
print(image.set("key1",{'name':123}).getInfo())
# setMaskValue
对Image对象设置过滤值,返回过滤后的影像对象。
函数 | 返回值 |
---|---|
setMaskValue(value) | Image |
参数 | 类型 | 说明 |
---|---|---|
value | Number | 过滤值 |
# 示例
Map = pie.Map()
geometry0 = pie.Geometry.Polygon([
[
[
120.33098111580796,
41.77378692294579
],
[
121.04583702008586,
41.77378692294579
],
[
121.04583702008586,
41.11888189806936
],
[
120.33098111580796,
41.11888189806936
],
[
120.33098111580796,
41.77378692294579
]
]
], None)
image5=pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
palette1 = pie.Palette().getPalette("YlOrRd",6)
image=image5.setMaskValue(300).clip(geometry0)
Map.addLayer(image, {'min':0, 'max':3000, 'palette':palette1}, 'imag')
Map.setCenter(120.3,41.5,8)
Map
# setMulti
批量设置Image下的属性信息,如果存在就覆盖更新,如果不存在则直接创建。
函数 | 返回值 |
---|---|
setMulti(properties) | Void |
参数 | 类型 | 说明 |
---|---|---|
properties | Dictionary | 属性键值对,以字典形式传入 |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1')
dict = {'key1': {'name':"abc", 'value':123}, 'key2': 12.34, 'key3': "12.34"}
image = image.setMulti(dict)
print(image.getInfo())
# sin
对Image每一像素进行正弦运算(默认为弧度),返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
sin() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.sin()
# sqrt
对Image每一像素进行平方根运算,返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
sqrt() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.sqrt()
# subtract
做左边影像中每一像素与右边影像中对应像素或数值相减的运算,返回一个数据类型为Double的Image对象。
函数 | 返回值 |
---|---|
subtract(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Double | Image对象或数值 |
# 示例
image4 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B4')
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
image = image5.subtract(image4)
# tan
对Image每一像素进行正切运算(默认为弧度),返回一个类型为Double的Image对象。
函数 | 返回值 |
---|---|
tan() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B1')
newImage=image.tan()
print(newImage.getInfo())
# toByte
将Image数据类型转换成Byte,强制转换,高精度向低精度转换会发生数据丢失,返回Byte类型的Image。
函数 | 返回值 |
---|---|
toByte() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.toByte()
# toDouble
将Image数据类型转换成Double,强制转换,高精度向低精度转换会发生数据丢失,返回Double类型的Image。
函数 | 返回值 |
---|---|
toDouble() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.toDouble()
# toFloat
将Image数据类型转换成Float,强制转换,高精度向低精度转换会发生数据丢失,返回Float类型的Image。
函数 | 返回值 |
---|---|
toFloat() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.toFloat()
# toInt16
将Image数据类型转换成Int16,强制转换,高精度向低精度转换会发生数据丢失,返回Int16类型的Image。
函数 | 返回值 |
---|---|
toInt16() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.toInt16()
# toInt32
将Image数据类型转换成Int32,强制转换,高精度向低精度转换会发生数据丢失,返回Int32类型的Image。
函数 | 返回值 |
---|---|
toInt32() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.toInt32()
# toUInt16
将Image数据类型转换成UInt16,强制转换,高精度向低精度转换会发生数据丢失,返回UInt16类型的Image。
函数 | 返回值 |
---|---|
toUInt16() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.toUInt16()
# toUInt32
将Image数据类型转换成UInt32,强制转换,高精度向低精度转换会发生数据丢失,返回UInt32类型的Image。
函数 | 返回值 |
---|---|
toUInt32() | Image |
# 示例
image = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
imageResult = image.toUInt32()
# updateMask
更新应用于Image对象的掩膜,参数image需要是一个0和1的二值图,返回一个Image对象。
函数 | 返回值 |
---|---|
updateMask(image) | Image |
参数 | 类型 | 说明 |
---|---|---|
image | Image|Number | Image对象或数值 |
# 示例
image5 = pie.Image("LC08/01/T1/LC08_121031_20181019").select('B5')
mask2 = image5.lt(3000)
image =image5.updateMask(mask2)
print(image.getInfo())
# where
对Image根据给定条件进行判断运算,满足condition条件的像素值更新为value下的值,不满足的像素保留image的原像素值,返回结果为一个Image对象。
函数 | 返回值 |
---|---|
where(self,condition,value) | Image |
参数 | 类型 | 说明 |
---|---|---|
condition | json | 设置处理条件 |
image | Image|Number | Image对象或数值 |
# 示例
geometry = pie.Geometry.Polygon([[
[
116.29721542611139,
39.961859016358545
],
[
116.30175848687782,
39.8352246197168
],
[
116.46530867451116,
39.83755029383428
],
[
116.46379432092459,
39.96534105732522
],
[
116.29721542611139,
39.961859016358545
]
]], None)
l8 = pie.ImageCollection('LC08/01/T1').filterBounds(geometry).filterDate("2019-01-01","2019-03-01")
i1 = l8.getAt(0)
i2 = i1.where(i1.select('B1').gt(3000), 5000)
print(i2.getInfo())
Map = pie.Map()
Map.addLayer(i1,{'min':0,'max':5000},'i1')
Map.addLayer(i2,{'min':0,'max':5000},'i2')
Map.centerObject(i1,7)
Map