def test_points_gridding(tmpdir, reek_map, generate_plot):
"""Make points of surface; then grid back to surface."""
xs = reek_map
assert xs.ncol == 554
xyz = Points(xs)
xyz.dataframe["Z_TVDSS"] = xyz.dataframe["Z_TVDSS"] + 300
logger.info("Avg of points: %s", xyz.dataframe["Z_TVDSS"].mean())
xscopy = xs.copy()
logger.info(xs.values.flags)
logger.info(xscopy.values.flags)
# now regrid
xscopy.gridding(xyz, coarsen=1) # coarsen will speed up test a lot
if generate_plot:
logger.info("Output plots to file (may be time consuming)")
xs.quickplot(filename=join(tmpdir, "s1.png"))
xscopy.quickplot(filename=join(tmpdir, "s2.png"))
tsetup.assert_almostequal(xscopy.values.mean(), xs.values.mean() + 300, 2)
xscopy.to_file(join(tmpdir, "reek_points_to_map.gri"),
fformat="irap_binary")
def test_get_zone_thickness_one_well(testpath):
"""Import a well and get the zone thicknesses"""
wlist = [Well((testpath / WFILES1), zonelogname="Zonelog")]
mypoints = Points()
mypoints.from_wells(wlist, tops=False, zonelist=[12, 13, 14])
def test_export_points():
"""Export XYZ points to file, various formats"""
mypoints = Points(POINTSET4) # should guess based on extesion
print(mypoints.dataframe)
mypoints.to_file(join(TMPD, "poi_export1.rmsattr"), fformat="rms_attr")
def test_points_gridding(reek_map):
"""Make points of surface; then grid back to surface."""
xs = reek_map
assert xs.ncol == 554
xyz = Points(xs)
xyz.dataframe['Z_TVDSS'] = xyz.dataframe['Z_TVDSS'] + 300
logger.info('Avg of points: {}'.format(xyz.dataframe['Z_TVDSS'].mean()))
xscopy = xs.copy()
logger.info(xs.values.flags)
logger.info(xscopy.values.flags)
# now regrid
xscopy.gridding(xyz, coarsen=1) # coarsen will speed up test a lot
if XTGSHOW:
logger.info('Output plots to file (may be time consuming)')
xs.quickplot(filename=os.path.join(TMPD, 's1.png'))
xscopy.quickplot(filename=os.path.join(TMPD, '/tmp/s2.png'))
tsetup.assert_almostequal(xscopy.values.mean(), xs.values.mean() + 300, 2)
xscopy.to_file(os.path.join(TMPD, 'reek_points_to_map.gri'),
fformat='irap_binary')
def test_check_multi_point_single_polygon_zdir():
pol = Polygons(SMALL_POLY_INNER)
poi = Points([(4.0, 4.0, 0.0), (4.0, 4.0, 4.0), (4.0, 4.0, 8.0)])
assert len(poi.dataframe) == 3
# Note z-direction has no effect. All points are deleted.
poi.operation_polygons(pol, value=1, opname="eli", inside=True)
assert len(poi.dataframe) == 0
def test_polygons_overlap():
pol = Polygons(SMALL_POLY_INNER + SMALL_POLY_OVERLAP_INNER)
# The Four points are placed: within first poly, within the overlap, within the
# second poly, outside both poly
poi = Points([(3.5, 3.5, 0.0), (4.5, 4.5, 0.0), (5.5, 5.5, 0.0),
(6.5, 6.5, 0.0)])
poi.operation_polygons(pol, value=1, opname="eli", inside=True)
assert len(poi.dataframe) == 1
def test_oper_points_inside_overlapping_polygon(oper, expected):
pol = Polygons(SMALL_POLY_INNER + SMALL_POLY_OVERLAP_INNER)
# The Four points are placed: within first poly, within the overlap, within the
# second poly, outside both poly
poi = Points([(3.5, 3.5, 10.0), (4.5, 4.5, 10.0), (5.5, 5.5, 10.0),
(6.5, 6.5, 10.0)])
# Operations are performed n times, where n reflects the number of polygons a
# point is outside
poi.operation_polygons(pol, value=2, opname=oper, inside=False)
assert list(poi.dataframe[poi.zname].values) == expected
def test_export_points_rmsattr():
"""Export XYZ points to file, as rmsattr"""
mypoints = Points(POINTSET4) # should guess based on extesion
logger.info(mypoints.dataframe)
mypoints.to_file(join(TMPD, "poi_export1.rmsattr"), fformat="rms_attr")
mypoints2 = Points(join(TMPD, "poi_export1.rmsattr"))
assert mypoints.dataframe["Seg"].equals(mypoints2.dataframe["Seg"])
assert mypoints.dataframe["MyNum"].equals(mypoints2.dataframe["MyNum"])
def test_map_to_points(reek_map):
"""Get the list of the coordinates"""
px = Points()
surf = RegularSurface(ftop1)
assert isinstance(surf, RegularSurface)
tsetup.assert_almostequal(surf.values.mean(), 0.5755830099, 0.001)
px.from_surface(surf)
# convert to a Points instance
px = Points(reek_map)
# or
# px.from_surface(...)
outf = os.path.join(td, 'points_from_surf_reek.poi')
px.to_file(outf)
assert px.dataframe['X_UTME'].min() == 456719.75
tsetup.assert_almostequal(px.dataframe['Z_TVDSS'].mean(), 0.57558, 0.001)
# read the output for comparison
pxx = Points(outf)
tsetup.assert_almostequal(px.dataframe['Z_TVDSS'].mean(),
pxx.dataframe['Z_TVDSS'].mean(), 0.00001)
def test_export_points_rmsattr(testpath, tmp_path):
"""Export XYZ points to file, as rmsattr."""
mypoints = Points(testpath / POINTSET4) # should guess based on extesion
output_path = tmp_path / "poi_export.rmsattr"
mypoints.to_file(output_path, fformat="rms_attr")
mypoints2 = Points(output_path)
assert mypoints.dataframe["Seg"].equals(mypoints2.dataframe["Seg"])
assert mypoints.dataframe["MyNum"].equals(mypoints2.dataframe["MyNum"])
def test_check_multi_point_multi_polyon_outside_op():
pol = Polygons(SMALL_POLY_INNER + LARGE_POLY_SHIFTED)
# Two points in small cube, one in large cube, one outside
poi = Points([(4.0, 4.0, 0.0), (4.5, 4.0, 0.0), (7.0, 7.0, 0.0),
(20.0, 5.0, 0.0)])
assert len(poi.dataframe) == 4
# Note the operation will loop over the polygons, and hence remove the points
# in the small polygon when considering the large polygon, and vice versa
poi.operation_polygons(pol, value=1, opname="eli", inside=False)
assert len(poi.dataframe) == 0
def test_export_load_rmsformatted_points(testpath, tmp_path):
"""Export XYZ points to file, various formats."""
test_points_path = testpath / POINTSET4
orig_points = Points(test_points_path) # should guess based on extesion
export_path = tmp_path / "attrs.rmsattr"
orig_points.to_file(export_path, fformat="rms_attr")
reloaded_points = Points(export_path)
pd.testing.assert_frame_equal(orig_points.dataframe,
reloaded_points.dataframe)
def test_get_zone_thickness_some_wells(testpath, tmp_path):
"""Import some wells and get the zone thicknesses"""
wlist = [
Well(wpath, zonelogname="Zonelog")
for wpath in glob.glob(str(testpath / WFILES2))
]
mypoints = Points()
mypoints.from_wells(wlist, tops=False, zonelist=(1, 22))
mypoints.to_file(
tmp_path / "zpoints_w_so622.rmsasc",
fformat="rms_attr",
attributes=["WellName", "ZoneName"],
pfilter={"ZoneName": ["SO622"]},
)
# filter, for backwards compatibility
mypoints.to_file(
tmp_path / "zpoints_w_so622_again.rmsasc",
fformat="rms_attr",
attributes=["WellName", "ZoneName"],
filter={"ZoneName": ["SO622"]},
)
def test_export_and_load_points(tmp_path):
"""Export XYZ points to file."""
plist = [(1.0, 1.0, 1.0), (2.0, 3.0, 4.0), (5.0, 6.0, 7.0)]
test_points = Points(plist)
export_path = tmp_path / "test_points.xyz"
test_points.to_file(export_path)
exported_points = Points(export_path)
pd.testing.assert_frame_equal(test_points.dataframe,
exported_points.dataframe)
assert list(itertools.chain.from_iterable(plist)) == list(
test_points.dataframe.values.flatten())
def test_get_zone_thickness_one_well():
"""Import a well and get the zone thicknesses"""
wlist = []
for w in glob.glob(str(WFILES1)):
wlist.append(Well(w, zonelogname="Zonelog"))
logger.info("Imported well {}".format(w))
mypoints = Points()
nwell = mypoints.from_wells(wlist, tops=False, zonelist=[12, 13, 14])
print(mypoints.dataframe)
logger.info("Number of well made to tops: {}".format(nwell))
def test_import_rmsattr_format(testpath, tmp_path):
"""Import points with attributes from RMS attr format."""
orig_points = Points()
test_points_path = testpath / POINTSET3
orig_points.from_file(test_points_path, fformat="rms_attr")
export_path = tmp_path / "attrs.rmsattr"
orig_points.to_file(export_path, fformat="rms_attr")
reloaded_points = Points()
reloaded_points.from_file(export_path, fformat="rms_attr")
pd.testing.assert_frame_equal(orig_points.dataframe,
reloaded_points.dataframe)
def test_import():
"""Import XYZ points from file."""
mypoints = Points(PFILE) # should guess based on extesion
x0 = mypoints.dataframe["X_UTME"].values[0]
tsetup.assert_almostequal(x0, 460842.434326, 0.001)
def test_points_in_polygon():
"""Import XYZ points and do operations if inside or outside"""
poi = Points(POINTSET2)
pol = Polygons(POLSET2)
assert poi.nrow == 30
# remove points in polygon
poi.operation_polygons(pol, 0, opname="eli", where=True)
assert poi.nrow == 19
poi.to_file(join(TMPD, "poi_test.poi"))
poi = Points(POINTSET2)
# remove points outside polygon
poi.operation_polygons(pol, 0, opname="eli", inside=False, where=True)
assert poi.nrow == 1
def test_get_zone_thickness_some_wells():
"""Import some wells and get the zone thicknesses"""
wlist = []
for w in glob.glob(wfiles2):
wlist.append(Well(w, zonelogname='Zonelog'))
logger.info('Imported well {}'.format(w))
mypoints = Points()
nwell = mypoints.from_wells(wlist, tops=False, zonelist=(1, 22))
print(nwell, '\n', mypoints.dataframe)
mypoints.to_file('TMP/zpoints_w_so622.rmsasc',
fformat='rms_attr',
attributes=['WellName', 'ZoneName'],
pfilter={'ZoneName': ['SO622']})
# filter, for backwards compatibility
mypoints.to_file('TMP/zpoints_w_so622_again.rmsasc',
fformat='rms_attr',
attributes=['WellName', 'ZoneName'],
filter={'ZoneName': ['SO622']})
logger.info('Number of well made to tops: {}'.format(nwell))
def test_get_faciesfraction_some_wells(testpath, tmp_path):
"""Import some wells and get the facies fractions per zone, for
wells < 70 degrees inclination.
"""
wlist = [
Well(wpath, zonelogname="Zonelog")
for wpath in glob.glob(str(testpath / WFILES2))
]
mypoints = Points()
facname = "Facies"
fcode = [1]
mypoints.dfrac_from_wells(wlist,
facname,
fcode,
zonelist=None,
incl_limit=70)
# rename column
mypoints.zname = "FACFRAC"
myquery = 'WELLNAME == "OP_1" and ZONE == 1'
usedf = mypoints.dataframe.query(myquery)
assert abs(usedf[mypoints.zname].values[0] - 0.86957) < 0.001
mypoints.to_file(
tmp_path / "ffrac_per_zone.rmsasc",
fformat="rms_attr",
attributes=["WELLNAME", "ZONE"],
pfilter={"ZONE": [1]},
)
def test_get_zone_thickness_some_wells():
"""Import some wells and get the zone thicknesses"""
wlist = []
for w in glob.glob(str(WFILES2)):
wlist.append(Well(w, zonelogname="Zonelog"))
logger.info("Imported well {}".format(w))
mypoints = Points()
nwell = mypoints.from_wells(wlist, tops=False, zonelist=(1, 22))
print(nwell, "\n", mypoints.dataframe)
mypoints.to_file(
"TMP/zpoints_w_so622.rmsasc",
fformat="rms_attr",
attributes=["WellName", "ZoneName"],
pfilter={"ZoneName": ["SO622"]},
)
# filter, for backwards compatibility
mypoints.to_file(
"TMP/zpoints_w_so622_again.rmsasc",
fformat="rms_attr",
attributes=["WellName", "ZoneName"],
filter={"ZoneName": ["SO622"]},
)
logger.info("Number of well made to tops: {}".format(nwell))
def test_get_zone_tops_some_wells():
"""Import some well and get the zone tops"""
wlist = []
for w in glob.glob(str(WFILES2)):
wlist.append(Well(w, zonelogname="Zonelog"))
logger.info("Imported well {}".format(w))
mypoints = Points()
nwell = mypoints.from_wells(wlist)
print(mypoints.dataframe)
logger.info("Number of well made to tops: {}".format(nwell))
mypoints.to_file(
"TMP/points_w1_many.rmsasc",
fformat="rms_attr",
attributes=["WellName", "TopName"],
)
mypoints.to_file(
"TMP/points_w1_many.rmswpicks",
fformat="rms_wellpicks",
wcolumn="WellName",
hcolumn="TopName",
)
def test_get_zone_tops_one_well_w_undef():
"""Import a well and get the zone tops, include undef transition"""
wlist = []
for w in glob.glob(wfiles1):
wlist.append(Well(w, zonelogname="Zonelog"))
logger.info("Imported well {}".format(w))
mypoints = Points()
nwell = mypoints.from_wells(wlist, use_undef=True)
print(mypoints.dataframe)
logger.info("Number of well made to tops: {}".format(nwell))
mypoints.to_file(
"TMP/points_w1_w_undef.rmsasc",
fformat="rms_attr",
attributes=["WellName", "TopName"],
)
mypoints.to_file(
"TMP/points_w1_w_undef.rmswpicks",
fformat="rms_wellpicks",
wcolumn="WellName",
hcolumn="TopName",
)
def test_operation_inclusive_polygon():
pol = Polygons(SMALL_POLY_INNER)
# We place a point on the edge of a polygon
poi = Points([(4.0, 4.0, 0.0)])
poi.operation_polygons(pol, value=1, opname="eli", inside=True)
assert len(poi.dataframe) == 0
# We place a point on a corner of a polygon
poi = Points([(3.0, 3.0, 0.0)])
poi.operation_polygons(pol, value=1, opname="eli", inside=True)
assert len(poi.dataframe) == 0
def test_custom_points():
"""Make points from list of tuples."""
plist = [(234, 556, 11), (235, 559, 14), (255, 577, 12)]
mypoints = Points(plist)
x0 = mypoints.dataframe["X_UTME"].values[0]
z2 = mypoints.dataframe["Z_TVDSS"].values[2]
assert x0 == 234
assert z2 == 12
def test_map_plot_with_points():
"""Test as simple map plot with underlying points."""
mysurf = RegularSurface()
mysurf.from_file(SFILE1)
mypoints = Points()
mypoints.from_surface(mysurf)
df = mypoints.dataframe.copy()
df = df[::20]
mypoints.dataframe = df
# just make the instance, with a lot of defaults behind the scene
myplot = Map()
myplot.canvas(title="My o my")
myplot.colormap = "gist_ncar"
myplot.plot_surface(mysurf)
myplot.plot_points(mypoints)
myplot.savefig("TMP/map_with_points.png")
def test_get_faciesfraction_some_wells():
"""Import some wells and get the facies fractions per zone, for
wells < 70 degrees inclination.
"""
wlist = []
for w in sorted(glob.glob(wfiles2)):
wlist.append(Well(w, zonelogname='Zonelog'))
logger.info('Imported well {}'.format(w))
mypoints = Points()
facname = 'Facies'
fcode = [1]
nwell = mypoints.dfrac_from_wells(wlist,
facname,
fcode,
zonelist=None,
incl_limit=70)
# rename column
mypoints.zname = 'FACFRAC'
logger.info('Number of wells is %s, DATAFRAME:\n, %s', nwell,
mypoints.dataframe)
myquery = 'WELLNAME == "OP_1" and ZONE == 1'
usedf = mypoints.dataframe.query(myquery)
assert abs(usedf[mypoints.zname].values[0] - 0.86957) < 0.001
mypoints.to_file('TMP/ffrac_per_zone.rmsasc',
fformat='rms_attr',
attributes=['WELLNAME', 'ZONE'],
pfilter={'ZONE': [1]})
def test_get_faciesfraction_some_wells():
"""Import some wells and get the facies fractions per zone, for
wells < 70 degrees inclination.
"""
wlist = []
for w in sorted(glob.glob(str(WFILES2))):
wlist.append(Well(w, zonelogname="Zonelog"))
logger.info("Imported well {}".format(w))
mypoints = Points()
facname = "Facies"
fcode = [1]
nwell = mypoints.dfrac_from_wells(
wlist, facname, fcode, zonelist=None, incl_limit=70
)
# rename column
mypoints.zname = "FACFRAC"
logger.info("Number of wells is %s, DATAFRAME:\n, %s", nwell, mypoints.dataframe)
myquery = 'WELLNAME == "OP_1" and ZONE == 1'
usedf = mypoints.dataframe.query(myquery)
assert abs(usedf[mypoints.zname].values[0] - 0.86957) < 0.001
mypoints.to_file(
"TMP/ffrac_per_zone.rmsasc",
fformat="rms_attr",
attributes=["WELLNAME", "ZONE"],
pfilter={"ZONE": [1]},
)
def test_check_multi_point_multi_polyon_inside_op():
pol = Polygons(SMALL_POLY_INNER + LARGE_POLY_SHIFTED)
# Two points in small cube, one in large cube, one outside
poi = Points([(4.0, 4.0, 0.0), (4.5, 4.0, 0.0), (7.0, 7.0, 0.0),
(20.0, 5.0, 0.0)])
assert len(poi.dataframe) == 4
poi.operation_polygons(pol, value=1, opname="eli", inside=True)
assert len(poi.dataframe) == 1
poi = Points([(4.0, 4.0, 0.0), (4.5, 4.0, 0.0), (7.0, 7.0, 0.0),
(20.0, 5.0, 0.0)])
poi.operation_polygons(pol, value=1, opname="eli", inside=False)
assert len(poi.dataframe) == 0
def test_create_pointset(points):
"""Create randomly generated points and verify content."""
pointset = Points(points)
points = np.array(points)
assert len(points) == pointset.nrow
np.testing.assert_array_almost_equal(pointset.dataframe["X_UTME"],
points[:, 0])
np.testing.assert_array_almost_equal(pointset.dataframe["Y_UTMN"],
points[:, 1])
np.testing.assert_array_almost_equal(pointset.dataframe["Z_TVDSS"],
points[:, 2])
