def subprobEditCB(self, gtkobj, path=None, col=None):
subproblemname = self.currentFullSubProblemName()
if subproblemname:
menuitem = mainmenu.OOF.Subproblem.Edit
subpctxt = ooflib.engine.subproblemcontext.subproblems[
subproblemname]
subpparam = menuitem.get_arg('subproblem')
subpparam.set(subpctxt.subptype)
extra_params = []
extra_params.append(whoville.WhoParameter(subpctxt.name(), subpctxt, subpctxt.path()))
if parameterwidgets.getParameters(
subpparam, title="Edit Subproblem definition", scope=self, hidden_params=extra_params):
menuitem.callWithDefaults(name=subproblemname)
def buildImageModMenu():
imagemodmenu.clearMenu()
for registration in imagemodifier.ImageModifier.registry:
try:
help = registration.tip
except AttributeError:
help = None
params = [whoville.WhoParameter('image', whoville.getClass('Image'),
tip=parameter.emptyTipString)] \
+ registration.params
menuitem = imagemodmenu.addItem(
oofmenu.OOFMenuItem(registration.name(),
callback=imagemodifier.doImageMod,
params=params,
help=help,
discussion=registration.discussion))
menuitem.data = registration
skeleton=skel,
elementdict=edict,
materialfactory=skeletonelement.SkeletonElement.realmaterial)
meshctxt.createDefaultSubProblem()
meshmenu.addItem(
OOFMenuItem(
'New',
callback=_newMesh,
params=[
parameter.StringParameter('name', tip="Name for the Mesh."),
parameter.ListOfStringsParameter('masterelems',
tip="Names of Master Elements."),
whoville.WhoParameter('skeleton',
skeletoncontext.skeletonContexts,
tip=parameter.emptyTipString)
],
help="Load a Mesh. Used internally in Mesh data files.",
discussion="<para>Load a &mesh; from a datafile.</para>"))
def _newSubProblem(menuitem, mesh, name, subproblem):
meshcontext = ooflib.engine.mesh.meshes[mesh]
meshcontext.reserve()
meshcontext.begin_writing()
try:
subpobj = subproblem.create()
meshcontext.newSubProblem(subpobj, subproblem,
labeltree.makePath(mesh) + [name])
finally:
dependencysubp.subptype.add_dependent(copyname)
for dep in copyctxt.subptype.get_dependencies():
ooflib.engine.subproblemcontext.subproblems[
dep].update_consistency()
copyctxt.propagate_consistency([copyname])
subproblemMenu.addItem(
oofmenu.OOFMenuItem(
'Copy',
callback=_copy_subproblem,
threadable=oofmenu.THREADABLE,
params=parameter.ParameterGroup(
whoville.WhoParameter('subproblem',
ooflib.engine.subproblemcontext.subproblems,
tip='The subproblem to be copied.'),
SyncMeshParameter('mesh', tip='The copy will be in this mesh.'),
whoville.AutoWhoNameParameter('name',
value=automatic.automatic,
resolver=subproblemNameResolver,
tip="Name to give to the copy")),
help="Copy a subproblem.",
discussion="""<para>
Copy a &subproblem;, possibly to another &mesh;. If the original
&subproblem; is defined in terms of objects (&pixelgroups;,
&materials;, <foreignphrase>etc.</foreignphrase> that don't exist
in the destination &mesh;, then the copied &subproblem; will
contain no &elems;.
</para>"""))
def buildSelectionModMenu():
selmodmenu.clearMenu()
selmodmenu.addItem(
oofmenu.OOFMenuItem('Undo',
params=[
whoville.WhoParameter(
'microstructure',
microstructure.microStructures,
tip=parameter.emptyTipString)
],
callback=pixelselectionmod.undo,
help="Undo the latest selection.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/common/menu/undo_pixsel.xml')))
selmodmenu.addItem(
oofmenu.OOFMenuItem('Redo',
params=[
whoville.WhoParameter(
'microstructure',
microstructure.microStructures,
tip=parameter.emptyTipString)
],
callback=pixelselectionmod.redo,
help="Redo the latest undone selection.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/common/menu/redo_pixsel.xml')))
selmodmenu.addItem(
oofmenu.OOFMenuItem(
'Clear',
params=[
whoville.WhoParameter('microstructure',
microstructure.microStructures,
tip=parameter.emptyTipString)
],
callback=pixelselectionmod.clear,
help="Clear the current selection.",
discussion="<para>Clear the current selection.</para>"))
for registration in pixelselectionmod.SelectionModifier.registry:
# Help string
try:
help = registration.tip
except AttributeError:
help = None
# Discussion
try:
discussion = registration.discussion
except AttributeError:
discussion = None
menuitem = selmodmenu.addItem(
oofmenu.OOFMenuItem(
utils.space2underscore(registration.name()),
callback=pixelselectionmod.doSelectionMod,
threadable=oofmenu.THREADABLE,
params=[
whoville.WhoParameter('microstructure',
microstructure.microStructures,
tip=parameter.emptyTipString)
] + registration.params,
help=help,
discussion=discussion))
menuitem.data = registration
# copied. We don't need to know it here.
meshctxt = ooflib.engine.mesh.meshes[self.mesh]
meshctxt.restoreCachedData(meshctxt.getTime(self.time))
try:
meshobj = meshctxt.getObject()
femesh.init_field(meshobj.skeleton, meshobj, field)
finally:
meshctxt.releaseCachedData()
def shortrepr(self):
return "mesh=%s" % self.mesh
othermeshparams = [
whoville.WhoParameter('mesh',
ooflib.engine.mesh.meshes,
tip='Copy field values from this Mesh.'),
placeholder.TimeParameter(
'time',
value=placeholder.latest,
tip='Use values at this time in the source Mesh.')
]
class ScalarOtherMeshInit(OtherMeshFieldInit, ScalarFieldInit):
pass
registeredclass.Registration(
"Other Mesh",
ScalarFieldInit,
switchboard.notify("new pixel group", grp)
return grp
reporter.report("Failed to create group", name, "in microstructure",
microstructure)
ipcpixgrpmenu.addItem(
OOFMenuItem(
'New',
callback=newPixelGroup_parallel,
threadable=oofmenu.PARALLEL_THREADABLE,
params=parameter.ParameterGroup(
StringParameter('name', tip="Group name."),
whoville.WhoParameter(
'microstructure',
whoville.getClass('Microstructure'),
tip="Microstructure in which to create this PixelGroup.")),
help='Create a new PixelGroup in the given Microstructure.',
discussion="""<para>
Create a new &pixelgroup;. The <varname>name</varname> of the
group must be unique within the µ. If it is not unique, a
suffix of the form <userinput><x></userinput> will be
appended, for some integer <userinput>x</userinput>.
</para>"""))
##########################
def renamePixelGroup_parallel(menuitem, microstructure, group, new_name):
##############################
class CopyActiveArea(ActiveAreaModifier):
def __init__(self, source):
self.source = source # source Microstructure
def __call__(self, microstructure):
sourceMS = ooflib.common.microstructure.microStructures[self.source]
microstructure.activearea.start()
microstructure.activearea.getObject().setFromGroup(
sourceMS.getObject().activearea.getPixelSet())
## TODO OPT: Does this have to send "pixel selection changed"?
registeredclass.Registration(
'Copy',
ActiveAreaModifier,
CopyActiveArea,
ordering=5.0,
params=[
whoville.WhoParameter(
'source',
ooflib.common.microstructure.microStructures,
tip='Copy the active area from this Microstructure.')
],
tip="Copy the active area from another Microstructure.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/common/menu/copy_activearea.xml'))
tip="Gray image data.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/image/reg/graydata8.xml'))
def _newImage(menuitem, name, microstructure, pixels):
ms = ooflib.common.microstructure.microStructures[microstructure].getObject()
image = oofimage.newImageFromData(name, ms.sizeInPixels(), pixels.values())
image.setSize(ms.size())
imagemenu.loadImageIntoMS(image, microstructure)
imgmenu.addItem(oofmenu.OOFMenuItem(
'New',
callback=_newImage,
params=[
parameter.StringParameter('name', tip="Name for the Image."),
whoville.WhoParameter('microstructure',whoville.getClass('Microstructure'),
tip=parameter.emptyTipString),
parameter.RegisteredParameter('pixels', ImageData,
tip=parameter.emptyTipString)],
help="Load an Image.",
discussion="<para>Load an ℑ from a saved µ.</para>"
))
def writeImage(datafile, imagecontext):
datafile.startCmd(mainmenu.OOF.LoadData.Image.New)
datafile.argument('name', imagecontext.name())
datafile.argument('microstructure', imagecontext.getMicrostructure().name())
datafile.argument('pixels', RGBData8(imagecontext.getObject().getPixels()))
datafile.endCmd()
endtime = meshctxt.getTime(finish)
for t in meshctxt.cachedTimes():
if starttime <= t <= endtime:
yield t
registeredclass.Registration(
"Times From One Mesh",
animationtimes.AnimationTimes,
MeshTimes,
ordering=0,
## TODO 3.1: Restrict to meshes actually displayed in the gfx
## window! This might be hard to do.
params=[
whoville.WhoParameter('mesh',
ooflib.engine.mesh.meshes,
tip="The name of the Mesh.")
],
tip="Get frame times from stored data in a Mesh.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/meshtimes.xml'))
class AllMeshTimes(animationtimes.AnimationTimes):
# Use times stored in all animated Meshes in the window
def times(self, start, finish, gfxwindow):
# Return a list of times between start and finish for all the
# animatable layers in the graphics window.
thymes = gfxwindow.findAnimationTimes()
if thymes:
if start is placeholder.earliest:
if finish is placeholder.latest:
parameter.BooleanParameter("front_back_periodicity", value=False,
tip="Whether or not the skeleton is periodic in the third direction"))
skeletonmenu.addItem(oofmenu.OOFMenuItem(
'Auto',
callback=autoskeleton.autoSkeleton,
threadable=oofmenu.THREADABLE,
no_log=True, # because it calls other menu items
params=parameter.ParameterGroup(
parameter.AutomaticNameParameter('name',
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")
# This resolver can return "None" in the skelname==None case, which
# occurs when the registeredclassfactory switches around.
def bdynameresolver(param, startname):
if param.automatic():
basename = 'boundary'
else:
basename = startname
skelname = param.group['skeleton'].value
skelcontext = skeletoncontext.skeletonContexts[skelname]
return skelcontext.uniqueBoundaryName(basename)
skeletonparam = whoville.WhoParameter(
'skeleton',
skeletoncontext.skeletonContexts,
tip="The Skeleton containing the boundary.")
nameparam = parameter.AutomaticNameParameter('name',
bdynameresolver,
value=automatic.automatic,
tip="Name for this boundary.")
paramgroup = parameter.ParameterGroup(skeletonparam, nameparam)
# ## ### #### ##### ###### ####### ######## ####### ###### ##### #### ### ## #
class BoundaryConstructor(registeredclass.RegisteredClass):
registry = []
tip = "Tools to build Skeleton boundaries."
"Deselect all pixels within a given distance of the boundaries of the current selection.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/common/menu/shrink_pixsel.xml'))
#############################
class CopyPixelSelection(SelectionModifier):
def __init__(self, source):
self.source = source
def __call__(self, ms, selection):
selection.start()
sourceMS = ooflib.common.microstructure.microStructures[self.source]
selection.selectFromGroup(
sourceMS.getObject().pixelselection.getSelectionAsGroup())
registeredclass.Registration(
'Copy',
SelectionModifier,
CopyPixelSelection,
ordering=4.0,
params=[
whoville.WhoParameter(
'source',
ooflib.common.microstructure.microStructures,
tip="Copy the current selection from this Microstructure.")
],
tip="Copy the current selection from another Microstructure.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/copy_pixsel.xml'))
def __init__(self, gfxwindow):
toolbox.Toolbox.__init__(self, 'Pin_Nodes', gfxwindow)
self.skeleton_param = whoville.WhoParameter(
'skeleton',
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
themesh.begin_writing()
try:
themesh.rename(name, exclude=oldmeshpath[-1])
finally:
themesh.end_writing()
themesh.cancel_reservation()
ipcmeshmenu.addItem(
oofmenu.OOFMenuItem(
'Rename',
callback=renameMesh_parallel,
threadable=oofmenu.PARALLEL_THREADABLE,
params=[
whoville.WhoParameter('mesh',
ooflib.engine.mesh.meshes,
tip=parameter.emptyTipString),
parameter.StringParameter('name', '', tip='New name for the mesh.')
]))
#######################################
def deleteMesh_parallel(menuitem, mesh):
meshctxt = ooflib.engine.mesh.meshes[mesh]
subproblems = meshctxt.subproblems()
for subproblem in subproblems:
subproblem.begin_writing()
try:
subproblem.destroy()
def makeMenu():
pinnodesmenu.clearMenu()
pinnodesmenu.addItem(
oofmenu.OOFMenuItem('Undo',
callback=pinnodesmodifier.undo,
params=[
whoville.WhoParameter(
'skeleton',
skeletoncontext.skeletonContexts,
tip=parameter.emptyTipString)
],
help="Undo the pinning operation.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/pinnodes_undo.xml')))
pinnodesmenu.addItem(
oofmenu.OOFMenuItem('Redo',
callback=pinnodesmodifier.redo,
params=[
whoville.WhoParameter(
'skeleton',
skeletoncontext.skeletonContexts,
tip=parameter.emptyTipString)
],
help="Undo the undone pinning operation.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/pinnodes_redo.xml')))
pinnodesmenu.addItem(
oofmenu.OOFMenuItem('UnPinAll',
callback=pinnodesmodifier.unpinall,
params=[
whoville.WhoParameter(
'skeleton',
skeletoncontext.skeletonContexts,
tip=parameter.emptyTipString)
],
help="Unpin all nodes of the Skeleton.",
discussion="""<para>
Unpin all of the <link
linkend='MenuItem-OOF.Skeleton.PinNodes'>pinned</link> &nodes;
in the given &skel;.
</para>"""))
pinnodesmenu.addItem(
oofmenu.OOFMenuItem('Invert',
callback=pinnodesmodifier.invert,
params=[
whoville.WhoParameter(
'skeleton',
skeletoncontext.skeletonContexts,
tip=parameter.emptyTipString)
],
help="Pin the unpinned and unpin the pinned.",
discussion="""<para>
Invert the status of <link
linkend='MenuItem-OOF.Skeleton.PinNodes'>pinned</link> &nodes;
in the given &skel;. Pinned &nodes; will be released and free
nodes will be pinned.
</para>"""))
for registration in pinnodesmodifier.PinNodesModifier.registry:
try:
help = registration.tip
except AttributeError:
help = None
try:
discussion = registration.discussion
except AttributeError:
discussion = None
menuitem = pinnodesmenu.addItem(
oofmenu.OOFMenuItem(
utils.space2underscore(registration.name()),
callback=pinnodesmodifier.pinnodesmod,
params=[
whoville.WhoParameter('skeleton',
skeletoncontext.skeletonContexts,
tip=parameter.emptyTipString)
] + registration.params,
help=help,
discussion=discussion))
menuitem.data = registration
def buildActiveAreaModMenu():
aamodmenu.clearMenu()
aamodmenu.addItem(oofmenu.OOFMenuItem(
'Undo',
callback=_undo,
params=[whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString)
],
help="Undo the latest active area modification.",
discussion="""<para>
Revert to the previous &active; in the given
µ.</para>"""
))
aamodmenu.addItem(oofmenu.OOFMenuItem(
'Redo',
callback=_redo,
params=[whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString)
],
help="Redo the latest undone active area modification.",
discussion="""<para>
Undo the latest <xref linkend='MenuItem-OOF.ActiveArea.Undo'/>.
</para>"""))
aamodmenu.addItem(oofmenu.OOFMenuItem(
'Override',
params=[parameter.BooleanParameter('override', 0,
tip="Whether to override or not."),
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString)
],
callback=_override,
help="Temporarily activate the entire Microstructure.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/activearea_override.xml')))
aamodmenu.addItem(oofmenu.OOFMenuItem(
'Store',
callback=_store,
params=parameter.ParameterGroup(
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString),
parameter.AutomaticNameParameter('name', value=automatic.automatic,
resolver=activeAreaNameResolver,
tip = "The name of the active are to be stored")),
help="Store the current active area.",
discussion="""<para>
Give the current &active; a <varname>name</varname>, and store
it for future use. This makes it easy to switch between
different active regions of a µ. If the given
<varname>name</varname> is already being used for another
&active; in the same µ, then
<userinput><x></userinput> will be appended to it, where
<userinput>x</userinput> is an integer chosen to make the name
unique.
</para>"""))
aamodmenu.addItem(oofmenu.OOFMenuItem(
'Restore',
callback=_restore,
params=[whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString),
parameter.StringParameter('name', tip="The name of the active area to be restored.")],
help="Restore a named active area.",
discussion="""<para>
Set the current &active; to the given <link
linkend='MenuItem-OOF.ActiveArea.Store'>stored</link>
&active;.
</para>"""))
aamodmenu.addItem(oofmenu.OOFMenuItem(
'Rename',
callback=_rename,
params=[
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString),
parameter.StringParameter('oldname',
tip="The name of a stored active area."),
parameter.StringParameter('newname', '',
tip='A new name for the active area.')
],
help="Rename the stored active area.",
discussion="<para>Assign a new name to a stored active area.</para>"))
aamodmenu.addItem(oofmenu.OOFMenuItem(
'Delete',
callback=_delete,
params=[
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString),
parameter.StringParameter('name', tip="The name of the active area to be deleted.")],
help="Delete a stored active area.",
discussion="""<para>
Delete a <link
linkend='MenuItem-OOF.ActiveArea.Store'>stored</link> active
area. This only deletes the stored copy of the active area.
It does not affect the activity of any pixels.
</para>"""))
for registration in activeareamod.ActiveAreaModifier.registry:
# registration tip string => menuitem help string
try:
help = registration.tip
except AttributeError:
help = None
# registration discussion => menuitem discussion
try:
discussion = registration.discussion
except AttributeError:
discussion = None
menuitem = aamodmenu.addItem(
oofmenu.OOFMenuItem(utils.space2underscore(registration.name()),
callback=activeareamod.modify,
params=[
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString)
] + registration.params,
help=help,
discussion=discussion))
menuitem.data = registration
from ooflib.engine import namedanalysis
from ooflib.engine.IO import analyzemenu
from ooflib.engine.IO import meshmenu
from ooflib.engine.IO import meshparameters
from ooflib.engine.IO import outputdestination
import ooflib.engine.mesh
import string
import types
bdyanalysismenu = meshmenu.meshmenu.addItem(
oofmenu.OOFMenuItem(
'Boundary_Analysis',
help="Compute properties of the solution on boundaries."))
mesh_param = whoville.WhoParameter(
'mesh',
ooflib.engine.mesh.meshes,
tip="The mesh on which to perform the analysis.")
time_param = placeholder.TimeParameter(
'time', tip='Time at which to perform the analysis.')
bdy_param = meshparameters.MeshEdgeBdyParameter('boundary',
tip="The boundary to analyze.")
analyzer_param = parameter.RegisteredParameter(
'analyzer',
meshbdyanalysis.MeshBdyAnalyzer,
tip="Operation to perform on the boundary.")
destination_param = outputdestination.OutputDestinationParameter(
'destination',
def makeMenu(menu, modifier, selection_name):
menu.clearMenu()
objname = selection_name[:-9] # 'node', 'segment', or 'element'
undo_item = menu.addItem(
oofmenu.OOFMenuItem(
"Undo",
callback=_undo,
params=[
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
],
help="Undo the latest Skeleton %s selection operation." % objname,
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/%s_undo.xml' % objname)))
undo_item.data = selection_name
redo_item = menu.addItem(oofmenu.OOFMenuItem(
"Redo", callback=_redo,
params = [
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)],
help="Redo the latest undone Skeleton %s selection operation."\
% objname,
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/%s_redo.xml'
% objname)
))
redo_item.data = selection_name
clear_item = menu.addItem(
oofmenu.OOFMenuItem(
"Clear",
callback=_clear,
params=[
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
],
help="Clear the current Skeleton %s selection." % objname,
discussion="<para>Unselect all %ss in the &skel;.</para>" %
objname))
clear_item.data = selection_name
invert_item = menu.addItem(
oofmenu.OOFMenuItem(
"Invert",
callback=_invert,
params=[
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
],
help="Invert the current Skeleton %s selection." % objname,
discussion="""<para>
Select the unselected %ss, and unselect the selected %ss in the &skel;.
</para>""" % (objname, objname)))
invert_item.data = selection_name
for r in modifier.registry:
# For help
try:
help = r.tip
except AttributeError:
help = None
# For discussion
try:
discussion = r.discussion
except AttributeError:
discussion = None
menuitem = menu.addItem(
oofmenu.OOFMenuItem(
utils.space2underscore(r.name()),
callback=skeletonselectionmod.modify,
params=[
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
] + r.params,
help=help,
discussion=discussion))
menuitem.data = r
def __call__(self, ms, selection):
skel = skeletoncontext.skeletonContexts[self.skeleton].getObject()
selection.start()
for el in skel.elements:
if el.selected:
selection.select(ElementSelection(ms, el))
registeredclass.Registration(
'Select Element Pixels',
registeredclass=pixelselectionmod.SelectionModifier,
subclass=SelectPixelsInElement,
ordering=100,
params=[
whoville.WhoParameter('skeleton',
skeletoncontext.skeletonContexts,
tip=parameter.emptyTipString)
],
tip="Select the pixels lying under the selected elements.",
discussion="""<para>
Select all pixels that intersect the currently selected &skel; elements.
</para>""")
SegmentSelection = pixelselectioncouriere.SegmentSelection
class SelectPixelsUnderSegment(pixelselectionmod.SelectionModifier):
def __init__(self, skeleton):
self.skeleton = skeleton
def __call__(self, ms, selection):
corientation.COrientABG(*orientations[count]))
count += 1
orientmapdata.registerOrientMap(microstructure, od)
orientmapplugin = mscontext.getObject().getPlugIn('OrientationMap')
orientmapplugin.set_data(od, filename)
orientmapplugin.timestamp.increment()
orientmapdata.orientationmapNotify(ms)
microstructureIO.micromenu.addItem(
oofmenu.OOFMenuItem(
'OrientationMap',
callback=_loadOrientationMap,
params=[
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString),
parameter.StringParameter('filename',
tip="File from which the map was read."),
parameter.ListOfListOfFloatsParameter(
'orientations', tip='Tuples containing ABG values.')
],
help="Load an Orientation Map. Used internally in data files.",
discussion="""<para>
Load an <classname>Orientation Map</classname> into a µ.
This command is used only in data files, and is only available if
&oof2; was built with the
<userinput>--enable-orientationmap</userinput> option.
</para>"""))
for name in active_areas:
aal.add(aa_dict[name])
px_dict[name].append(p)
for name in active_areas:
aa_dict[name].add_pixels(px_dict[name])
# This item is a sub-item of OOF.LoadData.Microstructure.DefineCategory.
microstructureIO.categorymenu.addItem(
oofmenu.OOFMenuItem(
'NamedActiveArea',
callback=_namedactivearea,
params=[
whoville.WhoParameter('microstructure',
ms_module.microStructures,
tip=parameter.emptyTipString),
parameter.IntParameter('category', tip=parameter.emptyTipString),
parameter.ListOfStringsParameter('active_areas',
tip=parameter.emptyTipString)
],
help="Create a named active area in a microstructure",
discussion="""<para> Creates a named active area when
loading a microstructure from
a file. This menu item is only used in data files.</para>"""))
def _newactivearea(menuitem, microstructure, name):
ms_obj = ms_module.getMicrostructure(microstructure)
new_aa = activearea.ActiveArea(ms_obj.sizeInPixels(), ms_obj.size(),
ms_obj)
meshcontext = ooflib.engine.mesh.meshes[meshpath]
return meshcontext.uniqueBCName(basename)
bcmenu.addItem(
oofmenu.OOFMenuItem(
'New',
callback=_buildbc,
params=parameter.ParameterGroup(
parameter.AutomaticNameParameter(
'name',
value=automatic.automatic,
tip="Name of the new boundary condition",
resolver=bcnameResolver),
whoville.WhoParameter(
'mesh',
ooflib.engine.mesh.meshes,
tip='Mesh to which to apply the boundary condition.'),
parameter.RegisteredParameter("condition",
bdycondition.BC,
tip="The new boundary condition.")),
help='Create a new boundary condition.',
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/new_bc.xml')))
def _bcrename(menuitem, mesh, bc, name):
if parallel_enable.enabled():
boundaryconditionIPC.ipcbcmenu.Rename(mesh=mesh, bc=bc, name=name)
else:
meshcontext = ooflib.engine.mesh.meshes[mesh]
meshcontext.renameBdyCondition(bc, name)
if config.dimension() == 2:
def loadImage(menuitem, filename, microstructure, height, width):
if filename:
# Read file and create an OOFImage object
image = autoReadImage(filename, height, width, depth=0)
loadImageIntoMS(image, microstructure)
switchboard.notify("redraw")
imageparams = parameter.ParameterGroup(
filenameparam.ReadFileNameParameter('filename',
'image',
tip="Name of the image file."),
whoville.WhoParameter('microstructure',
whoville.getClass('Microstructure'),
tip=parameter.emptyTipString))
elif config.dimension() == 3:
def loadImage(menuitem, filenames, microstructure, height, width, depth):
if filenames:
# Read file and create an OOFImage3D object
image = autoReadImage(filenames, height, width, depth)
loadImageIntoMS(image, microstructure)
switchboard.notify("redraw")
imageparams = parameter.ParameterGroup(
parameter.RegisteredParameter("filenames",
oofimage.ThreeDImageSpecification),
whoville.WhoParameter('microstructure',
imageobj = image.getObject()
ms = image.getMicrostructure()
selection.start()
selection.clearAndSelect(
pixelselectioncourieri.ColorSelection(ms, imageobj, self.reference,
self.range))
registeredclass.Registration(
'Color Range',
pixelselectionmod.SelectionModifier,
ColorRange,
ordering=3.14,
params=[
whoville.WhoParameter('image',
whoville.getClass('Image'),
tip=parameter.emptyTipString),
color.NewColorParameter('reference', tip='Reference color.'),
colordiffparameter.ColorDifferenceParameter(
'range', tip='Deviation from the reference color.')
],
tip="Select all pixels similar to a reference color.",
discussion="""<para>
Select all pixels in an ℑ within a given
<varname>range</varname> of a given <varname>refererence</varname>
color. This command basically does the same thing that <xref
linkend='MenuItem:OOF.Graphics_n.Toolbox.Pixel_Select.Color'/>
does except the latter takes its <varname>reference</varname>
input from a mouse click in the Graphics window.
meshctxt.begin_writing()
try:
meshctxt.outputSchedule.add(name, output)
output.setSchedule(schedule, scheduletype)
output.setDestination(destination)
finally:
meshctxt.end_writing()
switchboard.notify("new scheduled output", meshctxt, name)
outputmenu.addItem(oofmenu.OOFMenuItem(
'New',
callback=_newOutput,
params=parameter.ParameterGroup(
whoville.WhoParameter(
'mesh', ooflib.engine.mesh.meshes,
tip='Define an output operation on this mesh.'),
parameter.AutomaticNameParameter(
'name', resolver=outputNameResolver,
value=automatic.automatic,
tip="A name for the new output operation."),
parameter.RegisteredParameter(
'output',
scheduledoutput.ScheduledOutput,
tip="The output operation."))
+ parameter.ParameterGroup(
parameter.RegisteredParameter(
'scheduletype',
outputschedule.ScheduleType,
tip='How to interpret the schedule.'),
outputschedule.OutputScheduleParameter(
def sourceParams(self):
return [
whoville.WhoParameter('skeleton',
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
]
help="Compute properties of the solution.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/analyze.xml'))
mainmenu.OOF.Mesh.addItem(ops_menu)
## OOF.LoadData.IPC.Analyze
if parallel_enable.enabled():
from ooflib.common.IO import parallelmainmenu
ipcops_menu = parallelmainmenu.ipcmenu.addItem(
oofmenu.OOFMenuItem('Analyze', secret=1, no_log=1)
)
# Parameters to all the menu items.
mesh_param = whoville.WhoParameter(
'mesh', ooflib.engine.mesh.meshes,
tip="The mesh on which to compute the output")
time_param = placeholder.TimeParameter(
'time', tip='Time at which to perform the analysis.')
output_param = output.ValueOutputParameter(
'data', tip="The output data source.")
domain_param = parameter.RegisteredParameter(
'domain', analysisdomain.Domain,
tip="Where on the mesh to compute the data.")
sample_param = parameter.RegisteredParameter(
'sampling', analysissample.SampleSet,
tip="How to sample the domain.")
# Gets the default name from the object being copied (or renamed).
def getBasename(self, param, startname):
if param.automatic():
return param.group['group'].value
return startname
#######################################
# Node-specific menu items:
new = oofmenu.OOFMenuItem(
"New_Group",
cli_only=1,
callback=_new_group,
params=parameter.ParameterGroup(
whoville.WhoParameter("skeleton", whoville.getClass('Skeleton'),
tip=parameter.emptyTipString),
AutomaticNameParameter("name", value=automatic.automatic,
resolver=NewGroupNameResolver("nodegroup",
"nodegroups"),
tip="Name of the group to be created.")),
help="Create a new node group.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/newnodegroup.xml')
)
new.data = "nodegroups"
nodegroupmenu.addItem(new)
auto = oofmenu.OOFMenuItem(
"Auto_Group",
cli_only=1,
callback=_auto_group,
def parallel_new_subproblem(menuitem, name, mesh, subproblem):
debug.fmsg()
meshcontext = ooflib.engine.mesh.meshes[mesh]
meshcontext.newSubProblem(subproblem, labeltree.makePath(mesh) + [name])
ipcsubproblemmenu.addItem(
oofmenu.OOFMenuItem(
'New',
callback=parallel_new_subproblem,
threadable=oofmenu.PARALLEL_THREADABLE,
params=[
parameter.StringParameter('name'),
whoville.WhoParameter('mesh',
ooflib.engine.mesh.meshes,
tip=parameter.emptyTipString),
parameter.RegisteredParameter('subproblem',
csubproblem.CSubProblemPtr,
tip=parameter.emptyTipString)
]))
#############
## TODO MER: The code in _copy_subproblem and _edit_subproblem is
## virtually identical and should be shared.
def parallel_copy_subproblem(menuitem, subproblem, mesh, name):
debug.fmsg()
sourcectxt = ooflib.engine.subproblemcontext.subproblems[subproblem]