Exemple #1
0
 def test_constructor(self):
     v1 = Vertex((0,0))
     v2 = Vertex((1,1))
     v3 = Vertex((2,2))
     half_edge_1 = HalfEdge(v1, v2)
     half_edge_2 = HalfEdge(v2, v3)
     
     # Should complain about tuple input
     self.assertRaises(Exception, HalfEdge, *[v1,(1,1)]) 
     
     # Should complain about incompatible twin 
     self.assertRaises(Exception, HalfEdge, \
                       *(v2, v3), **{'twin':half_edge_1})
     
     # Should complain about incompatible previous
     self.assertRaises(Exception, HalfEdge, \
                       *(v3, v2), **{'previous':half_edge_1})
     
     # Should complain about incompatible nxt
     self.assertRaises(Exception, HalfEdge, *(v3, v2), \
                       **{'next':half_edge_1})
     
     # Should complain about nxt of incompatible type
     self.assertRaises(Exception, HalfEdge, *(v3, v2), \
                       **{'next':2})
     
     # Should complain about incompatible parent
     self.assertRaises(Exception, HalfEdge, *(v3, v2), \
                       **{'parent':half_edge_2})
Exemple #2
0
    def test_get_neighbor(self):
        """
        TODO: Test flagged neighbor
        """
        #
        # Make interval
        #
        v1 = Vertex(0)
        v2 = Vertex(1)
        I = Interval(v1, v2)

        #
        # Left interval
        #
        v0 = Vertex(-1)
        I0 = Interval(v0, v1)

        #
        # Right interval
        #
        v3 = Vertex(2)
        I1 = Interval(v2, v3)

        I0.assign_next(I)
        self.assertEqual(I0.next(), I)
        I.assign_next(I1)

        self.assertEqual(I.get_neighbor(1), I1)
        self.assertEqual(I.get_neighbor(0), I0)
Exemple #3
0
    def test_assign_next(self):
        #
        # Make interval
        #
        v1 = Vertex(0)
        v2 = Vertex(1)
        I = Interval(v1, v2)

        #
        # Left interval
        #
        v0 = Vertex(-1)
        I0 = Interval(v0, v1)

        #
        # Right interval
        #
        v3 = Vertex(2)
        I1 = Interval(v2, v3)

        I0.assign_next(I)
        self.assertEqual(I0.next(), I)
        self.assertEqual(I.previous(), I0)

        I.assign_next(I1)
        self.assertEqual(I.next(), I1)
        self.assertEqual(I1.previous(), I)
Exemple #4
0
 def test_intersects_line_segment(self):
     vertices = [Vertex((0,0)), Vertex((3,1)), 
                 Vertex((2,3)), Vertex((-1,1))]
     
     h_edges = []
     for i in range(4):
         h_edges.append(HalfEdge(vertices[i], vertices[(i+1)%4]))
     cell = Cell(h_edges)
     
     #
     # Line beginning in cell and ending outside
     # 
     line_1 = [(1,1),(3,0)]
     self.assertTrue(cell.intersects_line_segment(line_1),\
                     'Cell should intersect line segment.')
     #
     # Line inside cell
     #
     line_2 = [(1,1),(1.1,1.1)]
     self.assertTrue(cell.intersects_line_segment(line_2),\
                     'Cell contains line segment.')
     #
     # Line outside cell
     # 
     line_3 = [(3,0),(5,6)]
     self.assertFalse(cell.intersects_line_segment(line_3),\
                      'Cell does not intersect line segment.')
Exemple #5
0
 def test_intersects_line_segment(self):
     # 
     # Define a HalfEdge
     # 
     v1 = Vertex((0,0))
     v2 = Vertex((0,1))
     h_edge = HalfEdge(v1,v2)
     #
     # Line 1 intersects h_edge in the middle
     # 
     line_1 = [(-0.5,0.5),(0.5,0.5)]
     self.assertTrue(h_edge.intersects_line_segment(line_1),\
                     'HalfEdge should intersect line_1.')
     #
     # Line 2 intersects h_edge at the vertex
     # 
     line_2 = [(-1,1),(0,1)]
     self.assertTrue(h_edge.intersects_line_segment(line_2),\
                     'HalfEdge should intersect line_2.')
     #
     # Line 3 is on top of h_edge
     # 
     line_3 = [(0,0),(0,1)]
     self.assertTrue(h_edge.intersects_line_segment(line_3),\
                     'HalfEdge should intersect line_3.')
     #
     # Line 4 does not intersect h_edge
     # 
     line_4 = [(1,2), (3,3)]
     self.assertFalse(h_edge.intersects_line_segment(line_4),\
                     'HalfEdge should intersect line_4.')
