czml3 package

czml3.properties module

Bases: BaseCZMLObject, Interpolatable, Deletable

An aligned axis represented by a unit vector which can optionally vary over time.

See here for it’s definition.

checks() → Self[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The axis specified as a reference to another property. See here for it’s definition.

unitCartesian: None | UnitCartesian3Value | list[float] | TimeIntervalCollection: The axis specified as a three-dimensional unit magnitude Cartesian value [X, Y, Z], in world coordinates. See here for it’s definition.

unitSpherical: None | UnitSphericalValue | list[float] | TimeIntervalCollection: The axis specified as a unit spherical value [Clock, Cone], in radians. The clock angle is measured in the XY plane from the positive X axis toward the positive Y axis. The cone angle is the angle from the positive Z axis toward the negative Z axis. See here for it’s definition.

classmethod validate_cartesian(r: UnitCartesian3Value | list[float]) → UnitCartesian3Value[source]

classmethod validate_reference(r: ReferenceValue | str) → ReferenceValue[source]

classmethod validate_spherical(r: UnitSphericalValue | list[float]) → UnitSphericalValue[source]

classmethod validate_velocity_reference(r: VelocityReferenceValue | str) → VelocityReferenceValue[source]

velocityReference: None | VelocityReferenceValue | str | TimeIntervalCollection: The axis specified as the normalized velocity vector of a position property. The reference must be to a position property. See here for it’s definition.

Bases: BaseCZMLObject, Deletable

The type of an arc.

See here for it’s definition.

arcType: None | ArcTypes | str | TimeIntervalCollection: The arc type. See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The arc type specified as a reference to another property. See here for it’s definition.

classmethod validate_arc_type(t)[source]

classmethod validate_reference(r)[source]

class czml3.properties.Billboard[source]

Bases: BaseCZMLObject

A billboard, or viewport-aligned image. The billboard is positioned in the scene by the position property. A billboard is sometimes called a marker.

See here for it’s definition.

alignedAxis: None | AlignedAxis: The aligned axis is the unit vector, in world coordinates, that the billboard up vector points towards. The default is the zero vector, which means the billboard is aligned to the screen up vector.

color: None | Color | str | TimeIntervalCollection: The color of the billboard. This color value is multiplied with the values of the billboard’s image to produce the final color. See here for it’s definition.

disableDepthTestDistance: None | float | NumberValue | TimeIntervalCollection: The distance from the camera at which to disable the depth test. This can be used to prevent clipping against terrain, for example. When set to zero, the depth test is always applied. When set to Infinity, the depth test is never applied.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: How the billboard’s scale should change based on the billboard’s distance from the camera. This scalar value will be multiplied by scale.

eyeOffset: None | EyeOffset | list[float] | TimeIntervalCollection: The eye offset of the billboard, which is the offset in eye coordinates at which to place the billboard relative to the position property. Eye coordinates are a left-handed coordinate system where the X-axis points toward the viewer’s right, the Y-axis points up, and the Z-axis points into the screen. See here for it’s definition.

height: None | float | NumberValue | TimeIntervalCollection: The height of the billboard, in pixels (or meters, if sizeInMeters is true). By default, the native height of the image is used.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the billboard, which indicates if height is relative to terrain or not. See here for it’s definition.

horizontalOrigin: None | HorizontalOrigins | TimeIntervalCollection: See here for it’s definition.

image: str | Uri | TimeIntervalCollection: The URI of the image displayed on the billboard. For broadest client compatibility, the URI should be accessible via Cross-Origin Resource Sharing (CORS). The URI may also be a data URI. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pixelOffset: None | list[float] | TimeIntervalCollection: The offset, in viewport pixels, of the billboard origin from the position. A pixel offset is the number of pixels up and to the right to place the billboard, relative to the position. See here for it’s definition.

pixelOffsetScaleByDistance: None | NearFarScalar | TimeIntervalCollection: How the billboard’s pixel offset should change based on the billboard’s distance from the camera. This scalar value will be multiplied by pixelOffset. See here for it’s definition.

rotation: None | float | Rotation | NumberValue | TimeIntervalCollection: The rotation of the billboard, in radians, counter-clockwise from the alignedAxis.

scale: None | float | NumberValue | TimeIntervalCollection: The scale of the billboard. The scale is multiplied with the pixel size of the billboard’s image. For example, if the scale is 2.0, the billboard will be rendered with twice the number of pixels, in each direction, of the image.

scaleByDistance: None | NearFarScalar | TimeIntervalCollection: How the point’s scale should change based on the point’s distance from the camera. This scalar value will be multiplied by pixelSize. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the billboard is shown.

sizeInMeters: None | bool | TimeIntervalCollection: Whether this billboard’s size (width and height) should be measured in meters, otherwise size is measured in pixels.

translucencyByDistance: None | NearFarScalar | TimeIntervalCollection: How the billboard’s translucency should change based on the billboard’s distance from the camera. This scalar value should range from 0 to 1. See here for it’s definition.

classmethod validate_reference(r)[source]

verticalOrigin: None | VerticalOrigins | TimeIntervalCollection: See here for it’s definition.

width: None | float | NumberValue | TimeIntervalCollection: The width of the billboard, in pixels (or meters, if sizeInMeters is true). By default, the native width of the image is used.

class czml3.properties.Box[source]

Bases: BaseCZMLObject

A box, which is a closed rectangular cuboid.

See here for it’s definition.

dimensions: BoxDimensions | TimeIntervalCollection: The dimensions of the box. See here for it’s definition.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying the distance from the camera at which this box will be displayed. See here for it’s definition.

fill: None | bool | TimeIntervalCollection: The height reference of the box, which indicates if the position is relative to terrain or not.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the box, which indicates if the position is relative to terrain or not. See here for it’s definition.

material: None | Material | str | TimeIntervalCollection: The material to display on the surface of the box. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

outline: None | bool | TimeIntervalCollection: Whether or not the box is outlined.

outlineColor: None | Color | str | TimeIntervalCollection: The color of the box outline. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the box outline.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the box casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the box is shown.

Bases: BaseCZMLObject, Interpolatable, Deletable

The width, depth, and height of a box.

See here for it’s definition.

cartesian: None | Cartesian3Value | list[float] | TimeIntervalCollection: The dimensions specified as a three-dimensional Cartesian value [X, Y, Z], with X representing width, Y representing depth, and Z representing height, in world coordinates in meters. See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The dimensions specified as a reference to another property. See here for it’s definition.

classmethod validate_cartesian(r)[source]

classmethod validate_reference(r)[source]

class czml3.properties.CheckerboardMaterial[source]

Bases: BaseCZMLObject

A material that fills the surface with alternating colors.

See here for it’s definition.

evenColor: None | Color | str | TimeIntervalCollection: The even color. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

oddColor: None | Color | str | TimeIntervalCollection: The odd color. See here for it’s definition.

repeat: None | list[int] | TimeIntervalCollection: The number of times the tiles repeat along each axis.

Bases: BaseCZMLObject, Deletable

Whether a classification affects terrain, 3D Tiles, or both.

See here for it’s definition.

checks()[source]

classificationType: None | ClassificationTypes | TimeIntervalCollection: The classification type, which indicates whether a classification affects terrain, 3D Tiles, or both. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The classification type specified as a reference to another property. See here for it’s definition.

classmethod validate_reference(r)[source]

Bases: BaseCZMLObject

Initial settings for a simulated clock when a document is loaded. The start and stop time are configured using the interval property.

See here for it’s definition.

currentTime: None | str | dt.datetime | TimeIntervalCollection: The current time, specified in ISO8601 format.

classmethod format_time(time)[source]

interval: None | TimeInterval: The interval of the clock.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

multiplier: None | float | NumberValue | TimeIntervalCollection: The multiplier. When step is set to TICK_DEPENDENT, this is the number of seconds to advance each tick. When step is set to SYSTEM_CLOCK_DEPENDENT, this is multiplied by the elapsed system time between ticks. This value is ignored in SYSTEM_CLOCK mode.

range: None | ClockRanges | TimeIntervalCollection: The behavior when the current time reaches its start or end times. See here for it’s definition.

step: None | ClockSteps | TimeIntervalCollection: How the current time advances each tick. See here for it’s definition.

Bases: BaseCZMLObject, Interpolatable, Deletable

A color. The color can optionally vary over time.

See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The color specified as a reference to another property. See here for it’s definition.

rgba: None | RgbaValue | str | list[int] | list[float] | list[int | float] | TimeIntervalCollection: The color specified as an array of color components [Red, Green, Blue, Alpha] where each component is an integer in the range 0-255. See here for it’s definition.

rgbaf: None | RgbafValue | str | list[float] | TimeIntervalCollection: The color specified as an array of color components [Red, Green, Blue, Alpha] where each component is a double in the range 0.0-1.0. See here for it’s definition.

classmethod validate_reference(r)[source]

classmethod validate_rgba(c)[source]

classmethod validate_rgbaf(c)[source]

Bases: BaseCZMLObject, Deletable

The height reference of an object, which indicates if the object’s position is relative to terrain or not.

See here for it’s definition.

checks()[source]

colorBlendMode: None | ColorBlendModes | TimeIntervalCollection: The color blend mode. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The color blend mode specified as a reference to another property. See here for it’s definition.

classmethod validate_reference(r)[source]

Bases: BaseCZMLObject, Deletable

The height reference of an object, which indicates if the object’s position is relative to terrain or not.

See here for it’s definition.

checks()[source]

cornerType: None | CornerTypes | TimeIntervalCollection: The corner style. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The corner style specified as a reference to another property. See here for it’s definition.

classmethod validate_reference(r)[source]

class czml3.properties.Corridor[source]

Bases: BaseCZMLObject

A corridor , which is a shape defined by a centerline and width that conforms to the curvature of the body shape. It can can optionally be extruded into a volume.

See here for it’s definition.

classificationType: None | ClassificationType | TimeIntervalCollection: Whether a classification affects terrain, 3D Tiles, or both. See here for it’s definition.

cornerType: None | CornerType | TimeIntervalCollection: The style of the corners of the corridor. See here for it’s definition.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying the distance from the camera at which this corridor will be displayed. See here for it’s definition.

extrudedHeight: None | float | NumberValue | TimeIntervalCollection: The extruded height of the corridor, which is the altitude of the corridor’s extruded face relative to the surface.

extrudedHeightReference: None | HeightReference | TimeIntervalCollection: The extruded height reference of the corridor, which indicates if extrudedHeight is relative to terrain or not. See here for it’s definition.

fill: None | bool | TimeIntervalCollection: Whether or not the corridor is filled.

granularity: None | float | NumberValue | TimeIntervalCollection: The sampling distance, in radians.

height: None | float | NumberValue | TimeIntervalCollection: The height of the corridor, which is the altitude of the corridor relative to the surface.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the corridor, which indicates if height is relative to terrain or not. See here for it’s definition.

material: None | Material | str | TimeIntervalCollection: The material to display on the surface of the corridor. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

outline: None | bool | TimeIntervalCollection: Whether or not the corridor is outlined. See here for it’s definition.

outlineColor: None | Color | str | TimeIntervalCollection: The color of the corridor outline. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the corridor outline.

positions: PositionList | TimeIntervalCollection: The array of positions defining the centerline of the corridor. See here for it’s definition.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the corridor casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the corridor is shown.

width: float | NumberValue: The width of the corridor, which is the distance between the edges of the corridor.

zIndex: None | int | TimeIntervalCollection: The z-index of the corridor, used for ordering ground geometry. Only has an effect if the corridor is constant, and height and extrudedHeight are not specified.

class czml3.properties.Cylinder[source]

Bases: BaseCZMLObject

A cylinder, which is a special cone defined by length, top and bottom radius.

See here for it’s definition.

bottomRadius: float | NumberValue | TimeIntervalCollection: The radius of the bottom of the cylinder.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying the distance from the camera at which this cylinder will be displayed. See here for it’s definition.

fill: None | bool | TimeIntervalCollection: Whether or not the cylinder is filled.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the cylinder, which indicates if the position is relative to terrain or not. See here for it’s definition.

length: float | NumberValue | TimeIntervalCollection: The length of the cylinder.

material: None | Material | str | TimeIntervalCollection: The material to display on the surface of the cylinder. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

numberOfVerticalLines: None | int | TimeIntervalCollection: The number of vertical lines to draw along the perimeter for the outline.

outline: None | bool | TimeIntervalCollection: Whether or not the cylinder is outlined.

outlineColor: None | Color | str | TimeIntervalCollection: The color of the cylinder outline. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the cylinder outline.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the cylinder casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the cylinder is shown.

slices: None | int | TimeIntervalCollection: The number of edges around the perimeter of the cylinder.

topRadius: float | NumberValue | TimeIntervalCollection: The radius of the top of the cylinder.

Bases: BaseCZMLObject, Interpolatable, Deletable

Indicates the visibility of an object based on the distance to the camera.

See here for it’s definition.

checks()[source]

distanceDisplayCondition: None | DistanceDisplayConditionValue | TimeIntervalCollection: The value specified as two values [NearDistance, FarDistance], with distances in meters. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The value specified as a reference to another property. See here for it’s definition.

classmethod validate_reference(r)[source]

class czml3.properties.Ellipse[source]

Bases: BaseCZMLObject

An ellipse, which is a close curve, on or above Earth’s surface.

See here for it’s definition.

classificationType: None | ClassificationType | TimeIntervalCollection: Whether a classification affects terrain, 3D Tiles, or both. See here for it’s definition.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying at what distance from the camera this ellipse will be displayed. See here for it’s definition.

extrudedHeight: None | float | NumberValue | TimeIntervalCollection: The altitude of the ellipse’s extruded face relative to the surface.

extrudedHeightReference: None | HeightReference | TimeIntervalCollection: The extruded height reference of the ellipse, which indicates if extrudedHeight is relative to terrain or not. See here for it’s definition.

fill: None | bool | TimeIntervalCollection: Whether or not the ellipse is filled.

granularity: None | float | NumberValue | TimeIntervalCollection: The sampling distance, in radians.

height: None | float | NumberValue | TimeIntervalCollection: The altitude of the ellipse relative to the surface.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the ellipse, which indicates if height is relative to terrain or not. See here for it’s definition.

material: None | Material | str | TimeIntervalCollection: The material to use to fill the ellipse. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

numberOfVerticalLines: None | int | TimeIntervalCollection: The number of vertical lines to use when outlining an extruded ellipse.

outline: None | bool | TimeIntervalCollection: Whether or not the ellipse is outlined.

outlineColor: None | Color | str | TimeIntervalCollection: The color of the ellipse outline. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the ellipse outline.

rotation: None | float | NumberValue | TimeIntervalCollection: The angle from north (counter-clockwise) in radians.

semiMajorAxis: float | NumberValue | TimeIntervalCollection: The length of the ellipse’s semi-major axis in meters.

semiMinorAxis: float | NumberValue | TimeIntervalCollection: The length of the ellipse’s semi-minor axis in meters.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the ellipse casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the ellipse is shown.

stRotation: None | float | NumberValue | TimeIntervalCollection: The rotation of any applied texture coordinates.

zIndex: None | int | TimeIntervalCollection: The z-index of the ellipse, used for ordering ground geometry. Only has an effect if the ellipse is constant, and height and extrudedHeight are not specified.

class czml3.properties.Ellipsoid[source]

Bases: BaseCZMLObject

A closed quadric surface that is a three-dimensional analogue of an ellipse.

See here for it’s definition.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying at what distance from the camera this ellipsoid will be displayed. See here for it’s definition.

fill: None | bool | TimeIntervalCollection: Whether or not the ellipsoid is filled.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the ellipsoid, which indicates if the position is relative to terrain or not. See here for it’s definition.

innerRadii: None | EllipsoidRadii | TimeIntervalCollection: The inner radii of the ellipsoid. See here for it’s definition.

material: None | Material | str | TimeIntervalCollection: The material to display on the surface of the ellipsoid. See here for it’s definition.

maximumClock: None | float | NumberValue | TimeIntervalCollection: The maximum clock angle of the ellipsoid.

maximumCone: None | float | NumberValue | TimeIntervalCollection: The maximum cone angle of the ellipsoid.

minimumClock: None | float | NumberValue | TimeIntervalCollection: The minimum clock angle of the ellipsoid.

minimumCone: None | float | NumberValue | TimeIntervalCollection: The minimum cone angle of the ellipsoid.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

outline: None | bool | TimeIntervalCollection: Whether or not the ellipsoid is outlined.

outlineColor: None | Color | str | TimeIntervalCollection: The color of the ellipsoid outline. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the ellipsoid outline.

radii: EllipsoidRadii | TimeIntervalCollection: The radii of the ellipsoid. See here for it’s definition.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the ellipsoid casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the ellipsoid is shown.

slicePartitions: None | int | TimeIntervalCollection: The number of times to partition the ellipsoid into radial slices.

stackPartitions: None | int | TimeIntervalCollection: The number of times to partition the ellipsoid into stacks.

subdivisions: None | int | TimeIntervalCollection: The number of samples per outline ring, determining the granularity of the curvature.

Bases: BaseCZMLObject, Interpolatable, Deletable

The radii of an ellipsoid.

See here for it’s definition.

cartesian: Cartesian3Value | list[float] | TimeIntervalCollection | None: The radii specified as a three-dimensional Cartesian value [X, Y, Z], in world coordinates in meters. See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The radii specified as a reference to another property. See here for it’s definition.

classmethod validate_cartesian(r)[source]

classmethod validate_reference(r)[source]

Bases: BaseCZMLObject, Deletable

An offset in eye coordinates which can optionally vary over time. Eye coordinates are a left-handed coordinate system where the X-axis points toward the viewer’s right, the Y-axis poitns up, and the Z-axis points into the screen.

See here for it’s definition.

cartesian: None | Cartesian3Value | list[float] | TimeIntervalCollection: The eye offset specified as a three-dimensional Cartesian value [X, Y, Z], in eye coordinates in meters. If the array has three elements, the eye offset is constant. If it has four or more elements, they are time-tagged samples arranged as [Time, X, Y, Z, Time, X, Y, Z, …], where Time is an ISO 8601 date and time string or seconds since epoch. See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The eye offset specified as a reference to another property. See here for it’s definition.

classmethod validate_cartesian(r)[source]

classmethod validate_reference(r)[source]

class czml3.properties.GridMaterial[source]

Bases: BaseCZMLObject

A material that fills the surface with a two-dimensional grid.

See here for it’s definition.

cellAlpha: None | float | NumberValue | TimeIntervalCollection: The alpha value for the space between grid lines. This will be combined with the color alpha.

color: None | Color | str | TimeIntervalCollection: The color of the surface. See here for it’s definition.

lineCount: None | list[int] | TimeIntervalCollection: The number of grid lines along each axis. See here for it’s definition.

lineOffset: None | list[float] | LineOffset | TimeIntervalCollection: The offset of grid lines along each axis, as a percentage from 0 to 1. See here for it’s definition.

lineThickness: None | list[float] | TimeIntervalCollection: The thickness of grid lines along each axis, in pixels. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Bases: BaseCZMLObject, Deletable

The height reference of an object, which indicates if the object’s position is relative to terrain or not.

See here for it’s definition.

checks()[source]

heightReference: None | HeightReferences | TimeIntervalCollection: The height reference. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The height reference specified as a reference to another property. See here for it’s definition.

classmethod validate_reference(r)[source]

class czml3.properties.ImageMaterial[source]

Bases: BaseCZMLObject

A material that fills the surface with an image.

See here for it’s definition.

color: None | Color | str | TimeIntervalCollection: The color of the image. This color value is multiplied with the image to produce the final color. See here for it’s definition.

image: None | Uri | TimeIntervalCollection: The image to display on the surface. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

repeat: None | list[int] | TimeIntervalCollection: The number of times the image repeats along each axis. See here for it’s definition.

transparent: None | bool | TimeIntervalCollection: Whether or not the image has transparency.

Bases: BaseCZMLObject

A string of text.

See here for it’s definition.

backgroundColor: None | Color | str | TimeIntervalCollection: The color of the background behind the label. See here for it’s definition.

backgroundPadding: None | Any | TimeIntervalCollection: The amount of padding between the text and the label’s background.. See here for it’s definition.

disableDepthTestDistance: None | float: The distance from the camera at which to disable the depth test. This can be used to prevent clipping against terrain, for example. When set to zero, the depth test is always applied. When set to Infinity, the depth test is never applied.

distanceDisplayCondition: None | DistanceDisplayCondition: The display condition specifying the distance from the camera at which this label will be displayed.

eyeOffset: None | EyeOffset | TimeIntervalCollection: The eye offset of the label, which is the offset in eye coordinates at which to place the label relative to the position property. Eye coordinates are a left-handed coordinate system where the X-axis points toward the viewer’s right, the Y-axis points up, and the Z-axis points into the screen. See here for it’s definition.

fillColor: None | Color | str | TimeIntervalCollection: The fill color of the label. See here for it’s definition.

font: None | str | TimeIntervalCollection: The font to use for the label. See here for it’s definition.

heightReference: None | HeightReference: The height reference of the label, which indicates if the position is relative to terrain or not.

horizontalOrigin: None | HorizontalOrigins | TimeIntervalCollection: See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

outlineColor: None | Color | str | TimeIntervalCollection: The outline color of the label. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The outline width of the label.

pixelOffset: None | Cartesian2Value | TimeIntervalCollection: The offset, in viewport pixels, of the label origin from the position. A pixel offset is the number of pixels up and to the right to place the label, relative to the position. See here for it’s definition.

pixelOffsetScaleByDistance: None | list[float] | NearFarScalar: How the label’s pixel offset should change based on the label’s distance from the camera. This scalar value will be multiplied by pixelOffset.

scale: None | float | NumberValue | TimeIntervalCollection: The scale of the label. The scale is multiplied with the pixel size of the label’s text. For example, if the scale is 2.0, the label will be rendered with twice the number of pixels, in each direction, of the text.

scaleByDistance: None | list[float] | NearFarScalar: How the label’s scale should change based on the label’s distance from the camera. This scalar value will be multiplied by scale.

show: None | bool | TimeIntervalCollection: Whether or not the label is shown.

showBackground: None | bool | TimeIntervalCollection: Whether or not a background behind the label is shown.

style: None | LabelStyles | TimeIntervalCollection: The style of the label. See here for it’s definition.

text: None | str | TimeIntervalCollection: The text displayed by the label. The newline character ( ) indicates line breaks.

translucencyByDistance: None | list[float] | NearFarScalar: How the label’s translucency should change based on the label’s distance from the camera. This scalar value should range from 0 to 1.

verticalOrigin: None | VerticalOrigins | TimeIntervalCollection: See here for it’s definition.

Bases: BaseCZMLObject, Interpolatable, Deletable

The offset of grid lines along each axis, as a percentage from 0 to 1. See here for its definition.

cartesian2: None | list[float] | Cartesian2Value: The offset specified as a 2D Cartesian value. See here for its definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The value specified as a reference to another property. See here for it’s definition.

classmethod validate_cartesian2(c)[source]

classmethod validate_reference(r)[source]

class czml3.properties.Material[source]

Bases: BaseCZMLObject

A definition of how a surface is colored or shaded.

See here for it’s definition.

checkerboard: None | CheckerboardMaterial | TimeIntervalCollection: A material that fills the surface with a checkerboard pattern. See here for it’s definition.

grid: None | GridMaterial | TimeIntervalCollection: A material that fills the surface with a grid. See here for it’s definition.

image: None | ImageMaterial | str | Uri | TimeIntervalCollection: A material that fills the surface with an image. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

solidColor: None | SolidColorMaterial | str | TimeIntervalCollection: A material that fills the surface with a solid color, which may be translucent. See here for it’s definition.

stripe: None | StripeMaterial | TimeIntervalCollection: A material that fills the surface with alternating colors. See here for it’s definition.

class czml3.properties.Model[source]

Bases: BaseCZMLObject

A 3D model.

See here for it’s definition.

articulations: None | Any | TimeIntervalCollection: A mapping of keys to articulation values, where the keys are the name of the articulation, a single space, and the name of the stage. See here for it’s definition.

color: None | Color | str | TimeIntervalCollection: The color to blend with the model’s rendered color. See here for it’s definition.

colorBlendAmount: None | float | NumberValue | TimeIntervalCollection: The color strength when colorBlendMode is MIX. A value of 0.0 results in the model’s rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.

colorBlendMode: None | ColorBlendMode | TimeIntervalCollection: The mode to use for blending between color and the model’s color. See here for it’s definition.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying at what distance from the camera this model will be displayed. See here for it’s definition.

gltf: Uri | str | TimeIntervalCollection: The URI of a glTF model. For broadest client compatibility, the URI should be accessible via Cross-Origin Resource Sharing (CORS). The URI may also be a data URI. See here for it’s definition.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the model, which indicates if the position is relative to terrain or not. See here for it’s definition.

incrementallyLoadTextures: None | bool | TimeIntervalCollection: Whether or not the model can be rendered before all textures have loaded.

maximumScale: None | float | NumberValue | TimeIntervalCollection: The maximum scale size of the model. This is used as an upper limit for minimumPixelSize.

minimumPixelSize: None | float | NumberValue | TimeIntervalCollection: The approximate minimum pixel size of the model regardless of zoom.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

nodeTransformations: None | Any | TimeIntervalCollection: A mapping of node names to node transformations. See here for it’s definition.

runAnimations: None | bool | TimeIntervalCollection: Whether or not to run all animations defined in the glTF model.

scale: None | float | NumberValue | TimeIntervalCollection: The scale of the model.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the model casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the model is shown.

silhouetteColor: None | Color | str | TimeIntervalCollection: The color of the silhouette drawn around the model. See here for it’s definition.

silhouetteSize: None | Color | str | TimeIntervalCollection: The size, in pixels, of the silhouette drawn around the model. See here for it’s definition.

classmethod validate_gltf(r)[source]

Bases: BaseCZMLObject, Interpolatable, Deletable

A numeric value which will be linearly interpolated between two values based on an object’s distance from the camera, in eye coordinates. The computed value will interpolate between the near value and the far value while the camera distance falls between the near distance and the far distance, and will be clamped to the near or far value while the distance is less than the near distance or greater than the far distance, respectively.

See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

nearFarScalar: None | NearFarScalarValue | list[float] | TimeIntervalCollection: The value specified as four values [NearDistance, NearValue, FarDistance, FarValue], with distances in eye coordinates in meters. See here for it’s definition.

reference: None | ReferenceValue | str | TimeIntervalCollection: The value specified as a reference to another property. See here for it’s definition.

classmethod validate_nearFarScalar(r)[source]

classmethod validate_reference(r)[source]

Bases: BaseCZMLObject, Interpolatable, Deletable

Defines an orientation. An orientation is a rotation that takes a vector expressed in the “body” axes of the object and transforms it to the Earth fixed axes.

See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The orientation specified as a reference to another property. See here for it’s definition.

unitQuaternion: None | list[float] | UnitQuaternionValue | TimeIntervalCollection: The orientation specified as a 4-dimensional unit magnitude quaternion, specified as [X, Y, Z, W]. See here for it’s definition.

classmethod validate_reference(r)[source]

classmethod validate_unitQuaternion(q)[source]

velocityReference: None | str | TimeIntervalCollection: The orientation specified as the normalized velocity vector of a position property. The reference must be to a position property. See here for it’s definition.

class czml3.properties.Path[source]

Bases: BaseCZMLObject

A path, which is a polyline defined by the motion of an object over time. The possible vertices of the path are specified by the position property. Note that because clients cannot render a truly infinite path, the path must be limited, either by defining availability for this object, or by using the leadTime and trailTime properties.

See here for it’s definition.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying at what distance from the camera this path will be displayed. See here for it’s definition.

leadTime: None | float | NumberValue | TimeIntervalCollection: The time ahead of the animation time, in seconds, to show the path. The time will be limited to not exceed the object’s availability. By default, the value is unlimited, which effectively results in drawing the entire available path of the object.

material: None | PolylineMaterial | str | TimeIntervalCollection: The material to use to draw the path. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

resolution: None | float | NumberValue | TimeIntervalCollection: The maximum step-size, in seconds, used to sample the path. If the position property has data points farther apart than resolution specifies, additional samples will be computed, creating a smoother path.

show: None | bool | TimeIntervalCollection: Whether or not the path is shown.

trailTime: None | float | NumberValue | TimeIntervalCollection: The time behind the animation time, in seconds, to show the path. The time will be limited to not exceed the object’s availability. By default, the value is unlimited, which effectively results in drawing the entire available path of the object.

width: None | float | NumberValue | TimeIntervalCollection: The width of the path line.

class czml3.properties.Point[source]

Bases: BaseCZMLObject

A point, or viewport-aligned circle.

See here for it’s definition.

color: None | Color | str | TimeIntervalCollection: The color of the point. See here for it’s definition.

disableDepthTestDistance: None | float | NumberValue | TimeIntervalCollection: The distance from the camera at which to disable the depth test. This can be used to prevent clipping against terrain, for example. When set to zero, the depth test is always applied. When set to Infinity, the depth test is never applied.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying the distance from the camera at which this point will be displayed. See here for it’s definition.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the point, which indicates if the position is relative to terrain or not. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

outlineColor: None | Color | str | TimeIntervalCollection: The color of the outline of the point. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the outline of the point.

pixelSize: None | float | NumberValue | TimeIntervalCollection: The size of the point, in pixels.

scaleByDistance: None | NearFarScalar | TimeIntervalCollection: How the point’s scale should change based on the point’s distance from the camera. This scalar value will be multiplied by pixelSize. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the point is shown.

translucencyByDistance: None | NearFarScalar | TimeIntervalCollection: How the point’s translucency should change based on the point’s distance from the camera. This scalar value should range from 0 to 1. See here for it’s definition.

class czml3.properties.Polygon[source]

Bases: BaseCZMLObject

A polygon, which is a closed figure on the surface of the Earth.

See here for it’s definition.

arcType: None | ArcTypes | ArcType | TimeIntervalCollection: The type of arc that should connect the positions of the polygon. See here for it’s definition.

classificationType: None | ClassificationType | TimeIntervalCollection: Whether a classification affects terrain, 3D Tiles, or both. See here for it’s definition.

closeBottom: None | bool | TimeIntervalCollection: Whether to close the bottom of the polygon.

closeTop: None | bool | TimeIntervalCollection: Whether to close the top of the polygon.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying the distance from the camera at which this polygon will be displayed. See here for it’s definition.

extrudedHeight: None | float | NumberValue | TimeIntervalCollection: The extruded height of the polygon.

extrudedHeightReference: None | float | NumberValue | TimeIntervalCollection: The extruded height reference of the polygon, which indicates if extrudedHeight is relative to terrain or not. See here for it’s definition.

fill: None | bool | TimeIntervalCollection: Whether or not the polygon is filled.

granularity: None | float | NumberValue | TimeIntervalCollection: The sampling distance, in radians.

height: None | float | NumberValue | TimeIntervalCollection: The height of the polygon when perPositionHeight is false.

heightReference: None | HeightReference | TimeIntervalCollection: The height reference of the polygon, which indicates if height is relative to terrain or not. See here for it’s definition.

holes: None | PositionListOfLists | TimeIntervalCollection: The array of arrays of positions defining holes in the polygon. See here for it’s definition.

material: None | Material | str | TimeIntervalCollection: The material to use to fill the polygon. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

outline: None | bool | TimeIntervalCollection: Whether or not the polygon is outlined.

outlineColor: None | Color | str | TimeIntervalCollection: The color of the polygon outline. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the polygon outline.

perPositionHeight: None | bool | TimeIntervalCollection: Whether to use the height of each position to define the polygon or to use height as a constant height above the surface.

positions: PositionList | TimeIntervalCollection: The array of positions defining a simple polygon. See here for it’s definition.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the polygon casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the polygon is shown.

stRotation: None | float | NumberValue | TimeIntervalCollection: The rotation of any applied texture. A positive rotation is counter-clockwise.

zIndex: None | int | TimeIntervalCollection: The z-index of the polygon, used for ordering ground geometry. Only has an effect if the polygon is constant, and height and extrudedHeight are not specified.

class czml3.properties.Polyline[source]

Bases: BaseCZMLObject

A polyline, which is a line in the scene composed of multiple segments.

See here for it’s definition.

arcType: None | ArcTypes | ArcType | TimeIntervalCollection: The type of arc that should connect the positions of the polyline. See here for it’s definition.

clampToGround: None | bool | TimeIntervalCollection: Whether or not the polyline should be clamped to the ground.

classificationType: None | ClassificationType | TimeIntervalCollection: Whether a classification affects terrain, 3D Tiles, or both. See here for it’s definition.

depthFailMaterial: None | PolylineMaterial | str | TimeIntervalCollection: The material to use to draw the polyline when it is below the terrain. See here for it’s definition.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying at what distance from the camera this polyline will be displayed. See here for it’s definition.

followSurface: None | bool | TimeIntervalCollection: Whether or not the positions are connected as great arcs (the default) or as straight lines. This property has been superseded by arcType, which should be used instead.

granularity: None | float | NumberValue | TimeIntervalCollection: The sampling distance, in radians.

material: None | PolylineMaterial | str | TimeIntervalCollection: The material to use to draw the polyline. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

positions: PositionList | TimeIntervalCollection: The array of positions defining the polyline as a line strip.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the polyline casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the polyline is shown.

width: None | float | NumberValue | TimeIntervalCollection: The width of the polyline.

zIndex: None | int | TimeIntervalCollection: The z-index of the polyline, used for ordering ground geometry. Only has an effect if the polyline is constant, and clampToGround is true.

class czml3.properties.PolylineArrowMaterial[source]

Bases: BaseCZMLObject

A material that fills the surface of a line with an arrow.

See here for it’s definition.

color: None | Color | str | TimeIntervalCollection: The color of the surface. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class czml3.properties.PolylineDashMaterial[source]

Bases: BaseCZMLObject

A material that provides a how a polyline should be dashed.

See here for it’s definition.

color: None | Color | str | TimeIntervalCollection: The color of the dashes on the line. See here for it’s definition.

dashLength: None | float | NumberValue | TimeIntervalCollection: The length in screen-space pixels of a single dash and gap pattern.

dashPattern: None | int | TimeIntervalCollection: A 16-bit bitfield representing which portions along a single dashLength are the dash (1) and which are the gap (0). The default value, 255 (0000000011111111), indicates 50% gap followed by 50% dash.

gapColor: None | Color | str | TimeIntervalCollection: The color of the gaps between dashes on the line. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class czml3.properties.PolylineGlowMaterial[source]

Bases: BaseCZMLObject

A material that fills the surface of a line with a glowing color.

See here for it’s definition.

color: None | Color | str | TimeIntervalCollection: The color of the surface. See here for it’s definition.

glowPower: None | float | NumberValue | TimeIntervalCollection: The strength of the glow.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

taperPower: None | float | NumberValue | TimeIntervalCollection: The strength of the tapering effect. 1.0 and higher means no tapering.

class czml3.properties.PolylineMaterial[source]

Bases: BaseCZMLObject

A definition of how a surface is colored or shaded.

See here for it’s definition.

checkerboard: None | CheckerboardMaterial | TimeIntervalCollection: A material that fills the line with a checkerboard pattern. See here for it’s definition.

grid: None | GridMaterial | TimeIntervalCollection: A material that fills the line with a grid. See here for it’s definition.

image: None | ImageMaterial | str | Uri | TimeIntervalCollection: A material that fills the line with an image. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

polylineArrow: None | PolylineArrowMaterial | TimeIntervalCollection: A material that fills the line with an arrow. See here for it’s definition.

polylineDash: None | PolylineDashMaterial | TimeIntervalCollection: A material that fills the line with a pattern of dashes. See here for it’s definition.

polylineGlow: None | PolylineGlowMaterial | TimeIntervalCollection: A material that fills the line with a glowing color. See here for it’s definition.

polylineOutline: None | PolylineOutlineMaterial | TimeIntervalCollection: A material that fills the line with a color and outline. See here for it’s definition.

solidColor: None | SolidColorMaterial | str | TimeIntervalCollection: A material that fills the line with a solid color, which may be translucent. See here for it’s definition.

stripe: None | StripeMaterial | TimeIntervalCollection: A material that fills the line with alternating colors. See here for it’s definition.

class czml3.properties.PolylineOutlineMaterial[source]

Bases: BaseCZMLObject

A material that fills the surface of a line with an outlined color.

See here for it’s definition.

color: None | Color | str | TimeIntervalCollection: The color of the surface. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

outlineColor: None | Color | str | TimeIntervalCollection: The color of the surface outline. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the outline.

Bases: BaseCZMLObject, Interpolatable, Deletable

Defines a position. The position can optionally vary over time.

See here for it’s definition.

cartesian: None | Cartesian3Value | list[float] | TimeIntervalCollection: The position specified as a three-dimensional Cartesian value, [X, Y, Z], in meters relative to the referenceFrame. See here for it’s definition.

cartesianVelocity: None | Cartesian3VelocityValue | list[float] | TimeIntervalCollection: The position and velocity specified as a three-dimensional Cartesian value and its derivative, [X, Y, Z, dX, dY, dZ], in meters relative to the referenceFrame.

cartographicDegrees: None | CartographicDegreesValue | list[float] | TimeIntervalCollection: The position specified in Cartographic WGS84 coordinates, [Longitude, Latitude, Height], where Longitude and Latitude are in degrees and Height is in meters.

cartographicRadians: None | CartographicRadiansValue | list[float] | TimeIntervalCollection: The position specified in Cartographic WGS84 coordinates, [Longitude, Latitude, Height], where Longitude and Latitude are in radians and Height is in meters.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The position specified as a reference to another property. See here for it’s definition.

referenceFrame: None | str | TimeIntervalCollection: The reference frame in which cartesian positions are specified. Possible values are FIXED and INERTIAL.

classmethod validate_cartesian(r)[source]

classmethod validate_cartesianVelocity(r)[source]

classmethod validate_cartographicDegrees(r)[source]

classmethod validate_cartographicRadians(r)[source]

classmethod validate_reference(r)[source]

Bases: BaseCZMLObject, Deletable

A list of positions.

See here for it’s definition.

cartesian: None | Cartesian3ListValue | list[float] | TimeIntervalCollection: The list of positions specified as three-dimensional Cartesian values, [X, Y, Z, X, Y, Z, …], in meters relative to the referenceFrame. See here for it’s definition.

cartographicDegrees: None | CartographicDegreesListValue | list[float] | TimeIntervalCollection: The list of positions specified in Cartographic WGS84 coordinates, [Longitude, Latitude, Height, Longitude, Latitude, Height, …], where Longitude and Latitude are in degrees and Height is in meters. See here for it’s definition.

cartographicRadians: None | CartographicRadiansListValue | list[float] | TimeIntervalCollection: The list of positions specified in Cartographic WGS84 coordinates, [Longitude, Latitude, Height, Longitude, Latitude, Height, …], where Longitude and Latitude are in radians and Height is in meters. See here for it’s definition.

checks()[source]

interval: None | TimeInterval | TimeIntervalCollection

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

referenceFrame: None | str | TimeIntervalCollection: The reference frame in which cartesian positions are specified. Possible values are FIXED and INERTIAL.

references: None | ReferenceListValue | list[str] | TimeIntervalCollection: The list of positions specified as references. Each reference is to a property that defines a single position, which may change with time. See here for it’s definition.

classmethod validate_cartesian(r)[source]

classmethod validate_cartographicDegrees(r)[source]

classmethod validate_cartographicRadians(r)[source]

classmethod validate_reference(r)[source]

Bases: BaseCZMLObject, Deletable

A list of positions.

See here for it’s definition.

cartesian: None | Cartesian3ListOfListsValue | list[list[float]] | TimeIntervalCollection: The list of lists of positions specified as three-dimensional Cartesian values, [X, Y, Z, X, Y, Z, …], in meters relative to the referenceFrame. See here for it’s definition.

cartographicDegrees: None | CartographicDegreesListOfListsValue | list[list[float]] | TimeIntervalCollection: The list of lists of positions specified in Cartographic WGS84 coordinates, [Longitude, Latitude, Height, Longitude, Latitude, Height, …], where Longitude and Latitude are in degrees and Height is in meters. See here for it’s definition.

cartographicRadians: None | CartographicRadiansListOfListsValue | list[list[float]] | TimeIntervalCollection: The list of lists of positions specified in Cartographic WGS84 coordinates, [Longitude, Latitude, Height, Longitude, Latitude, Height, …], where Longitude and Latitude are in radians and Height is in meters. See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

referenceFrame: None | str | TimeIntervalCollection

references: None | ReferenceListOfListsValue | list[list[str]] | TimeIntervalCollection: The list of lists of positions specified as references. Each reference is to a property that defines a single position, which may change with time. See here for it’s definition.

classmethod validate_cartesian(r)[source]

classmethod validate_cartographicDegrees(r)[source]

classmethod validate_cartographicRadians(r)[source]

classmethod validate_reference(r)[source]

class czml3.properties.Rectangle[source]

Bases: BaseCZMLObject

A cartographic rectangle, which conforms to the curvature of the globe and can be placed on the surface or at altitude and can optionally be extruded into a volume.

See here for it’s definition.

coordinates: None | RectangleCoordinates | TimeIntervalCollection: The coordinates of the rectangle. See here for it’s definition.

fill: None | bool | TimeIntervalCollection: Whether or not the rectangle is filled.

material: None | Material | str | TimeIntervalCollection: The material to display on the surface of the rectangle. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

show: None | bool | TimeIntervalCollection: Whether or not the rectangle is shown.

Bases: BaseCZMLObject, Interpolatable, Deletable

A set of coordinates describing a cartographic rectangle on the surface of the ellipsoid.

See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The set of coordinates specified as a reference to another property. See here for it’s definition.

classmethod validate_reference(r)[source]

wsen: None | list[float] | TimeIntervalCollection: The set of coordinates specified as Cartographic values [WestLongitude, SouthLatitude, EastLongitude, NorthLatitude], with values in radians.The list of heights to be used for the bottom of the wall, instead of the surface.

wsenDegrees: None | list[float] | TimeIntervalCollection: The set of coordinates specified as Cartographic values [WestLongitude, SouthLatitude, EastLongitude, NorthLatitude], with values in degrees.The list of heights to be used for the bottom of the wall, instead of the surface.

Bases: BaseCZMLObject, Interpolatable, Deletable

Defines a rotation that transforms a vector expressed in one axes and transforms it to another.

See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The value specified as a reference to another property. See here for it’s definition.

unitQuaternion: None | list[float] | UnitQuaternionValue | TimeIntervalCollection: The value specified as four values [NearDistance, NearValue, FarDistance, FarValue], with distances in eye coordinates in meters. See here for it’s definition.

classmethod validate_reference(r)[source]

classmethod validate_unitQuaternion(q)[source]

Bases: BaseCZMLObject, Deletable

Whether or not an object casts or receives shadows from each light source when shadows are enabled.

See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The shadow mode specified as a reference to another property. See here for it’s definition.

shadowMode: None | ShadowModes | TimeIntervalCollection: The shadow mode. See here for it’s definition.

classmethod validate_reference(r)[source]

class czml3.properties.SolidColorMaterial[source]

Bases: BaseCZMLObject

A material that fills the surface with a solid color.

See here for it’s definition.

color: None | Color | str | TimeIntervalCollection: The color of the surface. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class czml3.properties.StripeMaterial[source]

Bases: BaseCZMLObject

A material that fills the surface with alternating colors.

See here for it’s definition.

evenColor: None | Color | str | TimeIntervalCollection: The even color. See here for it’s definition.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

oddColor: None | Color | str | TimeIntervalCollection: The odd color. See here for it’s definition.

offset: None | float | NumberValue | TimeIntervalCollection: The value indicating where in the pattern to begin drawing, with 0.0 being the beginning of the even color, 1.0 the beginning of the odd color, 2.0 being the even color again, and any multiple or fractional values being in between.

orientation: None | StripeOrientations | str | TimeIntervalCollection: The value indicating if the stripes are horizontal or vertical. See here for it’s definition.

repeat: None | float | NumberValue | TimeIntervalCollection: The number of times the stripes repeat.

class czml3.properties.Tileset[source]

Bases: BaseCZMLObject

A 3D Tiles tileset.

See here for it’s definition.

maximumScreenSpaceError: None | float | NumberValue | TimeIntervalCollection: The maximum screen space error used to drive level of detail refinement.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

show: None | bool | TimeIntervalCollection: Whether or not the tileset is shown.

uri: Uri | str | TimeIntervalCollection: The URI of a 3D tiles tileset. For broadest client compatibility, the URI should be accessible via Cross-Origin Resource Sharing (CORS). See here for it’s definition.

classmethod validate_uri(r)[source]

Bases: BaseCZMLObject, Deletable

A URI value. The URI can optionally vary with time.

See here for it’s definition.

checks()[source]

custom_serializer() → str | dict[str, bool | ReferenceValue] | TimeIntervalCollection | None[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The color specified as a reference to another property. See here for it’s definition.

uri: None | str | TimeIntervalCollection: The URI value.

classmethod validate_reference(r)[source]

Bases: BaseCZMLObject, Interpolatable, Deletable

A suggested initial camera position offset when tracking this object, specified as a Cartesian position. Typically defined in the East (x), North (y), Up (z) reference frame relative to the object’s position, but may use another frame depending on the object’s velocity.

See here for it’s definition.

cartesian: None | Cartesian3Value | list[float] | TimeIntervalCollection: The offset specified as a three-dimensional Cartesian value [X, Y, Z]. See here for it’s definition.

checks()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reference: None | ReferenceValue | str | TimeIntervalCollection: The offset specified as a reference to another property. See here for it’s definition.

classmethod validate_cartesian(r)[source]

classmethod validate_reference(r)[source]

class czml3.properties.Wall[source]

Bases: BaseCZMLObject

A two-dimensional wall defined as a line strip and optional maximum and minimum heights. It conforms to the curvature of the globe and can be placed along the surface or at altitude.

See here for it’s definition.

distanceDisplayCondition: None | DistanceDisplayCondition | TimeIntervalCollection: The display condition specifying at what distance from the camera this wall will be displayed. See here for it’s definition.

fill: None | bool | TimeIntervalCollection: Whether or not the wall is filled.

granularity: None | float | NumberValue | TimeIntervalCollection: The sampling distance, in radians.

material: None | Material | str | TimeIntervalCollection: The material to display on the surface of the wall. See here for it’s definition.

maximumHeights: None | list[float] | TimeIntervalCollection: The list of heights to be used for the top of the wall, instead of the height of each position.

minimumHeights: None | list[float] | TimeIntervalCollection: The list of heights to be used for the bottom of the wall, instead of the surface.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

outline: None | bool | TimeIntervalCollection: Whether or not the wall is outlined.

outlineColor: None | Color | str | TimeIntervalCollection: The color of the wall outline. See here for it’s definition.

outlineWidth: None | float | NumberValue | TimeIntervalCollection: The width of the wall outline.

positions: PositionList | TimeIntervalCollection: The array of positions defining the centerline of the wall. See here for it’s definition.

shadows: None | ShadowMode | TimeIntervalCollection: Whether or not the wall casts or receives shadows. See here for it’s definition.

show: None | bool | TimeIntervalCollection: Whether or not the wall is shown.

czml3.enums module

class czml3.enums.ArcTypes(*values)[source]

Bases: OCaseStrEnum

GEODESIC = 'GEODESIC'

NONE = 'NONE'

RHUMB = 'RHUMB'

class czml3.enums.ClassificationTypes(*values)[source]

Bases: OCaseStrEnum

BOTH = 'BOTH'

CESIUM_3D_TILE = 'CESIUM_3D_TILE'

TERRAIN = 'TERRAIN'

class czml3.enums.ClockRanges(*values)[source]

Bases: OCaseStrEnum

The behavior of a clock when its current time reaches its start or end time.

CLAMPED = 'CLAMPED'

LOOP_STOP = 'LOOP_STOP'

UNBOUNDED = 'UNBOUNDED'

class czml3.enums.ClockSteps(*values)[source]

Bases: OCaseStrEnum

SYSTEM_CLOCK = 'SYSTEM_CLOCK'

SYSTEM_CLOCK_MULTIPLIER = 'SYSTEM_CLOCK_MULTIPLIER'

TICK_DEPENDENT = 'TICK_DEPENDENT'

class czml3.enums.ColorBlendModes(*values)[source]

Bases: OCaseStrEnum

HIGHLIGHT = 'HIGHLIGHT'

MIX = 'MIX'

REPLACE = 'REPLACE'

class czml3.enums.CornerTypes(*values)[source]

Bases: OCaseStrEnum

BEVELED = 'BEVELED'

MITERED = 'MITERED'

ROUNDED = 'ROUNDED'

class czml3.enums.ExtrapolationTypes(*values)[source]

Bases: OCaseStrEnum

The type of extrapolation to perform when a value is requested at a time after any available samples.

EXTRAPOLATE = 'EXTRAPOLATE'

HOLD = 'HOLD'

NONE = 'NONE'

class czml3.enums.HeightReferences(*values)[source]

Bases: OCaseStrEnum

CLAMP_TO_GROUND = 'CLAMP_TO_GROUND'

NONE = 'NONE'

RELATIVE_TO_GROUND = 'RELATIVE_TO_GROUND'

class czml3.enums.HorizontalOrigins(*values)[source]

Bases: OCaseStrEnum

CENTER = 'CENTER'

LEFT = 'LEFT'

RIGHT = 'RIGHT'

class czml3.enums.InterpolationAlgorithms(*values)[source]

Bases: OCaseStrEnum

The interpolation algorithm to use when interpolating.

HERMITE = 'HERMITE'

LAGRANGE = 'LAGRANGE'

LINEAR = 'LINEAR'

class czml3.enums.LabelStyles(*values)[source]

Bases: OCaseStrEnum

The style of a label.

FILL = 'FILL'

FILL_AND_OUTLINE = 'FILL_AND_OUTLINE'

OUTLINE = 'OUTLINE'

class czml3.enums.OCaseStrEnum(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: StrEnum

StrEnum where enum.auto() returns the original member name, not lower-cased name.

class czml3.enums.ReferenceFrames(*values)[source]

Bases: OCaseStrEnum

The reference frame in which cartesian positions are specified.

FIXED = 'FIXED'

INERTIAL = 'INERTIAL'

class czml3.enums.ShadowModes(*values)[source]

Bases: OCaseStrEnum

CAST_ONLY = 'CAST_ONLY'

DISABLED = 'DISABLED'

ENABLED = 'ENABLED'

RECEIVE_ONLY = 'RECEIVE_ONLY'

class czml3.enums.StripeOrientations(*values)[source]

Bases: OCaseStrEnum

HORIZONTAL = 'HORIZONTAL'

VERTICAL = 'VERTICAL'

class czml3.enums.VerticalOrigins(*values)[source]

Bases: OCaseStrEnum

BASELINE = 'BASELINE'

BOTTOM = 'BOTTOM'

CENTER = 'CENTER'

TOP = 'TOP'

czml3.types module

class czml3.types.Cartesian2Value(*, values: list[float])[source]

Bases: BaseCZMLObject

A two-dimensional Cartesian value specified as [X, Y]. If the values has two elements, the value is constant. If it has three or more elements, they are time-tagged samples arranged as [Time, X, Y, Time, X, Y, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.Cartesian3ListOfListsValue(*, values: list[list[float]])[source]

Bases: BaseCZMLObject

A list of lists of three-dimensional Cartesian values specified as [X, Y, Z, X, Y, Z, …]

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[list[float]]

class czml3.types.Cartesian3ListValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A list of three-dimensional Cartesian values specified as [X, Y, Z, X, Y, Z, …]

See here for it’s definition.

custom_serializer() → list[float][source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.Cartesian3Value(*, values: list[float])[source]

Bases: BaseCZMLObject

A three-dimensional Cartesian value specified as [X, Y, Z]. If the values has three elements, the value is constant. If it has four or more elements, they are time-tagged samples arranged as [Time, X, Y, Z, Time, X, Y, Z, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer() → list[float][source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.Cartesian3VelocityValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A three-dimensional Cartesian value and its derivative specified as [X, Y, Z, dX, dY, dZ]. If the array has six elements, the value is constant. If it has seven or more elements, they are time-tagged samples arranged as [Time, X, Y, Z, dX, dY, dZ, Time, X, Y, Z, dX, dY, dZ, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer() → list[float][source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.CartographicDegreesListOfListsValue(*, values: list[list[float]])[source]

Bases: BaseCZMLObject

A list of lists of geodetic, WGS84 positions specified as [Longitude, Latitude, Height, Longitude, Latitude, Height, …], where Longitude and Latitude are in degrees and Height is in meters

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[list[float]]

class czml3.types.CartographicDegreesListValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A list of geodetic, WGS84 positions specified as [Longitude, Latitude, Height, Longitude, Latitude, Height, …], where Longitude and Latitude are in degrees and Height is in meters.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.CartographicDegreesValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A geodetic, WGS84 position specified as [Longitude, Latitude, Height], where Longitude and Latitude are in degrees and Height is in meters. If the array has three elements, the value is constant. If it has four or more elements, they are time-tagged samples arranged as [Time, Longitude, Latitude, Height, Time, Longitude, Latitude, Height, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer() → list[float][source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.CartographicRadiansListOfListsValue(*, values: list[list[float]])[source]

Bases: BaseCZMLObject

A list of lists of geodetic, WGS84 positions specified as [Longitude, Latitude, Height, Longitude, Latitude, Height, …], where Longitude and Latitude are in radians and Height is in meters

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[list[float]]

class czml3.types.CartographicRadiansListValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A list of geodetic, WGS84 positions specified as [Longitude, Latitude, Height, Longitude, Latitude, Height, …], where Longitude and Latitude are in radians and Height is in meters.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.CartographicRadiansValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A geodetic, WGS84 position specified as [Longitude, Latitude, Height], where Longitude and Latitude are in radians and Height is in meters. If the array has three elements, the value is constant. If it has four or more elements, they are time-tagged samples arranged as [Time, Longitude, Latitude, Height, Time, Longitude, Latitude, Height, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.DistanceDisplayConditionValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A value indicating the visibility of an object based on the distance to the camera, specified as two values [NearDistance, FarDistance]. If the array has two elements, the value is constant. If it has three or more elements, they are time-tagged samples arranged as [Time, NearDistance, FarDistance, Time, NearDistance, FarDistance, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.EpochValue(*, value: str | datetime)[source]

Bases: BaseCZMLObject

A value representing a time epoch.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

value: str | datetime

class czml3.types.FontValue(*, font: str)[source]

Bases: BaseCZMLObject

A font, specified using the same syntax as the CSS “font” property.

See here for it’s definition.

custom_serializer()[source]

font: str

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class czml3.types.IntervalValue(*, start: str | datetime, end: str | datetime, value: Any = None)[source]

Bases: BaseCZMLObject

Value over some interval.

custom_serializer() → dict[str, Any][source]

end: str | datetime

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

start: str | datetime

value: Any

class czml3.types.NearFarScalarValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A near-far scalar value specified as four values [NearDistance, NearValue, FarDistance, FarValue]. If the array has four elements, the value is constant. If it has five or more elements, they are time-tagged samples arranged as [Time, NearDistance, NearValue, FarDistance, FarValue, Time, NearDistance, NearValue, FarDistance, FarValue, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

Bases: BaseCZMLObject, Interpolatable, Deletable

A single number, or a list of number pairs signifying the time and representative value.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

number: int | float | list[int] | list[float] | list[int | float]: The numerical value or values.

class czml3.types.ReferenceListOfListsValue(*, values: list[list[str]])[source]

Bases: BaseCZMLObject

Represents a reference to another property. References can be used to specify that two properties on different objects are in fact, the same property.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[list[str]]

class czml3.types.ReferenceListValue(*, values: list[str])[source]

Bases: BaseCZMLObject

Represents a reference to another property. References can be used to specify that two properties on different objects are in fact, the same property.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[str]

class czml3.types.ReferenceValue(*, value: str)[source]

Bases: BaseCZMLObject

Represents a reference to another property. References can be used to specify that two properties on different objects are in fact, the same property.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

value: str

class czml3.types.RgbaValue(*, values: list[int] | list[float] | list[int | float])[source]

Bases: BaseCZMLObject

A color specified as an array of color components [Red, Green, Blue, Alpha] where each component is in the range 0-255. If the array has four elements, the color is constant. If it has five or more elements, they are time-tagged samples arranged as [Time, Red, Green, Blue, Alpha, Time, Red, Green, Blue, Alpha, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer()[source]

classmethod get_color_from_values(r)[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[int] | list[float] | list[int | float]

class czml3.types.RgbafValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A color specified as an array of color components [Red, Green, Blue, Alpha] where each component is in the range 0.0-1.0. If the array has four elements, the color is constant. If it has five or more elements, they are time-tagged samples arranged as [Time, Red, Green, Blue, Alpha, Time, Red, Green, Blue, Alpha, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer()[source]

classmethod get_color_from_values(r)[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.StringValue(*, string: str)[source]

Bases: BaseCZMLObject

A string value.

See here for it’s definition.

custom_serializer() → str[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

string: str

class czml3.types.TimeInterval(*, start: str | datetime, end: str | datetime)[source]

Bases: BaseCZMLObject

A time interval, specified in ISO8601 interval format.

custom_serializer() → str[source]

end: str | datetime

classmethod format_time(time)[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

start: str | datetime

class czml3.types.TimeIntervalCollection(*, values: list[TimeInterval] | list[IntervalValue])[source]

Bases: BaseCZMLObject

A collection of time intervals, specified in ISO8601 interval format.

See here for it’s definition.

custom_serializer() → list[Any][source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[TimeInterval] | list[IntervalValue]

class czml3.types.UnitCartesian3Value(*, values: list[float])[source]

Bases: BaseCZMLObject

A three-dimensional unit magnitude Cartesian value specified as [X, Y, Z]. If the array has three elements, the value is constant. If it has four or more elements, they are time-tagged samples arranged as [Time, X, Y, Z, Time, X, Y, Z, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer() → list[float][source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.UnitQuaternionValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A set of 4-dimensional coordinates used to represent rotation in 3-dimensional space. It’s specified as [X, Y, Z, W]. If the array has four elements, the value is constant. If it has five or more elements, they are time-tagged samples arranged as [Time, X, Y, Z, W, Time, X, Y, Z, W, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.UnitSphericalValue(*, values: list[float])[source]

Bases: BaseCZMLObject

A unit spherical value specified as [Clock, Cone] angles. The clock angle is measured in the XY plane from the positive X axis toward the positive Y axis. The cone angle is the angle from the positive Z axis toward the negative Z axis. If the array has two elements, the value is constant. If it has three or more elements, they are time-tagged samples arranged as [Time, Clock, Cone, Time, Clock, Cone, …], where Time is an ISO 8601 date and time string or seconds since epoch.

See here for it’s definition.

custom_serializer() → list[float][source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

values: list[float]

class czml3.types.VelocityReferenceValue(*, value: str)[source]

Bases: BaseCZMLObject

Represents the normalized velocity vector of a position property. The reference must be to a position property.

See here for it’s definition.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

value: str

czml3.types.check_list_of_list_values(num_points: int, values: list[list[Any]]) → None[source]: Values that support [X, Y, Z, X, Y, Z, …]

czml3.types.check_list_of_values(num_points: int, values: list[Any]) → None[source]: Values that support [X, Y, Z, X, Y, Z, …]

czml3.types.check_reference(r: str | None) → None[source]

czml3.types.check_values(num_points: int, values: list[Any]) → None[source]: Values that support [X, Y, Z] or [Time, X, Y, Z, Time, X, Y, Z, …]

czml3.types.format_datetime_like(dt_object: None | str | datetime) → str | None[source]

czml3.types.get_color(color: None | list[int | float], max_val: int | float) → list[int | float] | None[source]: Determines if the input is a valid color

czml3.core module

class czml3.core.Document(*, packets: list[Packet])[source]

Bases: BaseCZMLObject

A CZML document, consisting on a list of packets.

custom_serializer()[source]

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

packets: list[Packet]

classmethod validate_packets(packets)[source]

Bases: BaseCZMLObject

A CZML Packet. Describes the graphical properties of a single object in a scene, such as a single aircraft.

See here for it’s definition.

availability: None | TimeInterval | TimeIntervalCollection: The set of time intervals over which data for an object is available. The property can be a single string specifying a single interval, or an array of strings representing intervals. A later CZML packet can update this availability if it changes or is found to be incorrect. For example, an SGP4 propagator may initially report availability for all time, but then later the propagator throws an exception and the availability can be adjusted to end at that time. If this optional property is not present, the object is assumed to be available for all time. Availability is scoped to a particular CZML stream, so two different streams can list different availability for a single object. Within a single stream, the last availability stated for an object is the one in effect and any availabilities in previous packets are ignored. If an object is not available at a time, the client will not draw that object.

billboard: None | Billboard | TimeIntervalCollection: A billboard, or viewport-aligned image, sometimes called a marker. The billboard is positioned in the scene by the position property.

box: None | Box | TimeIntervalCollection: A box, which is a closed rectangular cuboid. The box is positioned and oriented using the position and orientation properties.

clock: None | Clock | IntervalValue: The clock settings for the entire data set. Only valid on the document object.

corridor: None | Corridor | TimeIntervalCollection: A corridor, which is a shape defined by a centerline and width.

cylinder: None | Cylinder | TimeIntervalCollection: A cylinder, truncated cone, or cone defined by a length, top radius, and bottom radius. The cylinder is positioned and oriented using the position and orientation properties.

delete: None | bool: Whether the client should delete all existing data for this object, identified by ID. If true, all other properties in this packet will be ignored.

description: None | str | StringValue | TimeIntervalCollection: An HTML description of the object.

ellipse: None | Ellipse | TimeIntervalCollection: An ellipse, which is a closed curve on the surface of the Earth. The ellipse is positioned using the position property.

ellipsoid: None | Ellipsoid | TimeIntervalCollection: An ellipsoid, which is a closed quadric surface that is a three-dimensional analogue of an ellipse. The ellipsoid is positioned and oriented using the position and orientation properties.

id: str: The ID of the object described by this packet. IDs do not need to be GUIDs, but they do need to uniquely identify a single object within a CZML source and any other CZML sources loaded into the same scope. If this property is not specified, the client will automatically generate a unique one. However, this prevents later packets from referring to this object in order to add more data to it.

label: None | Label | TimeIntervalCollection: A string of text. The label is positioned in the scene by the position property.

model: None | Model | TimeIntervalCollection: A 3D model. The model is positioned and oriented using the position and orientation properties.

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: None | str | TimeIntervalCollection: The name of the object. It does not have to be unique and is intended for user consumption.

orientation: None | Orientation | TimeIntervalCollection: The orientation of the object in the world. The orientation has no direct visual representation, but it is used to orient models, cones, pyramids, and other graphical items attached to the object.

parent: None | str | TimeIntervalCollection: The ID of the parent object, if any.

path: None | Path | TimeIntervalCollection: A path, which is a polyline defined by the motion of an object over time. The possible vertices of the path are specified by the position property.

point: None | Point | TimeIntervalCollection: A point, or viewport-aligned circle. The point is positioned in the scene by the position property.

polygon: None | Polygon | TimeIntervalCollection: A polygon, which is a closed figure on the surface of the Earth.

polyline: None | Polyline | TimeIntervalCollection: A polyline, which is a line in the scene composed of multiple segments.

position: None | Position | PositionList | PositionListOfLists | TimeIntervalCollection: The position of the object in the world. The position has no direct visual representation, but it is used to locate billboards, labels, and other graphical items attached to the object.

properties: None | Any | TimeIntervalCollection: A set of custom properties for this object.

rectangle: None | Rectangle | TimeIntervalCollection: A cartographic rectangle, which conforms to the curvature of the globe and can be placed along the surface or at altitude.

tileset: None | Tileset | TimeIntervalCollection: A 3D Tiles tileset.

version: None | str: The CZML version being written. Only valid on the document object.

viewFrom: None | ViewFrom | TimeIntervalCollection: A suggested camera location when viewing this object. The property is specified as a Cartesian position in the East (x), North (y), Up (z) reference frame relative to the object’s position.

wall: None | Wall | TimeIntervalCollection: A two-dimensional wall which conforms to the curvature of the globe and can be placed along the surface or at altitude.

czml3.base module

class czml3.base.BaseCZMLObject[source]

Bases: BaseModel

check_delete() → Self[source]

dumps(**kwargs: Any) → str[source]

Serialize the object to a JSON string.

kwargs are passed to BaseModel.model_dump_json().

Returns:: JSON string representation of the object with None values excluded
Return type:: str

model_config = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to_dict(**kwargs: Any) → dict[str, Any][source]

Return the object as a dictionary.

kwargs are passed to BaseModel.model_dump().

Returns:: Dictionary representation of the object with None values excluded
Return type:: dict

to_json(*, indent: int = 4, **kwargs: Any) → str[source]

Return the object as a formatted JSON string.

kwargs are passed to BaseModel.model_dump_json().

Parameters:: indent (int, optional) – Number of spaces for indentation, defaults to 4
Returns:: Formatted JSON string representation with None values excluded
Return type:: str

czml3.common module

class czml3.common.Deletable(*, delete: None | bool = None)[source]

Bases: BaseModel

A property whose value may be deleted.

delete: None | bool: Whether the client should delete existing samples or interval data for this property. Data will be deleted for the containing interval, or if there is no containing interval, then all data. If true, all other properties in this property will be ignored.

model_config = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Bases: BaseModel

The base schema for a property whose value may be determined by interpolating over provided time-tagged samples.

backwardExtrapolationDuration: None | int | float: The duration of time to extrapolate backwards before the first provided sample time.

backwardExtrapolationType: None | ExtrapolationTypes: The type of extrapolation to use when extrapolating backwards.

classmethod check(e)[source]

epoch: None | str | dt.datetime | TimeIntervalCollection: The epoch to use for times specified as seconds since an epoch.

forwardExtrapolationDuration: None | int | float: The duration of time to extrapolate forwards after the last provided sample time.

forwardExtrapolationType: None | ExtrapolationTypes: The type of extrapolation to use when extrapolating forwards.

interpolationAlgorithm: None | InterpolationAlgorithms | TimeIntervalCollection: The interpolation algorithm to use when interpolating. Valid values are LINEAR, LAGRANGE, and HERMITE.

interpolationDegree: None | int | TimeIntervalCollection: The degree of interpolation to use when interpolating.

model_config = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

czml3.constants module

czml3.widget module

class czml3.widget.CZMLWidget(*, document: Document = Document(packets=[Packet(id='document', delete=None, name='name', parent=None, description=None, version='1.0', clock=None, availability=None, properties=None, position=None, orientation=None, viewFrom=None, billboard=None, box=None, corridor=None, cylinder=None, ellipse=None, ellipsoid=None, label=None, model=None, path=None, point=None, polygon=None, polyline=None, rectangle=None, tileset=None, wall=None)]), cesium_version: str = '1.88', ion_token: str = '', terrain: str = 'new Cesium.EllipsoidTerrainProvider()', imagery: str = 'new Cesium.OpenStreetMapImageryProvider()', container_id: str = '<function uuid4>')[source]

Bases: BaseModel

build_script() → str[source]

cesium_version: str

container_id: str

document: Document

imagery: str

ion_token: str

model_config = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

terrain: str

to_html(widget_height: str = '400px') → str[source]