Merge develop into master

.github/workflows/test.yml

@@ -0,0 +1,29 @@
+name: Test DefDAP
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install --upgrade pytest
+        python -m pip install .[testing]
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+
+    - name: Test with pytest
+      run: |
+        pytest

.gitignore

@@ -33,3 +33,6 @@ DefDAP.egg-info/
 
 # coverage
 .coverage
+
+# vscode
+.vscode

.readthedocs.yml

@@ -10,4 +10,4 @@ python:
     - method: pip
       path: .
       extra_requirements:
-        - docs
+        - docs

CHANGELOG.md

@@ -1,12 +1,46 @@
 # Change Log
 
+
 ## Current
 
 ### Added
+- Each grain is assigned a phase and slip systems are automatically loaded 
+  for a given phase based on crystal structure. 
+  - This means that unit cells and slip traces plot correctly for grains
+  in a multi-phase EBSD map
+- Add slip system file for FCC but in same order as DAMASK
+- Use example_notebook to generate a 'How To Use' page in the documentation
+- Add reader for EDAX .ang EBSD files, pyvale .csv files and openPIV-XL .npx files
+- Added a `plot_map` function for grains
+- Added more testing
 
 ### Changed
+- All functions and arguments are now in snake_case instead of CamelCase
+- Cropping and masking are now performed upon access to data
+- Changed function names from CamelCase to snake_case
+- Overhaul of data storage in the Map classes
+- RDR calculation `calcRDR` in grain inspector is faster and more robust
+- Improve formatting of grain inspector and RDR plot window
+- Refactor boundary lines calculations
+- Use GitHub actions to run `pytest` on commit push or pull request
+
+### Fixed
+- Fix bug in grain inspector (`None` passed to `corrAngle` inadvertently)
+- Fix EBSD grain linker
+- Remove `IPython` and `jupyter` as requirements
+- Bug in IPF traiangle plotting now fixed with options for `up` triangle (like MTEX) and `down` triangle (like OI)
+
+
+## 0.93.5 (20-11-2023)
+
+### Added
+- Add more options for colouring lines
 
 ### Fixed
+- Fix bug with accessing slip systems in grain inspector
+- Replace np.float with python float
+- Remove in_place argument to skimage.morphology.remove_small_objects
+- set_window_title has been moved from figure.canvas to figure.canvas.manager
 
 
 ## 0.93.5 (20-11-2023)
@@ -24,7 +58,7 @@
 ## 0.93.5 (17-01-2023)
 
 ### Added
-- Add equality check for Quat
+- Add equality check for `Quat`
 
 ### Fixed
 - Fix bug in boundary line warping
@@ -59,7 +93,7 @@
 ## 0.93.2 (16-04-2021)
 
 ### Added
-- Reading of Channel project files that contain EDX data
+- Reading of Channel5 project files that contain EDX data
 
 ### Fixed
 - Plotting unit cells
@@ -75,21 +109,21 @@
 
 ### Changed
 - Speed up EBSD map data rotation 
-- Speed up 'warp' grain finding
+- Speed up `warp` grain finding
 - Store band slope and MAD arrays from EBSD
-- Update nCorrToDavis.m script
+- Update `nCorrToDavis.m` script
   - Better description of how to use the function
   - Sub-window size is subset radius * 2, as defined in nCorr
   - Subset spacing is subset spacing, as defined in nCorr
 - Generate phase boundary points and lines at same time as grain boundaries
 - Improve histogram plotting
-  - Options for scatter (as before), step and bar
-  - Options for logx, logy, loglog and linear
+  - Options for scatter (as before), `step` and `bar`
+  - Options for `logx`, `logy`, `loglog` and `linear`
 - Updates to example notebook
 
 ### Fixed 
 - Fixed docstring links
-- Fix bug in 'warp' grain finding algorithm
+- Fix bug in `warp` grain finding algorithm
 
 
 ## 0.93.0 (20-02-2021)
@@ -108,7 +142,7 @@
 - Add misorientation calculation between neighbouring EBSD grains.
 - Add a `BoundarySegment` class to represent a section of grain boundary between 2 grain in an EBSD map. Objects of this class are assigned to edges of the neighbour network and contain all the boundary points between the grains.
 - Add Kuwahara filter for EBSD map noise reduction.
-- Add shape property to maps.
+- Add `shape` property to maps.
 - Read EBSD phases from file.
 - Add classes to represent phases and crystal structures.
 
@@ -125,7 +159,7 @@
 - Change docs over to readthedocs.
 - Move version number to own file.
 - Update neighbour network to use grains as nodes.
-- Store grainID in grain objects.
+- Store `grainID` in grain objects.
 - Split plotGrainDataMap into separate array construction and plotting function.
 - Update neighbour network construction to use new EBSD boundary definition.
 - Update flood fill algorithm for grain finding in a EBSD map.

README.md

@@ -17,7 +17,7 @@
 
 ## How to install
 - DefDAP can be installed from PyPI using the command `pip install defdap`
