utilities.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2014 - 2022 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, 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.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
 
#ifndef dealii_occ_utilities_h
#define dealii_occ_utilities_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_OPENCASCADE
 
#  include <deal.II/base/point.h>
 
#  include <deal.II/fe/mapping_q1.h>
 
#  include <deal.II/grid/tria.h>
 
#  include <string>
 
// opencascade needs "HAVE_CONFIG_H" to be exported...
#  define HAVE_CONFIG_H
#  include <IFSelect_ReturnStatus.hxx>
#  include <TopoDS_CompSolid.hxx>
#  include <TopoDS_Compound.hxx>
#  include <TopoDS_Edge.hxx>
#  include <TopoDS_Face.hxx>
#  include <TopoDS_Shape.hxx>
#  include <TopoDS_Shell.hxx>
#  include <TopoDS_Solid.hxx>
#  include <TopoDS_Vertex.hxx>
#  include <TopoDS_Wire.hxx>
#  include <gp_Pnt.hxx>
#  undef HAVE_CONFIG_H
 
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace OpenCASCADE
{
  std::tuple<unsigned int, unsigned int, unsigned int>
  count_elements(const TopoDS_Shape &shape);
 
  TopoDS_Shape
  read_IGES(const std::string &filename, const double scale_factor = 1e-3);
 
  void
  write_IGES(const TopoDS_Shape &shape, const std::string &filename);
 
 
  TopoDS_Shape
  read_STL(const std::string &filename);
 
  void
  write_STL(const TopoDS_Shape &shape,
            const std::string & filename,
            const double        deflection,
            const bool          sew_different_faces = false,
            const double        sewer_tolerance     = 1e-6,
            const bool          is_relative         = false,
            const double        angular_deflection  = 0.5,
            const bool          in_parallel         = false);
 
 
  TopoDS_Shape
  read_STEP(const std::string &filename, const double scale_factor = 1e-3);
 
 
  void
  write_STEP(const TopoDS_Shape &shape, const std::string &filename);
 
  double
  get_shape_tolerance(const TopoDS_Shape &shape);
 
  TopoDS_Shape
  intersect_plane(const TopoDS_Shape &in_shape,
                  const double        c_x,
                  const double        c_y,
                  const double        c_z,
                  const double        c,
                  const double        tolerance = 1e-7);
 
  TopoDS_Edge
  join_edges(const TopoDS_Shape &in_shape, const double tolerance = 1e-7);
 
  template <int dim>
  TopoDS_Edge
  interpolation_curve(std::vector<Point<dim>> &curve_points,
                      const Tensor<1, dim> &   direction = Tensor<1, dim>(),
                      const bool               closed    = false,
                      const double             tolerance = 1e-7);
 
  void
  extract_geometrical_shapes(const TopoDS_Shape &        shape,
                             std::vector<TopoDS_Face> &  faces,
                             std::vector<TopoDS_Edge> &  edges,
                             std::vector<TopoDS_Vertex> &vertices);
 
  template <int spacedim>
  void
  create_triangulation(const TopoDS_Face &         face,
                       Triangulation<2, spacedim> &tria);
 
 
  template <int spacedim>
  std::vector<TopoDS_Edge>
  create_curves_from_triangulation_boundary(
    const Triangulation<2, spacedim> &triangulation,
    const Mapping<2, spacedim> &      mapping =
      StaticMappingQ1<2, spacedim>::mapping);
 
  void
  extract_compound_shapes(const TopoDS_Shape &           shape,
                          std::vector<TopoDS_Compound> & compounds,
                          std::vector<TopoDS_CompSolid> &compsolids,
                          std::vector<TopoDS_Solid> &    solids,
                          std::vector<TopoDS_Shell> &    shells,
                          std::vector<TopoDS_Wire> &     wires);
 
  template <int dim>
  std::tuple<Point<dim>, TopoDS_Shape, double, double>
  project_point_and_pull_back(const TopoDS_Shape &in_shape,
                              const Point<dim> &  origin,
                              const double        tolerance = 1e-7);
 
  template <int dim>
  Point<dim>
  closest_point(const TopoDS_Shape &in_shape,
                const Point<dim> &  origin,
                const double        tolerance = 1e-7);
 
  template <int dim>
  Point<dim>
  push_forward(const TopoDS_Shape &in_shape, const double u, const double v);
 
 
  std::tuple<Point<3>, Tensor<1, 3>, double, double>
  push_forward_and_differential_forms(const TopoDS_Face &face,
                                      const double       u,
                                      const double       v,
                                      const double       tolerance = 1e-7);
 
 
  std::tuple<Point<3>, Tensor<1, 3>, double, double>
  closest_point_and_differential_forms(const TopoDS_Shape &in_shape,
                                       const Point<3> &    origin,
                                       const double        tolerance = 1e-7);
 
 
  template <int dim>
  Point<dim>
  line_intersection(const TopoDS_Shape &  in_shape,
                    const Point<dim> &    origin,
                    const Tensor<1, dim> &direction,
                    const double          tolerance = 1e-7);
 
 
  template <int spacedim>
  Point<spacedim>
  point(const gp_Pnt &p, const double tolerance = 1e-10);
 
 
  template <int spacedim>
  gp_Pnt
  point(const Point<spacedim> &p);
 
 
  template <int dim>
  bool
  point_compare(const Point<dim> &    p1,
                const Point<dim> &    p2,
                const Tensor<1, dim> &direction = Tensor<1, dim>(),
                const double          tolerance = 1e-10);
 
 
  template <int dim>
  DeclException1(ExcPointNotOnManifold,
                 Point<dim>,
                 << "The point [ " << arg1 << " ] is not on the manifold.");
 
  template <int dim>
  DeclException1(ExcProjectionFailed,
                 Point<dim>,
                 << "Projection of point [ " << arg1 << " ] failed.");
 
  DeclException1(ExcOCCError,
                 IFSelect_ReturnStatus,
                 << "An OpenCASCADE routine failed with return status "
                 << arg1);
 
  DeclException0(ExcEdgeIsDegenerate);
 
  DeclException0(ExcUnsupportedShape);
} // namespace OpenCASCADE
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // DEAL_II_WITH_OPENCASCADE
 
#endif