# Patent

## Title
Vision-based obstacle avoidance

## Abstract

A method for allowing a robot to avoid objects along a programmed path: first, a field of view for an electronic imager of the robot is established along a path where the electronic imager obtains the object location information within the field of view; second, a population coded control signal is then derived from the object location information and is transmitted to the robot; finally, the robot then responds to the control signal and avoids the detected object.

## Background
RELATED APPLICATIONS
This application claims the benefit of Provisional Application No. 60/424,596 filed on Nov. 7, 2002 for applicant John Galbraith.


STATEMENT REGARDING FEDERAL RIGHTS
This invention was made with government support under Contract No. W-7405-ENG-36 awarded by the U.S. Department of Energy. The government has certain rights in the invention.


REFERENCE TO COMPUTER PROGRAM LISTING APPENDIX
This application includes a computer program listing appendix submitted in duplicate on two compact discs, CD-R. The computer program listing for practicing the invention is incorporated herein in its entirety by reference. The following files reside on the compact discs:












Name
Size
Date


















AdelsonBergen.cc
26,845 kb 
Oct. 8, 2002
2:40 PM


Camera.cc
9,151 kb
May 11, 2002
2:21 PM


CollisionServer.cc
4,913 kb
Oct. 10, 2002
3:46 PM


Element.cc
1,672 kb
Sep. 26, 2002
11:28 PM


Initializer.cc
8,474 kb
Oct. 9, 2002
12.42 PM


MotionServer.cc
8,878 kb
Oct. 10, 2002
12:09 PM


MpegDecoder.cc
1,674 kb
Apr. 15, 2002
4:52 PM


OpticFlowServer.cc
14,091 kb 
Aug. 20, 2002
12:18 PM


OverheadServer.cc
8,516 kb
Oct. 14, 2002
1:35 PM


PyServer.cc
36,626 kb 
Sep. 26, 2002
11:06 PM


RotationServer.cc
5,039 kb
Oct. 27, 2002
5:49 PM


Server-templates.cc
3,874 kb
May 23, 2002
3:53 PM


Server.cc
44,314 kb 
Oct. 8, 2002
4:07 PM


TranslationColumn.cc
13,515 kb 
Sep. 28, 2002
1:04 PM


TranslationInitilizer.cc
1,420 kb
May 10, 2002
1:40 PM


TranslationServer.cc
6,440 kb
Oct. 9, 2002
9:53 PM


Variable.cc
6,911 kb
Sep. 26, 2002
11:09 PM


VelocityColumn.cc
13,665 kb 
Oct. 8, 2002
11:35 PM


VelocityColumn.compute.cc
4,173 kb
Oct. 31, 2002
1:33 PM


VelocityInitializer.cc
2,053 kb
Aug. 23, 2002
2:59 PM


VelocityServer.cc
8,318 kb
Oct. 8, 2002
7:45 PM


futaba.cc
2,928 kb
May 16, 2002
3:08 PM


global.cc
  588 kb
Sep. 26, 2002
11:40 PM


stringUtils.cc
3,596 kb
May 23, 2002
4:46 PM


ControlServer.py
7,545 kb
Oct. 14, 2002
12:36 PM


DisplayMixin.py
8,017 kb
Oct. 10, 2002
4:43 PM


DisplayServer.py
1,067 kb
May 18, 2002
3:36 PM


InitializerServer.py
39,712 kb 
Dec. 8, 2002
1:34 PM


Locomotor.py
3,856 kb
Oct. 14, 2002
3:38 PM


PatternStimulus.py
21,254 kb 
Sep. 26, 2002
10:57 PM


Server.py
20,218 kb 
Mar. 25, 2002
5:03 PM


StimulusServer.py
5,865 kb
Oct. 11, 2002
12:13 PM


Variable.py
5,016 kb
Apr. 11, 2002
8:23 PM


VideoStimulus.py
5,716 kb
Oct. 8, 2002
7:50 PM


futaba.py
1,739 kb
Oct. 7, 2002
11:43 PM


stimulus.py
4,187 kb
Sep. 26, 2002
10:38 PM


video.py
5,106 kb
Sep. 26, 2002
10:54 PM


AdelsonBergen.h
3,394 kb
Oct. 6, 2002
9:06 PM


Camera.h
2,598 kb
Jul. 8, 2002
2:24 PM


ComputeAtom.h
  541 kb
Apr. 25, 2002
2:40 PM


Element.h
5,395 kb
Sep. 26, 2002
11:28 PM


Initializer.h
1,957 kb
May 23, 2002
10:48 PM


MpegDecoder.h
  932 kb
May 11, 2002
2:17 PM


Retina.h
1,232 kb
Apr. 22, 2002
2:47 PM


Server.h
6,756 kb
Sep. 26, 2002
11:38 PM


Timer.h
2,902 kb
May 24, 2002
8:54 PM


TranslationColumn.h
3,158 kb
Aug. 19, 2002
2:06 PM


Variable.h
7,146 kb
Sep. 26, 2002
10:17 PM


VelocityColumn.h
3,419 kb
Oct. 8, 2002
9:39 PM


futaba.h
  451 kb
May 16, 2002
2:04 PM


global.h
1,002 kb
Sep. 26, 2002
11:11 PM


StringUtils.h
1,418 kb
May 23, 2002
4:45 PM


futaba.i
  623 kb
Sep. 26, 2002
8:36 PM


mylib.i
6,956 kb
Sep. 26, 2002
8:45 PM


stimulus.i
13,860 kb 
Sep. 25, 2002
3:29 PM


video.i
9,670 kb
Sep. 26, 2002
10:54 PM


vision.i
  47 kb
Sep. 25, 2002
3:29 PM


Makefile
5,281 kb
Oct. 7, 2002
11:22 PM


