Ejemplo n.º 1
0
class UnsortedPriorityQueue(PriorityQueueBase):
    def _find_min(self):
        if self.is_empty():
            raise Empty('Priority queue is empty')
        small = self._data.first()
        walk = self._data.after(small)
        while walk is not None:
            if walk.element() < small.element():
                small = walk
            walk = self._data.after(walk)
        return small

    def __init__(self):
        self._data = PositionalList()

    def __len__(self):
        return len(self._data)

    def add(self, key, value):
        self._data.add_last(self._Item(key, value))

    def min(self):
        p = self._find_min()
        item = p.element()
        return(item._key, item._value)

    def remove_min(self):
        p = self._find_min()
        item = self._data.delete(p)
        return (item._key, item._value)
Ejemplo n.º 2
0
def list_to_positional_list(L):
    pos_list = PositionalList()

    for i in L:
        pos_list.add_last(i)

    return pos_list
def list_to_positional_list(list_):

    new_pos_list = PositionalList()

    for element in list_:
        new_pos_list.add_last(element)
    return new_pos_list
Ejemplo n.º 4
0
class UnsortedPriorityQueue(PriorityQueueBase):
    """ a min-oriented priority queue implemented with an unsorted list """

    def __init__(self):
        """ Create a new empty Priority Queue """
        self._data = PositionalList()

    def _find_min(self):            # nonpublic utility
        """ Return Position of item with min key """
        if self.is_empty():         # method inherited from base class
            raise Exception('Priority queue is empty')
        small = self._data.first()
        walk = self._data.after(small)

    def __len__(self):
        """ Return the number of items in the priority queue. """
        return len(self._data)

    def add(self, key, value):
        """ add a key-value pair. """
        self._data.add_last(self._Item(key, value))

    def min(self):
        """ Return but do not remove (k,v) tuple with min key. """
        p = self._find_min()
        item = p.element()
        return (item._key, item._value)

    def remove_min(self):
        """ Remove and return (k,v) tuple with min key. """
        p = self._find_min()
        item = self._data.delete(p)
        return (item._key, item._value)
Ejemplo n.º 5
0
class SortedPriorityQueue(PriorityQueueBase):
    def __init__(self):
        self._data = PositionalList()

    def __len__(self):
        return len(self._data)

    def add(self, key, value):
        newest = self._Item(key, value)
        walk = self._data.last()
        while walk is not None and newest < walk.element():
            walk = self._data.before(walk)
        if walk is None:
            self._data.add_first(newest)
        else:
            self._data.add_after(walk, newest)

    def min(self):
        if self.is_empty():
            raise Empty('Priority queue is empty')
        p = self._data.first()
        item = p.element()
        return (item._key, item._value)

    def remove_min(self):
        if self.is_empty():
            raise Empty('Priority queue is empty')
        item = self._data.delete(self._data.first())
        return (item._key, item._value)
Ejemplo n.º 6
0
class SortedPriorityQueue(PriorityQueueBase):

    def __init__(self):
        self._data = PositionalList()

    def __len__(self):
        return len(self._data)

    def add(self, key, value):
        new = self._Item(key, value)
        walk = self._data.last()
        while walk is not None and new < walk.element():
            walk = self._data.before(walk)
        if walk is None:
            self._data.add_first(new)
        else:
            self._data.add_before(walk, new)

    def min(self):
        if self.is_empty():
            raise Empty('Priority queue is empty.')
        p = self._data.first()
        item = p.element()
        return item._key, item._value

    def remove_min(self):
        if self.is_empty():
            raise Empty('Priority queue is empty.')
        item = self._data.delete(self._data.first())
        return item._key, item._value
class SortedPriorityQueue(PriorityQueueBase):  # base class defines _Item
    """ A min-oriented priority queue implemented with a sorted list. """
    def __init__(self):
        """ Create a new empty Priority Queue. """
        self._data = PositionalList()

    def __len__(self):
        """ Return the num of items in the priority queue. """
        return len(self._data)

    def add(self, key, value):
        """ Add a key-value pair. """
        newest = self._Item(key, value)  # make new item instance
        walk = self._data.last()  # walk backward looking for smaller key
        while walk is not None and newest < walk.element():
            walk = self._data.before(walk)
        if walk is None:
            self._data.add_first(newest)  # new key is smallest
        else:
            self._data.add_after(walk, newest)  # newest goes after walk

    def min(self):
        """ Return but do not remove (k,v) tuple with min key """
        if self.is_empty():
            raise Exception('Priority queue is empty.')
        p = self._data.first()
        item = p.element()
        return (item._key, item._value)

    def remove_min(self):
        """ Remove and return (k,v) tuple with min key. """
        if self.is_empty():
            raise Exception('Priority queue is empty.')
        item = self._data.delete(self._data.first())
        return (item._key, item._value)
