CSOLabelPlacementGlobal.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2014, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
 
 
#pragma once
 
#include "../CSOLabelPlacement.h"
 
#include <ThirdPartyWarningsDisable.h>
 
#include <boost/unordered_map.hpp>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/geometry/geometries/adapted/boost_tuple.hpp>
#include <boost/geometry/algorithms/convex_hull.hpp>
 
#include <ThirdPartyWarningsRestore.h>
 
 
ML_START_NAMESPACE
 
typedef boost::tuple <MLint, MLint> Point2D;
 
class SOCSO_EXPORT CSOLabelPlacementGlobal : public CSOLabelPlacement
{
public:
 
  enum HullMode {
    CONVEX_CSO_HULL = 0,
    HULL_POINTS_FROM_CSO_LIST
  };
 
  CSOLabelPlacementGlobal();
 
  void layoutVisibleCSOs(const std::vector<CSODrawCSOInfos>& drawCSOInfos,
                         const std::map < int, SbVec2f>& labelBoxes,
                         const CSODrawView2DInfos& view2DInfos,
                         SoCSOLabelRenderer* labelRenderer) override;
 
  void getAttachedLabelPosition( const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, int labelWidth, int labelHeight, float& deviceX, float& deviceY ) override;
 
protected:
 
  void handleNotification(Field* field) override;
 
private:
 
  FloatField* _labelDeviceOffsetFld;
  IntField* _additionalSlotsFld;
  EnumField* _hullModeFld;
  FloatField* _startAngleFld;
  FloatField* _endAngleFld;
  BaseField* _inHullCSOListFld;
 
  struct LabelBoundingBox
  {
    SbVec2f upper;
    float width;
    float height;
    bool overlaps(const LabelBoundingBox& labelBoundingBox) const
    {
      const MLdouble augment = 3.;
 
      const MLdouble bb1v1x = labelBoundingBox.upper[0] - augment;
      const MLdouble bb1v1y = labelBoundingBox.upper[1] - augment;
      const MLdouble bb1v2x = labelBoundingBox.upper[0] + augment + labelBoundingBox.width;
      const MLdouble bb1v2y = labelBoundingBox.upper[1] + augment + labelBoundingBox.height;
 
      const MLdouble bb2v1x = upper[0] - augment;
      const MLdouble bb2v1y = upper[1] - augment;
      const MLdouble bb2v2x = upper[0] + width  + augment;
      const MLdouble bb2v2y = upper[1] + height + augment;
 
      // store v1 maximum values in min-variables
      const MLdouble minX = (bb1v1x > bb2v1x) ? bb1v1x : bb2v1x;
      const MLdouble minY = (bb1v1y > bb2v1y) ? bb1v1y : bb2v1y;
 
      // store v2 minimum values in max-variables
      const MLdouble maxX = (bb1v2x < bb2v2x) ? bb1v2x : bb2v2x;
      const MLdouble maxY = (bb1v2y < bb2v2y) ? bb1v2y : bb2v2y;
 
      // if boxes intersect, all min values must be less/equal than the max values
      bool result = true;
 
      result = result && (minX <= maxX);
      result = result && (minY <= maxY);
 
      return result;
    }
  };
 
  void computeDeviceConvexHullOfAllCSOs(const std::vector<CSODrawCSOInfos>& drawCSOInfos,
                                        boost::geometry::model::polygon < Point2D >& convexHull);
  void computeCSODevicePositions(const std::vector<CSODrawCSOInfos>& drawCSOInfos,
                                 const CSODrawView2DInfos& view2DInfos);
  bool seedPointIsInSlicePlane(CSO* cso, int index, const CSODrawView2DInfos& view2DInfos) const;
  CSO* getCSOInPlane(const CSODrawView2DInfos& view2DInfos) const;
  bool computeDeviceHullForCSOList(const CSODrawView2DInfos& view2DInfos,
                                   boost::geometry::model::polygon<Point2D>& convexHull) const;
 
  void offsetConvexHull(boost::geometry::model::polygon < Point2D >& convexHull, const Point2D& centroidOfHull, float deviceOffset) const;
  static float computeMaxDistanceOfConvexHullFromCentroid(const boost::geometry::model::polygon < Point2D >& convexHull, const Point2D& centroidOfHull);
  void computeLabelRays(size_t numCSOs, float rayLength, const Point2D& centroidOfHull, std::vector <Point2D>& labelRayEndPositions) const;
  static void computeLabelSlotPositions( const boost::geometry::model::polygon < Point2D >& convexHull, const Point2D& centroidOfHull,
                                  const std::vector <Point2D>& labelRayEndPositions, std::vector <Point2D>& labelSlotPositions );
 
  std::vector < std::pair < int, int> > computeNearestCSOForLabelPositionSlot(const std::vector <Point2D>& labelSlotPositions, const std::vector<unsigned int>& csoIds);
  void computeCSOToSlotDistanceMatrix(const std::vector <Point2D>& labelSlotPositions, const std::vector<unsigned int>& csoIds, std::vector < std::vector < float > >& csoSlotDistancesMatrix);
 
  static float computeMinDistanceCSOToSlot(const std::vector<Point2D>& csoDevicePositions, const Point2D& slotPosition);
  void setLabelPositionsForCSOs( const std::vector< std::pair< int, int > >& csoToSlotMapping,
                                 const std::vector<unsigned int>& csoIds,
                                 const std::map< int, SbVec2f>& labelBoxes,
                                 const std::vector<Point2D>& labelSlotPositions,
                                 const CSODrawView2DInfos& view2DInfos );
  static SbVec2f getLabelBoxForCSO(const std::map < int, SbVec2f >& labelBoxes, int csoId);
  void moveLabelByWidthHeight(const CSODrawView2DInfos& view2DInfos, int labelWidth, int labelHeight, MLint64& deviceX, MLint64& deviceY);
  void avoidLabelOverlap(const std::map < int, SbVec2f >& labelBoxes);
 
  void setupLabelBoundingBoxes( const std::map< int, SbVec2f >& labelBoxes, std::map< int, LabelBoundingBox >& labelBoundingBoxes );
  static bool boundingBoxHasOverlap( int csoId, const LabelBoundingBox& labelBoundingBox, const std::map< int, LabelBoundingBox >& labelBoundingBoxes );
  bool moveLabelOutwards(LabelBoundingBox& labelBoundingBox);
 
  std::map <unsigned int, Point2D> _labelPositions;
  std::map <unsigned int, std::vector<Point2D> > _csoDevicePositions;
  CSOListPtr _hullCSOList;
 
  Point2D _centroidOfConvexHull;
 
  ML_MODULE_CLASS_HEADER(CSOLabelPlacementGlobal);
};
 
ML_END_NAMESPACE