def animate(self): self.index = 0 catmull = self.openGLWidget.history[0] if len(self.openGLWidget.animationObjects) == 1: self.openGLWidget.animationObjects.pop() ellipse = Ellipse(catmull.userDefinedPoints[1].x, catmull.userDefinedPoints[1].y, 10, 10) ellipse.compute() self.openGLWidget.animationObjects.append(ellipse) self.timer.start(self.delay)
def mousePressEvent(self, event): #check the type of object we are drawing if self.objectType == "Rectangle": # create Rectangle with properties at the clicked point: self.object = Rectangle(event.x(), self.height - event.y(), event.x(), self.height - event.y()) else: # create Ellipse with properties at the clicked point: self.object = Ellipse(event.x(), self.height - event.y(), event.x(), self.height - event.y())
def __init__(self, center=Coordinate(), radius=1.0, id=None, classes=None): """ @param center: A Coordinate defining the center in the SVG document @type center: Coordinate @param radius: The radius of the circle @param id: The unique ID to be used in the SVG document @type id: string @param classes: Classnames to be used in the SVG document @type classes: string or sequence of strings """ if isinstance(center, Coordinate): Ellipse.__init__(self, center, radius, radius, id, classes) self.tag = u'circle' else: raise TypeError("center must be of type 'Coordinate'")
def _detectMainEllipse(self): minDist = 100000 mainBlob = None for blob in self.image.dilate(2).findBlobs(minsize=200): dist = math.sqrt((blob.x - self.image.width/2)**2 + (blob.y - self.image.height/2)**2) if dist < minDist: minDist = dist mainBlob = blob blob = mainBlob ellipse = Ellipse() ellipse.fitToData(np.array(blob.hull())) return ellipse
def __init__(self): super().__init__() self.colorCounter = 1 self.setMouseTracking(False) __ellipseWidth = 100 __ellipseHeight = 450 self.object = Ellipse(0, 0, __ellipseWidth, __ellipseHeight) self.theta = 0 self.objectType = None self.rotationPointX = self.object.cx self.rotationPointY = self.object.cy
def buildEllipse(winner, center, top_votes, num_voters, major_axis, imgSize): minor_axis = winner[0] theta = winner[1] theshold = 0.1 ratio = 4 # votes must high enough and the major/minor rate cant be too much if top_votes <= num_voters*theshold or major_axis/minor_axis > ratio: # 0.15 / 2.5 print('[No result] {}/{} < {}, major/minor {} > {}'.format( top_votes, num_voters, theshold, major_axis/minor_axis, ratio)) e = None success = False else: print('[Detected] minor = {}, theta={}'.format(minor_axis, theta*pi/180)) e = Ellipse((major_axis, minor_axis), center, theta, imgSize) success = True return success, e
class CreateObjects: if __name__ == '__main__': figure1 = Circle("red", 12) figure2 = Ellipse("pink", 9, 15) figure3 = Triangle("black", 4, 7, 10) figure4 = IsoscelesTriangle("none", 6, 10) figure5 = EquilateralTriangle("millitary", 7) figure6 = Square("red", 6) figure7 = Rectangle("green", 6, 12) listFigures = [ figure1, figure2, figure3, figure3, figure4, figure5, figure6, figure7 ] for shape in listFigures: print("========= Number : " + str(listFigures.index(shape) + 1) + " ============") shape.informationAboutFigure()
from Vector import * from Ellipse import Ellipse C = O() a = 2.0 b1 = 1.0 b2 = 2.0 N = 100 db = 1.0 * (b2 - b1) / (1.0 * (N - 1)) b = b1 for n in range(N): curve = Ellipse(a, b, C, N) curve.Rs() curve.Init_Canvas() fname = "Ellipse/" + ("%03d" % n) + ".svg" options = { "stroke": 'blue', "style": { "stroke-width": 2, } } curve.Curve_SVG_Line_Write(fname, options) b += db
# Simulation parameters N, s, T = 64, 10e6, .102 h = 1. / N dt = .00000003 Time = SimTime(dt = dt, T = T) # Setup for saving the simulation output SavePeriod = 100 #int((T / dt) / 120) Save = SaveData.SaveDataControl(('EllipseRelaxation', 'Explicit')) # Ellipse X = Ellipse(2 * N, s, [.5,.5], [.8,.5], [.5,.6]) X.UseNativePython = False # If true native python code is used instead of C code # Initialize the fluid solver u = Fluid(dt = dt, N = [N,N], dims = [1., 1.]) # The simulation loop Time.StartTimer() while Time.t < Time.T: Time.PrintStepInfo() X.CheckForExplosion() # The FE/BE method # First calculate the fiber force F (stored in X.F) X.CalcForceDistribution()
rectangle = Rectangle('5','8','88','99') ROIs.append(rectangle.generateXML()) square = Square('55','99','520') ROIs.append(square.generateXML()) xs=[1,2,3,4,5,6] ys=[6,5,4,555,2,3] polygon = Polygon(xs,ys) ROIs.append(polygon.generateXML()) """ #Como hemos comentado en el metodo, aqui solo tenemos que llamarlo y el se encarga de generar el xml esperado. Solo queda aniadirlo a la raiz rois = [ Ellipse('7', '8', '0.2'), Ellipse('55', '55', '0.222'), Ellipse('777', '777', '0.777') ] ROIsofImage.append(generateXMLDocument(rois)) """ En esta parte es donde creamos el archivo XML que tiene de contenido las regiones que hemos captado de OpenCV. Al abrir ese archivo, si no esta se crea pero si ya esta generado se machaca el contenido que tuviera, de esta forma es conveniente que el nombre del archivo sea diferente cada vez que queramos guardar las regiones de una foto. """ archi = open('datos.xml', 'w') archi.flush() archi.write( etree.tostring(ROIsofImage, pretty_print=True,
def calculate(value): schema = Ellipse(c_aux = value) return schema.mas()
""" from numpy import zeros, float64, floor, array, dot import IB from Fluid import Fluid from Ellipse import Ellipse from MatrixUtility import Stack, Unstack # Simulation parameters N = 128 RestrictToEulerian = False # If True we restrict the fiber points to Eulerian intersections. When done the matrix should give EXACT results. # Create the fiber in the shape of an ellipse X = Ellipse(2 * N, s = 10e6, c = [.5,.5], p1 = [.8,.5], p2 = [.5,.6]) if RestrictToEulerian: X.X = floor(X.X * N) / N # Initialize the fluid solver u = Fluid(dt = 1. / N, N = [N,N], dims = [1., 1.]) # Calculate dX/dt (stored in X.U) using a fluid solve X.CalcForceDistribution() X.ToGrid(u) u.UpdateFluid(u.f) X.FromGrid(u) # Calculate dX/dt (stored in U) using the fluid matrix
* black background * white foreground ''' import sys import math from Rectangle import Rectangle from Ellipse import Ellipse from PyQt5.QtOpenGL import QGLWidget from PyQt5.QtCore import QSize import OpenGL.GL as GL import OpenGL.GLU as GLU REC = Rectangle(0, 0, 0, 0) ELLI = Ellipse(0, 0, 0, 0) class GLStandardDrawingWindow(QGLWidget): def __init__(self): super().__init__() self.width, self.height = 500, 600 self.resize(self.width, self.height) self.move(100, 100) self.history = [] self.numberOfClicks = 0 def minimumSizeHint(self): return QSize(50, 100) def sizeHint(self):
""" from numpy import zeros, float64, floor, array, dot import IB from Fluid import Fluid from Ellipse import Ellipse from MatrixUtility import Stack, Unstack # Simulation parameters N = 128 RestrictToEulerian = False # If True we restrict the fiber points to Eulerian intersections. When done the matrix should give EXACT results. # Create the fiber in the shape of an ellipse X = Ellipse(2 * N, s=10e6, c=[.5, .5], p1=[.8, .5], p2=[.5, .6]) if RestrictToEulerian: X.X = floor(X.X * N) / N # Initialize the fluid solver u = Fluid(dt=1. / N, N=[N, N], dims=[1., 1.]) # Calculate dX/dt (stored in X.U) using a fluid solve X.CalcForceDistribution() X.ToGrid(u) u.UpdateFluid(u.f) X.FromGrid(u) # Calculate dX/dt (stored in U) using the fluid matrix # First construt the fluid matrix M = X.ConstructFluidMatrix(u)
def eval_mas(value): schema = Ellipse(N=N, a=a, b=b, k=k, c_aux=value, c_obs=2*c_obs) return schema.mas(champion=True)
def evaluation_function2(value): schema = Ellipse(N=N, a=a, b=b, k=k, c_aux=value, c_obs=c_obs) return schema.mas(champion=True)
def test_ellipse_circle_area(self): ellipse = Ellipse('circle',12,12) self.assertEqual(round(ellipse.get_area(),1), 113.1)
def test_ellipse_noncircle_area(self): ellipse = Ellipse('non-circle',12,4) self.assertEqual(round(ellipse.get_area(),1), 37.7)
class DrawingWindow(GLStandardDrawingWindow): def __init__(self): super().__init__() self.colorCounter = 1 self.setMouseTracking(False) self.object = None self.objectType = None def setObjectType(self, name): self.objectType = name def mousePressEvent(self, event): #check the type of object we are drawing if self.objectType == "Rectangle": # create Rectangle with properties at the clicked point: self.object = Rectangle(event.x(), self.height - event.y(), event.x(), self.height - event.y()) else: # create Ellipse with properties at the clicked point: self.object = Ellipse(event.x(), self.height - event.y(), event.x(), self.height - event.y()) def mouseMoveEvent(self, event): #check the type of object we are re-drawing if type(self.object) is type(REC): self.object.points = [] self.object.x1 = event.x() # Make square if event.modifiers() and QtCore.Qt.ShiftModifier: #length and width have to be the same self.object.y1 = distance( self.object.y0, (distance(self.object.x0, self.object.x1))) else: self.object.y1 = distance(self.height, event.y()) self.object.compute() elif type(self.object) is type(ELLI): self.object.points = [] self.currentX = distance(self.object.cx, event.x()) if event.modifiers() and QtCore.Qt.ShiftModifier: self.object.a = self.currentX self.object.b = self.currentX else: self.object.a = self.currentX self.object.b = distance(self.object.cy, self.height - event.y()) self.object.bresenhamAlg() else: pass self.updateGL() def mouseReleaseEvent(self, event): self.history.append(self.object) def paintGL(self): ''' paintGL Updates the current object that is being drawn in screen. Draws whatever is on the history stack as a set of points ''' GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glBegin(GL.GL_POINTS) if self.object: for point in self.object.points: GL.glVertex2fv(point) for element in self.history: for point in element.points: GL.glVertex2fv( point ) # #map points according to the coordinates they belong to GL.glEnd() GL.glFlush()