Ejemplo n.º 8
0
class SortedPriorityQueue(PriorityQueueBase):
    """
    A priority queue class storing elements sorted according to priority
    """
    def __init__(self):
        self._data = PositionalList()

    def __len__(self):
        return len(self._data)

    def min(self):
        if self.is_empty():
            raise EmptyException('Priority queue is empty.')
        p = self._data.first()
        return (p.element()._key, p.element()._value)

    def remove_min(self):
        if self.is_empty():
            raise EmptyException('Priority queue is empty.')
        p = self._data.first()
        item = self._data.delete(p)
        return (item._key, item._value)

    def add(self, k, v):
        newest = self._Item(k, v)
        walk = self._data.last()
        while walk is not None and newest < walk.element():
            walk = self._data.before(walk)
        if walk is None:
            self._data.add_first(newest)
        else:
            self._data.add_after(walk, newest)
Ejemplo n.º 9
0
class FavoritesList:
    class _Item:
        __slots__ = '_value', '_count'

        def __init__(self, e):
            self._value = e
            self._count = 0

    def _find_position(self, e):
        walk = self._data.first()
        while walk is not None and walk.element()._value != e:
            walk = self._data.after(walk)
        return walk

    def _move_up(self, p):
        if p != self._data.first():
            cnt = p.element()._count
            walk = self._data.before(p)
            if cnt > walk.element()._count:
                while walk != self._data.first() and cnt > self._data.before(
                        walk).element()._count:
                    walk = self._data.before(walk)
                self._data.add_before(walk, self._data.delete(p))

    def __init__(self):
        self._data = PositionalList()

    def __len__(self):
        return len(self._data)

    def is_empty(self):
        return len(self._data) == 0

    def access(self, e):
        p = self._find_position(e)
        if p is None:
            p = self._data.add_last(self._Item(e))
        p.element()._count += 1
        self._move_up(p)

    def remove(self, e):
        p = self._find_position(e)
        if p is not None:
            self._data.delete(p)

    def top(self, k):
        if not 1 <= k <= len(self):
            raise ValueError('Illegal value for k')
        walk = self._data.first()
        for j in range(k):
            item = walk.element()
            yield item._value
            walk = self._data.after(walk)
Ejemplo n.º 10
0
class UnsortedPriorityQueue(PriorityQueueBase): # base class defines _Item
  """A min-oriented priority queue implemented with an unsorted list."""

  #----------------------------- nonpublic behavior -----------------------------
  def _find_min(self):
    """Return Position of item with minimum key."""
    if self.is_empty():               # is_empty inherited from base class
      raise Exception('Priority queue is empty')
    small = self._data.first()
    walk = self._data.after(small)
    while walk is not None:
      if walk.element() < small.element():
        small = walk
      walk = self._data.after(walk)
    return small

  #------------------------------ public behaviors ------------------------------
  def __init__(self):
    """Create a new empty Priority Queue."""
    self._data = PositionalList()

  def __len__(self):
    """Return the number of items in the priority queue."""
    return len(self._data)

  def add(self, key, value):
    """Add a key-value pair."""
    self._data.add_last(self._Item(key, value))

  def min(self):
    """Return but do not remove (k,v) tuple with minimum key.

    Raise Empty exception if empty.
    """
    p = self._find_min()
    item = p.element()
    return (item._key, item._value)

  def remove_min(self):
    """Remove and return (k,v) tuple with minimum key.

    Raise Empty exception if empty.
    """
    p = self._find_min()
    item = self._data.delete(p)
    return (item._key, item._value)

  def __iter__(self):
    """Generate iteration of the map's keys."""
    for item in self._data:
      yield item  # yield the KEY
Ejemplo n.º 11
0
class sortedPriorityQueue(PriorityQueueBase):  # base class defines _Item
    """A min-oriented priority queue implemented with an unsorted list."""

    #----------------------------- nonpublic behavior -----------------------------

    #------------------------------ public behaviors ------------------------------
    def __init__(self):
        """Create a new empty Priority Queue."""
        self._data = PositionalList()

    def __len__(self):
        """Return the number of items in the priority queue."""
        return len(self._data)

    def add(self, key, value):
        """Add a key-value pair."""
        newest = self._Item(key, value)
        walk = self._data.last()
        while walk is not None and newest < walk.element():
            walk = self._data.before(walk)
        if walk is None:
            self._data.add_first(newest)
        else:
            self._data.add_after(walk, newest)

    def min(self):
        """Return but do not remove (k,v) tuple with minimum key.

    Raise Empty exception if empty.
    """
        if self.is_empty():
            raise Exception("Priority queue is empty")
        p = self._data.first()
        item = p.element()
        return (item._key, item._value)

    def remove_min(self):
        """Remove and return (k,v) tuple with minimum key.

    Raise Empty exception if empty.
    """
        if self.is_empty():
            raise Exception("Priority Queue is empty.")
        item = self._data.delete(self._data.first())
        return (item._key)

    def __iter__(self):
        """Generate iteration of the map's keys."""
        for item in self._data:
            yield item  # yield the KEY

    def insertionSort(self, A):
        for i in A:
            self.add(i, i)
        for i in range(len(A)):
            A[i] = self.remove_min()
