// Copyright (C) 2017 Chris N. Richardson and Garth N. Wells
//
// This file is part of DOLFIN.
//
// DOLFIN 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 3 of the License, or
// (at your option) any later version.
//
// DOLFIN 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 DOLFIN. If not, see .
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace py = pybind11;
namespace dolfin_wrappers
{
void geometry(py::module& m)
{
// dolfin::BoundingBoxTree
py::class_>
(m, "BoundingBoxTree")
.def(py::init<>())
.def("build", (void (dolfin::BoundingBoxTree::*)(const dolfin::Mesh&))
&dolfin::BoundingBoxTree::build)
.def("build", (void (dolfin::BoundingBoxTree::*)(const dolfin::Mesh&, std::size_t))
&dolfin::BoundingBoxTree::build)
.def("build", (void (dolfin::BoundingBoxTree::*)(const std::vector&, std::size_t))
&dolfin::BoundingBoxTree::build)
.def("compute_collisions", (std::vector (dolfin::BoundingBoxTree::*)(const dolfin::Point&) const)
&dolfin::BoundingBoxTree::compute_collisions)
.def("compute_collisions",
(std::pair, std::vector>
(dolfin::BoundingBoxTree::*)(const dolfin::BoundingBoxTree&) const)
&dolfin::BoundingBoxTree::compute_collisions)
.def("compute_entity_collisions", (std::vector (dolfin::BoundingBoxTree::*)(const dolfin::Point&) const)
&dolfin::BoundingBoxTree::compute_entity_collisions)
.def("compute_entity_collisions",
(std::pair, std::vector>
(dolfin::BoundingBoxTree::*)(const dolfin::BoundingBoxTree&) const)
&dolfin::BoundingBoxTree::compute_entity_collisions)
.def("compute_first_collision", &dolfin::BoundingBoxTree::compute_first_collision)
.def("compute_first_entity_collision", &dolfin::BoundingBoxTree::compute_first_entity_collision)
.def("compute_closest_entity", &dolfin::BoundingBoxTree::compute_closest_entity);
// dolfin::Point
py::class_(m, "Point")
.def(py::init<>())
.def(py::init())
.def(py::init())
.def(py::init())
.def(py::init([](py::array_t x)
{
auto b = x.request();
assert(b.shape.size() == 1);
assert(b.shape[0] <= 3);
return dolfin::Point(b.shape[0], x.data());
}))
.def("__getitem__", [](dolfin::Point& self, std::size_t index)
{
if (index > 2)
throw py::index_error("Out of range");
return self[index];
})
.def("__getitem__", [](const dolfin::Point& instance, py::slice slice)
{
std::size_t start, stop, step, slicelength;
if (!slice.compute(3, &start, &stop, &step, &slicelength))
throw py::error_already_set();
if (start != 0 or stop != 3 or step != 1)
throw std::range_error("Only full slices are supported");
return py::array_t(3, instance.coordinates());
})
.def("__setitem__", [](dolfin::Point& self, std::size_t index, double value)
{
if (index > 2)
throw py::index_error("Out of range");
self[index] = value;
})
.def("__setitem__", [](dolfin::Point& instance, py::slice slice, py::array_t values)
{
std::size_t start, stop, step, slicelength;
if (!slice.compute(3, &start, &stop, &step, &slicelength))
throw py::error_already_set();
if (start != 0 or stop != 3 or step != 1)
throw std::range_error("Only full slices are supported");
auto b = values.request();
if (b.ndim != 1)
throw std::range_error("Can only assign vector to a Point");
if (b.shape[0] != 3)
throw std::range_error("Can only assign vector of length 3 to a Point");
double* x = instance.coordinates();
std::copy_n(values.data(), 3, x);
})
.def(py::self + py::self)
.def(py::self - py::self)
.def(py::self == py::self)
.def(py::self * float())
.def(py::self / float())
.def("array",
[](dolfin::Point& self) { return Eigen::Vector3d(self.coordinates()); },
"Return copy of coordinate array")
.def("norm", &dolfin::Point::norm)
.def("x", &dolfin::Point::x)
.def("y", &dolfin::Point::y)
.def("z", &dolfin::Point::z)
.def("distance", &dolfin::Point::distance)
.def("dot", &dolfin::Point::dot);
// dolfin::MeshPointIntersection
py::class_>
(m, "MeshPointIntersection")
.def("intersected_cells", &dolfin::MeshPointIntersection::intersected_cells);
// These classes are wrapped only to be able to write tests in python.
// They are not imported into the dolfin namespace in python, but must be accessed through
// dolfin.cpp.geometry
py::class_(m, "CollisionPredicates")
.def_static("collides_segment_point_2d",
&dolfin::CollisionPredicates::collides_segment_point_2d)
.def_static("collides_triangle_point_2d",
&dolfin::CollisionPredicates::collides_triangle_point_2d)
.def_static("collides_triangle_triangle_2d",
&dolfin::CollisionPredicates::collides_triangle_triangle_2d)
.def_static("collides_segment_segment_2d",
&dolfin::CollisionPredicates::collides_segment_segment_2d);
py::class_(m, "IntersectionConstruction")
.def_static("intersection_triangle_triangle_2d",
&dolfin::IntersectionConstruction::intersection_triangle_triangle_2d)
.def_static("intersection_segment_segment_2d",
&dolfin::IntersectionConstruction::intersection_segment_segment_2d)
.def_static("intersection_triangle_segment_2d",
&dolfin::IntersectionConstruction::intersection_triangle_segment_2d);
// dolfin/geometry free functions
m.def("intersect", &dolfin::intersect);
}
}