Esempio n. 1
0
def main():
    global objArr, isRunning, projection, camera
    createWindow()
    projection = glGetFloatv(GL_PROJECTION_MATRIX)  # MATRICES VALUES....
    camera = CameraManagement.Camera(projection)
    # Creates objects at origin 0,0,0
    cube = Shapes.Cube(5)
    rectangle = Shapes.Rectangle(5, 5, 4, -5, 1, -2)
    pyramid = Shapes.Pyramid(-3, -4, 1)
    objArr = {cube, rectangle, pyramid}
    isRunning = True
    while isRunning:
        projection = glGetFloatv(GL_PROJECTION_MATRIX)
        #print (projection)
        glLoadIdentity
        try:
            glLoadMatrixf(camera.getMapped())
        except:
            """"""
        getKeys()
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        for i in objArr:
            i.update()
            i.updateColor()
        #UPDATES DIMENSIONS OF EACH OBJECT
        pygame.display.flip()
        pygame.time.wait(50)
 def __init__(self,
              center=(0, 0),
              width=5000,
              height=5000,
              power=45,
              freq=20,
              speed=25000):
     super(LaseredFiducial, self).__init__()
     if isinstance(center, tuple) == False:
         raise ValueError(
             'parameter center must be a tuple of x and y position!')
     if Utils._checkIfIntFloatOrLong(
             center[0]) == False or Utils._checkIfIntFloatOrLong(
                 center[1]) == False:
         raise ValueError('x and y of center must be long or int!')
     xstart = center[0] - width / 2.0
     xend = center[0] + width / 2.0
     ystart = center[1] - height / 2.0
     yend = center[1] + height / 2.0
     self.addElement(
         Shapes.LaserLine((xstart, center[1]), (xend, center[1]), power,
                          freq, speed))
     self.addElement(
         Shapes.LaserLine((center[0], ystart), (center[0], yend), power,
                          freq, speed))
Esempio n. 3
0
    def fractest(self, item, it=3):
        self.frac_choice = item
        if not self.F_c_v:
            self.F_c_v = True
            mb = Menubutton(self.fracsubframe, text="Iterations")
            mb.grid()
            mb.menu = Menu(mb, tearoff=0)
            mb["menu"] = mb.menu

            for x in range(3, 7):
                mb.menu.add_command(
                    label="%s" % x,
                    command=lambda x=x: self.fractest(self.frac_choice, x))
            mb.pack(side=BOTTOM, anchor=W)

        if item == 1:
            sq = Shapes.RegPoly(150, 4)
            sq.set_center(175, 175)
            sq.vertices(0)
            draw.sierpinski_sq_start(self.fraccr, sq, it)

        if item == 2:
            draw.t_frac_start(self.fraccr, it)

        elif item == 0:
            sq = Shapes.RegPoly(160, 3)
            sq.set_center(175, 175)
            sq.vertices(0)
            draw.s_gasket_start(self.fraccr, sq, it)
Esempio n. 4
0
class TestShapes(unittest.TestCase):


# Select a shape:
# 1. Circle
# 2. Square
# 3. Rhombus
# 4. Cube
# 5. Cylinder

# After basic size information is entered, the program will output
 # circumference/area/volume
#  of the shape, and the number of sides for the shape.

  @classmethod
  def setUp(self):
    self.shapes = Shapes()


  def test_circle_circumfrence(self):
    self.assertEqual(self.shapes.create_circle(4), 25.13)

  def test_square_volume(self):
    self.assertEqual(self.shapes.create_square(4), 16)

  def test_Rhombus_area(self):
    self.assertEqual(self.shapes.create_rhombus(4,4), 8)

  def test_cube_surface_area(self):
    self.assertEqual(self.shapes.create_cube(4), 64)

  def test_cylinder_volume(self):
    self.assertEqual(self.shapes.create_cylinder(4,4), 200.96)
