Merge remote-tracking branch 'upstream/master' into 1088_numpy_1.16

Author: kif

foo-mask.edf

@@ -34,7 +34,7 @@
 __contact__ = "[email protected]"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "07/01/2019"
+__date__ = "15/01/2019"
 __satus__ = "production"
 import sys
 import logging
@@ -65,10 +65,21 @@ def integrate_gui(options, args):
     from silx.gui import qt
     from pyFAI.gui.IntegrationDialog import IntegrationDialog
     app = qt.QApplication([])
-    window = IntegrationDialog(args, options.output, json_file=options.json)
+
+    from pyFAI.gui.ApplicationContext import ApplicationContext
+    settings = qt.QSettings(qt.QSettings.IniFormat,
+                            qt.QSettings.UserScope,
+                            "pyfai",
+                            "pyfai-integrate",
+                            None)
+    context = ApplicationContext(settings)
+
+    window = IntegrationDialog(args, options.output, json_file=options.json, context=context)
     window.set_input_data(args)
     window.show()
-    return app.exec_()
+    result = app.exec_()
+    context.saveSettings()
+    return result
 
 
 def get_monitor_value(image, monitor_key):

pyFAI/app/integrate.py

@@ -32,7 +32,7 @@
 __contact__ = "[email protected]"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "03/01/2019"
+__date__ = "14/01/2019"
 __status__ = "stable"
 __docformat__ = 'restructuredtext'
 
@@ -172,8 +172,9 @@
     # Register splitPixelFullCSR integrators
     IntegrationMethod(1, "full", "CSR", "cython", old_method="full_csr",
                       class_funct=(splitPixelFullCSR.FullSplitCSR_1d, splitPixelFullCSR.FullSplitCSR_1d.integrate))
-    IntegrationMethod(2, "full", "CSR", "cython", old_method="full_csr",
-                      class_funct=(splitPixelFullCSR.FullSplitCSR_2d, splitPixelFullCSR.FullSplitCSR_2d.integrate))
+    # FIXME: The implementation is there but the routing have to be fixed
+    # IntegrationMethod(2, "full", "CSR", "cython", old_method="full_csr",
+    #                   class_funct=(splitPixelFullCSR.FullSplitCSR_2d, splitPixelFullCSR.FullSplitCSR_2d.integrate))
 
 from .opencl import ocl
 if ocl:

pyFAI/azimuthalIntegrator.py

@@ -36,7 +36,7 @@
 __contact__ = "[email protected]"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "16/10/2018"
+__date__ = "18/01/2019"
 __status__ = "production"
 
 import functools
@@ -535,16 +535,15 @@ def _calc_pixels_size(self, length, module_size, pixel_size):
 
     def _passage(self, corners, rot):
         shape = corners.shape
-        origine = corners[0][0][0, :]
+        deltaX, deltaY = 0.0, 0.0
         nmd = self._rotation(corners, rot)
