def test_RenameSource(self):
source = simple.Sphere(guiName='oldName')
simple.SetActiveSource(source)
simple.RenameSource('newName')
# changing the source name should unregister the old name
self.assertEqual(None, self.pxm.GetProxy('sources', 'oldName'))
self.assertEqual(source, self.pxm.GetProxy('sources', 'newName'))
# renaming as the current name should not unregister the source
simple.RenameSource('newName')
self.assertEqual(source, self.pxm.GetProxy('sources', 'newName'))
def plotTurbine(hubxy, basexy, turbR, NacYaw, name):
# Some constants
towerres = 100 # Resolution for tower
nacellelength = 7.5
# --- Plot the tower ---
towerheight = hubxy[2] - basexy[2]
plotTower(basexy, towerheight, name)
# towerline = pvs.Line()
# towerline.Point1 = basexy
# towerline.Point2 = np.array(basexy) + towerheight*np.array([0,0,1])
# towerline.Resolution = towerRes
# pvs.RenameSource(name+'_tower', towerline)
# --- Plot the nacelle ---
plotNacelle(basexy, towerheight, NacYaw, name)
# --- Plot the rotor disk ---
plotRotorDisk(hubxy, turbR, NacYaw, name)
# --- Group the datasets together ---
turbine0_rotordisk = pvs.FindSource(name + '_rotordisk')
turbine0_nacelle = pvs.FindSource(name + '_nacelle')
turbine0_tower = pvs.FindSource(name + '_tower')
groupDatasets1 = pvs.GroupDatasets(
Input=[turbine0_rotordisk, turbine0_nacelle, turbine0_tower])
pvs.RenameSource(name + '_allobjects', groupDatasets1)
return
def openRelativeFile(self, relativePath):
fileToLoad = []
if type(relativePath) == list:
for file in relativePath:
fileToLoad.append(os.path.join(self.baseDir, file))
else:
fileToLoad.append(os.path.join(self.baseDir, relativePath))
reader = simple.OpenDataFile(fileToLoad)
name = fileToLoad[0].split("/")[-1]
if len(name) > 15:
name = name[:15] + '*'
simple.RenameSource(name, reader)
simple.Show()
simple.Render()
simple.ResetCamera()
# Add node to pipeline
self.pipeline.addNode('0', reader.GetGlobalIDAsString())
# Create LUT if need be
self.lutManager.registerFieldData(reader.GetPointDataInformation())
self.lutManager.registerFieldData(reader.GetCellDataInformation())
return helper.getProxyAsPipelineNode(reader.GetGlobalIDAsString(),
self.lutManager)
def _rename(self, name):
assert self._data is not None
try:
ps.RenameSource(name, self._data)
self._name = name
except Exception as e:
print("Could not rename to {}".format(name))
print(e)
def load(self, path):
vtk = ps.LegacyVTKReader(FileNames=[str(path)])
ps.RenameSource(" ", vtk)
name = self._get_postfix(path)
data = self._threshold_vtk(vtk, name)
self._data = data
self._rename(name)
self.show()
def makeLineOfSight(p1, p2, resolution, name=''):
# create a new 'Line'
line1 = pvs.Line()
# Properties modified on line1
line1.Point1 = p1
line1.Point2 = p2
line1.Resolution = resolution
if (len(name) > 0):
# rename source object
pvs.RenameSource(name, line1)
return line1
def setupCalculator(source, arrayName, color, fctString, renderView):
calculator = smp.Calculator(Input=source)
smp.RenameSource(getCalculatorName(arrayName), calculator)
calculator.Function = ''
calculator.ResultArrayName = arrayName
calculator.Function = fctString
calculatorDisplay = smp.GetDisplayProperties(calculator, view=renderView)
calculatorDisplay.SetRepresentationType('3D Glyphs')
calculatorDisplay.DiffuseColor = color
calculatorDisplay.Orient = 1
calculatorDisplay.SelectOrientationVectors = 'Orientation(AxisAngle)'
calculatorDisplay.SelectOrientationVectors = arrayName
def makeSamplePlane(cornerpt, edge1, edge2, Nx, Ny, name=''):
# create a new 'Plane'
plane1 = pvs.Plane()
# Properties modified on plane1
plane1.Origin = cornerpt
plane1.Point1 = cornerpt + edge1
plane1.Point2 = cornerpt + edge2
plane1.XResolution = Nx
plane1.YResolution = Ny
if (len(name) > 0):
# rename source object
pvs.RenameSource(name, plane1)
return plane1
def openFile(self, path):
reader = simple.OpenDataFile(path)
simple.RenameSource( path.split("/")[-1], reader)
simple.Show()
simple.Render()
simple.ResetCamera()
# Add node to pipeline
self.pipeline.addNode('0', reader.GetGlobalIDAsString())
# Create LUT if need be
self.lutManager.registerFieldData(reader.GetPointDataInformation())
self.lutManager.registerFieldData(reader.GetCellDataInformation())
return helper.getProxyAsPipelineNode(reader.GetGlobalIDAsString(), self.lutManager)
def plotRotorDisk(hubxy, turbR, NacYaw, name):
# Define some constants
rotorres = 30
rotorthick = 1
# create a new 'Cylinder'
rotordisk = pvs.Cylinder()
rotordisk.Height = rotorthick
rotordisk.Resolution = rotorres
rotordisk.Radius = turbR
#rotordisk.Center = hubxy
# create a new 'Transform'
rotortrans = pvs.Transform(Input=rotordisk)
rotortrans.Transform = 'Transform'
rotortrans.Transform.Translate = hubxy
rotortrans.Transform.Rotate = [0.0, 0.0, 90 + NacYaw]
pvs.RenameSource(name + '_rotordisk', rotortrans)
return
def plotNacelle(basexy, height, NacYaw, name):
# Define some constants
nacellewidth = 5
nacellelength = 15
# create a new nacelle
nacellebox = pvs.Box()
nacellebox.XLength = nacellelength
nacellebox.YLength = nacellewidth
nacellebox.ZLength = nacellewidth
nacellebox.Center = [0.5 * nacellelength, 0,
0] #[basexy[0], basexy[1], basexy[2]+height]
transnacelle = pvs.Transform(Input=nacellebox)
transnacelle.Transform.Translate = [
basexy[0], basexy[1], basexy[2] + height
] #[0.3*nacellelength, 0, 0]
transnacelle.Transform.Rotate = [0.0, 0.0, NacYaw]
pvs.RenameSource(name + '_nacelle', transnacelle)
return
def plotTower(basexy, height, name):
# Define some constants
towerres = 30
towerR = 1.5
# create a new 'Cylinder'
towercyl = pvs.Cylinder()
# Properties modified on cylinder1
towercyl.Height = height
towercyl.Resolution = towerres
towercyl.Radius = towerR
towercyl.Center = [0, 0, 0]
# create a new 'Transform'
transcyl = pvs.Transform(Input=towercyl)
transcyl.Transform = 'Transform'
# Properties modified on transform1.Transform
transcyl.Transform.Translate = [
basexy[0], basexy[1], basexy[2] + 0.5 * height
]
transcyl.Transform.Rotate = [90.0, 0.0, 0.0]
#towercyl.RenameSource(name+'_tower_temp', towercyl)
pvs.RenameSource(name + '_tower', transcyl)
return
def main():
import paraview.simple as para
version_major = para.servermanager.vtkSMProxyManager.GetVersionMajor()
source = para.GetActiveSource()
renderView1 = para.GetRenderView()
atoms = para.Glyph(
Input=source,
GlyphType='Sphere',
Scalars='radii',
ScaleMode='scalar',
)
para.RenameSource('Atoms', atoms)
atomsDisplay = para.Show(atoms, renderView1)
if version_major <= 4:
atoms.SetScaleFactor = 0.8
atomicnumbers_PVLookupTable = para.GetLookupTableForArray(
'atomic numbers', 1)
atomsDisplay.ColorArrayName = ('POINT_DATA', 'atomic numbers')
atomsDisplay.LookupTable = atomicnumbers_PVLookupTable
else:
atoms.ScaleFactor = 0.8
para.ColorBy(atomsDisplay, 'atomic numbers')
atomsDisplay.SetScalarBarVisibility(renderView1, True)
para.Render()
def RequestData():
# V.2019.031
import sys
sys.path.insert(0, r'EMC_SRC_PATH')
import paraview.simple as simple
import numpy as np
import csv
import os
import datetime
from vtk.util import numpy_support as nps
import IrisEMC_Paraview_Lib as Lib
import IrisEMC_Paraview_Utils as Utils
import urllib.parse
pts = vtk.vtkPoints()
Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End = Lib.get_area(
Area, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End)
label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f, depth:%0.1f-%0.1f)" % (
Lib.areaValues[Area], Latitude_Begin, Latitude_End, Longitude_Begin,
Longitude_End, Depth_Begin, Depth_End)
# make sure we have input files
if not Time_End.strip():
Time_End = datetime.datetime.today().strftime('%Y-%m-%d')
query = Lib.earthquakeQuery % (Time_Begin, Time_End, Magnitude_Begin,
Magnitude_End, Depth_Begin, Depth_End,
Latitude_Begin, Latitude_End,
Longitude_Begin, Longitude_End)
Alternate_FileName = Alternate_FileName.strip()
if len(Alternate_FileName) <= 0:
eqFile = Lib.query2filename(query, url=Lib.earthquakeKeys[Data_Source])
query = '?'.join([Lib.earthquakeKeys[Data_Source], query])
fileFound, address, source = Lib.find_file(eqFile,
loc=r'EMC_EARTHQUAKES_PATH',
query=query)
else:
fileFound, address, source = Lib.find_file(Alternate_FileName,
loc=r'EMC_EARTHQUAKES_PATH')
if not fileFound:
raise Exception(
'earthquake catalog file "' + address +
'" not found! Please provide the full path or UR for the file. Aborting.'
)
(params, lines) = Lib.read_geocsv(address)
pdo = self.GetOutput() # vtkPoints
column_keys = Lib.columnKeys
for key in list(Lib.columnKeys.keys()):
if key in list(params.keys()):
column_keys[key] = params[key]
origin = None
if 'source' in params:
origin = params['source']
this_label = urllib.parse.urlparse(origin).netloc
else:
try:
this_label = urllib.parse.urlparse(Alternate_FileName).netloc
except:
this_label = Alternate_FileName
header = params['header']
lat_index = None
lon_index = None
depth_index = None
mag_index = None
time_index = None
for index, value in enumerate(header):
if value.strip().lower() == column_keys['longitude_column'].lower():
lon_index = index
elif value.strip().lower() == column_keys['latitude_column'].lower():
lat_index = index
elif value.strip().lower() == column_keys['depth_column'].lower():
depth_index = index
elif value.strip().lower() == column_keys['magnitude_column'].lower():
mag_index = index
elif value.strip().lower() == column_keys['time_column'].lower():
time_index = index
scalar_m = vtk.vtkFloatArray()
scalar_m.SetNumberOfComponents(1)
scalar_m.SetName("magnitude")
scalar_d = vtk.vtkFloatArray()
scalar_d.SetNumberOfComponents(1)
scalar_d.SetName("depth")
scalar_t = vtk.vtkLongArray()
scalar_t.SetNumberOfComponents(1)
scalar_t.SetName("year-month")
lat = []
lon = []
depth = []
mag = []
time = []
frame_tag = Frame_Tag.strip()
frame = dict()
frame_single = dict()
frame_key = Frame_Length_sec
for i in range(len(lines)):
line = lines[i].strip()
values = line.strip().split(params['delimiter'].strip())
lat_value = float(values[lat_index])
lat.append(lat_value)
lon_value = float(values[lon_index])
lon.append(lon_value)
depth_value = float(values[depth_index])
depth.append(depth_value)
mag_value = float(values[mag_index])
mag.append(mag_value)
time_value = values[time_index]
time.append(time_value)
# check conditions again in case data came from a file
if not (float(Latitude_Begin) <= lat_value <= float(Latitude_End)
and float(Longitude_Begin) <= lon_value <= float(Longitude_End)
and float(Depth_Begin) <= depth_value <= float(Depth_End) and
float(Magnitude_Begin) <= mag_value <= float(Magnitude_End)):
continue
if Latitude_Begin <= lat[-1] <= Latitude_End and Longitude_Begin <= lon[
-1] <= Longitude_End:
x, y, z = Lib.llz2xyz(lat[-1], lon[-1], depth[-1])
pts.InsertNextPoint(x, y, z)
scalar_m.InsertNextValue(mag[-1])
scalar_d.InsertNextValue(depth[-1])
day_value = Utils.datetime_to_int(time[-1], level='day')
scalar_t.InsertNextValue(day_value)
if frame_tag:
frame_time = int(
Utils.datetime_to_float(time_value) -
Utils.datetime_to_float(Time_Begin))
if frame_time < frame_key:
frame[str(frame_key)] = '%s\n%f,%f,%f,%0.2f,%0.1f,%d' % (
frame[str(frame_key)], x, y, z, depth[-1], mag[-1],
day_value)
if frame_time >= frame_key - Frame_Length_sec:
frame_single[str(
frame_key)] = '%s\n%f,%f,%f,%0.2f,%0.1f,%d' % (
frame_single[str(frame_key)], x, y, z,
depth[-1], mag[-1], day_value)
else:
frame_key += Frame_Length_sec
frame[str(frame_key)] = '%f,%f,%f,%0.2f,%0.1f,%d' % (
x, y, z, depth[-1], mag[-1], day_value)
frame_single[str(
frame_key)] = '%f,%f,%f,%0.2f,%0.1f,%d' % (
x, y, z, depth[-1], mag[-1], day_value)
# save animation frames
if frame_tag:
Utils.remove_files(
os.path.join('EMC_EQ_ANIMATION_PATH', '%s_*.txt') % frame_tag)
key_list = [int(x) for x in list(frame.keys())]
key_list.sort()
key0 = key_list[0]
eq_list = 'X,Y,Z,Depth,Mag,Year-Month'
for i, key in enumerate(key_list):
eq_list = '%s\n%s' % (eq_list, frame[str(key)])
with open(
os.path.join('EMC_EQ_ANIMATION_PATH',
'%s_%012d.txt' % (frame_tag, key - key0)),
'w') as fp:
fp.write('%s' % eq_list)
eq = 'X,Y,Z,Depth,Mag,Year-Month\n%s' % frame_single[str(key)]
with open(
os.path.join(
'EMC_EQ_ANIMATION_PATH',
'%s_single_%012d.txt' % (frame_tag, key - key0)),
'w') as fp:
fp.write('%s' % eq)
pdo.SetPoints(pts)
pdo.GetPointData().AddArray(scalar_m)
pdo.GetPointData().AddArray(scalar_d)
pdo.GetPointData().AddArray(scalar_t)
if len(this_label.strip()) > 0:
simple.RenameSource(' '.join([
'Earthquake locations:', 'from',
this_label.strip(),
label2.strip()
]))
# store metadata
field_data = pdo.GetFieldData()
field_data.AllocateArrays(3) # number of fields
data = vtk.vtkFloatArray()
data.SetName('Latitude\nRange (deg)')
data.InsertNextValue(min(lat))
data.InsertNextValue(max(lat))
field_data.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Longitude\nRange (deg)')
data.InsertNextValue(min(lon))
data.InsertNextValue(max(lon))
field_data.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Depth\nRange (km)')
data.InsertNextValue(min(depth))
data.InsertNextValue(max(depth))
field_data.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Magnitude\nRange')
data.InsertNextValue(min(mag))
data.InsertNextValue(max(mag))
field_data.AddArray(data)
data = vtk.vtkIntArray()
data.SetName('Max. Event\nCount')
data.InsertNextValue(len(mag))
field_data.AddArray(data)
data = vtk.vtkStringArray()
data.SetName('Start Date')
data.InsertNextValue(Time_Begin)
field_data.AddArray(data)
data = vtk.vtkStringArray()
data.SetName('End Date')
data.InsertNextValue(Time_End)
field_data.AddArray(data)
data = vtk.vtkStringArray()
data.SetName('Source')
if origin is not None:
data.InsertNextValue(origin)
data.InsertNextValue(source)
field_data.AddArray(data)
pdo.SetFieldData(field_data)
def RequestData():
# R.0.2018.080
import sys
import paraview.simple as simple
import numpy as np
import csv
import os
sys.path.insert(0, "EMC_SRC_PATH")
import IrisEMC_Paraview_Lib as lib
import urlparse
if len(Alternate_FileName.strip()) > 0:
FileName = Alternate_FileName
Label = ' '.join(['Boundary',lib.fileName(Alternate_FileName).strip()])
else:
FileName = lib.boundaryKeys[DataFile]
Label = lib.boundaryValues[DataFile]
# make sure we have input files
fileFound,address,source = lib.findFile(FileName,loc='EMC_BOUNDARIES_PATH')
if not fileFound:
raise Exception('boundary file "'+address+'" not found! Please provide the full path or UR for the file. Aborting.')
(params,lines) = lib.readGcsv(address)
pdo = self.GetOutput() # vtkPolyData
Latitude_Begin,Latitude_End,Longitude_Begin,Longitude_End = lib.getArea(Area,Latitude_Begin,Latitude_End,Longitude_Begin,Longitude_End)
Label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f)"%(lib.areaValues[Area],Latitude_Begin,Latitude_End,Longitude_Begin,Longitude_End)
x = []
y = []
z = []
segments = []
pointIndex = -1
thisSegment = []
order = 1
# depth is positive down
Boundary_Elevation *= -1
column_keys = lib.columnKeys
for key in lib.columnKeys.keys():
if key in params.keys():
column_keys[key] = params[key].strip()
delimiter = params['delimiter'].strip()
gaps = params['gaps'].strip()
latIndex = 0
lonIndex = 1
if 'source' in params.keys():
try:
netloc = urlparse.urlparse(params['source']).netloc
except:
netloc = params['source']
if len(netloc.strip()) <= 0:
netloc = params['source']
Label = ' '.join([Label.strip(),'from',netloc.strip()])
header = lines[0].strip()
fields = header.split(delimiter)
if fields[0].strip() == column_keys['longitude_column']:
latIndex = 1
lonIndex = 0
for l in range(1,len(lines)):
line = lines[l].strip()
# segment break
if gaps in line:
# file start
if pointIndex <= 0:
continue
# finished one segment, store the number of points
else:
segments.append(thisSegment)
thisSegment = []
pointIndex = 0
else:
values = line.strip().split(delimiter)
lat,lon = values[latIndex],values[lonIndex]
if float(lat)< Latitude_Begin or float(lat)> Latitude_End or float(lon) < Longitude_Begin or float(lon) > Longitude_End:
continue
# convert to spherical coordinates
X,Y,Z =lib.llz2xyz(float(lat),float(lon),Boundary_Elevation)
x.append(X)
y.append(Y)
z.append(Z)
pointIndex += 1
# store point index for this segment
thisSegment.append(len(x)-1)
# This vtk object will store all the points
newPts = vtk.vtkPoints()
nPoints = len(x)
for i in range(nPoints):
newPts.InsertPoint(i, x[i],y[i],z[i])
# Add the points to the vtkPolyData object
pdo.SetPoints(newPts)
# storage for the line segments
nSegments = len(segments)
pdo.Allocate(nSegments, 1)
# Make a vtkPolyLine object to hold each segment data
for i in range(0,nSegments):
aPolyLine = vtk.vtkPolyLine()
# Indicate the number of points along the line
aPolyLine.GetPointIds().SetNumberOfIds(len(segments[i]))
for j in range(len(segments[i])):
aPolyLine.GetPointIds().SetId(j, segments[i][j])
pdo.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds())
simple.RenameSource(Label+Label2)
# store boundary metadata
fieldData = pdo.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
data = vtk.vtkFloatArray()
data.SetName('Latitude\nRange (deg)')
data.InsertNextValue(Latitude_Begin)
data.InsertNextValue(Latitude_End)
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Longitude\nRange (deg)')
data.InsertNextValue(Longitude_Begin)
data.InsertNextValue(Longitude_End)
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Boundary Elevation (km)')
data.InsertNextValue(-1*Boundary_Elevation)
fieldData.AddArray(data)
data = vtk.vtkStringArray()
data.SetName('Source')
data.InsertNextValue(source)
fieldData.AddArray(data)
pdo.SetFieldData(fieldData)
def manySlicesAlongAxis(dataNm, rng, axis=0, exportpath='', ext='.csv'):
"""
Description
-----------
Parameters
----------
`dataNm` : string
- The string name of the data source to slice.
- Make sure this data source is slice-able.
`numSlices` : int, optional
- The number of slices along the path.
`exportpath` : string, optional
- The absolute file path of where to save each slice
`ext` : string, optional
- The file extension for saving out the slices.
- Default to '.csv'
Notes
-----
- Make sure the input data source is slice-able.
- The SciPy module is required for this macro.
"""
# exportpath: Where to save data. Absolute path:
if axis not in (0, 1, 2):
raise Exception('Axis choice must be 0, 1, or 2 (x, y, or z)')
# Specify data set to be sliced
data = pvs.FindSource(dataNm)
# get active view
renderView = pvs.GetActiveViewOrCreate('RenderView')
def getNorm():
norm = [0, 0, 0]
norm[axis] = 1
return norm
def updateOrigin(og, i):
og[axis] = rng[i]
return og
norm = getNorm()
num = 0
inputs = []
for i in range(len(rng)):
# create slice
slc = pvs.Slice(Input=data)
slc.SliceType = 'Plane'
# set origin at points
og = slc.SliceType.Origin
og = updateOrigin(og, i)
# set normal as vector from current point to next point
slc.SliceType.Normal = norm
if exportpath != '':
# save out slice with good metadata: TODO: change name
# This will use a value from the point data to add to the name
#num = wpdi.PointData['Advance LL (S-558)'][ptsi[i]]
filename = path + 'Slice_%d%s' % (num, ext)
print(filename)
pvs.SaveData(filename, proxy=slc)
num += 1
inputs.append(slc)
#pvs.Show(slc, renderView)
# Now append all slices into once source for easy management
app = pvs.AppendDatasets(Input=inputs)
pvs.RenameSource('%s-Slices' % dataNm, app)
pvs.Show(app, renderView)
pvs.RenderAllViews()
pvs.ResetCamera()
return app
def RequestData():
# R.0.2018.080
import sys
sys.path.insert(0, "EMC_SRC_PATH")
from datetime import datetime
import numpy as np
from vtk.numpy_interface import dataset_adapter as dsa
from vtk.util import numpy_support
import IrisEMC_Paraview_Lib as lib
import paraview.simple as simple
views = simple.GetViews(viewtype="SpreadSheetView")
if len(views) > 0:
simple.Delete(views[0])
else:
view = simple.GetActiveView()
layout = simple.GetLayout(view)
locationId = layout.SplitViewVertical(view=view ,fraction=0.7)
myId = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
proxyList = []
for key in proxies:
listElt = {}
listElt['name'] = key[0]
listElt['id'] = key[1]
proxy = proxies[key]
parentId = '0'
if hasattr(proxy, 'Input'):
parentId = proxy.Input.GetGlobalIDAsString()
listElt['parent'] = parentId
proxyList.append(listElt)
pdi = self.GetInput() # VTK PolyData Type
np = pdi.GetNumberOfPoints()
depthMin = 9999999999999.0
depthMax = -9999999999999.0
latitude = {}
longitude = {}
pdo = self.GetOutput() # VTK Table Type
polyData = vtk.vtkPolyData()
dataPoints = vtk.vtkPoints()
if len(Label.strip()) <= 0:
pid = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
for key in proxies:
if key[1] == pid:
Label = " ".join(["Coordinates View:",key[0]])
break
for i in range(np):
point = pdi.GetPoints().GetPoint(i)
(lat,lon,depth) = lib.xyz2llz(point[0],point[1],point[2])
dataPoints.InsertNextPoint((lat,lon,depth))
key = "%0.1f"%(depth)
if depthMin >= float(key):
depthMin = float(key)
depthMinKey = key
if depthMax <= float(key):
depthMax = float(key)
depthMaxKey = key
if key not in latitude.keys():
latitude[key] =[]
longitude[key] = []
latitude[key].append(float("%0.1f"%(lat)))
longitude[key].append(float("%0.1f"%(lon)))
# store boundary metadata
fieldData = polyData.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
depthData = vtk.vtkStringArray()
depthData.SetName('Depth\n(km)')
data = vtk.vtkStringArray()
data.SetName('Corners (lat,lon)\n(degrees)')
depthKeys = [depthMinKey,depthMaxKey]
if depthMinKey == depthMaxKey:
depthKeys = [depthMinKey]
for i in range(len(depthKeys)):
depthKey = depthKeys[i]
borderLat = []
borderLon = []
oldMin = 999999999.0
oldMax = -99999999.0
lonList = list(set(sorted(longitude[depthKey])))
for j in range(len(lonList)):
lon = lonList[j]
minVal = 999999999.0
maxVal = -99999999.0
for i in range(len(longitude[depthKey])):
if longitude[depthKey][i] == lon:
if latitude[depthKey][i] > maxVal:
maxVal = latitude[depthKey][i]
if latitude[depthKey][i] < minVal:
minVal = latitude[depthKey][i]
if oldMin != minVal or j==len(lonList)-1:
if abs(oldMin) < 9999.0:
borderLat.append(oldMin)
borderLon.append(lon)
borderLat.append(minVal)
borderLon.append(lon)
oldMin = minVal
if oldMax != maxVal or j==len(lonList)-1:
if abs(oldMax) < 9999.0:
borderLat.append(oldMax)
borderLon.append(lon)
borderLat.append(maxVal)
borderLon.append(lon)
oldMax = maxVal
borderList = zip(borderLat, borderLon)
borderList.sort()
borderList = list(set(borderList))
min1 = borderList[0][0]
max1 = borderList[0][0]
for i in range(len(borderList)):
if borderList[i][0] < min1:
min1 = borderList[i][0]
if borderList[i][0] > max1:
max1 = borderList[i][0]
minList = []
maxList = []
for i in range(len(borderList)):
if borderList[i][0] == min1:
minList.append(borderList[i][1])
if borderList[i][0] == max1:
maxList.append(borderList[i][1])
depthData.InsertNextValue(depthKey)
data.InsertNextValue("%0.1f, %0.1f"%(min1,min(minList)))
if min(minList) != max(minList):
depthData.InsertNextValue(" ")
data.InsertNextValue("%0.1f, %0.1f"%(min1,max(minList)))
depthData.InsertNextValue(" ")
data.InsertNextValue("%0.1f, %0.1f"%(max1,max(maxList)))
if min(maxList) != max(maxList):
depthData.InsertNextValue(" ")
data.InsertNextValue("%0.1f, %0.1f"%(max1,min(maxList)))
fieldData.AddArray(data)
fieldData.AddArray(depthData)
if len(Label.strip()) > 0:
simple.RenameSource(Label)
pdo.SetFieldData(fieldData)
def RequestData():
# R.0.2018.080
import sys
import numpy as np
import os
import paraview.simple as simple
sys.path.insert(0, r'EMC_SRC_PATH')
import IrisEMC_Paraview_Lib as lib
grid_depth = float(Depth_Bias)
spacing = float(Grid_Spacing)
pdo = self.GetOutput() # vtkPolyData
Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End = lib.get_area(
Area, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End)
Label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f) with grid spacing of %0.1f degrees" % (
lib.areaValues[Area], Latitude_Begin, Latitude_End, Longitude_Begin,
Longitude_End, spacing)
x = []
y = []
z = []
segments = []
# create grid points along latitudes
nLat = int((Latitude_End - Latitude_Begin) / spacing) + 1
mLat = int((Latitude_End - Latitude_Begin) / Grid_Resolution_degrees) + 1
nLon = int((Longitude_End - Longitude_Begin) / spacing) + 1
mLon = int((Longitude_End - Longitude_Begin) / Grid_Resolution_degrees) + 1
lat = Latitude_Begin - spacing
for i in range(nLat):
lat += spacing
this_segment = []
point_index = 0
lon = Longitude_Begin - Grid_Resolution_degrees
for j in range(mLon):
lon += Grid_Resolution_degrees
X, Y, Z = lib.llz2xyz(lat, lon, grid_depth)
x.append(X)
y.append(Y)
z.append(Z)
point_index += 1
# store point index for this segment
this_segment.append(len(x) - 1)
segments.append(this_segment)
# create grid points along longitudes
lon = Longitude_Begin - spacing
for j in range(nLon):
lon += spacing
this_segment = []
point_index = 0
lat = Latitude_Begin - Grid_Resolution_degrees
for i in range(mLat):
lat += Grid_Resolution_degrees
X, Y, Z = lib.llz2xyz(lat, lon, grid_depth)
x.append(X)
y.append(Y)
z.append(Z)
point_index += 1
# store point index for this segment
this_segment.append(len(x) - 1)
segments.append(this_segment)
# this vtk object will store all the points
new_points = vtk.vtkPoints()
npoints = len(x)
for i in range(npoints):
new_points.InsertPoint(i, x[i], y[i], z[i])
# add the points to the vtkPolyData object
pdo.SetPoints(new_points)
# initialize storage for line segments
nSegments = len(segments)
pdo.Allocate(nSegments, 1)
# make a vtkPolyLine object to hold each segment data
for i in range(0, nSegments):
a_polyLine = vtk.vtkPolyLine()
# indicate the number of points along the line
a_polyLine.GetPointIds().SetNumberOfIds(len(segments[i]))
for j in range(len(segments[i])):
a_polyLine.GetPointIds().SetId(j, segments[i][j])
pdo.InsertNextCell(a_polyLine.GetCellType(), a_polyLine.GetPointIds())
# store grid metadata
fieldData = pdo.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
data = vtk.vtkFloatArray()
data.SetName('Latitude\nRange (deg)')
data.InsertNextValue(Latitude_Begin)
data.InsertNextValue(Latitude_End)
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Longitude\nRange (deg)')
data.InsertNextValue(Longitude_Begin)
data.InsertNextValue(Longitude_End)
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Grid Elevation (km),\nResolution & Spacing (deg)')
data.InsertNextValue(grid_depth)
data.InsertNextValue(Grid_Resolution_degrees)
data.InsertNextValue(spacing)
fieldData.AddArray(data)
pdo.SetFieldData(fieldData)
simple.RenameSource(' '.join(['Grid', Label2.strip()]))
def RequestData():
# V.2019.014
import sys
sys.path.insert(0, r'EMC_SRC_PATH')
import paraview.simple as simple
import numpy as np
import csv
import os
from vtk.util import numpy_support as nps
import IrisEMC_Paraview_Lib as lib
import urllib.parse
Label = ''
pts = vtk.vtkPoints()
# make sure we have input files
if len(File_name.strip()) <= 0:
fileFound = False
address = ''
else:
fileFound, address, source = lib.find_file(File_name.strip(),
loc=r'EMC_VOLCANOES_PATH')
if not fileFound:
raise Exception(
'volcano file "' + address +
'" not found! Please provide the full path or UR for the file. Aborting.'
)
(params, lines) = lib.read_geocsv(address)
Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End = lib.get_area(
Area, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End)
Label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f)" % (
lib.areaValues[Area], Latitude_Begin, Latitude_End, Longitude_Begin,
Longitude_End)
pdo = self.GetOutput() # vtkPoints
lat_index = 0
lon_index = 1
column_keys = lib.columnKeys
for key in list(lib.columnKeys.keys()):
if key in list(params.keys()):
column_keys[key] = params[key]
delimiter = params['delimiter'].strip()
origin = None
if 'source' in params:
origin = params['source']
if len(Label.strip()) <= 0:
Label = origin
fields = params['header']
for i in range(len(fields)):
if fields[i].strip().lower() == column_keys['longitude_column'].lower(
):
lon_index = i
elif fields[i].strip().lower() == column_keys['latitude_column'].lower(
):
lat_index = i
elif fields[i].strip().lower(
) == column_keys['elevation_column'].lower():
elev_index = i
for i, line in enumerate(lines):
line = line.strip()
values = line.split(delimiter)
try:
lat = float(values[lat_index])
lon = float(values[lon_index])
except:
continue
if len(values[elev_index].strip()) <= 0:
depth = 0.0
else:
try:
depth = -1 * float(values[elev_index]) / 1000.0
except:
continue
if Latitude_Begin <= lat <= Latitude_End and Longitude_Begin <= lon <= Longitude_End:
x, y, z = lib.llz2xyz(lat, lon, depth)
pts.InsertNextPoint(x, y, z)
pdo.SetPoints(pts)
simple.RenameSource(' '.join(
['Volcano locations:',
Label.strip(), Label2.strip()]))
view = simple.GetActiveView()
# store metadata
fieldData = pdo.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
data = vtk.vtkFloatArray()
data.SetName('Latitude\nRange (deg)')
data.InsertNextValue(Latitude_Begin)
data.InsertNextValue(Latitude_End)
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Longitude\nRange (deg)')
data.InsertNextValue(Longitude_Begin)
data.InsertNextValue(Longitude_End)
fieldData.AddArray(data)
data = vtk.vtkStringArray()
data.SetName('Source')
if origin is not None:
data.InsertNextValue(origin)
data.InsertNextValue(source)
fieldData.AddArray(data)
pdo.SetFieldData(fieldData)
def RequestData():
# R.0.2018.120
import sys
sys.path.insert(0, "EMC_SRC_PATH")
import paraview.simple as simple
import numpy as np
import csv
import os
from vtk.util import numpy_support as nps
import IrisEMC_Paraview_Lib as lib
import urlparse
Label = ''
pts = vtk.vtkPoints()
Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End = lib.getArea(
Area, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End)
Label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f, depth:%0.1f-%0.1f)" % (
lib.areaValues[Area], Latitude_Begin, Latitude_End, Longitude_Begin,
Longitude_End, Depth_Begin, Depth_End)
# make sure we have input files
query = lib.earthquakeQuery % (Start_Time, Magnitude_Begin, Magnitude_End,
Depth_Begin, Depth_End, Latitude_Begin,
Latitude_End, Longitude_Begin,
Longitude_End, Max_Count)
if len(Alternate_FileName) <= 0:
eqFile = lib.query2fileName(query, url=lib.earthquakeKeys[Data_Source])
query = '?'.join([lib.earthquakeKeys[Data_Source], query])
fileFound, address, source = lib.findFile(eqFile,
loc='EMC_EARTHQUAKES_PATH',
query=query)
else:
fileFound, address, source = lib.findFile(Alternate_FileName,
loc='EMC_EARTHQUAKES_PATH')
if not fileFound:
raise Exception(
'earthquake catalog file "' + address +
'" not found! Please provide the full path or UR for the file. Aborting.'
)
(params, lines) = lib.readGcsv(address)
pdo = self.GetOutput() # vtkPoints
column_keys = lib.columnKeys
for key in lib.columnKeys.keys():
if key in params.keys():
column_keys[key] = params[key]
delimiter = params['delimiter'].strip()
origin = None
if 'source' in params:
origin = params['source']
Label = urlparse.urlparse(origin).netloc
else:
try:
Label = urlparse.urlparse(Alternate_FileName).netloc
except:
Label = Alternate_FileName
header = lines[0].strip()
fields = header.split(delimiter)
for i in range(len(fields)):
if fields[i].strip().lower() == column_keys['longitude_column'].lower(
):
lonIndex = i
elif fields[i].strip().lower() == column_keys['latitude_column'].lower(
):
latIndex = i
elif fields[i].strip().lower() == column_keys['depth_column'].lower():
depthIndex = i
elif fields[i].strip().lower(
) == column_keys['magnitude_column'].lower():
magIndex = i
scalars = vtk.vtkFloatArray()
scalars.SetNumberOfComponents(1)
scalars.SetName("magnitude")
lat = []
lon = []
depth = []
mag = []
for i in range(1, len(lines)):
line = lines[i].strip()
values = line.strip().split(params['delimiter'].strip())
lat.append(float(values[latIndex]))
lon.append(float(values[lonIndex]))
depth.append(float(values[depthIndex]))
mag.append(float(values[magIndex]))
if lat[-1] >= Latitude_Begin and lat[-1] <= Latitude_End and lon[
-1] >= Longitude_Begin and lon[-1] <= Longitude_End:
x, y, z = lib.llz2xyz(lat[-1], lon[-1], depth[-1])
pts.InsertNextPoint(x, y, z)
scalars.InsertNextValue(mag[-1])
pdo.SetPoints(pts)
pdo.GetPointData().AddArray(scalars)
if len(Label.strip()) > 0:
simple.RenameSource(' '.join(
['Earthquake locations:', 'from',
Label.strip(),
Label2.strip()]))
view = simple.GetActiveView()
# store metadata
fieldData = pdo.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
data = vtk.vtkFloatArray()
data.SetName('Latitude\nRange (deg)')
data.InsertNextValue(min(lat))
data.InsertNextValue(max(lat))
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Longitude\nRange (deg)')
data.InsertNextValue(min(lon))
data.InsertNextValue(max(lon))
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Depth\nRange (km)')
data.InsertNextValue(min(depth))
data.InsertNextValue(max(depth))
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Magnitude\nRange')
data.InsertNextValue(min(mag))
data.InsertNextValue(max(mag))
fieldData.AddArray(data)
data = vtk.vtkIntArray()
data.SetName('Max. Event\nCount')
data.InsertNextValue(len(mag))
fieldData.AddArray(data)
data = vtk.vtkStringArray()
data.SetName('Start Date')
data.InsertNextValue(Start_Time)
fieldData.AddArray(data)
data = vtk.vtkStringArray()
data.SetName('Source')
if origin is not None:
data.InsertNextValue(origin)
data.InsertNextValue(source)
fieldData.AddArray(data)
pdo.SetFieldData(fieldData)
# Double check and santize meshfilename
root_ext = os.path.splitext(inputmeshfilename)
if (len(root_ext) > 1):
if ((root_ext[1] != '.exo') and (root_ext[1] != '.e')):
print('Cannot load exo mesh from: %s' % inputmeshfilename,
file=sys.stderr)
print('Possibly not an exodus file', file=sys.stderr)
plotexomesh = False
meshfilename = checkfilepath(fixslash(inputmeshfilename), basepath)
if (not checkfileexists(meshfilename)):
print('Cannot load exo mesh from: %s' % meshfilename, file=sys.stderr)
plotexomesh = False
if plotexomesh:
print('Loading exo mesh from: %s' % meshfilename)
meshexo = pvs.ExodusIIReader(FileName=[meshfilename])
pvs.RenameSource(meshfilename, meshexo)
#plotdataprobes=True
if ((plotdataprobes) and ('data_probes' in data['realms'][0])):
data_probe_specs = data['realms'][0]['data_probes']['specifications']
# Stuff
for spec in data_probe_specs:
if 'plane_specifications' in spec:
for plane in spec['plane_specifications']:
name = plane['name']
corner = np.array(plane['corner_coordinates'])
edge1 = np.array(plane['edge1_vector'])
edge2 = np.array(plane['edge2_vector'])
Nx = plane['edge1_numPoints'] - 1
Ny = plane['edge2_numPoints'] - 1
offsetvec = np.array([0, 0, 0])
def RequestData():
# R.0.2018.080
import sys
sys.path.insert(0, "EMC_SRC_PATH")
import paraview.simple as simple
import numpy as np
import csv
import os
from vtk.util import numpy_support as nps
import IrisEMC_Paraview_Lib as lib
import urlparse
Label = ''
pts = vtk.vtkPoints()
# make sure we have input files
query = lib.volcanoLocationsQuery
if len(Alternate_FileName) <= 0:
volcanoFile = lib.query2fileName(query)
query = '?'.join([lib.volcanoLocationsKeys[Data_Source], query])
fileFound, address, source = lib.findFile(volcanoFile,
loc='EMC_VOLCANOES_PATH',
query=query)
Label = ' '.join([
lib.volcanoLocationsValues[Data_Source].strip(), 'from',
urlparse.urlparse(
lib.volcanoLocationsKeys[Data_Source]).netloc.strip()
])
else:
fileFound, address, source = lib.findFile(Alternate_FileName,
loc='EMC_VOLCANOES_PATH')
if not fileFound:
raise Exception(
'volcano file "' + address +
'" not found! Please provide the full path or UR for the file. Aborting.'
)
(params, lines) = lib.readGcsv(address)
Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End = lib.getArea(
Area, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End)
Label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f)" % (
lib.areaValues[Area], Latitude_Begin, Latitude_End, Longitude_Begin,
Longitude_End)
pdo = self.GetOutput() # vtkPoints
count = 0
latIndex = 0
lonIndex = 1
column_keys = lib.columnKeys
for key in lib.columnKeys.keys():
if key in params.keys():
column_keys[key] = params[key]
delimiter = params['delimiter'].strip()
origin = None
if 'source' in params:
origin = params['source']
if len(Label.strip()) <= 0:
Label = origin
header = lines[0].strip()
fields = header.split(delimiter)
for i in range(len(fields)):
if fields[i].strip().lower() == column_keys['longitude_column'].lower(
):
lonIndex = i
elif fields[i].strip().lower() == column_keys['latitude_column'].lower(
):
latIndex = i
elif fields[i].strip().lower(
) == column_keys['elevation_column'].lower():
elevIndex = i
for i in range(1, len(lines)):
line = lines[i].strip()
values = line.strip().split(params['delimiter'].strip())
try:
lat = float(values[latIndex])
lon = float(values[lonIndex])
except:
continue
if len(values[elevIndex].strip()) <= 0:
depth = 0.0
else:
try:
depth = -1 * float(values[elevIndex]) / 1000.0
except:
continue
if lat >= Latitude_Begin and lat <= Latitude_End and lon >= Longitude_Begin and lon <= Longitude_End:
x, y, z = lib.llz2xyz(lat, lon, depth)
pts.InsertNextPoint(x, y, z)
pdo.SetPoints(pts)
done = False
simple.RenameSource(' '.join(
['Volcano locations:',
Label.strip(), Label2.strip()]))
view = simple.GetActiveView()
# store metadata
fieldData = pdo.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
data = vtk.vtkFloatArray()
data.SetName('Latitude\nRange (deg)')
data.InsertNextValue(Latitude_Begin)
data.InsertNextValue(Latitude_End)
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('Longitude\nRange (deg)')
data.InsertNextValue(Longitude_Begin)
data.InsertNextValue(Longitude_End)
fieldData.AddArray(data)
data = vtk.vtkStringArray()
data.SetName('Source')
if origin is not None:
data.InsertNextValue(origin)
data.InsertNextValue(source)
fieldData.AddArray(data)
pdo.SetFieldData(fieldData)
def RequestData():
# R.1.2018.354
import sys
sys.path.insert(0, "EMC_SRC_PATH")
from operator import itemgetter
from datetime import datetime
import numpy as np
from vtk.numpy_interface import dataset_adapter as dsa
from vtk.util import numpy_support
import IrisEMC_Paraview_Lib as lib
import paraview.simple as simple
views = simple.GetViews(viewtype="SpreadSheetView")
if len(views) > 0:
# set active view
view = simple.SetActiveView(views[0])
else:
view = simple.GetActiveView()
layout = simple.GetLayout(view)
location_id = layout.SplitViewVertical(view=view, fraction=0.7)
myId = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
proxyList = []
for key in proxies:
list_elt = dict()
list_elt['name'] = key[0]
list_elt['id'] = key[1]
proxy = proxies[key]
parent_id = '0'
if hasattr(proxy, 'Input'):
parent_id = proxy.Input.GetGlobalIDAsString()
list_elt['parent'] = parent_id
proxyList.append(list_elt)
pdi = self.GetInput() # VTK PolyData Type
try:
np = pdi.GetNumberOfPoints()
except Exception:
raise Exception('Invalid input!')
na = pdi.GetPointData().GetNumberOfArrays()
val_arrays = []
for i in range(na):
val_arrays.append(pdi.GetPointData().GetArray(i))
latitude = {}
longitude = {}
value = {}
depth = {}
pdo = self.GetOutput() # VTK Table Type
poly_data = vtk.vtkPolyData()
data_points = vtk.vtkPoints()
if len(Label.strip()) <= 0:
pid = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
for key in proxies:
if key[1] == pid:
Label = " ".join(["Coordinates:", key[0]])
break
for i in range(np):
point = pdi.GetPoints().GetPoint(i)
(lat, lon, this_depth) = lib.xyz2llz(point[0], point[1], point[2])
data_points.InsertNextPoint((lat, lon, this_depth))
key = "%0.2f" % this_depth
if key not in list(latitude.keys()):
latitude[key] = []
longitude[key] = []
value[key] = []
# need to control precision to have a reasonable sort order
# note that these coordinates are recomputed
if key not in list(depth.keys()):
depth[key] = float('%0.4f' % this_depth)
latitude[key].append(float('%0.4f' % lat))
longitude[key].append(float('%0.4f' % lon))
value_array = []
for j in range(na):
value_array.append(float(val_arrays[j].GetTuple1(i)))
value[key].append(value_array)
# store boundary metadata
field_data = poly_data.GetFieldData()
field_data.AllocateArrays(5) # number of fields
depth_data = vtk.vtkFloatArray()
depth_data.SetName('depth')
lat_data = vtk.vtkFloatArray()
lat_data.SetName('latitude')
lon_data = vtk.vtkFloatArray()
lon_data.SetName('longitude')
val_data = []
for j in range(na):
val_data.append(vtk.vtkFloatArray())
val_data[j].SetName('value(%s)' %
pdi.GetPointData().GetArray(j).GetName())
depth_keys = list(latitude.keys())
for i in range(len(depth_keys)):
depth_key = depth_keys[i]
lon_list = longitude[depth_key]
lat_list = latitude[depth_key]
val_list = value[depth_key]
point_list = list(zip(lat_list, lon_list, val_list))
point_list.sort(key=itemgetter(0, 1))
for index, data in enumerate(point_list):
depth_data.InsertNextValue(float(depth[depth_key]))
lat_data.InsertNextValue(float(data[0]))
lon_data.InsertNextValue(float(data[1]))
for k in range(na):
point_data = data[2]
val_data[k].InsertNextValue(point_data[k])
field_data.AddArray(lat_data)
field_data.AddArray(lon_data)
field_data.AddArray(depth_data)
for j in range(na):
field_data.AddArray(val_data[j])
if len(Label.strip()) > 0:
simple.RenameSource(Label)
pdo.SetFieldData(field_data)