TranslationInitializer.sh
  120 kb
May 10, 2002
1:41 PM


VelocityInitializer.sh
  139 kb
Jun. 2, 2002
3:04 PM









FIELD OF THE INVENTION
The present invention relates generally to a method for robot self-control, and, more particularly, to a method and for allowing an electronic robot to perform obstacle avoidance maneuvers.
BACKGROUND OF THE INVENTION
Over the years, scientists and engineers have designed and implemented methods for machine vision and subsequent response to objects observed in the world with varying degrees of success. Some of the previous engineering methods were based on natural biological vision systems that required a mix of computer science, engineering, and physiology. Biologically inspired vision engineering is one of the most promising research areas for future successes in machine vision applications.
The performance, from an information processing point of view, of people and animals behaving in the real world greatly surpasses the current abilities of the most sophisticated engineered systems for seemingly simple tasks, including basic image understanding, robotic navigation, and obstacle avoidance. Artificial machines do not have to function like a biological system to be useful, but there is obvious evidence that biologically inspired systems actually work better for many engineering problems.
Although the potential benefits of building information processing machines that work like biological systems are clear, the technical details of how to complete such a task are not clear. This field depends on the convergence of neuroscience and engineering. Neuroscience is the field concerned with the way biological systems process information. Electrical and computer engineering is concerned with the implementation of information processing systems. The present invention demonstrates the achievement of an electronic implementation of selected contemporary neuroscience models associated with the mammalian vision system integrated into an engineered system that performs depth detection and subsequent obstacle avoidance.
A designer of a mobile, autonomous robot has many sensors available to detect obstacles and other environmental features. These detector types include sonar, laser range-finding, bump sensing, radar, infrared, and vision; to date, sonar has met with the most success. Sonar is a mature, accurate technology with moderate data processing requirements. Even some biological systems, such as a bat, use sonar for obstacle and target detection.
Despite the limited success of sonar applied to robotics, visual based processing is potentially much more useful. Vision carries more tactical information than one dimensional technologies like sonar, because vision has higher bandwidth and a two dimensional format. Sonar, radar, and laser range-finding are essentially one dimensional technologies unless one applies additional enhancements such as scanning techniques or detector arrays. Those technologies also radiate power, resulting in fundamental limitations on sensor range and vehicle power requirements. Infrared technology is similar to vision, but it uses a different portion of the electromagnetic spectrum. Unlike vision, it also works in the dark, but can only see obstacles that radiate heat.
Vision is a superior strategy as it does not suffer from any of the above problems. Vision is passive. Sensor range is limited only by the scene and environmental factors, and power requirements are limited only by the information processing technology. Unfortunately, robotic vision requires large amounts of data processing, and engineers have not yet discovered how to extract adequate information for robot navigation, regardless of computational limitations. However, the majority of biological systems have evolved to handle the data processing requirements with tremendous success. Casual observation of humans or almost any animal will show that vision enables sophisticated, fast behavior that engineers have not duplicated in previous machines.
The present invention method involves the electronic processing of algorithms that model the neural processes that allow humans to observe objects and move around them. The emulation of biological systems as carried out by the present invention is implemented by technologies currently available, despite the fact that these technologies support limited interconnection topologies and parallelism as compared to real neural systems.
Various objects, advantages and novel features of the invention will be set forth in part in the description which follows, and in part will become apparent to those skilled in the art upon examination of the following or may be learned by practice of the invention. The objects and advantages of the invention may be realized and attained by means of the instrumentalities and combinations particularly pointed out in the appended claims.
SUMMARY OF THE INVENTION
In accordance with the purposes of the present invention, as embodied and broadly described herein, the present invention includes a method for allowing a robot to avoid objects along a programmed path. First, a field of view for an electronic imager of the robot is established along a path where the electronic imager obtains the object location information within the field of view. A population coded control signal is then derived from the object location information and is transmitted to the robot. The robot then responds to the control signal and avoids the detected object.



BRIEF DESCRIPTION OF THE DRAWINGS
The accompanying drawings, which are incorporated in and form a part of the specification, illustrate the embodiments of the present invention and, together with the description, serve to explain the principles of the invention. In the drawings:
FIG. 1 is a pictorial illustration of the line features sensed by certain feature detector neurons.
FIG. 2 is a pictorial illustration of neuron sampling in a parameter space, the resulting output yielding a population code {right arrow over (p)}=[p1, . . . , p6].
FIG. 3 is a flowchart describing the method of the present invention.
FIG. 4 is a pictorial illustration of the robot used to practice the present invention.
FIG. 5 is a table showing a rough estimate of the computation requirements required of the present invention.
FIG. 6 is a pictorial illustration of the experimental arena.
FIG. 7 is a pictorial illustration of the pattern place on obstacles within the experimental arena.
FIG. 8 is a pictorial illustration of the pre-programmed waypoint path of the robot using the method of the present invention.
FIG. 9 is a pictorial illustration showing the path of the robot while practicing the method of the present invention.



