fake-bpy-module 20240417__py3-none-any.whl → 20240418__py3-none-any.whl

freestyle/predicates/__init__.pyi

@@ -1,3 +1,19 @@
+"""
+This module contains predicates operating on vertices (0D elements)
+and polylines (1D elements).  It is also intended to be a collection
+of examples for predicate definition in Python.
+
+User-defined predicates inherit one of the following base classes,
+depending on the object type (0D or 1D) to operate on and the arity
+(unary or binary):
+
+* freestyle.types.BinaryPredicate0D
+* freestyle.types.BinaryPredicate1D
+* freestyle.types.UnaryPredicate0D
+* freestyle.types.UnaryPredicate1D
+
+"""
+
 import typing
 import freestyle.types
 
@@ -16,9 +32,7 @@ class AndUP1D:
 class ContourUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `ContourUP1D`"""
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Returns true if the Interface1D is a contour. An Interface1D is a
         contour if it is bordered by a different shape on each of its sides.
 
@@ -32,19 +46,19 @@ class ContourUP1D:
 class DensityLowerThanUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `DensityLowerThanUP1D`"""
 
-    def __init__(self, threshold, sigma=2.0):
+    def __init__(self, threshold: float, sigma: float = 2.0):
         """Builds a DensityLowerThanUP1D object.
 
                 :param threshold: The value of the threshold density. Any Interface1D
         having a density lower than this threshold will match.
+                :type threshold: float
                 :param sigma: The sigma value defining the density evaluation window
         size used in the `freestyle.functions.DensityF0D` functor.
+                :type sigma: float
         """
         ...
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Returns true if the density evaluated for the Interface1D is less
         than a user-defined density value.
 
@@ -58,16 +72,15 @@ class DensityLowerThanUP1D:
 class EqualToChainingTimeStampUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `freestyle.types.EqualToChainingTimeStampUP1D`"""
 
-    def __init__(self, ts):
+    def __init__(self, ts: int):
         """Builds a EqualToChainingTimeStampUP1D object.
 
         :param ts: A time stamp value.
+        :type ts: int
         """
         ...
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Returns true if the Interface1D's time stamp is equal to a certain
         user-defined value.
 
@@ -81,16 +94,15 @@ class EqualToChainingTimeStampUP1D:
 class EqualToTimeStampUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `EqualToTimeStampUP1D`"""
 
-    def __init__(self, ts):
+    def __init__(self, ts: int):
         """Builds a EqualToTimeStampUP1D object.
 
         :param ts: A time stamp value.
+        :type ts: int
         """
         ...
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Returns true if the Interface1D's time stamp is equal to a certain
         user-defined value.
 
@@ -104,9 +116,7 @@ class EqualToTimeStampUP1D:
 class ExternalContourUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `ExternalContourUP1D`"""
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Returns true if the Interface1D is an external contour.
         An Interface1D is an external contour if it is bordered by no shape on
         one of its sides.
@@ -124,7 +134,7 @@ class FalseBP1D:
 
     def __call__(
         self, inter1: freestyle.types.Interface1D, inter2: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    ) -> bool:
         """Always returns false.
 
         :param inter1: The first Interface1D object.
@@ -139,9 +149,7 @@ class FalseBP1D:
 class FalseUP0D:
     """Class hierarchy: `freestyle.types.UnaryPredicate0D` > `FalseUP0D`"""
 
-    def __call__(
-        self, it: freestyle.types.Interface0DIterator
-    ) -> freestyle.types.Interface0DIterator:
+    def __call__(self, it: freestyle.types.Interface0DIterator) -> bool:
         """Always returns false.
 
         :param it: An Interface0DIterator object.
@@ -154,9 +162,7 @@ class FalseUP0D:
 class FalseUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `FalseUP1D`"""
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Always returns false.
 
         :param inter: An Interface1D object.
@@ -171,7 +177,7 @@ class Length2DBP1D:
 
     def __call__(
         self, inter1: freestyle.types.Interface1D, inter2: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    ) -> bool:
         """Returns true if the 2D length of inter1 is less than the 2D length
         of inter2.
 
@@ -222,17 +228,16 @@ class QuantitativeInvisibilityRangeUP1D:
 class QuantitativeInvisibilityUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `QuantitativeInvisibilityUP1D`"""
 
-    def __init__(self, qi=0):
+    def __init__(self, qi: int = 0):
         """Builds a QuantitativeInvisibilityUP1D object.
 
                 :param qi: The Quantitative Invisibility you want the Interface1D to
         have.
+                :type qi: int
         """
         ...
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Returns true if the Quantitative Invisibility evaluated at an
         Interface1D, using the
         `freestyle.functions.QuantitativeInvisibilityF1D` functor,
