def test_texture():
try:
dirname, _ = os.path.split(os.path.abspath(__file__))
png_file = os.path.sep.join(dirname.split(os.path.sep) + ['temp.png'])
s = ['110010010011', '101011010100', '110010110101', '100010010011']
s = [[int(v) for v in val] for val in s]
f = open(png_file, 'wb')
w = png.Writer(len(s[0]), len(s), greyscale=True, bitdepth=16)
w.write(f, s)
f.close()
proj = omf.Project()
surf = omf.SurfaceElement(
geometry=omf.SurfaceGridGeometry(
tensor_u=[1., 1., 1., 1., 1.],
tensor_v=[1., 1., 1., 1., 1.],
),
textures=[
omf.ImageTexture(
origin=[0., 0, 0],
axis_u=[5., 0, 0],
axis_v=[0., 5, 0],
image=png_file,
)
],
)
proj.elements = [surf]
proj.validate()
view = get_view_from_proj(proj)
view.validate()
assert len(view.contents) == 3
finally:
os.remove(png_file)
def test_lines(subtype, options_class):
proj = omf.Project(origin=[5., 5, 5])
lines = omf.LineSetElement(
name='my elem',
description='my desc',
geometry=omf.LineSetGeometry(
vertices=[[i / 3, i / 4, i / 5] for i in range(10)],
segments=[[i, i + 1] for i in range(9)],
origin=[5., 5, 5],
),
subtype=subtype,
color='red',
)
proj.elements = [lines]
proj.validate()
view = get_view_from_proj(proj)
view.validate()
assert len(view.contents) == 3
lineset = find(view, spatial.ElementLineSet)
defaults = lineset.defaults.serialize()
assert defaults['__class__'] == options_class
assert defaults['color']['value'] == '#FF0000'
assert list(lineset.vertices.array[0]) == [10., 10, 10]
assert lineset.name == 'my elem'
assert lineset.description == 'my desc'
def test_volume_grid():
proj = omf.Project(origin=[5., 5, 5])
vol = omf.VolumeElement(
name='my elem',
description='my desc',
geometry=omf.VolumeGridGeometry(
tensor_u=[1., 1., 1., 1., 1.],
tensor_v=[1., 1., 1., 1., 1.],
tensor_w=[1., 1., 1., 1., 1.],
origin=[5., 5, 5],
),
color='red',
)
proj.elements = [vol]
proj.validate()
view = get_view_from_proj(proj)
view.validate()
assert len(view.contents) == 1
vol = find(view, spatial.ElementVolumeGrid)
defaults = vol.defaults.serialize()
assert defaults['__class__'] == 'OptionsBlockModel'
assert defaults['color']['value'] == '#FF0000'
assert list(vol.origin) == [10., 10, 10]
assert vol.name == 'my elem'
assert vol.description == 'my desc'
def to_omf(self, filename=None):
import omf
project = omf.Project(
name=self.title or '',
description=self.description or '',
elements=[res._to_omf() for res in self.resources],
)
if filename is not None:
omf.OMFWriter(project, filename)
return project
def test_project():
proj = omf.Project(
name='my proj',
description='my desc',
)
proj.validate()
view = get_view_from_proj(proj)
view.validate()
assert view.name == 'my proj'
assert view.description == 'my desc'
assert view.contents == []
def test_data():
arr = [float(val) for val in range(25)]
arr_int = [int(val % 4) for val in range(25)]
proj = omf.Project()
surf = omf.SurfaceElement(
geometry=omf.SurfaceGridGeometry(
tensor_u=[1., 1., 1., 1., 1.],
tensor_v=[1., 1., 1., 1., 1.],
),
data=[
omf.ScalarData(name='my data',
description='my desc',
location='faces',
array=arr,
colormap=omf.ScalarColormap(
gradient=[
'red',
'blue',
'black',
'orange',
] * 32,
limits=[min(arr), max(arr)],
)),
omf.MappedData(
name='my data',
description='my desc',
location='faces',
array=arr_int,
legends=[
omf.Legend(values=[
'yellow',
'black',
'brown',
'green',
], ),
omf.Legend(values=[
'yellow!',
'black!!',
'brown!!!',
'green!!!!',
], ),
],
)
],
)
proj.elements = [surf]
proj.validate()
view = get_view_from_proj(proj)
view.validate()
assert len(view.contents) == 9
def view_to_omf(view, filename='view.omf'):
"""Save a View as an OMF file
All object types, data/texture types, and legends are supported. Only
custom colormaps are unsupported due to limitations of OMF v1.
Input:
**view** - Valid View instance; see
:class:`lfview.resources.manifests.manifests.View`
**filename** - Path and filename for output OMF file (default: 'view.omf')`
"""
omf_project = omf.Project(
name=view.name or '',
description=view.description or '',
elements=[elem.to_omf() for elem in view.elements],
)
omf.OMFWriter(omf_project, filename)
def test_surfaces():
proj = omf.Project(origin=[5., 5, 5])
surf_0 = omf.SurfaceElement(
name='my elem',
description='my desc',
geometry=omf.SurfaceGeometry(
vertices=[[i / 3, i / 4, i / 5] for i in range(10)],
triangles=[[i, i + 1, i + 2] for i in range(8)],
origin=[5., 5, 5],
),
color='red',
)
surf_1 = omf.SurfaceElement(
name='my elem',
description='my desc',
geometry=omf.SurfaceGridGeometry(
tensor_u=[1., 1., 1., 1., 1.],
tensor_v=[1., 1., 1., 1., 1.],
offset_w=[1.] * 36,
origin=[5., 5, 5],
),
color='red',
)
proj.elements = [surf_0, surf_1]
proj.validate()
view = get_view_from_proj(proj)
view.validate()
assert len(view.contents) == 5
for cls in (spatial.ElementSurface, spatial.ElementSurfaceGrid):
surface = find(view, cls)
defaults = surface.defaults.serialize()
assert defaults['__class__'] == 'OptionsSurface'
assert defaults['color']['value'] == '#FF0000'
assert surface.name == 'my elem'
assert surface.description == 'my desc'
assert list(find(
view, spatial.ElementSurface).vertices.array[0]) == [10., 10, 10]
assert list(find(view, spatial.ElementSurfaceGrid).origin) == [10., 10, 10]
def test_points():
proj = omf.Project(origin=[5., 5, 5])
pts = omf.PointSetElement(
name='my elem',
description='my desc',
geometry=omf.PointSetGeometry(
vertices=[[i / 3, i / 4, i / 5] for i in range(10)],
origin=[5., 5, 5],
),
color='red',
)
proj.elements = [pts]
proj.validate()
view = get_view_from_proj(proj)
view.validate()
assert len(view.contents) == 2
pointset = find(view, spatial.ElementPointSet)
defaults = pointset.defaults.serialize()
assert defaults['__class__'] == 'OptionsPoints'
assert defaults['color']['value'] == '#FF0000'
assert list(pointset.vertices.array[0]) == [10., 10, 10]
assert pointset.name == 'my elem'
assert pointset.description == 'my desc'
import unittest
import os
import shutil
import tempfile
import numpy as np
import omf
import omfvista
import pyvista
PROJECT = omf.Project(name='Test project',
description='Just some assorted elements')
POINTSET = omf.PointSetElement(
name='Random Points',
description='Just random points',
geometry=omf.PointSetGeometry(vertices=np.random.rand(100, 3)),
data=[
omf.ScalarData(name='rand data',
array=np.random.rand(100),
location='vertices'),
omf.ScalarData(name='More rand data',
array=np.random.rand(100),
location='vertices')
],
# textures=[
# omf.ImageTexture(
# name='test image',
# image='test_image.png',
# origin=[0, 0, 0],
# axis_u=[1, 0, 0],
# axis_v=[0, 1, 0]
land_surface.textures = [geo_aer, topo_map, geo_no_aer]
land_surface.validate()
###############################################################################
topo = omfvista.wrap(land_surface)
###############################################################################
topo.plot(show_edges=False, texture=True)
###############################################################################
# And now create an OMF project file for the surfaces
proj = omf.Project(
name='FORGE Surfaces',
description=
'All surfaces for the 2019 FORGE Geothermal Student Competition ')
proj.elements = [
land_surface,
temp_225c,
temp_175c,
opal_mound_fault,
negro_mag_fault,
top_granitoid,
]
proj.validate()
###############################################################################
# Save the GIS project file
# Load the shape files
shapes = gdc19.read_shape_file_to_omf(gdc19.get_shp_path('FORGE_Outline'),
topo_points=topo.points)
shapes
###############################################################################
boundary = shapes[0]
boundary.name = 'boundary'
boundary.validate()
###############################################################################
omfvista.wrap(boundary).plot(show_edges=False)
###############################################################################
# Now save out the GIS data to an OMF project file
proj = omf.Project(
name='FORGE GIS Data',
description=
'All GIS data for the 2019 FORGE Geothermal Student Competition ')
proj.elements = [boundary]
proj.validate()
###############################################################################
# Save the GIS project file
omf.OMFWriter(proj, gdc19.get_project_path('gis.omf'))
(ncz, ncy, ncx), order='F').ravel(),
location='cells'),
],
)
temp_model.validate()
###############################################################################
# And one final sanity check
omfvtk.wrap(temp_model).clip_box(gdc19.get_roi_bounds(),
invert=False).plot(cmap='coolwarm')
###############################################################################
# Write the data
# ++++++++++++++
proj = omf.Project(
name='FORGE Temperature Data',
description=
'All temperature data/models for the 2019 FORGE Geothermal Student Competition '
)
proj.elements = [temperature, temp_model]
proj.validate()
###############################################################################
# Save the temperature project file
omf.OMFWriter(proj, gdc19.get_project_path('temperature.omf'))
def test_doc_ex(self):
dirname, _ = os.path.split(os.path.abspath(__file__))
pngfile = os.path.sep.join(dirname.split(os.path.sep)[:-1] +
['docs', 'images', 'PointSetGeometry.png'])
proj = omf.Project(
name='Test project',
description='Just some assorted elements'
)
pts = omf.PointSetElement(
name='Random Points',
description='Just random points',
geometry=omf.PointSetGeometry(
vertices=np.random.rand(100, 3)
),
data=[
omf.ScalarData(
name='rand data',
array=np.random.rand(100),
location='vertices'
),
omf.ScalarData(
name='More rand data',
array=np.random.rand(100),
location='vertices'
)
],
textures=[
omf.ImageTexture(
name='test image',
image=pngfile,
origin=[0, 0, 0],
axis_u=[1, 0, 0],
axis_v=[0, 1, 0]
),
omf.ImageTexture(
name='test image',
image=pngfile,
origin=[0, 0, 0],
axis_u=[1, 0, 0],
axis_v=[0, 0, 1]
)
],
color='green'
)
lin = omf.LineSetElement(
name='Random Line',
geometry=omf.LineSetGeometry(
vertices=np.random.rand(100, 3),
segments=np.floor(np.random.rand(50, 2)*100).astype(int)
),
data=[
omf.ScalarData(
name='rand vert data',
array=np.random.rand(100),
location='vertices'
),
omf.ScalarData(
name='rand segment data',
array=np.random.rand(50),
location='segments'
)
],
color='#0000FF'
)
surf = omf.SurfaceElement(
name='trisurf',
geometry=omf.SurfaceGeometry(
vertices=np.random.rand(100, 3),
triangles=np.floor(np.random.rand(50, 3)*100).astype(int)
),
data=[
omf.ScalarData(
name='rand vert data',
array=np.random.rand(100),
location='vertices'
),
omf.ScalarData(
name='rand face data',
array=np.random.rand(50),
location='faces'
)
],
color=[100, 200, 200]
)
grid = omf.SurfaceElement(
name='gridsurf',
geometry=omf.SurfaceGridGeometry(
tensor_u=np.ones(10).astype(float),
tensor_v=np.ones(15).astype(float),
origin=[50., 50., 50.],
axis_u=[1., 0, 0],
axis_v=[0, 0, 1.],
offset_w=np.random.rand(11, 16).flatten()
),
data=[
omf.ScalarData(
name='rand vert data',
array=np.random.rand(11, 16).flatten(),
location='vertices'
),
omf.ScalarData(
name='rand face data',
array=np.random.rand(10, 15).flatten(order='f'),
location='faces'
)
],
textures=[
omf.ImageTexture(
name='test image',
image=pngfile,
origin=[2., 2., 2.],
axis_u=[5., 0, 0],
axis_v=[0, 2., 5.]
)
]
)
vol = omf.VolumeElement(
name='vol',
geometry=omf.VolumeGridGeometry(
tensor_u=np.ones(10).astype(float),
tensor_v=np.ones(15).astype(float),
tensor_w=np.ones(20).astype(float),
origin=[10., 10., -10]
),
data=[
omf.ScalarData(
name='Random Data',
location='cells',
array=np.random.rand(10, 15, 20).flatten()
)
]
)
proj.elements = [pts, lin, surf, grid, vol]
assert proj.validate()
serial_file = os.path.sep.join([dirname, 'out.omf'])
omf.OMFWriter(proj, serial_file)
reader = omf.OMFReader(serial_file)
new_proj = reader.get_project()
assert new_proj.validate()
assert str(new_proj.elements[3].textures[0].uid) == \
str(proj.elements[3].textures[0].uid)
del reader
os.remove(serial_file)