# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

"""
GCE2d module, see official documentation at
https://www.opencascade.com/doc/occt-7.4.0/refman/html/package_gce2d.html
"""

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _GCE2d
else:
    import _GCE2d

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _GCE2d.delete_SwigPyIterator

    def value(self) -> "PyObject *":
        return _GCE2d.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _GCE2d.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _GCE2d.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        return _GCE2d.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        return _GCE2d.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        return _GCE2d.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        return _GCE2d.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        return _GCE2d.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        return _GCE2d.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _GCE2d.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        return _GCE2d.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        return _GCE2d.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _GCE2d.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _GCE2d.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _GCE2d.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        return _GCE2d.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _GCE2d:
_GCE2d.SwigPyIterator_swigregister(SwigPyIterator)


def _dumps_object(klass):
    """ Overwrite default string output for any wrapped object.
    By default, __repr__ method returns something like:
    <OCC.Core.TopoDS.TopoDS_Shape; proxy of <Swig Object of type 'TopoDS_Shape *' at 0x02BB0758> >
    This is too much verbose.
    We prefer :
    <class 'gp_Pnt'>
    or
    <class 'TopoDS_Shape'>
    """
    klass_name = str(klass.__class__).split(".")[3].split("'")[0]
    repr_string = "<class '" + klass_name + "'"
# for TopoDS_Shape, we also look for the base type
    if klass_name == "TopoDS_Shape":
        if klass.IsNull():
            repr_string += ": Null>"
            return repr_string
        st = klass.ShapeType()
        types = {OCC.Core.TopAbs.TopAbs_VERTEX: "Vertex",
                 OCC.Core.TopAbs.TopAbs_SOLID: "Solid",
                 OCC.Core.TopAbs.TopAbs_EDGE: "Edge",
                 OCC.Core.TopAbs.TopAbs_FACE: "Face",
                 OCC.Core.TopAbs.TopAbs_SHELL: "Shell",
                 OCC.Core.TopAbs.TopAbs_WIRE: "Wire",
                 OCC.Core.TopAbs.TopAbs_COMPOUND: "Compound",
                 OCC.Core.TopAbs.TopAbs_COMPSOLID: "Compsolid"}
        repr_string += "; Type:%s" % types[st]        
    elif hasattr(klass, "IsNull"):
        if klass.IsNull():
            repr_string += "; Null"
    repr_string += ">"
    return repr_string


def process_exception(error: "Standard_Failure", method_name: "std::string", class_name: "std::string") -> "void":
    return _GCE2d.process_exception(error, method_name, class_name)

from six import with_metaclass
import warnings
from OCC.Wrapper.wrapper_utils import Proxy, deprecated

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.gp
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.Geom2d
import OCC.Core.GeomAbs
import OCC.Core.TColgp
import OCC.Core.gce

from enum import IntEnum
from OCC.Core.Exception import *



