---

Objects.cpp

Go to the documentation of this file.

/*
Copyright (c) 2000-2003, Jelle Kok, University of Amsterdam
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.

3. Neither the name of the University of Amsterdam nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include"Objects.h"

#include<stdlib.h>       // needed for free
#include<iostream>       // needed for cout
#ifdef Solaris
  #include <strings.h>   // needed for strdup
#else
  #include <string.h>    // needed for strdup
#endif

/*****************************************************************************/
/********************* CLASS OBJECT ******************************************/
/*****************************************************************************/

Object::Object( )
{
  objectType                   = OBJECT_ILLEGAL;
}

AngDeg Object::getRelativeAngle( )
{
  return VecPosition::normalizeAngle(posRelative.getDirection());
}

double Object::getRelativeDistance( )
{
  return posRelative.getMagnitude();
}

double Object::getConfidence( Time time )
{
  if( timeLastSeen.getTime() == -1 )       
    return 0.0;
  double dConf = 
      max( 0.0, 1.0-(double)(time.getTimeDifference(timeLastSeen))/100.0);
  if( dConf > 1.0 )
    return 0.0;
  return dConf;
}


bool Object::setType( ObjectT o )
{
  objectType = o;
  return true;
}

ObjectT  Object::getType() const
{
  return objectType;
}

bool Object::setRelativePosition( double dDist, AngDeg ang, Time time )
{
  posRelative.setVecPosition( dDist, ang, POLAR );
  setTimeRelativePosition( time );
  return true;
}

bool Object::setRelativePosition( VecPosition v, Time time )
{
  posRelative = v;
  setTimeRelativePosition( time );
  return true;
}

VecPosition Object::getRelativePosition() const
{
  return posRelative;
}

bool Object::setTimeRelativePosition( Time time )
{
  timeRelativePosition = time;
  return true;
}

Time Object::getTimeRelativePosition() const
{
  return timeRelativePosition;
}

bool Object::setGlobalPosition( VecPosition p, Time time )
{
  posGlobal = p;
  setTimeGlobalPosition( time );
  return true;
}

VecPosition Object::getGlobalPosition() const
{
  return posGlobal;
}

bool Object::setTimeGlobalPosition( Time time )
{
  timeGlobalPosition = time;
  return true;
}

Time Object::getTimeGlobalPosition() const
{
  return timeGlobalPosition;
}

bool Object::setGlobalPositionLastSee( VecPosition p, Time time )
{
  posGlobalLastSee = p;
  setTimeGlobalPosDerivedFromSee( time );
  return true;
}

VecPosition Object::getGlobalPositionLastSee() const
{
  return posGlobalLastSee;
}

bool Object::setTimeGlobalPosDerivedFromSee( Time time )
{
  timeGlobalPosDerivedFromSee = time;
  return true;
}

Time Object::getTimeGlobalPosDerivedFromSee() const
{
  return timeGlobalPosDerivedFromSee;
}

bool Object::setTimeLastSeen( Time time)
{
  timeLastSeen = time;
  return true;
}

Time Object::getTimeLastSeen() const
{
  return timeLastSeen;
}


/*****************************************************************************/
/********************** CLASS FIXEDOBJECT ************************************/
/*****************************************************************************/

void FixedObject::show( ostream & os )
{
  char buf[MAX_TEAM_NAME_LENGTH];

  // DEFAULT_TEAM_NAME is used since it is not a player, name does not matter
  SoccerTypes::getObjectStr( buf, objectType, DEFAULT_TEAM_NAME );
  os <<  buf
     << " rel("  << posRelative << " r:" << posRelative.getMagnitude()
     << " phi:"  << posRelative.getDirection()
     << " t:"    << timeRelativePosition << ")"
     << " seen:" << timeLastSeen << "\n";
}

VecPosition FixedObject::getGlobalPosition( SideT s, double dGoalWidth )const
{
  return SoccerTypes::getGlobalPositionFlag( getType(), s, dGoalWidth );
}

