Example #1
0
 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
     #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
Example #3
0
    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
        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
Example #6
0
    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 traverse(self, iter):
        winner = None
        it = AdjacencyIterator(iter)
        while not it.is_end:
            ve = it.object
            if self._isExternalContour(ve):
                if ve.time_stamp == CF.get_time_stamp():
                    winner = ve
            it.increment()

        self._nEdges = self._nEdges+1
        if winner is None:
            orient = 1
            it = AdjacencyIterator(iter)
            while not it.is_end:
                ve = it.object
                if it.is_incoming:
                    orient = 0
                good = self.checkViewEdge(ve,orient)
                if good != 0:
                    winner = ve
                it.increment()
        return winner
Example #8
0
    def traverse(self, iter):
        winner = None
        it = AdjacencyIterator(iter)
        while not it.is_end:
            ve = it.object
            if self._isExternalContour(ve):
                if ve.time_stamp == CF.get_time_stamp():
                    winner = ve
            it.increment()

        self._nEdges = self._nEdges + 1
        if winner is None:
            orient = 1
            it = AdjacencyIterator(iter)
            while not it.is_end:
                ve = it.object
                if it.is_incoming:
                    orient = 0
                good = self.checkViewEdge(ve, orient)
                if good != 0:
                    winner = ve
                it.increment()
        return winner
 def init(self):
     self._timeStamp = CF.get_time_stamp() + self._nRounds
 def __init__(self, nRounds=3, stayInSelection=True):
     ChainingIterator.__init__(self, stayInSelection, False, None, True)
     self._timeStamp = CF.get_time_stamp() + nRounds
     self._nRounds = nRounds
     self.t = False
Example #11
0
 def __init__(self, length):
     ChainingIterator.__init__(self, False, True, None, True)
     self._length = float(length)
     self.timestamp = CF.get_time_stamp()
Example #12
0
 def __init__(self, percent):
     ChainingIterator.__init__(self, False, True, None, True)
     self._length = 0.0
     self._percent = float(percent)
     self.timestamp = CF.get_time_stamp()
Example #13
0
 def init(self):
     self._timeStamp = CF.get_time_stamp() + self._nRounds
    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)
                # if not, let's check whether it's short enough with
                # respect to the chain made without staying in the selection
                #------------------------------------------------------------
                # Did we compute the prospective chain length already ?
                if self._length == 0:
                    #if not, let's do it
                    _it = pyChainSilhouetteGenericIterator(False, False)
                    _it.begin = winner
                    _it.current_edge = winner
                    _it.orientation = winnerOrientation
                    _it.init()
                    while not _it.is_end:
                        ve = _it.object
                        #print("--------", ve.id.first, ve.id.second)
                        self._length = self._length + ve.length_2d
                        _it.increment()
                        if _it.is_begin:
                            break;
                    _it.begin = winner
                    _it.current_edge = winner
                    _it.orientation = winnerOrientation
                    if not _it.is_begin:
                        _it.decrement()
                        while (not _it.is_end) and (not _it.is_begin):
                            ve = _it.object
                            #print("--------", ve.id.first, ve.id.second)
                            self._length = self._length + ve.length_2d
                            _it.decrement()

                # let's do the comparison:
                # 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._percent * self._length) or (connexl > self._absLength):
                    winner = None
        return winner
Example #15
0
    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)
                # if not, let's check whether it's short enough with
                # respect to the chain made without staying in the selection
                #------------------------------------------------------------
                # Did we compute the prospective chain length already ?
                if self._length == 0:
                    #if not, let's do it
                    _it = pyChainSilhouetteGenericIterator(False, False)
                    _it.begin = winner
                    _it.current_edge = winner
                    _it.orientation = winnerOrientation
                    _it.init()
                    while not _it.is_end:
                        ve = _it.object
                        #print("--------", ve.id.first, ve.id.second)
                        self._length = self._length + ve.length_2d
                        _it.increment()
                        if _it.is_begin:
                            break
                    _it.begin = winner
                    _it.current_edge = winner
                    _it.orientation = winnerOrientation
                    if not _it.is_begin:
                        _it.decrement()
                        while (not _it.is_end) and (not _it.is_begin):
                            ve = _it.object
                            #print("--------", ve.id.first, ve.id.second)
                            self._length = self._length + ve.length_2d
                            _it.decrement()

                # let's do the comparison:
                # 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._percent * self._length) or (
                        connexl > self._absLength):
                    winner = None
        return winner
 def __init__(self, percent):
     ChainingIterator.__init__(self, False, True, None, True)
     self._length = 0.0
     self._percent = float(percent)
     self.timestamp = CF.get_time_stamp()
 def __init__(self, length):
     ChainingIterator.__init__(self, False, True, None, True)
     self._length = float(length)
     self.timestamp = CF.get_time_stamp()
Example #18
0
 def __init__(self, nRounds=3, stayInSelection=True):
     ChainingIterator.__init__(self, stayInSelection, False, None, True)
     self._timeStamp = CF.get_time_stamp() + nRounds
     self._nRounds = nRounds
     self.t = False