Exemple #6
0
    def test_bin_points(self):
        #
        # Cell vertices
        #
        v1 = Vertex((0, 0))
        v2 = Vertex((1, 0))
        v3 = Vertex((1, 1))
        v4 = Vertex((0, 1))

        # Cell HalfEdges
        h12 = HalfEdge(v1, v2)
        h23 = HalfEdge(v2, v3)
        h34 = HalfEdge(v3, v4)
        h41 = HalfEdge(v4, v1)

        # Cell
        cell = QuadCell([h12, h23, h34, h41])

        # Split cell twice
        cell.split()
        cell.get_child(1).split()

        #
        # Error: point not in cell
        #
        x = np.array([[-1, -1]])
        self.assertRaises(Exception, cell.bin_points, *(x, ))

        #
        # Corner points
        #
        x = convert_to_array([v1, v2, v3, v4])
        bins = cell.bin_points(x)

        # There should be four bins
        self.assertEqual(len(bins), 4)

        # No binning cells should have children
        for c, dummy in bins:
            self.assertFalse(c.has_children())

        #
        # Center point
        #
        x = np.array([[0.5, 0.5]])
        bins = cell.bin_points(x)
        self.assertEqual(len(bins), 1)

        #
        # Mark
        #
        sf = '1'
        for child in cell.get_children():
            child.mark(sf)

        x = np.array([[0.75, 0.25]])
        bins = cell.bin_points(x, subforest_flag=sf)
        for c, dummy in bins:
            self.assertTrue(c.is_marked(sf))
            self.assertFalse(c.has_children(flag=sf))
Exemple #7
0
 def test_head(self):
     #
     # Retrieve head
     # 
     v1 = Vertex((0,0))
     v2 = Vertex((1,1))
     half_edge = HalfEdge(v1,v2)
     self.assertEqual(half_edge.head(), v2, 'Incorrect head.')
Exemple #8
0
 def test_base(self):
     #
     # Retrieve base
     # 
     v1 = Vertex((0,0))
     v2 = Vertex((1,1))
     half_edge = HalfEdge(v1,v2)
     self.assertEqual(half_edge.base(), v1, 'Incorrect base.')
Exemple #9
0
    def test_mark(self):
        v = Vertex(0)
        v.mark()
        self.assertTrue(v.is_marked())

        v = Vertex(0)
        v.mark('sflkj')
        self.assertTrue(v.is_marked())
Exemple #10
0
 def test_twin(self):
     v1 = Vertex((0,0))
     v2 = Vertex((1,1))
     half_edge_1 = HalfEdge(v1,v2)
     half_edge_2 = HalfEdge(v2,v1, twin=half_edge_1)
     self.assertEqual(half_edge_2.twin(), half_edge_1,\
                      'Twin incorrectly specified.')
     self.assertIsNone(half_edge_1.twin(), \
                       'half_edge_2 has no twin yet.')
Exemple #11
0
    def test_get_vertices(self):
        #
        # Make interval
        #
        v1 = Vertex(0)
        v2 = Vertex(1)
        I = Interval(v1, v2)

        self.assertEqual(I.get_vertices(), [v1, v2])
Exemple #12
0
    def test_subcell_position(self):
        """
        Locate sub-cell within a skew quadcell
        """

        #
        # Define ROOT Cell
        #

        # Define vertices
        v1 = Vertex((1, 1))
        v2 = Vertex((2, 3))
        v3 = Vertex((1.5, 5))
        v4 = Vertex((0, 2))
        vertices = [v1, v2, v3, v4]

        # Define HalfEdges
        h12 = HalfEdge(v1, v2)
        h23 = HalfEdge(v2, v3)
        h34 = HalfEdge(v3, v4)
        h41 = HalfEdge(v4, v1)
        halfedges = [h12, h23, h34, h41]

        # Define QuadCell
        cell = QuadCell(halfedges)

        # Check that cell is not a rectangle
        self.assertFalse(cell.is_rectangle())

        #
        # Refine ROOT cell twice and pick a grandchild
        #
        cell.split()
        child = cell.get_child(2)
        child.split()
        grandchild = child.get_child(1)

        #
        # Determine relative position of the grandchild within cell
        #
        pos, width = cell.subcell_position(grandchild)

        #
        # Map the associated region the reference cell to physical cell
        #
        x_ref = np.array([
            pos, pos + np.array([width, 0]), pos + np.array([width, width]),
            pos + np.array([0, width])
        ])

        x_vertices = cell.reference_map(x_ref)

        #
        # Check that points match up
        #
        for v, vh in zip(grandchild.get_vertices(), x_vertices):
            self.assertTrue(np.allclose(np.array(v.coordinates()), vh))
