FeaturesPlugin_Measurement.h

// Copyright (C) 2018-2026  CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef FeaturesPlugin_Measurement_H_
#define FeaturesPlugin_Measurement_H_
 
#include "FeaturesPlugin.h"
#include <ModelAPI_Feature.h>
 
#include <GeomAPI_IPresentable.h>
#include <GeomAPI_IScreenParams.h>
 
class FeaturesPlugin_Measurement : public ModelAPI_Feature,
  public GeomAPI_IPresentable,
  public GeomAPI_IScreenParams
{
public:
  inline static const std::string& ID()
  {
    static const std::string MY_ID("Measurement");
    return MY_ID;
  }
 
  virtual const std::string& getKind()
  {
    return ID();
  }
 
  inline static const std::string& MEASURE_KIND()
  {
    static const std::string MY_MEASURE_KIND_ID("MeasureKind");
    return MY_MEASURE_KIND_ID;
  }
 
  inline static const std::string& MEASURE_LENGTH()
  {
    static const std::string MY_MEASURE_ID("Length");
    return MY_MEASURE_ID;
  }
 
  inline static const std::string& MEASURE_DISTANCE()
  {
    static const std::string MY_MEASURE_ID("Distance");
    return MY_MEASURE_ID;
  }
 
  inline static const std::string& MEASURE_PROXIMITY()
  {
    static const std::string MY_MEASURE_ID("Proximity");
    return MY_MEASURE_ID;
  }
 
  inline static const std::string& MEASURE_RADIUS()
  {
    static const std::string MY_MEASURE_ID("Radius");
    return MY_MEASURE_ID;
  }
 
  inline static const std::string& MEASURE_ANGLE()
  {
    static const std::string MY_MEASURE_ID("Angle");
    return MY_MEASURE_ID;
  }
 
  inline static const std::string& MEASURE_ANGLE_POINTS()
  {
    static const std::string MY_MEASURE_ID("AngleBy3Points");
    return MY_MEASURE_ID;
  }
 
 
  inline static const std::string& EDGE_FOR_LENGTH_ID()
  {
    static const std::string MY_EDGE_FOR_LENGTH_ID("edge_for_length");
    return MY_EDGE_FOR_LENGTH_ID;
  }
 
  inline static const std::string& DISTANCE_FROM_OBJECT_ID()
  {
    static const std::string MY_DISTANCE_FROM_OBJECT_ID("distance_from");
    return MY_DISTANCE_FROM_OBJECT_ID;
  }
 
  inline static const std::string& DISTANCE_TO_OBJECT_ID()
  {
    static const std::string MY_DISTANCE_TO_OBJECT_ID("distance_to");
    return MY_DISTANCE_TO_OBJECT_ID;
  }
 
  // Attribute name of edge or face selected to calculate radius.
  inline static const std::string& CIRCULAR_OBJECT_ID()
  {
    static const std::string MY_CIRCULAR_OBJECT_ID("circular");
    return MY_CIRCULAR_OBJECT_ID;
  }
 
  inline static const std::string& ANGLE_FROM_EDGE_ID()
  {
    static const std::string MY_ANGLE_FROM_EDGE_ID("angle_from");
    return MY_ANGLE_FROM_EDGE_ID;
  }
 
  inline static const std::string& ANGLE_TO_EDGE_ID()
  {
    static const std::string MY_ANGLE_TO_EDGE_ID("angle_to");
    return MY_ANGLE_TO_EDGE_ID;
  }
 
  inline static const std::string& ANGLE_POINT1_ID()
  {
    static const std::string MY_ANGLE_POINT1_ID("angle_point_1");
    return MY_ANGLE_POINT1_ID;
  }
 
  inline static const std::string& ANGLE_POINT2_ID()
  {
    static const std::string MY_ANGLE_POINT2_ID("angle_point_2");
    return MY_ANGLE_POINT2_ID;
  }
 
  inline static const std::string& ANGLE_POINT3_ID()
  {
    static const std::string MY_ANGLE_POINT3_ID("angle_point_3");
    return MY_ANGLE_POINT3_ID;
  }
 
  inline static const std::string& RESULT_ID()
  {
    static const std::string MY_RESULT_ID("result");
    return MY_RESULT_ID;
  }
 
  inline static const std::string& RESULT_VALUES_ID()
  {
    static const std::string MY_RESULT_VALUES_ID("result_values");
    return MY_RESULT_VALUES_ID;
  }
 
  FEATURESPLUGIN_EXPORT virtual void execute();
 
  FEATURESPLUGIN_EXPORT virtual void initAttributes();
 
  FEATURESPLUGIN_EXPORT virtual void attributeChanged(const std::string& theID);
 
  virtual bool isMacro() const { return true; }
 
  FEATURESPLUGIN_EXPORT virtual AISObjectPtr getAISObject(AISObjectPtr thePrevious);
 
  virtual void setScreenPlane(GeomPlanePtr theScreenPlane) {
    myScreenPlane = theScreenPlane;
  }
 
  virtual void setViewScale(double theScale) {
    mySceenScale = theScale;
  }
 
  FeaturesPlugin_Measurement();
 
private:
  void computeLength();
  void computeDistance();
  void computeProximity();
  void computeRadius();
  void computeAngle();
  void computeAngleByPoints();
 
  AISObjectPtr lengthDimension(AISObjectPtr thePrevious);
 
  AISObjectPtr distanceDimension(AISObjectPtr thePrevious);
 
  AISObjectPtr radiusDimension(AISObjectPtr thePrevious);
 
  AISObjectPtr angleDimension(AISObjectPtr thePrevious);
 
  AISObjectPtr angleByPointsDimension(AISObjectPtr thePrevious);
 
  void setupDimension(AISObjectPtr theDim);
 
  GeomPlanePtr myScreenPlane; //< a plane of current screen
  double mySceenScale; //< a scale of current view
};
 
#endif