Esempio n. 5
0
    def setShapes(self, shapeNum, x_offset, y_offset, x_width, y_width, angle):

        if shapeNum == 1:
            self.shape1_x = x_offset
            self.shape1_y = y_offset
            self.shape1_width = x_width
            self.shape1_height = y_width
            self.shape1_angle = angle
            self.shape1 = Shapes.AngledBox(self.x_init + self.shape1_x,
                                           self.y_init + self.shape1_y,
                                           self.shape1_width,
                                           self.shape1_height, angle)
        elif shapeNum == 2:
            self.shape2_x = x_offset
            self.shape2_y = y_offset
            self.shape2_width = x_width
            self.shape2_height = y_width
            self.shape2_angle = angle
            self.shape2 = Shapes.AngledBox(self.x_init + self.shape2_x,
                                           self.y_init + self.shape2_y,
                                           self.shape2_width,
                                           self.shape2_height, angle)
        elif shapeNum == 3:
            self.shape3_x = x_offset
            self.shape3_y = y_offset
            self.shape3_width = x_width
            self.shape3_height = y_width
            self.shape3_angle = angle
            self.shape3 = Shapes.AngledBox(self.x_init + self.shape3_x,
                                           self.y_init + self.shape3_y,
                                           self.shape3_width,
                                           self.shape3_height, angle)
        else:
            print "ERROR INCORRECT SHAPE NUMBER RECEIVED IN SET SHAPES"
Esempio n. 6
0
    def mousePressEvent(self, event):
        #randomly choose a shape to draw
        shapenum = randint(0, 4)
        if shapenum == 0:
            #information to draw Rectangle
            rect = Shapes.Rectangle(event.x(), event.y())
            self.__shapes.append(rect)

        elif shapenum == 1:
            #information to draw Squares
            square = Shapes.Squares(event.x(), event.y())
            self.__shapes.append(square)

        elif shapenum == 2:
            #information to draw Ellipse
            elpse = Shapes.Ellipses(event.x(), event.y())
            self.__shapes.append(elpse)

        elif shapenum == 3:
            #information to draw Circle
            circle = Shapes.Circles(event.x(), event.y())
            self.__shapes.append(circle)

        elif shapenum == 4:
            #information to draw Triangle
            tri = Shapes.Triangles(event.x(), event.y())
            self.__shapes.append(tri)

        self.update()
Esempio n. 7
0
 def __init__(self, x, y, eqns):
     super(ExpressionList, self).__init__()
     self.setX(x)
     self.setY(y)
     self.tree = list(eqns)
     self.bg = Shapes.getDefaultBackBrush()
     self.fr = Shapes.getDefaultHighlightColor()
Esempio n. 8
0
def runStartScreen(self):
    onStartScreen = True
    while onStartScreen:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                onStartScreen = False
                self.exit = True

        self.drawKinectFrame()
        self.getJointPos()

        drawStartText(self)

        if not drawDepthWarning(self) and playClicked(self):
            onStartScreen = False
            self.play = True
        elif editorClicked(self):
            onStartScreen = False
            self.editor = True

        Shapes.getHandCircle(self)
        Shapes.drawStartShapes(self)

        self.adjustKinectFrame()
        pygame.display.update()
        self.clock.tick(60)
Esempio n. 9
0
def _calc_RMSD(x0, y, ppm, spins):

    x0 = np.ndarray.tolist(x0)
    ls = np.zeros_like(ppm)

    for i, s in enumerate(spins):
        s.set_opt_vals(x0)
        if i == 0: ls += Shapes.logistic_basline(ppm, s)
        else: ls += Shapes.Gaussian(ppm, s)
    return np.linalg.norm(y - ls)
Esempio n. 10
0
 def paint(self, painter, option, widget):
     pen = getDefaultExpressionPen()
     font = Shapes.getDefaultFont()
     brush = Shapes.getDefaultForeBrush()
     pen.setWidthF(2.0)
     painter.scale(1, -1)
     painter.setPen(pen)
     painter.setFont(font)
     painter.setBrush(brush)
     for i in self.tree:
         i.paint(painter, font, 0, 0);
Esempio n. 11
0
    def divide(self):
        self.divided = True
        cx = self.boundary.center.x
        cy = self.boundary.center.y
        w = self.boundary.w
        h = self.boundary.h

        ul_rect = Shapes.Rect(Shapes.Point(cx - w / 4., cy - h / 4.), w / 2.,
                              h / 2.)
        self.ul = QuadTree(ul_rect, self.capacity)
        ur_rect = Shapes.Rect(Shapes.Point(cx + w / 4., cy - h / 4.), w / 2.,
                              h / 2.)
        self.ur = QuadTree(ur_rect, self.capacity)
        ll_rect = Shapes.Rect(Shapes.Point(cx - w / 4., cy + h / 4.), w / 2.,
                              h / 2.)
        self.ll = QuadTree(ll_rect, self.capacity)
        lr_rect = Shapes.Rect(Shapes.Point(cx + w / 4., cy + h / 4.), w / 2.,
                              h / 2.)
        self.lr = QuadTree(lr_rect, self.capacity)

        for object in self.objects:
            self.ul.insert(object)
            self.ur.insert(object)
            self.ll.insert(object)
            self.lr.insert(object)

        self.objects = []