Ejemplo n.º 12
0
 def __init__(self):
     self.__verts = list()
     self.__faces = PositionalList()
     self.__polygon_types = list(
     )  # RP: shape of polygon or the name of n-gon
     self.__numberOfVertices = 0  # RP: total number of vertices
     self.__totalPolygons = 0  # RP: total number of faces
     self.__polygons = dict(
     )  # RP: count of each type of faces, 3 squares, 5 pentagons etc
     self.__x_minimum = 0  # RP: minimum of x co-ordinates
     self.__y_minimum = 0  # RP: minimum of y co-ordinates
     self.__z_minimum = 0  # RP: minimum of z co-ordinates
     self.__x_maximum = 0  # RP: maximim of x co-ordinates
     self.__y_maximum = 0  # RP: maximim of y co-ordinates
     self.__z_maximum = 0  # RP: maximim of z co-ordinates
class UnsortedPriorityQueue(PriorityQueueBase): # base class defines _Item
  """A min-oriented priority queue implemented with an unsorted list."""

  #----------------------------- nonpublic behavior -----------------------------
  def _find_min(self):
    """Return Position of item with minimum key."""
    if self.is_empty():               # is_empty inherited from base class
      raise Empty('Priority queue is empty')
    small = self._data.first()
    walk = self._data.after(small)
    while walk is not None:
      if walk.element() < small.element():
        small = walk
      walk = self._data.after(walk)
    return small

  #------------------------------ public behaviors ------------------------------
  def __init__(self):
    """Create a new empty Priority Queue."""
    self._data = PositionalList()

  def __len__(self):
    """Return the number of items in the priority queue."""
    return len(self._data)

  def add(self, key, value):
    """Add a key-value pair."""
    self._data.add_last(self._Item(key, value))

  def min(self):
    """Return but do not remove (k,v) tuple with minimum key.

    Raise Empty exception if empty.
    """
    p = self._find_min()
    item = p.element()
    return (item._key, item._value)

  def remove_min(self):
    """Remove and return (k,v) tuple with minimum key.

    Raise Empty exception if empty.
    """
    p = self._find_min()
    item = self._data.delete(p)
    return (item._key, item._value)
class SortedPriorityQueue(PriorityQueue):
    """
    Implementation of a PriorityQueue using a sorted PositionalList
    Adds items to the list in order
    """
    def __init__(self):
        """
        Creates an empty PriorityQueue
        """
        self._data = PositionalList()

    def __len__(self):
        """
        returns: the number of items in the PriorityQueue
        """
        return len(self._data)

    def add(self, key, value):
        """
        Adds a key-value pair to the PriorityQueue
        """
        new_item = self._Item(key, value)
        walk = self._data.last()
        while walk is not None and new_item < walk.element():
            walk = self._data.before(walk)
        if walk is not None:
            self._data.add_after(walk, new_item)
        else:
            self._data.add_first(new_item)

    def min(self):
        """
        returns: the (k,v) tuple with the minimum key, without removing it
        """
        if self.is_empty():
            raise Empty('Priority Queue is empty')
        p = self._data.first()
        item = p.element()
        return (item._key, item._value)

    def remove_min(self):
        """
        removes the minimum (k,v) tuple from the priority queue
        returns: the (k,v) tuple
        """
        if self.is_empty():
            raise Empty('Priority Queue is empty')
        p = self._data.first()
        item = self._data.delete(p)
        return (item._key, item._value)
Ejemplo n.º 15
0
class UnsortedPriorityQueue(PriorityQueueBase):

    def __init__(self):
        self._data = PositionalList()

    def __len__(self):
        return len(self._data)

    def _find_min(self):
        if self.is_empty():
            raise Empty('Priority queue is empty.')
        min = self._data.first()
        walk = self._data.after(min)
        while walk is not None:
            if walk.element() < min.element():
                min = walk
            walk = self._data.after(min)
        return min

    def add(self, key, value):
        self._data.add_last(self._Item(key, value))

    def min(self):
        p = self._find_min()
        item = p.element()
        return item._key, item._value

    def remove_min(self):
        p = self._find_min()
        item = self._data.delete(p)
        return item._key, item._value
Ejemplo n.º 16
0
class UnsortedPriorityQueue(PriorityQueueBase):
    """
    A priority queue class storing elements in arbitrary order
    """
    def __init__(self):
        self._data = PositionalList()

    def __len__(self):
        return len(self._data)

    def _find_min(self):
        if self.is_empty():
            raise EmptyException("Priority Queue is empty.")
        curr_min = self._data.first()
        walk = self._data.after(curr_min)
        while walk is not None:
            if walk.element() < curr_min.element():
                curr_min = walk
            walk = self._data.after(walk)
        return curr_min

    def min(self):
        p = self._find_min()
        return (p.element()._key, p.element()._value)

    def remove_min(self):
        p = self._find_min()
        item = self._data.delete(p)
        return (item._key, item._value)

    def add(self, k, v):
        self._data.add_last(self._Item(k, v))