DETAILED DESCRIPTION
The present invention involves the electronic processing of algorithms that model the biological processes that allow humans to observe objects in the environment and move around them. The emulation of the biological system as carried out by the present invention is implemented by technologies currently available, despite the fact that these technologies support limited interconnection topologies and parallelism as compared to real neural systems. A particular feature of real neural systems, population coding, is incorporated into the present invention as it offers unique advantages in image understanding and visual depth detection.
Information Representation and Population Coding
Neurons in biological vision systems operate primarily as feature detectors. One of the simplest feature detector neurons in the visual cortex and the first discovered by neuroscientists is a line detector. A single neuron is sensitive to a particular line with a given location on the retina, orientation, and polarity (light vs. dark).
FIG. 1 displays four different lines in order to illustrate this concept. The circular outlines represent the borders of the “receptive field”, or processing area, of the neuron. Each line within the circular outline is different from the other lines considering the parameters of orientation, contrast, and length. Combined with a retinotopic location, each line is detectable by a neuron. However, any particular neuron only detects one line feature of a given type; if the neuron detects the associated feature, the neuron will “activate”, or output a large signal, otherwise the neuron will remain silent.
Referring to FIG. 2, biophysical systems, like mammals, sample a parameter space through set of “tuned” feature detector neurons, p1 thru p6. In practice, some neuron types span more than one “tuning” dimension, for example location and orientation, as is in the case of motion processing. The collection of neuron outputs is called a population code. The population code represents a quantized orientation measurement that is capable of simultaneously representing multiple tunings, like two distinct orientations at the same location.
FIG. 3 is a flowchart displaying the method of the present invention. Step 100 represents an electronic imager, such as an infrared imager, charge coupled device (CCD) imager, or CMOS imager, acquiring video images of the world in the robot's field of view. The motion energy algorithm, step 110, decomposes the video stream into spatial and temporal frequency components and eliminates dependence on phase. The velocity algorithm, 120, recombines the spatial and temporal frequency components corresponding to visual objects, identifying how those objects are moving through the imager's field of view. The rotation algorithm, step 130, determines if the imager, and thus the robot, is turning left or right. The translation algorithm, step 140, reduces the velocity information produced by step 120 into a simple speed coding by eliminating the effects of rotation and the aperture problem, and calculates the distance of the object from the imager. The Navigation algorithm, step 150, comprises two parts. In the absence of obstacles, which are close objects as determined by step 140, the robot proceeds in a straight line towards some strategic goal location (programmed waypoint), solely determined by the robot's application and independent of the environment. When an obstacle appears, the second part of the navigational algorithm (tactical navigation) steers the robot in a direction away from the obstacle. In step 160, the output of step 150 is converted to a control signal that is compatible with the robot's drive motor circuits. The method is then repeated until the robot reaches the waypoint.
Algorithm Development
The method of the present invention comprises the algorithms described below that compute the distance from a robot, comprising an electronic imager, to environmental objects using the speed at which the objects move across the field of view as recognized through the aperture of the electronic imager. Close objects appear to move faster than distant objects from a reference point near the center of the image called the “focus of expansion”, as disclosed in H. C Longuet-Higgins and K. Prazdny, The Interpretation of The Moving Retinal Image, Proceedings of the Royal Society of London B, vol. 208, 1980, incorporated herein by reference. After detecting a close object, the method of the present invention directs the robot to avoid the obstacle. The obstacle detection algorithm included in the present invention is complex because of two complicating factors: the aperture problem and rotational flow.
The aperture problem occurs because objects that move in a video stream also have a direction of movement in addition to the speed, and the direction is often hard to estimate. The speed and direction quantities are related; an error in estimating the direction corrupts the speed estimate. Certain objects in the environment, like those with long straight edges, are especially prone to ambiguous direction estimates because the object will appear to move perpendicular to the orientation of the linear feature. However, the object may actually be moving in a different direction due to the aperture problem.
Rotational image flows caused by the robot turning is the second complicating factor addressed by the algorithm. The speed of motion is directly related to the object's distance to the camera only when the direction is oriented away from the middle of the scene, a point called the focus of expansion. When the robot turns, the whole scene shifts uniformly to the right or left, and the speed of motion no longer directly indicates the distance to the object.
Motion Energy Algorithm
Any still image may be decomposed into spatial frequency components through a routine Fourier transform computation. For video images, the spatial frequency components change position (phase) with time if the object is moving. The changing position results in a temporal frequency ψt associated with a particular spatial frequency ψs. The speed of motion, which can indicate object distance, is the ratio of the temporal frequency to the spatial frequency, Vs=ψt/ψs. Hence, the first step of the motion energy algorithm, as taught in E. H. Adelson and J. R. Bergen, Spatiotemporal Energy Models for the Perception of Motion, Journal of the Optical Society of America A, vol.2, February 1985, incorporated herein by reference, is a spatial filter that decomposes each frame of the video input S(x, y, t) into spatial frequency components, yielding a population code:

ξG(t)=S(x, y, t)*hs(xM,yM,θM,ψs)  Equation 1

where x and y are the spatial coordinates of the image, t is time, θM is the 2D orientation of the frequency component, and hs(xM,yM,θM,ψs) is the impulse response of the filter that selects the frequency ψs, centered in the image at (xM,yM). The convolution operation is notated by the symbol *. The spatial impulse response hs(xM,yM,θM,ψs) implements an oriented bandpass characteristic, such as a Gabor filter.

Next, each spatial frequency component is decomposed into temporal frequency components with a temporal filter:

ξSn(t)=ξG(t)*ht(t,ψt)  Equation 2

The temporal impulse response ht(t,ψt) also implements a bandpass characteristic with center frequency ψt.

To form an “energy”, the amplitude of ξSn(t) is found by eliminating the temporal oscillations that remain from the original spatial and temporal frequency characteristics of the detected object. This step requires that each filter is performed in quadrature pairs, such that four quantities result as taught in Adelson and Bergen, supra:

ξS1(t)=S(x,y,t)*hse(xM,yM,θM,ψs)*hte(t,ψt)  Equation 3

ξS2(t)=S(x,y,t)*hse(xM,yM,θM,ψs)*hto(t,ψt)  Equation 4

ξS3(t)=S(x,y,t)*hso(xM,yM,θM,ψs)*hto(t,ψt)  Equation 5

ξS4(t)=S(x,y,t)*hso(xM,yM,θM,ψs)*hto(t,ψt)  Equation 6

