---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Input In [13], in <cell line: 2>()
      1 pc0 = (0.4, 0.2, 0.5)
----> 2 pc = pcopt.optimize(s.data[tuple(idx_2d)].reshape(-1, *sig_shape), indexer, pc0, batch=True)
      3 print(pc)

File ~/kode/pyebsdindex/pyebsdindex/pcopt.py:114, in optimize(pats, indexer, PC0, batch)
    112     PCoutRet = np.zeros((npoints, 3))
    113     for i in range(npoints):
--> 114         PCopt = opt.minimize(optfunction, PC0, args=(indexer, banddat[i, :, :]), method='Nelder-Mead')
    115         PCoutRet[i, :] = PCopt['x']
    117 if emsoftflag == True: # return original state for indexer

IndexError: too many indices for array: array is 2-dimensional, but 3 were indexed

from diffsims.crystallography import ReciprocalLatticeVector
from orix.crystal_map import Phase

phase = Phase.from_cif("pi_al8femg3si6.cif")

ref = ReciprocalLatticeVector.from_min_dspacing(phase, 1)
ref.calculate_structure_factor()  # Parametrizations from Lobato and van Dyck (2014) or International Tables for Crystallography
F = abs(ref.structure_factor)
ref2 = ref[F > 0.48 * F.max()]

>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from pyebsdindex import ebsd_index, pcopt
>>> pattern = plt.imread("/home/hakon/al_sim_20kv.png")
>>> plt.figure()
>>> plt.imshow(pattern, cmap="gray")
>>> indexer = ebsd_index.EBSDIndexer(vendor="EDAX", patDim=pattern.shape)
>>> pc = pcopt.optimize(pattern.reshape((1,) + pattern.shape), indexer, PC0=[0.4, 0.6, 0.5])
[Errno 2] Fila eller mappa finnes ikke: '/home/hakon/miniconda3/envs/kp-rel/lib/python3.9/site-packages/pyebsdindex/opencl/clkernels.cl'
'NoneType' object has no attribute 'radonSum'
>>> print(pc)
0.39558783 0.60637312 0.50082604]

>>> import kikuchipy as kp
>>> from pyebsdindex import ebsd_index
>>> detector = kp.detectors.EBSDDetector(
...     shape=(512, 622),
...     pc=(0.48, 0.548, 0.508),
...     convention="oxford",
...     sample_tilt=70
... )
>>> indexer = ebsd_index.EBSDIndexer(
...     phaselist=["FCC"],
...     vendor="EDAX",
...     PC=detector.pc_tsl(),
...     sampleTilt=detector.sample_tilt,
...     patDim=detector.shape,
... )
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [66], in <module>
----> 1 indexer = ebsd_index.EBSDIndexer(
      2     phaselist=["FCC"],
      3     vendor="EDAX",
      4     PC=detector.pc_tsl().squeeze(),
      5     sampleTilt=detector.sample_tilt,
      6     camElev=0,
      7     patDim=detector.shape,
      8 )

File ~/kode/pyebsdindex/pyebsdindex/ebsd_index.py:476, in EBSDIndexer.__init__(self, filename, phaselist, vendor, PC, sampleTilt, camElev, bandDetectPlan, nRho, nTheta, tSigma, rSigma, rhoMaskFrac, nBands, patDim)
    474 else:
    475   if patDim is not None:
--> 476     self.bandDetectPlan.band_detect_setup(patDim=patDim)
    478 self.dataTemplate = np.dtype([('quat',np.float32,(4)),('iq',np.float32), \
    479                               ('pq',np.float32),('cm',np.float32),('phase',np.int32), \
    480                               ('fit',np.float32),('nmatch',np.int32),('matchattempts',np.int32,(2)), ('totvotes', np.int32)])

File ~/kode/pyebsdindex/pyebsdindex/band_detect.py:128, in BandDetect.band_detect_setup(self, patterns, patDim, nTheta, nRho, tSigma, rSigma, rhoMaskFrac, nBands)
    126 self.rhoMax = 0.5 * np.float32(self.patDim.min())
    127 self.dRho = self.rhoMax/np.float32(self.nRho)