Esempio n. 12
0
 def print_dynamic(self, name, dyn, pos, alias, prop):
     def assert_pos(name, n):
         if len(pos) != n:
             raise Exception('%s dynamic expects %d offsets, provided %d' % (name, n, len(pos)))
     if dyn == 'force':
         assert_pos('force', 4)
         d = Shapes.Arrow(pos[0], pos[1], pos[2], pos[3], alias)
     elif dyn == 'weight':
         assert_pos('weight', 4)
         d = Shapes.Arrow(pos[0], pos[1], pos[2], pos[3], alias)
     elif dyn == 'rod':
         assert_pos('rod', 4)
         d = Shapes.Rod(pos[0], pos[1], pos[2], pos[3], alias)
     elif dyn == 'spring':
         assert_pos('spring', 4)
         d = Shapes.Spring(pos[0], pos[1], pos[2], pos[3], alias)
     elif dyn == 'dampener':
         assert_pos('dampener', 4)
         d = Shapes.Dampener(pos[0], pos[1], pos[2], pos[3], alias)
     elif dyn == 'torque':
         assert_pos('torque', 2)
         r = float(prop.get('radius', Shapes.getDefaultCArrowRadius()))
         c = prop.get('ccw', '0')
         if c == '0':
             c = False
         else:
             c = True
         d = Shapes.CircularArrow(pos[0], pos[1], r, alias)
     elif dyn == 'belt':
         assert_pos('belt', 4)
         c = prop.get('crossed', '0')
         r0 = float(prop['r0'])
         r1 = float(prop['r1'])
         if c == '0':
             c = False
         else:
             c = True
         d = Shapes.Belt(pos[0], pos[1], r0, pos[2], pos[3], r1, c, alias)
     elif dyn == 'angularspring':
         assert_pos('angularspring', 2)
         r = float(prop.get('radius', Shapes.getDefaultCArrowRadius()))
         d = Shapes.AngularSpring(pos[0], pos[1], r, alias)
     elif dyn == 'angulardampener':
         assert_pos('angulardampener', 2)
         r = float(prop.get('radius', Shapes.getDefaultCArrowRadius()))
         d = Shapes.AngularDampener(pos[0], pos[1], r, alias)
     else:
         raise Exception('unknown dynamic type %s' % dyn)
     self.dynscene[name] = d
     self.scene.addItem(d)
Esempio n. 13
0
    def __init__(self, handle):
        super(PeterActivity, self).__init__(handle)

        # Build the activity toolbar.
        toolbox = activity.ActivityToolbox(self)
        activity_toolbar = toolbox.get_activity_toolbar()
        activity_toolbar.keep.props.visible = False
        activity_toolbar.share.props.visible = False

        toolbox.show()
        self.set_toolbox(toolbox)

        # Create the game instance.
        self.game = Shapes.Shapes()

        # Build the Pygame canvas.
        self._pygamecanvas = \
            sugargame.canvas.PygameCanvas(self)
        # Note that set_canvas implicitly calls
        # read_file when resuming from the Journal.
        self.set_canvas(self._pygamecanvas)
        self.game.canvas=self._pygamecanvas

        # Start the game running.
        self._pygamecanvas.run_pygame(self.game.run)
Esempio n. 14
0
def test_example():

    expected = 19.63495
    circle = sh.Circle()
    circle.radius = 2.5
    actual = round(circle.area, 5)
    print_test_results(test_example, expected, actual)
Esempio n. 15
0
    def __init__(self, resultsQueue):
        self.height = 24
        self.width = 10
        self.field = [
        ]  # Initialising the field with this for some reason breaks things [[0]*self.width]*self.height
        self.currentBlock = None
        self.score = 0
        self.linesCleared = 0
        self.level = 0
        self.down = False
        self.gameOver = False
        self.reserved = None
        self.startX = (1920 / 2) - (
            self.width * (35 / 2)
        )  #The top left of the grid's x cord, 35 is how big each square is in units
        self.startY = (1080 / 2) - (
            self.height * (35 / 2)
        )  #The top left of the grid's y cord, 35 is how big each square is in units
        self.nextShapes = []

        self.resultsQueue = resultsQueue
        for i in range(3):
            self.picked = self.nextShapes.append(
                Shapes.Shapes(3, 0, self.picked))
            self.picked = self.nextShapes[-1].picked
        for i in range(self.height):
            newRow = []
            for j in range(self.width):
                newRow.append(0)
            self.field.append(newRow)
