def _get_available_classifier_factories(self): # FIXME: Replace this logic with a proper plugin mechanism from lazyflow.classifiers import VigraRfLazyflowClassifierFactory, SklearnLazyflowClassifierFactory, \ ParallelVigraRfLazyflowClassifierFactory, VigraRfPixelwiseClassifierFactory,\ LazyflowVectorwiseClassifierFactoryABC, LazyflowPixelwiseClassifierFactoryABC classifiers = OrderedDict() classifiers["Parallel Random Forest (VIGRA)"] = ParallelVigraRfLazyflowClassifierFactory(100) try: from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier from sklearn.naive_bayes import GaussianNB from sklearn.tree import DecisionTreeClassifier from sklearn.neighbors import KNeighborsClassifier from sklearn.lda import LDA from sklearn.qda import QDA from sklearn.svm import SVC, NuSVC classifiers["Random Forest (scikit-learn)"] = SklearnLazyflowClassifierFactory( RandomForestClassifier, 100 ) classifiers["Gaussian Naive Bayes (scikit-learn)"] = SklearnLazyflowClassifierFactory( GaussianNB ) classifiers["AdaBoost (scikit-learn)"] = SklearnLazyflowClassifierFactory( AdaBoostClassifier, n_estimators=100 ) classifiers["Single Decision Tree (scikit-learn)"] = SklearnLazyflowClassifierFactory( DecisionTreeClassifier, max_depth=5 ) classifiers["K-Neighbors (scikit-learn)"] = SklearnLazyflowClassifierFactory( KNeighborsClassifier ) classifiers["LDA (scikit-learn)"] = SklearnLazyflowClassifierFactory( LDA ) classifiers["QDA (scikit-learn)"] = SklearnLazyflowClassifierFactory( QDA ) classifiers["SVM C-Support (scikit-learn)"] = SklearnLazyflowClassifierFactory( SVC, probability=True ) classifiers["SVM Nu-Support (scikit-learn)"] = SklearnLazyflowClassifierFactory( NuSVC, probability=True ) except ImportError: import warnings warnings.warn("Couldn't import sklearn. Scikit-learn classifiers not available.") # Debug classifiers classifiers["Parallel Random Forest with Variable Importance (VIGRA)"] = ParallelVigraRfLazyflowClassifierFactory(100, variable_importance_enabled=True) classifiers["(debug) Single-threaded Random Forest (VIGRA)"] = VigraRfLazyflowClassifierFactory(100) classifiers["(debug) Pixelwise Random Forest (VIGRA)"] = VigraRfPixelwiseClassifierFactory(100) return classifiers
def execute(self, slot, subindex, roi, result): all_features_and_labels_df = None for lane_index, (labels_dict_slot, features_slot) in \ enumerate( zip(self.EdgeLabelsDict, self.EdgeFeaturesDataFrame) ): logger.info( "Retrieving features for lane {}...".format(lane_index)) labels_dict = labels_dict_slot.value.copy( ) # Copy now to avoid threading issues. if not labels_dict: continue sp_columns = np.array(labels_dict.keys()) edge_features_df = features_slot.value assert list(edge_features_df.columns[0:2]) == ['sp1', 'sp2'] labels_df = pd.DataFrame(sp_columns, columns=['sp1', 'sp2']) labels_df['label'] = labels_dict.values() # Drop zero labels labels_df = labels_df[labels_df['label'] != 0] # Merge in features features_and_labels_df = pd.merge(edge_features_df, labels_df, how='right', on=['sp1', 'sp2']) if all_features_and_labels_df is not None: all_features_and_labels_df = all_features_and_labels_df.append( features_and_labels_df) else: all_features_and_labels_df = features_and_labels_df if all_features_and_labels_df is None: # No labels yet. result[0] = None return assert list(all_features_and_labels_df.columns[0:2]) == ['sp1', 'sp2'] assert all_features_and_labels_df.columns[-1] == 'label' feature_matrix = all_features_and_labels_df.iloc[:, 2: -1].values # Omit 'sp1', 'sp2', and 'label' labels = all_features_and_labels_df.iloc[:, -1].values logger.info("Training classifier with {} labels...".format( len(labels))) # TODO: Allow factory to be configured via an input slot classifier_factory = ParallelVigraRfLazyflowClassifierFactory() classifier = classifier_factory.create_and_train( feature_matrix, labels, feature_names=all_features_and_labels_df.columns[2:-1].values) assert set(classifier.known_classes).issubset(set([1, 2])) result[0] = classifier
def test_basic(self): # Initialize factory factory = ParallelVigraRfLazyflowClassifierFactory(10) # Train classifier = factory.create_and_train(self.training_feature_matrix, self.training_labels) assert isinstance(classifier, ParallelVigraRfLazyflowClassifier) assert list(classifier.known_classes) == [1,2] # Predict probabilities = classifier.predict_probabilities( self.prediction_data ) assert probabilities.shape == (4,2) assert probabilities.dtype == numpy.float32 assert (0 <= probabilities).all() and (probabilities <= 1.0).all() assert (numpy.argmax(probabilities, axis=-1)+1 == self.expected_classes).all()
def retrieve_segmentation_new(self, feat): ''' Attempt to use the opSimplePixelClassification by Stuart. Could not get this to work so far... :param feat: :return: ''' from . import opSimplePixelClassification from lazyflow import graph from lazyflow.classifiers import ParallelVigraRfLazyflowClassifierFactory self.opSimpleClassification = opSimplePixelClassification.OpSimplePixelClassification(parent = self.opPixelClassification.parent.pcApplet.topLevelOperator) self.opSimpleClassification.Labels.connect(self.opPixelClassification.opLabelPipeline.Output) self.opSimpleClassification.Features.connect(self.opPixelClassification.FeatureImages) self.opSimpleClassification.Labels.resize(1) self.opSimpleClassification.Features.resize(1) self.opSimpleClassification.ingest_labels() self.opSimpleClassification.ClassifierFactory.setValue(ParallelVigraRfLazyflowClassifierFactory(100)) # resize of input slots required, otherwise "IndexError: list index out of range" after this line segmentation = self.opSimpleClassification.Predictions[0][0, :, :, 25, 0].wait() # now I get: '''RuntimeError: Precondition violation! Sampler(): Requested sample count must be at least as large as the number of strata. (/miniconda/conda-bld/work/include/vigra/sampling.hxx:371)''' '''
def testBasic(self): features = numpy.indices( (100,100) ).astype(numpy.float32) + 0.5 features = numpy.rollaxis(features, 0, 3) features = vigra.taggedView(features, 'xyc') labels = numpy.zeros( (100,100,1), dtype=numpy.uint8 ) labels = vigra.taggedView(labels, 'xyc') labels[10,10] = 1 labels[10,11] = 1 labels[20,20] = 2 labels[20,21] = 2 graph = Graph() opFeatureMatrixCache = OpFeatureMatrixCache(graph=graph) opFeatureMatrixCache.FeatureImage.setValue(features) opFeatureMatrixCache.LabelImage.setValue(labels) opFeatureMatrixCache.LabelImage.setDirty( numpy.s_[10:11, 10:12] ) opFeatureMatrixCache.LabelImage.setDirty( numpy.s_[20:21, 20:22] ) opFeatureMatrixCache.LabelImage.setDirty( numpy.s_[30:31, 30:32] ) opTrain = OpTrainClassifierFromFeatureVectors( graph=graph ) opTrain.ClassifierFactory.setValue( ParallelVigraRfLazyflowClassifierFactory(100) ) opTrain.MaxLabel.setValue(2) opTrain.LabelAndFeatureMatrix.connect( opFeatureMatrixCache.LabelAndFeatureMatrix ) assert opTrain.Classifier.ready() trained_classifier = opTrain.Classifier.value # This isn't much of a test at the moment... assert isinstance( trained_classifier, ParallelVigraRfLazyflowClassifier ), \ "classifier is of the wrong type: {}".format(type(trained_classifier))
def execute(self, slot, subindex, roi, result): all_features_and_labels_df = None for lane_index, (labels_dict_slot, features_slot) in \ enumerate( zip(self.EdgeLabelsDict, self.EdgeFeaturesDataFrame) ): logger.info("Retrieving features for lane {}...".format(lane_index)) labels_dict = labels_dict_slot.value.copy() # Copy now to avoid threading issues. if not labels_dict: continue sp_columns = np.array(labels_dict.keys()) edge_features_df = features_slot.value assert list(edge_features_df.columns[0:2]) == ['sp1', 'sp2'] labels_df = pd.DataFrame(sp_columns, columns=['sp1', 'sp2']) labels_df['label'] = labels_dict.values() # Drop zero labels labels_df = labels_df[labels_df['label'] != 0] # Merge in features features_and_labels_df = pd.merge(edge_features_df, labels_df, how='right', on=['sp1', 'sp2']) if all_features_and_labels_df is not None: all_features_and_labels_df = all_features_and_labels_df.append(features_and_labels_df) else: all_features_and_labels_df = features_and_labels_df if all_features_and_labels_df is None: # No labels yet. result[0] = None return assert list(all_features_and_labels_df.columns[0:2]) == ['sp1', 'sp2'] assert all_features_and_labels_df.columns[-1] == 'label' feature_matrix = all_features_and_labels_df.iloc[:, 2:-1].values # Omit 'sp1', 'sp2', and 'label' labels = all_features_and_labels_df.iloc[:, -1].values logger.info("Training classifier with {} labels...".format( len(labels) )) # TODO: Allow factory to be configured via an input slot classifier_factory = ParallelVigraRfLazyflowClassifierFactory() classifier = classifier_factory.create_and_train( feature_matrix, labels, feature_names=all_features_and_labels_df.columns[2:-1].values ) assert set(classifier.known_classes).issubset(set([1,2])) result[0] = classifier
def test_basic(self): # Initialize factory factory = ParallelVigraRfLazyflowClassifierFactory(10) # Train classifier = factory.create_and_train(self.training_feature_matrix, self.training_labels) assert isinstance(classifier, ParallelVigraRfLazyflowClassifier) assert list(classifier.known_classes) == [1, 2] # Predict probabilities = classifier.predict_probabilities(self.prediction_data) assert probabilities.shape == (4, 2) assert probabilities.dtype == numpy.float32 assert (0 <= probabilities).all() and (probabilities <= 1.0).all() assert (numpy.argmax(probabilities, axis=-1) + 1 == self.expected_classes).all()
def test(): # Make up some garbage features for this test features = numpy.indices((100, 100)).astype(numpy.float32) + 0.5 features = numpy.rollaxis(features, 0, 3) features = vigra.taggedView(features, 'yxc') assert features.shape == (100, 100, 2) # Define a couple arbitrary labels. labels = numpy.zeros((100, 100, 1), dtype=numpy.uint8) labels = vigra.taggedView(labels, 'yxc') labels[10, 10] = 1 labels[10, 11] = 1 labels[20, 20] = 2 labels[20, 21] = 2 graph = Graph() opPixelClassification = OpSimplePixelClassification(graph=Graph()) # Specify the classifier type: A random forest with just 10 trees. opPixelClassification.ClassifierFactory.setValue( ParallelVigraRfLazyflowClassifierFactory(10)) # In a typical use-case, the inputs to our operator would be connected to some upstream pipeline via Slot.connect(). # But for this test, we will provide the data as raw VigraArrays via the special Slot.setValue() function. # Also, we have to manually resize() the level-1 slots. opPixelClassification.Features.resize(1) opPixelClassification.Features[0].setValue(features) opPixelClassification.Labels.resize(1) opPixelClassification.Labels.setValue(labels) # Load the label cache, which will pull from the Labels slot... print "Ingesting labels..." opPixelClassification.ingest_labels() print "Initiating prediction..." predictions = opPixelClassification.Predictions[0][:].wait() assert predictions.shape == (100, 100, 2) assert predictions.dtype == numpy.float32 assert 0.0 <= predictions.min() <= predictions.max() <= 1.0 print "Done predicting."
def test_pickle_fields(self): """ Classifier factories are meant to be pickled and restored, but that only works if the thing we're restoring has the EXACT SAME MEMBERS as the current version of the class. Any changes to the factory's member variables will change it's pickled representation. Therefore, we store a special member named VERSION as both a class member AND instance member (see LazyflowVectorwiseClassifierFactoryABC.__new__), so we can check for compatibility before attempting to unpickle a factory. In this test, we verify that the pickle interface hasn't changed. IF THIS TEST FAILS: - Think about whether that's what you intended (see below) - Update ParallelVigraRfLazyflowClassifierFactory.VERSION - and then change the version and members listed below. ... but think hard about whether or not the changes you made to ParallelVigraRfLazyflowClassifierFactory are important, because they will invalidate stored classifiers in existing ilastik project files. (The project file should still load, but a warning will be shown, explaining that the user will need to train a new classifer.) """ factory = ParallelVigraRfLazyflowClassifierFactory( 10, variable_importance_enabled=True) members = set(factory.__dict__.keys()) # Quick way to get the updated set of members. # print members assert ParallelVigraRfLazyflowClassifierFactory.VERSION == 2 assert members == set([ "VERSION", "_variable_importance_path", "_kwargs", "_variable_importance_enabled", "_num_trees", "_label_proportion", "_num_forests", ])
class OpMockPixelClassifier(Operator): """ This class is a simple stand-in for the real pixel classification operator. Uses hard-coded data shape and block shape. Provides hard-coded outputs. """ name = "OpMockPixelClassifier" LabelInputs = InputSlot(optional = True, level=1) # Input for providing label data from an external source PredictionsFromDisk = InputSlot( optional = True, level=1 ) # TODO: Actually use this input for something ClassifierFactory = InputSlot( value=ParallelVigraRfLazyflowClassifierFactory(10,10) ) NonzeroLabelBlocks = OutputSlot(level=1, stype='object') # A list if slices that contain non-zero label values LabelImages = OutputSlot(level=1) # Labels from the user Classifier = OutputSlot(stype='object') PredictionProbabilities = OutputSlot(level=1) FreezePredictions = InputSlot() LabelNames = OutputSlot() LabelColors = OutputSlot() PmapColors = OutputSlot() Bookmarks = OutputSlot(level=1) def __init__(self, *args, **kwargs): super(OpMockPixelClassifier, self).__init__(*args, **kwargs) self.LabelNames.setValue( ["Membrane", "Cytoplasm"] ) self.LabelColors.setValue( [(255,0,0), (0,255,0)] ) # Red, Green self.PmapColors.setValue( [(255,0,0), (0,255,0)] ) # Red, Green self._data = [] self.dataShape = (1,10,100,100,1) self.prediction_shape = self.dataShape[:-1] + (2,) # Hard-coded to provide 2 classes self.FreezePredictions.setValue(False) self.opClassifier = OpTrainClassifierBlocked(graph=self.graph, parent=self) self.opClassifier.ClassifierFactory.connect( self.ClassifierFactory ) self.opClassifier.Labels.connect(self.LabelImages) self.opClassifier.nonzeroLabelBlocks.connect(self.NonzeroLabelBlocks) self.opClassifier.MaxLabel.setValue(2) self.classifier_cache = OpValueCache(graph=self.graph, parent=self) self.classifier_cache.Input.connect( self.opClassifier.Classifier ) p1 = numpy.indices(self.dataShape).sum(0) / 207.0 p2 = 1 - p1 self.predictionData = numpy.concatenate((p1,p2), axis=4) def setupOutputs(self): numImages = len(self.LabelInputs) self.PredictionsFromDisk.resize( numImages ) self.NonzeroLabelBlocks.resize( numImages ) self.LabelImages.resize( numImages ) self.PredictionProbabilities.resize( numImages ) self.opClassifier.Images.resize( numImages ) for i in range(numImages): self._data.append( numpy.zeros(self.dataShape) ) self.NonzeroLabelBlocks[i].meta.shape = (1,) self.NonzeroLabelBlocks[i].meta.dtype = object # Hard-coded: Two prediction classes self.PredictionProbabilities[i].meta.shape = self.prediction_shape self.PredictionProbabilities[i].meta.dtype = numpy.float64 self.PredictionProbabilities[i].meta.axistags = vigra.defaultAxistags('txyzc') # Classify with random data self.opClassifier.Images[i].setValue( vigra.taggedView( numpy.random.random(self.dataShape), 'txyzc' ) ) self.LabelImages[i].meta.shape = self.dataShape self.LabelImages[i].meta.dtype = numpy.float64 self.LabelImages[i].meta.axistags = self.opClassifier.Images[i].meta.axistags self.Classifier.connect( self.opClassifier.Classifier ) def setInSlot(self, slot, subindex, roi, value): key = roi.toSlice() assert slot.name == "LabelInputs" self._data[subindex[0]][key] = value self.LabelImages[subindex[0]].setDirty(key) def execute(self, slot, subindex, roi, result): key = roiToSlice(roi.start, roi.stop) index = subindex[0] if slot.name == "NonzeroLabelBlocks": # Split into 10 chunks blocks = [] slicing = [slice(0,maximum) for maximum in self.dataShape] for i in range(10): slicing[2] = slice(i*10, (i+1)*10) if not (self._data[index][slicing] == 0).all(): blocks.append( list(slicing) ) result[0] = blocks if slot.name == "LabelImages": result[...] = self._data[index][key] if slot.name == "PredictionProbabilities": result[...] = self.predictionData[key] def propagateDirty(self, slot, subindex, roi): pass
class OpPixelClassification(Operator): """ Top-level operator for pixel classification """ name = "OpPixelClassification" category = "Top-level" # Graph inputs InputImages = InputSlot( level=1) # Original input data. Used for display only. PredictionMasks = InputSlot( level=1, optional=True ) # Routed to OpClassifierPredict.PredictionMask. See there for details. LabelInputs = InputSlot( optional=True, level=1) # Input for providing label data from an external source FeatureImages = InputSlot( level=1 ) # Computed feature images (each channel is a different feature) CachedFeatureImages = InputSlot(level=1) # Cached feature data. FreezePredictions = InputSlot(stype='bool') ClassifierFactory = InputSlot( value=ParallelVigraRfLazyflowClassifierFactory(100)) PredictionsFromDisk = InputSlot(optional=True, level=1) PredictionProbabilities = OutputSlot( level=1 ) # Classification predictions (via feature cache for interactive speed) PredictionProbabilitiesUint8 = OutputSlot( level=1) # Same thing, but converted to uint8 first PredictionProbabilityChannels = OutputSlot( level=2) # Classification predictions, enumerated by channel SegmentationChannels = OutputSlot( level=2) # Binary image of the final selections. LabelImages = OutputSlot(level=1) # Labels from the user NonzeroLabelBlocks = OutputSlot( level=1) # A list if slices that contain non-zero label values Classifier = OutputSlot( ) # We provide the classifier as an external output for other applets to use CachedPredictionProbabilities = OutputSlot( level=1 ) # Classification predictions (via feature cache AND prediction cache) HeadlessPredictionProbabilities = OutputSlot( level=1 ) # Classification predictions ( via no image caches (except for the classifier itself ) HeadlessUint8PredictionProbabilities = OutputSlot( level=1) # Same as above, but 0-255 uint8 instead of 0.0-1.0 float32 HeadlessUncertaintyEstimate = OutputSlot( level=1 ) # Same as uncertaintly estimate, but does not rely on cached data. UncertaintyEstimate = OutputSlot(level=1) SimpleSegmentation = OutputSlot(level=1) # For debug, for now # GUI-only (not part of the pipeline, but saved to the project) LabelNames = OutputSlot() LabelColors = OutputSlot() PmapColors = OutputSlot() NumClasses = OutputSlot() def setupOutputs(self): self.LabelNames.meta.dtype = object self.LabelNames.meta.shape = (1, ) self.LabelColors.meta.dtype = object self.LabelColors.meta.shape = (1, ) self.PmapColors.meta.dtype = object self.PmapColors.meta.shape = (1, ) def __init__(self, *args, **kwargs): """ Instantiate all internal operators and connect them together. """ super(OpPixelClassification, self).__init__(*args, **kwargs) # Default values for some input slots self.FreezePredictions.setValue(True) self.LabelNames.setValue([]) self.LabelColors.setValue([]) self.PmapColors.setValue([]) # SPECIAL connection: The LabelInputs slot doesn't get it's data # from the InputImages slot, but it's shape must match. self.LabelInputs.connect(self.InputImages) # Hook up Labeling Pipeline self.opLabelPipeline = OpMultiLaneWrapper( OpLabelPipeline, parent=self, broadcastingSlotNames=['DeleteLabel']) self.opLabelPipeline.RawImage.connect(self.InputImages) self.opLabelPipeline.LabelInput.connect(self.LabelInputs) self.opLabelPipeline.DeleteLabel.setValue(-1) self.LabelImages.connect(self.opLabelPipeline.Output) self.NonzeroLabelBlocks.connect(self.opLabelPipeline.nonzeroBlocks) # Hook up the Training operator self.opTrain = OpTrainClassifierBlocked(parent=self) self.opTrain.ClassifierFactory.connect(self.ClassifierFactory) self.opTrain.Labels.connect(self.opLabelPipeline.Output) self.opTrain.Images.connect(self.FeatureImages) self.opTrain.nonzeroLabelBlocks.connect( self.opLabelPipeline.nonzeroBlocks) # Hook up the Classifier Cache # The classifier is cached here to allow serializers to force in # a pre-calculated classifier (loaded from disk) self.classifier_cache = OpValueCache(parent=self) self.classifier_cache.name = "OpPixelClassification.classifier_cache" self.classifier_cache.inputs["Input"].connect( self.opTrain.outputs['Classifier']) self.classifier_cache.inputs["fixAtCurrent"].connect( self.FreezePredictions) self.Classifier.connect(self.classifier_cache.Output) # Hook up the prediction pipeline inputs self.opPredictionPipeline = OpMultiLaneWrapper(OpPredictionPipeline, parent=self) self.opPredictionPipeline.FeatureImages.connect(self.FeatureImages) self.opPredictionPipeline.CachedFeatureImages.connect( self.CachedFeatureImages) self.opPredictionPipeline.Classifier.connect( self.classifier_cache.Output) self.opPredictionPipeline.FreezePredictions.connect( self.FreezePredictions) self.opPredictionPipeline.PredictionsFromDisk.connect( self.PredictionsFromDisk) self.opPredictionPipeline.PredictionMask.connect(self.PredictionMasks) # Feature Selection Stuff self.opFeatureMatrixCaches = OpMultiLaneWrapper(OpFeatureMatrixCache, parent=self) self.opFeatureMatrixCaches.LabelImage.connect( self.opLabelPipeline.Output) self.opFeatureMatrixCaches.FeatureImage.connect(self.FeatureImages) self.opFeatureMatrixCaches.LabelImage.setDirty( ) # do I still need this? def _updateNumClasses(*args): """ When the number of labels changes, we MUST make sure that the prediction image changes its shape (the number of channels). Since setupOutputs is not called for mere dirty notifications, but is called in response to setValue(), we use this function to call setValue(). """ numClasses = len(self.LabelNames.value) self.opTrain.MaxLabel.setValue(numClasses) self.opPredictionPipeline.NumClasses.setValue(numClasses) self.NumClasses.setValue(numClasses) self.LabelNames.notifyDirty(_updateNumClasses) # Prediction pipeline outputs -> Top-level outputs self.PredictionProbabilities.connect( self.opPredictionPipeline.PredictionProbabilities) self.PredictionProbabilitiesUint8.connect( self.opPredictionPipeline.PredictionProbabilitiesUint8) self.CachedPredictionProbabilities.connect( self.opPredictionPipeline.CachedPredictionProbabilities) self.HeadlessPredictionProbabilities.connect( self.opPredictionPipeline.HeadlessPredictionProbabilities) self.HeadlessUint8PredictionProbabilities.connect( self.opPredictionPipeline.HeadlessUint8PredictionProbabilities) self.PredictionProbabilityChannels.connect( self.opPredictionPipeline.PredictionProbabilityChannels) self.SegmentationChannels.connect( self.opPredictionPipeline.SegmentationChannels) self.UncertaintyEstimate.connect( self.opPredictionPipeline.UncertaintyEstimate) self.SimpleSegmentation.connect( self.opPredictionPipeline.SimpleSegmentation) self.HeadlessUncertaintyEstimate.connect( self.opPredictionPipeline.HeadlessUncertaintyEstimate) def inputResizeHandler(slot, oldsize, newsize): if (newsize == 0): self.LabelImages.resize(0) self.NonzeroLabelBlocks.resize(0) self.PredictionProbabilities.resize(0) self.CachedPredictionProbabilities.resize(0) self.InputImages.notifyResized(inputResizeHandler) # Debug assertions: Check to make sure the non-wrapped operators stayed that way. assert self.opTrain.Images.operator == self.opTrain def handleNewInputImage(multislot, index, *args): def handleInputReady(slot): self._checkConstraints(index) self.setupCaches(multislot.index(slot)) multislot[index].notifyReady(handleInputReady) self.InputImages.notifyInserted(handleNewInputImage) # If any feature image changes shape, we need to verify that the # channels are consistent with the currently cached classifier # Otherwise, delete the currently cached classifier. def handleNewFeatureImage(multislot, index, *args): def handleFeatureImageReady(slot): def handleFeatureMetaChanged(slot): if (self.classifier_cache.fixAtCurrent.value and self.classifier_cache.Output.ready() and slot.meta.shape is not None): classifier = self.classifier_cache.Output.value channel_names = slot.meta.channel_names if classifier and classifier.feature_names != channel_names: self.classifier_cache.resetValue() slot.notifyMetaChanged(handleFeatureMetaChanged) multislot[index].notifyReady(handleFeatureImageReady) self.FeatureImages.notifyInserted(handleNewFeatureImage) def handleNewMaskImage(multislot, index, *args): def handleInputReady(slot): self._checkConstraints(index) multislot[index].notifyReady(handleInputReady) self.PredictionMasks.notifyInserted(handleNewMaskImage) # All input multi-slots should be kept in sync # Output multi-slots will auto-sync via the graph multiInputs = filter(lambda s: s.level >= 1, self.inputs.values()) for s1 in multiInputs: for s2 in multiInputs: if s1 != s2: def insertSlot(a, b, position, finalsize): a.insertSlot(position, finalsize) s1.notifyInserted(partial(insertSlot, s2)) def removeSlot(a, b, position, finalsize): a.removeSlot(position, finalsize) s1.notifyRemoved(partial(removeSlot, s2)) def setupCaches(self, imageIndex): numImages = len(self.InputImages) inputSlot = self.InputImages[imageIndex] # # Can't setup if all inputs haven't been set yet. # if numImages != len(self.FeatureImages) or \ # numImages != len(self.CachedFeatureImages): # return # # self.LabelImages.resize(numImages) self.LabelInputs.resize(numImages) # Special case: We have to set up the shape of our label *input* according to our image input shape shapeList = list(self.InputImages[imageIndex].meta.shape) try: channelIndex = self.InputImages[imageIndex].meta.axistags.index( 'c') shapeList[channelIndex] = 1 except: pass self.LabelInputs[imageIndex].meta.shape = tuple(shapeList) self.LabelInputs[imageIndex].meta.axistags = inputSlot.meta.axistags def _checkConstraints(self, laneIndex): """ Ensure that all input images have the same number of channels. """ if not self.InputImages[laneIndex].ready(): return thisLaneTaggedShape = self.InputImages[laneIndex].meta.getTaggedShape() # Find a different lane and use it for comparison validShape = thisLaneTaggedShape for i, slot in enumerate(self.InputImages): if slot.ready() and i != laneIndex: validShape = slot.meta.getTaggedShape() break if 't' in thisLaneTaggedShape: del thisLaneTaggedShape['t'] if 't' in validShape: del validShape['t'] if validShape['c'] != thisLaneTaggedShape['c']: raise DatasetConstraintError( "Pixel Classification", "All input images must have the same number of channels. "\ "Your new image has {} channel(s), but your other images have {} channel(s)."\ .format( thisLaneTaggedShape['c'], validShape['c'] ) ) if len(validShape) != len(thisLaneTaggedShape): raise DatasetConstraintError( "Pixel Classification", "All input images must have the same dimensionality. "\ "Your new image has {} dimensions (including channel), but your other images have {} dimensions."\ .format( len(thisLaneTaggedShape), len(validShape) ) ) mask_slot = self.PredictionMasks[laneIndex] input_shape = self.InputImages[laneIndex].meta.shape if mask_slot.ready() and mask_slot.meta.shape[:-1] != input_shape[:-1]: raise DatasetConstraintError( "Pixel Classification", "If you supply a prediction mask, it must have the same shape as the input image."\ "Your input image has shape {}, but your mask has shape {}."\ .format( input_shape, mask_slot.meta.shape ) ) def setInSlot(self, slot, subindex, roi, value): # Nothing to do here: All inputs that support __setitem__ # are directly connected to internal operators. pass def propagateDirty(self, slot, subindex, roi): # Nothing to do here: All outputs are directly connected to # internal operators that handle their own dirty propagation. pass def addLane(self, laneIndex): numLanes = len(self.InputImages) assert numLanes == laneIndex, "Image lanes must be appended." self.InputImages.resize(numLanes + 1) def removeLane(self, laneIndex, finalLength): self.InputImages.removeSlot(laneIndex, finalLength) def getLane(self, laneIndex): return OperatorSubView(self, laneIndex) def importLabels(self, laneIndex, slot): # Load the data into the cache new_max = self.getLane( laneIndex).opLabelPipeline.opLabelArray.ingestData(slot) # Add to the list of label names if there's a new max label old_names = self.LabelNames.value old_max = len(old_names) if new_max > old_max: new_names = old_names + map(lambda x: "Label {}".format(x), range(old_max + 1, new_max + 1)) self.LabelNames.setValue(new_names) # Make some default colors, too default_colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255), (128, 128, 128), (255, 105, 180), (255, 165, 0), (240, 230, 140)] label_colors = self.LabelColors.value pmap_colors = self.PmapColors.value self.LabelColors.setValue(label_colors + default_colors[old_max:new_max]) self.PmapColors.setValue(pmap_colors + default_colors[old_max:new_max]) def mergeLabels(self, from_label, into_label): for laneIndex in range(len(self.InputImages)): self.getLane(laneIndex).opLabelPipeline.opLabelArray.mergeLabels( from_label, into_label) def clearLabel(self, label_value): for laneIndex in range(len(self.InputImages)): self.getLane(laneIndex).opLabelPipeline.opLabelArray.clearLabel( label_value)