where hse and hso are the even and odd components of a quadrature, bandpass, spatial filter tuned to orientation θM and spatial frequency ψs, and hte(t,ψt) and hto(t,ψt) are the even and odd components of a quadrature, bandpass, temporal filter tuned to the temporal frequency ψt. Finally, the nonlinear combination





  
    
      
        
          
            
              
                
                  ξ
                  M
                
                ⁡
                
                  (
                  
                    t
                    ,
                    
                      Ω
                      M
                    
                  
                  )
                
              
              =
              
              ⁢
              
                
                  
                    [
                    
                      
                        
                          ξ
                          S1
                        
                        ⁡
                        
                          (
                          t
                          )
                        
                      
                      +
                      
                        
                          ξ
                          S4
                        
                        ⁡
                        
                          (
                          t
                          )
                        
                      
                    
                    ]
                  
                  2
                
                +
                
                  
                    [
                    
                      
                        
                          ξ
                          S2
                        
                        ⁡
                        
                          (
                          t
                          )
                        
                      
                      -
                      
                        
                          ξ
                          S3
                        
                        ⁡
                        
                          (
                          t
                          )
                        
                      
                    
                    ]
                  
                  2
                
                -
              
            
          
        
        
          
            
              
              ⁢
              
                
                  
                    [
                    
                      
                        
                          ξ
                          S1
                        
                        ⁡
                        
                          (
                          t
                          )
                        
                      
                      -
                      
                        
                          ξ
                          S4
                        
                        ⁡
                        
                          (
                          t
                          )
                        
                      
                    
                    ]
                  
                  2
                
                -
                
                  
                    [
                    
                      
                        
                          ξ
                          S2
                        
                        ⁡
                        
                          (
                          t
                          )
                        
                      
                      +
                      
                        
                          ξ
                          S3
                        
                        ⁡
                        
                          (
                          t
                          )
                        
                      
                    
                    ]
                  
                  2
                
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        7
      
    
  




represents the population coded motion energy, Adelson and Bergen, supra. Thus, all of the tuning parameters are represented by the set ΩM={xM,yM,θM,ψt}.

The motion energy output is a large set of individual feature detectors, with each feature detector ξM(t,ΩM) sensitive to, or “tuned”, to a particular value of spatial frequency ψs, spatial orientation θM, temporal frequency ψt, and image location (xM,yM).
The motion energy algorithm is incorporated into the computer code used to practice the present invention through modules AdelsonBergen.cc and MotionServer.cc which are included in the appendix.
Velocity Algorithm
The velocity speed vs of a spatial component is computed from the motion energy output as the ratio of the component's temporal frequency ψt divided by the component's spatial frequency ψs. Summing motion energy features with similar velocity speeds and orientations recombines the spatial frequency components into complex objects, each with known velocity as taught in N. M. Grzywacz and A. L Yuille, A Model for the Estimate of Local Image Velocity by Cells in the Visual Cortex, Proceedings of the Royal Society of London B, vol. 239, 1990, incorporated herein by reference. In addition to speed, velocity vs is tuned to orientation θV and image location (xM,yM). The whole tuning set is notated ΩV={xM,yM,vs,θv}.
As discussed previously, motion energy is susceptible to the aperture problem. The velocity computation used here accounts for the aperture problem by computing velocity for all the possible motion energy orientations θM as displayed in FIG. 2, not just the single orientation perpendicular to linear features. This capability is made possible by the use of population coding, which allows multiple velocity estimates to exist together. Generally, the velocity orientation θV is similar to the motion energy orientation θM when the aperture problem is not a factor, but the two quantities diverge as the aperture problem grows. The terms that include cos(θM−θv) in the following equations implement this divergence.
Each velocity feature of the population code ξV(t,ΩV) is the composite sum of the spatial frequency components ξM(t,ΩM) that have similar orientation and velocity speed to the velocity tuning, vS and θV. The corresponding summation is

ξV(t,ΩV)=ΣWV(ΩM,ΩV)ξM(t,ΩM)  Equation 8

with the velocity weights





  
    
      
        
          
            W
            V
          
          ⁡
          
            (
            
              
                Ω
                M
              
              ⁢
              
                Ω
                V
              
            
            )
          
        
        =
        
          
            
              
                
                  
                    H
                    s
                    2
                  
                  (
                  
                    
                      
                        f
                        x
                      
                      =
                      
                        
                          ψ
                          t
                        
                        ⁢
                        
                          
                            cos
                            ⁡
                            
                              (
                              
                                θ
                                M
                              
                              )
                            
                          
                          /
                          
                            [
                            
                              
                                v
                                s
                              
                              ⁢
                              
                                cos
                                ⁡
                                
                                  (
                                  
                                    
                                      θ
                                      M
                                    
                                    -
                                    
                                      θ
                                      v
                                    
                                  
                                  )
                                
                              
                            
                            ]
                          
                        
                      
                    
                    ,
                  
                
              
            
            
              
                
                  
                    
                      f
                      y
                    
                    =
                    
                      
                        ψ
                        t
                      
                      ⁢
                      
                        
                          sin
                          ⁡
                          
                            (
                            
                              θ
                              M
                            
                            )
                          
                        
                        /
                        
                          [
                          
                            
                              v
                              s
                            
                            ⁢
                            
                              cos
                              ⁡
                              
                                (
                                
                                  
                                    θ
                                    M
                                  
                                  -
                                  
                                    θ
                                    v
                                  
                                
                                )
                              
                            
                          
                          ]
                        
                      
                    
                  
                  )
                
              
            
            
              
                
                  
                    H
                    t
                    2
                  
                  ⁡
                  
                    (
                    
                      
                        f
                        t
                      
                      =
                      
                        
                          v
                          s
                        
                        /
                        
                          [
                          
                            
                              cos
                              ⁡
                              
                                (
                                
                                  
                                    θ
                                    v
                                  
                                  -
                                  
                                    θ
                                    M
                                  
                                
                                )
                              
                            
                            ⁢
                            
                              ψ
                              s
                            
                          
                          ]
                        
                      
                    
                    )
                  
                
              
            
          
          
            
              ∑
              
                Ω
                M
              
            
            ⁢
            
              
                W
                V
              
              ⁡
              
                (
                
                  
                    Ω
                    M
                  
                  ,
                  
                    Ω
                    V
                  
                
                )
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        9
      
    
  




