Пример #1
0
def paint_polygon(polygon: tr.Triangle, draw: ImageDraw, texture: Image, z_buffer ):
    """
    Colorize inner part of triangle with specified color
    """
    first , second , third = polygon.first.projection() , polygon.second.projection() , polygon.third.projection()

    x0 = int(min(first.x, second.x, third.x))
    x1 = int(max(first.x, second.x, third.x))
    y0 = int(min(first.y, second.y, third.y))
    y1 = int(max(first.y, second.y, third.y))

    for x in range( x0 , x1 + 1 ) :
        for y in range( y0 , y1 + 1 ) :
            barycentric = polygon.getBaricenterCordinates(gr.Point(x, y))

            is_inside_triangle = all( i >= 0 for i in barycentric )
            if is_inside_triangle :
                # получаем координаты пикселя, соответствующего отрисовываемому в данный момент, из файла текстур
                # получаем цвет пикселя из файла текстур по вычисленным координатам
                z = polygon.tmp_Z(barycentric)
                get_pixel = get_texture_point(polygon, barycentric)
                color = (texture.getpixel(get_pixel))
                pixels = texture.load()

                intensity = (polygon.normalFirst.first +polygon.normalFirst.second + polygon.normalFirst.third) *barycentric[0]+\
                    (polygon.normalSecond.first +polygon.normalSecond.second + polygon.normalSecond.third) *barycentric[1]+\
                    (polygon.normalThird.first +polygon.normalThird.second + polygon.normalThird.third) *barycentric[2]

                color = (int(color[0]*intensity),int(color[1]*intensity),int(color[2]*intensity))
                draw_pixel(tr.Point(x, y, z), z_buffer, draw,get_pixel,intensity ,pixels,color)
    def __init__(self, master):
        self.dim = 500
        #init vars
        self.got_edge = 0
        #self.move_line = 0
        #self.move_oval = 0
        self.anistack = deque()
        self.moveanistack = deque()

        # create paining area
        self.canv = Canvas(root, width=self.dim, height=self.dim)
        self.canv.bind("<Button-1>", self.clicked)
        self.canv.bind("<B1-Motion>", self.moved)
        self.canv.bind("<ButtonRelease-1>", self.released)
        self.canv.pack()

        self.tri = Triangle([50, 70], [300, 300], [400, 100])
        self.tri.id = self.canv.create_polygon(self.tri.coo, fill='yellow')

        frame = Frame(master)
        frame.pack()

        self.button = Button(frame, text="QUIT", fg="red", command=frame.quit)
        self.button.pack(side=LEFT)

        self.hi_there = Button(frame, text="Reset", command=self.reset)
        self.hi_there.pack(side=LEFT)
Пример #3
0
def main():
    """
    Asks user for an input file
    Converts the series of height data values into triangles
    Writes triangles to file in stl format
    :return: None
    """
    # Ask user for file path and return data:
    in_path, data, meta_data = file_path_and_data()
    # Get useful meta data:
    cell_size = meta_data["cellsize"]
    offset = (meta_data["xllcorner"], meta_data["yllcorner"])
    # Set up output file:
    out_path = os.path.splitext(in_path)[0] + ".stl"
    setup_out_file(out_path)
    # Loop through data and write to file:
    # Each data point and its three right and lower neighbours
    # generate two surface triangles
    print("Writing STL surface...")
    for j0, row in enumerate(data[:-1]):
        for i0, z0 in enumerate(row[:-1]):
            # Triangle 1
            i = [i0, i0 + 1, i0]
            j = [j0, j0 + 1, j0 + 1]
            vx, vy, vz = calc_vertices(i, j, data, cell_size, offset)
            write_to_file(out_path, Triangle(vx, vy, vz))
            # Triangle 2
            i = [i0, i0 + 1, i0 + 1]
            j = [j0, j0, j0 + 1]
            vx, vy, vz = calc_vertices(i, j, data, cell_size, offset)
            write_to_file(out_path, Triangle(vx, vy, vz))
    end_out_file(out_path)
    print("Done.")
class TestTriangle(unittest.TestCase):
    def setUp(self):
        self.triangle = Triangle(2, 3, 4)

    def testInvariants(self):
        self.assertAlmostEqual(
            math.pi,
            self.triangle.alfa() + self.triangle.beta() +
            self.triangle.gamma())
        self.assertAlmostEqual(
            self.triangle.a / math.sin(self.triangle.alfa()),
            self.triangle.b / math.sin(self.triangle.beta()))
        self.assertAlmostEqual(
            self.triangle.c / math.sin(self.triangle.gamma()),
            self.triangle.b / math.sin(self.triangle.beta()))

    def testCircumference(self):
        self.assertAlmostEqual(9, self.triangle.circumference())

    def testScale(self):
        self.triangle.scale(10)
        self.assertAlmostEqual(20, self.triangle.a)
        self.assertAlmostEqual(30, self.triangle.b)
        self.assertAlmostEqual(40, self.triangle.c)
        self.testInvariants()
Пример #5
0
 def make_triangles(self):
     polyline = []
     triangles = []
     for p in self.points_list:
         polyline.append(p.get_coord())
     this_polygon = None
     for i in range(5):
         try:
             this_polygon = poly2tri.Triangulator(polyline)
             break
         except:
             pass
     if not this_polygon:
         return None
     for triangle in this_polygon.polygons:
         point_a = Point()
         point_a.set_coord(triangle[0].x, triangle[0].y)
         point_b = Point()
         point_b.set_coord(triangle[1].x, triangle[1].y)
         point_c = Point()
         point_c.set_coord(triangle[2].x, triangle[2].y)
         this_triangle = Triangle()
         this_triangle.set_point_by_points(point_a,
                                           point_b,
                                           point_c)
         triangles.append(this_triangle)
     return triangles
Пример #6
0
 def polygon_triangulation(self):
     """returns a list of triangles that describe the current polygon"""
     self.close_polygon()
     poly_line = []
     triangles = []
     for point in self.polygon_points:
         poly_line.append(point.get_point())
     this_polygon = None
     for i in range(5):
         try:
             this_polygon = poly2tri.Triangulator(poly_line)
             break
         except:
             pass
     if not this_polygon:
         return None
     for triangle in this_polygon.polygons:
         point_a = Point()
         point_a.set_point(triangle[0].x, triangle[0].y)
         point_b = Point()
         point_b.set_point(triangle[1].x, triangle[1].y)
         point_c = Point()
         point_c.set_point(triangle[2].x, triangle[2].y)
         this_triangle = Triangle()
         this_triangle.set_points_by_point(point_a, point_b, point_c)
         triangles.append(this_triangle)
     return triangles
Пример #7
0
 def testTriangleThirdNode(self):
     n1 = Node((0,0),1)
     n2 = Node((1,1),2)
     n3 = Node((0,1),3)
     t = Triangle(n1, n2, n3)
     self.assertEqual(n1, t.getThirdNode(n2,n3))
     self.assertEqual(n2, t.getThirdNode(n1,n3))
     self.assertEqual(n3, t.getThirdNode(n1,n2))
Пример #8
0
 def test_normal_Triangle(self):
     t = Triangle(Point(0, 1, 0), Point(-1, 0, 0), Point(1, 0, 0))
     n1 = t.local_normal_at(Point(0, 0.5, 0))
     n2 = t.local_normal_at(Point(-0.5, 0.75, 0))
     n3 = t.local_normal_at(Point(0.5, 0.25, 0))
     self.assertEqual(n1, t.normal)
     self.assertEqual(n2, t.normal)
     self.assertEqual(n3, t.normal)
Пример #9
0
 def test_triangle_bounding_box(self):
     p1 = Point(-3, 7, 2)
     p2 = Point(6, 2, -4)
     p3 = Point(2, -1, -1)
     shape = Triangle(p1, p2, p3)
     box = shape.bounds_of()
     self.assertEqual(box.min, Point(-3, -1, -4))
     self.assertEqual(box.max, Point(6, 7, 2))
Пример #10
0
    def add_point(self, p):
        # получаем новые образованные рёбра и треугольники в виде очереди
        flip_list = self.make_triangles(p)
        # флипаем некоторые рёбра, добавляем их соседей в очередь
        while flip_list:
            t1, e = flip_list.popleft()
            if t1 is None:
                continue
            t2 = t1.get_neigh(e)
            if t2 is None:
                continue
            p1, p2 = e
            p3 = t1.get_opposite(e)
            p4 = t2.get_opposite(e)
            # получаем окружность по трём точкам
            circle = Circle.get_circle(p1, p2, p3)
            # если четвертая точка в окружности, то делаем флип
            if Circle.is_in_circle(circle, p4):
                id1 = t1.id
                id2 = t2.id
                e13 = (p1, p3)
                e14 = (p1, p4)
                e23 = (p2, p3)
                e24 = (p2, p4)
                e34 = (p3, p4)

                t13 = t1.get_neigh(e13)
                t23 = t1.get_neigh(e23)
                t14 = t2.get_neigh(e14)
                t24 = t2.get_neigh(e24)

                t1_new = Triangle([[e13, t13],
                                   [e14, t14],
                                   [e34, None]],
                                  id1)
                t2_new = Triangle([[e23, t23],
                                   [e24, t24],
                                   [e34, t1_new]],
                                  id2)
                t1_new.set_neigh(e34, t2_new)

                # заменяем старые треугольники на новые
                self.triangles_list[id1] = t1_new
                self.triangles_list[id2] = t2_new

                if t13 is not None:
                    t13.set_neigh(e13, t1_new)
                if t14 is not None:
                    t14.set_neigh(e14, t1_new)
                if t23 is not None:
                    t23.set_neigh(e23, t2_new)
                if t24 is not None:
                    t24.set_neigh(e24, t2_new)
                # добавляем новые потенциально опасные ребра в виде пар [треугольник, проблемное ребро]
                flip_list.append([t14, e14])
                flip_list.append([t24, e24])
                flip_list.append([t13, e13])
                flip_list.append([t23, e23])
