def test_extend_to_polyline(self):
grid = EclGrid.createRectangular((3, 3, 1), (1, 1, 1))
# o o o o
#
# o---o---o---o
#
# o===+ o o
# |
# o o o o
fault1 = Fault(grid, "Fault")
fault1.addRecord(0, 0, 0, 0, 0, 0, "X-")
fault1.addRecord(0, 0, 0, 0, 0, 0, "Y")
polyline = CPolyline(init_points=[(0, 2), (3, 2)])
points = fault1.extendToPolyline(polyline, 0)
self.assertEqual(points, [(1, 1), (2, 2)])
end_join = fault1.endJoin(polyline, 0)
self.assertEqual(end_join, [(1, 1), (0, 2)])
polyline2 = CPolyline(init_points=[(0.8, 2), (0.8, 0.8)])
end_join = fault1.endJoin(polyline2, 0)
self.assertIsNone(end_join)
def test_select_polygon(self):
surface = self.small_surface()
pointset = GeoPointset.fromSurface(surface)
georegion = GeoRegion(pointset)
self.assertEqual(0, len(georegion))
points = [(-0.1, 2.0), (1.9, 8.1), (6.1, 8.1), (9.1, 5), (7.1, 0.9)]
polygon = CPolyline(name='test_polygon', init_points=points)
picked = 52 # https://www.futilitycloset.com/2013/04/24/picks-theorem/
georegion.select_inside(polygon)
self.assertEqual(picked, len(georegion))
georegion.deselect_inside(polygon)
self.assertEqual(0, len(georegion))
georegion.select_outside(polygon)
self.assertEqual(len(surface) - picked, len(georegion))
georegion.deselect_outside(polygon)
self.assertEqual(0, len(georegion))
georegion.select_inside(polygon)
georegion.select_outside(polygon)
self.assertEqual(len(surface), len(georegion))
georegion.deselect_inside(polygon)
georegion.deselect_outside(polygon)
self.assertEqual(0, len(georegion))
georegion.select_inside(polygon)
self.assertEqual(picked, len(georegion))
internal_square = [(2.5, 2.5), (2.5, 6.5), (6.5, 6.5), (6.5, 2.5)]
georegion.deselect_inside(CPolyline(init_points=internal_square))
self.assertEqual(picked - 4 * 4,
len(georegion)) # internal square is 4x4
def test_polyline_intersection(self):
grid = EclGrid.createRectangular((100, 100, 10), (0.25, 0.25, 1))
# Fault1 Fault4
# | |
# | |
# | |
# | ------- Fault2 |
# | |
# | |
# (5 , 2.50)
# -------- Fault3
#
fault1 = Fault(grid, "Fault1")
fault2 = Fault(grid, "Fault2")
fault3 = Fault(grid, "Fault3")
fault4 = Fault(grid, "Fault4")
fault1.addRecord(1, 1, 10, grid.getNY() - 1, 0, 0, "X")
fault2.addRecord(5, 10, 15, 15, 0, 0, "Y")
fault3.addRecord(5, 10, 5, 5, 0, 0, "Y")
fault4.addRecord(20, 20, 10, grid.getNY() - 1, 0, 0, "X")
polyline = Polyline(init_points=[(4, 4), (8, 4)])
self.assertTrue(fault4.intersectsPolyline(polyline, 0))
cpolyline = CPolyline(init_points=[(4, 4), (8, 4)])
self.assertTrue(fault4.intersectsPolyline(cpolyline, 0))
polyline = Polyline(init_points=[(8, 4), (16, 4)])
self.assertFalse(fault4.intersectsPolyline(polyline, 0))
cpolyline = CPolyline(init_points=[(8, 4), (16, 4)])
self.assertFalse(fault4.intersectsPolyline(cpolyline, 0))
def test_extend_polyline_on(self):
grid = EclGrid.createRectangular((3, 3, 1), (1, 1, 1))
# o o o o
#
# o---o---o---o
#
# o===o===o===o
#
# o o o o
fault1 = Fault(grid, "Fault")
fault1.addRecord(0, 2, 0, 0, 0, 0, "Y")
polyline0 = CPolyline(init_points=[(0, 2)])
polyline1 = CPolyline(init_points=[(0, 2), (3, 2)])
polyline2 = CPolyline(init_points=[(1, 3), (1, 2)])
polyline3 = CPolyline(init_points=[(1, 3), (1, 0)])
with self.assertRaises(ValueError):
fault1.extendPolylineOnto(polyline0, 0)
points = fault1.extendPolylineOnto(polyline1, 0)
self.assertIsNone(points)
points = fault1.extendPolylineOnto(polyline2, 0)
self.assertEqual(points, [(1, 2), (1, 1)])
points = fault1.extendPolylineOnto(polyline3, 0)
self.assertIsNone(points)
def test_equal(self):
pl1 = CPolyline(name="Poly1", init_points=[(0, 0), (1, 1), (2, 2)])
pl2 = CPolyline(name="Poly2", init_points=[(0, 0), (1, 1), (2, 2)])
pl3 = CPolyline(init_points=[(0, 0), (1, 1), (2, 3)])
self.assertEqual(pl1, pl1)
self.assertEqual(pl1, pl2)
self.assertFalse(pl1 == pl3)
def test_extend_to_bbox(self):
bbox = [(0, 0), (10, 0), (10, 10), (0, 10)]
polyline = CPolyline(init_points=[(11, 11), (13, 13)])
with self.assertRaises(ValueError):
polyline.extendToBBox(bbox, start=False)
polyline = CPolyline(init_points=[(1, 1), (3, 3)])
line1 = polyline.extendToBBox(bbox, start=True)
self.assertEqual(line1, CPolyline(init_points=[(1, 1), (0, 0)]))
line1 = polyline.extendToBBox(bbox, start=False)
self.assertEqual(line1, CPolyline(init_points=[(3, 3), (10, 10)]))
def test_join__polylines(self):
l1 = Polyline(init_points=[(0, 1), (1, 1)])
l2 = CPolyline(init_points=[(2, -1), (2, 0)])
l3 = CPolyline(init_points=[(2, 2), (2, 3)])
l4 = Polyline()
l5 = CPolyline(init_points=[(0.5, 0), (0.5, 2)])
with self.assertRaises(ValueError):
GeometryTools.joinPolylines(l1, l4)
with self.assertRaises(ValueError):
GeometryTools.joinPolylines(l4, l1)
self.assertIsNone(GeometryTools.joinPolylines(l1, l5))
self.assertEqual(GeometryTools.joinPolylines(l1, l2), [(1, 1), (2, 0)])
def test_join_extend_polylines_onto(self):
l1 = Polyline( init_points = [(0,1) , (1,1)])
l2 = CPolyline( init_points = [(2,0) , (2,2)])
l3 = CPolyline( init_points = [(0.5 , 0) , (0.5 , 2)])
l4 = Polyline( init_points = [(0,5) , (1,5)])
l5 = Polyline( init_points = [(0,5)])
self.assertIsNone( GeometryTools.connectPolylines( l1 , l3 ))
with self.assertRaises( ValueError ):
GeometryTools.connectPolylines( l1 , l5 )
with self.assertRaises( ValueError ):
GeometryTools.connectPolylines( l1 , l4 )
self.assertEqual( GeometryTools.connectPolylines( l1 , l2 ) , [(1,1) , (2,1)])
def deselect_outside_polygon(self, points):
"""
Will select all points outside polygon.
See select_inside_polygon for more docuemntation.
"""
self._deselect_outside_polygon(CPolyline(init_points=points))
def test_add_polyline_barrier(self):
d = 10
layer = Layer(d, d)
grid = EclGrid.createRectangular((d, d, 1), (1, 1, 1))
pl = CPolyline(init_points=[(0, 0), (d / 2, d / 2), (d, d)])
layer.addPolylineBarrier(pl, grid, 0)
for i in range(d):
self.assertTrue(layer.bottomBarrier(i, i))
if i < (d - 1):
self.assertTrue(layer.leftBarrier(i + 1, i))
def create_coll2(self):
coll1 = self.create_collection()
coll2 = coll1.shallowCopy()
coll1.addPolyline( CPolyline( name = "POLY3" , init_points = [(1,1) , (2,2) , (1,3) , (1,1)]))
self.assertEqual(len(coll1) , 3)
self.assertTrue( "POLY3" in coll1 )
self.assertEqual(len(coll2) , 2)
self.assertFalse( "POLY3" in coll2 )
return coll2
def test_add_polyline(self):
pc = CPolylineCollection()
pl = pc.createPolyline( name = "TestP" )
self.assertTrue( isinstance(pl , CPolyline))
self.assertEqual(len(pc) , 1)
self.assertTrue( "TestP" in pc )
with self.assertRaises(IndexError):
pl = pc[2]
p0 = pc[0]
self.assertTrue( p0 == pl )
with self.assertRaises(KeyError):
pn = pc["missing"]
pn = pc["TestP"]
self.assertTrue( pn == pl )
px = CPolyline( name = "TestP")
with self.assertRaises(KeyError):
pc.addPolyline( px )
self.assertEqual(len(pc) , 1)
p2 = CPolyline( name = "Poly2")
pc.addPolyline( p2 )
self.assertEqual( len(pc) , 2 )
self.assertTrue( "Poly2" in pc )
l = []
for p in pc:
l.append(p)
self.assertEqual( len(pc) , 2 )
points = [(0,1) , (1,1)]
pc.addPolyline( points , name = "XYZ")
self.assertTrue( "XYZ" in pc )
def test_intersects(self):
polyline1 = CPolyline(init_points=[(0, 0), (1, 0), (1, 1)])
polyline2 = CPolyline(init_points=[(0.50, 0.50), (1.50, 0.50)])
polyline3 = Polyline(init_points=[(0.50, 0.50), (1.50, 0.50)])
polyline4 = CPolyline(init_points=[(0.50, 1.50), (1.50, 1.50)])
self.assertTrue(polyline1.intersects(polyline2))
self.assertTrue(polyline1.intersects(polyline3))
self.assertFalse(polyline1.intersects(polyline4))
def test_cross_segment(self):
polyline = CPolyline(init_points=[(0, 0), (1, 0), (1, 1)])
#
# x
# |
# |
# |
# x-------x
#
self.assertTrue(polyline.segmentIntersects((0.5, 0.5), (0.5, -0.5)))
self.assertTrue(polyline.segmentIntersects((0.5, 0.5), (1.5, 0.5)))
self.assertFalse(polyline.segmentIntersects((0.5, 0.5), (0.5, 1.5)))
self.assertFalse(polyline.segmentIntersects((0.5, 0.5), (-0.5, 0.5)))
self.assertFalse(polyline.segmentIntersects((0.5, 1.5), (1.5, 1.5)))
self.assertTrue(polyline.segmentIntersects((1.0, 1.0), (1.5, 1.5)))
self.assertTrue(polyline.segmentIntersects((1.5, 1.5), (1.0, 1.0)))
self.assertTrue(polyline.segmentIntersects((1, 0), (1.0, 1.0)))
def test_front(self):
polyline = CPolyline()
polyline.addPoint(1, 1)
polyline.addPoint(0, 0, front=True)
self.assertEqual(len(polyline), 2)
x, y = polyline[0]
self.assertEqual(x, 0)
self.assertEqual(y, 0)
x, y = polyline[1]
self.assertEqual(x, 1)
self.assertEqual(y, 1)
def select_inside_polygon(self, points, intersect=False):
"""
Will select all points inside polygon.
Will select all points inside polygon specified by input
variable @points. Points should be a list of two-element
tuples (x,y). So to select all the points within the rectangle
bounded by the lower left rectangle (0,0) and upper right
(100,100) the @points list should be:
points = [(0,0) , (0,100) , (100,100) , (100,0)]
The elements in the points list should be (utm_x, utm_y)
values. These values will be compared with the centerpoints of
the cells in the grid. The selection is based the top k=0
layer, and then extending this selection to all k values; this
implies that the selection polygon will effectively be
translated if the pillars are not vertical.
"""
self._select_inside_polygon(CPolyline(init_points=points))
def extendToBBox(self, bbox, k, start=True):
fault_polyline = self.getPolyline(k)
if start:
p0 = fault_polyline[1]
p1 = fault_polyline[0]
else:
p0 = fault_polyline[-2]
p1 = fault_polyline[-1]
ray_dir = GeometryTools.lineToRay(p0,p1)
intersections = GeometryTools.rayPolygonIntersections(p1, ray_dir, bbox)
if intersections:
p2 = intersections[0][1]
if self.getName():
name = "Extend:%s" % self.getName()
else:
name = None
return CPolyline(name=name, init_points=[(p1[0], p1[1]), p2])
else:
raise Exception("Logical error - must intersect with bounding box")
def create_collection(self):
collection = CPolylineCollection()
p1 = CPolyline( name = "POLY1" , init_points = [(0,10) , (1,11) , (2,12)])
p2 = CPolyline( name = "POLY2" , init_points = [(0,100) , (10,110) , (20,120)])
collection.addPolyline( p1 )
collection.addPolyline( p2 )
tail = p1[-1]
self.assertEqual( tail , (2,12))
self.assertEqual(p1.getName() , "POLY1")
tail = p2[-1]
self.assertEqual( tail , (20,120))
self.assertEqual(p2.getName() , "POLY2")
return collection
def test_item(self):
polyline = CPolyline()
polyline.addPoint(10, 20)
self.assertEqual(len(polyline), 1)
with self.assertRaises(TypeError):
(x, y) = polyline["KEY"]
with self.assertRaises(IndexError):
(x, y) = polyline[10]
(x, y) = polyline[0]
self.assertEqual(x, 10)
self.assertEqual(y, 20)
polyline.addPoint(20, 20)
(x, y) = polyline[-1]
self.assertEqual(x, 20)
self.assertEqual(y, 20)
def addPolyline(self, polyline, name=None):
if not isinstance(polyline, CPolyline):
polyline = CPolyline(init_points=polyline, name=name)
else:
if not name is None:
raise ValueError(
"The name keyword argument can only be supplied when add not CPOlyline object"
)
name = polyline.getName()
if name and name in self:
raise KeyError("The polyline collection already has an object:%s" %
name)
if polyline.isReference():
self._add_polyline(polyline, False)
else:
polyline.convertToCReference(self)
self._add_polyline(polyline, True)
def test_construction(self):
polyline = CPolyline()
self.assertEqual(len(polyline), 0)
with self.assertRaises(IOError):
CPolyline.createFromXYZFile("Does/not/exist")
p1 = CPolyline.createFromXYZFile(self.polyline1)
self.assertEqual(len(p1), 13)
x, y = p1[-1]
self.assertEqual(x, 389789.263184)
self.assertEqual(y, 6605784.945099)
p2 = CPolyline.createFromXYZFile(self.polyline2)
self.assertEqual(len(p2), 20)
x, y = p2[-1]
self.assertEqual(x, 396056.314697)
self.assertEqual(y, 6605835.119461)
p3 = CPolyline.createFromXYZFile(self.polyline3)
self.assertEqual(len(p3), 20)
x, y = p3[-1]
self.assertEqual(x, 396056.314697)
self.assertEqual(y, 6605835.119461)
def get_polyline(self, name=None):
polyline = CPolyline(name=name)
for fl in self:
polyline += fl.getPolyline()
return polyline
def test_length(self):
polyline = CPolyline(init_points=[(0, 1)])
self.assertEqual(polyline.segmentLength(), 0)
polyline = CPolyline(init_points=[(0, 0), (1, 0), (1, 1), (2, 2)])
self.assertEqual(polyline.segmentLength(), 2 + math.sqrt(2))
def test_unzip(self):
pl = CPolyline(init_points=[(0, 3), (1, 4), (2, 5)])
x, y = pl.unzip()
self.assertEqual(x, [0, 1, 2])
self.assertEqual(y, [3, 4, 5])
def test_name(self):
p1 = CPolyline()
self.assertTrue(p1.getName() is None)
p2 = CPolyline(name="Poly2")
self.assertEqual(p2.getName(), "Poly2")
def test_intersects2(self):
polyline = CPolyline(init_points=[(2, 10), (2, 100)])
self.assertTrue(polyline.intersects(polyline))
def __init_polyline(self):
pl = CPolyline()
for (i,j) in self.getIJPolyline():
x,y,z = self.__grid.getNodeXYZ(i, j, self.__k)
pl.addPoint(x, y)
self.__polyline = pl