where fx, fy, and ft are the frequency variables corresponding to x, y and t in the frequency domain representation of the spatial and temporal impulse response functions Hs(fx,fy) and Ht(ft). The output of the velocity stage is a population code of individual features ξv(t,Ωv), each tuned to a particular image location (xM,yM), velocity speed vs, and velocity orientation θv.

In practice, the velocity features ξv(t,Ωv) are tuned too broadly in velocity speed vs. The expansive normalization, as taught in S. J. Nowlan and T. J. Sejnowski, A Selection Model for Motion Processing in Area MT of Primates, The Journal of Neuroscience, vol. 15, February 1995, incorporated herein by reference, results in the following inhibited velocity equation:




  
    
      
        
          
            ξ
            VI
          
          ⁡
          
            (
            
              t
              ,
              
                Ω
                V
              
            
            )
          
        
        =
        
          
            e
            
              
                α
                v
              
              ⁢
              
                
                  ξ
                  v
                
                ⁡
                
                  (
                  
                    t
                    ,
                    
                      Ω
                      v
                    
                  
                  )
                
              
            
          
          /
          
            
              ∑
              
                V
                s
              
            
            ⁢
            
              e
              
                
                  α
                  v
                
                ⁢
                
                  
                    ξ
                    v
                  
                  ⁡
                  
                    (
                    
                      t
                      ,
                      
                        Ω
                        v
                      
                    
                    )
                  
                
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        10
      
    
  




that implements mutual inhibition and normalization. This step narrows the velocity tuning characteristics of the plain velocity features with the parameter αv, which is empirically determined, setting the amount of mutual inhibition.

The velocity algorithm is incorporated into the computer code used to practice the present invention through modules VelocityColumn.cc, VelocityColumn.compute.cc, VelocityInitializer.cc, and VelocityServer.cc, which are included in the appendix.
Rotation Algorithm
When the robot turns, global velocity flows occur that are equal in magnitude across the whole image as disclosed in J. A. Perrone, Model for the Computation of Self-motion in Biological Systems, Journal of the Optical Society of America A, vol.9, 1992, incorporated herein by reference. These flows corrupt the relationship between the velocity speed vs and the distance to the object in the world. The first step in compensating for rotation is estimating the magnitude of the rotational flow R by computing a new population code ξR(t,R). Because rotational flow is constant across the image, the rotational features detect horizontally oriented velocities θv≈0 or θv≈π with similar velocity speed tunings vs across the whole image:




  
    
      
        
          
            ξ
            R
          
          ⁡
          
            (
            
              t
              ,
              R
            
            )
          
        
        =
        
          
            ∑
            
              θ
              V
            
          
          ⁢
          
            
              
                W
                R
              
              ⁡
              
                (
                
                  
                    Ω
                    V
                  
                  ,
                  R
                
                )
              
            
            ⁢
            
              
            
            ⁢
            
              
                ξ
                VI
              
              ⁡
              
                (
                
                  t
                  ,
                  
                    Ω
                    V
                  
                
                )
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        11
      
    
  




where the rotation weights

WR(ΩV,R)=WRH(R,vs,θV)[WRF(xM,yM)+WRT(θT,θV)]  Equation 12

pick the horizontally oriented velocity features with the term

WRH(R,vs,θV)=e−1/2[(R−Vs)/σR]2 for θVε{0,π}  Equation 13

    
    
        or zero otherwise

where αR determines the spread of velocity speeds around rotational flow R.

A pair of useful optional enhancements to the rotational weights are, first

WRT(θT,θV)=1−e−1/2[(θT−θV)/σθ]2  Equation 14

that discounts particular rotational flows that might not be from the robot turning, but from the useful flow that indicates distance to an object. In this term, θT is the orientation that results from the robot approaching an object without turning that points directly away from the focus of expansion near the center of the image. Hence, the WRT term eliminates velocity features from the rotation algorithm that cannot be distinguished between flow from an approaching object and flow from rotation. The term σθ determines the separation between the θT and θV required for the WRT term to be included in the rotation features.

    
    


The second enhancement,

WRF(xM,yM)=e−1/2[(xM2+yM2)/σRF2]  Equation 15

emphasizes the region in the center of the image (around the focus of expansion) that results from rotational flow and never from an approaching object. The size of the region free of parallax induced motion is indicated by σRF.

The rotation algorithm is incorporated into the computer code used to practice the present invention through the module RotationServer.cc, which is included in the appendix.
Translation Algorithm
The translation algorithm eliminates the adverse effects of the aperture problem and rotational flow. The distance to an object is coded in the speed that the object appears to move in the direction opposite the focus of expansion θT. This speed is called the translation speed vt, where the translation orientation is θT=a tan(yM/xM). Thus, the translation orientation is a fixed angle that is computed from the relationship of the image position and the focus of expansion and is not an independent tuning variable. The population coded translation features




  
    
      
        
          
            ξ
            T
          
          ⁡
          
            (
            
              t
              ,
              
                Ω
                T
              
            
            )
          
        
        =
        
          
            ∑
            
              Ω
              
                V
                ,
                R
              
            
          
          ⁢
          
            
              
                W
                T
              
              ⁡
              
                (
                
                  
                    Ω
                    V
                  
                  ,
                  R
                  ,
                  
                    Ω
                    T
                  
                
                )
              
            
            ⁢
            
              
                ξ
                VI
              
              ⁡
              
                (
                
                  t
                  ,
                  
                    Ω
                    V
                  
                
                )
              
            
            ⁢
            
              
            
            ⁢
            
              
                ξ
                R
              
              ⁡
              
                (
                
                  t
                  ,
                  R
                
                )
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        16
      
    
  




