---

DistanceResults.hpp

Go to the documentation of this file.

//
//       Title           : DistanceResults.hpp
//       Project         : D&D Demos
//       Created         : March 15, 2005
//       Author          : Ethan Swint
//       Platforms       :
//       Copyright       : Copyright© The University of Texas at Austin, 2002. All rights reserved.
//                 
//          This software and documentation constitute an unpublished work
//          and contain valuable trade secrets and proprietary information
//          belonging to the University. None of the foregoing material may be
//          copied or duplicated or disclosed without the express, written
//          permission of University. THE UNIVERSITY EXPRESSLY DISCLAIMS ANY
//          AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION,
//          INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//          PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY
//          THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE.
//          NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF
//          THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall the
//          University be liable for incidental, special, indirect, direct or
//          consequential damages or loss of profits, interruption of business,
//          or related expenses which may arise from use of software or documentation,
//          including but not limited to those resulting from defects in software
//          and/or documentation, or loss or inaccuracy of data of any kind.
//       Purpose         : Container  to hold obstacle information.
//
//
//----------------------------------------------------------------------------
//
//       $Revisions$
//
//       $Log: DistanceResults.hpp,v $
//       Revision 1.8  2007/03/30 20:41:27  aspencer
//       Changed obstacle avoidance criteria to use the new node structure as the basis for its modeling.
//
//       Revision 1.7  2006/04/09 20:48:00  mitch
//       moved Dhat from ipp (inline) to cpp file
//
//       Revision 1.6  2005/09/26 16:29:37  aspencer
//       Moved commenting so that the class will show up correctly in doxygen
//
//       Revision 1.5  2005/09/02 17:53:38  josh
//       Added methods to more easily access distance results.
//
//       Revision 1.4  2005/07/15 16:27:01  aspencer
//       Changed the way that DistanceCalculator stores results in DistanceResults. Now DistanceResults can be re-used for the same manipulator/enviornment over and over, without being cleared, and without having a memory explosion.
//
//       Revision 1.3  2005/07/01 19:18:08  aspencer
//       Added doxygen commenting (ingroup, class brief)
//
//       Revision 1.2  2005/06/23 21:28:43  josh
//       Fixed bugs in CalcDist between two nodes. Changed method signatures in DistanceResults.
//
//       Revision 1.1  2005/06/15 21:53:17  aspencer
//       Initial Commit
//
//
//
//

#ifndef DistanceResults_h
#define DistanceResults_h

#ifdef _MSC_VER
        //disable warnI ngs due to truncation of mangled function names of STL template 
        //instantiations
        #pragma warning (disable: 4786)
#endif //_MSC_VER

#include "Primitive.hpp"
#include "ScaleInverseF.hpp"
#include "Math/Vector3.h"
#include <assert.h>
#include <map>
#include <vector>



namespace OSCAR {

class DistanceCalculator;
typedef std::vector<Vector3> Vector3vec;

class DistanceResults {
  friend class DistanceCalculator;
public:
  typedef std::map<const Primitive*, std::pair<Vector3, int> > InnerMap;
  typedef std::map<const Primitive*, InnerMap> OuterMap;
  typedef std::map<const Primitive*, vector<double> > InnerGMap;
  typedef std::map<const Primitive*, InnerGMap> OuterGMap;
  //typedef std::map<const Primitive*, Tensor> hFuncMap;
  typedef std::map<const Primitive*, Matrix*> InnerHMap;
  typedef std::map<const Primitive*, InnerHMap> OuterHMap;
        typedef InnerMap::const_iterator        InnerMapIterator;

        DistanceResults();

  bool LocateDHat(const Primitive* const from, const Primitive* const to, int& index) const;
  
        bool LocatePair(const Primitive* const from, const Primitive* const to, InnerMapIterator& iter) const;
  
  bool Distance(const Primitive* const p0, const Primitive* const p1, double& distance) const;

  bool CalculateForce(const Primitive* const p0, const Primitive* const p1, const ArtificialPotentialF& func);

  bool GetForce(const Primitive* const p0, const Primitive* const p1, double& force) const;
    
  double Distance(InnerMapIterator iter) const;

  bool CalculateForceD1(const Primitive* const p0, const Primitive* const p1, const ArtificialPotentialF& func);

  bool GetForceD1(const Primitive* const p0, const Primitive* const p1, double& forceD1) const;
        

        Vector3 Dhat(InnerMapIterator iter) const;

        const Vector3& WitnessPoint(InnerMapIterator iter) const;

  bool GetWitnessPoint(const Primitive* const locatedOn, const Primitive* const closestTo, Vector3& wit) const;
  
  const Vector3vec& Dhat() const;
  
  bool Contains(const Primitive* const thisObject) const;

  ~DistanceResults();
  
        void Clear();

  bool GetGFunctions(const Primitive* from, const Primitive* to, const vector<double>*& gFunctions) const;

  bool GetHFunctions(const Primitive* from, const Primitive* to, const Matrix* hFunctions);

  

private:
  Vector3vec dHats;
  std::vector<double> distances;
  std::vector<double> forces;
  std::vector<double> forcesD1;
  OuterMap results;
  OuterGMap gFuncs;
  OuterHMap hFuncs;
  bool contains(const Primitive* prim1, const Primitive* prim2, int& index);
  bool setHFunctions(const Primitive* to, const Primitive* from, Matrix* hFunctions);
  Matrix* containsHFunction(const Primitive* from, const Primitive* to);
};//end of class

//Include definition of inline methods
#include "DistanceResults.ipp"

}  //namespace OSCAR
#endif //DistanceResults_h

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations