PyObject* GeometrySurfacePy::intersect(PyObject *args)
{
Handle_Geom_Surface surf = Handle_Geom_Surface::DownCast(getGeometryPtr()->handle());
try {
if (!surf.IsNull()) {
PyObject *p;
double prec = Precision::Confusion();
try {
if (PyArg_ParseTuple(args, "O!|d", &(Part::GeometrySurfacePy::Type), &p, &prec))
return intersectSS(args);
} catch(...) {};
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!|d", &(Part::GeometryCurvePy::Type), &p, &prec)) {
GeometryCurvePy* curve = static_cast<GeometryCurvePy*>(p);
PyObject* t = PyTuple_New(2);
PyTuple_SetItem(t, 0, this);
PyTuple_SetItem(t, 1, PyFloat_FromDouble(prec));
return curve->intersectCS(t);
} else {
return 0;
}
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
PyErr_SetString(PyExc_Exception, "intersect(): Geometry is not a surface");
return 0;
}
PyObject* GeometrySurfacePy::tangent(PyObject *args)
{
Handle_Geom_Geometry g = getGeometryPtr()->handle();
Handle_Geom_Surface s = Handle_Geom_Surface::DownCast(g);
try {
if (!s.IsNull()) {
double u,v;
if (!PyArg_ParseTuple(args, "dd", &u,&v))
return 0;
gp_Dir dir;
Py::Tuple tuple(2);
GeomLProp_SLProps prop(s,u,v,1,Precision::Confusion());
if (prop.IsTangentUDefined()) {
prop.TangentU(dir);
tuple.setItem(0, Py::Vector(Base::Vector3d(dir.X(),dir.Y(),dir.Z())));
}
if (prop.IsTangentVDefined()) {
prop.TangentV(dir);
tuple.setItem(1, Py::Vector(Base::Vector3d(dir.X(),dir.Y(),dir.Z())));
}
return Py::new_reference_to(tuple);
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return 0;
}
PyErr_SetString(PartExceptionOCCError, "Geometry is not a surface");
return 0;
}
PyObject* GeometrySurfacePy::parameter(PyObject *args)
{
Handle_Geom_Surface surf = Handle_Geom_Surface
::DownCast(getGeometryPtr()->handle());
try {
if (!surf.IsNull()) {
PyObject *p;
double prec = Precision::Confusion();
if (!PyArg_ParseTuple(args, "O!|d", &(Base::VectorPy::Type), &p, &prec))
return 0;
Base::Vector3d v = Py::Vector(p, false).toVector();
gp_Pnt pnt(v.x,v.y,v.z);
ShapeAnalysis_Surface as(surf);
gp_Pnt2d uv = as.ValueOfUV(pnt, prec);
Py::Tuple tuple(2);
tuple.setItem(0, Py::Float(uv.X()));
tuple.setItem(1, Py::Float(uv.Y()));
return Py::new_reference_to(tuple);
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return 0;
}
PyErr_SetString(PartExceptionOCCError, "Geometry is not a surface");
return 0;
}
PyObject* GeometrySurfacePy::toShape(PyObject *args)
{
Handle_Geom_Geometry g = getGeometryPtr()->handle();
Handle_Geom_Surface s = Handle_Geom_Surface::DownCast(g);
try {
if (!s.IsNull()) {
double u1,u2,v1,v2;
s->Bounds(u1,u2,v1,v2);
if (!PyArg_ParseTuple(args, "|dddd", &u1,&u2,&v1,&v2))
return 0;
BRepBuilderAPI_MakeFace mkBuilder(s, u1, u2, v1, v2
#if OCC_VERSION_HEX >= 0x060502
, Precision::Confusion()
#endif
);
TopoDS_Shape sh = mkBuilder.Shape();
return new TopoShapeFacePy(new TopoShape(sh));
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return 0;
}
PyErr_SetString(PartExceptionOCCError, "Geometry is not a surface");
return 0;
}
static Handle(Geom_Plane) getGeomPlane(const TopoDS_Face &faceIn)
{
Handle_Geom_Plane planeSurfaceOut;
Handle_Geom_Surface surface = BRep_Tool::Surface(faceIn);
if (!surface.IsNull())
{
planeSurfaceOut = Handle(Geom_Plane)::DownCast(surface);
if (planeSurfaceOut.IsNull())
{
Handle_Geom_RectangularTrimmedSurface trimmedSurface = Handle(Geom_RectangularTrimmedSurface)::DownCast(surface);
if (!trimmedSurface.IsNull())
planeSurfaceOut = Handle(Geom_Plane)::DownCast(trimmedSurface->BasisSurface());
}
}
return planeSurfaceOut;
}
PyObject* GeometryCurvePy::makeRuledSurface(PyObject *args)
{
PyObject* curve;
if (!PyArg_ParseTuple(args, "O!", &(Part::GeometryCurvePy::Type), &curve))
return 0;
try {
Handle_Geom_Curve aCrv1 = Handle_Geom_Curve::DownCast(getGeometryPtr()->handle());
GeometryCurvePy* c = static_cast<GeometryCurvePy*>(curve);
Handle_Geom_Curve aCrv2 = Handle_Geom_Curve::DownCast(c->getGeometryPtr()->handle());
Handle_Geom_Surface aSurf = GeomFill::Surface (aCrv1, aCrv2);
if (aSurf.IsNull()) {
PyErr_SetString(PartExceptionOCCError, "Failed to create ruled surface");
return 0;
}
// check the result surface type
if (aSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
Handle_Geom_RectangularTrimmedSurface aTSurf =
Handle_Geom_RectangularTrimmedSurface::DownCast(aSurf);
return new RectangularTrimmedSurfacePy(new GeomTrimmedSurface(aTSurf));
}
else if (aSurf->IsKind(STANDARD_TYPE(Geom_BSplineSurface))) {
Handle_Geom_BSplineSurface aBSurf =
Handle_Geom_BSplineSurface::DownCast(aSurf);
return new BSplineSurfacePy(new GeomBSplineSurface(aBSurf));
}
else {
PyErr_Format(PyExc_NotImplementedError, "Ruled surface is of type '%s'",
aSurf->DynamicType()->Name());
return 0;
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return 0;
}
PyErr_SetString(PartExceptionOCCError, "Geometry is not a curve");
return 0;
}
PyObject* GeometrySurfacePy::value(PyObject *args)
{
Handle_Geom_Geometry g = getGeometryPtr()->handle();
Handle_Geom_Surface s = Handle_Geom_Surface::DownCast(g);
try {
if (!s.IsNull()) {
double u,v;
if (!PyArg_ParseTuple(args, "dd", &u,&v))
return 0;
gp_Pnt p = s->Value(u,v);
return new Base::VectorPy(Base::Vector3d(p.X(),p.Y(),p.Z()));
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return 0;
}
PyErr_SetString(PartExceptionOCCError, "Geometry is not a surface");
return 0;
}
// constructor method
int TopoShapeFacePy::PyInit(PyObject* args, PyObject* /*kwd*/)
{
PyObject *pW;
if (PyArg_ParseTuple(args, "O!", &(Part::TopoShapePy::Type), &pW)) {
try {
const TopoDS_Shape& sh = static_cast<Part::TopoShapePy*>(pW)->getTopoShapePtr()->getShape();
if (sh.IsNull()) {
PyErr_SetString(PartExceptionOCCError, "cannot create face out of empty wire");
return -1;
}
if (sh.ShapeType() == TopAbs_WIRE) {
BRepBuilderAPI_MakeFace mkFace(TopoDS::Wire(sh));
if (!mkFace.IsDone()) {
PyErr_SetString(PartExceptionOCCError, "Failed to create face from wire");
return -1;
}
getTopoShapePtr()->setShape(mkFace.Face());
return 0;
}
else if (sh.ShapeType() == TopAbs_FACE) {
getTopoShapePtr()->setShape(sh);
return 0;
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return -1;
}
}
PyErr_Clear();
PyObject *surf, *bound=0;
if (PyArg_ParseTuple(args, "O!|O!", &(GeometryPy::Type), &surf, &(PyList_Type), &bound)) {
try {
Handle_Geom_Surface S = Handle_Geom_Surface::DownCast
(static_cast<GeometryPy*>(surf)->getGeometryPtr()->handle());
if (S.IsNull()) {
PyErr_SetString(PyExc_TypeError, "geometry is not a valid surface");
return -1;
}
BRepBuilderAPI_MakeFace mkFace(S
#if OCC_VERSION_HEX >= 0x060502
, Precision::Confusion()
#endif
);
if (bound) {
Py::List list(bound);
for (Py::List::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(Part::TopoShapePy::Type))) {
const TopoDS_Shape& sh = static_cast<Part::TopoShapePy*>(item)->getTopoShapePtr()->getShape();
if (sh.ShapeType() == TopAbs_WIRE)
mkFace.Add(TopoDS::Wire(sh));
else {
PyErr_SetString(PyExc_TypeError, "shape is not a wire");
return -1;
}
}
else {
PyErr_SetString(PyExc_TypeError, "item is not a shape");
return -1;
}
}
}
getTopoShapePtr()->setShape(mkFace.Face());
return 0;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return -1;
}
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!", &(PyList_Type), &bound)) {
try {
std::vector<TopoDS_Wire> wires;
Py::List list(bound);
for (Py::List::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(Part::TopoShapePy::Type))) {
const TopoDS_Shape& sh = static_cast<Part::TopoShapePy*>(item)->getTopoShapePtr()->getShape();
if (sh.ShapeType() == TopAbs_WIRE)
wires.push_back(TopoDS::Wire(sh));
else
Standard_Failure::Raise("shape is not a wire");
}
else
Standard_Failure::Raise("shape is not a wire");
}
if (!wires.empty()) {
BRepBuilderAPI_MakeFace mkFace(wires.front());
if (!mkFace.IsDone()) {
switch (mkFace.Error()) {
case BRepBuilderAPI_NoFace:
Standard_Failure::Raise("No face");
break;
case BRepBuilderAPI_NotPlanar:
Standard_Failure::Raise("Not planar");
break;
case BRepBuilderAPI_CurveProjectionFailed:
Standard_Failure::Raise("Curve projection failed");
break;
case BRepBuilderAPI_ParametersOutOfRange:
Standard_Failure::Raise("Parameters out of range");
break;
#if OCC_VERSION_HEX < 0x060500
case BRepBuilderAPI_SurfaceNotC2:
Standard_Failure::Raise("Surface not C2");
break;
#endif
default:
Standard_Failure::Raise("Unknown failure");
break;
}
}
for (std::vector<TopoDS_Wire>::iterator it = wires.begin()+1; it != wires.end(); ++it)
mkFace.Add(*it);
getTopoShapePtr()->setShape(mkFace.Face());
return 0;
}
else {
Standard_Failure::Raise("no wires in list");
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return -1;
}
}
char* className = 0;
PyObject* pcPyShapeOrList = nullptr;
PyErr_Clear();
if (PyArg_ParseTuple(args, "Os", &pcPyShapeOrList, &className)) {
try {
std::unique_ptr<FaceMaker> fm = Part::FaceMaker::ConstructFromType(className);
//dump all supplied shapes to facemaker, no matter what type (let facemaker decide).
if (PySequence_Check(pcPyShapeOrList)){
Py::Sequence list(pcPyShapeOrList);
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(Part::TopoShapePy::Type))) {
const TopoDS_Shape& sh = static_cast<Part::TopoShapePy*>(item)->getTopoShapePtr()->getShape();
fm->addShape(sh);
} else {
PyErr_SetString(PyExc_TypeError, "Object is not a shape.");
return -1;
}
}
} else if (PyObject_TypeCheck(pcPyShapeOrList, &(Part::TopoShapePy::Type))) {
const TopoDS_Shape& sh = static_cast<Part::TopoShapePy*>(pcPyShapeOrList)->getTopoShapePtr()->getShape();
if (sh.IsNull())
throw Base::Exception("Shape is null!");
if (sh.ShapeType() == TopAbs_COMPOUND)
fm->useCompound(TopoDS::Compound(sh));
else
fm->addShape(sh);
} else {
PyErr_SetString(PyExc_TypeError, "First argument is neither a shape nor list of shapes.");
return -1;
}
fm->Build();
getTopoShapePtr()->setShape(fm->Face());
return 0;
} catch (Base::Exception &e){
PyErr_SetString(Base::BaseExceptionFreeCADError, e.what());
return -1;
} catch (Standard_Failure){
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return -1;
}
}
PyErr_SetString(PartExceptionOCCError,
"Argument list signature is incorrect.\n\nSupported signatures:\n"
"(face)\n"
"(wire)\n"
"(list_of_wires)\n"
"(wire, facemaker_class_name)\n"
"(list_of_wires, facemaker_class_name)\n"
"(surface, list_of_wires)\n"
);
return -1;
}
// constructor method
int TopoShapeFacePy::PyInit(PyObject* args, PyObject* /*kwd*/)
{
PyObject *pW;
if (PyArg_ParseTuple(args, "O!", &(Part::TopoShapePy::Type), &pW)) {
try {
const TopoDS_Shape& sh = static_cast<Part::TopoShapePy*>(pW)->getTopoShapePtr()->_Shape;
if (sh.IsNull()) {
PyErr_SetString(PartExceptionOCCError, "cannot create face out of empty wire");
return -1;
}
if (sh.ShapeType() == TopAbs_WIRE) {
BRepBuilderAPI_MakeFace mkFace(TopoDS::Wire(sh));
if (!mkFace.IsDone()) {
PyErr_SetString(PartExceptionOCCError, "Failed to create face from wire");
return -1;
}
getTopoShapePtr()->_Shape = mkFace.Face();
return 0;
}
else if (sh.ShapeType() == TopAbs_FACE) {
getTopoShapePtr()->_Shape = sh;
return 0;
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return -1;
}
}
PyErr_Clear();
PyObject *surf, *bound=0;
if (PyArg_ParseTuple(args, "O!|O!", &(GeometryPy::Type), &surf, &(PyList_Type), &bound)) {
try {
Handle_Geom_Surface S = Handle_Geom_Surface::DownCast
(static_cast<GeometryPy*>(surf)->getGeometryPtr()->handle());
if (S.IsNull()) {
PyErr_SetString(PyExc_TypeError, "geometry is not a valid surface");
return -1;
}
BRepBuilderAPI_MakeFace mkFace(S
#if OCC_VERSION_HEX >= 0x060502
, Precision::Confusion()
#endif
);
if (bound) {
Py::List list(bound);
for (Py::List::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(Part::TopoShapePy::Type))) {
const TopoDS_Shape& sh = static_cast<Part::TopoShapePy*>(item)->getTopoShapePtr()->_Shape;
if (sh.ShapeType() == TopAbs_WIRE)
mkFace.Add(TopoDS::Wire(sh));
else {
PyErr_SetString(PyExc_TypeError, "shape is not a wire");
return -1;
}
}
else {
PyErr_SetString(PyExc_TypeError, "item is not a shape");
return -1;
}
}
}
getTopoShapePtr()->_Shape = mkFace.Face();
return 0;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return -1;
}
}
PyErr_Clear();
if (PyArg_ParseTuple(args, "O!", &(PyList_Type), &bound)) {
try {
std::vector<TopoDS_Wire> wires;
Py::List list(bound);
for (Py::List::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(Part::TopoShapePy::Type))) {
const TopoDS_Shape& sh = static_cast<Part::TopoShapePy*>(item)->getTopoShapePtr()->_Shape;
if (sh.ShapeType() == TopAbs_WIRE)
wires.push_back(TopoDS::Wire(sh));
else
Standard_Failure::Raise("shape is not a wire");
}
else
Standard_Failure::Raise("shape is not a wire");
}
if (!wires.empty()) {
BRepBuilderAPI_MakeFace mkFace(wires.front());
if (!mkFace.IsDone()) {
switch (mkFace.Error()) {
case BRepBuilderAPI_NoFace:
Standard_Failure::Raise("No face");
break;
case BRepBuilderAPI_NotPlanar:
Standard_Failure::Raise("Not planar");
break;
case BRepBuilderAPI_CurveProjectionFailed:
Standard_Failure::Raise("Curve projection failed");
break;
case BRepBuilderAPI_ParametersOutOfRange:
Standard_Failure::Raise("Parameters out of range");
break;
#if OCC_VERSION_HEX < 0x060500
case BRepBuilderAPI_SurfaceNotC2:
Standard_Failure::Raise("Surface not C2");
break;
#endif
default:
Standard_Failure::Raise("Unknown failure");
break;
}
}
for (std::vector<TopoDS_Wire>::iterator it = wires.begin()+1; it != wires.end(); ++it)
mkFace.Add(*it);
getTopoShapePtr()->_Shape = mkFace.Face();
return 0;
}
else {
Standard_Failure::Raise("no wires in list");
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return -1;
}
}
PyErr_SetString(PartExceptionOCCError, "wire or list of wires expected");
return -1;
}
// constructor method
int PlateSurfacePy::PyInit(PyObject* args, PyObject* kwds)
{
static char* kwds_Parameter[] = {"Surface","Points","Curves","Degree",
"NbPtsOnCur","NbIter","Tol2d","Tol3d","TolAng","TolCurv","Anisotropie",NULL};
PyObject* surface = 0;
PyObject* points = 0;
PyObject* curves = 0;
int Degree = 3;
int NbPtsOnCur = 10;
int NbIter = 3;
double Tol2d = 0.00001;
double Tol3d = 0.0001;
double TolAng = 0.01;
double TolCurv = 0.1;
PyObject* Anisotropie = Py_False;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O!OOiiiddddO!", kwds_Parameter,
&(GeometryPy::Type), &surface, &points, &curves,
&Degree, &NbPtsOnCur, &NbIter, &Tol2d, &Tol3d, &TolAng, &TolCurv,
&PyBool_Type,&Anisotropie))
return -1;
if (!surface && !points && !curves) {
PyErr_SetString(PyExc_ValueError, "set points or curves as constraints");
return -1;
}
Handle_Geom_Surface surf;
if (surface) {
GeometryPy* pcGeo = static_cast<GeometryPy*>(surface);
surf = Handle_Geom_Surface::DownCast
(pcGeo->getGeometryPtr()->handle());
if (surf.IsNull()) {
PyErr_SetString(PyExc_TypeError, "geometry is not a surface");
return -1;
}
}
try {
GeomPlate_BuildPlateSurface buildPlate(Degree, NbPtsOnCur, NbIter, Tol2d, Tol3d, TolAng, TolCurv,
PyObject_IsTrue(Anisotropie) ? Standard_True : Standard_False);
if (!surf.IsNull()) {
buildPlate.LoadInitSurface(surf);
if (!points && !curves) {
Standard_Real U1,U2,V1,V2;
surf->Bounds(U1,U2,V1,V2);
buildPlate.Add(new GeomPlate_PointConstraint(surf->Value(U1,V1),0));
buildPlate.Add(new GeomPlate_PointConstraint(surf->Value(U1,V2),0));
buildPlate.Add(new GeomPlate_PointConstraint(surf->Value(U2,V1),0));
buildPlate.Add(new GeomPlate_PointConstraint(surf->Value(U2,V2),0));
}
}
if (points) {
Py::Sequence list(points);
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
Base::Vector3d vec = Py::Vector(*it).toVector();
Handle(GeomPlate_PointConstraint) PCont = new GeomPlate_PointConstraint(gp_Pnt(vec.x,vec.y,vec.z),0);
buildPlate.Add(PCont);
}
}
if (curves) {
Py::Sequence list(curves);
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
//TODO
}
}
buildPlate.Perform();
getGeomPlateSurfacePtr()->setHandle(buildPlate.Surface());
return 0;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
return -1;
}
}