--> 128 self.radonPlan = radon_fast.Radon(imageDim=self.patDim, nTheta=self.nTheta, nRho=self.nRho, rhoMax=self.rhoMax)
    129 temp = np.ones(self.patDim[-2:], dtype=np.float32)
    130 back = self.radonPlan.radon_faster(temp,fixArtifacts=True)

File ~/kode/pyebsdindex/pyebsdindex/radon_fast.py:58, in Radon.__init__(self, image, imageDim, nTheta, nRho, rhoMax)
     56 else:
     57   self.imDim = np.asarray(imageDim[-2:])
---> 58 self.radon_plan_setup(imageDim=self.imDim, nTheta=self.nTheta, nRho=self.nRho, rhoMax=self.rhoMax)

File ~/kode/pyebsdindex/pyebsdindex/radon_fast.py:106, in Radon.radon_plan_setup(self, image, imageDim, nTheta, nRho, rhoMax)
    104   #indx_y = np.clip(indx_y, 0, self.imDim[1])
    105   indx1D = np.clip(m+self.imDim[0]*indx_y, 0, outofbounds)
--> 106   self.indexPlan[:,i, :] = indx1D
    107 else:
    108   b1 /= cTheta[i]

ValueError: could not broadcast input array from shape (90,512) into shape (90,622)

import os

from diffpy.structure import Lattice, Structure
from diffsims.crystallography import ReciprocalLatticeVector
import numpy as np
from orix import io, plot
from orix.crystal_map import CrystalMap, Phase, PhaseList
from orix.quaternion import Rotation

import kikuchipy as kp
from pyebsdindex import ebsd_index


# Load data and set some shapes
dir_data = "/home/hakon/phd/data/oxford"
fname = "Al_SLBM 10kV_8x8_small"
s = kp.load(os.path.join(dir_data, fname + ".h5oina"))
nav_shape = s.axes_manager.navigation_shape[::-1]
sig_shape = s.axes_manager.signal_shape[::-1]

# Create indexer and perform Hough indexing
indexer = ebsd_index.EBSDIndexer(
    vendor="KIKUCHIPY",
    sampleTilt=s.detector.sample_tilt,
    camElev=s.detector.tilt,
    patDim=sig_shape
)
data, *_ = indexer.index_pats(
    s.data.reshape((-1,) + sig_shape), PC=s.detector.pc.reshape((-1, 3))
)

# Store results in a crystal map and save in an .ang file
rot = Rotation(data[-1]["quat"])
phase = Phase(
    "al",
    space_group=225,
    structure=Structure(lattice=Lattice(0.404, 0.404, 0.404, 90, 90, 90))
)
y, x = np.indices(nav_shape)
xmap = CrystalMap(
    rotations=rot,
    x=x.flatten() * s.axes_manager["x"].scale,
    y=y.flatten() * s.axes_manager["y"].scale,
    phase_list=PhaseList(phase),
    prop=dict(
        pq=data[-1]["pq"],  # Pattern quality
        cm=data[-1]["cm"],  # Confidence metric
        fit=data[-1]["fit"],  # Pattern fit
        nmatch=data[-1]["nmatch"],  # Number of detected bands matched
    ),
)
io.save(os.path.join(dir_data, fname + "_hi.ang"), xmap)

# Inspect results using geometrical simulations
ref = ReciprocalLatticeVector(
    phase=phase, hkl=[[1, 1, 1], [2, 0, 0], [2, 2, 0], [3, 1, 1]]
)
ref = ref.symmetrise().unique()
simulator = kp.simulations.KikuchiPatternSimulator(ref)
sim = simulator.on_detector(s.detector, xmap.rotations.reshape(*xmap.shape))

# Create IPF-Z map
ckey = plot.IPFColorKeyTSL(phase.point_group)
rgbz = ckey.orientation2color(xmap.orientations).reshape(nav_shape + (3,))
map_rgbz = kp.draw.get_rgb_navigator(rgbz)

# Navigate patterns in IPF-Z map with geometrical simulations
s.plot(navigator=map_rgbz)
s.add_marker(sim.as_markers())