subtract the rotational estimate R from the inhibited velocity features ξVI(t,ΩV), and align their orientations from θV to θT according to the weights

WT(ΩV,R,ΩT)=e−1/2[|({right arrow over (C)}−{right arrow over (T)}−{right arrow over (R)})|/σC]2  Equation 17

where {right arrow over (T)}=vt∠θt is the corrected vector, {right arrow over (R)}=R∠0 is the horizontal flow vector resulting from rotation, {right arrow over (C)}=vs∠θv is the uncorrected velocity vector tuning, and σc defines the range of velocity feature tunings that contribute to the translation features ξT(t,ΩT).

The subtraction of {right arrow over (R)} accommodates rotational flow, and the alignment resolves the aperture problem. This operation takes advantage of the fact that the velocity features include all the velocity vectors consistent with the aperture problem, choosing the subset of activated velocity features closest in tuning to the vector {right arrow over (T)}. The translation stage output is a set of features tuned to ΩT={xM,yM,vT}.
The translation features ξT(t,ΩT) are equivalent to distance detectors if one considers the distance tuning as D=√{square root over (xM2+yM2)}/VT and the focus of expansion at x=y=0. Hence, the translation detectors ξT(t,ΩT) may be interpreted to indicate the “time to collision”, or distance, between the electronic imager and an object in the environment.
The translation algorithm is incorporated into the computer code used to practice the present invention through the modules TranslationColumn.cc, TranslationServer.cc, TranslationInitializer.cc, and CollisionServer.cc, which are included in the appendix.
Navigation Algorithm
Navigation consists of two complimentary functions. First, the robot must be programmed to go somewhere different than the robot's current location. Often, this primary “strategic” goal is a programmed waypoint that the robot must reach to deliver a payload object, take a picture, or achieve some other application specific purpose; without such a goal, the robot has no motivation to move at all. The secondary “Tactical” goal is to avoid collisions along the way. Thus, the obstacle avoidance task, implemented by the present invention, is independent of the robot's strategic goal.
As the robot moves forward, several options are available at any given time. The robot may maintain the current heading or the robot may turn left or right. When turning, the robot may turn in varying speeds. The turn rate RC varies from −1, that represents the fastest left turn, to +1, that represents the fastest right turn. A turn rate of zero indicates no turn. The strategic control vector ξCW(t,RC) is a population coded representation of RC.
Tactical Navigation
The present invention demonstrates the tactical goal of obstacle avoidance. The result ξT(t,ΩT) indicates the distance to various objects in the scene. The tactical control vector




  
    
      
        
          
            ξ
            CA
          
          ⁡
          
            (
            
              t
              ,
              
                R
                C
              
            
            )
          
        
        =
        
          
            ∑
            
              Ω
              T
            
          
          ⁢
          
            
              
                W
                R
              
              ⁡
              
                (
                
                  
                    Ω
                    T
                  
                  ,
                  
                    R
                    C
                  
                
                )
              
            
            ⁢
            
              
            
            ⁢
            
              
                ξ
                T
              
              ⁡
              
                (
                
                  t
                  ,
                  
                    Ω
                    T
                  
                
                )
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        18
      
    
  




picks new directions by pointing the robot at distant objects as represented in ξT(t,ΩT) according to the weights

WA(ΩT,RC)=WAX(RC,xM)WAD(D)WAFOE(xM,yM).  Equation 19

The factor WAX(RC,xM) chooses a course correction RC to steer away from detected obstacles in the region σx around xM:





  
    
      
        
          
            
              
                
                  
                    W
                    AX
                  
                  ⁡
                  
                    (
                    
                      
                        R
                        C
                      
                      ,
                      
                        x
                        M
                      
                    
                    )
                  
                
                =
                
                ⁢
                
                  
                    
                      e
                      
                        -
                        
                          
                            [
                            
                              
                                (
                                
                                  
                                    
                                      R
                                      X
                                    
                                    ⁡
                                    
                                      (
                                      
                                        
                                          R
                                          C
                                        
                                        -
                                        1
                                      
                                      )
                                    
                                  
                                  -
                                  
                                    X
                                    M
                                  
                                
                                )
                              
                              /
                              
                                σ
                                X
                              
                            
                            ]
                          
                          2
                        
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    for
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                  ≥
                  
                    R
                    C
                  
                  >
                  0
                
              
              ,
              and
            
          
        
        
          
            
              
              ⁢
              
                
                  
                    
                      e
                      
                        -
                        
                          
                            [
                            
                              
                                (
                                
                                  
                                    
                                      R
                                      X
                                    
                                    ⁡
                                    
                                      (
                                      
                                        
                                          R
                                          C
                                        
                                        +
                                        1
                                      
                                      )
                                    
                                  
                                  -
                                  
                                    X
                                    M
                                  
                                
                                )
                              
                              /
                              
                                σ
                                X
                              
                            
                            ]
                          
                          2
                        
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    for
                  
                  ⁢
                  
                    
                  
                  -
                  1
                
                ≤
                
                  R
                  C
                
                ≤
                0
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        20
      
    
  




where RX is the number of pixels to the edge of the stimulus from the focus of expansion near the center of the image. The expressions RX(RC−1) and RX(RC+1) scale Rc to the same units as the horizontal pixel coordinate xM. Obstacles detected horizontally near the focus of expansion (xM≈0) generate strong course corrections in contrast to obstacles near the scene periphery that cause only minor adjustments. The distinction between positive and negative RC determines the corresponding behavior for right and left turns.

