scenic.syntax.veneer

Python implementations of Scenic language constructs.

This module is automatically imported by all Scenic programs. In addition to defining the built-in functions, operators, specifiers, etc., it also stores global state such as the list of all created Scenic objects.

Summary of Module Members

Functions

Ahead	The ‘ahead of X [by Y]’ polymorphic specifier.
AngleFrom	The ‘angle from <vector> to <vector>’ operator.
AngleTo	The ‘angle to <vector>’ operator (using the position of ego as the reference).
ApparentHeading	The ‘apparent heading of <oriented point> [from <vector>]’ operator.
ApparentlyFacing	The ‘apparently facing <heading> [from <vector>]’ specifier.
At	The ‘at <vector>’ specifier.
Back	The ‘back of <object>’ operator.
BackLeft	The ‘back left of <object>’ operator.
BackRight	The ‘back right of <object>’ operator.
Behind	The ‘behind X [by Y]’ polymorphic specifier.
Beyond	The ‘beyond X by Y [from Z]’ polymorphic specifier.
CanSee	The ‘X can see Y’ polymorphic operator.
DistanceFrom	The ‘distance from <vector> [to <vector>]’ operator.
Facing	The ‘facing X’ polymorphic specifier.
FacingToward	The ‘facing toward <vector>’ specifier.
FieldAt	The ‘<VectorField> at <vector>’ operator.
Follow	The ‘follow <field> from <vector> for <number>’ operator.
Following	The ‘following F [from X] for D’ specifier.
Front	The ‘front of <object>’ operator.
FrontLeft	The ‘front left of <object>’ operator.
FrontRight	The ‘front right of <object>’ operator.
In	The ‘in/on <region>’ specifier.
Left	The ‘left of <object>’ operator.
LeftSpec	The ‘left of X [by Y]’ polymorphic specifier.
OffsetAlong	The ‘X offset along H by Y’ polymorphic operator.
OffsetAlongSpec	The ‘offset along X by Y’ polymorphic specifier.
OffsetBy	The ‘offset by <vector>’ specifier.
RelativeHeading	The ‘relative heading of <heading> [from <heading>]’ operator.
RelativePosition	The ‘relative position of <vector> [from <vector>]’ operator.
RelativeTo	The ‘X relative to Y’ polymorphic operator.
Right	The ‘right of <object>’ operator.
RightSpec	The ‘right of X [by Y]’ polymorphic specifier.
Uniform
Visible	The ‘visible <region>’ operator.
VisibleFrom	The ‘visible from <Point>’ specifier.
VisibleSpec	The ‘visible’ specifier (equivalent to ‘visible from ego’).
With	The ‘with <property> <value>’ specifier.
activate	Activate the veneer when beginning to compile a Scenic module.
alwaysProvidesOrientation	Whether a Region or distribution over Regions always provides an orientation.
deactivate	Deactivate the veneer after compiling a Scenic module.
ego	Function implementing loads and stores to the ‘ego’ pseudo-variable.
getAllGlobals	Find all names the given lambda depends on, along with their current bindings.
isActive	Are we in the middle of compiling a Scenic module?
leftSpecHelper
mutate	Function implementing the mutate statement.
param	Function implementing the param statement.
registerExternalParameter	Register a parameter whose value is given by an external sampler.
registerObject	Add a Scenic object to the global list of created objects.
require	Function implementing the require statement.
resample	The built-in resample function.
verbosePrint	Built-in function printing a message when the verbosity is >0.

Member Details

class Vector(x, y)

Bases: scenic.core.distributions.Samplable, collections.abc.Sequence

A 2D vector, whose coordinates can be distributions.

rotatedBy(angle)

Return a vector equal to this one rotated counterclockwise by the given angle.

class Region(name, *dependencies, orientation=None)

Bases: scenic.core.distributions.Samplable

Abstract class for regions.

intersect(other, triedReversed=False)

Get a Region representing the intersection of this one with another.

static uniformPointIn(region)

Get a uniform Distribution over points in a Region.

uniformPoint()

