def makeMenu(self, menu):
self.menu = menu
menu.addItem(oofmenu.OOFMenuItem(
'Query',
callback=self.queryObj,
params=[
parameter.StringParameter(
'mode', tip="The type of object being queried."),
parameter.IntParameter(
'index', tip="The queried object's index.")],
help="Query the object with the given index."))
menu.addItem(oofmenu.OOFMenuItem(
"Peek",
callback=self.peekObj,
params=[
parameter.StringParameter(
'mode', tip="The type of object being queried."),
parameter.IntParameter(
'index', tip="The queried object's index.")],
help="Query the object with the given index."))
menu.addItem(oofmenu.OOFMenuItem(
'Prev',
callback=self.prevQuery,
help="Go to the previous query."))
menu.addItem(oofmenu.OOFMenuItem(
'Next',
callback=self.nextQuery,
help="Go to the next query."))
menu.addItem(oofmenu.OOFMenuItem(
'Clear',
callback=self.clear,
help='Clear the toolbox.'))
def makeMenu(self, menu):
self.menu = menu
menu.addItem(
oofmenu.OOFMenuItem(
'QueryElement',
callback=self.queryElem,
params=[
primitives.PointParameter('position', tip='Target point.')
],
help="Query the element closest to the given point.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/query_skel_elem.xml')))
menu.addItem(
oofmenu.OOFMenuItem(
'QueryElementByID',
callback=self.queryElemByID,
params=[parameter.IntParameter('index', tip="Element index.")],
help="Query the element with the given index.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/query_skel_elem_id.xml')))
menu.addItem(
oofmenu.OOFMenuItem(
'QuerySegment',
callback=self.querySgmt,
params=[
primitives.PointParameter('position', tip='Target point.')
],
help="Query the segment closest to the given point.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/query_skel_sgmt.xml')))
menu.addItem(
oofmenu.OOFMenuItem(
'QuerySegmentByID',
callback=self.querySgmtByID,
params=[parameter.IntParameter('index', tip="Segment index.")],
help="Query the segment with the given index.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/query_skel_sgmt_id.xml')))
menu.addItem(
oofmenu.OOFMenuItem(
'QueryNode',
callback=self.queryNode,
params=[
primitives.PointParameter('position', tip='Target point.')
],
help="Query the node closest to the given point.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/query_skel_node.xml')))
menu.addItem(
oofmenu.OOFMenuItem(
'QueryNodeByID',
callback=self.queryNodeByID,
params=[parameter.IntParameter(
'index',
tip="Node index.",
)],
help="Query the node with the given index.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/query_skel_node_id.xml')))
def makeMenu(self, menu):
self.menu = menu
menu.addItem(oofmenu.OOFMenuItem(
'MoveNode',
callback = self.moveNode,
params=[
parameter.IntParameter(
'node', tip='Index of the node to be moved.'),
primitives.PointParameter(
'destination', tip=parameter.emptyTipString)],
help="Move a node to another positon.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/move_node.xml')
))
menu.addItem(oofmenu.OOFMenuItem(
'SelectNode',
callback = self.selectNode,
params=[
primitives.PointParameter(
'position', tip=parameter.emptyTipString),
view.ViewParameter('view')],
help="Select a node to move.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/select_move_node.xml')
))
menu.addItem(oofmenu.OOFMenuItem(
'AllowIllegal',
callback = self.allowIllegal,
params=[parameter.BooleanParameter(
'allowed', 0, tip=parameter.emptyTipString)],
help="Are illegal elements allowed?",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/allow_illegal.xml')
))
def __init__(self,
name,
ordering,
parentClass=None,
instanceClass=WhoDoUndo,
proxyClasses=[],
secret=0):
WhoClass.__init__(self,
name,
ordering,
parentClass=parentClass,
instanceClass=instanceClass,
proxyClasses=proxyClasses,
secret=secret)
self.historysize = historysize
mainmenu.bufsizemenu.addItem(
oofmenu.OOFMenuItem(
utils.space2underscore(name),
callback=self.setUndoBufferSize,
# TODO 3.1: Disallow size=0.
params=[
parameter.IntParameter(
'size',
historysize,
tip='number of previous versions to preserve')
],
help="Set the history buffer size for %ss" % name,
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/common/menu/bufsize.xml',
lambda text, obj: text.replace('CLASS', name))))
def makeMenu(self, menu):
self.menu = menu
if config.dimension() == 2:
positionparams = [
parameter.IntParameter('x', 0, tip="The x coordinate."),
parameter.IntParameter('y', 0, tip="The y coordinate.")
]
helpstring = "Query the pixel that is closest to the given point(x,y)."
elif config.dimension() == 3:
positionparams = [
parameter.IntParameter('x', 0, tip="The x coordinate."),
parameter.IntParameter('y', 0, tip="The y coordinate."),
parameter.IntParameter('z', 0, tip="The z coordinate.")
]
helpstring = "Query the pixel that is closest to the given point(x,y,z)."
menu.addItem(
oofmenu.OOFMenuItem('Query',
callback=self.queryPixel,
params=positionparams,
help=helpstring,
discussion="""<para>
Display information about the pixel that is closest to the
given point. In GUI mode, the information appears in the
<link linkend='Section-Graphics-PixelInfo'>Pixel
Info</link> toolbox in the graphics window. This command
has no effect when the GUI is not running.
</para>"""))
menu.addItem(
oofmenu.OOFMenuItem('Clear',
callback=self.clearPixel,
params=[],
help="Reset the pixel info toolbox.",
discussion="""<para>
Clear any displayed information from previous mouse clicks.
In GUI mode, this clears the <link
linkend='Section-Graphics-PixelInfo'>Pixel Info</link>
toolbox in the graphics window. This command has no
effect if the GUI is not running.
</para>"""))
for plugin in self.plugIns:
plugin.makeMenu(menu)
self.solver_converged = False
else:
self.solver_converged = True
finally:
meshctxt.end_writing()
#################################################
registeredclass.Registration(
'Relax',
skeletonmodifier.SkeletonModifier,
Relax,
ordering=0.5,
params=[
skeletonmodifier.alphaParameter,
parameter.FloatParameter(name = 'gamma', value = 0.5,
tip='Node mobility'),
parameter.IntParameter('iterations', value = 1, tip='number of steps')
],
tip='Improve a skeleton by solving a finite element system where the properties are functions of the underlying homogeneity and shape',
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/relax.xml')
)
# Old tip for gamma:
# tip='Coefficient of mesh expansion or rate of
# expansion/contraction per inhomogeneity or per deviation from
# ideal shape. A small positive value is recommended for meshes
# where element edges want to be made coincide with pixel group
# edges.'
def select(self, skelctxt, selection):
el = skelctxt.getObject().getElement(self.element)
clist, plist = selection.trackerlist()
courier = skeletonselectioncourier.SingleObjectCourier(
skelctxt.getObject(), el, clist, plist)
self.operator.operate(selection, courier)
ElementSelectionMethodRegistration(
'Single Element',
SingleElementSelect,
ordering=0,
params=[
parameter.hidden(
parameter.IntParameter('element', tip="An element index.")),
selectionoperators.SelectionOperatorParam('operator', passive=1)
],
tip="Select an element.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/reg/single_element.xml'))
#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#
class PixelElementSelect(ElementSelectionMethod):
def __init__(self, category, operator):
self.category = category
self.operator = operator
def select(self, skelctxt, selection):
old = imageops.findLargerVals(current, old)
else:
old = current
scaled = imageops.scaleArray(old, 0.0, 1.0, self.Line_color)
bools = imageops.connect(scaled, self.Threshold, self.t, self.d,
self.n, self.B, self.trimYN)
oofimage.setFromBool(image, bools)
registeredclass.Registration(
'FullEdgeDetection',
imagemodifier.ImageModifier,
FullGaborModifier,
ordering=100,
params=[
parameter.IntParameter('a', value=3, tip="a in pixels"),
parameter.IntParameter('b', value=3, tip="b in pixels"),
parameter.IntParameter('numAngles',
value=6,
tip="number of angles to apply the filter"),
parameter.FloatParameter(
'Threshold',
value=.5,
tip="Threshold value used when thresholding image"),
parameter.IntParameter(
'Line_color',
value=2,
tip=
"Colors of the lines to detect. (2) Both white and dark lines. (1) Only white lines (0) Only black lines."
),
parameter.IntParameter('d',
parameter.FloatParameter('tolerance', 1.e-13)
],
secret=not debug.debug()))
def _checkCategoryVolumes(menuitem, skeleton, iteration):
skel = skeletoncontext.skeletonContexts[skeleton].getObject()
data = skel.checkCategoryVolumes()
catnames = ", ".join(["cat%d" % c for c in range(data.nCategories())])
caterrs = ["%7.4g" % data.catError(c) for c in range(data.nCategories())]
if iteration == 0:
reporter.data("CategoryVolume errors: overall, rms, max,", catnames)
reporter.data(
"%4d %7.4g\t%7.4g\t%7.4g\t" %
(iteration, data.avgError(), data.rmsError(), data.maxError()),
"\t".join(caterrs))
mainmenu.debugmenu.addItem(
oofmenu.OOFMenuItem(
"Check_CategoryVolumes",
callback=_checkCategoryVolumes,
ordering=101,
params=[
whoville.WhoParameter('skeleton',
skeletoncontext.skeletonContexts),
parameter.IntParameter('iteration',
tip="Prepended to output lines")
],
secret=not debug.debug()))
(grp, newness) = ms.getGroup(groupname)
grp.addPixels(pixels)
all_group_dict[grp] = 1
if newness:
new_group_list.append(grp)
finally:
mscontext.end_writing()
for g in all_group_dict.keys():
switchboard.notify("changed pixel group", g, microstructure)
for g in new_group_list:
switchboard.notify("new pixel group", g)
microstructureIO.categorymenu.addItem(
OOFMenuItem(
pixelgroup.attributeReg.name(),
callback=_readPixelGroups,
params=[
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString),
parameter.IntParameter('category', tip="Pixel category."),
parameter.ListOfStringsParameter(
'groups', tip="List of names of pixel groups.")
],
help=
"Assign pixel groups to pixel categories. Used internally in data files.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/common/menu/pgroupcategory.xml')))
# Resume a tutorial from a saved script.
def resume_tutorial(menuitem, subject, progress):
tutor = tutorial.allTutorials[subject]
mainthread.runBlock(start_class, (tutor, progress))
mainmenu.OOF.Help.Tutorials.addItem(
oofmenu.OOFMenuItem(
'Resume',
callback=resume_tutorial,
secret=1,
params=[
parameter.StringParameter('subject'),
parameter.IntParameter('progress')
],
help=
"Resume a tutorial. This command is only used when tutorials are saved."
))
def raise_tutorial(menuitem):
debug.mainthreadTest()
tutorialInProgress.raise_window()
mainmenu.OOF.Windows.addItem(
oofmenu.OOFMenuItem('Tutorial',
help="Raise the tutorial window.",
callback=raise_tutorial,
In GUI mode, when <command>AutoDismiss</command> is on, progress
bars will be removed from the <link
linkend='Section-Windows-ActivityViewer'>Activity Viewer</link>
window when the task that they're monitoring finishes. If
<command>AutoDismiss</command> is off, it's necessary to remove
progress bars explicitly with the <guibutton>Dismiss</guibutton> or
<guibutton>Dismiss All</guibutton> buttons.
</para>"""))
settingsmenu.addItem(oofmenu.OOFMenuItem(
'DelayProgressBarCreation',
callback=progressbar_delay.set_delay,
params=[
parameter.IntParameter('milliseconds', progressbar_delay.delay, tip="Delay time of the progress bar in milliseconds.")],
help='Create progress bars only for processes that take longer than a specified time.',
threadable = oofmenu.UNTHREADABLE,
discussion="""<para>
Don't create progress bars until a task has been running for the
given number of <varname>milliseconds</varname>. This has the
effect of suppressing progress bars for short-lived tasks, and not
cluttering up the screen so much.
</para>"""
))
from ooflib.engine import skeletoncontext
try:
from ooflib.SWIG.common import mpitools
except ImportError:
pass
## General definitions
_rank = mpitools.Rank()
_size = mpitools.Size()
def _parallel_init(self, skeleton, _id = None):
## here, skeleton is the name of the skeleton
if _rank == 0:
id = parallel_object_manager.parallelObjectManager.add(self)
deputymenu.Create(skeleton = skeleton, id = id) ## back-end call
else:
parallel_object_manager.parallelObjectManager.add(self, _id)
deputymenu = parallelmainmenu.ipcmenu.addItem(oofmenu.OOFMenuItem('Deputy', secret=1, no_log=1))
def _create_deputy(menuitem, skeleton, id):
## skeleton skeleton is the full name of the skeleton
global _rank
if _rank != 0:
skel = skeletoncontext.skeletonContexts[skeleton].getObject()
deputy = skel.deputyCopy() ## creates back-end deputy with the correct id
parallel_object_manager.parallelObjectManager.add(deputy, id)
deputymenu.addItem(oofmenu.OOFMenuItem('Create', callback = _create_deputy, secret=1, no_log=1, threadable = oofmenu.PARALLEL_UNTHREADABLE, params=[parameter.StringParameter('skeleton'), parameter.IntParameter('id')] ))
# available when the pixel attributes are written.
writeMaterials(dfile,
ooflib.SWIG.engine.material.getMaterials(microstructure))
ooflib.SWIG.engine.material.MaterialAttributeRegistrationPtr.writeGlobalData = \
_writeGlobalData
microstructureIO.categorymenu.addItem(
OOFMenuItem(
ooflib.SWIG.engine.material.attributeReg.name(),
callback=_readMSMaterial,
params=[
whoville.WhoParameter("microstructure",
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString),
parameter.IntParameter('category', tip="Category of pixels."),
parameter.StringParameter('material', tip="Name of the Material.")
],
help=
"Assign a Material to a pixel category. Used internally in data files.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/materialcategory.xml')))
###############################
# Read and write a Material and its Properties in a data file.
def writeMaterials(dfile, materials, excludeProps={}):
# Make sure to save each property only once, even if it's in more
# than one Material. Properties in excludeProps have already been
defaultSkelBdyGlyphSize = 10
skelbdyparams.append(
parameter.IntRangeParameter('glyphsize', (0, 20),
defaultSkelBdyGlyphSize,
tip="Arrow size for edge boundaries."))
elif config.dimension() == 3:
defaultSkelBdyGlyphSize = automatic.automatic
defaultSkelBdyGlyphResolution = 20
skelbdyparams.extend(
[parameter.AutoNumericParameter(
'glyphsize',
defaultSkelBdyGlyphSize,
tip="Size of boundary markers."),
parameter.IntParameter(
'resolution',
defaultSkelBdyGlyphResolution,
tip='Number of polygons to use to draw markers.')]
)
def _setSkelBdyParams(menuitem, color, linewidth, glyphsize, resolution):
global defaultSkelBdyColor
global defaultSkelBdyLineWidth
global defaultSkelBdyGlyphSize
global defaultSkelBdyGlyphResolution
defaultSkelBdyColor = color
defaultSkelBdyLineWidth = linewidth
defaultSkelBdyGlyphSize = glyphsize
defaultSkelBdyGlyphResolution = resolution
mainmenu.gfxdefaultsmenu.Skeletons.addItem(oofmenu.OOFMenuItem(
## OOF.Windows.Parallel Menu
menusystem = mainmenu.OOF.Windows.addItem(
oofmenu.OOFMenuItem('Parallel', secret=0, no_log=0))
## OOF.LoadData.IPC Menu
ipcmenu = mainmenu.OOF.LoadData.addItem(
oofmenu.OOFMenuItem('IPC', secret=1, no_log=1))
## Add the MenuKey and ObjKey menus to keep the parser happy
ipcmenu.addItem(
oofmenu.OOFMenuItem('MenuKey',
callback=binarydata.menuKeyCB,
secret=1,
params=[
parameter.StringParameter('path'),
parameter.IntParameter('key')
]))
ipcmenu.addItem(
oofmenu.OOFMenuItem('ObjKey',
callback=binarydata.objectKeyCB,
secret=1,
params=[
parameter.StringParameter('obj'),
parameter.IntParameter('key')
]))
## OOF.LoadData.IPC.Quit
## Quit should never ever be run on a separate thread.
def _quit(menuitem):
global _rank
skelmenu.addItem(
OOFMenuItem(
'PointBoundary',
callback=_loadPointBoundary,
params=[
whoville.WhoParameter('skeleton',
skeletoncontext.skeletonContexts,
tip=parameter.emptyTipString),
parameter.StringParameter('name', tip="Name of Point Boundary."),
parameter.ListOfIntsParameter('nodes',
tip="List of node indices."),
# TODO 3.1: Use BoolParameter. Will have to change test reference files.
parameter.IntParameter(
'exterior',
0,
tip="1 (true) for an exterior boundary and 0 (false) otherwise."
)
],
help="Load Point Boundary. Used internally in data files.",
discussion=
"<para>Load a <link linkend='Section-Concepts-Skeleton-Boundary-Point'><classname>PointBoundary</classname></link> from a Skeleton data file.</para>"
))
###
def _loadEdgeBoundary(menuitem, skeleton, name, edges, exterior):
# "edges" is a list of pairs of integer indices into skeleton.nodes
skelcontext = skeletoncontext.skeletonContexts[skeleton]
skeleton = skelcontext.getObject()
cmdformat = ">i"
cmdsize = struct.calcsize(cmdformat)
###########################
def menuKeyCB(menuitem, path, key):
menuitem.parser.mode.defineMenuKey(path, key)
OOF.LoadData.addItem(
oofmenu.OOFMenuItem('MenuKey',
callback=menuKeyCB,
params=[
parameter.StringParameter('path'),
parameter.IntParameter('key')
]))
def objectKeyCB(menuitem, obj, key):
menuitem.parser.mode.defineObjKey(utils.OOFeval_r(obj), key)
OOF.LoadData.addItem(
oofmenu.OOFMenuItem('ObjKey',
callback=objectKeyCB,
params=[
parameter.StringParameter('obj'),
parameter.IntParameter('key')
]))
id = parallel_object_manager.parallelObjectManager.add(self)
deputymenu.Create(skeleton=skeleton, id=id) ## back-end call
else:
parallel_object_manager.parallelObjectManager.add(self, _id)
deputymenu = parallelmainmenu.ipcmenu.addItem(
oofmenu.OOFMenuItem('Deputy', secret=1, no_log=1))
def _create_deputy(menuitem, skeleton, id):
## skeleton skeleton is the full name of the skeleton
global _rank
if _rank != 0:
skel = skeletoncontext.skeletonContexts[skeleton].getObject()
deputy = skel.deputyCopy(
) ## creates back-end deputy with the correct id
parallel_object_manager.parallelObjectManager.add(deputy, id)
deputymenu.addItem(
oofmenu.OOFMenuItem('Create',
callback=_create_deputy,
secret=1,
no_log=1,
threadable=oofmenu.PARALLEL_UNTHREADABLE,
params=[
parameter.StringParameter('skeleton'),
parameter.IntParameter('id')
]))
commands into your &oof2rc; file
to set defaults for every &oof2; session.
</para>"""))
import random
from ooflib.SWIG.common import crandom
def _randomseed(menuitem, seed):
random.seed(seed)
crandom.rndmseed(seed)
settingsmenu.addItem(oofmenu.OOFMenuItem(
'Random_Seed',
callback=_randomseed,
params=[parameter.IntParameter('seed', 17)]
))
##################################
## Subwindows menu.
_windowmenu = OOFMenuItem(
'Windows',
help="Menus for opening and raising windows.")
OOF.addItem(_windowmenu)
def dummy(menuitem): pass # Dummy callback, so trivial menu items get logged.
# Add an entry for the main window, which, when clicked, raises it.
dy = 0
for j in range(self.y_points):
for i in range(self.x_points):
pt = primitives.Point(bxmin + i * dx, bymin + j * dy)
if domain.contains(pt):
self.sample_list.append(PointSample(pt))
return 1
DirectSampleSetRegistration(
"Grid Points",
GridSampleSet,
20,
params=[
parameter.IntParameter(
'x_points',
10,
tip="Total number of points horizontally in the grid."),
parameter.IntParameter(
'y_points',
10,
tip="Total number of points vertically in the grid.")
],
sample_type=GRID,
tip='Evaluate data on a rectangular grid of points.',
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/reg/gridsampleset.xml'))
#=-=#=-=#=-=#=-=#=-=#=-=#=-=#=-=#=-=#=-=#=-=#=-=#=-=#
# Grid of given delta-x, delta-y.
def __init__(self, radius):
self.radius = radius
def __call__(self, image):
image.medianFilter(self.radius)
if config.dimension() == 2:
filterparam = [
parameter.FloatParameter('radius', 1.0, tip="Radius of the filter.")
]
elif config.dimension() == 3:
filterparam = [
parameter.IntParameter(
'radius',
1,
tip="Radius of the filter in voxels."
" The kernel is a cube with 2*r+1 voxels on a side.")
]
registeredclass.Registration(
'MedianFilter',
ImageModifier,
MedianFilterImage,
ordering=2.06,
params=filterparam,
tip=
"Reduce noice by replacing each pixel color with its median over a local region.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/image/reg/median.xml'))
help="Create a new layer set.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/common/menu/newlayerset.xml')))
def loadLayerCB(menuitem, window, layer_number):
openLayerEditor()
layerEditor.loadLayerCB(window, layer_number)
layermenu.addItem(
OOFMenuItem('Edit',
callback=loadLayerCB,
params=[
parameter.StringParameter('window', tip="Which window."),
parameter.IntParameter('layer_number', tip="Layer number.")
],
help="Edit the layer.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/common/menu/editlayerset.xml')))
def displayedObjectCB(menuitem, category, object):
openLayerEditor()
layerEditor.displayedObjectCB(category, object)
layermenu.addItem(
OOFMenuItem('DisplayedObject',
callback=displayedObjectCB,
params=[
def makeMenu(self, menu):
self.menu = menu
dollymenu = menu.addItem(oofmenu.OOFMenuItem("Dolly", cli_only=1))
dollymenu.addItem(
oofmenu.OOFMenuItem(
"In",
callback=self.dollyIn,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("factor")]))
dollymenu.addItem(
oofmenu.OOFMenuItem(
"Out",
callback=self.dollyOut,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("factor")]))
dollymenu.addItem(
oofmenu.OOFMenuItem("Fill",
threadable=oofmenu.UNTHREADABLE,
callback=self.dollyFill))
trackmenu = menu.addItem(oofmenu.OOFMenuItem("Track", cli_only=1))
trackmenu.addItem(
oofmenu.OOFMenuItem(
"Horizontal",
callback=self.trackHoriz,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("distance")]))
trackmenu.addItem(
oofmenu.OOFMenuItem(
"Vertical",
callback=self.trackVert,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("distance")]))
trackmenu.addItem(
oofmenu.OOFMenuItem("Recenter",
callback=self.recenter,
threadable=oofmenu.UNTHREADABLE))
rotatemenu = menu.addItem(oofmenu.OOFMenuItem("Rotate",
cli_only=1))
rotatemenu.addItem(
oofmenu.OOFMenuItem("Roll",
callback=self.roll,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("angle")
]))
rotatemenu.addItem(
oofmenu.OOFMenuItem("Azimuth",
callback=self.azimuth,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("angle")
]))
rotatemenu.addItem(
oofmenu.OOFMenuItem("Elevation",
callback=self.elevation,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("angle")
]))
rotatemenu.addItem(
oofmenu.OOFMenuItem("Yaw",
callback=self.yaw,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("angle")
]))
rotatemenu.addItem(
oofmenu.OOFMenuItem("Pitch",
callback=self.pitch,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("angle")
]))
zoommenu = menu.addItem(oofmenu.OOFMenuItem("Zoom", cli_only=1))
zoommenu.addItem(
oofmenu.OOFMenuItem(
"In",
callback=self.zoomIn,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("factor")]))
zoommenu.addItem(
oofmenu.OOFMenuItem(
"Out",
callback=self.zoomOut,
threadable=oofmenu.UNTHREADABLE,
params=[parameter.FloatParameter("factor")]))
zoommenu.addItem(
oofmenu.OOFMenuItem("Fill",
threadable=oofmenu.UNTHREADABLE,
callback=self.zoomFill))
clipmenu = menu.addItem(oofmenu.OOFMenuItem("Clip", cli_only=1))
clipmenu.addItem(
oofmenu.OOFMenuItem(
"New",
callback=self.newClipCB,
params=[
parameter.ConvertibleRegisteredParameter(
"normal", direction.Direction,
direction.DirectionX()),
parameter.FloatParameter("offset", 0.0)
]))
clipmenu.addItem(
oofmenu.OOFMenuItem(
"Edit",
callback=self.editClipCB,
params=[
parameter.IntParameter("plane"),
parameter.ConvertibleRegisteredParameter(
"normal", direction.Direction),
parameter.FloatParameter("offset")
]))
clipmenu.addItem(
oofmenu.OOFMenuItem("Delete",
callback=self.delClipCB,
params=[parameter.IntParameter("plane")]))
clipmenu.addItem(
oofmenu.OOFMenuItem("Enable",
callback=self.clipEnableCB,
params=[parameter.IntParameter("plane")]))
clipmenu.addItem(
oofmenu.OOFMenuItem("Disable",
callback=self.clipDisableCB,
params=[parameter.IntParameter("plane")]))
clipmenu.addItem(
oofmenu.OOFMenuItem("Flip",
callback=self.clipFlipCB,
params=[parameter.IntParameter("plane")]))
clipmenu.addItem(
oofmenu.OOFMenuItem("Unflip",
callback=self.clipUnflipCB,
params=[parameter.IntParameter("plane")]))
clipmenu.addItem(
oofmenu.OOFMenuItem("InvertOn", callback=self.clipInvertOnCB))
clipmenu.addItem(
oofmenu.OOFMenuItem("InvertOff",
callback=self.clipInvertOffCB))
clipmenu.addItem(
oofmenu.OOFMenuItem("SuppressOn",
callback=self.clipSuppressOnCB))
clipmenu.addItem(
oofmenu.OOFMenuItem("SuppressOff",
callback=self.clipSuppressOffCB))
clipmenu.addItem(
oofmenu.OOFMenuItem("Select",
callback=self.clipSelectCB,
params=[parameter.IntParameter("plane")]))
clipmenu.addItem(
oofmenu.OOFMenuItem("Unselect", callback=self.clipUnselectCB))
menu.addItem(
oofmenu.OOFMenuItem("Restore_View",
callback=self.restoreView,
params=[view.ViewParameter("view")]))
menu.addItem(
oofmenu.OOFMenuItem("Restore_Named_View",
callback=self._restoreNamedView,
params=[ViewNameParameter("view")]))
menu.addItem(
oofmenu.OOFMenuItem("Save_View",
callback=self.saveView,
params=[parameter.StringParameter("name")
]))
menu.addItem(
oofmenu.OOFMenuItem(
"Delete_View",
callback=self.deleteView,
params=[
ViewNameParameter(
"view", tip="The name of the View to delete.")
]))
# Shared parameters for the nontrivial solvers.
nonlin_params = [
parameter.FloatParameter(
'relative_tolerance',
1.e-8,
tip="Relative tolerance for convergence to a nonlinear solution."),
parameter.FloatParameter(
'absolute_tolerance',
1.e-13,
tip="Absolute tolerance for convergence to a nonlinear solution."),
parameter.IntParameter(
'maximum_iterations',
200,
tip=
"Maximum number of iterations for convergence to a nonlinear solution."
)
]
#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#
class Newton(nonlinearsolvercore.Newton, NonlinearSolver):
def __init__(self, *args, **kwargs):
nonlinearsolvercore.Newton.__init__(self, *args, **kwargs)
def solve(self, *args, **kwargs):
niters, residual = nonlinearsolvercore.Newton.solve(
self, *args, **kwargs)
self.subproblem.solverStats.nonlinearSolution(niters, residual)
class MedianFilterImage(ImageModifier):
def __init__(self, radius):
self.radius = radius
def __call__(self, image):
image.medianFilter(self.radius)
if config.dimension() == 2:
filterparam = [
parameter.FloatParameter('radius', 1.0, tip="Radius of the filter.")
]
elif config.dimension() == 3:
filterparam = [
parameter.IntParameter('radius', 1, tip="Radius of the filter.")
]
registeredclass.Registration(
'MedianFilter',
ImageModifier,
MedianFilterImage,
ordering=2.06,
params=filterparam,
tip=
"Reduce noice by replacing each pixel color with its median over a local region.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/image/reg/median.xml'))
class NegateImage(ImageModifier):
def __call__(self, image):
oofmenu.OOFMenuItem(
'Skeleton_Selection',
help=
"Set the size of history buffers for Skeleton selection operations",
ordering=1))
_stacksize = 50
def _allBufSizesCB(menuitem, size):
_stacksize = size
for mode in SkeletonSelectionMode.modes:
mode.setUndoBufferSize(menuitem, size)
_stacksize_params = [
parameter.IntParameter('size',
_stacksize,
tip='number of previous selections to retain')
]
_all_stacksize_menuitem = bufsizmenu.addItem(
oofmenu.OOFMenuItem(
'All',
callback=_allBufSizesCB,
ordering=-1,
params=_stacksize_params,
help="Set the history buffer size for all Skeleton selections",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/skelbufsizes.xml')))
"CG",
MatrixMethod,
ConjugateGradient,
ordering=1,
symmetricOnly=True,
params=[
parameter.RegisteredParameter(
"preconditioner",
preconditioner.PreconditionerPtr,
tip="Black magic for making the matrix more easily solvable."),
parameter.FloatParameter(
"tolerance",
1.e-13,
tip="Largest acceptable relative error in the matrix solution."),
parameter.IntParameter("max_iterations",
1000,
tip="Maximum number of iterations to perform.")
],
tip="Conjugate Gradient method for iteratively solving symmetric matrices.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/cg.xml'))
def check_symmetry(menuitem, state):
global _check_symmetry
_check_symmetry = state
mainmenu.debugmenu.addItem(
oofmenu.CheckOOFMenuItem(
'Check_CG_symmetry',
debug.debug(),
oofmenu.OOFMenuItem(
'New_Parallel',
callback=newMicrostructure_Parallel,
secret=1,
no_log=1,
threadable=oofmenu.PARALLEL_THREADABLE,
params=[
parameter.StringParameter('name'),
parameter.FloatParameter('width',
1.,
tip='Width in physical units.'),
parameter.FloatParameter('height',
1.,
tip='Height in physical units.'),
parameter.IntParameter('width_in_pixels',
10,
tip='Width in pixels.'),
parameter.IntParameter('height_in_pixels',
10,
tip='Height in pixels.')
]))
### OOF.LoadData.IPC.Microstructure.Initialize
### Transfers the microstructure to the back-end
##def _parallel_init_mic(menuitem, microstructure, pixelsize, physicalsize):
## debug.fmsg()
## # microstructure is the name of the microstructure
## global _rank
## import ooflib.common.microstructure
## # front-end work
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)
new_aa.rename(name)
ms_obj.namedActiveAreas.append(new_aa)
