Python Scripting Command Reference

 
Classes
       
CE

 
class CE
    The interface for scripting the CityEngine.
 
  Methods defined here:
addAnalysisLayer(self, name)
Add a layer that can contain analysis objects.
 
@param name: The name to give the new layer.  [str]
@return: The new analysis layer.
 
@example:
# create a new analyis layer in the current scene.
ce.addAnalysisLayer('My Analysis Layer')
addAttributeLayer(self, name, texture=None, heightmap=None, useGeoRef=False)
Adds a new attribute layer to the current CityEngine scene.
 
@param name: The name of the new attribute layer.  [str]
@param texture: The texture to be used for the layer or null if no texture. (default  = None). [str]
@param heightmap: The height to be used for the layer or null if no heightmap. (default  = None). [str]
@param useGeoRef: If true, and the texture or heightmap contains georeference information, the layer will be positioned using the georeference data. If both contain georeference information the heightmap wins. (default  = False). [True/False]
@return: The added layer.
 
@example:
# add a new attribute Layer with name 'new attribute layer', and no texture
l = ce.addAttributeLayer('newAttributeLayer')
# add a new terrain attribute Layer with name 'Terrain',
# and the files map.png and elevation.png for texture and heightmap using georeferenced position
l = ce.addAttributeLayer('Terrain', "maps/map.png", "maps/elevation.png", True)
# and set the layer attributes to define an elevation
ce.setLayerAttributes(l, "attr elevation = map_01(brightness, 0.0, 100.0)")
addGraphLayer(self, name)
Adds a new graph layer to the current CityEngine scene.
 
@param name: The name of the new graph layer.  [str]
@return: The added layer.
 
@example:
# add a new shape Layer with name 'new graph layer'
ce.addGraphLayer('new graph layer')
addScriptMenuItems(self, scriptPath)
Adds one or more scripts to the script menu.
 
@param scriptPath: Absolute filesystem path to the script.  [sequence of str]
@return: True if all scripts have been successfully added, false otherwise. [True/False]
 
@example:
# Scripts can be used from inside or outside the workspace
# Add the script located at path to the menu
print ce.addScriptMenuItems([path])
addShapeLayer(self, name)
Adds a new shape layer to the current CityEngine scene.
 
@param name: The name of the new shape layer.  [str]
@return: The added layer.
 
@example:
# add a new shape Layer with name 'new shape layer'
ce.addShapeLayer('new shape layer')
addStaticModelLayer(self, name)
Adds a new static model layer to the current CityEngine scene.
 
@param name: The name of the new static model layer.  [str]
@return: The added layer.
 
@example:
# add a new static model layer name 'Landmarks',
l = ce.addStaticModelLayer('Landmarks')
alignGraph(self, graph, settings=None)
Align graph network.
 
@param graph: The set of graph objects to align. 
@param settings: The align settings. Omit to use default settings. (default  = None).
 
@example:
#align the graph layer 'streets' to the 'Heightmap' layer
graph = ce.getObjectsFrom(ce.scene, ce.withName('streets'))
settings = AlignGraphSettings()
settings.setHeightmap('Heightmap')
ce.alignGraph(graph, settings)
alignShapes(self, shapes, settings=None)
Aligns a set of shapes.
 
@param shapes: The set of shapes to align. 
@param settings: The align settings. Omit to use default settings. (default  = None).
 
@example:
# align shapes of layer 'Lots' to layer 'Heightmap'
lotLayer = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Lots'"))
settings = AlignShapesSettings()
settings.setHeightmap('Heightmap')
settings.setAlignFunction(AlignShapesSettings.TRANSLATE_TO_MIN)
ce.alignShapes(lotLayer, settings)
alignStaticModels(self, models, settings=None)
Aligns a set of static models.
 
@param models: The set of static models to align. 
@param settings: The align settings. Omit to use default settings. (default  = None).
 
@example:
# align static models in layer 'Landmarks' to layer 'Heightmap'
staticModelLayer = ce.getObjectsFrom(ce.scene, ce.isStaticModelLayer, ce.withName("'Landmarks'"))
settings = AlignStaticModelsSettings()
settings.setHeightmap('Heightmap')
ce.alignStaticModels(staticModelLayer, settings)
alignTerrain(self, shapes=None, settings=None)
Aligns the terrain to the specified shapes.
 
@param shapes: The shapes to align the terrain to (default  = None).
@param settings: (Optional) The AlignTerrainSettings to apply. Omit to use default values. (default  = None).
 
@example:
# Aligns the terrain to the given shapes to apply to
ce.alignTerrain( ce.getObjectsFrom(ce.scene, ce.isShape) )
analyzeGraph(self, layer, settings=None)
Runs the analyze graph tool.
 
@param layer: A graph layer or street segments to analyze .
@param settings: The analyze graph settings. Omit to use default settings. (default  = None).
 
@example:
# analyze the connectivity of the given segments or graph layers
graph = ce.getObjectsFrom(ce.scene, ce.isGraphLayer)
ce.analyzeGraph(graph)
cleanupGraph(self, graph, settings=None)
Cleanup graph networks (intersect segments and merge nodes).
 
@param graph: The initial set of street graph objects to clean. 
@param settings: The cleanup settings. Omit to use default settings. (default  = None).
 
@example:
# cleanup alls graph layers in scene
cleanupSettings = CleanupGraphSettings()
cleanupSettings.setIntersectSegments(True)
cleanupSettings.setMergeNodes(True)
cleanupSettings.setMergingDist(10)
cleanupSettings.setSnapNodesToSegments(True)
cleanupSettings.setSnappingDist(10)
cleanupSettings.setResolveConflictShapes(True)
graphlayer = ce.getObjectsFrom(ce.scene, ce.isGraphLayer)
ce.cleanupGraph(graphlayer, cleanupSettings)
cleanupShapes(self, shapes, settings=None)
Applies the cleanup shape tool to given shape(s).
 
@param shapes: The set of shapes to cleanup. 
@param settings: The cleanup settings. Omit to use default settings. (default  = None).
 
@example:
# Tidies the geometry of the given shape(s)
shape = ce.getObjectsFrom(ce.scene, ce.withName("'newShape'"))
ce.cleanupShapes(shape)
closeFile(self, workspacePath=None)
Closes the currently open CityEngine scene or given workspace file.
 
@param workspacePath: Workspace path of the file to close or null to close current scene. (default  = None). [str]
 
@example:
# close the scene newcity.cej
ce.closeFile('scenes/newcity.cej')
combineShapes(self, shapes)
Combines all the selected shapes into a single shape.
 
@param shapes: The set of shapes to combine. 
@return: result.
 
@example:
# Combine the given lot shapes into a single shape
combinedShape = ce.combineShapes( [ ce.findByOID("90dd0000-0030-1bbc-4fe5-86e1dfcd11b4"),ce.findByOID("90dd0000-0030-1bbc-4fe4-0d46dfcd11b4") ] )
computeFirstStreetEdges(self, shapes)
Sets the first edge and street edges of a set of shapes from nearby roads.
 
@param shapes: The set of shapes to find first and street edges for, and the streets edges to fit to. 
 
@example:
# set first edge of static shape, and assign street edge attributes. If no shapes are selected, all visible shapes are used. If no street segments are selected, all visible segments are used.
shapes = ce.getObjectsFrom(ce.scene, ce.isShape, ce.withName("'Block 1'"))
ce.computeFirstStreetEdges(shapes)
convertModelsToShapes(self, models)
Convert models to shapes.
 
@param models: The models to convert. 
@return: The created shapes.
 
@example:
#convert models to static shapes
models = ce.selection()
shapes = ce.convertModelsToShapes(models)
print "new shape converted from model: "+ce.getName(shapes[0])
convertToStaticShapes(self, objects)
Creates a static shape from the selected dynamic shapes.
 
@param objects: A collection of dynamic shapes or graph layers to convert to static shapes. 
@return: The created mesh layer.
 
@example:
# convert dynamic shapes to static shapes
shapes = ce.getObjectsFrom(ce.scene, ce.isShape)
staticShapesLayer = ce.convertToStaticShapes(shapes)
copy(self, toCopy, delete=False, layer=None)
Copy the selected objects. Can also be used to move the objects to a new layer.
 
@param toCopy: The objects to copy. 
@param delete: If true the original objects are deleted. (default  = False). [True/False]
@param layer: The layer to copy the objects to; without this argument objects remain on their existing layers. (default  = None).
@return: The new objects. [sequence]
 