Exemple #13
0
 def test_contains_points(self):
     #
     # Triangle
     # 
     v1 = Vertex((0,0))
     v2 = Vertex((1,0))
     v3 = Vertex((0,1))
     
     h12 = HalfEdge(v1, v2)
     h23 = HalfEdge(v2, v3)
     h31 = HalfEdge(v3, v1)
     
     cell = Cell([h12, h23, h31])
     
     # Vertices
     in_cell = cell.contains_points([v1,v2,v3])
     in_cell_ref = np.ones(3, dtype=np.bool)
     for i in range(3):
         self.assertEqual(in_cell_ref[i], in_cell[i])
     
     # Random points
     points = np.random.rand(100,2)
     in_cell_ref = (points[:,1]<1-points[:,0])
     in_cell = cell.contains_points(points)
     for i in range(100):
         self.assertEqual(in_cell_ref[i], in_cell[i])
     
     #
     # Square 
     # 
     v4 = Vertex((1,1))
     h24 = HalfEdge(v2,v4)
     h43 = HalfEdge(v4,v3)
     square_half_edges = [h12, h24, h43, h31]
     cell = Cell(square_half_edges)
     
     points = [(2,0), (-1,0), (0.5,0.5)]
     in_cell_ref = np.array([0,0,1], dtype=np.bool)
     in_cell = cell.contains_points(points)
     for i in range(3):
         self.assertEqual(in_cell_ref[i], in_cell[i])
     
     #
     # Single points
     # 
     # Vertex 
     point = Vertex((3,3))
     self.assertFalse(cell.contains_points(point))
     # Tuple
     point = (1,0)
     self.assertTrue(cell.contains_points(point)) 
     # Array
     point = np.array([1,0])
     self.assertTrue(cell.contains_points(point))
Exemple #14
0
 def test_reference_map(self):
     v1 = Vertex((1,1))
     v2 = Vertex((2,3))
     
     h = HalfEdge(v1,v2)
     
     x = np.linspace(0, 1, 5)
     points = h.reference_map(x)
             
     y = h.reference_map(points, mapsto='reference')
     for (yi,xi) in zip(x,y):
         self.assertAlmostEqual(xi,yi)
Exemple #15
0
 def test_assign_cell(self):
     # Make a cell
     points = [(0,0),(1,0),(1,1),(0,1)]
     vertices = [Vertex(point) for point in points]
     half_edges = [HalfEdge(vertices[i], vertices[(i+1)%4]) for i in range(4)]
     cell = Cell(half_edges)
     
     # Make a (different) half_edge
     he = HalfEdge(Vertex((0,0)), Vertex((1,1)))
     he.assign_cell(cell)
     
     self.assertEqual(he.cell(),cell)
Exemple #16
0
 def test_make_twin(self):
     #
     # New HalfEdge
     #
     v1 = Vertex((0,0))
     v2 = Vertex((2,2))
     h12 = HalfEdge(v1,v2)
     h21 = h12.make_twin()
     self.assertIsNotNone(h12.twin())
     self.assertIsNotNone(h21.twin())
     self.assertEqual(h12.base(),h21.head())
     self.assertEqual(h21.base(),h12.head())
Exemple #17
0
 def test_next(self):
     #
     # New HalfEdge
     #
     v1 = Vertex((0,0))
     v2 = Vertex((2,2))
     v3 = Vertex((3,4))
     next_half_edge = HalfEdge(v1, v2)
     half_edge = HalfEdge(v3, v1, nxt=next_half_edge)
     
     # Check
     self.assertEqual(half_edge.next(),next_half_edge,\
                      'Next HalfEdge incorrect.')
