Ejemplo n.º 1
0
def divideBy2(num):
    remstack = Stack()

    while num > 0:
        rem = num % 2
        remstack.push(rem)
        num = num // 2
class DirectedCycle:
	def __init__(self,digraph):
		self.marked = [False] * (digraph.v + 1)
		self.edgeTo = [None] * (digraph.v +1)
		self.cycle = None
		self.onStack = [False] * (digraph.v +1)

		for v in range(digraph.v +1):
			if self.marked[v] is False:
				self._dfs(digraph,v)

	def _dfs(self,dg,v):
		self.onStack[v] = True
		self.marked[v] = True
		for w in dg.adj(v):
			if (self.hasCycle()):
				return 
			elif (self.marked[w] is False):
				self.edgeTo[w] = v
				self._dfs(dg,w)
			elif(self.onStack[w]):
				self.cycle = Stack()
				x = self.edgeTo[v]
				while(x != w):
					self.cycle.push(x)
				self.cycle.push(w)
				self.cycle.push(v)

		self.onStack[v] = False

	def hasCycle(self):
		return self.cycle is not None
def TestInput(inputStr):
    s = Stack();

    for i in inputStr:

        if i == '(' or i == '[' or i == '{':

            s.push(i)

        elif i == ')' or i == ']' or i == '}':

            temp = s.pop()

            if temp == '(':

                if i == ']' or i == '}':
                    return False

            elif temp == '[':

                if i == '(' or i == '}':
                    return False

            if temp == '{':

                if i == ']' or i == ')':
                    return False

    return True
class DepthFirstOrder:
	def __init__(self,digraph):
		self._pre = Queue()
		self._post = Queue()
		self._reversePost = Stack()
		self._marked = [False] * (digraph.v +1)

		for v in range(digraph.v +1):
			if self._marked[v] is False:
				self._dfs(digraph,v)

	def _dfs(self,dg,v):
		self._pre.enqueue(v)
		self._marked[v] = True

		for w in dg.adj(v):
			if self._marked[w] is False:
				self._dfs(dg,w)

		self._post.enqueue(v)
		self._reversePost.push(v)

	def pre(self):
		return self._pre

	def post(self):
		return self._post

	def reversePost(self):
		return self._reversePost
class Queue(object):

    def __init__(self):
        self.newStack = Stack()
        self.oldStack = Stack()

    def add(self, item):
        self.newStack.push(item)

    def remove(self):
        if self.oldStack.isEmpty():
            self.transferStacks()

        return self.oldStack.pop()

    def peek(self):
        if self.oldStack.isEmpty():
            self.transferStacks()

        return self.oldStack.pop()

    def transferStacks(self):
        while not self.newStack.isEmpty():
            popped = self.newStack.pop()
            self.oldStack.push(popped)
Ejemplo n.º 6
0
 def genrate_actualtour(self, StartCity):
     """
     This method generates the graph of the bestTour. 
     
     It calls the move_branch method with a given StartCity. From the bestTour
     stack it filters out only the interestCities by leaving out all the 
     intersection points. It then creates an instance of graph class in the same
     order as in bestTour.
     """
     tour = Stack()  # create a new stack
     
     self.currentTour.push(StartCity)    # push the startCity in currentTour stack
     self.mark_visit(StartCity)  # mark it visited
     self.move_branch(StartCity) # call move_branch recursive function, with the given city
     
     # The following block of code removes vertices from bestTour and filters out
     # only the interest points and adds it to tour Stack
     while self.bestTour.size() != 0:    
         city = self.bestTour.pop()
         if city in self.interestCities:
             tour.push(city)
             
     # The following block of code generates a Graph object from the tour Stack
     newGraph = Graph(tour.items)    # adds only the vertices in the graph
     for i in range(len(tour.items)-1):
         newEdge = Edge(tour.items[i], tour.items[i+1])  # create an edge within two consecutive vertices
         newGraph.add_edge(newEdge)  # add the edge to the graph
     return newGraph
Ejemplo n.º 7
0
def rev_str(str):
    s = Stack()
    for i in str:
        s.push(i)
    rev = ""
    while not s.is_empty():
        rev += s.pop()
    return rev
Ejemplo n.º 8
0
def reverse(a):
    stack = Stack()
    for x in a:
        stack.push(x)
    answer = ""
    while not stack.isEmpty():
        answer = answer + stack.pop()
    return answer
Ejemplo n.º 9
0
	def __init__(self, diskNumber = 4):
		assert(diskNumber > 0)
		self.diskNumber = diskNumber
		self.towerA = Stack()
		self.towerB = Stack()
		self.towerC = Stack()
		for i in xrange(diskNumber):
			diskIndex = diskNumber - i
			self.towerA.push(diskIndex)
Ejemplo n.º 10
0
def reverseString(stringToReverse):
	stackList = Stack()
	for char in stringToReverse:
		stackList.push(char)

	newString = ""
	while not stackList.isEmpty():
		newString += stackList.pop()
	return newString
Ejemplo n.º 11
0
def decToBin(dec):
    remStack = Stack()
    bin = ''
    while dec > 0:
        remStack.push(dec % 2)
        dec //= 2
    while not remStack.isEmpty():
        bin += str(remStack.pop())
    return bin
Ejemplo n.º 12
0
def sortStack(stacks):
    buffer = Stack()
    while(stacks.size !=0):
        temp = stacks.pop()
        while(buffer.size !=0 and temp < buffer.peek()):
            stacks.push(buffer.pop())
        buffer.push(temp)

    return buffer
Ejemplo n.º 13
0
    def test_len(self):
        '''
        Test Len
        :return:
        '''
        s = Stack()
        s.push("One")

        self.assertEquals(1,len(s))
Ejemplo n.º 14
0
 def __init__(self, cities=[]):
     self.currentTour = Stack()
     self.bestTour = Stack()
     self.currentCost = 0
     self.bestCost = 10000000000000000000000000000000
     self.interestCities = [Vertex(city) for city in cities]
     self._map = Graph()
     self._visitedPoints = []
     self._visitedCities = []
Ejemplo n.º 15
0
def tenToTwo(toConvert):
    stack = Stack()
    while toConvert > 0:
        stack.push(toConvert % 2)
        toConvert = toConvert // 2    # integer division
    answer = ""
    while not stack.isEmpty():
        answer = answer + str(stack.pop())
    return answer
Ejemplo n.º 16
0
def sortStack(s):
	stackA = s
	stackB = Stack()
	while not stackA.isEmpty():
		maxm = popA(stackA)
		pushB(stackA, stackB, maxm)

	while not stackB.isEmpty():
		stackA.push(stackB.pop())
Ejemplo n.º 17
0
    def testLen(self):
        #initialize the stack
        s = Stack()
        #push three itmes into the stack
        for i in range(3):
            s.push(i)

        #Check the length
        self.assertEqual(len(s),3)
def revstring(mystr):
	myStack = Stack()
	for ch in mystr:
		myStack.push(ch)
	revstr=''
	while not myStack.isEmpty():
		revstr = revstr + myStack.pop()
		
	return revstr
Ejemplo n.º 19
0
 def printContents(self):
     s = Stack()
     print("Contents of Stack " + str(self.index))
     while not self.stack.empty():
         disk = self.stack.pop()
         print(disk)
         s.push(disk)
         
     while not s.empty():
         self.stack.push(s.pop())
Ejemplo n.º 20
0
def buildParseTree(fpexp):
    fplist = fpexp.split()
    pStack = Stack()
    eTree = BinaryTree('')
    pStack.push(eTree)
    currentTree = eTree
    for i in fplist:
        if i == '(':
            currentTree.insertLeft('')
            pStack.push(currentTree)
            currentTree = currentTree.getLeftChild()
        elif i not in ['+', '-', '*', '/', ')']:
            currentTree.setRootVal(int(i))
            parent = pStack.pop()
            currentTree = parent
        elif i in ['+', '-', '*', '/']:
            currentTree.setRootVal(i)
            currentTree.insertRight('')
            pStack.push(currentTree)
            currentTree = currentTree.getRightChild()
        elif i == ')':
            currentTree = pStack.pop()
        else:
            raise ValueError
    return eTree
Ejemplo n.º 21
0
class StackWithMin(Stack):

    def __init__(self, *args, **kwargs):
        super(StackWithMin, self).__init__(*args, **kwargs)
        self.min_stack = Stack()

    def push(self, data):
        new_node = Node(data)
        new_node.set_next(self.head)
        self.head = new_node

        try:
            min = self.min_stack.peek()
            if data <= min:
                self.min_stack.push(data)
        except Stack.Empty:
            self.min_stack.push(data)

    def pop(self):
        value = super(StackWithMin, self).pop()
        if value == self.min_stack.peek():
            self.min_stack.pop()
        return value

    def min(self):
        return self.min_stack.peek()
Ejemplo n.º 22
0
 def TopologicalSort(self):
     s = Stack(len(self.V) + 1)
     S = []
     for v in self.V:
         v.parent = None
         v.colour = white
         v.d = v.f = inf
     time = 0
     s.push(self.V[0])
     while not s.isEmpty():
         v = s.top()
         if v.colour == white:
             v.colour = grey
             v.d = time = time + 1
         for u in v.adjacent:
             if u.colour == white:
                 u.parent = v
                 s.push(u)
                 break
         if u.colour != white:
             v.f = time = time + 1
             v.colour = black
             S.insert(0, v)
             s.pop()
     return S
Ejemplo n.º 23
0
 def __init__(self):
     """Initializes all of the instance variables"""
     self.myCurrent	= None	# my currently displayed card
     self.otherCurrent = None	# other currently displayed card
     self.currentState = 0	# keeps track of the state of play
     self.dealingPile = Stack()	# stack
     self.myPlayingPile = Stack()	# stack 
     self.myStoragePile = Queue()# queue
     self.otherPlayingPile	= Stack()# stack 
     self.otherStoragePile	= Queue()# queue
     self.lootPile = Queue()		# queue
Ejemplo n.º 24
0
def devBy2(Number):
    storageStack = Stack()
    binaryData = ""
    while Number > 0:
        storageStack.push(Number%2)
        Number = Number // 2

    while not storageStack.isEmpty():
        binaryData = binaryData + str(storageStack.pop())

    return binaryData
def binaryConverter(decimal_number):
    # defined for whole numbers ( n > 0)
    s = Stack()
    
    while decimal_number > 0:
        s.push( decimal_number % 2 )
        decimal_number = decimal_number // 2
    binary_string = ''
    while not s.is_empty():
        binary_string += str( s.pop() )
    return binary_string
Ejemplo n.º 26
0
def save_poles(poles):
    # duplicating poles
    a, b, c = Stack(), Stack(), Stack()

    a.copyFrom(poles[0])
    b.copyFrom(poles[1])
    c.copyFrom(poles[2])
    
    saved = [a, b, c]
    
    return saved