@example:
# Copies selected objects either on the same layer, or between different layers. If the
# requested layer isn't of a compatible type, the objects are copied into the existing layer
result = ce.copy ( ce.getObjectsFrom( graphLayer, ce.isGraphSegment ) )
ce.move (result, [-30, 0, 20]);
#copy the segments to a different layer
graphLayer2 = ce.addGraphLayer('streets_c2')
result = ce.copy ( ce.getObjectsFrom( graphLayer, ce.isGraphSegment ), False, graphLayer2 )
ce.move (result, [-200, 0, 20]);
# copy the entire layer
graphLayer3 = ce.copy (graphLayer2)[0]
ce.setName(graphLayer3, "streets_c3")
ce.move (ce.getObjectsFrom( graphLayer3), [-200, 0, 20]);
# move a segment to a different layer using delete=True
result = ce.copy ( getObjectsFrom(graphLayer3, ce.isGraphSegment)[1], True, graphLayer )
ce.move (result, [370, 0, 0]);
# segments are invalid on a shape layer, so remain on the original layer
shapeLayer = ce.addShapeLayer('streets_shapes')
result = ce.copy (  getObjectsFrom(graphLayer3, ce.isGraphSegment), False, shapeLayer )
ce.move (result, [-60, 0, 20]);
createGraphSegments(self, layer, vertices)
Create connected graph segments.
 
@param layer: The graph layer to add the segments to, or 'None' in order to create a new layer. 
@param vertices: An array of (unstructured) floating point values.  [sequence of float]
@return: The list of created graph segments. [sequence]
 
@example:
# create two graph segments on new layer 'streets'
graphlayer = ce.addGraphLayer('streets')
vertices = [400,0,-200,400,0,-280,480,0,-290]
graph = ce.createGraphSegments(graphlayer, vertices)
vertices = [420,0,-220,350,0,-220]
graph = ce.createGraphSegments(graphlayer, vertices)
createShape(self, layer, vertices)
Create shape.
 
@param layer: The shape layer to add the shape to, or 'None' in order to create a new layer. 
@param vertices: An array of (unstructured) floating point values.  [sequence of float]
@return: The created shape.
 
@example:
# create an shape by specifying a vertex list
vertices = [0,300,0,0,300,200,300,300,200,300,300,0]
shape = ce.createShape(None, vertices)
ce.setName(shape, "my Shape")
createStaticModel(self, layer, pos, staticModelFile)
Create static model.
 
@param layer: The static model layer to add the static model to, or 'None' in order to create a new layer. 
@param pos: An array of three floating point values.  [sequence of float]
@param staticModelFile: The filename of the static model.  [str]
@return: The created static model.
 
@example:
# create a new static model from file antenna_1.obj into layer 'Landmarks' at position [-1000,0,2000]
# staticModelFile must be an absolute workspace path
landmarkLayer = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Landmarks'"))[0]
staticModelFile = "/general/assets/obj/antenna_1.obj"
staticModel = ce.createStaticModel(landmarkLayer, [-1000,0,2000], staticModelFile)
print "staticModel: ", staticModel
createViewCorridor(self, observerPoint, POI, layer)
Add a View Corridor to the scene.
 
@param observerPoint: A double list representing the observer position.  [sequence of float]
@param POI: A double list representing the point of interest.  [sequence of float]
@param layer: The analysis layer in which the View Corridor should be created. 
@return: The new View Corridor object.
 
@example:
# create a View Corridor object with the observer at (20, 0, 0) and the point of interest (-20, 10, 10).
ce.createViewCorridor([ 20, 0, 0], [-20, 10, 10], None)
createViewDome(self, observerPoint, radius, layer)
Add a View Dome to the scene.
 
@param observerPoint: A double list representing the observer position.  [sequence of float]
@param radius: The radius of the View Dome.  [float]
@param layer: The analysis layer in which the View Dome should be created. 
@return: The new View Dome object.
 
@example:
# create a View Dome object with the observer at (20, 30, 10) and the radius 20.
ce.createViewDome([ 20, 30, 10], 20, None)
createViewshed(self, observerPoint, poI, layer)
Add a Viewshed to the scene.
 
@param observerPoint: A double list representing the observer position.  [sequence of float]
@param poI: A double list representing the point of interest.  [sequence of float]
@param layer: The analysis layer in which the Viewshed should be created. 
@return: The new Viewshed object.
 
@example:
# create a Viewshed object with the observer at (20, 0, 0) and the point of interest (-20, 10, 10).
ce.createViewshed([ 20, 0, 0], [-20, 10, 10], None)
curveAutoSmooth(self, objects, settings=None)
Runs the curves auto smooth tool.
 
@param objects: A collection of graph nodes and/or edges .
@param settings: The curves auto smooth settings. Omit to use default settings. (default  = None).
 
@example:
# automatically set curve handles depending on threshold angle
segments = ce.getObjectsFrom(ce.scene, ce.isGraphSegment)
settings = CurveAutoSmoothSettings()
settings.setThresholdAngle(30)
settings.setHorizontalOptimize(True)
ce.curveAutoSmooth(segments, settings)
delete(self, object=None)
Deletes objects or a workspace file.
 
@param object: Objects or a file to delete, or null for current selection. (default  = None).
 
@example:
# delete all objects in scene
ce.delete(ce.getObjectsFrom(ce.scene))
deleteAttribute(self, objects, name)
Deletes the named object attribute.
 
@param objects: The objects to delete the attribute from. 
@param name: The attribute name.  [str]
 
@example:
# delete the attribute height from the currently selected objects
ce.deleteAttribute(ce.selection(), 'height')
exit(self, save=False)
Safely shuts down CityEngine and optionally saves any open scene.
 
@param save: If true, any open scene will be saved. (default  = False). [True/False]
export(self, objects, settings, interactive=False)
Export the given objects.
 
@param objects: The objects to be exported. 
@param settings: The export settings. 
@param interactive: Run the export interactive (let user finish dialog). (default  = False). [True/False]
 
@example:
# batch generate and export selected shapes as obj with default settings
settings = OBJExportModelSettings()
ce.export(ce.selection(), settings)
exportRPK(self, settings)
Creates a rule package according to settings.
 
@param settings: The rule package settings. 
 
@example:
# export a CGA file to a rule package
settings = RPKExportSettings()
settings.setRuleFile("/general/rules/rpkassets_simple.cga")
settings.setFile(ce.toFSPath("/general/data/rpk/rpkassets_simple_01.rpk"))
settings.addFilesAutomatically()
ce.exportRPK(settings)
findByOID(self, oid)
Get an object specified by a specific Object IDentifier
 
@param oid: The OID string
@return: The objects with the given ID, or null if no such object exists
 
@example:
# returns the object with given Object Identifier, if any
object = ce.findByOID(oid)
ce.setSelection (object)
fitStreetWidths(self, objects, settings=None)
Runs the fit street widths to shapes tool.
 
@param objects: A collection of graph nodes and/or edges .
@param settings: The fit widths to shapes settings. Omit to use default settings. (default  = None).
 
@example:
# Settings specify how streets widths are increased to meet static geometry
segments = ce.getObjectsFrom(ce.scene, ce.isGraphSegment)
ce.fitStreetWidths(segments)
segments = ce.getObjectsFrom(ce.scene, ce.isGraphSegment)
# optional use of settings:
settings = FitStreetWidthSettings()
settings.setAdjustStreetOffsets(False)
settings.setMinStreetWidth(1)
settings.setMaxStreetWidth(50)
settings.setAdditionalMargin(1)
settings.setSidewalkScale("DONT")
ce.fitStreetWidths(segments, settings)
generateBridges(self, objects, settings=None)
Runs the generate bridges tool.
 
@param objects: A collection of graph nodes and/or edges .
@param settings: The generate bridges settings. Omit to use default settings. (default  = None).
 
@example:
# Organise crossing streets vertically so they do not intersect. Takes hints from layer or absolute height attributes
graphlayer = ce.getObjectsFrom(ce.scene, ce.isGraphLayer, ce.withName("Streetnetwork"))[0]
segments = ce.getObjectsFrom(graphlayer, ce.isGraphSegment)
settings = GenerateBridgeSettings()
ce.generateBridges(segments, settings)
generateModels(self, shapes, synchronous=True, updateSeed=False)
Generate the models for the selected shapes.
 
@param shapes: The set of shapes to use for generation. 
@param synchronous: If true, the this operation will block until all models are generated. If false, the generation will take place in the background. (default  = True). [True/False]
@param updateSeed: If true, the seed will be updated before generation. (default  = False). [True/False]
@return: result. [sequence]
 
@example:
# generate models on selected shapes
ce.generateModels(ce.selection())
# generate models on selected shapes in async mode
ce.generateModels(ce.selection(), False)
get3DViews(self)
Gets the currently open 3D views.
 
@return: All open 3D views. [sequence]
 
@example:
# print list of currently opened 3D views
views = ce.get3DViews()
print views
getAnglesOfView(self, object)
Returns the angles of view of the Viewshed or View Corridor object.
 
@param object: The Viewshed or View Corridor object to query. 
@return: The angles of view the Viewshed object. [sequence of float]
 
@example:
# print the view angles for one of the Viewsheds in the scene.
viewshed = ce.getObjectsFrom(ce.scene, ce.isViewshed)[0]
angles = ce.getAnglesOfView(viewshed)
print "Horizontal:", angles[0], "Degrees, Vertical", angles [1], "Degrees"
getAttribute(self, object, name)
Get the named object attribute or None if the attribute does not exist.
 