Exemple #18
0
 def test_previous(self):
     #
     # New HalfEdge
     #
     v1 = Vertex((0,0))
     v2 = Vertex((2,2))
     v3 = Vertex((3,4))
     previous_half_edge = HalfEdge(v1, v2)
     half_edge = HalfEdge(v2, v3, previous=previous_half_edge)
     
     # Check
     self.assertEqual(half_edge.previous(),previous_half_edge,\
                      'Previous HalfEdge incorrect.')
Exemple #19
0
    def test_locate_point(self):
        v_sw = Vertex((0, 0))
        v_se = Vertex((3, 1))
        v_ne = Vertex((2, 3))
        v_nw = Vertex((-1, 1))

        h12 = HalfEdge(v_sw, v_se)
        h23 = HalfEdge(v_se, v_ne)
        h34 = HalfEdge(v_ne, v_nw)
        h41 = HalfEdge(v_nw, v_sw)
        cell = QuadCell([h12, h23, h34, h41])

        points = np.random.rand(5, 2)
Exemple #20
0
    def test_constructor(self):
        #
        # Proper Interval
        #
        v1 = Vertex(0)
        v2 = Vertex(1)
        I = Interval(v1, v2)
        self.assertTrue(isinstance(I, HalfEdge))
        #
        # Interval using 2D Vertices
        #
        w1 = Vertex((0, 0))
        w2 = Vertex((1, 1))

        self.assertRaises(Exception, Interval, *(w1, w2))
Exemple #21
0
 def test_get_parent(self):
     #
     # New HalfEdge
     #
     v1 = Vertex((0,0))
     v2 = Vertex((2,2))
     half_edge = HalfEdge(v1, v2)
     
     # Split
     half_edge.split()
     
     # Check if half_edge is children's parent
     for child in half_edge.get_children():
         self.assertEqual(half_edge, child.get_parent(),\
                          'HalfEdge should be child"s parent')
Exemple #22
0
    def test_constructor(self):
        # Check the right number of halfedges
        self.assertRaises(Exception, QuadCell, *([1, 2, 2, 2, 2]))

        # Rectangle
        v1 = Vertex((0, 0))
        v2 = Vertex((1, 0))
        v3 = Vertex((1, 1))
        v4 = Vertex((0, 1))
        h12 = HalfEdge(v1, v2)
        h23 = HalfEdge(v2, v3)
        h34 = HalfEdge(v3, v4)
        h41 = HalfEdge(v4, v1)

        cell = QuadCell([h12, h23, h34, h41])
        self.assertTrue(cell.is_rectangle())
Exemple #23
0
 def test_get_half_edges(self):
     #
     # Construct Cell
     # 
     v1 = Vertex((0,0))
     v2 = Vertex((1,0))
     v3 = Vertex((0,1))
     
     h12 = HalfEdge(v1, v2)
     h23 = HalfEdge(v2, v3)
     h31 = HalfEdge(v3, v1)
     
     # Check whether you get the right he's back
     hes = [h12, h23, h31]
     cell = Cell(hes)
     self.assertEqual(cell.get_half_edges(), hes)
Exemple #24
0
 def test_cell(self):
     points = [(0,0),(1,0),(1,1),(0,1)]
     vertices = [Vertex(point) for point in points]
     half_edges = [HalfEdge(vertices[i], vertices[(i+1)%4]) for i in range(4)]
     cell = Cell(half_edges)
     for he in half_edges:
         self.assertEqual(he.cell(), cell)
Exemple #25
0
    def test_split(self):
        # New (regular) Interval
        I = Interval(Vertex(0), Vertex(1), n_children=3)
        I.split()
        for i in range(2):
            self.assertEqual(I.get_child(i).next(), I.get_child(i + 1))

        for i in np.arange(1, 3):
            self.assertEqual(I.get_child(i).previous(), I.get_child(i - 1))
        #
        # Split the middle child
        #
        middle_child = I.get_child(1)
        # Check that you can't split the middle child into 2 because the
        # tree is not regular.
        self.assertRaises(Exception, middle_child.split, **{'n_children': 2})

        # Split using the default number of children
        middle_child.split()

        # Check that middle child has 3 children
        self.assertEqual(middle_child.n_children(), 3)

        # Check that middle child's right child has no next interval
        self.assertEqual(
            middle_child.get_child(2).get_neighbor(1), I.get_child(2))

        #
        # Split the right child
        #
        right_child = I.get_child(2)
        right_child.split()

        # Check that the right child has the correct number of children
        self.assertEqual(right_child.n_children(), 3)

        # Now the middle child's right child has a right neighbor
        self.assertEqual(middle_child.get_child(2).get_neighbor(1),\
                         right_child.get_child(0))

        #
        # Irregular Interval
        #
        I = Interval(Vertex(0), Vertex(1), regular=False, n_children=3)
        I.split(n_children=2)
        for child in I.get_children():
            self.assertEqual(child.n_children(), 2)