Sample a uniformly-random point in this Region.

Can only be called on fixed Regions with no random parameters.

uniformPointInner()

Do the actual random sampling. Implemented by subclasses.

containsPoint(point)

Check if the Region contains a point. Implemented by subclasses.

containsObject(obj)

Check if the Region contains an Object.

The default implementation assumes the Region is convex; subclasses must override the method if this is not the case.

getAABB()

Axis-aligned bounding box for this Region. Implemented by some subclasses.

orient(vec)

Orient the given vector along the region’s orientation, if any.

class PointSetRegion(name, points, kdTree=None, orientation=None, tolerance=1e-06)

Bases: scenic.core.regions.Region

Region consisting of a set of discrete points.

No Object can be contained in a PointSetRegion, since the latter is discrete. (This may not be true for subclasses, e.g. GridRegion.)

Parameters

• name (str) – name for debugging

• points (iterable) – set of points comprising the region

• kdtree (scipy.spatial.KDTree, optional) – k-D tree for the points (one will be computed if none is provided)

• orientation (VectorField, optional) – orientation for the region

• tolerance (float, optional) – distance tolerance for checking whether a point lies in the region

class PolygonalRegion(points=None, polygon=None, orientation=None)

Bases: scenic.core.regions.Region

Region given by one or more polygons (possibly with holes)

class PolylineRegion(points=None, polyline=None, orientation=True)

Bases: scenic.core.regions.Region

Region given by one or more polylines (chain of line segments)

class Workspace(region=<scenic.core.regions.AllRegion object>)

Bases: scenic.core.regions.Region

A workspace describing the fixed world of a scenario

show(plt)

Render a schematic of the workspace for debugging

zoomAround(plt, objects, expansion=2)

Zoom the schematic around the specified objects

scenicToSchematicCoords(coords)

Convert Scenic coordinates to those used for schematic rendering.

class Range(low, high)

Bases: scenic.core.distributions.Distribution

Uniform distribution over a range

class Options(opts)

Bases: scenic.core.distributions.MultiplexerDistribution

Distribution over a finite list of options.

Specified by a dict giving probabilities; otherwise uniform over a given iterable.

class Normal(mean, stddev)

Bases: scenic.core.distributions.Distribution

Normal distribution

Discrete

alias of scenic.core.distributions.Options

class VerifaiParameter(domain)

Bases: scenic.core.external_params.ExternalParameter

An external parameter sampled using one of VerifAI’s samplers.

static withPrior(dist, buckets=None)

Creates a VerifaiParameter using the given distribution as a prior.

Since the VerifAI cross-entropy sampler currently only supports piecewise-constant distributions, if the prior is not of that form it may be approximated. For most built-in distributions, the approximation is exact: for a particular distribution, check its bucket method.

class VerifaiRange(low, high, buckets=None, weights=None)

Bases: scenic.core.external_params.VerifaiParameter

A Range (real interval) sampled by VerifAI.

class VerifaiDiscreteRange(low, high, weights=None)

Bases: scenic.core.external_params.VerifaiParameter

A DiscreteRange (integer interval) sampled by VerifAI.

class VerifaiOptions(opts)

Bases: scenic.core.distributions.Options

An Options (discrete set) sampled by VerifAI.

class Mutator

Bases: object

An object controlling how the mutate statement affects an Object.

A Mutator can be assigned to the mutator property of an Object to control the effect of the mutate statement. When mutation is enabled for such an object using that statement, the mutator’s appliedTo method is called to compute a mutated version.

appliedTo(obj)

Return a mutated copy of the object. Implemented by subclasses.

class Point(*args, **kwargs)

Bases: scenic.core.object_types.Constructible

Implementation of the Scenic class Point.

The default mutator for Point adds Gaussian noise to position with a standard deviation given by the positionStdDev property.

Attributes

• position (Vector) – Position of the point. Default value is the origin.

• visibleDistance (float) – Distance for can see operator. Default value 50.

• width (float) – Default value zero (only provided for compatibility with operators that expect an Object).

