Python utils.ContextFunctions类代码示例

def process(layer_name, lineset_name):
    scene = getCurrentScene()
    layer = scene.render.layers[layer_name]
    lineset = layer.freestyle_settings.linesets[lineset_name]
    linestyle = lineset.linestyle

    selection_criteria = []
    # prepare selection criteria by visibility
    if lineset.select_by_visibility:
        if lineset.visibility == 'VISIBLE':
            selection_criteria.append(
                QuantitativeInvisibilityUP1D(0))
        elif lineset.visibility == 'HIDDEN':
            selection_criteria.append(
                NotUP1D(QuantitativeInvisibilityUP1D(0)))
        elif lineset.visibility == 'RANGE':
            selection_criteria.append(
                QuantitativeInvisibilityRangeUP1D(lineset.qi_start, lineset.qi_end))
    # prepare selection criteria by edge types
    if lineset.select_by_edge_types:
        edge_type_criteria = []
        if lineset.select_silhouette:
            upred = pyNatureUP1D(Nature.SILHOUETTE)
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_silhouette else upred)
        if lineset.select_border:
            upred = pyNatureUP1D(Nature.BORDER)
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_border else upred)
        if lineset.select_crease:
            upred = pyNatureUP1D(Nature.CREASE)
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_crease else upred)
        if lineset.select_ridge_valley:
            upred = pyNatureUP1D(Nature.RIDGE)
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_ridge_valley else upred)
        if lineset.select_suggestive_contour:
            upred = pyNatureUP1D(Nature.SUGGESTIVE_CONTOUR)
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_suggestive_contour else upred)
        if lineset.select_material_boundary:
            upred = pyNatureUP1D(Nature.MATERIAL_BOUNDARY)
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_material_boundary else upred)
        if lineset.select_edge_mark:
            upred = pyNatureUP1D(Nature.EDGE_MARK)
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_edge_mark else upred)
        if lineset.select_contour:
            upred = ContourUP1D()
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_contour else upred)
        if lineset.select_external_contour:
            upred = ExternalContourUP1D()
            edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_external_contour else upred)
        if lineset.edge_type_combination == 'OR':
            upred = OrUP1D(*edge_type_criteria)
        else:
            upred = AndUP1D(*edge_type_criteria)
        if upred is not None:
            if lineset.edge_type_negation == 'EXCLUSIVE':
                upred = NotUP1D(upred)
            selection_criteria.append(upred)
    # prepare selection criteria by face marks
    if lineset.select_by_face_marks:
        if lineset.face_mark_condition == 'BOTH':
            upred = FaceMarkBothUP1D()
        else:
            upred = FaceMarkOneUP1D()

        if lineset.face_mark_negation == 'EXCLUSIVE':
            upred = NotUP1D(upred)
        selection_criteria.append(upred)
    # prepare selection criteria by group of objects
    if lineset.select_by_group:
        if lineset.group is not None:
            names = {ob.name: True for ob in lineset.group.objects}
            upred = ObjectNamesUP1D(names, lineset.group_negation == 'EXCLUSIVE')
            selection_criteria.append(upred)
    # prepare selection criteria by image border
    if lineset.select_by_image_border:
        upred = WithinImageBoundaryUP1D(*ContextFunctions.get_border())
        selection_criteria.append(upred)
    # select feature edges
    upred = AndUP1D(*selection_criteria)
    if upred is None:
        upred = TrueUP1D()
    Operators.select(upred)
    # join feature edges to form chains
    if linestyle.use_chaining:
        if linestyle.chaining == 'PLAIN':
            if linestyle.use_same_object:
                Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
            else:
                Operators.bidirectional_chain(ChainPredicateIterator(upred, TrueBP1D()), NotUP1D(upred))
        elif linestyle.chaining == 'SKETCHY':
            if linestyle.use_same_object:
                Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(linestyle.rounds))
            else:
                Operators.bidirectional_chain(pySketchyChainingIterator(linestyle.rounds))
    else:
        Operators.chain(ChainPredicateIterator(FalseUP1D(), FalseBP1D()), NotUP1D(upred))
    # split chains
    if linestyle.material_boundary:
        Operators.sequential_split(MaterialBoundaryUP0D())
    if linestyle.use_angle_min or linestyle.use_angle_max:
        angle_min = linestyle.angle_min if linestyle.use_angle_min else None