-- If you use conda as your package manager (https://www.anaconda.com/), the prerequisite packages that are available from anaconda can be installed using the command `conda install scipy numpy matplotlib scikit-image pandas networkx jupyter ipython` (Anaconda3-2020.02 has been tested)
+- If you use conda as your package manager (https://www.anaconda.com/), the prerequisite packages that are available from anaconda can be installed using the command `conda install scipy numpy matplotlib scikit-image pandas networkx` (Anaconda3-2020.02 has been tested)
 - For more information, see the [documentation](https://defdap.readthedocs.io/en/latest/installation.html)
 
 ## How to use
@@ -43,8 +43,6 @@ The software uses the following open source packages:
 - [pandas](http://pandas.pydata.org)
 - [peakutils](https://peakutils.readthedocs.io/en/latest/)
 - [matplotlib_scalebar](https://pypi.org/project/matplotlib-scalebar/)
-- [IPython](https://ipython.org/)
-- [jupyter](https://jupyter.org/)
 
 ## License
 [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0)

defdap/__init__.py

@@ -1,3 +1,5 @@
+from defdap.experiment import Experiment
+
 defaults = {
     # Convention to use when attaching an orthonormal frame to a crystal
     # structure. 'hkl' or 'tsl'
@@ -14,6 +16,10 @@
     'slip_system_file': {
         'FCC': 'cubic_fcc',
         'BCC': 'cubic_bcc',
-        'HCP': 'hexagonal_noca',
+        'HCP': 'hexagonal_withca',
     },
+    # up or down
+    'ipf_triangle_convention': 'up'
 }
+
+anonymous_experiment = Experiment()

defdap/_accelerated.py

@@ -0,0 +1,163 @@
+# Copyright 2025 Mechanics of Microstructures Group
+#    at The University of Manchester
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from numba import njit
+import numpy as np
+
+
+@njit
+def find_first(arr):
+    for i in range(len(arr)):
+        if arr[i]:
+            return i
+
+
+@njit
+def flood_fill(seed, index, points_remaining, grains, boundary_x, boundary_y,
+               added_coords):
+    """Flood fill algorithm that uses the x and y boundary arrays to
+    fill a connected area around the seed point. The points are inserted
+    into a grain object and the grain map array is updated.
+
+    Parameters
+    ----------
+    seed : tuple of 2 int
+        Seed point x for flood fill
+    index : int
+        Value to fill in grain map
+    points_remaining : numpy.ndarray
+        Boolean map of the points that have not been assigned a grain yet
+
+    Returns
+    -------
+    grain : defdap.ebsd.Grain
+        New grain object with points added
+    """
+    x, y = seed
+    grains[y, x] = index
+    points_remaining[y, x] = False
+    edge = [seed]
+    added_coords[0] = seed
+    npoints = 1
+
+    while edge:
+        x, y = edge.pop()
+        moves = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]
+        # get rid of any that go out of the map area
+        if x <= 0:
+            moves.pop(1)
+        elif x > grains.shape[1] - 2:
+            moves.pop(0)
+        if y <= 0:
+            moves.pop(-1)
+        elif y > grains.shape[0] - 2:
+            moves.pop(-2)
+
+        for (s, t) in moves:
+            if grains[t, s] > 0:
+                continue
+
+            add_point = False
+
+            if t == y:
+                # moving horizontally
+                if s > x:
+                    # moving right
+                    add_point = not boundary_x[y, x]
+                else:
+                    # moving left
+                    add_point = not boundary_x[t, s]
+            else:
+                # moving vertically
+                if t > y:
+                    # moving down
+                    add_point = not boundary_y[y, x]
+                else:
+                    # moving up
+                    add_point = not boundary_y[t, s]
+
+            if add_point:
+                added_coords[npoints] = s, t
+                grains[t, s] = index
+                points_remaining[t, s] = False
+                npoints += 1
+                edge.append((s, t))
+
+    return added_coords[:npoints]
+
+
+@njit
+def flood_fill_dic(seed, index, points_remaining, grains, added_coords):
+    """Flood fill algorithm that uses the combined x and y boundary array
+    to fill a connected area around the seed point. The points are returned and
+    the grain map array is updated.
+
+    Parameters
+    ----------
+    seed : tuple of 2 int
+        Seed point x for flood fill
+    index : int
+        Value to fill in grain map
+    points_remaining : numpy.ndarray
+        Boolean map of the points remaining to assign a grain yet
+    grains : numpy.ndarray
+    added_coords : numpy.ndarray
+        Buffer for points in the grain
+
+    Returns
+    -------
+    numpy.ndarray
+        Flooded points (n, 2)
+
+    """
+    # add first point to the grain
+    x, y = seed
+    grains[y, x] = index
+    points_remaining[y, x] = False
+    edge = [seed]
+    added_coords[0] = seed
+    npoints = 1
+
+    while edge:
+        x, y = edge.pop()
+
+        moves = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]
+        # get rid of any that go out of the map area
+        if x <= 0:
+            moves.pop(1)
+        elif x >= grains.shape[1] - 1:
+            moves.pop(0)
+        if y <= 0:
+            moves.pop(-1)
+        elif y >= grains.shape[0] - 1:
+            moves.pop(-2)
+
+        for (s, t) in moves:
+            add_point = False
+
+            if grains[t, s] == 0:
+                add_point = True
+                edge.append((s, t))
+
+            elif grains[t, s] == -1 and (s > x or t > y):
+                add_point = True
+
+            if add_point:
+                added_coords[npoints] = (s, t)
+                grains[t, s] = index
+                points_remaining[t, s] = False
+                npoints += 1
+
+    return added_coords[:npoints]

defdap/_version.py

@@ -1 +1 @@
-__version__ = '0.93.6'
+__version__ = '0.93.6dev'