DefaultScanBinder.h

Go to the documentation of this file.

#pragma once
#include <ipj/iface/CalibrationSets.h>
#include <ipj/iface/ScanBinder.h>
#include <misc/gen/ElapseTimer.h>
 
namespace sf
{
 
class DefaultBinderFrame;
 
class DefaultScanBinder final : public ScanBinder
{
  public:
    explicit DefaultScanBinder(const Parameters& parameters);
 
    ~DefaultScanBinder() override;
 
    enum EPositionSource : int
    {
      psNONE,
      psSET,
      psPARK,
      psSAFE,
      psSCANSTART,
      psSCANSTOP,
      psSCANINDEX,
      psLASTENTRY
    };
 
    static std::string GetSourceName(int value);
 
    static EPositionSource GetSourceValue(const std::string& name);
    static constexpr int MAX_POSITIONS{30};
 
    struct Position
    {
        Position()
          : Enabled(true)
          , Source(psNONE)
        {}
 
        Position(const Position& p)
          : Enabled(p.Enabled)
          , Name(p.Name)
          , Source(p.Source)
          , Coord(p.Coord)
        {}
 
        bool isEqual(const Position& p) const
        {
          return Enabled == p.Enabled && Name == p.Name && Source == p.Source && Coord.isEqual(p.Coord);
        }
 
        bool operator==(const Position& p) const
        {
          return isEqual(p);
        }
 
        bool operator!=(const Position& p) const
        {
          return !isEqual(p);
        }
 
        std::string toString() const;
 
        void fromString(const std::string& s);
 
        bool Enabled;
        std::string Name;
        EPositionSource Source;
        gmi::AxesCoord Coord;
    };
 
    struct CheckPosition
    {
        CheckPosition()
          : _line(0.0)
          , _frac(0.0)
          , _perp(true)
        {}
 
        CheckPosition(const CheckPosition& p)
          : _line(p._line)
          , _frac(p._frac)
          , _perp(p._perp)
        {}
 
        bool isEqual(const CheckPosition& p) const
        {
          return sf::isEqual(_line, p._line) && sf::isEqual(_frac, p._frac) && _perp == p._perp;
        }
 
        bool operator==(const CheckPosition& p) const
        {
          return isEqual(p);
        }
 
        bool operator!=(const CheckPosition& p) const
        {
          return !isEqual(p);
        }
 
        std::string toString() const;
 
        bool fromString(const std::string& s);
 
        double _line;
        double _frac;
        bool _perp;
    };
 
    bool MoveToCheckPosition(int check_index);
 
    bool MoveToCheckPosition(const CheckPosition& check_pos);
 
    bool MoveToCheckPosition(int scan, const CheckPosition&, bool confirm);
 
    bool CanMoveToCheckPosition();
 
    const Vector3D& GetCheckOffset() const;
 
    bool SetCheckOffset(const Vector3D& chk_ofs);
 
    bool CalcCheckOffset(Vector3D& vect) const;
 
    void ControllerEventHandler(gmi::Controller* ctrl, gmi::EControllerEvent event);
 
    void doStoreConfig(IniEnvelope& ini, bool rd) override;
 
    InfoBase* createScanInfo() override;
 
    void addPropertyPages(PropertySheetDialog* sheet) override;
 
    void addPropertyPages(PropertySheetDialog* sheet, bool scan) override;
 
    void readProfile(IniProfile& inifile) override;
 
    void writeProfile(IniProfile& inifile) override;
 
    void sustain(const timespec& ts) override;
 
    void stateChange(EState prev, EState cur) override;
 
    int getIndex() override;
 
    void clear() override;
 
    bool initialize() override;
 
    bool suspend(bool immediate) override;
 
    bool resume() override;
 
    bool stop() override;
 
    bool abort() override;
 
    bool moveTo(int scan, int index, double frac, bool perp) override;
 
    bool check(int scan) override;
 
    bool startScan(int scan) override;
 
    bool evaluate(int scan) override;
 
    bool activate(int scan) override;
 
    bool rotate(int scan, int index) override;
 
    QWidget* GetFrame() override;
 
    Vector3D getOffset() const override;
 
    bool getGenericInfoList(StringList&) override;
 
    const IdInfo* getInfo(const std::string& name) const override;
 
    virtual bool GetSetValue(const IdInfo* info, Value* value, Value::vector_type* params, bool flag_set);
 
    bool moveTo(int scan, int index, double frac, bool perp, bool chk);
 