Ejemplo n.º 17
0
 def top(self, k):
     if not 1 <= k <= len(self):
         raise ValueError('Illegal value for k')
     temp = PositionalList()
     for item in self._data:
         temp.add_last(item)
     for j in range(k):
         highPos = temp.first()
         walk = temp.after(highPos)
         while walk is not None:
             if walk.element()._count > highPos.element()._count:
                 highPos = walk
         yield highPos.element()._value
         temp.delete(highPos)
Ejemplo n.º 18
0
class SortedPriorityQueue(PriorityQueueBase):  # base class defines _Item
    """A min-oriented priority queue implemented with a sorted list."""

    # ------------------------------ public behaviors ------------------------------
    def __init__(self):
        """Create a new empty Priority Queue."""
        self._data = PositionalList()

    def __len__(self):
        """Return the number of items in the priority queue."""
        return len(self._data)

    def add(self, key, value):
        """Add a key-value pair."""
        newest = self._Item(key, value)
        walk = self._data.last()  # walk backward look for smaller

        while walk and newest < walk.element():
            walk = self._data.before(walk)

        if not walk:
            self._data.add_first(newest)
        else:
            self._data.add_after(walk, newest)

    def min(self):
        """Return but do not remove (k,v) tuple with minimum key.

        Raise Empty exception if empty.
        """
        if self.is_empty():
            raise Empty('Priority Queue is empty')
        first = self._data.first()
        item = first.element()
        return (item._key, item._value)

    def remove_min(self):
        """Remove and return (k,v) tuple with minimum key.

        Raise Empty exception if empty.
        """
        min = self._data.first()
        item = self._data.delete(min)
        return (item._key, item._value)
class SortedPriorityQueue(PriorityQueueBase): # base class defines _Item
  """A min-oriented priority queue implemented with a sorted list."""

  #------------------------------ public behaviors ------------------------------
  def __init__(self):
    """Create a new empty Priority Queue."""
    self._data = PositionalList()

  def __len__(self):
    """Return the number of items in the priority queue."""
    return len(self._data)

  def add(self, key, value):
    """Add a key-value pair."""
    newest = self._Item(key, value)             # make new item instance
    walk = self._data.last()       # walk backward looking for smaller key
    while walk is not None and newest < walk.element():
      walk = self._data.before(walk)
    if walk is None:
      self._data.add_first(newest)              # new key is smallest
    else:
      self._data.add_after(walk, newest)        # newest goes after walk

  def min(self):
    """Return but do not remove (k,v) tuple with minimum key.

    Raise Empty exception if empty.
    """
    if self.is_empty():
      raise Empty('Priority queue is empty.')
    p = self._data.first()
    item = p.element()
    return (item._key, item._value)

  def remove_min(self):
    """Remove and return (k,v) tuple with minimum key.

    Raise Empty exception if empty.
    """
    if self.is_empty():
      raise Empty('Priority queue is empty.')
    item = self._data.delete(self._data.first())
    return (item._key, item._value)
 def top(self, k):
     """Generate sequence of top k elements in terms of access count."""
     if not 1 <= k <= len(self):
         raise ValueError('Illegal value for k')
     # we begin by making a copy of the original list
     temp = PositionalList()
     for item in self._data:  # positional lists support iteration
         temp.add_last(item)
     # we repeatedly find, report, and remove element with largest count
     for j in range(k):
         # find and report next highest from temp
         highPos = temp.first()
         walk = temp.after(highPos)
         while walk is not None:
             if walk.element()._count > highPos.element()._count:
                 highPos = walk
             walk = temp.after(walk)
         # we have found the element with highest count
         yield highPos.element()._value  # report element to user
         temp.delete(highPos)  # remove from temp list
class UnsortedPriorityQueue(PriorityQueue):
    """
    An implementstion of a PriorityQueue
    Store items in an unsorted list
    Requires searching the entire list when accessing items
    """
    def __init__(self):
        """
        Creates an empty PriorityQueue
        """
        self._data = PositionalList()

    def __len__(self):
        """
        returns: the number of items in the PriorityQueue
        """
        return len(self._data)

    def add(self, key, value):
        """
        Adds a key-value pair to the PriorityQueue
        """
        self._data.add_last(self._Item(key, value))

    def _find_min(self):
        """
        Non-public utility method
        returns: the item with the minimum key
        """
        if self.is_empty():
            raise Empty('Priority Queue is empty')
        minimum = self._data.first()
        walk = self._data.after(minimum)
        while walk is not None:
            if walk.element() < minimum.element(
            ):  # __lt__ is implemented by the PriorityQueue class
                minimum = walk
            walk = self._data.after(walk)
        return minimum

    def min(self):
        """
        returns: the (k,v) tuple with the minimum key, without removing it
        """
        p = self._find_min()
        item = p.element()
        return (item._key, item._value)

    def remove_min(self):
        """
        removes the minimum (k,v) tuple from the priority queue
        returns: the (k,v) tuple
        """
        p = self._find_min()
        item = self._data.delete(p)  # PositionalList removes and returns item
        return (item._key, item._value)