AngDeg FixedObject::getGlobalAngle( SideT s )
{
  return SoccerTypes::getGlobalAngleLine( getType(), s );
}

/*****************************************************************************/
/********************* CLASS DYNAMICOBJECT ***********************************/
/*****************************************************************************/

DynamicObject::DynamicObject( ):Object( )
{
  dRelativeDistanceChange   = UnknownDoubleValue;
  dRelativeAngleChange      = UnknownDoubleValue;
}

bool DynamicObject::setGlobalVelocity( VecPosition v, Time time)
{
  if( v.getMagnitude() < EPSILON )
    vecGlobalVelocity.setVecPosition( 0.0, 0.0 );
  else
     vecGlobalVelocity = v;
  setTimeGlobalVelocity( time );
  return true;
}

VecPosition DynamicObject::getGlobalVelocity( ) const
{
  return vecGlobalVelocity;
}

double DynamicObject::getSpeed( ) const
{
  return vecGlobalVelocity.getMagnitude();
}

bool DynamicObject::setTimeGlobalVelocity( Time time )
{
  timeGlobalVelocity = time;
  return true;
}

Time DynamicObject::getTimeGlobalVelocity() const
{
  return timeGlobalVelocity;
}


bool DynamicObject::setRelativeDistanceChange( double d, Time time )
{
  dRelativeDistanceChange = d;
  setTimeChangeInformation( time );
  return true;
}

double DynamicObject::getRelativeDistanceChange() const
{
  return dRelativeDistanceChange;
}

bool DynamicObject::setRelativeAngleChange( double d, Time time )
{
  dRelativeAngleChange = d;
  setTimeChangeInformation( time );
  return true;
}

double DynamicObject::getRelativeAngleChange() const
{
  return dRelativeAngleChange;
}

bool DynamicObject::setTimeChangeInformation( Time time )
{
  timeChangeInformation = time ;
  return true;
}

Time DynamicObject::getTimeChangeInformation()  const
{
  return timeChangeInformation;
}

bool DynamicObject::setGlobalVelocityLastSee ( VecPosition vec )
{
  vecGlobalVelocityLastSee = vec;
  return true;
}

VecPosition DynamicObject::getGlobalVelocityLastSee ( )   const
{
  return vecGlobalVelocityLastSee;
}


/*****************************************************************************/
/********************* CLASS PLAYEROBJECT ************************************/
/*****************************************************************************/

PlayerObject::PlayerObject( ):DynamicObject( )
{
  angGlobalBodyAngle   = UnknownAngleValue;
  angGlobalNeckAngle   = UnknownAngleValue;
  isKnownPlayer        = false;
  isGoalie             = false;

  angRelativeBodyAngle = UnknownAngleValue;
  angRelativeNeckAngle = UnknownAngleValue;
  
  iHeteroPlayerType    = 0;
}

bool PlayerObject::setRelativeBodyAngle( AngDeg ang, Time time )
{
  angRelativeBodyAngle = ang;
  setTimeRelativeAngles( time );
  return true;
}

AngDeg PlayerObject::getRelativeBodyAngle( )  const
{
  return angRelativeBodyAngle;
}

bool PlayerObject::setGlobalBodyAngle( AngDeg ang, Time time)
{
  angGlobalBodyAngle = ang;
  setTimeGlobalAngles( time );
  return true;
}

AngDeg PlayerObject::getGlobalBodyAngle( )  const
{
  return angGlobalBodyAngle;
}

bool PlayerObject::setRelativeNeckAngle( AngDeg ang, Time time )
{
  angRelativeNeckAngle = ang;
  setTimeRelativeAngles( time );
  return true;
}

AngDeg PlayerObject::getRelativeNeckAngle( )  const
{
  return angRelativeNeckAngle;
}

bool PlayerObject::setGlobalNeckAngle( AngDeg ang, Time time )
{
  angGlobalNeckAngle = ang;
  setTimeGlobalAngles( time );
  return true;
}