@@ -251,7 +256,7 @@ class SameShapeIdBP1D:
 
     def __call__(
         self, inter1: freestyle.types.Interface1D, inter2: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    ) -> bool:
         """Returns true if inter1 and inter2 belong to the same shape.
 
         :param inter1: The first Interface1D object.
@@ -266,17 +271,17 @@ class SameShapeIdBP1D:
 class ShapeUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `ShapeUP1D`"""
 
-    def __init__(self, first, second=0):
+    def __init__(self, first: int, second: int = 0):
         """Builds a ShapeUP1D object.
 
         :param first: The first Id component.
+        :type first: int
         :param second: The second Id component.
+        :type second: int
         """
         ...
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Returns true if the shape to which the Interface1D belongs to has the
         same `freestyle.types.Id` as the one specified by the user.
 
@@ -293,7 +298,7 @@ class TrueBP1D:
 
     def __call__(
         self, inter1: freestyle.types.Interface1D, inter2: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    ) -> bool:
         """Always returns true.
 
         :param inter1: The first Interface1D object.
@@ -308,9 +313,7 @@ class TrueBP1D:
 class TrueUP0D:
     """Class hierarchy: `freestyle.types.UnaryPredicate0D` > `TrueUP0D`"""
 
-    def __call__(
-        self, it: freestyle.types.Interface0DIterator
-    ) -> freestyle.types.Interface0DIterator:
+    def __call__(self, it: freestyle.types.Interface0DIterator) -> bool:
         """Always returns true.
 
         :param it: An Interface0DIterator object.
@@ -323,9 +326,7 @@ class TrueUP0D:
 class TrueUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `TrueUP1D`"""
 
-    def __call__(
-        self, inter: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    def __call__(self, inter: freestyle.types.Interface1D) -> bool:
         """Always returns true.
 
         :param inter: An Interface1D object.
@@ -340,14 +341,15 @@ class ViewMapGradientNormBP1D:
 
     def __init__(
         self,
-        level,
+        level: int,
         integration_type: freestyle.types.IntegrationType = None,
-        sampling=2.0,
+        sampling: float = 2.0,
     ):
         """Builds a ViewMapGradientNormBP1D object.
 
                 :param level: The level of the pyramid from which the pixel must be
         read.
+                :type level: int
                 :param integration_type: The integration method used to compute a single value
         from a set of values.
                 :type integration_type: freestyle.types.IntegrationType
@@ -355,12 +357,13 @@ class ViewMapGradientNormBP1D:
         GetViewMapGradientNormF0D is evaluated at each sample point and
         the result is obtained by combining the resulting values into a
         single one, following the method specified by integration_type.
+                :type sampling: float
         """
         ...
 
     def __call__(
         self, inter1: freestyle.types.Interface1D, inter2: freestyle.types.Interface1D
-    ) -> freestyle.types.Interface1D:
+    ) -> bool:
         """Returns true if the evaluation of the Gradient norm Function is
         higher for inter1 than for inter2.
 
@@ -376,13 +379,17 @@ class ViewMapGradientNormBP1D:
 class WithinImageBoundaryUP1D:
     """Class hierarchy: `freestyle.types.UnaryPredicate1D` > `WithinImageBoundaryUP1D`"""
 
-    def __init__(self, xmin, ymin, xmax, ymax):
+    def __init__(self, xmin: float, ymin: float, xmax: float, ymax: float):
         """Builds an WithinImageBoundaryUP1D object.
 
         :param xmin: X lower bound of the image boundary.
+        :type xmin: float
         :param ymin: Y lower bound of the image boundary.
+        :type ymin: float
         :param xmax: X upper bound of the image boundary.
+        :type xmax: float
         :param ymax: Y upper bound of the image boundary.
+        :type ymax: float
         """
         ...
 

freestyle/shaders/__init__.pyi

@@ -1,3 +1,13 @@
+"""
+This module contains stroke shaders used for creation of stylized
+strokes.  It is also intended to be a collection of examples for
+shader definition in Python.
+
+User-defined stroke shaders inherit the
+freestyle.types.StrokeShader class.
+
+"""
+
 import typing
 import freestyle.types
 import mathutils
@@ -7,10 +17,11 @@ GenericType = typing.TypeVar("GenericType")
 class BackboneStretcherShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `BackboneStretcherShader`[Geometry shader]"""
 
-    def __init__(self, amount=2.0):
+    def __init__(self, amount: float = 2.0):
         """Builds a BackboneStretcherShader object.
 
         :param amount: The stretching amount value.
+        :type amount: float
         """
         ...
 
@@ -26,12 +37,13 @@ class BackboneStretcherShader:
 class BezierCurveShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `BezierCurveShader`[Geometry shader]"""
 
-    def __init__(self, error=4.0):
+    def __init__(self, error: float = 4.0):
         """Builds a BezierCurveShader object.
 
                 :param error: The error we're allowing for the approximation. This
         error is the max distance allowed between the new curve and the
         original geometry.
