Visible/Non Visible Specifier Changes

docs/porting.rst

@@ -53,5 +53,7 @@ Specifically:
 
 * The specifier :specifier:`with heading {X}` is replaced with :specifier:`facing {X}`.
 
+* The :specifier:`visible` and :specifier:`not visible` will behave as they did in Scenic 2. Specifically, :specifier:`visible` will specify position from the observing object's visible region and :specifier:`not visible` will specify position from the difference of the workspace and the observing object's visible region.
+
 Note that despite these changes, Scenic will still use 3D geometry internally.
 For example, if you write :scenic:`ego = new Object at (1, 2)` the value of :scenic:`ego.position` will be the 3D vector :scenic:`(1, 2, 0)`.

docs/reference/specifiers.rst

@@ -192,8 +192,11 @@ visible [from (*Point* | *OrientedPoint*)]
 
 Requires that this object is visible from the :scenic:`ego` or the given `Point`/`OrientedPoint`. See the :ref:`Visibility System <visibility>` reference for a discussion of the visibility model.
 
-Also optionally specifies :prop:`position` to be a uniformly random point in the :term:`visible region` of the ego, or of the given Point/OrientedPoint if given.
-Note that the position set by this specifier is slightly stricter than simply adding a requirement that the ego :keyword:`can see` the object: the specifier makes the *center* of the object (its :prop:`position`) visible, while the :keyword:`can see` condition will be satisfied even if the center is not visible as long as some other part of the object is visible.
+Also optionally specifies :prop:`position` to be uniformly random over all points that could result in a visible object (note that the above requirement will ensure the object is in fact visible).
+
+.. versionchanged:: 3.0
+
+    This specifier now specifies position uniformly randomly over all points that could result in a visible object. This accounts for objects who's position might be out of the visible region, but who have a portion of their occupied space visible (e.g. a corner that is visible), which would never be generated with the previous semantics.
 
 .. _not visible [from ({Point} | {OrientedPoint})]:
 
@@ -209,8 +212,12 @@ not visible [from (*Point* | *OrientedPoint*)]
 
 Requires that this object is *not* visible from the ego or the given `Point`/`OrientedPoint`.
 
-Similarly to :sampref:`visible [from ({Point} | {OrientedPoint})]`, this specifier can position the object uniformly at random in the *non-visible* region of the ego.
-However, it depends on :prop:`regionContainedIn`, in order to restrict the non-visible region to the :term:`container` of the object being created, which is hopefully a bounded region (if the non-visible region is unbounded, it cannot be uniformly sampled from and an error will be raised).
+Similarly to :sampref:`visible [from ({Point} | {OrientedPoint})]`, this specifier can optionally position the object uniformly at random over all points that could result in a non-visible object (note that the above requirement will ensure the object is in fact not-visible).
+
+.. versionchanged:: 3.0
+
+    This specifier now specifies position uniformly randomly over all points that could result in a non-visible object. This accounts for objects who's position might be out of the visible region, but who have a portion of their occupied space visible (e.g. a corner that is visible), which could be generated with the previous semantics (and now will not).
+
 
 .. _(left | right) of {vector} [by {scalar}]:
 .. _left of:

docs/syntax_guide.rst

@@ -219,9 +219,9 @@ Additional specifiers for the :prop:`position` and :prop:`orientation` propertie
    * - :sampref:`beyond {vector} by ({vector} | {scalar}) [from ({vector} | {OrientedPoint})]`
      - Positions the object with respect to the line of sight from a point or the ego
    * - :sampref:`visible [from ({Point} | {OrientedPoint})]`
-     - Ensures the object is visible from the ego, or from the given Point/OrientedPoint if given, while optionally specifying position to be in the appropriate visible region.
+     - Ensures the object is visible from the ego, or from the given Point/OrientedPoint if given, while optionally specifying position to be uniformly random over all positions that result in a visible object.
    * - :sampref:`not visible [from ({Point} | {OrientedPoint})]`
-     - Ensures the object is not visible from the ego, or from the given Point/OrientedPoint if given, while optionally specifying position to be outside the appropriate visible region.
+     - Ensures the object is not visible from the ego, or from the given Point/OrientedPoint if given, while optionally specifying position to be uniformly random over all positions that result in a non-visible object.
    * - :sampref:`(left | right) of ({vector} | {OrientedPoint} | {Object}) [by {scalar}] <left of>`
      - Positions the object to the left/right by the given scalar distance.
    * - :sampref:`(ahead of | behind) ({vector} | {OrientedPoint} | {Object}) [by {scalar}] <ahead of>`

src/scenic/core/pruning.py

@@ -237,31 +237,14 @@ def pruneContainment(scenario, verbosity):
                 container = container.buffer(-maxErosion)
             elif isinstance(container, MeshVolumeRegion):
                 # We can attempt to erode a voxel approximation of the MeshVolumeRegion.
