user: What is Freestyle Types (freestyle.types) and how is it used in Blender Python scripting?

assistant: mooth`

    Class defining a smooth edge. This kind of edge typically runs across
    a face of the input mesh. It can be a silhouette, a ridge or valley,
    a suggestive contour.

    __init__()

    __init__(*brother*)

    __init__(*first_vertex*, *second_vertex*)
    :   Builds an `FEdgeSmooth` using the default constructor,
        copy constructor, or between two `SVertex`.

        Parameters:
        :   - **brother** (`FEdgeSmooth`) – An FEdgeSmooth object.
            - **first_vertex** (`SVertex`) – The first SVertex object.
            - **second_vertex** (`SVertex`) – The second SVertex object.

    face_mark
    :   The face mark of the face that this FEdge is running across.

        Type:
        :   bool

    material
    :   The material of the face that this FEdge is running across.

        Type:
        :   `Material`

    material_index
    :   The index of the material of the face that this FEdge is running across.

        Type:
        :   int

    normal
    :   The normal of the face that this FEdge is running across.

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")

*class* freestyle.types.Id
:   Class for representing an object Id.

    __init__(*brother*)

    __init__(*first=0*, *second=0*)
    :   Build the Id from two numbers or another `Id` using the copy constructor.

        Parameters:
        :   - **brother** (`Id` :arg first: The first number.) – An Id object.
            - **second** (*int*) – The second number.

    first
    :   The first number constituting the Id.

        Type:
        :   int

    second
    :   The second number constituting the Id.

        Type:
        :   int

*class* freestyle.types.IntegrationType
:   Class hierarchy: int > `IntegrationType`

    Different integration methods that can be invoked to integrate into a
    single value the set of values obtained from each 0D element of an 1D
    element:

    - IntegrationType.MEAN: The value computed for the 1D element is the
      mean of the values obtained for the 0D elements.
    - IntegrationType.MIN: The value computed for the 1D element is the
      minimum of the values obtained for the 0D elements.
    - IntegrationType.MAX: The value computed for the 1D element is the
      maximum of the values obtained for the 0D elements.
    - IntegrationType.FIRST: The value computed for the 1D element is the
      first of the values obtained for the 0D elements.
    - IntegrationType.LAST: The value computed for the 1D element is the
      last of the values obtained for the 0D elements.

*class* freestyle.types.Interface0D
:   Base class for any 0D element.

    __init__()
    :   Default constructor.

    get_fedge(*inter*)
    :   Returns the FEdge that lies between this 0D element and the 0D
        element given as the argument.

        Parameters:
        :   **inter** (`Interface0D`) – A 0D element.

        Returns:
        :   The FEdge lying between the two 0D elements.

        Return type:
        :   `FEdge`

    id
    :   The Id of this 0D element.

        Type:
        :   `Id`

    name
    :   The string of the name of this 0D element.

        Type:
        :   str

    nature
    :   The nature of this 0D element.

        Type:
        :   `Nature`

    point_2d
    :   The 2D point of this 0D element.

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")

    point_3d
    :   The 3D point of this 0D element.

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")

    projected_x
    :   The X coordinate of the projected 3D point of this 0D element.

        Type:
        :   float

    projected_y
    :   The Y coordinate of the projected 3D point of this 0D element.

        Type:
        :   float

    projected_z
    :   The Z coordinate of the projected 3D point of this 0D element.

        Type:
        :   float

*class* freestyle.types.Interface0DIterator
:   Class hierarchy: `Iterator` > `Interface0DIterator`

    Class defining an iterator over Interface0D elements. An instance of
    this iterator is always obtained from a 1D element.

    __init__(*brother*)

    __init__(*it*)
    :   Construct a nested Interface0DIterator using either the copy constructor
        or the constructor that takes an argument of a Function0D.

        Parameters:
        :   - **brother** (`Interface0DIterator`) – An Interface0DIterator object.
            - **it** (`SVertexIterator` | `CurvePointIterator` | `StrokeVertexIterator`) – An iterator object to be nested.

    at_last
    :   True if the iterator points to the last valid element.
        For its counterpart (pointing to the first valid element), use it.is_begin.

        Type:
        :   bool

    object
    :   The 0D object currently pointed to by this iterator. Note that the object
        may be an instance of an Interface0D subclass. For example if the iterator
        has been created from the vertices_begin() method of the `Stroke`
        class, the .object property refers to a `StrokeVertex` object.

        Type:
        :   `Interface0D` or one of its subclasses.

    t
    :   The curvilinear abscissa of the current point.

        Type:
        :   float

    u
    :   The point parameter at the current point in the 1D element (0 <= u <= 1).

        Type:
        :   float

*class* freestyle.types.Interface1D
:   Base class for any 1D element.

    __init__()
    :   Default constructor.

    points_begin(*t=0.0*)
    :   Returns an iterator over the Interface1D points, pointing to the
        first point. The difference with vertices_begin() is that here we can
        iterate over points of the 1D element at a any given sampling.
        Indeed, for each iteration, a virtual point is created.

        Parameters:
        :   **t** (*float*) – A sampling with which we want to iterate over points of
            this 1D element.

        Returns:
        :   An Interface0DIterator pointing to the first point.

        Return type:
        :   `Interface0DIterator`

    points_end(*t=0.0*)
    :   Returns an iterator over the Interface1D points, pointing after the
        last point. The difference with vertices_end() is that here we can
        iterate over points of the 1D element at a given sampling. Indeed,
        for each iteration, a virtual point is created.

        Parameters:
        :   **t** (*float*) – A sampling with which we want to iterate over points of
            this 1D element.

        Returns:
        :   An Interface0DIterator pointing after the last point.

        Return type:
        :   `Interface0DIterator`

    vertices_begin()
    :   Returns an iterator over the Interface1D vertices, pointing to the
        first vertex.

        Returns:
        :   An Interface0DIterator pointing to the first vertex.

        Return type:
        :   `Interface0DIterator`

    vertices_end()
    :   Returns an iterator over the Interface1D vertices, pointing after
        the last vertex.

        Returns:
        :   An Interface0DIterator pointing after the last vertex.

        Return type:
        :   `Interface0DIterator`

    id
    :   The Id of this Interface1D.

        Type:
        :   `Id`

    length_2d
    :   The 2D length of this Interface1D.

        Type:
        :   float

    name
    :   The string of the name of the 1D element.

        Type:
        :   str

    nature
    :   The nature of this Interface1D.

        Type:
        :   `Nature`

    time_stamp
    :   The time stamp of the 1D element, mainly used for selection.

        Type:
        :   int

*class* freestyle.types.Iterator
:   Base class to define iterators.

    __init__()
    :   Default constructor.

    decrement()
    :   Makes the iterator point the previous element.

    increment()
    :   Makes the iterator point the next element.

    is_begin
    :   True if the iterator points to the first element.

        Type:
        :   bool

    is_end
    :   True if the iterator points to the last element.

        Type:
        :   bool

    name
    :   The string of the name of this iterator.

        Type:
        :   str

*class* freestyle.types.Material
:   Class defining a material.

    __init__()

    __init__(*brother*)

    __init__(*line*, *diffuse*, *ambient*, *specular*, *emission*, *shininess*, *priority*)
    :   Creates a `FrsMaterial` using either default constructor,
        copy constructor, or an overloaded constructor

        Parameters:
        :   - **brother** (`Material`) – A Material object to be used as a copy constructor.
            - **line** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") | tuple[float, float, float, float] | list[float]) – The line color.
            - **diffuse** – The diffuse color.
            - **ambient** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") | tuple[float, float, float, float] | list[float]) – The ambient color.
            - **specular** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") | tuple[float, float, float, float] | list[float]) – The specular color.
            - **emission** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") | tuple[float, float, float, float] | list[float]) – The emissive color.
            - **shininess** (*float*) – The shininess coefficient.
            - **priority** (*int*) – The line color priority.

    ambient
    :   RGBA components of the ambient color of the material.

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color")

    diffuse
    :   RGBA components of the diffuse color of the material.

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")

    emission
    :   RGBA components of the emissive color of the material.

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color")

    line
    :   RGBA components of the line color of the material.

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")

    priority
    :   Line color priority of the material.

        Type:
        :   int

    shininess
    :   Shininess coefficient of the material.

        Type:
        :   float

    specular
    :   RGBA components of the specular color of the material.

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")

*class* freestyle.types.MediumType
:   Class hierarchy: int > `MediumType`

    The different blending modes available to simulate the interaction
    media-medium:

    - Stroke.DRY_MEDIUM: To simulate a dry medium such as Pencil or Charcoal.
    - Stroke.HUMID_MEDIUM: To simulate ink painting (color subtraction blending).
    - Stroke.OPAQUE_MEDIUM: To simulate an opaque medium (oil, spray…).

*class* freestyle.types.Nature
:   Class hierarchy: int > `Nature`

    Different possible natures of 0D and 1D elements of the ViewMap.

    Vertex natures:

    - Nature.POINT: True for any 0D element.
    - Nature.S_VERTEX: True for SVertex.
    - Nature.VIEW_VERTEX: True for ViewVertex.
    - Nature.NON_T_VERTEX: True for NonTVertex.
    - Nature.T_VERTEX: True for TVertex.
    - Nature.CUSP: True for CUSP.

    Edge natures:

    - Nature.NO_FEATURE: True for non feature edges (always false for 1D
      elements of the ViewMap).
    - Nature.SILHOUETTE: True for silhouettes.
    - Nature.BORDER: True for borders.
    - Nature.CREASE: True for creases.
    - Nature.RIDGE: True for ridges.
    - Nature.VALLEY: True for valleys.
    - Nature.SUGGESTIVE_CONTOUR: True for suggestive contours.
    - Nature.MATERIAL_BOUNDARY: True for edges at material boundaries.
    - Nature.EDGE_MARK: True for edges having user-defined edge marks.

*class* freestyle.types.Noise
:   Class to provide Perlin noise functionalities.

    __init__(*seed=-1*)
    :   Builds a Noise object. Seed is an optional argument. The seed value is used
        as a seed for random number generation if it is equal to or greater than zero;
        otherwise, time is used as a seed.

        Parameters:
        :   **seed** (*int*) – Seed for random number generation.

    Undocumented, consider [contributing](https://developer.blender.org/).

    smoothNoise1(*v*)
    :   Returns a smooth noise value for a 1D element.

        Parameters:
        :   **v** (*float*) – One-dimensional sample point.

        Returns:
        :   A smooth noise value.

        Return type:
        :   float

    smoothNoise2(*v*)
    :   Returns a smooth noise value for a 2D element.

        Parameters:
        :   **v** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") | tuple[float, float] | list[float]) – Two-dimensional sample point.

        Returns:
        :   A smooth noise value.

        Return type:
        :   float

    smoothNoise3(*v*)
    :   Returns a smooth noise value for a 3D element.

        Parameters:
        :   **v** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") | tuple[float, float, float] | list[float]) – Three-dimensional sample point.

        Returns:
        :   A smooth noise value.

        Return type:
        :   float

    turbulence1(*v*, *freq*, *amp*, *oct=4*)
    :   Returns a noise value for a 1D element.

        Parameters:
        :   - **v** (*float*) – One-dimensional sample point.
            - **freq** (*float*) – Noise frequency.
            - **amp** (*float*) – Amplitude.
            - **oct** (*int*) – Number of octaves.

        Returns:
        :   A noise value.

        Return type:
        :   float

    turbulence2(*v*, *freq*, *amp*, *oct=4*)
    :   Returns a noise value for a 2D element.

        Parameters:
        :   - **v** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") | tuple[float, float] | list[float]) – Two-dimensional sample point.
            - **freq** (*float*) – Noise frequency.
            - **amp** (*float*) – Amplitude.
            - **oct** (*int*) – Number of octaves.

        Returns:
        :   A noise value.

        Return type:
        :   float

    turbulence3(*v*, *freq*, *amp*, *oct=4*)
    :   Returns a noise value for a 3D element.

        Parameters:
        :   - **v** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") | tuple[float, float, float] | list[float]) – Three-dimensional sample point.
            - **freq** (*float*) – Noise frequency.
            - **amp** (*float*) – Amplitude.
            - **oct** (*int*) – Number of octaves.

        Returns:
        :   A noise value.

        Return type:
        :   float

    Undocumented, consider [contributing](https://developer.blender.org/).

*class* freestyle.types.NonTVertex
:   Class hierarchy: `Interface0D` > `ViewVertex` > `NonTVertex`

    View vertex for corners, cusps, etc. associated to a single SVertex.
    Can be associated to 2 or more view edges.

    __init__()

    __init__(*svertex*)
    :   Builds a `NonTVertex` using the default constructor or a `SVertex`.

        Parameters:
        :   **svertex** (`SVertex`) – An SVertex object.

    svertex
    :   The SVertex on top of which this NonTVertex is built.

        Type:
        :   `SVertex`

*class* freestyle.types.Operators
:   Class defining the operators used in a style module. There are five
    types of operators: Selection, chaining, splitting, sorting and
    creation. All these operators are user controlled through functors,
    predicates and shaders that are taken as arguments.

    *static* bidirectional_chain(*it*, *pred*)

    *static* bidirectional_chain(*it*)
    :   Builds a set of chains from the current set of ViewEdges. Each
        ViewEdge of the current list potentially starts a new chain. The
        chaining operator then iterates over the ViewEdges of the ViewMap
        using the user specified iterator. This operator iterates both using
        the increment and decrement operators and is therefore bidirectional.
        This operator works with a ChainingIterator which contains the
        chaining rules. It is this last one which can be told to chain only
        edges that belong to the selection or not to process twice a ViewEdge
        during the chaining. Each time a ViewEdge is added to a chain, its
        chaining time stamp is incremented. This allows you to keep track of
        the number of chains to which a ViewEdge belongs to.

        Parameters:
        :   - **it** (`ChainingIterator`) – The ChainingIterator on the ViewEdges of the ViewMap. It
              contains the chaining rule.
            - **pred** (`UnaryPredicate1D`) – The predicate on the ViewEdge that expresses the stopping condition.
              This parameter is optional, you make not want to pass a stopping criterion
              when the stopping criterion is already contained in the iterator definition.

    *static* chain(*it*, *pred*, *modifier*)

    *static* chain(*it*, *pred*)
    :   Builds a set of chains from the current set of ViewEdges. Each
        ViewEdge of the current list starts a new chain. The chaining
        operator then iterates over the ViewEdges of the ViewMap using the
        user specified iterator. This operator only iterates using the
        increment operator and is therefore unidirectional.

        Parameters:
        :   - **it** (`ViewEdgeIterator`) – The iterator on the ViewEdges of the ViewMap. It contains
              the chaining rule.
            - **pred** (`UnaryPredicate1D`) – The predicate on the ViewEdge that expresses the
              stopping condition.
            - **modifier** (`UnaryFunction1DVoid`) – A function that takes a ViewEdge as argument and
              that is used to modify the processed ViewEdge state (the
              timestamp inc