Ejemplo n.º 22
0
class SortedPriorityQueue(PriorityQueueBase):
    def __init__(self):
        #empty priority queue
        self._data = PositionalList()

    def __len__(self):
        #number of items in priority queue
        return len(self._data)

    def add(self, key, value):
        #add key-value pair
        #._Item defined by base class
        newest = self._Item(key, value)
        walk = self._data.last()
        #look for smaller key
        while walk is not None and newest < walk.element():
            walk = self._data.before(walk)
        if walk is None:
            self._data.add_first(newest)
        else:
            self._data.add_after(walk, newest)

    def min(self):
        #returns but does not remove the tuple with min key
        if self.is_empty():
            raise Empty('Priority queue is empty.')
        p = self._data.first()
        item = p.element()
        return (item._key, item._value)

    def remove_min(self):
        #removes and returns the tuple with minimum key
        if self.is_empty():
            raise Empty('Priority queue is empty')
        item = self._data.delete(self._data.first())
        return (item._key)

    def __iter__(self):
        #iteration of the map's keys
        for item in self._data:
            yield item
Ejemplo n.º 23
0
class SortedListPQ(PriorityQueueBase):  # base class defines _Item
    """A min-oriented priority queue implemented with an unsorted list."""
    def __init__(self):
        """Create a new empty Priority Queue."""
        self._data = PositionalList()

    def __len__(self):
        """Return the number of items in the priority queue."""
        return len(self._data)

    def add(self, key, value):
        """Add a key-value pair."""
        newest = self._Item(key, value)
        walk = self._data.last()
        while walk is not None and newest < walk.element():
            walk = self._data.before(walk)
        if walk is None:
            self._data.add_first(newest)
        else:
            self._data.add_after(walk, newest)

    def min(self):
        """Return but do not remove (k,v) tuple with minimum key.
    Raise Empty exception if empty.
    """
        if self.is_empty():
            raise Empty("Priority queue is empty")
        p = self._data.first()
        item = p.element()
        return item._key, item._value

    def remove_min(self):
        """Remove and return (k,v) tuple with minimum key.
    Raise Empty exception if empty.
    """
        if self.is_empty():
            raise Empty("Priority queue is empty")
        item = self._data.delete(self._data.first())
        return (item._key, item._value)
    def top(self, k):
        """Generate sequence of top k elements in terms of access count."""
        if not 0 <= k <= len(self):
            raise ValueError("Illegal value for k")

        # we begin my making copy of original list, as we will modify the temprary list
        temp = PositionalList()
        for item in self._data:  # positional list supports iteration
            temp.add_last(item)

        # we repeatedly find, report, and remove elements with largest count from temp list
        for j in range(k):
            # find and report next highest from temp
            highPos = temp.first()
            walk = temp.after(highPos)
            while walk != None:
                if walk.element()._count > highPos.element()._count:
                    highPos = walk
                walk = temp.after(walk)
            # we have found element with the highest count
            yield highPos.element()._value  # report element to user
            temp.delete(
                highPos)  # remove from temp to get next most accessed element
Ejemplo n.º 25
0
def main():
    global screen, polygonList, mainloop

    polygonList = PositionalList()

    mainloop = True

    while mainloop:

        pygame.time.Clock().tick(FPS)
        screen.blit(background, (0, 0))

        update()
        draw()

        pygame.display.update()

    pygame.quit()
Ejemplo n.º 26
0
class PositionalQueue(object):
    """ A queue implementation based on positional list.

    With enqueue returning a position instance and support for a new method,
    delete(p), that removes the element associated with position p from the
    queue.
    """
    def __init__(self):
        self._data = PositionalList()

    def __len__(self):
        """ Length method."""
        return len(self._data)

    def is_empty(self):
        """ check if the queue is empty or not."""
        return len(self._data) == 0

    def first(self):
        """ get the first element of the queue."""
        if self._data.is_empty():
            raise Empty('The queue is empty')
        return self._data.first().element()

    def enqueue(self, e):
        """ add an element to the end of the queue.
        :return: the Position of the element just be enqueued.
        """
        return self._data.add_last(e)

    def dequeue(self):
        """ remove the first element of the queue."""
        self._data.delete(self._data.first())

    def delete(self, p):
        """ Delete the element associated with position p."""
        self._data.delete(p)

    def __repr__(self):
        return str(self._data)
Ejemplo n.º 27
0
    def top(self, k):
        if k < 1 or k > len(self._data):
            raise ValueError("Invalid value for k.")

        tmp = PositionalList()
        for i in range(len(self._data)):
            tmp.add_first(self._data.delete(self._data.first()))

        for i in range(k):
            p = tmp.first()
            p_max = tmp.first()
            max = p.element()._value

            while p != None:
                if p.element()._value > max:
                    p = self._data.after(p)
                    p_max = p.element()
                    max = p_max._value

            yield max