AngDeg PlayerObject::getGlobalNeckAngle( )  const
{
  return angGlobalNeckAngle;
}

bool PlayerObject::setTimeRelativeAngles( Time time )
{
  timeRelativeAngles = time;
  return true;
}

Time PlayerObject::getTimeRelativeAngles( ) const
{
  return timeRelativeAngles ;
}

bool PlayerObject::setTimeGlobalAngles( Time time )
{
  timeGlobalAngles = time;
  return true;
}


bool PlayerObject::setGlobalBodyAngleLastSee( AngDeg ang )
{
  angGlobalBodyAngleLastSee = ang;
  return true;
}


AngDeg PlayerObject::getGlobalBodyAngleLastSee( )  const
{
  return angGlobalBodyAngleLastSee;
}
  

Time PlayerObject::getTimeGlobalAngles( ) const
{
  return timeGlobalAngles ;
}

bool PlayerObject::setPossibleRange( ObjectT objMin, ObjectT objMax )
{
  objRangeMin = objMin;
  objRangeMax = objMax;
  return true;
}

bool PlayerObject::isInRange( ObjectT obj, bool bTeammatesFirst )
{
  int  iIndObj = SoccerTypes::getIndex( obj );
  int  iIndMin = SoccerTypes::getIndex( objRangeMin );
  int  iIndMax = SoccerTypes::getIndex( objRangeMax );

  // teammates 0 to 10, opponents 11 to 21 or -10..1 I guess
  if( SoccerTypes::isOpponent( obj ) )
    iIndObj += ( bTeammatesFirst ) ? 11 : -11 ;
  if( SoccerTypes::isOpponent( objRangeMin ) )
    iIndMin += ( bTeammatesFirst ) ? 11 : -11 ;
  if( SoccerTypes::isOpponent( objRangeMax ) )
    iIndMax += ( bTeammatesFirst ) ? 11 : -11 ;
  
  return iIndMin <= iIndObj && iIndObj <= iIndMax ;
}

ObjectT PlayerObject::getMinRange( )
{
  return objRangeMin;
}

ObjectT PlayerObject::getMaxRange( )
{
  return objRangeMax;
}

bool PlayerObject::setIsKnownPlayer( bool b )
{
  isKnownPlayer = b;
  return true;
}

bool PlayerObject::getIsKnownPlayer() const
{
  return isKnownPlayer;
}

bool PlayerObject::setIsGoalie( bool b )
{
  isGoalie = b;
  return true;
}

bool PlayerObject::getIsGoalie() const
{
  return isGoalie;
}


void PlayerObject::show( ostream & os )
{
  show( DEFAULT_TEAM_NAME, os );
}

void PlayerObject::show( const char* strTeamName , ostream & os )
{
  char buf[MAX_TEAM_NAME_LENGTH];
  SoccerTypes::getObjectStr( buf, objectType, strTeamName );
  os << buf 
            << " conf: "              << getConfidence( timeGlobalPosition )
            << " pos: "               << posGlobal
            << ","                    << timeGlobalPosition
            << " vel: "               << vecGlobalVelocity
            << ","                    << timeGlobalVelocity
            << " ang (b:"             << getGlobalBodyAngle()
            << ",n:"                  << angGlobalNeckAngle
            << "),"                   << timeGlobalAngles
            << "known: "              << isKnownPlayer
            << " lastseen:"            << timeLastSeen << "\n";
}

bool PlayerObject::setHeteroPlayerType( int index )
{
  iHeteroPlayerType = index;
  return true;
}  

int  PlayerObject::getHeteroPlayerType( ) const
{
  return iHeteroPlayerType;
}


bool PlayerObject::setTimeTackle( Time time )
{
  m_timeTackle = time;
  return true;
}

Time PlayerObject::getTimeTackle( ) const
{
  return m_timeTackle;
}