    enum EBinderStage : int
    {
      bsSYSTEM = 0,
      bsAPPROACH,
      bsSTART,
      bsSCAN,
    };
 
    static std::string getStageName(int stage);
 
    class StagePosition
    {
      public:
        StagePosition();
 
        StagePosition(const StagePosition&);
 
        StagePosition(int scan, EBinderStage stage, int index = -1, double frac = -1.0, bool perp = false);
 
        const StagePosition& set(int scan, EBinderStage stage, int index = -1, double frac = -1.0, bool perp = false);
 
        bool isEqual(const StagePosition& stage_pos) const;
 
        bool operator!=(const StagePosition& sp) const
        {
          return !isEqual(sp);
        }
 
        bool operator==(const StagePosition& sp) const
        {
          return isEqual(sp);
        }
 
        std::string getName(DefaultScanBinder*) const;
 
        std::string getString() const;
 
        bool setString(const std::string& s);
 
        int _scan;
        EBinderStage _stage;
        int _index;
        double _frac;
        bool _rect;
    };
 
    typedef TVector<StagePosition> StagePositions;
 
    const StagePosition _current;
    StagePosition _move;
    StagePosition _target;
    StagePosition _resume;
    ListenerList _listenerList;
 
    bool getStagePos(gmi::AxesCoord& pos, const StagePosition& stage_pos) const;
 
    bool checkPos(const gmi::AxesCoord& pos) const;
 
    bool checkStagePos(const StagePosition& stage_pos) const;
 
    bool moveToStage(const StagePosition& stage_pos);
 
    void setCurrentStage(const StagePosition& stage_pos);
 
    bool getNextStep(StagePosition& next, const StagePosition& sp1, const StagePosition& sp2, StagePositions& traject);
 
    bool addCalculatedTraject(StagePositions& traject, const StagePosition& from, const StagePosition& to);
 
    StagePositions _traject;
    int _trajectIndex;
 
    // -----------------------------
    // Safe positions.
    // -----------------------------
 
    int GetCommonApproachCount(int scan1, int scan2);
 
    struct PositionList : TVector<Position>
    {
        bool isEqual(const PositionList& p) const;
 
        bool operator!=(const PositionList& p) const
        {
          return !isEqual(p);
        }
 
        bool operator==(const PositionList& p) const
        {
          return isEqual(p);
        }
    };
 
    PositionList FPositions;
 
    struct CheckPositionList : TVector<CheckPosition>
    {
        bool isEqual(const CheckPositionList& p) const;
 
        bool operator!=(const CheckPositionList& p) const
        {
          return !isEqual(p);
        }
 
        bool operator==(const CheckPositionList& p) const
        {
          return isEqual(p);
        }
    };
 
    struct ScanInfo final : InfoBase
    {
        // Default constructor.
        ScanInfo()
          : _straightMove(true)
          , _balance(false)
          , _bidirectional(true)
          , _scanGainActive(true)
        {}
 
        // Copy constructor.
        ScanInfo(const ScanInfo& si)
          : _safePosition(si._safePosition)
          , _checkPositions(si._checkPositions)
          , _straightMove(si._straightMove)
          , _balance(si._balance)
          , _bidirectional(false)
          , _scanGainActive(si._scanGainActive)
        {}
 
        // Overridden from base class.
        void ReadWrite(IniProfile* inifile, bool rd) override;
        gmi::AxesCoord _safePosition;
        CheckPositionList _checkPositions;
        bool _straightMove;
        bool _balance;
        bool _bidirectional;
        bool _scanGainActive;
    };
 
    ScanInfo& getScanInfo(int scan);
 
    const ScanInfo& getScanInfo(int scan) const;
 
    EState _afterStopState;
    EState _resumeState;
    gmi::AxesCoord _stopCoord;
    DefaultBinderFrame* _binderFrame;
 
    enum EScanningStage : int
    {
      ssABORTED,
      ssSTART,
      ssSPINUP,
      ssTRACE,
      ssRETRACE,
      ssFINISH,
      ssRETURN,
      ssREADY,
    };
 
    //
    enum EMoveMode : int
    {
      mmVEL,
      mmCON,
      mmUNI,
      mmBI,
    };
 
    struct Scanning
    {
        Scanning()
        {
          Clear();
        }
 
        void Clear()
        {
          ScanIndex = -1;
          Method = nullptr;
          Info = nullptr;
          Stage = ssSTART;
          ScanAxis = gmi::alNA;
          MoveMode = mmCON;
          TargetIndex = 0;
        }
 