Ejemplo n.º 28
0
 def __init__(self):
   """Create a new empty Priority Queue."""
   self._data = PositionalList()
Ejemplo n.º 29
0
class Mesh:
    '''A polygonal mesh class. Contains a Python list of vertex tuples and
    a positional list of faces that are themselves Python lists.
    '''
    def __init__(self):
        self.__verts = list()
        self.__faces = PositionalList()
        self.__polygon_types = list(
        )  # RP: shape of polygon or the name of n-gon
        self.__numberOfVertices = 0  # RP: total number of vertices
        self.__totalPolygons = 0  # RP: total number of faces
        self.__polygons = dict(
        )  # RP: count of each type of faces, 3 squares, 5 pentagons etc
        self.__x_minimum = 0  # RP: minimum of x co-ordinates
        self.__y_minimum = 0  # RP: minimum of y co-ordinates
        self.__z_minimum = 0  # RP: minimum of z co-ordinates
        self.__x_maximum = 0  # RP: maximim of x co-ordinates
        self.__y_maximum = 0  # RP: maximim of y co-ordinates
        self.__z_maximum = 0  # RP: maximim of z co-ordinates

    def loadOBJ(self, f):
        '''Loads data from an OBJ file and stores it in the __verts and __faces
        data members. Also calculates the X,Y,Z bounds and the counts of
        face's index sizes.
        '''
        with open(f, 'r') as infile:
            text = infile.read()
            lines = text.split('\n')
            for line_number, line_value in enumerate(lines):
                if line_value is not '':
                    elements = line_value.split()
                    if elements[0] == 'v':
                        self.__verts += [
                            (float(elements[1]), float(elements[2]),
                             float(elements[3]))
                        ]
                        self.__numberOfVertices += 1
                    if elements[0] == 'f':
                        face = list()
                        for vertex_index in elements[1:]:
                            face.append(int(vertex_index))
                        self.__faces.add_last(
                            face)  # RP: ist of vertex indexs, face
                        # RP: In len(face) if-statement, counting the number of each type of polygon, if len(face)=3 or
                        # RP: say triangle already exist, add one to it, else start count from 1
                        if len(face) in self.__polygon_types:
                            # RP: self.__polygons is the dictionary of total number of each polygons
                            self.__polygons[len(face)] += 1
                        else:
                            self.__polygon_types.append(len(face))
                            self.__polygons[len(face)] = 1
                        # RP: Adding all types of polygon all in the total polygons
                        self.__totalPolygons += 1

    def get_stats(self):
        '''Gets the stats of the Mesh data:
           - the total number of vertices
           - the total number of polygons
           - the number of polygons of each number of sides
           - the mininum and maximum X, Y, and Z coordinates for
             the entire mesh
        '''
        # MVM: Hint for the total number of polys of each number of
        # of sides, use a dictionary.

        # RP: Made a list of x,y and z elements/coordinates, to get minimum and maximum of each co-ordinates individually

        x_elements = list()
        y_elements = list()
        z_elements = list()

        for vertex in self.__verts:
            x_elements.append(vertex[0])
            y_elements.append(vertex[1])
            z_elements.append(vertex[2])

        self.__x_minimum = min(x_elements)
        self.__y_minimum = min(y_elements)
        self.__z_minimum = min(z_elements)

        self.__x_maximum = max(x_elements)
        self.__y_maximum = max(y_elements)
        self.__z_maximum = max(z_elements)

        stats = {
            "totalVertices": self.__numberOfVertices,
            "totalPolygon": self.__totalPolygons,
            "numberOfPolygons": self.__polygons,
            "minimumXCoordinates": self.__x_minimum,
            "minimumYCoordinates": self.__y_minimum,
            "minimumZCoordinates": self.__z_minimum,
            "maximumXCoordinates": self.__x_maximum,
            "maximumYCoordinates": self.__y_maximum,
            "maximumZCoordinates": self.__z_maximum
        }

        return stats

    def writeVTK(self, outfile):
        '''Writes a VTK legacy ASCII format file from data stored in __verts
        and __faces.
        '''
        with open(outfile, 'w') as outfile:
            # RP: First part of vtk file, uptil vertices
            outfile.write('# vtk DataFile Version 3.0\n')
            outfile.write('An object\n')
            outfile.write('ASCII\n')
            outfile.write('DATASET POLYDATA\n')
            outfile.write('POINTS ' + str(self.__numberOfVertices) +
                          ' float\n')
            for vertex in self.__verts:
                outfile.write(
                    str(vertex[0]) + ' ' + str(vertex[1]) + ' ' +
                    str(vertex[2]) + '\n')
            outfile.write('\n')

            # RP: As in the dictionary {key:value}, typeOfPolygon(tri/4/penta...gon) is the key and numberOfThosePolygon
            # is the value, which together is used to calculate total points for vtk file.
            total_points = 0
            for typeOfPolygon, numberOfThosePolygon in self.__polygons.items():
                total_points += (typeOfPolygon + 1) * numberOfThosePolygon

            outfile.write('POLYGONS ' + str(self.__totalPolygons) + ' ' +
                          str(total_points) + '\n')

            for face in self.__faces:
                outfile.write(str(len(face)) + ' ')
                for vertex_index in face:
                    outfile.write(str(vertex_index - 1) + ' ')
                outfile.write('\n')

    def triangularize(self):
        '''Triangularizes any non-triangles in the face list. It modifes
        the list be replacing non-triangles with two or more triangles. The
        modifcation occurs at the site of the non-triangle.'''

        # RP: Because in Triangulation, we only need to print number of triangles
        if 3 not in self.__polygon_types:
            self.__polygons[3] = 0
            self.__polygon_types.append(3)
        pos = self.__faces.first(
        )  # RP: setting position of the first list in the PositionalList(self.__faces)
        while pos is not None:  # RP: will do one face at a time
            face = pos.element(
            )  # RP: accessing the elements in that position of the list calling it face
            if len(face) > 3:
                for n in range(2,
                               len(face) -
                               1):  # RP: if face is [1 2 3 4] say in square
                    triangle = list()
                    triangle.append(face[0])  # RP: here goes, face[0]=1
                    triangle.extend(
                        face[n:n + 2]
                    )  # RP: here goes a slice of face[2:4], which is 3,4, and is
                    # extended to previous one, making it [1 3 4] face as triangle
                    self.__faces.add_before(
                        pos, triangle
                    )  # RP: Now adding that face [1 3 4] before [1 2 3], similarly all the
                    # triangle face is added before the place where it is cut
                    self.__polygons[3] += 1
                    self.__totalPolygons += 1
                self.__faces.replace(pos,
                                     face[0:3])  # RP: Slice of face [1 2 3]
                self.__polygons[3] += 1
            pos = self.__faces.after(
                pos)  # RP: Giving the position to the next one
        new_polygons = {3: self.__polygons[3]}
        self.__polygons = new_polygons

    def __repr__(self):
        '''Print user-friendly representation of the Mesh object.'''
        # MVM: have this call get_stats()

        output = 'This is a 3D object which consists of {} type(s) of polygon(s).\n'.format(
            len(self.__polygons))
        output += 'Polygon stats:\n'
        try:
            output += '\tTotal Vertices:{0:>16}\n'.format(
                self.get_stats()['totalVertices'])
            output += '\tTotal Polygons:{0:>16}\n'.format(
                self.get_stats()['totalPolygon'])
            for key, values in self.get_stats()['numberOfPolygons'].items():
                output += '\tTotal {0} sided polygon:{1:>9}\n'.format(
                    key, values)
            output += '\tMinimum x coordinate:{0:>10.2f}\n'.format(
                self.get_stats()['minimumXCoordinates'])
            output += '\tMaximum x coordinate:{0:>10.2f}\n'.format(
                self.get_stats()['maximumXCoordinates'])
            output += '\tMinimum y coordinate:{0:>10.2f}\n'.format(
                self.get_stats()['minimumYCoordinates'])
            output += '\tMaximum y coordinate:{0:>10.2f}\n'.format(
                self.get_stats()['maximumYCoordinates'])
            output += '\tMinimum z coordinate:{0:>10.2f}\n'.format(
                self.get_stats()['minimumZCoordinates'])
            output += '\tMaximum z coordinate:{0:>10.2f}\n'.format(
                self.get_stats()['maximumZCoordinates'])
        except:
            output += 'NO DATA\n'
        return output
