예제 #1
0
파일: testStats.py 프로젝트: WuZifan/silx
 def getBasicStats(self):
     return {
         'min': stats.StatMin(),
         'minCoords': stats.StatCoordMin(),
         'max': stats.StatMax(),
         'maxCoords': stats.StatCoordMax(),
         'std': stats.Stat(name='std', fct=numpy.std),
         'mean': stats.Stat(name='mean', fct=numpy.mean),
         'com': stats.StatCOM()
     }
예제 #2
0
파일: testStats.py 프로젝트: WuZifan/silx
 def testKindNotManagedByContext(self):
     """
     Make sure an error is raised if we try to calculate a statistic with
     a context not managed
     """
     myStat = stats.Stat(name='toto', fct=numpy.std, kinds=('curve'))
     myStat.calculate(self.curveContext)
     with self.assertRaises(ValueError):
         myStat.calculate(self.scatterContext)
     with self.assertRaises(ValueError):
         myStat.calculate(self.imageContext)
예제 #3
0
 def test(self):
     """Test stats result on an image context with different scale and
     origins"""
     roi_origins = [(0, 0), (2, 10), (14, 20)]
     img_origins = [(0, 0), (14, 20), (2, 10)]
     img_scales = [1.0, 0.5, 2.0]
     _stats = {
         'sum': stats.Stat(name='sum', fct=numpy.sum),
     }
     for roi_origin in roi_origins:
         for img_origin in img_origins:
             for img_scale in img_scales:
                 with self.subTest(roi_origin=roi_origin,
                                   img_origin=img_origin,
                                   img_scale=img_scale):
                     self.plot.addImage(self.data,
                                        legend='img',
                                        origin=img_origin,
                                        scale=img_scale)
                     roi = RectangleROI()
                     roi.setGeometry(origin=roi_origin, size=(20, 20))
                     context = stats._ImageContext(
                         item=self.plot.getImage('img'),
                         plot=self.plot,
                         onlimits=False,
                         roi=roi)
                     x_start = int(
                         (roi_origin[0] - img_origin[0]) / img_scale)
                     x_end = int(x_start + (20 / img_scale)) + 1
                     y_start = int(
                         (roi_origin[1] - img_origin[1]) / img_scale)
                     y_end = int(y_start + (20 / img_scale)) + 1
                     x_start = max(x_start, 0)
                     x_end = min(max(x_end, 0), self.data_dims[1])
                     y_start = max(y_start, 0)
                     y_end = min(max(y_end, 0), self.data_dims[0])
                     th_sum = numpy.sum(self.data[y_start:y_end,
                                                  x_start:x_end])
                     self.assertAlmostEqual(
                         _stats['sum'].calculate(context), th_sum)