Esempio n. 16
0
 def newBlock(self):
     self.down = False
     self.currentBlock = self.nextShapes.pop(0)
     self.nextShapes.append(Shapes.Shapes(3, 0, self.picked))
     self.picked = self.nextShapes[-1].picked
     if self.intersects():
         self.gameOver = True
Esempio n. 17
0
 def __init__(self, symbol):
     self.text = QtGui.QStaticText()
     self.text.setTextWidth(-1)
     opt = self.text.textOption()
     opt.setWrapMode(QtGui.QTextOption.NoWrap)
     self.text.setTextOption(opt)
     self.text.setText(Shapes.texToRTF(symbol))
Esempio n. 18
0
def make_rect_at_center(x, y, w, h, rot=0):  #pylint:disable-msg=C0103
    """
    Makes a collision rectangle.
    
    x, y specify the center of the rectangle.
    """
    return Shapes.Rectangle(x, y, w, h, rot)
Esempio n. 19
0
def make_rect_at_bottom_left(x, y, w, h, rot=0):  #pylint:disable-msg=C0103
    """
    Makes a collision rectangle.
    
    x, y specify the bottom left corner of the rectangle.
    """
    return Shapes.Rectangle(x + w / 2.0, y + w / 2.0, w, h, rot)
Esempio n. 20
0
 def redraw(self, type):
     if type == MOUSEMOTION and type != self.MODE:
         self.blit(Shapes.drawOutsetRect(self, self.get_size(), 10, Colors.LIGHT_BACKGROUND, Colors.MENU_BUTTON_BACKGROUND), (0,0))
         self.blit(self.text, self.text_location)
         self.mainController.myView.MENU.drawMenu()
         self.mainController.myView.drawScreen()
     elif type == MOUSEBUTTONUP and type != self.MODE:
         self.blit(Shapes.drawOutsetRect(self, self.get_size(), 10, Colors.BACKGROUND, Colors.MENU_BUTTON_BACKGROUND), (0,0))
         self.blit(self.text, self.text_location)
         self.mainController.myView.MENU.drawMenu()
         self.mainController.myView.drawScreen()
     elif type == MOUSEBUTTONDOWN and type != self.MODE:
         self.blit(Shapes.drawOutsetRect(self, self.get_size(), 10, Colors.DARK_GREY, Colors.MENU_BUTTON_BACKGROUND), (0,0))
         self.blit(self.text, self.text_location)
         self.mainController.myView.MENU.drawMenu()
         self.mainController.myView.drawScreen()
Esempio n. 21
0
def test_shapes_c():
    shape_circle_test = Shapes.Circle()
    shape_circle_test.radius = 2.5
    desc = ""
    expected = 19.63495
    actual = shape_circle_test.area()
    print_test_results(test_shapes_c, desc, expected, actual)
    print str(shape_circle_test)
Esempio n. 22
0
def test_find_circle_area():
    '''Test radius 2.5'''
    expected = round(19.6349540849, 5)
    circle = sha.Circle()
    circle.radius = 2.5
    actual = round(circle.area, 5)
    print_test_results(test_find_circle_area, expected, actual)
    print str(circle)
Esempio n. 23
0
def test_circleArea():
    circle1 = shp.Circle()
    circle1.radius = 2.5
    expected = (math.pi * circle1.radius**2)
    desc = "Returns area of circle from radius."
    actual = circle1.area
    print_test_results(blank, desc, expected, actual)
    print str(circle1) , '\n'
Esempio n. 24
0
def test_SquareArea():
    square1 = shp.Square()
    square1.side_length = 3
    expected = (square1.side_length ** 2)
    desc = "Returns area of square from side length."
    actual = square1.area
    print_test_results(blank, desc, expected, actual)
    print str(square1), '\n'
Esempio n. 25
0
def test_find_square_area():
    '''Test length 10'''
    expected = 9
    square = sha.Square()
    square.length = 3
    actual = square.area
    print_test_results(test_find_square_area, expected, actual)
    print str(square)
