Make Gaussian/Mahalanobis classifiers work with non-ndarray images (fixes #49).

Author: tboggs

spectral/algorithms/classifiers.py

@@ -193,7 +193,7 @@ def classify_image(self, image):
         '''
         import math
         import spectral
-        if not self.cache_class_scores:
+        if not (self.cache_class_scores and isinstance(image, np.ndarray)):
             return super(GaussianClassifier, self).classify_image(image)
 
         status = spectral._status
@@ -289,7 +289,7 @@ def classify_image(self, image):
         '''
         import spectral
         from .detectors import RX
-        if not self.cache_class_scores:
+        if not (self.cache_class_scores and isinstance(image, np.ndarray)):
             return super(MahalanobisDistanceClassifier,
                          self).classify_image(image)
 

spectral/tests/classifiers.py

@@ -83,6 +83,31 @@ def test_gmlc_spectrum_image_equal(self):
         assert(gmlc.classify_spectrum(data[2, 2]) == \
                gmlc.classify_image(data)[2, 2])
 
+    def test_gmlc_classify_spyfile_runs(self):
+        '''Tests that GaussianClassifier classifies a SpyFile object.'''
+        gmlc = spy.GaussianClassifier(self.ts, min_samples=600)
+        ret = gmlc.classify_image(self.image)
+
+    def test_gmlc_classify_transformedimage_runs(self):
+        '''Tests that GaussianClassifier classifies a TransformedImage object.'''
+        pc = spy.principal_components(self.data).reduce(num=3)
+        ximg = pc.transform(self.image)
+        ts = spy.create_training_classes(pc.transform(self.data), self.gt,
+                                              calc_stats=True)
+        gmlc = spy.GaussianClassifier(ts)
+        ret = gmlc.classify_image(ximg)
+
+    def test_gmlc_classify_ndarray_transformedimage_equal(self):
+        '''Gaussian classification of an ndarray and TransformedImage are equal'''
+        pc = spy.principal_components(self.data).reduce(num=3)
+        ximg = pc.transform(self.image)
+        ts = spy.create_training_classes(pc.transform(self.data), self.gt,
+                                              calc_stats=True)
+        gmlc = spy.GaussianClassifier(ts)
+        cl_ximg = gmlc.classify_image(ximg)
+        cl_ndarray = gmlc.classify_image(pc.transform(self.data))
+        assert(np.all(cl_ximg == cl_ndarray))
+
     def test_mahalanobis_class_mean(self):
         '''Test that a class's mean spectrum is classified as that class.
         Note this assumes that class priors are equal.
@@ -91,6 +116,31 @@ def test_mahalanobis_class_mean(self):
         cl = mdc.classes[0]
         assert(mdc.classify(cl.stats.mean) == cl.index)
 
+    def test_mahalanobis_classify_spyfile_runs(self):
+        '''Mahalanobis classifier works with a SpyFile object.'''
+        mdc = spy.MahalanobisDistanceClassifier(self.ts)
+        ret = mdc.classify_image(self.image)
+
+    def test_mahalanobis_classify_transformedimage_runs(self):
+        '''Mahalanobis classifier works with a TransformedImage object.'''
+        pc = spy.principal_components(self.data).reduce(num=3)
+        ximg = pc.transform(self.image)
+        ts = spy.create_training_classes(pc.transform(self.data), self.gt,
+                                              calc_stats=True)
+        gmlc = spy.MahalanobisDistanceClassifier(ts)
+        ret = gmlc.classify_image(ximg)
+
+    def test_mahalanobis_classify_ndarray_transformedimage_equal(self):
+        '''Mahalanobis classification of ndarray and TransformedImage are equal'''
+        pc = spy.principal_components(self.data).reduce(num=3)
+        ximg = pc.transform(self.image)
+        ts = spy.create_training_classes(pc.transform(self.data), self.gt,
+                                              calc_stats=True)
+        mdc = spy.GaussianClassifier(ts)
+        cl_ximg = mdc.classify_image(ximg)
+        cl_ndarray = mdc.classify_image(pc.transform(self.data))
+        assert(np.all(cl_ximg == cl_ndarray))
+
     def test_perceptron_learns_and(self):
         '''Test that 2x1 network can learn the logical AND function.'''
         from spectral.algorithms.perceptron import test_and