bool PlayerObject::setGlobalArm( AngDeg ang, Time time )
{
  m_angGlobalArm = ang;
  return setTimeGlobalArm( time );
}

AngDeg PlayerObject::getGlobalArm( ) const
{
  return m_angGlobalArm;
}

bool PlayerObject::setTimeGlobalArm( Time time )
{
  m_timeGlobalArm = time;
  return true;
}

Time PlayerObject::getTimeGlobalArm( ) const
{
  return m_timeGlobalArm;
}

/*****************************************************************************/
/********************* CLASS BALLOBJECT **************************************/
/*****************************************************************************/

BallObject::BallObject():DynamicObject()
{

}

void BallObject::show( ostream& os)
{
  char buf[MAX_TEAM_NAME_LENGTH];
  SoccerTypes::getObjectStr( buf, objectType, DEFAULT_TEAM_NAME );
  os <<  buf
       << "r: "                 << posRelative.getMagnitude()
       << " phi: "              << posRelative.getDirection()
       << " vel: "              << vecGlobalVelocity
       << " "                   << timeGlobalVelocity
       << " rel: "              << posRelative
       << ", "                  << timeRelativePosition
       << " global: "           << posGlobal
       << ", "                  << timeGlobalPosition
       << ", changes: "         << dRelativeDistanceChange
       << ", "                  << dRelativeAngleChange
       << " last seen:"         << timeLastSeen
       << " globalposderived: " << timeGlobalPosDerivedFromSee
       << "\n";
}

/*****************************************************************************/
/********************* CLASS AGENTOBJECT *************************************/
/*****************************************************************************/

AgentObject::AgentObject( double dStaminaMax ):PlayerObject( )
{
  viewAngle              = VA_NORMAL;
  viewQuality            = VQ_HIGH;

  stamina.setStamina ( dStaminaMax );
  stamina.setEffort  ( 1.0 );
  stamina.setRecovery( 1.0 );
  velSpeedRelToNeck.setVecPosition( 0.0, 0.0 );

  angGlobalNeckAngle   = UnknownAngleValue;
  angBodyAngleRelToNeck  = UnknownAngleValue;
}

void AgentObject::show( ostream& os )
{
  show( DEFAULT_TEAM_NAME, os );
}

void AgentObject::show( const char * strTeamName, ostream & os )
{
  char buf[MAX_TEAM_NAME_LENGTH];
  SoccerTypes::getObjectStr( buf, objectType, strTeamName );
  os   <<  buf
       << " (global("    << posGlobal
       << ", "           << timeGlobalPosition
       << ") (vel("      << vecGlobalVelocity
       << ", "           << timeGlobalVelocity
       << ") (angles(n:" << angGlobalNeckAngle
       << ", b:"         << angBodyAngleRelToNeck << ") ";
  stamina.show( os );
}

ViewAngleT AgentObject::getViewAngle() const
{
  return viewAngle;
}

VecPosition AgentObject::getPositionDifference() const
{
  return posPositionDifference;
}

bool  AgentObject::setPositionDifference( VecPosition p )
{
  posPositionDifference = p;
  return true;
}

bool AgentObject::setViewAngle( ViewAngleT v )
{
  viewAngle = v;
  return true;
}

ViewQualityT AgentObject::getViewQuality() const
{
  return viewQuality;
}

bool AgentObject::setViewQuality( ViewQualityT v )
{
  viewQuality = v;
  return true;
}

Stamina AgentObject::getStamina( ) const
{
  return stamina;
}

bool AgentObject::setStamina( Stamina sta )
{
  stamina = sta;
  return true ;
}

VecPosition AgentObject::getSpeedRelToNeck( ) const
{
  return velSpeedRelToNeck;
}

bool AgentObject::setSpeedRelToNeck( VecPosition v )
{
  velSpeedRelToNeck = v;
  return true;
}

bool AgentObject::setGlobalNeckAngle( AngDeg ang )
{
  angGlobalNeckAngle= ang;
  angGlobalBodyAngle= VecPosition::normalizeAngle(getBodyAngleRelToNeck()+ang);
  return true ;
}

