1 # Copyright (C) 2010-2015 CEA/DEN, EDF R&D
3 # This library is free software; you can redistribute it and/or
4 # modify it under the terms of the GNU Lesser General Public
5 # License as published by the Free Software Foundation; either
6 # version 2.1 of the License, or (at your option) any later version.
8 # This library is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 # Lesser General Public License for more details.
13 # You should have received a copy of the GNU Lesser General Public
14 # License along with this library; if not, write to the Free Software
15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 This module is intended to provide Python API for building presentations
22 typical for Post-Pro module (Scalar Map, Deformed Shape, Vectors, etc.)
26 from __future__ import division
27 ##from __future__ import print_function
32 from math import sqrt, sin, cos, radians
33 from string import upper
35 # Do not use pv as a short name.
36 # It is a name of function from numpy and may be redefined implicitly by 'from numpy import *' call.
37 # import pvsimple as pv
38 import pvsimple as pvs
40 # # TODO(MZN): to be removed (issue with Point Sprite texture)
41 # #import paravisSM as sm
43 # import paraview.simple as pvs
44 # import paraview.servermanager as sm
50 VTK_LARGE_FLOAT = 1E+38
51 GAP_COEFFICIENT = 0.0001
56 _med_field_sep = '@@][@@'
62 Post-Pro presentation types.
70 DEFORMEDSHAPESCALARMAP = 6
76 _type2name = {MESH: 'Mesh',
77 SCALARMAP: 'Scalar Map',
78 ISOSURFACES: 'Iso Surfaces',
79 CUTPLANES: 'Cut Planes',
80 CUTLINES: 'Cut Lines',
81 DEFORMEDSHAPE: 'Deformed Shape',
82 DEFORMEDSHAPESCALARMAP: 'Deformed Shape And Scalar Map',
85 STREAMLINES: 'Stream Lines',
86 GAUSSPOINTS: 'Gauss Points'}
89 def get_name(cls, type):
90 """Return presentaion name by its type."""
91 return cls._type2name[type]
101 _type2name = {NODE: 'P1',
104 _name2type = {'P1': NODE,
107 _type2pvtype = {NODE: 'POINT_DATA',
111 def get_name(cls, type):
112 """Return entity name (used in full group names) by its type."""
113 return cls._type2name[type]
116 def get_type(cls, name):
117 """Return entity type by its name (used in full group names)."""
118 return cls._name2type[name]
121 def get_pvtype(cls, type):
122 """Return entity type from ['CELL_DATA', 'POINT_DATA']"""
123 return cls._type2pvtype[type]
127 """Orientation types.
129 Defines a set of plane orientation possibilities:
130 AUTO: plane orientation should be calculated.
131 XY: plane formed by X and Y axis.
132 YZ: plane formed by Y and Z axis.
133 ZX: plane formed by Z and X axis
145 Set of elements defining the position of the vector head:
146 CENTER: in the center of the vector
147 TAIL: in the tail of the vector
148 HEAD: in the head of the vector
158 Gauss Points primitive types.
164 _type2mode = {SPRITE: 'Texture',
165 POINT: 'SimplePoint',
166 SPHERE: 'Sphere (Texture)'}
169 def get_mode(cls, type):
170 """Return paraview point sprite mode by the primitive type."""
171 return cls._type2mode[type]
174 # Auxiliary functions
176 def get_field_mesh_name(full_field_name):
177 """Return mesh name of the field by its full name."""
178 aList = full_field_name.split('/')
180 field_name = full_field_name.split('/')[1]
184 def get_field_entity(full_field_name):
185 """Return entity type of the field by its full name."""
186 aList = full_field_name.split(_med_field_sep)
188 entity_name = full_field_name.split(_med_field_sep)[-1]
189 entity = EntityType.get_type(entity_name)
193 def get_field_short_name(full_field_name):
194 """Return short name of the field by its full name."""
195 aList = full_field_name.split('/')
197 short_name_with_type = full_field_name.split('/')[-1]
198 short_name = short_name_with_type.split(_med_field_sep)[0]
202 def find_mesh_full_name(proxy, short_mesh_name):
203 """Return full mesh path by short mesh name, if found"""
204 proxy.UpdatePipeline()
205 all_mesh_names = get_mesh_full_names(proxy)
206 for name in all_mesh_names:
207 if short_mesh_name == get_field_short_name(name):
211 def process_prs_for_test(prs, view, picture_name, show_bar=True):
212 """Show presentation and record snapshot image.
215 prs: the presentation to show
216 view: the render view
217 picture_name: the full name of the graphics file to save
218 show_bar: to show scalar bar or not
221 # Show the presentation only
222 display_only(prs, view)
225 if show_bar and _current_bar:
226 _current_bar.Visibility = 1
231 # Create a directory for screenshot if necessary
232 file_name = re.sub("\s+", "_", picture_name)
233 pic_dir = os.path.dirname(picture_name)
234 if not os.path.exists(pic_dir):
238 pvs.WriteImage(file_name, view=view, Magnification=1)
241 def reset_view(view=None):
244 Set predefined (taken from Post-Pro) camera settings.
245 If the view is not passed, the active view is used.
249 view = pvs.GetRenderView()
252 view.CameraFocalPoint = [0.0, 0.0, 0.0]
253 view.CameraViewUp = [0.0, 0.0, 1.0]
254 view.CameraPosition = [738.946, -738.946, 738.946]
256 # Turn on the headligth
258 view.LightIntensity = 0.5
260 # Use parallel projection
261 view.CameraParallelProjection = 1
264 pvs.Render(view=view)
267 def hide_all(view, to_remove=False):
268 """Hide all representations in the view."""
270 view = pvs.GetRenderView()
272 rep_list = view.Representations
274 if hasattr(rep, 'Visibility') and rep.Visibility != 0:
277 view.Representations.remove(rep)
278 pvs.Render(view=view)
281 def display_only(prs, view=None):
282 """Display only the given presentation in the view."""
284 view = pvs.GetRenderView()
286 rep_list = view.Representations
288 if hasattr(rep, 'Visibility'):
289 rep.Visibility = (rep == prs)
290 pvs.Render(view=view)
293 def set_visible_lines(xy_prs, lines):
294 """Set visible only the given lines for XYChartRepresentation."""
295 sv = xy_prs.GetProperty("SeriesVisibilityInfo").GetData()
298 for i in xrange(0, len(sv)):
301 if line_name in lines:
308 xy_prs.SeriesVisibility = sv
311 def check_vector_mode(vector_mode, nb_components):
312 """Check vector mode.
314 Check if vector mode is correct for the data array with the
315 given number of components.
318 vector_mode: 'Magnitude', 'X', 'Y' or 'Z'
319 nb_components: number of component in the data array
322 ValueError: in case of the vector mode is unexistent
326 if vector_mode not in ('Magnitude', 'X', 'Y', 'Z'):
327 raise ValueError("Unexistent vector mode: " + vector_mode)
329 if ((nb_components == 1 and (vector_mode == 'Y' or vector_mode == 'Z')) or
330 (nb_components == 2 and vector_mode == 'Z')):
331 raise ValueError("Incorrect vector mode " + vector_mode + " for " +
332 nb_components + "-component field")
335 def get_vector_component(vector_mode):
336 """Get vector component as ineger.
338 Translate vector component notation from string
348 if vector_mode == 'X':
350 elif vector_mode == 'Y':
352 elif vector_mode == 'Z':
358 def get_data_range(proxy, entity, field_name, vector_mode='Magnitude',
360 """Get data range for the field.
363 proxy: the pipeline object, containig data array for the field
364 entity: the field entity
365 field_name: the field name
366 vector_mode: the vector mode ('Magnitude', 'X', 'Y' or 'Z')
369 Data range as [min, max]
372 proxy.UpdatePipeline()
373 entity_data_info = None
374 field_data = proxy.GetFieldDataInformation()
376 if field_name in field_data.keys():
377 entity_data_info = field_data
378 elif entity == EntityType.CELL:
379 entity_data_info = proxy.GetCellDataInformation()
380 elif entity == EntityType.NODE:
381 entity_data_info = proxy.GetPointDataInformation()
385 if field_name in entity_data_info.keys():
386 vcomp = get_vector_component(vector_mode)
387 data_range = entity_data_info[field_name].GetComponentRange(vcomp)
389 pv_entity = EntityType.get_pvtype(entity)
390 warnings.warn("Field " + field_name +
391 " is unknown for " + pv_entity + "!")
394 if cut_off and (data_range[0] <= data_range[1]):
395 data_range = list(data_range)
396 delta = abs(data_range[1] - data_range[0]) * GAP_COEFFICIENT
397 data_range[0] += delta
398 data_range[1] -= delta
403 def get_bounds(proxy):
404 """Get bounds of the proxy in 3D."""
405 proxy.UpdatePipeline()
406 dataInfo = proxy.GetDataInformation()
407 bounds_info = dataInfo.GetBounds()
411 def get_x_range(proxy):
412 """Get X range of the proxy bounds in 3D."""
413 proxy.UpdatePipeline()
414 bounds_info = get_bounds(proxy)
415 return bounds_info[0:2]
418 def get_y_range(proxy):
419 """Get Y range of the proxy bounds in 3D."""
420 proxy.UpdatePipeline()
421 bounds_info = get_bounds(proxy)
422 return bounds_info[2:4]
425 def get_z_range(proxy):
426 """Get Z range of the proxy bounds in 3D."""
427 proxy.UpdatePipeline()
428 bounds_info = get_bounds(proxy)
429 return bounds_info[4:6]
432 def is_planar_input(proxy):
433 """Check if the given input is planar."""
434 proxy.UpdatePipeline()
435 bounds_info = get_bounds(proxy)
437 if (abs(bounds_info[0] - bounds_info[1]) <= FLT_MIN or
438 abs(bounds_info[2] - bounds_info[3]) <= FLT_MIN or
439 abs(bounds_info[4] - bounds_info[5]) <= FLT_MIN):
445 def is_data_on_cells(proxy, field_name):
446 """Check the existence of a field on cells with the given name."""
447 proxy.UpdatePipeline()
448 cell_data_info = proxy.GetCellDataInformation()
449 return (field_name in cell_data_info.keys())
453 """Check if the object contains any points or cells.
456 True: if the given proxy doesn't contain any points or cells
460 proxy.UpdatePipeline()
461 data_info = proxy.GetDataInformation()
463 nb_cells = data_info.GetNumberOfCells()
464 nb_points = data_info.GetNumberOfPoints()
466 return not(nb_cells + nb_points)
469 def get_orientation(proxy):
470 """Get the optimum cutting plane orientation for Plot 3D."""
471 proxy.UpdatePipeline()
472 orientation = Orientation.XY
474 bounds = get_bounds(proxy)
475 delta = [bounds[1] - bounds[0],
476 bounds[3] - bounds[2],
477 bounds[5] - bounds[4]]
479 if (delta[0] >= delta[1] and delta[0] >= delta[2]):
480 if (delta[1] >= delta[2]):
481 orientation = Orientation.XY
483 orientation = Orientation.ZX
484 elif (delta[1] >= delta[0] and delta[1] >= delta[2]):
485 if (delta[0] >= delta[2]):
486 orientation = Orientation.XY
488 orientation = Orientation.YZ
489 elif (delta[2] >= delta[0] and delta[2] >= delta[1]):
490 if (delta[0] >= delta[1]):
491 orientation = Orientation.ZX
493 orientation = Orientation.YZ
498 def dot_product(a, b):
499 """Dot product of two 3-vectors."""
500 dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
504 def multiply3x3(a, b):
505 """Mutltiply one 3x3 matrix by another."""
511 c[0][i] = a[0][0] * b[0][i] + a[0][1] * b[1][i] + a[0][2] * b[2][i]
512 c[1][i] = a[1][0] * b[0][i] + a[1][1] * b[1][i] + a[1][2] * b[2][i]
513 c[2][i] = a[2][0] * b[0][i] + a[2][1] * b[1][i] + a[2][2] * b[2][i]
519 """Get X rotation matrix by angle."""
520 rx = [[1.0, 0.0, 0.0],
521 [0.0, cos(ang), -sin(ang)],
522 [0.0, sin(ang), cos(ang)]]
528 """Get Y rotation matrix by angle."""
529 ry = [[cos(ang), 0.0, sin(ang)],
531 [-sin(ang), 0.0, cos(ang)]]
537 """Get Z rotation matrix by angle."""
538 rz = [[cos(ang), -sin(ang), 0.0],
539 [sin(ang), cos(ang), 0.0],
545 def get_normal_by_orientation(orientation, ang1=0, ang2=0):
546 """Get normal for the plane by its orientation."""
548 rotation = [[], [], []]
549 rx = ry = rz = [[1.0, 0.0, 0.0],
553 normal = [0.0, 0.0, 0.0]
554 if orientation == Orientation.XY:
559 rotation = multiply3x3(rx, ry)
561 elif orientation == Orientation.ZX:
566 rotation = multiply3x3(rz, rx)
568 elif orientation == Orientation.YZ:
573 rotation = multiply3x3(ry, rz)
576 for i in xrange(0, 3):
577 normal[i] = rotation[i][i_plane]
582 def get_bound_project(bound_box, dir):
583 """Get bounds projection"""
584 bound_points = [[bound_box[0], bound_box[2], bound_box[4]],
585 [bound_box[1], bound_box[2], bound_box[4]],
586 [bound_box[0], bound_box[3], bound_box[4]],
587 [bound_box[1], bound_box[3], bound_box[4]],
588 [bound_box[0], bound_box[2], bound_box[5]],
589 [bound_box[1], bound_box[2], bound_box[5]],
590 [bound_box[0], bound_box[3], bound_box[5]],
591 [bound_box[1], bound_box[3], bound_box[5]]]
593 bound_prj = [0, 0, 0]
594 bound_prj[0] = dot_product(dir, bound_points[0])
595 bound_prj[1] = bound_prj[0]
597 for i in xrange(1, 8):
598 tmp = dot_product(dir, bound_points[i])
599 if bound_prj[1] < tmp:
601 if bound_prj[0] > tmp:
604 bound_prj[2] = bound_prj[1] - bound_prj[0]
605 bound_prj[1] = bound_prj[0] + (1.0 - EPS) * bound_prj[2]
606 bound_prj[0] = bound_prj[0] + EPS * bound_prj[2]
607 bound_prj[2] = bound_prj[1] - bound_prj[0]
612 def get_positions(nb_planes, dir, bounds, displacement):
613 """Compute plane positions."""
615 bound_prj = get_bound_project(bounds, dir)
617 step = bound_prj[2] / (nb_planes - 1)
618 abs_displacement = step * displacement
619 start_pos = bound_prj[0] - 0.5 * step + abs_displacement
620 for i in xrange(nb_planes):
621 pos = start_pos + i * step
622 positions.append(pos)
624 pos = bound_prj[0] + bound_prj[2] * displacement
625 positions.append(pos)
630 def get_contours(scalar_range, nb_contours):
631 """Generate contour values."""
633 for i in xrange(nb_contours):
634 pos = scalar_range[0] + i * (
635 scalar_range[1] - scalar_range[0]) / (nb_contours - 1)
641 def get_nb_components(proxy, entity, field_name):
642 """Return number of components for the field."""
643 proxy.UpdatePipeline()
644 entity_data_info = None
645 field_data = proxy.GetFieldDataInformation()
647 if field_name in field_data.keys():
648 entity_data_info = field_data
649 elif entity == EntityType.CELL:
650 select_cells_with_data(proxy, on_cells=[field_name])
651 entity_data_info = proxy.GetCellDataInformation()
652 elif entity == EntityType.NODE:
653 select_cells_with_data(proxy, on_points=[field_name])
654 entity_data_info = proxy.GetPointDataInformation()
657 if field_name in entity_data_info.keys():
658 nb_comp = entity_data_info[field_name].GetNumberOfComponents()
660 pv_entity = EntityType.get_pvtype(entity)
661 raise ValueError("Field " + field_name +
662 " is unknown for " + pv_entity + "!")
667 def get_scale_factor(proxy):
668 """Compute scale factor."""
672 proxy.UpdatePipeline()
673 data_info = proxy.GetDataInformation()
675 nb_cells = data_info.GetNumberOfCells()
676 nb_points = data_info.GetNumberOfPoints()
677 nb_elements = nb_cells if nb_cells > 0 else nb_points
678 bounds = get_bounds(proxy)
683 for i in xrange(0, 6, 2):
684 vol = abs(bounds[i + 1] - bounds[i])
689 if nb_elements == 0 or dim < 1 / VTK_LARGE_FLOAT:
692 volume /= nb_elements
694 return pow(volume, 1 / dim)
697 def get_default_scale(prs_type, proxy, entity, field_name):
698 """Get default scale factor."""
699 proxy.UpdatePipeline()
700 data_range = get_data_range(proxy, entity, field_name)
702 if prs_type == PrsTypeEnum.DEFORMEDSHAPE:
703 EPS = 1.0 / VTK_LARGE_FLOAT
704 if abs(data_range[1]) > EPS:
705 scale_factor = get_scale_factor(proxy)
706 return scale_factor / data_range[1]
707 elif prs_type == PrsTypeEnum.PLOT3D:
708 bounds = get_bounds(proxy)
709 length = sqrt((bounds[1] - bounds[0]) ** 2 +
710 (bounds[3] - bounds[2]) ** 2 +
711 (bounds[5] - bounds[4]) ** 2)
714 if data_range[1] > 0:
715 return length / data_range[1] * EPS
720 def get_calc_magnitude(proxy, array_entity, array_name):
721 """Compute magnitude for the given vector array via Calculator.
724 the calculator object.
727 proxy.UpdatePipeline()
730 # Transform vector array to scalar array if possible
731 nb_components = get_nb_components(proxy, array_entity, array_name)
732 if (nb_components > 1):
733 calculator = pvs.Calculator(proxy)
734 attribute_mode = "Point Data"
735 if array_entity != EntityType.NODE:
736 attribute_mode = "Cell Data"
737 calculator.AttributeMode = attribute_mode
738 if (nb_components == 2):
739 # Workaroud: calculator unable to compute magnitude
740 # if number of components equal to 2
741 func = "sqrt(" + array_name + "_X^2+" + array_name + "_Y^2)"
742 calculator.Function = func
744 calculator.Function = "mag(" + array_name + ")"
745 calculator.ResultArrayName = array_name + "_magnitude"
746 calculator.UpdatePipeline()
751 def get_add_component_calc(proxy, array_entity, array_name):
752 """Creates 3-component array from 2-component.
754 The first two components is from the original array. The 3rd component
756 If the number of components is not equal to 2 - return original array name.
759 the calculator object.
762 proxy.UpdatePipeline()
765 nb_components = get_nb_components(proxy, array_entity, array_name)
766 if nb_components == 2:
767 calculator = pvs.Calculator(proxy)
768 attribute_mode = "Point Data"
769 if array_entity != EntityType.NODE:
770 attribute_mode = "Cell Data"
771 calculator.AttributeMode = attribute_mode
772 expression = "iHat * " + array_name + "_X + jHat * " + array_name + "_Y + kHat * 0"
773 calculator.Function = expression
774 calculator.ResultArrayName = array_name + "_3c"
775 calculator.UpdatePipeline()
780 def select_all_cells(proxy):
781 """Select all cell types.
783 Used in creation of mesh/submesh presentation.
786 proxy.UpdatePipeline()
787 extractCT = pvs.ExtractCellType()
788 extractCT.AllGeoTypes = extractCT.GetProperty("GeoTypesInfo")[::2]
789 extractCT.UpdatePipelineInformation()
792 def select_cells_with_data(proxy, on_points=[], on_cells=[], on_gauss=[]):
793 """Select cell types with data.
795 Only cell types with data for the given fields will be selected.
796 If no fields defined (neither on points nor on cells) only cell
797 types with data for even one field (from available) will be selected.
800 if not proxy.GetProperty("FieldsTreeInfo"):
803 proxy.UpdatePipeline()
804 if not hasattr(proxy, 'Entity'):
805 fields_info = proxy.GetProperty("FieldsTreeInfo")[::2]
806 arr_name_with_dis=[elt.split("/")[-1] for elt in fields_info]
809 proxy.UpdatePipeline()
812 for name in on_gauss:
813 fields.append(name+_med_field_sep+'GAUSS')
814 for name in on_cells:
815 fields.append(name+_med_field_sep+'P0')
816 for name in on_points:
817 fields.append(name+_med_field_sep+'P1')
821 if arr_name_with_dis.count(name) > 0:
822 index = arr_name_with_dis.index(name)
823 field_list.append(fields_info[index])
825 proxy.AllArrays = field_list
826 proxy.UpdatePipeline()
827 return len(field_list) != 0
829 # TODO: VTN. Looks like this code is out of date.
831 #all_cell_types = proxy.CellTypes.Available
832 all_cell_types = proxy.Entity.Available
833 all_arrays = list(proxy.CellArrays.GetData())
834 all_arrays.extend(proxy.PointArrays.GetData())
837 file_name = proxy.FileName.split(os.sep)[-1]
838 print "Warning: " + file_name + " doesn't contain any data array."
840 # List of cell types to be selected
843 for cell_type in all_cell_types:
844 #proxy.CellTypes = [cell_type]
845 proxy.Entity = [cell_type]
846 proxy.UpdatePipeline()
848 cell_arrays = proxy.GetCellDataInformation().keys()
849 point_arrays = proxy.GetPointDataInformation().keys()
851 if on_points or on_cells:
852 if on_points is None:
857 if (all(array in cell_arrays for array in on_cells) and
858 all(array in point_arrays for array in on_points)):
859 # Add cell type to the list
860 cell_types_on.append(cell_type)
862 in_arrays = lambda array: ((array in cell_arrays) or
863 (array in point_arrays))
864 if any(in_arrays(array) for array in all_arrays):
865 cell_types_on.append(cell_type)
868 #proxy.CellTypes = cell_types_on
869 proxy.Entity = cell_types_on
870 proxy.UpdatePipeline()
872 def if_possible(proxy, field_name, entity, prs_type, extrGrps=None):
873 """Check if the presentation creation is possible on the given field."""
874 proxy.UpdatePipeline()
876 if (prs_type == PrsTypeEnum.DEFORMEDSHAPE or
877 prs_type == PrsTypeEnum.DEFORMEDSHAPESCALARMAP or
878 prs_type == PrsTypeEnum.VECTORS or
879 prs_type == PrsTypeEnum.STREAMLINES):
880 nb_comp = get_nb_components(proxy, entity, field_name)
881 result = (nb_comp > 1)
882 elif (prs_type == PrsTypeEnum.GAUSSPOINTS):
883 result = (entity == EntityType.CELL or
884 field_name in proxy.QuadraturePointArrays.Available)
885 elif (prs_type == PrsTypeEnum.MESH):
886 result = len(get_group_names(extrGrps)) > 0
891 def add_scalar_bar(field_name, nb_components,
892 vector_mode, lookup_table, time_value):
893 """Add scalar bar with predefined properties."""
896 # Construct bar title
897 title = "\n".join([field_name, str(time_value)])
898 if nb_components > 1:
899 title = "\n".join([title, vector_mode])
902 scalar_bar = pvs.CreateScalarBar(Enabled=1)
903 scalar_bar.Orientation = 'Vertical'
904 scalar_bar.Title = title
905 scalar_bar.LookupTable = lookup_table
907 # Set default properties same as in Post-Pro
908 scalar_bar.NumberOfLabels = 5
909 scalar_bar.AutomaticLabelFormat = 0
910 scalar_bar.LabelFormat = '%-#6.6g'
912 scalar_bar.TitleFontFamily = 'Arial'
913 scalar_bar.TitleFontSize = 8
914 scalar_bar.TitleBold = 1
915 scalar_bar.TitleItalic = 1
916 scalar_bar.TitleShadow = 1
918 scalar_bar.LabelFontFamily = 'Arial'
919 scalar_bar.LabelFontSize = 8
920 scalar_bar.LabelBold = 1
921 scalar_bar.LabelItalic = 1
922 scalar_bar.LabelShadow = 1
924 # Add the scalar bar to the view
925 pvs.GetRenderView().Representations.append(scalar_bar)
927 # Reassign the current bar
928 _current_bar = scalar_bar
934 """Get current scalar bar."""
940 def get_lookup_table(field_name, nb_components, vector_mode='Magnitude'):
941 """Get lookup table for the given field."""
942 lookup_table = pvs.GetLookupTableForArray(field_name, nb_components)
944 if vector_mode == 'Magnitude':
945 lookup_table.VectorMode = vector_mode
946 elif vector_mode == 'X':
947 lookup_table.VectorMode = 'Component'
948 lookup_table.VectorComponent = 0
949 elif vector_mode == 'Y':
950 lookup_table.VectorMode = 'Component'
951 lookup_table.VectorComponent = 1
952 elif vector_mode == 'Z':
953 lookup_table.VectorMode = 'Component'
954 lookup_table.VectorComponent = 2
956 raise ValueError("Incorrect vector mode: " + vector_mode)
958 lookup_table.Discretize = 0
959 lookup_table.ColorSpace = 'HSV'
960 lookup_table.LockScalarRange = 0
965 def get_group_mesh_name(full_group_name):
966 """Return mesh name of the group by its full name."""
967 aList = full_group_name.split('/')
969 group_name = full_group_name.split('/')[1]
973 def get_group_entity(full_group_name):
974 """Return entity type of the group by its full name."""
975 aList = full_group_name.split('/')
977 entity_name = full_group_name.split('/')[2]
978 entity = EntityType.get_type(entity_name)
982 def get_group_short_name(full_group_name):
983 """Return short name of the group by its full name."""
984 short_name = re.sub('^GRP_', '', full_group_name)
988 def get_mesh_full_names(proxy):
989 """Return all mesh names in the given proxy as a set."""
990 proxy.UpdatePipeline()
991 fields = proxy.GetProperty("FieldsTreeInfo")[::2]
992 mesh_full_names = set([item for item in fields if get_field_mesh_name(item) == get_field_short_name(item)])
993 return mesh_full_names
996 def get_group_names(extrGrps):
997 """Return full names of all groups of the given 'ExtractGroup' filter object.
999 group_names = filter(lambda x:x[:4]=="GRP_",list(extrGrps.GetProperty("GroupsFlagsInfo")[::2]))
1003 def get_time(proxy, timestamp_nb):
1004 """Get time value by timestamp number."""
1005 proxy.UpdatePipeline()
1006 # Check timestamp number
1009 if (hasattr(proxy, 'TimestepValues')):
1010 timestamps = proxy.TimestepValues.GetData()
1011 elif (hasattr(proxy.Input, 'TimestepValues')):
1012 timestamps = proxy.Input.TimestepValues.GetData()
1014 length = len(timestamps)
1015 if (timestamp_nb > 0 and (timestamp_nb - 1) not in xrange(length) ) or (timestamp_nb < 0 and -timestamp_nb > length):
1016 raise ValueError("Timestamp number is out of range: " + str(timestamp_nb))
1019 if timestamp_nb > 0:
1020 return timestamps[timestamp_nb - 1]
1022 return timestamps[timestamp_nb]
1024 def create_prs(prs_type, proxy, field_entity, field_name, timestamp_nb):
1025 """Auxiliary function.
1027 Build presentation of the given type on the given field and
1029 Set the presentation properties like visu.CreatePrsForResult() do.
1032 proxy.UpdatePipeline()
1035 if prs_type == PrsTypeEnum.SCALARMAP:
1036 prs = ScalarMapOnField(proxy, field_entity, field_name, timestamp_nb)
1037 elif prs_type == PrsTypeEnum.CUTPLANES:
1038 prs = CutPlanesOnField(proxy, field_entity, field_name, timestamp_nb,
1039 orientation=Orientation.ZX)
1040 elif prs_type == PrsTypeEnum.CUTLINES:
1041 prs = CutLinesOnField(proxy, field_entity, field_name, timestamp_nb,
1042 orientation1=Orientation.XY,
1043 orientation2=Orientation.ZX)
1044 elif prs_type == PrsTypeEnum.DEFORMEDSHAPE:
1045 prs = DeformedShapeOnField(proxy, field_entity,
1046 field_name, timestamp_nb)
1047 elif prs_type == PrsTypeEnum.DEFORMEDSHAPESCALARMAP:
1048 prs = DeformedShapeAndScalarMapOnField(proxy, field_entity,
1049 field_name, timestamp_nb)
1050 elif prs_type == PrsTypeEnum.VECTORS:
1051 prs = VectorsOnField(proxy, field_entity, field_name, timestamp_nb)
1052 elif prs_type == PrsTypeEnum.PLOT3D:
1053 prs = Plot3DOnField(proxy, field_entity, field_name, timestamp_nb)
1054 elif prs_type == PrsTypeEnum.ISOSURFACES:
1055 prs = IsoSurfacesOnField(proxy, field_entity, field_name, timestamp_nb)
1056 elif prs_type == PrsTypeEnum.GAUSSPOINTS:
1057 prs = GaussPointsOnField(proxy, field_entity, field_name, timestamp_nb)
1058 elif prs_type == PrsTypeEnum.STREAMLINES:
1059 prs = StreamLinesOnField(proxy, field_entity, field_name, timestamp_nb)
1061 raise ValueError("Unexistent presentation type.")
1066 # Functions for building Post-Pro presentations
1067 def ScalarMapOnField(proxy, entity, field_name, timestamp_nb,
1068 vector_mode='Magnitude'):
1069 """Creates Scalar Map presentation on the given field.
1072 proxy: the pipeline object, containig data
1073 entity: the entity type from PrsTypeEnum
1074 field_name: the field name
1075 timestamp_nb: the number of time step (1, 2, ...)
1076 vector_mode: the mode of transformation of vector values
1077 into scalar values, applicable only if the field contains vector values.
1078 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1081 Scalar Map as representation object.
1084 proxy.UpdatePipeline()
1085 # We don't need mesh parts with no data on them
1086 if entity == EntityType.NODE:
1087 select_cells_with_data(proxy, on_points=[field_name])
1089 select_cells_with_data(proxy, on_cells=[field_name])
1092 nb_components = get_nb_components(proxy, entity, field_name)
1093 check_vector_mode(vector_mode, nb_components)
1096 time_value = get_time(proxy, timestamp_nb)
1099 pvs.GetRenderView().ViewTime = time_value
1100 pvs.UpdatePipeline(time_value, proxy)
1102 # Get Scalar Map representation object
1103 scalarmap = pvs.GetRepresentation(proxy)
1106 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
1108 # Set field range if necessary
1109 data_range = get_data_range(proxy, entity,
1110 field_name, vector_mode)
1111 lookup_table.LockScalarRange = 1
1112 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
1114 scalarmap.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
1115 scalarmap.LookupTable = lookup_table
1118 bar_title = field_name + ", " + str(time_value)
1119 if (nb_components > 1):
1120 bar_title += "\n" + vector_mode
1121 add_scalar_bar(field_name, nb_components, vector_mode,
1122 lookup_table, time_value)
1127 def CutPlanesOnField(proxy, entity, field_name, timestamp_nb,
1128 nb_planes=10, orientation=Orientation.YZ,
1130 displacement=0.5, vector_mode='Magnitude'):
1131 """Creates Cut Planes presentation on the given field.
1134 proxy: the pipeline object, containig data
1135 entity: the entity type from PrsTypeEnum
1136 field_name: the field name
1137 timestamp_nb: the number of time step (1, 2, ...)
1138 nb_planes: number of cutting planes
1139 orientation: cutting planes orientation in 3D space
1140 angle1: rotation of the planes in 3d space around the first axis of the
1141 selected orientation (X axis for XY, Y axis for YZ, Z axis for ZX).
1142 The angle of rotation is set in degrees. Acceptable range: [-45, 45].
1143 angle2: rotation of the planes in 3d space around the second axis of the
1144 selected orientation. Acceptable range: [-45, 45].
1145 displacement: the displacement of the planes into one or another side
1146 vector_mode: the mode of transformation of vector values
1147 into scalar values, applicable only if the field contains vector values.
1148 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1151 Cut Planes as representation object.
1154 proxy.UpdatePipeline()
1155 if entity == EntityType.NODE:
1156 select_cells_with_data(proxy, on_points=[field_name])
1158 select_cells_with_data(proxy, on_cells=[field_name])
1161 nb_components = get_nb_components(proxy, entity, field_name)
1162 check_vector_mode(vector_mode, nb_components)
1165 time_value = get_time(proxy, timestamp_nb)
1168 pvs.GetRenderView().ViewTime = time_value
1169 pvs.UpdatePipeline(time_value, proxy)
1171 # Create slice filter
1172 slice_filter = pvs.Slice(proxy)
1173 slice_filter.SliceType = "Plane"
1175 # Set cut planes normal
1176 normal = get_normal_by_orientation(orientation,
1177 radians(angle1), radians(angle2))
1178 slice_filter.SliceType.Normal = normal
1180 # Set cut planes positions
1181 positions = get_positions(nb_planes, normal,
1182 get_bounds(proxy), displacement)
1183 slice_filter.SliceOffsetValues = positions
1185 # Get Cut Planes representation object
1186 cut_planes = pvs.GetRepresentation(slice_filter)
1189 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
1191 # Set field range if necessary
1192 data_range = get_data_range(proxy, entity,
1193 field_name, vector_mode)
1194 lookup_table.LockScalarRange = 1
1195 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
1198 cut_planes.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
1199 cut_planes.LookupTable = lookup_table
1202 add_scalar_bar(field_name, nb_components,
1203 vector_mode, lookup_table, time_value)
1208 def CutLinesOnField(proxy, entity, field_name, timestamp_nb,
1210 orientation1=Orientation.XY,
1211 base_angle1=0, base_angle2=0,
1212 orientation2=Orientation.YZ,
1213 cut_angle1=0, cut_angle2=0,
1214 displacement1=0.5, displacement2=0.5,
1215 generate_curves=False,
1216 vector_mode='Magnitude'):
1217 """Creates Cut Lines presentation on the given field.
1220 proxy: the pipeline object, containig data
1221 entity: the entity type from PrsTypeEnum
1222 field_name: the field name
1223 timestamp_nb: the number of time step (1, 2, ...)
1224 nb_lines: number of lines
1225 orientation1: base plane orientation in 3D space
1226 base_angle1: rotation of the base plane in 3d space around the first
1227 axis of the orientation1 (X axis for XY, Y axis for YZ, Z axis for ZX).
1228 The angle of rotation is set in degrees. Acceptable range: [-45, 45].
1229 base_angle2: rotation of the base plane in 3d space around the second
1230 axis of the orientation1. Acceptable range: [-45, 45].
1231 orientation2: cutting planes orientation in 3D space
1232 cut_angle1: rotation of the cut planes in 3d space around the first
1233 axis of the orientation2. Acceptable range: [-45, 45].
1234 cut_angle2: rotation of the cuting planes in 3d space around the second
1235 axis of the orientation2. Acceptable range: [-45, 45].
1236 displacement1: base plane displacement
1237 displacement2: cutting planes displacement
1238 generate_curves: if true, 'PlotOverLine' filter will be created
1240 vector_mode: the mode of transformation of vector values
1241 into scalar values, applicable only if the field contains vector values.
1242 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1245 Cut Lines as representation object if generate_curves == False,
1246 (Cut Lines as representation object, list of 'PlotOverLine') otherwise
1249 proxy.UpdatePipeline()
1250 if entity == EntityType.NODE:
1251 select_cells_with_data(proxy, on_points=[field_name])
1253 select_cells_with_data(proxy, on_cells=[field_name])
1256 nb_components = get_nb_components(proxy, entity, field_name)
1257 check_vector_mode(vector_mode, nb_components)
1260 time_value = get_time(proxy, timestamp_nb)
1263 pvs.GetRenderView().ViewTime = time_value
1264 pvs.UpdatePipeline(time_value, proxy)
1267 base_plane = pvs.Slice(proxy)
1268 base_plane.SliceType = "Plane"
1270 # Set base plane normal
1271 base_normal = get_normal_by_orientation(orientation1,
1272 radians(base_angle1),
1273 radians(base_angle2))
1274 base_plane.SliceType.Normal = base_normal
1276 # Set base plane position
1277 base_position = get_positions(1, base_normal,
1278 get_bounds(proxy), displacement1)
1279 base_plane.SliceOffsetValues = base_position
1282 base_plane.UpdatePipeline()
1283 if (base_plane.GetDataInformation().GetNumberOfCells() == 0):
1286 # Create cutting planes
1287 cut_planes = pvs.Slice(base_plane)
1288 cut_planes.SliceType = "Plane"
1290 # Set cutting planes normal and get positions
1291 cut_normal = get_normal_by_orientation(orientation2,
1292 radians(cut_angle1),
1293 radians(cut_angle2))
1294 cut_planes.SliceType.Normal = cut_normal
1296 # Set cutting planes position
1297 cut_positions = get_positions(nb_lines, cut_normal,
1298 get_bounds(base_plane), displacement2)
1304 for pos in cut_positions:
1305 # Get points for plot over line objects
1306 cut_planes.SliceOffsetValues = pos
1307 cut_planes.UpdatePipeline()
1308 bounds = get_bounds(cut_planes)
1309 point1 = [bounds[0], bounds[2], bounds[4]]
1310 point2 = [bounds[1], bounds[3], bounds[5]]
1312 # Create plot over line filter
1313 pol = pvs.PlotOverLine(cut_planes,
1314 Source="High Resolution Line Source")
1315 pvs.RenameSource('Y' + str(index), pol)
1316 pol.Source.Point1 = point1
1317 pol.Source.Point2 = point2
1318 pol.UpdatePipeline()
1323 cut_planes.SliceOffsetValues = cut_positions
1324 cut_planes.UpdatePipeline()
1326 # Get Cut Lines representation object
1327 cut_lines = pvs.GetRepresentation(cut_planes)
1330 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
1332 # Set field range if necessary
1333 data_range = get_data_range(proxy, entity,
1334 field_name, vector_mode)
1335 lookup_table.LockScalarRange = 1
1336 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
1339 cut_lines.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
1340 cut_lines.LookupTable = lookup_table
1342 # Set wireframe represenatation mode
1343 cut_lines.Representation = 'Wireframe'
1346 add_scalar_bar(field_name, nb_components,
1347 vector_mode, lookup_table, time_value)
1350 # If curves were generated return tuple (cut lines, list of curves)
1352 result = cut_lines, curves
1357 def CutSegmentOnField(proxy, entity, field_name, timestamp_nb,
1358 point1, point2, vector_mode='Magnitude'):
1359 """Creates Cut Segment presentation on the given field.
1362 proxy: the pipeline object, containig data
1363 entity: the entity type from PrsTypeEnum
1364 field_name: the field name
1365 timestamp_nb: the number of time step (1, 2, ...)
1366 point1: set the first point of the segment (as [x, y, z])
1367 point1: set the second point of the segment (as [x, y, z])
1368 vector_mode: the mode of transformation of vector values
1369 into scalar values, applicable only if the field contains vector values.
1370 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1373 Cut Segment as 3D representation object.
1376 proxy.UpdatePipeline()
1377 if entity == EntityType.NODE:
1378 select_cells_with_data(proxy, on_points=[field_name])
1380 select_cells_with_data(proxy, on_cells=[field_name])
1383 nb_components = get_nb_components(proxy, entity, field_name)
1384 check_vector_mode(vector_mode, nb_components)
1387 time_value = get_time(proxy, timestamp_nb)
1390 pvs.GetRenderView().ViewTime = time_value
1391 pvs.UpdatePipeline(time_value, proxy)
1393 # Create plot over line filter
1394 pol = pvs.PlotOverLine(proxy, Source="High Resolution Line Source")
1395 pol.Source.Point1 = point1
1396 pol.Source.Point2 = point2
1397 pol.UpdatePipeline()
1399 # Get Cut Segment representation object
1400 cut_segment = pvs.GetRepresentation(pol)
1403 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
1405 # Set field range if necessary
1406 data_range = get_data_range(proxy, entity,
1407 field_name, vector_mode)
1408 lookup_table.LockScalarRange = 1
1409 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
1412 cut_segment.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
1413 cut_segment.LookupTable = lookup_table
1415 # Set wireframe represenatation mode
1416 cut_segment.Representation = 'Wireframe'
1419 add_scalar_bar(field_name, nb_components,
1420 vector_mode, lookup_table, time_value)
1425 def VectorsOnField(proxy, entity, field_name, timestamp_nb,
1427 glyph_pos=GlyphPos.TAIL, glyph_type='2D Glyph',
1428 is_colored=False, vector_mode='Magnitude'):
1429 """Creates Vectors presentation on the given field.
1432 proxy: the pipeline object, containig data
1433 entity: the entity type from PrsTypeEnum
1434 field_name: the field name
1435 timestamp_nb: the number of time step (1, 2, ...)
1436 scale_factor: scale factor
1437 glyph_pos: the position of glyphs
1438 glyph_type: the type of glyphs
1439 is_colored: this option allows to color the presentation according to
1440 the corresponding data array values
1441 vector_mode: the mode of transformation of vector values
1442 into scalar values, applicable only if the field contains vector values.
1443 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1446 Vectors as representation object.
1449 proxy.UpdatePipeline()
1450 if entity == EntityType.NODE:
1451 select_cells_with_data(proxy, on_points=[field_name])
1453 select_cells_with_data(proxy, on_cells=[field_name])
1456 nb_components = get_nb_components(proxy, entity, field_name)
1457 check_vector_mode(vector_mode, nb_components)
1460 time_value = get_time(proxy, timestamp_nb)
1463 pvs.GetRenderView().ViewTime = time_value
1464 pvs.UpdatePipeline(time_value, proxy)
1466 # Extract only groups with data for the field
1470 if is_data_on_cells(proxy, field_name):
1471 cell_centers = pvs.CellCenters(source)
1472 cell_centers.VertexCells = 1
1473 source = cell_centers
1475 vector_array = field_name
1476 # If the given vector array has only 2 components, add the third one
1477 if nb_components == 2:
1478 calc = get_add_component_calc(source, EntityType.NODE, field_name)
1479 vector_array = calc.ResultArrayName
1483 glyph = pvs.Glyph(source)
1484 glyph.Vectors = vector_array
1485 glyph.ScaleMode = 'vector'
1486 #glyph.MaskPoints = 0
1489 glyph.GlyphType = glyph_type
1490 if glyph_type == '2D Glyph':
1491 glyph.GlyphType.GlyphType = 'Arrow'
1492 elif glyph_type == 'Cone':
1493 glyph.GlyphType.Resolution = 7
1494 glyph.GlyphType.Height = 2
1495 glyph.GlyphType.Radius = 0.2
1497 # Set glyph position if possible
1498 if glyph.GlyphType.GetProperty("Center"):
1499 if (glyph_pos == GlyphPos.TAIL):
1500 glyph.GlyphType.Center = [0.5, 0.0, 0.0]
1501 elif (glyph_pos == GlyphPos.HEAD):
1502 glyph.GlyphType.Center = [-0.5, 0.0, 0.0]
1503 elif (glyph_pos == GlyphPos.CENTER):
1504 glyph.GlyphType.Center = [0.0, 0.0, 0.0]
1506 if scale_factor is not None:
1507 glyph.ScaleFactor = scale_factor
1509 def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE,
1510 proxy, entity, field_name)
1511 glyph.ScaleFactor = def_scale
1513 glyph.UpdatePipeline()
1515 # Get Vectors representation object
1516 vectors = pvs.GetRepresentation(glyph)
1519 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
1521 # Set field range if necessary
1522 data_range = get_data_range(proxy, entity,
1523 field_name, vector_mode)
1524 lookup_table.LockScalarRange = 1
1525 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
1529 vectors.ColorArrayName = 'GlyphVector'
1531 vectors.ColorArrayName = ''
1532 vectors.LookupTable = lookup_table
1534 vectors.LineWidth = 1.0
1536 # Set wireframe represenatation mode
1537 vectors.Representation = 'Wireframe'
1540 add_scalar_bar(field_name, nb_components,
1541 vector_mode, lookup_table, time_value)
1546 def DeformedShapeOnField(proxy, entity, field_name,
1548 scale_factor=None, is_colored=False,
1549 vector_mode='Magnitude'):
1550 """Creates Defromed Shape presentation on the given field.
1553 proxy: the pipeline object, containig data
1554 entity: the entity type from PrsTypeEnum
1555 field_name: the field name
1556 timestamp_nb: the number of time step (1, 2, ...)
1557 scale_factor: scale factor of the deformation
1558 is_colored: this option allows to color the presentation according to
1559 the corresponding data array values
1560 vector_mode: the mode of transformation of vector values
1561 into scalar values, applicable only if the field contains vector values.
1562 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1565 Defromed Shape as representation object.
1568 proxy.UpdatePipeline()
1569 # We don't need mesh parts with no data on them
1570 if entity == EntityType.NODE:
1571 select_cells_with_data(proxy, on_points=[field_name])
1573 select_cells_with_data(proxy, on_cells=[field_name])
1576 nb_components = get_nb_components(proxy, entity, field_name)
1577 check_vector_mode(vector_mode, nb_components)
1580 time_value = get_time(proxy, timestamp_nb)
1583 pvs.GetRenderView().ViewTime = time_value
1584 pvs.UpdatePipeline(time_value, proxy)
1587 source = pvs.MergeBlocks(proxy)
1589 # Cell data to point data
1590 if is_data_on_cells(proxy, field_name):
1591 cell_to_point = pvs.CellDatatoPointData()
1592 cell_to_point.PassCellData = 1
1593 source = cell_to_point
1595 vector_array = field_name
1596 # If the given vector array has only 2 components, add the third one
1597 if nb_components == 2:
1598 calc = get_add_component_calc(source, EntityType.NODE, field_name)
1599 vector_array = calc.ResultArrayName
1603 warp_vector = pvs.WarpByVector(source)
1604 warp_vector.Vectors = [vector_array]
1605 if scale_factor is not None:
1606 warp_vector.ScaleFactor = scale_factor
1608 def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE,
1609 proxy, entity, field_name)
1610 warp_vector.ScaleFactor = def_scale
1612 # Get Deformed Shape representation object
1613 defshape = pvs.GetRepresentation(warp_vector)
1616 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
1618 # Set field range if necessary
1619 data_range = get_data_range(proxy, entity,
1620 field_name, vector_mode)
1621 lookup_table.LockScalarRange = 1
1622 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
1626 defshape.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
1628 defshape.ColorArrayName = ''
1629 defshape.LookupTable = lookup_table
1631 # Set wireframe represenatation mode
1632 defshape.Representation = 'Wireframe'
1635 add_scalar_bar(field_name, nb_components,
1636 vector_mode, lookup_table, time_value)
1641 def DeformedShapeAndScalarMapOnField(proxy, entity, field_name,
1645 scalar_field_name=None,
1646 vector_mode='Magnitude'):
1647 """Creates Defromed Shape And Scalar Map presentation on the given field.
1650 proxy: the pipeline object, containig data
1651 entity: the entity type from PrsTypeEnum
1652 field_name: the field name
1653 timestamp_nb: the number of time step (1, 2, ...)
1654 scale_factor: scale factor of the deformation
1655 scalar_entity: scalar field entity
1656 scalar_field_name: scalar field, i.e. the field for coloring
1657 vector_mode: the mode of transformation of vector values
1658 into scalar values, applicable only if the field contains vector values.
1659 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1662 Defromed Shape And Scalar Map as representation object.
1665 proxy.UpdatePipeline()
1666 # We don't need mesh parts with no data on them
1670 if entity == EntityType.NODE:
1671 on_points.append(field_name)
1673 on_cells.append(field_name)
1675 if scalar_entity and scalar_field_name:
1676 if scalar_entity == EntityType.NODE:
1677 on_points.append(scalar_field_name)
1679 on_cells.append(scalar_field_name)
1681 nb_components = get_nb_components(proxy, entity, field_name)
1684 select_cells_with_data(proxy, on_points, on_cells)
1687 check_vector_mode(vector_mode, nb_components)
1690 time_value = get_time(proxy, timestamp_nb)
1693 pvs.GetRenderView().ViewTime = time_value
1694 pvs.UpdatePipeline(time_value, proxy)
1696 # Set scalar field by default
1697 scalar_field_entity = scalar_entity
1698 scalar_field = scalar_field_name
1699 if (scalar_field_entity is None) or (scalar_field is None):
1700 scalar_field_entity = entity
1701 scalar_field = field_name
1704 source = pvs.MergeBlocks(proxy)
1706 # Cell data to point data
1707 if is_data_on_cells(proxy, field_name):
1708 cell_to_point = pvs.CellDatatoPointData(source)
1709 cell_to_point.PassCellData = 1
1710 source = cell_to_point
1712 vector_array = field_name
1713 # If the given vector array has only 2 components, add the third one
1714 if nb_components == 2:
1715 calc = get_add_component_calc(source, EntityType.NODE, field_name)
1716 vector_array = calc.ResultArrayName
1720 warp_vector = pvs.WarpByVector(source)
1721 warp_vector.Vectors = [vector_array]
1722 if scale_factor is not None:
1723 warp_vector.ScaleFactor = scale_factor
1725 def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE,
1726 proxy, entity, field_name)
1727 warp_vector.ScaleFactor = def_scale
1729 # Get Defromed Shape And Scalar Map representation object
1730 defshapemap = pvs.GetRepresentation(warp_vector)
1733 lookup_table = get_lookup_table(scalar_field, nb_components, vector_mode)
1735 # Set field range if necessary
1736 data_range = get_data_range(proxy, scalar_field_entity,
1737 scalar_field, vector_mode)
1738 lookup_table.LockScalarRange = 1
1739 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
1742 defshapemap.ColorArrayName = (EntityType.get_pvtype(scalar_field_entity), scalar_field)
1743 defshapemap.LookupTable = lookup_table
1746 add_scalar_bar(field_name, nb_components,
1747 vector_mode, lookup_table, time_value)
1752 def Plot3DOnField(proxy, entity, field_name, timestamp_nb,
1753 orientation=Orientation.AUTO,
1755 position=0.5, is_relative=True,
1757 is_contour=False, nb_contours=32,
1758 vector_mode='Magnitude'):
1759 """Creates Plot 3D presentation on the given field.
1762 proxy: the pipeline object, containig data
1763 entity: the entity type from PrsTypeEnum
1764 field_name: the field name
1765 timestamp_nb: the number of time step (1, 2, ...)
1766 orientation: the cut plane plane orientation in 3D space, if
1767 the input is planar - will not be taken into account
1768 angle1: rotation of the cut plane in 3d space around the first axis
1769 of the selected orientation (X axis for XY, Y axis for YZ,
1771 The angle of rotation is set in degrees. Acceptable range: [-45, 45].
1772 angle2: rotation of the cut plane in 3d space around the second axis
1773 of the selected orientation. Acceptable range: [-45, 45].
1774 position: position of the cut plane in the object (ranging from 0 to 1).
1775 The value 0.5 corresponds to cutting by halves.
1776 is_relative: defines if the cut plane position is relative or absolute
1777 scale_factor: deformation scale factor
1778 is_contour: if True - Plot 3D will be represented with a set of contours,
1779 otherwise - Plot 3D will be represented with a smooth surface
1780 nb_contours: number of contours, applied if is_contour is True
1781 vector_mode: the mode of transformation of vector values
1782 into scalar values, applicable only if the field contains vector values.
1783 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1786 Plot 3D as representation object.
1789 proxy.UpdatePipeline()
1790 # We don't need mesh parts with no data on them
1791 if entity == EntityType.NODE:
1792 select_cells_with_data(proxy, on_points=[field_name])
1794 select_cells_with_data(proxy, on_cells=[field_name])
1797 nb_components = get_nb_components(proxy, entity, field_name)
1798 check_vector_mode(vector_mode, nb_components)
1801 time_value = get_time(proxy, timestamp_nb)
1804 pvs.GetRenderView().ViewTime = time_value
1805 pvs.UpdatePipeline(time_value, proxy)
1808 merge_blocks = pvs.MergeBlocks(proxy)
1809 merge_blocks.UpdatePipeline()
1815 # Define orientation if necessary (auto mode)
1816 plane_orientation = orientation
1817 if (orientation == Orientation.AUTO):
1818 plane_orientation = get_orientation(proxy)
1820 # Get cutting plane normal
1823 if (not is_planar_input(proxy)):
1824 normal = get_normal_by_orientation(plane_orientation,
1825 radians(angle1), radians(angle2))
1827 # Create slice filter
1828 slice_filter = pvs.Slice(merge_blocks)
1829 slice_filter.SliceType = "Plane"
1831 # Set cutting plane normal
1832 slice_filter.SliceType.Normal = normal
1834 # Set cutting plane position
1836 base_position = get_positions(1, normal,
1837 get_bounds(proxy), position)
1838 slice_filter.SliceOffsetValues = base_position
1840 slice_filter.SliceOffsetValues = position
1842 slice_filter.UpdatePipeline()
1843 poly_data = slice_filter
1845 normal = get_normal_by_orientation(plane_orientation, 0, 0)
1849 if not poly_data or poly_data.GetDataInformation().GetNumberOfCells() == 0:
1850 geometry_filter = pvs.GeometryFilter(merge_blocks)
1851 poly_data = geometry_filter
1852 use_normal = 1 # TODO(MZN): workaround
1858 if is_data_on_cells(poly_data, field_name):
1859 # Cell data to point data
1860 cell_to_point = pvs.CellDatatoPointData(poly_data)
1861 cell_to_point.PassCellData = 1
1862 source = cell_to_point
1864 scalars = ['POINTS', field_name]
1866 # Transform vector array to scalar array if necessary
1867 if (nb_components > 1):
1868 calc = get_calc_magnitude(source, EntityType.NODE, field_name)
1869 scalars = ['POINTS', calc.ResultArrayName]
1873 warp_scalar = pvs.WarpByScalar(source)
1874 warp_scalar.Scalars = scalars
1875 warp_scalar.Normal = normal
1876 warp_scalar.UseNormal = use_normal
1877 if scale_factor is not None:
1878 warp_scalar.ScaleFactor = scale_factor
1880 def_scale = get_default_scale(PrsTypeEnum.PLOT3D,
1881 proxy, entity, field_name)
1882 warp_scalar.ScaleFactor = def_scale
1884 warp_scalar.UpdatePipeline()
1885 source = warp_scalar
1889 contour = pvs.Contour(warp_scalar)
1890 contour.PointMergeMethod = "Uniform Binning"
1891 contour.ContourBy = ['POINTS', field_name]
1892 scalar_range = get_data_range(proxy, entity,
1893 field_name, vector_mode)
1894 contour.Isosurfaces = get_contours(scalar_range, nb_contours)
1895 contour.UpdatePipeline()
1898 # Get Plot 3D representation object
1899 plot3d = pvs.GetRepresentation(source)
1902 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
1904 # Set field range if necessary
1905 data_range = get_data_range(proxy, entity,
1906 field_name, vector_mode)
1907 lookup_table.LockScalarRange = 1
1908 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
1911 plot3d.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
1912 plot3d.LookupTable = lookup_table
1915 add_scalar_bar(field_name, nb_components,
1916 vector_mode, lookup_table, time_value)
1921 def IsoSurfacesOnField(proxy, entity, field_name, timestamp_nb,
1922 custom_range=None, nb_surfaces=10,
1923 is_colored=True, color=None, vector_mode='Magnitude'):
1924 """Creates Iso Surfaces presentation on the given field.
1927 proxy: the pipeline object, containig data
1928 entity: the entity type from PrsTypeEnum
1929 field_name: the field name
1930 timestamp_nb: the number of time step (1, 2, ...)
1931 custom_range: scalar range, if undefined the source range will be applied
1932 nb_surfaces: number of surfaces, which will be generated
1933 is_colored: this option allows to color the presentation according to
1934 the corresponding data array values. If False - the presentation will
1936 color: defines the presentation color as [R, G, B] triple. Taken into
1937 account only if is_colored is False.
1938 vector_mode: the mode of transformation of vector values
1939 into scalar values, applicable only if the field contains vector values.
1940 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
1943 Iso Surfaces as representation object.
1946 proxy.UpdatePipeline()
1947 # We don't need mesh parts with no data on them
1948 if entity == EntityType.NODE:
1949 select_cells_with_data(proxy, on_points=[field_name])
1951 select_cells_with_data(proxy, on_cells=[field_name])
1954 nb_components = get_nb_components(proxy, entity, field_name)
1955 check_vector_mode(vector_mode, nb_components)
1958 time_value = get_time(proxy, timestamp_nb)
1961 pvs.GetRenderView().ViewTime = time_value
1962 pvs.UpdatePipeline(time_value, proxy)
1965 source = pvs.MergeBlocks(proxy)
1967 # Transform cell data into point data if necessary
1968 if is_data_on_cells(proxy, field_name):
1969 cell_to_point = pvs.CellDatatoPointData(source)
1970 cell_to_point.PassCellData = 1
1971 source = cell_to_point
1973 contour_by = ['POINTS', field_name]
1975 # Transform vector array to scalar array if necessary
1976 if (nb_components > 1):
1977 calc = get_calc_magnitude(source, EntityType.NODE, field_name)
1978 contour_by = ['POINTS', calc.ResultArrayName]
1981 # Contour filter settings
1982 contour = pvs.Contour(source)
1983 contour.ComputeScalars = 1
1984 contour.ContourBy = contour_by
1987 scalar_range = custom_range
1988 if (scalar_range is None):
1989 scalar_range = get_data_range(proxy, entity,
1990 field_name, cut_off=True)
1992 # Get contour values for the range
1993 surfaces = get_contours(scalar_range, nb_surfaces)
1995 # Set contour values
1996 contour.Isosurfaces = surfaces
1998 # Get Iso Surfaces representation object
1999 isosurfaces = pvs.GetRepresentation(contour)
2002 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
2004 # Set field range if necessary
2005 data_range = get_data_range(proxy, entity,
2006 field_name, vector_mode)
2007 lookup_table.LockScalarRange = 1
2008 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
2010 # Set display properties
2012 isosurfaces.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
2014 isosurfaces.ColorArrayName = ''
2016 isosurfaces.DiffuseColor = color
2017 isosurfaces.LookupTable = lookup_table
2020 add_scalar_bar(field_name, nb_components,
2021 vector_mode, lookup_table, time_value)
2026 def GaussPointsOnField(proxy, entity, field_name,
2028 is_deformed=True, scale_factor=None,
2029 is_colored=True, color=None,
2030 primitive=GaussType.SPRITE,
2031 is_proportional=True,
2033 multiplier=None, vector_mode='Magnitude'):
2034 """Creates Gauss Points on the given field.
2038 proxy: the pipeline object, containig data
2039 entity: the field entity type from PrsTypeEnum
2040 field_name: the field name
2041 timestamp_nb: the number of time step (1, 2, ...)
2042 is_deformed: defines whether the Gauss Points will be deformed or not
2043 scale_factor -- the scale factor for deformation. Will be taken into
2044 account only if is_deformed is True.
2045 If not passed by user, default scale will be computed.
2046 is_colored -- defines whether the Gauss Points will be multicolored,
2047 using the corresponding data values
2048 color: defines the presentation color as [R, G, B] triple. Taken into
2049 account only if is_colored is False.
2050 primitive: primitive type from GaussType
2051 is_proportional: if True, the size of primitives will depends on
2052 the gauss point value
2053 max_pixel_size: the maximum sizr of the Gauss Points primitive in pixels
2054 multiplier: coefficient between data values and the size of primitives
2055 If not passed by user, default scale will be computed.
2056 vector_mode: the mode of transformation of vector values into
2057 scalar values, applicable only if the field contains vector values.
2058 Possible modes: 'Magnitude' - vector module;
2059 'X', 'Y', 'Z' - vector components.
2062 Gauss Points as representation object.
2065 proxy.UpdatePipeline()
2066 # We don't need mesh parts with no data on them
2067 on_gauss = select_cells_with_data(proxy, on_gauss=[field_name])
2069 if entity == EntityType.NODE:
2070 select_cells_with_data(proxy, on_points=[field_name])
2072 select_cells_with_data(proxy, on_cells=[field_name])
2075 nb_components = get_nb_components(proxy, entity, field_name)
2076 check_vector_mode(vector_mode, nb_components)
2079 time_value = get_time(proxy, timestamp_nb)
2082 pvs.GetRenderView().ViewTime = time_value
2083 proxy.UpdatePipeline(time=time_value)
2087 # If no quadrature point array is passed, use cell centers
2089 generate_qp = pvs.GenerateQuadraturePoints(source)
2090 generate_qp.QuadratureSchemeDef = ['CELLS', 'ELGA@0']
2091 source = generate_qp
2094 cell_centers = pvs.CellCenters(source)
2095 cell_centers.VertexCells = 1
2096 source = cell_centers
2098 source.UpdatePipeline()
2100 # Check if deformation enabled
2101 if is_deformed and nb_components > 1:
2102 vector_array = field_name
2103 # If the given vector array has only 2 components, add the third one
2104 if nb_components == 2:
2105 calc = get_add_component_calc(source,
2106 EntityType.NODE, field_name)
2107 vector_array = calc.ResultArrayName
2111 warp_vector = pvs.WarpByVector(source)
2112 warp_vector.Vectors = [vector_array]
2113 if scale_factor is not None:
2114 warp_vector.ScaleFactor = scale_factor
2116 def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, proxy,
2118 warp_vector.ScaleFactor = def_scale
2119 warp_vector.UpdatePipeline()
2120 source = warp_vector
2122 # Get Gauss Points representation object
2123 gausspnt = pvs.GetRepresentation(source)
2126 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
2128 # Set field range if necessary
2129 data_range = get_data_range(proxy, entity,
2130 field_name, vector_mode)
2131 lookup_table.LockScalarRange = 1
2132 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
2134 # Set display properties
2136 gausspnt.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
2138 gausspnt.ColorArrayName = ''
2140 gausspnt.DiffuseColor = color
2142 gausspnt.LookupTable = lookup_table
2145 add_scalar_bar(field_name, nb_components,
2146 vector_mode, lookup_table, time_value)
2148 # Set point sprite representation
2149 gausspnt.Representation = 'Point Sprite'
2151 # Point sprite settings
2152 gausspnt.InterpolateScalarsBeforeMapping = 0
2153 gausspnt.MaxPixelSize = max_pixel_size
2156 gausspnt.RenderMode = GaussType.get_mode(primitive)
2158 #if primitive == GaussType.SPRITE:
2160 # TODO(MZN): replace with pvsimple high-level interface
2161 # texture = sm.CreateProxy("textures", "SpriteTexture")
2162 # alphamprop = texture.GetProperty("AlphaMethod")
2163 # alphamprop.SetElement(0, 2) # Clamp
2164 # alphatprop = texture.GetProperty("AlphaThreshold")
2165 # alphatprop.SetElement(0, 63)
2166 # maxprop = texture.GetProperty("Maximum")
2167 # maxprop.SetElement(0, 255)
2168 # texture.UpdateVTKObjects()
2170 # gausspnt.Texture = texture
2171 #gausspnt.Texture.AlphaMethod = 'Clamp'
2172 #gausspnt.Texture.AlphaThreshold = 63
2173 #gausspnt.Texture.Maximum= 255
2175 # Proportional radius
2176 gausspnt.RadiusUseScalarRange = 0
2177 gausspnt.RadiusIsProportional = 0
2182 mult = abs(0.1 / data_range[1])
2184 gausspnt.RadiusScalarRange = data_range
2185 gausspnt.RadiusTransferFunctionEnabled = 1
2186 gausspnt.RadiusMode = 'Scalar'
2187 gausspnt.RadiusArray = ['POINTS', field_name]
2188 if nb_components > 1:
2189 v_comp = get_vector_component(vector_mode)
2190 gausspnt.RadiusVectorComponent = v_comp
2191 gausspnt.RadiusTransferFunctionMode = 'Table'
2192 gausspnt.RadiusScalarRange = data_range
2193 gausspnt.RadiusUseScalarRange = 1
2194 gausspnt.RadiusIsProportional = 1
2195 gausspnt.RadiusProportionalFactor = mult
2197 gausspnt.RadiusTransferFunctionEnabled = 0
2198 gausspnt.RadiusMode = 'Constant'
2199 gausspnt.RadiusArray = ['POINTS', 'Constant Radius']
2203 def GaussPointsOnField1(proxy, entity, field_name,
2205 is_colored=True, color=None,
2206 primitive=GaussType.SPHERE,
2207 is_proportional=True,
2210 vector_mode='Magnitude'):
2211 """Creates Gauss Points on the given field. Use GaussPoints() Paraview interface.
2214 proxy: the pipeline object, containig data
2215 entity: the field entity type from PrsTypeEnum
2216 field_name: the field name
2217 timestamp_nb: the number of time step (1, 2, ...)
2218 is_colored -- defines whether the Gauss Points will be multicolored,
2219 using the corresponding data values
2220 color: defines the presentation color as [R, G, B] triple. Taken into
2221 account only if is_colored is False.
2222 primitive: primitive type from GaussType
2223 is_proportional: if True, the size of primitives will depends on
2224 the gauss point value
2225 max_pixel_size: the maximum sizr of the Gauss Points primitive in pixels
2226 multiplier: coefficient between data values and the size of primitives
2227 If not passed by user, default scale will be computed.
2228 vector_mode: the mode of transformation of vector values into
2229 scalar values, applicable only if the field contains vector values.
2230 Possible modes: 'Magnitude' - vector module;
2231 'X', 'Y', 'Z' - vector components.
2234 Gauss Points as representation object.
2237 proxy.UpdatePipeline()
2238 select_cells_with_data(proxy, on_gauss=[field_name])
2240 nb_components = get_nb_components(proxy, entity, field_name)
2243 time_value = get_time(proxy, timestamp_nb)
2246 pvs.GetRenderView().ViewTime = time_value
2247 proxy.UpdatePipeline(time=time_value)
2249 # Create Gauss Points object
2250 source = pvs.GaussPoints(proxy)
2251 source.UpdatePipeline()
2253 # Get Gauss Points representation object
2254 gausspnt = pvs.GetRepresentation(source)
2257 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
2259 # Set field range if necessary
2260 data_range = get_data_range(proxy, entity,
2261 field_name, vector_mode)
2262 lookup_table.LockScalarRange = 1
2263 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
2265 # Set display properties
2267 gausspnt.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
2269 gausspnt.ColorArrayName = ''
2271 gausspnt.DiffuseColor = color
2273 gausspnt.LookupTable = lookup_table
2276 add_scalar_bar(field_name, nb_components,
2277 vector_mode, lookup_table, time_value)
2279 # Set point sprite representation
2280 gausspnt.Representation = 'Point Sprite'
2282 # Point sprite settings
2283 gausspnt.InterpolateScalarsBeforeMapping = 0
2284 gausspnt.MaxPixelSize = max_pixel_size
2287 gausspnt.RenderMode = GaussType.get_mode(primitive)
2289 #if primitive == GaussType.SPRITE:
2291 # TODO(MZN): replace with pvsimple high-level interface
2292 # texture = sm.CreateProxy("textures", "SpriteTexture")
2293 # alphamprop = texture.GetProperty("AlphaMethod")
2294 # alphamprop.SetElement(0, 2) # Clamp
2295 # alphatprop = texture.GetProperty("AlphaThreshold")
2296 # alphatprop.SetElement(0, 63)
2297 # maxprop = texture.GetProperty("Maximum")
2298 # maxprop.SetElement(0, 255)
2299 # texture.UpdateVTKObjects()
2301 # gausspnt.Texture = texture
2302 #gausspnt.Texture.AlphaMethod = 'Clamp'
2303 #gausspnt.Texture.AlphaThreshold = 63
2304 #gausspnt.Texture.Maximum= 255
2306 # Proportional radius
2307 gausspnt.RadiusUseScalarRange = 0
2308 gausspnt.RadiusIsProportional = 0
2313 mult = abs(0.1 / data_range[1])
2315 gausspnt.RadiusScalarRange = data_range
2316 gausspnt.RadiusTransferFunctionEnabled = 1
2317 gausspnt.RadiusMode = 'Scalar'
2318 gausspnt.RadiusArray = ['POINTS', field_name]
2319 if nb_components > 1:
2320 v_comp = get_vector_component(vector_mode)
2321 gausspnt.RadiusVectorComponent = v_comp
2322 gausspnt.RadiusTransferFunctionMode = 'Table'
2323 gausspnt.RadiusScalarRange = data_range
2324 gausspnt.RadiusUseScalarRange = 1
2325 gausspnt.RadiusIsProportional = 1
2326 gausspnt.RadiusProportionalFactor = mult
2328 gausspnt.RadiusTransferFunctionEnabled = 0
2329 gausspnt.RadiusMode = 'Constant'
2330 gausspnt.RadiusArray = ['POINTS', 'Constant Radius']
2334 def StreamLinesOnField(proxy, entity, field_name, timestamp_nb,
2335 direction='BOTH', is_colored=False, color=None,
2336 vector_mode='Magnitude'):
2337 """Creates Stream Lines presentation on the given field.
2340 proxy: the pipeline object, containig data
2341 entity: the entity type from PrsTypeEnum
2342 field_name: the field name
2343 timestamp_nb: the number of time step (1, 2, ...)
2344 direction: the stream lines direction ('FORWARD', 'BACKWARD' or 'BOTH')
2345 is_colored: this option allows to color the presentation according to
2346 the corresponding data values. If False - the presentation will
2348 color: defines the presentation color as [R, G, B] triple. Taken into
2349 account only if is_colored is False.
2350 vector_mode: the mode of transformation of vector values
2351 into scalar values, applicable only if the field contains vector values.
2352 Possible modes: 'Magnitude', 'X', 'Y' or 'Z'.
2355 Stream Lines as representation object.
2358 proxy.UpdatePipeline()
2359 # We don't need mesh parts with no data on them
2360 if entity == EntityType.NODE:
2361 select_cells_with_data(proxy, on_points=[field_name])
2363 select_cells_with_data(proxy, on_cells=[field_name])
2366 nb_components = get_nb_components(proxy, entity, field_name)
2367 check_vector_mode(vector_mode, nb_components)
2370 time_value = get_time(proxy, timestamp_nb)
2373 pvs.GetRenderView().ViewTime = time_value
2374 pvs.UpdatePipeline(time_value, proxy)
2377 source = pvs.MergeBlocks(proxy)
2379 # Cell data to point data
2380 if is_data_on_cells(proxy, field_name):
2381 cell_to_point = pvs.CellDatatoPointData(source)
2382 cell_to_point.PassCellData = 1
2383 cell_to_point.UpdatePipeline()
2384 source = cell_to_point
2386 vector_array = field_name
2387 # If the given vector array has only 2 components, add the third one
2388 if nb_components == 2:
2389 calc = get_add_component_calc(source, EntityType.NODE, field_name)
2390 vector_array = calc.ResultArrayName
2391 calc.UpdatePipeline()
2395 stream = pvs.StreamTracer(source)
2396 stream.SeedType = "Point Source"
2397 stream.Vectors = ['POINTS', vector_array]
2398 stream.SeedType = "Point Source"
2399 stream.IntegrationDirection = direction
2400 stream.IntegratorType = 'Runge-Kutta 2'
2401 stream.UpdatePipeline()
2403 # Get Stream Lines representation object
2404 if is_empty(stream):
2406 streamlines = pvs.GetRepresentation(stream)
2409 lookup_table = get_lookup_table(field_name, nb_components, vector_mode)
2411 # Set field range if necessary
2412 data_range = get_data_range(proxy, entity,
2413 field_name, vector_mode)
2414 lookup_table.LockScalarRange = 1
2415 lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0]
2419 streamlines.ColorArrayName = (EntityType.get_pvtype(entity), field_name)
2421 streamlines.ColorArrayName = ''
2423 streamlines.DiffuseColor = color
2425 streamlines.LookupTable = lookup_table
2428 add_scalar_bar(field_name, nb_components,
2429 vector_mode, lookup_table, time_value)
2434 def MeshOnEntity(proxy, mesh_name, entity):
2435 """Creates submesh of the entity type for the mesh.
2438 proxy -- the pipeline object, containig data
2439 mesh_name -- the full or short name of mesh field
2442 Submesh as representation object of the given source.
2445 proxy.UpdatePipeline()
2446 mesh_full_name = None
2447 aList = mesh_name.split('/')
2449 mesh_full_name = mesh_name
2451 mesh_full_name = find_mesh_full_name(proxy, mesh_name)
2452 if not mesh_full_name:
2453 raise RuntimeError, "The given mesh name was not found"
2454 # Select only the given mesh
2455 proxy.AllArrays = []
2456 proxy.UpdatePipeline()
2457 proxy.AllArrays = [mesh_full_name]
2458 proxy.UpdatePipeline()
2460 # Get representation object if the submesh is not empty
2462 if (proxy.GetDataInformation().GetNumberOfPoints() or
2463 proxy.GetDataInformation().GetNumberOfCells()):
2464 prs = pvs.GetRepresentation(proxy)
2465 prs.ColorArrayName = ''
2470 def MeshOnGroup(proxy, extrGroups, group_name):
2471 """Creates submesh on the group.
2474 proxy -- the pipeline object, containig data
2475 group_name -- the full group name
2476 extrGroups -- all extracted groups object
2479 Representation object of the given source with single group
2483 proxy.UpdatePipeline()
2484 # Deselect all groups
2485 extrGroups.AllGroups = []
2486 extrGroups.UpdatePipelineInformation()
2487 # Select only the group with the given name
2488 extrGroups.AllGroups = [group_name]
2489 extrGroups.UpdatePipelineInformation()
2491 # Get representation object if the submesh is not empty
2494 # Check if the group was set
2495 if len(extrGroups.AllGroups) == 1 and \
2496 extrGroups.AllGroups[0] == group_name:
2497 # Check if the submesh is not empty
2498 nb_points = proxy.GetDataInformation().GetNumberOfPoints()
2499 nb_cells = proxy.GetDataInformation().GetNumberOfCells()
2501 if nb_points or nb_cells:
2502 # prs = pvs.GetRepresentation(proxy)
2504 prs.ColorArrayName = ''
2510 def CreatePrsForFile(paravis_instance, file_name, prs_types,
2511 picture_dir, picture_ext):
2512 """Build presentations of the given types for the file.
2514 Build presentations for all fields on all timestamps.
2517 paravis_instance: ParaVis module instance object
2518 file_name: full path to the MED file
2519 prs_types: the list of presentation types to build
2520 picture_dir: the directory path for saving snapshots
2521 picture_ext: graphics files extension (determines file type)
2525 print "Import " + file_name.split(os.sep)[-1] + "..."
2528 proxy = pvs.MEDReader(FileName=file_name)
2532 proxy.UpdatePipeline()
2538 view = pvs.GetRenderView()
2540 # Create required presentations for the proxy
2541 CreatePrsForProxy(proxy, view, prs_types,
2542 picture_dir, picture_ext)
2544 def CreatePrsForProxy(proxy, view, prs_types, picture_dir, picture_ext):
2545 """Build presentations of the given types for all fields of the proxy.
2547 Save snapshots in graphics files (type depends on the given extension).
2548 Stores the files in the given directory.
2551 proxy: the pipeline object, containig data
2552 view: the render view
2553 prs_types: the list of presentation types to build
2554 picture_dir: the directory path for saving snapshots
2555 picture_ext: graphics files extension (determines file type)
2558 proxy.UpdatePipeline()
2559 # List of the field names
2560 fields_info = proxy.GetProperty("FieldsTreeInfo")[::2]
2562 # Add path separator to the end of picture path if necessery
2563 if not picture_dir.endswith(os.sep):
2564 picture_dir += os.sep
2567 if PrsTypeEnum.MESH in prs_types:
2569 mesh_names = get_mesh_full_names(proxy)
2570 for mesh_name in mesh_names:
2571 # Build mesh field presentation
2572 print "Creating submesh for '" + get_field_short_name(mesh_name) + "' mesh... "
2573 prs = MeshOnEntity(proxy, mesh_name, None)
2579 # Construct image file name
2580 pic_name = picture_dir + get_field_short_name(mesh_name) + "." + picture_ext
2582 # Show and dump the presentation into a graphics file
2583 process_prs_for_test(prs, view, pic_name, False)
2585 # Create Mesh presentation. Build all groups.
2586 extGrp = pvs.ExtractGroup()
2587 extGrp.UpdatePipelineInformation()
2588 if if_possible(proxy, None, None, PrsTypeEnum.MESH, extGrp):
2589 for group in get_group_names(extGrp):
2590 print "Creating submesh on group " + get_group_short_name(group) + "... "
2591 prs = MeshOnGroup(proxy, extGrp, group)
2597 # Construct image file name
2598 pic_name = picture_dir + get_group_short_name(group) + "." + picture_ext
2600 # Show and dump the presentation into a graphics file
2601 process_prs_for_test(prs, view, pic_name, False)
2603 # Presentations on fields
2604 for field in fields_info:
2605 field_name = get_field_short_name(field)
2606 # Ignore mesh presentation
2607 if field_name == get_field_mesh_name(field):
2609 field_entity = get_field_entity(field)
2610 # Clear fields selection state
2611 proxy.AllArrays = []
2612 proxy.UpdatePipeline()
2613 # Select only the current field:
2614 # necessary for getting the right timestamps
2615 proxy.AllArrays = field
2616 proxy.UpdatePipeline()
2619 entity_data_info = proxy.GetCellDataInformation()
2620 timestamps = proxy.TimestepValues.GetData()
2622 for prs_type in prs_types:
2623 # Ignore mesh presentation
2624 if prs_type == PrsTypeEnum.MESH:
2627 # Get name of presentation type
2628 prs_name = PrsTypeEnum.get_name(prs_type)
2630 # Build the presentation if possible
2631 possible = if_possible(proxy, field_name,
2632 field_entity, prs_type)
2634 # Presentation type for graphics file name
2635 f_prs_type = prs_name.replace(' ', '').upper()
2637 for timestamp_nb in xrange(1, len(timestamps) + 1):
2638 time = timestamps[timestamp_nb - 1]
2640 scalar_range = get_data_range(proxy, field_entity,
2641 field_name, cut_off=True)
2642 # exclude time stamps with null lenght of scalar range
2643 if (scalar_range[0] == scalar_range[1]):
2645 print "Creating " + prs_name + " on " + field_name + ", time = " + str(time) + "... "
2646 prs = create_prs(prs_type, proxy,
2647 field_entity, field_name, timestamp_nb)
2654 # Construct image file name
2655 pic_name = picture_dir + field_name + "_" + str(time) + "_" + f_prs_type + "." + picture_ext
2657 # Show and dump the presentation into a graphics file
2658 process_prs_for_test(prs, view, pic_name)