@tushar-br/editing-pack 1.0.188 → 1.0.190

package/staging_area/Blender/5.0/scripts/addons_core/rigify/utils/naming.py

@@ -1,366 +0,0 @@
-# SPDX-FileCopyrightText: 2019-2022 Blender Foundation
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-import random
-import time
-import re
-import collections
-import enum
-
-from typing import Optional, TYPE_CHECKING
-
-
-if TYPE_CHECKING:
-    from ..base_generate import BaseGenerator
-
-
-ORG_PREFIX = "ORG-"  # Prefix of original bones.
-MCH_PREFIX = "MCH-"  # Prefix of mechanism bones.
-DEF_PREFIX = "DEF-"  # Prefix of deformation bones.
-ROOT_NAME = "root"   # Name of the root bone.
-
-_PREFIX_TABLE = {'org': "ORG", 'mch': "MCH", 'def': "DEF", 'ctrl': ''}
-
-########################################################################
-# Name structure
-########################################################################
-
-NameParts = collections.namedtuple('NameParts', ['prefix', 'base', 'side_z', 'side', 'number'])
-
-
-def split_name(name: str):
-    name_parts = re.match(
-        r'^(?:(ORG|MCH|DEF)-)?(.*?)([._-][tTbB])?([._-][lLrR])?(?:\.(\d+))?$', name)
-    return NameParts(*name_parts.groups())
-
-
-def is_control_bone(name: str):
-    return not split_name(name).prefix
-
-
-def combine_name(parts: NameParts, *, prefix=None, base=None, side_z=None, side=None, number=None):
-    eff_prefix = prefix if prefix is not None else parts.prefix
-    eff_number = number if number is not None else parts.number
-    if isinstance(eff_number, int):
-        eff_number = '%03d' % eff_number
-
-    return ''.join([
-        eff_prefix + '-' if eff_prefix else '',
-        base if base is not None else parts.base,
-        side_z if side_z is not None else parts.side_z or '',
-        side if side is not None else parts.side or '',
-        '.' + eff_number if eff_number else '',
-    ])
-
-
-def insert_before_lr(name: str, text: str) -> str:
-    parts = split_name(name)
-
-    if parts.side:
-        return combine_name(parts, base=parts.base + text)
-    else:
-        return name + text
-
-
-def make_derived_name(name: str, subtype: str, suffix: Optional[str] = None):
-    """ Replaces the name prefix, and optionally adds the suffix (before .LR if found).
-    """
-    assert(subtype in _PREFIX_TABLE)
-
-    parts = split_name(name)
-    new_base = parts.base + (suffix or '')
-
-    return combine_name(parts, prefix=_PREFIX_TABLE[subtype], base=new_base)
-
-
-########################################################################
-# Name mirroring
-########################################################################
-
-class Side(enum.IntEnum):
-    LEFT = -1
-    MIDDLE = 0
-    RIGHT = 1
-
-    @staticmethod
-    def from_parts(parts: NameParts):
-        if parts.side:
-            if parts.side[1].lower() == 'l':
-                return Side.LEFT
-            else:
-                return Side.RIGHT
-        else:
-            return Side.MIDDLE
-
-    @staticmethod
-    def to_string(parts: NameParts, side: 'Side'):
-        if side != Side.MIDDLE:
-            side_char = 'L' if side == Side.LEFT else 'R'
-            side_str = parts.side or parts.side_z
-
-            if side_str:
-                sep, side_char2 = side_str[0:2]
-                if side_char2.lower() == side_char2:
-                    side_char = side_char.lower()
-            else:
-                sep = '.'
-
-            return sep + side_char
-        else:
-            return ''
-
-    @staticmethod
-    def to_name(parts: NameParts, side: 'Side'):
-        new_side = Side.to_string(parts, side)
-        return combine_name(parts, side=new_side)
-
-
-class SideZ(enum.IntEnum):
-    TOP = 2
-    MIDDLE = 0
-    BOTTOM = -2
-
-    @staticmethod
-    def from_parts(parts: NameParts):
-        if parts.side_z:
-            if parts.side_z[1].lower() == 't':
-                return SideZ.TOP
-            else:
-                return SideZ.BOTTOM
-        else:
-            return SideZ.MIDDLE
-
-    @staticmethod
-    def to_string(parts: NameParts, side: 'SideZ'):
-        if side != SideZ.MIDDLE:
-            side_char = 'T' if side == SideZ.TOP else 'B'
-            side_str = parts.side_z or parts.side
-
-            if side_str:
-                sep, side_char2 = side_str[0:2]
-                if side_char2.lower() == side_char2:
-                    side_char = side_char.lower()
-            else:
-                sep = '.'
-
-            return sep + side_char
-        else:
-            return ''
-
-    @staticmethod
-    def to_name(parts: NameParts, side: 'SideZ'):
-        new_side = SideZ.to_string(parts, side)
-        return combine_name(parts, side_z=new_side)
-
-
-NameSides = collections.namedtuple('NameSides', ['base', 'side', 'side_z'])
-
-
-def get_name_side(name: str):
-    return Side.from_parts(split_name(name))
-
-
-def get_name_side_z(name: str):
-    return SideZ.from_parts(split_name(name))
-
-
-def get_name_base_and_sides(name: str):
-    parts = split_name(name)
-    base = combine_name(parts, side='', side_z='')
-    return NameSides(base, Side.from_parts(parts), SideZ.from_parts(parts))
-
-
-def change_name_side(name: str,
-                     side: Optional[Side] = None, *,
-                     side_z: Optional[SideZ] = None):
-    parts = split_name(name)
-    new_side = None if side is None else Side.to_string(parts, side)
-    new_side_z = None if side_z is None else SideZ.to_string(parts, side_z)
-    return combine_name(parts, side=new_side, side_z=new_side_z)
-
-
-def mirror_name(name: str):
-    parts = split_name(name)
-    side = Side.from_parts(parts)
-
-    if side != Side.MIDDLE:
-        return Side.to_name(parts, -side)
-    else:
-        return name
-
-
-def mirror_name_z(name: str):
-    parts = split_name(name)
-    side = SideZ.from_parts(parts)
-
-    if side != SideZ.MIDDLE:
-        return SideZ.to_name(parts, -side)
-    else:
-        return name
-
-
-########################################################################
-# Name manipulation
-########################################################################
-
-def get_name(bone) -> Optional[str]:
-    return bone.name if bone else None
-
-
-def strip_trailing_number(name: str):
-    return combine_name(split_name(name), number='')
-
-
-def strip_prefix(name: str):
-    return combine_name(split_name(name), prefix='')
-
-
-def unique_name(collection, base_name: str):
-    parts = split_name(base_name)
-    name = combine_name(parts, number='')
-    count = 1
-
-    while name in collection:
-        name = combine_name(parts, number=count)
-        count += 1
-
-    return name
-
-
-def strip_org(name: str):
-    """ Returns the name with ORG_PREFIX stripped from it.
-    """
-    if name.startswith(ORG_PREFIX):
-        return name[len(ORG_PREFIX):]
-    else:
-        return name
-
-
-org_name = strip_org
-
-
-def strip_mch(name: str):
-    """ Returns the name with MCH_PREFIX stripped from it.
-        """
-    if name.startswith(MCH_PREFIX):
-        return name[len(MCH_PREFIX):]
-    else:
-        return name
-
-
-def strip_def(name: str):
-    """ Returns the name with DEF_PREFIX stripped from it.
-        """
-    if name.startswith(DEF_PREFIX):
-        return name[len(DEF_PREFIX):]
-    else:
-        return name
-
-
-def org(name: str):
-    """ Prepends the ORG_PREFIX to a name if it doesn't already have
-        it, and returns it.
-    """
-    if name.startswith(ORG_PREFIX):
-        return name
-    else:
-        return ORG_PREFIX + name
-
-
-make_original_name = org
-
-
-def mch(name: str):
-    """ Prepends the MCH_PREFIX to a name if it doesn't already have
-        it, and returns it.
-    """
-    if name.startswith(MCH_PREFIX):
-        return name
-    else:
-        return MCH_PREFIX + name
-
-
-make_mechanism_name = mch
-
-
-def deformer(name: str):
-    """ Prepends the DEF_PREFIX to a name if it doesn't already have
-        it, and returns it.
-    """
-    if name.startswith(DEF_PREFIX):
-        return name
-    else:
-        return DEF_PREFIX + name
-
-
-make_deformer_name = deformer
-
-
-def random_id(length=8):
-    """ Generates a random alphanumeric id string.
-    """
-    t_length = int(length / 2)
-    r_length = int(length / 2) + int(length % 2)
-
-    chars = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f',
-             'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
-             'x', 'y', 'z']
-    text = ""
-    for i in range(0, r_length):
-        text += random.choice(chars)
-    text += str(hex(int(time.time())))[2:][-t_length:].rjust(t_length, '0')[::-1]
-    return text
-
-
-def choose_derived_bone(generator: 'BaseGenerator', original: str, subtype: str, *,
-                        by_owner=True, recursive=True):
-    bones = generator.obj.pose.bones
-    names = generator.find_derived_bones(original, by_owner=by_owner, recursive=recursive)
-
-    direct = make_derived_name(original, subtype)
-    if direct in names and direct in bones:
-        return direct
-
-    prefix = _PREFIX_TABLE[subtype] + '-'
-    matching = [name for name in names if name.startswith(prefix) and name in bones]
-
-    if len(matching) > 0:
-        return matching[0]
-
-    # Try matching bones created by legacy rigs just by name - there is no origin data
-    from ..base_generate import LegacyRig
-
-    if isinstance(generator.bone_owners.get(direct), LegacyRig):
-        if not by_owner or generator.bone_owners.get(original) is generator.bone_owners[direct]:
-            assert direct in bones
-            return direct
-
-    return None
-
-
-_MIRROR_MAP_RAW = [
-    ("Left", "Right"),
-    ("L", "R"),
-]
-_MIRROR_MAP = {
-    **{a: b for a, b in _MIRROR_MAP_RAW},
-    **{b: a for a, b in _MIRROR_MAP_RAW},
-    **{a.lower(): b.lower() for a, b in _MIRROR_MAP_RAW},
-    **{b.lower(): a.lower() for a, b in _MIRROR_MAP_RAW},
-}
-_MIRROR_RE = [
-    r"(?<![a-z])(left|light)(?![a-z])",
-    r"(?<=[\._])(l|r)(?![a-z])",
-]
-
-
-def mirror_name_fuzzy(name: str) -> str:
-    """Try to mirror a name by trying various patterns without expecting any rigid structure."""
-
-    for reg in _MIRROR_RE:
-        new_name = re.sub(reg, lambda m: _MIRROR_MAP.get(m[0], m[0]), name, flags=re.IGNORECASE)
-        if new_name != name:
-            return new_name
-
-    return name

