TTTM

PereGaea

Laslo Godel
Previous
TOC


4: MAPS




Before the Dynism can acquire the ability to Identify `generic' objects, it must first extend its Object RAM so that it extends beyond the size of its largest Retinal Box to its entire Visual Field, that is, everywhere its eye can rotate to in its socket in all directions. It then translates the positions of any stimuli it then captures into the additional `Locations' that make up the extended Object RAM.

 
These new Locations are by default the same size as those of the largest Retinal Box, but if the eye rotates into a particular part of the Visual Field, they immediately take on the sizes of the Retinal Boxes that map onto it. 

The Visual Processor may perform periodic `saccades' in which the eye is moved in random directions both to detect new objects and delete old ones from the Object RAM. 





The extended Object RAM engenders the evolution of many more Testers. They test particular Patterns and Lists for properties which allow the Visual Processor to Identify them as belonging to `generic' objects like Rocks and Boulders. The Processor can then attach Object Type Numbers to them which will allow the Dynism to respond to them where necessary.


 
Let's begin our look at Testers by defining those objects that can be identified solely through ROM Templates as `ROM Objects', and generic ones that can only be Identified via Testers as `RAM Objects'. 


On PereGaea at least there are two major classes of RAM Object. All its Rock and Gem-like objects have certain characteristics in common: they are made up of visual phenomena we call `facets'. Facetted Objects in the Rockpile include the large Rock at the bottom left of the Rockpile, those near the flower, and the slabs making up the steps. The first Testers the Dynism evolves test for such facets using these four Rules:

 
1. A Facet is made up solely of Angles, Straights and Junctions with 3 Arms or more.
2. A Facet's angles may be of any size.
3. A Facet must share nothing more than two Junctions and a Straight with any adjacent facet. 
4. A Facet must adjoin at least two other facets that are themselves mutually adjacent.

Connected Straights ending in Angles or Junctions mark either the visual border of the entire object, or where it is partly occluded by another The Dynism can then respond to the object, which now also has a Faceted Object Number attached to it, in any way it may evolve, even simple avoidance. 


More advanced Faceted Object Testers may test for particular types of Faceted Objects, the two gemstones for example. It may even surround these with Orientational Spheres should determining their orientation be useful to it.




To look at the second major class of RAM Objects, let's suppose an object presents a set of Areals like this. To our eye this looks like a Faceted Object.


However, if we add a few more rectangular Areals to each side, and make them slightly thinner and darker as we go, we visually interpret the set in an entirely different way.


We see it as a curved surface, or `contour', even when the lightest Areal moves from the center towards
 one or other side of the set. The extent to which the proportions of each rectangle change with each tonal step is determined by the surface curvature. In these examples the objects appear cylindrical - or at least hemicylindrical, we assume the other `half' is hidden
.

 
 However, if the Areals are fainter and wider relative to the object's width, the object is perceived as being only gently curved and the `hidden half' assumption may no longer be made. If the proportions change at a varying rate, the curve is perceived to vary. And if the Areals actually reverse in tonal value in some parts of the set, we perceive the object to contain either concave elements or even as two adjacent cylinders. 

The Dynism evolves a set of Contoured Object Testers that look for such Contour sets using these four rules:

 
1. A Contour Areal can contain only Straights, Arcs, or Angles, no Junctions. 
2. A Contour Areal must be no more than one tonal value greater or lesser than its neighbor. 
3. A Contour Areal can have no more than two Contour Areals as immediate neighbors. They can however join at a Junction with 3 or more Arms as in the vertex of a cylinder or cone. 
4. A Contour Areal must be part of a set of at least three such Tones. 
These Contours ought not be confused with the `contour lines' of our world. Those are essentially mathematical constructs we invented in order to describe the three dimensional shape of an object independent of the conditions under which it is observed. In short, Contour borders will move with a shift in illumination angle, Contour lines will not. 





Most of PereGaea's RAM objects will of course have complex shapes. For instance if the Field of View is illuminated by a point source of light rather than a diffuse one, many objects will cast shadows on others. And perhaps most difficult of all, a few objects will change their shapes over time, sometimes quickly, as we'll assume the Fronds streaming away from the top of the Rockpile do. 


The Dynism will need to acquire many new Testers to cope with these visual challenges. It may also acquire a new form of `attention'. Up until now the Dynism has only rotated its eye in response to sudden changes in brightness, often also indicating movement. Its Testers can now cause it to move towards any set of Areals or Lineals they detect as conforming to at least one of its RAM Object Rules. They can then more reliably perform their task with a full set of Retinal Boxes. We will call this internally-generated form of attention `examination'.

 
To look now at how the Dynism might Identify RAM Objects containing both Facets and Contours, the Facet Tester will need to alter its first operational Rule so that it can accommodate `curved facets' that can contain Arcs as well as Straights. 
RAM Objects with rough surfaces can only be Identified via the larger Areals and Lineals making them up; protrusions or depressions can be tolerated provided they are not so large as to intrude into them. 
Indeed, Facet and Contour Testers need not evolve to test for pure `classical' volumes like cylinders, cones, spheres, boxes and pyramids, but what we would think of as more generalized versions of them. For instance, the Areals making up a cylinder or cone need not have perfectly straight sides. With the cone they need not even meet at a vertex; tending to be narrower at one end than the other is sufficient. 
Much the same applies to Spheres. The Contour Testers for these will test for circles or arcs that have particular spatial relationships with each other. Again the limits can be fairly broad; they can be ovoidal rather than perfectly round and again have minor protrusions and depressions. The Rockpile Boulders will be picked up by these Testers; subtesters triggered by these will look for characteristic surface markings to identify them as Boulders rather than some other spherical object. 




