diff options
Diffstat (limited to 'extern/mantaflow/preprocessed/shapes.h')
-rw-r--r-- | extern/mantaflow/preprocessed/shapes.h | 665 |
1 files changed, 665 insertions, 0 deletions
diff --git a/extern/mantaflow/preprocessed/shapes.h b/extern/mantaflow/preprocessed/shapes.h new file mode 100644 index 00000000000..09d3d23d938 --- /dev/null +++ b/extern/mantaflow/preprocessed/shapes.h @@ -0,0 +1,665 @@ + + +// DO NOT EDIT ! +// This file is generated using the MantaFlow preprocessor (prep generate). + +/****************************************************************************** + * + * MantaFlow fluid solver framework + * Copyright 2011 Tobias Pfaff, Nils Thuerey + * + * This program is free software, distributed under the terms of the + * Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0 + * + * shapes classes + * + ******************************************************************************/ + +#ifndef _SHAPES_H +#define _SHAPES_H + +#include "manta.h" +#include "vectorbase.h" +#include "levelset.h" + +namespace Manta { + +// forward declaration +class Mesh; + +//! Base class for all shapes +class Shape : public PbClass { + public: + enum GridType { TypeNone = 0, TypeBox = 1, TypeSphere = 2, TypeCylinder = 3, TypeSlope = 4 }; + + Shape(FluidSolver *parent); + static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + PbClass *obj = Pb::objFromPy(_self); + if (obj) + delete obj; + try { + PbArgs _args(_linargs, _kwds); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(0, "Shape::Shape", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + obj = new Shape(parent); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "Shape::Shape", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("Shape::Shape", e.what()); + return -1; + } + } + + //! Get the type of grid + inline GridType getType() const + { + return mType; + } + + //! Apply shape to flag grid, set inside cells to <value> + void applyToGrid(GridBase *grid, FlagGrid *respectFlags = 0); + static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock); + FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 1, 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->applyToGrid(grid, respectFlags); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Shape::applyToGrid", e.what()); + return 0; + } + } + + void applyToGridSmooth(GridBase *grid, + Real sigma = 1.0, + Real shift = 0, + FlagGrid *respectFlags = 0); + static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock); + Real sigma = _args.getOpt<Real>("sigma", 1, 1.0, &_lock); + Real shift = _args.getOpt<Real>("shift", 2, 0, &_lock); + FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 3, 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->applyToGridSmooth(grid, sigma, shift, respectFlags); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Shape::applyToGridSmooth", e.what()); + return 0; + } + } + + LevelsetGrid computeLevelset(); + static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->computeLevelset()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Shape::computeLevelset", e.what()); + return 0; + } + } + + void collideMesh(Mesh &mesh); + static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->collideMesh(mesh); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Shape::collideMesh", e.what()); + return 0; + } + } + + virtual Vec3 getCenter() const + { + return Vec3::Zero; + } + static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Shape::getCenter", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->getCenter()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Shape::getCenter", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Shape::getCenter", e.what()); + return 0; + } + } + + virtual void setCenter(const Vec3 ¢er) + { + } + static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Shape::setCenter", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const Vec3 ¢er = _args.get<Vec3>("center", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->setCenter(center); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Shape::setCenter", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Shape::setCenter", e.what()); + return 0; + } + } + + virtual Vec3 getExtent() const + { + return Vec3::Zero; + } + static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Shape::getExtent", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->getExtent()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Shape::getExtent", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Shape::getExtent", e.what()); + return 0; + } + } + + //! Inside test of the shape + virtual bool isInside(const Vec3 &pos) const; + inline bool isInsideGrid(int i, int j, int k) const + { + return isInside(Vec3(i + 0.5, j + 0.5, k + 0.5)); + }; + + virtual void generateMesh(Mesh *mesh){}; + virtual void generateLevelset(Grid<Real> &phi){}; + + protected: + GridType mType; + public: + PbArgs _args; +} +#define _C_Shape +; + +//! Dummy shape +class NullShape : public Shape { + public: + NullShape(FluidSolver *parent) : Shape(parent) + { + } + static int _W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + PbClass *obj = Pb::objFromPy(_self); + if (obj) + delete obj; + try { + PbArgs _args(_linargs, _kwds); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(0, "NullShape::NullShape", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + obj = new NullShape(parent); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "NullShape::NullShape", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("NullShape::NullShape", e.what()); + return -1; + } + } + + virtual bool isInside(const Vec3 &pos) const + { + return false; + } + virtual void generateMesh(Mesh *mesh) + { + } + + protected: + virtual void generateLevelset(Grid<Real> &phi) + { + gridSetConst<Real>(phi, 1000.0f); + } + public: + PbArgs _args; +} +#define _C_NullShape +; + +//! Box shape +class Box : public Shape { + public: + Box(FluidSolver *parent, + Vec3 center = Vec3::Invalid, + Vec3 p0 = Vec3::Invalid, + Vec3 p1 = Vec3::Invalid, + Vec3 size = Vec3::Invalid); + static int _W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + PbClass *obj = Pb::objFromPy(_self); + if (obj) + delete obj; + try { + PbArgs _args(_linargs, _kwds); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(0, "Box::Box", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + Vec3 center = _args.getOpt<Vec3>("center", 1, Vec3::Invalid, &_lock); + Vec3 p0 = _args.getOpt<Vec3>("p0", 2, Vec3::Invalid, &_lock); + Vec3 p1 = _args.getOpt<Vec3>("p1", 3, Vec3::Invalid, &_lock); + Vec3 size = _args.getOpt<Vec3>("size", 4, Vec3::Invalid, &_lock); + obj = new Box(parent, center, p0, p1, size); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "Box::Box", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("Box::Box", e.what()); + return -1; + } + } + + inline Vec3 getSize() const + { + return mP1 - mP0; + } + inline Vec3 getP0() const + { + return mP0; + } + inline Vec3 getP1() const + { + return mP1; + } + virtual void setCenter(const Vec3 ¢er) + { + Vec3 dh = 0.5 * (mP1 - mP0); + mP0 = center - dh; + mP1 = center + dh; + } + virtual Vec3 getCenter() const + { + return 0.5 * (mP1 + mP0); + } + virtual Vec3 getExtent() const + { + return getSize(); + } + virtual bool isInside(const Vec3 &pos) const; + virtual void generateMesh(Mesh *mesh); + virtual void generateLevelset(Grid<Real> &phi); + + protected: + Vec3 mP0, mP1; + public: + PbArgs _args; +} +#define _C_Box +; + +//! Spherical shape +class Sphere : public Shape { + public: + Sphere(FluidSolver *parent, Vec3 center, Real radius, Vec3 scale = Vec3(1, 1, 1)); + static int _W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + PbClass *obj = Pb::objFromPy(_self); + if (obj) + delete obj; + try { + PbArgs _args(_linargs, _kwds); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(0, "Sphere::Sphere", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + Vec3 center = _args.get<Vec3>("center", 1, &_lock); + Real radius = _args.get<Real>("radius", 2, &_lock); + Vec3 scale = _args.getOpt<Vec3>("scale", 3, Vec3(1, 1, 1), &_lock); + obj = new Sphere(parent, center, radius, scale); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "Sphere::Sphere", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("Sphere::Sphere", e.what()); + return -1; + } + } + + virtual void setCenter(const Vec3 ¢er) + { + mCenter = center; + } + virtual Vec3 getCenter() const + { + return mCenter; + } + inline Real getRadius() const + { + return mRadius; + } + virtual Vec3 getExtent() const + { + return Vec3(2.0 * mRadius); + } + virtual bool isInside(const Vec3 &pos) const; + virtual void generateMesh(Mesh *mesh); + virtual void generateLevelset(Grid<Real> &phi); + + protected: + Vec3 mCenter, mScale; + Real mRadius; + public: + PbArgs _args; +} +#define _C_Sphere +; + +//! Cylindrical shape +class Cylinder : public Shape { + public: + Cylinder(FluidSolver *parent, Vec3 center, Real radius, Vec3 z); + static int _W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + PbClass *obj = Pb::objFromPy(_self); + if (obj) + delete obj; + try { + PbArgs _args(_linargs, _kwds); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(0, "Cylinder::Cylinder", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + Vec3 center = _args.get<Vec3>("center", 1, &_lock); + Real radius = _args.get<Real>("radius", 2, &_lock); + Vec3 z = _args.get<Vec3>("z", 3, &_lock); + obj = new Cylinder(parent, center, radius, z); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "Cylinder::Cylinder", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("Cylinder::Cylinder", e.what()); + return -1; + } + } + + void setRadius(Real r) + { + mRadius = r; + } + static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Real r = _args.get<Real>("r", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->setRadius(r); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Cylinder::setRadius", e.what()); + return 0; + } + } + + void setZ(Vec3 z) + { + mZDir = z; + mZ = normalize(mZDir); + } + static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Vec3 z = _args.get<Vec3>("z", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->setZ(z); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Cylinder::setZ", e.what()); + return 0; + } + } + + virtual void setCenter(const Vec3 ¢er) + { + mCenter = center; + } + virtual Vec3 getCenter() const + { + return mCenter; + } + inline Real getRadius() const + { + return mRadius; + } + inline Vec3 getZ() const + { + return mZ * mZDir; + } + virtual Vec3 getExtent() const + { + return Vec3(2.0 * sqrt(square(mZ) + square(mRadius))); + } + virtual bool isInside(const Vec3 &pos) const; + virtual void generateMesh(Mesh *mesh); + virtual void generateLevelset(Grid<Real> &phi); + + protected: + Vec3 mCenter, mZDir; + Real mRadius, mZ; + public: + PbArgs _args; +} +#define _C_Cylinder +; + +//! Slope shape +// generates a levelset based on a plane +// plane is specified by two angles and an offset on the y axis in (offset vector would be ( 0, +// offset, 0) ) the two angles are specified in degrees, between: y-axis and x-axis +// y-axis and z-axis +class Slope : public Shape { + public: + Slope(FluidSolver *parent, Real anglexy, Real angleyz, Real origin, Vec3 gs); + static int _W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + PbClass *obj = Pb::objFromPy(_self); + if (obj) + delete obj; + try { + PbArgs _args(_linargs, _kwds); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(0, "Slope::Slope", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + Real anglexy = _args.get<Real>("anglexy", 1, &_lock); + Real angleyz = _args.get<Real>("angleyz", 2, &_lock); + Real origin = _args.get<Real>("origin", 3, &_lock); + Vec3 gs = _args.get<Vec3>("gs", 4, &_lock); + obj = new Slope(parent, anglexy, angleyz, origin, gs); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "Slope::Slope", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("Slope::Slope", e.what()); + return -1; + } + } + + virtual void setOrigin(const Real &origin) + { + mOrigin = origin; + } + virtual void setAnglexy(const Real &anglexy) + { + mAnglexy = anglexy; + } + virtual void setAngleyz(const Real &angleyz) + { + mAnglexy = angleyz; + } + + inline Real getOrigin() const + { + return mOrigin; + } + inline Real getmAnglexy() const + { + return mAnglexy; + } + inline Real getmAngleyz() const + { + return mAngleyz; + } + virtual bool isInside(const Vec3 &pos) const; + virtual void generateMesh(Mesh *mesh); + virtual void generateLevelset(Grid<Real> &phi); + + protected: + Real mAnglexy, mAngleyz; + Real mOrigin; + Vec3 mGs; + public: + PbArgs _args; +} +#define _C_Slope +; + +} // namespace Manta +#endif |