-        u = corners[shape[0] - 1][0][1, :] - corners[0][0][0, :]
-        u = u / numpy.linalg.norm(u)
-        s = self._rotation(u, rot)
-        s = s / numpy.linalg.norm(s)
-        v = numpy.array([-u[1], u[0], u[2]])
-        r = origine - nmd[0][0][0, :]
-        w = (0.1e-3 + 0.24e-3 + 75.14e-3) * u + (0.8e-3) * v + (0.55e-3) * s + r
-        return self._translation(nmd, w)
+        # Size in mm of the chip in the Y direction (including 10px gap)
+        size_Y = ((560.0 + 3 * 6 + 20)*0.13/1000)
+        for i in range(1, int(round(numpy.abs(rot[2])/6.74))):
+            deltaX = deltaX + numpy.sin(numpy.deg2rad(-rot[2] -6.74*(i)))
+        for i in range(int(round(numpy.abs(rot[2])/6.74))):
+            deltaY = deltaY + numpy.cos(numpy.deg2rad(-rot[2] - 6.74*(i+1)))
+        return self._translation(nmd, [size_Y*deltaX,size_Y*deltaY, 0])
 
     def _get_pixel_corners(self):
         pixel_size1 = self._calc_pixels_size(self.MEDIUM_MODULE_SIZE[0],
@@ -581,13 +580,15 @@ def _get_pixel_corners(self):
         corners[:, :, 3, 1] = pixel_center1 - pixel_size1 / 2.0
         corners[:, :, 3, 2] = pixel_center2 + pixel_size2 / 2.0
 
-        modules = [self._passage(corners, [self.ROT[0], self.ROT[1], self.ROT[2]*i]) for i in range(20)]
-        return numpy.concatenate(modules, axis=0)
+        modules = [self._passage(corners, [self.ROT[0], self.ROT[1], self.ROT[2] * i]) for i in range(20)]
+        result = numpy.concatenate(modules, axis=0)
+        result = numpy.ascontiguousarray(result, result.dtype)
+        return result
 
     def get_pixel_corners(self):
         if self._pixel_corners is None:
             with self._sem:
-                if self._pixel_corners is None:  
+                if self._pixel_corners is None:
                     self._pixel_corners = self._get_pixel_corners()
         return self._pixel_corners
 

pyFAI/detectors/_imxpad.py

@@ -35,7 +35,7 @@
 __contact__ = "[email protected]"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "27/11/2018"
+__date__ = "11/01/2019"
 __status__ = "development"
 
 import os
@@ -331,9 +331,6 @@ def refine2(self, maxiter=1000000, fix=None):
                 bounds.append((getattr(self, "_%s_min" % i), getattr(self, "_%s_max" % i)))
         self.param = numpy.array(param)
 
-        print(self.data)
-        print(self.param, fix, bounds, self.chi2(param) / self.data.shape[0])
-
         if self.data.shape[-1] == 3:
             pos0 = self.data[:, 0]
             pos1 = self.data[:, 1]
@@ -360,8 +357,6 @@ def refine2(self, maxiter=1000000, fix=None):
         logger.info("Constrained Least square %s --> %s",
                     oldDeltaSq, newDeltaSq)
 
-        print(new_param, fix, bounds, self.chi2(new_param) / self.data.shape[0])
-
         if newDeltaSq < oldDeltaSq:
             i = abs(self.param - new_param).argmax()
 
@@ -519,8 +514,13 @@ def curve_fit(self, with_rot=True):
         size = d1.size
         x = d1, d2
         rings = self.data[:, 2].astype(numpy.int32)
-        f_with_rot = lambda x, *param: self.tth(x[0], x[1], numpy.concatenate((param, [self.rot3])))
-        f_no_rot = lambda x, *param: self.tth(x[0], x[1], numpy.concatenate((param, [self.rot1, self.rot2, self.rot3])))
+
+        def f_with_rot(x, *param):
+            return self.tth(x[0], x[1], numpy.concatenate((param, [self.rot3])))
+
+        def f_no_rot(x, *param):
+            return self.tth(x[0], x[1], numpy.concatenate((param, [self.rot1, self.rot2, self.rot3])))
+
         y = self.calc_2th(rings, self.wavelength)
         param0 = numpy.array([self.dist, self.poni1, self.poni2, self.rot1, self.rot2, self.rot3], dtype=numpy.float64)
         ref = self.residu2(param0, d1, d2, rings)

pyFAI/geometryRefinement.py

@@ -0,0 +1,155 @@
+# coding: utf-8
+# /*##########################################################################
+# Copyright (C) 2016-2018 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ############################################################################*/
+"""Context shared through all the application"""
+
+__authors__ = ["V. Valls"]
+__license__ = "MIT"
+__date__ = "15/01/2019"
+
+import weakref
+import logging
+import functools
+import os
+
+from silx.gui import qt
+
+from ..utils import stringutil
+
+
+_logger = logging.getLogger(__name__)
+
+
+class ApplicationContext(object):
+
+    __instance = None
+
+    @staticmethod
+    def _releaseSingleton():
+        ApplicationContext.__instance = None
+
+    @staticmethod
+    def instance():
+        """
+        :rtype: CalibrationContext
+        """
+        assert(ApplicationContext.__instance is not None)
+        return ApplicationContext.__instance
+
+    def __init__(self, settings=None):
+        assert(ApplicationContext.__instance is None)
+        self.__parent = None
+        self.__dialogState = None
+        self.__settings = settings
+        ApplicationContext.__instance = self
+
+    def saveSettings(self):
+        """Save the settings of all the application"""
+        # Synchronize the file storage
+        self.__settings.sync()
+
+    def restoreWindowLocationSettings(self, groupName, window):
+        """Restore the window settings using this settings object
+
+        :param qt.QSettings settings: Initialized settings
+        """
+        settings = self.__settings
+        if settings is None:
+            _logger.debug("Settings not set")
+            return
+
+        settings.beginGroup(groupName)
+        size = settings.value("size", qt.QSize())
+        pos = settings.value("pos", qt.QPoint())
+        isFullScreen = settings.value("full-screen", False)
+        try:
+            if not isinstance(isFullScreen, bool):
+                isFullScreen = stringutil.to_bool(isFullScreen)
+        except ValueError:
+            isFullScreen = False
+        settings.endGroup()
+
+        if not pos.isNull():
+            window.move(pos)
+        if not size.isNull():
+            window.resize(size)
+        if isFullScreen:
+            window.showFullScreen()
+
+    def saveWindowLocationSettings(self, groupName, window):
+        """Save the window settings to this settings object
+
+        :param qt.QSettings settings: Initialized settings
+        """
+        settings = self.__settings
+        if settings is None:
+            _logger.debug("Settings not set")
+            return
+
+        isFullScreen = bool(window.windowState() & qt.Qt.WindowFullScreen)
+        if isFullScreen:
+            # show in normal to catch the normal geometry
+            window.showNormal()
+
+        settings.beginGroup(groupName)
+        settings.setValue("size", window.size())
+        settings.setValue("pos", window.pos())
+        settings.setValue("full-screen", isFullScreen)
+        settings.endGroup()
+
+        if isFullScreen:
+            window.showFullScreen()
+
+    def setParent(self, parent):
+        self.__parent = weakref.ref(parent)
+
+    def parent(self):
+        if self.__parent is None:
+            return None
+        return self.__parent()
+
+    def createFileDialog(self, parent, previousFile=None):
+        """Create a file dialog configured with a default path.
+
+        :rtype: qt.QFileDialog
+        """
+        dialog = qt.QFileDialog(parent)
+        dialog.finished.connect(functools.partial(self.__saveDialogState, dialog))
+        if self.__dialogState is None:
+            currentDirectory = os.getcwd()
+            dialog.setDirectory(currentDirectory)
+        else:
+            dialog.restoreState(self.__dialogState)
+
+        if previousFile is not None:
+            if os.path.exists(previousFile):
+                if os.path.isdir(previousFile):
+                    directory = previousFile
+                else:
+                    directory = os.path.dirname(previousFile)
+                dialog.setDirectory(directory)
+
+        return dialog
+
+    def __saveDialogState(self, dialog):
+        self.__dialogState = dialog.saveState()