Пример #11
0
    def calcAffordances(self, lines):
        # Calculate affordances by intersecting agains one triangle per affordance
        # make initial triangle
        o = Point(0,0,0)  
        # The triangle is a bit behind
        oBehind = Point(-.2,0,0)
        v1 = Point(cos(self.aperture/2)*self.lenght, sin(self.aperture/2)*self.lenght,0)
        v2 = Point(cos(self.aperture/2)*self.lenght, -sin(self.aperture/2)*self.lenght,0)        
        t = Triangle([o,v1,v2])
        
        # for each angle: transform the triangle and intersect it with all lines
        lBase = Line(o, Point(1,0,0)); 
        affordances = []
        markers = []
        i = 0
        for angle in self.possibleAngles:
            # reference transformation
            lTransform = Line(o, Point(cos(angle), sin(angle), 0))
            mov = Movement(lBase, lTransform)
            tMoved = t.moved(mov);
            
            canMove = True
            j = 0
            while j < len(lines) and canMove:
                l = lines[j]
                p1 = l.p1
                p2 = l.p2
                canMove = canMove and not tMoved.containedOrIntersect(Point(p1.x,p1.y,p1.z), Point(p2.x,p2.y,p2.z))
                if not canMove:
                    print "cant move to", angle
                    print tMoved.vertices
                    print p1
                    print p2
                j += 1
            affordances.append(canMove)
            
#            if canMove:
#                color = 'b'
#            else:
#                color = 'r'
#            geomPoints = [geometry_msgs.msg.Point(p.r[0],p.r[1],p.r[2]) for p in tMoved.vertices]
#            geomPoints.append(geomPoints[0])
#            markers.append(self.getLineStrip(geomPoints, i, rospy.Time.now(), color))
#            i += 1
      
#        for l in lines:
##            print "line", a
#            markers.append(self.getLineStrip([l.p1,l.p2], i, rospy.Time.now(), 'g'))
#            i = i + 1 
#            
#        mArray = MarkerArray()
#        mArray.markers = markers
#        self.pubMarker.publish(mArray)
        
#        print "lines", lines
        
        return affordances 
Пример #12
0
    def flip_edges(self, min_sabr=0.05):
        new_internal_edges = list()
        while len(self.internal_edges) != 0:
            edge = self.internal_edges.pop()
            o_edge = opposite_edge(edge)
            if o_edge is not None:
                edge_len_squared = distance_squared(edge[0], edge[1])
                o_edge_len_squared = distance_squared(o_edge[0], o_edge[1])

                # sabr = "squared altitude-base ratio"
                current_too_skinny = min_sabr > min(
                    o_edge[0].dist_squared_from_line(edge[0], edge[1]) /
                    edge_len_squared,
                    o_edge[1].dist_squared_from_line(edge[0], edge[1]) /
                    edge_len_squared)
                new_too_skinny = min_sabr > min(
                    edge[0].dist_squared_from_line(o_edge[0], o_edge[1]) /
                    o_edge_len_squared,
                    edge[1].dist_squared_from_line(o_edge[0], o_edge[1]) /
                    o_edge_len_squared)

                current_tri1 = [o_edge[0], edge[0], edge[1]]
                current_tri2 = [o_edge[1], edge[0], edge[1]]
                new_tri1 = [edge[0], o_edge[0], o_edge[1]]
                new_tri2 = [edge[1], o_edge[0], o_edge[1]]

                if new_too_skinny == current_too_skinny:  # we won't check var_improves if (F, T) or (T, F)
                    current_var1 = self.variance(pixels_in_tri(current_tri1))
                    current_var2 = self.variance(pixels_in_tri(current_tri2))
                    new_var1 = self.variance(pixels_in_tri(new_tri1))
                    new_var2 = self.variance(pixels_in_tri(new_tri2))

                    var_improves = None not in (current_var1, current_var2, new_var1, new_var2) and \
                        new_var1 + new_var2 < current_var1 + current_var1

                # the edge will be flipped if a bordering triangle is currently too skinny (and flipping will fix that)
                # or if the variance would be better in the other direction
                if (current_too_skinny and not new_too_skinny) or \
                        (current_too_skinny and var_improves) or \
                        (not new_too_skinny and var_improves):
                    # flip the edge

                    self.tris.remove(Triangle(current_tri1))
                    self.tris.remove(Triangle(current_tri2))

                    self.tris.add(Triangle(new_tri1))
                    self.tris.add(Triangle(new_tri2))

                    remove_edge(edge[0], edge[1])
                    self.add_edge(o_edge[0], o_edge[1], auto_add_to_ie=False)

                    new_internal_edges.append(o_edge)
                else:
                    new_internal_edges.append(edge)
            else:
                new_internal_edges.append(edge)
        self.internal_edges = new_internal_edges
    def _generate_back(self):
        a = self._l_t + Point3D(z=self._step_count * self._step_height)
        b = a + Point3D(self._width)

        self.triangles.append(Triangle(a, b, self._r_t))
        self.triangles.append(Triangle(a, self._l_t, self._r_t))

        self.edges.append(Edge(a, self._l_t))
        self.edges.append(Edge(b, self._r_t))
Пример #14
0
def main():
	sh = Shape()
	print sh
	t = Triangle(5, 10)
	print t.area()
	print "%s Static Method" % t.static_area(10, 20)

	s = Square(20)
	print s.area()
	print s.perimeter()
Пример #15
0
def main(args):
    side1 = int(args[1])
    side2 = int(args[2])
    side3 = int(args[3])
    height = int(args[4])

    print("the three sides and height of triangle area %d %d %d and %d" %
          (side1, side2, side3, height))
    t1 = Triangle(side1, side2, side3, height)
    print("Perimeter: ", t1.perimeter())
    print("Area: ", t1.area())
Пример #16
0
    def make_triangles(self, p):
        # ищем треугольник для вставки внутрь него точки
        for index in range(len(self.triangles_list)):
            if self.triangles_list[index].is_point_in(p):
                insert_index = index
                break
        else:
            print("Точка должна лежать по крайней мере в одном из треугольников.")
            return None
        # треугольник, в который вставляем точку
        insert_triangle = self.triangles_list[insert_index]

        # создаём 3 новых треугольника
        p1, p2, p3 = insert_triangle.points()

        e1 = (p1, p2)
        e2 = (p2, p3)
        e3 = (p1, p3)

        e4 = (p1, p)
        e5 = (p2, p)
        e6 = (p3, p)

        t1 = insert_triangle.get_neigh(e1)
        t2 = insert_triangle.get_neigh(e2)
        t3 = insert_triangle.get_neigh(e3)

        new_t1 = Triangle([[e1, t1],
                           [e4, None],
                           [e5, None]],
                          insert_index)
        new_t2 = Triangle([[e2, t2],
                           [e5, new_t1],
                           [e6, None]],
                          len(self.triangles_list))
        new_t3 = Triangle([[e3, t3],
                           [e4, new_t1],
                           [e6, new_t2]],
                          len(self.triangles_list) + 1)

        new_t1.set_neigh(e5, new_t2)
        new_t1.set_neigh(e4, new_t3)
        new_t2.set_neigh(e6, new_t3)

        # обновляем соседей треугольника, в который вставили точку
        if t1 is not None:
            t1.set_neigh(e1, new_t1)
        if t2 is not None:
            t2.set_neigh(e2, new_t2)
        if t3 is not None:
            t3.set_neigh(e3, new_t3)

        # заменяем старый треугольник и добавляем новые
        self.triangles_list[insert_index] = new_t1
        self.triangles_list.append(new_t2)
        self.triangles_list.append(new_t3)

        # рёбра для возможного flip - пары [треугольник, проблемное ребро]
        return deque([[new_t1, e1], [new_t2, e2], [new_t3, e3]])
    def _generate_base(self):
        self._l_t = self._base_point
        self._r_t = self._l_t + Point3D(self._width)
        self._r_b = self._r_t + Point3D(y=self._step_count * self._step_length)
        self._l_b = self._r_b + Point3D(x=-self._width)

        self.triangles.append(Triangle(self._l_t, self._r_t, self._r_b))
        self.triangles.append(Triangle(self._l_t, self._l_b, self._r_b))

        self.edges.append(Edge(self._l_t, self._r_t))
        self.edges.append(Edge(self._r_t, self._r_b))
        self.edges.append(Edge(self._r_b, self._l_b))
        self.edges.append(Edge(self._l_b, self._l_t))
Пример #18
0
def test_one_cell_mesh():
    t = Triangle()
    points = [(0., 0.), (1., 0.), (0., 1.)]
    markers = [1, 1, 1]
    t.set_points(points, markers=markers)
    segments = [(0, 1), (1, 2), (2, 0)]
    t.set_segments(segments)
    t.triangulate(area=0.5)
    cells = t.get_triangles()
    assert len(cells) == 1
Пример #19
0
    def get_triangles(self, vert):
        # bottom triangles
        d = self.density
        triangles = []
        # bottom arc 1-x, top arc 1+d+1 - 1 + 2d
        # bottom triangles
        for i in range(d - 2):
            triangles.append(Triangle(vert[0], vert[i + 1], vert[i + 2]))
        triangles.append(Triangle(
            vert[0], vert[d], vert[1]))  # we can safely assume vert[1] exists

        # top triangles
        for i in range(d - 2):
            triangles.append(
                Triangle(vert[d + 1], vert[i + d + 2], vert[i + d + 3]))
        triangles.append(Triangle(vert[d + 1], vert[2 * d + 1], vert[d + 2]))

        # side triangles
        for i in range(d - 1):
            triangles.append(
                Triangle(vert[i + 1], vert[i + 2], vert[i + d + 2]))
            triangles.append(
                Triangle(vert[i + 2], vert[i + d + 2], vert[i + d + 3]))
        triangles.append(Triangle(vert[d], vert[1], vert[2 * d + 1]))
        triangles.append(Triangle(vert[1], vert[2 * d + 1], vert[d + 2]))

        return triangles