Esempio n. 26
0
def test_shapes_s():
    shape_square_test = Shapes.Square()
    shape_square_test.side = 2.0
    desc = ""
    expected = 4.0
    actual = shape_square_test.area()
    print_test_results(test_shapes_s, desc, expected, actual)
    print str(shape_square_test)
Esempio n. 27
0
def draw_PENROSE(cr, tri, l):
    #Draws Penrose N-sided regular polygon onto canvas with a stroke and no fill

    #Checks if possible to draw with given polygon side length and offset length
    if 0 >= tri.side_length - 4 * l * (math.cos(tri.inter_angle) + 1):
        print "INVALID"
        return

    else:
        inner_tri = Shapes.RegPoly(
            tri.side_length - 4 * l * (math.cos(tri.inter_angle) + 1),
            tri.num_sides)
        inner_tri.set_center(tri.centerx, tri.centery)
        inner_tri.vertices(tri.offset)
        point_tri = []
        for y in range(tri.num_sides):
            point_tri.append(Shapes.RegPoly(l, tri.num_sides))
            point_tri[y].set_center(tri.centerx+(tri.radius-point_tri[y].radius)*math.cos(tri.angle*y \
            +tri.offset),tri.centery+(tri.radius-point_tri[y].radius)*math.sin(tri.angle*y+tri.offset))
            point_tri[y].vertices(tri.offset)
            #draw_RegPoly(cr,point_tri[y])

        #draw_RegPoly(cr,tri)
        draw_RegPoly(cr, inner_tri)

        cr.move_to(point_tri[0].points[tri.num_sides - 1][0],
                   point_tri[0].points[tri.num_sides - 1][1])
        cr.line_to(point_tri[0].points[1][0], point_tri[0].points[1][1])
        for x in range(1, tri.num_sides):
            a = (x + tri.num_sides - 1) % tri.num_sides
            b = (x + 1) % tri.num_sides
            cr.line_to(point_tri[x].points[a][0], point_tri[x].points[a][1])
            cr.line_to(point_tri[x].points[b][0], point_tri[x].points[b][1])
        cr.close_path()
        cr.stroke()

        for z in range(tri.num_sides):
            a = (z + tri.num_sides - 1) % tri.num_sides
            b = (z + 1) % tri.num_sides
            angle = tri.inter_angle*(float((tri.num_sides-3))/(tri.num_sides-2) ) - \
            (tri.inter_angle)*(z)*(float(2)/(tri.num_sides-2))
            cr.move_to(inner_tri.points[b][0], inner_tri.points[b][1])
            cr.rel_line_to(l * math.sin(angle), l * math.cos(angle))
            cr.line_to(point_tri[z].points[a][0], point_tri[z].points[a][1])
            cr.stroke()
Esempio n. 28
0
def test_square_area():
    desc = 'Returns the the area of a square if we know the length of its side'
    square = Shapes.Square()
    side = 3
    square.side = side
    expected = (side)**2
    actual = square.area
    print_test_results(Shapes.Square, desc, expected, actual)
    print str(square) + '\n'
Esempio n. 29
0
def test_find_rectangle_area():
    '''Test length 2, width 4'''
    expected = 8
    rectangle = sha.Rectangle()
    rectangle.length = 2
    rectangle.width = 4
    actual = rectangle.area
    print_test_results(test_find_rectangle_area, expected, actual)
    print str(rectangle)
Esempio n. 30
0
def random_sphere():
    r = random.random()
    g = random.random()
    b = random.random()
    x = random.randint(0, 10) * (random.random() * 2 - 1)
    y = random.randint(0, 10) * (random.random() * 2 - 1)
    z = random.randint(0, 10) * (random.random() * 2 - 1)
    sphere = Shapes.Sphere(1, 20, 20, (x, y, z), (r, g, b),(0, 0, 0))
    return sphere
Esempio n. 31
0
def Penrose():
    Length, Width = 1000, 1000
    for x in range(3, 10):
        img = cairo.SVGSurface("Penrose%s.svg" % x, Length, Width)
        cr = cairo.Context(img)
        polygon = Shapes.RegPoly(333, x)
        polygon.set_center(Length / 2, Width / 2)
        draw_PENROSE(cr, polygon, 30)
        cr.show_page()
