CalibrationSets.h

Go to the documentation of this file.

#pragma once
#include "Namespace.h"
#include "ProjectScriptObject.h"
#include <gii/gen/Variable.h>
#include <gii/gen/VariableIdList.h>
 
namespace sf
{
// Forward definitions.
class TCalibrationSets;
class CalibrationVariablesPropertyPage;
 
enum ECalibrationValueState
{
  cvsEMPTY,
  cvsINITIALIZED,
  cvsASSIGNED
};
 
class CalibrationSet
{
  protected:
    explicit CalibrationSet(TCalibrationSets* owner);
 
    ~CalibrationSet();
 
  public:
    const Variable::PtrVector& Get(ECalibrationType ct = ctCAL_NONE) const;
    void ReadWriteConfig(bool rd);
    // Reads or writes the calibration set to the specified ini file.
    void ReadWriteConfig(IniProfile* inifile, bool rd);
    // Copy the current calibrated settings for those which are specified int the id's list.
    // When the list is NULL all calib parameters are set.
    bool AssignType(ECalibrationType cal_type, const InformationIds* ids = nullptr);
    // Assignment flags in the variables data field are reset.
    void ClearType(ECalibrationType cal_type, const InformationIds* ids = nullptr);
    // Returns true if all calibration values are assigned.
    bool AssignComplete(ECalibrationType ct) const;
    // Returns true if all calibration values are assigned.
    bool AssignComplete() const;
 
  private:
    // Read s or writes the calibration values of the specified cal type.
    bool ReadWriteAssignValues(ECalibrationValueState cvs, ECalibrationType cal_type, KeyValues& key_values, bool rd);
 
    //
    const std::string& GetName()
    {
      return FName;
    }
 
    void SetName(const std::string& name)
    {
      FName = name;
    }
 
    // Gets a list of global variable Ids.
    InformationIds* GetIds()
    {
      return FIds[ctCAL_NONE];
    }
 
    // Handles changes on the
    void HandleIdsChange(void* sender);
    // Exports or revokes the current exports.
    void SetExports(bool var_export);
    // Owner of this instance which is the set list.
    TCalibrationSets* FOwner;
    // Calibration set name.
    std::string FName;
    // Holds the list with calibration variables. ctCAL_NONE holds the global vars.
    Variable::PtrVector FVars[ctCAL_LASTENTRY];
    // Wrapper for the all variable lists.
    VariableIdList* FIds[ctCAL_LASTENTRY];
 
    friend TCalibrationSets;
    friend CalibrationVariablesPropertyPage;
};
 
inline const Variable::PtrVector& CalibrationSet::Get(ECalibrationType ct) const
{
  // Always return a valid vector.
  if (ct < ctCAL_NONE || ct >= ctCAL_LASTENTRY)
    ct = ctCAL_NONE;
  return FVars[ct];
}
 
class TCalibrationSets final
  : public ProjectScriptObject
  , VariableHandler
{
  public:
    // Constructor.
    TCalibrationSets(const std::string& prefix, id_type id_offset, id_type id_range);
    // Destructor.
    ~TCalibrationSets() override;
    // Returns the amount of sets
    int Size() const;
    // Returns the set names.
    void GetNames(string_list& names) const;
    // Returns the set index of passed name.
    int IndexOf(const std::string& name) const;
    // Returns the set of the passed index.
    const CalibrationSet* operator[](int index) const;
    CalibrationSet* operator[](int index);
 
    const CalibrationSet* Get(int index) const
    {
      return (*this)[index];
    }
 
    CalibrationSet* Get(int index)
    {
      return (*this)[index];
    }
 
    // Returns the set with the passed name or NULL when not found.
    const CalibrationSet* Get(const std::string& name) const;
    CalibrationSet* Get(const std::string& name);
    // Reads or writes the calibrations sets and their configurations.
    void ReadWriteConfig(IniProfile* inifile, bool rd);
    // Reads all calibration values of all sets for the passed inspection.
    bool ReadWriteAssignValues(PartInspection* part_insp, bool rd);
    // Reads all pre calibration values of all sets for the passed project.
    bool ReadWriteAssignValues(PartProject* part_proj, bool rd);
    // Returns dirty if the config has changed.
    bool IsDirty() const;
    // Resets or sets the dirty flag.
    void SetDirty(bool dirty = false);
 
    // Copy the current calibrated settings for those which are specified in
    // the ID's list. When the list is NULL all calib parameters are set.
    bool AssignType(ECalibrationType cal_type, const std::string& set_name, const InformationIds* ids = nullptr);
    // Export all variables of the passed set and revoke all other sets.
    // When the set does not exist all current exports are revoked.
    void SetExports(const std::string& set_name) const;
    void SetExports(int index = -1) const;
    // When the set does exist assignments of the set are revoked.
    void ClearType(ECalibrationType cal_type, const std::string& set_name, InformationIds* ids = nullptr);
    void ClearType(ECalibrationType cal_type, int index = -1, const InformationIds* ids = nullptr);
    // Returns true when the calibration set is completely assign.
    bool AssignComplete(const std::string& set_name) const;
    // Returns true when the calibration set of the passed index is completely assign.
    // When -1 is passed it checks all sets for assign completion.
    bool AssignComplete(int index = -1) const;
 
  protected:
    // Sets the amount of entries.
    void Resize(int sz);
    // Event handler for the global calibration variables.
    void variableEventHandler(EEvent event, const Variable& caller, Variable& link, bool same_inst) override;
 
    // Returns the complete name string.
    std::string GetNamePrefix(ECalibrationType cal_type);
 
  private:
    TVector<CalibrationSet*> FSets;
    std::string FNamePrefix;
    id_type FIdOffset;
    id_type FIdRange;
    bool FDirty;
 
    friend CalibrationSet;
    friend CalibrationVariablesPropertyPage;
};
 
inline int TCalibrationSets::Size() const
{
  return FSets.count();
}
 
inline const CalibrationSet* TCalibrationSets::operator[](int index) const
{
  if (index >= FSets.count())
    return nullptr;
  return FSets[index];
}
 
inline CalibrationSet* TCalibrationSets::operator[](int index)
{
  if (index >= FSets.count())
    return nullptr;
  return FSets[index];
}
 
inline const CalibrationSet* TCalibrationSets::Get(const std::string& name) const
{
  auto index = IndexOf(name);
  if (index < 0)
    return nullptr;
  return FSets.get(index);
}
 
inline CalibrationSet* TCalibrationSets::Get(const std::string& name)
{
  return FSets[IndexOf(name)];
}
 
inline bool TCalibrationSets::IsDirty() const
{
  return FDirty;
}
 
inline void TCalibrationSets::SetDirty(bool dirty)
{
  FDirty = dirty;
}
 
inline void TCalibrationSets::SetExports(const std::string& set_name) const
{
  SetExports(IndexOf(set_name));
}
 
inline void TCalibrationSets::ClearType(ECalibrationType cal_type, const std::string& set_name, InformationIds* ids)
{
  int index = IndexOf(set_name);
  if (index >= 0)
    ClearType(cal_type, index, ids);
}
 
inline bool TCalibrationSets::AssignComplete(const std::string& set_name) const
{
  int index = IndexOf(set_name);
  if (index >= 0)
    return AssignComplete();
  return false;
}
 
}// namespace sf