@param object: The object to get the attribute from. 
@param name: The attribute name.  [str]
@return: The object attribute or None if the attribute does not exist.
 
@example:
# print value of object attribute 'height' of currently selected object
print ce.getAttribute(ce.selection()[0], 'height')
# print value of user-set rule parameter 'areaName' of currently selected object
print ce.getAttribute(ce.selection()[0], '/ce/rule/areaName')
# print block parameter 'shapeCreation' of block 'BlockSouth_8'
block = ce.getObjectsFrom(ce.scene, ce.withName("'BlockSouth_8'"))[0]
print ce.getAttribute(block, '/ce/block/shapeCreation')
# print street parameter 'streetWidth' of segment 'ShapeFile Segment 3148'
streetsegment = ce.getObjectsFrom(ce.scene, ce.withName("'ShapeFile Segment 3148'"))[0]
print ce.getAttribute(streetsegment, '/ce/street/streetWidth')
# print crossing parameter 'type' of node 'Shapefile Node 4496'
nodes = ce.getObjectsFrom(ce.scene, ce.withName("'Shapefile Node 4496'"))[0]
print ce.getAttribute(nodes, '/ce/crossing/type')
getAttributeLayerExtents(self, layer)
Returns the X-Z extents of an attribute layer.
 
@param layer: The attribute layer to get the extents from. 
@return: List consisting of four values. [sequence]
 
@example:
# get position and size of the layer "Terrain" 
l = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Terrain'"))[0]
print ce.getAttributeLayerExtents(l)
getAttributeList(self, object)
Get a list of object attributes.
 
@param object: The object get the attribute list from. 
@return: A list of object attribute names. [sequence]
 
@example:
# print a list of all attribute names  of the currently selected object
print ce.getAttributeList(ce.selection()[0])
getAttributeSource(self, object, name)
Set the attribute source of the given attribute for the given objects.
 
@param object: The object to get the attribute source from. 
@param name: The name of the attribute of which the source will be returned.  [str]
@return: result.
 
@example:
# get source of attribute 'height'
print ce.getAttributeSource(ce.selection()[0], 'height')
getColorGeometry(self, object)
Returns whether the visibility object colors the geometry or not.
 
@param object: The visibility object to query. 
@return: True if the visibility object colors scene geometry. [True/False]
 
@example:
# print whether the first View Dome colors geometry in the scene.
dome = ce.getObjectsFrom(ce.scene, ce.isViewDome)[0]
print ce.getColorGeometry(dome)
getCurveHandle(self, segment, node)
Get the curve handle associated with a street segment.
 
@param segment: The street segment whose handle will by returned by this command. 
@param node: Either the node associated with the start of the street, or the end. This specifies whether this command will return the first or second curve handle. 
@return: The vector defining the direction and distance of the curve handle [x, y, z]. [sequence]
 
@example:
# Gets the location of curve handle at the node's end of the specified segment
graphLayer = ce.getObjectsFrom(ce.scene, ce.isGraphLayer)[0]
segment = ce.getObjectsFrom(graphLayer, ce.isGraphSegment)[0]
node = ce.getObjectsFrom(segment, ce.isGraphNode)[1]
direction = ce.getCurveHandle( segment, node)
getLayer(self, object)
Get the layer of the specified object.
 
@param object: The object to get the layer from. 
@return: The object's layer or null if the object does not provide a layer.
 
@example:
# print the name of the layer containing the selected object
print ce.getLayer(ce.selection()[0])
getLayerAttributes(self, layer)
Returns the attribute code of the specified layer.
 
@param layer: The layer to get the attributes from. 
@return: Layer attributes. [str]
 
@example:
# print the layer attributes code of the layer "Terrain" 
l = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Terrain'"))[0]
print ce.getLayerAttributes(l)
getLayerPreferences(self, layer, preference)
Returns the specified group or layer preference.
 
@param layer: The layer or group to get the preference from. 
@param preference: "Visible", "Locked", "Show Network", "Show Blocks", "Colored", "Color" . [str]
@return: Layer Preference. [True, False, None, list with 3 numbers].
 
@example:
# print the visible preference of one layer
l = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Heightmap'"))[0]
print ce.getLayerPreferences(l,"Visible")
# print the layer color of "Heightmap"
ce.setLayerPreferences(l, "Colored", True)
ce.setLayerPreferences(l, "Color", [0, 0, 1])
print ce.getLayerPreferences(l, "Color") # prints [0, 0, 1]
getName(self, object)
Get the name of the specified object (if the object has a name).
 
@param object: The object to get the name from. 
@return: The object's name or null if the object does not provide a name. [str]
 
@example:
# print name of selected object
print ce.getName(ce.selection()[0])
getOID(self, object)
Get the OID (Object IDentifier) of the specified layer or object.
 
@param object: The layer or layer object to get the OID from. 
@return: The object's OID or null if the object is not of required type. [str]
 
@example:
# returns the unique Object IDentifier string of the given object
oid = ce.getOID( ce.getObjectsFrom( ce.scene, ce.withName("newShape") )[0] )
print oid
getObjectsFrom(self, container, *filters)
Get child objects from container with optional filters
 
@param container: The parent container
@param *filters: Optional filter constraints
@return: The filtered set of child objects
 
@example:
# return list of objects from different containers, using optional filters
# if the argument is a list, it will be filtered given the specified filters.
# if the argument is a single object it will be expanded to adjacent objects, given the specified filters.
# all objects in selection
selectedObjects = ce.getObjectsFrom(ce.selection)
# all shapes in selection
selectedShapes = ce.getObjectsFrom(ce.selection, ce.isShape)
# all objects in the scene
allSceneObjects = ce.getObjectsFrom(ce.scene)
# all shapes in the scene
sceneShapes = ce.getObjectsFrom(ce.scene, ce.isShape)
# shapes with a specific name
myShape = ce.getObjectsFrom(ce.scene, ce.isShape, ce.withName("'my Shape'"))
# all generated models in scene
models = ce.getObjectsFrom(ce.scene, ce.isModel)
# all layers in the scene
layers = ce.getObjectsFrom(ce.scene, ce.isLayer)
# layers with a specific name / type
streetlayer = ce.getObjectsFrom(ce.scene, ce.withName("'Streetnetwork'"))[0]
lotLayers = ce.getObjectsFrom(ce.scene, ce.isShapeLayer, ce.withName("*Lot*"))
# all objects in a layer
streetlayerObjects = ce.getObjectsFrom(streetlayer)
# a block with a specific name
block = ce.getObjectsFrom(ce.scene, ce.isBlock, ce.withName("BlockSouth_21"))[0]
# all files in a specific folder
files = ce.getObjectsFrom("/general/scenes/", ce.isFile)
# using a single object expands the selection
segments    = ce.getObjectsFrom(streetlayer, ce.isGraphSegment)
segment     = segments[0]
# the two adjacent nodes from a segment
segNodes    = ce.getObjectsFrom(segment          , ce.isGraphNode)
# the adjacent segments of a node
segments    = ce.getObjectsFrom(segNodes[0]      , ce.isGraphSegment)
# the 0, 1 or 2 blocks adjacent to a street segment
blocks      = ce.getObjectsFrom(segments[0]      , ce.isBlock)
# the surrounding street segments from a block
blockSegs   = ce.getObjectsFrom(block            , ce.isGraphSegment)
# the surrounding street nodes from a block
blockNodes  = ce.getObjectsFrom(block            , ce.isGraphNode)
# models from shapes
models      = ce.getObjectsFrom(ce.scene         , ce.isModel)
# the shapes associated with a model
modelShapes = ce.getObjectsFrom(models[0]        , ce.isShape)
# lots shapes from a block
lots        = ce.getObjectsFrom(block            , ce.isShape)
# shapes from a node or segment
nodeShapes  = ce.getObjectsFrom(blockNodes[0]    , ce.isShape)
# the static model associated with a shape
staticModels= ce.getObjectsFrom(ce.scene         , ce.isStaticModel)
# the shape associated with a static model
staticShapes= ce.getObjectsFrom(staticModels[0]  , ce.isShape)
getObserverPoint(self, object)
Returns the observer position of the visibility object.
 
@param object: The visibility object to query. 
@return: The observer position of the visibility object. [sequence of float]
 
@example:
# print the observer position of one of the view domes in the scene.
dome = ce.getObjectsFrom(ce.scene, ce.isViewDome)[0]
print ce.getObserverPoint(dome)
getPOI(self, object)
Returns the point of interest of the View Corridor object.
 
@param object: The View Corridor object to query. 
@return: The point of interest of the View Corridor object. [sequence of float]
 
@example:
# print the point of interest of one of the View Corridors in the scene.
corridor = ce.getObjectsFrom(ce.scene, ce.isViewCorridor)[0]
print ce.getPOI(corridor)
getParentGroup(self, object)
get parent Group.
 
@param object: The Group or Layer .
@return: void.
 
