Ejemplos de Handle_Geom_Plane::Pln en C++ (Cpp)

Ejemplo n.º 1

Archivo: GeometryCurvePyImp.cpp Proyecto: 3DPrinterGuy/FreeCAD

PyObject* GeometryCurvePy::intersect2d(PyObject *args)
{
    PyObject *c,*p;
    if (!PyArg_ParseTuple(args, "O!O!", &(Part::GeometryCurvePy::Type), &c,
                                        &(Part::PlanePy::Type), &p))
        return 0;

    try {
        Handle_Geom_Curve self = Handle_Geom_Curve::DownCast(getGeometryPtr()->handle());
        Handle_Geom_Curve curv = Handle_Geom_Curve::DownCast(static_cast<GeometryPy*>(c)->
            getGeometryPtr()->handle());
        Handle_Geom_Plane plane = Handle_Geom_Plane::DownCast(static_cast<GeometryPy*>(p)->
            getGeometryPtr()->handle());

        Handle_Geom2d_Curve curv1 = GeomAPI::To2d(self, plane->Pln());
        Handle_Geom2d_Curve curv2 = GeomAPI::To2d(curv, plane->Pln());
        Geom2dAPI_InterCurveCurve intCC(curv1, curv2);
        int nbPoints = intCC.NbPoints();
        Py::List list;
        for (int i=1; i<= nbPoints; i++) {
            gp_Pnt2d pt = intCC.Point(i);
            Py::Tuple tuple(2);
            tuple.setItem(0, Py::Float(pt.X()));
            tuple.setItem(1, Py::Float(pt.Y()));
            list.append(tuple);
        }
        return Py::new_reference_to(list);
    }
    catch (Standard_Failure) {
        Handle_Standard_Failure e = Standard_Failure::Caught();
        PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
        return 0;
    }
}

Ejemplo n.º 2

Archivo: PlanePyImp.cpp Proyecto: abdullahtahiriyo/FreeCAD_sf_master

// constructor method
int PlanePy::PyInit(PyObject* args, PyObject* kwds)
{
    // plane and distance for offset
    PyObject *pPlane;
    double dist;
    static char* keywords_pd[] = {"Plane","Distance",NULL};
    if (PyArg_ParseTupleAndKeywords(args, kwds, "O!d", keywords_pd, &(PlanePy::Type), &pPlane, &dist)) {
        PlanePy* pcPlane = static_cast<PlanePy*>(pPlane);
        Handle_Geom_Plane plane = Handle_Geom_Plane::DownCast
            (pcPlane->getGeometryPtr()->handle());
        GC_MakePlane mc(plane->Pln(), dist);
        if (!mc.IsDone()) {
            PyErr_SetString(PartExceptionOCCError, gce_ErrorStatusText(mc.Status()));
            return -1;
        }

        Handle_Geom_Plane plan = Handle_Geom_Plane::DownCast(getGeometryPtr()->handle());
        plan->SetPln(mc.Value()->Pln());
        return 0;
    }

    // plane from equation
    double a,b,c,d;
    static char* keywords_abcd[] = {"A","B","C","D",NULL};
    PyErr_Clear();
    if (PyArg_ParseTupleAndKeywords(args, kwds, "dddd", keywords_abcd,
                                        &a,&b,&c,&d)) {
        GC_MakePlane mc(a,b,c,d);
        if (!mc.IsDone()) {
            PyErr_SetString(PartExceptionOCCError, gce_ErrorStatusText(mc.Status()));
            return -1;
        }

        Handle_Geom_Plane plane = Handle_Geom_Plane::DownCast(getGeometryPtr()->handle());
        plane->SetPln(mc.Value()->Pln());
        return 0;
    }

    PyObject *pV1, *pV2, *pV3;
    static char* keywords_ppp[] = {"Point1","Point2","Point3",NULL};
    PyErr_Clear();
    if (PyArg_ParseTupleAndKeywords(args, kwds, "O!O!O!", keywords_ppp,
                                         &(Base::VectorPy::Type), &pV1,
                                         &(Base::VectorPy::Type), &pV2,
                                         &(Base::VectorPy::Type), &pV3)) {
        Base::Vector3d v1 = static_cast<Base::VectorPy*>(pV1)->value();
        Base::Vector3d v2 = static_cast<Base::VectorPy*>(pV2)->value();
        Base::Vector3d v3 = static_cast<Base::VectorPy*>(pV3)->value();
        GC_MakePlane mc(gp_Pnt(v1.x,v1.y,v1.z),
                        gp_Pnt(v2.x,v2.y,v2.z),
                        gp_Pnt(v3.x,v3.y,v3.z));
        if (!mc.IsDone()) {
            PyErr_SetString(PartExceptionOCCError, gce_ErrorStatusText(mc.Status()));
            return -1;
        }

        Handle_Geom_Plane plane = Handle_Geom_Plane::DownCast(getGeometryPtr()->handle());
        plane->SetPln(mc.Value()->Pln());
        return 0;
    }

    // location and normal
    static char* keywords_cnr[] = {"Location","Normal",NULL};
    PyErr_Clear();
    if (PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", keywords_cnr,
                                        &(Base::VectorPy::Type), &pV1,
                                        &(Base::VectorPy::Type), &pV2)) {
        Base::Vector3d v1 = static_cast<Base::VectorPy*>(pV1)->value();
        Base::Vector3d v2 = static_cast<Base::VectorPy*>(pV2)->value();
        GC_MakePlane mc(gp_Pnt(v1.x,v1.y,v1.z),
                        gp_Dir(v2.x,v2.y,v2.z));
        if (!mc.IsDone()) {
            PyErr_SetString(PartExceptionOCCError, gce_ErrorStatusText(mc.Status()));
            return -1;
        }

        Handle_Geom_Plane plane = Handle_Geom_Plane::DownCast(getGeometryPtr()->handle());
        plane->SetPln(mc.Value()->Pln());
        return 0;
    }

    static char* keywords_p[] = {"Plane",NULL};
    PyErr_Clear();
    if (PyArg_ParseTupleAndKeywords(args, kwds, "O!", keywords_p, &(PlanePy::Type), &pPlane)) {
        PlanePy* pcPlane = static_cast<PlanePy*>(pPlane);
        Handle_Geom_Plane plane1 = Handle_Geom_Plane::DownCast
            (pcPlane->getGeometryPtr()->handle());
        Handle_Geom_Plane plane2 = Handle_Geom_Plane::DownCast
            (this->getGeometryPtr()->handle());
        plane2->SetPln(plane1->Pln());
        return 0;
    }

    static char* keywords_n[] = {NULL};
    PyErr_Clear();
    if (PyArg_ParseTupleAndKeywords(args, kwds, "", keywords_n)) {
        // do nothing
        return 0;
    }

    PyErr_SetString(PyExc_TypeError, "Plane constructor accepts:\n"
        "-- empty parameter list\n"
        "-- Plane\n"
        "-- Plane, Distance\n"
        "-- Location, Normal\n"
        "-- Point1, Point2, Point3\n"
        "-- A, B, C, D\n"
        "   (as equation: Ax + By + Cz + D = 0.0)");
    return -1;
}