Пример #20
0
    def __init__(self):
        self.__drawing_top = 0
        self.__drawing_bottom = 0
        self.__border_rect = Rectangle()

        self.__radius = 0
        self.__center = (0, 0)
        self.__theta = 0
        self.__triangle = Triangle()
        self.__triangle.edge_color = PALE_GRAY
        self.__triangle.node_radius = GRID_UNIT / 2
        self.__triangle.nodes_color = (PALE_RED, PALE_BLUE, PALE_GREEN
                                       )  # 緑と青が逆なのが工夫
        self.__triangle.center_color = PALE_GRAY
Пример #21
0
def main():
    """"""
    stage_color = clutter.Color(0, 0, 0, 255)
    actor_color = clutter.Color(255, 255, 255, 153)

    # Get the stage and set its size and color
    stage = clutter.Stage()
    stage.set_size(200, 200)
    stage.set_color(stage_color)

    # Add our custom actor to the stage
    actor = Triangle(actor_color)
    actor.set_size(100, 100)
    actor.set_position(20, 20)
    stage.add(actor)
    actor.show()

    # Show the stage
    stage.show()
    stage.connect('destroy', clutter.main_quit)

    #actor.set_color('Red')

    # Start the main loop, so we can respond to events
    clutter.main()

    return 0
    def _generate_step(self, step_number):
        a = self._l_b + Point3D(y=-(step_number * self._step_length))
        b = a + Point3D(z=self._step_height * (step_number + 1))
        c = b + Point3D(y=-self._step_length)
        d = a + Point3D(y=-self._step_length)
        f = b + Point3D(z=-self._step_height)
        a1 = a + Point3D(x=self._width)
        b1 = b + Point3D(x=self._width)
        c1 = c + Point3D(x=self._width)
        d1 = d + Point3D(x=self._width)
        f1 = f + Point3D(x=self._width)

        self.triangles.append(Triangle(a, b, c))
        self.triangles.append(Triangle(a, d, c))

        self.triangles.append(Triangle(a1, b1, c1))
        self.triangles.append(Triangle(a1, d1, c1))

        self.triangles.append(Triangle(b, f, f1))
        self.triangles.append(Triangle(f1, b1, b))

        self.triangles.append(Triangle(c, b, b1))
        self.triangles.append(Triangle(b1, c1, c))

        self.edges.append(Edge(f, b))
        self.edges.append(Edge(f1, b1))
        self.edges.append(Edge(b, b1))
        self.edges.append(Edge(c, c1))
        self.edges.append(Edge(b, c))
        self.edges.append(Edge(b1, c1))
Пример #23
0
 def update(self, x, y):
     Box.update(self, x, y)
     pos = vec2(x, y)
     self.a, self.b, self.c = a, b, c = self.get_vertices(x, y)
     self.left_triangle = Triangle(a, b, pos, self.color, self.batch)
     self.bottom_triangle = Triangle(b, c, pos, self.color, self.batch)
     self.right_triangle = Triangle(c, a, pos, self.color, self.batch)
     self.glow = self.batch.add_indexed(6, pyglet.gl.GL_TRIANGLES, None, [0, 1, 3, 1, 4, 3, 1, 2, 4, 2, 5, 4, 2, 0, 5, 0, 3, 5],
             ('v2f', (a.x-255, a.y+512 , b.x-255, b.y-255, c.x+512, c.y-255, a.x, a.y, b.x, b.y, c.x, c.y)),
             ('c4f', (self.color+(0.0,))*3+(self.color+(1.0,))*3)
             )
     self.leftattach = (b.x, y)
     self.bottomattach = (x, b.y)
     self.rightattach = (x+self.s1, y+self.s1)
Пример #24
0
    def on_pre_render(self):
        world_matrix = self.transform.get_matrix()
        tris = []

        if ((self.material != None) and (self.mesh)):

            #distance culling
            if (self.cull_by_distance):
                direction_from_camera = self.transform.position - Application.scene.camera.transform.position
                dist = direction_from_camera.magnitude()
                if (dist >= Application.scene.camera.culling_distance):
                    return

            #display each side with a different color (DEBUG)
            if (self.debug_mode == True):
                colors = [(1, 0, 0), (0, 1, 0), (0, 0, 1), (.5, .5, 0),
                          (.5, 0, .5), (0, .5, .5)]
                i = 0

            #Apply transform matrix transformation to triangles
            for triangle in self.mesh.tris:
                tpoly = []
                for v in triangle.vertices:
                    transformed = vector3.multiply_matrix(v, world_matrix)
                    tpoly.append(transformed)

                t = Triangle(tpoly[0], tpoly[1], tpoly[2])
                center = t.get_center()

                #calculate lights
                if (self.debug_mode == False):
                    light_intensity = .05
                    for light in Application.lights_buffer:
                        light_intensity += light.calculate_intensity(
                            center, t.normal)

                    if (light_intensity > 1):
                        light_intensity = 1

                    t.color = self.material.color * light_intensity
                else:
                    j = colors[math.floor(i / 2)]
                    t.color = color(j[0], j[1], j[2], 1)
                    i += 1

                tris.append(t)

        #add triangle to buffer
        Application.add_triangle_to_buffer(tris)
Пример #25
0
class AbstractorBox(Box):

    def __init__(self, x, y):
        self.topline = None
        self.rightline = None
        self.bottomline = None
        self.color = (1.0, 0.4, 0.8)
        Box.__init__(self, x, y)
        
    def get_vertices(self, centerx, centery):
        left = centerx-self.s2
        right = centerx+self.s1
        bottom = centery-self.s2
        top = centery+self.s1
        return vec2(right, bottom), vec2(right, top), vec2(left, top)

    def update(self, x, y):
        Box.update(self, x, y)
        self.a, self.b, self.c = a, b, c = self.get_vertices(x, y)
        pos = vec2(x, y)
        self.leftattach = (b.x, y)
        self.bottomattach = (x, b.y)
        self.rightattach = (x+self.s1, y+self.s1)
        self.right_triangle = Triangle(a, b, pos, self.color, self.batch)
        self.top_triangle = Triangle(b, c, pos, self.color, self.batch)
        self.bottom_triangle = Triangle(c, a, pos, self.color, self.batch)
        self.glow = self.batch.add_indexed(6, pyglet.gl.GL_TRIANGLES, None, [0, 1, 3, 1, 4, 3, 1, 2, 4, 2, 5, 4, 2, 0, 5, 0, 3, 5],
                ('v2f', (a.x+255, a.y-512 , b.x+255, b.y+255, c.x-512, c.y+255, a.x, a.y, b.x, b.y, c.x, c.y)),
                ('c4f', (self.color+(0.0,))*3+(self.color+(1.0,))*3)
                )
        self.topattach = (x, a.y)
        self.bottomattach = (x-self.s1, y-self.s1)
        self.rightattach = (a.x, y)

    def draw(self):
        self.batch.draw()

    def gethover(self, x, y):
        hovered = False
        if self.top_triangle.gethover(vec2(x, y)):
            hovered = self, self.leftattach
        if self.bottom_triangle.gethover(vec2(x, y)):
            hovered = self, self.bottomattach
        if self.right_triangle.gethover(vec2(x, y)):
            hovered = self, self.rightattach
        return hovered

    def drag_end(self, x, y):
        pass
    def ReadBlend(self, fname):
        """imports an OBJ file, and populates tris and points
        """
        print("filename",fname)
        file = open(fname, "r")

        currentLine = file.readline()

        while (currentLine):
            # parse out numbers from the string using Regex pattern language
            # (from the re package)
            numbers = re.findall(r'-?\d+(?:\.\d+)?', currentLine)

            # find 'v' character and populate vertex information
            if (currentLine[0] == "v" and currentLine[1] == " "):
                # make a new vertex object out of it
                self.newVertex = vertex(float(numbers[0]), float(numbers[1]), float(numbers[2]))
                self.points.append(self.newVertex)
                                
            # find 'f' character and populate face information
            elif (currentLine[0] == "f"):
                self.newTriangle = Triangle(int(numbers[0])-1, int(numbers[3])-1, int(numbers[6])-1)
                self.tris.append(self.newTriangle)

            currentLine = file.readline()

        for point in self.points:
            point.printXYZ()

        for tri in self.tris:
            tri.printIV()
Пример #27
0
def read_file_into_mesh(file, to_pickle=False):
    vertex_num = 0
    vertices = {}
    faces = []
    vert_key = []
    num_lines = len(open(file).readlines())
    line_num = 0.0

    print('Converting to work format...\n')
    triangles = []
    vectors = []
    for line in open(file):
        line_num += 1.0
        split_line = line.split()

        if split_line[0] == 'vertex':

            vectors.append(
                Vector(float(split_line[1]), float(split_line[2]),
                       float(split_line[3])))

        elif split_line[0] == 'endloop':
            triangles.append(Triangle(vectors[0], vectors[1], vectors[2]))
            vectors = []

        amtDone = line_num / num_lines
        sys.stdout.write("\rProgress: [{0:50s}] {1:.1f}%".format(
            '#' * int(amtDone * 50), amtDone * 100))

    return triangles
Пример #28
0
    def from_obj(file_path, mesh=None):
        """Load a mesh from an .obj file
        
        Arguments:
            file_path {string} -- the path to the file
        
        Keyword Arguments:
            mesh {Mesh} -- mesh to assign the polygons (default: {None})
        
        Returns:
            Mesh -- a mesh with the loaded polygons
        """
        if (mesh == None):
            mesh = Mesh(file_path)
        vertices = []

        file = open(file_path, 'r')
        for line in file:
            if (line[0] == 'v'):
                elements = line.split()
                p1 = float(elements[1])
                p2 = float(elements[2])
                p3 = float(elements[3])
                vertices.append(vector3(p1, p2, p3))
            if (line[0] == 'f'):
                elements = line.split()
                v1 = int(elements[1]) - 1
                v2 = int(elements[2]) - 1
                v3 = int(elements[3]) - 1
                triangle = Triangle(vertices[v1], vertices[v2], vertices[v3])
                mesh.tris.append(triangle)

        return mesh
