return max(self.timestamp, skelcontext.bdyselected)
defaultSelSkelBdyColor = color.orange
defaultSelSkelBdyLineWidth = 4
defaultSelSkelBdyDotSize = 4
if config.dimension() == 2:
defaultSelSkelBdyArrowSize = 10
arrowparam = parameter.IntRangeParameter(
'arrowsize', (0, 20),
defaultSelSkelBdyArrowSize,
tip="Arrow size for edge boundaries.")
elif config.dimension() == 3:
defaultSelSkelBdyArrowSize = 1.5
arrowparam = parameter.FloatRangeParameter(
'arrowsize', (0, 10, 0.1),
defaultSelSkelBdyArrowSize,
tip="Arrow size for edge boundaries.")
def _setSelSkelBdyParams(menuitem, color, linewidth, dotsize, arrowsize):
global defaultSelSkelBdyColor
global defaultSelSkelBdyLineWidth
global defaultSelSkelBdyDotSize
global defaultSelSkelBdyArrowSize
defaultSelSkelBdyColor = color
defaultSelSkelBdyLineWidth = linewidth
defaultSelSkelBdyDotSize = dotsize
defaultSelSkelBdyArrowSize = arrowsize
selskelbdyparams = [
defaultVoxelRegionSelectionFaceColor = face_color
global defaultVoxelRegionSelectionFaceOpacity
defaultVoxelRegionSelectionFaceOpacity = face_opacity
global defaultVoxelRegionSelectionOtherOpacity
defaultVoxelRegionSelectionOtherOpacity = other_opacity
global defaultHideInactive
defaultHideInactive = hide_inactive
global defaultDimInactive
defaultDimInactive = dim_inactive
# Sizing and coloring options for the box and arrow. These can be
# set in the graphics defaults menu.
voxelregionselectionparams = [
parameter.FloatRangeParameter(
'point_size',
pointSizeRange,
defaultVoxelRegionSelectionPointSize,
tip="Size of the points on the corners of the box."),
parameter.FloatRangeParameter(
'line_width',
lineWidthRange,
defaultVoxelRegionSelectionLineWidth,
tip="Width of the lines on the edges of the box."),
color.ColorParameter(
'line_color',
defaultVoxelRegionSelectionLineColor,
tip="Color for the edges of the box."),
color.ColorParameter(
'face_color',
defaultVoxelRegionSelectionFaceColor,
tip="Color of the faces of the box."),
pixelselectionmethod.PixelSelectionRegistration(
'Orientation',
OrientationSelector,
ordering=1.1,
events=['up'],
params=[
latticesystem.LatticeSymmetryParameter(
'lattice_symmetry',
tip=
"Assume the material at each point has this symmetry, making some orientations equivalent."
),
parameter.FloatRangeParameter(
'misorientation', (0, 180, 1),
0,
tip=
"Select orientations with misorientation less than this, relative to the selected pixel's orientation, in degrees."
)
],
whoclasses=['Microstructure'],
tip=
"Select pixels whose orientation is within the given misorientation of the selected pixel's orientation."
)
#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#
## TODO: This method should be suppressed in the Pixel Selection
## Toolbox if the microstructure has no orientation map. The best way
## to do that might be to make OrientationMap a WhoClass, and treat it
## like an Image. Then the 'whoclasses' entry in the Registration
## would do what we need here.
timestepper.NLData.__init__(self, subproblem, linsys, endtime)
def _asymmetric(subproblem):
return ((subproblem.second_order_fields()
and subproblem.matrix_symmetry_M == symstate.ASYMMETRIC)
or subproblem.matrix_symmetry_C == symstate.ASYMMETRIC
or subproblem.matrix_symmetry_K == symstate.ASYMMETRIC)
registeredclass.Registration(
'SS22',
timestepper.TimeStepper,
SS22,
params=[
parameter.FloatRangeParameter(
'theta1', (0.0, 1.0, 0.1),
0.5,
tip='First moment of the weight function for time averages.'),
parameter.FloatRangeParameter(
'theta2', (0.0, 1.0, 0.1),
0.5,
tip='Second moment of the weight function for time averages.')
],
ordering=3.0,
require_timederiv=True,
tip=
"Zienkowicz and Taylor's SS22 algorithm for solving equations with second order time derivatives.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/ss22.xml'))
for segment in skel.segment_iterator():
if segment.homogeneity(skel.MS) < self.threshold:
selected.append(segment)
selection.start()
selection.clear()
selection.select(selected)
registeredclass.Registration(
'Select by Homogeneity',
SegmentSelectionModifier,
SegmentHomogeneity,
ordering=1.5,
params=[
parameter.FloatRangeParameter('threshold', (0.0, 1.0, 0.01),
value=0.9,
tip='The threshold homogeneity.')
],
tip="Select segments with homogeneity less than the given threshold.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/hetero_segments.xml'))
#######################
# Select the indicated group.
class SegmentSelectGroup(SegmentSelectionModifier):
def __init__(self, group):
self.group = group
def __call__(self, skeleton, selection):
class FadeImage(ImageModifier):
def __init__(self, factor):
self.factor = factor
def __call__(self, image):
image.fade(self.factor)
registeredclass.Registration(
'Fade',
ImageModifier,
FadeImage,
ordering=1.1,
params=[
parameter.FloatRangeParameter('factor', (0, 1, 0.01),
0.1,
tip="0 does nothing, 1 fades to white.")
],
tip="Fade the image by the given factor.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/image/reg/fadeimage.xml'))
class DimImage(ImageModifier):
def __init__(self, factor):
self.factor = factor
def __call__(self, image):
image.dim(self.factor)
registeredclass.Registration(
class SpreadValues(imagemodifier.ImageModifier):
def __init__(self, T):
self.T = T
def __call__(self, image):
dbls = oofimage.grayify(image)
dbls = imageops.spread(dbls, self.T)
imageops.setFromArray(image, dbls)
registeredclass.Registration(
"SpreadDataValues",
imagemodifier.ImageModifier,
SpreadValues,
ordering=200,
params=[parameter.FloatRangeParameter('T', (0, 1, .01), value=.5)],
tip="Scale values over given threshold for larger spread.")
class SpreadValues2(imagemodifier.ImageModifier):
def __init__(self, T):
self.T = T
def __call__(self, image):
dbls = oofimage.grayify(image)
dbls = imageops.spread2(dbls, self.T)
imageops.setFromArray(image, dbls)
registeredclass.Registration(
"SpreadDataValues2",
self.global_flammability, self.color_space_norm == "L2")
selector(BurnSelection(ms, cd.cobj, startpt, self.next_nearest))
# b = BasicBurner(self.local_flammability, self.global_flammability,
# self.color_space_norm==L2, self.next_nearest)
# selector(BurnSelection(ms, b, immidge.getObject(), startpt))
pixelselectionmethod.PixelSelectionRegistration(
'Burn',
Burn,
ordering=1.0,
params=[
parameter.FloatRangeParameter(
'local_flammability',
range=(0, 1, 0.001),
value=0.1,
tip=
'Maximum difference in neighboring pixel values across which a burn will extend.'
),
parameter.FloatRangeParameter(
'global_flammability',
range=(0, 1, 0.001),
value=0.2,
tip=
'Difference from initial pixel value beyond which a burn will not spread.'
),
enum.EnumParameter(
'color_space_norm',
pixeldifferentiator.ColorNorm,
value=pixeldifferentiator.L1,
tip="How to compute the difference between two colors in RGB space."
global saveTilingFactor, saveMinTileScale, saveFixedSubdivision
pixelsetboundary.cvar.tilingfactor = saveTilingFactor
pixelsetboundary.cvar.mintilescale = saveMinTileScale
pixelsetboundary.cvar.fixed_subdivision = saveFixedSubdivision
micromenu.addItem(
oofmenu.OOFMenuItem(
'SetHomogeneityParameters',
callback=setHomogParams,
ordering=1000,
secret=1,
params=[
parameter.FloatRangeParameter(
'factor',
range=(0.0, 1.0, 0.01),
default=0.5,
tip='Refinement factor for hierarchical tiles'),
parameter.IntParameter('minimumTileSize',
default=6,
tip='Minimum tile size, in pixel units'),
parameter.AutoIntParameter('fixedSubdivision',
default=automatic.automatic,
tip='Fixed number of subdivisions')
],
help="Set parameters for calculating element homogeneity."))
micromenu.addItem(
oofmenu.OOFMenuItem(
'ResetHomogeneityParameters',
callback=resetHomogParams,
criterion(skeleton, element):
self.markElement(element, divisions, markedEdges)
if prog.stopped():
return
prog.setFraction(1.0 * (i + 1) / n)
prog.setMessage("checked %d/%d elements" % (i + 1, n))
registeredclass.Registration(
'Heterogeneous Elements',
RefinementTarget,
CheckHomogeneity,
ordering=0,
params=[
parameter.FloatRangeParameter(
'threshold', (0.0, 1.0, 0.05),
value=0.9,
tip='Refine elements whose homogeneity is less than this.')
],
tip='Refine heterogeneous elements.',
discussion="""<para>
Any elements whose <link
linkend='Section-Concepts-Skeleton-Homogeneity'>homogeneity</link>
is less than the given <varname>threshold</varname> will be
refined. <xref linkend='Figure-refine'/> illustrates the
refinement of all elements with homogeneity less than 1.0.
</para>""")
#####################
class SegmentChooser(registeredclass.RegisteredClass):
defaultClipPlaneClickAndDragOpacity = plane_opacity
global defaultHideInactive
defaultHideInactive = hide_inactive
global defaultDimInactive
defaultDimInactive = dim_inactive
# Sizing and coloring options for the plane-arrow pair, which can be
# set in the graphics defaults menu.
clipplaneclickanddragparams = [
color.ColorParameter(
'arrow_color',
defaultClipPlaneClickAndDragArrowColor,
tip="Color of the arrow representing the normal vector."),
parameter.FloatRangeParameter('arrow_tip_radius',
radiusRange,
defaultClipPlaneClickAndDragArrowTipRadius,
tip="Radius of the arrow tip."),
parameter.FloatRangeParameter(
'arrow_length',
lengthRange,
defaultClipPlaneClickAndDragArrowLength,
tip="Length of the arrow relative to the plane"),
color.ColorParameter('plane_color',
defaultClipPlaneClickAndDragColor,
tip="Color of the plane."),
parameter.FloatRangeParameter('plane_opacity',
opacityRange,
defaultClipPlaneClickAndDragOpacity,
tip="Opacity of the plane."),
parameter.BooleanParameter(
'hide_inactive',
</para>"""
class ReductionRateCondition:
def reductionRateFailed(self, delta, total):
if delta is None:
return 1
# delta is negative, if energy is going down
reduction = -delta / total * 100.
return reduction < self.reduction_rate
reductionRateParam = parameter.FloatRangeParameter(
'reduction_rate', (0., 100., 0.1),
value=0.1,
tip=
"Minimum allowable energy reduction rate as a percentage of the total energy."
)
class AcceptanceRateCondition:
def acceptanceRateFailed(self, rate):
if rate is None:
return 1
return rate * 100. < self.acceptance_rate
acceptanceRateParam = parameter.FloatRangeParameter(
'acceptance_rate', (0., 100., 0.1),
value=7,
tip=
self.autoOpacityFactor = factor
self.canvaslayer.set_opacity(self.getOpacity())
defaultImageOpacity = 1.0
opacityRange = (0, 1, 0.05)
bitmapDisplay = registeredclass.Registration(
'Bitmap',
display.DisplayMethod,
BitmapDisplayMethod,
ordering=-100,
layerordering=display.Planar,
params = [
parameter.RegisteredParameter(
"filter",
voxelfilter.VoxelFilterPtr,
voxelfilter.AllVoxels(),
tip="Voxels to include in the display."),
parameter.FloatRangeParameter(
"opacity",
opacityRange,
defaultImageOpacity,
tip='Opacity of the image.')
],
whoclasses = ('Image',),
tip="Display an Image as a bitmap.",
discussion = xmlmenudump.loadFile(
'DISCUSSIONS/common/reg/bitmapdisplay.xml')
)
def select(self, skelctxt, selection):
clist, plist = selection.trackerlist()
courier = skeletonselectioncourier.SegmentHomogeneityCourier(
skelctxt.getObject(), self.min_homogeneity, self.max_homogeneity,
clist, plist)
self.operator.operate(selection, courier)
SegmentSelectionModRegistration(
'By Homogeneity',
SegmentHomogeneity,
ordering=_homogeneityOrdering,
params=[
parameter.FloatRangeParameter(
'min_homogeneity', (0.0, 1.0, 0.01),
value=0.0,
tip='Select segments with homogeneity greater than this.'),
parameter.FloatRangeParameter(
'max_homogeneity', (0.0, 1.0, 0.01),
value=0.0,
tip='Select segments with homogeneity lesss than this.'),
selectionoperators.SelectionOperatorParam('operator')
],
tip="Select segments with homogeneity less than the given threshold.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/hetero_segments.xml'))
#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#
class RandomSegments(SegmentSelectionModifier):
defaultSelectedElementOpacity = 0.6
def _setSelectedElementParams(menuitem, color, opacity):
global defaultSelectedElementColor
global defaultSelectedElementOpacity
defaultSelectedElementColor = color
defaultSelectedElementOpacity = opacity
selectedElementParams = [
color.ColorParameter('color',
defaultSelectedElementColor,
tip="Color for the selected elements."),
parameter.FloatRangeParameter('opacity', (0., 1., 0.01),
defaultSelectedElementOpacity,
tip="Opacity of the selected elements.")
]
mainmenu.gfxdefaultsmenu.Skeletons.addItem(
oofmenu.OOFMenuItem(
'Selected_Elements',
callback=_setSelectedElementParams,
ordering=1,
params=selectedElementParams,
help=
"Set default parameters for displaying selected skeleton elements.",
discussion="""<para>
Set default parameters for the
<xref linkend="RegisteredClass-SkeletonElementSelectionDisplay"/>,
#################################
findParentSegment = refine.findParentSegment
findSignature = refine.findSignature
####################
registeredclass.Registration(
'Snap Refine',
skeletonmodifier.SkeletonModifier,
SnapRefine,
ordering=400,
params=[
parameter.RegisteredParameter('targets',
refinementtarget.RefinementTarget,
tip='Target elements to be refined.'),
parameter.RegisteredParameter('criterion',
refine.RefinementCriterion,
tip='Exclude certain elements.'),
parameter.FloatRangeParameter(
'min_distance', (0.01, 3.0, 0.01),
value=1.0,
tip="""Minimum distance of transition points along a given edge
from each other and the end-points, in units of the maximum pixel dimension."""
)
# ,skeletonmodifier.alphaParameter
],
tip="Subdivide elements along pixel boundaries.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/snaprefine.xml'))
def fix(self, skel, element, obtuse_angles, acute_angles,
large_solid_angles, small_solid_angles, large_dihedral_angles,
small_dihedral_angles):
return _removeBadTetra(skel, element, obtuse_angles, acute_angles,
large_solid_angles, small_solid_angles,
large_dihedral_angles, small_dihedral_angles)
registeredclass.Registration(
'Remove Bad Tetrahedra',
Rationalizer,
RemoveBadTetrahedra,
gerund='removing bad tetrahedra',
ordering=20000, # do this last!
params=[
parameter.FloatRangeParameter(
'acute_angle', (0.0, 45.0, 0.5),
value=15.0,
tip='Minimum acceptable acute interior angle, in degrees'),
parameter.FloatRangeParameter(
'obtuse_angle', (90.0, 180.0, 1.0),
value=150.0,
tip='Maximum acceptable obtuse interior angle, in degrees')
],
tip='Remove triangles with extreme interior solid angles.',
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/ration_sharp.xml'))
def _removeBadTetra(skel, element, obtuse_angles, acute_angles,
large_solid_angles, small_solid_angles,
large_dihedral_angles, small_dihedral_angles):
faceToNodeMap = element.faceToNodeMap()
</para>"""
class ReductionRateCondition:
def reductionRateFailed(self, delta, total):
if delta is None:
return 1
# delta is negative, if energy is going down
reduction = -delta / total * 100.
return reduction < self.reduction_rate
reductionRateParam = parameter.FloatRangeParameter(
'reduction_rate', (0., 100., 0.1),
value=0.1,
tip=
"Minimum allowable energy reduction rate as a percentage of the total energy."
)
class AcceptanceRateCondition:
def acceptanceRateFailed(self, rate):
if rate is None:
return 1
return rate * 100. < self.acceptance_rate
acceptanceRateParam = parameter.FloatRangeParameter(
'acceptance_rate', (0., 100., 0.1),
value=7,
tip=
defaultTintOpacity = 0.9
def _setDefaultPixelSelectionParams(menuitem, color, tintOpacity):
global defaultPixelSelectionColor
global defaultTintOpacity
defaultPixelSelectionColor = color
defaultTintOpacity = tintopacity
colorparams = [
color.ColorParameter('color',
defaultPixelSelectionColor,
tip='Color of selected pixels.'),
parameter.FloatRangeParameter('tintOpacity', (0., 1., 0.01),
defaultTintOpacity,
tip='Opacity of tint of selected pixels.'
' 0 is transparent, 1 is opaque.')
]
mainmenu.gfxdefaultsmenu.Pixels.addItem(
oofmenu.OOFMenuItem(
'Pixel_Selection',
callback=_setDefaultPixelSelectionParams,
params=colorparams,
help="Set default parameters for displaying selected pixels.",
discussion="""<para>
Set default parameters for the <xref
linkend="RegisteredClass:BitmapOverlayDisplayMethod"/> that is used
to display <link linkend="Section:Concepts:Microstructure:PixelSelection">pixel selections</link>.
This command can be put in the &oof2rc; file to set defaults for all
selection.start()
selection.clearAndSelect(
pixelselectioncouriero.OrientationSelection(
orientationmap, self.orientation.corient,
self.lattice_symmetry.schoenflies(), self.misorientation))
registeredclass.Registration(
'Orientation Range',
pixelselectionmod.SelectionModifier,
OrientationRange,
ordering=10,
params=[
parameter.ConvertibleRegisteredParameter(
'orientation',
orientationmatrix.Orientation,
tip="Select orientations similar to this."),
latticesystem.LatticeSymmetryParameter(
'lattice_symmetry',
tip=
"Assume the material at each point has this symmetry, making some orientations equivalent."
),
parameter.FloatRangeParameter(
'misorientation', (0, 180, 1),
0,
tip=
"Select orientations with misorientation less than this, relative to the given orientation, in degrees."
)
],
tip="Select all pixels whose orientation is in a given range.")
def fix(self, skel, element, which):
nodes = element.nodes
parents = element.getParents()
if which%2 == 0:
triangles = (ProvisionalTriangle([nodes[0], nodes[1], nodes[2]],
parents=parents),
ProvisionalTriangle([nodes[0], nodes[2], nodes[3]],
parents=parents))
else:
triangles = (ProvisionalTriangle([nodes[1], nodes[2], nodes[3]],
parents=parents),
ProvisionalTriangle([nodes[0], nodes[1], nodes[3]],
parents=parents))
change = skeleton.ProvisionalChanges(skel)
change.removeElements(element)
change.insertElements(*triangles)
return [change]
registeredclass.Registration(
'Split Wide Quads',
rationalize.Rationalizer,
QuadSplit,
gerund = 'splitting wide quads',
ordering=1,
params=[
parameter.FloatRangeParameter('angle', (90.0, 180.0, 1.0), value = 150.0,
tip = 'Maximum acceptable interior angle')
],
tip = 'Split quadrilaterals with large interior angles.',
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/ration_wide.xml'))
self.canvaslayer.set_opacity(self.opacity)
def _setSelectedElementParams(menuitem, color, opacity):
global defaultSelectedElementColor
global defaultSelectedElementOpacity
defaultSelectedElementColor = color
defaultSelectedElementOpacity = opacity
selectedElementParams = [
color.ColorParameter('color',
defaultSelectedElementColor,
tip="Color for the selected elements."),
parameter.FloatRangeParameter('opacity', (0., 1., 0.01),
defaultSelectedElementOpacity,
tip="Opacity of the selected elements.")
]
mainmenu.gfxdefaultsmenu.Skeletons.addItem(
oofmenu.OOFMenuItem(
'Selected_Elements',
callback=_setSelectedElementParams,
ordering=1,
params=selectedElementParams,
help=
"Set default parameters for displaying selected skeleton elements.",
discussion="""<para>
Set default parameters for the
<xref linkend="RegisteredClass:SkeletonElementSelectionDisplay"/>,
from ooflib.engine import skeleton3d as skeleton
from ooflib.engine.IO import skeletongroupparams
import random
########################
# The alpha parameter for computing an element's effective energy is
# defined here so that different commands can share the same Parameter
# object. Then GUI users won't have to be changing the parameter
# separately in all the different commands that use it.
alphaParameter = parameter.FloatRangeParameter(
'alpha',
range=(0., 1.0, 0.01),
value=0.3,
tip=
'alpha controls the relative importance of element shape and homogeneity. alpha=0 emphasizes shape and ignores homogeneity. alpha=1 emphasizes homogeneity and ignores shape.'
)
#########################
class SkelModTargets(registeredclass.RegisteredClass):
registry = []
tip = "Which elements to modify?"
discussion = """<para>
<classname>SkelModTargets</classname> objects are used as the
<varname>targets</varname> parameter in <link
linkend='RegisteredClass-SkeletonModifier'><classname>SkeletonModifiers</classname></link>.
They determine which &elems; will be modified when a <xref
def setMicrostructure(self):
who = self.who().resolve(self.gfxwindow)
if who:
self.filter.setMicrostructure(who.getMicrostructure())
self.canvaslayer.setEmpty(self.selectionContext().empty())
defaultPixelSelectionColor = color.RGBColor(1.0, 0.22, 0.09)
defaultOpacity = 0.9
pixelSelectParams = [
color.ColorParameter('color',
defaultPixelSelectionColor,
tip='Color of selected voxels.'),
parameter.FloatRangeParameter('opacity', (0., 1.0, 0.01),
defaultOpacity,
tip="Opacity of the color")
]
pixelSelectionDisplay = registeredclass.Registration(
'Pixel Selection',
display.DisplayMethod,
PixelSelectionDisplay,
params=pixelSelectParams,
ordering=0,
layerordering=display.SemiPlanar(0.1),
whoclasses=('Microstructure', 'Image', 'Top Bitmap'),
tip="Indicator for selected voxels.")
def _setDefaultPixelSelectionParams(menuitem, color, opacity):
value=automatic.automatic,
resolver=skeletonNameResolver,
tip="Name of the new skeleton."),
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString)) +
periodicityParams +
parameter.ParameterGroup(
parameter.FloatParameter('maxscale', value=1.0,
tip="Rough size of the largest elements."),
parameter.FloatParameter("minscale", value=1.0,
tip="Rough size of the smallest elements."),
enum.EnumParameter('units', ooflib.common.units.Units, value='Physical',
tip="Units for minscale and maxscale."),
parameter.FloatRangeParameter('threshold', (0.0, 1.0, 0.01),
value=0.90,
tip="Minimum acceptable homogeneity")
), # end of ParameterGroup
help="Automatically create and refine a &skel;.",
discussion=xmlmenudump.loadFile("DISCUSSIONS/engine/menu/autoskel.xml")
))
#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#
def sanity_check(menuitem, skeleton, quick):
skel = skeletoncontext.skeletonContexts[skeleton].getObject()
if quick:
sane = skel.quick_sanity_check()
else:
sane = skel.sanity_check()
if not sane:
# def getTimeStamp(self, gfxwindow):
# return self.timestamp
def isOverlayer(self):
return True
# def isEmpty(self, gfxwindow):
# bitmap = self.who().resolve(gfxwindow).getBitmap()
# return bitmap is None or bitmap.empty()
if config.dimension() == 2:
bitoverlayparams = [
color.ColorParameter('color', tip="Bitmap color."),
parameter.FloatRangeParameter('tintOpacity', (0., 1., 0.01),
0.6,
tip="Opacity of the overlay.")
]
elif config.dimension() == 3:
bitoverlayparams = [
color.ColorParameter('color', tip="Bitmap color."),
parameter.FloatRangeParameter('tintOpacity', (0., 1., 0.01),
0.0,
tip="Opacity of the tint."),
]
bitmapOverlay = registeredclass.Registration(
'BitmapOverlay',
display.DisplayMethod,
BitmapOverlayDisplayMethod,
params=bitoverlayparams,
device.draw_alpha_image(bitmap, coord.Coord(0, 0),
bitmap.size())
elif config.dimension() == 3:
bitmap.setVoxelAlpha(self.voxelOpacity)
device.draw_alpha_image(bitmap, coord.Coord(0, 0, 0),
bitmap.size())
def getTimeStamp(self, gfxwindow):
return self.timestamp
if config.dimension() == 2:
bitoverlayparams = [
color.ColorParameter('color', tip="Bitmap color."),
parameter.FloatRangeParameter('tintOpacity', (0., 1., 0.01),
0.6,
tip="Opacity of the overlay.")
]
elif config.dimension() == 3:
bitoverlayparams = [
color.ColorParameter('color', tip="Bitmap color."),
parameter.FloatRangeParameter('tintOpacity', (0., 1., 0.01),
0.0,
tip="Opacity of the tint."),
parameter.FloatRangeParameter('voxelOpacity', (0., 1., 0.01),
0.2,
tip="Opacity of the given region.")
]
bitmapOverlay = registeredclass.Registration(
'BitmapOverlay',
'Material',
display.DisplayMethod,
MicrostructureMaterialDisplay,
ordering=0,
layerordering=display.Planar(0.4),
params=[
color.ColorParameter(
'no_material',
color.black,
tip="Color to use if no material has been assigned to a pixel"),
color.ColorParameter(
'no_color',
color.blue,
tip="Color to use if the assigned material has no assigned color"),
parameter.FloatRangeParameter("opacity",
bitmapdisplay.opacityRange,
bitmapdisplay.defaultImageOpacity,
tip="Opacity of material colors."),
parameter.RegisteredParameter("filter",
voxelfilter.VoxelFilterPtr,
voxelfilter.AllVoxels(),
tip="Voxels to include in the display.")
],
whoclasses=('Microstructure', ),
tip="Display the color of the Material assigned to each pixel.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/reg/microstructuredisplay.xml'))
############################
if config.dimension() == 2:
## TODO MER: Update for new display layer methods and 3D.
# Dummy parameter for smart widget
class ZZFluxParameter(meshparameters.FluxParameter):
pass
registeredclass.Registration(
'Z-Z Estimator',
ErrorEstimator,
ZZ_Estimator,
ordering=0.,
params=[
parameter.RegisteredParameter('norm',
ErrorNorm,
tip="How to measure the size of an error."),
ZZFluxParameter('flux', tip=parameter.emptyTipString),
parameter.FloatRangeParameter('threshold', (0.0, 100.0, 0.5),
value=10.,
tip='Maximum allowable percentage error.')
],
tip="Error estimation by Zienkiewicz and Zhu's superconvergent patch recovery.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/zzspr.xml'))
################################
# RefinementTarget for AdaptiveMeshRefinement. Marks all elements
# that fail the error estimator test.
class AdaptiveMeshRefine(refinementtarget.RefinementTarget):
def __init__(self, subproblem, estimator):
#self.mesh = mesh # mesh
self.subproblem = subproblem
self.estimator = estimator # ErrorEstimator instance
whoville.WhoParameter(
'source',
ooflib.common.microstructure.microStructures,
tip="Copy the current selection from this Microstructure."),
selectionoperators.SelectionOperatorParam('operator')
],
tip="Copy the current selection from another Microstructure.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/copy_pixsel.xml')
)
#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#
class RandomPixelSelection(pixelselection.VoxelSelectionModifier):
def __init__(self, p, operator):
self.p = p
self.operator = operator
def select(self, ms, selection):
courier = pixelselectioncourier.RandomSelection(ms.getObject(), self.p)
self.operator.operate(selection, courier)
pixelselection.VoxelSelectionModRegistration(
"Random",
RandomPixelSelection,
ordering=10.,
params=[
parameter.FloatRangeParameter('p', (0., 1., 0.01), value=0.5,
tip="Probability of selecting a voxel"),
selectionoperators.SelectionOperatorParam('operator')
],
tip="Select pixels randomly")
