@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/freestyle/modules/freestyle/predicates.py

@@ -1,670 +0,0 @@
-# SPDX-FileCopyrightText: 2014-2023 Blender Authors
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-"""
-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):
-
-- :class:`freestyle.types.BinaryPredicate0D`
-- :class:`freestyle.types.BinaryPredicate1D`
-- :class:`freestyle.types.UnaryPredicate0D`
-- :class:`freestyle.types.UnaryPredicate1D`
-"""
-
-__all__ = (
-    "AndBP1D",
-    "AndUP1D",
-    "ContourUP1D",
-    "DensityLowerThanUP1D",
-    "EqualToChainingTimeStampUP1D",
-    "EqualToTimeStampUP1D",
-    "ExternalContourUP1D",
-    "FalseBP1D",
-    "FalseUP0D",
-    "FalseUP1D",
-    "Length2DBP1D",
-    "MaterialBP1D",
-    "NotBP1D",
-    "NotUP1D",
-    "ObjectNamesUP1D",
-    "OrBP1D",
-    "OrUP1D",
-    "QuantitativeInvisibilityRangeUP1D",
-    "QuantitativeInvisibilityUP1D",
-    "SameShapeIdBP1D",
-    "ShapeUP1D",
-    "TrueBP1D",
-    "TrueUP0D",
-    "TrueUP1D",
-    "ViewMapGradientNormBP1D",
-    "WithinImageBoundaryUP1D",
-    "pyBackTVertexUP0D",
-    "pyClosedCurveUP1D",
-    "pyDensityFunctorUP1D",
-    "pyDensityUP1D",
-    "pyDensityVariableSigmaUP1D",
-    "pyHighDensityAnisotropyUP1D",
-    "pyHighDirectionalViewMapDensityUP1D",
-    "pyHighSteerableViewMapDensityUP1D",
-    "pyHighViewMapDensityUP1D",
-    "pyHighViewMapGradientNormUP1D",
-    "pyHigherCurvature2DAngleUP0D",
-    "pyHigherLengthUP1D",
-    "pyHigherNumberOfTurnsUP1D",
-    "pyIsInOccludersListUP1D",
-    "pyIsOccludedByIdListUP1D",
-    "pyIsOccludedByItselfUP1D",
-    "pyIsOccludedByUP1D",
-    "pyLengthBP1D",
-    "pyLowDirectionalViewMapDensityUP1D",
-    "pyLowSteerableViewMapDensityUP1D",
-    "pyNFirstUP1D",
-    "pyNatureBP1D",
-    "pyNatureUP1D",
-    "pyParameterUP0D",
-    "pyParameterUP0DGoodOne",
-    "pyProjectedXBP1D",
-    "pyProjectedYBP1D",
-    "pyShapeIdListUP1D",
-    "pyShapeIdUP1D",
-    "pyShuffleBP1D",
-    "pySilhouetteFirstBP1D",
-    "pyUEqualsUP0D",
-    "pyVertexNatureUP0D",
-    "pyViewMapGradientNormBP1D",
-    "pyZBP1D",
-    "pyZDiscontinuityBP1D",
-    "pyZSmallerUP1D",
-)
-
-
-# module members
-from _freestyle import (
-    ContourUP1D,
-    DensityLowerThanUP1D,
-    EqualToChainingTimeStampUP1D,
-    EqualToTimeStampUP1D,
-    ExternalContourUP1D,
-    FalseBP1D,
-    FalseUP0D,
-    FalseUP1D,
-    Length2DBP1D,
-    QuantitativeInvisibilityUP1D,
-    SameShapeIdBP1D,
-    ShapeUP1D,
-    TrueBP1D,
-    TrueUP0D,
-    TrueUP1D,
-    ViewMapGradientNormBP1D,
-    WithinImageBoundaryUP1D,
-)
-
-# constructs for predicate definition in Python
-from freestyle.types import (
-    BinaryPredicate1D,
-    Id,
-    IntegrationType,
-    Interface0DIterator,
-    Nature,
-    TVertex,
-    UnaryPredicate0D,
-    UnaryPredicate1D,
-)
-from freestyle.functions import (
-    Curvature2DAngleF0D,
-    CurveNatureF1D,
-    DensityF1D,
-    GetCompleteViewMapDensityF1D,
-    GetCurvilinearAbscissaF0D,
-    GetDirectionalViewMapDensityF1D,
-    GetOccludersF1D,
-    GetProjectedXF1D,
-    GetProjectedYF1D,
-    GetProjectedZF1D,
-    GetShapeF1D,
-    GetSteerableViewMapDensityF1D,
-    GetZF1D,
-    QuantitativeInvisibilityF0D,
-    ZDiscontinuityF1D,
-    pyCurvilinearLengthF0D,
-    pyDensityAnisotropyF1D,
-    pyViewMapGradientNormF1D,
-)
-
-from freestyle.utils import material_from_fedge
-
-import random
-
-
-# -- Unary predicates for 0D elements (vertices) -- #
-
-class pyHigherCurvature2DAngleUP0D(UnaryPredicate0D):
-    def __init__(self, a):
-        UnaryPredicate0D.__init__(self)
-        self._a = a
-        self.func = Curvature2DAngleF0D()
-
-    def __call__(self, inter):
-        return (self.func(inter) > self._a)
-
-
-class pyUEqualsUP0D(UnaryPredicate0D):
-    def __init__(self, u, w):
-        UnaryPredicate0D.__init__(self)
-        self._u = u
-        self._w = w
-        self._func = pyCurvilinearLengthF0D()
-
-    def __call__(self, inter):
-        u = self._func(inter)
-        return (u > (self._u - self._w)) and (u < (self._u + self._w))
-
-
-class pyVertexNatureUP0D(UnaryPredicate0D):
-    def __init__(self, nature):
-        UnaryPredicate0D.__init__(self)
-        self._nature = nature
-
-    def __call__(self, inter):
-        return bool(inter.object.nature & self._nature)
-
-
-class pyBackTVertexUP0D(UnaryPredicate0D):
-    """
-    Check whether an Interface0DIterator references a TVertex and is
-    the one that is hidden (inferred from the context).
-    """
-
-    def __init__(self):
-        UnaryPredicate0D.__init__(self)
-        self._getQI = QuantitativeInvisibilityF0D()
-
-    def __call__(self, iter):
-        if not (iter.object.nature & Nature.T_VERTEX) or iter.is_end:
-            return False
-        return self._getQI(iter) != 0
-
-
-class pyParameterUP0DGoodOne(UnaryPredicate0D):
-    def __init__(self, pmin, pmax):
-        UnaryPredicate0D.__init__(self)
-        self._m = pmin
-        self._M = pmax
-
-    def __call__(self, inter):
-        u = inter.u
-        return ((u >= self._m) and (u <= self._M))
-
-
-class pyParameterUP0D(UnaryPredicate0D):
-    def __init__(self, pmin, pmax):
-        UnaryPredicate0D.__init__(self)
-        self._m = pmin
-        self._M = pmax
-        self._func = Curvature2DAngleF0D()
-
-    def __call__(self, inter):
-        c = self._func(inter)
-        b1 = (c > 0.1)
-        u = inter.u
-        b = ((u >= self._m) and (u <= self._M))
-        return (b and b1)
-
-
-# -- Unary predicates for 1D elements (curves) -- #
-
-class AndUP1D(UnaryPredicate1D):
-    def __init__(self, *predicates):
-        UnaryPredicate1D.__init__(self)
-        self.predicates = predicates
-        correct_types = all(isinstance(p, UnaryPredicate1D) for p in self.predicates)
-        if not (correct_types and predicates):
-            raise TypeError("%s: Expected one or more UnaryPredicate1D, got %r" %
-                            (self.__class__.__name__, self.predicates))
-
-    def __call__(self, inter):
-        return all(pred(inter) for pred in self.predicates)
-
-
-class OrUP1D(UnaryPredicate1D):
-    def __init__(self, *predicates):
-        UnaryPredicate1D.__init__(self)
-        self.predicates = predicates
-        correct_types = all(isinstance(p, UnaryPredicate1D) for p in self.predicates)
-        if not (correct_types and predicates):
-            raise TypeError("%s: Expected one or more UnaryPredicate1D, got %r" %
-                            (self.__class__.__name__, self.predicates))
-
-    def __call__(self, inter):
-        return any(pred(inter) for pred in self.predicates)
-
-
-class NotUP1D(UnaryPredicate1D):
-    def __init__(self, pred):
-        UnaryPredicate1D.__init__(self)
-        self.predicate = pred
-
-    def __call__(self, inter):
-        return not self.predicate(inter)
-
-
-class ObjectNamesUP1D(UnaryPredicate1D):
-    def __init__(self, names, negative=False):
-        UnaryPredicate1D.__init__(self)
-        self._names = names
-        self._negative = negative
-
-    def __call__(self, viewEdge):
-        found = viewEdge.viewshape.name in self._names
-        return found if not self._negative else not found
-
-
-class QuantitativeInvisibilityRangeUP1D(UnaryPredicate1D):
-    def __init__(self, qi_start, qi_end):
-        UnaryPredicate1D.__init__(self)
-        self.__getQI = QuantitativeInvisibilityF1D()
-        self.__qi_start = qi_start
-        self.__qi_end = qi_end
-
-    def __call__(self, inter):
-        qi = self.__getQI(inter)
-        return (self.__qi_start <= qi <= self.__qi_end)
-
-
-class pyNFirstUP1D(UnaryPredicate1D):
-    def __init__(self, n):
-        UnaryPredicate1D.__init__(self)
-        self.__n = n
-        self.__count = 0
-
-    def __call__(self, inter):
-        self.__count += 1
-        return (self.__count <= self.__n)
-
-
-class pyHigherLengthUP1D(UnaryPredicate1D):
-    def __init__(self, l):
-        UnaryPredicate1D.__init__(self)
-        self._l = l
-
-    def __call__(self, inter):
-        return (inter.length_2d > self._l)
-
-
-class pyNatureUP1D(UnaryPredicate1D):
-    def __init__(self, nature):
-        UnaryPredicate1D.__init__(self)
-        self._nature = nature
-        self._getNature = CurveNatureF1D()
-
-    def __call__(self, inter):
-        return bool(self._getNature(inter) & self._nature)
-
-
-class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
-    def __init__(self, n, a):
-        UnaryPredicate1D.__init__(self)
-        self._n = n
-        self._a = a
-        self.func = Curvature2DAngleF0D()
-
-    def __call__(self, inter):
-        it = Interface0DIterator(inter)
-        # sum the turns, check against n
-        return sum(1 for _ in it if self.func(it) > self._a) > self._n
-        # interesting fact, the line above is 70% faster than:
-        # return sum(self.func(it) > self._a for _ in it) > self._n
-
-
-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)
-
-    def __call__(self, inter):
-        return (self._func(inter) < self._threshold)
-
-
-class pyLowSteerableViewMapDensityUP1D(UnaryPredicate1D):
-    def __init__(self, threshold, level, integration=IntegrationType.MEAN):
-        UnaryPredicate1D.__init__(self)
-        self._threshold = threshold
-        self._level = level
-        self._integration = integration
-
-    def __call__(self, inter):
-        func = GetSteerableViewMapDensityF1D(self._level, self._integration)
-        return (func(inter) < self._threshold)
-
-
-class pyLowDirectionalViewMapDensityUP1D(UnaryPredicate1D):
-    def __init__(self, threshold, orientation, level, integration=IntegrationType.MEAN):
-        UnaryPredicate1D.__init__(self)
-        self._threshold = threshold
-        self._orientation = orientation
-        self._level = level
-        self._integration = integration
-
-    def __call__(self, inter):
-        func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration)
-        return (func(inter) < self._threshold)
-
-
-class pyHighSteerableViewMapDensityUP1D(UnaryPredicate1D):
-    def __init__(self, threshold, level, integration=IntegrationType.MEAN):
-        UnaryPredicate1D.__init__(self)
-        self._threshold = threshold
-        self._func = GetSteerableViewMapDensityF1D(level, integration)
-
-    def __call__(self, inter):
-        return (self._func(inter) > self._threshold)
-
-
-class pyHighDirectionalViewMapDensityUP1D(UnaryPredicate1D):
-    def __init__(self, threshold, orientation, level, integration=IntegrationType.MEAN, sampling=2.0):
-        UnaryPredicate1D.__init__(self)
-        self._threshold = threshold
-        self._func = GetDirectionalViewMapDensityF1D(orientation, level, integration, sampling)
-
-    def __call__(self, inter):
-        return (self.func(inter) > self._threshold)
-
-
-class pyHighViewMapDensityUP1D(UnaryPredicate1D):
-    def __init__(self, threshold, level, integration=IntegrationType.MEAN, sampling=2.0):
-        UnaryPredicate1D.__init__(self)
-        self._threshold = threshold
-        self._func = GetCompleteViewMapDensityF1D(level, integration, sampling)
-
-    def __call__(self, inter):
-        return (self._func(inter) > self._threshold)
-
-
-class pyDensityFunctorUP1D(UnaryPredicate1D):
-    def __init__(self, wsize, threshold, functor, funcmin=0.0, funcmax=1.0, integration=IntegrationType.MEAN):
-        UnaryPredicate1D.__init__(self)
-        self._threshold = float(threshold)
-        self._functor = functor
-        self._funcmin = float(funcmin)
-        self._funcmax = float(funcmax)
-        self._func = DensityF1D(wsize, integration)
-
-    def __call__(self, inter):
-        res = self._functor(inter)
-        k = (res - self._funcmin) / (self._funcmax - self._funcmin)
-        return (func(inter) < (self._threshold * k))
-
-
-class pyZSmallerUP1D(UnaryPredicate1D):
-    def __init__(self, z, integration=IntegrationType.MEAN):
-        UnaryPredicate1D.__init__(self)
-        self._z = z
-        self.func = GetProjectedZF1D(integration)
-
-    def __call__(self, inter):
-        return (self.func(inter) < self._z)
-
-
-class pyIsOccludedByUP1D(UnaryPredicate1D):
-    def __init__(self, id):
-        UnaryPredicate1D.__init__(self)
-        if not isinstance(id, Id):
-            raise TypeError("pyIsOccludedByUP1D expected freestyle.types.Id, not " + type(id).__name__)
-        self._id = id
-
-    def __call__(self, inter):
-        shapes = GetShapeF1D()(inter)
-        if any(s.id == self._id for s in shapes):
-            return False
-
-        # construct iterators
-        it = inter.vertices_begin()
-        itlast = inter.vertices_end()
-        itlast.decrement()
-
-        vertex = next(it)
-        if type(vertex) is TVertex:
-            eit = vertex.edges_begin()
-            if any(ve.id == self._id for (ve, incoming) in eit):
-                return True
-
-        vertex = next(itlast)
-        if type(vertex) is TVertex:
-            eit = tvertex.edges_begin()
-            if any(ve.id == self._id for (ve, incoming) in eit):
-                return True
-        return False
-
-
-class pyIsInOccludersListUP1D(UnaryPredicate1D):
-    def __init__(self, id):
-        UnaryPredicate1D.__init__(self)
-        self._id = id
-
-    def __call__(self, inter):
-        occluders = GetOccludersF1D()(inter)
-        return any(a.id == self._id for a in occluders)
-
-
-class pyIsOccludedByItselfUP1D(UnaryPredicate1D):
-    def __init__(self):
-        UnaryPredicate1D.__init__(self)
-        self.__func1 = GetOccludersF1D()
-        self.__func2 = GetShapeF1D()
-
-    def __call__(self, inter):
-        lst1 = self.__func1(inter)
-        lst2 = self.__func2(inter)
-        return any(vs1.id == vs2.id for vs1 in lst1 for vs2 in lst2)
-
-
-class pyIsOccludedByIdListUP1D(UnaryPredicate1D):
-    def __init__(self, idlist):
-        UnaryPredicate1D.__init__(self)
-        self._idlist = idlist
-        self.__func1 = GetOccludersF1D()
-
-    def __call__(self, inter):
-        lst1 = self.__func1(inter.object)
-        return any(vs1.id == _id for vs1 in lst1 for _id in self._idlist)
-
-
-class pyShapeIdListUP1D(UnaryPredicate1D):
-    def __init__(self, idlist):
-        UnaryPredicate1D.__init__(self)
-        self._funcs = tuple(ShapeUP1D(_id, 0) for _id in idlist)
-
-    def __call__(self, inter):
-        return any(func(inter) for func in self._funcs)
-
-
-# DEPRECATED
-class pyShapeIdUP1D(UnaryPredicate1D):
-    def __init__(self, _id):
-        UnaryPredicate1D.__init__(self)
-        self._id = _id
-
-    def __call__(self, inter):
-        shapes = GetShapeF1D()(inter)
-        return any(a.id == self._id for a in shapes)
-
-
-class pyHighDensityAnisotropyUP1D(UnaryPredicate1D):
-    def __init__(self, threshold, level, sampling=2.0):
-        UnaryPredicate1D.__init__(self)
-        self._l = threshold
-        self.func = pyDensityAnisotropyF1D(level, IntegrationType.MEAN, sampling)
-
-    def __call__(self, inter):
-        return (self.func(inter) > self._l)
-
-
-class pyHighViewMapGradientNormUP1D(UnaryPredicate1D):
-    def __init__(self, threshold, l, sampling=2.0):
-        UnaryPredicate1D.__init__(self)
-        self._threshold = threshold
-        self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
-
-    def __call__(self, inter):
-        gn = self._GetGradient(inter)
-        return (gn > self._threshold)
-
-
-class pyDensityVariableSigmaUP1D(UnaryPredicate1D):
-    def __init__(self, functor, sigmaMin, sigmaMax, lmin, lmax, tmin,
-                 tmax, integration=IntegrationType.MEAN, sampling=2.0):
-        UnaryPredicate1D.__init__(self)
-        self._functor = functor
-        self._sigmaMin = float(sigmaMin)
-        self._sigmaMax = float(sigmaMax)
-        self._lmin = float(lmin)
-        self._lmax = float(lmax)
-        self._tmin = tmin
-        self._tmax = tmax
-        self._integration = integration
-        self._sampling = sampling
-
-    def __call__(self, inter):
-        result = self._functor(inter) - self._lmin
-        sigma = (self._sigmaMax - self._sigmaMin) / (self._lmax - self._lmin) * result + self._sigmaMin
-        t = (self._tmax - self._tmin) / (self._lmax - self._lmin) * result + self._tmin
-        sigma = max(sigma, self._sigmaMin)
-        self._func = DensityF1D(sigma, self._integration, self._sampling)
-        return (self._func(inter) < t)
-
-
-class pyClosedCurveUP1D(UnaryPredicate1D):
-    def __call__(self, inter):
-        it = inter.vertices_begin()
-        itlast = inter.vertices_end()
-        itlast.decrement()
-        return (next(it).id == next(itlast).id)
-
-
-# -- Binary predicates for 1D elements (curves) -- #
-
-class AndBP1D(BinaryPredicate1D):
-    def __init__(self, *predicates):
-        BinaryPredicate1D.__init__(self)
-        self.predicates = tuple(predicates)
-        correct_types = all(isinstance(p, BinaryPredicate1D) for p in self.predicates)
-        if not (correct_types and predicates):
-            raise TypeError("%s: Expected one or more BinaryPredicate1D, got %r" %
-                            (self.__class__.__name__, self.predicates))
-
-    def __call__(self, i1, i2):
-        return all(pred(i1, i2) for pred in self.predicates)
-
-
-class OrBP1D(BinaryPredicate1D):
-    def __init__(self, *predicates):
-        BinaryPredicate1D.__init__(self)
-        self.predicates = tuple(predicates)
-        correct_types = all(isinstance(p, BinaryPredicate1D) for p in self.predicates)
-        if not (correct_types and predicates):
-            raise TypeError("%s: Expected one or more BinaryPredicate1D, got %r" %
-                            (self.__class__.__name__, self.predicates))
-
-    def __call__(self, i1, i2):
-        return any(pred(i1, i2) for pred in self.predicates)
-
-
-class NotBP1D(BinaryPredicate1D):
-    def __init__(self, predicate):
-        BinaryPredicate1D.__init__(self)
-        self.predicate = predicate
-
-    def __call__(self, i1, i2):
-        return (not self.predicate(i1, i2))
-
-
-class pyZBP1D(BinaryPredicate1D):
-    def __init__(self, iType=IntegrationType.MEAN):
-        BinaryPredicate1D.__init__(self)
-        self.func = GetZF1D(iType)
-
-    def __call__(self, i1, i2):
-        return (self.func(i1) > self.func(i2))
-
-
-class pyProjectedXBP1D(BinaryPredicate1D):
-    def __init__(self, iType=IntegrationType.MEAN):
-        BinaryPredicate1D.__init__(self)
-        self.func = GetProjectedXF1D(iType)
-
-    def __call__(self, i1, i2):
-        return (self.func(i1) > self.func(i2))
-
-
-class pyProjectedYBP1D(BinaryPredicate1D):
-    def __init__(self, iType=IntegrationType.MEAN):
-        BinaryPredicate1D.__init__(self)
-        self.func = GetProjectedYF1D(iType)
-
-    def __call__(self, i1, i2):
-        return (self.func(i1) > self.func(i2))
-
-
-class pyZDiscontinuityBP1D(BinaryPredicate1D):
-    def __init__(self, iType=IntegrationType.MEAN):
-        BinaryPredicate1D.__init__(self)
-        self._GetZDiscontinuity = ZDiscontinuityF1D(iType)
-
-    def __call__(self, i1, i2):
-        return (self._GetZDiscontinuity(i1) > self._GetZDiscontinuity(i2))
-
-
-class pyLengthBP1D(BinaryPredicate1D):
-    def __call__(self, i1, i2):
-        return (i1.length_2d > i2.length_2d)
-
-
-class pySilhouetteFirstBP1D(BinaryPredicate1D):
-    def __call__(self, inter1, inter2):
-        bpred = SameShapeIdBP1D()
-        if (not bpred(inter1, inter2)):
-            return False
-        if (inter1.nature & Nature.SILHOUETTE):
-            return bool(inter2.nature & Nature.SILHOUETTE)
-        return (inter1.nature == inter2.nature)
-
-
-class pyNatureBP1D(BinaryPredicate1D):
-    def __call__(self, inter1, inter2):
-        return (inter1.nature & inter2.nature)
-
-
-class pyViewMapGradientNormBP1D(BinaryPredicate1D):
-    def __init__(self, l, sampling=2.0):
-        BinaryPredicate1D.__init__(self)
-        self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
-
-    def __call__(self, i1, i2):
-        return (self._GetGradient(i1) > self._GetGradient(i2))
-
-
-class pyShuffleBP1D(BinaryPredicate1D):
-    def __init__(self):
-        BinaryPredicate1D.__init__(self)
-        random.seed = 1
-
-    def __call__(self, inter1, inter2):
-        return (random.uniform(0, 1) < random.uniform(0, 1))
-
-
-class MaterialBP1D(BinaryPredicate1D):
-    """Checks whether the two supplied ViewEdges have the same material."""
-
-    def __call__(self, i1, i2):
-        fedges = (fe for ve in (i1, i2) for fe in (ve.first_fedge, ve.last_fedge))
-        materials = {material_from_fedge(fe) for fe in fedges}
-        return len(materials) < 2