Пример #29
0
    def __init__(self, size=trigon_rules.default_size):
        self.size = size
        n = size

        field = []
        for x in range(n):
            line = []
            for y in range(2 * (n + x) + 1):
                line.append(Triangle(x + 1, y + 1, self.size))
            field.append(line)
        for x in range(n, 2 * n):
            line = []
            for y in range(4 * n - 1 - 2 * (x - n)):
                line.append(Triangle(x + 1, y + 1, self.size))
            field.append(tuple(line))
        self.field = tuple(field)
	def __init__(self, master):
		self.dim = 500
		#init vars
		self.got_edge = 0
		#self.move_line = 0
		#self.move_oval = 0
		self.anistack = deque()
		self.moveanistack = deque()

		# create paining area
		self.canv = Canvas(root, width = self.dim, height = self.dim)
		self.canv.bind("<Button-1>", self.clicked)
		self.canv.bind("<B1-Motion>", self.moved)
		self.canv.bind("<ButtonRelease-1>", self.released)
		self.canv.pack()
		
		self.tri = Triangle([50,70],[300,300],[400,100])
		self.tri.id = self.canv.create_polygon(self.tri.coo,fill='yellow')
		
		frame = Frame(master)
		frame.pack()

		self.button = Button(frame, text="QUIT", fg="red", command=frame.quit)
		self.button.pack(side=LEFT)

		self.hi_there = Button(frame, text="Reset", command=self.reset)
		self.hi_there.pack(side=LEFT)
Пример #31
0
    def fan_triangulation(vertices: Iterable[Point],
                          vertex_normals: Iterable[Point],
                          vertex_indices: Iterable[str]) -> Iterable:
        from triangle import Triangle

        triangles = []
        vertex_1_info = vertex_indices[1].split('/')
        for index in range(2, len(vertex_indices) - 1):
            if len(vertex_1_info) == 1:
                tri = Triangle(vertices[int(vertex_indices[1])],
                               vertices[int(vertex_indices[index])],
                               vertices[int(vertex_indices[index + 1])])
                triangles.append(tri)
            else:
                vertex_2_info = vertex_indices[index].split('/')
                vertex_3_info = vertex_indices[index + 1].split('/')
                tri = SmoothTriangle(vertices[int(vertex_1_info[0])],
                                     vertices[int(vertex_2_info[0])],
                                     vertices[int(vertex_3_info[0])],
                                     vertex_normals[int(vertex_1_info[2])],
                                     vertex_normals[int(vertex_2_info[2])],
                                     vertex_normals[int(vertex_3_info[2])])
                triangles.append(tri)

        return triangles
Пример #32
0
 def createNewTriangles(self):
     """createNewTriangles calculates smaller triangles with new corners
     """
     trisnew = []
     for t in self.tris:
         # calculate middle triangle
         t2 = Triangle(t.ie[0], t.ie[1], t.ie[2])
         # calculate triangles around the middle triangle
         t0 = Triangle(t.ie[1], t.ie[0], t.iv[2])
         t1 = Triangle(t.iv[0], t.ie[2], t.ie[1])
         t3 = Triangle(t.ie[2], t.iv[1], t.ie[0])
         trisnew.append(t0)
         trisnew.append(t1)
         trisnew.append(t2)
         trisnew.append(t3)
     self.tris = trisnew
Пример #33
0
class TestTriangle(unittest.TestCase):
    def setUp(self):
        self.triangle = Triangle(100, 30)

    # Return dimension
    def test_area(self):
        self.assertEqual(1500, self.triangle.area())
Пример #34
0
    def create_quad(origin, axis0, axis1, mesh):
        if (mesh == None):
            mesh = Mesh("UnknownQuad")

        v1 = origin + axis0 + axis1
        v2 = origin + axis0 - axis1
        v3 = origin - axis0 - axis1
        v4 = origin - axis0 + axis1

        t1 = Triangle(v1, v2, v3)
        t2 = Triangle(v1, v3, v4)

        mesh.tris.append(t1)
        mesh.tris.append(t2)

        return mesh
Пример #35
0
 def read_file_obj(file_obj):
     first_line = file_obj.readline()
     items = first_line.split()
     x, y = [int(a) for a in items[:2]]
     if len(items) == 3:
         color_type = items[2]
     else:
         color_type = RGB
     s = Sketch(Point(x, y), color_type)
     for line in file_obj:
         items = string_to_ints(line)
         if color_type == RGB:
             t = Triangle(items[:6], tuple(items[6:9]), items[9])
         else:
             t = Triangle(items[:6], items[6], items[7])
         s.triangles.append(t)
     return s
Пример #36
0
def bowyerWatson(points):
    # https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm
    # print("Running bowyerWatson on %d points" % len(points))
    triangulation = []
    # must be large enough to completely contain all the points in pointList
    P1 = Vec(-1e15, -1e15)
    P2 = Vec(1e15, -1e15)
    P3 = Vec(0, 1e15)
    megaTriangle = Triangle(P1, P2, P3)

    triangulation.append(megaTriangle)

    # add all the points one at a time to the triangulation
    for iP, P in enumerate(points):

        badTriangles = []
        # first find all the triangles that are no longer valid due to the insertion
        for iT, T in enumerate(triangulation):
            if distance(P, T.C) < T.R:  # If point inside triangle circumcircle
                badTriangles.append(T)  # Triangle is bad

        # find the boundary of the polygonal hole
        polygon = []
        for T in badTriangles:
            for V in T.vertices:  # for each edge in triangle
                # if edge is not shared by any other triangles in badTriangles
                if not any([_T.hasVertex(V)
                            for _T in badTriangles if T != _T]):
                    polygon.append(V)

        for T in badTriangles:
            triangulation.remove(T)

        # re-triangulate the polygonal hole
        for v1, v2 in polygon:
            triangulation.append(Triangle(P, v1, v2))

    # if triangle contains a vertex from original super-triangle
    triangulation = [
        T for T in triangulation if not T.sharesCornerWith(megaTriangle)
    ]

    return triangulation


#######################################
Пример #37
0
	def hit(self, ray_in, t_min, t_max):
		list_of_triangles = []
		for face in self.faces:
			vertices = self.getFaceData(self.faces.index(face))
			for triangle_no in range(0, len(vertices) - 2):
				list_of_triangles.append(Triangle(v = [vertices[0], vertices[triangle_no + 1], vertices[triangle_no + 2]], material = self.material))
		hitable_list = Hitable_List(list_of_triangles)
		return hitable_list.hit(ray_in, t_min, t_max)
Пример #38
0
 def __init__(self, inf = 65536, test = False):
     self._initTriangle = Triangle(Point2D(-inf, -inf), 
                                   Point2D(inf, -inf), 
                                   Point2D(0, inf))
     self.neighborhood = {self._initTriangle: {}}
     self.lock = threading.RLock()
     self.main_site = None
     self.fail_site = None
     self.fail_triangle = None
     self.fail_witness = None
     self.version = 0
     self.check_triangulation = test
Пример #39
0
class TriangleTest(unittest.TestCase):

    def setUp(self):
        self.triangle = Triangle()

    def test_get_side1(self):
        self.assertEqual(
            self.triangle.get_side1(),
            self.triangle._Triangle__side1
        )

    def test_get_side2(self):
        self.assertEqual(
            self.triangle.get_side2(),
            self.triangle._Triangle__side2
        )

    def test_get_side3(self):
        self.assertEqual(
            self.triangle.get_side3(),
            self.triangle._Triangle__side3
        )

    def test_get_perimeter(self):
        self.assertEqual(
            self.triangle.get_perimeter(),
            self.triangle._Triangle__side1 +
            self.triangle._Triangle__side2 +
            self.triangle._Triangle__side3
        )

    def test_get_area(self):
        p = self.triangle.get_perimeter() / 2
        area = math.sqrt(
            p *
            (p - self.triangle._Triangle__side1) *
            (p - self.triangle._Triangle__side2) *
            (p - self.triangle._Triangle__side3)
        )
        self.assertEqual(
            self.triangle.get_area(),
            area
        )
Пример #40
0
    def get_triangles_for_rectangle(self, min_x, max_x, min_y, max_y):
        """
        Args:
            min_x: int
            max_x: int
            min_y: int
            max_y: int

        Returns: List(tri_image.triangle.Triangle) of length 2
        """
        if self.color_type == RGB:
            c = (0, 0, 0)
        else:
            c = 0

        t1 = Triangle([min_x, min_y, min_x, max_y, max_x, max_y], c, 255)
        t1.set_color(self.source_image, self.color_type)
        t2 = Triangle([min_x, min_y, max_x, min_y, max_x, max_y], c, 255)
        t2.set_color(self.source_image, self.color_type)
        return [t1, t2]
