ArRangeDevice.h

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef ARRANGEDEVICE_H
#define ARRANGEDEVICE_H

#include "ariaTypedefs.h"
#include "ArRangeBuffer.h"
#include "ArSensorReading.h"
#include "ArDrawingData.h"
#include "ArMutex.h"

class ArRobot;

class ArRangeDevice
{
public:
  AREXPORT ArRangeDevice(size_t currentBufferSize, size_t cumulativeBufferSize,
             const char *name, unsigned int maxRange,
             int maxSecondsToKeepCurrent = 0,
             int maxSecondsToKeepCumulative = 0,
             double maxDistToKeepCumulative = 0,
             bool locationDependent = false);
  AREXPORT virtual ~ArRangeDevice();
  AREXPORT virtual const char *getName(void) const;
  AREXPORT virtual void setRobot(ArRobot *robot);
  AREXPORT virtual ArRobot *getRobot(void);
  AREXPORT virtual void setCurrentBufferSize(size_t size);
  AREXPORT virtual void setCumulativeBufferSize(size_t size);
  AREXPORT virtual void addReading(double x, double y);
  AREXPORT virtual double currentReadingPolar(double startAngle, 
                          double endAngle,
                          double *angle = NULL) const;
  AREXPORT virtual double cumulativeReadingPolar(double startAngle, 
                         double endAngle,
                         double *angle = NULL) const;
  AREXPORT virtual double currentReadingBox(double x1, double y1, double x2,
                        double y2, 
                        ArPose *readingPos = NULL) const;
  AREXPORT virtual double cumulativeReadingBox(double x1, double y1, double x2,
                           double y2, 
                           ArPose *readingPos = NULL) const;
#ifndef SWIG

  virtual const ArRangeBuffer *getCurrentRangeBuffer(void) const
    { return &myCurrentBuffer; }
  virtual const ArRangeBuffer *getCumulativeRangeBuffer(void) const
    { return &myCumulativeBuffer; }
  virtual const std::list<ArPoseWithTime *> *getCurrentBuffer(void) const
    { return myCurrentBuffer.getBuffer(); }
  virtual const std::list<ArPoseWithTime *> *getCumulativeBuffer(void) const
    { return myCumulativeBuffer.getBuffer(); }
#endif // SWIG

  virtual ArRangeBuffer *getCurrentRangeBuffer(void)
    { return &myCurrentBuffer; }
  virtual ArRangeBuffer *getCumulativeRangeBuffer(void) 
    { return &myCumulativeBuffer; }
  virtual std::list<ArPoseWithTime *> *getCurrentBuffer(void) 
    { return myCurrentBuffer.getBuffer(); }
  virtual std::vector<ArPoseWithTime> *getCurrentBufferAsVector(void) 
    { return myCurrentBuffer.getBufferAsVector(); }
  virtual std::list<ArPoseWithTime *> *getCumulativeBuffer(void) 
    { return myCumulativeBuffer.getBuffer(); }
  virtual std::vector<ArPoseWithTime> *getCumulativeBufferAsVector(void) 
    { return myCumulativeBuffer.getBufferAsVector(); }


  virtual const std::list<ArSensorReading *> *getRawReadings(void) const
    { return myRawReadings; }

  AREXPORT virtual std::vector<ArSensorReading> *getRawReadingsAsVector(void);


  virtual const std::list<ArSensorReading *> *getAdjustedRawReadings(void) const
    { return myRawReadings; }

  AREXPORT virtual std::vector<ArSensorReading> *getAdjustedRawReadingsAsVector(void);


  void setMaxSecondsToKeepCurrent(int maxSecondsToKeepCurrent)
    { myMaxSecondsToKeepCurrent = maxSecondsToKeepCurrent; }


  int getMaxSecondsToKeepCurrent(void) { return myMaxSecondsToKeepCurrent; }



  void setMaxSecondsToKeepCumulative(int maxSecondsToKeepCumulative)
    { myMaxSecondsToKeepCumulative = maxSecondsToKeepCumulative; }

  int getMaxSecondsToKeepCumulative(void) 
    { return myMaxSecondsToKeepCumulative; }


  void setMaxDistToKeepCumulative(double maxDistToKeepCumulative) 
    { myMaxDistToKeepCumulative = maxDistToKeepCumulative; } 


  double getMaxDistToKeepCumulative(void) { return myMaxDistToKeepCumulative; }

  bool isLocationDependent(void) { return myIsLocationDependent; }
  virtual void clearCurrentReadings(void) { myCurrentBuffer.clear(); }
  virtual void clearCumulativeReadings(void) { myCumulativeBuffer.clear(); }
  virtual void clearCumulativeOlderThan(int milliSeconds) 
    { myCumulativeBuffer.clearOlderThan(milliSeconds); }

  virtual void clearCumulativeOlderThanSeconds(int seconds) 
    { myCumulativeBuffer.clearOlderThanSeconds(seconds); }
  
  virtual unsigned int getMaxRange(void) { return myMaxRange; }
  virtual void setMaxRange(unsigned int maxRange) 
    { myMaxRange = maxRange; }

  AREXPORT virtual void applyTransform(ArTransform trans, 
                       bool doCumulative = true);

  virtual ArDrawingData *getCurrentDrawingData(void) 
    { return myCurrentDrawingData; }
  virtual ArDrawingData *getCumulativeDrawingData(void) 
    { return myCumulativeDrawingData; }
  AREXPORT virtual void setCurrentDrawingData(ArDrawingData *data, 
                          bool takeOwnershipOfData);
  AREXPORT virtual void setCumulativeDrawingData(ArDrawingData *data, 
                         bool takeOwnershipOfData);

  


  AREXPORT virtual int lockDevice() { return(myDeviceMutex.lock());}

  AREXPORT virtual int tryLockDevice() {return(myDeviceMutex.tryLock());}

  AREXPORT virtual int unlockDevice() {return(myDeviceMutex.unlock());}

protected:
  AREXPORT void filterCallback(void);
  AREXPORT void adjustRawReadings(bool interlaced);
  std::vector<ArSensorReading> myRawReadingsVector;
  std::vector<ArSensorReading> myAdjustedRawReadingsVector;
  std::string myName;
  ArRobot *myRobot;
  unsigned int myMaxRange; 
  ArRangeBuffer myCurrentBuffer;
  ArRangeBuffer myCumulativeBuffer;
  int myMaxSecondsToKeepCumulative;
  int myMaxSecondsToKeepCurrent;
  double myMaxDistToKeepCumulative;
  ArFunctorC<ArRangeDevice> myFilterCB;
  std::list<ArSensorReading *> *myRawReadings;
  std::list<ArSensorReading *> *myAdjustedRawReadings;
  ArDrawingData *myCurrentDrawingData;
  bool myOwnCurrentDrawingData;
  ArDrawingData *myCumulativeDrawingData;
  bool myOwnCumulativeDrawingData;
  ArMutex myDeviceMutex;
  bool myIsLocationDependent;
};

#endif // ARRANGEDEVICE_H

---