package/staging_area/Blender/5.0/scripts/addons_core/rigify/utils/node_merger.py

@@ -1,345 +0,0 @@
-# SPDX-FileCopyrightText: 2021-2022 Blender Foundation
-#
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-import collections
-
-from typing import Any, Sequence, Optional
-from mathutils import Vector
-from mathutils.kdtree import KDTree
-
-from .errors import MetarigError
-from .misc import ArmatureObject
-from ..base_rig import BaseRig, GenerateCallbackHost
-from ..base_generate import GeneratorPlugin
-
-
-class NodeMerger(GeneratorPlugin):
-    """
-    Utility that allows rigs to interact based on common points in space.
-
-    Rigs can register node objects representing locations during the
-    initialize stage, and at the end the plugin sorts them into buckets
-    based on proximity. For each such bucket a group object is created
-    and allowed to further process the nodes.
-
-    Nodes chosen by the groups as being 'final' become sub-objects of
-    the plugin and receive stage callbacks.
-
-    The domain parameter allows potentially having multiple completely
-    separate layers of nodes with different purpose.
-    """
-
-    epsilon = 1e-5
-
-    nodes: list['BaseMergeNode']
-    final_nodes: list['BaseMergeNode']
-    groups: list['MergeGroup']
-
-    def __init__(self, generator, domain: Any):
-        """
-        Construct a new merger instance.
-
-        @param domain: An arbitrary identifier to allow multiple independent merging domains.
-        """
-        super().__init__(generator)
-
-        assert domain is not None
-        assert generator.stage == 'initialize'
-
-        self.domain = domain
-        self.nodes = []
-        self.final_nodes = []
-        self.groups = []
-        self.frozen = False
-
-    def register_node(self, node: 'BaseMergeNode'):
-        """
-        Add a new node to generation, before merging is frozen.
-        """
-        assert not self.frozen
-        node.generator_plugin = self
-        self.nodes.append(node)
-
-    def initialize(self):
-        self.frozen = True
-
-        nodes = self.nodes
-        tree = KDTree(len(nodes))
-
-        for i, node in enumerate(nodes):
-            tree.insert(node.point, i)
-
-        tree.balance()
-        processed = set()
-        final_nodes = []
-        groups = []
-
-        for i in range(len(nodes)):
-            if i in processed:
-                continue
-
-            # Find points to merge
-            pending = [i]
-            merge_set = set(pending)
-
-            while pending:
-                added = set()
-                for j in pending:
-                    point = nodes[j].point
-                    eps = max(1.0, point.length) * self.epsilon
-                    for co, idx, dist in tree.find_range(point, eps):
-                        added.add(idx)
-                pending = added.difference(merge_set)
-                merge_set.update(added)
-
-            assert merge_set.isdisjoint(processed)
-
-            processed.update(merge_set)
-
-            # Group the points
-            merge_list = [nodes[i] for i in merge_set]
-            merge_list.sort(key=lambda x: x.name)
-
-            group_class = merge_list[0].group_class
-
-            for item in merge_list[1:]:
-                cls = item.group_class
-
-                if issubclass(cls, group_class):
-                    group_class = cls
-                elif not issubclass(group_class, cls):
-                    raise MetarigError(
-                        'Group class conflict: {} and {} from {} of {}'.format(
-                            group_class, cls, item.name, item.rig.base_bone,
-                        )
-                    )
-
-            group = group_class(merge_list)
-            group.build(final_nodes)
-
-            groups.append(group)
-
-        self.final_nodes = self.rigify_sub_objects = final_nodes
-        self.groups = groups
-
-
-class MergeGroup(object):
-    """
-    Standard node group, merges nodes based on certain rules and priorities.
-
-    1. Nodes are classified into main and query nodes; query nodes are not merged.
-    2. Nodes owned by the same rig cannot merge with each other.
-    3. Node can only merge into target if node.can_merge_into(target) is true.
-    4. Among multiple candidates in one rig, node.get_merge_priority(target) is used.
-    5. The largest clusters of nodes that can merge are picked until none are left.
-
-    The master nodes of the chosen clusters, plus query nodes, become 'final'.
-    """
-
-    main_nodes: list['MainMergeNode']    # All main nodes in the group.
-    query_nodes: list['QueryMergeNode']  # All query nodes in the group.
-    final_nodes: list['MainMergeNode']   # All main nodes not merged into any other node.
-
-    def __init__(self, nodes: list['BaseMergeNode']):
-        self.nodes = nodes
-
-        for node in nodes:
-            assert isinstance(node, (MainMergeNode, QueryMergeNode))
-            node.group = self
-
-        self.main_nodes = [n for n in nodes if isinstance(n, MainMergeNode)]
-        self.query_nodes = [n for n in nodes if isinstance(n, QueryMergeNode)]
-
-    def build(self, final_nodes):
-        main_nodes = self.main_nodes
-
-        # Sort nodes into rig buckets - can't merge within the same rig
-        rig_table = collections.defaultdict(list)
-
-        for node in main_nodes:
-            rig_table[node.rig].append(node)
-
-        # Build a 'can merge' table
-        merge_table = {n: set() for n in main_nodes}
-
-        for node in main_nodes:
-            for rig, tgt_nodes in rig_table.items():
-                if rig is not node.rig:
-                    nodes = [n for n in tgt_nodes if node.can_merge_into(n)]
-                    if nodes:
-                        best_node = max(nodes, key=node.get_merge_priority)
-                        merge_table[best_node].add(node)
-
-        # Output groups starting with largest
-        self.final_nodes = []
-
-        pending = set(main_nodes)
-
-        while pending:
-            # Find the largest group
-            nodes = [n for n in main_nodes if n in pending]
-            max_len = max(len(merge_table[n]) for n in nodes)
-
-            nodes = [n for n in nodes if len(merge_table[n]) == max_len]
-
-            # If a tie, try to resolve using comparison
-            if len(nodes) > 1:
-                weighted_nodes = [
-                    (n, sum(
-                        1 if (n.is_better_cluster(n2)
-                              and not n2.is_better_cluster(n)) else 0
-                        for n2 in nodes
-                    ))
-                    for n in nodes
-                ]
-                max_weight = max(wn[1] for wn in weighted_nodes)
-                nodes = [wn[0] for wn in weighted_nodes if wn[1] == max_weight]
-
-            # Final tiebreaker is the name
-            best = min(nodes, key=lambda n: n.name)
-            child_set = merge_table[best]
-
-            # Link children
-            best.point = sum((c.point for c in child_set),
-                             best.point) / (len(child_set) + 1)
-
-            for child in [n for n in main_nodes if n in child_set]:
-                child.point = best.point
-                best.merge_from(child)
-                child.merge_into(best)
-
-            final_nodes.append(best)
-            self.final_nodes.append(best)
-
-            best.merge_done()
-
-            # Remove merged nodes from the table
-            pending.remove(best)
-            pending -= child_set
-
-            for children in merge_table.values():
-                children &= pending
-
-        for node in self.query_nodes:
-            node.merge_done()
-
-        final_nodes += self.query_nodes
-
-
-class BaseMergeNode(GenerateCallbackHost):
-    """Base class of merge-able nodes."""
-
-    rig: BaseRig
-    obj: ArmatureObject
-    name: str
-    point: Vector
-
-    merge_domain: Any = None
-    merger = NodeMerger
-    group_class = MergeGroup
-
-    generator_plugin: NodeMerger
-    group: MergeGroup
-
-    def __init__(self, rig: BaseRig, name: str, point: Vector | Sequence[float], *,
-                 domain: Any = None):
-        self.rig = rig
-        self.obj = rig.obj
-        self.name = name
-        self.point = Vector(point)
-
-        merger = self.merger(rig.generator, domain or self.merge_domain)
-        merger.register_node(self)
-
-    def register_new_bone(self, new_name: str, old_name: Optional[str] = None):
-        self.generator_plugin.register_new_bone(new_name, old_name)
-
-    def can_merge_into(self, other: 'MainMergeNode') -> bool:
-        """Checks if this main or query node can merge into the specified master node."""
-        raise NotImplementedError
-
-    def get_merge_priority(self, other: 'MainMergeNode') -> float:
-        """Rank potential candidates to merge into."""
-        return 0
-
-    def merge_done(self):
-        """Called after all merging operations are complete."""
-        pass
-
-
-class MainMergeNode(BaseMergeNode):
-    """
-    Base class of standard merge-able nodes. Each node can either be
-    a master of its cluster or a merged child node. Children become
-    sub-objects of their master to receive callbacks in defined order.
-    """
-
-    merged_master: 'MainMergeNode'          # Master of this merge cluster; may be self.
-    merged_into: Optional['MainMergeNode']  # Master of this cluster if not self.
-    merged: list['MainMergeNode']           # List of nodes merged into this one.
-
-    def __init__(self, rig, name, point, *, domain=None):
-        super().__init__(rig, name, point, domain=domain)
-
-        self.merged_into = None
-        self.merged = []
-
-    def get_merged_siblings(self):
-        """Retrieve the list of all nodes merged together with this one,
-         starting with the master node."""
-        master = self.merged_master
-        return [master, *master.merged]
-
-    def is_better_cluster(self, other: 'MainMergeNode'):
-        """Compare with the other node to choose between cluster masters."""
-        return False
-
-    # noinspection PyMethodMayBeStatic
-    def can_merge_from(self, _other: 'MainMergeNode'):
-        """Checks if the other node can be merged into this one."""
-        return True
-
-    def can_merge_into(self, other: 'MainMergeNode'):
-        """Checks if this node can merge into the specified master."""
-        return other.can_merge_from(self)
-
-    def merge_into(self, other: 'MainMergeNode'):
-        """Called when it's decided to merge this node into a different master node."""
-        self.merged_into = other
-
-    def merge_from(self, other: 'MainMergeNode'):
-        """Called when it's decided to merge a different node into this master node."""
-        self.merged.append(other)
-
-    @property
-    def is_master_node(self):
-        """Returns if this node is a master of a merge cluster."""
-        return not self.merged_into
-
-    def merge_done(self):
-        self.merged_master = self.merged_into or self
-        self.rigify_sub_objects = list(self.merged)
-
-        for child in self.merged:
-            child.merge_done()
-
-
-# noinspection PyAbstractClass
-class QueryMergeNode(BaseMergeNode):
-    """Base class for special nodes used only to query which nodes are at a certain location."""
-
-    is_master_node = False
-    require_match = True
-
-    matched_nodes: list['MainMergeNode']  # Master nodes this query matched with.
-
-    def merge_done(self):
-        self.matched_nodes = [
-            n for n in self.group.final_nodes if self.can_merge_into(n)
-        ]
-        self.matched_nodes.sort(key=self.get_merge_priority, reverse=True)
-
-        if self.require_match and not self.matched_nodes:
-            self.rig.raise_error(
-                'Could not match control node for {}', self.name)