From: Cédric Aguerre Date: Tue, 25 Jul 2017 12:57:33 +0000 (+0200) Subject: Remove presentations.py - CoTech91 X-Git-Tag: V9_0_0~7 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=ebfa514d965aa77ff049a0dfff071b9a19954cd4;p=modules%2Fparavis.git Remove presentations.py - CoTech91 --- diff --git a/src/PV_SWIG/CMakeLists.txt b/src/PV_SWIG/CMakeLists.txt index e77b077a..d7be0ce3 100644 --- a/src/PV_SWIG/CMakeLists.txt +++ b/src/PV_SWIG/CMakeLists.txt @@ -1,4 +1,4 @@ -# Copyright (C) 2010-2016 CEA/DEN, EDF R&D +# Copyright (C) 2010-2017 CEA/DEN, EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,15 +22,13 @@ SET(_PYFILES_TO_INSTALL) IF(SALOME_LIGHT_ONLY) LIST(APPEND _PYFILES_TO_INSTALL pvsimple.py - presentations.py ) ELSE(SALOME_LIGHT_ONLY) - # Use a set of Python files redirecting the API directly + # Use a set of Python files redirecting the API directly # to the original ParaView modules. LIST(APPEND _PYFILES_TO_INSTALL pvserver.py pvsimple.py - presentations.py paravisSM.py ) ENDIF(SALOME_LIGHT_ONLY) diff --git a/src/PV_SWIG/presentations.py b/src/PV_SWIG/presentations.py deleted file mode 100644 index 91c7721e..00000000 --- a/src/PV_SWIG/presentations.py +++ /dev/null @@ -1,2757 +0,0 @@ -# Copyright (C) 2010-2016 CEA/DEN, EDF R&D -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# -# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -# - -""" -This module is intended to provide Python API for building presentations -typical for Post-Pro module (Scalar Map, Deformed Shape, Vectors, etc.) -""" - - - -##from __future__ import print_function - -import os -import re -import warnings -from math import sqrt, sin, cos, radians - -# Do not use pv as a short name. -# It is a name of function from numpy and may be redefined implicitly by 'from numpy import *' call. -# import pvsimple as pv -import pvsimple as pvs -#try: -# # TODO(MZN): to be removed (issue with Point Sprite texture) -# #import paravisSM as sm -#except: -# import paraview.simple as pvs -# import paraview.servermanager as sm - - -# Constants -EPS = 1E-3 -FLT_MIN = 1E-37 -VTK_LARGE_FLOAT = 1E+38 -GAP_COEFFICIENT = 0.0001 - - -# Globals -_current_bar = None -_med_field_sep = '@@][@@' - - -# Enumerations -class PrsTypeEnum: - """ - Post-Pro presentation types. - """ - MESH = 0 - SCALARMAP = 1 - ISOSURFACES = 2 - CUTPLANES = 3 - CUTLINES = 4 - DEFORMEDSHAPE = 5 - DEFORMEDSHAPESCALARMAP = 6 - VECTORS = 7 - PLOT3D = 8 - STREAMLINES = 9 - GAUSSPOINTS = 10 - - _type2name = {MESH: 'Mesh', - SCALARMAP: 'Scalar Map', - ISOSURFACES: 'Iso Surfaces', - CUTPLANES: 'Cut Planes', - CUTLINES: 'Cut Lines', - DEFORMEDSHAPE: 'Deformed Shape', - DEFORMEDSHAPESCALARMAP: 'Deformed Shape And Scalar Map', - VECTORS: 'Vectors', - PLOT3D: 'Plot3D', - STREAMLINES: 'Stream Lines', - GAUSSPOINTS: 'Gauss Points'} - - @classmethod - def get_name(cls, type): - """Return presentaion name by its type.""" - return cls._type2name[type] - - -class EntityType: - """ - Entity types. - """ - NODE = 0 - CELL = 1 - - _type2name = {NODE: 'P1', - CELL: 'P0'} - - _name2type = {'P1': NODE, - 'P0': CELL} - - _type2pvtype = {NODE: 'POINT_DATA', - CELL: 'CELL_DATA'} - - @classmethod - def get_name(cls, type): - """Return entity name (used in full group names) by its type.""" - return cls._type2name[type] - - @classmethod - def get_type(cls, name): - """Return entity type by its name (used in full group names).""" - return cls._name2type[name] - - @classmethod - def get_pvtype(cls, type): - """Return entity type from ['CELL_DATA', 'POINT_DATA']""" - return cls._type2pvtype[type] - - -class Orientation: - """Orientation types. - - Defines a set of plane orientation possibilities: - AUTO: plane orientation should be calculated. - XY: plane formed by X and Y axis. - YZ: plane formed by Y and Z axis. - ZX: plane formed by Z and X axis - - """ - AUTO = 0 - XY = 1 - YZ = 2 - ZX = 3 - - -class GlyphPos: - """Glyph positions. - - Set of elements defining the position of the vector head: - CENTER: in the center of the vector - TAIL: in the tail of the vector - HEAD: in the head of the vector - - """ - CENTER = 0 - TAIL = 1 - HEAD = 2 - - -class GaussType: - """ - Gauss Points primitive types. - """ - SPRITE = 0 - POINT = 1 - SPHERE = 2 - - _type2mode = {SPRITE: 'Texture', - POINT: 'SimplePoint', - SPHERE: 'Sphere (Texture)'} - - @classmethod - def get_mode(cls, type): - """Return paraview point sprite mode by the primitive type.""" - return cls._type2mode[type] - - -# Auxiliary functions - -def get_field_mesh_name(full_field_name): - """Return mesh name of the field by its full name.""" - aList = full_field_name.split('/') - if len(aList) >= 2 : - field_name = full_field_name.split('/')[1] - return field_name - - -def get_field_entity(full_field_name): - """Return entity type of the field by its full name.""" - aList = full_field_name.split(_med_field_sep) - if len(aList) == 2 : - entity_name = full_field_name.split(_med_field_sep)[-1] - entity = EntityType.get_type(entity_name) - return entity - - -def get_field_short_name(full_field_name): - """Return short name of the field by its full name.""" - aList = full_field_name.split('/') - if len(aList) == 4 : - short_name_with_type = full_field_name.split('/')[-1] - short_name = short_name_with_type.split(_med_field_sep)[0] - return short_name - - -def find_mesh_full_name(proxy, short_mesh_name): - """Return full mesh path by short mesh name, if found""" - proxy.UpdatePipeline() - all_mesh_names = get_mesh_full_names(proxy) - for name in all_mesh_names: - if short_mesh_name == get_field_short_name(name): - return name - - -def process_prs_for_test(prs, view, picture_name, show_bar=True): - """Show presentation and record snapshot image. - - Arguments: - prs: the presentation to show - view: the render view - picture_name: the full name of the graphics file to save - show_bar: to show scalar bar or not - - """ - # Show the presentation only - display_only(prs, view) - - # Show scalar bar - global _current_bar - if show_bar and _current_bar: - _current_bar.Visibility = 1 - - # Reset the view - reset_view(view) - - # Create a directory for screenshot if necessary - file_name = re.sub("\s+", "_", picture_name) - pic_dir = os.path.dirname(picture_name) - if not os.path.exists(pic_dir): - os.makedirs(pic_dir) - - # Save picture - print("Write image:", file_name) - pvs.WriteImage(file_name, view=view, Magnification=1) - - -def reset_view(view=None): - """Reset the view. - - Set predefined (taken from Post-Pro) camera settings. - If the view is not passed, the active view is used. - - """ - if not view: - view = pvs.GetRenderView() - - # Camera preferences - view.CameraFocalPoint = [0.0, 0.0, 0.0] - view.CameraViewUp = [0.0, 0.0, 1.0] - view.CameraPosition = [738.946, -738.946, 738.946] - - # Turn on the headligth - view.LightSwitch = 1 - view.LightIntensity = 0.5 - - # Use parallel projection - view.CameraParallelProjection = 1 - - view.ResetCamera() - pvs.Render(view=view) - - -def hide_all(view, to_remove=False): - """Hide all representations in the view.""" - if not view: - view = pvs.GetRenderView() - - rep_list = view.Representations - for rep in rep_list: - if hasattr(rep, 'Visibility') and rep.Visibility != 0: - rep.Visibility = 0 - if to_remove: - view.Representations.remove(rep) - pvs.Render(view=view) - - -def display_only(prs, view=None): - """Display only the given presentation in the view.""" - if not view: - view = pvs.GetRenderView() - - rep_list = view.Representations - for rep in rep_list: - if hasattr(rep, 'Visibility'): - rep.Visibility = (rep == prs) - pvs.Render(view=view) - - -def set_visible_lines(xy_prs, lines): - """Set visible only the given lines for XYChartRepresentation.""" - sv = xy_prs.GetProperty("SeriesVisibility").GetData() - visible = '0' - - for i in range(0, len(sv)): - if i % 2 == 0: - line_name = sv[i] - if line_name in lines: - visible = '1' - else: - visible = '0' - else: - sv[i] = visible - - xy_prs.SeriesVisibility = sv - - -def check_vector_mode(vector_mode, nb_components): - """Check vector mode. - - Check if vector mode is correct for the data array with the - given number of components. - - Arguments: - vector_mode: 'Magnitude', 'X', 'Y' or 'Z' - nb_components: number of component in the data array - - Raises: - ValueError: in case of the vector mode is unexistent - or nonapplicable. - - """ - if vector_mode not in ('Magnitude', 'X', 'Y', 'Z'): - raise ValueError("Unexistent vector mode: " + vector_mode) - - if ((nb_components == 1 and (vector_mode == 'Y' or vector_mode == 'Z')) or - (nb_components == 2 and vector_mode == 'Z')): - raise ValueError("Incorrect vector mode " + vector_mode + " for " + - nb_components + "-component field") - - -def get_vector_component(vector_mode): - """Get vector component as ineger. - - Translate vector component notation from string - to integer: - 'Magnitude': -1 - 'X': 0 - 'Y': 1 - 'Z': 2 - - """ - vcomponent = -1 - - if vector_mode == 'X': - vcomponent = 0 - elif vector_mode == 'Y': - vcomponent = 1 - elif vector_mode == 'Z': - vcomponent = 2 - - return vcomponent - - -def get_data_range(proxy, entity, field_name, vector_mode='Magnitude', - cut_off=False): - """Get data range for the field. - - Arguments: - proxy: the pipeline object, containig data array for the field - entity: the field entity - field_name: the field name - vector_mode: the vector mode ('Magnitude', 'X', 'Y' or 'Z') - - Returns: - Data range as [min, max] - - """ - proxy.UpdatePipeline() - entity_data_info = None - field_data = proxy.GetFieldDataInformation() - - if field_name in list(field_data.keys()): - entity_data_info = field_data - elif entity == EntityType.CELL: - entity_data_info = proxy.GetCellDataInformation() - elif entity == EntityType.NODE: - entity_data_info = proxy.GetPointDataInformation() - - data_range = [] - - if field_name in list(entity_data_info.keys()): - vcomp = get_vector_component(vector_mode) - data_range = entity_data_info[field_name].GetComponentRange(vcomp) - else: - pv_entity = EntityType.get_pvtype(entity) - warnings.warn("Field " + field_name + - " is unknown for " + pv_entity + "!") - - # Cut off the range - if cut_off and (data_range[0] <= data_range[1]): - data_range = list(data_range) - delta = abs(data_range[1] - data_range[0]) * GAP_COEFFICIENT - data_range[0] += delta - data_range[1] -= delta - - return data_range - - -def get_bounds(proxy): - """Get bounds of the proxy in 3D.""" - proxy.UpdatePipeline() - dataInfo = proxy.GetDataInformation() - bounds_info = dataInfo.GetBounds() - return bounds_info - - -def get_x_range(proxy): - """Get X range of the proxy bounds in 3D.""" - proxy.UpdatePipeline() - bounds_info = get_bounds(proxy) - return bounds_info[0:2] - - -def get_y_range(proxy): - """Get Y range of the proxy bounds in 3D.""" - proxy.UpdatePipeline() - bounds_info = get_bounds(proxy) - return bounds_info[2:4] - - -def get_z_range(proxy): - """Get Z range of the proxy bounds in 3D.""" - proxy.UpdatePipeline() - bounds_info = get_bounds(proxy) - return bounds_info[4:6] - - -def is_planar_input(proxy): - """Check if the given input is planar.""" - proxy.UpdatePipeline() - bounds_info = get_bounds(proxy) - - if (abs(bounds_info[0] - bounds_info[1]) <= FLT_MIN or - abs(bounds_info[2] - bounds_info[3]) <= FLT_MIN or - abs(bounds_info[4] - bounds_info[5]) <= FLT_MIN): - return True - - return False - - -def is_data_on_cells(proxy, field_name): - """Check the existence of a field on cells with the given name.""" - proxy.UpdatePipeline() - cell_data_info = proxy.GetCellDataInformation() - return (field_name in list(cell_data_info.keys())) - - -def is_empty(proxy): - """Check if the object contains any points or cells. - - Returns: - True: if the given proxy doesn't contain any points or cells - False: otherwise - - """ - proxy.UpdatePipeline() - data_info = proxy.GetDataInformation() - - nb_cells = data_info.GetNumberOfCells() - nb_points = data_info.GetNumberOfPoints() - - return not(nb_cells + nb_points) - - -def get_orientation(proxy): - """Get the optimum cutting plane orientation for Plot 3D.""" - proxy.UpdatePipeline() - orientation = Orientation.XY - - bounds = get_bounds(proxy) - delta = [bounds[1] - bounds[0], - bounds[3] - bounds[2], - bounds[5] - bounds[4]] - - if (delta[0] >= delta[1] and delta[0] >= delta[2]): - if (delta[1] >= delta[2]): - orientation = Orientation.XY - else: - orientation = Orientation.ZX - elif (delta[1] >= delta[0] and delta[1] >= delta[2]): - if (delta[0] >= delta[2]): - orientation = Orientation.XY - else: - orientation = Orientation.YZ - elif (delta[2] >= delta[0] and delta[2] >= delta[1]): - if (delta[0] >= delta[1]): - orientation = Orientation.ZX - else: - orientation = Orientation.YZ - - return orientation - - -def dot_product(a, b): - """Dot product of two 3-vectors.""" - dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] - return dot - - -def multiply3x3(a, b): - """Mutltiply one 3x3 matrix by another.""" - c = [[0, 0, 0], - [0, 0, 0], - [0, 0, 0]] - - for i in range(3): - c[0][i] = a[0][0] * b[0][i] + a[0][1] * b[1][i] + a[0][2] * b[2][i] - c[1][i] = a[1][0] * b[0][i] + a[1][1] * b[1][i] + a[1][2] * b[2][i] - c[2][i] = a[2][0] * b[0][i] + a[2][1] * b[1][i] + a[2][2] * b[2][i] - - return c - - -def get_rx(ang): - """Get X rotation matrix by angle.""" - rx = [[1.0, 0.0, 0.0], - [0.0, cos(ang), -sin(ang)], - [0.0, sin(ang), cos(ang)]] - - return rx - - -def get_ry(ang): - """Get Y rotation matrix by angle.""" - ry = [[cos(ang), 0.0, sin(ang)], - [0.0, 1.0, 0.0], - [-sin(ang), 0.0, cos(ang)]] - - return ry - - -def get_rz(ang): - """Get Z rotation matrix by angle.""" - rz = [[cos(ang), -sin(ang), 0.0], - [sin(ang), cos(ang), 0.0], - [0.0, 0.0, 1.0]] - - return rz - - -def get_normal_by_orientation(orientation, ang1=0, ang2=0): - """Get normal for the plane by its orientation.""" - i_plane = 0 - rotation = [[], [], []] - rx = ry = rz = [[1.0, 0.0, 0.0], - [0.0, 1.0, 0.0], - [0.0, 0.0, 1.0]] - - normal = [0.0, 0.0, 0.0] - if orientation == Orientation.XY: - if abs(ang1) > EPS: - rx = get_rx(ang1) - if abs(ang2) > EPS: - ry = get_ry(ang2) - rotation = multiply3x3(rx, ry) - i_plane = 2 - elif orientation == Orientation.ZX: - if abs(ang1) > EPS: - rz = get_rz(ang1) - if abs(ang2) > EPS: - rx = get_rx(ang2) - rotation = multiply3x3(rz, rx) - i_plane = 1 - elif orientation == Orientation.YZ: - if abs(ang1) > EPS: - ry = get_ry(ang1) - if abs(ang2) > EPS: - rz = get_rz(ang2) - rotation = multiply3x3(ry, rz) - i_plane = 0 - - for i in range(0, 3): - normal[i] = rotation[i][i_plane] - - return normal - - -def get_bound_project(bound_box, dir): - """Get bounds projection""" - bound_points = [[bound_box[0], bound_box[2], bound_box[4]], - [bound_box[1], bound_box[2], bound_box[4]], - [bound_box[0], bound_box[3], bound_box[4]], - [bound_box[1], bound_box[3], bound_box[4]], - [bound_box[0], bound_box[2], bound_box[5]], - [bound_box[1], bound_box[2], bound_box[5]], - [bound_box[0], bound_box[3], bound_box[5]], - [bound_box[1], bound_box[3], bound_box[5]]] - - bound_prj = [0, 0, 0] - bound_prj[0] = dot_product(dir, bound_points[0]) - bound_prj[1] = bound_prj[0] - - for i in range(1, 8): - tmp = dot_product(dir, bound_points[i]) - if bound_prj[1] < tmp: - bound_prj[1] = tmp - if bound_prj[0] > tmp: - bound_prj[0] = tmp - - bound_prj[2] = bound_prj[1] - bound_prj[0] - bound_prj[1] = bound_prj[0] + (1.0 - EPS) * bound_prj[2] - bound_prj[0] = bound_prj[0] + EPS * bound_prj[2] - bound_prj[2] = bound_prj[1] - bound_prj[0] - - return bound_prj - - -def get_positions(nb_planes, dir, bounds, displacement): - """Compute plane positions.""" - positions = [] - bound_prj = get_bound_project(bounds, dir) - if nb_planes > 1: - step = bound_prj[2] / (nb_planes - 1) - abs_displacement = step * displacement - start_pos = bound_prj[0] - 0.5 * step + abs_displacement - for i in range(nb_planes): - pos = start_pos + i * step - positions.append(pos) - else: - pos = bound_prj[0] + bound_prj[2] * displacement - positions.append(pos) - - return positions - - -def get_contours(scalar_range, nb_contours): - """Generate contour values.""" - contours = [] - for i in range(nb_contours): - pos = scalar_range[0] + i * ( - scalar_range[1] - scalar_range[0]) / (nb_contours - 1) - contours.append(pos) - - return contours - - -def get_nb_components(proxy, entity, field_name): - """Return number of components for the field.""" - proxy.UpdatePipeline() - entity_data_info = None - field_data = proxy.GetFieldDataInformation() - - if field_name in list(field_data.keys()): - entity_data_info = field_data - elif entity == EntityType.CELL: - select_cells_with_data(proxy, on_cells=[field_name]) - entity_data_info = proxy.GetCellDataInformation() - elif entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - entity_data_info = proxy.GetPointDataInformation() - - nb_comp = None - if field_name in list(entity_data_info.keys()): - nb_comp = entity_data_info[field_name].GetNumberOfComponents() - else: - pv_entity = EntityType.get_pvtype(entity) - raise ValueError("Field " + field_name + - " is unknown for " + pv_entity + "!") - - return nb_comp - - -def get_scale_factor(proxy): - """Compute scale factor.""" - if not proxy: - return 0.0 - - proxy.UpdatePipeline() - data_info = proxy.GetDataInformation() - - nb_cells = data_info.GetNumberOfCells() - nb_points = data_info.GetNumberOfPoints() - nb_elements = nb_cells if nb_cells > 0 else nb_points - bounds = get_bounds(proxy) - - volume = 1 - vol = dim = 0 - - for i in range(0, 6, 2): - vol = abs(bounds[i + 1] - bounds[i]) - if vol > 0: - dim += 1 - volume *= vol - - if nb_elements == 0 or dim < 1 / VTK_LARGE_FLOAT: - return 0 - - volume /= nb_elements - - return pow(volume, 1 / dim) - - -def get_default_scale(prs_type, proxy, entity, field_name): - """Get default scale factor.""" - proxy.UpdatePipeline() - data_range = get_data_range(proxy, entity, field_name) - - if prs_type == PrsTypeEnum.DEFORMEDSHAPE: - EPS = 1.0 / VTK_LARGE_FLOAT - if abs(data_range[1]) > EPS: - scale_factor = get_scale_factor(proxy) - return scale_factor / data_range[1] - elif prs_type == PrsTypeEnum.PLOT3D: - bounds = get_bounds(proxy) - length = sqrt((bounds[1] - bounds[0]) ** 2 + - (bounds[3] - bounds[2]) ** 2 + - (bounds[5] - bounds[4]) ** 2) - - EPS = 0.3 - if data_range[1] > 0: - return length / data_range[1] * EPS - - return 0 - - -def get_calc_magnitude(proxy, array_entity, array_name): - """Compute magnitude for the given vector array via Calculator. - - Returns: - the calculator object. - - """ - proxy.UpdatePipeline() - calculator = None - - # Transform vector array to scalar array if possible - nb_components = get_nb_components(proxy, array_entity, array_name) - if (nb_components > 1): - calculator = pvs.Calculator(proxy) - attribute_mode = "Point Data" - if array_entity != EntityType.NODE: - attribute_mode = "Cell Data" - calculator.AttributeMode = attribute_mode - if (nb_components == 2): - # Workaroud: calculator unable to compute magnitude - # if number of components equal to 2 - func = "sqrt(" + array_name + "_X^2+" + array_name + "_Y^2)" - calculator.Function = func - else: - calculator.Function = "mag(" + array_name + ")" - calculator.ResultArrayName = array_name + "_magnitude" - calculator.UpdatePipeline() - - return calculator - - -def get_add_component_calc(proxy, array_entity, array_name): - """Creates 3-component array from 2-component. - - The first two components is from the original array. The 3rd component - is zero. - If the number of components is not equal to 2 - return original array name. - - Returns: - the calculator object. - - """ - proxy.UpdatePipeline() - calculator = None - - nb_components = get_nb_components(proxy, array_entity, array_name) - if nb_components == 2: - calculator = pvs.Calculator(proxy) - attribute_mode = "Point Data" - if array_entity != EntityType.NODE: - attribute_mode = "Cell Data" - calculator.AttributeMode = attribute_mode - expression = "iHat * " + array_name + "_X + jHat * " + array_name + "_Y + kHat * 0" - calculator.Function = expression - calculator.ResultArrayName = array_name + "_3c" - calculator.UpdatePipeline() - - return calculator - - -def select_all_cells(proxy): - """Select all cell types. - - Used in creation of mesh/submesh presentation. - - """ - proxy.UpdatePipeline() - extractCT = pvs.ExtractCellType() - extractCT.AllGeoTypes = extractCT.GetProperty("GeoTypesInfo")[::2] - extractCT.UpdatePipelineInformation() - - -def select_cells_with_data(proxy, on_points=[], on_cells=[], on_gauss=[]): - """Select cell types with data. - - Only cell types with data for the given fields will be selected. - If no fields defined (neither on points nor on cells) only cell - types with data for even one field (from available) will be selected. - - """ - if not proxy.GetProperty("FieldsTreeInfo"): - return - - proxy.UpdatePipeline() - if not hasattr(proxy, 'Entity'): - fields_info = proxy.GetProperty("FieldsTreeInfo")[::2] - arr_name_with_dis=[elt.split("/")[-1] for elt in fields_info] - - fields = [] - for name in on_gauss: - fields.append(name+_med_field_sep+'GAUSS') - for name in on_cells: - fields.append(name+_med_field_sep+'P0') - for name in on_points: - fields.append(name+_med_field_sep+'P1') - - field_list = [] - for name in fields: - if arr_name_with_dis.count(name) > 0: - index = arr_name_with_dis.index(name) - field_list.append(fields_info[index]) - - if field_list: - proxy.AllArrays = field_list - proxy.UpdatePipeline() - return len(field_list) != 0 - - # TODO: VTN. Looks like this code is out of date. - - #all_cell_types = proxy.CellTypes.Available - all_cell_types = proxy.Entity.Available - all_arrays = list(proxy.CellArrays.GetData()) - all_arrays.extend(proxy.PointArrays.GetData()) - - if not all_arrays: - file_name = proxy.FileName.split(os.sep)[-1] - print("Warning: " + file_name + " doesn't contain any data array.") - - # List of cell types to be selected - cell_types_on = [] - - for cell_type in all_cell_types: - #proxy.CellTypes = [cell_type] - proxy.Entity = [cell_type] - proxy.UpdatePipeline() - - cell_arrays = list(proxy.GetCellDataInformation().keys()) - point_arrays = list(proxy.GetPointDataInformation().keys()) - - if on_points or on_cells: - if on_points is None: - on_points = [] - if on_cells is None: - on_cells = [] - - if (all(array in cell_arrays for array in on_cells) and - all(array in point_arrays for array in on_points)): - # Add cell type to the list - cell_types_on.append(cell_type) - else: - in_arrays = lambda array: ((array in cell_arrays) or - (array in point_arrays)) - if any(in_arrays(array) for array in all_arrays): - cell_types_on.append(cell_type) - - # Select cell types - #proxy.CellTypes = cell_types_on - proxy.Entity = cell_types_on - proxy.UpdatePipeline() - -def if_possible(proxy, field_name, entity, prs_type, extrGrps=None): - """Check if the presentation creation is possible on the given field.""" - proxy.UpdatePipeline() - result = True - if (prs_type == PrsTypeEnum.DEFORMEDSHAPE or - prs_type == PrsTypeEnum.DEFORMEDSHAPESCALARMAP or - prs_type == PrsTypeEnum.VECTORS or - prs_type == PrsTypeEnum.STREAMLINES): - nb_comp = get_nb_components(proxy, entity, field_name) - result = (nb_comp > 1) - elif (prs_type == PrsTypeEnum.GAUSSPOINTS): - result = (entity == EntityType.CELL or - field_name in proxy.QuadraturePointArrays.Available) - elif (prs_type == PrsTypeEnum.MESH): - result = len(get_group_names(extrGrps)) > 0 - - return result - - -def add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value): - """Add scalar bar with predefined properties.""" - global _current_bar - - # Construct bar title - title = "\n".join([field_name, str(time_value)]) - if nb_components > 1: - title = "\n".join([title, vector_mode]) - - # Create scalar bar - scalar_bar = pvs.CreateScalarBar(Enabled=1) - scalar_bar.Orientation = 'Vertical' - scalar_bar.Title = title - scalar_bar.LookupTable = lookup_table - - # Set default properties same as in Post-Pro - # NumberOfLabels removed (see commit ff8f9cb6 in PARAVIEW) - # scalar_bar.NumberOfLabels = 5 - scalar_bar.AutomaticLabelFormat = 0 - scalar_bar.LabelFormat = '%-#6.6g' - # Title - scalar_bar.TitleFontFamily = 'Arial' - scalar_bar.TitleFontSize = 8 - scalar_bar.TitleBold = 1 - scalar_bar.TitleItalic = 1 - scalar_bar.TitleShadow = 1 - # Labels - scalar_bar.LabelFontFamily = 'Arial' - scalar_bar.LabelFontSize = 8 - scalar_bar.LabelBold = 1 - scalar_bar.LabelItalic = 1 - scalar_bar.LabelShadow = 1 - - # Add the scalar bar to the view - pvs.GetRenderView().Representations.append(scalar_bar) - - # Reassign the current bar - _current_bar = scalar_bar - - return _current_bar - - -def get_bar(): - """Get current scalar bar.""" - return _current_bar - - -def get_lookup_table(field_name, nb_components, vector_mode='Magnitude'): - """Get lookup table for the given field.""" - lookup_table = pvs.GetLookupTableForArray(field_name, nb_components) - - if vector_mode == 'Magnitude': - lookup_table.VectorMode = vector_mode - elif vector_mode == 'X': - lookup_table.VectorMode = 'Component' - lookup_table.VectorComponent = 0 - elif vector_mode == 'Y': - lookup_table.VectorMode = 'Component' - lookup_table.VectorComponent = 1 - elif vector_mode == 'Z': - lookup_table.VectorMode = 'Component' - lookup_table.VectorComponent = 2 - else: - raise ValueError("Incorrect vector mode: " + vector_mode) - - lookup_table.Discretize = 0 - lookup_table.ColorSpace = 'HSV' - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 0 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 0 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - return lookup_table - - -def get_group_mesh_name(full_group_name): - """Return mesh name of the group by its full name.""" - aList = full_group_name.split('/') - if len(aList) >= 2 : - group_name = full_group_name.split('/')[1] - return group_name - -def get_group_entity(full_group_name): - """Return entity type of the group by its full name.""" - aList = full_group_name.split('/') - if len(aList) >= 3 : - entity_name = full_group_name.split('/')[2] - entity = EntityType.get_type(entity_name) - return entity - - -def get_group_short_name(full_group_name): - """Return short name of the group by its full name.""" - short_name = re.sub('^GRP_', '', full_group_name) - return short_name - - -def get_mesh_full_names(proxy): - """Return all mesh names in the given proxy as a set.""" - proxy.UpdatePipeline() - fields = proxy.GetProperty("FieldsTreeInfo")[::2] - mesh_full_names = set([item for item in fields if get_field_mesh_name(item) == get_field_short_name(item)]) - return mesh_full_names - - -def get_group_names(extrGrps): - """Return full names of all groups of the given 'ExtractGroup' filter object. - """ - group_names = [x for x in list(extrGrps.GetProperty("GroupsFlagsInfo")[::2]) if x[:4]=="GRP_"] - return group_names - - -def get_time(proxy, timestamp_nb): - """Get time value by timestamp number.""" - #proxy.UpdatePipeline() - # Check timestamp number - timestamps = [] - - if (hasattr(proxy, 'TimestepValues')): - timestamps = proxy.TimestepValues.GetData() - elif (hasattr(proxy.Input, 'TimestepValues')): - timestamps = proxy.Input.TimestepValues.GetData() - - length = len(timestamps) - if (timestamp_nb > 0 and (timestamp_nb - 1) not in range(length) ) or (timestamp_nb < 0 and -timestamp_nb > length): - raise ValueError("Timestamp number is out of range: " + str(timestamp_nb)) - - if not timestamps: - return 0.0 - - # Return time value - if timestamp_nb > 0: - return timestamps[timestamp_nb - 1] - else: - return timestamps[timestamp_nb] - -def create_prs(prs_type, proxy, field_entity, field_name, timestamp_nb): - """Auxiliary function. - - Build presentation of the given type on the given field and - timestamp number. - Set the presentation properties like visu.CreatePrsForResult() do. - - """ - proxy.UpdatePipeline() - prs = None - - if prs_type == PrsTypeEnum.SCALARMAP: - prs = ScalarMapOnField(proxy, field_entity, field_name, timestamp_nb) - elif prs_type == PrsTypeEnum.CUTPLANES: - prs = CutPlanesOnField(proxy, field_entity, field_name, timestamp_nb, - orientation=Orientation.ZX) - elif prs_type == PrsTypeEnum.CUTLINES: - prs = CutLinesOnField(proxy, field_entity, field_name, timestamp_nb, - orientation1=Orientation.XY, - orientation2=Orientation.ZX) - elif prs_type == PrsTypeEnum.DEFORMEDSHAPE: - prs = DeformedShapeOnField(proxy, field_entity, - field_name, timestamp_nb) - elif prs_type == PrsTypeEnum.DEFORMEDSHAPESCALARMAP: - prs = DeformedShapeAndScalarMapOnField(proxy, field_entity, - field_name, timestamp_nb) - elif prs_type == PrsTypeEnum.VECTORS: - prs = VectorsOnField(proxy, field_entity, field_name, timestamp_nb) - elif prs_type == PrsTypeEnum.PLOT3D: - prs = Plot3DOnField(proxy, field_entity, field_name, timestamp_nb) - elif prs_type == PrsTypeEnum.ISOSURFACES: - prs = IsoSurfacesOnField(proxy, field_entity, field_name, timestamp_nb) - elif prs_type == PrsTypeEnum.GAUSSPOINTS: - prs = GaussPointsOnField(proxy, field_entity, field_name, timestamp_nb) - elif prs_type == PrsTypeEnum.STREAMLINES: - prs = StreamLinesOnField(proxy, field_entity, field_name, timestamp_nb) - else: - raise ValueError("Unexistent presentation type.") - - return prs - - -# Functions for building Post-Pro presentations -def ScalarMapOnField(proxy, entity, field_name, timestamp_nb, - vector_mode='Magnitude'): - """Creates Scalar Map presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Scalar Map as representation object. - - """ - proxy.UpdatePipeline() - # We don't need mesh parts with no data on them - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Get Scalar Map representation object - scalarmap = pvs.GetRepresentation(proxy) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - # Set properties - pvs.ColorBy(scalarmap, (EntityType.get_pvtype(entity), field_name)) - scalarmap.LookupTable = lookup_table - - # Add scalar bar - bar_title = field_name + ", " + str(time_value) - if (nb_components > 1): - bar_title += "\n" + vector_mode - add_scalar_bar(field_name, nb_components, vector_mode, - lookup_table, time_value) - - return scalarmap - - -def CutPlanesOnField(proxy, entity, field_name, timestamp_nb, - nb_planes=10, orientation=Orientation.YZ, - angle1=0, angle2=0, - displacement=0.5, vector_mode='Magnitude'): - """Creates Cut Planes presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - nb_planes: number of cutting planes - orientation: cutting planes orientation in 3D space - angle1: rotation of the planes in 3d space around the first axis of the - selected orientation (X axis for XY, Y axis for YZ, Z axis for ZX). - The angle of rotation is set in degrees. Acceptable range: [-45, 45]. - angle2: rotation of the planes in 3d space around the second axis of the - selected orientation. Acceptable range: [-45, 45]. - displacement: the displacement of the planes into one or another side - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Cut Planes as representation object. - - """ - proxy.UpdatePipeline() - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Create slice filter - slice_filter = pvs.Slice(proxy) - slice_filter.SliceType = "Plane" - - # Set cut planes normal - normal = get_normal_by_orientation(orientation, - radians(angle1), radians(angle2)) - slice_filter.SliceType.Normal = normal - - # Set cut planes positions - positions = get_positions(nb_planes, normal, - get_bounds(proxy), displacement) - slice_filter.SliceOffsetValues = positions - - # Get Cut Planes representation object - cut_planes = pvs.GetRepresentation(slice_filter) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set properties - pvs.ColorBy(cut_planes, (EntityType.get_pvtype(entity), field_name)) - cut_planes.LookupTable = lookup_table - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - return cut_planes - - -def CutLinesOnField(proxy, entity, field_name, timestamp_nb, - nb_lines=10, - orientation1=Orientation.XY, - base_angle1=0, base_angle2=0, - orientation2=Orientation.YZ, - cut_angle1=0, cut_angle2=0, - displacement1=0.5, displacement2=0.5, - generate_curves=False, - vector_mode='Magnitude'): - """Creates Cut Lines presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - nb_lines: number of lines - orientation1: base plane orientation in 3D space - base_angle1: rotation of the base plane in 3d space around the first - axis of the orientation1 (X axis for XY, Y axis for YZ, Z axis for ZX). - The angle of rotation is set in degrees. Acceptable range: [-45, 45]. - base_angle2: rotation of the base plane in 3d space around the second - axis of the orientation1. Acceptable range: [-45, 45]. - orientation2: cutting planes orientation in 3D space - cut_angle1: rotation of the cut planes in 3d space around the first - axis of the orientation2. Acceptable range: [-45, 45]. - cut_angle2: rotation of the cuting planes in 3d space around the second - axis of the orientation2. Acceptable range: [-45, 45]. - displacement1: base plane displacement - displacement2: cutting planes displacement - generate_curves: if true, 'PlotOverLine' filter will be created - for each cut line - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Cut Lines as representation object if generate_curves == False, - (Cut Lines as representation object, list of 'PlotOverLine') otherwise - - """ - proxy.UpdatePipeline() - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Create base plane - base_plane = pvs.Slice(proxy) - base_plane.SliceType = "Plane" - - # Set base plane normal - base_normal = get_normal_by_orientation(orientation1, - radians(base_angle1), - radians(base_angle2)) - base_plane.SliceType.Normal = base_normal - - # Set base plane position - base_position = get_positions(1, base_normal, - get_bounds(proxy), displacement1) - base_plane.SliceOffsetValues = base_position - - # Check base plane - base_plane.UpdatePipeline() - if (base_plane.GetDataInformation().GetNumberOfCells() == 0): - base_plane = proxy - - # Create cutting planes - cut_planes = pvs.Slice(base_plane) - cut_planes.SliceType = "Plane" - - # Set cutting planes normal and get positions - cut_normal = get_normal_by_orientation(orientation2, - radians(cut_angle1), - radians(cut_angle2)) - cut_planes.SliceType.Normal = cut_normal - - # Set cutting planes position - cut_positions = get_positions(nb_lines, cut_normal, - get_bounds(base_plane), displacement2) - - # Generate curves - curves = [] - if generate_curves: - index = 0 - for pos in cut_positions: - # Get points for plot over line objects - cut_planes.SliceOffsetValues = pos - cut_planes.UpdatePipeline() - bounds = get_bounds(cut_planes) - point1 = [bounds[0], bounds[2], bounds[4]] - point2 = [bounds[1], bounds[3], bounds[5]] - - # Create plot over line filter - pol = pvs.PlotOverLine(cut_planes, - Source="High Resolution Line Source") - pvs.RenameSource('Y' + str(index), pol) - pol.Source.Point1 = point1 - pol.Source.Point2 = point2 - pol.UpdatePipeline() - curves.append(pol) - - index += 1 - - cut_planes.SliceOffsetValues = cut_positions - cut_planes.UpdatePipeline() - - # Get Cut Lines representation object - cut_lines = pvs.GetRepresentation(cut_planes) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set properties - pvs.ColorBy(cut_lines, (EntityType.get_pvtype(entity), field_name)) - cut_lines.LookupTable = lookup_table - - # Set wireframe represenatation mode - cut_lines.Representation = 'Wireframe' - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - result = cut_lines - # If curves were generated return tuple (cut lines, list of curves) - if curves: - result = cut_lines, curves - - return result - - -def CutSegmentOnField(proxy, entity, field_name, timestamp_nb, - point1, point2, vector_mode='Magnitude'): - """Creates Cut Segment presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - point1: set the first point of the segment (as [x, y, z]) - point1: set the second point of the segment (as [x, y, z]) - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Cut Segment as 3D representation object. - - """ - proxy.UpdatePipeline() - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Create plot over line filter - pol = pvs.PlotOverLine(proxy, Source="High Resolution Line Source") - pol.Source.Point1 = point1 - pol.Source.Point2 = point2 - pol.UpdatePipeline() - - # Get Cut Segment representation object - cut_segment = pvs.GetRepresentation(pol) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set properties - pvs.ColorBy(cut_segment, (EntityType.get_pvtype(entity), field_name)) - cut_segment.LookupTable = lookup_table - - # Set wireframe represenatation mode - cut_segment.Representation = 'Wireframe' - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - return cut_segment - - -def VectorsOnField(proxy, entity, field_name, timestamp_nb, - scale_factor=None, - glyph_pos=GlyphPos.TAIL, glyph_type='2D Glyph', - is_colored=False, vector_mode='Magnitude'): - """Creates Vectors presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - scale_factor: scale factor - glyph_pos: the position of glyphs - glyph_type: the type of glyphs - is_colored: this option allows to color the presentation according to - the corresponding data array values - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Vectors as representation object. - - """ - proxy.UpdatePipeline() - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Extract only groups with data for the field - source = proxy - - # Cell centers - if is_data_on_cells(proxy, field_name): - cell_centers = pvs.CellCenters(source) - cell_centers.VertexCells = 1 - source = cell_centers - - vector_array = field_name - # If the given vector array has only 2 components, add the third one - if nb_components == 2: - calc = get_add_component_calc(source, EntityType.NODE, field_name) - vector_array = calc.ResultArrayName - source = calc - - # Glyph - glyph = pvs.Glyph(source) - glyph.Vectors = vector_array - glyph.ScaleMode = 'vector' - #glyph.MaskPoints = 0 - - # Set glyph type - glyph.GlyphType = glyph_type - if glyph_type == '2D Glyph': - glyph.GlyphType.GlyphType = 'Arrow' - elif glyph_type == 'Cone': - glyph.GlyphType.Resolution = 7 - glyph.GlyphType.Height = 2 - glyph.GlyphType.Radius = 0.2 - - # Set glyph position if possible - if glyph.GlyphType.GetProperty("Center"): - if (glyph_pos == GlyphPos.TAIL): - glyph.GlyphType.Center = [0.5, 0.0, 0.0] - elif (glyph_pos == GlyphPos.HEAD): - glyph.GlyphType.Center = [-0.5, 0.0, 0.0] - elif (glyph_pos == GlyphPos.CENTER): - glyph.GlyphType.Center = [0.0, 0.0, 0.0] - - if scale_factor is not None: - glyph.ScaleFactor = scale_factor - else: - def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, - proxy, entity, field_name) - glyph.ScaleFactor = def_scale - - glyph.UpdatePipeline() - - # Get Vectors representation object - vectors = pvs.GetRepresentation(glyph) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set properties - if (is_colored): - pvs.ColorBy(vectors, (EntityType.get_pvtype(entity), 'GlyphVector')) - else: - pvs.ColorBy(vectors, (EntityType.get_pvtype(entity), None)) - vectors.LookupTable = lookup_table - - vectors.LineWidth = 1.0 - - # Set wireframe represenatation mode - vectors.Representation = 'Wireframe' - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - return vectors - - -def DeformedShapeOnField(proxy, entity, field_name, - timestamp_nb, - scale_factor=None, is_colored=False, - vector_mode='Magnitude'): - """Creates Defromed Shape presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - scale_factor: scale factor of the deformation - is_colored: this option allows to color the presentation according to - the corresponding data array values - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Defromed Shape as representation object. - - """ - proxy.UpdatePipeline() - # We don't need mesh parts with no data on them - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Do merge - source = pvs.MergeBlocks(proxy) - pvs.UpdatePipeline() - - # Cell data to point data - if is_data_on_cells(proxy, field_name): - cell_to_point = pvs.CellDatatoPointData() - cell_to_point.PassCellData = 1 - source = cell_to_point - - vector_array = field_name - # If the given vector array has only 2 components, add the third one - if nb_components == 2: - calc = get_add_component_calc(source, EntityType.NODE, field_name) - vector_array = calc.ResultArrayName - source = calc - - # Warp by vector - warp_vector = pvs.WarpByVector(source) - warp_vector.Vectors = [vector_array] - if scale_factor is not None: - warp_vector.ScaleFactor = scale_factor - else: - def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, - proxy, entity, field_name) - warp_vector.ScaleFactor = def_scale - - # Get Deformed Shape representation object - defshape = pvs.GetRepresentation(warp_vector) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set properties - if is_colored: - pvs.ColorBy(defshape, (EntityType.get_pvtype(entity), field_name)) - else: - pvs.ColorBy(defshape, (EntityType.get_pvtype(entity), None)) - defshape.LookupTable = lookup_table - - # Set wireframe represenatation mode - defshape.Representation = 'Wireframe' - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - return defshape - - -def DeformedShapeAndScalarMapOnField(proxy, entity, field_name, - timestamp_nb, - scale_factor=None, - scalar_entity=None, - scalar_field_name=None, - vector_mode='Magnitude'): - """Creates Defromed Shape And Scalar Map presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - scale_factor: scale factor of the deformation - scalar_entity: scalar field entity - scalar_field_name: scalar field, i.e. the field for coloring - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Defromed Shape And Scalar Map as representation object. - - """ - proxy.UpdatePipeline() - # We don't need mesh parts with no data on them - on_points = [] - on_cells = [] - - if entity == EntityType.NODE: - on_points.append(field_name) - else: - on_cells.append(field_name) - - if scalar_entity and scalar_field_name: - if scalar_entity == EntityType.NODE: - on_points.append(scalar_field_name) - else: - on_cells.append(scalar_field_name) - - nb_components = get_nb_components(proxy, entity, field_name) - - # Select fields - select_cells_with_data(proxy, on_points, on_cells) - - # Check vector mode - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Set scalar field by default - scalar_field_entity = scalar_entity - scalar_field = scalar_field_name - if (scalar_field_entity is None) or (scalar_field is None): - scalar_field_entity = entity - scalar_field = field_name - - # Do merge - source = pvs.MergeBlocks(proxy) - pvs.UpdatePipeline() - - # Cell data to point data - if is_data_on_cells(proxy, field_name): - cell_to_point = pvs.CellDatatoPointData(source) - cell_to_point.PassCellData = 1 - source = cell_to_point - - vector_array = field_name - # If the given vector array has only 2 components, add the third one - if nb_components == 2: - calc = get_add_component_calc(source, EntityType.NODE, field_name) - vector_array = calc.ResultArrayName - source = calc - - # Warp by vector - warp_vector = pvs.WarpByVector(source) - warp_vector.Vectors = [vector_array] - if scale_factor is not None: - warp_vector.ScaleFactor = scale_factor - else: - def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, - proxy, entity, field_name) - warp_vector.ScaleFactor = def_scale - - # Get Defromed Shape And Scalar Map representation object - defshapemap = pvs.GetRepresentation(warp_vector) - - # Get lookup table - lookup_table = get_lookup_table(scalar_field, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, scalar_field_entity, - scalar_field, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set properties - pvs.ColorBy(defshapemap, (EntityType.get_pvtype(scalar_field_entity), scalar_field)) - defshapemap.LookupTable = lookup_table - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - return defshapemap - - -def Plot3DOnField(proxy, entity, field_name, timestamp_nb, - orientation=Orientation.AUTO, - angle1=0, angle2=0, - position=0.5, is_relative=True, - scale_factor=None, - is_contour=False, nb_contours=32, - vector_mode='Magnitude'): - """Creates Plot 3D presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - orientation: the cut plane plane orientation in 3D space, if - the input is planar - will not be taken into account - angle1: rotation of the cut plane in 3d space around the first axis - of the selected orientation (X axis for XY, Y axis for YZ, - Z axis for ZX). - The angle of rotation is set in degrees. Acceptable range: [-45, 45]. - angle2: rotation of the cut plane in 3d space around the second axis - of the selected orientation. Acceptable range: [-45, 45]. - position: position of the cut plane in the object (ranging from 0 to 1). - The value 0.5 corresponds to cutting by halves. - is_relative: defines if the cut plane position is relative or absolute - scale_factor: deformation scale factor - is_contour: if True - Plot 3D will be represented with a set of contours, - otherwise - Plot 3D will be represented with a smooth surface - nb_contours: number of contours, applied if is_contour is True - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Plot 3D as representation object. - - """ - proxy.UpdatePipeline() - # We don't need mesh parts with no data on them - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Do merge - merge_blocks = pvs.MergeBlocks(proxy) - merge_blocks.UpdatePipeline() - - poly_data = None - - # Cutting plane - - # Define orientation if necessary (auto mode) - plane_orientation = orientation - if (orientation == Orientation.AUTO): - plane_orientation = get_orientation(proxy) - - # Get cutting plane normal - normal = None - - if (not is_planar_input(proxy)): - normal = get_normal_by_orientation(plane_orientation, - radians(angle1), radians(angle2)) - - # Create slice filter - slice_filter = pvs.Slice(merge_blocks) - slice_filter.SliceType = "Plane" - - # Set cutting plane normal - slice_filter.SliceType.Normal = normal - - # Set cutting plane position - if (is_relative): - base_position = get_positions(1, normal, - get_bounds(proxy), position) - slice_filter.SliceOffsetValues = base_position - else: - slice_filter.SliceOffsetValues = position - - slice_filter.UpdatePipeline() - poly_data = slice_filter - else: - normal = get_normal_by_orientation(plane_orientation, 0, 0) - - use_normal = 0 - # Geometry filter - if not poly_data or poly_data.GetDataInformation().GetNumberOfCells() == 0: - geometry_filter = pvs.GeometryFilter(merge_blocks) - poly_data = geometry_filter - use_normal = 1 # TODO(MZN): workaround - - warp_scalar = None - plot3d = None - source = poly_data - - if is_data_on_cells(poly_data, field_name): - # Cell data to point data - cell_to_point = pvs.CellDatatoPointData(poly_data) - cell_to_point.PassCellData = 1 - source = cell_to_point - - scalars = ['POINTS', field_name] - - # Transform vector array to scalar array if necessary - if (nb_components > 1): - calc = get_calc_magnitude(source, EntityType.NODE, field_name) - scalars = ['POINTS', calc.ResultArrayName] - source = calc - - # Warp by scalar - warp_scalar = pvs.WarpByScalar(source) - warp_scalar.Scalars = scalars - warp_scalar.Normal = normal - warp_scalar.UseNormal = use_normal - if scale_factor is not None: - warp_scalar.ScaleFactor = scale_factor - else: - def_scale = get_default_scale(PrsTypeEnum.PLOT3D, - proxy, entity, field_name) - warp_scalar.ScaleFactor = def_scale - - warp_scalar.UpdatePipeline() - source = warp_scalar - - if (is_contour): - # Contours - contour = pvs.Contour(warp_scalar) - contour.PointMergeMethod = "Uniform Binning" - contour.ContourBy = ['POINTS', field_name] - scalar_range = get_data_range(proxy, entity, - field_name, vector_mode) - contour.Isosurfaces = get_contours(scalar_range, nb_contours) - contour.UpdatePipeline() - source = contour - - # Get Plot 3D representation object - plot3d = pvs.GetRepresentation(source) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set properties - pvs.ColorBy(plot3d, (EntityType.get_pvtype(entity), field_name)) - plot3d.LookupTable = lookup_table - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - return plot3d - - -def IsoSurfacesOnField(proxy, entity, field_name, timestamp_nb, - custom_range=None, nb_surfaces=10, - is_colored=True, color=None, vector_mode='Magnitude'): - """Creates Iso Surfaces presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - custom_range: scalar range, if undefined the source range will be applied - nb_surfaces: number of surfaces, which will be generated - is_colored: this option allows to color the presentation according to - the corresponding data array values. If False - the presentation will - be one-coloured. - color: defines the presentation color as [R, G, B] triple. Taken into - account only if is_colored is False. - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Iso Surfaces as representation object. - - """ - proxy.UpdatePipeline() - # We don't need mesh parts with no data on them - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Do merge - source = pvs.MergeBlocks(proxy) - pvs.UpdatePipeline() - - # Transform cell data into point data if necessary - if is_data_on_cells(proxy, field_name): - cell_to_point = pvs.CellDatatoPointData(source) - cell_to_point.PassCellData = 1 - source = cell_to_point - - contour_by = ['POINTS', field_name] - - # Transform vector array to scalar array if necessary - if (nb_components > 1): - calc = get_calc_magnitude(source, EntityType.NODE, field_name) - contour_by = ['POINTS', calc.ResultArrayName] - source = calc - - # Contour filter settings - contour = pvs.Contour(source) - contour.ComputeScalars = 1 - contour.ContourBy = contour_by - - # Specify the range - scalar_range = custom_range - if (scalar_range is None): - scalar_range = get_data_range(proxy, entity, - field_name, cut_off=True) - - # Get contour values for the range - surfaces = get_contours(scalar_range, nb_surfaces) - - # Set contour values - contour.Isosurfaces = surfaces - - # Get Iso Surfaces representation object - isosurfaces = pvs.GetRepresentation(contour) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set display properties - if (is_colored): - pvs.ColorBy(isosurfaces, (EntityType.get_pvtype(entity), field_name)) - else: - pvs.ColorBy(isosurfaces, (EntityType.get_pvtype(entity), None)) - if color: - isosurfaces.DiffuseColor = color - isosurfaces.LookupTable = lookup_table - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - return isosurfaces - - -def GaussPointsOnField(proxy, entity, field_name, - timestamp_nb, - is_deformed=True, scale_factor=None, - is_colored=True, color=None, - primitive=GaussType.SPRITE, - is_proportional=True, - max_pixel_size=256, - multiplier=None, vector_mode='Magnitude'): - """Creates Gauss Points on the given field. - - Arguments: - - proxy: the pipeline object, containig data - entity: the field entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - is_deformed: defines whether the Gauss Points will be deformed or not - scale_factor -- the scale factor for deformation. Will be taken into - account only if is_deformed is True. - If not passed by user, default scale will be computed. - is_colored -- defines whether the Gauss Points will be multicolored, - using the corresponding data values - color: defines the presentation color as [R, G, B] triple. Taken into - account only if is_colored is False. - primitive: primitive type from GaussType - is_proportional: if True, the size of primitives will depends on - the gauss point value - max_pixel_size: the maximum sizr of the Gauss Points primitive in pixels - multiplier: coefficient between data values and the size of primitives - If not passed by user, default scale will be computed. - vector_mode: the mode of transformation of vector values into - scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude' - vector module; - 'X', 'Y', 'Z' - vector components. - - Returns: - Gauss Points as representation object. - - """ - proxy.UpdatePipeline() - # We don't need mesh parts with no data on them - on_gauss = select_cells_with_data(proxy, on_gauss=[field_name]) - if not on_gauss: - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - source = proxy - - # If no quadrature point array is passed, use cell centers - if on_gauss: - generate_qp = pvs.GenerateQuadraturePoints(source) - generate_qp.QuadratureSchemeDef = ['CELLS', 'ELGA@0'] - source = generate_qp - else: - # Cell centers - cell_centers = pvs.CellCenters(source) - cell_centers.VertexCells = 1 - source = cell_centers - - source.UpdatePipeline() - - # Check if deformation enabled - if is_deformed and nb_components > 1: - vector_array = field_name - # If the given vector array has only 2 components, add the third one - if nb_components == 2: - calc = get_add_component_calc(source, EntityType.NODE, field_name) - vector_array = calc.ResultArrayName - source = calc - - # Warp by vector - warp_vector = pvs.WarpByVector(source) - warp_vector.Vectors = [vector_array] - if scale_factor is not None: - warp_vector.ScaleFactor = scale_factor - else: - def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, proxy, - entity, field_name) - warp_vector.ScaleFactor = def_scale - warp_vector.UpdatePipeline() - source = warp_vector - - # Get Gauss Points representation object - gausspnt = pvs.GetRepresentation(source) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set display properties - if is_colored: - pvs.ColorBy(gausspnt, (EntityType.get_pvtype(entity), field_name)) - else: - pvs.ColorBy(gausspnt, (EntityType.get_pvtype(entity), None)) - if color: - gausspnt.DiffuseColor = color - - gausspnt.LookupTable = lookup_table - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - # Set point sprite representation - gausspnt.Representation = 'Point Sprite' - - # Point sprite settings - gausspnt.InterpolateScalarsBeforeMapping = 0 - gausspnt.MaxPixelSize = max_pixel_size - - # Render mode - gausspnt.RenderMode = GaussType.get_mode(primitive) - - #if primitive == GaussType.SPRITE: - # Set texture - # TODO(MZN): replace with pvsimple high-level interface - # texture = sm.CreateProxy("textures", "SpriteTexture") - # alphamprop = texture.GetProperty("AlphaMethod") - # alphamprop.SetElement(0, 2) # Clamp - # alphatprop = texture.GetProperty("AlphaThreshold") - # alphatprop.SetElement(0, 63) - # maxprop = texture.GetProperty("Maximum") - # maxprop.SetElement(0, 255) - # texture.UpdateVTKObjects() - - # gausspnt.Texture = texture - #gausspnt.Texture.AlphaMethod = 'Clamp' - #gausspnt.Texture.AlphaThreshold = 63 - #gausspnt.Texture.Maximum= 255 - - # Proportional radius - gausspnt.RadiusUseScalarRange = 0 - gausspnt.RadiusIsProportional = 0 - - if is_proportional: - mult = multiplier - if mult is None and data_range[1] != 0: - mult = abs(0.1 / data_range[1]) - - gausspnt.RadiusScalarRange = data_range - gausspnt.RadiusTransferFunctionEnabled = 1 - gausspnt.RadiusMode = 'Scalar' - gausspnt.RadiusArray = ['POINTS', field_name] - if nb_components > 1: - v_comp = get_vector_component(vector_mode) - gausspnt.RadiusVectorComponent = v_comp - gausspnt.RadiusTransferFunctionMode = 'Table' - gausspnt.RadiusScalarRange = data_range - gausspnt.RadiusUseScalarRange = 1 - if mult is not None: - gausspnt.RadiusIsProportional = 1 - gausspnt.RadiusProportionalFactor = mult - else: - gausspnt.RadiusTransferFunctionEnabled = 0 - gausspnt.RadiusMode = 'Constant' - gausspnt.RadiusArray = ['POINTS', 'Constant Radius'] - - return gausspnt - -def GaussPointsOnField1(proxy, entity, field_name, - timestamp_nb, - is_colored=True, color=None, - primitive=GaussType.SPHERE, - is_proportional=True, - max_pixel_size=256, - multiplier=None, - vector_mode='Magnitude'): - """Creates Gauss Points on the given field. Use GaussPoints() Paraview interface. - - Arguments: - proxy: the pipeline object, containig data - entity: the field entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - is_colored -- defines whether the Gauss Points will be multicolored, - using the corresponding data values - color: defines the presentation color as [R, G, B] triple. Taken into - account only if is_colored is False. - primitive: primitive type from GaussType - is_proportional: if True, the size of primitives will depends on - the gauss point value - max_pixel_size: the maximum sizr of the Gauss Points primitive in pixels - multiplier: coefficient between data values and the size of primitives - If not passed by user, default scale will be computed. - vector_mode: the mode of transformation of vector values into - scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude' - vector module; - 'X', 'Y', 'Z' - vector components. - - Returns: - Gauss Points as representation object. - - """ - proxy.UpdatePipeline() - select_cells_with_data(proxy, on_gauss=[field_name]) - - nb_components = get_nb_components(proxy, entity, field_name) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - proxy.UpdatePipeline(time=time_value) - - # Create Gauss Points object - source = pvs.ELGAfieldToPointSprite(proxy) - source.UpdatePipeline() - - # Get Gauss Points representation object - gausspnt = pvs.GetRepresentation(source) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set display properties - if is_colored: - pvs.ColorBy(gausspnt, (EntityType.get_pvtype(entity), field_name)) - else: - pvs.ColorBy(gausspnt, (EntityType.get_pvtype(entity), None)) - if color: - gausspnt.DiffuseColor = color - - gausspnt.LookupTable = lookup_table - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - # Set point sprite representation - gausspnt.Representation = 'Point Sprite' - - # Point sprite settings - gausspnt.InterpolateScalarsBeforeMapping = 0 - gausspnt.MaxPixelSize = max_pixel_size - - # Render mode - gausspnt.RenderMode = GaussType.get_mode(primitive) - - #if primitive == GaussType.SPRITE: - # Set texture - # TODO(MZN): replace with pvsimple high-level interface - # texture = sm.CreateProxy("textures", "SpriteTexture") - # alphamprop = texture.GetProperty("AlphaMethod") - # alphamprop.SetElement(0, 2) # Clamp - # alphatprop = texture.GetProperty("AlphaThreshold") - # alphatprop.SetElement(0, 63) - # maxprop = texture.GetProperty("Maximum") - # maxprop.SetElement(0, 255) - # texture.UpdateVTKObjects() - - # gausspnt.Texture = texture - #gausspnt.Texture.AlphaMethod = 'Clamp' - #gausspnt.Texture.AlphaThreshold = 63 - #gausspnt.Texture.Maximum= 255 - - # Proportional radius - gausspnt.RadiusUseScalarRange = 0 - gausspnt.RadiusIsProportional = 0 - - if is_proportional: - mult = multiplier - if mult is None and data_range[1] != 0: - mult = abs(0.1 / data_range[1]) - - gausspnt.RadiusScalarRange = data_range - gausspnt.RadiusTransferFunctionEnabled = 1 - gausspnt.RadiusMode = 'Scalar' - gausspnt.RadiusArray = ['POINTS', field_name] - if nb_components > 1: - v_comp = get_vector_component(vector_mode) - gausspnt.RadiusVectorComponent = v_comp - gausspnt.RadiusTransferFunctionMode = 'Table' - gausspnt.RadiusScalarRange = data_range - gausspnt.RadiusUseScalarRange = 1 - if mult is not None: - gausspnt.RadiusIsProportional = 1 - gausspnt.RadiusProportionalFactor = mult - else: - gausspnt.RadiusTransferFunctionEnabled = 0 - gausspnt.RadiusMode = 'Constant' - gausspnt.RadiusArray = ['POINTS', 'Constant Radius'] - - return gausspnt - -def StreamLinesOnField(proxy, entity, field_name, timestamp_nb, - direction='BOTH', is_colored=False, color=None, - vector_mode='Magnitude'): - """Creates Stream Lines presentation on the given field. - - Arguments: - proxy: the pipeline object, containig data - entity: the entity type from PrsTypeEnum - field_name: the field name - timestamp_nb: the number of time step (1, 2, ...) - direction: the stream lines direction ('FORWARD', 'BACKWARD' or 'BOTH') - is_colored: this option allows to color the presentation according to - the corresponding data values. If False - the presentation will - be one-coloured. - color: defines the presentation color as [R, G, B] triple. Taken into - account only if is_colored is False. - vector_mode: the mode of transformation of vector values - into scalar values, applicable only if the field contains vector values. - Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. - - Returns: - Stream Lines as representation object. - - """ - proxy.UpdatePipeline() - # We don't need mesh parts with no data on them - if entity == EntityType.NODE: - select_cells_with_data(proxy, on_points=[field_name]) - else: - select_cells_with_data(proxy, on_cells=[field_name]) - - # Check vector mode - nb_components = get_nb_components(proxy, entity, field_name) - check_vector_mode(vector_mode, nb_components) - - # Get time value - time_value = get_time(proxy, timestamp_nb) - - # Set timestamp - pvs.GetRenderView().ViewTime = time_value - pvs.UpdatePipeline(time_value, proxy) - - # Do merge - source = pvs.MergeBlocks(proxy) - pvs.UpdatePipeline() - - # Cell data to point data - if is_data_on_cells(proxy, field_name): - cell_to_point = pvs.CellDatatoPointData(source) - cell_to_point.PassCellData = 1 - pvs.UpdatePipeline() - source = cell_to_point - - vector_array = field_name - # If the given vector array has only 2 components, add the third one - if nb_components == 2: - calc = get_add_component_calc(source, EntityType.NODE, field_name) - vector_array = calc.ResultArrayName - pvs.UpdatePipeline() - source = calc - - # Stream Tracer - stream = pvs.StreamTracer(source) - stream.SeedType = "Point Source" - stream.Vectors = ['POINTS', vector_array] - stream.IntegrationDirection = direction - stream.IntegratorType = 'Runge-Kutta 2' - stream.SeedType = 'High Resolution Line Source' - stream.UpdatePipeline() - - # Get Stream Lines representation object - if is_empty(stream): - return None - streamlines = pvs.GetRepresentation(stream) - - # Get lookup table - lookup_table = get_lookup_table(field_name, nb_components, vector_mode) - - # Set field range if necessary - data_range = get_data_range(proxy, entity, - field_name, vector_mode) - if hasattr(lookup_table,"LockDataRange"): - lookup_table.LockDataRange = 1 - elif hasattr(lookup_table,"LockScalarRange"): - lookup_table.LockScalarRange = 1 - else: - raise RuntimeError("Object %s has no 'LockDataRange' or 'LockScalarRange' attribute!"%(lookup_table)) - - lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] - - # Set properties - if is_colored: - pvs.ColorBy(streamlines, (EntityType.get_pvtype(entity), field_name)) - else: - pvs.ColorBy(streamlines, (EntityType.get_pvtype(entity), None)) - if color: - streamlines.DiffuseColor = color - - streamlines.LookupTable = lookup_table - - # Add scalar bar - add_scalar_bar(field_name, nb_components, - vector_mode, lookup_table, time_value) - - return streamlines - - -def MeshOnEntity(proxy, mesh_name, entity): - """Creates submesh of the entity type for the mesh. - - Arguments: - proxy -- the pipeline object, containig data - mesh_name -- the full or short name of mesh field - - Returns: - Submesh as representation object of the given source. - - """ - proxy.UpdatePipeline() - mesh_full_name = None - aList = mesh_name.split('/') - if len(aList) >= 2: - mesh_full_name = mesh_name - else: - mesh_full_name = find_mesh_full_name(proxy, mesh_name) - if not mesh_full_name: - raise RuntimeError("The given mesh name was not found") - # Select only the given mesh - proxy.AllArrays = [mesh_full_name] - proxy.UpdatePipeline() - - # Get representation object if the submesh is not empty - prs = None - if (proxy.GetDataInformation().GetNumberOfPoints() or - proxy.GetDataInformation().GetNumberOfCells()): - my_view = pvs.GetRenderView() - prs = pvs.GetRepresentation(proxy, view=my_view) - prs.ColorArrayName = (None, '') - - return prs - - -def MeshOnGroup(proxy, extrGroups, group_name): - """Creates submesh on the group. - - Arguments: - proxy -- the pipeline object, containig data - group_name -- the full group name - extrGroups -- all extracted groups object - - Returns: - Representation object of the given source with single group - selected. - - """ - proxy.UpdatePipeline() - # Deselect all groups - extrGroups.AllGroups = [] - extrGroups.UpdatePipelineInformation() - # Select only the group with the given name - extrGroups.AllGroups = [group_name] - extrGroups.UpdatePipelineInformation() - - # Get representation object if the submesh is not empty - prs = None - - # Check if the group was set - if len(extrGroups.AllGroups) == 1 and \ - extrGroups.AllGroups[0] == group_name: - # Check if the submesh is not empty - nb_points = proxy.GetDataInformation().GetNumberOfPoints() - nb_cells = proxy.GetDataInformation().GetNumberOfCells() - - if nb_points or nb_cells: -# prs = pvs.GetRepresentation(proxy) - prs = pvs.Show() - prs.ColorArrayName = (None, '') - display_only(prs) - - return prs - - -def CreatePrsForFile(file_name, prs_types, - picture_dir, picture_ext): - """Build presentations of the given types for the file. - - Build presentations for all fields on all timestamps. - - Arguments: - file_name: full path to the MED file - prs_types: the list of presentation types to build - picture_dir: the directory path for saving snapshots - picture_ext: graphics files extension (determines file type) - - """ - # Import MED file - print("Import " + file_name.split(os.sep)[-1] + "...") - - try: - proxy = pvs.MEDReader(FileName=file_name) - if proxy is None: - print("FAILED") - else: - #proxy.UpdatePipeline() - print("OK") - except: - print("FAILED") - else: - # Get view - view = pvs.GetRenderView() - time_value = get_time(proxy, 0) - view.ViewTime = time_value - pvs.UpdatePipeline(time=time_value, proxy=proxy) - - # Create required presentations for the proxy - CreatePrsForProxy(proxy, view, prs_types, - picture_dir, picture_ext) - -def CreatePrsForProxy(proxy, view, prs_types, picture_dir, picture_ext): - """Build presentations of the given types for all fields of the proxy. - - Save snapshots in graphics files (type depends on the given extension). - Stores the files in the given directory. - - Arguments: - proxy: the pipeline object, containig data - view: the render view - prs_types: the list of presentation types to build - picture_dir: the directory path for saving snapshots - picture_ext: graphics files extension (determines file type) - - """ - proxy.UpdatePipeline() - # List of the field names - fields_info = proxy.GetProperty("FieldsTreeInfo")[::2] - - # Add path separator to the end of picture path if necessery - if not picture_dir.endswith(os.sep): - picture_dir += os.sep - - # Mesh Presentation - if PrsTypeEnum.MESH in prs_types: - # Iterate on meshes - mesh_names = get_mesh_full_names(proxy) - for mesh_name in mesh_names: - # Build mesh field presentation - print("Creating submesh for '" + get_field_short_name(mesh_name) + "' mesh... ") - prs = MeshOnEntity(proxy, mesh_name, None) - if prs is None: - print("FAILED") - continue - else: - print("OK") - # Construct image file name - pic_name = picture_dir + get_field_short_name(mesh_name) + "." + picture_ext - - # Show and dump the presentation into a graphics file - process_prs_for_test(prs, view, pic_name, False) - - # Create Mesh presentation. Build all groups. - extGrp = pvs.ExtractGroup() - extGrp.UpdatePipelineInformation() - if if_possible(proxy, None, None, PrsTypeEnum.MESH, extGrp): - for group in get_group_names(extGrp): - print("Creating submesh on group " + get_group_short_name(group) + "... ") - prs = MeshOnGroup(proxy, extGrp, group) - if prs is None: - print("FAILED") - continue - else: - print("OK") - # Construct image file name - pic_name = picture_dir + get_group_short_name(group) + "." + picture_ext - - # Show and dump the presentation into a graphics file - process_prs_for_test(prs, view, pic_name, False) - - # Presentations on fields - for field in fields_info: - field_name = get_field_short_name(field) - # Ignore mesh presentation - if field_name == get_field_mesh_name(field): - continue - field_entity = get_field_entity(field) - # Select only the current field: - # necessary for getting the right timestamps - proxy.AllArrays = [field] - proxy.UpdatePipeline() - - # Get timestamps - timestamps = proxy.TimestepValues.GetData() - - for prs_type in prs_types: - # Ignore mesh presentation - if prs_type == PrsTypeEnum.MESH: - continue - - # Get name of presentation type - prs_name = PrsTypeEnum.get_name(prs_type) - - # Build the presentation if possible - possible = if_possible(proxy, field_name, - field_entity, prs_type) - if possible: - # Presentation type for graphics file name - f_prs_type = prs_name.replace(' ', '').upper() - - for timestamp_nb in range(1, len(timestamps) + 1): - time = timestamps[timestamp_nb - 1] - if (time == 0.0): - scalar_range = get_data_range(proxy, field_entity, - field_name, cut_off=True) - # exclude time stamps with null lenght of scalar range - if (scalar_range[0] == scalar_range[1]): - continue - print("Creating " + prs_name + " on " + field_name + ", time = " + str(time) + "... ") - try: - prs = create_prs(prs_type, proxy, - field_entity, field_name, timestamp_nb) - except ValueError: - """ This exception comes from get_nb_components(...) function. - The reason of exception is an implementation of MEDReader - activating the first leaf when reading MED file (refer to - MEDFileFieldRepresentationTree::activateTheFirst() and - MEDFileFieldRepresentationTree::getTheSingleActivated(...) methods). - """ - print("ValueError exception is catched") - continue - if prs is None: - print("FAILED") - continue - else: - print("OK") - - # Construct image file name - pic_name = picture_dir + field_name + "_" + str(time) + "_" + f_prs_type + "." + picture_ext - - # Show and dump the presentation into a graphics file - process_prs_for_test(prs, view, pic_name) - return - - -def delete_pv_object(obj): - # There is a bug when repeating CreateRenderView/Delete calls - # Here is a workaround proposed by KW (#10744) - import gc - del obj - gc.collect()