Like ROM Objects, partial occlusion will not prevent the Identification of RAM Objects.. 
Just as the Dynism can use Lineal Lists to reintegrate ROM Objects, it can do the same with RAM Objects that are visually divided by others.  

Objects can also be visually divided either by a shadow from another object or a reflected color-cast. They may also be self-shadowing, or, as with the Moss on the Boulder, shadowed by the curvature of the object it sits on.
The Shadow Tester works similarly to the `Occlusion Tester' we've just seen except that the Areals of the two `segments' will differ at a constant rate. The distance between them will also always be zero. 
We can now at last see how the Dynism might visually interpret the Fronds. Basically all it needs is very fast versions of the Contour Mappers we have just seen to cope with the Fronds' movement. The Dynism's Occlusion Testers would also need to operate quickly enough to determine which laterally-separated portions of crossed-over Fronds `belong' to each other. 




RAM Object Testers eventually give rise to descendants that map spatial relationships between entire objects rather than the Areals and Lineals that make them up. These will, amongst other things, allow the Dynism to perceive many of PereGaea's Objects as constructs of smaller Component Objects.

 
The Tree in the Rockpile is the most obvious example of where such a capability would be useful. At this stage the Tree appears in the Dynism's Object RAM as countless thousands of Areals and Lineals deriving from what we would perceive as its Trunk, Branches, and Leaves.


At this point we will assume that the Dynism has evolved a form of color vision, albeit rather primitive and cartoon-like.

If the Dynism uses Trees as a source of Food or because its Predator or Prey are to be found in them, then it too may need to group these stimuli into Trunk, Branch, and Leaf components. It can then distinguish mere collections of such components, for instance a pile of dead Leaves or even a dead Tree from a live Tree by mapping their relative spatial positions. This may also help it to determine the Tree's species if necessary.

 
Let's begin with the Branches. All PereGaea's branch systems, not just those of its Trees, share certain characteristics that will allow them to be identified as such, even though they can, like Rocks, take an infinitude of forms within those limits.


Their identification begins with specialized variants of the Cylinder Testers we saw earlier that can cope with reflex or twisted bends, or `knots' left by broken-off branches.

 
The one `distortion' these Testers cannot cope with however is a set of Contours indicating that a Branch is splitting into two, in other words, a Branch Junction like this. 
A `Solid Junction Tester', similar to the Occlusion Tester we saw earlier, in effect joins any such set of mutually close branch `ends' it locates via a 3 x 3 Map Grid like this. The Tester may later acquire the ability to Identify the actual junction itself through the shape of its Areals and Lineals. 
Variants of this Tester may also detect different types of Junction, such as those between smaller diameter branches and much larger ones or a tree trunk. 



Further evolution of these Branch Testers link all these Junction Maps into a system of Branches, I will use simple symbols to represent these Maps.

 


When any Branch Junction Map is first extracted, it triggers into operation a set of `Branch System Testers'. These move out along the Junction's Branches in the Object RAM testing for any further Branch Junction Maps that may be connected to it. As each such Tester reaches a Branch Junction, it immediately sends out duplicates of itself along the as yet unmapped Branches. Should a Tester reach the end of a branch, it flags it as such and releases itself to locate other Junctions. Branches that cross each other are `joined' via Occlusion Testers and treated as if they were continuou


You can see how this all works in this drawing where I've numbered each such Tracer `generation'. The Branch System Tester can then link the Junctions into a single `Branch System' and assign a Tree Branch System Number to it. 
The Dynism eventually becomes able to use these Branch System Testers to Identify other kinds of Branch System, be it a Feather say, or a `Filigree' of some kind.