-                # Compute a voxel overapproximation of the mesh. Technically this is not
-                # an overapproximation, but one dilation with a rank 3 structuring unit
-                # with connectivity 3 is. To simplify, we just erode one less time than
-                # needed.
-                target_pitch = PRUNING_PITCH * max(container.mesh.extents)
-                voxelized_container = container.voxelized(target_pitch, lazy=True)
-
-                # Erode the voxel region. Erosion is done with a rank 3 structuring unit with
-                # connectivity 3 (a 3x3x3 cube of voxels). Each erosion pass can erode by at
-                # most math.hypot([pitch]*3). Therefore we can safely make at most
-                # floor(maxErosion/math.hypot([pitch]*3)) passes without eroding more
-                # than maxErosion. We also subtract 1 iteration for the reasons above.
-                iterations = (
-                    math.floor(maxErosion / math.hypot(*([target_pitch] * 3))) - 1
+                eroded_container = container._erodeOverapproximate(
+                    maxErosion, PRUNING_PITCH
                 )
 
-                if iterations > 0:
-                    eroded_container = voxelized_container.dilation(
-                        iterations=-iterations
-                    )
-
-                    # Now check if this erosion is useful, i.e. do we have less volume to sample from.
-                    # If so, replace the original container.
-                    if eroded_container.size < container.size:
-                        container = eroded_container
+                # Now check if this erosion is useful, i.e. do we have less volume to sample from.
+                # If so, replace the original container.
+                if eroded_container.size < container.size:
+                    container = eroded_container
 
         # Restrict the base region to the possibly eroded container, unless
         # they're the same in which case we're done
@@ -408,21 +391,7 @@ def pruneVisibility(scenario, verbosity):
         # in a region that contains all points that could feasibly be the position
         # of obj, if it is visible from the observer.
         def bufferHelper(viewRegion):
-            # Compute a voxel overapproximation of the mesh. Technically this is not
-            # an overapproximation, but one dilation with a rank 3 structuring unit
-            # with connectivity 3 is. To simplify, we just dilate one additional time.
-            target_pitch = PRUNING_PITCH * max(viewRegion.mesh.extents)
-            voxelized_vr = viewRegion.voxelized(target_pitch, lazy=True)
-
-            # Dilate the voxel region. Dilation is done with a rank 3 structuring unit with
-            # connectivity 3 (a 3x3x3 cube of voxels). Each dilation pass must dilate by at
-            # least pitch. Therefore we must make at least ceiling((radius/2)/pitch) passes
-            # to ensure we have dilated by the half the circumradius of the object. We also
-            # add 1 iteration for the reasons above.
-            iterations = math.ceil((obj.radius / 2) / target_pitch) + 1
-            dilated_vr = voxelized_vr.dilation(iterations=iterations)
-
-            return dilated_vr
+            return viewRegion._bufferOverapproximate(obj.radius / 2, PRUNING_PITCH)
 
         # Prune based off visibility/non-visibility requirements
         if obj.requireVisible:

src/scenic/core/regions.py

@@ -1729,6 +1729,11 @@ def inradius(self):
         else:
             return region_distance
 
+    @cached_property
+    @distributionFunction
+    def circumradius(self):
+        hypot(*(self.mesh.extents / 2))
+
     @property
     def dimensionality(self):
         return 3
@@ -1742,6 +1747,56 @@ def voxelized(self, pitch, lazy=False):
         """Returns a VoxelRegion representing a filled voxelization of this mesh"""
         return VoxelRegion(voxelGrid=self.mesh.voxelized(pitch).fill(), lazy=lazy)
 
+    @distributionFunction
+    def _erodeOverapproximate(self, maxErosion, pitch):
+        """Compute an overapproximation of this region eroded.
+
+        Erode as much as possible, but no more than maxErosion, outputting
+        a VoxelRegion. Note that this can sometimes return a larger region
+        than the original mesh
+        """
+        # Compute a voxel overapproximation of the mesh. Technically this is not
+        # an overapproximation, but one dilation with a rank 3 structuring unit
+        # with connectivity 3 is. To simplify, we just erode one less time than
+        # needed.
+        target_pitch = pitch * max(self.mesh.extents)
+        voxelized_mesh = self.voxelized(target_pitch, lazy=True)
+
+        # Erode the voxel region. Erosion is done with a rank 3 structuring unit with
+        # connectivity 3 (a 3x3x3 cube of voxels). Each erosion pass can erode by at
+        # most math.hypot([pitch]*3). Therefore we can safely make at most
+        # floor(maxErosion/math.hypot([pitch]*3)) passes without eroding more
+        # than maxErosion. We also subtract 1 iteration for the reasons above.
+        iterations = math.floor(maxErosion / math.hypot(*([target_pitch] * 3))) - 1
+
+        eroded_mesh = voxelized_mesh.dilation(iterations=-iterations)
+
+        return eroded_mesh
+
+    @distributionFunction
+    def _bufferOverapproximate(self, minBuffer, pitch):
+        """Compute an overapproximation of this region buffered.
+
+        Buffer as little as possible, but at least minBuffer, outputting
+        a VoxelRegion.
+        """
+        # Compute a voxel overapproximation of the mesh. Technically this is not
+        # an overapproximation, but one dilation with a rank 3 structuring unit
+        # with connectivity 3 is. To simplify, we just dilate one additional time
+        # than needed.
+        target_pitch = pitch * max(self.mesh.extents)
+        voxelized_mesh = self.voxelized(target_pitch, lazy=True)
+
+        # Dilate the voxel region. Dilation is done with a rank 3 structuring unit with
+        # connectivity 3 (a 3x3x3 cube of voxels). Each dilation pass must dilate by at
+        # least pitch. Therefore we must make at least ceil(minBuffer/pitch) passes to
+        # guarantee dilating at least minBuffer. We also add 1 iteration for the reasons above.
+        iterations = math.ceil(minBuffer / pitch) + 1
+
+        dilated_mesh = voxelized_mesh.dilation(iterations=iterations)
+
+        return dilated_mesh
+
     @cached_method
     def getSurfaceRegion(self):
         """Return a region equivalent to this one, except as a MeshSurfaceRegion"""

src/scenic/syntax/veneer.py

@@ -315,6 +315,7 @@
 evaluatingGuard = False
 mode2D = False
 _originalConstructibles = (Point, OrientedPoint, Object)
+BUFFERING_PITCH = 0.1
 
 ## APIs used internally by the rest of Scenic
 
@@ -1612,10 +1613,29 @@ def VisibleFrom(base):
     if not isA(base, Point):
         raise TypeError('specifier "visible from O" with O not a Point')
 
+    def helper(self):
+        if mode2D:
+            position = Region.uniformPointIn(base.visibleRegion)
+        else:
+            # We can limit the potential positions to an overapproximation of the
+            # visible region.
+            hw = self.width / 2
+            hl = self.length / 2
+            hh = self.height / 2
+            radius = hypot(hw, hl, hh)
+
+            buffered_vr = base.visibleRegion._bufferOverapproximate(
+                radius / 2, BUFFERING_PITCH
+            )
+
+            position = Region.uniformPointIn(buffered_vr)
+
+        return {"position": position, "_observingEntity": base}
+
     return Specifier(
         "Visible/VisibleFrom",
         {"position": 3, "_observingEntity": 1},
-        {"position": Region.uniformPointIn(base.visibleRegion), "_observingEntity": base},
+        DelayedArgument({"width", "length", "height"}, helper),
     )
 
 
@@ -1649,9 +1669,8 @@ def helper(self):
         if mode2D:
             position = Region.uniformPointIn(region.difference(base.visibleRegion))
         else:
-            position = Region.uniformPointIn(
-                convertToFootprint(region).difference(base.visibleRegion)
-            )
+            # We can't limit the available region since any spot could potentially be occluded.
+            position = Region.uniformPointIn(convertToFootprint(region))
 
         return {"position": position, "_nonObservingEntity": base}
 

tests/syntax/test_specifiers.py

@@ -508,9 +508,9 @@ def test_visible():
     for i in range(30):
         scene = sampleScene(scenario, maxIterations=10)
         ego, base = scene.objects
-        assert ego.position.distanceTo(base.position) <= 10
-        assert ego.position.x >= base.position.x
-        assert ego.position.y >= base.position.y
+        assert ego.position.distanceTo(base.position) <= 10 + math.sqrt(3 * 0.5**2)
+        assert ego.position.x >= base.position.x - math.sqrt(3 * 0.5**2)
+        assert ego.position.y >= base.position.y - math.sqrt(3 * 0.5**2)
 
 
 def test_visible_no_ego():
@@ -525,7 +525,9 @@ def test_visible_from_point():
     )
     for i in range(20):
         scene = sampleScene(scenario, maxIterations=10)