Пример #41
0
class ApplicatorBox(Box):

    def __init__(self, x, y):
        self.leftline = None
        self.rightline = None
        self.bottomline = None
        self.color = (0.4, 1.0, 0.8)
        Box.__init__(self, x, y)
        
    def get_vertices(self, centerx, centery):
        left = centerx-self.s1
        right = centerx+self.s2
        bottom = centery-self.s1
        top = centery+self.s2
        return vec2(left, top), vec2(left, bottom), vec2(right, bottom)

    def update(self, x, y):
        Box.update(self, x, y)
        pos = vec2(x, y)
        self.a, self.b, self.c = a, b, c = self.get_vertices(x, y)
        self.left_triangle = Triangle(a, b, pos, self.color, self.batch)
        self.bottom_triangle = Triangle(b, c, pos, self.color, self.batch)
        self.right_triangle = Triangle(c, a, pos, self.color, self.batch)
        self.glow = self.batch.add_indexed(6, pyglet.gl.GL_TRIANGLES, None, [0, 1, 3, 1, 4, 3, 1, 2, 4, 2, 5, 4, 2, 0, 5, 0, 3, 5],
                ('v2f', (a.x-255, a.y+512 , b.x-255, b.y-255, c.x+512, c.y-255, a.x, a.y, b.x, b.y, c.x, c.y)),
                ('c4f', (self.color+(0.0,))*3+(self.color+(1.0,))*3)
                )
        self.leftattach = (b.x, y)
        self.bottomattach = (x, b.y)
        self.rightattach = (x+self.s1, y+self.s1)

    def draw(self):
        self.batch.draw()
        if self.rightline:
            self.rightline.draw()
        if self.leftline:
            self.leftline.draw()

    def gethover(self, x, y):
        hovered = False
        if x > self.a.x and x < self.c.x and y > self.b.y and y < self.a.y: #bounding box check
            if self.left_triangle.gethover(vec2(x, y)):
                hovered = self, self.leftattach
            if self.bottom_triangle.gethover(vec2(x, y)):
                hovered = self, self.bottomattach
            if self.right_triangle.gethover(vec2(x, y)):
                hovered = self, self.rightattach
        else:
            self.left_triangle.highlight(False)
            self.bottom_triangle.highlight(False)
            self.right_triangle.highlight(False)
        return hovered

    def gethover_recursive(self, x, y):
        hovered = self.gethover(x, y)
        if hovered:
            return hovered
        else:
            if self.rightline:
                rightline_hover = self.rightline.gethover_recursive(x, y)
                if rightline_hover:
                    return rightline_hover
                else:
                    if self.leftline:
                        leftline_hover = self.leftline.gethover_recursive(x, y)
                        if leftline_hover:
                            return leftline_hover
                        else:
                            return False

    def drag_end(self, x, y):
        pass
Пример #42
0
 def setUp(self):
     path = tempfile.mktemp('.ldb')
     db = leveldb.LevelDB(path)
     self.triangle = Triangle(db)
Пример #43
0
class CoffeeData(flask.views.MethodView):
	@login_required
	def get(self):
		return flask.render_template('coffeedata.html')

# Routes

app.add_url_rule('/',
				 view_func=Login.as_view('login'),
				 methods=["GET", "POST"])
app.add_url_rule('/remote/',
				 view_func=Remote.as_view('remote'),
				 methods=["GET", "POST"])
app.add_url_rule('/triangle/', 
				 view_func=Triangle.as_view('triangle'),
				 methods=["GET", "POST"])
app.add_url_rule('/music/', 
				 view_func=Music.as_view('music'),
				 methods=["GET"])
app.add_url_rule('/asteroids/',
				 view_func=Asteroids.as_view('asteroids'),
				 methods=["GET"])
app.add_url_rule('/remotezsnes/',
				 view_func=RemoteZsnes.as_view('remotezsnes'),
				 methods=["GET"])
app.add_url_rule('/asteroids/',
				 view_func=CoffeeData.as_view('coffeedata'),
				 methods=["GET"])

@app.errorhandler(404)
Пример #44
0
#!/usr/bin/env python
import sys
import time
from triangle import Triangle

arr = [[6],[3,5],[9,7,1],[4,6,8,4]]

t = time.time()

Triangle = Triangle(arr)
(sum,path) = Triangle.maximumTotal()

t = time.time() - t

print("========== results ==========")
print(" triangle: %s " % (arr))
print(" maximum total: %d" % (sum))
print(" path: %s " % (path))
print(" execution time: %fs" % (t))
print("=============================")
Пример #45
0
def main():
    Lines=1
    Lines_valid=0
    total_perimeter=0
    total_area=0

    largest_perimeter=0
    largest_perimeters_area=0

    largest_area=0
    largest_areas_perimeter=0

    triangle_perimeter=''
    triangle_area=''

    for line in fo:
        line = "".join(c for c in line if c not in ('(',')',' '))
        linelist=line.strip().replace(' ', '').split(',')
        print("Line ",Lines,": ",line)
        
        sideA=linelist[0]
        sideB=linelist[1]
        sideC=linelist[2]
        
        triangle=Triangle(sideA,sideB,sideC)
        if triangle.is_valid()==True:
            Lines_valid+=1
            total_perimeter+=triangle.perimeter()
            total_area+=triangle.area()
            if triangle.perimeter()>largest_perimeter:
                largest_perimeter=triangle.perimeter()
                largest_perimeters_area=triangle.area()
                triangle_perimeter=line
            if triangle.area()>largest_area:
                largest_area=triangle.area()
                largest_areas_perimeter=triangle.perimeter()
                triangle_area=line
            print("This Triangle's perimeter= {}, and area= {}".format(triangle.perimeter(),triangle.area()))
        else:
            print("Triangle is not valid")
        Lines+=1

    print("")
    print("Total lines processed: ",Lines)
    print("Total valid triangles processed: ",Lines_valid)
    avg_perimeter=total_perimeter/Lines_valid
    avg_area=total_area/Lines_valid
    print("Average perimeter: ",avg_perimeter)
    print("Average area: ",avg_area)
    print("The Triangle with the largest perimeter= ",largest_perimeter," had a area= ",largest_perimeters_area," with sides: ",triangle_perimeter)
    print("The Triangle with the largest area= ",largest_area," had a perimeter= ",largest_areas_perimeter," with sides: ",triangle_area)
Пример #46
0
    def __init__(self):
        ShowBase.__init__(self)
        winProps = WindowProperties()
        winProps.setTitle("Triangle and SimpleCircle Unittest")
        # base.win.requestProperties(winProps) (same as below e.g. self == base)
        self.win.requestProperties(winProps)


        # 1) create GeomVertexData
        frmt = GeomVertexFormat.getV3n3cp()
        vdata = GeomVertexData('triangle_developer', frmt, Geom.UHDynamic)

        # 2) create Writers/Rewriters (must all be created before any readers and readers are one-pass-temporary)
        vertex = GeomVertexRewriter(vdata, 'vertex')
        normal = GeomVertexRewriter(vdata, 'normal')
        color = GeomVertexRewriter(vdata, 'color')

        zUp = Vec3(0, 0, 1)
        wt = Vec4(1.0, 1.0, 1.0, 1.0)
        gr = Vec4(0.5, 0.5, 0.5, 1.0)

        # 3) write each column on the vertex data object (for speed, have a different writer for each column)
        def addPoint(x, y, z):
            vertex.addData3f(x, y, z)
            normal.addData3f(zUp)
            color.addData4f(wt)

        addPoint(0.0, 0.0, 0.0)
        addPoint(5.0, 0.0, 0.0)
        addPoint(0.0, 5.0, 0.0)
        addPoint(15.0, 15.0, 0.0)

        # 4) create a primitive and add the vertices via index (not truely associated with the actual vertex table, yet)
        tris = GeomTriangles(Geom.UHDynamic)
        t1 = Triangle(0, 1, 2, vdata, tris, vertex)
        t2 = Triangle(2, 1, 3, vdata, tris, vertex)
        c1 = t1.getCircumcircle()
        t1AsEnum = t1.asPointsEnum()
        r0 = (t1AsEnum.point0 - c1.center).length()
        r1 = (t1AsEnum.point1 - c1.center).length()
        r2 = (t1AsEnum.point2 - c1.center).length()
        assert abs(r0 - r2) < utilities.EPSILON and abs(r0 - r1) < utilities.EPSILON
        t2AsEnum = t2.asPointsEnum()
        c2 = t2.getCircumcircle()
        r0 = (t2AsEnum.point0 - c2.center).length()
        r1 = (t2AsEnum.point1 - c2.center).length()
        r2 = (t2AsEnum.point2 - c2.center).length()
        assert abs(r0 - r2) < utilities.EPSILON and abs(r0 - r1) < utilities.EPSILON

        assert t1.getAngleDeg0() == 90.0
        assert t1.getAngleDeg1() == t1.getAngleDeg2()

        oldInd0 = t1.pointIndex0
        oldInd1 = t1.pointIndex1
        oldInd2 = t1.pointIndex2
        t1.pointIndex0 = t1.pointIndex1
        t1.pointIndex1 = oldInd0
        assert t1.pointIndex0 == oldInd1
        assert t1.pointIndex1 == oldInd0
        assert t1.pointIndex0 != t1.pointIndex1
        t1.reverse()
        assert t1.pointIndex1 == oldInd2

        # 5.1) (adding to scene) create a Geom and add primitives of like base-type i.e. triangles and triangle strips
        geom = Geom(vdata)
        geom.addPrimitive(tris)
        # 5.2) create a GeomNode to hold the Geom(s) and add the Geom(s)
        gn = GeomNode('gnode')
        gn.addGeom(geom)
        # 5.3) attache the node to the scene
        gnNodePath = render.attachNewNode(gn)

        # setup a wire frame
        wireNP = render.attachNewNode('wire')
        wireNP.setPos(0.0, 0.0, .1)
        wireNP.setColor(0.1, 0.1, 0.1, 1)
        wireNP.setRenderMode(RenderModeAttrib.MWireframe, .5, 0)
        gnNodePath.instanceTo(wireNP)

        # test and draw intersections and circles
        pt1 = Point3(0.0, 5.0, 0.0)
        pt2 = Point3(1.0, 5.0, 0.0)
        intersection = t2.getIntersectionsWithCircumcircle(pt1, pt2)
        circle = t2.getCircumcircle()
        cuts = 128
        border = circle.getBorder(cuts, closed=True)
        assert len(border) == cuts or (len(border) == cuts + 1 and border[0] == border[len(border) - 1])
        n = len(border)
        xMid = yMid = 0
        for p in border:
            xMid += p.x
            yMid += p.y
        mid = Point3(xMid / n, yMid / n, border[0].z)
        assert mid.almostEqual(circle.center, 0.06)
        assert t2.isCcw()
        assert t1.containsPoint(c1.center) != t1.containsPoint(c1.center, includeEdges=False)

        circleSegs = LineSegs("circleLines")
        circleSegs.setColor(1.0, 0.0, 0.0, 1.0)
        for p in border:
            circleSegs.drawTo(*p)
        circleNode = circleSegs.create(False)
        circleNP = render.attachNewNode(circleNode)
        circleNP.setZ(-5)

        originSpot = LineSegs("intersection")
        originSpot.setColor(1.0, 0.0, 0.0, 1.0)
        originSpot.setThickness(10)
        for p in intersection:
            originSpot.drawTo(p)
        spotNode = originSpot.create(False)
        spotNP = render.attachNewNode(spotNode)
        circleNP.setZ(-0.75)

        # fix the camera rot/pos
        PHF.PanditorDisableMouseFunc()
        camera.setPos(0.0, 0.0, 50.0)
        camera.lookAt(c2.center)
        PHF.PanditorEnableMouseFunc()
