Add Chromium-only Blender WebEngine parity work

blender-5.2.0/scripts/freestyle/styles/anisotropic_diffusion.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Fredo Durand
+#  Date     : 12/08/2004
+#  Purpose  : Smooth lines using an anisotropic diffusion scheme
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ExternalContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueBP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantThicknessShader,
+    IncreasingColorShader,
+    SamplingShader,
+    pyDiffusion2Shader,
+)
+from freestyle.types import Operators, Stroke
+
+
+# pyDiffusion2Shader parameters
+offset = 0.25
+nbIter = 30
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list = [
+    ConstantThicknessShader(4),
+    SamplingShader(2),
+    pyDiffusion2Shader(offset, nbIter),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/apriori_and_causal_density.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Selects the lines with high a priori density and
+#             subjects them to the causal density so as to avoid
+#             cluttering
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueBP1D,
+    pyDensityUP1D,
+    pyHighViewMapDensityUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+)
+from freestyle.types import IntegrationType, Operators
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.3, IntegrationType.LAST))
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    ConstantThicknessShader(2),
+    ConstantColorShader(0, 0, 0, 1),
+]
+Operators.create(pyDensityUP1D(1, 0.1, IntegrationType.MEAN), shaders_list)

blender-5.2.0/scripts/freestyle/styles/apriori_density.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws lines having a high a prior density
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueBP1D,
+    TrueUP1D,
+    pyHighViewMapDensityUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.1, 5)))
+bpred = TrueBP1D()
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.0007, 5))
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    ConstantThicknessShader(2),
+    ConstantColorShader(0.0, 0.0, 0.0, 1.0)
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/backbone_stretcher.py

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Stretches the geometry of visible lines
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    BackboneStretcherShader,
+    ConstantColorShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    ConstantColorShader(0.5, 0.5, 0.5),
+    BackboneStretcherShader(20),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/blueprint_circles.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using circular contour strokes
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    SameShapeIdBP1D,
+    TrueUP1D,
+    pyHigherLengthUP1D,
+)
+from freestyle.shaders import (
+    ConstantThicknessShader,
+    IncreasingColorShader,
+    pyBluePrintCirclesShader,
+    pyPerlinNoise1DShader,
+)
+from freestyle.types import Operators
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+    ConstantThicknessShader(5),
+    pyBluePrintCirclesShader(3),
+    pyPerlinNoise1DShader(0.1, 15, 8),
+    IncreasingColorShader(0.8, 0.8, 0.3, 0.4, 0.3, 0.3, 0.3, 0.1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/blueprint_ellipses.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using elliptic contour strokes
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    SameShapeIdBP1D,
+    TrueUP1D,
+    pyHigherLengthUP1D,
+)
+from freestyle.shaders import (
+    ConstantThicknessShader,
+    IncreasingColorShader,
+    pyBluePrintEllipsesShader,
+    pyPerlinNoise1DShader,
+)
+from freestyle.types import Operators
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+    ConstantThicknessShader(5),
+    pyBluePrintEllipsesShader(3),
+    pyPerlinNoise1DShader(0.1, 10, 8),
+    IncreasingColorShader(0.6, 0.3, 0.3, 0.7, 0.3, 0.3, 0.3, 0.1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/blueprint_squares.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using square contour strokes
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    SameShapeIdBP1D,
+    TrueUP1D,
+    pyHigherLengthUP1D,
+)
+from freestyle.shaders import (
+    ConstantThicknessShader,
+    IncreasingColorShader,
+    pyBluePrintSquaresShader,
+    pyPerlinNoise1DShader,
+)
+from freestyle.types import Operators
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+    ConstantThicknessShader(8),
+    pyBluePrintSquaresShader(2, 20),
+    pyPerlinNoise1DShader(0.07, 10, 8),
+    IncreasingColorShader(0.6, 0.3, 0.3, 0.7, 0.6, 0.3, 0.3, 0.3),
+    ConstantThicknessShader(4),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/cartoon.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws colored lines. The color is automatically
+#             inferred from each object's material in a cartoon-like
+#             fashion.
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    BezierCurveShader,
+    ConstantThicknessShader,
+    pyMaterialColorShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    BezierCurveShader(3),
+    ConstantThicknessShader(4),
+    pyMaterialColorShader(0.8),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/contour.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws each object's visible contour
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    SameShapeIdBP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantThicknessShader,
+    IncreasingColorShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D()))
+bpred = SameShapeIdBP1D()
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    ConstantThicknessShader(5.0),
+    IncreasingColorShader(0.8, 0, 0, 1, 0.1, 0, 0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/curvature2d.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The stroke points are colored in gray levels and depending
+#             on the 2d curvature value
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantThicknessShader,
+    py2DCurvatureColorShader,
+)
+from freestyle.types import Operators, Stroke
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    ConstantThicknessShader(5),
+    py2DCurvatureColorShader()
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/external_contour.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the external contour of the scene
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ExternalContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueBP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+)
+from freestyle.types import Operators
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list = [
+    ConstantThicknessShader(3),
+    ConstantColorShader(0.0, 0.0, 0.0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/external_contour_sketchy.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the external contour of the scene using a sketchy
+#             chaining iterator (in particular each ViewEdge can be drawn
+#             several times
+
+from freestyle.chainingiterators import pySketchyChainingIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ExternalContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    IncreasingColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    SmoothingShader,
+    SpatialNoiseShader,
+)
+from freestyle.types import Operators
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+Operators.bidirectional_chain(pySketchyChainingIterator(), NotUP1D(upred))
+shaders_list = [
+    SamplingShader(4),
+    SpatialNoiseShader(10, 150, 2, True, True),
+    IncreasingThicknessShader(4, 10),
+    SmoothingShader(400, 0.1, 0, 0.2, 0, 0, 0, 1),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/external_contour_smooth.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws a smooth external contour
+
+from freestyle.chainingiterators import ChainPredicateIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ExternalContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueBP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    IncreasingColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    SmoothingShader,
+)
+from freestyle.types import Operators
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list = [
+    SamplingShader(2),
+    IncreasingThicknessShader(4, 20),
+    IncreasingColorShader(1.0, 0.0, 0.5, 1, 0.5, 1, 0.3, 1),
+    SmoothingShader(100, 0.05, 0, 0.2, 0, 0, 0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/haloing.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : This style module selects the lines that
+#             are connected (in the image) to a specific
+#             object and trims them in order to produce
+#             a haloing effect around the target shape
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    AndUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+    pyIsOccludedByUP1D,
+)
+from freestyle.shaders import (
+    IncreasingColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    TipRemoverShader,
+    pyTVertexRemoverShader,
+)
+from freestyle.types import Id, Operators
+
+
+# id corresponds to the id of the target object
+# (accessed by SHIFT+click)
+id = Id(3, 0)
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyIsOccludedByUP1D(id))
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = [
+    IncreasingThicknessShader(3, 5),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+    SamplingShader(1.0),
+    pyTVertexRemoverShader(),
+    TipRemoverShader(3.0),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/ignore_small_occlusions.py

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The strokes are drawn through small occlusions
+
+from freestyle.chainingiterators import pyFillOcclusionsAbsoluteChainingIterator
+from freestyle.predicates import (
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+# Operators.bidirectional_chain(pyFillOcclusionsChainingIterator(0.1))
+Operators.bidirectional_chain(pyFillOcclusionsAbsoluteChainingIterator(12))
+shaders_list = [
+    SamplingShader(5.0),
+    ConstantThicknessShader(3),
+    ConstantColorShader(0.0, 0.0, 0.0),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/invisible_lines.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws all lines whose Quantitative Invisibility
+#             is different from 0
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+)
+from freestyle.types import Operators
+
+
+upred = NotUP1D(QuantitativeInvisibilityUP1D(0))
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = [
+    SamplingShader(5.0),
+    ConstantThicknessShader(3.0),
+    ConstantColorShader(0.7, 0.7, 0.7),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/japanese_bigbrush.py

@@ -0,0 +1,53 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Simulates a big brush fr oriental painting
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.functions import pyInverseCurvature2DAngleF0D
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    pyDensityUP1D,
+    pyHigherLengthUP1D,
+    pyHigherNumberOfTurnsUP1D,
+    pyLengthBP1D,
+    pyParameterUP0D,
+)
+from freestyle.shaders import (
+    BezierCurveShader,
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+    TipRemoverShader,
+    pyNonLinearVaryingThicknessShader,
+    pySamplingShader,
+)
+from freestyle.types import IntegrationType, Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+# Splits strokes at points of highest 2D curvature
+# when there are too many abrupt turns in it
+func = pyInverseCurvature2DAngleF0D()
+Operators.recursive_split(func, pyParameterUP0D(0.2, 0.8), NotUP1D(pyHigherNumberOfTurnsUP1D(3, 0.5)), 2)
+# Keeps only long enough strokes
+Operators.select(pyHigherLengthUP1D(100))
+# Sorts so as to draw the longest strokes first
+# (this will be done using the causal density)
+Operators.sort(pyLengthBP1D())
+shaders_list = [
+    pySamplingShader(10),
+    BezierCurveShader(30),
+    SamplingShader(50),
+    ConstantThicknessShader(10),
+    pyNonLinearVaryingThicknessShader(4, 25, 0.6),
+    ConstantColorShader(0.2, 0.2, 0.2, 1.0),
+    TipRemoverShader(10),
+]
+# Use the causal density to avoid cluttering
+Operators.create(pyDensityUP1D(8, 0.4, IntegrationType.MEAN), shaders_list)

blender-5.2.0/scripts/freestyle/styles/long_anisotropically_dense.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Selects the lines that are long and have a high anisotropic
+#             a priori density and uses causal density
+#             to draw without cluttering. Ideally, half of the
+#             selected lines are culled using the causal density.
+#
+#             ********************* WARNING *************************************
+#             ******** The Directional a priori density maps must          ******
+#             ******** have been computed prior to using this style module ******
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.functions import DensityF1D
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    UnaryPredicate1D,
+    pyHighDensityAnisotropyUP1D,
+    pyHigherLengthUP1D,
+    pyLengthBP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+)
+from freestyle.types import IntegrationType, Operators
+
+
+# custom density predicate
+class pyDensityUP1D(UnaryPredicate1D):
+    def __init__(self, wsize, threshold, integration=IntegrationType.MEAN, sampling=2.0):
+        UnaryPredicate1D.__init__(self)
+        self._wsize = wsize
+        self._threshold = threshold
+        self._integration = integration
+        self._func = DensityF1D(self._wsize, self._integration, sampling)
+        self._func2 = DensityF1D(self._wsize, IntegrationType.MAX, sampling)
+
+    def __call__(self, inter):
+        c = self._func(inter)
+        m = self._func2(inter)
+        if c < self._threshold:
+            return 1
+        if m > 4 * c:
+            if c < 1.5 * self._threshold:
+                return 1
+        return 0
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+Operators.select(pyHigherLengthUP1D(40))
+# selects lines having a high anisotropic a priori density
+Operators.select(pyHighDensityAnisotropyUP1D(0.3, 4))
+Operators.sort(pyLengthBP1D())
+shaders_list = [
+    SamplingShader(2.0),
+    ConstantThicknessShader(2),
+    ConstantColorShader(0.2, 0.2, 0.25, 1),
+]
+# uniform culling
+Operators.create(pyDensityUP1D(3.0, 2.0e-2, IntegrationType.MEAN, 0.1), shaders_list)

blender-5.2.0/scripts/freestyle/styles/multiple_parameterization.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The thickness and the color of the strokes vary continuously
+#             independently from occlusions although only
+#             visible lines are actually drawn. This is equivalent
+#             to assigning the thickness using a parameterization covering
+#             the complete silhouette (visible+invisible) and drawing
+#             the strokes using a second parameterization that only
+#             covers the visible portions.
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    IncreasingColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    pyHLRShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+# Chain following the same nature, but without the restriction
+# of staying inside the selection (False).
+Operators.bidirectional_chain(ChainSilhouetteIterator(False))
+shaders_list = [
+    SamplingShader(20),
+    IncreasingThicknessShader(1.5, 30),
+    ConstantColorShader(0.0, 0.0, 0.0),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+    pyHLRShader(),  # this shader draws only visible portions
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/nature.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Uses the NatureUP1D predicate to select the lines
+#             of a given type (among Nature.SILHOUETTE, Nature.CREASE, Nature.SUGGESTIVE_CONTOURS,
+#             Nature.BORDERS).
+#             The suggestive contours must have been enabled in the
+#             options dialog to appear in the View Map.
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    TrueUP1D,
+    pyNatureUP1D,
+)
+from freestyle.shaders import (
+    IncreasingColorShader,
+    IncreasingThicknessShader,
+)
+from freestyle.types import Operators, Nature
+
+
+Operators.select(pyNatureUP1D(Nature.SILHOUETTE))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(pyNatureUP1D(Nature.SILHOUETTE)))
+shaders_list = [
+    IncreasingThicknessShader(3, 10),
+    IncreasingColorShader(0.0, 0.0, 0.0, 1, 0.8, 0, 0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/near_lines.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the lines that are "closer" than a threshold
+#             (between 0 and 1)
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    AndUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+    pyZSmallerUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+)
+from freestyle.types import IntegrationType, Operators
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyZSmallerUP1D(0.5, IntegrationType.MEAN))
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = [
+    ConstantThicknessShader(5),
+    ConstantColorShader(0.0, 0.0, 0.0),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/occluded_by_specific_object.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws only the lines that are occluded by a given object
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    AndUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+    pyIsInOccludersListUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+)
+from freestyle.types import Id, Operators
+
+
+# the id of the occluder (use SHIFT+click on the ViewMap to
+# retrieve ids)
+id = Id(3, 0)
+upred = AndUP1D(NotUP1D(QuantitativeInvisibilityUP1D(0)), pyIsInOccludersListUP1D(id))
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = [
+    SamplingShader(5),
+    ConstantThicknessShader(3),
+    ConstantColorShader(0.3, 0.3, 0.3, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/polygonalize.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Make the strokes more "polygonal"
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    PolygonalizationShader,
+    SamplingShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    SamplingShader(2.0),
+    ConstantThicknessShader(3),
+    ConstantColorShader(0.0, 0.0, 0.0),
+    PolygonalizationShader(8),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/qi0.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the visible lines (chaining follows same nature lines)
+#             (most basic style module)
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    SamplingShader(5.0),
+    ConstantThicknessShader(4.0),
+    ConstantColorShader(0.0, 0.0, 0.0)
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/qi0_not_external_contour.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the visible lines (chaining follows same nature lines)
+#             that do not belong to the external contour of the scene
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    AndUP1D,
+    ExternalContourUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    BackboneStretcherShader,
+    IncreasingColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    SpatialNoiseShader,
+)
+from freestyle.types import Operators
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = [
+    SamplingShader(4),
+    SpatialNoiseShader(4, 150, 2, True, True),
+    IncreasingThicknessShader(2, 5),
+    BackboneStretcherShader(20),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/qi1.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws lines hidden by one surface.
+#             *** Quantitative Invisibility must have been
+#             enabled in the options dialog to use this style module ****
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(1))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(1)))
+shaders_list = [
+    SamplingShader(5.0),
+    ConstantThicknessShader(3),
+    ConstantColorShader(0.5, 0.5, 0.5, 1)
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/qi2.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws lines hidden by two surfaces.
+#             *** Quantitative Invisibility must have been
+#             enabled in the options dialog to use this style module ****
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(2))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(2)))
+shaders_list = [
+    SamplingShader(10),
+    ConstantThicknessShader(1.5),
+    ConstantColorShader(0.7, 0.7, 0.7, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/sequentialsplit_sketchy.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Use the sequential split with two different
+#             predicates to specify respectively the starting and
+#             the stopping extremities for strokes
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+    pyBackTVertexUP0D,
+    pyVertexNatureUP0D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    IncreasingThicknessShader,
+    SpatialNoiseShader,
+)
+from freestyle.types import Nature, Operators
+
+
+upred = QuantitativeInvisibilityUP1D(0)
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+# starting and stopping predicates:
+start = pyVertexNatureUP0D(Nature.NON_T_VERTEX)
+stop = pyBackTVertexUP0D()
+Operators.sequential_split(start, stop, 10)
+shaders_list = [
+    SpatialNoiseShader(7, 120, 2, True, True),
+    IncreasingThicknessShader(5, 8),
+    ConstantColorShader(0.2, 0.2, 0.2, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/sketchy_multiple_parameterization.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Builds sketchy strokes whose topology relies on a
+#             parameterization that covers the complete lines (visible+invisible)
+#             whereas only the visible portions are actually drawn
+
+from freestyle.chainingiterators import pySketchyChainSilhouetteIterator
+from freestyle.predicates import (
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    IncreasingColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    SmoothingShader,
+    SpatialNoiseShader,
+    pyHLRShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(3, False))
+shaders_list = [
+    SamplingShader(2),
+    SpatialNoiseShader(15, 120, 2, True, True),
+    IncreasingThicknessShader(5, 30),
+    SmoothingShader(100, 0.05, 0, 0.2, 0, 0, 0, 1),
+    IncreasingColorShader(0, 0.2, 0, 1, 0.2, 0.7, 0.2, 1),
+    pyHLRShader(),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/sketchy_topology_broken.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The topology of the strokes is, first, built
+#             independently from the 3D topology of objects,
+#             and, second, so as to chain several times the same ViewEdge.
+
+from freestyle.chainingiterators import pySketchyChainingIterator
+from freestyle.predicates import (
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    IncreasingColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    SmoothingShader,
+    SpatialNoiseShader,
+    pyBackboneStretcherNoCuspShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+# Chain 3 times each ViewEdge independently from the
+# initial objects topology
+Operators.bidirectional_chain(pySketchyChainingIterator(3))
+shaders_list = [
+    SamplingShader(4),
+    SpatialNoiseShader(6, 120, 2, True, True),
+    IncreasingThicknessShader(4, 10),
+    SmoothingShader(100, 0.1, 0, 0.2, 0, 0, 0, 1),
+    pyBackboneStretcherNoCuspShader(20),
+    IncreasingColorShader(0.2, 0.2, 0.2, 1, 0.5, 0.5, 0.5, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/sketchy_topology_preserved.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The topology of the strokes is built
+#             so as to chain several times the same ViewEdge.
+#             The topology of the objects is preserved
+
+from freestyle.chainingiterators import pySketchyChainSilhouetteIterator
+from freestyle.predicates import (
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    SmoothingShader,
+    SpatialNoiseShader,
+)
+from freestyle.types import Operators
+
+
+upred = QuantitativeInvisibilityUP1D(0)
+Operators.select(upred)
+Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(3, True))
+shaders_list = [
+    SamplingShader(4),
+    SpatialNoiseShader(20, 220, 2, True, True),
+    IncreasingThicknessShader(4, 8),
+    SmoothingShader(300, 0.05, 0, 0.2, 0, 0, 0, 0.5),
+    ConstantColorShader(0.6, 0.2, 0.0),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/split_at_highest_2d_curvatures.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the visible lines (chaining follows same nature lines)
+#             (most basic style module)
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.functions import pyInverseCurvature2DAngleF0D
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+    pyHigherLengthUP1D,
+    pyParameterUP0D,
+)
+from freestyle.shaders import (
+    ConstantThicknessShader,
+    IncreasingColorShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+func = pyInverseCurvature2DAngleF0D()
+Operators.recursive_split(func, pyParameterUP0D(0.4, 0.6), NotUP1D(pyHigherLengthUP1D(100)), 2)
+shaders_list = [
+    ConstantThicknessShader(10),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/split_at_tvertices.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws strokes that starts and stops at Tvertices (visible or not)
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+    pyVertexNatureUP0D,
+)
+from freestyle.shaders import (
+    ConstantThicknessShader,
+    IncreasingColorShader,
+)
+from freestyle.types import Nature, Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+start = pyVertexNatureUP0D(Nature.T_VERTEX)
+# use the same predicate to decide where to start and where to stop
+# the strokes:
+Operators.sequential_split(start, start, 10)
+shaders_list = [
+    ConstantThicknessShader(5),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/suggestive.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the suggestive contours.
+#             ***** The suggestive contours must be enabled
+#             in the options dialog *****
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    AndUP1D,
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+    pyNatureUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    IncreasingThicknessShader,
+)
+from freestyle.types import Nature, Operators
+
+
+upred = AndUP1D(pyNatureUP1D(Nature.SUGGESTIVE_CONTOUR), QuantitativeInvisibilityUP1D(0))
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = [
+    IncreasingThicknessShader(1, 3),
+    ConstantColorShader(0.2, 0.2, 0.2, 1),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/thickness_fof_depth_discontinuity.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Assigns to strokes a thickness that depends on the depth discontinuity
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+    pyDepthDiscontinuityThicknessShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    SamplingShader(1),
+    ConstantThicknessShader(3),
+    ConstantColorShader(0.0, 0.0, 0.0),
+    pyDepthDiscontinuityThicknessShader(0.8, 6),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/tipremover.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Removes strokes extremities
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+    TipRemoverShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    SamplingShader(5),
+    ConstantThicknessShader(3),
+    ConstantColorShader(0, 0, 0),
+    TipRemoverShader(20),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/tvertex_remover.py

@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Removes TVertices
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    NotUP1D,
+    QuantitativeInvisibilityUP1D,
+    TrueUP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    IncreasingThicknessShader,
+    SamplingShader,
+    pyTVertexRemoverShader,
+)
+from freestyle.types import Operators
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    IncreasingThicknessShader(3, 5),
+    ConstantColorShader(0.2, 0.2, 0.2, 1),
+    SamplingShader(10.0),
+    pyTVertexRemoverShader(),
+]
+Operators.create(TrueUP1D(), shaders_list)

blender-5.2.0/scripts/freestyle/styles/uniformpruning_zsort.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: 2008-2023 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin
+#  Date     : 08/04/2005
+
+from freestyle.chainingiterators import ChainSilhouetteIterator
+from freestyle.predicates import (
+    QuantitativeInvisibilityUP1D,
+    pyDensityUP1D,
+    pyZBP1D,
+)
+from freestyle.shaders import (
+    ConstantColorShader,
+    ConstantThicknessShader,
+    SamplingShader,
+)
+from freestyle.types import IntegrationType, Operators, Stroke
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator())
+# Operators.sequential_split(pyVertexNatureUP0D(Nature.VIEW_VERTEX), 2)
+Operators.sort(pyZBP1D())
+shaders_list = [
+    ConstantThicknessShader(3),
+    SamplingShader(5.0),
+    ConstantColorShader(0, 0, 0, 1),
+]
+Operators.create(pyDensityUP1D(2, 0.05, IntegrationType.MEAN, 4), shaders_list)