Esempio n. 32
0
def test_circle_area():
    desc = 'Returns the the area of a circle if we know its radius'
    circle = Shapes.Circle()
    radius = 2.5
    circle.radius = radius
    expected = math.pi * radius**2
    actual = circle.area
    print_test_results(Shapes.Circle, desc, expected, actual)
    print str(circle) + '\n'
Esempio n. 33
0
def listtopoints(points):
    Pts = []
    for cs in points:
        try:
            x, y, z = cs
            Pts.append(Sh.Point(x, y, z))
        except:
            Pts.append([])
    return Pts
Esempio n. 34
0
def test_RectangleArea():
    rect1 = shp.Rectangle()
    rect1.width = 4
    rect1.height = 2
    expected = (rect1.height * rect1.width)
    desc = "Returns area of a rectangle from length and height."
    actual = rect1.area
    print_test_results(blank, desc, expected, actual)
    print str(rect1)
Esempio n. 35
0
def test_shapes_r():
    shape_rectangle_test = Shapes.Rectangle()
    shape_rectangle_test.height = 2.0
    shape_rectangle_test.width = 4.0
    desc = ""
    expected = 8.0
    actual = shape_rectangle_test.area()
    print_test_results(test_shapes_r, desc, expected, actual)
    print str(shape_rectangle_test)
Esempio n. 36
0
 def boundingRect(self):
     h = 0
     w = 0
     m = getDefaultExpressionListMargin()
     font = Shapes.getDefaultFont()
     for eqn in self.tree:
         b = eqn.boundingRect(font)
         h += b.height()
         w = max(w, b.width())
     return QtCore.QRectF(0, 0, w+m, h+m)
Esempio n. 37
0
def _calc_RMSD( x0, y, ppm, spins ):

	x0 = np.ndarray.tolist(x0)
	ls = np.zeros_like(ppm)

	for i,s in enumerate(spins): 
		s.set_opt_vals( x0 )
		if i == 0: ls += Shapes.logistic_basline(ppm, s ) 
		else:      ls += Shapes.Gaussian(ppm, s) 
	return np.linalg.norm( y - ls  )
Esempio n. 38
0
def sierpinski_sq_start(cr, sq, it):
    #Draws outer and center square of Sierpinski Carpet
    if it == 0:
        return
    draw_RegPoly(cr, sq)
    sq0 = Shapes.RegPoly(sq.side_length / 3, 4)
    sq0.set_center(sq.centerx, sq.centery)
    draw_RegPoly(cr, sq0)

    sierpinski_sq_rest(cr, sq0, it - 2)
Esempio n. 39
0
 def paint(self, painter, option, widget):
     pen = getDefaultExpressionPen()
     rpen = Shapes.getDefaultPen(True)
     font = Shapes.getDefaultFont()
     brush = Shapes.getDefaultForeBrush()
     m = getDefaultExpressionListMargin()
     b = self.boundingRect().adjusted(0, 0, m, m)
     pen.setWidthF(2.0)
     painter.scale(1, -1)
     painter.setPen(rpen)
     painter.setFont(font)
     painter.setBrush(self.bg)
     painter.drawRect(b)
     painter.setPen(pen)
     painter.setBrush(brush)
     h = m/2
     for i in self.tree:
         b = i.boundingRect(font)
         i.paint(painter, font, -b.left() + m/2, h + b.height()/2);
         h += b.height()
Esempio n. 40
0
 def __init__(self, mainController, location, size, text, isDropdown, command, options=[], commands=[]):
     pygame.Surface.__init__(self, (size))
     self.blit(Shapes.drawOutsetRect(self, size, 10, Colors.BACKGROUND, Colors.MENU_BUTTON_BACKGROUND), (0,0))
     self.mainController = mainController
     self.size = size
     self.location = location
     self.text = text
     self.command = command
     self.isDropdown = isDropdown
     self.text = Sources.MENU_FONT.render(text, 1, Colors.MENU_BUTTON_TEXT_COLOR)
     self.text_location = (self.size[0]/2 - self.text.get_size()[0]/2, self.size[1]/2 - self.text.get_size()[1]/2)
     self.blit(self.text, self.text_location)
     self.MODE = MOUSEBUTTONUP