class GCE2d_MakeMirror(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        Point: gp_Pnt2d

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        Axis: gp_Ax2d

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        Line: gp_Lin2d

        Returns
        -------
        None
        Make a symetry transformation af axis defined by <point> and <direc>.

        Parameters
        ----------
        Point: gp_Pnt2d
        Direc: gp_Dir2d

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeMirror_swiginit(self, _GCE2d.new_GCE2d_MakeMirror(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Transformation > const &":
        r"""
        Returns the constructed transformation.

        Returns
        -------
        opencascade::handle<Geom2d_Transformation>

        """
        return _GCE2d.GCE2d_MakeMirror_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeMirror

# Register GCE2d_MakeMirror in _GCE2d:
_GCE2d.GCE2d_MakeMirror_swigregister(GCE2d_MakeMirror)

class GCE2d_MakeRotation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Constructs a rotation through angle angle about the center point.

        Parameters
        ----------
        Point: gp_Pnt2d
        Angle: float

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeRotation_swiginit(self, _GCE2d.new_GCE2d_MakeRotation(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Transformation > const &":
        r"""
        Returns the constructed transformation.

        Returns
        -------
        opencascade::handle<Geom2d_Transformation>

        """
        return _GCE2d.GCE2d_MakeRotation_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeRotation

# Register GCE2d_MakeRotation in _GCE2d:
_GCE2d.GCE2d_MakeRotation_swigregister(GCE2d_MakeRotation)

class GCE2d_MakeScale(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Constructs a scaling transformation with - point as the center of the transformation, and - scale as the scale factor.

        Parameters
        ----------
        Point: gp_Pnt2d
        Scale: float

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeScale_swiginit(self, _GCE2d.new_GCE2d_MakeScale(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Transformation > const &":
        r"""
        Returns the constructed transformation.

        Returns
        -------
        opencascade::handle<Geom2d_Transformation>

        """
        return _GCE2d.GCE2d_MakeScale_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeScale

# Register GCE2d_MakeScale in _GCE2d:
_GCE2d.GCE2d_MakeScale_swigregister(GCE2d_MakeScale)

class GCE2d_MakeTranslation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Constructs a translation along the vector vect.

        Parameters
        ----------
        Vect: gp_Vec2d

        Returns
        -------
        None
        Constructs a translation along the vector (point1,point2) defined from the point point1 to the point point2.

        Parameters
        ----------
        Point1: gp_Pnt2d
        Point2: gp_Pnt2d

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeTranslation_swiginit(self, _GCE2d.new_GCE2d_MakeTranslation(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Transformation > const &":
        r"""
        Returns the constructed transformation.

        Returns
        -------
        opencascade::handle<Geom2d_Transformation>

        """
        return _GCE2d.GCE2d_MakeTranslation_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeTranslation

# Register GCE2d_MakeTranslation in _GCE2d:
_GCE2d.GCE2d_MakeTranslation_swigregister(GCE2d_MakeTranslation)

class GCE2d_Root(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the construction is successful.

        Returns
        -------
        bool

        """
        return _GCE2d.GCE2d_Root_IsDone(self, *args)

    def Status(self, *args) -> "gce_ErrorType":
        r"""
        Returns the status of the construction - gce_done, if the construction is successful, or - another value of the gce_errortype enumeration indicating why the construction failed.

        Returns
        -------
        gce_ErrorType

        """
        return _GCE2d.GCE2d_Root_Status(self, *args)

    __repr__ = _dumps_object


    def __init__(self):
        _GCE2d.GCE2d_Root_swiginit(self, _GCE2d.new_GCE2d_Root())
    __swig_destroy__ = _GCE2d.delete_GCE2d_Root

# Register GCE2d_Root in _GCE2d:
_GCE2d.GCE2d_Root_swigregister(GCE2d_Root)

class GCE2d_MakeArcOfCircle(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Makes an arc of circle (trimmedcurve from geom2d) from a circle between two parameters alpha1 and alpha2. the two parameters are angles. the parameters are in radians.

        Parameters
        ----------
        Circ: gp_Circ2d
        Alpha1: float
        Alpha2: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Makes an arc of circle (trimmedcurve from geom2d) from a circle between point <p> and the parameter alpha. alpha is given in radians.

        Parameters
        ----------
        Circ: gp_Circ2d
        P: gp_Pnt2d
        Alpha: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Makes an arc of circle (trimmedcurve from geom2d) from a circle between two points p1 and p2.

        Parameters
        ----------
        Circ: gp_Circ2d
        P1: gp_Pnt2d
        P2: gp_Pnt2d
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Makes an arc of circle (trimmedcurve from geom2d) from three points p1,p2,p3 between two points p1 and p3, and passing through the point p2.

        Parameters
        ----------
        P1: gp_Pnt2d
        P2: gp_Pnt2d
        P3: gp_Pnt2d

        Returns
        -------
        None
        Makes an arc of circle (trimmedcurve from geom2d) from two points p1,p2 and the tangente to the solution at the point p1.

        Parameters
        ----------
        P1: gp_Pnt2d
        V: gp_Vec2d
        P2: gp_Pnt2d

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeArcOfCircle_swiginit(self, _GCE2d.new_GCE2d_MakeArcOfCircle(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_TrimmedCurve > const &":
        r"""
        Returns the constructed arc of circle. exceptions stdfail_notdone if no arc of circle is constructed.

        Returns
        -------
        opencascade::handle<Geom2d_TrimmedCurve>

        """
        return _GCE2d.GCE2d_MakeArcOfCircle_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeArcOfCircle

# Register GCE2d_MakeArcOfCircle in _GCE2d:
_GCE2d.GCE2d_MakeArcOfCircle_swigregister(GCE2d_MakeArcOfCircle)

class GCE2d_MakeArcOfEllipse(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Make an arc of ellipse (trimmedcurve from geom2d) from a ellipse between two parameters alpha1 and alpha2.

        Parameters
        ----------
        Elips: gp_Elips2d
        Alpha1: float
        Alpha2: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Make an arc of ellipse (trimmedcurve from geom2d) from a ellipse between point <p> and the parameter alpha.

        Parameters
        ----------
        Elips: gp_Elips2d
        P: gp_Pnt2d
        Alpha: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Make an arc of ellipse (trimmedcurve from geom2d) from a ellipse between two points p1 and p2. please, note: the orientation of the arc is: - the trigonometric sense if sense is not defined or is true (default value), or - the opposite sense if sense is false. - alpha1, alpha2 and alpha are angle values, given in radians. - isdone always returns true.

        Parameters
        ----------
        Elips: gp_Elips2d
        P1: gp_Pnt2d
        P2: gp_Pnt2d
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeArcOfEllipse_swiginit(self, _GCE2d.new_GCE2d_MakeArcOfEllipse(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_TrimmedCurve > const &":
        r"""
        Returns the constructed arc of ellipse.

        Returns
        -------
        opencascade::handle<Geom2d_TrimmedCurve>

        """
        return _GCE2d.GCE2d_MakeArcOfEllipse_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeArcOfEllipse

# Register GCE2d_MakeArcOfEllipse in _GCE2d:
_GCE2d.GCE2d_MakeArcOfEllipse_swigregister(GCE2d_MakeArcOfEllipse)

class GCE2d_MakeArcOfHyperbola(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Makes an arc of hyperbola (trimmedcurve from geom2d) from a hyperbola between two parameters alpha1 and alpha2.

        Parameters
        ----------
        Hypr: gp_Hypr2d
        Alpha1: float
        Alpha2: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Makes an arc of hyperbola (trimmedcurve from geom2d) from a hyperbola between point <p> and the parameter alpha.

        Parameters
        ----------
        Hypr: gp_Hypr2d
        P: gp_Pnt2d
        Alpha: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Makes an arc of hyperbola (trimmedcurve from geom2d) from a hyperbola between two points p1 and p2. note: the orientation of the arc of hyperbola is: - the trigonometric sense if sense is not defined or is true (default value), or - the opposite sense if sense is false. - isdone always returns true.

        Parameters
        ----------
        Hypr: gp_Hypr2d
        P1: gp_Pnt2d
        P2: gp_Pnt2d
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeArcOfHyperbola_swiginit(self, _GCE2d.new_GCE2d_MakeArcOfHyperbola(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_TrimmedCurve > const &":
        r"""
        Returns the constructed arc of hyperbola.

        Returns
        -------
        opencascade::handle<Geom2d_TrimmedCurve>

        """
        return _GCE2d.GCE2d_MakeArcOfHyperbola_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeArcOfHyperbola

# Register GCE2d_MakeArcOfHyperbola in _GCE2d:
_GCE2d.GCE2d_MakeArcOfHyperbola_swigregister(GCE2d_MakeArcOfHyperbola)

class GCE2d_MakeArcOfParabola(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Make an arc of parabola (trimmedcurve from geom2d) from a parabola between two parameters alpha1 and alpha2.

        Parameters
        ----------
        Parab: gp_Parab2d
        Alpha1: float
        Alpha2: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Make an arc of parabola (trimmedcurve from geom2d) from a parabola between point <p> and the parameter alpha.

        Parameters
        ----------
        Parab: gp_Parab2d
        P: gp_Pnt2d
        Alpha: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Make an arc of parabola (trimmedcurve from geom2d) from a parabola between two points p1 and p2. please, note: the orientation of the arc of parabola is: - the trigonometric sense if sense is not defined or is true (default value), or - the opposite sense if sense is false. - isdone always returns true.

        Parameters
        ----------
        Parab: gp_Parab2d
        P1: gp_Pnt2d
        P2: gp_Pnt2d
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeArcOfParabola_swiginit(self, _GCE2d.new_GCE2d_MakeArcOfParabola(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_TrimmedCurve > const &":
        r"""
        Returns the constructed arc of parabola.

        Returns
        -------
        opencascade::handle<Geom2d_TrimmedCurve>

        """
        return _GCE2d.GCE2d_MakeArcOfParabola_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeArcOfParabola

# Register GCE2d_MakeArcOfParabola in _GCE2d:
_GCE2d.GCE2d_MakeArcOfParabola_swigregister(GCE2d_MakeArcOfParabola)

class GCE2d_MakeCircle(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates a circle from a non persistent one.

        Parameters
        ----------
        C: gp_Circ2d

        Returns
        -------
        None
        A is the 'xaxis' of the circle which defines the origin of parametrization. it is not forbidden to create a circle with radius = 0.0 the status is 'negativeradius' if radius < 0.

        Parameters
        ----------
        A: gp_Ax2d
        Radius: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        A is the local coordinate system of the circle which defines the origin of parametrization. it is not forbidden to create a circle with radius = 0.0 the status is 'negativeradius' if radius < 0.

        Parameters
        ----------
        A: gp_Ax22d
        Radius: float

        Returns
        -------
        None
        Make a circle from geom2d <thecirc> parallel to another circ <circ> with a distance <dist>. if dist is greater than zero the result is enclosing the circle <circ>, else the result is enclosed by the circle <circ>.

        Parameters
        ----------
        Circ: gp_Circ2d
        Dist: float

        Returns
        -------
        None
        Make a circle from geom2d <thecirc> parallel to another circ <circ> and passing through a pnt <point>.

        Parameters
        ----------
        Circ: gp_Circ2d
        Point: gp_Pnt2d

        Returns
        -------
        None
        Make a circ from gp <thecirc> passing through 3 pnt2d <p1>,<p2>,<p3>.

        Parameters
        ----------
        P1: gp_Pnt2d
        P2: gp_Pnt2d
        P3: gp_Pnt2d

        Returns
        -------
        None
        Make a circ from geom2d <thecirc> by its center an radius.

        Parameters
        ----------
        P: gp_Pnt2d
        Radius: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Makes a circle from geom2d <thecirc> with its center <center> and a point giving the radius. if sense is true the local coordinate system of the solution is direct and non direct in the other case. warning the makecircle class does not prevent the construction of a circle with a null radius. if an error occurs (that is, when isdone returns false), the status function returns: - gce_negativeradius if radius is less than 0.0, or - gce_intersectionerror if points p1, p2 and p3 are collinear and the three are not coincident.

        Parameters
        ----------
        Center: gp_Pnt2d
        Point: gp_Pnt2d
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeCircle_swiginit(self, _GCE2d.new_GCE2d_MakeCircle(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Circle > const &":
        r"""
        Returns the constructed circle. exceptions stdfail_notdone if no circle is constructed.

        Returns
        -------
        opencascade::handle<Geom2d_Circle>

        """
        return _GCE2d.GCE2d_MakeCircle_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeCircle

# Register GCE2d_MakeCircle in _GCE2d:
_GCE2d.GCE2d_MakeCircle_swigregister(GCE2d_MakeCircle)

class GCE2d_MakeEllipse(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates an ellipse from a non persistent one from package gp.

        Parameters
        ----------
        E: gp_Elips2d

        Returns
        -------
        None
        Majoraxis is the local coordinate system of the ellipse. it is the 'xaxis'. the minor axis is the yaxis of the ellipse. sense give the sense of parametrization of the ellipse. it is not forbidden to create an ellipse with majorradius = minorradius. the status is 'invertradius' if majorradius < minorradius or 'negativeradius' if minorradius < 0.

        Parameters
        ----------
        MajorAxis: gp_Ax2d
        MajorRadius: float
        MinorRadius: float
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Axis is the local coordinate system of the ellipse. it is not forbidden to create an ellipse with majorradius = minorradius. the status is 'invertradius' if majorradius < minorradius or 'negativeradius' if minorradius < 0.

        Parameters
        ----------
        Axis: gp_Ax22d
        MajorRadius: float
        MinorRadius: float

        Returns
        -------
        None
        Make an ellipse centered on the point center, where - the major axis of the ellipse is defined by center and s1, - its major radius is the distance between center and s1, and - its minor radius is the distance between s2 and the major axis. the implicit orientation of the ellipse is: - the sense defined by axis or e, - the sense defined by points center, s1 and s2, - the trigonometric sense if sense is not given or is true, or - the opposite sense if sense is false.

        Parameters
        ----------
        S1: gp_Pnt2d
        S2: gp_Pnt2d
        Center: gp_Pnt2d

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeEllipse_swiginit(self, _GCE2d.new_GCE2d_MakeEllipse(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Ellipse > const &":
        r"""
        Returns the constructed ellipse. exceptions stdfail_notdone if no ellipse is constructed.

        Returns
        -------
        opencascade::handle<Geom2d_Ellipse>

        """
        return _GCE2d.GCE2d_MakeEllipse_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeEllipse

# Register GCE2d_MakeEllipse in _GCE2d:
_GCE2d.GCE2d_MakeEllipse_swigregister(GCE2d_MakeEllipse)

class GCE2d_MakeHyperbola(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates an hyperbola from a non persistent one from package gp.

        Parameters
        ----------
        H: gp_Hypr2d

        Returns
        -------
        None
        Majoraxis is the 'xaxis' of the hyperbola. the major radius of the hyperbola is on this 'xaxis' and the minor radius is on the 'yaxis' of the hyperbola. the status is 'negativeradius' if majorradius < 0.0 or if minorradius < 0.0.

        Parameters
        ----------
        MajorAxis: gp_Ax2d
        MajorRadius: float
        MinorRadius: float
        Sense: bool

        Returns
        -------
        None
        Axis is the local coordinate system of the hyperbola. the major radius of the hyperbola is on this 'xaxis' and the minor radius is on the 'yaxis' of the hyperbola. the status is 'negativeradius' if majorradius < 0.0 or if minorradius < 0.0.

        Parameters
        ----------
        Axis: gp_Ax22d
        MajorRadius: float
        MinorRadius: float

        Returns
        -------
        None
        Creates a hyperbol centered on the origin of the coordinate system axis, with major and minor radii majorradius and minorradius, where the major axis is the 'x axis' of axis (axis is the local coordinate system of the hyperbola). the implicit orientation of the ellipse is: - the sense defined by axis or h, - the sense defined by points center, s1 and s2, - the trigonometric sense if sense is not given or is true, or - the opposite sense if sense is false. warning if an error occurs (that is, when isdone returns false), the status function returns: - gce_negativeradius if majorradius or minorradius is less than 0.0, or - gce_invertaxis if the major radius defined by center and s1 is less than the minor radius defined by center, s1 and s2.make an hyperbola with its center and two apexes.

        Parameters
        ----------
        S1: gp_Pnt2d
        S2: gp_Pnt2d
        Center: gp_Pnt2d

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeHyperbola_swiginit(self, _GCE2d.new_GCE2d_MakeHyperbola(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Hyperbola > const &":
        r"""
        Returns the constructed hyperbola. exceptions: stdfail_notdone if no hyperbola is constructed.

        Returns
        -------
        opencascade::handle<Geom2d_Hyperbola>

        """
        return _GCE2d.GCE2d_MakeHyperbola_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeHyperbola

# Register GCE2d_MakeHyperbola in _GCE2d:
_GCE2d.GCE2d_MakeHyperbola_swigregister(GCE2d_MakeHyperbola)

class GCE2d_MakeLine(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates a line located in 2d space with the axis placement a. the location of a is the origin of the line.

        Parameters
        ----------
        A: gp_Ax2d

        Returns
        -------
        None
        Creates a line from a non persistent line from package gp.

        Parameters
        ----------
        L: gp_Lin2d

        Returns
        -------
        None
        P is the origin and v is the direction of the line.

        Parameters
        ----------
        P: gp_Pnt2d
        V: gp_Dir2d

        Returns
        -------
        None
        Make a line from geom2d <thelin> parallel to another lin <lin> and passing through a pnt <point>.

        Parameters
        ----------
        Lin: gp_Lin2d
        Point: gp_Pnt2d

        Returns
        -------
        None
        Make a line from geom2d <thelin> parallel to another lin <lin> at a distance <dist>.

        Parameters
        ----------
        Lin: gp_Lin2d
        Dist: float

        Returns
        -------
        None
        Make a line from geom2d <thelin> passing through 2 pnt <p1>,<p2>. it returns false if <p1> and <p2> are confused. warning if points p1 and p2 coincident (that is, when isdone returns false), the status function returns gce_confusedpoints.

        Parameters
        ----------
        P1: gp_Pnt2d
        P2: gp_Pnt2d

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeLine_swiginit(self, _GCE2d.new_GCE2d_MakeLine(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Line > const &":
        r"""
        Returns the constructed line. exceptions stdfail_notdone if no line is constructed.

        Returns
        -------
        opencascade::handle<Geom2d_Line>

        """
        return _GCE2d.GCE2d_MakeLine_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeLine

# Register GCE2d_MakeLine in _GCE2d:
_GCE2d.GCE2d_MakeLine_swigregister(GCE2d_MakeLine)

class GCE2d_MakeParabola(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates a parabola from a non persistent one.

        Parameters
        ----------
        Prb: gp_Parab2d

        Returns
        -------
        None
        Creates a parabola with its local coordinate system and it's focal length 'focal'. the 'location' point of 'axis' is the vertex of the parabola status is 'negativefocuslength' if focal < 0.0.

        Parameters
        ----------
        Axis: gp_Ax22d
        Focal: float

        Returns
        -------
        None
        Creates a parabola with its 'mirroraxis' and it's focal length 'focal'. mirroraxis is the axis of symmetry of the curve, it is the 'xaxis'. the 'yaxis' is parallel to the directrix of the parabola. the 'location' point of 'mirroraxis' is the vertex of the parabola status is 'negativefocuslength' if focal < 0.0.

        Parameters
        ----------
        MirrorAxis: gp_Ax2d
        Focal: float
        Sense: bool

        Returns
        -------
        None
        D is the directrix of the parabola and f the focus point. the symmetry axis 'xaxis' of the parabola is normal to the directrix and pass through the focus point f, but its 'location' point is the vertex of the parabola. the 'yaxis' of the parabola is parallel to d and its 'location' point is the vertex of the parabola.

        Parameters
        ----------
        D: gp_Ax2d
        F: gp_Pnt2d
        Sense: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Make a parabola with focal point s1 and center o the branch of the parabola returned will have <s1> as focal point the implicit orientation of the parabola is: - the same one as the parabola prb, - the sense defined by the coordinate system axis or the directrix d, - the trigonometric sense if sense is not given or is true, or - the opposite sense if sense is false. warning the makeparabola class does not prevent the construction of a parabola with a null focal distance. if an error occurs (that is, when isdone returns false), the status function returns: - gce_nullfocuslength if focal is less than 0.0, or - gce_nullaxis if points s1 and o are coincident.

        Parameters
        ----------
        S1: gp_Pnt2d
        O: gp_Pnt2d

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeParabola_swiginit(self, _GCE2d.new_GCE2d_MakeParabola(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_Parabola > const &":
        r"""
        Returns the constructed parabola. exceptions stdfail_notdone if no parabola is constructed.

        Returns
        -------
        opencascade::handle<Geom2d_Parabola>

        """
        return _GCE2d.GCE2d_MakeParabola_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeParabola

# Register GCE2d_MakeParabola in _GCE2d:
_GCE2d.GCE2d_MakeParabola_swigregister(GCE2d_MakeParabola)

class GCE2d_MakeSegment(GCE2d_Root):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Make a segment of line from the 2 points <p1> and <p2>. status is 'confusedpoints' if <p1> and <p2> are confused.

        Parameters
        ----------
        P1: gp_Pnt2d
        P2: gp_Pnt2d

        Returns
        -------
        None
        Make a segment of line from the point <p1> with the direction <p> and ended by the projection of <p2> on the line <p1,v>. status is 'confusedpoints' if <p1> and <p2> are confused.

        Parameters
        ----------
        P1: gp_Pnt2d
        V: gp_Dir2d
        P2: gp_Pnt2d

        Returns
        -------
        None
        Make a segment of line from the line <line> between the two parameters u1 and u2. status is 'sameparamters' if <u1> is equal <u2>.

        Parameters
        ----------
        Line: gp_Lin2d
        U1: float
        U2: float

        Returns
        -------
        None
        Make a segment of line from the line <line> between the point <point> and the parameter ulast. it returns nullobject if <u1> is equal <u2>.

        Parameters
        ----------
        Line: gp_Lin2d
        Point: gp_Pnt2d
        Ulast: float

        Returns
        -------
        None
        Make a segment of line from the line <line> between the two points <p1> and <p2>. it returns nullobject if <p1> and <p2> are confused. warning if the points which limit the segment are coincident for given points or for the projection of given points on the line which supports the line segment (that is, when isdone returns false), the status function returns gce_confusedpoints. this warning only concerns the first two constructors.

        Parameters
        ----------
        Line: gp_Lin2d
        P1: gp_Pnt2d
        P2: gp_Pnt2d

        Returns
        -------
        None

        """
        _GCE2d.GCE2d_MakeSegment_swiginit(self, _GCE2d.new_GCE2d_MakeSegment(*args))

    def Value(self, *args) -> "opencascade::handle< Geom2d_TrimmedCurve > const &":
        r"""
        Returns the constructed line segment. exceptions stdfail_notdone if no line segment is constructed.

        Returns
        -------
        opencascade::handle<Geom2d_TrimmedCurve>

        """
        return _GCE2d.GCE2d_MakeSegment_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _GCE2d.delete_GCE2d_MakeSegment

# Register GCE2d_MakeSegment in _GCE2d:
_GCE2d.GCE2d_MakeSegment_swigregister(GCE2d_MakeSegment)