The term

WAD(D)=1−[(D−min(D))/(max(D)−min(D))]  Equation 21

emphasizes close objects, so the nearest obstacle is avoided first.

The region around the focus of expansion at the center of the image does not provide good distance estimates, so

WAFOE(xM,yM)=0 for |xM|<10, |yM|<20, and 1 elsewhere  Equation 22

discounts those inputs.

Combined Navigation

Usually, the course towards the strategic goal, indicated by ξCW(t,RC), and the course that best avoids obstacles, indicated by ξCA(t,RC), are different. At any given time, one course or the other must be chosen. Generally, ξCW(t,RC) is the default behavior guiding the robot towards a useful goal. However, when an obstacle lies in between the robot and the waypoint, the tactical course ξCA(t,RC) necessarily takes priority as the obstacle is avoided. The two control vectors are combined as




  
    
      
        
          
            ξ
            C
          
          ⁡
          
            (
            
              t
              ,
              
                R
                C
              
            
            )
          
        
        =
        
          
            e
            
              
                α
                C
              
              ⁡
              
                [
                
                  
                    
                      ξ
                      CW
                    
                    ⁡
                    
                      (
                      
                        t
                        ,
                        
                          R
                          C
                        
                      
                      )
                    
                  
                  +
                  
                    
                      β
                      C
                    
                    ⁢
                    
                      
                        ξ
                        CA
                      
                      ⁡
                      
                        (
                        
                          t
                          ,
                          
                            R
                            C
                          
                        
                        )
                      
                    
                  
                
                ]
              
            
          
          
            
              ∑
              
                R
                C
              
            
            ⁢
            
              e
              
                
                  α
                  C
                
                ⁡
                
                  [
                  
                    
                      
                        ξ
                        CW
                      
                      ⁡
                      
                        (
                        
                          t
                          ,
                          
                            R
                            C
                          
                        
                        )
                      
                    
                    +
                    
                      
                        β
                        C
                      
                      ⁢
                      
                        
                          ξ
                          CA
                        
                        ⁡
                        
                          (
                          
                            t
                            ,
                            
                              R
                              C
                            
                          
                          )
                        
                      
                    
                  
                  ]
                
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        23
      
    
  




to implement the joint behavior. The empirically determined parameter βC determines the threshold at which ξCA(t,RC) takes the priority, and αC implements mutual inhibition such that one and only one course RC dominates at any given time.

At the end of the algorithmic processing, the population coded control vector ξC(t,RC) is converted from a population code to a single scalar number




  
    
      
        
          
            C
            T
          
          ⁡
          
            (
            t
            )
          
        
        =
        
          
            ∑
            
              R
              C
            
          
          ⁢
          
            
              
                ξ
                C
              
              ⁡
              
                (
                
                  t
                  ,
                  
                    R
                    C
                  
                
                )
              
            
            ⁢
            
              
                R
                C
              
              /
              
                
                  ∑
                  
                    R
                    C
                  
                
                ⁢
                
                  
                    ξ
                    C
                  
                  ⁡
                  
                    (
                    
                      t
                      ,
                      
                        R
                        C
                      
                    
                    )
                  
                
              
            
          
        
      
    
    
      
        Equation
        ⁢
        
          
        
        ⁢
        24
      
    
  




that is used as a control signal.

