Changeset 977


Ignore:
Timestamp:
02/18/2011 02:17:21 PM (8 years ago)
Author:
joao.dias
Message:
 
Location:
AgentMind/branches/FAtiMA-Modular/FAtiMA.Empathy
Files:
3 added
2 deleted
5 edited
1 moved

Legend:

Unmodified
Added
Removed
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.Empathy/.classpath

    r973 r977  
    66        <classpathentry combineaccessrules="false" kind="src" path="/FAtiMA.OCCAffectDerivation"/> 
    77        <classpathentry kind="src" path="/FAtiMA.ReactiveComponent"/> 
     8        <classpathentry kind="src" path="/FAtiMA.SocialRelations"/> 
    89        <classpathentry kind="output" path="bin"/> 
    910</classpath> 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.Empathy/src/FAtiMA/empathy/EmpathicAppraisal.java

    r972 r977  
    11package FAtiMA.empathy; 
    22 
    3 import java.util.ArrayList; 
    4 import java.util.Iterator; 
    5  
    6 import FAtiMA.Core.emotionalState.ActiveEmotion; 
     3import FAtiMA.Core.emotionalState.AppraisalFrame; 
    74import FAtiMA.Core.emotionalState.BaseEmotion; 
    85import FAtiMA.Core.emotionalState.EmotionalState; 
    9 import FAtiMA.Core.sensorEffector.Event; 
    106 
    11 public abstract class EmpatheticReaction extends Thread{ 
     7 
     8public class EmpathicAppraisal{ 
    129         
    13         static final int REACTION_DELAY_MS = 600; // a  small delay to wait for the other agent reactions to the event 
     10        private String _empathicTarget; 
     11        private AppraisalFrame _appraisalFrame; 
     12        private BaseEmotion _elicitedEmotion; 
     13        private long _startTime; 
    1414         
    15         Event _event; 
    16         ArrayList _potentialEmotions; 
     15        public EmpathicAppraisal(String empathicTarget, AppraisalFrame aF, BaseEmotion elicitedEmotion, long startTime){ 
     16                this._empathicTarget = empathicTarget; 
     17                this._appraisalFrame = aF; 
     18                this._elicitedEmotion = elicitedEmotion; 
     19                this._startTime = startTime;    }        
    1720         
    18         public EmpatheticReaction(Event e, ArrayList potentialEmphaticEmotions){ 
    19                 if(e == null){ 
    20                         _event = null; 
    21                 }else{ 
    22                         _event = (Event)e.clone();       
    23                 } 
    24                 _potentialEmotions = new ArrayList(potentialEmphaticEmotions); 
    25         }        
    26          
    27         public void run(){ 
    28                  
    29                  
    30                 this.pause(REACTION_DELAY_MS); 
    31                  
    32                 float familiarity = getFamiliarityWithEmpathicTarget(); 
    33                  
    34                 if(existsSimilarityWithEmpathicTarget()){                
    35                         Iterator it = _potentialEmotions.iterator(); 
    36                         while(it.hasNext()){ 
    37                                 BaseEmotion e = (BaseEmotion) it.next(); 
    38                                 e.increasePotential(e.GetPotential() * ((familiarity/10)*2)); 
    39                                 System.out.println(familiarity); 
    40                         }        
    41                         EmotionalState.GetInstance().AddPotentialEmpathicEmotions(_potentialEmotions); 
    42                 }else if(familiarity > 0){ 
    43                         short emotionType = getTargetEmotionTypeFromFacialExpression(); 
    44                         BaseEmotion potentialEmotion = new BaseEmotion(emotionType,familiarity,_event,null); 
    45                         _potentialEmotions.clear(); 
    46                         _potentialEmotions.add(potentialEmotion); 
    47                         EmotionalState.GetInstance().AddPotentialEmpathicEmotions(_potentialEmotions); 
    48                 } 
    49     } 
    50  
    51         private short getTargetEmotionTypeFromFacialExpression(){ 
    52                 String targetFacialExpression = getEmpathicTargetFacialExpression();  
    53                 short facialExpressionType = FacialExpressionType.ParseType(targetFacialExpression); 
    54                 short result = FacialExpressionSimulator.gI().CalculateEmotionType(facialExpressionType); 
    55                  
    56                 return result; 
     21        public AppraisalFrame getAppraisalFrame(){ 
     22                return _appraisalFrame; 
    5723        } 
    58  
    59         private boolean existsSimilarityWithEmpathicTarget(){ 
    60                 String targetFacialExpression = getEmpathicTargetFacialExpression();  
    61                 String simulatedFacialExpression =  getSimulatedFacialExpression(); 
    62                  
    63                 if(targetFacialExpression == null || simulatedFacialExpression == null){ 
    64                         return false; 
    65                 }else{ 
    66                         return targetFacialExpression.equals(simulatedFacialExpression);         
    67                 }        
     24        public String getEmpathicTarget(){ 
     25                return _empathicTarget; 
    6826        } 
    69  
    70         abstract protected String getEmpathicTargetFacialExpression(); 
    71          
    72         abstract protected float getFamiliarityWithEmpathicTarget(); 
    73                  
    74         private String getSimulatedFacialExpression() { 
    75                 ActiveEmotion strongestSimulatedEmotion = EmotionalState.GetInstance().SimulateStrongestExpressiveEmotion(_potentialEmotions); 
    76                 return FacialExpressionSimulator.gI().CalculateFacialExpression(strongestSimulatedEmotion); 
     27        public BaseEmotion getElicitedEmotion(){ 
     28                return _elicitedEmotion; 
    7729        } 
    78  
    79         private void pause(int miliseconds){     
    80                  try { 
    81                         Thread.sleep(REACTION_DELAY_MS); 
    82                 } catch (InterruptedException e) { 
    83                         e.printStackTrace(); 
    84                 } 
     30        public long getStartTime(){ 
     31                return _startTime; 
    8532        } 
    8633} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.Empathy/src/FAtiMA/empathy/EmpathyComponent.java

    r973 r977  
    22 
    33import java.io.File; 
     4import java.util.ArrayList; 
     5import java.util.HashMap; 
    46 
    57import javax.xml.parsers.SAXParser; 
     
    911import FAtiMA.Core.ValuedAction; 
    1012import FAtiMA.Core.Display.AgentDisplayPanel; 
     13import FAtiMA.Core.componentTypes.IAffectDerivationComponent; 
    1114import FAtiMA.Core.componentTypes.IAppraisalDerivationComponent; 
    1215import FAtiMA.Core.componentTypes.IBehaviourComponent; 
    1316import FAtiMA.Core.emotionalState.AppraisalFrame; 
     17import FAtiMA.Core.emotionalState.BaseEmotion; 
     18import FAtiMA.Core.emotionalState.EmotionalState; 
     19import FAtiMA.Core.memory.Memory; 
    1420import FAtiMA.Core.sensorEffector.Event; 
    1521import FAtiMA.Core.util.AgentLogger; 
    1622import FAtiMA.Core.util.ConfigurationManager; 
     23import FAtiMA.Core.util.Constants; 
     24import FAtiMA.Core.wellFormedNames.Name; 
    1725import FAtiMA.ReactiveComponent.ActionTendencies; 
    1826import FAtiMA.ReactiveComponent.ReactiveComponent; 
    19  
    20 public class EmpathyComponent  implements IAppraisalDerivationComponent, IBehaviourComponent{ 
     27import FAtiMA.ReactiveComponent.display.ActionTendenciesPanel; 
     28import FAtiMA.socialRelations.LikeRelation; 
     29import FAtiMA.socialRelations.SocialRelationsComponent; 
     30 
     31public class EmpathyComponent  implements IAppraisalDerivationComponent, IAffectDerivationComponent, IBehaviourComponent{ 
    2132 
    2233        final String NAME = "EmpathyComponent"; 
     
    2435        private static final long serialVersionUID = 1L; 
    2536        public static final long IGNOREDURATION = 30000; 
    26          
    27         ActionTendencies _empatheticActions; 
    28          
    29         @Override 
    30         public String name() { 
     37        public static final long REACTION_DELAY_MS = 600; 
     38         
     39        private enum AppraisalVariables{ 
     40                SIMILARITY, 
     41                AFFECTIVE_LINK 
     42        } 
     43 
     44        private long _currentTime; 
     45        private EmpathicActions _empathicActions; 
     46        private ArrayList<EmpathicAppraisal> _empathicAppraisals; 
     47        private HashMap<String,BaseEmotion> _elicitedEmotions; 
     48 
     49         
     50        @Override 
     51        public String name(){ 
    3152                return NAME; 
    3253        } 
     
    3455        @Override 
    3556        public void initialize(AgentModel am) { 
    36                 _empatheticActions = new ActionTendencies(); 
     57                _empathicActions = new EmpathicActions(); 
     58                _empathicAppraisals = new ArrayList<EmpathicAppraisal>(); 
     59                _elicitedEmotions = new HashMap<String,BaseEmotion>(); 
     60                 
    3761                AgentLogger.GetInstance().log("Adding Reactive Empathic Actions in the EmpathyComponent:"); 
    3862                EmpathyLoaderHandler empathyLoader = new EmpathyLoaderHandler(this); 
     
    4165                        SAXParserFactory factory = SAXParserFactory.newInstance(); 
    4266                        SAXParser parser = factory.newSAXParser(); 
    43                          
    4467                        parser.parse(new File(ConfigurationManager.getPersonalityFile()), empathyLoader); 
    45  
    46  
    4768                } catch (Exception e) { 
    4869                        throw new RuntimeException( 
     
    5273        } 
    5374         
    54          
    55         @Override 
    56         public void appraisal(AgentModel am, Event e, AppraisalFrame af) { 
    57                 // TODO Auto-generated method stub       
    58         } 
    59          
    60         @Override 
    61         public AppraisalFrame reappraisal(AgentModel am) { 
    62                 // TODO Auto-generated method stub 
    63                 return null; 
    64         } 
    65  
    66  
    67         public ActionTendencies getEmpatheticActions() { 
    68                 return _empatheticActions; 
    69         } 
    70  
    71         @Override 
    72         public ValuedAction actionSelection(AgentModel am) { 
    73                 return _empatheticActions.SelectAction(am); 
    74         } 
    75          
    76          
    77         @Override 
    78         public void reset() {    
    79                 _empatheticActions = new ActionTendencies(); 
    80         } 
    81  
     75 
     76         
     77         
    8278        @Override 
    8379        public void update(AgentModel am, long time) { 
    8480                FacialExpressionSimulator.gI().updateFacialExpression(am); 
    85         } 
    86  
     81                this._currentTime = time; 
     82        } 
     83         
    8784        @Override 
    8885        public void update(AgentModel am, Event e) { 
    89                 // TODO Auto-generated method stub 
    90                  
    91         } 
     86        } 
     87 
     88         
     89         
     90        @Override 
     91        public void appraisal(AgentModel am, Event e, AppraisalFrame af) { 
     92                ArrayList<String> empathicTargets = determineEmpathicTargets(e); 
     93                BaseEmotion elicitedEmotion; 
     94                float affectiveLink;  
     95                 
     96                for(String empathicTarget : empathicTargets){ 
     97                 
     98                        elicitedEmotion = this.selfProjectionAppraisal(empathicTarget,e,am);     
     99                         
     100                        this._elicitedEmotions.put(e + empathicTarget, elicitedEmotion); 
     101                         
     102                        affectiveLink = determineAffectiveLink(empathicTarget, am.getMemory()); 
     103                         
     104                        af.SetAppraisalVariable(NAME, AppraisalVariables.AFFECTIVE_LINK + empathicTarget, affectiveLink); 
     105                         
     106                         
     107                        _empathicAppraisals.add(new EmpathicAppraisal(empathicTarget,af,elicitedEmotion,_currentTime)); 
     108                }        
     109        } 
     110         
     111        @Override 
     112        public AppraisalFrame reappraisal(AgentModel am) { 
     113                FacialExpressionType targetFacialExpression; 
     114                float similarity; 
     115                EmpathicAppraisal eAppraisal; 
     116                 
     117                if(_empathicAppraisals.size()>0){ 
     118                        eAppraisal = _empathicAppraisals.get(0); 
     119                        if((_currentTime - eAppraisal.getStartTime()) > REACTION_DELAY_MS){ 
     120                                _empathicAppraisals.remove(0); 
     121                         
     122                                targetFacialExpression = FacialExpressionSimulator.gI().determineTargetFacialExpression(eAppraisal.getEmpathicTarget(), am); 
     123                                similarity = determineSimilarity(eAppraisal.getElicitedEmotion(),targetFacialExpression); 
     124                                eAppraisal.getAppraisalFrame().SetAppraisalVariable(NAME, AppraisalVariables.SIMILARITY + eAppraisal.getEmpathicTarget(), similarity); 
     125                         
     126                                return eAppraisal.getAppraisalFrame(); 
     127                        } 
     128                } 
     129                return null; 
     130        } 
     131         
     132        private float determineSimilarity(BaseEmotion elicitedEmotion, 
     133                        FacialExpressionType targetFacialExpression) { 
     134 
     135                FacialExpressionType projectedFacialExpression = FacialExpressionSimulator.gI().CalculateFacialExpression(elicitedEmotion); 
     136                 
     137                if(projectedFacialExpression == targetFacialExpression){ 
     138                        return 1; 
     139                }else{ 
     140                        return 0; 
     141                } 
     142        } 
     143 
     144        @Override 
     145        public ArrayList<BaseEmotion> affectDerivation(AgentModel am, 
     146                        AppraisalFrame af) { 
     147                 
     148                EmpathicEmotion empathicEmotion; 
     149                FacialExpressionType targetFacialExpression; 
     150                ArrayList<BaseEmotion> potentialEmpathicEmotions = new ArrayList<BaseEmotion>(); 
     151                ArrayList<String> empathicTargets = determineEmpathicTargets(af.getEvent()); 
     152                 
     153                for(String empathicTarget : empathicTargets){ 
     154                        if(af.containsAppraisalVariable(AppraisalVariables.AFFECTIVE_LINK + empathicTarget)){ 
     155                                if(af.containsAppraisalVariable(AppraisalVariables.SIMILARITY + empathicTarget)){ 
     156                                         
     157                                        float similarity = af.getAppraisalVariable(AppraisalVariables.SIMILARITY + empathicTarget); 
     158                                        float affectiveLink = af.getAppraisalVariable(AppraisalVariables.AFFECTIVE_LINK + empathicTarget); 
     159                                         
     160                                        if(similarity > 0){ 
     161                                                BaseEmotion elicitedEmotion = _elicitedEmotions.get(af.getEvent() + empathicTarget); 
     162                                                if(elicitedEmotion != null){ 
     163                                                        empathicEmotion = new EmpathicEmotion(elicitedEmotion); 
     164                                                        empathicEmotion.increasePotential(empathicEmotion.GetPotential() * ((affectiveLink/10)*2)); 
     165                                                        potentialEmpathicEmotions.add(empathicEmotion);  
     166                                                } 
     167                                        }else if(affectiveLink > 0){ 
     168                                                targetFacialExpression = FacialExpressionSimulator.gI().determineTargetFacialExpression(empathicTarget, am);                             
     169                                                BaseEmotion recognizedEmotion = FacialExpressionSimulator.gI().recognizeEmotion(targetFacialExpression,af.getEvent()); 
     170                                                if(recognizedEmotion != null){ 
     171                                                        empathicEmotion = new EmpathicEmotion(recognizedEmotion); 
     172                                                        empathicEmotion.setPotential(empathicEmotion.GetPotential() * (affectiveLink/10)); 
     173                                                        potentialEmpathicEmotions.add(empathicEmotion);  
     174                                                } 
     175                                        } 
     176                                } 
     177                        } 
     178                } 
     179                 
     180                return potentialEmpathicEmotions; 
     181        } 
     182         
     183         
     184        //TODO: Check if the empathicTargets are agents or not 
     185        private ArrayList<String> determineEmpathicTargets(Event e){ 
     186                ArrayList<String> empathicTargets = new ArrayList<String>(); 
     187                 
     188                if(!e.GetSubject().equalsIgnoreCase(Constants.SELF)){ 
     189                        empathicTargets.add(e.GetSubject()); 
     190                } 
     191                 
     192                if(e.GetTarget() != null && !e.GetTarget().equalsIgnoreCase(Constants.SELF)){ 
     193                        empathicTargets.add(e.GetTarget()); 
     194                } 
     195                return empathicTargets; 
     196        } 
     197         
     198         
     199        private float determineAffectiveLink(String empathicTarget, Memory agentMemory){ 
     200                LikeRelation affectiveLink = new LikeRelation (Constants.SELF, empathicTarget); 
     201                return affectiveLink.getValue(agentMemory); 
     202        } 
     203         
     204        private BaseEmotion selfProjectionAppraisal(String empathicTarget, Event e, AgentModel am){ 
     205                Event selfProjectedEvent = e.ApplyPerspective(empathicTarget); 
     206                EmotionalState eS = am.simulateEmotionalState(selfProjectedEvent, this); 
     207                if(eS!=null){ 
     208                        return eS.GetStrongestEmotion(); 
     209                }else{ 
     210                        return null; 
     211                } 
     212        }        
     213 
     214 
     215        public ActionTendencies getEmpathicActions() { 
     216                return _empathicActions; 
     217        } 
     218 
     219        @Override 
     220        public ValuedAction actionSelection(AgentModel am) { 
     221                return _empathicActions.SelectAction(am); 
     222        } 
     223         
     224         
     225        @Override 
     226        public void reset() {    
     227                _empathicActions = new EmpathicActions(); 
     228        } 
     229 
     230 
     231 
    92232         
    93233        @Override 
    94234        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    95                 // TODO Auto-generated method stub 
    96                 return null; 
     235                return new EmpathicEmotionsPanel();              
    97236        } 
    98237 
     
    115254                 * or else we will have a character reacting in the same way several times 
    116255                 */ 
    117                 _empatheticActions.IgnoreActionForDuration(va,IGNOREDURATION); 
     256                _empathicActions.IgnoreActionForDuration(va,IGNOREDURATION); 
    118257                 
    119258        } 
     
    121260        @Override 
    122261        public String[] getComponentDependencies() { 
    123                 return new String[]{ReactiveComponent.NAME}; 
     262                return new String[]{ReactiveComponent.NAME,SocialRelationsComponent.NAME}; 
     263        } 
     264 
     265         
     266 
     267        @Override 
     268        public void inverseAffectDerivation(AgentModel am, BaseEmotion em, 
     269                        AppraisalFrame af) { 
     270                // TODO Auto-generated method stub 
     271                 
    124272        } 
    125273 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.Empathy/src/FAtiMA/empathy/EmpathyLoaderHandler.java

    r973 r977  
    2828        } 
    2929 
    30         public void EmpatheticAction(Attributes attributes){ 
     30        public void EmpathicAction(Attributes attributes){ 
    3131                _action = new Action(Name.ParseName(attributes.getValue("action")));     
    3232        } 
     
    3535        public void ElicitingEmotion(Attributes attributes) throws InvalidEmotionTypeException { 
    3636                parseElicitingEmotion(attributes.getValue("type"),new Integer(attributes.getValue("minIntensity"))); 
    37         _empathyComponent.getEmpatheticActions().AddAction(_action); 
     37        _empathyComponent.getEmpathicActions().AddAction(_action); 
    3838        } 
    3939         
     
    4343        } 
    4444         
     45        @Override 
     46        public void Event(Attributes attributes){ 
     47                 
     48        } 
     49         
    4550} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.Empathy/src/FAtiMA/empathy/FacialExpressionSimulator.java

    r973 r977  
    33import FAtiMA.Core.AgentModel; 
    44import FAtiMA.Core.emotionalState.ActiveEmotion; 
     5import FAtiMA.Core.emotionalState.BaseEmotion; 
     6import FAtiMA.Core.sensorEffector.Event; 
     7import FAtiMA.Core.util.Constants; 
    58import FAtiMA.Core.wellFormedNames.Name; 
     9import FAtiMA.OCCAffectDerivation.OCCBaseEmotion; 
    610import FAtiMA.OCCAffectDerivation.OCCEmotionType; 
    711 
    812public class FacialExpressionSimulator { 
    913         
    10         final private Name FACIAL_EXP_PROPERTY = Name.ParseName("SELF(facial-exp)"); 
     14        final private String FACIAL_EXP_PROPERTY = "(facial-exp)"; 
     15        final private float DEFAULT_EMOTION_POTENTIAL = 5; 
    1116         
    1217         
     
    2126                { 
    2227                        _facialSim = new FacialExpressionSimulator(); 
     28                 
     29                 
     30                         
    2331                } 
    2432                 
     
    2735         
    2836         
    29         public String updateFacialExpression(AgentModel am){ 
     37        public FacialExpressionType updateFacialExpression(AgentModel am){ 
    3038                     
    3139                //search for the previous facial expression in the KB 
    32                 String facialExpressionValue = (String) am.getMemory().getSemanticMemory().AskProperty(FACIAL_EXP_PROPERTY); 
     40                FacialExpressionType previousFacialExpression = (FacialExpressionType) am.getMemory().getSemanticMemory().AskProperty(Name.ParseName(Constants.SELF + FACIAL_EXP_PROPERTY)); 
    3341                 
    34                 FacialExpressionType previousFacialExpression = FacialExpressionType.valueOf(facialExpressionValue); 
     42                if(previousFacialExpression == null){ 
     43                        //Set the initial FacialExpression 
     44                        am.getMemory().getSemanticMemory().Tell(Name.ParseName(Constants.SELF + FACIAL_EXP_PROPERTY), FacialExpressionType.NEUTRAL); 
     45                        previousFacialExpression = FacialExpressionType.NEUTRAL; 
     46                } 
    3547                 
    3648        //checks the current strongest active emotion that is based on the reactive appraisal 
     
    6072                } 
    6173                 
    62                 String newFacialExpressionName = newFacialExpression.name(); 
    63                  
    64                 if(!newFacialExpressionName.equalsIgnoreCase(previousFacialExpression.name())){  
    65                         am.getMemory().getSemanticMemory().Tell(FACIAL_EXP_PROPERTY, newFacialExpressionName);                   
    66                         return newFacialExpressionName; 
     74                if(newFacialExpression != previousFacialExpression){     
     75                        am.getMemory().getSemanticMemory().Tell(Name.ParseName(Constants.SELF + FACIAL_EXP_PROPERTY), newFacialExpression);                      
     76                        return newFacialExpression; 
    6777                }else{ 
    6878                        return null; 
     
    7080        } 
    7181         
    72         public FacialExpressionType CalculateFacialExpression(ActiveEmotion e){      
     82        public FacialExpressionType CalculateFacialExpression(BaseEmotion e){        
    7383    
    7484                if(e == null){ 
     
    8898        } 
    8999 
    90         public OCCEmotionType CalculateEmotionType(FacialExpressionType facialExpressionType) { 
     100        public OCCBaseEmotion recognizeEmotion(FacialExpressionType facialExpressionType, Event e) { 
    91101                switch(facialExpressionType){ 
    92                         case ANGRY: return OCCEmotionType.ANGER; 
    93                         case HAPPY: return OCCEmotionType.JOY; 
    94                         case SAD: return OCCEmotionType.DISTRESS; 
     102                        case ANGRY: return new OCCBaseEmotion(OCCEmotionType.ANGER, DEFAULT_EMOTION_POTENTIAL, e); 
     103                        case HAPPY: return new OCCBaseEmotion(OCCEmotionType.JOY, DEFAULT_EMOTION_POTENTIAL, e); 
     104                        case SAD: return new OCCBaseEmotion(OCCEmotionType.DISTRESS,DEFAULT_EMOTION_POTENTIAL, e); 
    95105                        case NEUTRAL : return null; 
    96106                        default : return null; 
    97107                } 
    98108        } 
     109         
     110        public FacialExpressionType determineTargetFacialExpression(String target, AgentModel am){ 
     111                //search for the previous facial expression in the KB 
     112                FacialExpressionType targetFacialExpression = (FacialExpressionType)am.getMemory().getSemanticMemory().AskProperty(Name.ParseName(target + FACIAL_EXP_PROPERTY)); 
     113                 
     114                if(targetFacialExpression == null){ 
     115                        return FacialExpressionType.NEUTRAL; 
     116                }else{ 
     117                        return targetFacialExpression; 
     118                } 
     119                 
     120        } 
    99121} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.Empathy/src/FAtiMA/empathy/FacialExpressionType.java

    r973 r977  
    1 /**  
    2  * EmotionType.java - Class that implements the Enumerable for OCC's 22 emotion types 
    3  *   
    4  * Copyright (C) 2006 GAIPS/INESC-ID  
    5  *   
    6  * This program is free software; you can redistribute it and/or modify 
    7  * it under the terms of the GNU General Public License as published by 
    8  * the Free Software Foundation; either version 2 of the License, or 
    9  * (at your option) any later version. 
    10  * 
    11  * This program is distributed in the hope that it will be useful, 
    12  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    14  * GNU General Public License for more details. 
    15  * 
    16  * You should have received a copy of the GNU General Public License 
    17  * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA 
    19  *  
    20  * Company: GAIPS/INESC-ID 
    21  * Project: FAtiMA 
    22  * Created: 21/12/2004  
    23  * @author: João Dias 
    24  * Email to: joao.assis@tagus.ist.utl.pt 
    25  *  
    26  * History:  
    27  * João Dias: 21/12/2004 - File created 
    28  */ 
    29  
    301package FAtiMA.empathy; 
    312 
Note: See TracChangeset for help on using the changeset viewer.