Ejemplo n.º 27
0
    def testpopEmpty_empty(self):
        # First of a series of tests to check proper exception being thrown by a
        # violation of precondition.  In this case, the pop() from an empty stack.
        s = Stack()

        #first Test Case
        try:
            val = s.pop()
            self.assertTrue(False, "No exception / or not right type of excpetion rasied for pop of empty stack")
        except IndexError:
            self.assertTrue(True)
def revStr(strToRev):
    s = Stack()

    for x in strToRev:
        s.push(x)

    a = ''
    while not s.isEmpty():
        a = a + s.pop()
    
    return a
Ejemplo n.º 29
0
def devByX(Number, base):
    digits="0123456789ABCDEF"
    storageStack = Stack()
    binaryData = ""
    while Number > 0:
        storageStack.push(Number%base)
        Number = Number // base

    while not storageStack.isEmpty():
        binaryData = binaryData + digits[storageStack.pop()]

    return binaryData
Ejemplo n.º 30
0
def reverseString(st):
    s = Stack()
    stLen = len(st)
    for i in range(stLen):
        s.push(st[i])

    outStr = []
    for i in range(stLen):
        outStr.append(s.pop())

    rev = ''.join(outStr)
    return rev
Ejemplo n.º 31
0
 def __init__(self):
     self.stack1 = Stack()
     self.stack2 = Stack()
Ejemplo n.º 32
0
from Stack import Stack

arrayStack = Stack()

arrayStack.push(5)  # contents: [5]
arrayStack.push(3)  # contents: [5, 3]
print(arrayStack.size())  # contents: [5, 3]; outputs 2
print(arrayStack.pop())  # contents: [5]; outputs 3
print(arrayStack.isEmpty())  # contents: [5]; outputs False
print(arrayStack.pop())  # contents: [ ]; outputs 5
print(arrayStack.isEmpty())  # contents: [ ]; outputs True
arrayStack.push(7)  # contents: [7]
arrayStack.push(9)  # contents: [7, 9]
print(arrayStack.top())  # contents: [7, 9]; outputs 9
arrayStack.push(4)  # contents: [7, 9, 4]
print(arrayStack.size())  # contents: [7, 9, 4]; outputs 3
print(arrayStack.pop())  # contents: [7, 9]; outputs 4
arrayStack.push(6)  # contents: [7, 9, 6]
Ejemplo n.º 33
0
 def push(self, item):
     if self.list[-1].size() == self.stackSize:
         self.list.append(Stack())
     self.list[-1].push(item)
Ejemplo n.º 34
0
 def __init__(self, stackSize=5):
     self.list = []
     self.list.append(Stack())
     self.stackSize = stackSize
Ejemplo n.º 35
0
class LaberintoADT:
    '''
0 pasillo, 1 pared, S salida y E entrada
pasillo es una tupla ((2, 1), (2, 2), (2, 3 ), (2, 4), (3, 2), (4, 2))
entrada en una tupla (5, 1)
salida (2, 5)
    '''
    def __init__(self, rens, cols, pasillos, entrada, salida):
        self.__laberinto = Array2D(rens, cols, '1')
        for pasillo in pasillos:
            self.__laberinto.set_item(pasillo[0], pasillo[1], '0')
        self.set_entrada(entrada[0], entrada[1])
        self.set_salida(salida[0], salida[1])
        self.__camino = Stack()
        self.__previa = None #Guardará la posición previa 


    def to_string(self): #Muestra el laberinto
        self.__laberinto.to_string()

#Establece la entrada 'E' en la matriz, verificar límites.

    def set_entrada(self, ren, col):
        # Terminar la validación de las coordenadas
        self.__laberinto.set_item(ren, col, 'E')

#Establece la salida 'S' en la matriz, verificar límites periféricos

    def set_salida(self, ren, col):
        #Terminar las validaciiones
        self.__laberinto.set_item(ren, col, 'S')

    def es_salida(self, ren, col):
        return self.__laberinto.get_item(ren, col) == 'S'

    def buscar_entrada(self): #Busca la posición de la entrada y la mete a la pila
        encontrado = False
        for renglon in range(self.__laberinto.get_num_rows()):
            for columna in range(self.__laberinto.get_num_cols()):
                tope = self.__camino.peek() #Tupla
                if self.__laberinto.get_item(tope[0, tope[1]]) == 'E':
                    self.__camino.push((renglon, columna))
                    encontrado = True
        return encontrado

    def set_previa(self, pos_previa):
        self.__previa = pos_previa

    def get_previa(self):
        return self.__previa

    def imprimir_camino(self):
        self.__camino.to_string()

    def get_pos_actual(self):
        return self.__camino.peek()

    def resolver_laberinto(self): #Aplicar reglas 
        actual = self.__camino.peek() #(5, 2)
        #Buscar izquierda
        if actual[1]-1 != -1 \ 
        and self.__laberinto.get_item(actual[0], actual[1]-1) == '0' \ 
        and self.get_previa() != (actualactual[0], actual[1]-1) \ 
        and self.__laberinto.get_item(actual[0], actual[1]-1) != 'X':
            self.set_previa(actual)
            self.__camino.push((actual[0], actual[1]-1))

        #Buscar arriba
        elif actual[1]-1 != -1 \ 
        and self.__laberinto.get_item(actual[0]-1, actual[1]) == '0' \ 
        and self.get_previa() != (actualactual[0]-1, actual[1]) \ 
        and self.__laberinto.get_item(actual[0]-1, actual[1]-1) != 'X':
            self.set_previa(actual)
            self.__camino.push((actual[0]-1, actual[1]))

       #Buscar derecha
        elif 1==0:
            pass

        #Buscar abajo
        elif 1==0:
            pass

        else:
            self.__laberinto.set_item(actual[0] actual[1], 'X')
            self.__previa = actual
            self.__camino.pop()
Ejemplo n.º 36
0
from Stack import Stack


def sort_stack(stack):
    if stack.isEmpty():
        return stack

    out = Stack()

    while not stack.isEmpty():
        temp = stack.pop()
        while not out.isEmpty() and out.peek() > temp:
            stack.push(out.pop())
        out.push(temp)

    return out


arr = [1, 4, 10, 5, 6]
stack = Stack()
for n in arr:
    stack.push(n)
sorted_stack = sort_stack(stack)
out = []
while not sorted_stack.isEmpty():
    x = sorted_stack.pop()
    out.append(x)
print(out)
from Stack import Stack

s = Stack()

print(s.isEmpty())
s.push(10)
s.push(20)
s.push(30)
print(s.pop())
print(s.peek())
print(s.size())
from Stack import Stack

stack = Stack()
stack.push(5)
stack.push(6)
print stack.pop()

stack.push(7)
print stack.pop()

print stack.pop()

print stack.pop()
Ejemplo n.º 39
0
from Stack import Stack

stack = Stack()
assert stack.is_empty() is True
stack.push(1)
assert stack.is_empty() is False
stack.push(2)
assert stack.size() == 2
assert stack.peek() == 2
assert stack.size() == 2
assert stack.pop() == 2
assert stack.size() == 1
assert stack.peek() == 1
assert stack.size() == 1
assert stack.pop() == 1
assert stack.size() == 0
assert stack.is_empty() is True
Ejemplo n.º 40
0
def p_match(expression):
    # if type(expression) is not '<class \'str\'>':
    #     raise Exception("Passed object is not String, its",type(expression))
    brackets = ["(", "[", "{", ")", "]", "}"]
    right_bracket = brackets[3:]
    left_bracket = brackets[:2]
    eqn_str = expression
    # eqn_str = "[(){()[]}]"
    eqn_stack = Stack()
    for x in eqn_str:
        if x in brackets:
            eqn_stack.push(x)
    s = Stack()

    i = eqn_stack.get_top()
    while i:
        i -= 1
        # print("\nTop:", eqn_stack.get_top())
        if eqn_stack.get_data() in right_bracket:
            #     print("Right Bracket")
            s.push(eqn_stack.pop())
            # print("s top:", s.get_top())
        else:
            # print("Left Bracket")
            # print("s top:", s.get_top())
            if eqn_stack.get_data() == '[':
                if s.get_data() == ']':
                    # print("Match")
                    eqn_stack.pop()
                    s.pop()
            elif eqn_stack.get_data() == '(':
                if s.get_data() == ')':
                    # print("Match")
                    eqn_stack.pop()
                    s.pop()

            elif eqn_stack.get_data() == '{':
                if s.get_data() == '}':
                    # print("Match")
                    eqn_stack.pop()
                    s.pop()
    if s.get_top() == eqn_stack.get_top():
        return 1
    else:
        return 0