+                :type error: float
         """
         ...
 
@@ -69,8 +81,8 @@ class CalligraphicShader:
 
     def __init__(
         self,
-        thickness_min,
-        thickness_max,
+        thickness_min: float,
+        thickness_max: float,
         orientation: typing.Union[typing.Sequence[float], mathutils.Vector],
         clamp: bool,
     ):
@@ -78,7 +90,9 @@ class CalligraphicShader:
 
                 :param thickness_min: The minimum thickness in the direction
         perpendicular to the main direction.
+                :type thickness_min: float
                 :param thickness_max: The maximum thickness in the main direction.
+                :type thickness_max: float
                 :param orientation: The 2D vector giving the main direction.
                 :type orientation: typing.Union[typing.Sequence[float], mathutils.Vector]
                 :param clamp: If true, the strokes are drawn in black when the stroke
@@ -103,11 +117,13 @@ class CalligraphicShader:
 class ColorNoiseShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ColorNoiseShader`[Color shader]"""
 
-    def __init__(self, amplitude, period):
+    def __init__(self, amplitude: float, period: float):
         """Builds a ColorNoiseShader object.
 
         :param amplitude: The amplitude of the noise signal.
+        :type amplitude: float
         :param period: The period of the noise signal.
+        :type period: float
         """
         ...
 
@@ -122,13 +138,17 @@ class ColorNoiseShader:
 class ConstantColorShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ConstantColorShader`[Color shader]"""
 
-    def __init__(self, red, green, blue, alpha=1.0):
+    def __init__(self, red: float, green: float, blue: float, alpha: float = 1.0):
         """Builds a ConstantColorShader object.
 
         :param red: The red component.
+        :type red: float
         :param green: The green component.
+        :type green: float
         :param blue: The blue component.
+        :type blue: float
         :param alpha: The alpha value.
+        :type alpha: float
         """
         ...
 
@@ -143,10 +163,11 @@ class ConstantColorShader:
 class ConstantThicknessShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ConstantThicknessShader`[Thickness shader]"""
 
-    def __init__(self, thickness):
+    def __init__(self, thickness: float):
         """Builds a ConstantThicknessShader object.
 
         :param thickness: The thickness that must be assigned to the stroke.
+        :type thickness: float
         """
         ...
 
@@ -161,12 +182,15 @@ class ConstantThicknessShader:
 class ConstrainedIncreasingThicknessShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ConstrainedIncreasingThicknessShader`[Thickness shader]"""
 
-    def __init__(self, thickness_min, thickness_max, ratio):
+    def __init__(self, thickness_min: float, thickness_max: float, ratio: float):
         """Builds a ConstrainedIncreasingThicknessShader object.
 
         :param thickness_min: The minimum thickness.
+        :type thickness_min: float
         :param thickness_max: The maximum thickness.
+        :type thickness_max: float
         :param ratio: The thickness/length ratio that we don't want to exceed.
+        :type ratio: float
         """
         ...
 
@@ -183,13 +207,14 @@ class ConstrainedIncreasingThicknessShader:
 class GuidingLinesShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `GuidingLinesShader`[Geometry shader]"""
 
-    def __init__(self, offset):
+    def __init__(self, offset: float):
         """Builds a GuidingLinesShader object.
 
                 :param offset: The line that replaces the stroke is initially in the
         middle of the initial stroke bounding box. offset is the value
         of the displacement which is applied to this line along its
         normal.
+                :type offset: float
         """
         ...
 
@@ -211,25 +236,33 @@ class IncreasingColorShader:
 
     def __init__(
         self,
-        red_min,
-        green_min,
-        blue_min,
-        alpha_min,
-        red_max,
-        green_max,
-        blue_max,
-        alpha_max,
+        red_min: float,
+        green_min: float,
+        blue_min: float,
+        alpha_min: float,
+        red_max: float,
+        green_max: float,
+        blue_max: float,
+        alpha_max: float,
     ):
         """Builds an IncreasingColorShader object.
 
         :param red_min: The first color red component.
+        :type red_min: float
         :param green_min: The first color green component.
+        :type green_min: float
         :param blue_min: The first color blue component.
+        :type blue_min: float
         :param alpha_min: The first color alpha value.
+        :type alpha_min: float
         :param red_max: The second color red component.
+        :type red_max: float
         :param green_max: The second color green component.
+        :type green_max: float
         :param blue_max: The second color blue component.
+        :type blue_max: float
         :param alpha_max: The second color alpha value.
+        :type alpha_max: float
         """
         ...
 
@@ -246,11 +279,13 @@ class IncreasingColorShader:
 class IncreasingThicknessShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `IncreasingThicknessShader`[Thickness shader]"""
 