AngDeg AgentObject::getBodyAngleRelToNeck( ) const
{
  return angBodyAngleRelToNeck;
}

bool AgentObject::setBodyAngleRelToNeck( AngDeg ang )
{
  angBodyAngleRelToNeck = ang;
//  angGlobalBodyAngle = VecPosition::normalizeAngle(getGlobalNeckAngle()+ang);
  return true;
}

bool AgentObject::getArmMovable( ) const
{
  return m_bArmMovable;
}

bool AgentObject::setArmMovable( bool b ) 
{
  m_bArmMovable = b;
  return true;
}

int AgentObject::getArmExpires( ) const
{
  return m_iArmExpires;
}

bool AgentObject::setArmExpires( int i )
{
  m_iArmExpires = i;
  return true;
}

VecPosition AgentObject::getGlobalArmPosition( ) const
{
  return m_posGlobalArm;
}

bool AgentObject::setGlobalArmPosition ( VecPosition  v )
{
  m_posGlobalArm = v;
  return true;
}

int AgentObject::getTackleExpires( ) const
{
  return m_iTackleExpires;
}

bool AgentObject::setTackleExpires( int i )
{
  m_iTackleExpires = i;
  return true;
}


/*****************************************************************************/
/********************* CLASS STAMINA *****************************************/
/*****************************************************************************/

Stamina::Stamina( double dSta, double dEff, double dRec )
{
  setStamina ( dSta );
  setEffort  ( dEff );
  setRecovery( dRec );
}

void Stamina::show( ostream & os)
{
  os  << "(sta:"   << m_dStamina
      << ", eff:"  << m_dEffort
      << ", rec: " << m_dRecovery << ")" << "\n";
}

TiredNessT  Stamina::getTiredNess( double dRecDecThr, double dStaminaMax )
{
  double dStaDiffWithThr = getStamina() - dRecDecThr * dStaminaMax;
//  cerr << getStamina() << " " << dStaminaMax << 
//    " " << dRecDecThr << " " << dStaDiffWithThr << endl;
  if( dStaDiffWithThr < 100 )
    return TIREDNESS_TERRIBLE;
  else if( dStaDiffWithThr < 750 )
    return TIREDNESS_VERY_BAD;
  else if( dStaDiffWithThr < 1500 )
    return TIREDNESS_BAD;
  else if( dStaDiffWithThr < 2250 )
    return TIREDNESS_AVERAGE;

  return TIREDNESS_GOOD;
}

double Stamina::getStamina() const
{
  return m_dStamina;
}

bool Stamina::setStamina( double d )
{
  if( d < 0.0 )
  {
    m_dStamina = 0.0;
    return false;
  }
  else
    m_dStamina = d;
  return true;
}

double Stamina::getEffort() const
{
  return m_dEffort;
}

bool Stamina::setEffort( double d )
{
  if( d < 0.0 )
  {
    m_dEffort = 0.0;
    return false;
  }
   else if( d > 1.0 )
  {
    m_dEffort = 1.0;
    return false;
  }
  else
    m_dEffort = d;
  return true;
}

double Stamina::getRecovery() const
{
  return m_dRecovery;
}

bool Stamina::setRecovery( double d )
{
  if( d < 0.0 )
  {
    m_dRecovery = 0.0;
    return false;
  }
   else if( d > 1.0 )
  {
    m_dRecovery = 1.0;
    return false;
  }
  else
    m_dRecovery = d;
  return true;
}

/*****************************************************************************/
/********************* TESTING PURPOSES **************************************/
/*****************************************************************************/

/*
int main( void )
{
  PlayerObject p();
  BallObject b();
  FixedObject s();

  cout << p.getDeltaRelativeAngle() << "\n" <<
      b.getDeltaRelativeDistance() << "\n" <<
  p.getTimeRelativeDistance() << "\n";
  return 0;

}
*/

---