Ejemplo n.º 41
0
class UI:

    LOAD_TAB = 0
    ALIGN_TAB = 1
    STACK_TAB = 2
    SHARPEN_TAB = 3

    TITLE = "AstraStack"
    VERSION = "2.0.0"

    def __init__(self):
        self.parentConn, self.childConn = Pipe(duplex=True)
        self.pids = []
        self.newVersionUrl = ""
        self.video = None
        self.align = None
        self.stack = None
        self.sharpen = None
        self.mousePosition = None
        self.clickedDriftP1 = False
        self.clickedDriftP2 = False
        self.clickedAreaOfInterest = False

        self.builder = Gtk.Builder()
        self.builder.add_from_file("ui/ui.glade")

        self.window = self.builder.get_object("mainWindow")
        self.saveDialog = self.builder.get_object("saveDialog")
        self.openDialog = self.builder.get_object("openDialog")
        self.tabs = self.builder.get_object("tabs")
        self.cpus = self.builder.get_object("cpus")
        self.progressBox = self.builder.get_object("progressBox")
        self.progress = self.builder.get_object("progress")
        self.frame = self.builder.get_object("frame")
        self.overlay = self.builder.get_object("overlay")
        self.frameSlider = self.builder.get_object("frameSlider")
        self.frameScale = self.builder.get_object("frameScale")
        self.startFrame = self.builder.get_object("startFrame")
        self.endFrame = self.builder.get_object("endFrame")
        self.normalize = self.builder.get_object("normalize")
        self.alignChannels = self.builder.get_object("alignChannels")
        self.autoCrop = self.builder.get_object("autoCrop")
        self.transformation = self.builder.get_object("transformation")
        self.drizzleFactor = self.builder.get_object("drizzleFactor")
        self.drizzleInterpolation = self.builder.get_object(
            "drizzleInterpolation")
        self.limit = self.builder.get_object("limit")
        self.limitPercent = self.builder.get_object("limitPercent")
        self.averageRadio = self.builder.get_object("averageRadio")
        self.medianRadio = self.builder.get_object("medianRadio")

        self.openDialog.set_preview_widget(Gtk.Image())
        self.saveDialog.set_preview_widget(Gtk.Image())

        self.builder.get_object("alignTab").set_sensitive(False)
        self.builder.get_object("stackTab").set_sensitive(False)
        self.builder.get_object("processTab").set_sensitive(False)

        self.builder.get_object("blackLevel").add_mark(0, Gtk.PositionType.TOP,
                                                       None)
        self.builder.get_object("gamma").add_mark(100, Gtk.PositionType.TOP,
                                                  None)
        self.builder.get_object("value").add_mark(100, Gtk.PositionType.TOP,
                                                  None)
        self.builder.get_object("red").add_mark(100, Gtk.PositionType.TOP,
                                                None)
        self.builder.get_object("green").add_mark(100, Gtk.PositionType.TOP,
                                                  None)
        self.builder.get_object("blue").add_mark(100, Gtk.PositionType.TOP,
                                                 None)
        self.builder.get_object("saturation").add_mark(100,
                                                       Gtk.PositionType.TOP,
                                                       None)

        self.disableScroll()

        self.cpus.set_upper(min(
            61, cpu_count()))  # 61 is the maximum that Windows allows
        self.cpus.set_value(min(61, math.ceil(cpu_count() / 2)))
        g.pool = None

        self.processThread = None

        self.builder.connect_signals(self)

        # Needed so it can be temporarily removed
        self.limitPercentSignal = self.limitPercent.connect(
            "value-changed", self.setLimitPercent)

        g.driftP1 = (0, 0)
        g.driftP2 = (0, 0)

        g.areaOfInterestP1 = (0, 0)
        g.areaOfInterestP2 = (0, 0)

        self.window.show_all()
        self.checkNewVersion()
        self.setProgress()
        self.setNormalize()
        self.setAlignChannels()
        self.setTransformation()
        self.setDrizzleFactor()
        self.setDrizzleInterpolation()
        self.setAutoCrop()
        self.setThreads()
        self.frameScale.set_sensitive(False)
        g.reference = "0"

    # Cancels scroll event for widget
    def propagateScroll(self, widget, event):
        Gtk.propagate_event(widget.get_parent(), event)

    # Disables the scroll event from some fields
    def disableScroll(self):
        mask = Gdk.EventMask.BUTTON_MOTION_MASK | Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.KEY_RELEASE_MASK | Gdk.EventMask.TOUCH_MASK
        self.builder.get_object("denoiseWidget1").set_events(mask)
        self.builder.get_object("denoiseWidget2").set_events(mask)
        self.builder.get_object("denoiseWidget3").set_events(mask)
        self.builder.get_object("denoiseWidget4").set_events(mask)
        self.builder.get_object("denoiseWidget5").set_events(mask)

        self.builder.get_object("radiusWidget1").set_events(mask)
        self.builder.get_object("radiusWidget2").set_events(mask)
        self.builder.get_object("radiusWidget3").set_events(mask)
        self.builder.get_object("radiusWidget4").set_events(mask)
        self.builder.get_object("radiusWidget5").set_events(mask)

    # Sets up a listener so that processes can communicate with each other
    def createListener(self, function):
        def listener(function):
            while True:
                try:
                    msg = self.parentConn.recv()
                except:
                    return False
                if (msg == "stop"):
                    g.ui.setProgress()
                    return False
                function(msg)

        thread = Thread(target=listener, args=(function, ))
        thread.start()
        return thread

    # Shows the error dialog with the given title and message
    def showErrorDialog(self, message):
        dialog = self.builder.get_object("errorDialog")
        dialog.format_secondary_text(message)
        response = dialog.run()
        dialog.hide()
        return response

    # Shows the warning dialog with the given title and message
    def showWarningDialog(self, message):
        dialog = self.builder.get_object("warningDialog")
        dialog.format_secondary_text(message)
        response = dialog.run()
        dialog.hide()
        return response

    # Opens the About dialog
    def showAbout(self, *args):
        dialog = self.builder.get_object("about")
        dialog.set_program_name(UI.TITLE)
        dialog.set_version(UI.VERSION)
        response = dialog.run()
        dialog.hide()

    # Opens the user manual in the default pdf application
    def showManual(self, *args):
        if sys.platform.startswith('darwin'):
            subprocess.call(('open', "manual/Manual.pdf"))
        elif os.name == 'nt':  # For Windows
            os.startfile("manual\Manual.pdf")
        elif os.name == 'posix':  # For Linux, Mac, etc.
            subprocess.call(('xdg-open', "manual/Manual.pdf"))

    # Disable inputs
    def disableUI(self):
        self.builder.get_object("tabs").set_sensitive(False)
        self.builder.get_object("toolbar").set_sensitive(False)

    # Enable inputs
    def enableUI(self):
        self.builder.get_object("tabs").set_sensitive(True)
        self.builder.get_object("toolbar").set_sensitive(True)

    # The following is needed to forcibly refresh the value spacing of the slider
    def fixFrameSliderBug(self):
        self.frameScale.set_value_pos(Gtk.PositionType.RIGHT)
        self.frameScale.set_value_pos(Gtk.PositionType.LEFT)

    # Sets the number of threads to use
    def setThreads(self, *args):
        def initPool(method=None):
            if (method == "spawn"):
                GLib.idle_add(self.disableUI)
            g.nThreads = int(self.cpus.get_value())
            if (g.pool is not None):
                g.pool.shutdown()
            g.pool = ProcessPoolExecutor(g.nThreads)

            # This seems like the most reliable way to get the pid of pool processes
            self.pids = []
            before = list(map(lambda p: p.pid, active_children()))
            g.pool.submit(dummy, ()).result()
            after = list(map(lambda p: p.pid, active_children()))
            for pid in after:
                if (pid not in before):
                    self.pids.append(pid)
            if (method == "spawn"):
                GLib.idle_add(self.enableUI)

        # Behave a bit differently depending on platform
        if (get_start_method() == "spawn"):
            thread = Thread(target=initPool, args=(get_start_method(), ))
            thread.start()
        else:
            initPool()

    # Checks github to see if there is a new version available
    def checkNewVersion(self):
        def callUrl():
            try:
                contents = urllib.request.urlopen(
                    "https://api.github.com/repos/Finalfantasykid/AstraStack/releases/latest"
                ).read()
                obj = json.loads(contents)
                if (version.parse(obj['name']) > version.parse(UI.VERSION)):
                    self.newVersionUrl = obj['html_url']
                    button.show()
            except:
                return

        button = self.builder.get_object("newVersion")
        button.hide()
        thread = Thread(target=callUrl, args=())
        thread.start()

    # Opens the GitHub releases page in a browser
    def clickNewVersion(self, *args):
        webbrowser.open(self.newVersionUrl)

    # Checks to see if there will be enough memory to process the image
    def checkMemory(self, w=0, h=0):
        if (Sharpen.estimateMemoryUsage(w, h) >
                psutil.virtual_memory().available):
            response = self.showWarningDialog(
                "Your system may not have enough memory to process this file, are you sure you want to continue?"
            )
            return (response == Gtk.ResponseType.YES)
        return True

    # Shows preview image in file chooser dialog
    def updatePreview(self, dialog):
        path = dialog.get_preview_filename()
        pixbuf = None
        try:
            # First try as image
            pixbuf = GdkPixbuf.Pixbuf.new_from_file(path)
        except Exception:
            try:
                # Now try as video
                if ("video/" in mimetypes.guess_type(path)[0]):
                    video = Video()
                    img = cv2.cvtColor(video.getFrame(path, 0),
                                       cv2.COLOR_BGR2RGB)
                    height, width = img.shape[:2]

                    z = img.tobytes()
                    Z = GLib.Bytes.new(z)

                    pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(
                        Z, GdkPixbuf.Colorspace.RGB, False, 8, width, height,
                        width * 3)
            except Exception:
                dialog.set_preview_widget_active(False)
        if (pixbuf is not None):
            # Valid pixbuf
            maxwidth, maxheight = 250, 250
            width, height = pixbuf.get_width(), pixbuf.get_height()
            scale = min(maxwidth / width, maxheight / height)
            if (scale < 1):
                width, height = int(width * scale), int(height * scale)
                pixbuf = pixbuf.scale_simple(width, height,
                                             GdkPixbuf.InterpType.BILINEAR)

            dialog.get_preview_widget().set_size_request(
                width + 10, height + 10)
            dialog.get_preview_widget().set_from_pixbuf(pixbuf)
            dialog.set_preview_widget_active(True)

    # Opens the file chooser to open load a file
    def openVideo(self, *args):
        self.openDialog.set_current_folder(path.expanduser("~"))
        self.openDialog.set_select_multiple(False)
        self.openDialog.set_filter(self.builder.get_object("videoFilter"))
        response = self.openDialog.run()
        self.openDialog.hide()
        if (response == Gtk.ResponseType.OK):
            try:
                g.file = self.openDialog.get_filename()
                self.video = Video()
                self.video.checkMemory()
                thread = Thread(target=self.video.run, args=())
                thread.start()
                self.disableUI()
            except MemoryError as error:
                self.enableUI()

    # Opens the file chooser to open load a file
    def openImageSequence(self, *args):
        self.openDialog.set_current_folder(path.expanduser("~"))
        self.openDialog.set_select_multiple(True)
        self.openDialog.set_filter(self.builder.get_object("imageFilter"))
        response = self.openDialog.run()
        self.openDialog.hide()
        if (response == Gtk.ResponseType.OK):
            try:
                g.file = self.openDialog.get_filenames()
                self.video = Video()
                self.video.checkMemory()
                thread = Thread(target=self.video.run, args=())
                thread.start()
                self.disableUI()
            except MemoryError as error:
                self.enableUI()

    # Opens the file chooser to open load a file
    def openImage(self, *args):
        self.openDialog.set_current_folder(path.expanduser("~"))
        self.openDialog.set_select_multiple(False)
        self.openDialog.set_filter(self.builder.get_object("imageFilter"))
        response = self.openDialog.run()
        self.openDialog.hide()
        if (response == Gtk.ResponseType.OK):
            self.disableUI()
            g.file = self.openDialog.get_filename()
            try:
                self.video = Video()
                img = cv2.imread(g.file)
                h, w = img.shape[:2]
                if (not self.checkMemory(w, h)):
                    raise MemoryError()

                self.window.set_title(path.split(g.file)[1] + " - " + UI.TITLE)
                self.saveDialog.set_current_name("")
                self.sharpen = Sharpen(g.file, True)
                self.builder.get_object("alignTab").set_sensitive(False)
                self.builder.get_object("stackTab").set_sensitive(False)
                self.builder.get_object("processTab").set_sensitive(True)
                self.tabs.set_current_page(UI.SHARPEN_TAB)
                self.frame.set_from_file(g.file)
            except MemoryError as error:
                pass
            except:  # Open Failed
                self.showErrorDialog(
                    "There was an error opening the image, make sure it is a valid image."
                )
            self.enableUI()

    # Opens the file chooser to save the final image
    def saveFileDialog(self, *args):
        self.saveDialog.set_current_folder(path.expanduser("~"))
        if (self.saveDialog.get_current_name() == ""):
            # Set default file to save if empty
            if (isinstance(g.file, list)):
                sList = g.file
                self.saveDialog.set_current_name(
                    Path(sList[0]).stem + "_" + Path(sList[-1]).stem + ".png")
            else:
                self.saveDialog.set_current_name(Path(g.file).stem + ".png")
        response = self.saveDialog.run()
        if (response == Gtk.ResponseType.OK):
            fileName = self.saveDialog.get_filename()
            try:
                cv2.imwrite(
                    fileName,
                    cv2.cvtColor(self.sharpen.finalImage.astype('uint8'),
                                 cv2.COLOR_RGB2BGR))
            except:  # Save Failed
                self.showErrorDialog(
                    "There was an error saving the image, make sure it is a valid file extension."
                )
        self.saveDialog.hide()

    # Called when the video is finished loading
    def finishedVideo(self):
        def update():
            self.tabs.next_page()

            self.frameScale.set_sensitive(True)

            self.startFrame.set_lower(0)
            self.startFrame.set_upper(len(self.video.frames) - 1)
            self.startFrame.set_value(0)

            self.endFrame.set_upper(len(self.video.frames) - 1)
            self.endFrame.set_lower(0)
            self.endFrame.set_value(len(self.video.frames) - 1)

            g.driftP1 = (0, 0)
            g.driftP2 = (0, 0)
            g.areaOfInterestP1 = (0, 0)
            g.areaOfInterestP2 = (0, 0)
            g.reference = self.video.sharpest
            self.frameSlider.set_value(self.video.sharpest)

            self.setReference()
            self.setStartFrame()
            self.setEndFrame()
            self.setDriftPoint()
            self.enableUI()
            if (isinstance(g.file, list)):
                sList = g.file
                self.window.set_title(
                    path.split(sList[0])[1] + " ... " +
                    path.split(sList[-1])[1] + " - " + UI.TITLE)
            else:
                self.window.set_title(path.split(g.file)[1] + " - " + UI.TITLE)
            self.saveDialog.set_current_name("")
            self.builder.get_object("alignTab").set_sensitive(True)
            self.builder.get_object("stackTab").set_sensitive(False)
            self.builder.get_object("processTab").set_sensitive(False)
            self.stack = None

        GLib.idle_add(update)

    # Called when the tab is changed.  Updates parts of the UI based on the tab
    def changeTab(self, notebook, page, page_num, user_data=None):
        if (page_num == UI.LOAD_TAB or page_num == UI.ALIGN_TAB):
            self.frameSlider.set_value(0)
            self.frameSlider.set_upper(len(self.video.frames) - 1)
            self.setStartFrame()
            self.setEndFrame()
            self.frameScale.show()
            self.updateImage(None, page_num)
        elif (page_num == UI.STACK_TAB):
            self.frameSlider.set_lower(0)
            self.frameSlider.set_upper(len(self.align.tmats) - 1)
            self.frameSlider.set_value(0)
            self.frameScale.show()
            self.updateImage(None, page_num)
        elif (page_num == UI.SHARPEN_TAB):
            self.frameScale.hide()
            self.sharpenImage()
        self.fixFrameSliderBug()

    # Changes the image frame to the frameSlider position
    def updateImage(self, adjustment=None, page_num=None):
        if (self.video is None):
            return
        if (page_num is None):
            page_num = self.tabs.get_current_page()
        if (page_num == UI.LOAD_TAB or page_num == UI.ALIGN_TAB):
            videoIndex = int(self.frameSlider.get_value())
            img = cv2.cvtColor(
                self.video.getFrame(g.file, self.video.frames[videoIndex]),
                cv2.COLOR_BGR2RGB)
            height, width = img.shape[:2]

            z = img.tobytes()
            Z = GLib.Bytes.new(z)

            pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(Z,
                                                     GdkPixbuf.Colorspace.RGB,
                                                     False, 8, width, height,
                                                     width * 3)
            self.frame.set_from_pixbuf(pixbuf)
        elif (page_num == UI.STACK_TAB):
            tmat = self.stack.tmats[int(self.frameSlider.get_value())]
            videoIndex = tmat[0]
            M = tmat[1]
            img = self.video.getFrame(g.file, videoIndex)
            if (g.autoCrop):
                ref = self.stack.refBG.astype(np.uint8)
            else:
                ref = None
            img = transform(img, ref, M, self.align.minX, self.align.maxX,
                            self.align.minY, self.align.maxY, g.drizzleFactor,
                            g.drizzleInterpolation)
            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            height, width = img.shape[:2]

            z = img.tobytes()
            Z = GLib.Bytes.new(z)

            pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(Z,
                                                     GdkPixbuf.Colorspace.RGB,
                                                     False, 8, width, height,
                                                     width * 3)
            self.frame.set_from_pixbuf(pixbuf)

    # Draws a rectangle where the area of interest is
    def drawOverlay(self, widget, cr):
        width = widget.get_allocated_width()
        height = widget.get_allocated_height()

        def drawPoint(cr, x, y):
            cr.new_sub_path()
            cr.set_line_width(2)
            cr.set_source_rgb(1, 1, 1)

            cr.arc(x, y, 2, 0, 2 * math.pi)
            cr.stroke_preserve()

            cr.set_source_rgb(1, 0, 0)
            cr.fill()

        def drawRect(cr, x1, y1, x2, y2):
            cr.rectangle(0, 0, x1, y1)
            cr.rectangle(0, y1, x1, (y2 - y1))
            cr.rectangle(0, y1, x1, height * 2)
            cr.rectangle(x1, y2, (x2 - x1), height * 2)
            cr.rectangle(x2, y2, width * 2, height * 2)
            cr.rectangle(x2, y1, width * 2, (y2 - y1))
            cr.rectangle(x2, 0, width * 2, y1)
            cr.rectangle(x1, 0, (x2 - x1), y1)

            cr.set_source_rgba(0, 0, 0, 0.25)
            cr.fill()

            cr.set_line_width(1)
            cr.set_source_rgb(1, 0, 0)

            cr.rectangle(x1, y1, (x2 - x1), (y2 - y1))
            cr.stroke()

        if (self.tabs.get_current_page() == UI.ALIGN_TAB):
            current = self.frameSlider.get_value()

            # Area of Interest
            px1 = min(g.areaOfInterestP1[0], g.areaOfInterestP2[0])
            py1 = min(g.areaOfInterestP1[1], g.areaOfInterestP2[1])

            px2 = max(g.areaOfInterestP1[0], g.areaOfInterestP2[0])
            py2 = max(g.areaOfInterestP1[1], g.areaOfInterestP2[1])

            # Drift Points
            dx1 = g.driftP1[0]
            dy1 = g.driftP1[1]

            dx2 = g.driftP2[0]
            dy2 = g.driftP2[1]

            dx = 0
            dy = 0

            if (dx1 != 0 and dy1 != 0 and dx2 != 0 and dy2 != 0):
                dx = dx2 - dx1
                dy = dy2 - dy1

            if (px1 != 0 and py1 != 0 and px2 != 0 and py2 != 0):
                # Draw Area of Interest Rectangle
                drawRect(
                    cr, px1 + (dx / (g.endFrame - g.startFrame)) *
                    (current - g.startFrame),
                    py1 + (dy / (g.endFrame - g.startFrame)) *
                    (current - g.startFrame),
                    px2 + (dx / (g.endFrame - g.startFrame)) *
                    (current - g.startFrame),
                    py2 + (dy / (g.endFrame - g.startFrame)) *
                    (current - g.startFrame))

            if (dx1 != 0 and dy1 != 0 and current == g.startFrame):
                # Draw point on first frame
                drawPoint(cr, dx1, dy1)

            if (dx1 != 0 and dy1 != 0 and current != g.startFrame and dx2 != 0
                    and dy2 != 0 and current != g.endFrame):
                # Draw interpolated point
                drawPoint(
                    cr, dx1 + (dx / (g.endFrame - g.startFrame)) *
                    (current - g.startFrame),
                    dy1 + (dy / (g.endFrame - g.startFrame)) *
                    (current - g.startFrame))

            if (dx2 != 0 and dy2 != 0 and current == g.endFrame):
                # Draw point on last frame
                drawPoint(cr, dx2, dy2)

    # Sets the reference frame to the current visible frame
    def setReference(self, *args):
        g.reference = str(int(self.frameSlider.get_value()))
        self.builder.get_object("referenceLabel").set_text(g.reference)
        self.builder.get_object("alignButton").set_sensitive(True)

    # Updates the progress bar
    def setProgress(self, i=0, total=0, text=""):
        def update():
            if (total == 0):
                self.progressBox.hide()
            else:
                self.progressBox.show()
                self.progress.set_fraction(i / total)
                self.progress.set_text(text + " " +
                                       str(round((i / total) * 100)) + "%")

        GLib.idle_add(update)

    # Sets the start frame for trimming
    def setStartFrame(self, *args):
        g.startFrame = int(self.startFrame.get_value())
        self.endFrame.set_lower(g.startFrame + 1)
        self.frameSlider.set_lower(g.startFrame)
        self.frameSlider.set_value(
            max(g.startFrame, self.frameSlider.get_value()))
        if (int(g.startFrame) > int(g.reference)):
            # Reference is outside of the range, fix it
            g.reference = str(int(g.startFrame))
            self.builder.get_object("referenceLabel").set_text(g.reference)
        self.fixFrameSliderBug()

    # Sets the end frame for trimming
    def setEndFrame(self, *args):
        g.endFrame = int(self.endFrame.get_value())
        self.startFrame.set_upper(g.endFrame - 1)
        self.frameSlider.set_upper(g.endFrame)
        self.frameSlider.set_value(
            min(g.endFrame, self.frameSlider.get_value()))
        if (int(g.endFrame) < int(g.reference)):
            # Reference is outside of the range, fix it
            g.reference = str(int(g.endFrame))
            self.builder.get_object("referenceLabel").set_text(g.reference)
        self.fixFrameSliderBug()

    # Drift Point 1 Button Clicked
    def clickDriftP1(self, *args):
        self.clickedDriftP1 = False
        self.clickedDriftP2 = False
        self.clickedAreaOfInterest = False
        self.setDriftPoint()
        self.frameSlider.set_value(g.startFrame)
        self.clickedDriftP1 = True
        self.window.get_window().set_cursor(
            Gdk.Cursor(Gdk.CursorType.CROSSHAIR))

    # Drift Point 2 Button Clicked
    def clickDriftP2(self, *args):
        self.clickedDriftP1 = False
        self.clickedDriftP2 = False
        self.clickedAreaOfInterest = False
        self.setDriftPoint()
        self.frameSlider.set_value(g.endFrame)
        self.clickedDriftP2 = True
        self.window.get_window().set_cursor(
            Gdk.Cursor(Gdk.CursorType.CROSSHAIR))

    # Reset Drift Point 1 to (0, 0)
    def resetDriftP1(self, widget, event):
        if (event.button == 3):  # Right Click
            g.driftP1 = (0, 0)
            self.clickedDriftP1 = False
            self.clickedDriftP2 = False
            self.clickedAreaOfInterest = False
            self.window.get_window().set_cursor(
                Gdk.Cursor(Gdk.CursorType.LEFT_PTR))
            self.overlay.queue_draw()

    # Reset Drift Point 2 to (0, 0)
    def resetDriftP2(self, widget, event):
        if (event.button == 3):  # Right Click
            g.driftP2 = (0, 0)
            self.clickedDriftP1 = False
            self.clickedDriftP2 = False
            self.clickedAreaOfInterest = False
            self.window.get_window().set_cursor(
                Gdk.Cursor(Gdk.CursorType.LEFT_PTR))
            self.overlay.queue_draw()

    # Updates the drift point
    def setDriftPoint(self, *args):
        if (self.clickedDriftP1 or self.clickedDriftP2):
            if (self.clickedDriftP1):
                g.driftP1 = self.mousePosition
            elif (self.clickedDriftP2):
                g.driftP2 = self.mousePosition
            self.clickedDriftP1 = False
            self.clickedDriftP2 = False
            self.window.get_window().set_cursor(
                Gdk.Cursor(Gdk.CursorType.LEFT_PTR))
            self.overlay.queue_draw()

    # Area of Interest button clicked
    def clickAreaOfInterest(self, *args):
        g.areaOfInterestP1 = (0, 0)
        g.areaOfInterestP2 = (0, 0)
        self.clickedDriftP1 = False
        self.clickedDriftP2 = False
        self.clickedAreaOfInterest = True
        self.frameSlider.set_value(g.startFrame)
        self.window.get_window().set_cursor(
            Gdk.Cursor(Gdk.CursorType.CROSSHAIR))
        self.overlay.queue_draw()

    # Reset Area of Interest to (0, 0)
    def resetAreaOfInterest(self, widget, event):
        if (event.button == 3):  # Right Click
            g.areaOfInterestP1 = (0, 0)
            g.areaOfInterestP2 = (0, 0)
            self.clickedDriftP1 = False
            self.clickedDriftP2 = False
            self.clickedAreaOfInterest = False
            self.window.get_window().set_cursor(
                Gdk.Cursor(Gdk.CursorType.LEFT_PTR))
            self.overlay.queue_draw()

    # First point int the Area of Interest clicked, drag started
    def dragBegin(self, *args):
        if (self.clickedAreaOfInterest):
            g.areaOfInterestP1 = self.mousePosition

    # Mouse released after dragging Area of Interest
    def dragEnd(self, *args):
        if (self.clickedAreaOfInterest):
            g.areaOfInterestP2 = self.mousePosition
            self.clickedAreaOfInterest = False
            self.window.get_window().set_cursor(
                Gdk.Cursor(Gdk.CursorType.LEFT_PTR))

    # Called when the mouse moves over the frame
    def updateMousePosition(self, *args):
        pointer = self.frame.get_pointer()
        self.mousePosition = (min(max(0, pointer.x),
                                  self.frame.get_allocation().width),
                              min(max(0, pointer.y),
                                  self.frame.get_allocation().height))
        if (self.clickedAreaOfInterest):
            if (g.areaOfInterestP1 != (0, 0)):
                g.areaOfInterestP2 = self.mousePosition
            self.overlay.queue_draw()

    # Sets whether or not to normalize the frames during alignment
    def setNormalize(self, *args):
        g.normalize = self.normalize.get_active()

    # Sets whether or not to align channels separately
    def setAlignChannels(self, *args):
        g.alignChannels = self.alignChannels.get_active()

    # Sets the type of transformation
    def setTransformation(self, *args):
        text = self.transformation.get_active_text()
        if (text == "None"):
            g.transformation = -1
        elif (text == "Translation"):
            g.transformation = StackReg.TRANSLATION
        elif (text == "Rigid Body"):
            g.transformation = StackReg.RIGID_BODY
        elif (text == "Scaled Rotation"):
            g.transformation = StackReg.SCALED_ROTATION
        elif (text == "Affine"):
            g.transformation = StackReg.AFFINE

    # Sets the drizzle scaling factor
    def setDrizzleFactor(self, *args):
        text = self.drizzleFactor.get_active_text()
        if (text == "0.25X"):
            g.drizzleFactor = 0.25
        elif (text == "0.50X"):
            g.drizzleFactor = 0.50
        elif (text == "0.75X"):
            g.drizzleFactor = 0.75
        elif (text == "1.0X"):
            g.drizzleFactor = 1.0
        elif (text == "1.5X"):
            g.drizzleFactor = 1.5
        elif (text == "2.0X"):
            g.drizzleFactor = 2.0
        elif (text == "2.5X"):
            g.drizzleFactor = 2.5
        elif (text == "3.0X"):
            g.drizzleFactor = 3.0
        if (self.stack is not None):
            self.stack.generateRefBG()
        self.updateImage()

    # Sets the drizzle scaling factor
    def setDrizzleInterpolation(self, *args):
        text = self.drizzleInterpolation.get_active_text()
        if (text == "Nearest Neighbor"):
            g.drizzleInterpolation = cv2.INTER_NEAREST
        elif (text == "Bilinear"):
            g.drizzleInterpolation = cv2.INTER_LINEAR
        elif (text == "Bicubic"):
            g.drizzleInterpolation = cv2.INTER_CUBIC
        elif (text == "Lanczos"):
            g.drizzleInterpolation = cv2.INTER_LANCZOS4
        if (self.stack is not None):
            self.stack.generateRefBG()
        self.updateImage()

    # Sets whether or not to auto crop
    def setAutoCrop(self, *args):
        g.autoCrop = not self.autoCrop.get_active()
        self.updateImage()

    # Runs the Alignment step
    def clickAlign(self, *args):
        self.align = Align(self.video.frames[g.startFrame:g.endFrame + 1])
        thread = Thread(target=self.align.run, args=())
        thread.start()
        self.disableUI()

    # Kills all pool processes
    def killPool(self):
        for pid in self.pids:
            if (psutil.pid_exists(pid)):
                p = psutil.Process(pid)
                p.kill()

    # Stops the current action being performed
    def stopProcessing(self, *args):
        self.killPool()
        g.pool = None
        self.setThreads()
        self.setProgress()
        self.enableUI()

    # Called when the Alignment is complete
    def finishedAlign(self):
        def update():
            self.stack = Stack(self.align.tmats)
            self.tabs.next_page()
            self.enableUI()
            self.builder.get_object("alignTab").set_sensitive(True)
            self.builder.get_object("stackTab").set_sensitive(True)
            self.builder.get_object("processTab").set_sensitive(False)
            self.limit.set_upper(len(self.align.tmats))
            self.limit.set_value(int(len(self.align.tmats) / 2))
            self.limitPercent.set_value(
                round(self.limit.get_value() / len(self.align.tmats) * 100))
            self.setLimit()
            self.setLimitPercent()

        GLib.idle_add(update)

    # Sets the number of frames to use in the Stack
    def setLimit(self, *args):
        self.limitPercent.disconnect(self.limitPercentSignal)
        self.limit.set_upper(len(self.align.tmats))
        g.limit = int(self.limit.get_value())
        self.limitPercent.set_value(
            round(g.limit / len(self.align.tmats) * 100))
        self.limitPercentSignal = self.limitPercent.connect(
            "value-changed", self.setLimitPercent)

    # Sets the number of frames to use in the Stack
    def setLimitPercent(self, *args):
        limitPercent = self.limitPercent.get_value() / 100
        self.limit.set_value(round(limitPercent * len(self.align.tmats)))

    # Stack Button clicked
    def clickStack(self, *args):
        try:
            self.stack.checkMemory()
            thread = Thread(target=self.stack.run, args=())
            thread.start()
            self.disableUI()
        except MemoryError as error:
            self.enableUI()

    # Called when the stack is complete
    def finishedStack(self):
        def update():
            self.sharpen = Sharpen(self.stack.stackedImage)
            self.tabs.next_page()
            self.enableUI()
            self.builder.get_object("alignTab").set_sensitive(True)
            self.builder.get_object("stackTab").set_sensitive(True)
            self.builder.get_object("processTab").set_sensitive(True)

        GLib.idle_add(update)

    # Sharpens the final Stacked image
    def sharpenImage(self, *args):
        g.sharpen1 = self.builder.get_object("sharpen1").get_value()
        g.sharpen2 = self.builder.get_object("sharpen2").get_value()
        g.sharpen3 = self.builder.get_object("sharpen3").get_value()
        g.sharpen4 = self.builder.get_object("sharpen4").get_value()
        g.sharpen5 = self.builder.get_object("sharpen5").get_value()

        g.radius1 = self.builder.get_object("radius1").get_value()
        g.radius2 = self.builder.get_object("radius2").get_value()
        g.radius3 = self.builder.get_object("radius3").get_value()
        g.radius4 = self.builder.get_object("radius4").get_value()
        g.radius5 = self.builder.get_object("radius5").get_value()

        g.denoise1 = self.builder.get_object("denoise1").get_value()
        g.denoise2 = self.builder.get_object("denoise2").get_value()
        g.denoise3 = self.builder.get_object("denoise3").get_value()
        g.denoise4 = self.builder.get_object("denoise4").get_value()
        g.denoise5 = self.builder.get_object("denoise5").get_value()

        g.level1 = self.builder.get_object("level1").get_active()
        g.level2 = self.builder.get_object("level2").get_active()
        g.level3 = self.builder.get_object("level3").get_active()
        g.level4 = self.builder.get_object("level4").get_active()
        g.level5 = self.builder.get_object("level5").get_active()

        g.gamma = self.builder.get_object("gammaAdjust").get_value()
        g.blackLevel = self.builder.get_object("blackLevelAdjust").get_value()
        g.value = self.builder.get_object("valueAdjust").get_value()

        g.redAdjust = self.builder.get_object("redAdjust").get_value()
        g.greenAdjust = self.builder.get_object("greenAdjust").get_value()
        g.blueAdjust = self.builder.get_object("blueAdjust").get_value()
        g.saturation = self.builder.get_object("saturationAdjust").get_value()

        if (len(args) > 0
                and (self.builder.get_object("gammaAdjust") == args[0]
                     or self.builder.get_object("blackLevelAdjust") == args[0]
                     or self.builder.get_object("redAdjust") == args[0]
                     or self.builder.get_object("greenAdjust") == args[0]
                     or self.builder.get_object("blueAdjust") == args[0]
                     or self.builder.get_object("saturationAdjust") == args[0]
                     or self.builder.get_object("valueAdjust") == args[0])):
            processAgain = self.sharpen.processAgain
            processColor = True
        else:
            processAgain = True
            processColor = False

        if (self.sharpen is None):
            if (self.stack is not None):
                self.sharpen = Sharpen(self.stack.stackedImage)
            else:
                self.sharpen = Sharpen(g.file, True)
        if (self.processThread != None and self.processThread.is_alive()):
            self.sharpen.processAgain = processAgain
            self.sharpen.processColorAgain = processColor
        else:
            self.processThread = Thread(target=self.sharpen.run,
                                        args=(processAgain, processColor))
            self.processThread.start()

    # Called when sharpening is complete
    def finishedSharpening(self):
        def update():
            z = self.sharpen.finalImage.astype('uint8').tobytes()
            Z = GLib.Bytes.new(z)
            pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(Z,
                                                     GdkPixbuf.Colorspace.RGB,
                                                     False, 8, self.sharpen.w,
                                                     self.sharpen.h,
                                                     self.sharpen.w * 3)
            self.frame.set_from_pixbuf(pixbuf)

        GLib.idle_add(update)

    # Closes the application
    def close(self, *args):
        self.killPool()
        Gtk.main_quit()
        sys.exit()