>>> from pyebsdindex import ebsd_index, pcopt
---------------------------------------------------------------------------
TypingError                               Traceback (most recent call last)
Cell In[4], line 1
----> 1 from pyebsdindex import pcopt, ebsd_index

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/pyebsdindex/ebsd_index.py:26
     23 """Setup and handling of Hough indexing runs of EBSD patterns."""
     25 from pyebsdindex import _ray_installed
---> 26 from pyebsdindex._ebsd_index_single import EBSDIndexer, index_pats
     28 if _ray_installed:
     29     from pyebsdindex._ebsd_index_parallel import index_pats_distributed, IndexerRay

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/pyebsdindex/_ebsd_index_single.py:32
     29 import numpy as np
     30 import h5py
---> 32 from pyebsdindex import (
     33     band_vote,
     34     ebsd_pattern,
     35     rotlib,
     36     tripletlib,
     37     _pyopencl_installed,
     38 )
     40 if _pyopencl_installed:
     41     from pyebsdindex.opencl import band_detect_cl as band_detect

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/pyebsdindex/band_vote.py:32
     29 import numba
     30 import numpy as np
---> 32 from pyebsdindex import rotlib
     35 RADEG = 180.0/np.pi
     37 tempdir = PurePath("/tmp" if platform.system() == "Darwin" else tempfile.gettempdir())

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/pyebsdindex/rotlib.py:1346
   1341     xyzba[2] = sXYZ[0]
   1342   return xyzba
   1345 @numba.jit(['f8[:](f8[:])','f8[:](f4[:])'], nopython=True,fastmath=nbFastmath, cache=nbcache)
-> 1346 def lambert3DBallToCube(xyz):
   1347   LPR1 = np.float(1.33067003949147) # (3pi/4)**(1/3)
   1348   LPpref = np.float(1.38197659788534) # sqrt(6/pi)

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/decorators.py:241, in _jit.<locals>.wrapper(func)
    239     with typeinfer.register_dispatcher(disp):
    240         for sig in sigs:
--> 241             disp.compile(sig)
    242         disp.disable_compile()
    243 return disp

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/dispatcher.py:965, in Dispatcher.compile(self, sig)
    963 with ev.trigger_event("numba:compile", data=ev_details):
    964     try:
--> 965         cres = self._compiler.compile(args, return_type)
    966     except errors.ForceLiteralArg as e:
    967         def folded(args, kws):

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/dispatcher.py:129, in _FunctionCompiler.compile(self, args, return_type)
    127     return retval
    128 else:
--> 129     raise retval

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/dispatcher.py:139, in _FunctionCompiler._compile_cached(self, args, return_type)
    136     pass
    138 try:
--> 139     retval = self._compile_core(args, return_type)
    140 except errors.TypingError as e:
    141     self._failed_cache[key] = e

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/dispatcher.py:152, in _FunctionCompiler._compile_core(self, args, return_type)
    149 flags = self._customize_flags(flags)
    151 impl = self._get_implementation(args, {})
--> 152 cres = compiler.compile_extra(self.targetdescr.typing_context,
    153                               self.targetdescr.target_context,
    154                               impl,
    155                               args=args, return_type=return_type,
    156                               flags=flags, locals=self.locals,
    157                               pipeline_class=self.pipeline_class)
    158 # Check typing error if object mode is used
    159 if cres.typing_error is not None and not flags.enable_pyobject:

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler.py:742, in compile_extra(typingctx, targetctx, func, args, return_type, flags, locals, library, pipeline_class)
    718 """Compiler entry point
    719 
    720 Parameter
   (...)
    738     compiler pipeline
    739 """
    740 pipeline = pipeline_class(typingctx, targetctx, library,
    741                           args, return_type, flags, locals)
--> 742 return pipeline.compile_extra(func)

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler.py:460, in CompilerBase.compile_extra(self, func)
    458 self.state.lifted = ()
    459 self.state.lifted_from = None
--> 460 return self._compile_bytecode()

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler.py:528, in CompilerBase._compile_bytecode(self)
    524 """
    525 Populate and run pipeline for bytecode input
    526 """
    527 assert self.state.func_ir is None
--> 528 return self._compile_core()

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler.py:507, in CompilerBase._compile_core(self)
    505         self.state.status.fail_reason = e
    506         if is_final_pipeline:
--> 507             raise e
    508 else:
    509     raise CompilerError("All available pipelines exhausted")

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler.py:494, in CompilerBase._compile_core(self)
    492 res = None
    493 try:
--> 494     pm.run(self.state)
    495     if self.state.cr is not None:
    496         break

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler_machinery.py:368, in PassManager.run(self, state)
    365 msg = "Failed in %s mode pipeline (step: %s)" % \
    366     (self.pipeline_name, pass_desc)
    367 patched_exception = self._patch_error(msg, e)
--> 368 raise patched_exception

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler_machinery.py:356, in PassManager.run(self, state)
    354 pass_inst = _pass_registry.get(pss).pass_inst
    355 if isinstance(pass_inst, CompilerPass):
--> 356     self._runPass(idx, pass_inst, state)
    357 else:
    358     raise BaseException("Legacy pass in use")

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler_lock.py:35, in _CompilerLock.__call__.<locals>._acquire_compile_lock(*args, **kwargs)
     32 @functools.wraps(func)
     33 def _acquire_compile_lock(*args, **kwargs):
     34     with self:
---> 35         return func(*args, **kwargs)

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler_machinery.py:311, in PassManager._runPass(self, index, pss, internal_state)
    309     mutated |= check(pss.run_initialization, internal_state)
    310 with SimpleTimer() as pass_time:
--> 311     mutated |= check(pss.run_pass, internal_state)
    312 with SimpleTimer() as finalize_time:
    313     mutated |= check(pss.run_finalizer, internal_state)

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/compiler_machinery.py:273, in PassManager._runPass.<locals>.check(func, compiler_state)
    272 def check(func, compiler_state):
--> 273     mangled = func(compiler_state)
    274     if mangled not in (True, False):
    275         msg = ("CompilerPass implementations should return True/False. "
    276                "CompilerPass with name '%s' did not.")

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/typed_passes.py:110, in BaseTypeInference.run_pass(self, state)
    104 """
    105 Type inference and legalization
    106 """
    107 with fallback_context(state, 'Function "%s" failed type inference'
    108                       % (state.func_id.func_name,)):
    109     # Type inference
--> 110     typemap, return_type, calltypes, errs = type_inference_stage(
    111         state.typingctx,
    112         state.targetctx,
    113         state.func_ir,
    114         state.args,
    115         state.return_type,
    116         state.locals,
    117         raise_errors=self._raise_errors)
    118     state.typemap = typemap
    119     # save errors in case of partial typing

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/typed_passes.py:88, in type_inference_stage(typingctx, targetctx, interp, args, return_type, locals, raise_errors)
     86     infer.build_constraint()
     87     # return errors in case of partial typing
---> 88     errs = infer.propagate(raise_errors=raise_errors)
     89     typemap, restype, calltypes = infer.unify(raise_errors=raise_errors)
     91 # Output all Numba warnings

File ~/miniconda3/envs/kp-dev/lib/python3.10/site-packages/numba/core/typeinfer.py:1086, in TypeInferer.propagate(self, raise_errors)
   1083 force_lit_args = [e for e in errors
   1084                   if isinstance(e, ForceLiteralArg)]
   1085 if not force_lit_args:
-> 1086     raise errors[0]
   1087 else:
   1088     raise reduce(operator.or_, force_lit_args)

TypingError: Failed in nopython mode pipeline (step: nopython frontend)
Internal error at resolving type of attribute "float" of "$2load_global.0".
module 'numpy' has no attribute 'float'.
`np.float` was a deprecated alias for the builtin `float`. To avoid this error in existing code, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.
The aliases was originally deprecated in NumPy 1.20; for more details and guidance see the original release note at:
    https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
During: typing of get attribute at /home/hakon/miniconda3/envs/kp-dev/lib/python3.10/site-packages/pyebsdindex/rotlib.py (1347)
Enable logging at debug level for details.

File "../../../../miniconda3/envs/kp-dev/lib/python3.10/site-packages/pyebsdindex/rotlib.py", line 1347:
def lambert3DBallToCube(xyz):
  LPR1 = np.float(1.33067003949147) # (3pi/4)**(1/3)
  ^