-    def __init__(self, thickness_A, thickness_B):
+    def __init__(self, thickness_A: float, thickness_B: float):
         """Builds an IncreasingThicknessShader object.
 
         :param thickness_A: The first thickness value.
+        :type thickness_A: float
         :param thickness_B: The second thickness value.
+        :type thickness_B: float
         """
         ...
 
@@ -269,13 +304,14 @@ class IncreasingThicknessShader:
 class PolygonalizationShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `PolygonalizationShader`[Geometry shader]"""
 
-    def __init__(self, error):
+    def __init__(self, error: float):
         """Builds a PolygonalizationShader object.
 
                 :param error: The error we want our polygonal approximation to have
         with respect to the original geometry. The smaller, the closer
         the new stroke is to the original one. This error corresponds to
         the maximum distance between the new stroke and the old one.
+                :type error: float
         """
         ...
 
@@ -311,10 +347,11 @@ class RoundCapShader:
 class SamplingShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `SamplingShader`[Geometry shader]"""
 
-    def __init__(self, sampling):
+    def __init__(self, sampling: float):
         """Builds a SamplingShader object.
 
         :param sampling: The sampling to use for the stroke resampling.
+        :type sampling: float
         """
         ...
 
@@ -331,25 +368,33 @@ class SmoothingShader:
 
     def __init__(
         self,
-        num_iterations=100,
-        factor_point=0.1,
-        factor_curvature=0.0,
-        factor_curvature_difference=0.2,
-        aniso_point=0.0,
-        aniso_normal=0.0,
-        aniso_curvature=0.0,
-        carricature_factor=1.0,
+        num_iterations: int = 100,
+        factor_point: float = 0.1,
+        factor_curvature: float = 0.0,
+        factor_curvature_difference: float = 0.2,
+        aniso_point: float = 0.0,
+        aniso_normal: float = 0.0,
+        aniso_curvature: float = 0.0,
+        carricature_factor: float = 1.0,
     ):
         """Builds a SmoothingShader object.
 
         :param num_iterations: The number of iterations.
+        :type num_iterations: int
         :param factor_point: 0.1
+        :type factor_point: float
         :param factor_curvature: 0.0
+        :type factor_curvature: float
         :param factor_curvature_difference: 0.2
+        :type factor_curvature_difference: float
         :param aniso_point: 0.0
+        :type aniso_point: float
         :param aniso_normal: 0.0
+        :type aniso_normal: float
         :param aniso_curvature: 0.0
+        :type aniso_curvature: float
         :param carricature_factor: 1.0
+        :type carricature_factor: float
         """
         ...
 
@@ -367,12 +412,22 @@ class SmoothingShader:
 class SpatialNoiseShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `SpatialNoiseShader`[Geometry shader]"""
 
-    def __init__(self, amount, scale, num_octaves, smooth: bool, pure_random: bool):
+    def __init__(
+        self,
+        amount: float,
+        scale: float,
+        num_octaves: int,
+        smooth: bool,
+        pure_random: bool,
+    ):
         """Builds a SpatialNoiseShader object.
 
         :param amount: The amplitude of the noise.
+        :type amount: float
         :param scale: The noise frequency.
+        :type scale: float
         :param num_octaves: The number of octaves
+        :type num_octaves: int
         :param smooth: True if you want the noise to be smooth.
         :type smooth: bool
         :param pure_random: True if you don't want any coherence.
@@ -402,10 +457,11 @@ class SquareCapShader:
 class StrokeTextureStepShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `StrokeTextureStepShader`[Texture shader]"""
 
-    def __init__(self, step):
+    def __init__(self, step: float):
         """Builds a StrokeTextureStepShader object.
 
         :param step: The spacing along the stroke.
+        :type step: float
         """
         ...
 
@@ -420,11 +476,13 @@ class StrokeTextureStepShader:
 class ThicknessNoiseShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ThicknessNoiseShader`[Thickness shader]"""
 
-    def __init__(self, amplitude, period):
+    def __init__(self, amplitude: float, period: float):
         """Builds a ThicknessNoiseShader object.
 
         :param amplitude: The amplitude of the noise signal.
+        :type amplitude: float
         :param period: The period of the noise signal.
+        :type period: float
         """
         ...
 
@@ -439,11 +497,12 @@ class ThicknessNoiseShader:
 class TipRemoverShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `TipRemoverShader`[Geometry shader]"""
 
-    def __init__(self, tip_length):
+    def __init__(self, tip_length: float):
         """Builds a TipRemoverShader object.
 
                 :param tip_length: The length of the piece of stroke we want to remove
         at each extremity.
+                :type tip_length: float
         """
         ...