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 TDefaultScanBinder : public ScanBinder
{
  public:
    TDefaultScanBinder(const Parameters& parameters);
 
    ~TDefaultScanBinder() 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 TPosition
    {
        TPosition()
          : Enabled(true)
          , Source(psNONE)
        {}
 
        TPosition(const TPosition& p)
          : Enabled(p.Enabled)
          , Name(p.Name)
          , Source(p.Source)
          , Coord(p.Coord)
        {}
 
        bool isEqual(const TPosition& p) const
        {
          return Enabled == p.Enabled && Name == p.Name && Source == p.Source && Coord == p.Coord;
        }
 
        bool operator==(const TPosition& p) const
        {
          return isEqual(p);
        }
 
        bool operator!=(const TPosition& 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 TCheckPosition
    {
        TCheckPosition()
          : Line(0.0)
          , Frac(0.0)
          , Rect(true)
        {}
 
        TCheckPosition(const TCheckPosition& p)
          : Line(p.Line)
          , Frac(p.Frac)
          , Rect(p.Rect)
        {}
 
        bool isEqual(const TCheckPosition& p) const
        {
          return sf::isEqual(Line, p.Line) && sf::isEqual(Frac, p.Frac) && Rect == p.Rect;
        }
 
        bool operator==(const TCheckPosition& p) const
        {
          return isEqual(p);
        }
 
        bool operator!=(const TCheckPosition& p) const
        {
          return !isEqual(p);
        }
 
        std::string toString() const;
 
        bool fromString(const std::string& s);
 
        double Line;
        double Frac;
        bool Rect;
    };
 
    bool MoveToCheckPosition(int check_index);
 
    bool MoveToCheckPosition(const TCheckPosition& check_pos);
 
    bool MoveToCheckPosition(int scan, const TCheckPosition&, 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 DoReadWriteConfig(IniEnvelope& ini, bool rd) override;
 
    InfoBase* NewScanInfo() override;
 
    void AddPropertyPages(PropertySheetDialog* sheet) override;
 
    void AddPropertyPages(PropertySheetDialog* sheet, bool scan) override;
 
    void ReadProfile(IniProfile& inifile) override;
 
    void WriteProfile(IniProfile& inifile) override;
 
    virtual void Sustain(const timespec& ts);
 
    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 rect) override;
 
    bool Check(int scan) override;
 
    bool Scan(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 rect, bool chk);
 
    enum EBinderStage : int
    {
      bsSYSTEM = 0,
      bsAPPROACH,
      bsSTART,
      bsSCAN,
    };
 
    static std::string GetStageName(int stage);
 
    class TStagePosition
    {
      public:
        TStagePosition();
 
        TStagePosition(const TStagePosition&);
 
        TStagePosition(int scan, EBinderStage stage, int index = -1, double frac = -1.0, bool rect = false);
 
        const TStagePosition& Set(int scan, EBinderStage stage, int index = -1, double frac = -1.0, bool rect = false);
 
        bool IsEqual(const TStagePosition& stage_pos) const;
 
        bool operator!=(const TStagePosition& sp) const
        {
          return !IsEqual(sp);
        }
 
        bool operator==(const TStagePosition& sp) const
        {
          return IsEqual(sp);
        }
 
        std::string GetName(TDefaultScanBinder*) const;
 
        std::string GetString() const;
 
        bool SetString(const std::string& s);
 
        int Scan;
        EBinderStage Stage;
        int Index;
        double Frac;
        bool Rect;
    };
 
    typedef TVector<TStagePosition> TStagePositions;
 
    const TStagePosition FCur;
    TStagePosition FMove;
    TStagePosition FTarget;
    TStagePosition FResume;
    ListenerList _listenerList;
 
    bool GetStagePos(gmi::AxesCoord& pos, const TStagePosition& stage_pos) const;
 
    bool CheckPos(const gmi::AxesCoord& pos) const;
 
    bool CheckStagePos(const TStagePosition& stage_pos) const;
 
    bool MoveToStage(const TStagePosition& stage_pos);
 
    void SetCurStage(const TStagePosition& stage_pos);
 
    bool GetNextStep(TStagePosition& next, const TStagePosition& sp1, const TStagePosition& sp2, TStagePositions& traject);
 
    bool AddCalculatedTraject(TStagePositions& traject, const TStagePosition& from, const TStagePosition& to);
 
    TStagePositions FTraject;
    int FTrajectIndex;
 
    // -----------------------------
    // Safe positions.
    // -----------------------------
 
    int GetCommonApproachCount(int scan1, int scan2);
 
    struct TPositions : TVector<TPosition>
    {
        bool isEqual(const TPositions& p) const;
 
        bool operator!=(const TPositions& p) const
        {
          return !isEqual(p);
        }
 
        bool operator==(const TPositions& p) const
        {
          return isEqual(p);
        }
    };
 
    TPositions FPositions;
 
    struct TCheckPositions : TVector<TCheckPosition>
    {
        bool IsEqual(const TCheckPositions& p) const;
 
        bool operator!=(const TCheckPositions& p) const
        {
          return !IsEqual(p);
        }
 
        bool operator==(const TCheckPositions& p) const
        {
          return IsEqual(p);
        }
    };
 
    struct TScanInfo : InfoBase
    {
        // Default constructor.
        TScanInfo()
          : StraightMove(true)
          , Balance(false)
          , Bidirectional(true)
          , ScanGainActive(true)
        {}
 
        // Copy constructor.
        TScanInfo(const TScanInfo& si)
          : SafePos(si.SafePos)
          , CheckPos(si.CheckPos)
          , StraightMove(si.StraightMove)
          , Balance(si.Balance)
          , Bidirectional(false)
          , ScanGainActive(si.ScanGainActive)
        {}
 
        // Overloaded from base class.
        virtual void ReadWrite(IniProfile* inifile, bool rd);
        gmi::AxesCoord SafePos;
        TCheckPositions CheckPos;
        bool StraightMove;
        bool Balance;
        bool Bidirectional;
        bool ScanGainActive;
    };
 
    TScanInfo& GetScanInfo(int scan);
 
    const TScanInfo& GetScanInfo(int scan) const;
 
    EState FAfterStopState;
    EState FResumeState;
    gmi::AxesCoord FStopCoord;
    DefaultBinderFrame* FBinderFrame;
 
    enum EScanningStage : int
    {
      ssABORTED,
      ssSTART,
      ssSPINUP,
      ssTRACE,
      ssRETRACE,
      ssFINISH,
      ssRETURN,
      ssREADY,
    };
 
    //
    enum EMoveMode : int
    {
      mmVEL,
      mmCON,
      mmUNI,
      mmBI,
    };
 
    struct TScanning
    {
        TScanning()
        {
          Clear();
        }
 
        void Clear()
        {
          ScanIndex = -1;
          Method = nullptr;
          Info = nullptr;
          Stage = ssSTART;
          ScanAxis = gmi::alNA;
          MoveMode = mmCON;
          TargetIndex = 0;
        }
 
        int ScanIndex;
        ScanMethod* Method;
        TScanInfo* Info;
        EScanningStage Stage;
        EMoveMode MoveMode;
        gmi::EAxisLocation ScanAxis;
        ElapseTimer SpinUpTimer;
        ElapseTimer Timer;
        gmi::AxisValue Trigger;
        int TargetIndex;
    } FScanning;
 
    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 FCheckOffset;
    Variable::PtrVector FVarsImport;
 
    void handleVariableEventImport(Variable::EEvent event, const Variable& caller, Variable& link, bool same_inst);
 
    TVariableHandler<TDefaultScanBinder> _handlerVariableEventImport{this, &TDefaultScanBinder::handleVariableEventImport};
 
    /*
     * Imported and linked variables.
     */
    Variable VBalance;
    Variable VBidirectional;
    Variable VScanGainActive;
 
    enum EBalance : int
    {
      balDISABLED,
      balACTIVE,
      balWAIT,
    };
 
    EBalance FBalanceState;
    bool FCheckMoveConfirm;
    bool FClearCheckOffset;
    int FCheckOffsetScanIndex;
    TCheckPosition FManualPosition;
 
    bool QueryCheckPosition(TCheckPosition& check_pos);
 
  protected:
    void Sustain(timespec) override;
 
  public:
    friend TScanning;
    friend class TStagePosition;
    friend class SelectCurrentPositionDialog;
    /*
     * @brief Giving access to several property pages.
     */
    friend class DefaultBinderPropertyPage;
    friend class CheckPositionsPropertyPage;
    friend class DefaultBinderConfigPropertyPage;
    friend class BinderCommonPropertyPage;
    friend class DefaultBinderProjectPropertyPage;
};
 
inline TDefaultScanBinder::TScanInfo& TDefaultScanBinder::GetScanInfo(int scan)
{
  return *static_cast<TScanInfo*>(ScanBinder::GetScanInfoBase(scan));
}
 
inline const TDefaultScanBinder::TScanInfo& TDefaultScanBinder::GetScanInfo(int scan) const
{
  return *static_cast<TScanInfo*>(const_cast<TDefaultScanBinder*>(this)->ScanBinder::GetScanInfoBase(scan));
}
 
inline TDefaultScanBinder::TStagePosition::TStagePosition()
  : Scan(-1)
  , Stage(bsSYSTEM)
  , Index(-1)
  , Frac(-1.0)
  , Rect(true)
{}
 
inline TDefaultScanBinder::TStagePosition::TStagePosition(const TStagePosition& sp)
  : Scan(sp.Scan)
  , Stage(sp.Stage)
  , Index(sp.Index)
  , Frac(sp.Frac)
  , Rect(sp.Rect)
{}
 
inline TDefaultScanBinder::TStagePosition::TStagePosition(int scan, EBinderStage stage, int index, double frac, bool rect)
  : Scan(scan)
  , Stage(stage)
  , Index(index)
  , Frac(frac)
  , Rect(rect)
{}
 
inline const TDefaultScanBinder::TStagePosition& TDefaultScanBinder::TStagePosition::Set(int scan, EBinderStage stage, int index, double frac, bool rect)
{
  Scan = scan;
  Stage = stage;
  Index = index;
  Frac = frac;
  Rect = rect;
  return *this;
}
 
inline bool TDefaultScanBinder::TStagePosition::IsEqual(const TStagePosition& 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 (isEqual(Frac, stage_pos.Frac))
      return false;
    // Check rectangular flag.
    if (Rect != stage_pos.Rect)
      return false;
  }
  return true;
}
 
inline const Vector3D& TDefaultScanBinder::GetCheckOffset() const
{
  return FCheckOffset;
}
 
}// namespace sf