From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02343.html | 1102 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1102 insertions(+) create mode 100644 docs/doxygen/nel/a02343.html (limited to 'docs/doxygen/nel/a02343.html') diff --git a/docs/doxygen/nel/a02343.html b/docs/doxygen/nel/a02343.html new file mode 100644 index 00000000..f076028b --- /dev/null +++ b/docs/doxygen/nel/a02343.html @@ -0,0 +1,1102 @@ + + +NeL: NLAINIMAT::CClassifierSystem class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLAINIMAT::CClassifierSystem Class Reference

#include <classifier.h> +

+

Detailed Description

+A simple and minimal version of a Classifier System.
Author:
Gabriel ROBERT

+Nevrax France

+
Date:
2001
+ +

+ +

+Definition at line 165 of file classifier.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

void addClassifier (const CConditionMap &conditionsMap, CClassifierPriority priority, TAction behavior)
void addClassifierSystem (const CClassifierSystem &cs)
 Merge two CS.

 CClassifierSystem ()
 Destructor.

void dividePriorityByTheMinPriorityPart ()
TAction getActionPart (TClassifierNumber classifierNumber) const
TClassifierNumber getClassifierNumber () const
 Return the number of classifiers.

void getDebugString (TClassifierNumber classifierNumber, std::string &t) const
void getDebugString (std::string &t) const
CClassifierPriority getPriorityPart (TClassifierNumber classifierNumber) const
void selectBehavior (const CCSPerception *psensorMap, std::multimap< CClassifierPriority, std::pair< TClassifierNumber, TTargetId > > &mapActivableCS)
void setPriorityPart (TClassifierNumber classifierNumber, CClassifierPriority priority)
virtual ~CClassifierSystem ()

Private Types

typedef std::map< TClassifierNumber,
+ CClassifier * >::iterator 		TitClassifiers

Private Member Functions

void RAZNoTargetSensors ()
void RAZTargetSensors ()
void updateNoTargetSensors (const CCSPerception *psensorMap)
void updateTargetSensors (const CCSPerception *psensorMap, TTargetId target)

Private Attributes

TClassifierNumber _ClassifierNumber
std::map< TClassifierNumber,
+ CClassifier * > 		_Classifiers
TSensorMap _Sensors
+

Member Typedef Documentation

+