class FavoritesList:
    """List of elements ordered from most frequently accessed to least."""

    # ------------------------------ nested _Item class ------------------------------
    class _Item:
        __slots__ = '_value', '_count'  # streamline memory usage

        def __init__(self, e):
            self._value = e  # the user's element
            self._count = 0  # access count initially zero

    # ------------------------------- nonpublic utilities -------------------------------
    def _find_position(self, e):
        """Search for element e and return its Position (or None if not found)."""
        walk = self._data.first()
        while walk is not None and walk.element()._value != e:
            walk = self._data.after(walk)
        return walk

    def _move_up(self, p):
        """Move item at Position p earlier in the list based on access count."""
        if p != self._data.first():  # consider moving...
            cnt = p.element()._count
            walk = self._data.before(p)
            if cnt > walk.element()._count:  # must shift forward
                while (walk != self._data.first() and
                               cnt > self._data.before(walk).element()._count):
                    walk = self._data.before(walk)
                self._data.add_before(walk, self._data.delete(p))  # delete/reinsert

    # ------------------------------- public methods -------------------------------
    def __init__(self):
        """Create an empty list of favorites."""
        self._data = PositionalList()  # will be list of _Item instances

    def __len__(self):
        """Return number of entries on favorites list."""
        return len(self._data)

    def is_empty(self):
        """Return True if list is empty."""
        return len(self._data) == 0

    def access(self, e):
        """Access element e, thereby increasing its access count."""
        p = self._find_position(e)  # try to locate existing element
        if p is None:
            p = self._data.add_last(self._Item(e))  # if new, place at end
        p.element()._count += 1  # always increment count
        self._move_up(p)  # consider moving forward

    def remove(self, e):
        """Remove element e from the list of favorites."""
        p = self._find_position(e)  # try to locate existing element
        if p is not None:
            self._data.delete(p)  # delete, if found

    def top(self, k):
        """Generate sequence of top k elements in terms of access count."""
        if not 1 <= k <= len(self):
            raise ValueError('Illegal value for k')
        walk = self._data.first()
        for j in range(k):
            item = walk.element()  # element of list is _Item
            yield item._value  # report user's element
            walk = self._data.after(walk)

    def __repr__(self):
        """Create string representation of the favorites list."""
        return ', '.join('({0}:{1})'.format(i._value, i._count) for i in self._data)
