def __init__(self, url, layers, parameters=None, getFeatureInfoParameters=None,
enablePickFeatures=None, getFeatureInfoFormats=None,
rectangle=None, tillingScheme=None, ellipsoid=None, tileWidth=None,
tileHeight=None, tileDiscardPolicy=None, minimumLevel=None,
maximumLevel=None, credit=None, proxy=None, subdomains=None):
super(WebMapServiceImageryProvider, self).__init__(url=url, rectangle=rectangle,
tillingScheme=tillingScheme,
ellipsoid=ellipsoid,
tileWidth=tileWidth,
tileHeight=tileHeight,
tileDiscardPolicy=tileDiscardPolicy,
minimumLevel=minimumLevel,
maximumLevel=maximumLevel,
credit=credit, proxy=proxy,
subdomains=subdomains)
self.layers = layers
self.parameters = com.notimplemented(parameters)
self.getFeatureInfoParameters = com.notimplemented(getFeatureInfoParameters)
self.enablePickFeatures = enablePickFeatures
self.getFeatureInfoFormats = com.notimplemented(getFeatureInfoFormats)
def __init__(self, url=None, proxy=None, tilingScheme=None,
ellipsoid=None, credit=None):
self.url = url
self.proxy = com.notimplemented(proxy)
self.tilingScheme = com.notimplemented(tilingScheme)
self.ellipsoid = com.notimplemented(ellipsoid)
self.credit = credit
def __init__(self, position, image=None, show=None, scale=None,
horizontalOrigin=None, verticalOrigin=None,
eyeOffset=None, pixelOffset=None, rotation=None,
alignedAxis=None, width=None, height=None, color=None,
scaleByDistance=None, translucencyByDistance=None,
pixelOffsetScaleByDistance=None, imageSubRegion=None,
sizeInMeters=None, name=None):
super(Billboard, self).__init__(show=show, scale=scale, color=color,
horizontalOrigin=horizontalOrigin,
verticalOrigin=verticalOrigin,
eyeOffset=eyeOffset, pixelOffset=pixelOffset,
rotation=rotation, width=width, height=height,
scaleByDistance=scaleByDistance,
translucencyByDistance=translucencyByDistance,
pixelOffsetScaleByDistance=pixelOffsetScaleByDistance,
position=position, name=name)
if image is None:
image = Pin()
if isinstance(image, six.string_types):
image = cesiumpy.entities.pinbuilder.Icon(image)
self.image = image
self.alignedAxis = com.notimplemented(alignedAxis)
self.imageSubRegion = com.notimplemented(imageSubRegion)
self.sizeInMeters = com.notimplemented(sizeInMeters)
def __init__(self, width=None, height=None, extrudedHeight=None,
show=None, fill=None, material=None, color=None,
outline=None, outlineColor=None, outlineWidth=None,
numberOfVerticalLines=None, rotation=None, stRotation=None,
granularity=None, scaleByDistance=None, translucencyByDistance=None,
scale=None, verticalOrigin=None, horizontalOrigin=None,
eyeOffset=None, pixelOffset=None, pixelOffsetScaleByDistance=None,
position=None, name=None):
self.width = width
self.height = height
self.extrudedHeight = extrudedHeight
self.show = show
self.fill = fill
# color, validated in setter
self.material = material
self.color = color
self.outline = outline
# color, validated in setter
self.outlineColor = outlineColor
self.outlineWidth = outlineWidth
self.numberOfVerticalLines = numberOfVerticalLines
self.rotation = rotation
self.stRotation = stRotation
self.granularity = com.notimplemented(granularity)
self.scaleByDistance = com.notimplemented(scaleByDistance)
self.translucencyByDistance = com.notimplemented(translucencyByDistance)
self.scale = scale
self.horizontalOrigin = horizontalOrigin
self.verticalOrigin = verticalOrigin
self.eyeOffset = eyeOffset
self.pixelOffset = pixelOffset
self.pixelOffsetScaleByDistance = com.notimplemented(pixelOffsetScaleByDistance)
if position is not None:
position = cartesian.Cartesian3.maybe(position, degrees=True)
self.position = position
self.name = name
def __init__(self, image, repeat=None):
if isinstance(image, TemporaryImage):
image = image.script
self.image = image
com._check_uri(self.image)
self.repeat = com.notimplemented(repeat)
def __init__(self, divid=None, width='100%', height='100%',
clock=None, imageryProvider=None, terrainProvider=None,
skyBox=None, skyAtmosphere=None, sceneMode=None,
scene3DOnly=None, orderIndependentTranslucency=None,
mapProjection=None, globe=None, useDefaultRenderLoop=None,
targetFrameRate=None, showRenderLoopErrors=None,
contextOptions=None, creditContainer=None,
terrainExaggeration=None):
if divid is None:
divid = 'container-{0}'.format(id(self))
self.divid = divid
self.width = width
self.height = height
self.clock = com.notimplemented(clock)
self.imageryProvider = imageryProvider
self.terrainProvider = terrainProvider
self.skyBox = com.notimplemented(skyBox)
self.skyAtmosphere = com.notimplemented(skyAtmosphere)
self.sceneMode = com.notimplemented(sceneMode)
self.scene3DOnly = scene3DOnly
self.orderIndependentTranslucency = orderIndependentTranslucency
self.mapProjection = com.notimplemented(mapProjection)
self.globe = com.notimplemented(globe)
self.useDefaultRenderLoop = useDefaultRenderLoop
self.targetFrameRate = targetFrameRate
self.showRenderLoopErrors = showRenderLoopErrors
self.contextOptions = com.notimplemented(contextOptions)
self.creditContainer = com.notimplemented(creditContainer)
self.terrainExaggeration = terrainExaggeration
from cesiumpy.camera import Camera
self._camera = Camera(self)
from cesiumpy.scene import Scene
self._scene = Scene(self)
from cesiumpy.entities.entity import _CesiumEntity
self._entities = RistrictedList(self, allowed=_CesiumEntity,
propertyname='entities')
from cesiumpy.datasource import DataSource
self._dataSources = RistrictedList(self, allowed=DataSource,
propertyname='dataSources')
self._scripts = RistrictedList(self, allowed=six.string_types,
propertyname='script')
def __init__(self, sourceUri, describe=None, markerSize=None,
markerSymbol=None, markerColor=None, stroke=None,
strokeWidth=None, fill=None):
super(GeoJsonDataSource, self).__init__(sourceUri=sourceUri)
self.describe = com.notimplemented(describe)
self.markerSize = markerSize
self.markerSymbol = markerSymbol
self.markerColor = markerColor
self.stroke = stroke
self.strokeWidth = strokeWidth
self.fill = fill
def __init__(self, url=None, fileExtension=None, rectangle=None, tillingScheme=None,
ellipsoid=None, tileWidth=None, tileHeight=None, tileDiscardPolicy=None,
minimumLevel=None, maximumLevel=None, credit=None, proxy=None, subdomains=None):
self.url = url
self.fileExtension = fileExtension
self.rectangle = rectangle
self.tillingScheme = com.notimplemented(tillingScheme)
self.ellipsoid = com.notimplemented(ellipsoid)
self.tileWidth = tileWidth
self.tileHeight = tileHeight
self.tileDiscardPolicy = com.notimplemented(tileDiscardPolicy)
self.minimumLevel = minimumLevel
self.maximumLevel = maximumLevel
self.credit = credit
self.proxy = com.notimplemented(proxy)
self.subdomains = com.notimplemented(subdomains)
def __init__(self, position, text, style=None, fillColor=None,
outlineColor=None, outlineWidth=None, show=None,
scale=None, horizontalOrigin=None, verticalOrigin=None,
eyeOffset=None, pixelOffset=None, translucencyByDistance=None,
pixelOffsetScaleByDistance=None, name=None):
super(Label, self).__init__(show=show, outlineColor=outlineColor,
outlineWidth=outlineWidth,
translucencyByDistance=translucencyByDistance,
scale=scale, horizontalOrigin=horizontalOrigin,
verticalOrigin=verticalOrigin,
eyeOffset=eyeOffset, pixelOffset=pixelOffset,
pixelOffsetScaleByDistance=pixelOffsetScaleByDistance,
position=position, name=name)
self.text = text
self.style = com.notimplemented(style)
self.fillColor = fillColor
def flyTo(self, destination, orientation=None):
from cesiumpy.entities.entity import _CesiumEntity
import cesiumpy.extension.geocode as geocode
if isinstance(destination, _CesiumEntity):
# if entity has a position (not positions), use it
if destination.position is not None:
destination = destination.position
destination = geocode._maybe_geocode(destination, height=100000)
if com.is_listlike(destination) and len(destination) == 4:
destination = cartesian.Rectangle.maybe(destination)
else:
destination = cartesian.Cartesian3.maybe(destination, degrees=True)
self.destination = destination
self.orientation = com.notimplemented(orientation)
return self
def __init__(self, url, layer, style, format=None, tileMatrixSetID=None,
tileMatrixLabels=None, rectangle=None, tillingScheme=None,
ellipsoid=None, tileWidth=None, tileHeight=None, tileDiscardPolicy=None,
minimumLevel=None, maximumLevel=None, credit=None, proxy=None, subdomains=None):
super(WebMapTileServiceImageryProvider, self).__init__(url=url, rectangle=rectangle,
tillingScheme=tillingScheme,
ellipsoid=ellipsoid,
tileWidth=tileWidth,
tileHeight=tileHeight,
tileDiscardPolicy=tileDiscardPolicy,
minimumLevel=minimumLevel,
maximumLevel=maximumLevel,
credit=credit, proxy=proxy,
subdomains=subdomains)
self.layer = layer
self.style = style
self.format = format
self.tileMatrixSetID = tileMatrixSetID
self.tileMatrixLabels = com.notimplemented(tileMatrixLabels)
def __init__(self, url, modelMatrix, basePath=None, show=None,
scale=None, minimumPixelSize=None, maximumScale=None,
id=None, allowPicking=None, incrementallyLoadTextures=None,
asynchronous=None, debugShowBoundingVolume=None,
debugWireframe=None):
self.url = url
com._check_uri(self.url)
self.modelMatrix = Transforms.eastNorthUpToFixedFrame(modelMatrix)
self.basePath = basePath
self.show = show
self.scale = scale
self.minimumPixelSize = minimumPixelSize
self.maximumScale = maximumScale
self.id = com.notimplemented(id)
self.allowPicking = allowPicking
self.incrementallyLoadTextures = incrementallyLoadTextures
self.asynchronous = asynchronous
self.debugShowBoundingVolume = debugShowBoundingVolume
self.debugWireframe = debugWireframe