Пример #47
0
 def testTriangleArea(self):
     t = Triangle(Node((1,1),(0,0)), Node((0,0),(0,0)), Node((1,0),(0,0)))
     self.assertEqual(t.getArea(), 0.5)
Пример #48
0
from triangle import Triangle
from camera import Camera
from random import random
from math import pi, tan
from vector3f import Vector3f

#cam = Camera()

tri = Triangle()

vec1 = Vector3f(0.556, 0.401054805321, 0.40692763018)
vec2 = Vector3f(-0.745565615449, 0.432850996024, -0.506726680076)
print tri.get_intersection(vec1, vec2)
tri.get_sample_point().echovec()
print tri.area
tri.tangent.echovec()
tri.normal.echovec()
Пример #49
0
 def test_maximumTotal_return_true_result2(self):
         triangle = [[6],[3,5]]
         T = Triangle(triangle)
         (val, path) = T.maximumTotal()
         self.assertEqual(val,11)
         self.assertEqual(path, [0, 1] )
Пример #50
0
from triangle import Triangle

scalene_triangle=Triangle(10.0,4.0,7.0)

print('A Triangle with side lengths of: ',scalene_triangle)

print('Is this a valid triangle?')
print(scalene_triangle.is_valid())

print('')
print('Is the Triangle equilateral?')
print(scalene_triangle.is_equilateral())

print('Is the Triangle isosceles?')
print(scalene_triangle.is_isosceles())

print('Is the Triangle scalene?')
print(scalene_triangle.is_scalene())

print('')
print('What are the lengths of this Triangle again..?')
print(scalene_triangle.sides())

print('What are the interior angles of this triangle?')
print(scalene_triangle.angles())

print('What is the perimeter of this triangle?')
print(scalene_triangle.perimeter())

print('What is the area of this triangle?')
print(scalene_triangle.area())
Пример #51
0
class Delaunay(object):
    '''
    Delaunay Triangulation
    ref: http://www.cs.cornell.edu/home/chew/Delaunay.html
    '''

    # INT => MAX=+(pow(2,31) - 1)(2147483647) & MIN=-pow(2,31)(-2147483648)
    # inf = 1000000 was empirically limited due to pygame simulator
    # inf = 2^16 was empirically limited due to float point precision

    def __init__(self, inf = 65536, test = False):
        self._initTriangle = Triangle(Point2D(-inf, -inf), 
                                      Point2D(inf, -inf), 
                                      Point2D(0, inf))
        self.neighborhood = {self._initTriangle: {}}
        self.lock = threading.RLock()
        self.main_site = None
        self.fail_site = None
        self.fail_triangle = None
        self.fail_witness = None
        self.version = 0
        self.check_triangulation = test

    def __repr__(self):
        return 'Triangulation with ' + str(len(self.neighborhood)) + \
            ' triangles'

    def __str__(self):
        return self.__repr__() 

    def _new_version(self):
        self.version += 1
        # cicle version
        if self.version > 2147483640:
            self.version = 0

    def updated_since(self, version):
        return (version != self.version)

    def has_error(self):
        return self.fail_site is not None

    def include(self, site):
        '''
        Add a site to triangulation
        '''
        if self.fail_site is not None:
            return False
        with self.lock:
            triangle = self._find_triangle_circumscribe(site)
            return self._add(site, triangle)
    
    def remove_far_sites(self, from_site):
        '''
        Remove all sites that do not affect a "from site" cell
        Returns the number of removed sites
        '''
        if self.fail_site is not None:
            return False
        with self.lock:
            from_triangle = self._find_triangle_by_vertex(from_site)
            if (from_triangle is None):
                return 0
            triangles, points = \
                    self.surrounding_triangles(from_site, from_triangle)
            # search irrlevant sites
            dispensables = []
            for triangle in self.neighborhood.keys():
                if (not triangle in triangles):
                    dispensable = True
                    for vertex in triangle:
                        if not vertex in points:
                            dispensables.append(vertex)
            # remove irrlevant sites
            removed = 0
            for site in dispensables:
                if not self._initTriangle.contains(site):
                    self.remove(site)
                    removed += 1
            return removed

    def include_near(self, site, from_site):
        '''
        Add a site only if it will affect a "from site" cell
        '''
        if self.fail_site is not None:
            return False
        with self.lock:
            triangle = self._find_triangle_by_vertex(from_site)
            if (triangle is None):
                raise Exception("'From site' don't found.")
            triangles, points = \
                    self.surrounding_triangles(from_site, triangle)
            # verify site influence
            for triangle in triangles:
                if triangle.circumscribe(site):
                    return self._add(site, triangle)
            return False

    def remove(self, site):
        '''
        Remove a site from triagulation
        '''
        if self.fail_site is not None:
            return False
        with self.lock:
            triangle = self._find_triangle_by_vertex(site)
            if triangle is not None:
                triangles, points = self.surrounding_triangles(site, triangle)
                self._remove(site, points, triangles)
                return True
            return False

    def _find_triangle_circumscribe(self, site):
        '''
        Search the triangle that circumcircle the point
        '''
        for triangle in self.neighborhood:
            if triangle.circumscribe(site) or triangle.contains(site):
                return triangle
        raise Exception("Site out of the valid area.")
    
    def _find_triangle_by_vertex(self, site):
        '''
        Search the triangle that contains the point as a vertex
        '''
        for triangle in self.neighborhood.keys():
            if triangle.contains(site):
                return triangle
        return None
    
    def _cavity(self, site, triangle):
        '''
        Determine the cavity caused by site.
        '''
        encroached = {}
        toBeChecked = [triangle]
        marked = {triangle: None}
        while (len(toBeChecked) > 0):
            triangle = toBeChecked.pop()
            # Site outside triangle => triangle not in cavity
            if not triangle.circumscribe(site):
                continue
            encroached[triangle] = None
            # Check the neighborhood
            for neighbor in self.neighborhood[triangle]:
                if neighbor not in marked:
                    marked[neighbor] = None
                    toBeChecked.append(neighbor)
        return encroached

    def _add(self, site, triangle):
        '''
        Add a site to triangulation with specific triangle
        '''
        if not triangle.contains(site):
            cavity = self._cavity(site, triangle)
            self._insert(site, cavity)
            return True
        return False

    def _add_triangle(self, t1, t2):
        '''
        Add a triangle to neighborhood control
        '''
        if t1 not in self.neighborhood:
            self.neighborhood[t1] = {t2}
        else:
            self.neighborhood[t1][t2] = None

    def _del_triangle(self, triangle):
        '''
        Remove a triangle from neighborhood control
        '''
        del self.neighborhood[triangle]
        for neighbor in self.neighborhood.values():
            if triangle in neighbor:
                del neighbor[triangle]
        
    def _link_triangles(self, t1, t2):
        '''
        Include mutual neighbor triangles
        '''
        self._add_triangle(t1, t2)
        self._add_triangle(t2, t1)

    def _insert(self, site, cavity):
        '''
        Update the triangulation by removing the cavity triangles and then
        filling the cavity with new triangles.
        '''
        boundary = {}
        triangles = {}

        # Find boundary facets and adjacent triangles
        for triangle in cavity:
            for neighbor in self.neighborhood[triangle]:
                # Adj triangles only
                if neighbor not in cavity:
                    triangles[neighbor] = None
            for point in triangle:
                facet = triangle.opposite_facet(point)
                if facet in boundary:
                    del boundary[facet]
                else:
                    boundary[facet] = None

        # Remove the cavity triangles from the triangulation
        for triangle in cavity:
            self._del_triangle(triangle)

        # Build each new triangle and include it to the triangulation
        new_triangles = {}
        for facet in boundary.keys():
            newTriangle = Triangle(facet[0], facet[1], site)
            self.neighborhood[newTriangle] = {}
            new_triangles[newTriangle] = None
            # Adj triangle + new triangles
            triangles[newTriangle] = None

        # Update the graph links for each new triangle
        for triangle in new_triangles:
            for other in triangles:
                if triangle.is_neighbor(other):
                    self._link_triangles(triangle, other)
                    
        if self.main_site is None:
            self.main_site = site
        self._new_version()
        if self.check_triangulation:
            if not self.valid():
                print "### Including failure"

    def _remove(self, site, points, triangles):
        '''
        Update the triangulation by removing the surrounding triangles 
        and then filling this cavity with new Delaunay triangles.
        Challenge: Maintain neighborhood control.
        Ref: Mir Abolfazl Mostafavi, Christopher Gold, and Maciej Dakowicz. 
             2003. Delete and insert operations in Voronoi/Delaunay methods 
             and applications. Comput. Geosci. 29, 4 (May 2003), 523-530. 
             DOI=10.1016/S0098-3004(03)00017-7 
             http://dx.doi.org/10.1016/S0098-3004(03)00017-7
        '''
        # verify compatibility of surrounding points and old triangles
        if len(points) != len(triangles):
            raise Exception("Triangulation has different sizes.")
        # verify is the triangulation is empty (or insufficient?)
        if len(points) < 3:
            return
        # initialize new triangulation controls
        i = -1
        new_triangles = {}
        # while there are points to form more than the last triangle
        while len(points) > 3:
            # checks the possible triangles considering 
            # all three consecutive points (i, i1, i2 in a cycle) 
            # of surrounding points of the site
            i += 1
            npoints = len(points)
            if (i >= npoints):
                raise Exception("Inexists a valid ear? Is it possible?")
            i1 = (i + 1) % npoints
            i2 = (i1 + 1) % npoints
            # verify if points represent a valid triangle to site,
            # like a ear listen to the site:
            # 1: gets triangle orientation (CW or CCW)
            o_ear = Triangle.orientation(points[i], points[i1], points[i2])
            # 2: gets direction of triangle to the site (CW or CCW)
            o_ear_site = Triangle.orientation(points[i], points[i2], site)
            # 3: if points are collinear, try another edge as a reference
            # ??why don't take this edge at first place??
            if o_ear_site == 0:
                o_ear_site = Triangle.orientation(points[i], points[i1], site)
            # 4: the directions is the same?
            if (o_ear * o_ear_site) > 0:
                # if so, this a valid ear (possible triangulation)
                valid_ear = Triangle(points[i], points[i1], points[i2])
                # verify if this ear is a Delaunay Triangulation
                ear_is_delaunay = True
                # 1. for all other surrounding points
                for p in points:
                    # 1.1: is this other point (not in ear)?
                    if not valid_ear.contains(p):
                        # verify if ear won't circumcircle it
                        if valid_ear.circumscribe(p):
                            # if circumcircle, ear is not a Delaunay triangle
                            ear_is_delaunay = False
                            break
                # if it is a Delaunay triangle...
                if ear_is_delaunay:
                    # include to new triangle control
                    new_triangles[valid_ear] = None
                    # include to neighborhood control
                    self.neighborhood[valid_ear] = {}
                    # link to the opposite triangles from the removed vertices
                    self._link_ear(site, valid_ear, triangles[i], 
                                   new_triangles)
                    self._link_ear(site, valid_ear, triangles[i1], 
                                   new_triangles)
                    # change triangle related to vertex by the new one
                    # remove old triangle by switching the diagonal
                    triangles[i] = valid_ear
                    # remove middle point (leave the corners) 
                    del points[i1]
                    del triangles[i1]
                    # restart cycle of surrounding points
                    i = -1
        # if has only three neighbours remaining in the surrounding points, 
        # merged these three points (triangles) into last triangulation
        last_ear = Triangle(points[0], points[1], points[2])
        self.neighborhood[last_ear] = {}
        new_triangles[last_ear] = None
        # last triangle closes the triangulation and 
        # needs update the link with all sides (neighborhood)
        self._link_ear(site, last_ear, triangles[0], new_triangles)
        self._link_ear(site, last_ear, triangles[1], new_triangles)
        self._link_ear(site, last_ear, triangles[2], new_triangles)

        if self.main_site is not None:
            if self.main_site == site:
                self.main_site = None
        self._new_version()
        if self.check_triangulation:
            if not self.valid():
                print "### Removing failure"

    def _link_ear(self, site, ear, triangle, new_triangles):
        # check if the triangle has neighbor that is opposite from the site
        neighbor = self.neighbor_opposite(site, triangle)
        # if not, it's a external triangulation (from initial triangle)
        # or it's a new triangulation...
        if neighbor is None:
            # if the triangle related to the vertex is new
            if triangle in new_triangles:
                # update neighborhood with the new triangle
                self._link_triangles(ear, triangle)
            else:
                # otherwise, old triangle doesn't had a neighbor: 
                # ignore its neighborhood and delete it
                self._del_triangle(triangle)
        else:
            # update neighborhood of new triangle (ear)
            self._link_triangles(ear, neighbor)
            # delete old voronoi cell triangle
            self._del_triangle(triangle)

    def neighbor_opposite(self, site, triangle):
        '''
        Report neighbor opposite the given vertex of triangle.
        '''
        if site not in triangle:
            return None
        with self.lock:
            for neighbor in self.neighborhood[triangle]:
                if not neighbor.contains(site):
                    return neighbor
            return None

    def surrounding_triangles(self, site, triangle):
        '''
        Report triangles and points surrounding site in order (cw or ccw).
        '''
        if site not in triangle:
            raise Exception("Site not in triangle.")
        with self.lock:
            points = []
            triangles = []
            start = triangle
            # cw or cww (pay attention)
            guide = triangle.next_vertex_except({site})
            while triangle is not None:
                triangles.append(triangle)
                points.append(guide)
                previous = triangle
                triangle = self.neighbor_opposite(guide, triangle)
                guide = previous.next_vertex_except({site, guide})
                if (triangle == start):
                    break
            return triangles, points

    def voronoi_cells(self):
        '''
        Report polygons of each voronoi cell
        '''
        with self.lock:
            cells = {}
            ignore = {} #x:None for x in self._initTriangle}
            for triangle in self.neighborhood.keys():
                for site in triangle:
                    if site in ignore:
                        continue
                    ignore[site] = None
                    triangles, points = self.surrounding_triangles(site, 
                                                                   triangle)
                    cell = []
                    for tri in triangles:
                        cell.append(tri.circumcenter())
                    cells[site] = cell 
            return cells

    def voronoi_cell_trinagulation(self, site):
        '''
        Test purpose only
        '''
        with self.lock:
            triangle = self._find_triangle_by_vertex(site)
            triangles, points = self.surrounding_triangles(site, triangle)
            return triangles, triangle

    def valid(self):
        for triangle in self.neighborhood.keys():
            for other in self.neighborhood.keys():
                if (other != triangle):
                    for vertex in other:
                        if not triangle.contains(vertex):
                            if triangle.circumscribe(vertex):
                                self.fail_site = vertex
                                self.fail_triangle = triangle
                                self.fail_witness = other
                                print "Triangle     : " + str(triangle)
                                print "Other        : " + str(other)
                                print "Other vertex : " + str(vertex)
                                triangle.debug_distance(vertex)
                                return False
        return True