Esempio n. 41
0
 def __init__(self, mainController, location, size, text, command, insideColor, outsideColor):
     pygame.Surface.__init__(self, (size))
     self.blit(Shapes.drawOutsetRect(self, size, 10, insideColor, outsideColor), (0,0))
     self.insideColor = insideColor
     self.outsideColor = outsideColor
     self.mainController = mainController
     self.size = size
     self.location = location
     self.text = text
     self.command = command
     self.text = Sources.MENU_FONT.render(text, 1, Colors.MENU_BUTTON_TEXT_COLOR)
     self.text_location = (self.size[0]/2 - self.text.get_size()[0]/2, self.size[1]/2 - self.text.get_size()[1]/2)
     self.blit(self.text, self.text_location)
     self.MODE = MOUSEBUTTONUP
Esempio n. 42
0
def coll_circle_line(circle, line, eps):
    """Circle-line collision detection."""
    d = Shapes.vec(line.p2 - line.p1) #pylint:disable-msg=C0103
    f = Shapes.vec(line.p1 - circle.get_center()) #pylint:disable-msg=C0103

    a = d.dot(d) #pylint:disable-msg=C0103
    b = 2 * f.dot(d) #pylint:disable-msg=C0103
    c = f.dot(f) - (circle.radius * circle.radius + eps) #pylint:disable-msg=C0103,C0301
    disc = b * b - 4 * a * c

    if disc < 0:
        #No intersection
        return False

    disc **= 0.5
    t1 = (-b + disc) / (2 * a) #pylint:disable-msg=C0103
    t2 = (-b - disc) / (2 * a) #pylint:disable-msg=C0103

    if 0 <= t1 <= 1:
        return True
    if 0 <= t2 <= 1:
        return True

    return False
Esempio n. 43
0
 def __init__(self, location, size, text, hint, inputType, mainController):
     pygame.Surface.__init__(self, (size))
     self.blit(Shapes.drawOutsetRect(self, size, 10, Colors.BACKGROUND, Colors.MENU_BUTTON_BACKGROUND), (0,0))
     self.size = size
     self.location = location
     self.fillerText = text
     self.hint = hint
     self.text = text
     self.asciiText = []
     self.text = Sources.MENU_FONT.render(text, 1, Colors.MENU_BUTTON_TEXT_COLOR)
     self.text_location = (self.size[0]/2 - self.text.get_size()[0]/2, self.size[1]/2 - self.text.get_size()[1]/2)
     self.blit(self.text, self.text_location)
     self.mainController = mainController
     self.MODE = MOUSEBUTTONUP
     self.ON_OFF_COUNTER = 0
     self.HAS_FOCUS = False
     self.redraw(False)
Esempio n. 44
0
def LorenDiff( ppm, y ):

	baseline  = Sim.Spin.Spin( R1=y[-1], R2= 0,  x0=0.0, c = 1.0 )
	water     = Sim.Spin.Spin( R1=0    , R2=100 , x0=0.0, c = 1e3 )
	s1        = Sim.Spin.Spin( R1=0    , R2=1e4 , x0=-3.0, c = 1e3 )


	baseline.set_lb_ub( 'c', None, None )
	baseline.set_lb_ub( 'x0', None, None )
	baseline.set_lb_ub( 'R1', None, None )
	baseline.set_lb_ub( 'R2', None, None )

	water.set_lb_ub( 'R2', None, None )
	water.set_lb_ub( 'c',  None, None )
	water.set_lb_ub( 'x0', None, None )

	s1.set_lb_ub( 'R2', None, None )
	s1.set_lb_ub( 'c',  None, None )
	s1.set_lb_ub( 'x0',  None, None )


	spins = [baseline, water, s1]
	
	x0=[]
	for s in spins: 
		for v in s.get_opt_vals(): x0.append(v)

	opt = optimize.minimize( _calc_RMSD, x0, args=(y, ppm, spins), method='Nelder-Mead', jac=False, options={'maxiter':1e4,'maxfev':1e4} )
	
	ls = np.zeros_like(ppm)
	xxx = np.ndarray.tolist( opt.x )	
	for i,s in enumerate(spins): 
		s.set_opt_vals( xxx )
		if i == 0: ls += Shapes.logistic_basline(ppm, s )
		else: ls +=  Shapes.Guassian(ppm, s )
	return ls 
Esempio n. 45
0
 def setUp(self):
   self.shapes = Shapes()
Esempio n. 46
0
def getDefaultExpressionPen():
    pen = Shapes.getDefaultPen()
    pen.setWidthF(1.0)
    return pen