def __call__(self,x): lowdx = int(math.floor(x*float(self.listlen-1))) if lowdx<=0: return color.RGBColor(self.redlist[0], self.greenlist[0], self.bluelist[0]) if lowdx>=(self.listlen-1): return color.RGBColor(self.redlist[-1], self.greenlist[-1], self.bluelist[-1]) frac = x*self.listlen-lowdx rl = self.redlist[lowdx] rh = self.redlist[lowdx+1] gl = self.greenlist[lowdx] gh = self.greenlist[lowdx+1] bl = self.bluelist[lowdx] bh = self.bluelist[lowdx+1] return color.RGBColor(rl+frac*(rh-rl), gl+frac*(gh-gl), bl+frac*(bh-bl))
def AutoGroup(self): from ooflib.common import color def colordiff(c1,c2): return (c1.red-c2.red)**2 + \ (c1.green-c2.green)**2 + \ (c1.blue-c2.blue)**2 # Dictionary of nearest pure colors and sizes of the # corresponding groups, which will not have exactly this # color, but will be closer to it than to any other color (in # colordiff measure). expected_sizes = {color.magenta : 2404, color.RGBColor(1.0,1.0,1.0) : 4781, color.RGBColor(0.0,0.0,0.0) : 2585, color.blue : 2947, color.green : 4795, color.cyan : 1001, color.yellow : 3617, color.red : 370 } OOF.Image.AutoGroup(image="small.ppm:small.ppm") ms = microstructure.getMicrostructure("small.ppm") groups = ms.groupNames() self.assertEqual(len(groups), 8) for name in groups: # rgb = eval(name) rgb = color.rgb_from_hex(name) key = None diff = None for c in expected_sizes.keys(): cdiff = colordiff(rgb,c) if (diff is None) or (cdiff < diff): key = c diff = cdiff self.assertEqual(len(ms.findGroup(name)), expected_sizes[key])
def Rich_MS_Copy(self): from ooflib.common import color OOF.Image.AutoGroup(image="small.ppm:small.ppm") OOF.Graphics_1.Toolbox.Pixel_Select.Circle( source="small.ppm:small.ppm", points=[Point(66.0, 55.0), Point(87.6, 41.8)], shift=0, ctrl=0) OOF.Microstructure.Copy(microstructure="small.ppm", name="copy") # Essentially a re-run of the autogroup test. def colordiff(c1, c2): return (c1.red-c2.red)**2 + \ (c1.green-c2.green)**2 + \ (c1.blue-c2.blue)**2 # Dictionary of nearest pure colors and sizes of the # corresponding groups, which will not have exactly this # color, but will be closer to it than to any other color (in # colordiff measure). expected_sizes = { color.magenta: 2404, color.RGBColor(1.0, 1.0, 1.0): 4781, color.RGBColor(0.0, 0.0, 0.0): 2585, color.blue: 2947, color.green: 4795, color.cyan: 1001, color.yellow: 3617, color.red: 370 } ms = microstructure.getMicrostructure("copy") groups = ms.groupNames() self.assertEqual(len(groups), 8) for name in groups: # rgb = eval(name) rgb = color.rgb_from_hex(name) key = None diff = None for c in expected_sizes.keys(): cdiff = colordiff(rgb, c) if (diff is None) or (cdiff < diff): key = c diff = cdiff self.assertEqual(len(ms.findGroup(name)), expected_sizes[key]) ps = pixelselection.pixelselectionWhoClass["copy"] # Selection should *not* be copied. self.assertEqual(ps.getObject().len(), 0) OOF.Microstructure.Delete(microstructure="copy")
def AutoGroup(self): from ooflib.common import color def colordiff(c1, c2): return (c1.red-c2.red)**2 + \ (c1.green-c2.green)**2 + \ (c1.blue-c2.blue)**2 # Dictionary of nearest pure colors and sizes of the # corresponding groups, which will not have exactly this # color, but will be closer to it than to any other color (in # colordiff measure). expected_sizes = { color.RGBColor(1.0, 1.0, 1.0): 2385, color.blue: 1205, color.green: 1020, color.yellow: 2313, color.red: 1077 } OOF.Image.AutoGroup(image="slice*.tif:slice*.tif") ms = microstructure.getMicrostructure("slice*.tif") groups = ms.groupNames() self.assertEqual(len(groups), 5) for name in groups: rgb = eval(name) key = None diff = None for c in expected_sizes.keys(): cdiff = colordiff(rgb, c) if (diff is None) or (cdiff < diff): key = c diff = cdiff self.assertEqual(len(ms.findGroup(name)), expected_sizes[key])
def Load(self): OOF.Microstructure.New(name="load_test", width=100, height=100, depth=100, width_in_pixels=100, height_in_pixels=100, depth_in_pixels=100) OOF.File.Load.Image(filenames=ThreeDImageDirectory( directory=reference_file("ms_data", "jpeg"), sort=NumericalOrder()), microstructure="load_test", height=automatic, width=automatic, depth=automatic) ms = getMicrostructure("load_test") ms_images = ms.imageNames() self.assertEqual(len(ms_images), 1) self.assert_("jpeg" in ms_images) # Check a few pixel values im = imagecontext.imageContexts['load_test:jpeg'].getObject() self.assertEqual( im[primitives.iPoint(0, 0, 0)], color.RGBColor(0.054901960784313725, 0.996078431372549, 0.9921568627450981)) self.assertNotEqual(im[primitives.iPoint(0, 0, 0)], color.RGBColor(0.054901960, 0.0, 0.99215686)) # This voxel is selected in Direct_Pixel_Selection.Color in # pixel_test.py on Mac but not Linux. Apparently Mac and # Linux use different jpeg libraries which decompress images # differently. WTF? ## TODO: Check that problem is avoided if vtk on Mac is ## compiled with USE_SYSTEM_JPEG=OFF self.assertEqual( im[primitives.iPoint(16, 9, 99)], # Linux value color.RGBColor(0.3058823529411765, 0.9921568627450981, 0.7215686274509804) # Mac value # color.RGBColor( # 0.2901960784313726, # 1.0, # 0.7372549019607844) )
def Rich_Load(self): OOF.File.Load.Data(filename=reference_file("ms_data", "rich_ms")) ms = microstructure.getMicrostructure("rich") group = ms.findGroup("test") self.assertEqual(len(group), 2000) colorgroups = ms.groupNames() colorgroups.remove("test") from ooflib.common import color def colordiff(c1, c2): return (c1.red-c2.red)**2 + \ (c1.green-c2.green)**2 + \ (c1.blue-c2.blue)**2 # This is a reprise of the AutoGroup test in pixel_test. expected_sizes = { color.magenta: 2404, color.RGBColor(1.0, 1.0, 1.0): 4781, color.RGBColor(0.0, 0.0, 0.0): 2585, color.blue: 2947, color.green: 4795, color.cyan: 1001, color.yellow: 3617, color.red: 370 } for name in colorgroups: rgb = color.rgb_from_hex(name) key = None diff = None for c in expected_sizes.keys(): cdiff = colordiff(rgb, c) if (diff is None) or (cdiff < diff): key = c diff = cdiff self.assertEqual(len(ms.findGroup(name)), expected_sizes[key]) # Find the "act1" stored active area, and check the size. act1 = ms.getNamedActiveArea("act1") self.assertEqual(len(act1.activearea.members()), 19872)
def __getitem__(self, idx): ## num_components = self.image.GetNumberOfScalarComponents() ## if num_components == 1: ## return color.Gray(self.image.GetScalarComponentAsFloat(idx[0],idx[1],idx[2],0)/255) ## elif num_components == 3 or num_components == 4: # Don't return the alpha channel since we just use it for # manipulating the visualization of materials, selected # regions, active areas, etc. return color.RGBColor( self.image.GetScalarComponentAsFloat(idx[0],idx[1],idx[2],0)/255, self.image.GetScalarComponentAsFloat(idx[0],idx[1],idx[2],1)/255, self.image.GetScalarComponentAsFloat(idx[0],idx[1],idx[2],2)/255)
self.size = size display.DisplayMethod.__init__(self) def draw(self, gfxwindow, device): skel = self.who().resolve(gfxwindow) device.set_lineColor(self.color) device.set_lineWidth(self.size) for node in skel.pinnednodes.retrieve(): device.draw_dot(node.position()) def getTimeStamp(self, gfxwindow): return max(self.timestamp, self.who().resolve(gfxwindow).pinnednodes.timestamp) defaultPinNodeColor = color.RGBColor(0.93, 0.93, 0.0) defaultPinNodeSize = 2 def _setPinNodeParams(menuitem, color, size): global defaultPinNodeColor global defaultPinNodeSize defaultPinNodeColor = color defaultPinNodeSize = size pinnodeparams = [ color.ColorParameter('color', defaultPinNodeColor, tip="Color for the pinned nodes."), parameter.IntRangeParameter('size', (0, 10),
if obj is not None: return self.getObject().getBounds() ################## pixelselectionWhoClass = whoville.WhoDoUndoClass( 'Pixel Selection', instanceClass=PixelSelectionContext, ordering=999, secret=0, proxyClasses=['<top microstructure>']) ################### defaultPixelSelectionColor = color.RGBColor(1.0, 0.22, 0.09) 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),
if toolbox.querier and toolbox.peeker: return max(self.timestamp, gfxwindow.displayTimeChanged, toolbox.querier.getTimeStamp(), toolbox.peeker.getTimeStamp()) elif toolbox.querier and not toolbox.peeker: return max(self.timestamp, gfxwindow.displayTimeChanged, toolbox.querier.getTimeStamp()) else: return self.timestamp # This object should be created via the registration, and not # directly via the initializer, because the registration creation # method gives it a timestamp. defaultQueryColor = color.RGBColor(0.0, 0.5, 1.0) defaultPeekColor = color.RGBColor(1.0, 0.5, 0.5) defaultNodeSize = 3 defaultElementWidth = 2 if config.dimension() == 2: widthRange = (0, 10) # In vtk, line widths of 0 cause errors elif config.dimension() == 3: widthRange = (1, 10) def _setMeshInfoParams(menuitem, query_color, peek_color, node_size, element_width): global defaultQueryColor global defaultPeekColor global defaultNodeSize
ms.drawVoxelSetBoundary(self.canvaslayer, self.category) def whoChanged(self): return True # call setParams if debug.debug: registeredclass.Registration( "VoxelSetBdy", display.DisplayMethod, VoxelSetBdyDisplay, ordering=1000, layerordering=display.Linear, params=[ parameter.IntParameter("category", 0), color.ColorParameter('color', color.RGBColor(0, 0.7, 0.3)), parameter.IntRangeParameter('line_width', (1, 10), 4) ], whoclasses=('Microstructure', ), tip="Display boundary loops of voxel categories") # class Normal(enum.EnumClass("Positive", "Negative", "Any")): # pass # class Direction(enum.EnumClass("X", "Y", "Z", "All")): # pass # dirDict = {Direction("X") : 0, # Direction("Y") : 1, # Direction("Z") : 2, # Direction("All") : -1}
else: sublayer.clear() def meshDataChangedCB(self, meshctxt): if meshctxt is self.who().resolve(self.gfxwindow): self.queryCB() toolbox = self.gfxwindow.getToolboxByName("Mesh_Info") for mode in toolbox.allPeekModes(): self.peekCB(mode) # This object should be created via the registration, and not # directly via the initializer, because the registration creation # method gives it a timestamp. defaultQueryColor = color.RGBColor(0.0, 0.4, 0.85) defaultPeekColor = color.RGBColor(0.9, 0.5, 0.5) if config.dimension() == 2: widthRange = (0, 10) defaultNodeSize = 3 defaultLineWidth = 2 elif config.dimension() == 3: widthRange = (1, 20) # In vtk, line widths of 0 cause errors defaultNodeSize = 10 defaultLineWidth = 4 def _setMeshInfoParams(menuitem, query_color, peek_color, node_size, line_width): global defaultQueryColor global defaultPeekColor
display.DisplayMethod.__init__(self) def draw(self, gfxwindow, device): toolbox = gfxwindow.getToolboxByName("Move_Nodes") node = toolbox.selectednode.node() if node and toolbox.selectednode.visible: device.set_lineColor(self.color) device.set_lineWidth(self.size) device.draw_dot(node.position()) def getTimeStamp(self, gfxwindow): toolbox = gfxwindow.getToolboxByName("Move_Nodes") return max(self.timestamp, toolbox.selectednode.getTimeStamp()) defaultMoveNodeColor = color.RGBColor(1.0, 0.5, 0.5) defaultMoveNodeSize = 3 def _setDefaultMoveNodeParams(menuitem, color, size): global defaultMoveNodeSize global defaultMoveNodeColor defaultMoveNodeColor = color defaultMoveNodeSize = size movenodeparams = [ color.ColorParameter('color', defaultMoveNodeColor, tip="Color for the to-be-moved node."), parameter.IntRangeParameter('size', (0, 10),
def __call__(self, x): if x < 0.33: return color.RGBColor(x/0.33, 0, 0) if x < 0.67: return color.RGBColor(1, (x-0.33)/0.34, 0) return color.RGBColor(1, 1, (x-0.67)/0.33)
def __call__(self,x): return color.RGBColor(1.0, 0.86667*math.sqrt(x), 0.0)
## LOCK in display.py cskeletonselectable.rebuildLayerCells( skelctxt.getObject(), self.canvaslayer, selection.currentSelectionTracker()) def destroy(self, destroy_canvaslayer): map(switchboard.removeCallback, self.tbcallbacks) display.DisplayMethod.destroy(self, destroy_canvaslayer) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# # The default opacity for selected elements is 1.0, because if it's # less than that they (sometimes) don't show up when superimposed on # an opaque image. defaultSelectedElementColor = color.RGBColor(0.88, 0.14, 0.07) defaultSelectedElementOpacity = 0.7 class SkeletonElementSelectionDisplay(SkeletonSelectionDisplay): def __init__(self, color, opacity): self.color = color self.opacity = opacity SkeletonSelectionDisplay.__init__( self, skeletonselmodebase.getMode("Element")) def newLayer(self): self.setupSignals() return canvaslayers.SimpleFilledCellLayer(self.gfxwindow.oofcanvas, "SkeletonSelectedElement")
gridPoints = skel.getObject().getPoints() grid = vtk.vtkUnstructuredGrid() grid.Allocate(numsegs, numsegs) grid.SetPoints(gridPoints) for s in skel.segmentselection.retrieve(): line = s.getVtkLine() grid.InsertNextCell(line.GetCellType(), line.GetPointIds()) device.draw_unstructuredgrid(grid) def getTimeStamp(self, gfxwindow): return max(self.timestamp, self.who().resolve(gfxwindow).segmentselection.timestamp) defaultSegSelColor = color.RGBColor(0.13, 0.93, 0.25) defaultSegSelWidth = 2 def _setSegSelParams(menuitme, color, line_width): global defaultSegSelColor global defaultSegSelWidth defaultSegSelColor = color defaultSegSelWidth = line_width segselparams = [ color.ColorParameter('color', defaultSegSelColor, tip="Color for the selected segments."), parameter.IntRangeParameter('line_width', (0, 10),
def drawNode(self, device, node, which="query"): device.set_lineColor(self.colors[which]) device.set_lineWidth(self.node_size) device.draw_dot(node.position()) def getTimeStamp(self, gfxwindow): toolbox = gfxwindow.getToolboxByName("Skeleton_Info") return max(self.timestamp, toolbox.timestamp) # This object should be created via the registration, and not # directly via the initializer, because the registration creation # method gives it a timestamp. defaultSkelInfoQueryColor = color.RGBColor(0.0, 0.5, 1.0) defaultSkelInfoPeekColor = color.RGBColor(1.0, 0.5, 0.5) defaultSkelInfoNodeSize = 3 defaultSkelInfoElemWidth = 3 defaultSkelInfoSgmtWidth = 3 if config.dimension() == 2: widthRange = (0, 10) # In vtk, line widths of 0 cause errors elif config.dimension() == 3: widthRange = (1, 10) def _setSkelInfoParams(menuitem, query_color, peek_color, node_size, element_width, segment_width): global defaultSkelInfoQueryColor global defaultSkelInfoPeekColor
retr = skel.nodeselection.retrieve().copy() size = len(retr) for node in retr: device.draw_dot(node.position()) ## for n in range(size): ## debug.fmsg("during drawing dot") ## device.draw_dot(retr[n].position()) ## debug.fmsg("::after drawing dot") def getTimeStamp(self, gfxwindow): return max(self.timestamp, self.who().resolve(gfxwindow).nodeselection.timestamp) defaultNodeSelColor = color.RGBColor(0.07, 0.09, 0.96) defaultNodeSelSize = 2 def _setNodeSelParams(menuitem, color, size): global defaultNodeSelColor global defaultNodeSelSize defaultNodeSelColor = color defaultNodeSelSize = size nodeselparams = [ color.ColorParameter('color', defaultNodeSelColor, tip="Color for the selected nodes."), parameter.IntRangeParameter('size', (0, 10),
e.getPointIds()) device.draw_filled_unstructuredgrid(grid) finally: skel.elementselection.end_reading() def getTimeStamp(self, gfxwindow): return max(self.timestamp, self.who().resolve(gfxwindow).elementselection.timestamp) # This object should be created via the registration, and not # directly via the initializer, because the registration creation # method gives it a timestamp. defaultSelectedElementColor = color.RGBColor(0.88, 0.14, 0.07) 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),
display.DisplayMethod, InterfaceElementDisplay, ordering=10, layerordering=display.SemiLinear, params=meshdispparams + [ meshparameters.MeshEdgeBdyParameterExtra( 'boundary', placeholder.every.IDstring, tip='Only display edges on this boundary or interface.'), materialparameter.InterfaceAnyMaterialParameter( 'material', materialparameter.InterfaceAnyMaterialParameter.extranames[0], tip="Only display edges with this material assigned to them."), ## TODO: Add settable defaults color.ColorParameter('color', color.RGBColor(0.5, 0.3, 0.5), tip=parameter.emptyTipString), IntRangeParameter( 'width', widthRange, defaultMeshWidth + 2, tip="Line width.") ], whoclasses=('Mesh', ), tip="Highlight the edgements (1-D elements) on the Mesh.") ###################### class MaterialDisplay: def draw(self, gfxwindow, device): device.comment("Material Color") if config.dimension() == 2: themesh = self.who().resolve(gfxwindow)
self.updatePinned(skelctxt) else: self.canvaslayer.clear() return True def updatePinned(self, skelctxt): cskeletonselectable.rebuildLayerCells( skelctxt.getObject(), self.canvaslayer, skelctxt.pinnednodes.currentSelectionTracker()) def setParams(self): self.canvaslayer.set_color(self.color) self.canvaslayer.set_pointSize(self.size) defaultPinNodeColor = color.RGBColor(1., 0.65, 0.0) defaultPinNodeSize = 7 def _setPinNodeParams(menuitem, color, size): global defaultPinNodeColor global defaultPinNodeSize defaultPinNodeColor = color defaultPinNodeSize = size pinnodeparams = [ color.ColorParameter('color', defaultPinNodeColor, tip="Color for the pinned nodes."), parameter.IntRangeParameter('size', (0, 10),