Пример #52
0
 def setUp(self):
     self.triangle = Triangle()
Пример #53
0
	def test_if_list_is_empty(self):
		triangle = []
		T = Triangle(triangle)
		(res) = T.maximumTotal()
		self.assertEqual(res,False)
Пример #54
0
class TriangleTest(unittest.TestCase):

    def setUp(self):
        path = tempfile.mktemp('.ldb')
        db = leveldb.LevelDB(path)
        self.triangle = Triangle(db)

    def test_it_exists(self):
        self.assertTrue(self.triangle)

    def test_insertion(self):
        wb = mock.Mock()
        self.triangle.db = mock.Mock()
        with mock.patch('triangle.leveldb.WriteBatch', return_value=wb):
            self.triangle.insert(s='Daniel', p='loves', o='Cheese')
            self.assertEqual(
                sorted(i[0][0] for i in wb.Put.call_args_list),
                sorted(['spo::Daniel::loves::Cheese',
                        'sop::Daniel::Cheese::loves',
                        'pso::loves::Daniel::Cheese',
                        'pos::loves::Cheese::Daniel',
                        'osp::Cheese::Daniel::loves',
                        'ops::Cheese::loves::Daniel'])
            )

    def test_retreival(self):
        self.triangle.insert(s='Daniel', p='loves', o='Cheese')
        self.triangle.insert(s='Daniel', p='loves', o='Sushi')
        self.assertEqual(set(self.triangle.start(s='Daniel')), {
            ('Daniel', 'loves', 'Cheese'),
            ('Daniel', 'loves', 'Sushi')
        })
        self.assertEqual(set(self.triangle.start(o='Sushi')), {
            ('Daniel', 'loves', 'Sushi')
        })

    def test_retreival_2(self):
        self.triangle.insert(s='Daniel', p='loves', o='Cheese')
        self.triangle.insert(s='Daniel', p='loves', o='Sushi')
        self.assertEqual(set(self.triangle.start(s='Daniel').traverse(o='Cheese')), {
            ('Daniel', 'loves', 'Cheese'),
        })

    def test_batch_insert(self):
        with self.triangle.batch_insert() as f:
            f.insert(s='Daniel', p='loves', o='Cheese')
            f.insert(s='Daniel', p='loves', o='Sushi')
        self.assertEqual(set(self.triangle.start(s='Daniel')), {
            ('Daniel', 'loves', 'Cheese'),
            ('Daniel', 'loves', 'Sushi')
        })

    def test_exception_rolls_back(self):
        try:
            with self.triangle.batch_insert() as f:
                f.insert(s='Daniel', p='loves', o='Cheese')
                f.insert(s='Daniel', p='loves', o='Sushi')
                0/0
        except ZeroDivisionError:
            pass
        self.assertEqual(len(set(self.triangle.start(s='Daniel'))), 0)

    def test_graph_of_the_gods(self):
        path = os.path.join(
            os.path.dirname(os.path.abspath(__file__)),
            'data/graph_of_the_gods.json'
        )
        with open(path) as f:
            graph = json.loads(f.read())

            vertex_map = {}
            for v in graph['node']:
                vertex_map[v['-id']] = v['data'][1]['#text'] + ':' + v['data'][0]['#text']

            with self.triangle.batch_insert() as h:
                for e in graph['edge']:
                    s = vertex_map[e['-source']]
                    o = vertex_map[e['-target']]
                    p = e['-label']
                    h.insert(s=s, p=p, o=o)

        # Where do gods live?
        self.assertEqual(
            sorted(list(self.triangle.start(s='god').traverse(p='lives'))),
            sorted([('god:jupiter', 'lives', 'location:sky'),
                   ('god:neptune', 'lives', 'location:sea'),
                   ('god:pluto', 'lives', 'location:tartarus')])
        )

        # Usually gods live in the sky
        self.assertEqual(
            list(self.triangle.start(s='god').traverse(p='lives').traverse(o='location:sky')),
            [('god:jupiter', 'lives', 'location:sky')]
        )

        result = (
            vs(self.triangle.start(s='demigod')) &
            vs(self.triangle.start(p='mother').traverse(o='human:alcmene'))
        )
        self.assertEqual(result, {'demigod:hercules'})