        int ScanIndex;
        ScanMethod* Method;
        ScanInfo* Info;
        EScanningStage Stage;
        EMoveMode MoveMode;
        gmi::EAxisLocation ScanAxis;
        ElapseTimer SpinUpTimer;
        ElapseTimer Timer;
        gmi::AxisValue Trigger;
        int TargetIndex;
    } _scanning;
 
    bool setTrigger(int scan);
 
    bool setScanAxes(bool);
 
    bool getScanPos(gmi::AxesCoord& pos, int index, bool begin);
 
    bool scanMoveTo(int index, bool begin, bool trace);
 
    bool checkScanPos(int index, bool begin);
 
    Vector3D _checkOffset;
    Variable::PtrVector _varsImport;
 
    void handleVariableEventImport(Variable::EEvent event, const Variable& caller, Variable& link, bool same_inst);
 
    TVariableHandler<DefaultScanBinder> _handlerVariableEventImport{this, &DefaultScanBinder::handleVariableEventImport};
 
    /*
     * Imported and linked variables.
     */
    Variable vBalance;
    Variable vBidirectional;
    Variable vScanGainActive;
 
    enum EBalance : int
    {
      balDISABLED,
      balACTIVE,
      balWAIT,
    };
 
    EBalance _balanceState;
    bool _checkMoveConfirm;
    bool _clearCheckOffset;
    int _checkOffsetScanIndex;
    CheckPosition _manualPosition;
 
    bool queryCheckPosition(CheckPosition& check_pos);
 
    friend Scanning;
    friend class StagePosition;
    friend class SelectCurrentPositionDialog;
    /*
     * Giving access to several property pages.
     */
    friend class DefaultBinderPropertyPage;
    friend class CheckPositionsPropertyPage;
    friend class DefaultBinderConfigPropertyPage;
    friend class BinderCommonPropertyPage;
    friend class DefaultBinderProjectPropertyPage;
};
 
inline DefaultScanBinder::ScanInfo& DefaultScanBinder::getScanInfo(int scan)
{
  return *static_cast<ScanInfo*>(getScanInfoBase(scan));
}
 
inline const DefaultScanBinder::ScanInfo& DefaultScanBinder::getScanInfo(int scan) const
{
  return *static_cast<ScanInfo*>(const_cast<DefaultScanBinder*>(this)->ScanBinder::getScanInfoBase(scan));
}
 
inline DefaultScanBinder::StagePosition::StagePosition()
  : _scan(-1)
  , _stage(bsSYSTEM)
  , _index(-1)
  , _frac(-1.0)
  , _rect(true)
{}
 
inline DefaultScanBinder::StagePosition::StagePosition(const StagePosition& sp)
  : _scan(sp._scan)
  , _stage(sp._stage)
  , _index(sp._index)
  , _frac(sp._frac)
  , _rect(sp._rect)
{}
 
inline DefaultScanBinder::StagePosition::StagePosition(int scan, EBinderStage stage, int index, double frac, bool perp)
  : _scan(scan)
  , _stage(stage)
  , _index(index)
  , _frac(frac)
  , _rect(perp)
{}
 
inline const DefaultScanBinder::StagePosition& DefaultScanBinder::StagePosition::set(int scan, EBinderStage stage, int index, double frac, bool perp)
{
  _scan = scan;
  _stage = stage;
  _index = index;
  _frac = frac;
  _rect = perp;
  return *this;
}
 
inline bool DefaultScanBinder::StagePosition::isEqual(const StagePosition& stage_pos) const
{
  // First check the stage
  if (_stage != stage_pos._stage)
    return false;
  // Then check the scan.
  if (_scan != stage_pos._scan)
    return false;
  // If the stage is bsSCAN bsAPPROACH or bsSYSTEM check also the index.
  if (_stage == bsSCAN || _stage == bsAPPROACH || _stage == bsSYSTEM)
    // Check the scan or approach index.
    if (_index != stage_pos._index)
      return false;
  // If the stage is bsSCAN check also the frac.
  if (_stage == bsSCAN)
  {
    // Check the scan line fraction.
    if (sf::isEqual(_frac, stage_pos._frac))
      return false;
    // Check rectangular flag.
    if (_rect != stage_pos._rect)
      return false;
  }
  return true;
}
 
inline const Vector3D& DefaultScanBinder::GetCheckOffset() const
{
  return _checkOffset;
}
 
}// namespace sf