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)