Exemple #26
0
 def test_get_vertex(self):
     #
     # Construct Cell
     # 
     v1 = Vertex((0,0))
     v2 = Vertex((1,0))
     v3 = Vertex((0,1))
     
     h12 = HalfEdge(v1, v2)
     h23 = HalfEdge(v2, v3)
     h31 = HalfEdge(v3, v1)
     
     # Check whether you get the right he's back
     vs = [v1, v2, v3]
     cell = Cell([h12,h23,h31])
     for i in range(3):
         self.assertEqual(cell.get_vertex(i), vs[i])
Exemple #27
0
 def test_has_children(self):
     #
     # New HalfEdge
     #
     v1 = Vertex((0,0))
     v2 = Vertex((2,2))
     half_edge = HalfEdge(v1, v2)
     
     # Shouldn't have children
     self.assertFalse(half_edge.has_children(),\
                      'Half Edge should not have children')
     
     # Split edge
     half_edge.split()
     
     # Should have children
     self.assertTrue(half_edge.has_children(),\
                     'HalfEdge should have children.')
Exemple #28
0
 def test_unmark(self):
     #
     # Define a HalfEdge
     # 
     v1 = Vertex((0,0))
     v2 = Vertex((0,1))
     h_edge = HalfEdge(v1,v2)
     #
     # Mark it with a specific flag
     # 
     h_edge.mark(1)
     self.assertTrue(h_edge.is_marked(1),'HalfEdge should be marked.')
     #
     # Unmark it 
     # 
     h_edge.unmark(1)
     self.assertFalse(h_edge.is_marked(),'HalfEdge should be marked.')
     self.assertFalse(h_edge.is_marked(1),'HalfEdge should be marked.')
Exemple #29
0
 def test_has_parent(self):
     #
     # New HalfEdge
     #
     v1 = Vertex((0,0))
     v2 = Vertex((2,2))
     half_edge = HalfEdge(v1, v2)
     
     self.assertFalse(half_edge.has_parent(), \
                      'Half Edge should not have a parent.')
     
     # Split edge
     half_edge.split()
     
     # Children should have parent
     for child in half_edge.get_children():
         self.assertTrue(child.has_parent(), \
                         'HalfEdge children should have a parent.')
Exemple #30
0
 def test_constructor(self):
     """
     Constructor
     """
     #
     # Triangle
     # 
     v1 = Vertex((0,0))
     v2 = Vertex((1,0))
     v3 = Vertex((0,1))
     
     h12 = HalfEdge(v1, v2)
     h23 = HalfEdge(v2, v3)
     h31 = HalfEdge(v3, v1)
     
     # Vertices not in order
     bad_list_1 = [h12, h31, h23]
     self.assertRaises(Exception, Cell, *[bad_list_1])
     
     # Not a closed loop
     bad_list_2 = [h12, h23]
     self.assertRaises(Exception, Cell, *[bad_list_2])
 
     triangle_half_edges = [h12, h23, h31]
     cell = Cell(triangle_half_edges)
     self.assertAlmostEqual(cell.area(),0.5)
     self.assertEqual(cell.n_vertices(),3)
     self.assertEqual(cell.n_half_edges(),3)
     half_edge = cell.get_half_edge(0)
     for i in range(3):
         self.assertEqual(half_edge.next(), triangle_half_edges[(i+1)%3])
         half_edge = half_edge.next()
     
     #
     # Square 
     # 
     v4 = Vertex((1,1))
     h24 = HalfEdge(v2,v4)
     h43 = HalfEdge(v4,v3)
     square_half_edges = [h12, h24, h43, h31]
     cell = Cell(square_half_edges)
     self.assertAlmostEqual(cell.area(),1)
     self.assertEqual(cell.n_vertices(),4)
     self.assertEqual(cell.n_half_edges(),4)