• height (float) – Default value zero.

class OrientedPoint(*args, **kwargs)

Bases: scenic.core.object_types.Point

Implementation of the Scenic class OrientedPoint.

The default mutator for OrientedPoint adds Gaussian noise to heading with a standard deviation given by the headingStdDev property, then applies the mutator for Point.

Attributes

• heading (float) – Heading of the OrientedPoint. Default value 0 (North).

• viewAngle (float) – View cone angle for can see operator. Default value \(2\pi\).

class Object(*args, **kwargs)

Bases: scenic.core.object_types.OrientedPoint, scenic.core.geometry.RotatedRectangle

Implementation of the Scenic class Object.

Attributes

• width (float) – Width of the object, i.e. extent along its X axis. Default value 1.

• height (float) – Height of the object, i.e. extent along its Y axis. Default value 1.

• allowCollisions (bool) – Whether the object is allowed to intersect other objects. Default value False.

• requireVisible (bool) – Whether the object is required to be visible from the ego object. Default value True.

• regionContainedIn (Region or None) – A Region the object is required to be contained in. If None, the object need only be contained in the scenario’s workspace.

• cameraOffset (Vector) – Position of the camera for the can see operator, relative to the object’s position. Default 0 @ 0.

class PropertyDefault(requiredProperties, attributes, value)

Bases: object

A default value, possibly with dependencies.

resolveFor(prop, overriddenDefs)

Create a Specifier for a property from this default and any superclass defaults.

ego(obj=None)

Function implementing loads and stores to the ‘ego’ pseudo-variable.

The translator calls this with no arguments for loads, and with the source value for stores.

require(reqID, req, line, prob=1)

Function implementing the require statement.

resample(dist)

The built-in resample function.

verbosePrint(msg)

Built-in function printing a message when the verbosity is >0.

param(*quotedParams, **params)

Function implementing the param statement.

mutate(*objects)

Function implementing the mutate statement.

Visible(region)

The ‘visible <region>’ operator.

FieldAt(X, Y)

The ‘<VectorField> at <vector>’ operator.

RelativeTo(X, Y)

The ‘X relative to Y’ polymorphic operator.

Allowed forms:

F relative to G (with at least one a field, the other a field or heading) <vector> relative to <oriented point> (and vice versa) <vector> relative to <vector> <heading> relative to <heading>

OffsetAlong(X, H, Y)

The ‘X offset along H by Y’ polymorphic operator.

Allowed forms:

<vector> offset along <heading> by <vector> <vector> offset along <field> by <vector>

RelativePosition(X, Y=None)

The ‘relative position of <vector> [from <vector>]’ operator.

If the ‘from <vector>’ is omitted, the position of ego is used.

RelativeHeading(X, Y=None)

The ‘relative heading of <heading> [from <heading>]’ operator.

If the ‘from <heading>’ is omitted, the heading of ego is used.

ApparentHeading(X, Y=None)

The ‘apparent heading of <oriented point> [from <vector>]’ operator.

If the ‘from <vector>’ is omitted, the position of ego is used.

DistanceFrom(X, Y=None)

The ‘distance from <vector> [to <vector>]’ operator.

If the ‘to <vector>’ is omitted, the position of ego is used.

AngleTo(X)

The ‘angle to <vector>’ operator (using the position of ego as the reference).

AngleFrom(X, Y)

The ‘angle from <vector> to <vector>’ operator.

Follow(F, X, D)

The ‘follow <field> from <vector> for <number>’ operator.

CanSee(X, Y)

The ‘X can see Y’ polymorphic operator.

Allowed forms:

<point> can see <object> <point> can see <vector>

With(prop, val)

The ‘with <property> <value>’ specifier.

Specifies the given property, with no dependencies.

At(pos)

The ‘at <vector>’ specifier.

Specifies ‘position’, with no dependencies.

In(region)

The ‘in/on <region>’ specifier.

Specifies ‘position’, with no dependencies. Optionally specifies ‘heading’ if the given Region has a preferred orientation.

Beyond(pos, offset, fromPt=None)

