ArRangeDevice.h

/*
ActivMedia Robotics Interface for Applications (ARIA)
Copyright (C) 2004,2005 ActivMedia Robotics, LLC


     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 
ActivMedia Robotics for information about a commercial version of ARIA at 
robots@activmedia.com or 
ActivMedia Robotics, 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:
  ArRangeDevice(size_t currentBufferSize, size_t cumulativeBufferSize,
                         const char *name, unsigned int maxRange,
                         int maxSecondsToKeepCurrent = 0,
                         int maxSecondsToKeepCumulative = 0,
                         double maxDistToKeepCumulative = 0);
  virtual ~ArRangeDevice();
  virtual const char *getName(void) const;
  virtual void setRobot(ArRobot *robot);
  virtual ArRobot *getRobot(void);
  virtual void setCurrentBufferSize(size_t size);
  virtual void setCumulativeBufferSize(size_t size);
  virtual void addReading(double x, double y);
  virtual double currentReadingPolar(double startAngle, 
                                              double endAngle,
                                              double *angle = NULL) const;
  virtual double cumulativeReadingPolar(double startAngle, 
                                                 double endAngle,
                                                 double *angle = NULL) const;
  virtual double currentReadingBox(double x1, double y1, double x2,
                                            double y2, 
                                            ArPose *readingPos = NULL) const;
  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; }

  virtual std::vector<ArSensorReading> *getRawReadingsAsVector(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; }

  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; }

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

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

  


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

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

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

protected:
  void filterCallback(void);
  std::vector<ArSensorReading> myRawReadingsVector;
  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;
  ArDrawingData *myCurrentDrawingData;
  bool myOwnCurrentDrawingData;
  ArDrawingData *myCumulativeDrawingData;
  bool myOwnCumulativeDrawingData;
  ArMutex myDeviceMutex;
};

#endif // ARRANGEDEVICE_H

---