Пример #55
0
    def _remove(self, site, points, triangles):
        '''
        Update the triangulation by removing the surrounding triangles 
        and then filling this cavity with new Delaunay triangles.
        Challenge: Maintain neighborhood control.
        Ref: Mir Abolfazl Mostafavi, Christopher Gold, and Maciej Dakowicz. 
             2003. Delete and insert operations in Voronoi/Delaunay methods 
             and applications. Comput. Geosci. 29, 4 (May 2003), 523-530. 
             DOI=10.1016/S0098-3004(03)00017-7 
             http://dx.doi.org/10.1016/S0098-3004(03)00017-7
        '''
        # verify compatibility of surrounding points and old triangles
        if len(points) != len(triangles):
            raise Exception("Triangulation has different sizes.")
        # verify is the triangulation is empty (or insufficient?)
        if len(points) < 3:
            return
        # initialize new triangulation controls
        i = -1
        new_triangles = {}
        # while there are points to form more than the last triangle
        while len(points) > 3:
            # checks the possible triangles considering 
            # all three consecutive points (i, i1, i2 in a cycle) 
            # of surrounding points of the site
            i += 1
            npoints = len(points)
            if (i >= npoints):
                raise Exception("Inexists a valid ear? Is it possible?")
            i1 = (i + 1) % npoints
            i2 = (i1 + 1) % npoints
            # verify if points represent a valid triangle to site,
            # like a ear listen to the site:
            # 1: gets triangle orientation (CW or CCW)
            o_ear = Triangle.orientation(points[i], points[i1], points[i2])
            # 2: gets direction of triangle to the site (CW or CCW)
            o_ear_site = Triangle.orientation(points[i], points[i2], site)
            # 3: if points are collinear, try another edge as a reference
            # ??why don't take this edge at first place??
            if o_ear_site == 0:
                o_ear_site = Triangle.orientation(points[i], points[i1], site)
            # 4: the directions is the same?
            if (o_ear * o_ear_site) > 0:
                # if so, this a valid ear (possible triangulation)
                valid_ear = Triangle(points[i], points[i1], points[i2])
                # verify if this ear is a Delaunay Triangulation
                ear_is_delaunay = True
                # 1. for all other surrounding points
                for p in points:
                    # 1.1: is this other point (not in ear)?
                    if not valid_ear.contains(p):
                        # verify if ear won't circumcircle it
                        if valid_ear.circumscribe(p):
                            # if circumcircle, ear is not a Delaunay triangle
                            ear_is_delaunay = False
                            break
                # if it is a Delaunay triangle...
                if ear_is_delaunay:
                    # include to new triangle control
                    new_triangles[valid_ear] = None
                    # include to neighborhood control
                    self.neighborhood[valid_ear] = {}
                    # link to the opposite triangles from the removed vertices
                    self._link_ear(site, valid_ear, triangles[i], 
                                   new_triangles)
                    self._link_ear(site, valid_ear, triangles[i1], 
                                   new_triangles)
                    # change triangle related to vertex by the new one
                    # remove old triangle by switching the diagonal
                    triangles[i] = valid_ear
                    # remove middle point (leave the corners) 
                    del points[i1]
                    del triangles[i1]
                    # restart cycle of surrounding points
                    i = -1
        # if has only three neighbours remaining in the surrounding points, 
        # merged these three points (triangles) into last triangulation
        last_ear = Triangle(points[0], points[1], points[2])
        self.neighborhood[last_ear] = {}
        new_triangles[last_ear] = None
        # last triangle closes the triangulation and 
        # needs update the link with all sides (neighborhood)
        self._link_ear(site, last_ear, triangles[0], new_triangles)
        self._link_ear(site, last_ear, triangles[1], new_triangles)
        self._link_ear(site, last_ear, triangles[2], new_triangles)

        if self.main_site is not None:
            if self.main_site == site:
                self.main_site = None
        self._new_version()
        if self.check_triangulation:
            if not self.valid():
                print "### Removing failure"
Пример #56
0
"""

"""
from point import Point
from line import Line
from triangle import Triangle

__author__ = "liuyang"


if __name__ == "__main__":
    points = []
    with open("test_case.txt") as f:
        ps = map(float, filter(str.isdigit, map(str.strip, f.readlines())))

    for i in range(0, len(ps), 2):
        points.append(Point(ps[i], ps[i + 1]))

    ps = points[9:12]
    for point in ps:
        print(point)
    triangle = Triangle(ps)
    print(triangle.isTriangle())
Пример #57
0
	def test_maximumTotal_return_true_result(self):
		triangle = [[6],[3,5],[9,7,1],[4,6,8,4]]
		T = Triangle(triangle)
		(val, path) = T.maximumTotal()
		self.assertEqual(val,26)
		self.assertEqual(path, [0, 1, 1, 2] )
class App:
	def __init__(self, master):
		self.dim = 500
		#init vars
		self.got_edge = 0
		#self.move_line = 0
		#self.move_oval = 0
		self.anistack = deque()
		self.moveanistack = deque()

		# create paining area
		self.canv = Canvas(root, width = self.dim, height = self.dim)
		self.canv.bind("<Button-1>", self.clicked)
		self.canv.bind("<B1-Motion>", self.moved)
		self.canv.bind("<ButtonRelease-1>", self.released)
		self.canv.pack()
		
		self.tri = Triangle([50,70],[300,300],[400,100])
		self.tri.id = self.canv.create_polygon(self.tri.coo,fill='yellow')
		
		frame = Frame(master)
		frame.pack()

		self.button = Button(frame, text="QUIT", fg="red", command=frame.quit)
		self.button.pack(side=LEFT)

		self.hi_there = Button(frame, text="Reset", command=self.reset)
		self.hi_there.pack(side=LEFT)
		

	def reset(self):
		print "reset isn't yet implemented, please just restart :)"

	def clicked(self, event) :
		#global xo, yo, got_edge, move_line, move_oval
		
		tol = 40 #egde snap tolerance, in sqrt(tol) = radius
		r = 6 #radius of moving animation

		#init vars and shortcut
		self.xo = xo = event.x
		self.yo = yo = event.y
		self.p = array([xo,yo])
		self.got_edge = 0
		tri = self.tri.coo

		for i in range(3):
			if (xo-tri[i][0])*(xo-tri[i][0])+(yo-tri[i][1])*(yo-tri[i][1]) < tol:
				self.got_edge = i+1
				#print 'got edge',i
		
		# if not clicking on a edge
		if self.got_edge == 0:
			isInSide=self.tri.isIn(xo,yo) # collision detection
			self.ani(xo,yo,isInSide)
			#move_line = self.canv.create_line(xo, yo, xo, yo)
			#move_oval = self.canv.create_oval(xo - r, yo - r, xo + r, yo + r)
			#self.moveanistack.append([move_line, move_oval])
		
	#this is the simplified crossp
	def cp(self,x,y):
		return x[0]*y[1]-x[1]*y[0]	#collision detection
		
# collision detection moved to triangle class, as for each object different...
#	def colDet(self,xo,yo):
# basic idea: take crossproduct(AP, AC) and crossp(AB, AP)
# if they have the same sign, p is inside a cone
# do the same with (BP, BA) and (BC, BP)
# crossp(A,B) in 2d is simply: Ax*By-Ay*Bx
# x,y have same sign <=> x*y>0 use div because of overflowss occuring


		
		#create some shortcuts
#		A=array(self.tri.a)
#		B=array(self.tri.b)
#		C=array(self.tri.c)
#		P=array(self.p)
		
		#print self.tri.a, B, C, P
		#print type(self.tri.a), type(B), type(C), type(P) 
		
#		if self.cp(P-A,C-A)//self.cp(B-A,P-A)>=0:
#			if self.cp(P-B,A-B)//self.cp(C-B,P-B)>=0:
#				return True
#		return False


	def moved(self, event) :
		# coordinates moved to
		x = event.x
		y = event.y
		
		if self.got_edge == 0:pass
			#while len(self.moveanistack)>1:
			#	ml, mo = self.moveanistack.popleft()
			#	self.canv.delete(ml)
			#	self.canv.delete(mo)
			
			#ml, mo = self.moveanistack.pop()
			#self.canv.coords(ml,xo,yo,x,y)
			#self.canv.coords(mo,x - 6, y - 6, x + 6, y + 6)
		else:
			self.tri.set_coo([[x,y],self.got_edge-1])
			self.canv.delete(self.tri.id)
			#print '-------------\n',self.tri.coo
			area = self.tri.getArea()
			area = area*255//(self.dim*self.dim)
			if area>255:area=255
			#print '-------------\n',area
			color = "#%02x%02x%02x" % (255, 255-area, 0)
			self.tri.id = self.canv.create_polygon(self.tri.get_c(),fill=color)
		self.canv.update()
		
	def released(self, event):
		#if self.got_edge == 0:
		#	while len(self.moveanistack)>0:
		#		ml, mo = self.moveanistack.popleft()
		#		self.canv.delete(ml)
		#		self.canv.delete(mo)
		self.got_edge = 0

	def ani(self,x,y,isOn):
		#clean up the stack, delete all remaining animation artifacts
		while len(self.anistack) > 0:
			self.canv.delete(self.anistack.popleft())
		
		if isOn: color="green"
		else: color = "red"
		
		f = 1 # size factor
		
		for i in range(50,0,-1):
			ani = self.canv.create_oval(x - f*i, y - f*i, x + f*i, y + f*i)
			self.anistack.append(ani)
			self.canv.itemconfigure(ani,fill=color)
			self.canv.update()
			self.canv.after(5)
			if len(self.anistack)>0:
				self.canv.delete(self.anistack.pop())