-        assert scene.egoObject.position.distanceTo(Vector(300, 200)) <= 2
+        assert scene.egoObject.position.distanceTo(Vector(300, 200)) <= 2 + math.sqrt(
+            3 * 0.5**2
+        )
 
 
 def test_visible_from_point_3d():
@@ -535,7 +537,9 @@ def test_visible_from_point_3d():
     )
     for i in range(20):
         scene = sampleScene(scenario, maxIterations=10)
-        assert scene.egoObject.position.distanceTo(Vector(300, 200, 500)) <= 2
+        assert scene.egoObject.position.distanceTo(
+            Vector(300, 200, 500)
+        ) <= 2 + math.sqrt(3 * 0.5**2)
 
 
 def test_visible_from_oriented_point():
@@ -548,9 +552,9 @@ def test_visible_from_oriented_point():
     for i in range(20):
         scene = sampleScene(scenario, maxIterations=10)
         pos = scene.egoObject.position
-        assert pos.distanceTo(base) <= 5
-        assert pos.x <= base.x
-        assert pos.y >= base.y
+        assert pos.distanceTo(base) <= 5 + math.sqrt(3 * 0.5**2)
+        assert pos.x <= base.x + math.sqrt(3 * 0.5**2)
+        assert pos.y >= base.y - math.sqrt(3 * 0.5**2)
 
 
 @pytest.mark.slow