Ejemplo n.º 42
0
def sortStack(stack):

    temp_stack = Stack()

    temp_stack.push(stack.pop())

    #pop an element off and hold in a variable
    #peek at element in temp_stack
    #if greater, just push on top
    #if less, keep popping until you reach smaller element (use peek)
    #insert temp element
    #push rest back on

    while not stack.isEmpty():
        value = stack.pop()

        while temp_stack.peek() > value or not temp_stack.isEmpty():
            stack.push(temp_stack.pop())
        temp_stack.push(value)

    while not temp_stack.isEmpty():
        stack.push(temp_stack.pop())

    return stack
Ejemplo n.º 43
0

def divOp():
    stack.div()


operation = {
    'pop': popOp,
    'add': addOp,
    'sub': subOp,
    'mul': mulOp,
    'div': divOp,
}

with open("entrada.txt", "r") as textFile:
    stack = Stack()
    pushOp = False

    for line in textFile:

        for word in line.split():

            if pushOp:
                stack.push(word)
                pushOp = False

            elif word == "push":
                pushOp = True

            else:
                try:
Ejemplo n.º 44
0
class DSQTester(unittest.TestCase):

  def setUp(self):
    self.__deque = get_deque()
    self.__stack = Stack()
    self.__queue = Queue()

  def test_empty_LL_deque_string(self):
    self.assertEqual('[ ]', str(self.__deque), 'Empty deque should print as "[ ]"')

  def test_empty_LL_deque_push_front(self):
    self.__deque.push_front(1)
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_empty_LL_deque_push_back(self):
    self.__deque.push_back(1)
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_empty_LL_deque_pop_front_return(self):#tests if pop method returns correctly, should return None.
    returned = self.__deque.pop_front()
    self.assertEqual(None, returned)

  def test_empty_LL_deque_pop_back_return(self):
    returned = self.__deque.pop_back()
    self.assertEqual(None, returned)

  def test_empty_LL_deque_pop_front(self):#tests if pop method works correctly when the deque is empty.
    self.__deque.pop_front()
    self.assertEqual('[ ]', str(self.__deque))

  def test_empty_LL_deque_pop_back(self):
    self.__deque.pop_back()
    self.assertEqual('[ ]', str(self.__deque))

  def test_empty_LL_deque_peek_front(self):
    returned = self.__deque.peek_front()
    self.assertEqual(None, returned)

  def test_empty_LL_deque_peek_back(self):
    returned = self.__deque.peek_back()
    self.assertEqual(None, returned)

  def test_empty_LL_deque_len(self):
    self.assertEqual(0, len(self.__deque))


  def test_one_LL_deque_string(self):#same testing for a deque of size 1.
    self.__deque.push_front(1)
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_one_LL_deque_push_front(self):
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.assertEqual('[ 2, 1 ]', str(self.__deque))

  def test_one_LL_deque_push_back(self):
    self.__deque.push_back(1)
    self.__deque.push_back(2)
    self.assertEqual('[ 1, 2 ]', str(self.__deque))

  def test_one_LL_deque_pop_front_return(self):#tests if pop method returns correctly.
    self.__deque.push_front(1)
    returned = self.__deque.pop_front()
    self.assertEqual(1, returned)

  def test_one_LL_deque_pop_back_return(self):
    self.__deque.push_front(1)
    returned = self.__deque.pop_back()
    self.assertEqual(1, returned)

  def test_one_LL_deque_pop_front(self):#tests if pop method removes correctly.
    self.__deque.push_front(1)
    self.__deque.pop_front()
    self.assertEqual('[ ]', str(self.__deque))

  def test_one_LL_deque_pop_back(self):
    self.__deque.push_front(1)
    self.__deque.pop_back()
    self.assertEqual('[ ]', str(self.__deque))

  def test_one_LL_deque_peek_front(self):
    self.__deque.push_front(1)
    returned = self.__deque.peek_front()
    self.assertEqual(1, returned)

  def test_one_LL_deque_peek_back(self):
    self.__deque.push_front(1)
    returned = self.__deque.peek_back()
    self.assertEqual(1, returned)

  def test_one_LL_deque_len(self):
    self.__deque.push_front(1)
    self.assertEqual(1, len(self.__deque))

  def test_two_LL_deque_string(self):#same tests for a deque with size 2.
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.assertEqual('[ 2, 1 ]', str(self.__deque))

  def test_two_LL_deque_push_front(self):
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.push_front(3)
    self.assertEqual('[ 3, 2, 1 ]', str(self.__deque))

  def test_two_LL_deque_push_back(self):
    self.__deque.push_back(1)
    self.__deque.push_back(2)
    self.__deque.push_back(3)
    self.assertEqual('[ 1, 2, 3 ]', str(self.__deque))

  def test_two_LL_deque_pop_front_return(self):#tests if pop method returns correctly.
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    returned = self.__deque.pop_front()
    self.assertEqual(2, returned)

  def test_two_LL_deque_pop_back_return(self):
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    returned = self.__deque.pop_back()
    self.assertEqual(1, returned)

  def test_two_LL_deque_pop_front(self):#tests if pop method removes correctly.
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.pop_front()
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_two_LL_deque_pop_back(self):
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.pop_back()
    self.assertEqual('[ 2 ]', str(self.__deque))

  def test_two_LL_deque_peek_front(self):
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    returned = self.__deque.peek_front()
    self.assertEqual(2, returned)

  def test_two_LL_deque_peek_back(self):
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    returned = self.__deque.peek_back()
    self.assertEqual(1, returned)

  def test_two_LL_deque_len(self):
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.assertEqual(2, len(self.__deque))

  def test_LL_deque_push_pop(self):#test if multiple push and pop work correctly
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.push_back(2)
    self.__deque.pop_back()
    self.__deque.push_front(3)
    self.__deque.pop_front()
    self.assertEqual('[ 2, 1 ]', str(self.__deque))

  def test_empty_ARR_deque_string(self):
    self.__deque = get_deque(1)
    self.assertEqual('[ ]', str(self.__deque), 'Empty deque should print as "[ ]"')

  def test_empty_ARR_deque_push_front(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_empty_ARR_deque_push_back(self):
    self.__deque = get_deque(1)
    self.__deque.push_back(1)
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_empty_ARR_deque_pop_front_return(self):#tests if pop method returns correctly, should return None.
    self.__deque = get_deque(1)
    returned = self.__deque.pop_front()
    self.assertEqual(None, returned)

  def test_empty_ARR_deque_pop_back_return(self):
    self.__deque = get_deque(1)
    returned = self.__deque.pop_back()
    self.assertEqual(None, returned)

  def test_empty_ARR_deque_pop_front(self):#tests if pop method works correctly when the deque is empty.
    self.__deque = get_deque(1)
    self.__deque.pop_front()
    self.assertEqual('[ ]', str(self.__deque))

  def test_empty_ARR_deque_pop_back(self):
    self.__deque = get_deque(1)
    self.__deque.pop_back()
    self.assertEqual('[ ]', str(self.__deque))

  def test_empty_ARR_deque_peek_front(self):
    self.__deque = get_deque(1)
    returned = self.__deque.peek_front()
    self.assertEqual(None, returned)

  def test_empty_ARR_deque_peek_back(self):
    self.__deque = get_deque(1)
    returned = self.__deque.peek_back()
    self.assertEqual(None, returned)

  def test_empty_ARR_deque_len(self):
    self.__deque = get_deque(1)
    self.assertEqual(0, len(self.__deque))


  def test_one_ARR_deque_string(self):#same testing for a deque of size 1.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_one_ARR_deque_push_front(self):#also tests if __grow works
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.assertEqual('[ 2, 1 ]', str(self.__deque))

  def test_one_ARR_deque_push_back(self):#also tests if __grow works
    self.__deque = get_deque(1)
    self.__deque.push_back(1)
    self.__deque.push_back(2)
    self.assertEqual('[ 1, 2 ]', str(self.__deque))

  def test_one_ARR_deque_pop_front_return(self):#tests if pop method returns correctly.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    returned = self.__deque.pop_front()
    self.assertEqual(1, returned)

  def test_one_ARR_deque_pop_back_return(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    returned = self.__deque.pop_back()
    self.assertEqual(1, returned)

  def test_one_ARR_deque_pop_front(self):#tests if pop method removes correctly.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.pop_front()
    self.assertEqual('[ ]', str(self.__deque))

  def test_one_ARR_deque_pop_back(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.pop_back()
    self.assertEqual('[ ]', str(self.__deque))

  def test_one_ARR_deque_peek_front(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    returned = self.__deque.peek_front()
    self.assertEqual(1, returned)

  def test_one_ARR_deque_peek_back(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    returned = self.__deque.peek_back()
    self.assertEqual(1, returned)

  def test_one_ARR_deque_len(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.assertEqual(1, len(self.__deque))

  def test_two_ARR_deque_string(self):#same tests for a deque with size 2.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.assertEqual('[ 2, 1 ]', str(self.__deque))

  def test_two_ARR_deque_push_front(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.push_front(3)
    self.assertEqual('[ 3, 2, 1 ]', str(self.__deque))

  def test_two_ARR_deque_push_back(self):
    self.__deque = get_deque(1)
    self.__deque.push_back(1)
    self.__deque.push_back(2)
    self.__deque.push_back(3)
    self.assertEqual('[ 1, 2, 3 ]', str(self.__deque))

  def test_two_ARR_deque_pop_front_return(self):#tests if pop method returns correctly.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    returned = self.__deque.pop_front()
    self.assertEqual(2, returned)

  def test_two_ARR_deque_pop_back_return(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    returned = self.__deque.pop_back()
    self.assertEqual(1, returned)

  def test_two_ARR_deque_pop_front(self):#tests if pop method removes correctly.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.pop_front()
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_two_ARR_deque_pop_back(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.pop_back()
    self.assertEqual('[ 2 ]', str(self.__deque))

  def test_two_ARR_deque_peek_front(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    returned = self.__deque.peek_front()
    self.assertEqual(2, returned)

  def test_two_ARR_deque_peek_back(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    returned = self.__deque.peek_back()
    self.assertEqual(1, returned)

  def test_two_ARR_deque_len(self):
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.assertEqual(2, len(self.__deque))

  def test_ARR_deque_push_pop(self):#test if multiple push and pops work expectedly
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.push_back(2)
    self.__deque.pop_back()
    self.__deque.push_front(3)
    self.__deque.pop_front()
    self.assertEqual('[ 2, 1 ]', str(self.__deque))

  def test_ARR_deque_push_front_circularity(self):#tests push_front when front index is 0.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.push_front(3)
    self.assertEqual('[ 3, 2, 1 ]', str(self.__deque))

  def test_ARR_deque_push_back_circularity(self):#similarly,tests if circular array works
    self.__deque = get_deque(1)
    self.__deque.push_back(1)
    self.__deque.push_back(2)
    self.__deque.push_back(3)
    self.assertEqual('[ 1, 2, 3 ]', str(self.__deque))

  def test_ARR_deque_pop_front_circularity(self):#tests pop_front when front index is capacity-1.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.pop_front()
    self.assertEqual('[ 1 ]', str(self.__deque))

  def test_ARR_deque_pop_back_circularity(self):#tests pop_back when back index is 0.
    self.__deque = get_deque(1)
    self.__deque.push_front(1)
    self.__deque.push_front(2)
    self.__deque.pop_back()
    self.assertEqual('[ 2 ]', str(self.__deque))

  def test_empty_stack_str(self):
    self.assertEqual('[ ]', str(self.__stack))

  def test_empty_stack_len(self):
    self.assertEqual(0, len(self.__stack))

  def test_empty_stack_push(self):
    self.__stack.push(1)
    self.assertEqual('[ 1 ]', str(self.__stack))

  def test_empty_stack_pop_return(self):#tests if pop returns value correctly
    self.assertEqual(None, self.__stack.pop())

  def test_empty_stack_pop_remove(self):#tests if pop removes value correctly
    self.__stack.pop()
    self.assertEqual('[ ]', str(self.__stack))

  def test_empty_stack_peek(self):
    self.assertEqual(None, self.__stack.peek())

  def test_one_stack_str(self):
    self.__stack.push(1)
    self.assertEqual('[ 1 ]', str(self.__stack))

  def test_one_stack_len(self):
    self.__stack.push(1)
    self.assertEqual(1, len(self.__stack))

  def test_one_stack_push(self):#notice that the top of stack is the at back of the deque, so the printed string from left to right is from bottom to top.
    self.__stack.push(1)
    self.__stack.push(2)
    self.assertEqual('[ 1, 2 ]', str(self.__stack))

  def test_one_stack_pop_return(self):#tests if pop returns value correctly
    self.__stack.push(1)
    self.assertEqual(1, self.__stack.pop())

  def test_one_stack_pop_remove(self):#tests if pop removes value correctly
    self.__stack.push(1)
    self.__stack.pop()
    self.assertEqual('[ ]', str(self.__stack))

  def test_one_stack_peek(self):
    self.__stack.push(1)
    self.assertEqual(1, self.__stack.peek())

  def test_two_stack_str(self):#notice that the top of stack is the at back of the deque
    self.__stack.push(1)
    self.__stack.push(2)
    self.assertEqual('[ 1, 2 ]', str(self.__stack))

  def test_two_stack_len(self):
    self.__stack.push(1)
    self.__stack.push(2)
    self.assertEqual(2, len(self.__stack))

  def test_two_stack_push(self):#notice that the top of stack is the at back of the deque
    self.__stack.push(1)
    self.__stack.push(2)
    self.__stack.push(3)
    self.assertEqual('[ 1, 2, 3 ]', str(self.__stack))

  def test_two_stack_pop_return(self):#tests if pop returns value correctly
    self.__stack.push(1)
    self.__stack.push(2)
    self.assertEqual(2, self.__stack.pop())

  def test_two_stack_pop_remove(self):#tests if pop removes value correctly
    self.__stack.push(1)
    self.__stack.push(2)
    self.__stack.pop()
    self.assertEqual('[ 1 ]', str(self.__stack))

  def test_two_stack_peek(self):
    self.__stack.push(1)
    self.__stack.push(2)
    self.assertEqual(2, self.__stack.peek())

  def test_stack_multiple_push_pop(self):#test if multiple push and pops work as expected
    self.__stack.push(1)
    self.__stack.push(2)
    self.__stack.pop()
    self.__stack.push(4)
    self.__stack.pop()
    self.__stack.push(6)
    self.__stack.push(7)
    self.__stack.push(8)
    self.__stack.pop()
    self.assertEqual('[ 1, 6, 7 ]', str(self.__stack))

  def test_empty_queue_str(self):
    self.assertEqual('[ ]', str(self.__queue))

  def test_empty_queue_len(self):
    self.assertEqual(0, len(self.__queue))

  def test_empty_queue_enqueue(self):
    self.__queue.enqueue(1)
    self.assertEqual('[ 1 ]', str(self.__queue))

  def test_empty_queue_dequeue_return(self):#tests if dequeue returns value correctly
    self.assertEqual(None, self.__queue.dequeue())

  def test_empty_queue_dequeue_remove(self):#tests if dequeue removes value correctly
    self.__queue.dequeue()
    self.assertEqual('[ ]', str(self.__queue))

  def test_empty_queue_peek(self):
    self.assertEqual(None, self.__queue.peek())

  def test_one_queue_str(self):
    self.__queue.enqueue(1)
    self.assertEqual('[ 1 ]', str(self.__queue))

  def test_one_queue_len(self):
    self.__queue.enqueue(1)
    self.assertEqual(1, len(self.__queue))

  def test_one_queue_enqueue(self):#notice that the right end of string representation is the back of queue.
    self.__queue.enqueue(1)
    self.__queue.enqueue(2)
    self.assertEqual('[ 1, 2 ]', str(self.__queue))

  def test_one_queue_dequeue_return(self):#tests if dequeue returns value correctly
    self.__queue.enqueue(1)
    self.assertEqual(1, self.__queue.dequeue())

  def test_one_queue_dequeue_remove(self):#tests if dequeue removes value correctly
    self.__queue.enqueue(1)
    self.__queue.dequeue()
    self.assertEqual('[ ]', str(self.__queue))

  def test_one_queue_peek(self):
    self.__queue.enqueue(1)
    self.assertEqual(1, self.__queue.peek())

  def test_two_queue_str(self):
    self.__queue.enqueue(1)
    self.__queue.enqueue(2)
    self.assertEqual('[ 1, 2 ]', str(self.__queue))

  def test_two_queue_len(self):
    self.__queue.enqueue(1)
    self.__queue.enqueue(2)
    self.assertEqual(2, len(self.__queue))

  def test_two_queue_enqueue(self):#notice that the right end of string representation is the back of queue.
    self.__queue.enqueue(1)
    self.__queue.enqueue(2)
    self.__queue.enqueue(3)
    self.assertEqual('[ 1, 2, 3 ]', str(self.__queue))

  def test_two_queue_dequeue_return(self):#tests if dequeue returns value correctly
    self.__queue.enqueue(1)
    self.__queue.enqueue(2)
    self.assertEqual(1, self.__queue.dequeue())

  def test_two_queue_dequeue_remove(self):#tests if dequeue removes value correctly
    self.__queue.enqueue(1)
    self.__queue.enqueue(2)
    self.__queue.dequeue()
    self.assertEqual('[ 2 ]', str(self.__queue))

  def test_two_queue_peek(self):
    self.__queue.enqueue(1)
    self.__queue.enqueue(2)
    self.assertEqual(1, self.__queue.peek())

  def test_queue_multiple_enqueue_dequeue(self):#test if multiple enqueues and dequeues work as expected
    self.__queue.enqueue(1)
    self.__queue.enqueue(2)
    self.__queue.dequeue()
    self.__queue.enqueue(4)
    self.__queue.dequeue()
    self.__queue.enqueue(6)
    self.__queue.enqueue(7)
    self.__queue.enqueue(8)
    self.__queue.dequeue()
    self.assertEqual('[ 6, 7, 8 ]', str(self.__queue))
def evalPost(post_list):
    val_stack = Stack()

    for post in post_list:
        # Numbers into a value stack
        if type(post) is float:
            val_stack.push(post)

        # Operators
        # calculate two numbers then add new value to the value stack
        elif post == '+':
            n1 = val_stack.pop()
            n2 = val_stack.pop()
            val_stack.push(n2 + n1)

        elif post == '-':
            n1 = val_stack.pop()
            n2 = val_stack.pop()
            val_stack.push(n2 - n1)

        elif post == '*':
            n1 = val_stack.pop()
            n2 = val_stack.pop()
            val_stack.push(n2 * n1)

        elif post == '/':
            n1 = val_stack.pop()
            n2 = val_stack.pop()
            val_stack.push(float(n2 / n1))

    # Get the final value after calculating all
    return val_stack.pop()
Ejemplo n.º 46
0
class Trashcan:
    def __init__(self, rounds):
        self.rounds = rounds
        self.player_1_round = 10  # A counter to keep track of which round each person is on
        self.player_2_round = 10
        self.draw_pile = Stack()
        self.burn_pile = Stack()
        self.player_1_hand = Queue()
        self.player_2_hand = Queue()
        self.cards = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
                      12]  # Standard suit of cards
        self.cards_s = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
        self.card_names = [
            "Ace", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight",
            "Nine", "Ten", "Jack", "Queen", "King"
        ]  # card name equivalents
        self.player_1_field = []
        self.player_2_field = []

    def create_draw_pile(self):  # This code was reused from War.py
        """
        Adds cards to dealing pile
        :return: None
        """
        for i in range(4):
            for l in self.cards:
                self.draw_pile.push(l)
        self.draw_pile.shuffle()

    def draw(self, hand):
        """
        Takes a card from the top of the draw_pile and enqueues that card into the the provided player's hand
        :param hand: A queue for a player's cards held in their hand
        :return: None
        """
        card = self.draw_pile.pop()
        hand.enqueue(card)

    def create_playing_field(
            self, n, hand, field):  # This is the code I did BigO analysis for
        """
        Draws 10 cards to each player from the draw_pile. Then the playing fields get the cards from each players hand
        :return: None
        """
        while hand.size() < n:
            self.draw(hand)
        while hand.size() != 0:
            field.append(hand.dequeue())

    def placing_phase(self, hand, field, player_round):
        """
        Draws a card and places it in the appropriate spot. If a King is drawn, prompts the user to provide a slot to
        place it in. If a Jack or Queen is drawn, the cycle ends. If a drawn card can not be placed, the cycle ends.
        :param hand: The hand of the current player
        :param field: The field of the current player
        :param player_round: what round the player is on
        :return: None
        """
        if self.draw_pile.size(
        ) == 0:  # If the draw pile is empty, it is refreshed using the burn pile
            self.refresh()
        self.draw(hand)
        while True:
            card = hand.dequeue()
            if card == 0 or card == 7:  # Code to print out what was drawn using an if the card is an Ace or 8
                input("An " + self.card_names[card] + " was drawn.")
            else:  # Code to print out what was drawn for all other cards
                input("A " + self.card_names[card] + " was drawn.")
            if player_round <= card < 12:  # If the card is a Jack or Queen
                print("Nothing could be done. . .")
                break
            elif card == 12 or card == "King":  # If the card is a King
                print(
                    "Here is your current field:"
                )  # Just a reminder to the player of what they have so far.
                print(field)
                choice = input(
                    "Choose a number between 1 and 10 to place the king in that spot."
                )  # Asks where the user wants the King
                while True:
                    while choice not in self.cards_s:
                        print("That was an invalid choice.")
                        choice = input(
                            "Choose a number between 1 and 10 to place the king in that spot"
                        )
                    choice = int(choice)
                    if isinstance(
                            field[choice - 1], str
                    ):  # Checks to see if the slot has been filled by checking if the type is a string
                        choice = input(
                            "That spot has already been filled with the correct card. Please provide "
                            "another number")
                    else:
                        hand.enqueue(field[choice -
                                           1])  # Fills the slot with a King
                        field[choice - 1] = "King"
                        break
            elif field[
                    card] == "King":  # Checks to see if the slot has a King so the King can be reused
                hand.enqueue(12)
                field[card] = self.card_names[card]
                print("   " + str(field))
                input("")
            elif not isinstance(
                    field[card], str
            ):  # If it is not a King, this checks if the slot can be filled with the card
                hand.enqueue(field[card])
                field[card] = self.card_names[card]
                print("   " + str(field))
                input("")
            else:  # If nothing else can be done, the card in the hand is put in the burn pile and the cycle ends
                print("Nothing could be done. . .")
                self.burn_pile.push(card)
                break

    def check_field(self, field):
        """
        Checks a field to see if it is been completed.
        :param field: field to be checked
        :return: A boolean
        """
        for i in field:
            if not isinstance(i, str):
                return True
        return False

    def reset(self):
        """
        Clears all of the hands, piles, and fields.
        :return: None
        """
        del self.player_1_field[:]
        del self.player_2_field[:]
        self.draw_pile.clear()
        self.burn_pile.clear()
        self.player_1_hand.clear()
        self.player_2_hand.clear()

    def refresh(self):
        """
        Moves all cards from the burn pile to the draw pile
        :return: None
        """
        for i in range(self.burn_pile.size()):
            self.draw_pile.push(self.burn_pile.pop())
        self.draw_pile.shuffle()

    def end_of_round(self):
        """
        Prints out the progress of each player and calls reset() to end the round.
        :return: None
        """
        print("Player 1 has " + str(self.player_1_round) +
              " cards to fill and Player 2 has " + str(self.player_2_round) +
              " cards to fill.")
        self.reset()

    def play(self):
        """
        Creates the drawing pile, the fields, and goes through the placing phase until a player completes their field.
        Whichever players completed their field move on to the next round with 1 less slot to fill.
        :return: A Boolean
        """
        self.create_draw_pile()
        self.create_playing_field(self.player_1_round, self.player_1_hand,
                                  self.player_1_field)
        self.create_playing_field(self.player_2_round, self.player_2_hand,
                                  self.player_2_field)
        while True:
            input("Player 1's turn. Press enter to start.")
            self.placing_phase(self.player_1_hand, self.player_1_field,
                               self.player_1_round)
            input("Player 2's turn. Press enter to start.")
            self.placing_phase(self.player_2_hand, self.player_2_field,
                               self.player_2_round)

            if not self.check_field(
                    self.player_1_field) and not self.check_field(
                        self.player_2_field
                    ):  # Checks if both players finished
                self.player_1_round -= 1
                self.player_2_round -= 1
                break
            elif not self.check_field(
                    self.player_1_field
            ):  # If both players didn't finish, checks if Player 1 finished
                self.player_1_round -= 1
                break
            elif not self.check_field(
                    self.player_2_field):  # Checks if Player 2
                self.player_2_round -= 1
                break
        if self.player_1_round == 10 - self.rounds:  # Checks if player 1 has won
            print("Player 1 has won!")
            return False
        elif self.player_2_round == 10 - self.rounds:  # Checks if player 2 has won
            print("Player 2 has won!")
            return False
        else:  # If neither player has won yet, this ends the round
            self.end_of_round()
            return True
Ejemplo n.º 47
0
 def setUp(self):
   self.__deque = get_deque()
   self.__stack = Stack()
   self.__queue = Queue()
Ejemplo n.º 48
0
 def __init__(self):
     self.enqueue_stack = Stack()
     self.dequeue_stack = Stack()
Ejemplo n.º 49
0
def rev_String(String):
    stack = Stack()
    for char in String:
        stack.push(char)
    while not stack.is_empty():
        print(stack.pop() + " ")
Ejemplo n.º 50
0
 def __init__(self):
     super().__init__()
     self.minstack = Stack()
Ejemplo n.º 51
0
 def calPoints(self, ops):
     """
     :type ops: List[str]
     :rtype: int
     """
     a = Stack()
     total = 0
     for operation in ops:
         if (operation[0] == '-' and operation[1:].isdigit()) or operation.isdigit():
             a.push(int(operation))
         if operation == "C":
             a.pop()
         if operation == "D":
             a.push(a.top() * 2)
         if operation == "+":
             a.push(a.items[-1]+a.items[-2])
     for i in a.items:
         total += i
     return total
Ejemplo n.º 52
0
class QueueViaStack:
    def __init__(self):
        self.enqueue_stack = Stack()
        self.dequeue_stack = Stack()

    def enqueue(self, data):
        self.enqueue_stack.push(data)

    def dequeue(self):
        if not self.dequeue_stack.is_empty():
            return self.dequeue_stack.pop()
        else:
            while not self.enqueue_stack.is_empty():
                self.dequeue_stack.push(self.enqueue_stack.pop())
            return self.dequeue_stack.pop()

    def is_empty(self):
        return self.dequeue_stack.is_empty() and self.enqueue_stack.is_emtpy()

    def peek(self):
        top_element = self.dequeue()
        self.dequeue_stack.push(top_element)
        return top_element
Ejemplo n.º 53
0
from Stack import Stack

s = Stack()
print s.isEmpty()
s.push(4)
s.push('dog')
print(s.peek())
s.push(True)
print(s.size())
print(s.isEmpty())
s.push(8.4)
print(s.pop())
print(s.pop())
print(s.size())
 def __init__(self, stack_size):
     super().__init__(stack_size)
     self.min_stack = Stack(stack_size)
Ejemplo n.º 55
0
from Graph import Graph
from Stack import Stack

stack = Stack()

def routeExists(graph, a, b):
    if a == b:
        return True
    if graph.graphDictionary[a] = []:
        return False
    a_edges_nodes = graph.graphDictionary[a]
    for node in a_edges_nodes:
        if node == b:
            return True
        stack.push(node)
    while not stack.isEmpty():
        node = stack.pop()
        return routeExists(graph, node, b)

Ejemplo n.º 56
0
 def __init__(self, *args, **kwargs):
     super(StackWithMin, self).__init__(*args, **kwargs)
     self.min_stack = Stack()
Ejemplo n.º 57
0
from Recursividad import suma_lista_rec,countdown,eliminar_pila
from Stack import Stack

print("Prueba suma lista recursiva")
datos = [4,2,3,5]
res = suma_lista_rec(datos)
print(f"La suma de la lista es {res}")

print("\nPrueba Cuentaregresiva")
countdown(20)

print("\nPrueba ADT Stack")
s = Stack()
s.push(100)
s.push(50)
s.push(30)
s.push(120)
s.push(230)
s.push(10)
print("\nCaso Base")
s.to_string()
eliminar_pila(s)
print("\nCaso despues de la funcion")
s.to_string()
Ejemplo n.º 58
0
from Stack import Stack

stack = Stack(int) #Initialise a stack object with the data type.

#Gotta love them true loops.
while True:

    try:
        intInput = int(input("Please enter a non-negative integer to convert to binary: ")) #Retrieve the terminal input. Convert to int.
    except Exception:
        break;
    
    if intInput < 0:
        break
    
    
    #Push these remainders and pop em out like a baby afterwards. A binary baby.
    
    while intInput != 0:
        stack.push(intInput % 2)
        intInput //= 2

    while stack.top is not None:
        print(stack.pop(), end="")

    print("")

Ejemplo n.º 59
0
def infixToPostfix(tokenList):
    opStack = Stack()
    prec = {"^": 4, "*": 3, "/": 3, "+": 2, "-": 2, "(": 1}
    postfixList = []
    # tokenList = list(infix.split(" "))
    charTokens = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    numTokens = "1234567890"

    print ("token list: ", tokenList)
    for token in tokenList:
        if token in charTokens or token in numTokens or token.isdigit():
            postfixList.append(token)
        elif token == "(":
            opStack.push(token)
        elif token == ")":
            topToken = opStack.pop()
            while topToken != "(":
                postfixList.append(topToken)
                topToken = opStack.pop()
        else:
            while (not opStack.is_empty()) and \
                    (prec[opStack.peek()] >= prec[token]):
                postfixList.append(opStack.pop())
            opStack.push(token)
    while not opStack.is_empty():
        postfixList.append(opStack.pop())

    return ' '.join(postfixList)
Ejemplo n.º 60
0
            title = row[1].strip()
            name = row[2].strip()
            last_name = row[3].strip()
            st = Student(str(id), str(title), str(name), str(last_name))
            students.append(
                st)  #put the st which is student object to the students list
        line_cnt = line_cnt + 1

print(
    "===================================Stack data structure==================================="
)
print(
    '-----------------------------------create stack------------------------------'
)

stStudent = Stack(45)

print(
    '-----------------------------------Normal Flow------------------------------'
)
for i in students:
    print("push the ", i.__str__(), "Which is student object to the stack")
    stStudent.push(i)

while not stStudent.is_empty():
    print("This is the top value of the stack: ", stStudent.peek().__str__())
    print("Then take it out of the top stack by pop() it")
    stStudent.pop()

print(
    '-----------------------------------Using pop all()------------------------------'