It does so by checking each Branch Junction Map to determine if it matches this `Category Map Template'. To Match, a Map can have any number of arms, but they must lie within the colored area. 

If the system consists entirely of such `modules' - or at least some evolution-determined number of them, the Tester identifies it as a particular type of Branch System and attaches a specific RAM  Object Number to it accordingly. Here the dotted symbols represent optional Junction Maps. 

Modules for Feathers for instance might be based on a much tighter four-way Junction Category plus two Branches with Ends. A variant of this may contain identical `submodules' that repeat themselves recursively an indefinite number of times. This would then allow fern-like systems to be identified. 
A random Branch System like this on the other hand is clearly unlikely to have any RAM Object Number attached to it. 
If a Branch System is visually divided by another object, then an Occlusion Tester can rejoin each Branch separately, and thereby the whole system. If the occluding object is too wide however for individual branches to be rejoined in this way, then those parts of the system thus `severed' will be Identified as separate Branch Systems. 
More advanced Branch System Testers will be able to Identify and Number Branch Systems that are silhouetted against bright backgrounds, such conditions do not allow cylinder contours to be perceived. 





Now that we've seen how the Dynism identifies the Tree's Branches, we can look briefly at how it identifies its Trunk and Leaves.

 
The Trunk is simple; if the Branch System Tester locates a Branch containing stimuli representing an interface with the ground at one end and a splitting into two or more branches at the other, it attaches a Trunk Component Number to it.
Since most of a Tree's Leaves will be similar in size and shape, a set of ROM Templates from the Observational Spheres for just a few `sample' Leaves may well suffice for these.


Clearly though, if the Object RAM is flooded with Leaf patterns, it would be dangerously time-consuming to process each and every one. Therefore, once a Tree Branch System is identified, this will trigger a `Context Tester', little more than a simple Mapper, into identifying all nearby leaf-sized stimuli as Leaves, whatever their actual shapes may be. The Tester may then allow an entire Clump of such Leaves to be Identified as a Clump complete with its own Component Number. Silhouetted Leaf Clumps can be identified in a similar way.


Such perceptual `shortcuts' obviously carries the risk that a predator may conceal itself within such Objects, especially if it has evolved a camouflage so as to blend in with them. This risk is however outweighed by the greater risks associated with failing to identify complex stimuli sufficiently quickly.






As I said earlier, the Dynism must now test that a set of Trunk, Branch. and Leaf Clump Components do in fact form a Tree and are not just debris left after a Nummic Storm.


 
 To do this it acquires another Context Tester that checks that the Trunk does not deviate too far from the vertical. This uses the same grid as the Branch Mapper; the rotation angle must lie within the arrowed sectors. 


Finally, a Tree Context Tester then tests the ends of all the branches for any adjacent leaf clumps, then for any clumps immediately adjacent to these, then any to these, and so on out to the Tree's boundaries. It samples each clump as it goes to ensure that the leaves making them up belong to the same species, and of course that of the Tree. 


This also allows the Tree Tester to identify the Tree even if it is one of several in a grove or forest. If it is one of several identical Trees in such a group, the boundaries are arbitrarily fixed in the Object RAM when the Tester for one Tree meets another from the next. More advanced Testers will also test for such things as clump orientations relative to the branch system and changes in tone across the canopy.



There is one last thing we must cover before we leave the Rockpile. Up until now we have assumed that all the simple RAM Objects the Dynism perceives have positive curvatures like the Rock and the Boulders. Objects can however have similar shapes but with negative curvatures: a Rock turns into a Cave, a Boulder into a Hollow. Some may contain elements of both like the Steps. 

It's hard to see why the Dynism might evolve a `Step Tester' however unless Steps were somehow common enough on PereGaea to allow it to evolve a specific use for them. It is more likely to acquire a `Gap Tester' to identify gaps between Rocks or Boulders; this would be invaluable if these contain Predators or Prey. 


Most such `Negative Objects' will be identified through Maps just as Positive Objects are. To identify others however the Dynism may need to acquire a Tester that determines light-source direction so that the actual boundary between a Negative Object and the Positive Object that must inevitably contain it can be determined.


Negative Objects, unlike Positive ones, cannot exist by themselves. This Light Source Tester would, if unable to locate the source directly in the Visual Field, may find itself liable to the same visual ambiguities we are occasionally subject to. The flight of stairs above, for instance, might also be seen as ambiguous in some lighting situations. An internal `Ambiguity Sensor' might need to evolve to make arbitrary decisions to prevent possible `lockups' in the Dynamism's perceptual systems.





Previous
TOC