+ + + + +
+ + +
typedef std::map<TClassifierNumber, CClassifier*>::iterator NLAINIMAT::CClassifierSystem::TitClassifiers [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 200 of file classifier.h. +

+Referenced by selectBehavior().

+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
NLAINIMAT::CClassifierSystem::CClassifierSystem (   ) 
+
+ + + + + +
+   + + +

+Destructor. +

+ +

+Definition at line 79 of file classifier.cpp. +

+References _ClassifierNumber. +

+

00080 {
+00081         _ClassifierNumber = 0;
+00082 }
+
+

+ + + + +
+ + + + + + + + + +
NLAINIMAT::CClassifierSystem::~CClassifierSystem (   )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Definition at line 84 of file classifier.cpp. +

+References _Classifiers. +

+

00085 {
+00086         std::map<TClassifierNumber, CClassifier*>::iterator itClassifiers = _Classifiers.begin();
+00087         while (itClassifiers != _Classifiers.end())
+00088         {
+00089                 delete (*itClassifiers).second;
+00090                 itClassifiers++;
+00091         }
+00092 }
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAINIMAT::CClassifierSystem::addClassifier ( const CConditionMap &  conditionsMap,
CClassifierPriority  priority,
TAction  behavior
) 
+
+ + + + + +
+   + + +

+Add a new classifier in the classifier system.

Parameters:
+ + + + +
conditionsMap is a map whose key is the sensor name and value the sensor value.
priority is the importance of this rule. The value should be between 0 an 1.
behavior is the action to execute if this classifier is selected.
+
+ +

+Definition at line 94 of file classifier.cpp. +

+References _ClassifierNumber, _Classifiers, _Sensors, NLAINIMAT::CConditionMap::begin(), NLAINIMAT::CClassifierSystem::CClassifier::Behavior, NLAINIMAT::CClassifierSystem::CClassifier::ConditionWithoutTarget, NLAINIMAT::CClassifierSystem::CClassifier::ConditionWithTarget, NLAINIMAT::CConditionMap::end(), NLAINIMAT::CClassifierSystem::CClassifier::Priority, and NLAINIMAT::TSensor. +

+Referenced by addClassifierSystem(), NLAINIMAT::CActionClassifiers::addMotivationRule(), and NLAINIMAT::CActionClassifiers::addVirtualActionRule(). +

+

00095 {
+00096         // We build a new classifier.
+00097         CClassifier* classifier = new CClassifier();
+00098         classifier->Behavior = behavior;
+00099         classifier->Priority = priority;
+00100 
+00101         CClassifierConditionCell* condCell;
+00102         std::map<TSensor, CConditionMap::CSensor >::const_iterator itCondition;
+00103         for (itCondition = conditionsMap.begin(); itCondition != conditionsMap.end(); itCondition++)
+00104         {
+00105                 // We add the new sensor in the sensor map and init it with a joker value '#'
+00106                 TSensor bibu = (*itCondition).first;
+00107                 _Sensors[(*itCondition).first] = '#';
+00108 
+00109                 // A new condition cell is added to the classifier condition.
+00110                 condCell = new CClassifierConditionCell(_Sensors.find((*itCondition).first),
+00111                                                                                                 (*itCondition).second.SensorValue,
+00112                                                                                                 (*itCondition).second.TruthValue);
+00113                 if ((*itCondition).second.NeedTarget)
+00114                 {
+00115                         classifier->ConditionWithTarget.push_back(condCell);
+00116                 }
+00117                 else
+00118                 {
+00119                         classifier->ConditionWithoutTarget.push_back(condCell);
+00120                 }
+00121         }
+00122 
+00123         // The new classifier is added to the classifier list.
+00124         _Classifiers[_ClassifierNumber++] = classifier;
+00125 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAINIMAT::CClassifierSystem::addClassifierSystem ( const CClassifierSystem &  cs  ) 
+
+ + + + + +
+   + + +

+Merge two CS. +

+ +

+Definition at line 128 of file classifier.cpp. +

+References _Classifiers, addClassifier(), NLAINIMAT::CConditionMap::addSensorCondition(), NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getSensorIsTrue(), NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getSensorName(), and NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getValue(). +

+Referenced by NLAINIMAT::CMHiCSbase::addVirtualActionCS(). +

+

00129 {
+00130         std::map<TClassifierNumber, CClassifier*>::const_iterator itCSClassifiers;
+00131 
+00132         // Pour chacun des classeurs de cs
+00133         for (itCSClassifiers = cs._Classifiers.begin(); itCSClassifiers != cs._Classifiers.end(); itCSClassifiers++)
+00134         {
+00135                 CConditionMap conditionsMap;
+00136                 std::list<CClassifierConditionCell*>::const_iterator itCondCell;
+00137 
+00138                 // Pour chacune des condition sans cible d'un de ces classeur
+00139                 for (itCondCell = (*itCSClassifiers).second->ConditionWithoutTarget.begin();
+00140                         itCondCell !=(*itCSClassifiers).second->ConditionWithoutTarget.end();
+00141                         itCondCell++)
+00142                 {
+00143                         CClassifierConditionCell* pCondCell = (*itCondCell);
+00144                         // Je construit une liste de condition
+00145                         conditionsMap.addSensorCondition(pCondCell->getSensorName(), pCondCell->getValue(),pCondCell->getSensorIsTrue());
+00146                 }
+00147 
+00148                 // Pour chacune des condition avec cible d'un de ces classeur
+00149                 for (itCondCell = (*itCSClassifiers).second->ConditionWithTarget.begin();
+00150                         itCondCell !=(*itCSClassifiers).second->ConditionWithTarget.end();
+00151                         itCondCell++)
+00152                 {
+00153                         CClassifierConditionCell* pCondCell = (*itCondCell);
+00154                         // Je construit une liste de condition
+00155                         conditionsMap.addSensorCondition(pCondCell->getSensorName(), pCondCell->getValue(),pCondCell->getSensorIsTrue());
+00156                 }
+00157                 
+00158                 // je rajoute dans mon cs un nouveau classeur avec ces conditions, la priorité et le comportement du classeur
+00159                 addClassifier(conditionsMap, (*itCSClassifiers).second->Priority, (*itCSClassifiers).second->Behavior);
+00160         }
+00161 }
+
+

+ + + + +
+ + + + + + + + + +
void NLAINIMAT::CClassifierSystem::dividePriorityByTheMinPriorityPart (   ) 
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + +
TAction NLAINIMAT::CClassifierSystem::getActionPart ( TClassifierNumber  classifierNumber  )  const
+
+ + + + + +
+   + + +

+Give the action part of a given Classifier.

Parameters:
+ + +
classifierNumber is the number of the classifier.
+
+
Returns:
is the condition part of the wanted Classifier.
+ +

+Definition at line 413 of file classifier.cpp. +

+References _Classifiers, nlassert, NLAINIMAT::TAction, and NLAINIMAT::TClassifierNumber. +

+

00414 {
+00415         std::map<TClassifierNumber, CClassifier*>::const_iterator itClassifiers = _Classifiers.find(classifierNumber);
+00416         nlassert(itClassifiers != _Classifiers.end());
+00417         return (*itClassifiers).second->Behavior;
+00418 }
+
+

+ + + + +
+ + + + + + + + + +
TClassifierNumber NLAINIMAT::CClassifierSystem::getClassifierNumber (   )  const [inline]
+
+ + + + + +
+   + + +

+Return the number of classifiers. +

+ +

+Definition at line 262 of file classifier.h. +

+References _ClassifierNumber, and NLAINIMAT::TClassifierNumber. +

+

00262 {return _ClassifierNumber;}
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAINIMAT::CClassifierSystem::getDebugString ( TClassifierNumber  classifierNumber,
std::string &  t
)  const
+
+ + + + + +
+   + + +

+ +

+Definition at line 505 of file classifier.cpp. +

+References _Classifiers, NLAINIMAT::CClassifierPriority::getPriority(), NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getSensorIsTrue(), NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getSensorName(), NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getValue(), nlassert, t, NLAINIMAT::TClassifierNumber, and NLMISC::toString(). +

+

00506 {
+00507         std::string dbg = "";
+00508         std::map<TClassifierNumber, CClassifier*>::const_iterator itClassifiers = _Classifiers.find(classifierNumber);
+00509         nlassert (itClassifiers != _Classifiers.end());
+00510 
+00511         dbg += "<" + NLMISC::toString(classifierNumber) + "> ";
+00512         std::list<CClassifierConditionCell*>::const_iterator itConditions;
+00513         // On parcour la liste de sensor indépendant d'une cible
+00514         for (itConditions = (*itClassifiers).second->ConditionWithoutTarget.begin();
+00515         itConditions != (*itClassifiers).second->ConditionWithoutTarget.end();
+00516         itConditions++)
+00517         {
+00518                 CClassifierConditionCell* condCell = (*itConditions);
+00519                 if (condCell->getSensorIsTrue())
+00520                 {
+00521                         dbg += " (" + conversionSensor.toString(condCell->getSensorName()) + "= " + condCell->getValue() + ") +";
+00522                 }
+00523                 else
+00524                 {
+00525                         dbg += " (" + conversionSensor.toString(condCell->getSensorName()) + "=!" + condCell->getValue() + ") +";
+00526                 }
+00527         }
+00528         // On parcour la liste de sensor dépendant d'une cible
+00529         for (itConditions = (*itClassifiers).second->ConditionWithTarget.begin();
+00530         itConditions != (*itClassifiers).second->ConditionWithTarget.end();
+00531         itConditions++)
+00532         {
+00533                 CClassifierConditionCell* condCell = (*itConditions);
+00534                 if (condCell->getSensorIsTrue())
+00535                 {
+00536                         dbg += " (" + conversionSensor.toString(condCell->getSensorName()) + "(x)= " + condCell->getValue() + ") +";
+00537                 }
+00538                 else
+00539                 {
+00540                         dbg += " (" + conversionSensor.toString(condCell->getSensorName()) + "(x)=!" + condCell->getValue() + ") +";
+00541                 }
+00542         }
+00543         std::string actionName = conversionAction.toString((*itClassifiers).second->Behavior);
+00544         CClassifierPriority             prio = (*itClassifiers).second->Priority;
+00545         dbg += "> " + actionName + " [" + NLMISC::toString(prio.getPriority()) + "]";
+00546         t += dbg;
+00547 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAINIMAT::CClassifierSystem::getDebugString ( std::string &  t  )  const
+
+ + + + + +
+   + + +

+ +

+Definition at line 459 of file classifier.cpp. +

+References _Classifiers, NLAINIMAT::CClassifierPriority::getPriority(), NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getSensorIsTrue(), NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getSensorName(), NLAINIMAT::CClassifierSystem::CClassifierConditionCell::getValue(), t, and NLMISC::toString(). +

+

00460 {
+00461         std::string dbg = "\n";
+00462 
+00463         std::map<TClassifierNumber, CClassifier*>::const_iterator itClassifiers;
+00464         for (itClassifiers = _Classifiers.begin(); itClassifiers != _Classifiers.end(); itClassifiers++)
+00465         {
+00466                 dbg += "<" + NLMISC::toString((*itClassifiers).first) + "> ";
+00467                 std::list<CClassifierConditionCell*>::const_iterator itConditions;
+00468                 // On parcour la liste de sensor indépendant d'une cible
+00469                 for (itConditions = (*itClassifiers).second->ConditionWithoutTarget.begin();
+00470                         itConditions != (*itClassifiers).second->ConditionWithoutTarget.end();
+00471                         itConditions++)
+00472                 {
+00473                         CClassifierConditionCell* condCell = (*itConditions);
+00474                         if (condCell->getSensorIsTrue())
+00475                         {
+00476                                 dbg += " (" + conversionSensor.toString(condCell->getSensorName()) + "= " + condCell->getValue() + ") +";
+00477                         }
+00478                         else
+00479                         {
+00480                                 dbg += " (" + conversionSensor.toString(condCell->getSensorName()) + "=!" + condCell->getValue() + ") +";
+00481                         }
+00482                 }
+00483                 // On parcour la liste de sensor dépendant d'une cible
+00484                 for (itConditions = (*itClassifiers).second->ConditionWithTarget.begin();
+00485                         itConditions != (*itClassifiers).second->ConditionWithTarget.end();
+00486                         itConditions++)
+00487                 {
+00488                         CClassifierConditionCell* condCell = (*itConditions);
+00489                         if (condCell->getSensorIsTrue())
+00490                         {
+00491                                 dbg += " (" + conversionSensor.toString(condCell->getSensorName()) + "(x)= " + condCell->getValue() + ") +";
+00492                         }
+00493                         else
+00494                         {
+00495                                 dbg += " (" + conversionSensor.toString(condCell->getSensorName()) + "(x)=!" + condCell->getValue() + ") +";
+00496                         }
+00497                 }
+00498                 std::string actionName = conversionAction.toString((*itClassifiers).second->Behavior);
+00499                 CClassifierPriority             prio = (*itClassifiers).second->Priority;
+00500                 dbg += "> " + actionName + " [" + NLMISC::toString(prio.getPriority()) + "]\n";
+00501         }
+00502         t += dbg;
+00503 }
+
+

+ + + + +
+ + + + + + + + + + +
CClassifierPriority NLAINIMAT::CClassifierSystem::getPriorityPart ( TClassifierNumber  classifierNumber  )  const
+
+ + + + + +
+   + + +

+ +

+Definition at line 420 of file classifier.cpp. +

+References _Classifiers, nlassert, and NLAINIMAT::TClassifierNumber. +

+

00421 {
+00422         std::map<TClassifierNumber, CClassifier*>::const_iterator itClassifiers = _Classifiers.find(classifierNumber);
+00423         nlassert(itClassifiers != _Classifiers.end());
+00424         return (*itClassifiers).second->Priority;
+00425 }
+
+

+ + + + +
+ + + + + + + + + +
void NLAINIMAT::CClassifierSystem::RAZNoTargetSensors (   )  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 215 of file classifier.cpp. +

+References _Sensors, and NLAINIMAT::Sensors_WITHTARGET. +

+Referenced by selectBehavior(). +

+

00216 {
+00217         TSensorMap::iterator itSensorBorder = _Sensors.upper_bound(Sensors_WITHTARGET);
+00218         TSensorMap::iterator itSensors;
+00219         for (itSensors = _Sensors.begin(); itSensors != itSensorBorder; itSensors++)
+00220         {
+00221                 (*itSensors).second = '#';
+00222         }
+00223 }
+
+

+ + + + +
+ + + + + + + + + +
void NLAINIMAT::CClassifierSystem::RAZTargetSensors (   )  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 204 of file classifier.cpp. +

+References _Sensors, and NLAINIMAT::Sensors_WITHTARGET. +

+Referenced by selectBehavior(). +

+

00205 {
+00206         TSensorMap::iterator itSensorBorder = _Sensors.upper_bound(Sensors_WITHTARGET);
+00207         TSensorMap::iterator itSensors;
+00208         for (itSensors = itSensorBorder; itSensors != _Sensors.end(); itSensors++)
+00209         {
+00210                 (*itSensors).second = '#';
+00211         }
+00212 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAINIMAT::CClassifierSystem::selectBehavior ( const CCSPerception *  psensorMap,
std::multimap< CClassifierPriority, std::pair< TClassifierNumber, TTargetId > > &  mapActivableCS
) 
+
+ + + + + +
+   + + +

+Select a behavior according to the values in the sensorMap.

Parameters:
+ + + +
sensorMap is a map whose key is the sensor name and value the sensor value.
mapActivableCS is the return value for the map containing all the activable CS. TClassifierPriority is the priority, TClassifierNumber the classifier number and TTargetId la cible de l'action
+
+ +

+Definition at line 357 of file classifier.cpp. +

+References _Classifiers, RAZNoTargetSensors(), RAZTargetSensors(), NLAINIMAT::CCSPerception::TargetSensors, TitClassifiers, NLAINIMAT::TTargetId, updateNoTargetSensors(), and updateTargetSensors(). +

+

00359 {
+00360         // We update the internal sensor values for the no target sensors
+00361         updateNoTargetSensors(psensorMap);
+00362 
+00363         TitClassifiers itClassifiers;
+00364         
+00365         for (itClassifiers = _Classifiers.begin();
+00366         itClassifiers != _Classifiers.end();
+00367         itClassifiers++)
+00368         {
+00369                 // S'il y a des conditions dépendantes d'une cible, ce n'est pas activable.
+00370                 if ((*itClassifiers).second->ConditionWithTarget.begin() == (*itClassifiers).second->ConditionWithTarget.end())
+00371                 {
+00372                         if ( (*itClassifiers).second->isActivable())
+00373                         {
+00374                                 mapActivableCS.insert(std::make_pair((*itClassifiers).second->Priority, std::make_pair((*itClassifiers).first, NullTargetId)));
+00375                         }
+00376                 }
+00377         }
+00378         
+00379         // We now do the same, but with target sensors.
+00380         std::map<TTargetId, TSensorMap>::const_iterator itTargetSensorMap;
+00381         for (itTargetSensorMap = psensorMap->TargetSensors.begin(); itTargetSensorMap != psensorMap->TargetSensors.end(); itTargetSensorMap++)
+00382         {
+00383                 TTargetId myTarget = (*itTargetSensorMap).first;
+00384                 // We update the internal sensor values for the target sensors
+00385                 updateTargetSensors(psensorMap, myTarget);
+00386                 
+00387                 // We select the activables classifiers
+00388                 for (itClassifiers = _Classifiers.begin();
+00389                 itClassifiers != _Classifiers.end();
+00390                 itClassifiers++)
+00391                 {
+00392                         // S'il n'y a pas de conditions dépendantes d'une cible, ça a déjà été traité au dessus.
+00393                         if ((*itClassifiers).second->ConditionWithTarget.begin() != (*itClassifiers).second->ConditionWithTarget.end())
+00394                         {
+00395                                 if ( (*itClassifiers).second->isActivable())
+00396                                 {
+00397                                         mapActivableCS.insert(std::make_pair((*itClassifiers).second->Priority, std::make_pair((*itClassifiers).first, myTarget)));
+00398                                 }
+00399                         }
+00400                 }
+00401                 RAZTargetSensors();
+00402         }
+00403         
+00404         // We set the sensors back to the default value.
+00405         RAZNoTargetSensors();
+00406 
+00407 //              // We set the return values.
+00408 //              lastClassifierNumber = selectionNumber;
+00409 //              lastTarget = myTarget;
+00410 //              lastSelectionMaxPriority = higherPriority;
+00411 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAINIMAT::CClassifierSystem::setPriorityPart ( TClassifierNumber  classifierNumber,
CClassifierPriority  priority
) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 427 of file classifier.cpp. +

+References _Classifiers, nlassert, and NLAINIMAT::TClassifierNumber. +

+

00428 {
+00429         std::map<TClassifierNumber, CClassifier*>::iterator itClassifiers = _Classifiers.find(classifierNumber);
+00430         nlassert(itClassifiers != _Classifiers.end());
+00431         (*itClassifiers).second->Priority = priority;
+00432 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAINIMAT::CClassifierSystem::updateNoTargetSensors ( const CCSPerception *  psensorMap  )  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 164 of file classifier.cpp. +

+References _Sensors, NLAINIMAT::CCSPerception::NoTargetSensors, NLAINIMAT::TSensor, and NLAINIMAT::TSensorValue. +

+Referenced by selectBehavior(). +

+

00165 {
+00166         // We use an internal sensor map, because each condition cell is mapped to this intrenal map.
+00167         TSensorMap::iterator itSensors;
+00168         TSensorMap::const_iterator itNoTargetSensors;
+00169 
+00170         for (itSensors = _Sensors.begin(); itSensors != _Sensors.end(); itSensors++)
+00171         {
+00172                 TSensor sensName = (*itSensors).first;
+00173                 itNoTargetSensors = psensorMap->NoTargetSensors.find(sensName);
+00174                 if (itNoTargetSensors !=psensorMap->NoTargetSensors.end())
+00175                 {
+00176                         TSensorValue c = (*itNoTargetSensors).second;
+00177                         (*itSensors).second = c;
+00178                 }
+00179         }
+00180 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAINIMAT::CClassifierSystem::updateTargetSensors ( const CCSPerception *  psensorMap,
TTargetId  target
)  [private]
+
+ + + + + +
+   + + +

+ +

+Definition at line 183 of file classifier.cpp. +

+References _Sensors, nlassert, NLAINIMAT::CCSPerception::TargetSensors, NLAINIMAT::TSensor, NLAINIMAT::TSensorValue, and NLAINIMAT::TTargetId. +

+Referenced by selectBehavior(). +

+

00184 {
+00185         // We update the internal sensor values for the target sensors
+00186         TSensorMap::iterator itSensors;
+00187         TSensorMap::const_iterator itTargetSensors;
+00188         std::map<TTargetId, TSensorMap>::const_iterator itTargetSensorMap = psensorMap->TargetSensors.find(target);
+00189         nlassert( itTargetSensorMap != psensorMap->TargetSensors.end() );
+00190 
+00191         for (itSensors = _Sensors.begin(); itSensors != _Sensors.end(); itSensors++)
+00192         {
+00193                 TSensor sensName = (*itSensors).first;
+00194                 itTargetSensors = (*itTargetSensorMap).second.find(sensName);
+00195                 if (itTargetSensors != (*itTargetSensorMap).second.end())
+00196                 {
+00197                         TSensorValue c = (*itTargetSensors).second;
+00198                         (*itSensors).second = c;
+00199                 }
+00200         }
+00201 }
+
+

Field Documentation

+

+ + + + +
+ + +
TClassifierNumber NLAINIMAT::CClassifierSystem::_ClassifierNumber [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 222 of file classifier.h. +

+Referenced by addClassifier(), CClassifierSystem(), and getClassifierNumber().

+

+ + + + +
+ + +
std::map<TClassifierNumber, CClassifier*> NLAINIMAT::CClassifierSystem::_Classifiers [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 221 of file classifier.h. +

+Referenced by addClassifier(), addClassifierSystem(), getActionPart(), getDebugString(), getPriorityPart(), selectBehavior(), setPriorityPart(), and ~CClassifierSystem().

+

+ + + + +
+ + +
TSensorMap NLAINIMAT::CClassifierSystem::_Sensors [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 220 of file classifier.h. +

+Referenced by addClassifier(), RAZNoTargetSensors(), RAZTargetSensors(), updateNoTargetSensors(), and updateTargetSensors().

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 11:09:43 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1