#.........这里部分代码省略.........

 def __call__(self, iter):
     p = iter.object.point_2d
     gx = CF.read_complete_view_map_pixel(self._l, int(p.x+self._step), int(p.y)) - \
         CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
     gy = CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y+self._step)) - \
         CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
     return Vector((gx, gy))

 def traverse(self, iter):
     winner = None
     winnerOrientation = False
     #print(self.current_edge.id.first, self.current_edge.id.second)
     it = AdjacencyIterator(iter)
     tvertex = self.next_vertex
     if type(tvertex) is TVertex:
         mateVE = tvertex.get_mate(self.current_edge)
         while not it.is_end:
             ve = it.object
             if ve.id == mateVE.id:
                 winner = ve
                 winnerOrientation = not it.is_incoming
                 break
             it.increment()
     else:
         ## case of NonTVertex
         natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.MATERIAL_BOUNDARY,Nature.EDGE_MARK,
                    Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
         for nat in natures:
             if (self.current_edge.nature & nat) != 0:
                 count=0
                 while not it.is_end:
                     ve = it.object
                     if (ve.nature & nat) != 0:
                         count = count+1
                         winner = ve
                         winnerOrientation = not it.is_incoming
                     it.increment()
                 if count != 1:
                     winner = None
                 break
     if winner is not None:
         # check whether this edge was part of the selection
         if winner.time_stamp != CF.get_time_stamp():
             #print("---", winner.id.first, winner.id.second)
             # nw let's compute the length of this connex non selected part:
             connexl = 0
             _cit = pyChainSilhouetteGenericIterator(False, False)
             _cit.begin = winner
             _cit.current_edge = winner
             _cit.orientation = winnerOrientation
             _cit.init()
             while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():
                 ve = _cit.object
                 #print("-------- --------", ve.id.first, ve.id.second)
                 connexl = connexl + ve.length_2d
                 _cit.increment()
             if connexl > self._length:
                 winner = None
     return winner

    def traverse(self, iter):
        winner = None
        winnerOrientation = False
        it = AdjacencyIterator(iter)
        ## case of TVertex
        vertex = self.next_vertex
        if type(vertex) is TVertex:
            mate = vertex.get_mate(self.current_edge)
            winner = find_matching_vertex(mate.id, it)
            winnerOrientation = not it.is_incoming if not it.is_end else False
        ## case of NonTVertex
        else:
            for nat in NATURES:
                if (self.current_edge.nature & nat):
                    for ve in it:
                        if (ve.nature & nat):
                            if winner is not None:
                                return None
                            winner = ve
                            winnerOrientation = not it.is_incoming
                    break

        if winner is not None and winner.time_stamp != CF.get_time_stamp():

                if self._length == 0.0:
                    self._length = get_chain_length(winner, winnerOrientation)

                connexl = 0.0
                _cit = pyChainSilhouetteGenericIterator(False, False)
                _cit.begin = winner
                _cit.current_edge = winner
                _cit.orientation = winnerOrientation
                _cit.init()
                while (not _cit.is_end) and _cit.object.time_stamp != CF.get_time_stamp():
                    connexl += _cit.object.length_2d
                    _cit.increment()
                    if _cit.is_begin:
                        break

                if (connexl > self._percent * self._length) or (connexl > self._absLength):
                    return None
        return winner

    def traverse(self, iter):
        winner = None
        self._nEdges += 1

        it = AdjacencyIterator(iter)
        time_stamp = CF.get_time_stamp()

        for ve in it:
            if self.ExternalContour(ve) and ve.time_stamp == time_stamp:
                winner = ve

        if winner is None:
            it = AdjacencyIterator(iter)
            for ve in it:
                if self.checkViewEdge(ve, not it.is_incoming):
                    winner = ve

        return winner

 def shade(self, stroke):
     fe = CF.get_selected_fedge()
     id1 = fe.first_svertex.id
     id2 = fe.second_svertex.id
     #print(id1.first, id1.second)
     #print(id2.first, id2.second)
     it = stroke.stroke_vertices_begin()
     found = True
     foundfirst = True
     foundsecond = False
     while not it.is_end:
         cp = it.object
         if cp.first_svertex.id == id1 or cp.second_svertex.id == id1:
             foundfirst = True
         if cp.first_svertex.id == id2 or cp.second_svertex.id == id2:
             foundsecond = True
         if foundfirst and foundsecond:
             found = True
             break
         it.increment()
     if found:
         print("The selected Stroke id is: ", stroke.id.first, stroke.id.second)

 def __init__(self, length):
     ChainingIterator.__init__(self, False, True, None, True)
     self._length = float(length)
     self.timestamp = CF.get_time_stamp()

 def init(self):
     self._timeStamp = CF.get_time_stamp() + self._nRounds