def propagateDirty(self, slot, subindex, roi): key = roi.toSlice() if slot == self.Input: key = key[:-1] + (slice(0,1,None),) self.outputs["Output"].setDirty(key) else: self.Output.setDirty(slice(None))
def propagateDirty(self, dirtySlot, subindex, roi): if dirtySlot == self.MergingFunction: self.Output.setDirty(slice(None)) elif dirtySlot == self.Inputs: # Assumes a pixel-wise merge function. key = roi.toSlice() self.Output.setDirty(key)
def propagateDirty(self, dirtySlot, subindex, roi): if dirtySlot == self.MergingFunction: self.Output.setDirty( slice(None) ) elif dirtySlot == self.Inputs: # Assumes a pixel-wise merge function. key = roi.toSlice() self.Output.setDirty( key )
def propagateDirty(self, slot, subindex, roi): key = roi.toSlice() if slot == self.Input: self.outputs["Output"].setDirty(key) elif slot == self.Function: self.Output.setDirty(slice(None)) else: assert False, "Unknown dirty input slot"
def propagateDirty(self, slot, subindex, roi): key = roi.toSlice() if slot == self.Input: self.outputs["Output"].setDirty(key) elif slot == self.Function: self.Output.setDirty( slice(None) ) else: assert False, "Unknown dirty input slot"
def propagateDirty(self, slot, subindex, roi): key = roi.toSlice() if slot == self.Input: channelIndex = self.Input.meta.axistags.channelIndex newKey = list(key) newKey[channelIndex] = slice(0, 1, None) # key = key[:-1] + (slice(0,1,None),) self.outputs["Output"].setDirty(tuple(newKey)) else: self.Output.setDirty(slice(None))
def propagateDirty(self, slot, subindex, roi): key = roi.toSlice() if slot == self.Input: channelIndex = self.Input.meta.axistags.channelIndex newKey = list(key) newKey[channelIndex] = slice(0, 1, None) #key = key[:-1] + (slice(0,1,None),) self.outputs["Output"].setDirty(tuple(newKey)) else: self.Output.setDirty(slice(None))
def propagateDirty(self, slot, subindex, roi): key = roi.toSlice() # Check for proper name because subclasses may define extra inputs. # (but decline to override notifyDirty) if slot is self.Input: self.Output.setDirty(key) else: # If some input we don't know about is dirty (i.e. we are subclassed by an operator with extra inputs), # then mark the entire output dirty. This is the correct behavior for e.g. 'sigma' inputs. self.Output.setDirty(slice(None))
def execute(self, slot, subindex, roi, result): key = roi.toSlice() data = self.inputs["Input"][key[:-1]+(slice(None),)].wait() #FIXME: only works if channels are in last dimension dm = numpy.max(data, axis = data.ndim-1) res = numpy.zeros(data.shape, numpy.uint8) for c in range(data.shape[-1]): res[...,c] = numpy.where(data[...,c] == dm, 1, 0) result[:] = res[...,key[-1]]
def execute(self, slot, subindex, roi, result): key = roi.toSlice() data = self.inputs["Input"][key[:-1] + (slice(None), )].wait() #FIXME: only works if channels are in last dimension dm = numpy.max(data, axis=data.ndim - 1) res = numpy.zeros(data.shape, numpy.uint8) for c in range(data.shape[-1]): numpy.equal(data[..., c], dm, out=res[..., c]) result[:] = res[..., key[-1]]
def execute(self, slot, subindex, roi, result): *key, c = roi.toSlice() n_channels_requested = c.stop - c.start if n_channels_requested != 1: raise InvalidRoiException( f"This operator only accepts slices of size 1 for c! Got {n_channels_requested}." ) data = self.Input[(*key, slice(None))].wait() # special case, when data is all zeros (e.g. directly from frozen cache w/o trained classifier) if not numpy.any(data): result[:] = 0 return result[:] = numpy.uint8( numpy.argmax(data, axis=-1) == c.start)[..., numpy.newaxis]
def execute(self, slot, subindex, roi, result): key = roi.toSlice() data = self.inputs["Input"][key[:-1] + (slice(None),)].wait() dm = numpy.max(data, axis=data.ndim - 1, keepdims=True) res = numpy.zeros(data.shape, numpy.uint8) numpy.equal(data, dm, out=res) # Special case: If all channels are tied, then none of them win. tied_pixels = numpy.logical_and.reduce(res, axis=-1, keepdims=True, dtype=numpy.uint8) # We could use numpy.concatenate(): # tied_pixels = numpy.concatenate((tied_pixels, tied_pixels), axis=-1) # But that's not as fast as duplicating the array with a stride trick. # (This only works because channel is the last axis.) tied_pixels = numpy.lib.stride_tricks.as_strided(tied_pixels, shape=res.shape, strides=tied_pixels.strides) res[tied_pixels] = 0 result[:] = res[..., key[-1]]
def propagateDirty(self, slot, subindex, roi): if slot == self.AxisFlag: for i,s in enumerate(self.Slices): s.setDirty( slice(None) ) elif slot == self.Input: key = roi.toSlice() reducedKey = list(key) inputTags = self.Input.meta.axistags flag = self.AxisFlag.value axisSlice = reducedKey.pop( inputTags.index(flag) ) axisStart, axisStop = axisSlice.start, axisSlice.stop if axisStart is None: axisStart = 0 if axisStop is None: axisStop = len( self.Slices ) for i in range(axisStart, axisStop): self.Slices[i].setDirty( reducedKey ) else: assert False, "Unknown dirty input slot"
def propagateDirty(self, slot, subindex, roi): if slot == self.AxisFlag: for i, s in enumerate(self.Slices): s.setDirty(slice(None)) elif slot == self.Input: key = roi.toSlice() reducedKey = list(key) inputTags = self.Input.meta.axistags flag = self.AxisFlag.value axisSlice = reducedKey.pop(inputTags.index(flag)) axisStart, axisStop = axisSlice.start, axisSlice.stop if axisStart is None: axisStart = 0 if axisStop is None: axisStop = len(self.Slices) for i in range(axisStart, axisStop): self.Slices[i].setDirty(reducedKey) else: assert False, "Unknown dirty input slot"
def execute(self, slot, subindex, roi, result): key = roi.toSlice() data = self.inputs["Input"][key[:-1] + (slice(None), )].wait() dm = numpy.max(data, axis=data.ndim - 1, keepdims=True) res = numpy.zeros(data.shape, numpy.uint8) numpy.equal(data, dm, out=res) # Special case: If all channels are tied, then none of them win. tied_pixels = numpy.logical_and.reduce(res, axis=-1, keepdims=True, dtype=numpy.uint8) # We could use numpy.concatenate(): # tied_pixels = numpy.concatenate((tied_pixels, tied_pixels), axis=-1) # But that's not as fast as duplicating the array with a stride trick. # (This only works because channel is the last axis.) tied_pixels = numpy.lib.stride_tricks.as_strided( tied_pixels, shape=res.shape, strides=tied_pixels.strides) res[tied_pixels] = 0 result[:] = res[..., key[-1]]
def execute(self, slot, subindex, roi, result): key = roi.toSlice() result[...] = self._data[key]
def execute(self, slot, subindex, roi, result): key = roi.toSlice() result[...] = self.Input(roi.start, roi.stop).wait()
def setInSlot(self, slot, subindex, roi, value): self.Output[0][roi.toSlice()] = value
def propagateDirty(self, slot, subindex, roi): key = roi.toSlice() if slot == self.Input: self.outputs["Output"].setDirty(key)
def setInSlot(self, slot, subindex, roi, value): # Forward to output assert subindex == () assert slot == self.Input key = roi.toSlice() self.Output[key] = value