def getProbeData(self):
"""Returns probe-data from all readers. The returned datastructure has
the following syntax.
[
{
"name" : "<name>",
"headers" : [ "foo", "time", "bar" ],
"data" : [ [3, "2009-11-04", 1], [...], ...]
},
{ ... }, ...
]
"""
retVal = []
for item in _DataProber.PipelineObjects:
name = item["name"]
probe = item["Probe"]
probe.Source.Point1 = _DataProber.Widget.Point1WorldPosition
probe.Source.Point2 = _DataProber.Widget.Point2WorldPosition
print "Probing ", probe.Source.Point1, probe.Source.Point2
simple.UpdatePipeline(time=_DataProber.View.ViewTime, proxy=probe)
# fetch probe result from root node.
do = simple.servermanager.Fetch(probe, 0)
data = vtkWebUtilities.WriteAttributesToJavaScript(
vtk.vtkDataObject.POINT, do)
headers = vtkWebUtilities.WriteAttributeHeadersToJavaScript(
vtk.vtkDataObject.POINT, do)
# process the strings returned by vtkPVWebUtilities to generate
# Python objects
nan = "_nan_"
data = eval(data)
headers = eval(headers)
retVal.append({"name": name, "headers": headers, "data": data})
return retVal
if options:
# add coda about extracts generation.
trace.append_separated(["",
"if __name__ == '__main__':",
" # generate extracts",
" SaveExtracts(ExtractsOutputDirectory='%s')" % options.ExtractsOutputDirectory])
del trace_config
smtrace.stop_trace()
#print (trace)
return str(trace) if not raw else trace.raw_data()
if __name__ == "__main__":
print ( "Running test")
simple.Mandelbrot()
simple.Show()
simple.Hide()
simple.Shrink().ShrinkFactor = 0.4
simple.UpdatePipeline()
simple.Clip().ClipType.Normal[1] = 1
rep = simple.Show()
view = simple.Render()
view.ViewSize=[500, 500]
rep.SetScalarBarVisibility(view, True)
simple.Render()
# rep.SetScalarBarVisibility(view, False)
print ("====================================================================")
print (get_state())
def apply(self):
"""Update pipeline with current timestep."""
pv.UpdatePipeline(self.time)
def render_frames(
scene,
frames_dir=None,
frame_window=None,
render_missing_frames=False,
save_state_to_file=None,
no_render=False,
show_preview=False,
show_progress=False,
job_id=None,
):
# Validate scene
if scene["View"]["ViewSize"][0] % 16 != 0:
logger.warning(
"The view width should be a multiple of 16 to be compatible with"
" QuickTime.")
if scene["View"]["ViewSize"][1] % 2 != 0:
logger.warning(
"The view height should be even to be compatible with QuickTime.")
render_start_time = time.time()
# Setup layout
layout = pv.CreateLayout("Layout")
# Setup view
if "Background" in scene["View"]:
bg_config = scene["View"]["Background"]
del scene["View"]["Background"]
if isinstance(bg_config, list):
if isinstance(bg_config[0], list):
assert len(bg_config) == 2, (
"When 'Background' is a list of colors, it must have 2"
" entries.")
bg_config = dict(
BackgroundColorMode="Gradient",
Background=parse_as.color(bg_config[0]),
Background2=parse_as.color(bg_config[1]),
)
else:
bg_config = dict(
BackgroundColorMode="Single Color",
Background=parse_as.color(bg_config),
)
bg_config["UseColorPaletteForBackground"] = 0
scene["View"].update(bg_config)
bg_config = None
else:
bg_config = None
view = pv.CreateRenderView(**scene["View"])
pv.AssignViewToLayout(view=view, layout=layout, hint=0)
# Set spherical background texture
if bg_config is not None:
bg_config["BackgroundColorMode"] = "Texture"
skybox_datasource = bg_config["Datasource"]
del bg_config["Datasource"]
background_texture = pvserver.rendering.ImageTexture(
FileName=parse_as.path(scene["Datasources"][skybox_datasource]))
background_sphere = pv.Sphere(Radius=bg_config["Radius"],
ThetaResolution=100,
PhiResolution=100)
background_texture_map = pv.TextureMaptoSphere(Input=background_sphere)
pv.Show(
background_texture_map,
view,
Texture=background_texture,
BackfaceRepresentation="Cull Frontface",
Ambient=1.0,
)
# Load the waveform data file
waveform_h5file, waveform_subfile = parse_as.file_and_subfile(
scene["Datasources"]["Waveform"])
waveform_data = WaveformDataReader(FileName=waveform_h5file,
Subfile=waveform_subfile)
pv.UpdatePipeline()
# Generate volume data from the waveform. Also sets the available time range.
# TODO: Pull KeepEveryNthTimestep out of datasource
waveform_to_volume_configs = scene["WaveformToVolume"]
if isinstance(waveform_to_volume_configs, dict):
waveform_to_volume_configs = [{
"Object": waveform_to_volume_configs,
}]
if "VolumeRepresentation" in scene:
waveform_to_volume_configs[0]["VolumeRepresentation"] = scene[
"VolumeRepresentation"]
waveform_to_volume_objects = []
for waveform_to_volume_config in waveform_to_volume_configs:
volume_data = WaveformToVolume(
WaveformData=waveform_data,
SwshCacheDirectory=parse_as.path(
scene["Datasources"]["SwshCache"]),
**waveform_to_volume_config["Object"],
)
if "Modes" in waveform_to_volume_config["Object"]:
volume_data.Modes = waveform_to_volume_config["Object"]["Modes"]
if "Polarizations" in waveform_to_volume_config["Object"]:
volume_data.Polarizations = waveform_to_volume_config["Object"][
"Polarizations"]
waveform_to_volume_objects.append(volume_data)
# Compute timing and frames information
time_range_in_M = (
volume_data.TimestepValues[0],
volume_data.TimestepValues[-1],
)
logger.debug(f"Full available data time range: {time_range_in_M} (in M)")
if "FreezeTime" in scene["Animation"]:
frozen_time = scene["Animation"]["FreezeTime"]
logger.info(f"Freezing time at {frozen_time}.")
view.ViewTime = frozen_time
animation = None
else:
if "Crop" in scene["Animation"]:
time_range_in_M = scene["Animation"]["Crop"]
logger.debug(f"Cropping time range to {time_range_in_M} (in M).")
animation_speed = scene["Animation"]["Speed"]
frame_rate = scene["Animation"]["FrameRate"]
num_frames = animate.num_frames(
max_animation_length=time_range_in_M[1] - time_range_in_M[0],
animation_speed=animation_speed,
frame_rate=frame_rate,
)
animation_length_in_seconds = num_frames / frame_rate
animation_length_in_M = animation_length_in_seconds * animation_speed
time_per_frame_in_M = animation_length_in_M / num_frames
logger.info(f"Rendering {animation_length_in_seconds:.2f}s movie with"
f" {num_frames} frames ({frame_rate} FPS or"
f" {animation_speed:.2e} M/s or"
f" {time_per_frame_in_M:.2e} M/frame)...")
if frame_window is not None:
animation_window_num_frames = frame_window[1] - frame_window[0]
animation_window_time_range = (
time_range_in_M[0] + frame_window[0] * time_per_frame_in_M,
time_range_in_M[0] +
(frame_window[1] - 1) * time_per_frame_in_M,
)
logger.info(
f"Restricting rendering to {animation_window_num_frames} frames"
f" (numbers {frame_window[0]} to {frame_window[1] - 1}).")
else:
animation_window_num_frames = num_frames
animation_window_time_range = time_range_in_M
frame_window = (0, num_frames)
# Setup animation so that sources can retrieve the `UPDATE_TIME_STEP`
animation = pv.GetAnimationScene()
# animation.UpdateAnimationUsingDataTimeSteps()
# Since the data can be evaluated at arbitrary times we define the time steps
# here by setting the number of frames within the full range
animation.PlayMode = "Sequence"
animation.StartTime = animation_window_time_range[0]
animation.EndTime = animation_window_time_range[1]
animation.NumberOfFrames = animation_window_num_frames
logger.debug(
f"Animating from scene time {animation.StartTime} to"
f" {animation.EndTime} in {animation.NumberOfFrames} frames.")
def scene_time_from_real(real_time):
return (real_time / animation_length_in_seconds *
animation_length_in_M)
# For some reason the keyframe time for animations is expected to be within
# (0, 1) so we need to transform back and forth from this "normalized" time
def scene_time_from_normalized(normalized_time):
return animation.StartTime + normalized_time * (
animation.EndTime - animation.StartTime)
def normalized_time_from_scene(scene_time):
return (scene_time - animation.StartTime) / (animation.EndTime -
animation.StartTime)
# Setup progress measuring already here so volume data computing for
# initial frame is measured
if show_progress and not no_render:
logging.getLogger().handlers = [TqdmLoggingHandler()]
animation_window_frame_range = tqdm.trange(
animation_window_num_frames,
desc="Rendering",
unit="frame",
miniters=1,
position=job_id,
)
else:
animation_window_frame_range = range(animation_window_num_frames)
# Set the initial time step
animation.GoToFirst()
# Display the volume data. This will trigger computing the volume data at the
# current time step.
for volume_data, waveform_to_volume_config in zip(
waveform_to_volume_objects, waveform_to_volume_configs):
vol_repr = (waveform_to_volume_config["VolumeRepresentation"]
if "VolumeRepresentation" in waveform_to_volume_config else
{})
volume_color_by = config_color.extract_color_by(vol_repr)
if (vol_repr["VolumeRenderingMode"] == "GPU Based"
and len(volume_color_by) > 2):
logger.warning(
"The 'GPU Based' volume renderer doesn't support multiple"
" components.")
volume = pv.Show(volume_data, view, **vol_repr)
pv.ColorBy(volume, value=volume_color_by)
if "Slices" in scene:
for slice_config in scene["Slices"]:
slice_obj_config = slice_config.get("Object", {})
slice = pv.Slice(Input=volume_data)
slice.SliceType = "Plane"
slice.SliceOffsetValues = [0.0]
slice.SliceType.Origin = slice_obj_config.get(
"Origin", [0.0, 0.0, -0.3])
slice.SliceType.Normal = slice_obj_config.get(
"Normal", [0.0, 0.0, 1.0])
slice_rep = pv.Show(slice, view,
**slice_config.get("Representation", {}))
pv.ColorBy(slice_rep, value=volume_color_by)
# Display the time
if "TimeAnnotation" in scene:
time_annotation = pv.AnnotateTimeFilter(volume_data,
**scene["TimeAnnotation"])
pv.Show(time_annotation, view, **scene["TimeAnnotationRepresentation"])
# Add spheres
if "Spheres" in scene:
for sphere_config in scene["Spheres"]:
sphere = pv.Sphere(**sphere_config["Object"])
pv.Show(sphere, view, **sphere_config["Representation"])
# Add trajectories and objects that follow them
if "Trajectories" in scene:
for trajectory_config in scene["Trajectories"]:
trajectory_name = trajectory_config["Name"]
radial_scale = (trajectory_config["RadialScale"]
if "RadialScale" in trajectory_config else 1.0)
# Load the trajectory data
traj_data_reader = TrajectoryDataReader(
RadialScale=radial_scale,
**scene["Datasources"]["Trajectories"][trajectory_name],
)
# Make sure the data is loaded so we can retrieve timesteps.
# TODO: This should be fixed in `TrajectoryDataReader` by
# communicating time range info down the pipeline, but we had issues
# with that (see also `WaveformDataReader`).
traj_data_reader.UpdatePipeline()
if "Objects" in trajectory_config:
with animate.restore_animation_state(animation):
follow_traj = FollowTrajectory(
TrajectoryData=traj_data_reader)
for traj_obj_config in trajectory_config["Objects"]:
for traj_obj_key in traj_obj_config:
if traj_obj_key in [
"Representation",
"Visibility",
"TimeShift",
"Glyph",
]:
continue
traj_obj_type = getattr(pv, traj_obj_key)
traj_obj_glyph = traj_obj_type(
**traj_obj_config[traj_obj_key])
follow_traj.UpdatePipeline()
traj_obj = pv.Glyph(Input=follow_traj,
GlyphType=traj_obj_glyph)
# Can't set this in the constructor for some reason
traj_obj.ScaleFactor = 1.0
for glyph_property in (traj_obj_config["Glyph"] if "Glyph"
in traj_obj_config else []):
setattr(
traj_obj,
glyph_property,
traj_obj_config["Glyph"][glyph_property],
)
traj_obj.UpdatePipeline()
if "TimeShift" in traj_obj_config:
traj_obj = animate.apply_time_shift(
traj_obj, traj_obj_config["TimeShift"])
pv.Show(traj_obj, view,
**traj_obj_config["Representation"])
if "Visibility" in traj_obj_config:
animate.apply_visibility(
traj_obj,
traj_obj_config["Visibility"],
normalized_time_from_scene,
scene_time_from_real,
)
if "Tail" in trajectory_config:
with animate.restore_animation_state(animation):
traj_tail = TrajectoryTail(TrajectoryData=traj_data_reader)
if "TimeShift" in trajectory_config:
traj_tail = animate.apply_time_shift(
traj_tail, trajectory_config["TimeShift"])
tail_config = trajectory_config["Tail"]
traj_color_by = config_color.extract_color_by(tail_config)
if "Visibility" in tail_config:
tail_visibility_config = tail_config["Visibility"]
del tail_config["Visibility"]
else:
tail_visibility_config = None
tail_rep = pv.Show(traj_tail, view, **tail_config)
pv.ColorBy(tail_rep, value=traj_color_by)
if tail_visibility_config is not None:
animate.apply_visibility(
traj_tail,
tail_visibility_config,
normalized_time_from_scene=normalized_time_from_scene,
scene_time_from_real=scene_time_from_real,
)
if "Move" in trajectory_config:
move_config = trajectory_config["Move"]
logger.debug(
f"Animating '{move_config['guiName']}' along trajectory.")
with h5py.File(trajectory_file, "r") as traj_data_file:
trajectory_data = np.array(
traj_data_file[trajectory_subfile])
if radial_scale != 1.0:
trajectory_data[:, 1:] *= radial_scale
logger.debug(f"Trajectory data shape: {trajectory_data.shape}")
animate.follow_path(
gui_name=move_config["guiName"],
trajectory_data=trajectory_data,
num_keyframes=move_config["NumKeyframes"],
scene_time_range=time_range_in_M,
normalized_time_from_scene=normalized_time_from_scene,
)
# Add non-spherical horizon shapes (instead of spherical objects following
# trajectories)
if "Horizons" in scene:
for horizon_config in scene["Horizons"]:
with animate.restore_animation_state(animation):
horizon = pv.PVDReader(FileName=scene["Datasources"]
["Horizons"][horizon_config["Name"]])
if horizon_config.get("InterpolateTime", False):
horizon = pv.TemporalInterpolator(
Input=horizon, DiscreteTimeStepInterval=0)
if "TimeShift" in horizon_config:
horizon = animate.apply_time_shift(horizon,
horizon_config["TimeShift"],
animation)
# Try to make horizon surfaces smooth. At low angular resoluton
# they still show artifacts, so perhaps more can be done.
horizon = pv.ExtractSurface(Input=horizon)
horizon = pv.GenerateSurfaceNormals(Input=horizon)
horizon_rep_config = horizon_config.get("Representation", {})
if "Representation" not in horizon_rep_config:
horizon_rep_config["Representation"] = "Surface"
if "AmbientColor" not in horizon_rep_config:
horizon_rep_config["AmbientColor"] = [0.0, 0.0, 0.0]
if "DiffuseColor" not in horizon_rep_config:
horizon_rep_config["DiffuseColor"] = [0.0, 0.0, 0.0]
if "Specular" not in horizon_rep_config:
horizon_rep_config["Specular"] = 0.2
if "SpecularPower" not in horizon_rep_config:
horizon_rep_config["SpecularPower"] = 10
if "SpecularColor" not in horizon_rep_config:
horizon_rep_config["SpecularColor"] = [1.0, 1.0, 1.0]
if "ColorBy" in horizon_rep_config:
horizon_color_by = config_color.extract_color_by(
horizon_rep_config)
else:
horizon_color_by = None
horizon_rep = pv.Show(horizon, view, **horizon_rep_config)
if horizon_color_by is not None:
pv.ColorBy(horizon_rep, value=horizon_color_by)
# Animate visibility
if "Visibility" in horizon_config:
animate.apply_visibility(
horizon,
horizon_config["Visibility"],
normalized_time_from_scene=normalized_time_from_scene,
scene_time_from_real=scene_time_from_real,
)
if "Contours" in horizon_config:
for contour_config in horizon_config["Contours"]:
contour = pv.Contour(Input=horizon,
**contour_config["Object"])
contour_rep = pv.Show(contour, view,
**contour_config["Representation"])
pv.ColorBy(contour_rep, None)
if "Visibility" in horizon_config:
animate.apply_visibility(
contour,
horizon_config["Visibility"],
normalized_time_from_scene=
normalized_time_from_scene,
scene_time_from_real=scene_time_from_real,
)
# Configure transfer functions
if "TransferFunctions" in scene:
for tf_config in scene["TransferFunctions"]:
colored_field = tf_config["Field"]
transfer_fctn = pv.GetColorTransferFunction(colored_field)
opacity_fctn = pv.GetOpacityTransferFunction(colored_field)
tf.configure_transfer_function(transfer_fctn, opacity_fctn,
tf_config["TransferFunction"])
# Save state file before configuring camera keyframes.
# TODO: Make camera keyframes work with statefile
if save_state_to_file is not None:
pv.SaveState(save_state_to_file + ".pvsm")
# Camera shots
# TODO: Make this work with freezing time while the camera is swinging
if animation is None:
for i, shot in enumerate(scene["CameraShots"]):
if (i == len(scene["CameraShots"]) - 1 or
(shot["Time"] if "Time" in shot else 0.0) >= view.ViewTime):
camera_motion.apply(shot)
break
else:
camera_motion.apply_swings(
scene["CameraShots"],
scene_time_range=time_range_in_M,
scene_time_from_real=scene_time_from_real,
normalized_time_from_scene=normalized_time_from_scene,
)
# Report time
if animation is not None:
report_time_cue = pv.PythonAnimationCue()
report_time_cue.Script = """
def start_cue(self): pass
def tick(self):
import paraview.simple as pv
import logging
logger = logging.getLogger('Animation')
scene_time = pv.GetActiveView().ViewTime
logger.info(f"Scene time: {scene_time}")
def end_cue(self): pass
"""
animation.Cues.append(report_time_cue)
if show_preview and animation is not None:
animation.PlayMode = "Real Time"
animation.Duration = 10
animation.Play()
animation.PlayMode = "Sequence"
if no_render:
logger.info("No rendering requested. Total time:"
f" {time.time() - render_start_time:.2f}s")
return
if frames_dir is None:
raise RuntimeError("Trying to render but `frames_dir` is not set.")
if os.path.exists(frames_dir):
logger.warning(
f"Output directory '{frames_dir}' exists, files may be overwritten."
)
else:
os.makedirs(frames_dir)
if animation is None:
pv.Render()
pv.SaveScreenshot(os.path.join(frames_dir, "frame.png"))
else:
# Iterate over frames manually to support filling in missing frames.
# If `pv.SaveAnimation` would support that, here's how it could be
# invoked:
# pv.SaveAnimation(
# os.path.join(frames_dir, 'frame.png'),
# view,
# animation,
# FrameWindow=frame_window,
# SuffixFormat='.%06d')
# Note that `FrameWindow` appears to be buggy, so we set up the
# `animation` according to the `frame_window` above so the frame files
# are numberd correctly.
for animation_window_frame_i in animation_window_frame_range:
frame_i = frame_window[0] + animation_window_frame_i
frame_file = os.path.join(frames_dir, f"frame.{frame_i:06d}.png")
if render_missing_frames and os.path.exists(frame_file):
continue
logger.debug(f"Rendering frame {frame_i}...")
animation.AnimationTime = (
animation.StartTime +
time_per_frame_in_M * animation_window_frame_i)
pv.Render()
pv.SaveScreenshot(frame_file)
logger.info(f"Rendered frame {frame_i}.")
logger.info(
f"Rendering done. Total time: {time.time() - render_start_time:.2f}s")
composite_class = info.GetCompositeDataClassName()
if composite_class is None or not composite_class == 'vtkMultiBlockDataSet':
raise WrongInput(
'Source produce wrong type of data. MultiBlockDataSet required.')
# make a filter to collect all well lines in order
# to workaround a bug that do not porduce selsection labels
# on composite datasets
merged = ps.ProgrammableFilter()
merged.Script = merge_groups_script
merged.OutputDataSetType = 0 # PolyData
merged.Input = source
# update pipeline in order to get total number of points
ps.SetActiveSource(merged)
ps.UpdatePipeline()
# make selection where to show labels
n_points = merged.GetDataInformation().DataInformation.GetNumberOfPoints()
selection = ps.IDSelectionSource()
IDs = []
for i in range(n_points):
# select only non-head points
IDs.append(0L)
IDs.append(long(i))
selection.IDs = IDs
selection.FieldType = 1 # select point
merged.SetSelectionInput(0, selection, 0)
# get representation and select its selection properties
ps.SetActiveSource(merged)
def generateData(datasetPath, outputDir) :
if not os.path.exists(outputDir):
os.makedirs(outputDir)
resolution = 500
center_of_rotation = [0.0, 0.0, 0.0]
rotation_axis = [0.0, 0.0, 1.0]
distance = 45.0
disk_out_refex2 = simple.ExodusIIReader(FileName=[datasetPath])
disk_out_refex2.PointVariables = ['Temp', 'V', 'Pres', 'AsH3', 'GaMe3', 'CH4', 'H2']
disk_out_refex2.NodeSetArrayStatus = []
disk_out_refex2.SideSetArrayStatus = []
disk_out_refex2.ElementBlocks = ['Unnamed block ID: 1 Type: HEX8']
filters = []
filters_description = []
calculator1 = simple.Calculator(Input=disk_out_refex2)
calculator1.ResultArrayName = 'Velocity'
calculator1.Function = 'mag(V)'
simple.UpdatePipeline()
color_by = []
#
# COMPLAINT
#
# As a user of this system, I'd like not to have to specify that I need
# 'nX', 'nY', and 'nZ' when I add a colorby of type "VALUE". Instead,
# I'd like it to figure out that I'm going to need normals for that kind
# of rendering and add them for me.
#
color_type = [
('VALUE', "Velocity"),
('VALUE', "Pres"),
('VALUE', "Temp"),
('VALUE', "nX"),
('VALUE', "nY"),
('VALUE', "nZ")
]
pdi = calculator1.GetPointDataInformation()
#
# COMPLAINT
#
# Ditto the above complaint here.
#
luts = {
"Velocity": ["point", "Velocity", 0, pdi.GetArray("Velocity").GetRange()],
"Pres": ["point", "Pres", 0, pdi.GetArray("Pres").GetRange()],
"Temp": ["point", "Temp", 0, pdi.GetArray("Temp").GetRange()],
"nX": ["point", "Normals", 0, (-1,1)],
"nY": ["point", "Normals", 1, (-1,1)],
"nZ": ["point", "Normals", 2, (-1,1)]
}
contour_values = [ 300.0, 600.0, 900.0 ]
for iso_value in contour_values:
contour = simple.Contour(
Input=calculator1,
PointMergeMethod="Uniform Binning",
ContourBy = ['POINTS', 'Temp'],
Isosurfaces = [iso_value],
ComputeScalars = 1)
# Add this isocontour to my list of filters
filters.append( contour )
color_by.append( color_type )
filters_description.append( {'name': 'iso=%s' % str(iso_value), 'parent': "Contour by temperature"} )
# create a new 'Stream Tracer'
streamTracer1 = StreamTracer(Input=calculator1,
SeedType='High Resolution Line Source')
streamTracer1.Vectors = ['POINTS', 'V']
streamTracer1.MaximumStreamlineLength = 20.15999984741211
# init the 'High Resolution Line Source' selected for 'SeedType'
streamTracer1.SeedType.Point1 = [-5.75, -5.75, -10.0]
streamTracer1.SeedType.Point2 = [5.75, 5.75, 10.15999984741211]
# create a new 'Tube'
tube1 = Tube(Input=streamTracer1)
tube1.Scalars = ['POINTS', 'Velocity']
tube1.Vectors = ['POINTS', 'Normals']
tube1.Radius = 0.10474160957336426
#
# COMPLAINT
#
# Here, because the "Normals" field of the tube filter is all funky
# (directions seem to change at the seed points, when integration
# proceeded in both directions), I actually needed to play around
# with ParaView until I found a filter that would get me nice
# looking normals. Then, that filter didn't have a "Normals" field,
# so I had to use a calculator to create it. Not super nice from a
# users perspective.
#
surfaceVectors1 = SurfaceVectors(Input=tube1)
surfaceVectors1.SelectInputVectors = ['POINTS', 'TubeNormals']
calculator2 = simple.Calculator(Input=surfaceVectors1)
calculator2.ResultArrayName = 'Normals'
calculator2.Function = 'TubeNormals'
# Now add the stream tubes to the filters list
filters.append(calculator2);
color_by.append(color_type);
filters_description.append({'name': 'Stream Tubes'})
# create a new 'Clip'
clip1 = Clip(Input=calculator1)
clip1.ClipType = 'Plane'
clip1.Value = 11.209410083552676
clip1.InsideOut = 1
# init the 'Plane' selected for 'ClipType'
clip1.ClipType.Origin = [0.0, 0.0, 0.07999992370605469]
clip1.ClipType.Normal = [0.7, 0.0, -0.4]
#
# COMPLAINT
#
# Here again, the output of the clip filter doesn't have a "Normals"
# field on points, so I have to do some funky stuff to get what I
# need. It would be nice if this could be figured out for me
# somehow.
#
extractSurface1 = ExtractSurface(Input=clip1)
generateSurfaceNormals1 = GenerateSurfaceNormals(Input=extractSurface1)
# Now add the first clip to the filters list
filters.append(generateSurfaceNormals1);
color_by.append(color_type);
filters_description.append({'name': 'Clip One'})
# create a new 'Clip'
clip2 = Clip(Input=calculator1)
clip2.ClipType = 'Plane'
clip2.Value = 11.209410083552676
clip2.InsideOut = 0
# init the 'Plane' selected for 'ClipType'
clip2.ClipType.Origin = [0.0, 0.0, 0.07999992370605469]
clip2.ClipType.Normal = [0.7, 0.0, -0.4]
#
# COMPLAINT
#
# Ditto the above complaint here.
#
extractSurface2 = ExtractSurface(Input=clip2)
generateSurfaceNormals2 = GenerateSurfaceNormals(Input=extractSurface2)
# Now add the second clip to the filters list
filters.append(generateSurfaceNormals2);
color_by.append(color_type);
filters_description.append({'name': 'Clip Two'})
title = "Composite Dynamic Rendering - Disk Out Ref"
description = "A sample dataset for dynamic rendering"
analysis = wx.AnalysisManager(outputDir, title, description)
id = 'composite'
title = '3D composite'
description = "contour set"
analysis.register_analysis(id, title, description, '{theta}/{phi}/{filename}', wx.CompositeImageExporter.get_data_type()+"-light")
fng = analysis.get_file_name_generator(id)
camera_handler = wx.ThreeSixtyCameraHandler(
fng,
None,
[ float(r) for r in range(0, 360, 30) ],
[ float(r) for r in range(-60, 61, 60) ],
center_of_rotation,
rotation_axis,
distance)
exporter = wx.CompositeImageExporter(
fng,
filters,
color_by,
luts,
camera_handler,
[resolution,resolution],
filters_description,
0, 0, 'png')
exporter.set_analysis(analysis)
analysis.begin()
exporter.UpdatePipeline(0)
analysis.end()