The ‘beyond X by Y [from Z]’ polymorphic specifier.

Specifies ‘position’, with no dependencies.

Allowed forms:

beyond <vector> by <number> [from <vector>] beyond <vector> by <vector> [from <vector>]

If the ‘from <vector>’ is omitted, the position of ego is used.

VisibleFrom(base)

The ‘visible from <Point>’ specifier.

Specifies ‘position’, with no dependencies.

This uses the given object’s ‘visibleRegion’ property, and so correctly handles the view regions of Points, OrientedPoints, and Objects.

VisibleSpec()

The ‘visible’ specifier (equivalent to ‘visible from ego’).

Specifies ‘position’, with no dependencies.

OffsetBy(offset)

The ‘offset by <vector>’ specifier.

Specifies ‘position’, with no dependencies.

OffsetAlongSpec(direction, offset)

The ‘offset along X by Y’ polymorphic specifier.

Specifies ‘position’, with no dependencies.

Allowed forms:

offset along <heading> by <vector> offset along <field> by <vector>

Facing(heading)

The ‘facing X’ polymorphic specifier.

Specifies ‘heading’, with dependencies depending on the form:

facing <number> – no dependencies; facing <field> – depends on ‘position’.

FacingToward(pos)

The ‘facing toward <vector>’ specifier.

Specifies ‘heading’, depending on ‘position’.

ApparentlyFacing(heading, fromPt=None)

The ‘apparently facing <heading> [from <vector>]’ specifier.

Specifies ‘heading’, depending on ‘position’.

If the ‘from <vector>’ is omitted, the position of ego is used.

LeftSpec(pos, dist=0)

The ‘left of X [by Y]’ polymorphic specifier.

Specifies ‘position’, depending on ‘width’. See other dependencies below.

Allowed forms:

left of <oriented point> [by <scalar/vector>] – optionally specifies ‘heading’; left of <vector> [by <scalar/vector>] – depends on ‘heading’.

If the ‘by <scalar/vector>’ is omitted, zero is used.

RightSpec(pos, dist=0)

The ‘right of X [by Y]’ polymorphic specifier.

Specifies ‘position’, depending on ‘width’. See other dependencies below.

Allowed forms:

right of <oriented point> [by <scalar/vector>] – optionally specifies ‘heading’; right of <vector> [by <scalar/vector>] – depends on ‘heading’.

If the ‘by <scalar/vector>’ is omitted, zero is used.

Ahead(pos, dist=0)

The ‘ahead of X [by Y]’ polymorphic specifier.

Specifies ‘position’, depending on ‘height’. See other dependencies below.

Allowed forms:

• ahead of <oriented point> [by <scalar/vector>] – optionally specifies ‘heading’;

• ahead of <vector> [by <scalar/vector>] – depends on ‘heading’.

If the ‘by <scalar/vector>’ is omitted, zero is used.

Behind(pos, dist=0)

The ‘behind X [by Y]’ polymorphic specifier.

Specifies ‘position’, depending on ‘height’. See other dependencies below.

Allowed forms:

behind <oriented point> [by <scalar/vector>] – optionally specifies ‘heading’; behind <vector> [by <scalar/vector>] – depends on ‘heading’.

If the ‘by <scalar/vector>’ is omitted, zero is used.

Following(field, dist, fromPt=None)

The ‘following F [from X] for D’ specifier.

Specifies ‘position’, and optionally ‘heading’, with no dependencies.

Allowed forms:

following <field> [from <vector>] for <number>

If the ‘from <vector>’ is omitted, the position of ego is used.

Front(X)

The ‘front of <object>’ operator.

Back(X)

The ‘back of <object>’ operator.

Left(X)

The ‘left of <object>’ operator.

Right(X)

The ‘right of <object>’ operator.

FrontLeft(X)

The ‘front left of <object>’ operator.

FrontRight(X)

The ‘front right of <object>’ operator.

BackLeft(X)

The ‘back left of <object>’ operator.

BackRight(X)

The ‘back right of <object>’ operator.