# -*- coding: utf-8 -*-
import numpy

from .GraphicsObject import GraphicsObject
from .. import debug as debug
from .. import functions as fn
from .. import getConfigOption
from ..Point import Point
from ..Qt import QtGui, QtCore
from ..util.cupy_helper import getCupy

import warnings
from collections.abc import Callable

translate = QtCore.QCoreApplication.translate

__all__ = ['ImageItem']


class ImageItem(GraphicsObject):
    """
    **Bases:** :class:`GraphicsObject <pyqtgraph.GraphicsObject>`
    """
    # Overall description of ImageItem (including examples) moved to documentation text
    sigImageChanged = QtCore.Signal()
    sigRemoveRequested = QtCore.Signal(object)  # self; emitted when 'remove' is selected from context menu

    def __init__(self, image=None, **kargs):
        """
        See :func:`~pyqtgraph.ImageItem.setOpts` for further keyword arguments and 
        and :func:`~pyqtgraph.ImageItem.setImage` for information on supported formats.

        Parameters
        ----------
            image: array 
                Image data
        """
        GraphicsObject.__init__(self)
        self.menu = None
        self.image = None   ## original image data
        self.qimage = None  ## rendered image for display

        self.paintMode = None
        self.levels = None  ## [min, max] or [[redMin, redMax], ...]
        self.lut = None
        self.autoDownsample = False
        self._lastDownsample = (1, 1)
        self._processingBuffer = None
        self._displayBuffer = None
        self._renderRequired = True
        self._unrenderable = False
        self._xp = None  # either numpy or cupy, to match the image data
        self._defferedLevels = None

        self.axisOrder = getConfigOption('imageAxisOrder')
        self._dataTransform = self._inverseDataTransform = None
        self._update_data_transforms( self.axisOrder ) # install initial transforms

        # In some cases, we use a modified lookup table to handle both rescaling
        # and LUT more efficiently
        self._effectiveLut = None

        self.drawKernel = None
        self.border = None
        self.removable = False

        if image is not None:
            self.setImage(image, **kargs)
        else:
            self.setOpts(**kargs)

    def setCompositionMode(self, mode):
        """
        Change the composition mode of the item. This is useful when overlaying
        multiple items.
        
        Parameters
        ----------
        mode : ``QtGui.QPainter.CompositionMode``
            Composition of the item, often used when overlaying items.  Common
            options include:

            ``QPainter.CompositionMode.CompositionMode_SourceOver`` (Default)
            Image replaces the background if it is opaque. Otherwise, it uses
            the alpha channel to blend the image with the background.

            ``QPainter.CompositionMode.CompositionMode_Overlay`` Image color is
            mixed with the background color to reflect the lightness or
            darkness of the background

            ``QPainter.CompositionMode.CompositionMode_Plus`` Both the alpha
            and color of the image and background pixels are added together.

            ``QPainter.CompositionMode.CompositionMode_Plus`` The output is the
            image color multiplied by the background.

            See ``QPainter::CompositionMode`` in the Qt Documentation for more
            options and details
        """
        self.paintMode = mode
        self.update()

    def setBorder(self, b):
        """
        Defines the border drawn around the image. Accepts all arguments supported by 
        :func:`~pyqtgraph.functions.mkPen`.
        """
        self.border = fn.mkPen(b)
        self.update()

    def width(self):
        if self.image is None:
            return None
        axis = 0 if self.axisOrder == 'col-major' else 1
        return self.image.shape[axis]

    def height(self):
        if self.image is None:
            return None
        axis = 1 if self.axisOrder == 'col-major' else 0
        return self.image.shape[axis]

    def channels(self):
        if self.image is None:
            return None
        return self.image.shape[2] if self.image.ndim == 3 else 1

    def boundingRect(self):
        if self.image is None:
            return QtCore.QRectF(0., 0., 0., 0.)
        return QtCore.QRectF(0., 0., float(self.width()), float(self.height()))

    def setLevels(self, levels, update=True):
        """
        Sets image scaling levels. 
        See :func:`makeARGB <pyqtgraph.makeARGB>` for more details on how levels are applied.
        
        Parameters
        ----------
            levels: list_like
                - [`blackLevel`, `whiteLevel`] 
                  sets black and white levels for monochrome data and can be used with a lookup table.
                - [[`minR`, `maxR`], [`minG`, `maxG`], [`minB`, `maxB`]] 
                  sets individual scaling for RGB values. Not compatible with lookup tables.
            update: bool, optional
                Controls if image immediately updates to reflect the new levels.
        """
        if self._xp is None:
            self.levels = levels
            self._defferedLevels = levels
            return
        if levels is not None:
            levels = self._xp.asarray(levels)
        self.levels = levels
        self._effectiveLut = None
        if update:
            self.updateImage()

    def getLevels(self):
        """
        Returns the list representing the current level settings. See :func:`~setLevels`.
        When ``autoLevels`` is active, the format is [`blackLevel`, `whiteLevel`].
        """
        return self.levels

    def setLookupTable(self, lut, update=True):
        """
        Sets lookup table `lut` to use for false color display of a monochrome image. See :func:`makeARGB <pyqtgraph.makeARGB>` for more 
        information on how this is used. Optionally, `lut` can be a callable that accepts the current image as an
        argument and returns the lookup table to use.

        Ordinarily, this table is supplied by a :class:`~pyqtgraph.HistogramLUTItem`,
        :class:`~pyqtgraph.GradientEditorItem` or :class:`~pyqtgraph.ColorBarItem`.
        
        Setting `update` to False avoids an immediate image update.
        """
        if lut is not self.lut:
            if self._xp is not None:
                lut = self._ensure_proper_substrate(lut, self._xp)
            self.lut = lut
            self._effectiveLut = None
            if update:
                self.updateImage()

    @staticmethod
    def _ensure_proper_substrate(data, substrate):
        if data is None or isinstance(data, Callable) or isinstance(data, substrate.ndarray):
            return data
        cupy = getCupy()
        if substrate == cupy and not isinstance(data, cupy.ndarray):
            data = cupy.asarray(data)
        elif substrate == numpy:
            if cupy is not None and isinstance(data, cupy.ndarray):
                data = data.get()
            else:
                data = numpy.asarray(data)
        return data

    def setAutoDownsample(self, active=True):
        """
        Controls automatic downsampling for this ImageItem.

        If active is `True`, the image is automatically downsampled to match the
        screen resolution. This improves performance for large images and
        reduces aliasing. If autoDownsample is not specified, then ImageItem will
        choose whether to downsample the image based on its size.
        `False` disables automatic downsampling.
        """
        self.autoDownsample = active
        self._renderRequired = True
        self.update()

    def setOpts(self, update=True, **kargs):
        """
        Sets display and processing options for this ImageItem. :func:`~pyqtgraph.ImageItem.__init__` and 
        :func:`~pyqtgraph.ImageItem.setImage` support all keyword arguments listed here.

        Parameters
        ----------
            autoDownsample: bool
                See :func:`~pyqtgraph.ImageItem.setAutoDownsample`.
            axisOrder: str
                | `'col-major'`: The shape of the array represents (width, height) of the image. This is the default.
                | `'row-major'`: The shape of the array represents (height, width).
            border: bool
                Sets a pen to draw to draw an image border. See :func:`~pyqtgraph.ImageItem.setBorder`.
            compositionMode:
                See :func:`~pyqtgraph.ImageItem.setCompositionMode`
            lut: array
                Sets a color lookup table to use when displaying the image.
                See :func:`~pyqtgraph.ImageItem.setLookupTable`.
            levels: list_like, usally [`min`, `max`]
                Sets minimum and maximum values to use when rescaling the image data. By default, these will be set to 
                the estimated minimum and maximum values in the image. If the image array has dtype uint8, no rescaling
                is necessary. See :func:`~pyqtgraph.ImageItem.setLevels`.
            opacity: float, 0.0-1.0
                Overall opacity for an RGB image.
            rect: QRectF, QRect or array_like of floats (`x`,`y`,`w`,`h`)
                Displays the current image within the specified rectangle in plot coordinates.
                See :func:`~pyqtgraph.ImageItem.setRect`.
            update : bool, optional
                Controls if image immediately updates to reflect the new options.
        """
        if 'axisOrder' in kargs:
            val = kargs['axisOrder']            
            if val not in ('row-major', 'col-major'):
                raise ValueError("axisOrder must be either 'row-major' or 'col-major'")
            self.axisOrder = val
            self._update_data_transforms(self.axisOrder) # update cached transforms 
        if 'lut' in kargs:
            self.setLookupTable(kargs['lut'], update=update)
        if 'levels' in kargs:
            self.setLevels(kargs['levels'], update=update)
        #if 'clipLevel' in kargs:
            #self.setClipLevel(kargs['clipLevel'])
        if 'opacity' in kargs:
            self.setOpacity(kargs['opacity'])
        if 'compositionMode' in kargs:
            self.setCompositionMode(kargs['compositionMode'])
        if 'border' in kargs:
            self.setBorder(kargs['border'])
        if 'removable' in kargs:
            self.removable = kargs['removable']
            self.menu = None
        if 'autoDownsample' in kargs:
            self.setAutoDownsample(kargs['autoDownsample'])
        if 'rect' in kargs:
            self.setRect(kargs['rect'])
        if update:
            self.update()

    def setRect(self, *args):
        """
        setRect(rect) or setRect(x,y,w,h)
        
        Sets translation and scaling of this ImageItem to display the current image within the rectangle given
        as ``QtCore.QRect`` or ``QtCore.QRectF`` `rect`, or described by parameters `x, y, w, h`, defining starting 
        position, width and height.

        This method cannot be used before an image is assigned.
        See the :ref:`examples <ImageItem_examples>` for how to manually set transformations.
        """
        if len(args) == 0:
            self.resetTransform() # reset scaling and rotation when called without argument
            return
        if isinstance(args[0], (QtCore.QRectF, QtCore.QRect)):
            rect = args[0] # use QRectF or QRect directly
        else:
            if hasattr(args[0],'__len__'):
                args = args[0] # promote tuple or list of values
            rect = QtCore.QRectF( *args ) # QRectF(x,y,w,h), but also accepts other initializers
        tr = QtGui.QTransform()
        tr.translate(rect.left(), rect.top())
        tr.scale(rect.width() / self.width(), rect.height() / self.height())
        self.setTransform(tr)

    def clear(self):
        """
        Clears the assigned image.
        """
        self.image = None
        self.prepareGeometryChange()
        self.informViewBoundsChanged()
        self.update()

    def _buildQImageBuffer(self, shape):
        self._displayBuffer = numpy.empty(shape[:2] + (4,), dtype=numpy.ubyte)
        if self._xp == getCupy():
            self._processingBuffer = self._xp.empty(shape[:2] + (4,), dtype=self._xp.ubyte)
        else:
            self._processingBuffer = self._displayBuffer
        self.qimage = None

    def setImage(self, image=None, autoLevels=None, **kargs):
        """
        Updates the image displayed by this ImageItem. For more information on how the image
        is processed before displaying, see :func:`~pyqtgraph.makeARGB>`.
        
        For backward compatibility, image data is assumed to be in column-major order (column, row) by default.
        However, most data is stored in row-major order (row, column). It can either be transposed before assignment::

            imageitem.setImage(imagedata.T)
        
        or the interpretation of the data can be changed locally through the ``axisOrder`` keyword or by changing the 
        `imageAxisOrder` :ref:`global configuration option <apiref_config>`.
        
        All keywords supported by :func:`~pyqtgraph.ImageItem.setOpts` are also allowed here.

        Parameters
        ----------
        image: array
            Image data given as NumPy array with an integer or floating
            point dtype of any bit depth. A 2-dimensional array describes single-valued (monochromatic) data.
            A 3-dimensional array is used to give individual color components. The third dimension must
            be of length 3 (RGB) or 4 (RGBA).

        rect: QRectF, QRect or list_like of floats (`x, y, w, h`), optional
            If given, sets translation and scaling to display the image within the specified rectangle. See 
            :func:`~pyqtgraph.ImageItem.setRect`.

        autoLevels: bool, optional
            If True, ImageItem will automatically select levels based on the maximum and minimum values encountered 
            in the data. For performance reasons, this search subsamples the images and may miss individual bright or
            or dark points in the data set.
            
            If False, the search will be omitted.

            The default is `False` if a ``levels`` keyword argument is given, and `True` otherwise.
            
        levelSamples: int, default 65536
            When determining minimum and maximum values, ImageItem
            only inspects a subset of pixels no larger than this number.
            Setting this larger than the total number of pixels considers all values.
            
        """
        profile = debug.Profiler()

        gotNewData = False
        if image is None:
            if self.image is None:
                return
        else:
            old_xp = self._xp
            cp = getCupy()
            self._xp = cp.get_array_module(image) if cp else numpy
            gotNewData = True
            processingSubstrateChanged = old_xp != self._xp
            if processingSubstrateChanged:
                self._processingBuffer = None
            shapeChanged = (processingSubstrateChanged or self.image is None or image.shape != self.image.shape)
            image = image.view()
            if self.image is None or image.dtype != self.image.dtype:
                self._effectiveLut = None
            self.image = image
            if self.image.shape[0] > 2**15-1 or self.image.shape[1] > 2**15-1:
                if 'autoDownsample' not in kargs:
                    kargs['autoDownsample'] = True
            if shapeChanged:
                self.prepareGeometryChange()
                self.informViewBoundsChanged()

        profile()

        if autoLevels is None:
            if 'levels' in kargs:
                autoLevels = False
            else:
                autoLevels = True
        if autoLevels:
            level_samples = kargs.pop('levelSamples', 2**16) 
            mn, mx = self.quickMinMax( targetSize=level_samples )
            # mn and mx can still be NaN if the data is all-NaN
            if mn == mx or self._xp.isnan(mn) or self._xp.isnan(mx):
                mn = 0
                mx = 255
            kargs['levels'] = [mn,mx]

        profile()

        self.setOpts(update=False, **kargs)

        profile()

        self._renderRequired = True
        self.update()

        profile()

        if gotNewData:
            self.sigImageChanged.emit()
        if self._defferedLevels is not None:
            levels = self._defferedLevels
            self._defferedLevels = None
            self.setLevels((levels))

    def _update_data_transforms(self, axisOrder='col-major'):
        """ Sets up the transforms needed to map between input array and display """
        self._dataTransform = QtGui.QTransform()
        self._inverseDataTransform = QtGui.QTransform()
        if self.axisOrder == 'row-major': # transpose both
            self._dataTransform.scale(1, -1)
            self._dataTransform.rotate(-90)
            self._inverseDataTransform.scale(1, -1)
            self._inverseDataTransform.rotate(-90)

        
    def dataTransform(self):
        """
        Returns the transform that maps from this image's input array to its
        local coordinate system.

        This transform corrects for the transposition that occurs when image data
        is interpreted in row-major order.
        
        :meta private:
        """
        # Might eventually need to account for downsampling / clipping here
        # transforms are updated in setOpts call.
        return self._dataTransform

    def inverseDataTransform(self):
        """Return the transform that maps from this image's local coordinate
        system to its input array.

        See dataTransform() for more information.

        :meta private:
        """
        # transforms are updated in setOpts call.
        return self._inverseDataTransform

    def mapToData(self, obj):
        return self._inverseDataTransform.map(obj)

    def mapFromData(self, obj):
        return self._dataTransform.map(obj)

    def quickMinMax(self, targetSize=1e6):
        """
        Estimates the min/max values of the image data by subsampling.
        Subsampling is performed at regular strides chosen to evaluate a number of samples
        equal to or less than `targetSize`.
        
        Returns (`min`, `max`).
        """
        data = self.image
        if targetSize < 2: # keep at least two pixels
            targetSize = 2
        while True:
            h, w = data.shape[:2]
            if h * w <= targetSize: break
            if h > w:
                data = data[::2, ::] # downsample first axis
            else:
                data = data[::, ::2] # downsample second axis
        return self._xp.nanmin(data), self._xp.nanmax(data)

    def updateImage(self, *args, **kargs):
        ## used for re-rendering qimage from self.image.

        ## can we make any assumptions here that speed things up?
        ## dtype, range, size are all the same?
        defaults = {
            'autoLevels': False,
        }
        defaults.update(kargs)
        return self.setImage(*args, **defaults)

    def render(self):
        # Convert data to QImage for display.
        self._unrenderable = True
        if self.image is None or self.image.size == 0:
            return

        # Request a lookup table if this image has only one channel
        if self.image.ndim == 2 or self.image.shape[2] == 1:
            self.lut = self._ensure_proper_substrate(self.lut, self._xp)
            if isinstance(self.lut, Callable):
                lut = self._ensure_proper_substrate(self.lut(self.image), self._xp)
            else:
                lut = self.lut
        else:
            lut = None

        if self.autoDownsample:
            xds, yds = self._computeDownsampleFactors()
            if xds is None:
                return

            axes = [1, 0] if self.axisOrder == 'row-major' else [0, 1]
            image = fn.downsample(self.image, xds, axis=axes[0])
            image = fn.downsample(image, yds, axis=axes[1])
            self._lastDownsample = (xds, yds)

            # Check if downsampling reduced the image size to zero due to inf values.
            if image.size == 0:
                return
        else:
            image = self.image

        # Convert single-channel image to 2D array
        if image.ndim == 3 and image.shape[-1] == 1:
            image = image[..., 0]

        # Assume images are in column-major order for backward compatibility
        # (most images are in row-major order)
        if self.axisOrder == 'col-major':
            image = image.swapaxes(0, 1)

        levels = self.levels
        augmented_alpha = False

        if lut is not None and lut.dtype != self._xp.uint8:
            # Both _try_rescale_float() and _try_combine_lut() assume that
            # lut is of type uint8. It is considered a usage error if that
            # is not the case.
            # However, the makeARGB() codepath has previously allowed such
            # a usage to work. Rather than fail outright, we delegate this
            # case to makeARGB().
            warnings.warn(
                "Using non-uint8 LUTs is an undocumented accidental feature and may "
                "be removed at some point in the future. Please open an issue if you "
                "instead believe this to be worthy of protected inclusion in pyqtgraph.",
                DeprecationWarning, stacklevel=2)
        elif image.dtype.kind == 'f':
            image, levels, lut, augmented_alpha = self._try_rescale_float(image, levels, lut)
            # if we succeeded, we will have an uint8 image with levels None.
            # lut if not None will have <= 256 entries

        # if the image data is a small int, then we can combine levels + lut
        # into a single lut for better performance
        elif image.dtype in (self._xp.ubyte, self._xp.uint16):
            image, levels, lut, augmented_alpha = self._try_combine_lut(image, levels, lut)

        qimage = self._try_make_qimage(image, levels, lut, augmented_alpha)

        if qimage is not None:
            self._processingBuffer = None
            self._displayBuffer = None
            self.qimage = qimage
            self._renderRequired = False
            self._unrenderable = False
            return

        if self._processingBuffer is None or self._processingBuffer.shape[:2] != image.shape[:2]:
            self._buildQImageBuffer(image.shape)

        fn.makeARGB(image, lut=lut, levels=levels, output=self._processingBuffer)
        if self._xp == getCupy():
            self._processingBuffer.get(out=self._displayBuffer)
        self.qimage = fn.ndarray_to_qimage(self._displayBuffer, QtGui.QImage.Format.Format_ARGB32)

        self._renderRequired = False
        self._unrenderable = False

    def _try_rescale_float(self, image, levels, lut):
        xp = self._xp
        augmented_alpha = False

        can_handle = False
        while True:
            if levels is None or levels.ndim != 1:
                # float images always need levels
                # can't handle multi-channel levels
                break

            # awkward, but fastest numpy native nan evaluation
            if xp.isnan(image.min()):
                # don't handle images with nans
                # this should be an uncommon case
                break

            can_handle = True
            break

        if not can_handle:
            return image, levels, lut, augmented_alpha

        # Decide on maximum scaled value
        if lut is not None:
            scale = lut.shape[0]
            num_colors = lut.shape[0]
        else:
            scale = 255.
            num_colors = 256
        dtype = xp.min_scalar_type(num_colors-1)

        minVal, maxVal = levels
        if minVal == maxVal:
            maxVal = xp.nextafter(maxVal, 2*maxVal)
        rng = maxVal - minVal
        rng = 1 if rng == 0 else rng

        fn_numba = fn.getNumbaFunctions()
        if xp == numpy and image.flags.c_contiguous and dtype == xp.uint16 and fn_numba is not None:
            lut, augmented_alpha = self._convert_2dlut_to_1dlut(lut)
            image = fn_numba.rescale_and_lookup1d(image, scale/rng, minVal, lut)
            if image.dtype == xp.uint32:
                image = image[..., xp.newaxis].view(xp.uint8)
            return image, None, None, augmented_alpha
        else:
            image = fn.rescaleData(image, scale/rng, offset=minVal, dtype=dtype, clip=(0, num_colors-1))

            levels = None

            if image.dtype == xp.uint16 and image.ndim == 2:
                image, augmented_alpha = self._apply_lut_for_uint16_mono(image, lut)
                lut = None

            # image is now of type uint8
            return image, levels, lut, augmented_alpha

    def _try_combine_lut(self, image, levels, lut):
        augmented_alpha = False
        xp = self._xp

        can_handle = False
        while True:
            if levels is not None and levels.ndim != 1:
                # can't handle multi-channel levels
                break
            if image.dtype == xp.uint16 and levels is None and \
                    image.ndim == 3 and image.shape[2] == 3:
                # uint16 rgb can't be directly displayed, so make it
                # pass through effective lut processing
                levels = [0, 65535]
            if levels is None and lut is None:
                # nothing to combine
                break

            can_handle = True
            break

        if not can_handle:
            return image, levels, lut, augmented_alpha

        # distinguish between lut for levels and colors
        levels_lut = None
        colors_lut = lut
        lut = None

        eflsize = 2**(image.itemsize*8)
        if levels is None:
            info = xp.iinfo(image.dtype)
            minlev, maxlev = info.min, info.max
        else:
            minlev, maxlev = levels
        levdiff = maxlev - minlev
        levdiff = 1 if levdiff == 0 else levdiff  # don't allow division by 0

        if colors_lut is None:
            if image.dtype == xp.ubyte and image.ndim == 2:
                # uint8 mono image
                ind = xp.arange(eflsize)
                levels_lut = fn.rescaleData(ind, scale=255./levdiff,
                                        offset=minlev, dtype=xp.ubyte)
                # image data is not scaled. instead, levels_lut is used
                # as (grayscale) Indexed8 ColorTable to get the same effect.
                # due to the small size of the input to rescaleData(), we
                # do not bother caching the result
                return image, None, levels_lut, augmented_alpha
            else:
                # uint16 mono, uint8 rgb, uint16 rgb
                # rescale image data by computation instead of by memory lookup
                image = fn.rescaleData(image, scale=255./levdiff,
                                    offset=minlev, dtype=xp.ubyte)
                return image, None, colors_lut, augmented_alpha
        else:
            num_colors = colors_lut.shape[0]
            effscale = num_colors / levdiff
            lutdtype = xp.min_scalar_type(num_colors - 1)

            if image.dtype == xp.ubyte or lutdtype != xp.ubyte:
                # combine if either:
                #   1) uint8 mono image
                #   2) colors_lut has more entries than will fit within 8-bits
                if self._effectiveLut is None:
                    ind = xp.arange(eflsize)
                    levels_lut = fn.rescaleData(ind, scale=effscale,
                                    offset=minlev, dtype=lutdtype, clip=(0, num_colors-1))
                    efflut = colors_lut[levels_lut]
                    levels_lut = None
                    colors_lut = None
                    self._effectiveLut = efflut
                efflut = self._effectiveLut

                # apply the effective lut early for the following types:
                if image.dtype == xp.uint16 and image.ndim == 2:
                    image, augmented_alpha = self._apply_lut_for_uint16_mono(image, efflut)
                    efflut = None
                return image, None, efflut, augmented_alpha
            else:
                # uint16 image with colors_lut <= 256 entries
                # don't combine, we will use QImage ColorTable
                image = fn.rescaleData(image, scale=effscale,
                                offset=minlev, dtype=lutdtype, clip=(0, num_colors-1))
                return image, None, colors_lut, augmented_alpha

    def _apply_lut_for_uint16_mono(self, image, lut):
        # Note: compared to makeARGB(), we have already clipped the data to range

        xp = self._xp
        augmented_alpha = False

        # if lut is 1d, then lut[image] is fastest
        # if lut is 2d, then lut.take(image, axis=0) is faster than lut[image]

        if not image.flags.c_contiguous:
            image = lut.take(image, axis=0)

            # if lut had dimensions (N, 1), then our resultant image would
            # have dimensions (h, w, 1)
            if image.ndim == 3 and image.shape[-1] == 1:
                image = image[..., 0]

            return image, augmented_alpha

        # if we are contiguous, we can take a faster codepath where we
        # ensure that the lut is 1d

        lut, augmented_alpha = self._convert_2dlut_to_1dlut(lut)

        fn_numba = fn.getNumbaFunctions()
        if xp == numpy and fn_numba is not None:
            image = fn_numba.numba_take(lut, image)
        else:
            image = lut[image]

        if image.dtype == xp.uint32:
            image = image[..., xp.newaxis].view(xp.uint8)

        return image, augmented_alpha

    def _convert_2dlut_to_1dlut(self, lut):
        # converts:
        #   - uint8 (N, 1) to uint8 (N,)
        #   - uint8 (N, 3) or (N, 4) to uint32 (N,)
        # this allows faster lookup as 1d lookup is faster
        xp = self._xp
        augmented_alpha = False

        if lut.ndim == 1:
            return lut, augmented_alpha

        if lut.shape[1] == 3:   # rgb
            # convert rgb lut to rgba so that it is 32-bits
            lut = xp.column_stack([lut, xp.full(lut.shape[0], 255, dtype=xp.uint8)])
            augmented_alpha = True
        if lut.shape[1] == 4:   # rgba
            lut = lut.view(xp.uint32)
        lut = lut.ravel()

        return lut, augmented_alpha

    def _try_make_qimage(self, image, levels, lut, augmented_alpha):
        xp = self._xp

        ubyte_nolvl = image.dtype == xp.ubyte and levels is None
        is_passthru8 = ubyte_nolvl and lut is None
        is_indexed8 = ubyte_nolvl and image.ndim == 2 and \
            lut is not None and lut.shape[0] <= 256
        is_passthru16 = image.dtype == xp.uint16 and levels is None and lut is None
        can_grayscale16 = is_passthru16 and image.ndim == 2 and \
            hasattr(QtGui.QImage.Format, 'Format_Grayscale16')
        is_rgba64 = is_passthru16 and image.ndim == 3 and image.shape[2] == 4

        # bypass makeARGB for supported combinations
        supported = is_passthru8 or is_indexed8 or can_grayscale16 or is_rgba64
        if not supported:
            return None

        if self._xp == getCupy():
            image = image.get()

        # worthwhile supporting non-contiguous arrays
        image = numpy.ascontiguousarray(image)

        fmt = None
        ctbl = None
        if is_passthru8:
            # both levels and lut are None
            # these images are suitable for display directly
            if image.ndim == 2:
                fmt = QtGui.QImage.Format.Format_Grayscale8
            elif image.shape[2] == 3:
                fmt = QtGui.QImage.Format.Format_RGB888
            elif image.shape[2] == 4:
                if augmented_alpha:
                    fmt = QtGui.QImage.Format.Format_RGBX8888
                else:
                    fmt = QtGui.QImage.Format.Format_RGBA8888
        elif is_indexed8:
            # levels and/or lut --> lut-only
            fmt = QtGui.QImage.Format.Format_Indexed8
            if lut.ndim == 1 or lut.shape[1] == 1:
                ctbl = [QtGui.qRgb(x,x,x) for x in lut.ravel().tolist()]
            elif lut.shape[1] == 3:
                ctbl = [QtGui.qRgb(*rgb) for rgb in lut.tolist()]
            elif lut.shape[1] == 4:
                ctbl = [QtGui.qRgba(*rgba) for rgba in lut.tolist()]
        elif can_grayscale16:
            # single channel uint16
            # both levels and lut are None
            fmt = QtGui.QImage.Format.Format_Grayscale16
        elif is_rgba64:
            # uint16 rgba
            # both levels and lut are None
            fmt = QtGui.QImage.Format.Format_RGBA64 # endian-independent
        if fmt is None:
            raise ValueError("unsupported image type")
        qimage = fn.ndarray_to_qimage(image, fmt)
        if ctbl is not None:
            qimage.setColorTable(ctbl)
        return qimage

    def paint(self, p, *args):
        profile = debug.Profiler()
        if self.image is None:
            return
        if self._renderRequired:
            self.render()
            if self._unrenderable:
                return
            profile('render QImage')
        if self.paintMode is not None:
            p.setCompositionMode(self.paintMode)
            profile('set comp mode')

        shape = self.image.shape[:2] if self.axisOrder == 'col-major' else self.image.shape[:2][::-1]
        p.drawImage(QtCore.QRectF(0,0,*shape), self.qimage)
        profile('p.drawImage')
        if self.border is not None:
            p.setPen(self.border)
            p.drawRect(self.boundingRect())

    def save(self, fileName, *args):
        """
        Saves this image to file. Note that this saves the visible image (after scale/color changes), not the 
        original data.
        """
        if self._renderRequired:
            self.render()
        self.qimage.save(fileName, *args)

    def getHistogram(self, bins='auto', step='auto', perChannel=False, targetImageSize=200,
                     targetHistogramSize=500, **kwds):
        """
        Returns `x` and `y` arrays containing the histogram values for the current image.
        For an explanation of the return format, see numpy.histogram().

        The `step` argument causes pixels to be skipped when computing the histogram to save time.
        If `step` is 'auto', then a step is chosen such that the analyzed data has
        dimensions approximating `targetImageSize` for each axis.

        The `bins` argument and any extra keyword arguments are passed to
        ``self.xp.histogram()``. If `bins` is `auto`, a bin number is automatically
        chosen based on the image characteristics:

          * Integer images will have approximately `targetHistogramSize` bins,
            with each bin having an integer width.
          * All other types will have `targetHistogramSize` bins.

        If `perChannel` is `True`, then a histogram is computed for each channel, 
        and the output is a list of the results.
        """
        # This method is also used when automatically computing levels.
        if self.image is None or self.image.size == 0:
            return None, None
        if step == 'auto':
            step = (max(1, int(self._xp.ceil(self.image.shape[0] / targetImageSize))),
                    max(1, int(self._xp.ceil(self.image.shape[1] / targetImageSize))))
        if self._xp.isscalar(step):
            step = (step, step)
        stepData = self.image[::step[0], ::step[1]]

        if isinstance(bins, str) and bins == 'auto':
            mn = self._xp.nanmin(stepData).item()
            mx = self._xp.nanmax(stepData).item()
            if mx == mn:
                # degenerate image, arange will fail
                mx += 1
            if self._xp.isnan(mn) or self._xp.isnan(mx):
                # the data are all-nan
                return None, None
            if stepData.dtype.kind in "ui":
                # For integer data, we select the bins carefully to avoid aliasing
                step = int(self._xp.ceil((mx - mn) / 500.))
                bins = []
                if step > 0.0:
                    bins = self._xp.arange(mn, mx + 1.01 * step, step, dtype=int)
            else:
                # for float data, let numpy select the bins.
                bins = self._xp.linspace(mn, mx, 500)

            if len(bins) == 0:
                bins = self._xp.asarray((mn, mx))

        kwds['bins'] = bins

        cp = getCupy()
        if perChannel:
            hist = []
            for i in range(stepData.shape[-1]):
                stepChan = stepData[..., i]
                stepChan = stepChan[self._xp.isfinite(stepChan)]
                h = self._xp.histogram(stepChan, **kwds)
                if cp:
                    hist.append((cp.asnumpy(h[1][:-1]), cp.asnumpy(h[0])))
                else:
                    hist.append((h[1][:-1], h[0]))
            return hist
        else:
            stepData = stepData[self._xp.isfinite(stepData)]
            hist = self._xp.histogram(stepData, **kwds)
            if cp:
                return cp.asnumpy(hist[1][:-1]), cp.asnumpy(hist[0])
            else:
                return hist[1][:-1], hist[0]

    def setPxMode(self, b):
        """
        Sets whether the item ignores transformations and draws directly to screen pixels.
        If True, the item will not inherit any scale or rotation transformations from its
        parent items, but its position will be transformed as usual.
        (see ``GraphicsItem::ItemIgnoresTransformations`` in the Qt documentation)
        """
        self.setFlag(self.GraphicsItemFlag.ItemIgnoresTransformations, b)

    def setScaledMode(self):
        self.setPxMode(False)

    def getPixmap(self):
        if self._renderRequired:
            self.render()
            if self._unrenderable:
                return None
        return QtGui.QPixmap.fromImage(self.qimage)

    def pixelSize(self):
        """
        Returns the scene-size of a single pixel in the image
        """
        br = self.sceneBoundingRect()
        if self.image is None:
            return 1,1
        return br.width()/self.width(), br.height()/self.height()

    def viewTransformChanged(self):
        if self.autoDownsample:
            xds, yds = self._computeDownsampleFactors()
            if xds is None:
                self._renderRequired = True
                self._unrenderable = True
                return
            if (xds, yds) != self._lastDownsample:
                self._renderRequired = True
                self.update()

    def _computeDownsampleFactors(self):
        # reduce dimensions of image based on screen resolution
        o = self.mapToDevice(QtCore.QPointF(0, 0))
        x = self.mapToDevice(QtCore.QPointF(1, 0))
        y = self.mapToDevice(QtCore.QPointF(0, 1))
        # scene may not be available yet
        if o is None:
            return None, None
        w = Point(x - o).length()
        h = Point(y - o).length()
        if w == 0 or h == 0:
            return None, None
        return max(1, int(1.0 / w)), max(1, int(1.0 / h))

    def mouseDragEvent(self, ev):
        if ev.button() != QtCore.Qt.MouseButton.LeftButton:
            ev.ignore()
            return
        elif self.drawKernel is not None:
            ev.accept()
            self.drawAt(ev.pos(), ev)

    def mouseClickEvent(self, ev):
        if ev.button() == QtCore.Qt.MouseButton.RightButton:
            if self.raiseContextMenu(ev):
                ev.accept()
        if self.drawKernel is not None and ev.button() == QtCore.Qt.MouseButton.LeftButton:
            self.drawAt(ev.pos(), ev)

    def raiseContextMenu(self, ev):
        menu = self.getMenu()
        if menu is None:
            return False
        menu = self.scene().addParentContextMenus(self, menu, ev)
        pos = ev.screenPos()
        menu.popup(QtCore.QPoint(pos.x(), pos.y()))
        return True

    def getMenu(self):
        if self.menu is None:
            if not self.removable:
                return None
            self.menu = QtGui.QMenu()
            self.menu.setTitle(translate("ImageItem", "Image"))
            remAct = QtGui.QAction(translate("ImageItem", "Remove image"), self.menu)
            remAct.triggered.connect(self.removeClicked)
            self.menu.addAction(remAct)
            self.menu.remAct = remAct
        return self.menu

    def hoverEvent(self, ev):
        if not ev.isExit() and self.drawKernel is not None and ev.acceptDrags(QtCore.Qt.MouseButton.LeftButton):
            ev.acceptClicks(QtCore.Qt.MouseButton.LeftButton) ## we don't use the click, but we also don't want anyone else to use it.
            ev.acceptClicks(QtCore.Qt.MouseButton.RightButton)
        elif not ev.isExit() and self.removable:
            ev.acceptClicks(QtCore.Qt.MouseButton.RightButton)  ## accept context menu clicks

    def tabletEvent(self, ev):
        pass
        #print(ev.device())
        #print(ev.pointerType())
        #print(ev.pressure())

    def drawAt(self, pos, ev=None):
        pos = [int(pos.x()), int(pos.y())]
        dk = self.drawKernel
        kc = self.drawKernelCenter
        sx = [0,dk.shape[0]]
        sy = [0,dk.shape[1]]
        tx = [pos[0] - kc[0], pos[0] - kc[0]+ dk.shape[0]]
        ty = [pos[1] - kc[1], pos[1] - kc[1]+ dk.shape[1]]

        for i in [0,1]:
            dx1 = -min(0, tx[i])
            dx2 = min(0, self.image.shape[0]-tx[i])
            tx[i] += dx1+dx2
            sx[i] += dx1+dx2

            dy1 = -min(0, ty[i])
            dy2 = min(0, self.image.shape[1]-ty[i])
            ty[i] += dy1+dy2
            sy[i] += dy1+dy2

        ts = (slice(tx[0],tx[1]), slice(ty[0],ty[1]))
        ss = (slice(sx[0],sx[1]), slice(sy[0],sy[1]))
        mask = self.drawMask
        src = dk

        if isinstance(self.drawMode, Callable):
            self.drawMode(dk, self.image, mask, ss, ts, ev)
        else:
            src = src[ss]
            if self.drawMode == 'set':
                if mask is not None:
                    mask = mask[ss]
                    self.image[ts] = self.image[ts] * (1-mask) + src * mask
                else:
                    self.image[ts] = src
            elif self.drawMode == 'add':
                self.image[ts] += src
            else:
                raise Exception("Unknown draw mode '%s'" % self.drawMode)
            self.updateImage()

    def setDrawKernel(self, kernel=None, mask=None, center=(0,0), mode='set'):
        self.drawKernel = kernel
        self.drawKernelCenter = center
        self.drawMode = mode
        self.drawMask = mask

    def removeClicked(self):
        ## Send remove event only after we have exited the menu event handler
        self.removeTimer = QtCore.QTimer()
        self.removeTimer.timeout.connect(self.emitRemoveRequested)
        self.removeTimer.start(0)

    def emitRemoveRequested(self):
        self.removeTimer.timeout.disconnect(self.emitRemoveRequested)
        self.sigRemoveRequested.emit(self)