Ejemplo n.º 31
0
 def __init__(self):
     #empty priority queue
     self._data = PositionalList()
Ejemplo n.º 32
0
 def __init__(self):
     self._data = PositionalList()
Ejemplo n.º 33
0
class FavoritesList:
    """List of elements ordered from most frequently accessed to least."""

    # ------------------------------ nested _Item class -----------------------
    class _Item:
        __slots__ = "_value", "_count"  # streamline memory usage

        def __init__(self, e):
            self._value = e  # the user's element
            self._count = 0  # access count initially zero

    # ------------------------------- nonpublic utilities ---------------------
    def _find_position(self, e):
        """Search for element e and return its Position (or None if not found)."""
        walk = self._data.first()
        while walk is not None and walk.element()._value != e:
            walk = self._data.after(walk)
        return walk

    def _move_up(self, p):
        """Move item at Position p earlier in the list based on access count."""
        if p != self._data.first():  # consider moving...
            cnt = p.element()._count
            walk = self._data.before(p)
            if cnt > walk.element()._count:  # must shift forward
                while walk != self._data.first() and cnt > self._data.before(walk).element()._count:
                    walk = self._data.before(walk)
                self._data.add_before(walk, self._data.delete(p))  # delete/reinsert

    # ------------------------------- public methods --------------------------
    def __init__(self):
        """Create an empty list of favorites."""
        self._data = PositionalList()  # will be list of _Item instances

    def __len__(self):
        """Return number of entries on favorites list."""
        return len(self._data)

    def is_empty(self):
        """Return True if list is empty."""
        return len(self._data) == 0

    def access(self, e):
        """Access element e, thereby increasing its access count."""
        p = self._find_position(e)  # try to locate existing element
        if p is None:
            p = self._data.add_last(self._Item(e))  # if new, place at end
        p.element()._count += 1  # always increment count
        self._move_up(p)  # consider moving forward

    def remove(self, e):
        """Remove element e from the list of favorites."""
        p = self._find_position(e)  # try to locate existing element
        if p is not None:
            self._data.delete(p)  # delete, if found

    def top(self, k):
        """Generate sequence of top k elements in terms of access count."""
        if not 1 <= k <= len(self):
            raise ValueError("Illegal value for k")
        walk = self._data.first()
        for j in range(k):
            item = walk.element()  # element of list is _Item
            yield item._value  # report user's element
            walk = self._data.after(walk)

    def __repr__(self):
        """Create string representation of the favorites list."""
        return ", ".join("({0}:{1})".format(i._value, i._count) for i in self._data)
Ejemplo n.º 34
0
 def __init__(self):
     """Create an empty list of favorites."""
     self._data = PositionalList()  # will be list of _Item instances
Ejemplo n.º 35
0
 def __init__(self):
     self._data = PositionalList()
 def __init__(self):
     """Create an empty list of favorites."""
     self._data = PositionalList()  # will be list of _Item instances
    """Print all elements of PositionalList as a string."""
    print(", ".join([str(elem) for elem in L]))


def clear_positional_list(L):
    """Delete all elements from PositionalList."""
    pos1 = L.first()
    while len(L) > 0:
        pos2 = L.after(pos1)
        L.delete(pos1)
        pos1 = pos2


if __name__ == "__main__":
    # Test 1: print_positional_list(), clear_positional_list()
    PL = PositionalList()
    for i in range(0, 38, 2):
        PL.add_last(i)
    print("before deletion:")
    print_positional_list(PL)
    print("length =", len(PL))
    clear_positional_list(PL)
    print("after deletion:")
    print_positional_list(PL)
    print("length =", len(PL))

    # Test 2: print_positional_list(), clear_positional_list()
    print()
    PL.add_last("apple")
    PL.add_last("orange")
    PL.add_last("pear")
 def __init__(self):
   """Create a new empty Priority Queue."""
   self._data = PositionalList()