@example:
# get the parent group of layer "Group Child"
l = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Group Child'"))[0]
parent = ce.getParentGroup(l)
print parent
getPosition(self, objects)
Get the position of the specified objects (calculated as the centroid of all objects' vertices).
 
@param objects: The objects to get the position from. 
@return: An list containing the center [x, y, z]. [sequence]
 
@example:
# print the absolute position in world coordinates of the selected object
print ce.getPosition(ce.selection()[0])
getRuleFile(self, shape)
Gets a shape's rule file.
 
@param shape: The shape to return the rule file from. 
@return: result. [str]
 
@example:
# print rule file of selected shape
print ce.getRuleFile(ce.selection()[0])
getRuleFileInfo(self, path)
Gets information about CGA or CGB rule file.
 
@param path: The path to the rule file (e.g. from getRuleFile).  [str]
@return: The RuleFileInfo of the rule file.
 
@example:
# print all rule names found in rule file
info =  ce.getRuleFileInfo('rules/extrude.cga')
for r in info['rules']:
        print r['name']
getSceneCoordSystem(self)
Gets the scenes coordinate system.
 
@return: a string touple containing AUTH:CODE and label. None if not set.
 
@example:
# get the current scene coordinate system details
(authAndCode, label) = ce.getSceneCoordSystem()
print authAndCode
print label
getSceneHierarchy(self)
Gets scene hierarchy.
 
@return: Returns a tree object containing the root group and its children. The tree contains all layers and layer groups but not shapes, networks, blocks, etc.
 
@example:
# This example browses the tree, locks layers and unlocks layer groups.
# Layers and layer groups are set to visible.
# For layers that are graph layers networks and blocks are shown.
def processSceneElements(rootGroup):
        for child in rootGroup.getChildren(None):
                if ce.isLayer(child):
                        ce.setLayerPreferences(child, "Visible", True)
                        ce.setLayerPreferences(child, "Locked", True)
                        if ce.isGraphLayer(child):
                                ce.setLayerPreferences(child, "Show Network", True)
                                ce.setLayerPreferences(child, "Show Blocks", True)
                if ce.isLayerGroup(child):
                        ce.setLayerPreferences(child, "Visible", True)
                        ce.setLayerPreferences(child, "Locked", False)
                        processSceneElements(child)
hierarchyRoot = ce.getSceneHierarchy()
processSceneElements(hierarchyRoot)
getSeed(self, shape)
Gets a shape's seed.
 
@param shape: The shape to return the seed from. 
@return: result.
 
@example:
# print seed of selected shape
print ce.getSeed(ce.selection()[0])
getStartRule(self, shape)
Gets the Start Rule for the given shape.
 
@param shape: The shape to return the Start Rule from. 
@return: result. [str]
 
@example:
# print start rule of selected shape
print "Startrule:", ce.getStartRule(ce.selection()[0])
getTiltAndHeadingAngles(self, object)
Returns the tilt and heading angles of the Viewshed object.
 
@param object: The Viewshed object to query. 
@return: The tilt and heading angles of the Viewshed object. [sequence of float]
 
@example:
# print the tilt and heading for one of the Viewsheds in the scene.
viewshed = ce.getObjectsFrom(ce.scene, ce.isViewshed)[0]
angles = ce.getTiltAndHeadingAngles(viewshed)
print "Tilt:", angles[0],"Degrees, Heading", angles [1], "Degrees"
getTotalSolidAngle(self, viewshed)
Get the total solid angle covered by the Viewshed.
 
@param viewshed: The Viewshed . [Analysis]
@return: result. [float]
 
@example:
# get the Total Solid Angle of the Viewshed
viewshed = ce.getObjectsFrom(ce.scene, ce.isViewshed)[0]
totalAngle = ce.getTotalSolidAngle(viewshed)
print "Viewshed 1 Total Solid Angle : ", totalAngle, "steradians"
getVersion(self)
Gets Version field. CityEngine version number.
@return: Value of Version field.  [str]
 
@example:
#print CityEngine version
print ce.getVersion()
getVersionBuild(self)
Gets VersionBuild field. CityEngine build number.
@return: Value of VersionBuild field.  [int]
 
@example:
#print CityEngine build version
print ce.getVersionBuild()
getVersionMajor(self)
Gets VersionMajor field. CityEngine major number.
@return: Value of VersionMajor field.  [int]
 
@example:
#print CityEngine major string
print ce.getVersionMajor()
getVersionMinor(self)
Gets VersionMinor field. CityEngine minor number.
@return: Value of VersionMinor field.  [int]
 
@example:
#print CityEngine minor version
print ce.getVersionMinor()
getVersionString(self)
CityEngine version string.
 
@return: result. [str]
 
@example:
#print long CityEngine version string
print ce.getVersionString()
getVertices(self, object)
Get the vertices of the specified object.
 
@param object: The object to get the vertices from. 
@return: A list of (unstructured) floating point values of the object's vertices. [sequence]
 
@example:
# print the vertex list of the selected object to the console
print ce.getVertices(ce.selection()[0])
getViewDistance(self, object)
Returns the view distance of the Viewshed or View Dome object.
 
@param object: The Viewshed or View Dome object to query. 
@return: The view distance of the Viewshed or View Dome object. [float]
 
@example:
# print the view distance of one of the Viewsheds in the scene.
viewshed = ce.getObjectsFrom(ce.scene, ce.isViewshed)[0]
print ce.getViewDistance(viewshed)
getVisibleSolidAngle(self, viewshed, requestedLayers)
Get the layers' visible solid angle from the viewshed.
 
@param viewshed: The Viewshed . [Analysis]
@param requestedLayers: An array of layers . [sequence of ]
@return: result. [sequence of float]
 
@example:
# get the Solid Angles of the Viewshed per Object Layer
viewshed = ce.getObjectsFrom(ce.scene, ce.isViewshed)[0]
panoramaLayer = ce.getObjectsFrom(ce.scene, ce.withName("'Panorama'"))[0]
newShapesLayer = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'New Shapes'"))[0]
layers = [panoramaLayer,newShapesLayer]
solidAngles = ce.getVisibleSolidAngle(viewshed, layers)
print "Panorama  : ", solidAngles [0], " steradians"
print "New Shapes: ", solidAngles [1], " steradians"
getWorkspaceRoot(self)
Gets the workspace root.
 
@return: The workspace root ('/'). [str]
growStreets(self, graph, settings=None)
Creates street network starting from an initial set of graph objects.
 
@param graph: The initial set of street graph objects to grow from. 
@param settings: The street grow settings. Omit to use default settings. (default  = None).
 
@example:
# grow streets on layer 'streets'
streetlayer = ce.getObjectsFrom(ce.scene, ce.withName("streets"))
growsettings = GrowStreetsSettings()
growsettings.setEnvironmentSettingsHeightmap('Heightmap')
growsettings.setEnvironmentSettingsObstaclemap('Obstacle')
ce.growStreets(streetlayer, growsettings)
importFile(self, filesystemPath, importSettings=None, interactive=False)
Imports objects into the current scene or creates a new scene from the import data.
 
@param filesystemPath: Path to the source file (must be a filesystem path).  [str]
@param importSettings: The import settings to apply or null for default settings. (default  = None).
@param interactive: Run the import interactively (open dialog and let user finish). (default  = False). [True/False]
@return: A list of newly created layers. [sequence]
 
@example:
# import the dxf file 'sesame_streetsketch.dxf' into the scene
settings = DXFImportSettings()
settings.setScale(0.5)
settings.setOffset([10000,0,-10000])
ce.importFile(ce.toFSPath("/general/data/sesame_streetsketch.dxf"), settings)
importProject(self, projectPath, copy=False, newName=None)
Adds one project to the workspace and changes the name.
 
@param projectPath: Absolute filesystem path to the project.  [str]
@param copy: Should the data be copied instead of linked. (default  = False). [True/False]
@param newName: The name of the project after import. (default  = None). [str]
 
@example:
# Add a project residing at path (without copying or renaming it).
ce.importProject(path)
# Copy the project residing at path and add it renamed to newName).
ce.importProject(path, True, newName)
insertGraphNodes(self, segment, nodeVertices)
Insert a Node to a street segment.
 
@param segment: The street segment in which we will add nodes .
@param nodeVertices: Node Vertices to add e.g. [[1.0,2.0,3.0], [4.0,5.0,6.0]] .
@return: The New Node and the New Segment. [sequence]
 
@example:
newGeometries = ce.insertGraphNodes(segment, nodesToAdd)
for i in range(0, len(newGeometries)):
        print "segment number", i, "First  Node", ce.getVertices(newGeometries[i][1])[0:3];
        print "segment number", i, "Second Node", ce.getVertices(newGeometries[i][1])[3:6];
inspect(self, objects)
Opens the inspector and selects the given objects.
 
@param objects: The objects to inspect. 
 
@example:
# show 'sphere.obj' in the inspector view
ce.inspect('/general/assets/sphere.obj')
isAnalysisLayer(self, object)
Predicate that works in ce.getObjectsFrom(ce.scene, ce.isAnalysisLayer) to get all analysis layers.
 
@param object: The object to be tested. 
@return: True if the object is an analysis layer. [True/False]
 
@example:
# get all analysis layers in the current scene.
ce.getObjectsFrom(ce.scene, ce.isAnalysisLayer)
isAutoDerive(self, object)
Predicate that tests if the given object is a generated model.
 
@param object: The object to be tested. 
@return: True if the object is a model or false otherwise. [True/False]
isBlock(self, object)
Predicate that tests if the given object is a block.
 
@param object: The object to be tested. 
@return: True if the object is a block or false otherwise. [True/False]
 
@example:
# get list of current selection filtered by block
selectedBlocks = ce.getObjectsFrom(ce.selection, ce.isBlock)
isEnvironmentLayer(self, object)
Predicate that tests if the given object is an environment layer.
 
@param object: The object to be tested. 
@return: True if the object is an environment layer or false otherwise. [True/False]
 
@example:
# create a list of all environment layers in the scene and print it
envLayers = ce.getObjectsFrom(ce.scene, ce.isEnvironmentLayer)
print len(envLayers), envLayers
isFile(self, workspacePath)
Predicate that tests if the given workspace path is an existing file.
 
@param workspacePath: Workspace path of the file to test . [str]
@return: True if the given workspace path is an existing file or false otherwise. [True/False]
 
@example:
# print a list of all files in the workspace directory 'general/assets/textures/facade/'
print ce.getObjectsFrom('/general/assets/textures/facade/', ce.isFile)
isFolder(self, workspacePath)
Predicate that tests if the given workspace path is an existing folder.
 
@param workspacePath: Workspace path of the folder to test.  [str]
@return: True if the given workspace path is an existing folder or false otherwise. [True/False]
 
@example:
# print a list of all folder in the workspace directory 'general/assets'
print ce.getObjectsFrom('/general/assets/', ce.isFolder)
isGraphLayer(self, object)
Predicate that tests if the given object is a graph layer.
 
@param object: The object to be tested. 
@return: True if the object is a graph layer or false otherwise. [True/False]
 
@example:
# create a list of all graph layers in the scene and print it
graphLayers = ce.getObjectsFrom(ce.scene, ce.isGraphLayer)
print len(graphLayers), graphLayers
isGraphNode(self, object)
Predicate that tests if the given object is a graph node.
 
@param object: The object to be tested. 
@return: True if the object is a graph node or false otherwise. [True/False]
 
@example:
# get list of current selection filtered by graph node
selectedNodes = ce.getObjectsFrom(ce.selection, ce.isGraphNode)
isGraphSegment(self, object)
Predicate that tests if the given object is a graph segment.
 
@param object: The object to be tested. 
@return: True if the object is a graph segment or false otherwise. [True/False]
 
@example:
# create list of graph segments and print it to the console
segments = ce.getObjectsFrom(ce.scene, ce.isGraphSegment)
print len(segments), "street segments in scene"
isInspector(self, view)
Predicate that tests if the given 3D view is an inspector view.
 
@param view: A 3D view obtained from get3DViews(). 
@return: True if the given 3D view is an inspector view or false otherwise. [True/False]
 
@example:
# filter inspectors from list of views
inspectorviews = ce.getObjectsFrom(ce.get3DViews(), ce.isInspector)
print inspectorviews
isLayer(self, object)
Predicate that tests if the given object is a layer.
 
@param object: The object to be tested. 
@return: True if the object is a layer or false otherwise. [True/False]
 
@example:
# create a list of all layers in the scene and print it
layers = ce.getObjectsFrom(ce.scene, ce.isLayer)
print len(layers), layers
isLayerGroup(self, object)
Predicate that tests if the given object is a layer group.
 
@param object: The object to be tested. 
@return: True if the object is a layer group or false otherwise. [True/False]
 
@example:
# create a list of all group layers in the scene and print it
layerGroups = ce.getObjectsFrom(ce.scene, ce.isLayerGroup)
print len(layerGroups), layerGroups
isMapLayer(self, object)
Predicate that tests if the given object is a map layer.
 
@param object: The object to be tested. 
@return: True if the object is an map layer or false otherwise. [True/False]
 
@example:
# create a list of all map layers in the scene and print it
mapLayers = ce.getObjectsFrom(ce.scene, ce.isMapLayer)
print len(mapLayers), mapLayers
isModel(self, object)
Predicate that tests if the given object is a generated model.
 
@param object: The object to be tested. 
@return: True if the object is a model or false otherwise. [True/False]
 
@example:
# test if a object is a model
model = ce.getObjectsFrom(ce.selection(), ce.isModel)[0]
if ce.isModel(model) : print "is model"
else : print "is not a model"
isShape(self, object)
Predicate that tests if the given object is a shape.
 
@param object: The object to be tested. 
@return: True if the object is a shape or false otherwise. [True/False]
 
@example:
# count all shapes in scene
shapes = ce.getObjectsFrom(ce.scene, ce.isShape)
print len(shapes)
# test if selected object is a shape
object = ce.selection()[0]
if ce.isShape(object) : print ce.getName(object)+" is a shape"
else : print ce.getName(object) + "is not a shape"
isShapeLayer(self, object)
Predicate that tests if the given object is a shape layer.
 
@param object: The object to be tested. 
@return: True if the object is a shape layer or false otherwise. [True/False]
 
@example:
# create a list of all shape layers in the scene and print it
shapeLayers = ce.getObjectsFrom(ce.scene, ce.isShapeLayer)
print len(shapeLayers), shapeLayers
isStaticModel(self, object)
Predicate that tests if the given object is a static model.
 
@param object: The object to be tested. 
@return: True if the object is a static model or false otherwise. [True/False]
 
@example:
# print all static models in scene
staticModels = ce.getObjectsFrom(ce.scene, ce.isStaticModel)
print len(staticModels), staticModels
isStaticModelLayer(self, object)
Predicate that tests if the given object is a staic model layer.
 
@param object: The object to be tested. 
@return: True if the object is a static model layer or false otherwise. [True/False]
 
@example:
# create a list of all static model layers in the scene and print it
staticModelLayers = ce.getObjectsFrom(ce.scene, ce.isStaticModelLayer)
print len(staticModelLayers), staticModelLayers
isViewCorridor(self, object)
Predicate that works in ce.getObjectsFrom(ce.scene, ce.isViewCorridor) to get all View Corridors.
 
@param object: The object to be tested. 
@return: True if the object is a View Corridor object. [True/False]
 
@example:
# get all View Corridor objects from the scene.
ce.getObjectsFrom(ce.scene, ce.isViewCorridor)
isViewDome(self, object)
Predicate that works in ce.getObjectsFrom(ce.scene, ce.isViewDome) to get all View Domes.
 
@param object: The object to be tested. 
@return: True if the object is a View Dome. [True/False]
 
@example:
# get all View Dome objects from the scene.
ce.getObjectsFrom(ce.scene, ce.isViewDome)
isViewport(self, view)
Predicate that tests if the given 3D view is a CityEngine viewport.
 
@param view: A 3D view obtained from get3DViews(). 
@return: True if the given 3D view is an CityEngine viewport or false otherwise. [True/False]
 
@example:
# filter viewports from list of views
viewports = ce.getObjectsFrom(ce.get3DViews(), ce.isViewport)
print viewports
isViewshed(self, object)
Predicate that works in ce.getObjectsFrom(ce.scene, ce.isViewshed) to get all Viewsheds.
 
@param object: The object to be tested. 
@return: True if the object is a Viewshed. [True/False]
 
@example:
# get all Viewshed objects from the scene.
ce.getObjectsFrom(ce.scene, ce.isViewshed)
isVisible(self, object)
Predicate that tests if the given object is visible.
 
@param object: The object to be tested. 
@return: True if the object is visible or false otherwise. [True/False]
 
@example:
# create a list of all visible layers in the scene and print it
visibleLayers = ce.getObjectsFrom(ce.scene, ce.isVisible)
print len(visibleLayers), visibleLayers
listProjects(self)
Returns all loaded project names.
 
@return: The names of all currently loaded projects. [sequence of str]
 
@example:
# Print the name of all projects currently loaded in the workspace
print ce.listProjects()
# Print the filesystem path to the first project.
print ce.toFSPath("/" + ce.listProjects()[0])
listScriptMenuItems(self)
Lists the current content of the script menu.
 
@return: Retuns a (potentially empty) list of absolute filesystem paths. [sequence of str]
 
@example:
# List all script menu entries
print ce.listScriptMenuItems()
mergeGraphNodes(self, destinationNode, nodesToMerge)
merge a list of nodes into another.
 
@param destinationNode: The street node in which the nodes will be merged .
@param nodesToMerge: Array of Nodes, or one Node .
@return: The Resulting Node .
 
@example:
ce.mergeGraphNodes(destinationNode, nodeToMerge)
mergeLayers(self, object)
Merges the layers of the same type together.
 
@param object: The layers to merge. If other objects are specified, the objects' layers are merged as well. 
@return: The newly merged layers. [sequence]
 
@example:
# merges the selected layers of the same type to a single layer
lotlayer = ce.getObjectsFrom(ce.scene, ce.isShapeLayer, ce.withName("'Lots_1'"))[0]
streetshapelayer = ce.getObjectsFrom(ce.scene, ce.isShapeLayer, ce.withName("'Street Shapes_1'"))[0]
mergedLayers = ce.mergeLayers([lotlayer, streetshapelayer])
move(self, objects, t, objectSpace=False, pivot=None)
Move (translate) the current selection or the specified objects.
 
@param objects: The objects to be moved. 
@param t: XYZ translation vector. 
@param objectSpace: Transform in object space. (default  = False). [True/False]
@param pivot: Set pivot for transformation. (default  = None).
 
@example:
# move the selected object in world coordinates by 10 in x and 600 in y axis
object = ce.selection()[0]
t = [10,600,0]
ce.move(object, t)
newFile(self, workspacePath, interactive=False)
Creates a new workspace file.
 
@param workspacePath: Workspace path of the file to create.  [str]
@param interactive: Run the new dialog interactively (let user finish). (default  = False). [True/False]
@return: The created file.
 
@example:
# create a new scene newcity.cej in the current project
ce.newFile('scenes/newcity.cej')
openFile(self, workspacePath=None)
Opens a file in the workspace.
 
@param workspacePath: Workspace path of the file to open or null to show a file dialog. (default  = None). [str]
@return: The newly opened window.
 
@example:
# open the scene city.cej in the project general
ce.openFile('/general/scenes/city.cej')
openView(self, view)
Opens workspace view.
 
@param view: One of ['VIEWPORT','INSPECTOR','NAVIGATOR'].  [str]
 
@example:
# open inspector view
ce.openView("INSPECTOR")
project(self)
Gets the current CityEngine project name.
 
@return: the current CityEngine project name. [str]
 
@example:
#print name of current CityEngine project
print ce.project()
#print absolute path iof current CityEngine project
print ce.toFSPath(ce.project())
refreshFolder(self, refreshPath)
Refreshes the given local (workspace) path, updating the user interface and resources available to the current state of the filesystem.
 
@param refreshPath: Workspace path to refresh.  [str]
 
@example:
# refresh a specific folder
ce.refreshFolder('/general/rules/')
refreshWorkspace(self)
Refreshes the workspace.
 
 
@example:
# refresh the workspace (check for new and modified files)
ce.refreshWorkspace()
removeHoles(self, shapes)
Remove holes from selected shapes.
 
@param shapes: The set of shapes to remove the holes from. 
 
@example:
# remove the holes of the shape 
ce.removeHoles(ce.findByOID("90dd0000-0030-1bbc-4fe5-86e1dfcd11b4"))
removeProject(self, projectName)
Removes the project from the workspace (not from disk).
 
@param projectName: Name of the project.  [str]
 
@example:
# Remove the project loaded as projectName. The files are not deleted.
ce.removeProject(projectName)
removeScriptMenuItems(self, scriptPaths)
Removes one or more scripts from the scripts menu.
 
@param scriptPaths: List of absolute filesystem paths.  [sequence of str]
@return: True if all scripts have been successfully removed, false otherwise. [True/False]
 
@example:
# Remove the script at absolute location path
print ce.removeScriptMenuItems([path])
renameProject(self, currentName, newName)
Renames a currently loaded project.
 
@param currentName: Current name of the project.  [str]
@param newName: New name of the project.  [str]
 
@example:
# Rename a project from oldName to newName.
ce.renameProject(oldName, newName)
resetShapeAttributes(self, object)
Runs the reset shape attribute tool.
 
@param object: The shape(s) to reset the attribuets of .
 
@example:
# resets the start rule for dynamic shapes
shapes = ce.getObjectsFrom(ce.scene, ce.isShape)
ce.resetShapeAttributes(shapes)
resetTerrain(self, shapes=None, settings=None)
Returns the X-Z extents of an attribute layer.
 
@param shapes: (Optional) The shapes to under which to reset the terrain (if the appropriate Constraint is set). (default  = None).
@param settings: (Optional) The ResetTerrainSettings to apply. Omit to use default values. (default  = None).
 
@example:
# reverts any changes to all terrains
ce.resetTerrain()
reverseNormals(self, shapes)
Reverses the normals of the given shape(s).
 
@param shapes: The set of shapes to reverse the normals of. 
 
@example:
# reverses the normals of the given shapes
shape = ce.getObjectsFrom(ce.scene, ce.withName("'newShape'"))
ce.reverseNormals(shape)
rotate(self, objects, r, objectSpace=False, pivot=None)
Rotate the current selection or the specified objects.
 
@param objects: The objects to be rotated. 
@param r: XYZ rotation vector. 
@param objectSpace: Transform in object space. (default  = False). [True/False]
@param pivot: Set pivot for transformation. (default  = None).
 
@example:
# rotate the selected object 70 degrees around the global y axis using its local center
object = ce.selection()[0]
r = [0,70,0]
ce.rotate(object, r)
sampleBooleanLayerAttribute(self, layer, name, x, z)
Returns the sampled value of an layers boolean attribute at given X-Z location.
 
@param layer: The layer to sample from. 
@param name: The attribute name.  [str]
@param x: The X position.  [float]
@param z: The Z position.  [float]
@return: Sampled value. [True/False]
 
@example:
# get value of bool attribute "obstacle" in attribute layer "Obstacle" at position x=25, z=30
obstacleLayer = ce.getObjectsFrom(ce.scene, ce.withName("'Obstacle'"))[0]          
print ce.sampleBooleanLayerAttribute(obstacleLayer, "obstacle", 25, 30)
sampleFloatLayerAttribute(self, layer, name, x, z)
Returns the sampled value of an layers float attribute at given X-Z location.
 
@param layer: The layer to sample from. 
@param name: The attribute name.  [str]
@param x: The X position.  [float]
@param z: The Z position.  [float]
@return: Sampled value. [float]
 
@example:
# get value of float attribute "elevation" in attribute layer "Heightmap" at position of the shape 'myShape'
heightmapLayer = ce.getObjectsFrom(ce.scene, ce.withName("'Heightmap'"))[0]
shape = ce.getObjectsFrom(ce.scene, ce.isShape, ce.withName("'myShape'"))[0]
pos = ce.getPosition(shape)        
print ce.sampleFloatLayerAttribute(heightmapLayer, "elevation", pos[0], pos[2])
sampleStringLayerAttribute(self, layer, name, x, z)
Returns the sampled value of an layers string attribute at given X-Z location.
 
@param layer: The layer to sample from. 
@param name: The attribute name.  [str]
@param x: The X position.  [float]
@param z: The Z position.  [float]
@return: Sampled value. [str]
 
@example:
# get value of string attribute "name" in shape layer "LotsSouth" at position x=25, z=30
lotLayer = ce.getObjectsFrom(ce.scene, ce.withName("'areaLayer'"))[0]          
print ce.sampleStringLayerAttribute(lotLayer, "areaName", 25, 30)
saveFile(self, workspacePath=None)
Saves an open file.
 
@param workspacePath: Workspace path of the file to save or null to save the current scene. (default  = None). [str]
 
@example:
# save the open scene
ce.saveFile()
scale(self, objects, s, objectSpace=False, pivot=None)
Scale the current selection or the specified objects.
 
@param objects: The objects to be scaled. 
@param s: XYZ scale vector or uniform scale value. 
@param objectSpace: Transform in object space. (default  = False). [True/False]
@param pivot: Set pivot for transformation. (default  = None).
 
@example:
# scale the selected object in world x and z axes using its local center
object = ce.selection()[0]
s = [8,1,7]
ce.scale(object, s)
scene(self)
Gets the current CityEngine scene.
 
@return: the current CityEngine scene.
 
@example:
# print the name of the currently opened scene
print ce.scene()
#get a list of all shapes in the scene
shapes = ce.getObjectsFrom(ce.scene, ce.isShape)
selectContinuousGraphObjects(self, object, maxAngle)
Select graph objects adjacent and .
 
@param object: The initial street segments .
@param maxAngle: Connected graph edges which are parallel or have an angle lower than this value are said to be continuous and are therefore selected (in degrees).  [float]
@return: result. [sequence]
 
@example:
#find continuous graph segments with angle tolerance 25 and change their widths
segment = ce.findByOID('a5300000-0030-1bbc-bdcd-b3a0439a11b2')
continuousStreet = ce.selectContinuousGraphObjects(segment, 60)
ce.setSelection(continuousStreet)
ce.setAttributeSource(continuousStreet, "/ce/street/streetWidth", "OBJECT")
ce.setAttribute(continuousStreet, "streetWidth", 35)
selection(self)
Gets the current CityEngine selection.
 
@return: The current CityEngine selection. [sequence]
 
@example:
# print a list of selected objects to the console
print ce.selection()
separateFaces(self, shapes)
Separates all the faces in the selected shapes.
 
@param shapes: The set of shapes whose faces will be separated. 
@return: The newly created faces. [sequence]
 
@example:
shape = ce.combineShapes( [ ce.findByOID("90dd0000-0030-1bbc-4fe5-86e1dfcd11b4"),ce.findByOID("90dd0000-0030-1bbc-4fe4-0d46dfcd11b4") ] )
# Separate the faces of the 'newShape'
newShapes = ce.separateFaces(shape)
setAnglesOfView(self, object, hAngle, vAngle)
Sets the angles of view of the Viewshed or View Corridor object.
 
@param object: The Viewshed or View Corridor object to update. 
@param hAngle: The horizontal angle of view.  [float]
@param vAngle: The vertical angle of view.  [float]
 
@example:
# set the angles of view of a View Dome to 90 degrees horizontally and 45 degrees vertically.
viewshed = ce.getObjectsFrom(ce.scene, ce.isViewshed)[0]
ce.setAnglesOfView(viewshed, 90, 45)
setAttribute(self, objects, name, value)
Set the named object attribute to the given value(s) for the given objects.
 
@param objects: The objects to set the attributes to. 
@param name: The attribute name.  [str]
@param value: The new attribute value or sequence or map. 
 
@example:
# add or overwrite object attribute 'area' with value 5 on selected object
ce.setAttribute(ce.selection()[0], 'height', 12)
# add or overwrite object attribute array 'streetWidth' on selected object
ce.setAttribute(ce.selection()[0], 'streetWidth', [0,0,12,0])
# set block parameter 'shapeCreation' of block 'BlockSouth_8' to false
#  and make sure parameter source is USER
block = ce.getObjectsFrom(ce.scene, ce.withName("'BlockSouth_8'"))[0]
ce.setAttribute(block, '/ce/block/shapeCreation', False)
ce.setAttributeSource(block, '/ce/block/shapeCreation', "USER")
# set street parameter 'streetWidth' on segment 'ShapeFile Segment 3148' to 20
# and make sure parameter source is USER
streetsegment = ce.getObjectsFrom(ce.scene, ce.withName("'ShapeFile Segment 3148'"))[0]
ce.setAttribute(streetsegment, '/ce/street/streetWidth', 20)
ce.setAttributeSource(streetsegment, '/ce/street/streetWidth', "USER")
# set crossing parameter 'type' on all nodes to Roundabout
# and make sure parameter source is USER
nodes = ce.getObjectsFrom(ce.scene, ce.isGraphNode)
ce.setAttribute(nodes, '/ce/crossing/type', "Roundabout")
ce.setAttributeSource(nodes, '/ce/crossing/type', "USER")
setAttributeLayerExtents(self, layer, extents)
Returns the X-Z extents of an attribute layer.
 
@param layer: The attribute layer to set the extents to. 
@param extents: An list of four floating point values.  [sequence of float]
 
@example:
# set position (0,20) and size (3000,4000 of the layer "Terrain" 
l = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Terrain'"))[0]
ce.setAttributeLayerExtents(l, [0,20,3000,4000])
setAttributeSource(self, objects, name, source)
Set the attribute source of the given attribute for the given objects.
 
@param objects: The objects to set the attribute source to. 
@param name: The name of the attribute of which the source will be set.  [str]
@param source: The new attribute source. Either 'OBJECT' for object source, 'USER' for user source, 'RULE' for rule source, 'SHAPE' for shape source, 'DEFAULT' for default source, or an attribute layer for an attribute layer. 
 
@example:
# Change the rule parameter source of 'height' to OBJECT
ce.setAttributeSource(ce.selection(), '/ce/rule/height', 'OBJECT')
# Change the rule parameter source of 'areaName' to layer 'areaLayer'
areaLayer = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'areaLayer'"))[0]
ce.setAttributeSource(ce.selection(), '/ce/rule/areaName', areaLayer)
setColorGeometry(self, object, colorGeometry)
Sets whether the visibility object colors scene geometry.
 
@param object: The visibility object to update. 
@param colorGeometry: Whether to color geometry or not.  [True/False]
 
@example:
# set that the View Dome should not color geometry in the scene.
dome = ce.getObjectsFrom(ce.scene, ce.isViewDome)[0]
ce.setColorGeometry(dome, False)
setCurveHandle(self, segment, node, dir)
Set the curve handle associated with a street segment.
 
@param segment: The street segment whose handle will by changed by this command. 
@param node: Either the node associated with the start of the street, or the end. This specifies whether this command will change the first or second curve handle. 
@param dir: The vector defining the direction and distance of the curve handle [x, y, z]. 
 
@example:
# Sets the location of curve handle at the node's end of the specified segment
graphLayer = ce.getObjectsFrom(ce.scene, ce.isGraphLayer)[0]
segment = ce.getObjectsFrom(graphLayer, ce.isGraphSegment)[0]
node = ce.getObjectsFrom(segment, ce.isGraphNode)[1]
ce.setCurveHandle( segment, node, [-50,50,-50])
setCurveSmooth(self, objects)
Set curve to smooth state.
 
@param objects: A collection of graph nodes and/or edges. 
 
@example:
# set curve handles to smooth state
segments = ce.getObjectsFrom(ce.scene, ce.isGraphSegment)
ce.setCurveSmooth(segments)
setCurveStraight(self, objects)
Set curve to straight state.
 
@param objects: A collection of graph nodes and/or edges. 
 
@example:
# set curve handles to sraight state
segments = ce.getObjectsFrom(ce.scene, ce.isGraphSegment)
ce.setCurveStraight(segments)
setFirstEdge(self, shape, firstEdge)
Specifies the first edge of a shape.
 
@param shape: The shape to specify the first edge of. 
@param firstEdge: The index of the new first edge.  [int]
 
@example:
# Increment the first edge of the selected shape by one
selectedShape = ce.getObjectsFrom(ce.scene, ce.withName("'newShape'"))[0]
print ce.getVertices(selectedShape)
ce.setFirstEdge(selectedShape, 1)
print ce.getVertices(selectedShape)
setLayerAttributes(self, layer, code)
Set the attribute code of the specified layer.
 
@param layer: The layer to set the attributes to. 
@param code: The function attribute code to be set.  [str]
 
@example:
# set the attribute elevation in the layer attribute code of the layer "Terrain" 
l = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Terrain'"))[0]
ce.setLayerAttributes(l, "attr elevation = brightness*150")
setLayerPreferences(self, layer, preference, value)
Set Group or Layer Preference.
 
@param layer: The Group or Layer .
@param preference: "Visible", "Locked", "Show Network", "Show Blocks", "Colored", "Color" . [str]
@param value: True, False or color (list of 3 numbers [0..1] or string #RRGGBB) .
 
@example:
# set visibility of the layer "Heightmap"
l = ce.getObjectsFrom(ce.scene, ce.isLayer, ce.withName("'Heightmap'"))[0]  
ce.setLayerPreferences(l, "Visible", True)
# enable coloring of layer "Heightmap"
ce.setLayerPreferences(l, "Colored", True)
# set color of the layer "Heightmap" via hex string
ce.setLayerPreferences(l, "Color", "#00FF00")
# set color of the layer "Heightmap" via float list
ce.setLayerPreferences(l, "Color", [1.0, 0.0, 0.0])
# disable coloring of layer "Heightmap"
ce.setLayerPreferences(l, "Colored", False)
setName(self, objects, name)
Set the name of the specified object.
 
@param objects: The objects to set the name to. 
@param name: The name to be set.  [str]
 
@example:
# set name of selected object to 'new Shape'
ce.setName(ce.selection()[0], 'my Shape')
setObserverPoint(self, object, observerPoint)
Sets the observer position of the visibility object.
 
@param object: The visibility object to update. 
@param observerPoint: The desired observer position as a list of 3 floating point values.  [sequence of float]
 
@example:
# update the observer position of one of the view domes in the scene to (30, 40, 50).
dome = ce.getObjectsFrom(ce.scene, ce.isViewDome)[0]
ce.setObserverPoint(dome, [30, 40, 50])
setPOI(self, object, poI)
Sets the point of interest of the View Corridor object.
 
@param object: The View Corridor object to update. 
@param poI: The desired poi as a list of 3 floating point values.  [sequence of float]
 
@example:
# sets the point of interest of a View Corridor to (20, 30, 40).
corridor = ce.getObjectsFrom(ce.scene, ce.isViewCorridor)[0]
ce.setPOI(corridor, [20, 30, 40])
setPosition(self, objects, position)
Set the position of the specified objects.
 
@param objects: The layer or layer objects to set the position to. 
@param position: An list containing the center [x, y, z] .
 
@example:
# set the absolute position in world coordinates of the selected object
object = ce.selection()[0]
position = [0,0,1000]
ce.setPosition(object, position)
setRuleFile(self, shapes, workspacePath=None, hasToExist=False)
Assigns a rule file to shapes.
 
@param shapes: The set of shapes to assign the rule file to. 
@param workspacePath: The workspace path of the CGA rule file to assign, or None to interactively select a file. (default  = None). [str]
@param hasToExist: Assign the CGA rule file only if it exists. (default  = False). [True/False]
 
@example:
# assign the rulefile extrude.cga to all selected shapes
ce.setRuleFile(ce.selection(), 'extrude.cga')
setSceneCoordSystem(self, description)
Sets the current scene coordinate system (does NOT relocate the scene).
 
@param description: The coordinate system description als AUTH:CODE, proj4 or WKT format.  [str]
 
@example:
# set scene coordinate system with proj4 string
proj4 = '+proj=lcc +lat_1=34.03333333333333 +lat_2=35.46666666666667 +lat_0=33.5 +lon_0=-118 +x_0=2000000 +y_0=500000 +datum=NAD83 +units=m +no_defs  +__auth=EPSG +__code=26945'
ce.setSceneCoordSystem(proj4)
# set scene coordinate system with WKT format
wkt = 'PROJCS["NAD_1983_StatePlane_California_V_FIPS_0405",GEOGCS["GCS_North_American_1983",DATUM["D_North_American_1983",SPHEROID["GRS_1980",6378137.0,298.257222101]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Lambert_Conformal_Conic"],PARAMETER["False_Easting",2000000.0],PARAMETER["False_Northing",500000.0],PARAMETER["Central_Meridian",-118.0],PARAMETER["Standard_Parallel_1",34.03333333333333],PARAMETER["Standard_Parallel_2",35.46666666666667],PARAMETER["Latitude_Of_Origin",33.5],UNIT["Meter",1.0]]'
ce.setSceneCoordSystem(wkt)
# set scene coordinate system with AUTH:CODE
ce.setSceneCoordSystem("EPSG:26954")
ce.setSceneCoordSystem("No_Projection:Meter")
setSeed(self, shapes, seed=None)
Sets the seed of shapes.
 
@param shapes: The set of shapes to set the seed. 
@param seed: The new seed to be set or None to reset the seed. (default  = None).
 
@example:
# set seed of selected shape to 1234
ce.setSeed(ce.selection()[0], 1234)
setSelection(self, objects)
Sets the current CityEngine selection to the given object(s).
 
@param objects: The objects to select. 
 
@example:
# select shape with name 'new Shape'
shapes = ce.getObjectsFrom(ce.scene, ce.withName("'new Shape'"))
ce.setSelection(shapes)
# clear selection
ce.setSelection(None)
setStartRule(self, shapes, rule)
Sets the Start Rule for the given shapes.
 
@param shapes: The set of shapes to set the Start Rule. 
@param rule: The new Start Rule.  [str]
 
@example:
# set start rule of selected shape to 'Park'
ce.setStartRule(ce.selection()[0], 'Park')
setStreetEdges(self, shape, edges)
Specifies the streetWidth values for a shape.
 
@param shape: The shape to specify streetWidths for. 
@param edges: The street widths of adjacent streets, or -1 for none.  [sequence of float]
 
@example:
# Set the streetWidth object attributes of the selected shape
selectedShape = ce.getObjectsFrom(ce.scene, ce.withName("'newShape'"))[0]
ce.setStreetEdges(selectedShape, [1,0,1,2,-1,-1,1,2])
setTiltAndHeadingAngles(self, object, tilt, heading)
Sets the tilt and heading angles of the Viewshed object.
 
@param object: The Viewshed object to update. 
@param tilt: The tilt angle.  [float]
@param heading: The heading angle.  [float]
 
@example:
# set the tilt and heading angle of a View Dome to be 45 degrees down and 120 degrees from north.
viewshed = ce.getObjectsFrom(ce.scene, ce.isViewshed)[0]
ce.setTiltAndHeadingAngles(viewshed, -45, 120)
setVertices(self, object, vertices)
Set vertices of the specified object.
 
@param object: The object to set the vertices to. 
@param vertices: An list of (unstructured) floating point values. The size of the array must be the same as the size of array that getVertices returns.  [sequence of float]
 
@example:
# modify the vertices of the selected object by specifying a vertex list
object = ce.selection()[0]
vertices = [10,0,0,0,0,20,30,0,40,50,0,0]
ce.setVertices(ce.selection()[0], vertices)
setViewDistance(self, object, distance)
Sets the view distance of the Viewshed or View Dome object.
 
@param object: The Viewshed or View object to update. 
@param distance: The view distance.  [float]
 
@example:
# sets the view distance of a View Dome to be 60m.
viewshed = ce.getObjectsFrom(ce.scene, ce.isViewshed)[0]
ce.setViewDistance(viewshed, 60)
showDashboard(self)
show Dashboard.
 
@return: .
simplifyGraph(self, objects, settings=None)
Runs the simplify graph tool. Fits curves to straight streets.
 
@param objects: A collection of graph nodes and/or edges .
@param settings: The simplify graph settings. Omit to use default settings. (default  = None).
 
@example:
# Fit curves to short, straight street segments
graphlayer = ce.getObjectsFrom(ce.scene, ce.isGraphLayer, ce.withName("Streetnetwork"))[0]
segments = ce.getObjectsFrom(graphlayer, ce.isGraphSegment)
settings = SimplifyGraphSettings()
settings.setThresholdAngle(10)
ce.simplifyGraph(segments, settings)
splitGraphNodes(self, node, nodeSegments)
Insert a Node to a street segment.
 
@param node: The street node to duplicate .
@param nodeSegments: segments to split  .
@return: The New Node and the New Segment.
 
@example:
ce.splitGraphNodes(node, segment)
subdivideShapes(self, shapes, settings=None)
Subdivides a set of shapes using a block to lot algorithm.
 
@param shapes: The set of shapes to subdivide. 
@param settings: The subdivision settings. Omit to use default settings. (default  = None).
@return: The new lot shapes. [sequence]
 
@example:
# subdivide shapes in scene
shapes = ce.getObjectsFrom(ce.scene, ce.isShape, ce.withName("'Block 1'"))
subdsettings = SubdivideShapesSettings()
subdsettings.setLotAreaMax(800)
ce.subdivideShapes(shapes, subdsettings)
textureShapeTool(self, objects, settings)
Runs the fit shape texturing tool.
 
@param objects: A collection of shapes .
@param settings: The shape texturing tool settings. 
 
@example:
shapes = ce.getObjectsFrom(ce.scene, ce.isShape, ce.withName("'Block 1'"))
ta = TexturingSettings()
ta.setTextureFile("maps/map.png")
ce.textureShapeTool(shapes[0], ta)
toFSPath(self, workspacePath)
Converts the local (workspace) path to an absolute file system path.
 
@param workspacePath: Workspace path to convert to a absolute file system path.  [str]
@return: An absolute file system path. [str]
 
@example:
# print the absolute path of the file 'scenes/city.cej' to the console
print ce.toFSPath('scenes/city.cej')
unionShapes(self, shapes)
Boolean union of all the selected shapes into a single shape.
 
@param shapes: The set of shapes to perform boolean union upon. 
@return: result.
 
@example:
# unify the two shapes 
shape = ce.unionShapes( [ ce.findByOID("90dd0000-0030-1bbc-4fe5-86e1dfcd11b4"), ce.findByOID("90dd0000-0030-1bbc-4fe4-0d46dfcd11b4") ] )
upload(self, settings)
Uploads a file to ArcGIS Portal.
 
@param settings: The upload settings. 
 
@example:
        # upload a 3ws to an ArcGIS portal
        uploadsettings = PortalUploadSettings()
        uploadsettings.setFile("/general/models/3ws/materialTest58.3ws")
        uploadsettings.setTitle("3ws_Script_Upload")
        uploadsettings.setDescription("3ws from apidoctest script cga0")
        uploadsettings.setUsername(username)
        uploadsettings.setPassword(password)
        ce.upload(uploadsettings)
waitForUIIdle(self)
Wait until the user interface is idle (e.g. no UI action is running, all animations have finished and all generated models are visible).
 
 
@example:
# pause script until frame() finishes
views = ce.getObjectsFrom(ce.get3DViews())
views[0].frame()
ce.waitForUIIdle()
print "frame finished"
withName(self, pattern)
Matches for a given file name pattern.
 
@param pattern: The pattern.  [str]
@return: A matcher for the given pattern.
 
@example:
# get a list of all scene objects whose name starts with 'Lot'
lotobjects =  ce.getObjectsFrom(ce.scene, ce.withName("'Lot 824*'"))
print lotobjects
# get object whose name is exactly 'new Shape'
lot =  ce.getObjectsFrom(ce.scene, ce.withName("'new Shape'"))
print lot

Data and other attributes defined here:
INSPECTOR = 'INSPECTOR'
NAVIGATOR = 'NAVIGATOR'
VIEWPORT = 'VIEWPORT'

Copyright ©2008-2018 Esri R&D Center Zurich. All rights reserved.