polygons.h

Go to the documentation of this file.

/* 
 * SPDX-FileCopyrightText: 2025 Gesellschaft fuer Anlagen- und Reaktorsicherheit gGmbH
 * SPDX-License-Identifier: EUPL-1.2
 * SPDX-FileContributor: Dmitry Logashenko
 * SPDX-FileContributor: Goethe Universität Frankfurt
 * SPDX-FileType: SOURCE
 * 
 * This file is part of d3f++.
 * d3f++ is an extension for UG4. Licensing information and citation requirements of UG4 are provided in LICENSES/UG4-LGPL_2.1
 */
 
 
/*
 * Definition of surface functions by polygons
 */
#ifndef __H__UG__PLUGINS__D3F__POLYGONS__
#define __H__UG__PLUGINS__D3F__POLYGONS__
 
#include <vector>
 
// ug4 headers
#include "common/common.h"
#include "common/math/ugmath.h"
 
namespace ug {
namespace d3f {
 
class PolygonalRegions
{
//  Description of a polygon
  class t_polygon_item
  {
  public:
    t_polygon_item * tl; 
    int id; 
    std::vector<MathVector<2> > corner; 
    MathVector<2> bb [2]; 
    
    t_polygon_item (int the_id, number x, number y, t_polygon_item * the_tl = NULL)
    : tl (the_tl), id (the_id), corner (1)
    {
      corner[0][0] = x; corner[0][1] = y;
      bb[0] = bb[1] = corner[0]; // a trivial bounding box
    }
    
    void append (number x, number y);
    
    bool is_valid () const {return corner.size () >= 3;}
  
    bool pnt_inside (number x, number y) const
    {
    //---- choose the prefered algorithm ----//
      return pnt_inside_WN (MathVector<2> (x, y));
    }
  
  private:    
  //----  the winding number algorithm
  
    inline bool pnt_is_on_the_left
    (
      const MathVector<2> & pnt_0,
      const MathVector<2> & pnt_1,
      const MathVector<2> & pnt
    ) const;
    
    bool pnt_inside_WN (const MathVector<2> pnt) const;
  
  //----  the crossing number algorithm
  
    bool pnt_inside_CN (const MathVector<2> pnt) const;
  };
 
public:
 
  PolygonalRegions () : m_polygons (NULL) {};
  
  ~PolygonalRegions ()
  {
    t_polygon_item * t = m_polygons;
    while (t != NULL)
    {
      t_polygon_item * s = t->tl;
      delete t;
      t = s;
    }
  }
  
  void append_point (number x, number y, int id)
  {
    t_polygon_item * t = polygon_by_id (id);
    if (t != NULL)
      t->append (x, y);
    else
      m_polygons = new t_polygon_item (id, x, y, m_polygons);
  }
 
  bool get_id_by_pnt (number x, number y, int & id) const
  {
    for (t_polygon_item * t = m_polygons; t != NULL; t = t->tl)
      if (t->pnt_inside (x, y))
      {
        id = t->id;
        return true;
      }
    return false;
  }
  
  int get_id_by_pnt_dv (number x, number y, int dv) const
  {
    int id;
    return (get_id_by_pnt (x, y, id))? id : dv;
  }
  
  void load_points_from (const char * file_name);
  
private:
 
  t_polygon_item * polygon_by_id (int id) const
  {
    t_polygon_item * t;
    for (t = m_polygons; t != NULL; t = t->tl)
      if (t->id == id)
        break;
    return t;
  }
 
  void load_points_from (std::istream & input);
  
  bool good () const
  {
    for (t_polygon_item * t = m_polygons; t != NULL; t = t->tl)
      if (! t->is_valid ())
        return false;
    return true;
  }
 
private:
  t_polygon_item * m_polygons; 
};
 
} // namespace d3f
} // end namespace ug
 
#endif // __H__UG__PLUGINS__D3F__POLYGONS__
 
/* End of File */