The navigation algorithm is incorporated into the computer code used to practice the present invention through the module ControlServer.py, which is included in the appendix.
EXAMPLE
Hardware Design Features
Referring to FIG. 4, in order to practice the method of the present invention, a hardware system comprising the following physical components was assembled: remote control robotic chassis 200, electronic imaging device 210, video transmitter 220, video receiver 230, digital multiprocessor computer 240, control radio transmitter 250, and control radio receiver 260.
Robotic chassis 200 was a small remote control model tank, just large enough to support the required payload of a few pounds. The model tank's control system, supplied with the model, included two drive motors, radio receiver 260 of a type used by model airplanes, an electronic circuit to convert servo commands received from receiver 260 into motor control signals, and two rechargeable batteries that powered receiver 260 and the drive motors. The original tank model was stripped of its cosmetic accessories to make room for an aluminum platform upon which the custom image acquisition and video transmission hardware was mounted.
Radio transmitter 250 used with chassis 200 was designed for manual operation. In this application, computer based control was achieved using a “trainer” feature of the radio. Normally, the trainer port accepts electronic commands from a second radio transmitter, often in the hands of a student pilot. For this demonstration, however, a custom circuit was substituted for the student's radio, which translated automatic commands from digital multiprocessor computer 240 into the electronic format compatible with the trainer port.
Electronic imaging device 210, a common CCD camera, was mounted on an aluminum post at the rear of chassis 200. The post mounting hardware allowed for coarse adjustment of the vertical and horizontal view angles of electronic imaging device 210 to ensure the focus of expansion (focal plane) was approximately at the center of the acquired imagery. There was no active control of electronic imaging device 210 orientation; once set, electronic imaging device 210 always pointed straight forward. Electronic imaging device 210 was mounted at the back of chassis 200 to reduce the possibility of objects leaving the field of view before they were safely avoided; this reduces the possibility of “body clipping”, a problem that occurs if electronic imaging device 210 is mounted forward on chassis 200, which results in an identified obstacle being forgotten by the computer program before the rear of the chassis 200 clears the obstacle, often resulting in a collision. The body clipping problem was reduced by mounting electronic imaging device 210 on the back of chassis 200.
Image transmission was performed with inexpensive wireless video transmitter 220 and video receiver 230. Electronic imaging device 210 produced a video signal compatible with video transmitter 220, and digital multiprocessor computer 240 recorded the output from video receiver 230 using a framegrabber accessory designed for video and television applications. The video transmission occurred with completely separate apparatus and frequency from the motor control radio. Electronic imaging device 210 and video transmitter 220 were powered with a rechargeable battery (not shown) mounted on robotic chassis 200.
Digital multiprocessor computer 240 comprised a cluster of sixteen 933 MHz Pentium-III processors, interconnected with 100 MBit ethernet, running the GNU/Linux operating system.
Software Design Features
The method of the present invention, as implemented in software, required more computer power than a single processor could provide for real time performance and control, thus, multiple processors were used. FIG. 5 is a table showing a rough estimate of the computational requirements of the present invention. The estimates add up to about 770 million floating point operations per frame (FLOPS). The overall computer computation ran at about 11 frames per second, for a total computational throughput of about 8.5 billion floating point operations per second. The column labeled “Interconnect Bandwidth” is the number of FLOPS that traveled to the next algorithm process over the ethernet that connected the multiple processors.
In order to take advantage of multiprocessing, each of the stages described above were implemented as a distinct computational process. Together, the processes implemented the method displayed in FIG. 3, with each process working on a whole timestep of data at a time. Following the method, each process worked on a different timestep relative to the others. Each stage of data assimilation used a whole frame to transfer between processes during which it was not otherwise involved in computation. Thus, processing the method achieved high throughput, but also generated several frames of latency between the time an image was captured and that frame influenced the navigational behavior in the Control module. In practice, the software ran at a rate of 11 frames per second, and the latency was about 1 second.
The stages of “Rotation”, “Translation”, “Collision”, and “Control”, each executed on a single processor. In some cases, processors were shared between these tasks if they ran fast enough. The “Motion” and “Velocity” stages were too large to execute on a single processor in real time, therefore, multiple processors were used for those individual tasks.
Many commonly available “open source” software modules were used in the implementation of the software. The software code used in this example of the present invention was written in the C++ language, using the Blitz++ library to support large multi-dimensional arrays. For message passing between processors, the LAM implementation of the MPI standard was used. The smaller processes were implemented in the Python language, using the Numerical Python extensions to implement arrays. Data was logged by a dedicated process using the NetCDF protocol and associated library. All of the original software code modules used to practice the present invention are located in the attached computer program listing appendix. Modules with the “cc” extension are in the C++ language. Modules with a “py” extension are in the Python language.
Test Run of Robot on Obstacle Course
The primary goal of the robot using the method of the present invention was to program the robot to follow a waypoint specified course that included obstacles. Waypoint finding is a useful goal which in real applications is easily implemented using the Global Positioning System (GPS).
FIG. 6 is a diagram of experimental arena 300. Obstacles 310 and 320 were placed within experimental arena 300 as shown. FIG. 7 displays the pattern placed on obstacles 310, 320 for the imager to detect. As shown, obstacles 310, 320 exhibited a line pattern perpendicular to the floor of experimental arena 300. The robot was pre-programmed to travel between the waypoints (strategic navigation) in square path pattern 400 as shown in FIG. 8 by the four marked waypoints 410, 420, 430, and 440.
FIG. 9 shows path 500 that the robot took along the programmed waypoint path. Obstacle location information was contained in the translation algorithm, ξT(t,ΩT). The translation information was integrated within the navigational algorithm, ξC(t,RC).
The result demonstrated herein is novel in the ability to handle more complex environments than previous autonomous robot works using only vision derived input. This test demonstrates for the first time the use of population coded time-to-collision features that were used as sensory input into a population coded control model. The experimental results were novel in the size and speed of the simulation and complexity of the real world arena. The obstacles were successfully avoided using vision alone with autonomy demonstrated by the robot.
The foregoing description of the invention has been presented for purposes of illustration and description and is not intended to be exhaustive or to limit the invention to the precise form disclosed, and obviously many modifications and variations are possible in light of the above teaching.
The embodiments were chosen and described in order to best explain the principles of the invention and its practical application to thereby enable others skilled in the art to best utilize the invention in various embodiments and with various modifications as are suited to the particular use contemplated. It is intended that the scope of the invention be defined by the claims appended hereto.

## Claims

1. A method for avoiding objects along a path programmed into a robot comprising the following steps in the order named:
(a) establishing a field of view for an electronic imager of said robot along said path,
(b) obtaining object location information in said field of view,
(c) deriving a population coded control signal from said object location information by,
processing a population coded motion energy algorithm that decomposes a video stream of said object location information into spatial and temporal frequency components,
processing a population coded velocity algorithm that recombines said spatial and temporal frequency components corresponding to said object and provides a velocity output, thereby identifying how said object is moving in said field of view,
processing a population coded rotation algorithm that determines if said electronic imager is turning and provides a turning information output,
processing a population coded translation algorithm that transforms said velocity output of said velocity algorithm into a speed signal and calculates a distance between said object and said electronic imager providing a strategic control vector and a tactical control vector,
processing a population coded navigation algorithm where said strategic control vector, said tactical control vector, and said turning information output are used to derive said population coded control signal, and

(d) transmitting said population coded control signal to said robot, thereby allowing said robot to avoid said object.

2. A method for deriving a distance from an object to an electronic imager comprising the following steps in the order named:
(a) establishing a field of view for said electronic imager,
(b) obtaining object location information in said field of view,
(c) deriving said distance from said object to said electronic imager by,
processing a population coded motion energy algorithm that decomposes a video stream of said object location information into spatial and temporal frequency components,
processing a population coded velocity algorithm that recombines said spatial and temporal frequency components corresponding to said object and provides a velocity output, thereby identifying how said object is moving in said field of view, and
processing a population coded translation algorithm that transforms said velocity output of said velocity algorithm into a speed signal and calculates said distance between said object and said electronic imager.