ippKTool.h

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 

#pragma once 
#include "ippdme/ippdme.h"
#include "ippdme/Property/ippOnePropertyCollisionVolume.h"
#include "ippdme/ippGoToPars.h"
#include "ippdme/ippPtMeasPars.h"
#include "ippdme/ippScanPars.h"
#include <string>


/* KTool class

A Ktool (tool) is the combination of (1) a stylus, (2) a tool holder,
and (3) a set of operational parameters.

Each tool has a collisionVolume which is a ippOnePropertyCollisionVolume
(defined in IppCmdRes.h). See pages 67-70 of the spec. In the tool
model given in this file, the coordinate system in which this volume
is defined has its origin at the center of the tip of the tool and its
positive Z axis along the axis of the stylus. The X axis direction is
a problem. We will assume here that each tool has an X axis marked on
it perpendicular to the axis of the stylus. To use a tool's
collision_volume for real collision detection, the location and
orientation of the tool in the current coordinate system must be known
and the collision_volume must be transformed to put it in the right
place. For constructing a pro-forma response to a
GetProp(Tool.CollisionVolume) command, the untransformed
collisionVolume can be used. The spec seems to intend that there must
be at least one Oriented Bounding Box in the collision volume of a
tool, although it does not explicitly prohibit having no boxes.

A tool has a radius, which is the radius of the ball at the end of the
stylus.

A tool has a length, which is the distance from the point on the tool
that is at the mount point (the point that is controlled when there
is no tool) to the center of the ball at the tip. This is a crude
geometric item that can be used for calculating a response to
GetChangeToolAction.

A tool has zero to three rotary joints that may be adjusted indirectly
(using an AlignTool command). The angles of these three joints are
represented by angleA, angleB, and angleC.  The number of actual
joints of a tool is not represented. If a tool does not have one of
the joints, the angle for that joint is always zero. Here, the angles
stay fixed (physically or logically) even when a tool is not being
used, so the angles are properties of the tool, not of the tool
changer.

It is not clear whether the spec intends that the angles of a tool
stay fixed between tool changes. If the same physical tool is two
logical tools, and they have different angles, motion will be required
when changing from one to the other. An alternative to having angles
persist between tool changes would be for the logical tool to inherit
its angles from the physical angles of the tool holder when it is
changed in, so that no motion would be required.

Currently, there is no geometric model of a tool, so the angles never
change.

A tool has a name and and id; both are strings. The spec says the id
will eventually identify the manufacturer and other information.

*/

//=============================================================================
class IPPDME_EXT_CLASS ippKTool : public ippObject
{
  friend class ippToolChanger;
private:
  double _angleA;
  double _angleB;
  double _angleC;

  ippOnePropertyCollisionVolumePtr _collisionVolume;
  ippGoToParsPtr _goToPar;
  ippPtMeasParsPtr _ptMeasPar;
  ippScanParsPtr _scanPar;

  std::string _id;
  bool _isQualified;
  double _length;

  std::string _name;
  double _radius;

public:
  ippKTool();
  ippKTool(
    const char * inName,
    const char * inId,
    ippGoToParsPtr inGoToPar,
          ippPtMeasParsPtr inPtMeasPar,
        ippScanParsPtr inScanPar,
    bool inIsQualified,
          ippOnePropertyCollisionVolumePtr inCollisionVolume,
          double inLength,
    double inRadius
  );
  
  virtual ~ippKTool();

  double getAngleA()const {return _angleA;}
  double getAngleB()const {return _angleB;}
  double getAngleC()const {return _angleC;}

  ippOnePropertyCollisionVolumePtr getCollisionVolume()const {return _collisionVolume; }
  
  ippGoToParsPtr getGoToPar() const  {return _goToPar;}
  ippPtMeasParsPtr getPtMeasPar()  const {return _ptMeasPar;}
  ippScanParsPtr getScanPar() const { return _scanPar; }
    
  const char * getId() const {return _id.c_str();}
  
  bool getIsQualified() const {return _isQualified;}
  double getLength() const  {return _length;}
  
  const char * getName()const  {return _name.c_str();}
  
  
  double getRadius() const {return _radius;}

  void setAngleA(double inAngleA)  {_angleA = inAngleA;}
  void setAngleB(double inAngleB)  {_angleB = inAngleB;}
  void setAngleC(double inAngleC)  {_angleC = inAngleC;}

  void setCollisionVolume(ippOnePropertyCollisionVolume* inCollisionVolume)
    {_collisionVolume = inCollisionVolume;}

  void setGoToPar(ippGoToPars* inGoToPar)
    {_goToPar = inGoToPar;}
  void setScanPar(ippScanPars* inScanPar)
    {_scanPar = inScanPar;}

  void setIsQualified(bool inIsQualified)
    {_isQualified = inIsQualified;}

  void setLength(double inLength)
    {_length = inLength;}

  void setName(const char * inName)
    {_name = inName;}

  void setPtMeasPar(ippPtMeasPars * inPtMeasPar)
    {_ptMeasPar = inPtMeasPar;}

  void setRadius(double inRadius)
    {_radius = inRadius;}

private:
  ippKTool(const ippKTool&);
  void operator=(const ippKTool&);

};
IPP_DECLARE_SMARTPOINTER(ippKTool);

---